agentpool 2.1.9__py3-none-any.whl → 2.2.3__py3-none-any.whl

agentpool/agents/events/event_emitter.py

@@ -8,12 +8,15 @@ from agentpool.agents.events import (
     CustomEvent,
     LocationContentItem,
     PlanUpdateEvent,
+    TextContentItem,
     ToolCallProgressEvent,
     ToolCallStartEvent,
 )
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from agentpool.agents.context import AgentContext
     from agentpool.agents.events import RichAgentStreamEvent, ToolCallContentItem
     from agentpool.resource_providers.plan_provider import PlanEntry
@@ -78,7 +81,7 @@ class StreamEventEmitter:
         title: str,
         *,
         status: Literal["pending", "in_progress", "completed", "failed"] = "in_progress",
-        items: list[ToolCallContentItem] | None = None,
+        items: Sequence[ToolCallContentItem | str] | None = None,
         replace_content: bool = False,
     ) -> None:
         """Emit a progress event.
@@ -89,12 +92,26 @@ class StreamEventEmitter:
             items: Rich content items (terminals, diffs, locations, text)
             replace_content: If True, items replace existing content instead of appending
         """
+        # Record file changes from DiffContentItem for diff/revert support
+        if self._context.pool and self._context.pool.file_ops and items:
+            from agentpool.agents.events import DiffContentItem
+
+            for item in items:
+                if isinstance(item, DiffContentItem):
+                    self._context.pool.file_ops.record_change(
+                        path=item.path,
+                        old_content=item.old_text,
+                        new_content=item.new_text,
+                        operation="create" if item.old_text is None else "write",
+                        agent_name=self._context.node_name,
+                    )
+
         event = ToolCallProgressEvent(
             tool_call_id=self._context.tool_call_id or "",
             tool_name=self._context.tool_name,
             status=status,
             title=title,
-            items=items or [],
+            items=[TextContentItem(text=i) if isinstance(i, str) else i for i in items or []],
             replace_content=replace_content,
         )
         await self._emit(event)
@@ -163,6 +180,16 @@ class StreamEventEmitter:
             new_text: New file content
             status: Current status of the edit operation
         """
+        # Record file change for diff/revert support
+        if self._context.pool and self._context.pool.file_ops:
+            self._context.pool.file_ops.record_change(
+                path=path,
+                old_content=old_text,
+                new_content=new_text,
+                operation="edit",
+                agent_name=self._context.node_name,
+            )
+
         event = ToolCallProgressEvent.file_edit(
             tool_call_id=self._context.tool_call_id or "",
             tool_name=self._context.tool_name,

agentpool/agents/events/events.py

@@ -543,6 +543,25 @@ class PlanUpdateEvent:
     """Event type identifier."""
 
 
+@dataclass(kw_only=True)
+class CompactionEvent:
+    """Event indicating context compaction is starting or completed.
+
+    This is a semantic event that consumers (ACP, OpenCode) handle differently:
+    - ACP: Converts to a text message for display
+    - OpenCode: Emits session.compacted SSE event
+    """
+
+    session_id: str
+    """The session ID being compacted."""
+    trigger: Literal["auto", "manual"] = "auto"
+    """What triggered the compaction (auto = context overflow, manual = slash command)."""
+    phase: Literal["starting", "completed"] = "starting"
+    """Current phase of compaction."""
+    event_kind: Literal["compaction"] = "compaction"
+    """Event type identifier."""
+
+
 type RichAgentStreamEvent[OutputDataT] = (
     AgentStreamEvent
     | StreamCompleteEvent[OutputDataT]
@@ -552,6 +571,7 @@ type RichAgentStreamEvent[OutputDataT] = (
     | ToolCallProgressEvent
     | ToolCallCompleteEvent
     | PlanUpdateEvent
+    | CompactionEvent
     | CustomEvent[Any]
 )
 

agentpool/agents/modes.py

@@ -0,0 +1,54 @@
+"""Mode definitions for agent behavior configuration.
+
+Modes represent switchable behaviors/configurations that agents can expose
+to clients. Each agent type can define its own mode categories.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ModeInfo:
+    """Information about a single mode option.
+
+    Represents one selectable option within a mode category.
+    """
+
+    id: str
+    """Unique identifier for this mode."""
+
+    name: str
+    """Human-readable display name."""
+
+    description: str = ""
+    """Optional description of what this mode does."""
+
+    category_id: str = ""
+    """ID of the category this mode belongs to."""
+
+
+@dataclass
+class ModeCategory:
+    """A category of modes that can be switched.
+
+    Represents a group of mutually exclusive modes. In the future,
+    ACP may support multiple categories rendered as separate dropdowns.
+
+    Examples:
+        - Permissions: default, acceptEdits
+        - Behavior: plan, code, architect
+    """
+
+    id: str
+    """Unique identifier for this category."""
+
+    name: str
+    """Human-readable display name for the category."""
+
+    available_modes: list[ModeInfo] = field(default_factory=list)
+    """List of available modes in this category."""
+
+    current_mode_id: str = ""
+    """ID of the currently active mode."""

agentpool/agents/tool_call_accumulator.py

@@ -0,0 +1,213 @@
+"""Tool call accumulator for streaming tool arguments.
+
+This module provides utilities for accumulating streamed tool call arguments
+from LLM APIs that stream JSON arguments incrementally (like Anthropic's
+input_json_delta or OpenAI's function call streaming).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import anyenv
+
+
+def repair_partial_json(buffer: str) -> str:
+    """Attempt to repair truncated JSON for preview purposes.
+
+    Handles common truncation cases:
+    - Unclosed strings
+    - Missing closing braces/brackets
+    - Trailing commas
+
+    Args:
+        buffer: Potentially incomplete JSON string
+
+    Returns:
+        Repaired JSON string (may still be invalid in edge cases)
+    """
+    if not buffer:
+        return "{}"
+
+    result = buffer.rstrip()
+
+    # Check if we're in the middle of a string by counting unescaped quotes
+    in_string = False
+    i = 0
+    while i < len(result):
+        char = result[i]
+        if char == "\\" and i + 1 < len(result):
+            i += 2  # Skip escaped character
+            continue
+        if char == '"':
+            in_string = not in_string
+        i += 1
+
+    # Close unclosed string
+    if in_string:
+        result += '"'
+
+    # Remove trailing comma (invalid JSON)
+    result = result.rstrip()
+    if result.endswith(","):
+        result = result[:-1]
+
+    # Balance braces and brackets
+    open_braces = result.count("{") - result.count("}")
+    open_brackets = result.count("[") - result.count("]")
+
+    result += "]" * max(0, open_brackets)
+    result += "}" * max(0, open_braces)
+
+    return result
+
+
+class ToolCallAccumulator:
+    """Accumulates streamed tool call arguments.
+
+    LLM APIs stream tool call arguments as deltas. This class accumulates them
+    and provides the complete arguments when the tool call ends, as well as
+    best-effort partial argument parsing during streaming.
+
+    Example:
+        ```python
+        accumulator = ToolCallAccumulator()
+
+        # On content_block_start with tool_use
+        accumulator.start("toolu_123", "write_file")
+
+        # On input_json_delta events
+        accumulator.add_args("toolu_123", '{"path": "/tmp/')
+        accumulator.add_args("toolu_123", 'test.txt", "content"')
+        accumulator.add_args("toolu_123", ': "hello"}')
+
+        # Get partial args for UI preview (repairs incomplete JSON)
+        partial = accumulator.get_partial_args("toolu_123")
+
+        # On content_block_stop, get final parsed args
+        name, args = accumulator.complete("toolu_123")
+        ```
+    """
+
+    def __init__(self) -> None:
+        self._calls: dict[str, dict[str, Any]] = {}
+
+    def start(self, tool_call_id: str, tool_name: str) -> None:
+        """Start tracking a new tool call.
+
+        Args:
+            tool_call_id: Unique identifier for the tool call
+            tool_name: Name of the tool being called
+        """
+        self._calls[tool_call_id] = {"name": tool_name, "args_buffer": ""}
+
+    def add_args(self, tool_call_id: str, delta: str) -> None:
+        """Add argument delta to a tool call.
+
+        Args:
+            tool_call_id: Tool call identifier
+            delta: JSON string fragment to append
+        """
+        if tool_call_id in self._calls:
+            self._calls[tool_call_id]["args_buffer"] += delta
+
+    def complete(self, tool_call_id: str) -> tuple[str, dict[str, Any]] | None:
+        """Complete a tool call and return (tool_name, parsed_args).
+
+        Removes the tool call from tracking and returns the final parsed arguments.
+
+        Args:
+            tool_call_id: Tool call identifier
+
+        Returns:
+            Tuple of (tool_name, args_dict) or None if call not found
+        """
+        if tool_call_id not in self._calls:
+            return None
+
+        call_data = self._calls.pop(tool_call_id)
+        args_str = call_data["args_buffer"]
+        try:
+            args = anyenv.load_json(args_str) if args_str else {}
+        except anyenv.JsonLoadError:
+            args = {"_raw": args_str}
+        return call_data["name"], args
+
+    def get_pending(self, tool_call_id: str) -> tuple[str, str] | None:
+        """Get pending call data (tool_name, args_buffer) without completing.
+
+        Args:
+            tool_call_id: Tool call identifier
+
+        Returns:
+            Tuple of (tool_name, args_buffer) or None if not found
+        """
+        if tool_call_id not in self._calls:
+            return None
+        data = self._calls[tool_call_id]
+        return data["name"], data["args_buffer"]
+
+    def get_partial_args(self, tool_call_id: str) -> dict[str, Any]:
+        """Get best-effort parsed args from incomplete JSON stream.
+
+        Uses heuristics to complete truncated JSON for preview purposes.
+        Handles unclosed strings, missing braces/brackets, and trailing commas.
+
+        Args:
+            tool_call_id: Tool call ID
+
+        Returns:
+            Partially parsed arguments or empty dict
+        """
+        if tool_call_id not in self._calls:
+            return {}
+
+        buffer = self._calls[tool_call_id]["args_buffer"]
+        if not buffer:
+            return {}
+
+        # Try direct parse first
+        try:
+            result: dict[str, Any] = anyenv.load_json(buffer)
+        except anyenv.JsonLoadError:
+            pass
+        else:
+            return result
+
+        # Try to repair truncated JSON
+        try:
+            repaired = repair_partial_json(buffer)
+            result = anyenv.load_json(repaired)
+        except anyenv.JsonLoadError:
+            return {}
+        else:
+            return result
+
+    def is_pending(self, tool_call_id: str) -> bool:
+        """Check if a tool call is being tracked.
+
+        Args:
+            tool_call_id: Tool call identifier
+
+        Returns:
+            True if the tool call is being accumulated
+        """
+        return tool_call_id in self._calls
+
+    def get_tool_name(self, tool_call_id: str) -> str | None:
+        """Get the tool name for a pending call.
+
+        Args:
+            tool_call_id: Tool call identifier
+
+        Returns:
+            Tool name or None if not found
+        """
+        if tool_call_id not in self._calls:
+            return None
+        name: str = self._calls[tool_call_id]["name"]
+        return name
+
+    def clear(self) -> None:
+        """Clear all pending tool calls."""
+        self._calls.clear()

agentpool/common_types.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -50,6 +51,26 @@ type JsonObject = dict[str, JsonValue]
 type JsonArray = list[JsonValue]
 
 
+MCPConnectionStatus = Literal["connected", "disconnected", "error"]
+
+
+@dataclass(frozen=True, slots=True)
+class MCPServerStatus:
+    """Status information for an MCP server.
+
+    Attributes:
+        name: Server name/identifier
+        status: Connection status
+        server_type: Transport type (stdio, sse, http)
+        error: Error message if status is "error"
+    """
+
+    name: str
+    status: MCPConnectionStatus
+    server_type: str = "unknown"
+    error: str | None = None
+
+
 NodeName = str
 TeamName = str
 AgentName = str

agentpool/config_resources/__init__.py

@@ -7,10 +7,47 @@ from typing import Final
 
 _RESOURCES = importlib.resources.files("agentpool.config_resources")
 
+# Template configuration
 AGENTS_TEMPLATE: Final[str] = str(_RESOURCES / "agents_template.yml")
 """Path to the agents template configuration."""
 
+# Pool configurations
 ACP_ASSISTANT: Final[str] = str(_RESOURCES / "acp_assistant.yml")
 """Path to default ACP assistant configuration."""
 
-__all__ = ["ACP_ASSISTANT", "AGENTS_TEMPLATE"]
+AGENTS: Final[str] = str(_RESOURCES / "agents.yml")
+"""Path to the main agents configuration."""
+
+AGUI_TEST: Final[str] = str(_RESOURCES / "agui_test.yml")
+"""Path to AGUI test configuration."""
+
+CLAUDE_CODE_ASSISTANT: Final[str] = str(_RESOURCES / "claude_code_agent.yml")
+"""Path to default Claude code assistant configuration."""
+
+EXTERNAL_ACP_AGENTS: Final[str] = str(_RESOURCES / "external_acp_agents.yml")
+"""Path to external ACP agents configuration."""
+
+TTS_TEST_AGENTS: Final[str] = str(_RESOURCES / "tts_test_agents.yml")
+"""Path to TTS test agents configuration."""
+
+# All pool configuration paths for validation
+ALL_POOL_CONFIGS: Final[tuple[str, ...]] = (
+    ACP_ASSISTANT,
+    AGENTS,
+    AGUI_TEST,
+    CLAUDE_CODE_ASSISTANT,
+    EXTERNAL_ACP_AGENTS,
+    TTS_TEST_AGENTS,
+)
+"""All pool configuration file paths."""
+
+__all__ = [
+    "ACP_ASSISTANT",
+    "AGENTS",
+    "AGENTS_TEMPLATE",
+    "AGUI_TEST",
+    "ALL_POOL_CONFIGS",
+    "CLAUDE_CODE_ASSISTANT",
+    "EXTERNAL_ACP_AGENTS",
+    "TTS_TEST_AGENTS",
+]

agentpool/config_resources/claude_code_agent.yml

@@ -7,10 +7,13 @@ agents:
     type: claude_code
     display_name: "AI Assistant"
     builtin_tools: []
+    env:
+      ANTHROPIC_API_KEY: ""
     description: "Claude code agent with enhanced tools"
     toolsets:
       - type: execution
       - type: file_access
+        edit_tool: batch
       - type: code
       - type: search
       - type: plan

agentpool/delegation/pool.py

@@ -40,7 +40,6 @@ if TYPE_CHECKING:
     from pydantic_ai import ModelSettings
     from pydantic_ai.models import Model
     from pydantic_ai.output import OutputSpec
-    from tokonomics.model_names import ModelId
     from upathtools import JoinablePathLike
 
     from agentpool.agents.acp_agent import ACPAgent
@@ -57,6 +56,7 @@ if TYPE_CHECKING:
     )
     from agentpool.delegation.base_team import BaseTeam
     from agentpool.mcp_server.tool_bridge import ToolManagerBridge
+    from agentpool.messaging.compaction import CompactionPipeline
     from agentpool.models import (
         AGUIAgentConfig,
         AnyAgentConfig,
@@ -118,6 +118,7 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         from agentpool.sessions import SessionManager
         from agentpool.skills.manager import SkillsManager
         from agentpool.storage import StorageManager
+        from agentpool.utils.streams import FileOpsTracker, TodoTracker
 
         match manifest:
             case None:
@@ -131,6 +132,12 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
                 raise ValueError(msg)
 
         registry.configure_observability(self.manifest.observability)
+
+        # Install memory log handler early so all logs are captured
+        from agentpool_toolsets.builtin.debug import install_memory_handler
+
+        self._memory_log_handler = install_memory_handler()
+
         self.shared_deps_type = shared_deps_type
         self._input_provider = input_provider
         self.exit_stack = AsyncExitStack()
@@ -150,14 +157,12 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             self._tasks.register(name, task)
         self.process_manager = ProcessManager()
         self.pool_talk = TeamTalk[Any].from_nodes(list(self.nodes.values()))
-
+        self.file_ops = FileOpsTracker()
+        # Todo/plan tracker for task management
+        self.todos = TodoTracker()
         # Create all agents from unified manifest.agents dict
         for name, config in self.manifest.agents.items():
-            agent = self._create_agent_from_config(
-                name,
-                config,
-                deps_type=shared_deps_type,
-            )
+            agent = self._create_agent_from_config(name, config, deps_type=shared_deps_type)
             agent.agent_pool = self
             self.register(name, agent)
 
@@ -179,32 +184,23 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
                 await self.exit_stack.enter_async_context(self.mcp)
                 await self.exit_stack.enter_async_context(self.skills)
                 aggregating_provider = self.mcp.get_aggregating_provider()
-                agents = list(self.agents.values())
-                acp_agents = list(self.acp_agents.values())
-                agui_agents = list(self.agui_agents.values())
-                claude_code_agents = list(self.claude_code_agents.values())
+                agents = list(self.all_agents.values())
                 teams = list(self.teams.values())
                 for agent in agents:
                     agent.tools.add_provider(aggregating_provider)
                 # Collect remaining components to initialize (MCP already initialized)
-                components: list[AbstractAsyncContextManager[Any]] = [
+                comps: list[AbstractAsyncContextManager[Any]] = [
                     self.storage,
                     self.sessions,
                     *agents,
-                    *acp_agents,
-                    *agui_agents,
-                    *claude_code_agents,
                     *teams,
                 ]
-                # MCP server is now managed externally - removed from pool
-                # Initialize all components
+                node_inits = [self.exit_stack.enter_async_context(c) for c in comps]
                 if self.parallel_load:
-                    await asyncio.gather(
-                        *(self.exit_stack.enter_async_context(c) for c in components)
-                    )
+                    await asyncio.gather(*node_inits)
                 else:
-                    for component in components:
-                        await self.exit_stack.enter_async_context(component)
+                    for init in node_inits:
+                        await init
 
             except Exception as e:
                 await self.cleanup()
@@ -538,6 +534,15 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
 
         return {i.name: i for i in self._items.values() if isinstance(i, MessageNode)}
 
+    @property
+    def compaction_pipeline(self) -> CompactionPipeline | None:
+        """Get the configured compaction pipeline for message history management.
+
+        Returns:
+            CompactionPipeline instance or None if not configured
+        """
+        return self.manifest.get_compaction_pipeline()
+
     def _validate_item(self, item: MessageNode[Any, Any] | Any) -> MessageNode[Any, Any]:
         """Validate and convert items before registration.
 
@@ -639,7 +644,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         agent: AgentName | Agent[Any, str],
         *,
         return_type: type[TResult] = str,  # type: ignore
-        model_override: ModelId | str | None = None,
         session: SessionIdType | SessionQuery = None,
     ) -> Agent[TPoolDeps, TResult]: ...
 
@@ -650,7 +654,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         *,
         deps_type: type[TCustomDeps],
         return_type: type[TResult] = str,  # type: ignore
-        model_override: ModelId | str | None = None,
         session: SessionIdType | SessionQuery = None,
     ) -> Agent[TCustomDeps, TResult]: ...
 
@@ -660,7 +663,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         *,
         deps_type: Any | None = None,
         return_type: Any = str,
-        model_override: ModelId | str | None = None,
         session: SessionIdType | SessionQuery = None,
     ) -> Agent[Any, Any]:
         """Get or configure an agent from the pool.
@@ -673,7 +675,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             agent: Either agent name or instance
             deps_type: Optional custom dependencies type (overrides shared deps)
             return_type: Optional type for structured responses
-            model_override: Optional model override
             session: Optional session ID or query to recover conversation
 
         Returns:
@@ -684,6 +685,10 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         Raises:
             KeyError: If agent name not found
             ValueError: If configuration is invalid
+
+        Note:
+            To change the model, call `await agent.set_model(model_id)` after
+            getting the agent.
         """
         from agentpool.agents import Agent
 
@@ -692,8 +697,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         # base.context.data = deps if deps is not None else self.shared_deps
         base.deps_type = deps_type
         base.agent_pool = self
-        if model_override:
-            base.set_model(model_override)
         if session:
             base.conversation.load_history_from_database(session=session)
         if return_type not in {str, None}:
@@ -987,6 +990,9 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             case _:
                 model = None
                 model_settings = None
+        # Extract pydantic-ai builtin tools from config
+        builtin_tools = config.get_builtin_tools()
+
         return Agent(
             # context=context,
             model=model,
@@ -1009,9 +1015,11 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             tool_mode=config.tool_mode,
             knowledge=config.knowledge,
             toolsets=toolsets_list,
-            auto_cache=config.auto_cache,
             hooks=config.hooks.get_agent_hooks() if config.hooks else None,
             tool_confirmation_mode=config.requires_tool_confirmation,
+            builtin_tools=builtin_tools or None,
+            usage_limits=config.usage_limits,
+            providers=config.model_providers,
         )
 
     def create_acp_agent[TDeps](

agentpool/delegation/team.py

@@ -176,6 +176,7 @@ class Team[TDeps = None](BaseTeam[TDeps, Any]):
             name=self.name,
             message_id=message_id,
             conversation_id=user_msg.conversation_id,
+            parent_id=user_msg.message_id,
             metadata={
                 "agent_names": [r.agent_name for r in result],
                 "errors": {name: str(error) for name, error in result.errors.items()},

agentpool/delegation/teamrun.py

@@ -172,6 +172,7 @@ class TeamRun[TDeps, TResult](BaseTeam[TDeps, TResult]):
             associated_messages=all_messages,
             message_id=message_id,
             conversation_id=user_msg.conversation_id,
+            parent_id=user_msg.message_id,
             metadata={
                 "execution_order": [r.agent_name for r in result],
                 "start_time": result.start_time.isoformat(),