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

responses_server/tools/custom_adapter.py

@@ -1,7 +1,6 @@
-
-from copy import deepcopy
 import json
 import typing
+from copy import deepcopy
 
 
 class CustomToolAdapterError(ValueError):
@@ -82,8 +81,8 @@ It is important to remember:
 """
 
 
-def collect_custom_tool_names(raw_tools: 'object') -> 'typing.Set[str]':
-    names: 'typing.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 +94,9 @@ def collect_custom_tool_names(raw_tools: 'object') -> 'typing.Set[str]':
     return names
 
 
-def build_tool_definition(raw_tool: 'typing.Dict[str, object]') -> 'typing.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 +126,7 @@ def build_tool_definition(raw_tool: 'typing.Dict[str, object]') -> 'typing.Dict[
     }
 
 
-def build_tool_call(raw_item: 'typing.Dict[str, object]') -> 'typing.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 +142,9 @@ def build_tool_call(raw_item: 'typing.Dict[str, object]') -> 'typing.Dict[str, o
     }
 
 
-def build_output_item(tool_call: 'typing.Dict[str, object]', index: 'int') -> 'typing.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(
@@ -149,9 +152,7 @@ def build_output_item(tool_call: 'typing.Dict[str, object]', index: 'int') -> 't
         )
     name = str(function.get("name", "")).strip()
     if not name:
-        raise CustomToolAdapterError(
-            "outcomming custom tool call is missing `name`"
-        )
+        raise CustomToolAdapterError("outcomming custom tool call is missing `name`")
     return {
         "type": "custom_tool_call",
         "call_id": str(tool_call.get("id", "")).strip() or f"call_{index}",
@@ -160,7 +161,7 @@ def build_output_item(tool_call: 'typing.Dict[str, object]', index: 'int') -> 't
     }
 
 
-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 +187,7 @@ def extract_input_text(raw_arguments: 'object') -> 'str':
     return str(raw_arguments or "")
 
 
-def _build_description(raw_tool: 'typing.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 +201,7 @@ def _build_description(raw_tool: 'typing.Dict[str, object]') -> 'str':
 
     raw_format = raw_tool.get("format")
     if isinstance(raw_format, dict):
-        format_lines: 'typing.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 +218,18 @@ def _build_description(raw_tool: 'typing.Dict[str, object]') -> 'str':
     return "\n\n".join(parts)
 
 
-def _tool_name(raw_tool: 'typing.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: 'typing.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: 'typing.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,9 @@
-
-from copy import deepcopy
 import json
+import typing
+from copy import deepcopy
 
 from pycodex.protocol import JSONValue
 from pycodex.tools.base_tool import BaseTool, ToolContext
-import typing
 
 
 class WebSearchTool(BaseTool):
@@ -29,10 +28,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: 'typing.Dict[str, object]' = {
+        output_payload: "typing.Dict[str, object]" = {
             "results": [],
             "mock": True,
         }
@@ -43,7 +42,7 @@ class WebSearchTool(BaseTool):
         return output_payload
 
 
-def build_tool_definition(tool: 'WebSearchTool') -> 'typing.Dict[str, object]':
+def build_tool_definition(tool: "WebSearchTool") -> "typing.Dict[str, object]":
     return {
         "type": "function",
         "name": tool.name,
@@ -57,13 +56,13 @@ def build_tool_definition(tool: 'WebSearchTool') -> 'typing.Dict[str, object]':
 
 
 def partition_tool_calls(
-    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]]]':
+    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: 'typing.List[typing.Dict[str, object]]' = []
-    ordinary_tool_calls: 'typing.Dict[int, typing.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 +77,9 @@ def partition_tool_calls(
 
 
 def hydrate_tool_call_names(
-    tool_calls: 'typing.Dict[int, typing.Dict[str, object]]',
-    outcomming_request: 'typing.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 +103,15 @@ def hydrate_tool_call_names(
 
 
 def build_output_items(
-    mock_search_calls: 'typing.List[typing.Dict[str, object]]',
-) -> 'typing.List[typing.Dict[str, object]]':
-    items: 'typing.List[typing.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: 'typing.Dict[str, object]' = {"type": "search"}
+        action: "typing.Dict[str, object]" = {"type": "search"}
         if query:
             action["query"] = query
         if queries:
@@ -128,17 +127,17 @@ def build_output_items(
 
 
 def build_followup_request(
-    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]':
+    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: 'typing.List[typing.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 +153,7 @@ def build_followup_request(
             }
         )
     if assistant_tool_calls:
-        assistant_message: 'typing.Dict[str, object]' = {
+        assistant_message: "typing.Dict[str, object]" = {
             "role": "assistant",
             "tool_calls": assistant_tool_calls,
         }
@@ -163,7 +162,9 @@ def build_followup_request(
         messages.append(assistant_message)
 
     for tool_call in mock_search_calls:
-        tool_output = _build_mock_output((tool_call.get("function") or {}).get("arguments"))
+        tool_output = _build_mock_output(
+            (tool_call.get("function") or {}).get("arguments")
+        )
         messages.append(
             {
                 "role": "tool",
@@ -187,7 +188,9 @@ def build_followup_request(
     return followup_request
 
 
-def extract_queries(raw_arguments: 'JSONValue') -> 'typing.Tuple[str, typing.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 +214,7 @@ def extract_queries(raw_arguments: 'JSONValue') -> 'typing.Tuple[str, typing.Lis
 
     query = str(parsed.get("query", "")).strip()
     queries_value = parsed.get("queries") or []
-    queries: 'typing.List[str]' = []
+    queries: "typing.List[str]" = []
     if isinstance(queries_value, list):
         for value in queries_value:
             normalized = str(value).strip()
@@ -224,7 +227,7 @@ def extract_queries(raw_arguments: 'JSONValue') -> 'typing.Tuple[str, typing.Lis
     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 +240,10 @@ def is_mock_tool(tool: 'WebSearchTool', raw_tool: 'object') -> 'bool':
 
 
 def _collect_mock_tool_names(
-    tool: 'WebSearchTool',
-    outcomming_request: 'typing.Dict[str, object]',
-) -> 'typing.Set[str]':
-    names: 'typing.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 +253,9 @@ def _collect_mock_tool_names(
     return names
 
 
-def _build_mock_output(raw_arguments: 'JSONValue') -> 'typing.Dict[str, object]':
+def _build_mock_output(raw_arguments: "JSONValue") -> "typing.Dict[str, object]":
     query, queries = extract_queries(raw_arguments)
-    output_payload: 'typing.Dict[str, object]' = {
+    output_payload: "typing.Dict[str, object]" = {
         "results": [],
         "mock": True,
     }

responses_server/trajectory_dump.py

@@ -4,19 +4,20 @@ import sys
 import threading
 import time
 import typing
+import urllib.error
 
 
 class TrajectoryDumpWriter:
     ENV_VAR = "PYCODEX_DUMP"
 
-    def __init__(self, root_dir: 'str') -> 'None':
+    def __init__(self, root_dir: "str") -> "None":
         self._root_dir = os.path.abspath(root_dir)
         self._dump_path = os.path.join(self._root_dir, "dump.jsonl")
         self._lock = threading.Lock()
         os.makedirs(self._root_dir, exist_ok=True)
 
     @classmethod
-    def from_env(cls) -> 'typing.Union[TrajectoryDumpWriter, None]':
+    def from_env(cls) -> "typing.Union[TrajectoryDumpWriter, None]":
         root_dir = str(os.environ.get(cls.ENV_VAR, "") or "").strip()
         if not root_dir:
             return None
@@ -25,7 +26,7 @@ class TrajectoryDumpWriter:
     def wrap_stream(
         self,
         outcomming_stream,
-        outcomming_request: 'typing.Dict[str, object]',
+        outcomming_request: "typing.Dict[str, object]",
     ):
         def iter_stream():
             capture = _TrajectoryCapture(
@@ -37,12 +38,22 @@ class TrajectoryDumpWriter:
                 for chunk in outcomming_stream:
                     capture.observe_chunk(chunk)
                     yield chunk
+            except Exception as error:
+                capture.stream_error_type = type(error).__name__
+                cause = error.__cause__
+                if cause is not None:
+                    capture.stream_error_cause_type = type(cause).__name__
+                if isinstance(cause, urllib.error.HTTPError):
+                    capture.stream_error_http_status = cause.code
+                raise
+            else:
+                capture.stream_completed = True
             finally:
                 capture.flush()
 
         return iter_stream()
 
-    def _append_record(self, record: 'typing.Dict[str, object]') -> 'None':
+    def _append_record(self, record: "typing.Dict[str, object]") -> "None":
         serialized = json.dumps(record, ensure_ascii=False)
         with self._lock:
             os.makedirs(self._root_dir, exist_ok=True)
@@ -54,19 +65,24 @@ class TrajectoryDumpWriter:
 class _TrajectoryCapture:
     def __init__(
         self,
-        writer: 'TrajectoryDumpWriter',
-        send_timestamp: 'float',
-        outcomming_request: 'typing.Dict[str, object]',
-    ) -> 'None':
+        writer: "TrajectoryDumpWriter",
+        send_timestamp: "float",
+        outcomming_request: "typing.Dict[str, object]",
+    ) -> "None":
         self._writer = writer
         self._send_timestamp = float(send_timestamp)
         self._outcomming_request = json.loads(json.dumps(outcomming_request))
         self._prefill_token_ids = None
         self._decode_token_ids = []
-        self._usage: 'typing.Dict[str, object]' = {}
+        self._usage: "typing.Dict[str, object]" = {}
+        self._finish_reason = None
         self._closed = False
+        self.stream_completed = False
+        self.stream_error_type = None
+        self.stream_error_cause_type = None
+        self.stream_error_http_status = None
 
-    def observe_chunk(self, payload: 'object') -> 'None':
+    def observe_chunk(self, payload: "object") -> "None":
         if not isinstance(payload, dict):
             return
         usage = payload.get("usage")
@@ -83,34 +99,40 @@ class _TrajectoryCapture:
         for raw_choice in choices:
             if not isinstance(raw_choice, dict):
                 continue
+            if raw_choice.get("finish_reason") is not None:
+                self._finish_reason = raw_choice["finish_reason"]
             normalized_decode = _normalize_token_ids(raw_choice.get("token_ids"))
             if normalized_decode:
                 self._decode_token_ids.extend(normalized_decode)
 
-    def flush(self) -> 'None':
+    def flush(self) -> "None":
         if self._closed:
             return
         self._closed = True
         record = {
             "request": self._outcomming_request,
             "usage": self._usage,
+            "finish_reason": self._finish_reason,
             "tokens": {
                 "prefill": list(self._prefill_token_ids or []),
                 "decode": list(self._decode_token_ids),
             },
             "send_timestamp": self._send_timestamp,
+            "stream_completed": self.stream_completed,
+            "stream_error_type": self.stream_error_type,
+            "stream_error_cause_type": self.stream_error_cause_type,
+            "stream_error_http_status": self.stream_error_http_status,
         }
         try:
             self._writer._append_record(record)
         except Exception as exc:
             print(
-                "responses_server: failed to append PYCODEX_DUMP trajectory: %s"
-                % exc,
+                "responses_server: failed to append PYCODEX_DUMP trajectory: %s" % exc,
                 file=sys.stderr,
             )
 
 
-def _normalize_token_ids(raw_value: 'object') -> 'typing.Union[typing.List[int], None]':
+def _normalize_token_ids(raw_value: "object") -> "typing.Union[typing.List[int], None]":
     if not isinstance(raw_value, list):
         return None
     token_ids = []

workspace_server/__main__.py

@@ -1,5 +1,4 @@
 from .app import main
 
-
 if __name__ == "__main__":
     main()