codex-agent-framework 0.1.26__tar.gz → 0.1.28__tar.gz

{codex_agent_framework-0.1.26 → codex_agent_framework-0.1.28}/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.28] - 2026-05-15
+### Added
+- Add `StreamManager` as a dedicated stream-processing manager and expose it through the package API.
+
+### Changed
+- Improve Textual TUI streaming performance with coalesced replay/live deltas and safer incremental rendering.
+- Make terminal resize handling re-render the TUI transcript and status cleanly.
+- Treat the worker status cache as the single status source of truth, with process fallback limited to bootstrap.
+
+### Fixed
+- Keep `/status`, context providers, and the TUI status bar aligned after worker restarts and busy turns.
+- Preserve wrapper/message partition counters and token splits across context builds, API status updates, and restarts.
+- Avoid status update events confusing stale-turn detection.
+
+### Tests
+- Expand regression coverage for status cache replication, fallback bootstrap behavior, wrapper partitions, TUI delta batching, replay coalescing, and resize handling; the current suite validates at 576 passed.
+
 ## [0.1.25] - 2026-05-12
 ### Added
 - Add bundled plugin `requirements.txt` metadata for built-in capabilities and move image generation, realtime voice, and TTS into plugin-scoped packages.

{codex_agent_framework-0.1.26/codex_agent_framework.egg-info → codex_agent_framework-0.1.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-agent-framework
-Version: 0.1.26
+Version: 0.1.28
 Summary: A lightweight event-driven Codex agent runtime.
 Author: Baptiste
 License-Expression: MIT
@@ -626,6 +626,7 @@ Core LLM calls, memory embeddings, non-streaming STT transcription, and realtime
 
 ## Recent releases
 
+- `0.1.27`: upgrade the agentic `read` tool with folder trees, recursive folder pattern search, and precise `start_at_line`/`end_at_line` ranges; add visible wrapper/token split stats, compactable turn counts, and refreshed TUI status-bar context telemetry.
 - `0.1.26`: align SDK-facing config with Responses API shapes, add the `context` management plugin with selective non-destructive wrapper pruning, keep wrappers out of memory retrieval and compaction payloads, move embeddings/STT/realtime onto Codex backend auth, streamline voice/TTS plugin config, and improve TUI streaming/windowing.
 - `0.1.25`: move built-in capabilities further into plugin-scoped modules, add bundled plugin requirement metadata, and replace the TUI conversation pane with a selectable rich chat area that preserves mouse scrolling, copy selection, lazy transcript loading, and bottom-aware auto-scroll.
 - `0.1.24`: add slash-command lifecycle events and TUI progress/result rendering so commands such as `/compact` and `/help` show running, done, failed, result, and error feedback instead of going silent.

{codex_agent_framework-0.1.26 → codex_agent_framework-0.1.28}/README.md

@@ -577,6 +577,7 @@ Core LLM calls, memory embeddings, non-streaming STT transcription, and realtime
 
 ## Recent releases
 
+- `0.1.27`: upgrade the agentic `read` tool with folder trees, recursive folder pattern search, and precise `start_at_line`/`end_at_line` ranges; add visible wrapper/token split stats, compactable turn counts, and refreshed TUI status-bar context telemetry.
 - `0.1.26`: align SDK-facing config with Responses API shapes, add the `context` management plugin with selective non-destructive wrapper pruning, keep wrappers out of memory retrieval and compaction payloads, move embeddings/STT/realtime onto Codex backend auth, streamline voice/TTS plugin config, and improve TUI streaming/windowing.
 - `0.1.25`: move built-in capabilities further into plugin-scoped modules, add bundled plugin requirement metadata, and replace the TUI conversation pane with a selectable rich chat area that preserves mouse scrolling, copy selection, lazy transcript loading, and bottom-aware auto-scroll.
 - `0.1.24`: add slash-command lifecycle events and TUI progress/result rendering so commands such as `/compact` and `/help` show running, done, failed, result, and error feedback instead of going silent.

{codex_agent_framework-0.1.26 → codex_agent_framework-0.1.28}/codex_agent/__init__.py

@@ -60,7 +60,7 @@ from .image import ImageMessage
 from .mainloop import MainLoopManager
 from .plugin import Plugin, PluginsManager, event_handler, hook_handler, stream_processor
 from .command import AgentCommand, AgentFuture, AgentTurn, CommandManager, command
-from .stream import AgentStream
+from .stream import AgentStream, StreamManager
 from .provider import ProvidersManager, provider
 from .runtime import RuntimeManager
 from .sessions import AgentSession, SessionsManager
@@ -138,6 +138,7 @@ __all__ = [
     "AgentFuture",
     "AgentTurn",
     "AgentStream",
+    "StreamManager",
     "CommandManager",
     "command",
     "provider",

{codex_agent_framework-0.1.26 → codex_agent_framework-0.1.28}/codex_agent/agent.py

@@ -14,6 +14,7 @@ from .runtime import RuntimeManager
 from .scheduler import AgentScheduler
 from .sessions import SessionsManager
 from .status import StatusManager
+from .stream import StreamManager
 from .tool import ToolsManager, reset_current_agent, set_current_agent
 from .ai import AIClient
 from .event import AssistantInterruptRequestedEvent, AssistantInterrupted, AssistantInterruptedEvent, EventBus
@@ -32,26 +33,20 @@ class Agent:
         ensure_runtime_dir()
         self.init_execution_environment()
         self.config_manager=ConfigManager(self)
-        self.config=self.config_manager.config
         self.config_manager.load()
         self.config_manager.update(kwargs, save=False)
         self.config_manager.apply_openai_capability_defaults()
         self.events=EventBus()
         self.tools_manager=ToolsManager(self)
-        self.tools=self.tools_manager.tools
         self.providers_manager=ProvidersManager(self)
-        self.providers=self.providers_manager.providers
         self.command_manager=CommandManager(self)
-        self.commands=self.command_manager.commands
         self.context_manager=ContextManager(self)
         self.plugins_manager=PluginsManager(self)
-        self.plugins=self.plugins_manager.plugins
         self.sessions_manager=SessionsManager(self)
         self.runtime=RuntimeManager(self)
         self.scheduler=AgentScheduler(self)
         self.hooks=HookManager(self)
-        self.stream_processors=modict()
-        self.stream_processor_owners={}
+        self.stream_manager=StreamManager(self)
         self.mainloop_manager=MainLoopManager(self)
         self._interrupt_requested=ThreadEvent()
         self.current_session_id=None
@@ -86,6 +81,40 @@ class Agent:
             mainloop_manager.record_event(event)
         return event
 
+    @property
+    def config(self):
+        return self.config_manager.config
+
+    @config.setter
+    def config(self, value):
+        self.config_manager.config = value
+        if hasattr(self.config_manager, "configs"):
+            self.config_manager.configs.agent = value
+
+    @property
+    def tools(self):
+        return self.tools_manager.tools
+
+    @property
+    def providers(self):
+        return self.providers_manager.providers
+
+    @property
+    def commands(self):
+        return self.command_manager.commands
+
+    @property
+    def plugins(self):
+        return self.plugins_manager.plugins
+
+    @property
+    def stream_processors(self):
+        return self.stream_manager.processors
+
+    @property
+    def stream_processor_owners(self):
+        return self.stream_manager.owners
+
     @property
     def busy(self):
         return self.mainloop_manager.busy
@@ -274,32 +303,13 @@ class Agent:
         return self.plugins_manager.reload_plugin(plugin_or_name, timeout=timeout)
 
     def add_stream_processor(self, key, processor, owner=None):
-        processors = self.stream_processors.setdefault(str(key), [])
-        processors.append(processor)
-        if owner is not None:
-            self.stream_processor_owners.setdefault(str(key), {})[processor] = owner
-        return processor
+        return self.stream_manager.add(key, processor, owner=owner)
 
     def get_stream_processors(self, key):
-        return list(self.stream_processors.get(str(key), []))
+        return self.stream_manager.get(key)
 
     def remove_stream_processors_by_owner(self, owner):
-        removed = modict()
-        for key, processors in list(self.stream_processors.items()):
-            owners = self.stream_processor_owners.get(key, {})
-            kept = []
-            for processor in processors:
-                if owners.get(processor) == owner:
-                    removed.setdefault(key, []).append(processor)
-                    owners.pop(processor, None)
-                else:
-                    kept.append(processor)
-            if kept:
-                self.stream_processors[key] = kept
-            else:
-                self.stream_processors.pop(key, None)
-                self.stream_processor_owners.pop(key, None)
-        return removed
+        return self.stream_manager.remove_by_owner(owner)
 
     def add_hook(self, key, func=None, owner=None):
         """Register a runtime hook.

{codex_agent_framework-0.1.26 → codex_agent_framework-0.1.28}/codex_agent/agent_runtime.py

@@ -8,8 +8,11 @@ from abc import ABC, abstractmethod
 from modict import modict
 
 from .agent import Agent
+from .config import AgentConfig
 from .event import Event
-from .message import UserMessage, message_from_data
+from .message import ToolResultWrapper, UserMessage, message_from_data
+from .sessions import AgentSession
+from .utils import token_count, truncate
 
 
 def jsonable(value):
@@ -270,13 +273,38 @@ class ProcessAgentRuntime(AgentRuntime):
             current_turn_id=None,
             current_session_id=None,
             status=modict(),
-            config=modict(),
+            config=AgentConfig(),
             session=modict(),
             sessions=modict(current=None, sessions=[]),
             messages=[],
             tools=modict(),
             wakeups=[],
         )
+        self.hydrate_local_session_cache()
+
+    def local_session_id(self):
+        session_id = self.agent_kwargs.get("session")
+        if not session_id or session_id == "latest":
+            try:
+                sessions = AgentSession.list_sessions()
+            except Exception:
+                return None
+            return sessions[0] if sessions else None
+        return session_id if AgentSession.can_load(session_id) else None
+
+    def hydrate_local_session_cache(self):
+        session_id = self.local_session_id()
+        if not session_id:
+            return False
+        try:
+            session = AgentSession.load(session_id)
+        except Exception:
+            return False
+        self.cache.current_session_id = session.session_id
+        self.cache.session = session
+        self.cache.messages = list(session.messages)
+        self.refresh_cached_wrapper_status(hydrate=False)
+        return True
 
     def start(self):
         with self.start_lock:
@@ -293,6 +321,7 @@ class ProcessAgentRuntime(AgentRuntime):
             self.process.start()
             self.event_thread = threading.Thread(target=self._event_loop, name="agent-runtime-events", daemon=True)
             self.event_thread.start()
+            self.hydrate_local_session_cache()
             try:
                 self.call("start", timeout=self.command_timeout, autostart=False)
                 self.refresh_cache()
@@ -339,6 +368,8 @@ class ProcessAgentRuntime(AgentRuntime):
             except Exception:
                 pass
         self.update_status_cache(self.cache.get("status") or {})
+        if not self.cache.get("status"):
+            self.refresh_cached_wrapper_status()
         return self.cache
 
     def call(self, name, payload=None, timeout=None, autostart=True):
@@ -391,6 +422,107 @@ class ProcessAgentRuntime(AgentRuntime):
         self.cache.current_session_id = status.get("session_id", self.cache.current_session_id)
         return status
 
+    def cached_message_from_event(self, message):
+        if not message:
+            return None
+        try:
+            return message_from_data(message)
+        except Exception:
+            return modict(message)
+
+    def is_cached_wrapper(self, message):
+        if isinstance(message, ToolResultWrapper):
+            return True
+        types = message.get("types") or []
+        return message.get("type") == "tool_result_wrapper" or "tool_result_wrapper" in types
+
+    def cached_wrapper_tokens(self, messages):
+        total = 0
+        config = modict(self.cache.get("config") or {})
+        max_tokens = int(config.get("max_input_tokens", 8000) or 8000)
+        model = config.get("model")
+        for message in messages:
+            content = message.get("content")
+            if not isinstance(content, str) or not content:
+                continue
+            total += token_count(truncate(content, max_tokens=max_tokens, model=model), model=model)
+        return total
+
+    def refresh_cached_wrapper_status(self, hydrate=True):
+        status = modict(self.cache.status or {})
+        if hydrate and not self.cache.get("messages"):
+            self.hydrate_local_session_cache()
+        messages = list(self.cache.get("messages") or [])
+        wrappers = [message for message in messages if self.is_cached_wrapper(message)]
+        active = [
+            message for message in wrappers
+            if isinstance(message.get("turns_left", -1), int) and message.get("turns_left", -1) > 0
+        ]
+        vanished = [message for message in wrappers if message.get("turns_left", -1) == 0]
+        active_tokens = self.cached_wrapper_tokens(active)
+        vanished_tokens = self.cached_wrapper_tokens(vanished)
+        visible_non_wrappers = [
+            message for message in messages
+            if not self.is_cached_wrapper(message) and message.get("turns_left", -1) != 0
+        ]
+        estimated_base_tokens = self.cached_wrapper_tokens(visible_non_wrappers)
+        # The fallback cache is updated by message events while the worker may be busy. Do not preserve
+        # a stale worker-provided context_current_tokens here: otherwise wrapper/message counts move but
+        # the context percentage appears frozen until a full worker status succeeds.
+        current_tokens = estimated_base_tokens + active_tokens
+        persistent = [message for message in messages if message.get("turns_left", -1) == -1]
+        temporary = [
+            message for message in messages
+            if isinstance(message.get("turns_left", -1), int) and message.get("turns_left", -1) > 0
+        ]
+        config = modict(self.cache.get("config") or {})
+        input_limit = int(status.get("context_limit_tokens") or config.get("input_token_limit", 0) or 0)
+        if not current_tokens:
+            current_tokens = estimated_base_tokens + active_tokens
+        base_tokens = max(0, current_tokens - active_tokens) if current_tokens else estimated_base_tokens
+        status.update(
+            context_current_tokens=current_tokens,
+            context_limit_tokens=input_limit,
+            context_percent=(current_tokens / input_limit * 100) if input_limit else 0,
+            model=status.get("model") or config.get("model"),
+            source="process_fallback",
+            total_session_messages=len(messages) or status.get("total_session_messages", 0),
+            persistent_session_messages=len(persistent),
+            temporary_session_messages=len(temporary),
+            active_wrapper_messages=len(active),
+            vanished_wrapper_messages=len(vanished),
+            total_wrapper_messages=len(wrappers),
+            active_wrapper_tokens=active_tokens,
+            vanished_wrapper_tokens=vanished_tokens,
+            base_context_tokens=base_tokens,
+        )
+        self.cache.status = status
+        return status
+
+    def has_worker_status_cache(self):
+        status = modict(self.cache.get("status") or {})
+        source = status.get("source")
+        return bool(source) and source != "process_fallback"
+
+    def append_cached_message(self, message):
+        message = self.cached_message_from_event(message)
+        if message is None:
+            return None
+        self.cache.messages.append(message)
+        if not self.has_worker_status_cache():
+            return self.refresh_cached_wrapper_status()
+        return self.cache.status
+
+    def age_cached_context_messages(self):
+        changed = False
+        for message in self.cache.get("messages") or []:
+            turns_left = message.get("turns_left", -1)
+            if isinstance(turns_left, int) and turns_left > 0:
+                message.turns_left = turns_left - 1
+                changed = True
+        if changed and not self.has_worker_status_cache():
+            self.refresh_cached_wrapper_status()
+
     def mark_turn_started(self, turn_id=None):
         self.cache.busy = True
         if turn_id is not None:
@@ -404,12 +536,22 @@ class ProcessAgentRuntime(AgentRuntime):
         event_type = event.get("type")
         if event_type == "assistant_turn_start_event":
             self.mark_turn_started(event.get("turn_id"))
+            self.age_cached_context_messages()
         elif event_type in ("assistant_turn_end_event", "assistant_turn_error_event"):
             self.mark_turn_finished()
+        elif event_type == "message_added_event":
+            message = self.cached_message_from_event(event.get("message"))
+            if message is not None:
+                self.cache.messages.append(message)
+                if not self.has_worker_status_cache():
+                    self.refresh_cached_wrapper_status()
         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"):
+            self.cache.messages = list((self.cache.session or {}).get("messages") or [])
+            if not self.has_worker_status_cache():
+                self.refresh_cached_wrapper_status()
+        elif event_type in ("status_updated_event", "compaction_completed_event") and event.get("status"):
             self.update_status_cache(event.status)
         for handler in list(self.event_handlers):
             try:
@@ -434,8 +576,13 @@ class ProcessAgentRuntime(AgentRuntime):
             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)
-            status.setdefault("current_turn_id", self.cache.current_turn_id)
+            if not self.has_worker_status_cache():
+                status = self.refresh_cached_wrapper_status()
+            status.update(
+                busy=self.cache.busy,
+                current_turn_id=self.cache.current_turn_id,
+                session_id=self.cache.current_session_id,
+            )
             return status
 
     def config(self):

{codex_agent_framework-0.1.26 → codex_agent_framework-0.1.28}/codex_agent/builtin_plugins/context/__init__.py

@@ -33,6 +33,15 @@ Tool result wrappers expose stable `wrapper_id` values in their XML representati
             total_history_messages=status.get("total_history_messages", 0),
             persistent_session_messages=status.get("persistent_session_messages", 0),
             temporary_session_messages=status.get("temporary_session_messages", 0),
+            active_wrapper_messages=status.get("active_wrapper_messages", 0),
+            vanished_wrapper_messages=status.get("vanished_wrapper_messages", 0),
+            total_wrapper_messages=status.get("total_wrapper_messages", 0),
+            base_context_tokens=status.get("base_context_tokens", status.used_tokens),
+            active_wrapper_tokens=status.get("active_wrapper_tokens", 0),
+            vanished_wrapper_tokens=status.get("vanished_wrapper_tokens", 0),
+            compactable_turns=status.get("compactable_turns", 0),
+            compactable_messages=status.get("compactable_messages", 0),
+            compactable_tokens=status.get("compactable_tokens", 0),
             context_session_messages=status.get("context_session_messages", 0),
             image_messages=status.get("image_messages", 0),
             pending_messages=status.get("pending_messages", 0),
@@ -48,8 +57,11 @@ Tool result wrappers expose stable `wrapper_id` values in their XML representati
         return "\n".join([
             "Context status:",
             f"- tokens: {status.used_tokens}/{status.input_token_limit} ({status.percent:.2f}%)",
+            f"- token split base/active_wrappers/vanished_wrappers: {status.base_context_tokens}/{status.active_wrapper_tokens}/{status.vanished_wrapper_tokens}",
             f"- messages sent/total: {status.sent_session_messages}/{status.total_session_messages}",
             f"- persistent/temporary context messages: {status.persistent_session_messages}/{status.temporary_session_messages}",
+            f"- wrappers active/vanished/total: {status.active_wrapper_messages}/{status.vanished_wrapper_messages}/{status.total_wrapper_messages}",
+            f"- compactable turns/messages/tokens: {status.compactable_turns}/{status.compactable_messages}/{status.compactable_tokens}",
             f"- visible/total history messages: {status.visible_history_messages}/{status.total_history_messages}",
             f"- tool spec tokens: {status.tool_spec_tokens}",
             f"- auto_compact: {status.auto_compact} threshold={status.auto_compact_threshold}",

{codex_agent_framework-0.1.26 → codex_agent_framework-0.1.28}/codex_agent/builtin_plugins/files/__init__.py

@@ -7,13 +7,13 @@ from . import tools as file_tools
 
 class FilesPlugin(Plugin):
     name = "files"
-    description = "Strict local UTF-8 file read/write/edit operations."
+    description = "Strict local UTF-8 file/folder read and search plus write/edit operations."
     prefix_tools = False
     system_prompt = """
 # File Tools
 
-Use the specialized file tools for local UTF-8 text file operations:
-- `read`: read line-numbered local UTF-8 files precisely, with optional pattern search.
+Use the specialized file tools for local UTF-8 text operations:
+- `read`: read line-numbered local UTF-8 files precisely, list local folders as a compact one-level tree, or search folders recursively with a pattern.
 - `write`: create or overwrite complete UTF-8 text files; use with caution.
 - `edit`: perform targeted exact-string replacements in local UTF-8 text files.
 

{codex_agent_framework-0.1.26 → codex_agent_framework-0.1.28}/codex_agent/builtin_plugins/files/tools.py

@@ -8,10 +8,11 @@ from ...utils import read_document_content, view_document_content
 def read(reads):
     """
     description: |
-        Strictly read one or more local UTF-8 text files as source-of-truth content.
-        This tool always prefixes returned content with reliable source line numbers.
-        It does not extract document formats, fetch URLs, inspect Python objects, or render directory trees.
-        Use `view` for folders, URLs, PDFs, DOCX, ODT, HTML, XLSX, and other extracted or transformed content.
+        Read one or more local UTF-8 text files or folders as source-of-truth content.
+        File reads always prefix returned content with reliable source line numbers.
+        Folder reads without `pattern` render a compact tree with one level of recursion.
+        Folder reads with `pattern` recursively search UTF-8 files under the folder and return numbered snippets per matching file.
+        This tool does not extract document formats, fetch URLs, or inspect Python objects; use `view` for URLs, PDFs, DOCX, ODT, HTML, XLSX, archives, and other extracted or transformed content.
 
         For large outputs: the output is automatically truncated. When truncated, a message indicates the omitted line range.
         When `pattern` is provided, it is treated as a Python regex by default and all matches are returned as separated numbered snippets with up to 10 lines before and after each match.
@@ -20,16 +21,19 @@ def read(reads):
         reads:
             description: |
                 A single read object or a list of read objects.
-                Each object must contain `source` and may contain `start_at_line`, `pattern`, and `regex`.
+                Each object must contain `source` and may contain `start_at_line`, `end_at_line`, `pattern`, and `regex`.
             anyOf:
                 - type: object
                   properties:
                     source:
-                        description: Local UTF-8 text file path only. For directories, URLs, rich documents, or Python objects, use `view` instead.
+                        description: Local UTF-8 text file or folder path. Folders are listed as a compact tree, or searched recursively when pattern is provided. For URLs, rich documents, archives, or Python objects, use `view` instead.
                         type: string
                     start_at_line:
                         description: Line number to start reading from (1-indexed). Default is 1 (start from beginning).
                         type: integer
+                    end_at_line:
+                        description: Optional inclusive line number to stop reading at for direct file reads.
+                        type: integer
                     pattern:
                         description: Optional search pattern. Treated as a Python regular expression by default.
                         type: string
@@ -43,9 +47,12 @@ def read(reads):
                     type: object
                     properties:
                         source:
+                            description: Local UTF-8 text file or folder path. Folders are listed as a compact tree, or searched recursively when pattern is provided.
                             type: string
                         start_at_line:
                             type: integer
+                        end_at_line:
+                            type: integer
                         pattern:
                             type: string
                         regex:
@@ -79,6 +86,7 @@ def apply_file_read(item):
         return read_document_content(
             source,
             start_at_line=item.get("start_at_line", 1),
+            end_at_line=item.get("end_at_line"),
             max_tokens=max_tokens,
             pattern=item.get("pattern"),
             regex=item.get("regex", True),

codex_agent_framework-0.1.28/codex_agent/builtin_plugins/interface/__init__.py

@@ -0,0 +1,53 @@
+"""Built-in local interface plugin."""
+
+from ...plugin import Plugin
+from ...provider import provider
+from ...tool import tool
+from ...tui import current_tui, open_tui_terminal, terminate_tui
+
+
+class InterfacePlugin(Plugin):
+    name = "interface"
+    description = "Open and close the local TUI interface."
+    prefix_tools = False
+
+    @provider
+    def tui_status(self):
+        """Expose whether the local TUI client is currently open."""
+        tui = current_tui()
+        if not tui:
+            return "TUI status: closed."
+        return (
+            "TUI status: open. "
+            f"pid={tui.get('pid')} "
+            f"base_url={tui.get('base_url')} "
+            f"timestamp={tui.get('timestamp')}"
+        )
+
+    @tool(name="open_tui")
+    def open_tui(self):
+        """
+        description: Open the Textual chat TUI client in a separate terminal connected to the local agent server.
+        parameters: {}
+        required: []
+        """
+        tui = current_tui()
+        if tui:
+            return {"status": "already_open", "tui": tui}
+        process = open_tui_terminal(base_url=self.agent.config.get("server_url", "http://127.0.0.1:8765"))
+        if process is None:
+            raise RuntimeError("No supported terminal emulator found to open the TUI")
+        return {"status": "opened", "pid": process.pid}
+
+    @tool(name="close_tui")
+    def close_tui(self):
+        """
+        description: Close the currently registered Textual chat TUI client process.
+        parameters: {}
+        required: []
+        """
+        tui = current_tui()
+        if not tui:
+            return {"status": "not_open"}
+        terminate_tui(tui.pid)
+        return {"status": "closed", "tui": tui}

{codex_agent_framework-0.1.26 → codex_agent_framework-0.1.28}/codex_agent/context.py

@@ -1,7 +1,7 @@
 from modict import modict
 
 from .image import ImageMessage
-from .message import Message, ProviderMessage, SystemMessage
+from .message import Message, ProviderMessage, SystemMessage, ToolResultWrapper
 from .tool import reset_current_agent, set_current_agent
 from .utils import sort, token_count_payload, truncate
 
@@ -100,14 +100,45 @@ class ContextManager:
         formatted_context = list(msg.format(context=self.agent.context_namespace) for msg in context)
         total_session_messages = len(self.agent.session.messages) if self.agent.session else 0
         sent_session_messages = len(history) + len(images)
+        all_session_messages = list(self.agent.session.messages) if self.agent.session else []
         persistent_session_messages = sum(
-            1 for msg in session_messages
+            1 for msg in all_session_messages
             if msg.get("turns_left", -1) == -1
         )
         temporary_session_messages = sum(
-            1 for msg in session_messages
+            1 for msg in all_session_messages
             if isinstance(msg.get("turns_left", -1), int) and msg.get("turns_left", -1) > 0
         )
+        wrappers = [msg for msg in all_session_messages if isinstance(msg, ToolResultWrapper)]
+        active_wrappers = [
+            msg for msg in wrappers
+            if isinstance(msg.get("turns_left", -1), int) and msg.get("turns_left", -1) > 0
+        ]
+        vanished_wrappers = [msg for msg in wrappers if msg.get("turns_left", -1) == 0]
+
+        def wrapper_token_count(messages):
+            total = 0
+            for msg in messages:
+                total += self.response_input_token_count([msg], response_tools=[])
+            return total
+
+        active_context_wrappers = [msg for msg in history if isinstance(msg, ToolResultWrapper)]
+        active_wrapper_tokens = wrapper_token_count(active_context_wrappers)
+        vanished_wrapper_tokens = wrapper_token_count(vanished_wrappers)
+        base_context_tokens = max(0, current_count - active_wrapper_tokens)
+        if self.agent.session:
+            compaction_plan = self.agent.session.compaction_plan(
+                max_input_tokens=max_input_tokens,
+                model=self.agent.config.model,
+                max_compacted_turns=None,
+            )
+            compactable_turns = compaction_plan.completed_turn_count
+            compactable_messages = compaction_plan.compacted_message_count
+            compactable_tokens = compaction_plan.compacted_token_count
+        else:
+            compactable_turns = 0
+            compactable_messages = 0
+            compactable_tokens = 0
         token_count_source = "local_estimate"
         try:
             current_count = self.agent.ai.count_input_tokens(
@@ -125,6 +156,15 @@ class ContextManager:
             sent_session_message_percent=(sent_session_messages / total_session_messages * 100) if total_session_messages else 0,
             persistent_session_messages=persistent_session_messages,
             temporary_session_messages=temporary_session_messages,
+            active_wrapper_messages=len(active_wrappers),
+            vanished_wrapper_messages=len(vanished_wrappers),
+            total_wrapper_messages=len(wrappers),
+            base_context_tokens=base_context_tokens,
+            active_wrapper_tokens=active_wrapper_tokens,
+            vanished_wrapper_tokens=vanished_wrapper_tokens,
+            compactable_turns=compactable_turns,
+            compactable_messages=compactable_messages,
+            compactable_tokens=compactable_tokens,
             token_count_source=token_count_source,
         ))
         hook = self.agent.run_hook("context.build.after", messages=formatted_context)

{codex_agent_framework-0.1.26 → codex_agent_framework-0.1.28}/codex_agent/event.py

@@ -102,6 +102,10 @@ class MessageAddedEvent(Event):
     message = None
 
 
+class StatusUpdatedEvent(Event):
+    status = None
+
+
 class MessageSubmittedEvent(Event):
     message = None
     turn_id = None

{codex_agent_framework-0.1.26 → codex_agent_framework-0.1.28}/codex_agent/server/core.py

@@ -396,9 +396,13 @@ class AgentServer:
 
     def event_stream_status(self, stale_timeout=120):
         with self.event_lock:
-            last_event = self.events[-1] if self.events else None
             active = bool(self.turn_replay_active)
             current_turn_events = list(self.current_turn_events)
+            source_events = current_turn_events if current_turn_events else list(self.events)
+            last_event = next(
+                (event for event in reversed(source_events) if event.get("type") != "status_updated_event"),
+                None,
+            )
         last_timestamp = self.event_timestamp(last_event)
         now = time.time()
         return modict(