python-codex 0.1.13__py3-none-any.whl → 0.2.0__py3-none-any.whl

pycodex/interactive_session.py

@@ -0,0 +1,397 @@
+import asyncio
+import json
+from dataclasses import asdict
+
+from .protocol import AgentEvent
+from .runtime import CliSubmissionQueue
+from .runtime_services import create_agent_runtime_environment
+from .utils import CliSessionView, uuid7_string
+from .utils.compactor import compact_agent
+from .utils.session_persist import (
+    SessionRolloutRecorder,
+    conversation_history_to_turns,
+    list_resumable_sessions,
+    load_resumed_session,
+    resolve_codex_home,
+)
+import typing
+
+
+EXIT_COMMANDS = {"/exit", "/quit"}
+HISTORY_COMMAND = "/history"
+TITLE_COMMAND = "/title"
+MODEL_COMMAND = "/model"
+QUEUE_COMMAND = "/queue"
+RESUME_COMMAND = "/resume"
+COMPACT_COMMAND = "/compact"
+LINK_COMMAND = "/link"
+UNLINK_COMMAND = "/unlink"
+EXTRA_COMMANDS_LINE = (
+    "Extra commands: /history, /title, /model, /resume, /compact, /link, /unlink"
+)
+
+
+def format_turn_output(result, json_mode: "bool") -> "str":
+    if json_mode:
+        return json.dumps(asdict(result), ensure_ascii=False, indent=2)
+    return result.output_text or ""
+
+
+async def prompt_request_user_input(
+    view,
+    payload: "typing.Dict[str, object]",
+) -> "typing.Union[typing.Dict[str, object], None]":
+    view.finish_stream()
+    view.write_line("[request_user_input] waiting for user response")
+    answers: "typing.Dict[str, typing.Dict[str, typing.List[str]]]" = {}
+    for question in payload.get("questions", []):
+        if not isinstance(question, dict):
+            continue
+        header = str(question.get("header", "")).strip()
+        question_text = str(question.get("question", "")).strip()
+        question_id = str(question.get("id", "")).strip()
+        if header:
+            view.write_line(f"[{header}] {question_text}")
+        else:
+            view.write_line(question_text)
+
+        options = question.get("options") or []
+        if isinstance(options, list):
+            for index, option in enumerate(options, start=1):
+                if not isinstance(option, dict):
+                    continue
+                label = str(option.get("label", "")).strip()
+                description = str(option.get("description", "")).strip()
+                view.write_line(f"  {index}. {label} - {description}")
+        view.write_line("  0. Other")
+
+        try:
+            raw_answer = await view.get_prompt("answer> ")
+        except EOFError:
+            return None
+        answer_text = raw_answer.strip()
+        if not answer_text:
+            return None
+
+        selected_answer = answer_text
+        if answer_text.isdigit() and isinstance(options, list):
+            choice = int(answer_text)
+            if 1 <= choice <= len(options):
+                option = options[choice - 1]
+                if isinstance(option, dict):
+                    selected_answer = (
+                        str(option.get("label", "")).strip() or answer_text
+                    )
+            elif choice == 0:
+                try:
+                    raw_answer = await view.get_prompt("other> ")
+                except EOFError:
+                    return None
+                selected_answer = raw_answer.strip()
+                if not selected_answer:
+                    return None
+
+        answers[question_id] = {"answers": [selected_answer]}
+
+    return {"answers": answers}
+
+
+async def prompt_request_permissions(
+    view,
+    payload: "typing.Dict[str, object]",
+) -> "typing.Union[typing.Dict[str, object], None]":
+    view.finish_stream()
+    view.write_line("[request_permissions] user approval required")
+    reason = payload.get("reason")
+    if reason:
+        view.write_line(f"Reason: {reason}")
+    view.write_line("Requested permissions:")
+    view.write_line(
+        json.dumps(payload.get("permissions", {}), ensure_ascii=False, indent=2)
+    )
+    view.write_line("Choose: [n] deny / [t] grant for turn / [s] grant for session")
+    try:
+        raw_answer = await view.get_prompt("permissions> ")
+    except EOFError:
+        return None
+
+    answer = raw_answer.strip().lower()
+    if answer in {"t", "turn", "y", "yes"}:
+        return {
+            "permissions": payload.get("permissions", {}),
+            "scope": "turn",
+        }
+    if answer in {"s", "session"}:
+        return {
+            "permissions": payload.get("permissions", {}),
+            "scope": "session",
+        }
+    return {
+        "permissions": {},
+        "scope": "turn",
+    }
+
+
+async def run_interactive_session(
+    queue: "CliSubmissionQueue",
+    json_mode: "bool",
+    config_path: "typing.Union[str, None]" = None,
+    view=None,
+    view_factory=None,
+    show_banner: "bool" = True,
+) -> "int":
+    worker = asyncio.create_task(queue.run_forever())
+    context_window_tokens = queue._agent._context_manager.resolve_model_context_window()
+    if view is None:
+        factory = view_factory or CliSessionView
+        view = factory()
+    view.set_context_window_tokens(context_window_tokens)
+    model_client = queue._agent._model_client
+    codex_home = resolve_codex_home(config_path)
+    queue.set_event_handler(view.handle_event)
+    pending_turn_tasks: "typing.Set[asyncio.Task[None]]" = set()
+    runtime_environment = queue._agent.runtime_environment
+    if runtime_environment is None:
+        runtime_environment = create_agent_runtime_environment()
+        queue._agent.runtime_environment = runtime_environment
+    runtime_environment.request_user_input_manager.set_handler(
+        lambda payload: prompt_request_user_input(view, payload)
+    )
+    runtime_environment.request_permissions_manager.set_handler(
+        lambda payload: prompt_request_permissions(view, payload)
+    )
+    if show_banner:
+        view.write_line("pycodex interactive mode. Type /exit to quit.")
+        view.write_line(EXTRA_COMMANDS_LINE)
+    feishu_link = None
+    try:
+
+        def has_pending_turn_tasks() -> "bool":
+            pending_turn_tasks.difference_update(
+                task for task in tuple(pending_turn_tasks) if task.done()
+            )
+            return bool(pending_turn_tasks)
+
+        async def run_manual_compact() -> "None":
+            current_agent = queue._agent
+            if not current_agent.history:
+                view.write_line("Nothing to compact.")
+                return
+
+            compact_turn_id = uuid7_string()
+
+            def handle_compact_stream_event(event) -> "None":
+                if event.kind not in {"token_count", "stream_error"}:
+                    return
+                view.handle_event(
+                    AgentEvent(
+                        kind=event.kind,
+                        turn_id=compact_turn_id,
+                        payload=dict(event.payload),
+                    )
+                )
+
+            view.write_line("Compacting conversation history...")
+            compact_result = await compact_agent(
+                current_agent,
+                handle_compact_stream_event,
+                True,
+            )
+            if compact_result is None:
+                view.write_line("Nothing to compact.")
+                return
+            view.load_session_history(
+                getattr(view, "_title", None),
+                conversation_history_to_turns(compact_result.history),
+            )
+            view.write_line(compact_result.display_text())
+
+        async def wait_for_turn_result(future) -> "None":
+            try:
+                result = await future
+            except Exception as exc:  # pragma: no cover - defensive surface
+                if str(exc) == "submission interrupted":
+                    return
+                view.show_error(str(exc))
+                return
+
+            if json_mode:
+                view.write_line(format_turn_output(result, True))
+
+        while True:
+            try:
+                raw_line = await view.poll_prompt()
+            except EOFError:
+                break
+            if raw_line is None:
+                await asyncio.sleep(0.05)
+                continue
+
+            prompt_text = raw_line.strip()
+            if not prompt_text:
+                continue
+            if prompt_text in EXIT_COMMANDS:
+                break
+            if prompt_text == HISTORY_COMMAND:
+                view.show_history()
+                continue
+            if prompt_text == TITLE_COMMAND:
+                view.show_title()
+                continue
+            if prompt_text.startswith(f"{TITLE_COMMAND} "):
+                title = prompt_text[len(TITLE_COMMAND) :].strip()
+                if not title:
+                    view.write_line("Usage: /title <title>")
+                    continue
+                set_session_title = getattr(view, "set_session_title", None)
+                if callable(set_session_title):
+                    set_session_title(title)
+                else:
+                    view.write_line(f"Session: {title}")
+                continue
+            if prompt_text == RESUME_COMMAND:
+                sessions = list_resumable_sessions(codex_home)
+                if not sessions:
+                    view.write_line("No resumable sessions found.")
+                    continue
+                view.write_line("Available sessions:")
+                for index, session in enumerate(sessions, start=1):
+                    view.write_line(f"[{index}] {session['preview']}")
+                continue
+            if prompt_text.startswith(f"{RESUME_COMMAND} "):
+                if has_pending_turn_tasks():
+                    view.write_line(
+                        "Cannot resume while work is running or queued."
+                    )
+                    continue
+                resume_target = prompt_text[len(RESUME_COMMAND) :].strip()
+                try:
+                    resumed = load_resumed_session(codex_home, resume_target)
+                    queue._agent.replace_history(resumed["history"])
+                    if hasattr(model_client, "_session_id"):
+                        model_client._session_id = str(resumed["session_id"])
+                    queue._agent.set_rollout_recorder(
+                        SessionRolloutRecorder.resume(resumed["rollout_path"])
+                    )
+                    view.load_session_history(
+                        str(resumed["title"]),
+                        tuple(resumed["turns"]),
+                    )
+                    show_resumed_session = getattr(view, "show_resumed_session", None)
+                    if callable(show_resumed_session):
+                        show_resumed_session(str(resumed["title"]))
+                    else:
+                        view.write_line(f"Resumed session: {resumed['title']}")
+                        view.show_history()
+                except Exception as exc:  # pragma: no cover - defensive surface
+                    view.show_error(str(exc))
+                continue
+            if prompt_text == COMPACT_COMMAND:
+                if has_pending_turn_tasks():
+                    view.write_line(
+                        "Cannot compact while work is running or queued."
+                    )
+                    continue
+                try:
+                    await run_manual_compact()
+                except Exception as exc:  # pragma: no cover - defensive surface
+                    view.show_error(str(exc))
+                continue
+            if prompt_text.startswith(f"{LINK_COMMAND} "):
+                link_target = prompt_text[len(LINK_COMMAND) :].strip()
+                if not link_target:
+                    view.write_line("Usage: /link <feishu-email|open_id|chat_id>")
+                    continue
+                if feishu_link:
+                    view.write_line("A Feishu card is already linked. Use /unlink first.")
+                    continue
+                try:
+                    from .feishu_link import PycodexRuntimeLink
+
+                    view.write_line(f"Linking Feishu card to current session: {link_target}")
+                    link = await PycodexRuntimeLink(
+                        queue,
+                        link_target,
+                    ).start_async()
+                    feishu_link = link
+                    view.write_line(
+                        "Linked Feishu card: session_key={0} message_id={1}".format(
+                            link.session_key,
+                            link.message_id or "-",
+                        )
+                    )
+                except Exception as exc:  # pragma: no cover - defensive surface
+                    view.show_error(str(exc))
+                continue
+            if prompt_text == UNLINK_COMMAND:
+                if not feishu_link:
+                    view.write_line("No Feishu card is linked.")
+                    continue
+                feishu_link.detach()
+                feishu_link = None
+                view.write_line("Unlinked Feishu card.")
+                continue
+            if prompt_text.startswith(f"{QUEUE_COMMAND} "):
+                queued_text = prompt_text[len(QUEUE_COMMAND) :].strip()
+                if not queued_text:
+                    view.write_line("Usage: /queue <message>")
+                    continue
+                try:
+                    submission_id, future = await queue.enqueue_user_turn(
+                        queued_text, queue="enqueue"
+                    )
+                    view.show_steer_queued(submission_id, queued_text)
+                    turn_task = asyncio.create_task(wait_for_turn_result(future))
+                    pending_turn_tasks.add(turn_task)
+                except Exception as exc:  # pragma: no cover - defensive surface
+                    view.show_error(str(exc))
+                continue
+            if prompt_text == MODEL_COMMAND:
+                view.write_line(
+                    f"Current model: {getattr(model_client, 'model', None) or 'unavailable'}"
+                )
+                models = await model_client.list_models()
+                view.write_line(f"Available models: {', '.join(models)}")
+                continue
+            if prompt_text.startswith(f"{MODEL_COMMAND} "):
+                if has_pending_turn_tasks():
+                    view.write_line(
+                        "Cannot change model while work is running or queued in steer mode."
+                    )
+                    continue
+                model_name = prompt_text[len(MODEL_COMMAND) :].strip()
+                if not model_name:
+                    view.write_line("Usage: /model <model>")
+                    continue
+
+                model_client.model = model_name
+                view.write_line(f"Switched model to {model_name}.")
+                continue
+
+            try:
+                steered = has_pending_turn_tasks()
+                submission_id, future = await queue.enqueue_user_turn(
+                    prompt_text,
+                    queue="steer",
+                )
+                if steered:
+                    view.schedule_steer_inserted(submission_id, prompt_text)
+                turn_task = asyncio.create_task(wait_for_turn_result(future))
+                pending_turn_tasks.add(turn_task)
+                continue
+            except Exception as exc:  # pragma: no cover - defensive surface
+                view.show_error(str(exc))
+                continue
+    finally:
+        if feishu_link:
+            feishu_link.detach()
+            feishu_link.stop()
+        runtime_environment.request_user_input_manager.set_handler(None)
+        runtime_environment.request_permissions_manager.set_handler(None)
+        await queue.shutdown()
+        await worker
+        if pending_turn_tasks:
+            await asyncio.gather(*pending_turn_tasks, return_exceptions=True)
+        view.close()
+
+    return 0

pycodex/model.py

@@ -298,13 +298,20 @@ class ResponsesModelClient:
                     prompt,
                     event_handler,
                 )
-            except ResponsesRetryableError as exc:
-                if _is_context_length_error_message(str(exc)):
+            except (ResponsesRetryableError, ResponsesIncompleteError) as exc:
+                if (
+                    isinstance(exc, ResponsesRetryableError)
+                    and _is_context_length_error_message(str(exc))
+                ):
                     raise ResponsesApiError(str(exc)) from exc
                 if retries >= max_retries:
                     raise
                 retries += 1
-                delay_seconds = exc.retry_delay_seconds
+                delay_seconds = (
+                    exc.retry_delay_seconds
+                    if isinstance(exc, ResponsesRetryableError)
+                    else None
+                )
                 if delay_seconds is None:
                     delay_seconds = self._retry_delay_seconds(retries)
                 event_handler(
@@ -507,7 +514,6 @@ class ResponsesModelClient:
         diagnostics: 'typing.Union[_StreamDiagnostics, None]' = None,
     ) -> 'ModelResponse':
         items: 'typing.List[typing.Union[typing.Union[AssistantMessage, ToolCall], ReasoningItem]]' = []
-        output_text_deltas: 'typing.List[str]' = []
         saw_completed = False
         last_event_type = ""
 
@@ -526,7 +532,6 @@ class ResponsesModelClient:
                 diagnostics.last_event_type = last_event_type
 
             if event_type == "response.output_text.delta":
-                output_text_deltas.append(str(payload.get("delta", "")))
                 event_handler(
                     ModelStreamEvent(
                         kind="assistant_delta",
@@ -607,10 +612,7 @@ class ResponsesModelClient:
                 break
 
             if event_type == "response.incomplete":
-                partial_items = self._items_with_partial_output_text(
-                    items,
-                    output_text_deltas,
-                )
+                partial_items = tuple(items)
                 reason = self._response_incomplete_reason(payload)
                 raise ResponsesIncompleteError(
                     self._format_response_incomplete_error(
@@ -632,19 +634,6 @@ class ResponsesModelClient:
 
         return ModelResponse(items=items)
 
-    def _items_with_partial_output_text(
-        self,
-        items: 'typing.Sequence[typing.Union[typing.Union[AssistantMessage, ToolCall], ReasoningItem]]',
-        output_text_deltas: 'typing.Sequence[str]',
-    ) -> 'typing.Tuple[typing.Union[typing.Union[AssistantMessage, ToolCall], ReasoningItem], ...]':
-        partial_items = list(items)
-        if any(isinstance(item, AssistantMessage) for item in partial_items):
-            return tuple(partial_items)
-        partial_text = "".join(output_text_deltas).strip()
-        if partial_text:
-            partial_items.append(AssistantMessage(text=partial_text))
-        return tuple(partial_items)
-
     def _parse_output_item(
         self,
         item: 'typing.Dict[str, object]',

pycodex/protocol.py

@@ -40,11 +40,8 @@ class ToolSpec:
     options: 'typing.Union[JSONDict, None]' = None
     output_schema: 'typing.Union[JSONDict, None]' = None
     supports_parallel: 'bool' = True
-    raw_payload: 'typing.Union[JSONDict, None]' = None
 
     def serialize(self) -> 'JSONDict':
-        if self.raw_payload is not None:
-            return deepcopy(self.raw_payload)
         if self.tool_type == "web_search":
             payload = {"type": "web_search"}
             if self.options is not None:
@@ -71,8 +68,6 @@ class ToolSpec:
             "parameters": self.input_schema,
             "strict": False,
         }
-        if self.output_schema is not None:
-            payload["output_schema"] = self.output_schema
         return payload
 
 

pycodex/runtime.py

@@ -65,6 +65,19 @@ class CliSubmissionQueue:
         self._queue_event.set()
         await future
 
+    def cancel_current(self) -> 'None':
+        exc = RuntimeError("submission interrupted")
+        current_task = self._current_task
+        if current_task is not None and not current_task.done():
+            current_task.cancel()
+        for queued in tuple(self._enqueue_queue):
+            self._finish_submission_exception(queued, exc)
+        for queued in tuple(self._steer_queue):
+            self._finish_submission_exception(queued, exc)
+        self._enqueue_queue.clear()
+        self._steer_queue.clear()
+        self._queue_event.set()
+
     async def run_forever(self) -> 'None':
         while True:
             queued = await self._next_submission()
@@ -152,6 +165,9 @@ class CliSubmissionQueue:
 
     async def _next_submission(self) -> '_QueuedSubmission':
         while True:
+            if self._agent._turn_running and not self._has_queue_active_turn():
+                await self._wait_for_agent_idle()
+                continue
             async with self._queue_lock:
                 queued: 'typing.Union[_QueuedSubmission, None]' = None
                 if self._steer_queue:
@@ -184,9 +200,16 @@ class CliSubmissionQueue:
                 future.set_exception(exc)
 
     def _has_active_turn(self) -> 'bool':
+        return self._has_queue_active_turn() or self._agent._turn_running
+
+    def _has_queue_active_turn(self) -> 'bool':
         current_task = self._current_task
         return current_task is not None and not current_task.done()
 
+    async def _wait_for_agent_idle(self) -> 'None':
+        while self._agent._turn_running:
+            await asyncio.sleep(0.01)
+
     def _handle_agent_event(self, event: 'AgentEvent') -> 'None':
         queued = self._current_submission
         if queued is None:

pycodex/runtime_services.py

@@ -285,7 +285,7 @@ class SubAgentManager:
     async def close_agent(self, agent_id: 'str') -> 'typing.Dict[str, object]':
         managed = self._agents.get(agent_id)
         if managed is None:
-            return {"status": "not_found"}
+            return {"previous_status": "not_found"}
         previous_status = self._status_payload(managed)
         if not managed.worker_task.done():
             managed.queue._agent.interrupt_asap = True
@@ -295,7 +295,7 @@ class SubAgentManager:
         managed.pending_submission_ids.clear()
         async with self._condition:
             self._condition.notify_all()
-        return {"status": previous_status}
+        return {"previous_status": previous_status}
 
     def _next_nickname(self) -> 'str':
         if not self._available_nicknames:

pycodex/tools/agent_tool_schemas.py

@@ -42,7 +42,7 @@ AGENT_STATUS_SCHEMA = {
     "oneOf": [
         {
             "type": "string",
-            "enum": ["pending_init", "running", "shutdown", "not_found"],
+            "enum": ["pending_init", "running", "interrupted", "shutdown", "not_found"],
         },
         {
             "type": "object",

pycodex/tools/apply_patch_tool.py

@@ -35,7 +35,7 @@ add_line: \"+\" /(.*)/ LF -> line
 change_move: \"*** Move to: \" filename LF
 change: (change_context | change_line)+ eof_line?
 change_context: (\"@@\" | \"@@ \" /(.+)/) LF
-change_line: (\"+\" | \"-\" | \" \" ) /(.*)/ LF
+change_line: (\"+\" | \"-\" | \" \") /(.*)/ LF
 eof_line: \"*** End of File\" LF
 
 %import common.LF

pycodex/tools/base_tool.py

@@ -11,37 +11,15 @@ Expected behavior:
 """
 
 import inspect
+import json
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from functools import lru_cache
-import json
-from pathlib import Path
 import traceback
 
 from ..protocol import ConversationItem, JSONDict, JSONValue, ToolCall, ToolResult, ToolSpec
 from ..utils import get_debug_dir
 import typing
 
-EXEC_TOOLS_SNAPSHOT_PATH = (
-    Path(__file__).resolve().parent.parent / "prompts" / "exec_tools.json"
-)
-
-
-@lru_cache(maxsize=1)
-def _load_exec_tool_payloads() -> 'typing.Dict[str, JSONDict]':
-    payloads: 'typing.Dict[str, JSONDict]' = {}
-    raw_payloads = EXEC_TOOLS_SNAPSHOT_PATH.read_text(encoding="utf-8")
-    for payload in json.loads(raw_payloads):
-        if not isinstance(payload, dict):
-            continue
-        name = payload.get("name")
-        if isinstance(name, str):
-            payloads[name] = payload
-            continue
-        if payload.get("type") == "web_search":
-            payloads["web_search"] = payload
-    return payloads
-
 
 @dataclass(frozen=True, )
 class ToolContext:
@@ -82,15 +60,11 @@ class BaseTool(ABC):
             options=self.options,
             output_schema=self.output_schema,
             supports_parallel=self.supports_parallel,
-            raw_payload=self.raw_payload(),
         )
 
     def serialize(self) -> 'JSONDict':
         return self.spec().serialize()
 
-    def raw_payload(self) -> 'typing.Union[JSONDict, None]':
-        return _load_exec_tool_payloads().get(self.name)
-
     @abstractmethod
     async def run(self, context: 'ToolContext', args: 'JSONValue') -> 'JSONValue':
         raise NotImplementedError

pycodex/tools/close_agent_tool.py

@@ -5,7 +5,7 @@ Original Codex mapping:
 
 Expected behavior:
 - Shut down a spawned agent when it is no longer needed.
-- Return the agent status observed at close time.
+- Return the agent status observed before shutdown was requested.
 """
 
 from ..protocol import JSONDict, JSONValue
@@ -16,9 +16,12 @@ from .base_tool import BaseTool, ToolContext
 CLOSE_AGENT_OUTPUT_SCHEMA = {
     "type": "object",
     "properties": {
-        "status": AGENT_STATUS_SCHEMA,
+        "previous_status": {
+            "description": "The agent status observed before shutdown was requested.",
+            "allOf": [AGENT_STATUS_SCHEMA],
+        },
     },
-    "required": ["status"],
+    "required": ["previous_status"],
     "additionalProperties": False,
 }
 
@@ -26,7 +29,11 @@ CLOSE_AGENT_OUTPUT_SCHEMA = {
 class CloseAgentTool(BaseTool):
     name = "close_agent"
     description = (
-        "Close an agent when it is no longer needed and return its status."
+        "Close an agent and any open descendants when they are no longer "
+        "needed, and return the target agent's previous status before shutdown "
+        "was requested. Completed agents remain open and count toward the "
+        "concurrency limit until closed. Don't keep agents open for too long "
+        "if they are not needed anymore."
     )
     input_schema = {
         "type": "object",

pycodex/tools/code_mode_manager.py

@@ -21,11 +21,11 @@ from loguru import logger
 
 from ..compat import is_ascii, stream_writer_is_closing
 from ..protocol import JSONDict, JSONValue, ToolCall
+from ..utils.truncation import DEFAULT_MAX_OUTPUT_TOKENS
 from .base_tool import StructuredToolOutput, ToolContext, ToolRegistry
 import typing
 
 DEFAULT_WAIT_YIELD_TIME_MS = 10_000
-DEFAULT_MAX_OUTPUT_TOKENS = 10_000
 CHARS_PER_TOKEN = 4
 EXEC_PRAGMA_PREFIX = "// @exec:"
 WAIT_COMPLETION_GRACE_SECONDS = 0.02