hammad-python 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

hammad/ai/completions/client.py

@@ -0,0 +1,729 @@
+"""hammad.ai.completions.client"""
+
+from httpx import Timeout
+from typing import Any, Dict, List, Generic, Literal, TypeVar, Optional, Union, Type
+import sys
+
+if sys.version_info >= (3, 12):
+    from typing import TypedDict, Required, NotRequired
+else:
+    from typing_extensions import TypedDict, Required, NotRequired
+
+try:
+    from openai.types.chat import (
+        ChatCompletionModality,
+        ChatCompletionPredictionContentParam,
+        ChatCompletionAudioParam,
+    )
+except ImportError:
+    raise ImportError(
+        "Using the `hammad.ai.completions` extension requires the `openai` package to be installed.\n"
+        "Please either install the `openai` package, or install the `hammad.ai` extension with:\n"
+        "`pip install 'hammad-python[ai]'"
+    )
+
+from ...pydantic.converters import convert_to_pydantic_model
+from .._utils import get_litellm, get_instructor
+from ...base.model import Model
+from ...typing import is_pydantic_basemodel
+from .utils import (
+    format_tool_calls,
+    parse_completions_input,
+    convert_response_to_completion,
+    create_async_completion_stream,
+    create_completion_stream,
+)
+from .types import (
+    CompletionsInputParam,
+    CompletionsOutputType,
+    Completion,
+    CompletionChunk,
+    CompletionStream,
+    AsyncCompletionStream,
+)
+
+
+class OpenAIWebSearchUserLocationApproximate(TypedDict):
+    city: str
+    country: str
+    region: str
+    timezone: str
+
+
+class OpenAIWebSearchUserLocation(TypedDict):
+    approximate: OpenAIWebSearchUserLocationApproximate
+    type: Literal["approximate"]
+
+
+class OpenAIWebSearchOptions(TypedDict, total=False):
+    search_context_size: Optional[Literal["low", "medium", "high"]]
+    user_location: Optional[OpenAIWebSearchUserLocation]
+
+
+class AnthropicThinkingParam(TypedDict, total=False):
+    type: Literal["enabled"]
+    budget_tokens: int
+
+
+InstructorModeParam = Literal[
+    "function_call",
+    "parallel_tool_call",
+    "tool_call",
+    "tools_strict",
+    "json_mode",
+    "json_o1",
+    "markdown_json_mode",
+    "json_schema_mode",
+    "anthropic_tools",
+    "anthropic_reasoning_tools",
+    "anthropic_json",
+    "mistral_tools",
+    "mistral_structured_outputs",
+    "vertexai_tools",
+    "vertexai_json",
+    "vertexai_parallel_tools",
+    "gemini_json",
+    "gemini_tools",
+    "genai_tools",
+    "genai_structured_outputs",
+    "cohere_tools",
+    "cohere_json_object",
+    "cerebras_tools",
+    "cerebras_json",
+    "fireworks_tools",
+    "fireworks_json",
+    "writer_tools",
+    "bedrock_tools",
+    "bedrock_json",
+    "perplexity_json",
+    "openrouter_structured_outputs",
+]
+"""Instructor prompt/parsing mode for structured outputs."""
+
+
+class CompletionsSettings(TypedDict):
+    """Accepted settings for the `litellm` completion function."""
+
+    model: str
+    messages: List
+    timeout: Optional[Union[float, str, Timeout]]
+    temperature: Optional[float]
+    top_p: Optional[float]
+    n: Optional[int]
+    stream: Optional[bool]
+    stream_options: Optional[Dict[str, Any]]
+    stop: Optional[str]
+    max_completion_tokens: Optional[int]
+    max_tokens: Optional[int]
+    modalities: Optional[List[ChatCompletionModality]]
+    prediction: Optional[ChatCompletionPredictionContentParam]
+    audio: Optional[ChatCompletionAudioParam]
+    presence_penalty: Optional[float]
+    frequency_penalty: Optional[float]
+    logit_bias: Optional[Dict[str, float]]
+    user: Optional[str]
+    reasoning_effort: Optional[Literal["low", "medium", "high"]]
+    # NOTE: response_format is not used within the `completions` resource
+    # in place of `instructor` and the `type` parameter
+    seed: Optional[int]
+    tools: Optional[List]
+    tool_choice: Optional[Union[str, Dict[str, Any]]]
+    logprobs: Optional[bool]
+    top_logprobs: Optional[int]
+    parallel_tool_calls: Optional[bool]
+    web_search_options: Optional[OpenAIWebSearchOptions]
+    deployment_id: Optional[str]
+    extra_headers: Optional[Dict[str, str]]
+    base_url: Optional[str]
+    functions: Optional[List]
+    function_call: Optional[str]
+    # set api_base, api_version, api_key
+    api_version: Optional[str]
+    api_key: Optional[str]
+    model_list: Optional[list]
+    # Optional liteLLM function params
+    thinking: Optional[AnthropicThinkingParam]
+
+
+class CompletionsError(Exception):
+    """Error raised when an error occurs during a completion."""
+
+    def __init__(
+        self,
+        message: str,
+        *args: Any,
+        **kwargs: Any,
+    ):
+        super().__init__(message, *args, **kwargs)
+        self.message = message
+        self.args = args
+        self.kwargs = kwargs
+
+
+class CompletionsClient(Generic[CompletionsOutputType]):
+    """Client for working with language model completions and structured
+    outputs using the `litellm` and `instructor` libraries."""
+
+    @staticmethod
+    async def async_chat_completion(
+        messages: CompletionsInputParam,
+        instructions: Optional[str] = None,
+        model: str = "openai/gpt-4o-mini",
+        *,
+        timeout: Optional[Union[float, str, Timeout]] = None,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        n: Optional[int] = None,
+        stream: Optional[bool] = None,
+        stream_options: Optional[Dict[str, Any]] = None,
+        stop: Optional[str] = None,
+        max_completion_tokens: Optional[int] = None,
+        max_tokens: Optional[int] = None,
+        modalities: Optional[List[ChatCompletionModality]] = None,
+        prediction: Optional[ChatCompletionPredictionContentParam] = None,
+        audio: Optional[ChatCompletionAudioParam] = None,
+        presence_penalty: Optional[float] = None,
+        frequency_penalty: Optional[float] = None,
+        logit_bias: Optional[Dict[str, float]] = None,
+        user: Optional[str] = None,
+        reasoning_effort: Optional[Literal["low", "medium", "high"]] = None,
+        # NOTE: response_format is not used within the `completions` resource
+        # in place of `instructor` and the `type` parameter
+        seed: Optional[int] = None,
+        tools: Optional[List] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        logprobs: Optional[bool] = None,
+        top_logprobs: Optional[int] = None,
+        parallel_tool_calls: Optional[bool] = None,
+        web_search_options: Optional[OpenAIWebSearchOptions] = None,
+        deployment_id: Optional[str] = None,
+        extra_headers: Optional[Dict[str, str]] = None,
+        base_url: Optional[str] = None,
+        functions: Optional[List] = None,
+        function_call: Optional[str] = None,
+        # set api_base, api_version, api_key
+        api_version: Optional[str] = None,
+        api_key: Optional[str] = None,
+        model_list: Optional[list] = None,
+        # Optional liteLLM function params
+        thinking: Optional[AnthropicThinkingParam] = None,
+    ):
+        try:
+            parsed_messages = parse_completions_input(messages, instructions)
+        except Exception as e:
+            raise CompletionsError(
+                f"Error parsing completions input: {e}",
+                input=messages,
+            ) from e
+
+        params: CompletionsSettings = {
+            "model": model,
+            "messages": parsed_messages,
+            "timeout": timeout,
+            "temperature": temperature,
+            "top_p": top_p,
+            "n": n,
+            "stop": stop,
+            "max_completion_tokens": max_completion_tokens,
+            "max_tokens": max_tokens,
+            "modalities": modalities,
+            "prediction": prediction,
+            "audio": audio,
+            "presence_penalty": presence_penalty,
+            "frequency_penalty": frequency_penalty,
+            "logit_bias": logit_bias,
+            "user": user,
+            "reasoning_effort": reasoning_effort,
+            "seed": seed,
+            "tools": tools,
+            "tool_choice": tool_choice,
+            "logprobs": logprobs,
+            "top_logprobs": top_logprobs,
+            "parallel_tool_calls": parallel_tool_calls,
+            "web_search_options": web_search_options,
+            "deployment_id": deployment_id,
+            "extra_headers": extra_headers,
+            "base_url": base_url,
+            "functions": functions,
+            "function_call": function_call,
+            "api_version": api_version,
+            "api_key": api_key,
+            "model_list": model_list,
+            "thinking": thinking,
+        }
+
+        if not stream:
+            response = await get_litellm().acompletion(
+                **{k: v for k, v in params.items() if v is not None}
+            )
+            return convert_response_to_completion(response)
+        else:
+            stream = await get_litellm().acompletion(
+                **{k: v for k, v in params.items() if v is not None},
+                stream=True,
+                stream_options=stream_options if stream_options else None,
+            )
+            return create_async_completion_stream(stream, output_type=str, model=model)
+
+    @staticmethod
+    def chat_completion(
+        messages: CompletionsInputParam,
+        instructions: Optional[str] = None,
+        model: str = "openai/gpt-4o-mini",
+        *,
+        timeout: Optional[Union[float, str, Timeout]] = None,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        n: Optional[int] = None,
+        stream: Optional[bool] = None,
+        stream_options: Optional[Dict[str, Any]] = None,
+        stop: Optional[str] = None,
+        max_completion_tokens: Optional[int] = None,
+        max_tokens: Optional[int] = None,
+        modalities: Optional[List[ChatCompletionModality]] = None,
+        prediction: Optional[ChatCompletionPredictionContentParam] = None,
+        audio: Optional[ChatCompletionAudioParam] = None,
+        presence_penalty: Optional[float] = None,
+        frequency_penalty: Optional[float] = None,
+        logit_bias: Optional[Dict[str, float]] = None,
+        user: Optional[str] = None,
+        reasoning_effort: Optional[Literal["low", "medium", "high"]] = None,
+        # NOTE: response_format is not used within the `completions` resource
+        # in place of `instructor` and the `type` parameter
+        seed: Optional[int] = None,
+        tools: Optional[List] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        logprobs: Optional[bool] = None,
+        top_logprobs: Optional[int] = None,
+        parallel_tool_calls: Optional[bool] = None,
+        web_search_options: Optional[OpenAIWebSearchOptions] = None,
+        deployment_id: Optional[str] = None,
+        extra_headers: Optional[Dict[str, str]] = None,
+        base_url: Optional[str] = None,
+        functions: Optional[List] = None,
+        function_call: Optional[str] = None,
+        # set api_base, api_version, api_key
+        api_version: Optional[str] = None,
+        api_key: Optional[str] = None,
+        model_list: Optional[list] = None,
+        # Optional liteLLM function params
+        thinking: Optional[AnthropicThinkingParam] = None,
+    ):
+        try:
+            parsed_messages = parse_completions_input(messages, instructions)
+        except Exception as e:
+            raise CompletionsError(
+                f"Error parsing completions input: {e}",
+                input=messages,
+            ) from e
+
+        params: CompletionsSettings = {
+            "model": model,
+            "messages": parsed_messages,
+            "timeout": timeout,
+            "temperature": temperature,
+            "top_p": top_p,
+            "n": n,
+            "stop": stop,
+            "max_completion_tokens": max_completion_tokens,
+            "max_tokens": max_tokens,
+            "modalities": modalities,
+            "prediction": prediction,
+            "audio": audio,
+            "presence_penalty": presence_penalty,
+            "frequency_penalty": frequency_penalty,
+            "logit_bias": logit_bias,
+            "user": user,
+            "reasoning_effort": reasoning_effort,
+            "seed": seed,
+            "tools": tools,
+            "tool_choice": tool_choice,
+            "logprobs": logprobs,
+            "top_logprobs": top_logprobs,
+            "parallel_tool_calls": parallel_tool_calls,
+            "web_search_options": web_search_options,
+            "deployment_id": deployment_id,
+            "extra_headers": extra_headers,
+            "base_url": base_url,
+            "functions": functions,
+            "function_call": function_call,
+            "api_version": api_version,
+            "api_key": api_key,
+            "model_list": model_list,
+            "thinking": thinking,
+        }
+
+        if not stream:
+            response = get_litellm().completion(
+                **{k: v for k, v in params.items() if v is not None}
+            )
+            return convert_response_to_completion(response)
+        else:
+            stream = get_litellm().completion(
+                **{k: v for k, v in params.items() if v is not None},
+                stream=True,
+                stream_options=stream_options if stream_options else None,
+            )
+            return create_completion_stream(stream, output_type=str, model=model)
+
+    @staticmethod
+    async def async_structured_output(
+        messages: CompletionsInputParam,
+        instructions: Optional[str] = None,
+        model: str = "openai/gpt-4o-mini",
+        type: CompletionsOutputType = str,
+        instructor_mode: InstructorModeParam = "tool_call",
+        max_retries: int = 3,
+        strict: bool = True,
+        *,
+        timeout: Optional[Union[float, str, Timeout]] = None,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        n: Optional[int] = None,
+        stream: Optional[bool] = None,
+        stream_options: Optional[Dict[str, Any]] = None,
+        stop: Optional[str] = None,
+        max_completion_tokens: Optional[int] = None,
+        max_tokens: Optional[int] = None,
+        modalities: Optional[List[ChatCompletionModality]] = None,
+        prediction: Optional[ChatCompletionPredictionContentParam] = None,
+        audio: Optional[ChatCompletionAudioParam] = None,
+        presence_penalty: Optional[float] = None,
+        frequency_penalty: Optional[float] = None,
+        logit_bias: Optional[Dict[str, float]] = None,
+        user: Optional[str] = None,
+        reasoning_effort: Optional[Literal["low", "medium", "high"]] = None,
+        # NOTE: response_format is not used within the `completions` resource
+        # in place of `instructor` and the `type` parameter
+        seed: Optional[int] = None,
+        tools: Optional[List] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        logprobs: Optional[bool] = None,
+        top_logprobs: Optional[int] = None,
+        parallel_tool_calls: Optional[bool] = None,
+        web_search_options: Optional[OpenAIWebSearchOptions] = None,
+        deployment_id: Optional[str] = None,
+        extra_headers: Optional[Dict[str, str]] = None,
+        base_url: Optional[str] = None,
+        functions: Optional[List] = None,
+        function_call: Optional[str] = None,
+        # set api_base, api_version, api_key
+        api_version: Optional[str] = None,
+        api_key: Optional[str] = None,
+        model_list: Optional[list] = None,
+        # Optional liteLLM function params
+        thinking: Optional[AnthropicThinkingParam] = None,
+    ):
+        try:
+            parsed_messages = parse_completions_input(messages, instructions)
+        except Exception as e:
+            raise CompletionsError(
+                f"Error parsing completions input: {e}",
+                input=messages,
+            ) from e
+
+        parsed_messages = format_tool_calls(parsed_messages)
+
+        params: CompletionsSettings = {
+            "model": model,
+            "messages": parsed_messages,
+            "timeout": timeout,
+            "temperature": temperature,
+            "top_p": top_p,
+            "n": n,
+            "stop": stop,
+            "max_completion_tokens": max_completion_tokens,
+            "max_tokens": max_tokens,
+            "modalities": modalities,
+            "prediction": prediction,
+            "audio": audio,
+            "presence_penalty": presence_penalty,
+            "frequency_penalty": frequency_penalty,
+            "logit_bias": logit_bias,
+            "user": user,
+            "reasoning_effort": reasoning_effort,
+            "seed": seed,
+            "tools": tools,
+            "tool_choice": tool_choice,
+            "logprobs": logprobs,
+            "top_logprobs": top_logprobs,
+            "parallel_tool_calls": parallel_tool_calls,
+            "web_search_options": web_search_options,
+            "deployment_id": deployment_id,
+            "extra_headers": extra_headers,
+            "base_url": base_url,
+            "functions": functions,
+            "function_call": function_call,
+            "api_version": api_version,
+            "api_key": api_key,
+            "model_list": model_list,
+            "thinking": thinking,
+        }
+
+        if type is str:
+            return await CompletionsClient.async_chat_completion(
+                messages=messages,
+                instructions=instructions,
+                model=model,
+                timeout=timeout,
+                temperature=temperature,
+                top_p=top_p,
+                n=n,
+                stream=stream,
+                stream_options=stream_options,
+                stop=stop,
+                max_completion_tokens=max_completion_tokens,
+                max_tokens=max_tokens,
+                modalities=modalities,
+                prediction=prediction,
+                audio=audio,
+                presence_penalty=presence_penalty,
+                frequency_penalty=frequency_penalty,
+                logit_bias=logit_bias,
+                user=user,
+                reasoning_effort=reasoning_effort,
+                seed=seed,
+                tools=tools,
+                tool_choice=tool_choice,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                parallel_tool_calls=parallel_tool_calls,
+                web_search_options=web_search_options,
+                deployment_id=deployment_id,
+                extra_headers=extra_headers,
+                base_url=base_url,
+                functions=functions,
+                function_call=function_call,
+                api_version=api_version,
+                api_key=api_key,
+                model_list=model_list,
+                thinking=thinking,
+            )
+
+        try:
+            client = get_instructor().from_litellm(
+                completion=get_litellm().acompletion,
+                mode=get_instructor().Mode(instructor_mode),
+            )
+        except Exception as e:
+            raise CompletionsError(
+                f"Error creating instructor client: {e}",
+                input=messages,
+            ) from e
+
+        if not is_pydantic_basemodel(type):
+            response_model = convert_to_pydantic_model(
+                target=type,
+                name="Response",
+                field_name="value",
+                description="A single field response in the correct type.",
+            )
+        else:
+            response_model = type
+
+        if stream:
+            stream = await client.chat.completions.create_partial(
+                response_model=response_model,
+                max_retries=max_retries,
+                strict=strict,
+                **{k: v for k, v in params.items() if v is not None},
+            )
+            return create_async_completion_stream(stream, output_type=type, model=model)
+        else:
+            response = await client.chat.completions.create(
+                response_model=response_model,
+                max_retries=max_retries,
+                strict=strict,
+                **{k: v for k, v in params.items() if v is not None},
+            )
+
+            # Extract the actual value if using converted pydantic model
+            if not is_pydantic_basemodel(type) and hasattr(response, "value"):
+                actual_output = response.value
+            else:
+                actual_output = response
+
+            return Completion(
+                output=actual_output, model=model, content=None, completion=None
+            )
+
+    @staticmethod
+    def structured_output(
+        messages: CompletionsInputParam,
+        instructions: Optional[str] = None,
+        model: str = "openai/gpt-4o-mini",
+        type: CompletionsOutputType = str,
+        instructor_mode: InstructorModeParam = "tool_call",
+        max_retries: int = 3,
+        strict: bool = True,
+        *,
+        timeout: Optional[Union[float, str, Timeout]] = None,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        n: Optional[int] = None,
+        stream: Optional[bool] = None,
+        stream_options: Optional[Dict[str, Any]] = None,
+        stop: Optional[str] = None,
+        max_completion_tokens: Optional[int] = None,
+        max_tokens: Optional[int] = None,
+        modalities: Optional[List[ChatCompletionModality]] = None,
+        prediction: Optional[ChatCompletionPredictionContentParam] = None,
+        audio: Optional[ChatCompletionAudioParam] = None,
+        presence_penalty: Optional[float] = None,
+        frequency_penalty: Optional[float] = None,
+        logit_bias: Optional[Dict[str, float]] = None,
+        user: Optional[str] = None,
+        reasoning_effort: Optional[Literal["low", "medium", "high"]] = None,
+        # NOTE: response_format is not used within the `completions` resource
+        # in place of `instructor` and the `type` parameter
+        seed: Optional[int] = None,
+        tools: Optional[List] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        logprobs: Optional[bool] = None,
+        top_logprobs: Optional[int] = None,
+        parallel_tool_calls: Optional[bool] = None,
+        web_search_options: Optional[OpenAIWebSearchOptions] = None,
+        deployment_id: Optional[str] = None,
+        extra_headers: Optional[Dict[str, str]] = None,
+        base_url: Optional[str] = None,
+        functions: Optional[List] = None,
+        function_call: Optional[str] = None,
+        # set api_base, api_version, api_key
+        api_version: Optional[str] = None,
+        api_key: Optional[str] = None,
+        model_list: Optional[list] = None,
+        # Optional liteLLM function params
+        thinking: Optional[AnthropicThinkingParam] = None,
+    ):
+        try:
+            parsed_messages = parse_completions_input(messages, instructions)
+        except Exception as e:
+            raise CompletionsError(
+                f"Error parsing completions input: {e}",
+                input=messages,
+            ) from e
+
+        parsed_messages = format_tool_calls(parsed_messages)
+
+        params: CompletionsSettings = {
+            "model": model,
+            "messages": parsed_messages,
+            "timeout": timeout,
+            "temperature": temperature,
+            "top_p": top_p,
+            "n": n,
+            "stop": stop,
+            "max_completion_tokens": max_completion_tokens,
+            "max_tokens": max_tokens,
+            "modalities": modalities,
+            "prediction": prediction,
+            "audio": audio,
+            "presence_penalty": presence_penalty,
+            "frequency_penalty": frequency_penalty,
+            "logit_bias": logit_bias,
+            "user": user,
+            "reasoning_effort": reasoning_effort,
+            "seed": seed,
+            "tools": tools,
+            "tool_choice": tool_choice,
+            "logprobs": logprobs,
+            "top_logprobs": top_logprobs,
+            "parallel_tool_calls": parallel_tool_calls,
+            "web_search_options": web_search_options,
+            "deployment_id": deployment_id,
+            "extra_headers": extra_headers,
+            "base_url": base_url,
+            "functions": functions,
+            "function_call": function_call,
+            "api_version": api_version,
+            "api_key": api_key,
+            "model_list": model_list,
+            "thinking": thinking,
+        }
+
+        if type is str:
+            return CompletionsClient.chat_completion(
+                messages=messages,
+                instructions=instructions,
+                model=model,
+                timeout=timeout,
+                temperature=temperature,
+                top_p=top_p,
+                n=n,
+                stream=stream,
+                stream_options=stream_options,
+                stop=stop,
+                max_completion_tokens=max_completion_tokens,
+                max_tokens=max_tokens,
+                modalities=modalities,
+                prediction=prediction,
+                audio=audio,
+                presence_penalty=presence_penalty,
+                frequency_penalty=frequency_penalty,
+                logit_bias=logit_bias,
+                user=user,
+                reasoning_effort=reasoning_effort,
+                seed=seed,
+                tools=tools,
+                tool_choice=tool_choice,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                parallel_tool_calls=parallel_tool_calls,
+                web_search_options=web_search_options,
+                deployment_id=deployment_id,
+                extra_headers=extra_headers,
+                base_url=base_url,
+                functions=functions,
+                function_call=function_call,
+                api_version=api_version,
+                api_key=api_key,
+                model_list=model_list,
+                thinking=thinking,
+            )
+
+        try:
+            client = get_instructor().from_litellm(
+                completion=get_litellm().completion,
+                mode=get_instructor().Mode(instructor_mode),
+            )
+        except Exception as e:
+            raise CompletionsError(
+                f"Error creating instructor client: {e}",
+                input=messages,
+            ) from e
+
+        if not is_pydantic_basemodel(type):
+            response_model = convert_to_pydantic_model(
+                target=type,
+                name="Response",
+                field_name="value",
+                description="A single field response in the correct type.",
+            )
+        else:
+            response_model = type
+
+        if stream:
+            stream = client.chat.completions.create_partial(
+                response_model=response_model,
+                max_retries=max_retries,
+                strict=strict,
+                **{k: v for k, v in params.items() if v is not None},
+            )
+            return create_completion_stream(stream, output_type=type, model=model)
+        else:
+            response = client.chat.completions.create(
+                response_model=response_model,
+                max_retries=max_retries,
+                strict=strict,
+                **{k: v for k, v in params.items() if v is not None},
+            )
+
+            # Extract the actual value if using converted pydantic model
+            if not is_pydantic_basemodel(type) and hasattr(response, "value"):
+                actual_output = response.value
+            else:
+                actual_output = response
+
+            return Completion(
+                output=actual_output, model=model, content=None, completion=None
+            )