python-codex 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

responses_server/stream_router.py

@@ -1,6 +1,6 @@
-from __future__ import annotations
 
 import json
+import http.client
 import ssl
 import urllib.error
 import urllib.request
@@ -21,6 +21,7 @@ from .tools.web_search import (
     hydrate_tool_call_names,
     partition_tool_calls,
 )
+import typing
 
 
 class UnsupportedIncommingFeature(ValueError):
@@ -32,15 +33,15 @@ class OutcommingChatError(RuntimeError):
 
 
 class StreamRouter:
-    def __init__(self, config: CompatServerConfig) -> None:
+    def __init__(self, config: 'CompatServerConfig') -> 'None':
         self._config = config
         self._mock_web_search = WebSearchTool()
 
     def _provider_capability(
         self,
-        explicit_support: dict[str, bool],
-        default: bool | None = None,
-    ) -> bool:
+        explicit_support: 'typing.Dict[str, bool]',
+        default: 'typing.Union[bool, None]' = None,
+    ) -> 'bool':
         provider_name = str(self._config.model_provider or "").strip().lower()
         if provider_name in explicit_support:
             return explicit_support[provider_name]
@@ -50,7 +51,7 @@ class StreamRouter:
             return default
         raise KeyError("provider capability map is missing `vllm` fallback")
 
-    def _supports_chat_reasoning(self) -> bool:
+    def _supports_chat_reasoning(self) -> 'bool':
         # Unknown providers inherit the vLLM compatibility behavior unless a
         # provider is explicitly declared otherwise.
         return self._provider_capability(
@@ -60,7 +61,7 @@ class StreamRouter:
             }
         )
 
-    def _supports_stream_usage(self) -> bool:
+    def _supports_stream_usage(self) -> 'bool':
         return self._provider_capability(
             {
                 "vllm": True,
@@ -70,8 +71,8 @@ class StreamRouter:
 
     def validate_incomming_request(
         self,
-        incomming_request: dict[str, object],
-    ) -> None:
+        incomming_request: 'typing.Dict[str, object]',
+    ) -> 'None':
         model = str(incomming_request.get("model", "")).strip()
         if not model:
             raise UnsupportedIncommingFeature("incomming request is missing `model`")
@@ -90,11 +91,11 @@ class StreamRouter:
 
     def collect_custom_tool_names(
         self,
-        incomming_request: dict[str, object],
-    ) -> set[str]:
+        incomming_request: 'typing.Dict[str, object]',
+    ) -> 'typing.Set[str]':
         return collect_custom_tool_names(incomming_request.get("tools") or [])
 
-    def list_models(self) -> dict[str, object]:
+    def list_models(self) -> 'typing.Dict[str, object]':
         request = urllib.request.Request(
             self._config.outcomming_models_url(),
             headers=self._build_headers(accept="application/json"),
@@ -104,8 +105,8 @@ class StreamRouter:
 
     def build_outcomming_request(
         self,
-        incomming_request: dict[str, object],
-    ) -> dict[str, object]:
+        incomming_request: 'typing.Dict[str, object]',
+    ) -> 'typing.Dict[str, object]':
         model = str(incomming_request.get("model", "")).strip()
         if not model:
             raise UnsupportedIncommingFeature("incomming request is missing `model`")
@@ -121,7 +122,7 @@ class StreamRouter:
         if not isinstance(input_items, list):
             raise UnsupportedIncommingFeature("incomming `input` must be a list")
 
-        payload: dict[str, object] = {
+        payload: 'typing.Dict[str, object]' = {
             "model": model,
             "messages": self._responses_input_to_chat_messages(
                 instructions,
@@ -148,7 +149,7 @@ class StreamRouter:
 
         return payload
 
-    def open_outcomming_stream(self, outcomming_request: dict[str, object]):
+    def open_outcomming_stream(self, outcomming_request: 'typing.Dict[str, object]'):
         request = urllib.request.Request(
             self._config.outcomming_chat_completions_url(),
             data=json.dumps(outcomming_request).encode("utf-8"),
@@ -161,12 +162,30 @@ class StreamRouter:
                 context=ssl.create_default_context(),
                 timeout=self._config.timeout_seconds,
             ) as response:
-                for _event_name, data in self._iter_sse_events(response):
-                    if not data:
-                        continue
-                    if data == "[DONE]":
-                        break
-                    yield json.loads(data)
+                try:
+                    saw_done = False
+                    for _event_name, data in self._iter_sse_events(response):
+                        if not data:
+                            continue
+                        if data == "[DONE]":
+                            saw_done = True
+                            break
+                        yield json.loads(data)
+                    if not saw_done:
+                        raise OutcommingChatError(
+                            "outcomming chat stream ended before [DONE]"
+                        )
+                except (
+                    ConnectionError,
+                    EOFError,
+                    OSError,
+                    http.client.HTTPException,
+                    json.JSONDecodeError,
+                ) as exc:
+                    raise OutcommingChatError(
+                        "outcomming chat stream failed while reading response body: "
+                        f"{exc}"
+                    ) from exc
         except urllib.error.HTTPError as exc:
             body = exc.read().decode("utf-8", errors="replace")
             raise OutcommingChatError(
@@ -180,9 +199,9 @@ class StreamRouter:
     def route_stream(
         self,
         incomming_stream,
-        stored_response: StoredResponse,
-        outcomming_request: dict[str, object],
-        custom_tool_names: set[str] | None = None,
+        stored_response: 'StoredResponse',
+        outcomming_request: 'typing.Dict[str, object]',
+        custom_tool_names: 'typing.Union[typing.Set[str], None]' = None,
     ):
         yield (
             "response.created",
@@ -197,15 +216,15 @@ class StreamRouter:
             },
         )
 
-        text_parts: list[str] = []
-        reasoning_parts: list[str] = []
-        latest_usage: dict[str, object] = {}
+        text_parts: 'typing.List[str]' = []
+        reasoning_parts: 'typing.List[str]' = []
+        latest_usage: 'typing.Dict[str, object]' = {}
         current_request = json.loads(json.dumps(outcomming_request))
         current_stream = incomming_stream
 
         while True:
-            tool_calls: dict[int, dict[str, object]] = {}
-            current_usage: dict[str, object] = {}
+            tool_calls: 'typing.Dict[int, typing.Dict[str, object]]' = {}
+            current_usage: 'typing.Dict[str, object]' = {}
             for chunk in current_stream:
                 for event_name, payload in self._consume_chat_chunk(
                     chunk,
@@ -290,16 +309,16 @@ class StreamRouter:
 
     def _responses_input_to_chat_messages(
         self,
-        instructions: str,
-        input_items: list[object],
-    ) -> list[dict[str, object]]:
-        messages: list[dict[str, object]] = []
+        instructions: 'str',
+        input_items: 'typing.List[object]',
+    ) -> 'typing.List[typing.Dict[str, object]]':
+        messages: 'typing.List[typing.Dict[str, object]]' = []
         if instructions:
             messages.append({"role": "developer", "content": instructions})
 
-        pending_assistant: dict[str, object] | None = None
+        pending_assistant: 'typing.Union[typing.Dict[str, object], None]' = None
 
-        def flush_pending_assistant() -> None:
+        def flush_pending_assistant() -> 'None':
             nonlocal pending_assistant
             if pending_assistant is None:
                 return
@@ -420,7 +439,7 @@ class StreamRouter:
         flush_pending_assistant()
         return messages
 
-    def _coalesce_content_text(self, raw_content: object) -> str:
+    def _coalesce_content_text(self, raw_content: 'object') -> 'str':
         if raw_content is None:
             return ""
         if isinstance(raw_content, str):
@@ -430,7 +449,7 @@ class StreamRouter:
                 "message `content` must be a list or string"
             )
 
-        text_parts: list[str] = []
+        text_parts: 'typing.List[str]' = []
         for part in raw_content:
             if not isinstance(part, dict):
                 raise UnsupportedIncommingFeature(
@@ -445,17 +464,17 @@ class StreamRouter:
             )
         return "".join(text_parts)
 
-    def _coalesce_tool_output_text(self, raw_output: object) -> str:
+    def _coalesce_tool_output_text(self, raw_output: 'object') -> 'str':
         if isinstance(raw_output, str):
             return raw_output
         if isinstance(raw_output, list):
             return self._coalesce_content_text(raw_output)
         return json.dumps(raw_output, ensure_ascii=False)
 
-    def _coalesce_reasoning_text(self, raw_item: dict[str, object]) -> str:
+    def _coalesce_reasoning_text(self, raw_item: 'typing.Dict[str, object]') -> 'str':
         content = raw_item.get("content")
         if isinstance(content, list):
-            text_parts: list[str] = []
+            text_parts: 'typing.List[str]' = []
             for part in content:
                 if not isinstance(part, dict):
                     continue
@@ -482,8 +501,8 @@ class StreamRouter:
                 return value
         return ""
 
-    def _translate_tools(self, incomming_tools: list[object]) -> list[dict[str, object]]:
-        translated: list[dict[str, object]] = []
+    def _translate_tools(self, incomming_tools: 'typing.List[object]') -> 'typing.List[typing.Dict[str, object]]':
+        translated: 'typing.List[typing.Dict[str, object]]' = []
         for raw_tool in incomming_tools:
             if not isinstance(raw_tool, dict):
                 raise UnsupportedIncommingFeature("tool definitions must be objects")
@@ -518,7 +537,7 @@ class StreamRouter:
             )
         return translated
 
-    def _translate_tool_choice(self, raw_tool_choice: object) -> object:
+    def _translate_tool_choice(self, raw_tool_choice: 'object') -> 'object':
         if isinstance(raw_tool_choice, str):
             return raw_tool_choice
         if not isinstance(raw_tool_choice, dict):
@@ -541,13 +560,13 @@ class StreamRouter:
 
     def _consume_chat_chunk(
         self,
-        payload: dict[str, object],
-        reasoning_parts: list[str],
-        text_parts: list[str],
-        tool_calls: dict[int, dict[str, object]],
-        current_usage: dict[str, object],
-    ) -> list[tuple[str, dict[str, object]]]:
-        events: list[tuple[str, dict[str, object]]] = []
+        payload: 'typing.Dict[str, object]',
+        reasoning_parts: 'typing.List[str]',
+        text_parts: 'typing.List[str]',
+        tool_calls: 'typing.Dict[int, typing.Dict[str, object]]',
+        current_usage: 'typing.Dict[str, object]',
+    ) -> 'typing.List[typing.Tuple[str, typing.Dict[str, object]]]':
+        events: 'typing.List[typing.Tuple[str, typing.Dict[str, object]]]' = []
         usage = payload.get("usage")
         if isinstance(usage, dict):
             self._capture_usage_snapshot(current_usage, usage)
@@ -627,9 +646,9 @@ class StreamRouter:
 
     def _capture_usage_snapshot(
         self,
-        current_usage: dict[str, object],
-        usage: dict[str, object],
-    ) -> None:
+        current_usage: 'typing.Dict[str, object]',
+        usage: 'typing.Dict[str, object]',
+    ) -> 'None':
         scalar_mappings = (
             ("input_tokens", usage.get("input_tokens", usage.get("prompt_tokens"))),
             (
@@ -661,12 +680,12 @@ class StreamRouter:
 
     def _build_output_items(
         self,
-        reasoning_parts: list[str],
-        text_parts: list[str],
-        tool_calls: dict[int, dict[str, object]],
-        custom_tool_names: set[str],
-    ) -> list[dict[str, object]]:
-        items: list[dict[str, object]] = []
+        reasoning_parts: 'typing.List[str]',
+        text_parts: 'typing.List[str]',
+        tool_calls: 'typing.Dict[int, typing.Dict[str, object]]',
+        custom_tool_names: 'typing.Set[str]',
+    ) -> 'typing.List[typing.Dict[str, object]]':
+        items: 'typing.List[typing.Dict[str, object]]' = []
         reasoning_text = "".join(reasoning_parts)
         if reasoning_text:
             items.append(
@@ -731,7 +750,7 @@ class StreamRouter:
 
         return items
 
-    def _request_json(self, request: urllib.request.Request) -> dict[str, object]:
+    def _request_json(self, request: 'urllib.request.Request') -> 'typing.Dict[str, object]':
         try:
             with urllib.request.urlopen(
                 request,
@@ -749,7 +768,7 @@ class StreamRouter:
                 f"outcomming request failed: {exc.reason}"
             ) from exc
 
-    def _build_headers(self, accept: str) -> dict[str, str]:
+    def _build_headers(self, accept: 'str') -> 'typing.Dict[str, str]':
         headers = {
             "Accept": accept,
             "Content-Type": "application/json",
@@ -760,8 +779,8 @@ class StreamRouter:
         return headers
 
     def _iter_sse_events(self, response):
-        event_name: str | None = None
-        data_lines: list[str] = []
+        event_name: 'typing.Union[str, None]' = None
+        data_lines: 'typing.List[str]' = []
 
         for raw_line in response:
             line = raw_line.decode("utf-8", errors="replace").rstrip("\r\n")

responses_server/tools/custom_adapter.py

@@ -1,7 +1,7 @@
-from __future__ import annotations
 
 from copy import deepcopy
 import json
+import typing
 
 
 class CustomToolAdapterError(ValueError):
@@ -82,8 +82,8 @@ It is important to remember:
 """
 
 
-def collect_custom_tool_names(raw_tools: object) -> set[str]:
-    names: set[str] = set()
+def collect_custom_tool_names(raw_tools: 'object') -> 'typing.Set[str]':
+    names: 'typing.Set[str]' = set()
     if not isinstance(raw_tools, list):
         return names
     for raw_tool in raw_tools:
@@ -95,7 +95,7 @@ def collect_custom_tool_names(raw_tools: object) -> set[str]:
     return names
 
 
-def build_tool_definition(raw_tool: dict[str, object]) -> dict[str, object]:
+def build_tool_definition(raw_tool: 'typing.Dict[str, object]') -> 'typing.Dict[str, object]':
     name = _required_tool_name(raw_tool)
     description = _build_description(raw_tool)
     input_description = (
@@ -125,7 +125,7 @@ def build_tool_definition(raw_tool: dict[str, object]) -> dict[str, object]:
     }
 
 
-def build_tool_call(raw_item: dict[str, object]) -> dict[str, object]:
+def build_tool_call(raw_item: 'typing.Dict[str, object]') -> 'typing.Dict[str, object]':
     name = _required_item_name(raw_item)
     return {
         "id": str(raw_item.get("call_id", "")).strip() or name,
@@ -141,7 +141,7 @@ def build_tool_call(raw_item: dict[str, object]) -> dict[str, object]:
     }
 
 
-def build_output_item(tool_call: dict[str, object], index: int) -> dict[str, object]:
+def build_output_item(tool_call: 'typing.Dict[str, object]', index: 'int') -> 'typing.Dict[str, object]':
     function = tool_call.get("function") or {}
     if not isinstance(function, dict):
         raise CustomToolAdapterError(
@@ -160,7 +160,7 @@ def build_output_item(tool_call: dict[str, object], index: int) -> dict[str, obj
     }
 
 
-def extract_input_text(raw_arguments: object) -> str:
+def extract_input_text(raw_arguments: 'object') -> 'str':
     if isinstance(raw_arguments, dict):
         parsed = deepcopy(raw_arguments)
     else:
@@ -186,7 +186,7 @@ def extract_input_text(raw_arguments: object) -> str:
     return str(raw_arguments or "")
 
 
-def _build_description(raw_tool: dict[str, object]) -> str:
+def _build_description(raw_tool: 'typing.Dict[str, object]') -> 'str':
     name = _tool_name(raw_tool)
     if name == APPLY_PATCH_NAME:
         return APPLY_PATCH_CHAT_DESCRIPTION
@@ -200,7 +200,7 @@ def _build_description(raw_tool: dict[str, object]) -> str:
 
     raw_format = raw_tool.get("format")
     if isinstance(raw_format, dict):
-        format_lines: list[str] = []
+        format_lines: 'typing.List[str]' = []
         format_type = str(raw_format.get("type", "")).strip()
         syntax = str(raw_format.get("syntax", "")).strip()
         definition = str(raw_format.get("definition", "") or "").strip()
@@ -217,18 +217,18 @@ def _build_description(raw_tool: dict[str, object]) -> str:
     return "\n\n".join(parts)
 
 
-def _tool_name(raw_tool: dict[str, object]) -> str:
+def _tool_name(raw_tool: 'typing.Dict[str, object]') -> 'str':
     return str(raw_tool.get("name", "")).strip()
 
 
-def _required_tool_name(raw_tool: dict[str, object]) -> str:
+def _required_tool_name(raw_tool: 'typing.Dict[str, object]') -> 'str':
     name = _tool_name(raw_tool)
     if not name:
         raise CustomToolAdapterError("custom tool definition is missing `name`")
     return name
 
 
-def _required_item_name(raw_item: dict[str, object]) -> str:
+def _required_item_name(raw_item: 'typing.Dict[str, object]') -> 'str':
     name = str(raw_item.get("name", "")).strip()
     if not name:
         raise CustomToolAdapterError("custom tool call is missing `name`")

responses_server/tools/web_search.py

@@ -1,10 +1,10 @@
-from __future__ import annotations
 
 from copy import deepcopy
 import json
 
 from pycodex.protocol import JSONValue
 from pycodex.tools.base_tool import BaseTool, ToolContext
+import typing
 
 
 class WebSearchTool(BaseTool):
@@ -29,10 +29,10 @@ class WebSearchTool(BaseTool):
     }
     supports_parallel = False
 
-    async def run(self, context: ToolContext, args: JSONValue) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONValue') -> 'JSONValue':
         del context
         query, queries = extract_queries(args)
-        output_payload: dict[str, object] = {
+        output_payload: 'typing.Dict[str, object]' = {
             "results": [],
             "mock": True,
         }
@@ -43,7 +43,7 @@ class WebSearchTool(BaseTool):
         return output_payload
 
 
-def build_tool_definition(tool: WebSearchTool) -> dict[str, object]:
+def build_tool_definition(tool: 'WebSearchTool') -> 'typing.Dict[str, object]':
     return {
         "type": "function",
         "name": tool.name,
@@ -57,13 +57,13 @@ def build_tool_definition(tool: WebSearchTool) -> dict[str, object]:
 
 
 def partition_tool_calls(
-    tool: WebSearchTool,
-    tool_calls: dict[int, dict[str, object]],
-    outcomming_request: dict[str, object],
-) -> tuple[list[dict[str, object]], dict[int, dict[str, object]]]:
+    tool: 'WebSearchTool',
+    tool_calls: 'typing.Dict[int, typing.Dict[str, object]]',
+    outcomming_request: 'typing.Dict[str, object]',
+) -> 'typing.Tuple[typing.List[typing.Dict[str, object]], typing.Dict[int, typing.Dict[str, object]]]':
     mock_tool_names = _collect_mock_tool_names(tool, outcomming_request)
-    mock_calls: list[dict[str, object]] = []
-    ordinary_tool_calls: dict[int, dict[str, object]] = {}
+    mock_calls: 'typing.List[typing.Dict[str, object]]' = []
+    ordinary_tool_calls: 'typing.Dict[int, typing.Dict[str, object]]' = {}
     for index in sorted(tool_calls):
         tool_call = tool_calls[index]
         function = tool_call.get("function") or {}
@@ -78,9 +78,9 @@ def partition_tool_calls(
 
 
 def hydrate_tool_call_names(
-    tool_calls: dict[int, dict[str, object]],
-    outcomming_request: dict[str, object],
-) -> None:
+    tool_calls: 'typing.Dict[int, typing.Dict[str, object]]',
+    outcomming_request: 'typing.Dict[str, object]',
+) -> 'None':
     raw_tools = outcomming_request.get("tools") or []
     if not isinstance(raw_tools, list):
         return
@@ -104,15 +104,15 @@ def hydrate_tool_call_names(
 
 
 def build_output_items(
-    mock_search_calls: list[dict[str, object]],
-) -> list[dict[str, object]]:
-    items: list[dict[str, object]] = []
+    mock_search_calls: 'typing.List[typing.Dict[str, object]]',
+) -> 'typing.List[typing.Dict[str, object]]':
+    items: 'typing.List[typing.Dict[str, object]]' = []
     for tool_call in mock_search_calls:
         function = tool_call.get("function") or {}
         if not isinstance(function, dict):
             continue
         query, queries = extract_queries(function.get("arguments"))
-        action: dict[str, object] = {"type": "search"}
+        action: 'typing.Dict[str, object]' = {"type": "search"}
         if query:
             action["query"] = query
         if queries:
@@ -128,17 +128,17 @@ def build_output_items(
 
 
 def build_followup_request(
-    tool: WebSearchTool,
-    outcomming_request: dict[str, object],
-    mock_search_calls: list[dict[str, object]],
-    reasoning_text: str | None = None,
-) -> dict[str, object]:
+    tool: 'WebSearchTool',
+    outcomming_request: 'typing.Dict[str, object]',
+    mock_search_calls: 'typing.List[typing.Dict[str, object]]',
+    reasoning_text: 'typing.Union[str, None]' = None,
+) -> 'typing.Dict[str, object]':
     followup_request = deepcopy(outcomming_request)
     messages = followup_request.get("messages") or []
     if not isinstance(messages, list):
         raise ValueError("outcomming request messages must be a list")
 
-    assistant_tool_calls: list[dict[str, object]] = []
+    assistant_tool_calls: 'typing.List[typing.Dict[str, object]]' = []
     for tool_call in mock_search_calls:
         function = tool_call.get("function") or {}
         if not isinstance(function, dict):
@@ -154,7 +154,7 @@ def build_followup_request(
             }
         )
     if assistant_tool_calls:
-        assistant_message: dict[str, object] = {
+        assistant_message: 'typing.Dict[str, object]' = {
             "role": "assistant",
             "tool_calls": assistant_tool_calls,
         }
@@ -187,7 +187,7 @@ def build_followup_request(
     return followup_request
 
 
-def extract_queries(raw_arguments: JSONValue) -> tuple[str, list[str]]:
+def extract_queries(raw_arguments: 'JSONValue') -> 'typing.Tuple[str, typing.List[str]]':
     if isinstance(raw_arguments, dict):
         parsed = raw_arguments
     else:
@@ -211,7 +211,7 @@ def extract_queries(raw_arguments: JSONValue) -> tuple[str, list[str]]:
 
     query = str(parsed.get("query", "")).strip()
     queries_value = parsed.get("queries") or []
-    queries: list[str] = []
+    queries: 'typing.List[str]' = []
     if isinstance(queries_value, list):
         for value in queries_value:
             normalized = str(value).strip()
@@ -224,7 +224,7 @@ def extract_queries(raw_arguments: JSONValue) -> tuple[str, list[str]]:
     return query, queries
 
 
-def is_mock_tool(tool: WebSearchTool, raw_tool: object) -> bool:
+def is_mock_tool(tool: 'WebSearchTool', raw_tool: 'object') -> 'bool':
     if not isinstance(raw_tool, dict) or raw_tool.get("type") != "function":
         return False
     function = raw_tool.get("function") or {}
@@ -237,10 +237,10 @@ def is_mock_tool(tool: WebSearchTool, raw_tool: object) -> bool:
 
 
 def _collect_mock_tool_names(
-    tool: WebSearchTool,
-    outcomming_request: dict[str, object],
-) -> set[str]:
-    names: set[str] = set()
+    tool: 'WebSearchTool',
+    outcomming_request: 'typing.Dict[str, object]',
+) -> 'typing.Set[str]':
+    names: 'typing.Set[str]' = set()
     raw_tools = outcomming_request.get("tools") or []
     if not isinstance(raw_tools, list):
         return names
@@ -250,9 +250,9 @@ def _collect_mock_tool_names(
     return names
 
 
-def _build_mock_output(raw_arguments: JSONValue) -> dict[str, object]:
+def _build_mock_output(raw_arguments: 'JSONValue') -> 'typing.Dict[str, object]':
     query, queries = extract_queries(raw_arguments)
-    output_payload: dict[str, object] = {
+    output_payload: 'typing.Dict[str, object]' = {
         "results": [],
         "mock": True,
     }