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

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

@@ -4,6 +4,23 @@ 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`.

{codex_agent_framework-0.1.21/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.21
+Version: 0.1.22
 Summary: A lightweight event-driven Codex agent runtime.
 Author: Baptiste
 License-Expression: MIT
@@ -846,13 +846,13 @@ The tests isolate `AGENT_RUNTIME_DIR` automatically, so they should not create o
 The current tree validates at:
 
 ```text
-483 passed
+489 passed
 ```
 
-The published `0.1.21` release was validated at:
+The published `0.1.22` release was validated at:
 
 ```text
-483 passed
+489 passed
 ```
 
 ## Packaging
@@ -870,6 +870,7 @@ 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.

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

@@ -797,13 +797,13 @@ The tests isolate `AGENT_RUNTIME_DIR` automatically, so they should not create o
 The current tree validates at:
 
 ```text
-483 passed
+489 passed
 ```
 
-The published `0.1.21` release was validated at:
+The published `0.1.22` release was validated at:
 
 ```text
-483 passed
+489 passed
 ```
 
 ## Packaging
@@ -821,6 +821,7 @@ 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.

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

@@ -56,6 +56,7 @@ 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",
@@ -132,4 +133,5 @@ __all__ = [
     "SummarizerWorker",
     "TurnSummaryWorker",
     "Worker",
+    "__version__",
 ]

{codex_agent_framework-0.1.21 → 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)
@@ -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.21 → codex_agent_framework-0.1.22}/codex_agent/builtin_plugins/subagents/__init__.py

@@ -125,15 +125,11 @@ Fundamentals:
         return config
 
     def relay_child_event(self, subagent, child, event):
-        wrapped = SubagentEvent(
+        self.agent.emit(SubagentEvent(
             subagent=subagent,
             event=event,
             session_id=getattr(child, "current_session_id", ""),
-        )
-        self.agent.events.emit(wrapped)
-        mainloop_manager = getattr(self.agent, "mainloop_manager", None)
-        if mainloop_manager is not None:
-            mainloop_manager.record_event(wrapped)
+        ))
         return event
 
     def install_child_tools(self, child):
@@ -163,16 +159,20 @@ Fundamentals:
             if path and os.path.exists(path):
                 os.remove(path)
 
-    def run_subagent(self, profile, task):
+    def create_child(self, profile_data):
         from ...agent import Agent
 
+        child = Agent(session="new", **self.child_config(profile_data))
+        self.install_child_tools(child)
+        return child
+
+    def run_subagent(self, profile, task):
         child = None
         profile_data = None
         try:
             profile_data = self.profile(profile)
-            child = Agent(session="new", **self.child_config(profile_data))
+            child = self.create_child(profile_data)
             child.on("*", lambda event: self.relay_child_event(profile, child, event))
-            self.install_child_tools(child)
             prompt = (
                 f"{task}\n\n"
                 "When the delegated task is complete, call the `set_result` tool with the structured result to return to the parent agent."

{codex_agent_framework-0.1.21 → codex_agent_framework-0.1.22}/codex_agent/client.py

@@ -6,6 +6,8 @@ from urllib.parse import urlencode
 import requests
 from modict import modict
 
+from .utils import snake_case_type
+
 
 class AgentClient:
     """Small HTTP/SSE client for a codex-agent server."""
@@ -13,6 +15,7 @@ class AgentClient:
     def __init__(self, base_url="http://127.0.0.1:8765", timeout=10):
         self.base_url = base_url.rstrip("/")
         self.timeout = timeout
+        self.event_read_timeout = max(2.0, min(float(timeout), 5.0))
         self.client_pid = os.getpid()
         self._event_handlers = {}
         self._event_thread = None
@@ -39,7 +42,7 @@ class AgentClient:
         if isinstance(event_type, str):
             return event_type
         if isinstance(event_type, type):
-            return self.snake_case_type(event_type)
+            return snake_case_type(event_type)
         return str(event_type)
 
     def emit_local(self, event):
@@ -129,7 +132,7 @@ class AgentClient:
                 with requests.get(
                     self.events_url(),
                     stream=True,
-                    timeout=(self.timeout, None),
+                    timeout=(self.timeout, self.event_read_timeout),
                     headers={"Accept": "text/event-stream"},
                 ) as response:
                     response.raise_for_status()
@@ -348,12 +351,3 @@ class AgentClient:
     def stop(self, timeout=None):
         return self.stop_events(timeout=timeout or 0.2)
 
-    @staticmethod
-    def snake_case_type(cls):
-        name = cls.__name__
-        chars = []
-        for i, char in enumerate(name):
-            if char.isupper() and i > 0:
-                chars.append("_")
-            chars.append(char.lower())
-        return "".join(chars)

{codex_agent_framework-0.1.21 → codex_agent_framework-0.1.22}/codex_agent/command.py

@@ -13,6 +13,12 @@ from .utils import runtime_join
 
 
 COMMAND_MARKER = "__codex_agent_command__"
+TURN_OUTCOME_TYPE = "turn_outcome"
+TURN_REASON_COMPLETED = "completed"
+TURN_REASON_ERROR = "error"
+TURN_REASON_INTERRUPTED = "interrupted"
+TURN_REASON_REQUIRES_NEXT_STEP = "requires_next_step"
+TURN_REASON_RESULT_SET = "result_set"
 
 
 def command(func=None, **options):
@@ -112,18 +118,22 @@ class AgentFuture(modict):
                 return message.get("content", "")
         return result
 
+    def is_turn_outcome(self, result):
+        return isinstance(result, dict) and result.get("type") == TURN_OUTCOME_TYPE
+
+    def apply_turn_outcome(self, outcome):
+        if self.is_turn_outcome(outcome):
+            self.turn.completed = bool(outcome.get("completed"))
+            self.turn.reason = outcome.get("reason", "")
+            return outcome.get("result")
+        self.turn.completed = True
+        self.turn.reason = TURN_REASON_COMPLETED
+        return outcome
+
     def set_result(self, result):
         from .utils import timestamp
 
-        outcome = result if isinstance(result, dict) and result.get("type") == "turn_outcome" else None
-        if outcome:
-            self.turn.completed = outcome.completed
-            self.turn.reason = outcome.reason
-            result = outcome.get("result")
-        else:
-            self.turn.completed = True
-            self.turn.reason = "completed"
-
+        result = self.apply_turn_outcome(result)
         self.status = "done"
         self.turn.status = "done"
         if self.turn.completed:
@@ -143,7 +153,7 @@ class AgentFuture(modict):
         self.turn.error = str(error)
         self.turn.status = "error"
         self.turn.completed = True
-        self.turn.reason = "error"
+        self.turn.reason = TURN_REASON_ERROR
         self.turn.completed_at = timestamp()
         self.finish_messages()
         self.set_attr("error_obj", error)
@@ -254,7 +264,7 @@ class CommandManager:
         self.agent.emit(AssistantTurnStartEvent, prompt=prompt)
         try:
             result = self.run(prompt)
-            self.agent.emit(AssistantTurnEndEvent, prompt=prompt, reason="completed")
+            self.agent.emit(AssistantTurnEndEvent, prompt=prompt, reason=TURN_REASON_COMPLETED)
             return result
         except Exception as exc:
             self.agent.emit(AssistantTurnErrorEvent, prompt=prompt, error=str(exc))

{codex_agent_framework-0.1.21 → codex_agent_framework-0.1.22}/codex_agent/context.py

@@ -82,17 +82,9 @@ class ContextManager:
             msg for msg in self.agent.session.context_messages()
             if self.is_message_visible_in_context(msg)
         )
-        images = [] if not self.agent.config.get("vision_enabled", False) else [
-            msg for msg in session_messages if isinstance(msg, ImageMessage)
-        ][-max_images:]
+        images = self.select_context_images(session_messages, max_images=max_images)
         others = [msg for msg in session_messages if not isinstance(msg, ImageMessage)]
-
-        truncated_others = []
-        for msg in others:
-            msg_copy = msg.copy()
-            if msg_copy.get("content") and isinstance(msg_copy.content, str):
-                msg_copy.content = truncate(msg_copy.content, max_tokens=max_input_tokens, model=self.agent.config.model)
-            truncated_others.append(msg_copy)
+        truncated_others = self.truncate_context_messages(others, max_input_tokens=max_input_tokens)
 
         current_count = self.response_input_token_count(system + images + providers_msgs, response_tools=response_tools)
         history_start = len(truncated_others)
@@ -138,6 +130,24 @@ class ContextManager:
         hook = self.agent.run_hook("context.build.after", messages=formatted_context)
         return hook.payload.messages
 
+    def select_context_images(self, messages, max_images=10):
+        if not self.agent.config.get("vision_enabled", False):
+            return []
+        return [msg for msg in messages if isinstance(msg, ImageMessage)][-max_images:]
+
+    def truncate_context_messages(self, messages, max_input_tokens):
+        truncated = []
+        for msg in messages:
+            msg_copy = msg.copy()
+            if msg_copy.get("content") and isinstance(msg_copy.content, str):
+                msg_copy.content = truncate(
+                    msg_copy.content,
+                    max_tokens=max_input_tokens,
+                    model=self.agent.config.model,
+                )
+            truncated.append(msg_copy)
+        return truncated
+
     def prune_orphaned_session_tool_outputs(self):
         if not self.agent.session:
             return []

{codex_agent_framework-0.1.21 → codex_agent_framework-0.1.22}/codex_agent/event.py

@@ -1,13 +1,5 @@
 from modict import modict
-from .utils import snake_case_type, timestamp
-
-
-def type_hierarchy(cls, root):
-    return [
-        snake_case_type(base)
-        for base in reversed(cls.mro())
-        if isinstance(base, type) and issubclass(base, root) and base is not object
-    ]
+from .utils import timestamp, type_hierarchy
 
 
 class AssistantInterrupted(Exception):

{codex_agent_framework-0.1.21 → codex_agent_framework-0.1.22}/codex_agent/mainloop.py

@@ -4,7 +4,17 @@ from threading import Event as ThreadEvent, Lock, Thread as BackgroundThread, ge
 
 from modict import modict
 
-from .command import AgentCommand, AgentFuture, AgentTurn
+from .command import (
+    TURN_OUTCOME_TYPE,
+    TURN_REASON_COMPLETED,
+    TURN_REASON_ERROR,
+    TURN_REASON_INTERRUPTED,
+    TURN_REASON_REQUIRES_NEXT_STEP,
+    TURN_REASON_RESULT_SET,
+    AgentCommand,
+    AgentFuture,
+    AgentTurn,
+)
 from .event import (
     AssistantInterrupted,
     AssistantStepEndEvent,
@@ -76,30 +86,31 @@ class MainLoopManager:
 
     def submit(self, command, **payload):
         self.start()
-        if isinstance(command, AgentCommand):
-            agent_command = command
-        else:
-            agent_command = AgentCommand(name=command, payload=payload)
-        message_start = len(self.agent.session.messages) if getattr(self.agent, "session", None) is not None else 0
-        future = AgentFuture(command_id=agent_command.id, command=agent_command.name)
+        agent_command = command if isinstance(command, AgentCommand) else AgentCommand(name=command, payload=payload)
         turn = payload.pop("turn", None)
-        future.turn = turn or AgentTurn(
-            id=future.id,
-            command_id=agent_command.id,
-            command=agent_command.name,
-            session_id=getattr(self.agent, "current_session_id", ""),
-            message_start=message_start,
-            message_end=message_start,
-        )
-        if turn is not None:
-            future.id = turn.id
-            future.turn.status = "pending"
-            future.turn.command_id = agent_command.id
+        future = AgentFuture(command_id=agent_command.id, command=agent_command.name)
+        future.turn = self.prepare_turn(future, agent_command, turn=turn)
         future.set_manager(self)
         self.futures[future.id] = future
         self.command_queue.put((agent_command, future))
         return future
 
+    def prepare_turn(self, future, command, turn=None):
+        if turn is None:
+            message_start = len(self.agent.session.messages) if getattr(self.agent, "session", None) is not None else 0
+            return AgentTurn(
+                id=future.id,
+                command_id=command.id,
+                command=command.name,
+                session_id=getattr(self.agent, "current_session_id", ""),
+                message_start=message_start,
+                message_end=message_start,
+            )
+        future.id = turn.id
+        turn.status = "pending"
+        turn.command_id = command.id
+        return turn
+
     def start_turn(self):
         if self.busy:
             return None
@@ -270,7 +281,7 @@ class MainLoopManager:
         return self.process(resume=resume)
 
     def turn_outcome(self, completed, reason, result=None):
-        return modict(type="turn_outcome", completed=completed, reason=reason, result=result)
+        return modict(type=TURN_OUTCOME_TYPE, completed=completed, reason=reason, result=result)
 
     def finish_turn(self, reason, message=None, result=None):
         self.agent.emit(AssistantTurnEndEvent, prompt=None, message=message, reason=reason)
@@ -311,19 +322,19 @@ class MainLoopManager:
                     )
 
                 if self.turn_result_set:
-                    return self.finish_turn("result_set", message=turn_message, result=self.turn_result)
+                    return self.finish_turn(TURN_REASON_RESULT_SET, message=turn_message, result=self.turn_result)
                 if self.require_next_step and not self.stop_agentic_loop:
                     if self.agent.config.auto_proceed:
                         continue
-                    return self.turn_outcome(completed=False, reason="requires_next_step")
-                return self.finish_turn("completed", message=turn_message)
+                    return self.turn_outcome(completed=False, reason=TURN_REASON_REQUIRES_NEXT_STEP)
+                return self.finish_turn(TURN_REASON_COMPLETED, message=turn_message)
         except AssistantInterrupted:
             self.dump_pending()
             self.agent.sessions_manager.append_message(InterruptMessage())
-            return self.finish_turn("interrupted", message=turn_message)
+            return self.finish_turn(TURN_REASON_INTERRUPTED, message=turn_message)
         except Exception as exc:
             self.agent.emit(AssistantTurnErrorEvent, prompt=None, message=turn_message, error=str(exc))
-            self.agent.emit(AssistantTurnEndEvent, prompt=None, message=turn_message, reason="error")
+            self.agent.emit(AssistantTurnEndEvent, prompt=None, message=turn_message, reason=TURN_REASON_ERROR)
             raise
 
     def call_tools(self, message):

{codex_agent_framework-0.1.21 → codex_agent_framework-0.1.22}/codex_agent/message.py

@@ -1,5 +1,5 @@
 from modict import modict
-from .utils import short_id, snake_case_type, timestamp, format
+from .utils import short_id, snake_case_type, timestamp, format, type_hierarchy
 import base64
 import hashlib
 import json
@@ -19,14 +19,6 @@ class MessageChunk(modict):
     output_items = None
 
 
-def type_hierarchy(cls, root):
-    return [
-        snake_case_type(base)
-        for base in reversed(cls.mro())
-        if isinstance(base, type) and issubclass(base, root) and base is not object
-    ]
-
-
 class Message(modict):
     """Base persisted message.
 

{codex_agent_framework-0.1.21 → codex_agent_framework-0.1.22}/codex_agent/server/app.py

@@ -1,6 +1,7 @@
 import json
 
 from ..agent import Agent
+from ..version import __version__
 from ..agent_runtime import InProcessAgentRuntime, ProcessAgentRuntime
 from .core import AgentServer, create_server_agent, remembered_server_session
 
@@ -28,7 +29,7 @@ def create_app(agent: Agent | None = None, start_agent=False, process_agent=Fals
         finally:
             service.stop(timeout=1.0)
 
-    app = FastAPI(title="Codex Agent", version="0.1.20", lifespan=lifespan)
+    app = FastAPI(title="Codex Agent", version=__version__, lifespan=lifespan)
     app.state.agent_service = service
 
     class TurnRequest(BaseModel):