python-codex 0.2.6__py3-none-any.whl → 0.3.0__py3-none-any.whl

responses_server/messages_api.py

@@ -9,8 +9,8 @@ class MessagesAPIAdapterError(ValueError):
 
 
 def build_messages_request(
-    outcomming_request: 'typing.Dict[str, object]',
-) -> 'typing.Dict[str, object]':
+    outcomming_request: "typing.Dict[str, object]",
+) -> "typing.Dict[str, object]":
     model = str(outcomming_request.get("model", "")).strip()
     if not model:
         raise MessagesAPIAdapterError("outcomming request is missing `model`")
@@ -19,13 +19,11 @@ def build_messages_request(
     if not isinstance(raw_messages, list):
         raise MessagesAPIAdapterError("outcomming request `messages` must be a list")
 
-    system_blocks: 'typing.List[typing.Dict[str, object]]' = []
-    messages: 'typing.List[typing.Dict[str, object]]' = []
+    system_blocks: "typing.List[typing.Dict[str, object]]" = []
+    messages: "typing.List[typing.Dict[str, object]]" = []
     for raw_message in raw_messages:
         if not isinstance(raw_message, dict):
-            raise MessagesAPIAdapterError(
-                "outcomming request messages must be objects"
-            )
+            raise MessagesAPIAdapterError("outcomming request messages must be objects")
         role = str(raw_message.get("role", "")).strip()
         if role in {"developer", "system"}:
             text = str(raw_message.get("content", "") or "")
@@ -60,7 +58,7 @@ def build_messages_request(
             f"unsupported outcomming message role for messages API: {role!r}"
         )
 
-    payload: 'typing.Dict[str, object]' = {
+    payload: "typing.Dict[str, object]" = {
         "model": model,
         "messages": messages,
         "max_tokens": _resolve_max_tokens(outcomming_request),
@@ -84,12 +82,12 @@ def build_messages_request(
 
 
 def iter_chat_chunks(
-    event_name: 'typing.Union[str, None]',
-    payload: 'typing.Dict[str, object]',
-    state: 'typing.Dict[str, object]',
-) -> 'typing.List[typing.Dict[str, object]]':
+    event_name: "typing.Union[str, None]",
+    payload: "typing.Dict[str, object]",
+    state: "typing.Dict[str, object]",
+) -> "typing.List[typing.Dict[str, object]]":
     event_type = str(payload.get("type") or event_name or "").strip()
-    chunks: 'typing.List[typing.Dict[str, object]]' = []
+    chunks: "typing.List[typing.Dict[str, object]]" = []
 
     if event_type == "message_start":
         message = payload.get("message") or {}
@@ -188,21 +186,72 @@ def iter_chat_chunks(
     return chunks
 
 
-def saw_message_stop(state: 'typing.Dict[str, object]') -> 'bool':
+def saw_message_stop(state: "typing.Dict[str, object]") -> "bool":
     return bool(state.get("saw_message_stop"))
 
 
-def _build_text_blocks(raw_content: 'object') -> 'typing.List[typing.Dict[str, object]]':
+def _build_text_blocks(
+    raw_content: "object",
+) -> "typing.List[typing.Dict[str, object]]":
+    if isinstance(raw_content, list):
+        blocks: "typing.List[typing.Dict[str, object]]" = []
+        for raw_part in raw_content:
+            if not isinstance(raw_part, dict):
+                raise MessagesAPIAdapterError("message content parts must be objects")
+            part_type = str(raw_part.get("type", "")).strip()
+            if part_type == "text":
+                text = str(raw_part.get("text", "") or "")
+                if text:
+                    blocks.append({"type": "text", "text": text})
+                continue
+            if part_type == "image_url":
+                blocks.append(_build_image_block(raw_part))
+                continue
+            raise MessagesAPIAdapterError(
+                f"unsupported outcomming content part type for messages API: {part_type!r}"
+            )
+        return blocks
+
     text = str(raw_content or "")
     if not text:
         return []
     return [{"type": "text", "text": text}]
 
 
+def _build_image_block(
+    raw_part: "typing.Dict[str, object]",
+) -> "typing.Dict[str, object]":
+    image_url = raw_part.get("image_url") or {}
+    if not isinstance(image_url, dict):
+        raise MessagesAPIAdapterError("`image_url` content parts must be objects")
+    url = str(image_url.get("url", "") or "").strip()
+    if not url:
+        raise MessagesAPIAdapterError(
+            "`image_url` content parts must carry a non-empty `url`"
+        )
+    if not url.startswith("data:"):
+        return {"type": "image", "source": {"type": "url", "url": url}}
+
+    header, _, data = url.partition(",")
+    media_type = header[len("data:") :].split(";")[0].strip()
+    if not media_type or not header.endswith(";base64"):
+        raise MessagesAPIAdapterError(
+            "`image_url` data URLs must be base64 encoded with a media type"
+        )
+    return {
+        "type": "image",
+        "source": {
+            "type": "base64",
+            "media_type": media_type,
+            "data": data,
+        },
+    }
+
+
 def _build_assistant_blocks(
-    raw_message: 'typing.Dict[str, object]',
-) -> 'typing.List[typing.Dict[str, object]]':
-    blocks: 'typing.List[typing.Dict[str, object]]' = []
+    raw_message: "typing.Dict[str, object]",
+) -> "typing.List[typing.Dict[str, object]]":
+    blocks: "typing.List[typing.Dict[str, object]]" = []
     reasoning = str(raw_message.get("reasoning", "") or "")
     if reasoning:
         blocks.append({"type": "thinking", "thinking": reasoning})
@@ -235,8 +284,8 @@ def _build_assistant_blocks(
 
 
 def _build_tool_result_block(
-    raw_message: 'typing.Dict[str, object]',
-) -> 'typing.Dict[str, object]':
+    raw_message: "typing.Dict[str, object]",
+) -> "typing.Dict[str, object]":
     return {
         "type": "tool_result",
         "tool_use_id": str(raw_message.get("tool_call_id", "")).strip(),
@@ -245,9 +294,9 @@ def _build_tool_result_block(
 
 
 def _translate_tools(
-    raw_tools: 'object',
-) -> 'typing.List[typing.Dict[str, object]]':
-    translated: 'typing.List[typing.Dict[str, object]]' = []
+    raw_tools: "object",
+) -> "typing.List[typing.Dict[str, object]]":
+    translated: "typing.List[typing.Dict[str, object]]" = []
     if not isinstance(raw_tools, list):
         return translated
     for raw_tool in raw_tools:
@@ -272,9 +321,9 @@ def _translate_tools(
 
 
 def _translate_tool_choice(
-    raw_tool_choice: 'object',
-    parallel_tool_calls: 'object',
-) -> 'typing.Union[typing.Dict[str, object], None]':
+    raw_tool_choice: "object",
+    parallel_tool_calls: "object",
+) -> "typing.Union[typing.Dict[str, object], None]":
     if raw_tool_choice is None:
         if parallel_tool_calls is False:
             return {
@@ -283,7 +332,7 @@ def _translate_tool_choice(
             }
         return None
 
-    translated: 'typing.Dict[str, object]'
+    translated: "typing.Dict[str, object]"
     if isinstance(raw_tool_choice, str):
         choice = raw_tool_choice.strip()
         if choice == "auto":
@@ -306,9 +355,7 @@ def _translate_tool_choice(
             if not name:
                 name = str(raw_tool_choice.get("name", "")).strip()
             if not name:
-                raise MessagesAPIAdapterError(
-                    "function tool_choice is missing `name`"
-                )
+                raise MessagesAPIAdapterError("function tool_choice is missing `name`")
             translated = {
                 "type": "tool",
                 "name": name,
@@ -327,7 +374,7 @@ def _translate_tool_choice(
     return translated
 
 
-def _parse_json_object(raw_value: 'object') -> 'typing.Dict[str, object]':
+def _parse_json_object(raw_value: "object") -> "typing.Dict[str, object]":
     if isinstance(raw_value, dict):
         return dict(raw_value)
     if isinstance(raw_value, str):
@@ -350,7 +397,7 @@ def _parse_json_object(raw_value: 'object') -> 'typing.Dict[str, object]':
     )
 
 
-def _resolve_max_tokens(outcomming_request: 'typing.Dict[str, object]') -> 'int':
+def _resolve_max_tokens(outcomming_request: "typing.Dict[str, object]") -> "int":
     raw_value = outcomming_request.get("max_tokens")
     if isinstance(raw_value, bool):
         return DEFAULT_MESSAGES_MAX_TOKENS
@@ -359,7 +406,7 @@ def _resolve_max_tokens(outcomming_request: 'typing.Dict[str, object]') -> 'int'
     return DEFAULT_MESSAGES_MAX_TOKENS
 
 
-def _usage_chunk(raw_usage: 'object') -> 'typing.Union[typing.Dict[str, object], None]':
+def _usage_chunk(raw_usage: "object") -> "typing.Union[typing.Dict[str, object], None]":
     usage = _translate_usage(raw_usage)
     if not usage:
         return None
@@ -369,10 +416,10 @@ def _usage_chunk(raw_usage: 'object') -> 'typing.Union[typing.Dict[str, object],
     }
 
 
-def _translate_usage(raw_usage: 'object') -> 'typing.Dict[str, object]':
+def _translate_usage(raw_usage: "object") -> "typing.Dict[str, object]":
     if not isinstance(raw_usage, dict):
         return {}
-    usage: 'typing.Dict[str, object]' = {}
+    usage: "typing.Dict[str, object]" = {}
     input_tokens = raw_usage.get("input_tokens")
     output_tokens = raw_usage.get("output_tokens")
     if isinstance(input_tokens, int):
@@ -385,7 +432,7 @@ def _translate_usage(raw_usage: 'object') -> 'typing.Dict[str, object]':
     elif isinstance(input_tokens, int) and isinstance(output_tokens, int):
         usage["total_tokens"] = input_tokens + output_tokens
 
-    input_details: 'typing.Dict[str, int]' = {}
+    input_details: "typing.Dict[str, int]" = {}
     cache_creation = raw_usage.get("cache_creation_input_tokens")
     if isinstance(cache_creation, int):
         input_details["cache_creation_input_tokens"] = cache_creation
@@ -397,7 +444,7 @@ def _translate_usage(raw_usage: 'object') -> 'typing.Dict[str, object]':
     return usage
 
 
-def _normalize_index(raw_index: 'object') -> 'int':
+def _normalize_index(raw_index: "object") -> "int":
     if isinstance(raw_index, int):
         return raw_index
     try:
@@ -406,7 +453,7 @@ def _normalize_index(raw_index: 'object') -> 'int':
         return 0
 
 
-def _translate_stop_reason(raw_stop_reason: 'object') -> 'typing.Union[str, None]':
+def _translate_stop_reason(raw_stop_reason: "object") -> "typing.Union[str, None]":
     if not isinstance(raw_stop_reason, str):
         return None
     stop_reason = raw_stop_reason.strip()
@@ -421,21 +468,21 @@ def _translate_stop_reason(raw_stop_reason: 'object') -> 'typing.Union[str, None
     return stop_reason
 
 
-def _chat_text_chunk(text: 'str') -> 'typing.Dict[str, object]':
+def _chat_text_chunk(text: "str") -> "typing.Dict[str, object]":
     return _chat_delta_chunk({"content": text})
 
 
-def _chat_reasoning_chunk(reasoning: 'str') -> 'typing.Dict[str, object]':
+def _chat_reasoning_chunk(reasoning: "str") -> "typing.Dict[str, object]":
     return _chat_delta_chunk({"reasoning_content": reasoning})
 
 
 def _chat_tool_chunk(
-    index: 'int',
-    call_id: 'str' = "",
-    name: 'str' = "",
-    arguments: 'str' = "",
-) -> 'typing.Dict[str, object]':
-    tool_call: 'typing.Dict[str, object]' = {
+    index: "int",
+    call_id: "str" = "",
+    name: "str" = "",
+    arguments: "str" = "",
+) -> "typing.Dict[str, object]":
+    tool_call: "typing.Dict[str, object]" = {
         "index": index,
         "function": {},
     }
@@ -453,7 +500,7 @@ def _chat_tool_chunk(
     return _chat_delta_chunk({"tool_calls": [tool_call]})
 
 
-def _chat_delta_chunk(delta: 'typing.Dict[str, object]') -> 'typing.Dict[str, object]':
+def _chat_delta_chunk(delta: "typing.Dict[str, object]") -> "typing.Dict[str, object]":
     return {
         "choices": [
             {
@@ -465,7 +512,7 @@ def _chat_delta_chunk(delta: 'typing.Dict[str, object]') -> 'typing.Dict[str, ob
     }
 
 
-def _chat_finish_chunk(finish_reason: 'str') -> 'typing.Dict[str, object]':
+def _chat_finish_chunk(finish_reason: "str") -> "typing.Dict[str, object]":
     return {
         "choices": [
             {
@@ -477,5 +524,5 @@ def _chat_finish_chunk(finish_reason: 'str') -> 'typing.Dict[str, object]':
     }
 
 
-def _dump_json(raw_value: 'object') -> 'str':
+def _dump_json(raw_value: "object") -> "str":
     return json.dumps(raw_value, ensure_ascii=False, separators=(",", ":"))

responses_server/payload_processors.py

@@ -1,4 +1,3 @@
-
 """Provider-specific post-process hooks for canonical outgoing chat requests.
 
 Each downstream chat-completions provider may have its own payload quirks:
@@ -8,9 +7,10 @@ building one canonical `outcomming_request`, while `server.py` selects the
 appropriate hook from `CompatServerConfig.model_provider`.
 """
 
+import typing
 from copy import deepcopy
 from typing import Callable, Optional
-import typing
+
 from typing_extensions import TypedDict
 
 ChatMessage = typing.Dict[str, object]
@@ -25,26 +25,29 @@ class OutgoingRequest(TypedDict):
     not rely on TypedDict inheritance.
     """
 
-    model: 'str'
-    messages: 'typing.List[ChatMessage]'
-    stream: 'bool'
-    max_tokens: 'Optional[int]'
-    tools: 'Optional[typing.List[typing.Dict[str, object]]]'
-    tool_choice: 'Optional[object]'
-    parallel_tool_calls: 'Optional[bool]'
-    return_token_ids: 'Optional[bool]'
+    model: "str"
+    messages: "typing.List[ChatMessage]"
+    stream: "bool"
+    chat_template_kwargs: "Optional[typing.Dict[str, object]]"
+    max_tokens: "Optional[int]"
+    tools: "Optional[typing.List[typing.Dict[str, object]]]"
+    tool_choice: "Optional[object]"
+    parallel_tool_calls: "Optional[bool]"
+    return_token_ids: "Optional[bool]"
 
 
 PayloadPostProcessor = Callable[[OutgoingRequest], OutgoingRequest]
 
 
-def _identity(outcomming_request: 'OutgoingRequest') -> 'OutgoingRequest':
+def _identity(outcomming_request: "OutgoingRequest") -> "OutgoingRequest":
     """Keep the canonical request unchanged."""
 
     return outcomming_request
 
 
-def _drop_developer_messages(outcomming_request: 'OutgoingRequest') -> 'OutgoingRequest':
+def _drop_developer_messages(
+    outcomming_request: "OutgoingRequest",
+) -> "OutgoingRequest":
     """Remove all developer-role messages for providers that reject them."""
 
     outcomming_request["messages"] = [
@@ -54,17 +57,20 @@ def _drop_developer_messages(outcomming_request: 'OutgoingRequest') -> 'Outgoing
     ]
     return outcomming_request
 
-def _replace_developer_messages(outcomming_request: 'OutgoingRequest') -> 'OutgoingRequest':
+
+def _replace_developer_messages(
+    outcomming_request: "OutgoingRequest",
+) -> "OutgoingRequest":
     """Replace all developer-role messages to system-role messages"""
 
-    for message in outcomming_request['messages']:
+    for message in outcomming_request["messages"]:
         if message.get("role") == "developer":
-            message['role'] = "system"
+            message["role"] = "system"
 
     return outcomming_request
 
 
-PAYLOAD_POST_PROCESSORS: 'typing.Dict[str, PayloadPostProcessor]' = {
+PAYLOAD_POST_PROCESSORS: "typing.Dict[str, PayloadPostProcessor]" = {
     "stepfun": _replace_developer_messages,
     "vllm": _identity,
 }
@@ -72,9 +78,9 @@ PAYLOAD_POST_PROCESSORS: 'typing.Dict[str, PayloadPostProcessor]' = {
 
 
 def post_process_outcomming_request(
-    outcomming_request: 'OutgoingRequest',
-    model_provider: 'typing.Union[str, None]',
-) -> 'OutgoingRequest':
+    outcomming_request: "OutgoingRequest",
+    model_provider: "typing.Union[str, None]",
+) -> "OutgoingRequest":
     """Apply the provider-specific payload hook to one outgoing request.
 
     This is the single wrapper around `PAYLOAD_POST_PROCESSORS`: it normalizes

responses_server/server.py

@@ -1,43 +1,43 @@
+import typing
 
 from .config import CompatServerConfig
 from .payload_processors import post_process_outcomming_request
 from .session_store import SessionStore
 from .stream_router import StreamRouter
 from .trajectory_dump import TrajectoryDumpWriter
-import typing
 
 
 class ResponseServer:
     def __init__(
         self,
-        config: 'CompatServerConfig',
-        session_store: 'typing.Union[SessionStore, None]' = None,
-        stream_router: 'typing.Union[StreamRouter, None]' = None,
-    ) -> 'None':
+        config: "CompatServerConfig",
+        session_store: "typing.Union[SessionStore, None]" = None,
+        stream_router: "typing.Union[StreamRouter, None]" = None,
+    ) -> "None":
         self._config = config
         self._session_store = session_store or SessionStore()
         self._stream_router = stream_router or StreamRouter(config)
         self._trajectory_dump = TrajectoryDumpWriter.from_env()
 
     @property
-    def config(self) -> 'CompatServerConfig':
+    def config(self) -> "CompatServerConfig":
         return self._config
 
     @property
-    def session_store(self) -> 'SessionStore':
+    def session_store(self) -> "SessionStore":
         return self._session_store
 
     @property
-    def stream_router(self) -> 'StreamRouter':
+    def stream_router(self) -> "StreamRouter":
         return self._stream_router
 
-    def list_models(self) -> 'typing.Dict[str, object]':
+    def list_models(self) -> "typing.Dict[str, object]":
         return self._stream_router.list_models()
 
     def start_response_stream(
         self,
-        request_body: 'typing.Dict[str, object]',
-        request_headers: 'typing.Dict[str, str]',
+        request_body: "typing.Dict[str, object]",
+        request_headers: "typing.Dict[str, str]",
     ):
         outcomming_request = self._stream_router.build_outcomming_request(request_body)
         if self._trajectory_dump is not None:

responses_server/session_store.py

@@ -1,25 +1,28 @@
-
-from dataclasses import dataclass
 import threading
 import time
 import typing
+from dataclasses import dataclass
 
 
-@dataclass(frozen=True, )
+@dataclass(
+    frozen=True,
+)
 class StoredResponse:
-    response_id: 'str'
-    session_id: 'typing.Union[str, None]'
-    model: 'str'
-    created_at: 'float'
+    response_id: "str"
+    session_id: "typing.Union[str, None]"
+    model: "str"
+    created_at: "float"
 
 
 class SessionStore:
-    def __init__(self) -> 'None':
+    def __init__(self) -> "None":
         self._lock = threading.Lock()
         self._next_response_number = 1
-        self._responses: 'typing.Dict[str, StoredResponse]' = {}
+        self._responses: "typing.Dict[str, StoredResponse]" = {}
 
-    def create_response(self, session_id: 'typing.Union[str, None]', model: 'str') -> 'StoredResponse':
+    def create_response(
+        self, session_id: "typing.Union[str, None]", model: "str"
+    ) -> "StoredResponse":
         with self._lock:
             response_id = f"resp_{self._next_response_number:08d}"
             self._next_response_number += 1
@@ -32,6 +35,6 @@ class SessionStore:
             self._responses[response_id] = stored
             return stored
 
-    def get_response(self, response_id: 'str') -> 'typing.Union[StoredResponse, None]':
+    def get_response(self, response_id: "str") -> "typing.Union[StoredResponse, None]":
         with self._lock:
             return self._responses.get(response_id)