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

pycodex/tools/read_file_tool.py

@@ -9,12 +9,12 @@ Expected behavior:
   mode used to inspect code structure without shelling out to `sed` or `cat`.
 """
 
+import typing
 from collections import deque
 from pathlib import Path
 
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
-import typing
 
 MAX_LINE_LENGTH = 500
 TAB_WIDTH = 4
@@ -78,7 +78,7 @@ class ReadFileTool(BaseTool):
         "additionalProperties": False,
     }
 
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
         del context
         file_path = Path(str(args.get("file_path", "")))
         offset = int(args.get("offset", 1))
@@ -101,7 +101,7 @@ class ReadFileTool(BaseTool):
             return self._read_indentation(file_path, offset, limit, indentation)
         return self._read_slice(file_path, offset, limit)
 
-    def _read_slice(self, file_path: 'Path', offset: 'int', limit: 'int') -> 'str':
+    def _read_slice(self, file_path: "Path", offset: "int", limit: "int") -> "str":
         lines = file_path.read_text(errors="replace").splitlines()
         if offset > len(lines):
             return "Error: `offset` exceeds file length."
@@ -114,11 +114,11 @@ class ReadFileTool(BaseTool):
 
     def _read_indentation(
         self,
-        file_path: 'Path',
-        offset: 'int',
-        limit: 'int',
-        indentation: 'JSONDict',
-    ) -> 'str':
+        file_path: "Path",
+        offset: "int",
+        limit: "int",
+        indentation: "JSONDict",
+    ) -> "str":
         lines = self._collect_line_records(file_path)
         anchor_line = int(indentation.get("anchor_line", offset))
         max_levels = int(indentation.get("max_levels", 0))
@@ -136,7 +136,9 @@ class ReadFileTool(BaseTool):
         anchor_index = anchor_line - 1
         effective_indents = self._compute_effective_indents(lines)
         anchor_indent = effective_indents[anchor_index]
-        min_indent = 0 if max_levels == 0 else max(anchor_indent - max_levels * TAB_WIDTH, 0)
+        min_indent = (
+            0 if max_levels == 0 else max(anchor_indent - max_levels * TAB_WIDTH, 0)
+        )
         final_limit = min(limit, max_lines, len(lines))
 
         if final_limit == 1:
@@ -157,8 +159,12 @@ class ReadFileTool(BaseTool):
                     selected.appendleft(lines[upper])
                     progressed += 1
                     if effective_indents[upper] == min_indent and not include_siblings:
-                        allow_header_comment = include_header and lines[upper]["is_comment"]
-                        can_take_line = allow_header_comment or upper_min_indent_count == 0
+                        allow_header_comment = (
+                            include_header and lines[upper]["is_comment"]
+                        )
+                        can_take_line = (
+                            allow_header_comment or upper_min_indent_count == 0
+                        )
                         if can_take_line:
                             upper_min_indent_count += 1
                         else:
@@ -200,9 +206,13 @@ class ReadFileTool(BaseTool):
             f"L{record['number']}: {record['display']}" for record in selected
         )
 
-    def _collect_line_records(self, file_path: 'Path') -> 'typing.List[typing.Dict[str, object]]':
+    def _collect_line_records(
+        self, file_path: "Path"
+    ) -> "typing.List[typing.Dict[str, object]]":
         records = []
-        for number, raw in enumerate(file_path.read_text(errors="replace").splitlines(), start=1):
+        for number, raw in enumerate(
+            file_path.read_text(errors="replace").splitlines(), start=1
+        ):
             records.append(
                 {
                     "number": number,
@@ -214,7 +224,9 @@ class ReadFileTool(BaseTool):
             )
         return records
 
-    def _compute_effective_indents(self, records: 'typing.List[typing.Dict[str, object]]') -> 'typing.List[int]':
+    def _compute_effective_indents(
+        self, records: "typing.List[typing.Dict[str, object]]"
+    ) -> "typing.List[int]":
         effective = []
         previous_indent = 0
         for record in records:
@@ -225,7 +237,7 @@ class ReadFileTool(BaseTool):
                 effective.append(previous_indent)
         return effective
 
-    def _measure_indent(self, line: 'str') -> 'int':
+    def _measure_indent(self, line: "str") -> "int":
         total = 0
         for character in line:
             if character == " ":
@@ -236,10 +248,10 @@ class ReadFileTool(BaseTool):
                 break
         return total
 
-    def _format_line(self, text: 'str') -> 'str':
+    def _format_line(self, text: "str") -> "str":
         return text[:MAX_LINE_LENGTH]
 
-    def _trim_empty_lines(self, records: 'deque[typing.Dict[str, object]]') -> 'None':
+    def _trim_empty_lines(self, records: "deque[typing.Dict[str, object]]") -> "None":
         while records and not str(records[0]["raw"]).strip():
             records.popleft()
         while records and not str(records[-1]["raw"]).strip():

pycodex/tools/request_permissions_tool.py

@@ -81,10 +81,10 @@ class RequestPermissionsTool(BaseTool):
     }
     supports_parallel = False
 
-    def __init__(self, request_manager: 'RequestPermissionsManager') -> 'None':
+    def __init__(self, request_manager: "RequestPermissionsManager") -> "None":
         self._request_manager = request_manager
 
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
         del context
         permissions = args.get("permissions")
         if not isinstance(permissions, dict):
@@ -94,11 +94,21 @@ class RequestPermissionsTool(BaseTool):
 
         response = await self._request_manager.request(
             {
-                "reason": None if args.get("reason") in (None, "") else str(args.get("reason")),
-                "environment_id": None if args.get("environment_id") in (None, "") else str(args.get("environment_id")),
+                "reason": (
+                    None
+                    if args.get("reason") in (None, "")
+                    else str(args.get("reason"))
+                ),
+                "environment_id": (
+                    None
+                    if args.get("environment_id") in (None, "")
+                    else str(args.get("environment_id"))
+                ),
                 "permissions": permissions,
             }
         )
         if response is None:
-            return "Error: request_permissions was cancelled before receiving a response."
+            return (
+                "Error: request_permissions was cancelled before receiving a response."
+            )
         return response

pycodex/tools/request_user_input_tool.py

@@ -4,21 +4,12 @@ Original Codex mapping:
 - Corresponds to the original Codex `request_user_input` collaboration tool.
 
 Expected behavior:
-- In upstream Codex this tool is only actually usable in Plan mode.
-- In the current `pycodex` default-mode path, runtime invocation returns the
-  same fixed unavailable error string as upstream Codex.
-- In Plan mode, the tool validates its question payload, forces `isOther=true`
-  on every question, and returns a JSON-string `function_call_output` with
-  `success=true`.
+- Keep the tool declaration available for upstream request compatibility.
+- Return the upstream Default-mode unavailable message without requesting input.
 """
 
-import json
-
-from ..collaboration import collaboration_mode_display_name
 from ..protocol import JSONDict, JSONValue
-from ..runtime_services import RequestUserInputManager
-from .base_tool import BaseTool, StructuredToolOutput, ToolContext
-import typing
+from .base_tool import BaseTool, ToolContext
 
 MIN_AUTO_RESOLUTION_MS = 60_000
 MAX_AUTO_RESOLUTION_MS = 240_000
@@ -42,8 +33,8 @@ REQUEST_USER_INPUT_QUESTION_SCHEMA = {
             "type": "array",
             "description": (
                 "Provide 2-3 mutually exclusive choices. Put the recommended option "
-                "first and suffix its label with \"(Recommended)\". Do not include "
-                "an \"Other\" option in this list; the client will add a free-form "
+                'first and suffix its label with "(Recommended)". Do not include '
+                'an "Other" option in this list; the client will add a free-form '
                 "Other option automatically."
             ),
             "items": {
@@ -68,48 +59,16 @@ REQUEST_USER_INPUT_QUESTION_SCHEMA = {
 }
 
 
-def request_user_input_is_available(
-    mode: 'str',
-    default_mode_request_user_input: 'bool' = False,
-) -> 'bool':
-    normalized = mode.strip().lower()
-    return normalized == "plan" or (
-        default_mode_request_user_input and normalized == "default"
-    )
-
-
-def request_user_input_unavailable_message(
-    mode: 'str',
-    default_mode_request_user_input: 'bool' = False,
-) -> 'typing.Union[str, None]':
-    if request_user_input_is_available(mode, default_mode_request_user_input):
-        return None
-    return (
-        "request_user_input is unavailable in "
-        f"{collaboration_mode_display_name(mode)} mode"
-    )
-
-
-def request_user_input_tool_description(
-    default_mode_request_user_input: 'bool' = False,
-) -> 'str':
-    if default_mode_request_user_input:
-        allowed_modes = "Default or Plan mode"
-    else:
-        allowed_modes = "Plan mode"
-    return (
+class RequestUserInputTool(BaseTool):
+    name = "request_user_input"
+    description = (
         "Request user input for one to three short questions and wait for the "
         f"response. Set autoResolutionMs, from {MIN_AUTO_RESOLUTION_MS} to "
         f"{MAX_AUTO_RESOLUTION_MS} milliseconds, only when the question is "
         "useful but non-blocking and continuing with best judgment is "
         "acceptable if the user does not answer; omit it when explicit user "
-        f"input is required. This tool is only available in {allowed_modes}."
+        "input is required. This tool is unavailable in Default mode."
     )
-
-
-class RequestUserInputTool(BaseTool):
-    name = "request_user_input"
-    description = request_user_input_tool_description()
     input_schema = {
         "type": "object",
         "properties": {
@@ -131,63 +90,13 @@ class RequestUserInputTool(BaseTool):
                     f"up to {MAX_AUTO_RESOLUTION_MS} when the answer would "
                     "materially unblock better work."
                 ),
-            }
+            },
         },
         "required": ["questions"],
         "additionalProperties": False,
     }
     supports_parallel = False
 
-    def __init__(
-        self,
-        request_manager: 'RequestUserInputManager',
-        default_mode_request_user_input: 'bool' = False,
-    ) -> 'None':
-        self._request_manager = request_manager
-        self._default_mode_request_user_input = default_mode_request_user_input
-        self.description = request_user_input_tool_description(
-            default_mode_request_user_input
-        )
-
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
-        unavailable = request_user_input_unavailable_message(
-            context.collaboration_mode,
-            self._default_mode_request_user_input,
-        )
-        if unavailable is not None:
-            return unavailable
-
-        questions = args.get("questions")
-        if not isinstance(questions, list):
-            raise ValueError("questions must be a list")
-
-        if any(
-            not isinstance(question, dict)
-            or not isinstance(question.get("options"), list)
-            or not question["options"]
-            for question in questions
-        ):
-            return "request_user_input requires non-empty options for every question"
-
-        request_payload = {
-            "questions": [
-                {
-                    **question,
-                    "isOther": True,
-                }
-                for question in questions
-            ]
-        }
-        auto_resolution_ms = args.get("autoResolutionMs")
-        if auto_resolution_ms not in (None, ""):
-            request_payload["autoResolutionMs"] = min(
-                max(int(auto_resolution_ms), MIN_AUTO_RESOLUTION_MS),
-                MAX_AUTO_RESOLUTION_MS,
-            )
-        response = await self._request_manager.request(request_payload)
-        if response is None:
-            return "request_user_input was cancelled before receiving a response"
-        return StructuredToolOutput(
-            json.dumps(response, ensure_ascii=False, separators=(",", ":")),
-            success=True,
-        )
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
+        del context, args
+        return "request_user_input is unavailable in Default mode"

pycodex/tools/resume_agent_tool.py

@@ -43,10 +43,10 @@ class ResumeAgentTool(BaseTool):
     output_schema = RESUME_AGENT_OUTPUT_SCHEMA
     supports_parallel = False
 
-    def __init__(self, subagent_manager: 'SubAgentManager') -> 'None':
+    def __init__(self, subagent_manager: "SubAgentManager") -> "None":
         self._subagent_manager = subagent_manager
 
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
         del context
         agent_id = str(args.get("id", "")).strip()
         if not agent_id:

pycodex/tools/send_input_tool.py

@@ -9,11 +9,12 @@ Expected behavior:
 - Return the submission id for the queued input.
 """
 
+import typing
+
 from ..protocol import JSONDict, JSONValue
 from ..runtime_services import SubAgentManager
 from .agent_tool_schemas import COLLAB_INPUT_ITEMS_SCHEMA
 from .base_tool import BaseTool, ToolContext
-import typing
 
 SEND_INPUT_OUTPUT_SCHEMA = {
     "type": "object",
@@ -59,10 +60,10 @@ class SendInputTool(BaseTool):
     output_schema = SEND_INPUT_OUTPUT_SCHEMA
     supports_parallel = False
 
-    def __init__(self, subagent_manager: 'SubAgentManager') -> 'None':
+    def __init__(self, subagent_manager: "SubAgentManager") -> "None":
         self._subagent_manager = subagent_manager
 
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
         del context
         agent_id = str(args.get("id", "")).strip()
         if not agent_id:
@@ -84,10 +85,10 @@ class SendInputTool(BaseTool):
 
     def _compose_prompt(
         self,
-        message: 'typing.Union[str, None]',
-        items: 'typing.Union[typing.List[typing.Dict[str, object]], None]',
-    ) -> 'str':
-        parts: 'typing.List[str]' = []
+        message: "typing.Union[str, None]",
+        items: "typing.Union[typing.List[typing.Dict[str, object]], None]",
+    ) -> "str":
+        parts: "typing.List[str]" = []
         if message:
             parts.append(message.strip())
         for item in items or []:
@@ -100,7 +101,9 @@ class SendInputTool(BaseTool):
                 parts.append(str(item))
         return "\n\n".join(part for part in parts if part)
 
-    def _optional_string(self, args: 'JSONDict', key: 'str') -> 'typing.Union[str, None]':
+    def _optional_string(
+        self, args: "JSONDict", key: "str"
+    ) -> "typing.Union[str, None]":
         value = args.get(key)
         if value in (None, ""):
             return None

pycodex/tools/shell_command_tool.py

@@ -12,11 +12,11 @@ Expected behavior:
 """
 
 import asyncio
+import typing
 from pathlib import Path
 
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
-import typing
 
 DEFAULT_SHELL_TIMEOUT_MS = 10_000
 MAX_OUTPUT_CHARS = 12_000
@@ -54,10 +54,12 @@ class ShellCommandTool(BaseTool):
     }
     supports_parallel = False
 
-    def __init__(self, cwd: 'typing.Union[typing.Union[str, Path], None]' = None) -> 'None':
+    def __init__(
+        self, cwd: "typing.Union[typing.Union[str, Path], None]" = None
+    ) -> "None":
         self._working_directory = Path(cwd or Path.cwd()).resolve()
 
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
         del context
         command = str(args.get("command", "")).strip()
         timeout_ms = int(args.get("timeout_ms", DEFAULT_SHELL_TIMEOUT_MS))
@@ -109,7 +111,7 @@ class ShellCommandTool(BaseTool):
 
         return "\n".join(pieces)
 
-    def _resolve_workdir(self, workdir_arg) -> 'Path':
+    def _resolve_workdir(self, workdir_arg) -> "Path":
         if workdir_arg in (None, ""):
             return self._working_directory
         workdir = Path(str(workdir_arg))
@@ -117,7 +119,7 @@ class ShellCommandTool(BaseTool):
             workdir = self._working_directory / workdir
         return workdir.resolve()
 
-    def _clip_output(self, text: 'str') -> 'str':
+    def _clip_output(self, text: "str") -> "str":
         if len(text) <= MAX_OUTPUT_CHARS:
             return text
         return text[:MAX_OUTPUT_CHARS] + "\n...[truncated]..."

pycodex/tools/shell_tool.py

@@ -12,11 +12,11 @@ Expected behavior:
 """
 
 import asyncio
+import typing
 from pathlib import Path
 
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
-import typing
 
 DEFAULT_SHELL_TIMEOUT_MS = 30_000
 MAX_OUTPUT_CHARS = 12_000
@@ -51,10 +51,12 @@ class ShellTool(BaseTool):
     }
     supports_parallel = False
 
-    def __init__(self, cwd: 'typing.Union[typing.Union[str, Path], None]' = None) -> 'None':
+    def __init__(
+        self, cwd: "typing.Union[typing.Union[str, Path], None]" = None
+    ) -> "None":
         self._working_directory = Path(cwd or Path.cwd()).resolve()
 
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
         del context
         command = args.get("command")
         timeout_ms = int(args.get("timeout_ms", DEFAULT_SHELL_TIMEOUT_MS))
@@ -106,7 +108,7 @@ class ShellTool(BaseTool):
 
         return "\n".join(pieces)
 
-    def _resolve_workdir(self, workdir_arg) -> 'Path':
+    def _resolve_workdir(self, workdir_arg) -> "Path":
         if workdir_arg in (None, ""):
             return self._working_directory
         workdir = Path(str(workdir_arg))
@@ -114,7 +116,7 @@ class ShellTool(BaseTool):
             workdir = self._working_directory / workdir
         return workdir.resolve()
 
-    def _clip_output(self, text: 'str') -> 'str':
+    def _clip_output(self, text: "str") -> "str":
         if len(text) <= MAX_OUTPUT_CHARS:
             return text
         return text[:MAX_OUTPUT_CHARS] + "\n...[truncated]..."

pycodex/tools/spawn_agent_tool.py

@@ -9,11 +9,12 @@ Expected behavior:
 - Return the new agent identifier plus any user-facing nickname.
 """
 
+import typing
+
 from ..protocol import JSONDict, JSONValue
 from ..runtime_services import SubAgentManager
 from .agent_tool_schemas import COLLAB_INPUT_ITEMS_SCHEMA
 from .base_tool import BaseTool, ToolContext
-import typing
 
 SPAWN_AGENT_OUTPUT_SCHEMA = {
     "type": "object",
@@ -92,10 +93,10 @@ Do not spawn sub-agents unless the user explicitly asks for sub-agents, delegati
     output_schema = SPAWN_AGENT_OUTPUT_SCHEMA
     supports_parallel = False
 
-    def __init__(self, subagent_manager: 'SubAgentManager') -> 'None':
+    def __init__(self, subagent_manager: "SubAgentManager") -> "None":
         self._subagent_manager = subagent_manager
 
-    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
+    async def run(self, context: "ToolContext", args: "JSONDict") -> "JSONValue":
         message = self._optional_string(args, "message")
         items = args.get("items")
         if items is not None and not isinstance(items, list):
@@ -112,7 +113,9 @@ Do not spawn sub-agents unless the user explicitly asks for sub-agents, delegati
             history=context.history,
         )
 
-    def _optional_string(self, args: 'JSONDict', key: 'str') -> 'typing.Union[str, None]':
+    def _optional_string(
+        self, args: "JSONDict", key: "str"
+    ) -> "typing.Union[str, None]":
         value = args.get(key)
         if value in (None, ""):
             return None