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

responses_server/stream_router.py

@@ -143,6 +143,17 @@ class StreamRouter:
             ),
             "stream": True,
         }
+        reasoning = incomming_request.get("reasoning")
+        if isinstance(reasoning, dict):
+            reasoning_effort = reasoning.get("effort")
+            if isinstance(reasoning_effort, str) and reasoning_effort:
+                # vLLM's Responses renderer consumes effort as a template
+                # kwarg; keeping it out of the chat schema also preserves
+                # provider-specific values such as `max`.
+                payload["chat_template_kwargs"] = {
+                    "reasoning_effort": reasoning_effort,
+                }
+
         max_tokens = self._coerce_positive_int(
             incomming_request.get("max_output_tokens")
         )
@@ -224,6 +235,11 @@ class StreamRouter:
             raise OutcommingChatError(
                 f"outcomming chat request failed with status {exc.code}: {body[:500]}"
             ) from exc
+        except TimeoutError as exc:
+            raise OutcommingChatError(
+                "outcomming chat request timed out after "
+                f"{self._config.timeout_seconds:g}s"
+            ) from exc
         except urllib.error.URLError as exc:
             raise OutcommingChatError(
                 f"outcomming chat request failed: {exc.reason}"
@@ -285,6 +301,11 @@ class StreamRouter:
             raise OutcommingChatError(
                 f"outcomming messages request failed with status {exc.code}: {body[:500]}"
             ) from exc
+        except TimeoutError as exc:
+            raise OutcommingChatError(
+                "outcomming messages request timed out after "
+                f"{self._config.timeout_seconds:g}s"
+            ) from exc
         except urllib.error.URLError as exc:
             raise OutcommingChatError(
                 f"outcomming messages request failed: {exc.reason}"
@@ -443,7 +464,10 @@ class StreamRouter:
         outcomming_stream = self.open_outcomming_stream(outcomming_request)
         if trajectory_dump is None:
             return outcomming_stream
-        return trajectory_dump.wrap_stream(outcomming_stream)
+        return trajectory_dump.wrap_stream(
+            outcomming_stream,
+            outcomming_request,
+        )
 
     def _responses_input_to_chat_messages(
         self,
@@ -455,6 +479,7 @@ class StreamRouter:
             messages.append({"role": "developer", "content": instructions})
 
         pending_assistant: 'typing.Union[typing.Dict[str, object], None]' = None
+        pending_tool_images: 'typing.List[typing.Dict[str, object]]' = []
 
         def flush_pending_assistant() -> 'None':
             nonlocal pending_assistant
@@ -470,12 +495,20 @@ class StreamRouter:
             messages.append(pending_assistant)
             pending_assistant = None
 
+        def flush_pending_tool_images() -> 'None':
+            if not pending_tool_images:
+                return
+            messages.append({"role": "user", "content": list(pending_tool_images)})
+            del pending_tool_images[:]
+
         for raw_item in input_items:
             if not isinstance(raw_item, dict):
                 raise UnsupportedIncommingFeature(
                     "all incomming `input` items must be objects"
                 )
             item_type = raw_item.get("type")
+            if item_type not in {"function_call_output", "custom_tool_call_output"}:
+                flush_pending_tool_images()
 
             if item_type == "message":
                 role = str(raw_item.get("role", "")).strip()
@@ -483,8 +516,12 @@ class StreamRouter:
                     raise UnsupportedIncommingFeature(
                         f"unsupported incomming message role: {role or '<empty>'}"
                     )
-                text = self._coalesce_content_text(raw_item.get("content"))
+                text, image_parts = self._split_content_parts(raw_item.get("content"))
                 if role == "assistant":
+                    if image_parts:
+                        raise UnsupportedIncommingFeature(
+                            "assistant messages cannot carry `input_image` content parts"
+                        )
                     if pending_assistant is None:
                         pending_assistant = {"role": "assistant"}
                     if text:
@@ -493,7 +530,13 @@ class StreamRouter:
                         )
                     continue
                 flush_pending_assistant()
-                messages.append({"role": role, "content": text})
+                if image_parts:
+                    content: 'object' = (
+                        ([{"type": "text", "text": text}] if text else []) + image_parts
+                    )
+                else:
+                    content = text
+                messages.append({"role": role, "content": content})
                 continue
 
             if item_type == "reasoning":
@@ -532,15 +575,17 @@ class StreamRouter:
 
             if item_type == "function_call_output":
                 flush_pending_assistant()
+                text, image_parts = self._split_tool_output_parts(
+                    raw_item.get("output")
+                )
                 messages.append(
                     {
                         "role": "tool",
                         "tool_call_id": str(raw_item.get("call_id", "")).strip(),
-                        "content": self._coalesce_tool_output_text(
-                            raw_item.get("output")
-                        ),
+                        "content": text,
                     }
                 )
+                pending_tool_images.extend(image_parts)
                 continue
 
             if item_type == "custom_tool_call":
@@ -559,15 +604,17 @@ class StreamRouter:
 
             if item_type == "custom_tool_call_output":
                 flush_pending_assistant()
+                text, image_parts = self._split_tool_output_parts(
+                    raw_item.get("output")
+                )
                 messages.append(
                     {
                         "role": "tool",
                         "tool_call_id": str(raw_item.get("call_id", "")).strip(),
-                        "content": self._coalesce_tool_output_text(
-                            raw_item.get("output")
-                        ),
+                        "content": text,
                     }
                 )
+                pending_tool_images.extend(image_parts)
                 continue
 
             raise UnsupportedIncommingFeature(
@@ -575,6 +622,7 @@ class StreamRouter:
             )
 
         flush_pending_assistant()
+        flush_pending_tool_images()
         return messages
 
     def _coerce_positive_int(self, raw_value: 'object') -> 'typing.Union[int, None]':
@@ -584,17 +632,21 @@ class StreamRouter:
             return raw_value
         return None
 
-    def _coalesce_content_text(self, raw_content: 'object') -> 'str':
+    def _split_content_parts(
+        self,
+        raw_content: 'object',
+    ) -> 'typing.Tuple[str, typing.List[typing.Dict[str, object]]]':
         if raw_content is None:
-            return ""
+            return "", []
         if isinstance(raw_content, str):
-            return raw_content
+            return raw_content, []
         if not isinstance(raw_content, list):
             raise UnsupportedIncommingFeature(
                 "message `content` must be a list or string"
             )
 
         text_parts: 'typing.List[str]' = []
+        image_parts: 'typing.List[typing.Dict[str, object]]' = []
         for part in raw_content:
             if not isinstance(part, dict):
                 raise UnsupportedIncommingFeature(
@@ -604,17 +656,38 @@ class StreamRouter:
             if part_type in {"input_text", "output_text"}:
                 text_parts.append(str(part.get("text", "")))
                 continue
+            if part_type == "input_image":
+                image_parts.append(self._build_chat_image_part(part))
+                continue
             raise UnsupportedIncommingFeature(
                 f"content part type `{part_type}` is not yet supported by the chat backend"
             )
-        return "".join(text_parts)
+        return "".join(text_parts), image_parts
+
+    def _build_chat_image_part(
+        self,
+        part: 'typing.Dict[str, object]',
+    ) -> 'typing.Dict[str, object]':
+        image_url = str(part.get("image_url", "") or "").strip()
+        if not image_url:
+            raise UnsupportedIncommingFeature(
+                "`input_image` content parts must carry a non-empty `image_url`"
+            )
+        image_payload: 'typing.Dict[str, object]' = {"url": image_url}
+        detail = part.get("detail")
+        if isinstance(detail, str) and detail in {"auto", "low", "high"}:
+            image_payload["detail"] = detail
+        return {"type": "image_url", "image_url": image_payload}
 
-    def _coalesce_tool_output_text(self, raw_output: 'object') -> 'str':
+    def _split_tool_output_parts(
+        self,
+        raw_output: 'object',
+    ) -> 'typing.Tuple[str, typing.List[typing.Dict[str, object]]]':
         if isinstance(raw_output, str):
-            return raw_output
+            return raw_output, []
         if isinstance(raw_output, list):
-            return self._coalesce_content_text(raw_output)
-        return json.dumps(raw_output, ensure_ascii=False)
+            return self._split_content_parts(raw_output)
+        return json.dumps(raw_output, ensure_ascii=False), []
 
     def _coalesce_reasoning_text(self, raw_item: 'typing.Dict[str, object]') -> 'str':
         content = raw_item.get("content")
@@ -732,12 +805,20 @@ class StreamRouter:
                 continue
 
             reasoning = delta.get("reasoning")
-            if isinstance(reasoning, str) and reasoning:
-                reasoning_parts.append(reasoning)
-
             reasoning_content = delta.get("reasoning_content")
-            if isinstance(reasoning_content, str) and reasoning_content:
-                reasoning_parts.append(reasoning_content)
+            if (
+                isinstance(reasoning, str)
+                and reasoning
+                and isinstance(reasoning_content, str)
+                and reasoning == reasoning_content
+            ):
+                # Some chat providers expose the same delta under both aliases.
+                reasoning_parts.append(reasoning)
+            else:
+                if isinstance(reasoning, str) and reasoning:
+                    reasoning_parts.append(reasoning)
+                if isinstance(reasoning_content, str) and reasoning_content:
+                    reasoning_parts.append(reasoning_content)
 
             content = delta.get("content")
             if isinstance(content, str) and content:
@@ -912,6 +993,11 @@ class StreamRouter:
             raise OutcommingChatError(
                 f"outcomming request failed with status {exc.code}: {body[:500]}"
             ) from exc
+        except TimeoutError as exc:
+            raise OutcommingChatError(
+                "outcomming request timed out after "
+                f"{self._config.timeout_seconds:g}s"
+            ) from exc
         except urllib.error.URLError as exc:
             raise OutcommingChatError(
                 f"outcomming request failed: {exc.reason}"

responses_server/trajectory_dump.py

@@ -22,9 +22,17 @@ class TrajectoryDumpWriter:
             return None
         return cls(root_dir)
 
-    def wrap_stream(self, outcomming_stream):
+    def wrap_stream(
+        self,
+        outcomming_stream,
+        outcomming_request: 'typing.Dict[str, object]',
+    ):
         def iter_stream():
-            capture = _TrajectoryCapture(self, time.time())
+            capture = _TrajectoryCapture(
+                self,
+                time.time(),
+                outcomming_request,
+            )
             try:
                 for chunk in outcomming_stream:
                     capture.observe_chunk(chunk)
@@ -48,16 +56,22 @@ class _TrajectoryCapture:
         self,
         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._closed = False
 
     def observe_chunk(self, payload: 'object') -> 'None':
         if not isinstance(payload, dict):
             return
+        usage = payload.get("usage")
+        if isinstance(usage, dict) and usage:
+            self._usage = json.loads(json.dumps(usage))
         if self._prefill_token_ids is None and "prompt_token_ids" in payload:
             normalized_prefill = _normalize_token_ids(payload.get("prompt_token_ids"))
             if normalized_prefill is not None:
@@ -78,6 +92,8 @@ class _TrajectoryCapture:
             return
         self._closed = True
         record = {
+            "request": self._outcomming_request,
+            "usage": self._usage,
             "tokens": {
                 "prefill": list(self._prefill_token_ids or []),
                 "decode": list(self._decode_token_ids),

workspace_server/app.py

@@ -32,7 +32,8 @@ from pycodex.utils.session_persist import (
 )
 from pycodex.utils import uuid7_string
 from pycodex.utils.visualize import (
-    IDLE_LISTENING_STATUS,
+    IDLE_SLEEPING_STATUS,
+    background_work_count,
     percent_of_context_window_remaining,
     shorten_title,
     tool_summary,
@@ -93,6 +94,12 @@ def build_parser() -> "argparse.ArgumentParser":
         default=None,
         help="Optional base instructions override passed to the model.",
     )
+    parser.add_argument(
+        "--toolset",
+        nargs="*",
+        default=None,
+        help="Builtin tool names for all sessions; an empty list disables tools.",
+    )
     parser.add_argument(
         "--timeout-seconds",
         type=float,
@@ -520,12 +527,8 @@ class WebSessionView:
         self._spinner_status = str(text or "").strip()
 
     def _set_idle_spinner_status(self, payload: "typing.Dict[str, object]") -> None:
-        try:
-            background_work_count = int(payload.get("background_exec_count", 0))
-        except (TypeError, ValueError):
-            background_work_count = 0
-        if background_work_count > 0:
-            self._set_spinner_status(IDLE_LISTENING_STATUS)
+        if background_work_count(payload) > 0:
+            self._set_spinner_status(IDLE_SLEEPING_STATUS)
         else:
             self._set_spinner_status("")
 
@@ -877,11 +880,7 @@ def create_multi_workspace_app(
             entry = await registry.add_workspace(
                 str(payload.get("name") or ""),
                 work_dir=str(payload.get("dir") or "./"),
-                board=(
-                    None
-                    if payload.get("board") in (None, "")
-                    else str(payload.get("board"))
-                ),
+                board=payload.get("board"),
             )
         except ValueError as exc:
             return JSONResponse({"ok": False, "error": str(exc)}, status_code=400)
@@ -1521,6 +1520,7 @@ def _build_workspace_entry(
                 else []
             ),
             cwd=definition.work_dir,
+            toolset=args.toolset,
         )
         return WorkspaceInteractiveSession(
             build_cli_queue(agent),