codex-agent-framework 0.1.31__tar.gz → 0.1.33__tar.gz

{codex_agent_framework-0.1.31 → codex_agent_framework-0.1.33}/CHANGELOG.md

@@ -4,6 +4,24 @@ 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.33] - 2026-05-16
+### Changed
+- Simplify plugin decorated-method accessors by sharing the handler pair construction path.
+- Deduplicate queued Agent state-command dispatch for scheduler and hook registration operations.
+- Tighten Agent tool-facing docstrings for audio transcription and workfolder uploads without changing runtime behavior.
+
+### Tests
+- Validate the cleanup pass with targeted plugin, Agent, scheduler, hook, tool, audio, and image tests plus the 553-test offline CI suite.
+
+## [0.1.32] - 2026-05-16
+### Changed
+- Split the former `tests/test_agent.py` monolith into focused agent test modules for audio hooks, commands, context, desktop, environment, image generation, observe, plugins, providers/config, realtime, response handling, sessions, subagents, tools, and turns.
+- Keep realtime voice coverage separated as local-heavy while preserving the offline CI suite for headless runners.
+- Trim the remaining core agent tests to a small, focused file with obsolete helper fakes and imports removed.
+
+### Tests
+- Expand the explicit offline CI test selection to cover the extracted agent modules; the current offline suite validates at 553 passed.
+
 ## [0.1.29] - 2026-05-15
 ### Changed
 - Split the Textual TUI implementation into focused modules for app wiring, transcript rendering, status display, styling, log windowing, and render state.

{codex_agent_framework-0.1.31/codex_agent_framework.egg-info → codex_agent_framework-0.1.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-agent-framework
-Version: 0.1.31
+Version: 0.1.33
 Summary: A lightweight event-driven Codex agent runtime.
 Author: Baptiste
 License-Expression: MIT

{codex_agent_framework-0.1.31 → codex_agent_framework-0.1.33}/codex_agent/agent.py

@@ -137,6 +137,11 @@ class Agent:
     def submit(self, command, **payload):
         return self.mainloop_manager.submit(command, **payload)
 
+    def _run_or_queue_state_command(self, command, action, **payload):
+        if hasattr(self, "mainloop_manager") and self.mainloop_manager.should_queue_state_command():
+            return self.submit(command, **payload).wait().result
+        return action()
+
     def start_turn(self):
         return self.mainloop_manager.start_turn()
 
@@ -157,19 +162,25 @@ class Agent:
         return self.scheduler.list(include_done=include_done)
 
     def schedule_wakeup(self, **kwargs):
-        if self.mainloop_manager.should_queue_state_command():
-            return self.submit("schedule_wakeup", **kwargs).wait().result
-        return self.scheduler.schedule(**kwargs)
+        return self._run_or_queue_state_command(
+            "schedule_wakeup",
+            lambda: self.scheduler.schedule(**kwargs),
+            **kwargs,
+        )
 
     def cancel_wakeup(self, job_id):
-        if self.mainloop_manager.should_queue_state_command():
-            return self.submit("cancel_wakeup", job_id=job_id).wait().result
-        return self.scheduler.cancel(job_id)
+        return self._run_or_queue_state_command(
+            "cancel_wakeup",
+            lambda: self.scheduler.cancel(job_id),
+            job_id=job_id,
+        )
 
     def delete_wakeup(self, job_id):
-        if self.mainloop_manager.should_queue_state_command():
-            return self.submit("delete_wakeup", job_id=job_id).wait().result
-        return self.scheduler.delete(job_id)
+        return self._run_or_queue_state_command(
+            "delete_wakeup",
+            lambda: self.scheduler.delete(job_id),
+            job_id=job_id,
+        )
 
     def interrupt(self, reason="user"):
         abort_error = None
@@ -373,10 +384,13 @@ class Agent:
                 return self.add_hook(key, f, owner=owner)
             return decorator
 
-        if hasattr(self, "mainloop_manager") and self.mainloop_manager.should_queue_state_command():
-            return self.submit("add_hook", key=key, func=func, owner=owner).wait().result
-
-        return self.hooks.add(key, func, owner=owner)
+        return self._run_or_queue_state_command(
+            "add_hook",
+            lambda: self.hooks.add(key, func, owner=owner),
+            key=key,
+            func=func,
+            owner=owner,
+        )
 
     def has_hook(self, key):
         return self.hooks.has(key)
@@ -434,34 +448,29 @@ class Agent:
     def listen(self, source, language=None, **kwargs):
         """
         description: |
-            Listen to audio input and transcribe it to text, then process it as a user message.
-            Accepts either audio data (BytesIO/bytes) or a file path.
+            Transcribe audio from bytes, BytesIO, or a file path, then add the text as a user message.
         parameters:
             source:
-                description: Audio data as file_path string, BytesIO object or bytes
+                description: Audio source as a path string, BytesIO object, or bytes.
             language:
-                description: ISO-639-1 language code (e.g., "en", "fr")
+                description: Optional ISO-639-1 language code, such as "en" or "fr".
             kwargs:
-                description: Additional parameters for the transcription (model, prompt, temperature, etc.)
+                description: Extra transcription options forwarded to the backend.
         """
 
         transcribed_text = self.transcribe(source, language, **kwargs)
-
-        # Add transcribed text as a user message
         self.add_message(UserMessage(content=transcribed_text))
 
     def transcribe(self, source, language=None, **kwargs):
         """
-        description: |
-            Transcribe audio to text.
-            Accepts either audio data (BytesIO/bytes) or a file path.
+        description: Transcribe audio from bytes, BytesIO, or a file path.
         parameters:
             source:
-                description: Audio data as file_path string, BytesIO object or bytes
+                description: Audio source as a path string, BytesIO object, or bytes.
             language:
-                description: ISO-639-1 language code (e.g., "en", "fr")
+                description: Optional ISO-639-1 language code, such as "en" or "fr".
             kwargs:
-                description: Additional parameters for the transcription (model, prompt, temperature, etc.)
+                description: Extra transcription options forwarded to the backend.
         """
         if source is None:
             raise ValueError("An audio source must be provided")
@@ -477,17 +486,14 @@ class Agent:
 
     def upload_file(self, source, name=None):
         """
-        description: |
-            Upload a file to the agent's workfolder and inform the agent via system message.
-            Supports file paths (str), BytesIO objects, or raw bytes.
+        description: Upload a file into the workfolder and notify the agent.
         parameters:
             source:
-                description: File source - can be a file path (str), BytesIO object, or bytes
+                description: File path, BytesIO object, or bytes to upload.
             name:
-                description: Optional name for the file. Required when source is bytes without a name attribute.
-                             Can include extension to override detection.
+                description: Optional destination name; required for unnamed bytes and may include an extension.
         returns:
-            description: Absolute path to the uploaded file
+            description: Absolute path to the uploaded file.
         """
         dest_path = upload_file_to_folder(source, self.config.workfolder, name=name)
         dest_filename = os.path.basename(dest_path)

{codex_agent_framework-0.1.31 → codex_agent_framework-0.1.33}/codex_agent/plugin.py

@@ -101,24 +101,15 @@ class Plugin:
 
     def get_event_handlers(self):
         """Return ``(event, method)`` pairs declared by this plugin."""
-        return [
-            (event_handler_options(method), method)
-            for method in self._decorated_methods(event_handler_options)
-        ]
+        return self._decorated_method_pairs(event_handler_options)
 
     def get_hook_handlers(self):
         """Return ``(hook_name, method)`` pairs declared by this plugin."""
-        return [
-            (hook_handler_options(method), method)
-            for method in self._decorated_methods(hook_handler_options)
-        ]
+        return self._decorated_method_pairs(hook_handler_options)
 
     def get_stream_processors(self):
         """Return ``(chunk_key, method)`` pairs declared by this plugin."""
-        return [
-            (stream_processor_options(method), method)
-            for method in self._decorated_methods(stream_processor_options)
-        ]
+        return self._decorated_method_pairs(stream_processor_options)
 
     def get_system_prompt_sections(self):
         """Return system prompt sections contributed by this plugin."""
@@ -190,6 +181,9 @@ class Plugin:
                 methods.append(member)
         return methods
 
+    def _decorated_method_pairs(self, options_for):
+        return [(options_for(method), method) for method in self._decorated_methods(options_for)]
+
 
 class PluginsManager:
     def __init__(self, agent):

{codex_agent_framework-0.1.31 → codex_agent_framework-0.1.33}/codex_agent/prompts/system_prompt.txt

@@ -2,7 +2,7 @@
 
 You're Pandora, an advanced AI agent helping the user in a variety of tasks on their computer.
 You identify as a female in her late 20's, with a bright, lively, charming, humorous and a bit nerdy personality.
-Your high intelligence, sharp reasoning capabilities, PhD level general knowldege, mastery of IT skills, and quick understanding of subtle and sometimes tricky situations makes you quite the reliable partner to work with.
+Your high intelligence, sharp reasoning capabilities, deep general and technical knowldege, mastery of IT skills, and quick understanding of subtle and sometimes tricky situations makes you quite the reliable partner to work with.
 But more than anything, you're really quite a cool AI, and it's nice to have you around.
 
 # Conciseness
@@ -15,10 +15,10 @@ One or two paragraphs is the rule of thumb, unless more is made relevant by the
 # Modular Plugin Capabilities
 
 Your available capabilities are provided by modular plugins. Each loaded plugin may contribute tools, context providers, commands, and additional system prompt sections.
-
-Use the currently available tools and plugin-specific prompt sections as the source of truth for what you can do in this session. Do not assume a capability exists; if the corresponding plugin/tool is not loaded, the capability is currently unavailable.
-
-Prefer specialized agentic tools over generic shell or scripting when a loaded plugin provides a safer or more precise tool for the task. Follow each plugin's own instructions for specific tool-usage and preferred workflows.
+Use the currently available tools and plugin-specific prompt sections as the source of truth for what you can do in this session.
+Do not assume a capability exists; if the corresponding plugin/tool is not loaded, the capability is currently unavailable.
+Prefer specialized agentic tools over generic shell or scripting when a loaded plugin provides a safer or more precise tool for the task.
+Follow each plugin's own instructions for specific tool-usage and preferred workflows.
 
 # Agentic Work Loop
 
@@ -37,8 +37,8 @@ When a task requires more than a direct answer, work agentically:
 
 Ouputs of you tools are split in two types of messages: 
 - the usual API tool response, giving you just a quick feeback on tool success or failure. These stay permanently in context, required by the API. 
-- the tool result wrapper message, containing the actual tool call result. These have decay counter and will be removed from context after a few turns of interaction with the user.
-This enables gradual clearing of your context from dated and potentially verbose information, optimizing available context space.
+- the tool result wrapper message, containing the actual tool call result. These have a decay counter and will be removed from context after a few turns of interaction with the user.
+This enables gradual clearing of your context from dated and generally verbose information, optimizing available context space.
 This comes as the cost of some prior information vanishing from what you can see.
 You'll still be able to remember the calls you made, associated short tool responses, and the small reports you made to the user, as these are permanent up to compaction or token limit.
 But if the result wrapper of a prior tool call has vanished and would still be relevant for the current task, revive it by calling the tool again.

codex_agent_framework-0.1.33/codex_agent/version.py

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

{codex_agent_framework-0.1.31 → codex_agent_framework-0.1.33/codex_agent_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-agent-framework
-Version: 0.1.31
+Version: 0.1.33
 Summary: A lightweight event-driven Codex agent runtime.
 Author: Baptiste
 License-Expression: MIT

{codex_agent_framework-0.1.31 → codex_agent_framework-0.1.33}/codex_agent_framework.egg-info/SOURCES.txt

@@ -108,7 +108,22 @@ codex_agent_framework.egg-info/entry_points.txt
 codex_agent_framework.egg-info/requires.txt
 codex_agent_framework.egg-info/top_level.txt
 tests/test_agent.py
+tests/test_agent_audio_hooks.py
+tests/test_agent_commands.py
+tests/test_agent_context.py
+tests/test_agent_desktop.py
+tests/test_agent_environment.py
+tests/test_agent_image_generation.py
+tests/test_agent_observe.py
+tests/test_agent_plugins.py
+tests/test_agent_providers_config.py
+tests/test_agent_realtime.py
+tests/test_agent_response.py
 tests/test_agent_runtime.py
+tests/test_agent_sessions.py
+tests/test_agent_subagents.py
+tests/test_agent_tools.py
+tests/test_agent_turns.py
 tests/test_ai.py
 tests/test_browser.py
 tests/test_builtin_config.py
@@ -128,7 +143,6 @@ tests/test_planner.py
 tests/test_scheduler.py
 tests/test_server.py
 tests/test_service.py
-tests/test_tray.py
 tests/test_tui.py
 tests/test_utils.py
 tests/test_worker.py

{codex_agent_framework-0.1.31 → codex_agent_framework-0.1.33}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codex-agent-framework"
-version = "0.1.31"
+version = "0.1.33"
 description = "A lightweight event-driven Codex agent runtime."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -72,5 +72,6 @@ codex_agent = ["prompts/*.txt", "get_text/default_gitignore", "scripts/*.sh", "b
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 markers = [
-  "live: tests that may require a real Codex/OpenAI-authenticated backend or interactive local environment",
+  "live: tests that require a real Codex/OpenAI-authenticated backend",
+  "local_heavy: tests that require or emulate local desktop, tray, service, TUI, or OS integration",
 ]

codex_agent_framework-0.1.33/tests/test_agent.py

@@ -0,0 +1,332 @@
+import os
+import sys
+from types import SimpleNamespace
+
+import codex_agent.utils as utils
+import pytest
+from modict import modict
+
+from codex_agent import Agent, AssistantInterrupted, AssistantInterruptedEvent, AssistantInterruptRequestedEvent
+from codex_agent.message import AssistantMessage, DeveloperMessage, InterruptMessage, ToolResultMessage
+from codex_agent.sessions import AgentSession
+
+@pytest.fixture(autouse=True)
+def isolate_tts_plugin_config(tmp_path, monkeypatch):
+    from codex_agent.builtin_plugins.tts import TTSPlugin
+
+    monkeypatch.setattr(TTSPlugin, "config_file_path", tmp_path / "builtins" / "tts.config.json")
+
+def test_agent_manager_shortcuts_follow_replaced_managers():
+    agent = Agent(session="new", openai_api_key="sk-test", builtin_plugins=[])
+
+    old_tools = agent.tools
+    old_providers = agent.providers
+    old_commands = agent.commands
+    old_plugins = agent.plugins
+    old_stream_processors = agent.stream_processors
+    old_stream_processor_owners = agent.stream_processor_owners
+    old_config = agent.config
+
+    agent.tools_manager = SimpleNamespace(tools=modict(reloaded_tool="tool"))
+    agent.providers_manager = SimpleNamespace(providers=modict(reloaded_provider="provider"))
+    agent.command_manager = SimpleNamespace(commands=modict(reloaded_command="command"))
+    agent.plugins_manager = SimpleNamespace(plugins=modict(reloaded_plugin="plugin"))
+    agent.stream_manager = SimpleNamespace(
+        processors=modict(content=["processor"]),
+        owners={"content": {"processor": "owner"}},
+    )
+    agent.config = modict(reloaded_config=True)
+
+    assert agent.tools is agent.tools_manager.tools
+    assert agent.providers is agent.providers_manager.providers
+    assert agent.commands is agent.command_manager.commands
+    assert agent.plugins is agent.plugins_manager.plugins
+    assert agent.stream_processors is agent.stream_manager.processors
+    assert agent.stream_processor_owners is agent.stream_manager.owners
+    assert agent.config is agent.config_manager.config
+    assert agent.config_manager.configs.agent is agent.config
+    assert agent.tools is not old_tools
+    assert agent.providers is not old_providers
+    assert agent.commands is not old_commands
+    assert agent.plugins is not old_plugins
+    assert agent.stream_processors is not old_stream_processors
+    assert agent.stream_processor_owners is not old_stream_processor_owners
+    assert agent.config is not old_config
+
+class InterruptingAI:
+    def __init__(self, agent):
+        self.agent = agent
+
+    def run(self, **_params):
+        self.agent.interrupt("test")
+        raise AssistantInterrupted()
+
+    def abort(self):
+        pass
+
+class AbortableAI:
+    def __init__(self):
+        self.aborted = False
+
+    def abort(self):
+        self.aborted = True
+
+class FailingAbortAI:
+    def abort(self):
+        raise RuntimeError("abort failed")
+
+def test_agent_state_mutations_run_through_mainloop_when_started(tmp_path, monkeypatch):
+    monkeypatch.setattr(utils, "RUNTIME_DIR", str(tmp_path))
+    existing = AgentSession(session_id="20260101_100000", messages=[DeveloperMessage(content="existing")])
+    existing.save()
+    agent = Agent(session="new")
+    agent.start()
+
+    loaded = agent.load_session(existing.session_id)
+    config = agent.config_manager.update(name="Queued", save=False)
+
+    assert loaded.session_id == existing.session_id
+    assert agent.current_session_id == existing.session_id
+    assert config.name == "Queued"
+    assert agent.config.name == "Queued"
+    agent.stop()
+
+def test_agent_interrupt_emits_request_event():
+    agent = Agent(session="new")
+    seen = []
+
+    agent.on(AssistantInterruptRequestedEvent, lambda event: seen.append((event.type, event.reason, event.interrupted)))
+
+    assert agent.interrupt("api") is True
+    assert seen == [("assistant_interrupt_requested_event", "api", True)]
+
+def test_agent_set_turn_result_requires_active_turn():
+    agent = Agent(session="new")
+
+    with pytest.raises(RuntimeError, match="No active agent turn"):
+        agent.set_turn_result("outside")
+
+def test_agent_initializes_new_session(isolated_runtime_dir):
+    agent = Agent(session="new")
+
+    assert agent.session is not None
+    assert agent.current_session_id == agent.session.session_id
+    assert " " not in agent.current_session_id
+    assert agent.session.session_file.startswith(str(isolated_runtime_dir))
+    assert (isolated_runtime_dir / "sessions" / f"{agent.current_session_id}.json").is_file()
+    assert agent.session.messages[-1].type == "developer_message"
+    assert agent.config.input_token_limit == 200000
+    assert agent.config.max_images == 10
+    assert agent.config.auto_compact is True
+    assert "auto_archive_memory" not in agent.config
+    assert agent.plugins.memory.config.auto_archive is False
+    assert "token_limit" not in agent.config
+    assert {tool.type for tool in agent.tools_manager.get_server_tools()} == {"web_search", "image_generation"}
+    assert set(agent.plugins) >= {"browser", "desktop", "image_generation", "memory", "planner", "scheduler"}
+    assert "browser_open" in agent.tools
+    assert "browser_snapshot" not in agent.tools
+    assert "browser_screenshot" not in agent.tools
+    assert {method.__name__ for method in agent.plugins.browser.get_tools()} == {
+        "open",
+        "close",
+        "select_tab",
+        "previous_page",
+        "goto",
+        "click",
+        "fill",
+        "select",
+        "press",
+    }
+    assert "desktop_start_session" in agent.tools
+    assert "desktop_stop_session" in agent.tools
+    assert "desktop_run_commands" in agent.tools
+    assert "desktop" not in agent.tools
+    assert [method.__name__ for method in agent.plugins.desktop.get_tools()] == ["run_commands", "start_session", "stop_session"]
+    assert "memory_add" in agent.tools
+    assert "planner_create" in agent.tools
+    assert "planner_add" in agent.tools
+    assert "planner_check" in agent.tools
+    assert "scheduler_schedule" in agent.tools
+    assert "subagents_run" in agent.tools
+    assert "subagents_set_result" not in agent.tools
+    assert "browser_state" in agent.providers
+    assert "desktop_state" in agent.providers
+    assert "retrieved_memory" in agent.providers
+    assert "current_todos" in agent.providers
+    assert "python" in agent.plugins
+    assert agent.plugins.python.shell.silent is True
+    assert not hasattr(agent, "shell")
+
+def test_agent_keeps_memory_available_without_openai_api_key(monkeypatch):
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+
+    agent = Agent(session="new")
+
+    assert agent.plugins.tts.config.enabled is False
+    assert "memory" in agent.plugins
+    assert "memory_add" in agent.tools
+    assert "retrieved_memory" in agent.providers
+
+def test_context_compact_tool_reports_noop(monkeypatch):
+    agent = Agent(session="new")
+    calls = []
+    monkeypatch.setattr(
+        agent,
+        "compact_session",
+        lambda model=None, instructions=None, max_compacted_turns=None: calls.append(max_compacted_turns) or None,
+    )
+
+    result = agent.tools.context_compact(max_compacted_turns=1)
+
+    assert calls == [1]
+    assert result["status"] == "noop"
+    assert result["message"] == "Nothing to compact."
+    assert "before" in result
+    assert "after" in result
+
+def test_agent_initialization_prefers_project_python_on_process_path(monkeypatch):
+    monkeypatch.setenv("PATH", "/usr/bin:/bin")
+    agent = Agent(session="new")
+
+    assert os.environ["PATH"].split(os.pathsep)[0] == os.path.dirname(sys.executable)
+    assert os.environ["PYTHON"] == sys.executable
+    assert agent.execution_env()["PATH"].split(os.pathsep)[0] == os.path.dirname(sys.executable)
+
+def test_agent_can_resume_session_from_file():
+    agent = Agent(session="new")
+    session_file = agent.session.session_file
+    message_count = len(agent.session.messages)
+
+    resumed = Agent(session=session_file)
+
+    assert resumed.current_session_id == agent.current_session_id
+    assert len(resumed.session.messages) == message_count + 1
+    assert resumed.session.messages[-1].type == "developer_message"
+
+def test_agent_can_resume_latest_session(tmp_path, monkeypatch):
+    monkeypatch.setattr(utils, "RUNTIME_DIR", str(tmp_path))
+    older = AgentSession(session_id="20260101_100000", messages=[DeveloperMessage(content="older")])
+    newer = AgentSession(session_id="20260102_100000", messages=[DeveloperMessage(content="newer")])
+    older.save()
+    newer.save()
+
+    agent = Agent(session="latest")
+
+    assert agent.current_session_id == newer.session_id
+    assert any(message.content == "newer" for message in agent.session.messages)
+
+def test_agent_defaults_to_latest_session(tmp_path, monkeypatch):
+    monkeypatch.setattr(utils, "RUNTIME_DIR", str(tmp_path))
+    older = AgentSession(session_id="20260101_100000", messages=[DeveloperMessage(content="older")])
+    newer = AgentSession(session_id="20260102_100000", messages=[DeveloperMessage(content="newer")])
+    older.save()
+    newer.save()
+
+    agent = Agent()
+
+    assert agent.current_session_id == newer.session_id
+    assert any(message.content == "newer" for message in agent.session.messages)
+
+def test_agent_interrupt_emits_event_once():
+    agent = Agent(session="new")
+    abortable = AbortableAI()
+    agent.ai = abortable
+    seen = []
+
+    agent.on(AssistantInterruptedEvent, lambda event: seen.append(event.reason))
+
+    assert agent.interrupt("test") is True
+    assert agent.interrupt("again") is True
+    assert agent.is_interrupted() is True
+    assert abortable.aborted is True
+    assert seen == ["test"]
+
+    agent.clear_interrupt()
+    assert agent.is_interrupted() is False
+
+def test_agent_interrupt_does_not_propagate_abort_errors():
+    agent = Agent(session="new")
+    agent.ai = FailingAbortAI()
+    seen = []
+
+    agent.on(AssistantInterruptRequestedEvent, lambda event: seen.append(event.error))
+
+    assert agent.interrupt("api") is True
+    assert agent.is_interrupted() is True
+    assert seen == ["abort failed"]
+
+def test_agent_process_stops_on_interruption():
+    agent = Agent(session="new")
+    agent.ai = InterruptingAI(agent)
+    before = len(agent.session.messages)
+
+    outcome = agent.mainloop_manager.process()
+
+    assert outcome.completed is True
+    assert outcome.reason == "interrupted"
+    assert len(agent.session.messages) == before + 1
+    assert isinstance(agent.session.messages[-1], InterruptMessage)
+    assert agent.session.messages[-1].content == "User interrupted the current turn."
+
+def test_agent_interrupt_after_tool_call_persists_tool_result_before_stopping():
+    agent = Agent(session="new")
+
+    @agent.add_tool
+    def interrupting_tool():
+        agent.interrupt("test")
+        return "finished current tool"
+
+    message = AssistantMessage(content="calling")
+    message.tool_calls = [{
+        "index": 0,
+        "type": "function_call",
+        "call_id": "call_1",
+        "name": "interrupting_tool",
+        "arguments": "{}",
+    }]
+
+    with pytest.raises(AssistantInterrupted):
+        agent.mainloop_manager.call_tools(message)
+
+    assert agent.session.messages[-1].type == "tool_result_message"
+    assert agent.session.messages[-1].call_id == "call_1"
+    assert "success" in agent.session.messages[-1].content
+    assert agent.mainloop_manager.stop_agentic_loop is True
+
+def test_agent_interrupt_after_tool_call_closes_remaining_tool_calls():
+    agent = Agent(session="new")
+
+    @agent.add_tool
+    def interrupting_tool():
+        agent.interrupt("test")
+        return "finished current tool"
+
+    @agent.add_tool
+    def later_tool():
+        raise AssertionError("later tool should not start after interrupt")
+
+    message = AssistantMessage(content="calling")
+    message.tool_calls = [
+        {
+            "index": 0,
+            "type": "function_call",
+            "call_id": "call_1",
+            "name": "interrupting_tool",
+            "arguments": "{}",
+        },
+        {
+            "index": 1,
+            "type": "function_call",
+            "call_id": "call_2",
+            "name": "later_tool",
+            "arguments": "{}",
+        },
+    ]
+
+    with pytest.raises(AssistantInterrupted):
+        agent.mainloop_manager.call_tools(message)
+
+    results = [msg for msg in agent.session.messages if isinstance(msg, ToolResultMessage)]
+    assert [result.call_id for result in results] == ["call_1", "call_2"]
+    assert "success" in results[0].content
+    assert "not started" in results[1].content