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

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

@@ -4,10 +4,29 @@ 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`.
+- Keep config persistence explicit for SDK-created agents while still materializing `agent.config.json` for long-lived server sessions at server bootstrap.
+- Simplify config loading by relying on direct `Config.load(...)` with ignored unknown extras instead of carrying legacy config shims.
+- Hide empty plugin config namespaces from `/config` output so only agent config and plugins with actual exposed config values are shown.
+- Align runtime/server/client paths and tests with the namespaced config model and the minimal default plugin surface.
+
+### Tests
+- Validate with targeted config/server/runtime coverage and the full suite at 611 passed.
+
 ## [0.1.53] - 2026-05-16
 ### Changed
 - Default new agents to a smaller built-in plugin surface: `files`, `environment`, `memory`, `planner`, `scheduler`, and `context`.
-- Create `~/.codex-agent/agent.config.json` automatically on agent initialization instead of waiting for an explicit config update.
+- Persist `~/.codex-agent/agent.config.json` only on explicit save/update actions instead of automatically on agent initialization.
 - Make `web_search` and `image_generation` plugin-first server tools: loading the plugin now controls whether the corresponding Responses API tool is exposed.
 - Remove the redundant `web_search_enabled` and `image_generation_enabled` config flags from the public agent config surface.
 - Update docs and tests to reflect the minimal default plugin set and plugin-driven server tool activation.

{codex_agent_framework-0.1.53/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.53
+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.53 → 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.53 → codex_agent_framework-0.1.55}/codex_agent/agent.py

@@ -54,7 +54,6 @@ class Agent:
         self.config_manager.update(kwargs, save=False)
         self.init_working_directories(root_dir=explicit_root_dir or launch_cwd, cwd=explicit_cwd)
         self.config_manager.apply_openai_capability_defaults()
-        self.config_manager.save()
         self.events = EventBus()
         self.tools_manager = ToolsManager(self)
         self.providers_manager = ProvidersManager(self)

{codex_agent_framework-0.1.53 → codex_agent_framework-0.1.55}/codex_agent/agent_runtime.py

@@ -189,8 +189,8 @@ class InProcessAgentRuntime(AgentRuntime):
     def config(self):
         return self.agent.config
 
-    def update_config(self, values=None, save=True, **kwargs):
-        return self.agent.config_manager.update(values, save=save, **kwargs)
+    def update_config(self, values=None, save=True, namespace="agent", **kwargs):
+        return self.agent.config_manager.update_config(namespace, values, save=save, **kwargs)
 
     def session(self):
         return self.agent.session
@@ -588,11 +588,16 @@ class ProcessAgentRuntime(AgentRuntime):
     def config(self):
         return self._cached_call("config")
 
-    def update_config(self, values=None, save=True, **kwargs):
+    def update_config(self, values=None, save=True, namespace="agent", **kwargs):
         payload = dict(values or {})
         payload.update(kwargs)
-        result = self.call("update_config", {"values": payload, "save": save}, timeout=self.command_timeout)
-        self.cache["config"] = result
+        result = self.call(
+            "update_config",
+            {"namespace": namespace, "values": payload, "save": save},
+            timeout=self.command_timeout,
+        )
+        if namespace == "agent":
+            self.cache["config"] = result
         return result
 
     def session(self):
@@ -703,6 +708,7 @@ class _RuntimeFuture:
 
 def agent_worker_main(command_queue, response_queue, event_queue, agent_kwargs):
     agent = Agent(**dict(agent_kwargs or {}))
+    agent.config_manager.save()
 
     def emit_event(event):
         event_queue.put(event_payload(event))
@@ -749,7 +755,11 @@ def run_worker_command(agent, name, payload):
     if name == "config":
         return agent.config
     if name == "update_config":
-        return agent.config_manager.update(payload.get("values") or {}, save=payload.get("save", True))
+        return agent.config_manager.update_config(
+            payload.get("namespace", "agent"),
+            payload.get("values") or {},
+            save=payload.get("save", True),
+        )
     if name == "session":
         return agent.session
     if name == "sessions":

codex_agent_framework-0.1.55/codex_agent/builtin_commands.py

@@ -0,0 +1,196 @@
+"""Built-in slash commands."""
+
+from modict import modict
+
+from .command import command
+from .config import parse_config_value
+from .sessions import AgentSession
+from .tool import get_agent
+
+
+def _format_lines(value, prefix=""):
+    if isinstance(value, dict):
+        lines = []
+        for key, child in value.items():
+            full_key = f"{prefix}.{key}" if prefix else str(key)
+            if isinstance(child, dict):
+                lines.append(f"{full_key}:")
+                lines.extend(_format_lines(child, full_key))
+            else:
+                lines.append(f"{full_key}: {child!r}")
+        return lines
+    return [f"{prefix}: {value!r}" if prefix else repr(value)]
+
+
+def format_config_output(value, prefix=""):
+    return "\n".join(_format_lines(value, prefix=prefix)) if isinstance(value, dict) else repr(value)
+
+
+@command
+def help():
+    agent = get_agent()
+    names = ", ".join(f"/{name}" for name in sorted(agent.commands))
+    return f"Available commands: {names}"
+
+
+@command
+def compact(max_compacted_turns=None):
+    agent = get_agent()
+    max_compacted_turns = None if max_compacted_turns in (None, "", "all") else int(max_compacted_turns)
+    message = agent.compact_session(
+        model=agent.config.model,
+        instructions=agent.config_manager.system_message().content,
+        max_compacted_turns=max_compacted_turns,
+    )
+    if message is None:
+        return "Nothing to compact."
+    if message.get("status") == "failed":
+        return f"Compaction failed: {message.error}"
+    suffix = "" if max_compacted_turns is None else f" from {max_compacted_turns} compacted turn(s)"
+    return f"Compacted {message.compacted_message_count} messages{suffix}."
+
+
+def _message_count_text(count):
+    return f"{count} message" if count == 1 else f"{count} messages"
+
+
+def _session_infos(agent):
+    infos = []
+    for index, info in enumerate(AgentSession.list_session_infos(), start=1):
+        infos.append(modict(
+            index=index,
+            session_id=info.session_id,
+            title=info.title or info.session_id,
+            message_count=info.message_count,
+            current=info.session_id == agent.current_session_id,
+        ))
+    return infos
+
+
+def _format_session_list(agent):
+    infos = _session_infos(agent)
+    if not infos:
+        return "No saved sessions."
+    lines = ["Sessions:"]
+    for info in infos:
+        marker = "*" if info.current else " "
+        lines.append(
+            f"{marker} [{info.index}] {info.title} "
+            f"({info.session_id}, {_message_count_text(info.message_count)})"
+        )
+    return "\n".join(lines)
+
+
+@command
+def session(action=None, *parts):
+    agent = get_agent()
+    if action is None:
+        return _format_session_list(agent)
+
+    action_text = str(action).strip()
+    action_lower = action_text.lower()
+    if action_lower == "new":
+        created = agent.start_new_session()
+        return f"Created session: {created.session_id}"
+
+    if action_lower == "rename":
+        title = " ".join(str(part) for part in parts).strip()
+        if not title:
+            raise ValueError("/session rename requires a title")
+        if agent.session is None:
+            raise ValueError("No active session to rename")
+        agent.session.title = title
+        agent.save_session()
+        return f"Renamed session: {title}"
+
+    if parts:
+        raise ValueError("Usage: /session, /session <index>, /session new, /session rename <title>")
+
+    try:
+        index = int(action_text)
+    except ValueError as exc:
+        raise ValueError(f"Unknown /session action: {action_text}") from exc
+
+    infos = _session_infos(agent)
+    if index < 1 or index > len(infos):
+        raise ValueError(f"Session index out of range: {index}")
+    loaded = agent.load_session(infos[index - 1].session_id)
+    return f"Loaded session: {loaded.session_id}"
+
+
+@command
+def config(path=None, value=None, *extra, **values):
+    agent = get_agent()
+    manager = agent.config_manager
+
+    if values:
+        unknown = sorted(key for key in values if key not in agent.config)
+        if unknown:
+            raise ValueError(f"Unknown model config keys: {', '.join(unknown)}")
+        parsed = {key: parse_config_value(raw) for key, raw in values.items()}
+        manager.update_config("agent", config=parsed, save=True)
+        changed = ", ".join(f"{key}={agent.config.get(key)!r}" for key in parsed)
+        return f"Updated config: {changed}" if changed else format_config_output(manager.export_tree())
+
+    if path is None:
+        if value is not None or extra:
+            raise ValueError("/config with no path does not accept extra arguments")
+        return format_config_output(manager.export_tree())
+
+    if path == "save":
+        manager.save_all()
+        return "Saved all config namespaces."
+
+    if value is None and not extra:
+        displayed = manager.get_path(path)
+        return format_config_output(displayed, prefix=path)
+
+    if value == "save" and not extra:
+        namespace, remainder = manager.namespace_path(path)
+        if remainder:
+            raise ValueError("Save targets a config namespace, not a nested key")
+        manager.save_config(namespace)
+        return f"Saved config namespace: {namespace}"
+
+    raw_value = " ".join(str(part) for part in ((value,) + extra))
+    updated = manager.set_path(path, raw_value, save=False)
+    return f"Updated config: {path}={updated!r}"
+
+
+@command
+def model(value=None):
+    if value is None:
+        return f"model: {get_agent().config.model!r}"
+    get_agent().config_manager.set_path("agent.model", value, save=True)
+    return f"Updated config: model={get_agent().config.model!r}"
+
+
+@command
+def reasoning(value=None):
+    agent = get_agent()
+    if value is None:
+        return f"reasoning: {agent.config.get('reasoning')!r}"
+    current = dict(agent.config.get("reasoning") or {})
+    current["effort"] = value
+    current.setdefault("summary", "auto")
+    agent.config_manager.update_config("agent", reasoning=current, save=True)
+    return f"Updated config: reasoning={agent.config.get('reasoning')!r}"
+
+
+@command
+def verbosity(value=None):
+    agent = get_agent()
+    if value is None:
+        return f"text: {agent.config.get('text')!r}"
+    current = dict(agent.config.get("text") or {})
+    current["verbosity"] = value
+    agent.config_manager.update_config("agent", text=current, save=True)
+    return f"Updated config: text={agent.config.get('text')!r}"
+
+
+@command
+def voice(value=None):
+    agent = get_agent()
+    if "tts" not in agent.plugins:
+        agent.load_builtin_plugin("tts")
+    return agent.plugins.tts.voice(value)

{codex_agent_framework-0.1.53 → 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):
@@ -327,10 +359,10 @@ class AgentClient:
     def get_config(self):
         return self.get("/config")
 
-    def update_config(self, values=None, save=True, **kwargs):
+    def update_config(self, values=None, save=True, namespace="agent", **kwargs):
         payload = dict(values or {})
         payload.update(kwargs)
-        return self.request("PATCH", "/config", json={"values": payload, "save": save})
+        return self.request("PATCH", "/config", json={"values": payload, "save": save, "namespace": namespace})
 
     def tools(self):
         return self.get("/tools")
@@ -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",