unique_toolkit 0.7.9__py3-none-any.whl → 1.33.3__py3-none-any.whl

unique_toolkit/language_model/_responses_api_utils.py

@@ -0,0 +1,93 @@
+from typing import Any
+
+from openai.types.chat import (
+    ChatCompletionContentPartImageParam,
+    ChatCompletionContentPartInputAudioParam,
+    ChatCompletionContentPartParam,
+    ChatCompletionContentPartTextParam,
+)
+from openai.types.chat.chat_completion_content_part_param import (
+    File as ChatCompletionContentPartFileParam,
+)
+from openai.types.responses import (
+    ResponseInputAudioParam,
+    ResponseInputFileParam,
+    ResponseInputImageParam,
+    ResponseInputMessageContentListParam,
+    ResponseInputTextParam,
+)
+from pydantic import (
+    TypeAdapter,
+)
+from pydantic.alias_generators import to_camel
+
+
+def _convert_text_part_to_responses_api(
+    part: ChatCompletionContentPartTextParam,
+) -> ResponseInputTextParam:
+    return ResponseInputTextParam(type="input_text", text=part["text"])
+
+
+def _convert_image_part_to_responses_api(
+    part: ChatCompletionContentPartImageParam,
+) -> ResponseInputImageParam:
+    detail = "auto"  # Responses API requires detail to be sent
+    if "detail" in part["image_url"]:
+        detail = part["image_url"]["detail"]
+
+    return ResponseInputImageParam(
+        type="input_image",
+        image_url=part["image_url"]["url"],
+        detail=detail,
+    )
+
+
+def _convert_file_part_to_responses_api(
+    part: ChatCompletionContentPartFileParam,
+) -> ResponseInputFileParam:
+    param = ResponseInputFileParam(type="input_file")
+
+    if "file_id" in part["file"]:
+        param["file_id"] = part["file"]["file_id"]
+
+    if "file_data" in part["file"]:
+        param["file_data"] = part["file"]["file_data"]
+
+    if "filename" in part["file"]:
+        param["filename"] = part["file"]["filename"]
+
+    return param
+
+
+def _convert_audio_part_to_responses_api(
+    part: ChatCompletionContentPartInputAudioParam,
+) -> ResponseInputAudioParam:
+    return ResponseInputAudioParam(type="input_audio", input_audio=part["input_audio"])
+
+
+def convert_user_message_content_to_responses_api(
+    content: str | list[dict[str, Any]],
+) -> str | ResponseInputMessageContentListParam:
+    """Convert user message content from Chat Completions format to Responses API format."""
+
+    if isinstance(content, str):
+        return content
+
+    # Parse the content of the dicts in order to allow for camelCase arguments
+    content_parsed = TypeAdapter(
+        list[ChatCompletionContentPartParam], config={"alias_generator": to_camel}
+    ).validate_python(content, by_alias=True, by_name=True)
+
+    responses_content: ResponseInputMessageContentListParam = []
+
+    for part in content_parsed:
+        match part["type"]:
+            case "text":
+                responses_content.append(_convert_text_part_to_responses_api(part))
+            case "image_url":
+                responses_content.append(_convert_image_part_to_responses_api(part))
+            case "file":
+                responses_content.append(_convert_file_part_to_responses_api(part))
+            case "input_audio":
+                responses_content.append(_convert_audio_part_to_responses_api(part))
+    return responses_content

unique_toolkit/language_model/builder.py

@@ -1,4 +1,4 @@
-from typing_extensions import Self
+from typing import Any, Self
 
 from unique_toolkit.language_model import (
     LanguageModelAssistantMessage,
@@ -17,6 +17,10 @@ class MessagesBuilder:
     def __init__(self):
         self.messages: list[LanguageModelMessage] = []
 
+    def append(self, message: LanguageModelMessage) -> Self:
+        self.messages.append(message)
+        return self
+
     def message_append(self, role: LanguageModelMessageRole, content: str):
         message = LanguageModelMessage(role=role, content=content)
         self.messages.append(message)
@@ -35,23 +39,33 @@ class MessagesBuilder:
         return self  # Return self to allow method chaining
 
     def image_message_append(
-        self, content: str, images: list[str], role=LanguageModelMessageRole.USER
+        self,
+        content: str,
+        images: list[str],
+        role: LanguageModelMessageRole = LanguageModelMessageRole.USER,
     ) -> Self:
+        final_content: list[dict[str, Any]] = [{"type": "text", "text": content}]
+        final_content.extend(
+            [
+                {
+                    "type": "image_url",
+                    "imageUrl": {"url": image},
+                }
+                for image in images
+            ],
+        )
+
         message = LanguageModelMessage(
             role=role,
-            content=[
-                {"type": "text", "text": content},
-                *[
-                    {"type": "image_url", "imageUrl": {"url": image}}
-                    for image in images
-                ],
-            ],
+            content=final_content,
         )
         self.messages.append(message)
         return self
 
     def assistant_message_append(
-        self, content: str, tool_calls: list[LanguageModelFunction] | None = None
+        self,
+        content: str,
+        tool_calls: list[LanguageModelFunction] | None = None,
     ) -> Self:
         """Appends an assistant message to the messages list."""
         message = LanguageModelAssistantMessage(content=content)
@@ -70,7 +84,9 @@ class MessagesBuilder:
     def tool_message_append(self, name: str, tool_call_id: str, content: str) -> Self:
         """Appends a tool message to the messages list."""
         message = LanguageModelToolMessage(
-            name=name, tool_call_id=tool_call_id, content=content
+            name=name,
+            tool_call_id=tool_call_id,
+            content=content,
         )
         self.messages.append(message)
         return self

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