python-codex 0.2.6__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),

workspace_server/workspace.html

@@ -304,7 +304,9 @@
       height: 18px;
       border: 0;
       background: transparent;
-      opacity: 0.42;
+      opacity: 0;
+      visibility: hidden;
+      pointer-events: none;
       font-size: 17px;
       font-weight: 500;
       line-height: 18px;
@@ -314,12 +316,12 @@
       font-weight: 400;
       line-height: 31px;
     }
-    .tab:hover .tab-close,
-    .tab:focus-within .tab-close,
     .tab.active .tab-close {
       opacity: 0.85;
+      visibility: visible;
+      pointer-events: auto;
     }
-    .tab-close:disabled {
+    .tab.active .tab-close:disabled {
       opacity: 0.22;
       cursor: default;
     }
@@ -1457,6 +1459,7 @@
       if (!sessionId || sessionId === activeSessionId) return;
       saveActiveSessionUiState();
       activeSessionId = sessionId;
+      renderTabs();
       const state = stateForSession(sessionId);
       state.lastRenderedSignature = "";
       lastRenderedSignature = "";

workspace_server/workspaces.py

@@ -123,19 +123,23 @@ def load_workspace_definitions(
             )
 
         board_value = item.get("board")
-        if not str(board_value or "").strip():
-            raise ValueError("workspace `{0}` is missing `board`".format(workspace_id))
-        board_path = _resolve_workspace_path(str(board_value), path.parent)
-        if board_path in seen_boards:
-            raise ValueError("duplicate workspace board: {0}".format(board_path))
-        seen_boards.add(board_path)
-        if not board_path.parent.is_dir():
-            raise ValueError(
-                "workspace `{0}` board parent directory does not exist: {1}".format(
-                    workspace_id,
-                    board_path.parent,
+        board_path = None
+        if board_value is not False:
+            if not isinstance(board_value, str) or not board_value.strip():
+                raise ValueError(
+                    "workspace `{0}` requires a board path or false".format(workspace_id)
+                )
+            board_path = _resolve_workspace_path(board_value, path.parent)
+            if board_path in seen_boards:
+                raise ValueError("duplicate workspace board: {0}".format(board_path))
+            seen_boards.add(board_path)
+            if not board_path.parent.is_dir():
+                raise ValueError(
+                    "workspace `{0}` board parent directory does not exist: {1}".format(
+                        workspace_id,
+                        board_path.parent,
+                    )
                 )
-            )
 
         result.append(
             WorkspaceDefinition(
@@ -169,7 +173,7 @@ def save_workspace_definitions(
 def _workspace_definition_to_json(
     definition: 'WorkspaceDefinition',
     base_dir: 'Path',
-) -> 'typing.Dict[str, str]':
+) -> 'typing.Dict[str, object]':
     result = {
         "id": definition.workspace_id,
         "work_dir": _format_path_for_workspace_config(definition.work_dir, base_dir),
@@ -179,6 +183,8 @@ def _workspace_definition_to_json(
             definition.board_path,
             base_dir,
         )
+    else:
+        result["board"] = False
     return result
 
 
@@ -440,7 +446,7 @@ class WorkspaceRegistry:
 
     def _key_for_definition(self, definition: 'WorkspaceDefinition') -> str:
         if definition.board_path is None:
-            raise ValueError("workspace `{0}` is missing board".format(definition.workspace_id))
+            return "workspace:{0}".format(definition.workspace_id)
         return str(definition.board_path.resolve())
 
     async def start(self) -> None:
@@ -466,7 +472,7 @@ class WorkspaceRegistry:
         self,
         name: str,
         work_dir: str = "./",
-        board: "typing.Union[str, None]" = None,
+        board: "typing.Union[str, bool, None]" = None,
     ) -> 'WorkspaceEntry':
         if self._entry_factory is None:
             raise ValueError("workspace creation is unavailable")
@@ -475,15 +481,19 @@ class WorkspaceRegistry:
         resolved_work_dir = _resolve_workspace_path(str(work_dir or "./"), base_dir)
         resolved_work_dir.mkdir(parents=True, exist_ok=True)
 
-        board_path = (
-            _resolve_workspace_path(str(board), base_dir)
-            if str(board or "").strip()
-            else default_board_path()
-        )
-        board_path.parent.mkdir(parents=True, exist_ok=True)
-        board_key = str(board_path.resolve())
-        if board_key in self._entries:
-            raise ValueError("workspace board already exists: {0}".format(board_path))
+        board_path = None
+        if board is not False:
+            if board is not None and not isinstance(board, str):
+                raise ValueError("board must be a path string or false")
+            board_path = (
+                _resolve_workspace_path(board, base_dir)
+                if board and board.strip()
+                else default_board_path()
+            )
+            board_path.parent.mkdir(parents=True, exist_ok=True)
+            board_key = str(board_path.resolve())
+            if board_key in self._entries:
+                raise ValueError("workspace board already exists: {0}".format(board_path))
 
         workspace_id = normalize_workspace_id(name)
         if not workspace_id: