codex-agent-framework 0.1.54__tar.gz → 0.1.55__tar.gz

{codex_agent_framework-0.1.54 → codex_agent_framework-0.1.55}/CHANGELOG.md

@@ -4,6 +4,14 @@ 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.55] - 2026-05-17
+### Fixed
+- Decouple SSE event-stream consumption from local client/TUI event handling so slow or blocked UI work no longer stalls event intake during long-running or heavy tool activity.
+- Remove the unsafe TUI bridge fallback that could execute UI callbacks off the Textual thread after `call_from_thread(...)` failures.
+
+### Tests
+- Add regression coverage for slow local handlers and TUI bridge thread-safety, then validate with targeted client/chat tests (88 passed).
+
 ## [0.1.54] - 2026-05-17
 ### Changed
 - Add a generic namespaced `/config` command surface so agent and plugin configs can be read, updated, and saved through a uniform dot-notation interface such as `/config agent.input_token_limit 200000`, `/config tts.voice nova`, `/config agent save`, and `/config save`.

{codex_agent_framework-0.1.54/codex_agent_framework.egg-info → codex_agent_framework-0.1.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-agent-framework
-Version: 0.1.54
+Version: 0.1.55
 Summary: A lightweight event-driven Codex agent runtime.
 Author: Baptiste
 License-Expression: MIT
@@ -129,6 +129,8 @@ turn = stream.turn
 print("\ncompleted:", turn.completed)
 ```
 
+The built-in TUI uses the same streamed event model and is designed to stay responsive during heavier tool activity by decoupling event intake from UI rendering.
+
 Add a small tool:
 
 ```python

{codex_agent_framework-0.1.54 → codex_agent_framework-0.1.55}/README.md

@@ -80,6 +80,8 @@ turn = stream.turn
 print("\ncompleted:", turn.completed)
 ```
 
+The built-in TUI uses the same streamed event model and is designed to stay responsive during heavier tool activity by decoupling event intake from UI rendering.
+
 Add a small tool:
 
 ```python

{codex_agent_framework-0.1.54 → codex_agent_framework-0.1.55}/codex_agent/client.py

@@ -1,5 +1,6 @@
 import json
 import os
+import queue
 import threading
 import time
 from urllib.parse import urlencode
@@ -22,7 +23,9 @@ class AgentClient:
         self._event_handlers = {}
         self._event_thread = None
         self._health_thread = None
+        self._dispatch_thread = None
         self._event_stop = threading.Event()
+        self._local_event_queue = queue.Queue()
         self._server_connected = False
         self._event_stream_connected = False
         self._event_stream_response = None
@@ -77,10 +80,35 @@ class AgentClient:
                     self.emit_local({"type": "client_event_error", "error": str(exc), "event": event_type})
         return event
 
+    def _start_dispatch_thread(self):
+        if self._dispatch_thread and self._dispatch_thread.is_alive():
+            return self
+        self._dispatch_thread = threading.Thread(target=self._dispatch_loop, name="agent-client-dispatch", daemon=True)
+        self._dispatch_thread.start()
+        return self
+
+    def _enqueue_local(self, event):
+        self._start_dispatch_thread()
+        self._local_event_queue.put(modict(event))
+        return event
+
+    def _dispatch_loop(self):
+        while True:
+            try:
+                event = self._local_event_queue.get(timeout=0.1)
+            except queue.Empty:
+                if self._event_stop.is_set():
+                    break
+                continue
+            if event is None:
+                break
+            self.emit_local(event)
+
     def start_events(self):
         if self._event_thread and self._event_thread.is_alive():
             return self
         self._event_stop.clear()
+        self._start_dispatch_thread()
         self._event_thread = threading.Thread(target=self._event_loop, name="agent-client-events", daemon=True)
         self._health_thread = threading.Thread(target=self._health_loop, name="agent-client-health", daemon=True)
         self._event_thread.start()
@@ -89,10 +117,13 @@ class AgentClient:
 
     def stop_events(self, timeout=0.2):
         self._event_stop.set()
+        self._local_event_queue.put(None)
         if self._event_thread:
             self._event_thread.join(timeout)
         if self._health_thread:
             self._health_thread.join(timeout)
+        if self._dispatch_thread:
+            self._dispatch_thread.join(timeout)
         return self
 
     def _set_server_connected(self):
@@ -100,7 +131,7 @@ class AgentClient:
             if self._server_connected:
                 return False
             self._server_connected = True
-        self.emit_local({"type": "server_connected"})
+        self._enqueue_local({"type": "server_connected"})
         return True
 
     def _set_server_offline(self, error=""):
@@ -108,7 +139,7 @@ class AgentClient:
             if not self._server_connected:
                 return False
             self._server_connected = False
-        self.emit_local({"type": "server_offline", "error": str(error or "")})
+        self._enqueue_local({"type": "server_offline", "error": str(error or "")})
         return True
 
     def _set_event_stream_connected(self, connected):
@@ -180,6 +211,7 @@ class AgentClient:
             self._event_stop.wait(self.health_interval)
 
     def _event_loop(self):
+        self._start_dispatch_thread()
         while not self._event_stop.is_set():
             try:
                 with requests.get(
@@ -200,7 +232,7 @@ class AgentClient:
                                 break
                             self._record_event_stream_activity()
                             self.remember_event_sequence(event)
-                            self.emit_local(event)
+                            self._enqueue_local(event)
                     finally:
                         self._clear_event_stream_response(response)
                     if stream_ended and not self._event_stop.is_set():
@@ -214,7 +246,7 @@ class AgentClient:
                     reconnecting = self._consume_event_reconnect_requested()
                     if not (reconnecting or (self._server_connected and self.is_event_idle_timeout(exc))):
                         self._set_server_offline(str(exc))
-                        self.emit_local(self.event_error_payload(exc))
+                        self._enqueue_local(self.event_error_payload(exc))
                     self._event_stop.wait(0.1)
 
     def event_error_payload(self, exc):
@@ -368,7 +400,7 @@ class AgentClient:
             return self.post("/interrupt", {"reason": reason})
         except Exception as exc:
             payload = modict(interrupted=False, interrupt_requested=False, error=str(exc))
-            self.emit_local({
+            self._enqueue_local({
                 "type": "client_event_error",
                 "error": str(exc),
                 "source": "interrupt",

{codex_agent_framework-0.1.54 → codex_agent_framework-0.1.55}/codex_agent/tui/state.py

@@ -60,10 +60,7 @@ class TuiAppBridge:
         if self.app is None:
             return None
         callback = getattr(self.app, method)
-        try:
-            return self.app.call_from_thread(callback, *args)
-        except RuntimeError:
-            return callback(*args)
+        return self.app.call_from_thread(callback, *args)
 
     def refresh_status(self):
         return self.call("refresh_status", skip_during_replay=True)

codex_agent_framework-0.1.55/codex_agent/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.55"

{codex_agent_framework-0.1.54 → codex_agent_framework-0.1.55/codex_agent_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-agent-framework
-Version: 0.1.54
+Version: 0.1.55
 Summary: A lightweight event-driven Codex agent runtime.
 Author: Baptiste
 License-Expression: MIT
@@ -129,6 +129,8 @@ turn = stream.turn
 print("\ncompleted:", turn.completed)
 ```
 
+The built-in TUI uses the same streamed event model and is designed to stay responsive during heavier tool activity by decoupling event intake from UI rendering.
+
 Add a small tool:
 
 ```python

{codex_agent_framework-0.1.54 → codex_agent_framework-0.1.55}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codex-agent-framework"
-version = "0.1.54"
+version = "0.1.55"
 description = "A lightweight event-driven Codex agent runtime."
 readme = "README.md"
 requires-python = ">=3.11"

{codex_agent_framework-0.1.54 → codex_agent_framework-0.1.55}/tests/test_chat.py

@@ -1204,6 +1204,29 @@ def test_chat_live_deltas_render_before_tool_start(monkeypatch):
     assert calls.index(("write_agent_delta", ("I will inspect.",))) < calls.index(("write_tool", ("bash", "call_1", "running")))
 
 
+def test_tui_app_bridge_does_not_fallback_to_off_thread_callback_execution():
+    chat = Chat()
+    calls = []
+
+    class App:
+        def call_from_thread(self, callback, *args):
+            raise RuntimeError("app not running")
+
+        def write_agent_delta(self, delta):
+            calls.append(("delta", delta))
+
+    chat.app = App()
+
+    try:
+        chat.view.write_agent_delta("hello")
+    except RuntimeError as exc:
+        assert "app not running" in str(exc)
+    else:
+        raise AssertionError("expected RuntimeError")
+
+    assert calls == []
+
+
 def test_chat_flushes_replay_deltas_before_live_deltas(monkeypatch):
     chat = Chat()
     calls = []

{codex_agent_framework-0.1.54 → codex_agent_framework-0.1.55}/tests/test_client.py

@@ -1,4 +1,6 @@
 import json
+import threading
+import time
 
 import requests
 
@@ -47,6 +49,72 @@ def test_agent_client_keeps_dispatching_when_handler_fails():
     assert seen == ["boom"]
 
 
+def test_agent_client_local_dispatch_queue_decouples_sse_from_slow_handler(monkeypatch):
+    client = AgentClient(timeout=0.01)
+    started = threading.Event()
+    release = threading.Event()
+    handled = []
+    request_count = {"count": 0}
+
+    def slow_handler(event):
+        handled.append(("start", event.type))
+        started.set()
+        release.wait(timeout=1.0)
+        handled.append(("done", event.type))
+
+    client.on("assistant_turn_start_event", slow_handler)
+    client.on("tool_call_start_event", lambda event: (handled.append(("fast", event.type)), client._event_stop.set()))
+
+    class Response:
+        content = b""
+
+        def __init__(self, lines):
+            self.lines = lines
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *args):
+            return False
+
+        def raise_for_status(self):
+            pass
+
+        def iter_lines(self, chunk_size=None, decode_unicode=True):
+            for line in self.lines:
+                yield line
+
+    def fake_get(*args, **kwargs):
+        request_count["count"] += 1
+        if request_count["count"] == 1:
+            return Response([
+                'event: assistant_turn_start_event',
+                'data: {"type": "assistant_turn_start_event", "sequence": 1}',
+                '',
+                'event: tool_call_start_event',
+                'data: {"type": "tool_call_start_event", "sequence": 2}',
+                '',
+            ])
+        return Response([])
+
+    monkeypatch.setattr("codex_agent.client.requests.get", fake_get)
+    monkeypatch.setattr(client._event_stop, "wait", lambda delay: None)
+
+    thread = threading.Thread(target=client._event_loop, daemon=True)
+    thread.start()
+
+    assert started.wait(timeout=1.0) is True
+    assert client._last_event_sequence == 2
+
+    release.set()
+    thread.join(timeout=1.0)
+    client.stop_events(timeout=0.2)
+
+    assert ("start", "assistant_turn_start_event") in handled
+    assert ("done", "assistant_turn_start_event") in handled
+    assert ("fast", "tool_call_start_event") in handled
+
+
 def test_agent_client_parses_bad_sse_json_as_client_error():
     client = AgentClient()
     lines = [
@@ -113,7 +181,8 @@ def test_agent_client_submit_prompt_posts_prompt(monkeypatch):
 def test_agent_client_interrupt_is_best_effort_on_http_error(monkeypatch):
     client = AgentClient(base_url="http://agent.local")
     seen = []
-    client.on("client_event_error", lambda event: seen.append(event))
+    received = threading.Event()
+    client.on("client_event_error", lambda event: (seen.append(event), received.set()))
 
     def fake_request(method, url, **kwargs):
         raise requests.ConnectionError("server disappeared")
@@ -125,7 +194,9 @@ def test_agent_client_interrupt_is_best_effort_on_http_error(monkeypatch):
     assert result.interrupted is False
     assert result.interrupt_requested is False
     assert "server disappeared" in result.error
+    assert received.wait(timeout=1.0) is True
     assert seen[-1].source == "interrupt"
+    client.stop_events(timeout=0.2)
 
 
 def test_agent_client_fetches_replay_events_with_cursor_and_session(monkeypatch):
@@ -195,8 +266,9 @@ def test_agent_client_emits_offline_then_connected_on_reconnect(monkeypatch):
     monkeypatch.setattr(client._event_stop, "wait", lambda delay: None)
 
     client._event_loop()
+    client.stop_events(timeout=0.2)
 
-    assert events == ["server_connected", "server_ping", "server_offline", "server_connected", "server_ping"]
+    assert events[:5] == ["server_connected", "server_ping", "server_offline", "server_connected", "server_ping"]
 
 
 def test_agent_client_does_not_emit_server_connected_for_failed_connection(monkeypatch):
@@ -347,12 +419,13 @@ def test_agent_client_reconnects_after_idle_read_timeout_without_offline_event(m
     monkeypatch.setattr(client._event_stop, "wait", lambda delay: False)
 
     client._event_loop()
+    client.stop_events(timeout=0.2)
 
-    assert urls == [
+    assert urls[:2] == [
         "http://agent.local/events?client_pid=1234",
         "http://agent.local/events?client_pid=1234&after_sequence=2",
     ]
-    assert events == ["server_connected", "tool_call_start_event", "tool_call_done_event"]
+    assert events[:3] == ["server_connected", "tool_call_start_event", "tool_call_done_event"]
 
 
 def test_agent_client_health_loop_reconnects_stale_event_stream_without_offline(monkeypatch):

codex_agent_framework-0.1.54/codex_agent/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.54"