unique_toolkit 1.8.1__py3-none-any.whl → 1.23.0__py3-none-any.whl

unique_toolkit/framework_utilities/openai/message_builder.py

@@ -1,5 +1,8 @@
+import base64
+import mimetypes
 from collections.abc import Iterable
-from typing import Self
+from pathlib import Path
+from typing import Self, overload
 
 from openai.types.chat.chat_completion_assistant_message_param import (
     Audio,
@@ -7,6 +10,10 @@ from openai.types.chat.chat_completion_assistant_message_param import (
     ContentArrayOfContentPart,
     FunctionCall,
 )
+from openai.types.chat.chat_completion_content_part_image_param import (
+    ChatCompletionContentPartImageParam,
+    ImageURL,
+)
 from openai.types.chat.chat_completion_content_part_param import (
     ChatCompletionContentPartParam,
 )
@@ -32,6 +39,83 @@ from openai.types.chat.chat_completion_tool_message_param import (
 from openai.types.chat.chat_completion_user_message_param import (
     ChatCompletionUserMessageParam,
 )
+from typing_extensions import Literal
+
+
+class OpenAIUserMessageBuilder:
+    def __init__(
+        self,
+    ) -> None:
+        self._messages: list[ChatCompletionContentPartParam] = []
+
+    def append_text(self, content: str) -> Self:
+        part = ChatCompletionContentPartTextParam(
+            type="text",
+            text=content,
+        )
+        self._messages.append(part)
+        return self
+
+    @overload
+    def append_image(
+        self, *, url: str, detail: Literal["auto", "low", "high"] = "auto"
+    ) -> Self: ...
+
+    @overload
+    def append_image(
+        self, *, path: Path, detail: Literal["auto", "low", "high"] = "auto"
+    ) -> Self: ...
+
+    @overload
+    def append_image(
+        self,
+        *,
+        content: bytes,
+        mime_type: str,
+        detail: Literal["auto", "low", "high"] = "auto",
+    ) -> Self: ...
+
+    def append_image(
+        self,
+        *,
+        url: str | None = None,
+        path: Path | None = None,
+        content: bytes | None = None,
+        mime_type: str | None = None,
+        detail: Literal["auto", "low", "high"] = "auto",
+    ) -> Self:
+        if url is None and path is None and (content is None or mime_type is None):
+            raise ValueError("Either url or path must be provided")
+
+        if path is not None:
+            # Read image file and encode as base64 data URI
+            image_data = path.read_bytes()
+            base64_image = base64.b64encode(image_data).decode("utf-8")
+            mime_type = mimetypes.guess_type(str(path))[0] or "image/jpeg"
+            url = f"data:{mime_type};base64,{base64_image}"
+
+        if content is not None and mime_type is not None:
+            base64_image = base64.b64encode(content).decode("utf-8")
+            url = f"data:{mime_type};base64,{base64_image}"
+
+        image_url = ImageURL(url=url or "", detail=detail)
+        part = ChatCompletionContentPartImageParam(
+            type="image_url",
+            image_url=image_url,
+        )
+        self._messages.append(part)
+        return self
+
+    @property
+    def user_message(self) -> ChatCompletionUserMessageParam:
+        return ChatCompletionUserMessageParam(
+            content=self._messages,
+            role="user",
+        )
+
+    @property
+    def iterable_content(self) -> Iterable[ChatCompletionContentPartParam]:
+        return self._messages
 
 
 class OpenAIMessageBuilder:

unique_toolkit/language_model/default_language_model.py

@@ -0,0 +1,3 @@
+from unique_toolkit.language_model.infos import LanguageModelName
+
+DEFAULT_GPT_4o = LanguageModelName.AZURE_GPT_4o_2024_1120

unique_toolkit/language_model/functions.py

@@ -1,10 +1,11 @@
 import copy
 import logging
 from datetime import UTC, datetime
-from typing import Any, cast
+from typing import Any, Sequence, cast
 
 import humps
 import unique_sdk
+from openai.types.chat import ChatCompletionToolChoiceOptionParam
 from openai.types.chat.chat_completion_message_param import ChatCompletionMessageParam
 from pydantic import BaseModel
 
@@ -159,7 +160,7 @@ async def complete_async(
 
 def _add_tools_to_options(
     options: dict,
-    tools: list[LanguageModelTool | LanguageModelToolDescription] | None,
+    tools: Sequence[LanguageModelTool | LanguageModelToolDescription] | None,
 ) -> dict:
     if tools:
         options["tools"] = [
@@ -172,7 +173,12 @@ def _add_tools_to_options(
     return options
 
 
-def _to_search_context(chunks: list[ContentChunk]) -> dict | None:
+SearchContext = list[unique_sdk.Integrated.SearchResult]
+
+
+def _to_search_context(
+    chunks: list[ContentChunk],
+) -> SearchContext | None:
     if not chunks:
         return None
     return [
@@ -211,12 +217,12 @@ def _prepare_completion_params_util(
     messages: LanguageModelMessages,
     model_name: LanguageModelName | str,
     temperature: float,
-    tools: list[LanguageModelTool | LanguageModelToolDescription] | None = None,
+    tools: Sequence[LanguageModelTool | LanguageModelToolDescription] | None = None,
     other_options: dict | None = None,
     content_chunks: list[ContentChunk] | None = None,
     structured_output_model: type[BaseModel] | None = None,
     structured_output_enforce_schema: bool = False,
-) -> tuple[dict, str, dict, dict | None]:
+) -> tuple[dict, str, dict, SearchContext | None]:
     """Prepare common parameters for completion requests.
 
     Returns
@@ -259,12 +265,12 @@ def _prepare_completion_params_util(
 def _prepare_openai_completion_params_util(
     model_name: LanguageModelName | str,
     temperature: float,
-    tools: list[LanguageModelTool | LanguageModelToolDescription] | None = None,
+    tools: Sequence[LanguageModelTool | LanguageModelToolDescription] | None = None,
     other_options: dict | None = None,
     content_chunks: list[ContentChunk] | None = None,
     structured_output_model: type[BaseModel] | None = None,
     structured_output_enforce_schema: bool = False,
-) -> tuple[dict, str, dict | None]:
+) -> tuple[dict, str, SearchContext | None]:
     """Prepare common parameters for completion requests.
 
     Returns
@@ -330,18 +336,28 @@ def _prepare_all_completions_params_util(
     messages: LanguageModelMessages | list[ChatCompletionMessageParam],
     model_name: LanguageModelName | str,
     temperature: float,
-    tools: list[LanguageModelTool | LanguageModelToolDescription] | None = None,
+    tools: Sequence[LanguageModelTool | LanguageModelToolDescription] | None = None,
     other_options: dict | None = None,
     content_chunks: list[ContentChunk] | None = None,
+    tool_choice: ChatCompletionToolChoiceOptionParam | None = None,
     structured_output_model: type[BaseModel] | None = None,
     structured_output_enforce_schema: bool = False,
 ) -> tuple[
     dict,
     str,
     list[unique_sdk.Integrated.ChatCompletionRequestMessage],
-    dict | None,
+    SearchContext | None,
 ]:
     model_info = None
+
+    other_options = copy.deepcopy(other_options)
+
+    if tool_choice is not None:
+        if other_options is None:
+            other_options = {}
+        if "toolChoice" not in other_options:
+            other_options["toolChoice"] = tool_choice  # Backend expects CamelCase
+
     if isinstance(model_name, LanguageModelName):
         model_info = LanguageModelInfo.from_name(model_name)
         other_options = _prepare_other_options(

unique_toolkit/language_model/infos.py

@@ -19,6 +19,7 @@ class LanguageModelName(StrEnum):
     AZURE_GPT_5_MINI_2025_0807 = "AZURE_GPT_5_MINI_2025_0807"
     AZURE_GPT_5_NANO_2025_0807 = "AZURE_GPT_5_NANO_2025_0807"
     AZURE_GPT_5_CHAT_2025_0807 = "AZURE_GPT_5_CHAT_2025_0807"
+    AZURE_GPT_5_PRO_2025_1006 = "AZURE_GPT_5_PRO_2025_1006"
     AZURE_GPT_4o_2024_0513 = "AZURE_GPT_4o_2024_0513"
     AZURE_GPT_4o_2024_0806 = "AZURE_GPT_4o_2024_0806"
     AZURE_GPT_4o_2024_1120 = "AZURE_GPT_4o_2024_1120"
@@ -36,6 +37,7 @@ class LanguageModelName(StrEnum):
     ANTHROPIC_CLAUDE_3_7_SONNET_THINKING = (
         "litellm:anthropic-claude-3-7-sonnet-thinking"
     )
+    ANTHROPIC_CLAUDE_HAIKU_4_5 = "litellm:anthropic-claude-haiku-4-5"
     ANTHROPIC_CLAUDE_SONNET_4 = "litellm:anthropic-claude-sonnet-4"
     ANTHROPIC_CLAUDE_SONNET_4_5 = "litellm:anthropic-claude-sonnet-4-5"
     ANTHROPIC_CLAUDE_OPUS_4 = "litellm:anthropic-claude-opus-4"
@@ -51,6 +53,7 @@ class LanguageModelName(StrEnum):
     LITELLM_OPENAI_GPT_5_MINI = "litellm:openai-gpt-5-mini"
     LITELLM_OPENAI_GPT_5_NANO = "litellm:openai-gpt-5-nano"
     LITELLM_OPENAI_GPT_5_CHAT = "litellm:openai-gpt-5-chat"
+    LITELLM_OPENAI_GPT_5_PRO = "litellm:openai-gpt-5-pro"
     LITELLM_OPENAI_O1 = "litellm:openai-o1"
     LITELLM_OPENAI_O3 = "litellm:openai-o3"
     LITELLM_OPENAI_O3_DEEP_RESEARCH = "litellm:openai-o3-deep-research"
@@ -90,10 +93,12 @@ def get_encoder_name(model_name: LanguageModelName) -> EncoderName:
             | LMN.AZURE_GPT_5_MINI_2025_0807
             | LMN.AZURE_GPT_5_NANO_2025_0807
             | LMN.AZURE_GPT_5_CHAT_2025_0807
+            | LMN.AZURE_GPT_5_PRO_2025_1006
             | LMN.LITELLM_OPENAI_GPT_5
             | LMN.LITELLM_OPENAI_GPT_5_MINI
             | LMN.LITELLM_OPENAI_GPT_5_NANO
             | LMN.LITELLM_OPENAI_GPT_5_CHAT
+            | LMN.LITELLM_OPENAI_GPT_5_PRO
             | LMN.LITELLM_OPENAI_O1
             | LMN.LITELLM_OPENAI_O3
             | LMN.LITELLM_OPENAI_O3_DEEP_RESEARCH
@@ -333,6 +338,27 @@ class LanguageModelInfo(BaseModel):
                     deprecated_at=date(2026, 8, 7),
                     retirement_at=date(2026, 8, 7),
                 )
+            case LanguageModelName.AZURE_GPT_5_PRO_2025_1006:
+                return cls(
+                    name=model_name,
+                    provider=LanguageModelProvider.AZURE,
+                    version="2025-10-06",
+                    encoder_name=EncoderName.O200K_BASE,
+                    capabilities=[
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.REASONING,
+                        ModelCapabilities.VISION,
+                        ModelCapabilities.STRUCTURED_OUTPUT,
+                    ],
+                    token_limits=LanguageModelTokenLimits(
+                        token_limit_input=272000, token_limit_output=128000
+                    ),
+                    info_cutoff_at=date(2024, 10, 30),
+                    published_at=date(2025, 10, 6),
+                    temperature_bounds=TemperatureBounds(
+                        min_temperature=1.0, max_temperature=1.0
+                    ),
+                )
             case LanguageModelName.AZURE_GPT_4_TURBO_2024_0409:
                 return cls(
                     name=model_name,
@@ -620,7 +646,7 @@ class LanguageModelInfo(BaseModel):
                     token_limits=LanguageModelTokenLimits(
                         # Input limit is 200_000, we leave 20_000 tokens as buffer due to tokenizer mismatch
                         token_limit_input=180_000,
-                        token_limit_output=128_000,
+                        token_limit_output=64_000,
                     ),
                     info_cutoff_at=date(2024, 10, 31),
                     published_at=date(2025, 2, 24),
@@ -640,11 +666,31 @@ class LanguageModelInfo(BaseModel):
                     token_limits=LanguageModelTokenLimits(
                         # Input limit is 200_000, we leave 20_000 tokens as buffer due to tokenizer mismatch
                         token_limit_input=180_000,
-                        token_limit_output=128_000,
+                        token_limit_output=64_000,
                     ),
                     info_cutoff_at=date(2024, 10, 31),
                     published_at=date(2025, 2, 24),
                 )
+            case LanguageModelName.ANTHROPIC_CLAUDE_HAIKU_4_5:
+                return cls(
+                    name=model_name,
+                    capabilities=[
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.STREAMING,
+                        ModelCapabilities.VISION,
+                        ModelCapabilities.REASONING,
+                    ],
+                    provider=LanguageModelProvider.LITELLM,
+                    version="claude-haiku-4-5",
+                    encoder_name=EncoderName.O200K_BASE,  # TODO: Update encoder with litellm
+                    token_limits=LanguageModelTokenLimits(
+                        # Input limit is 200_000, we leave 20_000 tokens as buffer due to tokenizer mismatch
+                        token_limit_input=180_000,
+                        token_limit_output=64_000,
+                    ),
+                    info_cutoff_at=date(2025, 2, 1),
+                    published_at=date(2025, 10, 1),
+                )
             case LanguageModelName.ANTHROPIC_CLAUDE_SONNET_4:
                 return cls(
                     name=model_name,
@@ -679,7 +725,7 @@ class LanguageModelInfo(BaseModel):
                     encoder_name=EncoderName.O200K_BASE,  # TODO: Update encoder with litellm
                     token_limits=LanguageModelTokenLimits(
                         # Input limit is 200_000, we leave 20_000 tokens as buffer due to tokenizer mismatch
-                        token_limit_input=200_000,
+                        token_limit_input=180_000,
                         token_limit_output=64_000,
                     ),
                     info_cutoff_at=date(2025, 7, 1),
@@ -718,7 +764,8 @@ class LanguageModelInfo(BaseModel):
                     version="claude-opus-4",
                     encoder_name=EncoderName.O200K_BASE,  # TODO: Update encoder with litellm
                     token_limits=LanguageModelTokenLimits(
-                        token_limit_input=200_000,
+                        # Input limit is 200_000, we leave 20_000 tokens as buffer due to tokenizer mismatch
+                        token_limit_input=180_000,
                         token_limit_output=32_000,
                     ),
                     info_cutoff_at=date(2025, 3, 1),
@@ -959,6 +1006,27 @@ class LanguageModelInfo(BaseModel):
                     deprecated_at=date(2026, 8, 7),
                     retirement_at=date(2026, 8, 7),
                 )
+            case LanguageModelName.LITELLM_OPENAI_GPT_5_PRO:
+                return cls(
+                    name=model_name,
+                    provider=LanguageModelProvider.LITELLM,
+                    version="2025-10-06",
+                    encoder_name=EncoderName.O200K_BASE,
+                    capabilities=[
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.REASONING,
+                        ModelCapabilities.VISION,
+                        ModelCapabilities.STRUCTURED_OUTPUT,
+                    ],
+                    token_limits=LanguageModelTokenLimits(
+                        token_limit_input=272000, token_limit_output=128000
+                    ),
+                    info_cutoff_at=date(2024, 10, 30),
+                    published_at=date(2025, 10, 6),
+                    temperature_bounds=TemperatureBounds(
+                        min_temperature=1.0, max_temperature=1.0
+                    ),
+                )
             case LanguageModelName.LITELLM_OPENAI_O1:
                 return cls(
                     name=model_name,