python-codex 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

pycodex/agent.py

@@ -20,6 +20,9 @@ from .tools import ToolContext, ToolRegistry
 from .utils import uuid7_string
 import typing
 
+if typing.TYPE_CHECKING:
+    from .utils.session_persist import SessionRolloutRecorder
+
 
 EventHandler = Callable[[AgentEvent], None]
 NOOP_EVENT_HANDLER: 'EventHandler' = lambda _event: None
@@ -46,6 +49,7 @@ class AgentLoop:
         parallel_tool_calls: 'bool' = True,
         event_handler: 'EventHandler' = NOOP_EVENT_HANDLER,
         initial_history: 'typing.Tuple[ConversationItem, ...]' = (),
+        rollout_recorder: 'typing.Union[SessionRolloutRecorder, None]' = None,
     ) -> 'None':
         self._model_client = model_client
         self._tool_registry = tool_registry
@@ -53,6 +57,7 @@ class AgentLoop:
         self._parallel_tool_calls = parallel_tool_calls
         self._event_handler = event_handler
         self._history: 'typing.List[ConversationItem]' = list(initial_history)
+        self._rollout_recorder = rollout_recorder
         self.interrupt_asap = False
 
     @property
@@ -64,6 +69,18 @@ class AgentLoop:
     ) -> 'None':
         self._event_handler = event_handler
 
+    def replace_history(
+        self,
+        history: 'typing.Iterable[ConversationItem]',
+    ) -> 'None':
+        self._history = list(history)
+
+    def set_rollout_recorder(
+        self,
+        rollout_recorder: 'typing.Union[SessionRolloutRecorder, None]',
+    ) -> 'None':
+        self._rollout_recorder = rollout_recorder
+
     def _raise_if_interrupt_requested(
         self,
         turn_id: 'str',
@@ -83,8 +100,9 @@ class AgentLoop:
     ) -> 'TurnResult':
         turn_id = turn_id or uuid7_string()
         self.interrupt_asap = False
-        for text in texts:
-            self._history.append(UserMessage(text=text))
+        new_user_messages = [UserMessage(text=text) for text in texts]
+        self._history.extend(new_user_messages)
+        self._persist_history_items(new_user_messages)
 
         self._emit(
             "turn_started",
@@ -131,12 +149,15 @@ class AgentLoop:
                 )
 
                 tool_calls: 'typing.List[ToolCall]' = []
+                persisted_response_items: 'typing.List[ConversationItem]' = []
                 for item in response.items:
                     self._history.append(item)
+                    persisted_response_items.append(item)
                     if isinstance(item, AssistantMessage):
                         last_assistant_message = item.text
                     elif isinstance(item, ToolCall):
                         tool_calls.append(item)
+                self._persist_history_items(persisted_response_items)
 
                 if not tool_calls:
                     self._raise_if_interrupt_requested(
@@ -160,7 +181,10 @@ class AgentLoop:
 
                 tool_results = await self._execute_tool_batch(turn_id, tool_calls)
                 self._history.extend(tool_results)
-                self._history.extend(self._build_follow_up_messages(tool_results))
+                self._persist_history_items(tool_results)
+                follow_up_messages = self._build_follow_up_messages(tool_results)
+                self._history.extend(follow_up_messages)
+                self._persist_history_items(follow_up_messages)
                 self._raise_if_interrupt_requested(
                     turn_id,
                     iteration,
@@ -226,7 +250,12 @@ class AgentLoop:
         call: 'ToolCall',
         prior_results: 'typing.Tuple[ToolResult, ...]' = (),
     ) -> 'ToolResult':
-        self._emit("tool_started", turn_id, tool_name=call.name, call_id=call.call_id)
+        payload: 'typing.Dict[str, object]' = {
+            "tool_name": call.name,
+            "call_id": call.call_id,
+            "call": call,
+        }
+        self._emit("tool_started", turn_id, **payload)
         result = await self._tool_registry.execute(
             call,
             ToolContext(
@@ -235,13 +264,8 @@ class AgentLoop:
                 collaboration_mode=self._context_manager.collaboration_mode,
             ),
         )
-        payload: 'typing.Dict[str, object]' = {
-            "tool_name": call.name,
-            "call_id": call.call_id,
-            "is_error": result.is_error,
-            "call": call,
-            "result": result,
-        }
+        payload["result"] = result
+        payload["is_error"] = result.is_error
         self._emit("tool_completed", turn_id, **payload)
         return result
 
@@ -250,11 +274,27 @@ class AgentLoop:
             AgentEvent(kind=kind, turn_id=turn_id, payload=dict(payload))
         )
 
+    def _persist_history_items(
+        self,
+        items: 'typing.Iterable[ConversationItem]',
+    ) -> 'None':
+        recorder = self._rollout_recorder
+        if recorder is None:
+            return
+        try:
+            recorder.append_history_items(items)
+        except Exception:  # pragma: no cover - persistence should not break turns
+            return
+
     def _handle_model_stream_event(self, turn_id: 'str', event: 'ModelStreamEvent') -> 'None':
         if event.kind == "assistant_delta":
             self._emit("assistant_delta", turn_id, **event.payload)
         elif event.kind == "tool_call":
             self._emit("tool_called", turn_id, **event.payload)
+        elif event.kind == "token_count":
+            self._emit("token_count", turn_id, **event.payload)
+        elif event.kind == "stream_error":
+            self._emit("stream_error", turn_id, **event.payload)
 
     def _build_follow_up_messages(
         self,

pycodex/cli.py

@@ -20,7 +20,15 @@ from .portable import bootstrap_called_home, upload_codex_home
 from .protocol import AgentEvent
 from .runtime import AgentRuntime
 from .runtime_services import RuntimeEnvironment, create_runtime_environment
-from .utils import CliSessionView, load_codex_dotenv
+from .utils import CliSessionView, load_codex_dotenv, uuid7_string
+from .utils.compactor import compact_agent_loop
+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"}
@@ -28,6 +36,8 @@ HISTORY_COMMAND = "/history"
 TITLE_COMMAND = "/title"
 MODEL_COMMAND = "/model"
 QUEUE_COMMAND = "/queue"
+RESUME_COMMAND = "/resume"
+COMPACT_COMMAND = "/compact"
 CliSessionMode = Literal["exec", "tui"]
 LOCAL_RESPONSES_SERVER_API_KEY_ENV = "PYCODEX_LOCAL_RESPONSES_SERVER_KEY"
 CLI_ORIGINATOR = "codex-tui"
@@ -284,6 +294,9 @@ def build_runtime(
         collaboration_mode=collaboration_mode,
         include_collaboration_instructions=use_tui_context,
     )
+    session_id = getattr(client, "_session_id", None) or uuid7_string()
+    if hasattr(client, "_session_id"):
+        client._session_id = session_id
     subagent_context_manager = ContextManager.from_codex_config(
         config_path,
         profile,
@@ -293,6 +306,14 @@ def build_runtime(
     runtime_environment = create_runtime_environment()
     runtime_environment.request_user_input_manager.set_handler(None)
     runtime_environment.request_permissions_manager.set_handler(None)
+    rollout_recorder = SessionRolloutRecorder.create(
+        resolve_codex_home(config_path),
+        session_id,
+        context_manager.cwd,
+        getattr(client, "_originator", CLI_ORIGINATOR),
+        getattr(getattr(client, "_config", None), "provider_name", None),
+        context_manager.resolve_base_instructions(),
+    )
 
     def make_subagent_runtime_builder(base_client):
         def build_subagent_runtime(
@@ -330,7 +351,10 @@ def build_runtime(
     )
     return AgentRuntime(
         AgentLoop(
-            client, get_tools(runtime_environment, exec_mode=True), context_manager
+            client,
+            get_tools(runtime_environment, exec_mode=True),
+            context_manager,
+            rollout_recorder=rollout_recorder,
         ),
         runtime_environment=runtime_environment,
     )
@@ -498,10 +522,14 @@ async def prompt_request_permissions(
 async def run_interactive_session(
     runtime: 'AgentRuntime',
     json_mode: 'bool',
+    config_path: 'typing.Union[str, None]' = None,
 ) -> 'int':
     worker = asyncio.create_task(runtime.run_forever())
+    context_window_tokens = runtime._agent_loop._context_manager.resolve_model_context_window()
     view = CliSessionView()
+    view.set_context_window_tokens(context_window_tokens)
     model_client = runtime._agent_loop._model_client
+    codex_home = resolve_codex_home(config_path)
     runtime.set_event_handler(view.handle_event)
     pending_turn_tasks: 'typing.Set[asyncio.Task[None]]' = set()
     runtime_environment = runtime.runtime_environment
@@ -515,7 +543,7 @@ async def run_interactive_session(
         lambda payload: prompt_request_permissions(view, payload)
     )
     view.write_line("pycodex interactive mode. Type /exit to quit.")
-    view.write_line("Extra commands: /history, /title, /model")
+    view.write_line("Extra commands: /history, /title, /model, /resume, /compact")
     try:
 
         def has_pending_turn_tasks() -> 'bool':
@@ -524,6 +552,39 @@ async def run_interactive_session(
             )
             return bool(pending_turn_tasks)
 
+        async def run_manual_compact() -> 'None':
+            agent_loop = runtime._agent_loop
+            if not agent_loop.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_loop(
+                agent_loop,
+                handle_compact_stream_event,
+            )
+            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
@@ -556,6 +617,50 @@ async def run_interactive_session(
             if prompt_text == TITLE_COMMAND:
                 view.show_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)
+                    runtime._agent_loop.replace_history(resumed["history"])
+                    if hasattr(model_client, "_session_id"):
+                        model_client._session_id = str(resumed["session_id"])
+                    runtime._agent_loop.set_rollout_recorder(
+                        SessionRolloutRecorder.resume(resumed["rollout_path"])
+                    )
+                    view.load_session_history(
+                        str(resumed["title"]),
+                        tuple(resumed["turns"]),
+                    )
+                    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"{QUEUE_COMMAND} "):
                 queued_text = prompt_text[len(QUEUE_COMMAND) :].strip()
                 if not queued_text:
@@ -663,6 +768,7 @@ async def run_cli(args: 'argparse.Namespace') -> 'int':
             return await run_interactive_session(
                 runtime,
                 args.json,
+                args.config,
             )
         else:
             prompt_text = resolve_prompt_text(args.prompt)

pycodex/context.py

@@ -30,6 +30,7 @@ DEFAULT_COLLABORATION_INSTRUCTIONS_PATH = (
 PLAN_COLLABORATION_INSTRUCTIONS_PATH = (
     Path(__file__).resolve().parent / "prompts" / "collaboration_plan.md"
 )
+DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT = 95
 PERMISSIONS_SANDBOX_PROMPTS_PATH = (
     Path(__file__).resolve().parent / "prompts" / "permissions" / "sandbox_mode"
 )
@@ -76,6 +77,7 @@ class ContextConfig:
     codex_home: 'typing.Union[Path, None]' = None
     project_doc_max_bytes: 'typing.Union[int, None]' = None
     model: 'typing.Union[str, None]' = None
+    model_context_window: 'typing.Union[int, None]' = None
     personality: 'typing.Union[str, None]' = None
     approval_policy: 'typing.Union[str, None]' = None
     sandbox_mode: 'typing.Union[str, None]' = None
@@ -117,6 +119,7 @@ class ContextConfig:
             codex_home=codex_home,
             project_doc_max_bytes=_normalize_int(selected.get("project_doc_max_bytes")),
             model=_normalize_text(selected.get("model")),
+            model_context_window=_normalize_int(selected.get("model_context_window")),
             personality=_normalize_text(selected.get("personality")),
             approval_policy=_normalize_text(selected.get("approval_policy")),
             sandbox_mode=_normalize_text(selected.get("sandbox_mode")),
@@ -240,6 +243,26 @@ class ContextManager:
             return resolved
         return self._default_base_instructions
 
+    def resolve_model_context_window(self) -> 'typing.Union[int, None]':
+        model_metadata = None
+        model_slug = self._config.model
+        if model_slug is not None:
+            model_metadata = _load_models_by_slug().get(model_slug)
+
+        context_window = self._config.model_context_window
+        if context_window is None and model_metadata is not None:
+            context_window = _normalize_int(model_metadata.get("context_window"))
+        if context_window is None:
+            return None
+        effective_percent = None
+        if model_metadata is not None:
+            effective_percent = _normalize_int(
+                model_metadata.get("effective_context_window_percent")
+            )
+        if effective_percent is None:
+            effective_percent = DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT
+        return context_window * max(effective_percent, 0) // 100
+
     def _resolve_model_instructions(self) -> 'typing.Union[str, None]':
         model_slug = self._config.model
         if model_slug is None: