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

agentpool_config/resources.py

@@ -1,33 +0,0 @@
-"""Models for resource information."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Self
-
-
-if TYPE_CHECKING:
-    from mcp.types import Resource as MCPResource
-
-
-@dataclass
-class ResourceInfo:
-    """Information about an available resource.
-
-    This class provides essential information about a resource that can be loaded.
-    Use the resource name with load_resource() to access the actual content.
-    """
-
-    name: str
-    """Name of the resource, use this with load_resource()"""
-
-    uri: str
-    """URI identifying the resource location"""
-
-    description: str | None = None
-    """Optional description of the resource's content or purpose"""
-
-    @classmethod
-    async def from_mcp_resource(cls, resource: MCPResource) -> Self:
-        """Create ResourceInfo from MCP resource."""
-        return cls(name=resource.name, uri=str(resource.uri), description=resource.description)

agentpool_server/acp_server/acp_tools.py

@@ -1,43 +0,0 @@
-"""ACP resource providers."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from exxec.acp_provider import ACPExecutionEnvironment
-
-from agentpool.resource_providers import PlanProvider
-from agentpool_toolsets.builtin import CodeTools, ExecutionEnvironmentTools
-from agentpool_toolsets.fsspec_toolset import FSSpecTools
-
-
-if TYPE_CHECKING:
-    from agentpool.resource_providers.aggregating import AggregatingResourceProvider
-    from agentpool_server.acp_server.session import ACPSession
-
-
-def get_acp_provider(session: ACPSession) -> AggregatingResourceProvider:
-    """Create aggregated resource provider with ACP-specific toolsets.
-
-    Args:
-        session: The ACP session to create providers for
-
-    Returns:
-        AggregatingResourceProvider with execution, filesystem, and code tools
-    """
-    from agentpool.resource_providers.aggregating import AggregatingResourceProvider
-
-    execution_env = ACPExecutionEnvironment(
-        fs=session.fs, requests=session.requests, cwd=session.cwd
-    )
-
-    providers = [
-        PlanProvider(),
-        ExecutionEnvironmentTools(env=execution_env, name=f"acp_execution_{session.session_id}"),
-        FSSpecTools(execution_env, name=f"acp_fs_{session.session_id}", cwd=session.cwd),
-        CodeTools(execution_env, name=f"acp_code_{session.session_id}", cwd=session.cwd),
-    ]
-    return AggregatingResourceProvider(providers=providers, name=f"acp_{session.session_id}")
-
-
-__all__ = ["get_acp_provider"]

agentpool_server/acp_server/commands/spawn.py

@@ -1,210 +0,0 @@
-"""Spawn subagent slash command."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-import uuid
-
-from pydantic_ai import (
-    FinalResultEvent,
-    FunctionToolCallEvent,
-    FunctionToolResultEvent,
-    PartDeltaEvent,
-    PartStartEvent,
-    RetryPromptPart,
-    TextPart,
-    TextPartDelta,
-    ThinkingPart,
-    ThinkingPartDelta,
-    ToolCallPartDelta,
-    ToolReturnPart,
-)
-from slashed import CommandContext, CommandError  # noqa: TC002
-
-from agentpool.agents.events import StreamCompleteEvent, ToolCallProgressEvent
-from agentpool.log import get_logger
-from agentpool.messaging.context import NodeContext  # noqa: TC001
-from agentpool_commands.base import NodeCommand
-from agentpool_server.acp_server.session import ACPSession  # noqa: TC001
-
-
-if TYPE_CHECKING:
-    from agentpool.agents.events import RichAgentStreamEvent
-
-
-logger = get_logger(__name__)
-
-
-class SpawnSubagentCommand(NodeCommand):
-    """Spawn a subagent to execute a specific task.
-
-    The subagent runs concurrently and reports progress in a dedicated tool call box.
-
-    Usage:
-      /spawn "agent-name" "prompt for the subagent"
-      /spawn "code-reviewer" "Review the main.py file for potential bugs"
-    """
-
-    name = "spawn"
-    category = "agents"
-
-    async def execute_command(
-        self,
-        ctx: CommandContext[NodeContext[ACPSession]],
-        agent_name: str,
-        task_prompt: str,
-    ) -> None:
-        """Spawn a subagent to execute a task.
-
-        Args:
-            ctx: Command context with ACP session
-            agent_name: Name of the agent to spawn
-            task_prompt: Task prompt for the subagent
-        """
-        session = ctx.context.data
-        assert session, "ACP session required for spawn command"
-        # Generate unique tool call ID
-        tool_call_id = f"spawn-{agent_name}-{uuid.uuid4().hex[:8]}"
-        try:
-            # Check if agent exists in pool
-            if not session.agent_pool or agent_name not in session.agent_pool.agents:
-                available = list(session.agent_pool.agents.keys())
-                error_msg = f"Agent {agent_name!r} not found. Available agents: {available}"
-                await ctx.print(f"❌ {error_msg}")
-                return
-
-            target_agent = session.agent_pool.get_agent(agent_name)
-            await session.notifications.tool_call_start(
-                tool_call_id=tool_call_id,
-                title=f"Spawning agent: {agent_name}",
-                kind="execute",
-                raw_input={
-                    "agent_name": agent_name,
-                    "task_prompt": task_prompt,
-                },
-            )
-
-            aggregated_content: list[str] = []  # Aggregate output as we stream
-            try:
-                # Run the subagent and handle events
-                async for event in target_agent.run_stream(task_prompt):
-                    await _handle_subagent_event(event, tool_call_id, aggregated_content, session)
-
-                final_content = "".join(aggregated_content).strip()
-                await session.notifications.tool_call_progress(
-                    tool_call_id=tool_call_id,
-                    status="completed",
-                    content=[final_content] if final_content else None,
-                )
-            except Exception as e:
-                error_msg = f"Subagent execution failed: {e}"
-                logger.exception("Subagent execution error", error=str(e))
-                await session.notifications.tool_call_progress(
-                    tool_call_id=tool_call_id,
-                    status="failed",
-                    raw_output=error_msg,
-                )
-
-        except Exception as e:
-            error_msg = f"Failed to spawn agent '{agent_name}': {e}"
-            logger.exception("Spawn command error", error=str(e))
-            raise CommandError(error_msg) from e
-
-
-async def _handle_subagent_event(
-    event: RichAgentStreamEvent[Any],
-    tool_call_id: str,
-    aggregated_content: list[str],
-    session: ACPSession,
-) -> None:
-    """Handle events from spawned subagent and convert to tool_call_progress.
-
-    Args:
-        event: Event from the subagent stream
-        tool_call_id: ID of the tool call box
-        aggregated_content: List to accumulate content for final display
-        session: ACP session for notifications
-    """
-    match event:
-        case (
-            PartStartEvent(part=TextPart(content=delta))
-            | PartDeltaEvent(delta=TextPartDelta(content_delta=delta))
-        ):
-            # Subagent text output → accumulate and update progress
-            aggregated_content.append(delta)
-            await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
-                status="in_progress",
-                content=["".join(aggregated_content)],
-            )
-
-        case (
-            PartStartEvent(part=ThinkingPart(content=delta))
-            | PartDeltaEvent(delta=ThinkingPartDelta(content_delta=delta))
-        ):
-            # Subagent thinking → show thinking indicator
-            if delta:
-                thinking_text = f"💭 {delta}"
-                aggregated_content.append(thinking_text)
-                await session.notifications.tool_call_progress(
-                    tool_call_id=tool_call_id,
-                    status="in_progress",
-                    content=["".join(aggregated_content)],
-                )
-
-        case FunctionToolCallEvent(part=part):
-            # Subagent calls a tool → show nested tool call
-            tool_text = f"\n🔧 Using tool: {part.tool_name}\n"
-            aggregated_content.append(tool_text)
-            await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
-                status="in_progress",
-                content=["".join(aggregated_content)],
-            )
-
-        case FunctionToolResultEvent(
-            result=ToolReturnPart(content=content, tool_name=tool_name),
-        ):
-            # Subagent tool completes → show tool result
-            result_text = f"✅ {tool_name}: {content}\n"
-            aggregated_content.append(result_text)
-            await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
-                status="in_progress",
-                content=["".join(aggregated_content)],
-            )
-
-        case FunctionToolResultEvent(
-            result=RetryPromptPart(tool_name=tool_name) as result,
-        ):
-            # Tool call failed and needs retry
-            error_message = result.model_response()
-            error_text = f"❌ {tool_name or 'unknown'}: Error: {error_message}\n"
-            aggregated_content.append(error_text)
-            await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
-                status="in_progress",
-                content=["".join(aggregated_content)],
-            )
-
-        case ToolCallProgressEvent(message=message, tool_name=tool_name):
-            # Progress event from tools
-            if message:
-                progress_text = f"🔄 {tool_name}: {message}\n"
-                aggregated_content.append(progress_text)
-                await session.notifications.tool_call_progress(
-                    tool_call_id=tool_call_id,
-                    status="in_progress",
-                    content=["".join(aggregated_content)],
-                )
-
-        case (
-            PartStartEvent()
-            | PartDeltaEvent(delta=ToolCallPartDelta())
-            | FinalResultEvent()
-            | StreamCompleteEvent()
-        ):
-            pass  # These events don't need special handling
-
-        case _:
-            logger.debug("Unhandled subagent event", event_type=type(event).__name__)

agentpool_storage/text_log_provider.py

@@ -1,275 +0,0 @@
-"""Text-based storage provider with dynamic paths."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, ClassVar
-
-from upathtools import to_upath
-
-from agentpool.log import get_logger
-from agentpool.utils.now import get_now
-from agentpool_storage.base import StorageProvider
-
-
-if TYPE_CHECKING:
-    from datetime import datetime
-
-    from jinja2 import Template
-    from upathtools import JoinablePathLike, UPath
-
-    from agentpool.common_types import JsonValue
-    from agentpool_config.storage import LogFormat, TextLogConfig
-
-
-logger = get_logger(__name__)
-
-
-CONVERSATIONS_TEMPLATE = """\
-=== AgentPool Log ===
-
-{%- for conv_id, conv in conversations.items() %}
-=== Conversation {{ conv_id }} (agent: {{ conv.agent_name }}, started: {{ conv.start_time.strftime('%Y-%m-%d %H:%M:%S') }}) ===
-
-{%- for msg in messages if msg.conversation_id == conv_id %}
-[{{ msg.timestamp.strftime('%Y-%m-%d %H:%M:%S') }}] {{ msg.sender }}{% if msg.model %} ({{ msg.model }}){% endif %}: {{ msg.content }}
-{%- if msg.cost_info %}
-Tokens: {{ msg.cost_info.token_usage.total }} (prompt: {{ msg.cost_info.token_usage.prompt }}, completion: {{ msg.cost_info.token_usage.completion }})
-Cost: ${{ "%.4f"|format(msg.cost_info.total_cost) }}
-{%- endif %}
-{%- if msg.response_time %}
-Response time: {{ "%.1f"|format(msg.response_time) }}s
-{%- endif %}
-{%- if msg.forwarded_from %}
-Forwarded via: {{ msg.forwarded_from|join(' -> ') }}
-{%- endif %}
-
-{%- for tool in tool_calls if tool.message_id == msg.id %}
-Tool Call: {{ tool.tool_name }}
-Args: {{ tool.args|pprint }}
-Result: {{ tool.result }}
-{%- endfor %}
-{%- endfor %}
-{%- endfor %}
-
-=== Commands ===
-{%- for cmd in commands %}
-[{{ cmd.timestamp.strftime('%Y-%m-%d %H:%M:%S') }}] {{ cmd.agent_name }} ({{ cmd.session_id }}): {{ cmd.command }}
-{%- endfor %}
-"""  # noqa: E501
-
-CHRONOLOGICAL_TEMPLATE = """\
-=== AgentPool Log ===
-
-{%- for entry in entries|sort(attribute="timestamp") %}
-{%- if entry.type == "conversation_start" %}
-=== Conversation {{ entry.conversation_id }} (agent: {{ entry.agent_name }}) started ===
-
-{%- elif entry.type == "message" %}
-[{{ entry.timestamp.strftime('%Y-%m-%d %H:%M:%S') }}] {{ entry.sender }}{% if entry.model %} ({{ entry.model }}){% endif %}: {{ entry.content }}
-{%- if entry.cost_info %}
-Tokens: {{ entry.cost_info.token_usage.total }} (prompt: {{ entry.cost_info.token_usage.prompt }}, completion: {{ entry.cost_info.token_usage.completion }})
-Cost: ${{ "%.4f"|format(entry.cost_info.total_cost) }}
-{%- endif %}
-{%- if entry.response_time %}
-Response time: {{ "%.1f"|format(entry.response_time) }}s
-{%- endif %}
-{%- if entry.forwarded_from %}
-Forwarded via: {{ entry.forwarded_from|join(' -> ') }}
-{%- endif %}
-
-{%- elif entry.type == "tool_call" %}
-[{{ entry.timestamp.strftime('%Y-%m-%d %H:%M:%S') }}] Tool Call: {{ entry.tool_name }}
-Args: {{ entry.args|pprint }}
-Result: {{ entry.result }}
-
-{%- elif entry.type == "command" %}
-[{{ entry.timestamp.strftime('%Y-%m-%d %H:%M:%S') }}] Command by {{ entry.agent_name }}: {{ entry.command }}
-
-{%- endif %}
-{%- endfor %}
-"""  # noqa: E501
-
-
-class TextLogProvider(StorageProvider):
-    """Human-readable text log provider with dynamic paths.
-
-    Available template variables:
-    - now: datetime - Current timestamp
-    - date: date - Current date
-    - operation: str - Type of operation (message/conversation/tool_call/command)
-    - conversation_id: str - ID of current conversation
-    - agent_name: str - Name of the agent
-    - content: str - Message content
-    - role: str - Message role
-    - model: str - Model name
-    - session_id: str - Session ID
-    - tool_name: str - Name of tool being called
-    - command: str - Command being executed
-
-    All variables default to empty string if not available for current operation.
-    """
-
-    TEMPLATES: ClassVar[dict[LogFormat, str]] = {
-        "chronological": CHRONOLOGICAL_TEMPLATE,
-        "conversations": CONVERSATIONS_TEMPLATE,
-    }
-    can_load_history = False
-
-    def __init__(self, config: TextLogConfig) -> None:
-        """Initialize text log provider."""
-        from jinja2 import Environment, Undefined
-
-        class EmptyStringUndefined(Undefined):
-            """Return empty string for undefined variables."""
-
-            def __str__(self) -> str:
-                return ""
-
-        super().__init__(config)
-        self.encoding = config.encoding
-        self.content_template = self._load_template(config.template)
-        # Configure Jinja env with empty string for undefined
-        env = Environment(undefined=EmptyStringUndefined, enable_async=True)
-        self.path_template = env.from_string(config.path)
-
-        self._entries: list[dict[str, Any]] = []
-
-    def _load_template(
-        self,
-        template: LogFormat | JoinablePathLike | None,
-    ) -> Template:
-        """Load template from predefined or file."""
-        from jinja2 import Template
-
-        if template is None:
-            template_str = self.TEMPLATES["chronological"]
-        elif template in self.TEMPLATES:
-            template_str = self.TEMPLATES[template]  # type: ignore
-        else:  # Assume it's a path
-            template_str = to_upath(template).read_text()
-        return Template(template_str)
-
-    def _get_base_context(self, operation: str) -> dict[str, Any]:
-        """Get base context with defaults.
-
-        Args:
-            operation: Type of operation being logged
-
-        Returns:
-            Base context dict with defaults
-        """
-        # All other variables will default to empty string via EmptyStringUndefined
-        return {"now": get_now(), "date": get_now().date(), "operation": operation}
-
-    async def _get_path(self, operation: str, **context: Any) -> UPath:
-        """Render path template with context.
-
-        Args:
-            operation: Type of operation being logged
-            **context: Additional context variables
-
-        Returns:
-            Concrete path for current operation
-        """
-        # Combine base context with provided values
-        path_context = self._get_base_context(operation)
-        path_context.update(context)
-
-        path = await self.path_template.render_async(**path_context)
-        resolved_path = to_upath(path)
-        resolved_path.parent.mkdir(parents=True, exist_ok=True)
-        return resolved_path
-
-    async def log_message(
-        self,
-        *,
-        conversation_id: str,
-        message_id: str,
-        content: str,
-        role: str,
-        name: str | None = None,
-        cost_info: Any | None = None,
-        model: str | None = None,
-        response_time: float | None = None,
-        forwarded_from: list[str] | None = None,
-        provider_name: str | None = None,
-        provider_response_id: str | None = None,
-        messages: str | None = None,
-        finish_reason: str | None = None,
-    ) -> None:
-        """Store message and update log."""
-        entry = {
-            "type": "message",
-            "timestamp": get_now(),
-            "conversation_id": conversation_id,
-            "message_id": message_id,
-            "content": content,
-            "role": role,
-            "agent_name": name,
-            "model": model,
-            "cost_info": cost_info,
-            "response_time": response_time,
-            "forwarded_from": forwarded_from,
-            "provider_name": provider_name,
-            "provider_response_id": provider_response_id,
-            "messages": messages,
-            "finish_reason": finish_reason,
-        }
-        self._entries.append(entry)
-
-        path = await self._get_path("message", **entry)
-        self._write(path)
-
-    async def log_conversation(
-        self,
-        *,
-        conversation_id: str,
-        node_name: str,
-        start_time: datetime | None = None,
-    ) -> None:
-        """Store conversation start."""
-        entry = {
-            "type": "conversation",
-            "timestamp": start_time or get_now(),
-            "conversation_id": conversation_id,
-            "agent_name": node_name,
-        }
-        self._entries.append(entry)
-
-        path = await self._get_path("conversation", **entry)
-        self._write(path)
-
-    async def log_command(
-        self,
-        *,
-        agent_name: str,
-        session_id: str,
-        command: str,
-        context_type: type | None = None,
-        metadata: dict[str, JsonValue] | None = None,
-    ) -> None:
-        """Store command."""
-        entry = {
-            "type": "command",
-            "timestamp": get_now(),
-            "agent_name": agent_name,
-            "session_id": session_id,
-            "command": command,
-            "context_type": context_type.__name__ if context_type else "",
-            "metadata": metadata or {},
-        }
-        self._entries.append(entry)
-
-        path = await self._get_path("command", **entry)
-        self._write(path)
-
-    def _write(self, path: UPath) -> None:
-        """Write current state to file at given path."""
-        context = {"entries": self._entries}
-        try:
-            text = self.content_template.render(context)
-            path.write_text(text, encoding=self.encoding)
-        except Exception as e:
-            logger.exception("Failed to write to log file", path=path)
-            msg = f"Failed to write to log file: {e}"
-            raise RuntimeError(msg) from e