chore: remove /v1/inference/completion and implementations (#3622)

# What does this PR do?

the /inference/completion route is gone. this removes the
implementations.

## Test Plan

ci

llama_stack/providers/utils/inference/litellm_openai_mixin.py

@@ -4,14 +4,11 @@
 # This source code is licensed under the terms described in the LICENSE file in
 # the root directory of this source tree.
 
-from collections.abc import AsyncGenerator, AsyncIterator
+from collections.abc import AsyncIterator
 from typing import Any
 
 import litellm
 
-from llama_stack.apis.common.content_types import (
-    InterleavedContent,
-)
 from llama_stack.apis.inference import (
     ChatCompletionRequest,
     ChatCompletionResponse,
@@ -108,17 +105,6 @@ class LiteLLMOpenAIMixin(
             else model_id
         )
 
-    async def completion(
-        self,
-        model_id: str,
-        content: InterleavedContent,
-        sampling_params: SamplingParams | None = None,
-        response_format: ResponseFormat | None = None,
-        stream: bool | None = False,
-        logprobs: LogProbConfig | None = None,
-    ) -> AsyncGenerator:
-        raise NotImplementedError("LiteLLM does not support completion requests")
-
     async def chat_completion(
         self,
         model_id: str,

llama_stack/providers/utils/inference/openai_compat.py

@@ -103,8 +103,6 @@ from llama_stack.apis.inference import (
     JsonSchemaResponseFormat,
     Message,
     OpenAIChatCompletion,
-    OpenAICompletion,
-    OpenAICompletionChoice,
     OpenAIEmbeddingData,
     OpenAIMessageParam,
     OpenAIResponseFormatParam,
@@ -1281,76 +1279,6 @@ async def prepare_openai_completion_params(**params):
     return completion_params
 
 
-class OpenAICompletionToLlamaStackMixin:
-    async def openai_completion(
-        self,
-        model: str,
-        prompt: str | list[str] | list[int] | list[list[int]],
-        best_of: int | None = None,
-        echo: bool | None = None,
-        frequency_penalty: float | None = None,
-        logit_bias: dict[str, float] | None = None,
-        logprobs: bool | None = None,
-        max_tokens: int | None = None,
-        n: int | None = None,
-        presence_penalty: float | None = None,
-        seed: int | None = None,
-        stop: str | list[str] | None = None,
-        stream: bool | None = None,
-        stream_options: dict[str, Any] | None = None,
-        temperature: float | None = None,
-        top_p: float | None = None,
-        user: str | None = None,
-        guided_choice: list[str] | None = None,
-        prompt_logprobs: int | None = None,
-        suffix: str | None = None,
-    ) -> OpenAICompletion:
-        if stream:
-            raise ValueError(f"{self.__class__.__name__} doesn't support streaming openai completions")
-
-        # This is a pretty hacky way to do emulate completions -
-        # basically just de-batches them...
-        prompts = [prompt] if not isinstance(prompt, list) else prompt
-
-        sampling_params = _convert_openai_sampling_params(
-            max_tokens=max_tokens,
-            temperature=temperature,
-            top_p=top_p,
-        )
-
-        choices = []
-        # "n" is the number of completions to generate per prompt
-        n = n or 1
-        for _i in range(0, n):
-            # and we may have multiple prompts, if batching was used
-
-            for prompt in prompts:
-                result = self.completion(
-                    model_id=model,
-                    content=prompt,
-                    sampling_params=sampling_params,
-                )
-
-                index = len(choices)
-                text = result.content
-                finish_reason = _convert_stop_reason_to_openai_finish_reason(result.stop_reason)
-
-                choice = OpenAICompletionChoice(
-                    index=index,
-                    text=text,
-                    finish_reason=finish_reason,
-                )
-                choices.append(choice)
-
-        return OpenAICompletion(
-            id=f"cmpl-{uuid.uuid4()}",
-            choices=choices,
-            created=int(time.time()),
-            model=model,
-            object="text_completion",
-        )
-
-
 class OpenAIChatCompletionToLlamaStackMixin:
     async def openai_chat_completion(
         self,

llama_stack/providers/utils/inference/prompt_adapter.py

@@ -229,28 +229,6 @@ async def convert_image_content_to_url(
         return base64.b64encode(content).decode("utf-8")
 
 
-async def completion_request_to_prompt(request: CompletionRequest) -> str:
-    content = augment_content_with_response_format_prompt(request.response_format, request.content)
-    request.content = content
-    request = await convert_request_to_raw(request)
-
-    formatter = ChatFormat(tokenizer=Tokenizer.get_instance())
-    model_input = formatter.encode_content(request.content)
-    return formatter.tokenizer.decode(model_input.tokens)
-
-
-async def completion_request_to_prompt_model_input_info(
-    request: CompletionRequest,
-) -> tuple[str, int]:
-    content = augment_content_with_response_format_prompt(request.response_format, request.content)
-    request.content = content
-    request = await convert_request_to_raw(request)
-
-    formatter = ChatFormat(tokenizer=Tokenizer.get_instance())
-    model_input = formatter.encode_content(request.content)
-    return (formatter.tokenizer.decode(model_input.tokens), len(model_input.tokens))
-
-
 def augment_content_with_response_format_prompt(response_format, content):
     if fmt_prompt := response_format_prompt(response_format):
         if isinstance(content, list):