codex-agent-framework 0.1.20__tar.gz → 0.1.22__tar.gz

{codex_agent_framework-0.1.20 → codex_agent_framework-0.1.22}/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to this project will be documented in this file.
 
 This project loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and uses semantic versioning where practical.
 
+## [0.1.22] - 2026-05-10
+### Changed
+- Harden the FastAPI/SSE bridge and Textual TUI streaming path after a stabilization audit: finite SSE read timeouts, batched live deltas, synchronous replay delta flushes, and explicit stale-subscriber replacement shutdowns.
+- Improve process-backed runtime robustness with guarded startup, isolated event handlers, and clearer cached status/turn-state updates.
+- Consolidate shared helpers for type hierarchy, turn outcomes, atomic session writes, tool exclusion matching, context truncation, and subagent child creation while removing smaller duplicated or dead helper paths.
+- Publish the package version from a single `codex_agent.version` module and use it for FastAPI metadata.
+
+### Fixed
+- Prevent stale SSE subscribers from lingering silently when a replacement TUI stream connects.
+- Avoid concurrent subscriber-table mutation during event publication and serialize persisted turn-event rewrite/append operations.
+- Preserve replay ordering in the TUI so caught-up deltas render before newly batched live stream deltas.
+- Keep one failing process-runtime event handler from stopping delivery to later handlers.
+
+### Tests
+- Validate post-restart API/import/runtime smoke tests after a real server restart.
+- Validate `pyflakes codex_agent tests`, targeted server/client/chat smoke tests, and the full suite at 489 passing tests.
+
+## [0.1.21] - 2026-05-10
+### Added
+- Add the structured `AgentTurn` API: `agent(...)` and `AgentFuture.wait()` now return a turn object with `result`, `completed`, `reason`, `messages`, and `events`.
+- Add resumable non-terminal turns for `auto_proceed=False`; turns that need another model step pause with `reason="requires_next_step"` and continue through `agent.resume_turn(turn)`.
+- Add `agent.set_turn_result(data)` for tools/plugins that need to explicitly finish the current turn with a structured result.
+- Add the built-in `subagents` plugin with profile-based child agents, compact parent results, child-local `set_result`, `SubagentEvent` relay, and a packaged read-only `explorer` profile.
+- Add hierarchical `types` to messages and events while keeping `type` as the concrete computed type.
+- Add configurable `exclude_tools` matching by public or canonical plugin tool names.
+
+### Changed
+- Treat scheduled and post-restart wakeups as internal `DeveloperMessage` entries instead of user-authored messages.
+- Make `AssistantTurnEndEvent` expose a terminal `reason` rather than carrying a raw result payload.
+- Capture turn-local events and messages on `AgentTurn` so embedded callers can inspect what happened without replaying the whole session.
+- Include packaged subagent profile JSON files in distributions.
+- Refresh the packaged default system prompt around agent identity, clarification, durable fixes, and concise final reporting.
+
+### Fixed
+- Preserve coherent turn state across suspended/resumed turns, including stable turn IDs, non-terminal suspension without a turn-end event, and terminal completion on resume.
+
+### Tests
+- Validate the full suite at 483 passing tests.
+- Validate post-restart wakeups after a real server restart and smoke-test `auto_proceed=False` `AgentTurn` suspension/resume behavior.
+
 ## [0.1.20] - 2026-05-09
 ### Added
 - Make runtime plugins the single user-facing extension unit for tools, providers, commands, prompt sections, hooks, and events.

{codex_agent_framework-0.1.20/codex_agent_framework.egg-info → codex_agent_framework-0.1.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-agent-framework
-Version: 0.1.20
+Version: 0.1.22
 Summary: A lightweight event-driven Codex agent runtime.
 Author: Baptiste
 License-Expression: MIT
@@ -286,10 +286,17 @@ agent = Agent(
     voice_enabled=False,
 )
 
-answer = agent("Summarize this repository in three practical bullet points.")
-print(answer)
+turn = agent("Summarize this repository in three practical bullet points.")
+
+print("Completed:", turn.completed)
+print("Reason:", turn.reason)
+print("Result:", turn.result)
+for message in turn.messages:
+    print(message.as_string())
 ```
 
+`agent(...)` returns an `AgentTurn`, not a raw string. `turn.result` is the useful final result, while `turn.messages` and `turn.events` contain the messages and events produced by that command. If `auto_proceed=False`, a tool-using turn can pause with `completed=False` and `reason="requires_next_step"`; call `agent.resume_turn(turn)` to continue the same turn object until it reaches a terminal reason such as `completed`, `result_set`, `interrupted`, or `error`.
+
 Resume the latest session interactively:
 
 ```python
@@ -398,7 +405,7 @@ def repo():
 
 agent = Agent(session="latest", voice_enabled=False)
 agent.add_command(repo)
-print(agent("/repo"))
+print(agent("/repo").result)
 ```
 
 ### Add stateful plugins
@@ -593,8 +600,11 @@ The default agent exposes local tools and plugin tools to the model. Plugin tool
 | Scheduler plugin | `scheduler_schedule`, `scheduler_cancel`, `scheduler_list`, `scheduler_restart_and_wakeup` | Future turns, periodic wakeups, post-restart continuation. |
 | Browser plugin | `browser_open`, `browser_goto`, `browser_click`, `browser_fill`, `browser_press`, ... | Persistent Playwright/Chromium automation with active-tab context. |
 | Desktop plugin | `desktop_start_session`, `desktop_run_commands`, `desktop_stop_session` | Screenshot-backed Linux desktop automation. |
+| Subagents plugin | `subagents_run` | Run an ephemeral child agent from a predefined profile and return a compact structured result. |
 
-Built-ins are intentionally packaged as plugins. Current built-in plugin modules include `files`, `content`, `bash`, `python`, `interface`, `environment`, `memory`, `planner`, `scheduler`, `browser`, and `desktop`.
+Built-ins are intentionally packaged as plugins. Current built-in plugin modules include `files`, `content`, `bash`, `python`, `interface`, `environment`, `memory`, `planner`, `scheduler`, `browser`, `desktop`, and `subagents`.
+
+The `subagents` plugin ships profile JSON files inside the package, starting with `explorer`, a read-only codebase inspection agent. Parent agents choose an existing profile and task; child agents receive their own config, tools, prompt, and temporary session instead of inheriting the parent's runtime implicitly.
 
 Built-in plugins are configurable. `None` means load all plugins, an empty list means load none, and an explicit list selects specific plugin module names:
 
@@ -703,8 +713,11 @@ Useful exported events include:
 - `ToolCallStartEvent` / `ToolCallDoneEvent`
 - `SessionLoadedEvent` / `SessionDeletedEvent`
 - `AssistantInterruptedEvent`
+- `SubagentEvent`
 - `AudioPlaybackEvent`
 
+Messages and events expose hierarchical `types` as well as the final computed `type`, so listeners can subscribe to broad classes such as all events or to precise concrete event types.
+
 Plugins can also register event and hook handlers with decorators:
 
 ```python
@@ -833,13 +846,13 @@ The tests isolate `AGENT_RUNTIME_DIR` automatically, so they should not create o
 The current tree validates at:
 
 ```text
-456 passed
+489 passed
 ```
 
-The published `0.1.20` release was validated at:
+The published `0.1.22` release was validated at:
 
 ```text
-456 passed
+489 passed
 ```
 
 ## Packaging
@@ -857,6 +870,8 @@ The distribution includes prompt text files, `codex_agent/get_text/default_gitig
 
 ## Recent changes
 
+- `0.1.22`: harden FastAPI/SSE and TUI streaming after a stabilization audit, including finite SSE read timeouts, stale-subscriber shutdown, persisted turn-event locking, synchronous replay delta flushes, process-runtime startup guards, and isolated event handlers.
+- `0.1.21`: add structured `AgentTurn` returns with messages/events, resumable non-terminal turns for `auto_proceed=False`, profile-based subagents, hierarchical message/event types, and internal wakeups as developer messages.
 - `0.1.20`: make runtime plugins the single user-facing extension unit for tools/providers/commands, remove legacy direct runtime tool/provider loading, split tool/provider managers, and keep system-prompt templating on an explicit minimal namespace.
 - `0.1.19`: prune compacted raw session history after compaction, keep only the latest compaction anchor plus the new compaction and any unfinished remainder, and drop older redundant compaction summaries from active session files.
 - `0.1.18`: make `start server/tray` detach by default, move durable memory fully into the memory plugin, keep wakeups as a core runtime primitive, expose RAG memory timestamps/sources, and move browser/desktop backend controllers into core modules with plugins as facades.

{codex_agent_framework-0.1.20 → codex_agent_framework-0.1.22}/README.md

@@ -237,10 +237,17 @@ agent = Agent(
     voice_enabled=False,
 )
 
-answer = agent("Summarize this repository in three practical bullet points.")
-print(answer)
+turn = agent("Summarize this repository in three practical bullet points.")
+
+print("Completed:", turn.completed)
+print("Reason:", turn.reason)
+print("Result:", turn.result)
+for message in turn.messages:
+    print(message.as_string())
 ```
 
+`agent(...)` returns an `AgentTurn`, not a raw string. `turn.result` is the useful final result, while `turn.messages` and `turn.events` contain the messages and events produced by that command. If `auto_proceed=False`, a tool-using turn can pause with `completed=False` and `reason="requires_next_step"`; call `agent.resume_turn(turn)` to continue the same turn object until it reaches a terminal reason such as `completed`, `result_set`, `interrupted`, or `error`.
+
 Resume the latest session interactively:
 
 ```python
@@ -349,7 +356,7 @@ def repo():
 
 agent = Agent(session="latest", voice_enabled=False)
 agent.add_command(repo)
-print(agent("/repo"))
+print(agent("/repo").result)
 ```
 
 ### Add stateful plugins
@@ -544,8 +551,11 @@ The default agent exposes local tools and plugin tools to the model. Plugin tool
 | Scheduler plugin | `scheduler_schedule`, `scheduler_cancel`, `scheduler_list`, `scheduler_restart_and_wakeup` | Future turns, periodic wakeups, post-restart continuation. |
 | Browser plugin | `browser_open`, `browser_goto`, `browser_click`, `browser_fill`, `browser_press`, ... | Persistent Playwright/Chromium automation with active-tab context. |
 | Desktop plugin | `desktop_start_session`, `desktop_run_commands`, `desktop_stop_session` | Screenshot-backed Linux desktop automation. |
+| Subagents plugin | `subagents_run` | Run an ephemeral child agent from a predefined profile and return a compact structured result. |
 
-Built-ins are intentionally packaged as plugins. Current built-in plugin modules include `files`, `content`, `bash`, `python`, `interface`, `environment`, `memory`, `planner`, `scheduler`, `browser`, and `desktop`.
+Built-ins are intentionally packaged as plugins. Current built-in plugin modules include `files`, `content`, `bash`, `python`, `interface`, `environment`, `memory`, `planner`, `scheduler`, `browser`, `desktop`, and `subagents`.
+
+The `subagents` plugin ships profile JSON files inside the package, starting with `explorer`, a read-only codebase inspection agent. Parent agents choose an existing profile and task; child agents receive their own config, tools, prompt, and temporary session instead of inheriting the parent's runtime implicitly.
 
 Built-in plugins are configurable. `None` means load all plugins, an empty list means load none, and an explicit list selects specific plugin module names:
 
@@ -654,8 +664,11 @@ Useful exported events include:
 - `ToolCallStartEvent` / `ToolCallDoneEvent`
 - `SessionLoadedEvent` / `SessionDeletedEvent`
 - `AssistantInterruptedEvent`
+- `SubagentEvent`
 - `AudioPlaybackEvent`
 
+Messages and events expose hierarchical `types` as well as the final computed `type`, so listeners can subscribe to broad classes such as all events or to precise concrete event types.
+
 Plugins can also register event and hook handlers with decorators:
 
 ```python
@@ -784,13 +797,13 @@ The tests isolate `AGENT_RUNTIME_DIR` automatically, so they should not create o
 The current tree validates at:
 
 ```text
-456 passed
+489 passed
 ```
 
-The published `0.1.20` release was validated at:
+The published `0.1.22` release was validated at:
 
 ```text
-456 passed
+489 passed
 ```
 
 ## Packaging
@@ -808,6 +821,8 @@ The distribution includes prompt text files, `codex_agent/get_text/default_gitig
 
 ## Recent changes
 
+- `0.1.22`: harden FastAPI/SSE and TUI streaming after a stabilization audit, including finite SSE read timeouts, stale-subscriber shutdown, persisted turn-event locking, synchronous replay delta flushes, process-runtime startup guards, and isolated event handlers.
+- `0.1.21`: add structured `AgentTurn` returns with messages/events, resumable non-terminal turns for `auto_proceed=False`, profile-based subagents, hierarchical message/event types, and internal wakeups as developer messages.
 - `0.1.20`: make runtime plugins the single user-facing extension unit for tools/providers/commands, remove legacy direct runtime tool/provider loading, split tool/provider managers, and keep system-prompt templating on an explicit minimal namespace.
 - `0.1.19`: prune compacted raw session history after compaction, keep only the latest compaction anchor plus the new compaction and any unfinished remainder, and drop older redundant compaction summaries from active session files.
 - `0.1.18`: make `start server/tray` detach by default, move durable memory fully into the memory plugin, keep wakeups as a core runtime primitive, expose RAG memory timestamps/sources, and move browser/desktop backend controllers into core modules with plugins as facades.

{codex_agent_framework-0.1.20 → codex_agent_framework-0.1.22}/codex_agent/__init__.py

@@ -27,6 +27,7 @@ from .event import (
     ResponseToolCallsDeltaEvent,
     ServerToolCallEvent,
     SessionDeletedEvent,
+    SubagentEvent,
     SessionLoadedEvent,
     ToolCallDoneEvent,
     ToolCallStartEvent,
@@ -48,13 +49,14 @@ from .message import (
 from .image import ImageMessage
 from .mainloop import MainLoopManager
 from .plugin import Plugin, PluginsManager, event_handler, hook_handler
-from .command import AgentCommand, AgentFuture, CommandManager, command
+from .command import AgentCommand, AgentFuture, AgentTurn, CommandManager, command
 from .provider import ProvidersManager, provider
 from .runtime import RuntimeManager
 from .sessions import AgentSession, SessionsManager
 from .status import StatusManager
 from .tool import ImageGenerationTool, ServerTool, Tool, ToolsManager, WebSearchTool, get_agent, get_current_call_id, tool
 from .worker import SummarizerWorker, TurnSummaryWorker, Worker
+from .version import __version__
 
 __all__ = [
     "Agent",
@@ -87,6 +89,7 @@ __all__ = [
     "ResponseToolCallsDeltaEvent",
     "ServerToolCallEvent",
     "SessionDeletedEvent",
+    "SubagentEvent",
     "SessionLoadedEvent",
     "ToolCallDoneEvent",
     "ToolCallStartEvent",
@@ -111,6 +114,7 @@ __all__ = [
     "ProvidersManager",
     "AgentCommand",
     "AgentFuture",
+    "AgentTurn",
     "CommandManager",
     "command",
     "provider",
@@ -129,4 +133,5 @@ __all__ = [
     "SummarizerWorker",
     "TurnSummaryWorker",
     "Worker",
+    "__version__",
 ]

{codex_agent_framework-0.1.20 → codex_agent_framework-0.1.22}/codex_agent/agent.py

@@ -14,7 +14,7 @@ from .scheduler import AgentScheduler
 from .sessions import SessionsManager
 from .status import StatusManager
 from .tool import ImageGenerationTool, ToolsManager, reset_current_agent, set_current_agent
-from .ai import AIBadRequestError, AIClient
+from .ai import AIClient
 from .voice import VoiceProcessor
 from .latex import LaTeXProcessor
 from .event import AssistantInterruptRequestedEvent, AssistantInterrupted, AssistantInterruptedEvent, AudioPlaybackEvent, EventBus
@@ -71,6 +71,7 @@ class Agent:
         self.plugins_manager.init_runtime()
         self.command_manager.init_runtime()
         self.tools_manager.init_server_tools()
+        self.tools_manager.apply_config_exclusions()
         self.start_new_session() if session == "new" else self.load_session(session)
 
     def on(self, event_type, handler=None):
@@ -82,7 +83,11 @@ class Agent:
         return self.events.on(event_type, handler)
 
     def emit(self, event_type, **data):
-        return self.events.emit(event_type, **data)
+        event = self.events.emit(event_type, **data)
+        mainloop_manager = getattr(self, "mainloop_manager", None)
+        if mainloop_manager is not None:
+            mainloop_manager.record_event(event)
+        return event
 
     @property
     def busy(self):
@@ -104,28 +109,35 @@ class Agent:
     def start_turn(self):
         return self.mainloop_manager.start_turn()
 
+    def resume_turn(self, turn):
+        future = self.mainloop_manager.resume_turn(turn)
+        return None if future is None else future.wait()
+
     def submit_command(self, prompt):
         return self.command_manager.submit(prompt)
 
     def submit_message(self, message):
         return self.mainloop_manager.submit_message(message)
 
+    def set_turn_result(self, data):
+        return self.mainloop_manager.set_turn_result(data)
+
     def list_wakeups(self, include_done=True):
         return self.scheduler.list(include_done=include_done)
 
     def schedule_wakeup(self, **kwargs):
         if self.mainloop_manager.should_queue_state_command():
-            return self.submit("schedule_wakeup", **kwargs).wait()
+            return self.submit("schedule_wakeup", **kwargs).wait().result
         return self.scheduler.schedule(**kwargs)
 
     def cancel_wakeup(self, job_id):
         if self.mainloop_manager.should_queue_state_command():
-            return self.submit("cancel_wakeup", job_id=job_id).wait()
+            return self.submit("cancel_wakeup", job_id=job_id).wait().result
         return self.scheduler.cancel(job_id)
 
     def delete_wakeup(self, job_id):
         if self.mainloop_manager.should_queue_state_command():
-            return self.submit("delete_wakeup", job_id=job_id).wait()
+            return self.submit("delete_wakeup", job_id=job_id).wait().result
         return self.scheduler.delete(job_id)
 
     def interrupt(self, reason="user"):
@@ -256,7 +268,7 @@ class Agent:
             return decorator
 
         if hasattr(self, "mainloop_manager") and self.mainloop_manager.should_queue_state_command():
-            return self.submit("add_hook", key=key, func=func).wait()
+            return self.submit("add_hook", key=key, func=func).wait().result
 
         return self.hooks.add(key, func)
 
@@ -327,6 +339,10 @@ class Agent:
         Returns:
             Message: The aggregated assistant message with content and/or tool calls.
         """
+        if self.session and not self.session.is_sane():
+            repair = self.session.repair()
+            if repair.repaired:
+                self.status_manager.invalidate_context_cache()
         messages = self.context_manager.get_context()
         if self.context_manager.should_auto_compact(messages):
             self.compact_session(
@@ -335,21 +351,16 @@ class Agent:
             )
             messages = self.context_manager.get_context()
 
-        try:
-            message=self.ai.run(
-                messages=messages,
-                tools=self.tools_manager.get_response_tools(),
-                prompt_cache_key=self.current_session_id,
-                **self.config.extract('model','reasoning_effort','verbosity','parallel_tool_calls')
-            )
-        except AIBadRequestError:
-            self.sessions_manager.restore_api_success_backup()
-            raise
+        message=self.ai.run(
+            messages=messages,
+            tools=self.tools_manager.get_response_tools(),
+            prompt_cache_key=self.current_session_id,
+            **self.config.extract('model','reasoning_effort','verbosity','parallel_tool_calls')
+        )
         self.sessions_manager.append_message(message)
         for item in message.output_items:
             if self.tools_manager.server_tool_for_item(item):
                 self.sessions_manager.append_message(ServerToolResponseMessage(item=item))
-        self.sessions_manager.save_api_success_backup()
         return message
 
     def speak(self,text,**kwargs):
@@ -431,7 +442,7 @@ class Agent:
 
         return dest_path
 
-    def __call__(self,prompt=None)->bool:
+    def __call__(self, prompt=None):
         return self.mainloop_manager.call(prompt=prompt)
 
     def interact(self):

{codex_agent_framework-0.1.20 → codex_agent_framework-0.1.22}/codex_agent/agent_runtime.py

@@ -262,6 +262,8 @@ class ProcessAgentRuntime(AgentRuntime):
         self.event_handlers = []
         self.pending = {}
         self.pending_lock = threading.Lock()
+        self.start_lock = threading.RLock()
+        self.starting = False
         self.running = threading.Event()
         self.cache = modict(
             busy=False,
@@ -277,24 +279,28 @@ class ProcessAgentRuntime(AgentRuntime):
         )
 
     def start(self):
-        if self.process and self.process.is_alive():
+        with self.start_lock:
+            if self.process and self.process.is_alive():
+                return self
+            self.starting = True
+            self.running.set()
+            self.process = self.context.Process(
+                target=agent_worker_main,
+                args=(self.command_queue, self.response_queue, self.event_queue, self.agent_kwargs),
+                name="codex-agent-worker",
+                daemon=True,
+            )
+            self.process.start()
+            self.event_thread = threading.Thread(target=self._event_loop, name="agent-runtime-events", daemon=True)
+            self.event_thread.start()
+            try:
+                self.call("start", timeout=self.command_timeout, autostart=False)
+                self.refresh_cache()
+            except Exception:
+                pass
+            finally:
+                self.starting = False
             return self
-        self.running.set()
-        self.process = self.context.Process(
-            target=agent_worker_main,
-            args=(self.command_queue, self.response_queue, self.event_queue, self.agent_kwargs),
-            name="codex-agent-worker",
-            daemon=True,
-        )
-        self.process.start()
-        self.event_thread = threading.Thread(target=self._event_loop, name="agent-runtime-events", daemon=True)
-        self.event_thread.start()
-        try:
-            self.call("start", timeout=self.command_timeout)
-            self.refresh_cache()
-        except Exception:
-            pass
-        return self
 
     def stop(self, timeout=None):
         timeout = timeout or 2.0
@@ -332,14 +338,14 @@ class ProcessAgentRuntime(AgentRuntime):
                 self.cache[key] = self.call(command, timeout=self.status_timeout)
             except Exception:
                 pass
-        status = modict(self.cache.get("status") or {})
-        self.cache.busy = bool(status.get("busy", self.cache.busy))
-        self.cache.current_turn_id = status.get("current_turn_id", self.cache.current_turn_id)
-        self.cache.current_session_id = status.get("session_id", self.cache.current_session_id)
+        self.update_status_cache(self.cache.get("status") or {})
         return self.cache
 
-    def call(self, name, payload=None, timeout=None):
-        self.start() if not (self.process and self.process.is_alive()) else None
+    def call(self, name, payload=None, timeout=None, autostart=True):
+        if not (self.process and self.process.is_alive()):
+            if not autostart or self.starting:
+                raise AgentRuntimeError("agent worker process is not running")
+            self.start()
         command_id = str(uuid.uuid4())
         future = _RuntimeFuture(command_id)
         with self.pending_lock:
@@ -377,24 +383,39 @@ class ProcessAgentRuntime(AgentRuntime):
         else:
             future.set_error(AgentRuntimeError(response.get("error") or "agent worker command failed"))
 
+    def update_status_cache(self, status):
+        status = modict(status or {})
+        self.cache.status = status
+        self.cache.busy = bool(status.get("busy", self.cache.busy))
+        self.cache.current_turn_id = status.get("current_turn_id", self.cache.current_turn_id)
+        self.cache.current_session_id = status.get("session_id", self.cache.current_session_id)
+        return status
+
+    def mark_turn_started(self, turn_id=None):
+        self.cache.busy = True
+        if turn_id is not None:
+            self.cache.current_turn_id = turn_id
+
+    def mark_turn_finished(self):
+        self.cache.busy = False
+        self.cache.current_turn_id = None
+
     def _handle_event(self, event):
         event_type = event.get("type")
         if event_type == "assistant_turn_start_event":
-            self.cache.busy = True
+            self.mark_turn_started(event.get("turn_id"))
         elif event_type in ("assistant_turn_end_event", "assistant_turn_error_event"):
-            self.cache.busy = False
-            self.cache.current_turn_id = None
+            self.mark_turn_finished()
         elif event_type == "session_loaded_event":
             self.cache.current_session_id = event.get("session_id")
             self.cache.session = event.get("session") or self.cache.session
         elif event_type == "compaction_completed_event" and event.get("status"):
-            status = modict(event.status)
-            self.cache.status = status
-            self.cache.busy = bool(status.get("busy", self.cache.busy))
-            self.cache.current_turn_id = status.get("current_turn_id", self.cache.current_turn_id)
-            self.cache.current_session_id = status.get("session_id", self.cache.current_session_id)
+            self.update_status_cache(event.status)
         for handler in list(self.event_handlers):
-            handler(event)
+            try:
+                handler(event)
+            except Exception:
+                continue
 
     @property
     def busy(self):
@@ -410,12 +431,7 @@ class ProcessAgentRuntime(AgentRuntime):
 
     def get_status(self):
         try:
-            status = modict(self.call("get_status", timeout=self.status_timeout))
-            self.cache.status = status
-            self.cache.busy = bool(status.get("busy", self.cache.busy))
-            self.cache.current_turn_id = status.get("current_turn_id", self.cache.current_turn_id)
-            self.cache.current_session_id = status.get("session_id", self.cache.current_session_id)
-            return status
+            return self.update_status_cache(self.call("get_status", timeout=self.status_timeout))
         except Exception:
             status = modict(self.cache.status or {})
             status.setdefault("busy", self.cache.busy)
@@ -429,7 +445,7 @@ class ProcessAgentRuntime(AgentRuntime):
         payload = dict(values or {})
         payload.update(kwargs)
         result = self.call("update_config", {"values": payload, "save": save}, timeout=self.command_timeout)
-        self.cache.config = result
+        self.cache["config"] = result
         return result
 
     def session(self):
@@ -478,8 +494,7 @@ class ProcessAgentRuntime(AgentRuntime):
             return None
         turn_id = self.call("start_turn", timeout=1.0)
         if turn_id is not None:
-            self.cache.busy = True
-            self.cache.current_turn_id = turn_id
+            self.mark_turn_started(turn_id)
         return turn_id
 
     def submit_command(self, prompt):
@@ -487,16 +502,14 @@ class ProcessAgentRuntime(AgentRuntime):
             return None
         turn_id = self.call("submit_command", {"prompt": prompt}, timeout=1.0)
         if turn_id is not None:
-            self.cache.busy = True
-            self.cache.current_turn_id = turn_id
+            self.mark_turn_started(turn_id)
         return turn_id
 
     def submit_message(self, message):
         result = self.call("submit_message", {"message": message}, timeout=1.0)
         turn_id = result.get("turn_id") if isinstance(result, dict) else None
         if turn_id is not None:
-            self.cache.busy = True
-            self.cache.current_turn_id = turn_id
+            self.mark_turn_started(turn_id)
         return result
 
     def schedule_wakeup(self, **kwargs):

{codex_agent_framework-0.1.20 → codex_agent_framework-0.1.22}/codex_agent/builtin_plugins/memory/__init__.py

@@ -370,6 +370,7 @@ You can manage memory explicitly with the memory tools:
 Use your memory tools judiciously and proactively to create durable records of important information that should persist beyond the current session.
 Do not over-memorize routine exchanges, transient implementation details, or information that is only useful within the current turn. 
 Prefer durable facts, preferences, decisions, and important outcomes.
+Memory entries should be rather short (one paragraph) and semantically well scoped for more efficient retrieval.
 Keep your memory tidy and up to date by editing or deleting outdated or irrelevant entries.
 When automatic memory archiving is enabled, completed turns are summarized into memory in the background when they contain something worth remembering.
 """
@@ -469,7 +470,7 @@ When automatic memory archiving is enabled, completed turns are summarized into
 
     @event_handler(AssistantTurnEndEvent)
     def archive_completed_turn(self, event):
-        if event.get("result") is not True:
+        if event.get("reason") != "completed":
             return None
         if not self.config.auto_archive:
             return None