agentpool 2.1.9__py3-none-any.whl

agentpool_storage/text_log_provider.py

@@ -0,0 +1,275 @@
+"""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

agentpool_toolsets/__init__.py

@@ -0,0 +1,15 @@
+"""Toolsets package."""
+
+from agentpool_toolsets.config_creation import ConfigCreationTools
+from agentpool_toolsets.fsspec_toolset import FSSpecTools
+from agentpool_toolsets.notifications import NotificationsTools
+from agentpool_toolsets.semantic_memory_toolset import SemanticMemoryTools
+from agentpool_toolsets.vfs_toolset import VFSTools
+
+__all__ = [
+    "ConfigCreationTools",
+    "FSSpecTools",
+    "NotificationsTools",
+    "SemanticMemoryTools",
+    "VFSTools",
+]

agentpool_toolsets/builtin/__init__.py

@@ -0,0 +1,33 @@
+"""Built-in toolsets for agent capabilities."""
+
+from __future__ import annotations
+
+
+# Import provider classes
+from agentpool_toolsets.builtin.agent_management import AgentManagementTools
+from agentpool_toolsets.builtin.code import CodeTools
+from agentpool_toolsets.builtin.debug import DebugTools
+from agentpool_toolsets.builtin.execution_environment import ExecutionEnvironmentTools
+from agentpool_toolsets.builtin.history import HistoryTools
+from agentpool_toolsets.builtin.integration import IntegrationTools
+from agentpool_toolsets.builtin.skills import SkillsTools
+from agentpool_toolsets.builtin.subagent_tools import SubagentTools
+from agentpool_toolsets.builtin.tool_management import ToolManagementTools
+from agentpool_toolsets.builtin.user_interaction import UserInteractionTools
+from agentpool_toolsets.builtin.workers import WorkersTools
+
+
+__all__ = [
+    # Provider classes
+    "AgentManagementTools",
+    "CodeTools",
+    "DebugTools",
+    "ExecutionEnvironmentTools",
+    "HistoryTools",
+    "IntegrationTools",
+    "SkillsTools",
+    "SubagentTools",
+    "ToolManagementTools",
+    "UserInteractionTools",
+    "WorkersTools",
+]

agentpool_toolsets/builtin/agent_management.py

@@ -0,0 +1,239 @@
+"""Provider for agent pool building tools."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import TYPE_CHECKING, Any, Literal
+
+import anyio
+from pydantic_ai import ModelRetry
+
+from agentpool.agents.context import AgentContext  # noqa: TC001
+from agentpool.log import get_logger
+from agentpool.resource_providers import StaticResourceProvider
+from agentpool.tools.exceptions import ToolError
+from agentpool.utils.result_utils import to_type
+
+
+if TYPE_CHECKING:
+    from agentpool.agents import Agent
+
+logger = get_logger(__name__)
+
+
+async def create_worker_agent[TDeps](
+    ctx: AgentContext[TDeps],
+    name: str,
+    system_prompt: str,
+    model: str | None = None,
+) -> str:
+    """Create a new agent and register it as a tool.
+
+    The new agent will be available as a tool for delegating specific tasks.
+    It inherits the current model unless overridden.
+    """
+    from agentpool import Agent
+
+    if not ctx.pool:
+        msg = "Agent needs to be in a pool to list agents"
+        raise ToolError(msg)
+
+    model = model or ctx.agent.model_name
+    agent = Agent[TDeps](name=name, model=model, system_prompt=system_prompt, agent_pool=ctx.pool)
+    assert ctx.agent
+    tool_info = ctx.native_agent.register_worker(agent)
+    return f"Created worker agent and registered as tool: {tool_info.name}"
+
+
+async def add_agent(  # noqa: D417
+    ctx: AgentContext,
+    name: str,
+    system_prompt: str,
+    model: str | None = None,
+    tools: list[str] | None = None,
+    session: str | None = None,
+    output_type: str | None = None,
+) -> str:
+    """Add a new agent to the pool.
+
+    Args:
+        name: Name for the new agent
+        system_prompt: System prompt defining agent's role/behavior
+        model: Optional model override (uses default if not specified)
+        tools: Imort paths of the tools the agent should have, if any.
+        session: Session ID to recover conversation state from
+        output_type: Name of response type from manifest (for structured output)
+
+    Returns:
+        Confirmation message about the created agent
+    """
+    assert ctx.pool, "No agent pool available"
+    try:
+        agent: Agent[Any, Any] = await ctx.pool.add_agent(
+            name=name,
+            system_prompt=system_prompt,
+            model=model,
+            tools=tools,
+            output_type=to_type(output_type, responses=ctx.pool.manifest.responses),
+            session=session,
+        )
+    except ValueError as e:  # for wrong tool imports
+        raise ModelRetry(message=f"Error creating agent: {e}") from None
+    return f"Created agent **{agent.name}** using model **{agent.model_name}**"
+
+
+async def add_team(  # noqa: D417
+    ctx: AgentContext,
+    nodes: list[str],
+    mode: Literal["sequential", "parallel"] = "sequential",
+    name: str | None = None,
+) -> str:
+    """Create a team from existing agents.
+
+    Args:
+        nodes: Names of agents / sub-teams to include in team
+        mode: How the team should operate:
+            - sequential: Agents process in sequence (pipeline)
+            - parallel: Agents process simultaneously
+        name: Optional name for the team
+    """
+    if not ctx.pool:
+        msg = "No agent pool available"
+        raise ToolError(msg)
+
+    # Verify all agents exist
+    for node_name in nodes:
+        if node_name not in ctx.pool.nodes:
+            msg = (
+                f"No agent or team found with name: {node_name}. "
+                f"Available nodes: {', '.join(ctx.pool.nodes.keys())}"
+            )
+            raise ModelRetry(msg)
+    if mode == "sequential":
+        ctx.pool.create_team_run(nodes, name=name)
+    else:
+        ctx.pool.create_team(nodes, name=name)
+    mode_str = "pipeline" if mode == "sequential" else "parallel"
+    return f"Created **{mode_str}** team with nodes: **{', '.join(nodes)}**"
+
+
+async def connect_nodes(  # noqa: D417
+    ctx: AgentContext,
+    source: str,
+    target: str,
+    *,
+    connection_type: Literal["run", "context", "forward"] = "run",
+    priority: int = 0,
+    delay_seconds: float | None = None,
+    queued: bool = False,
+    queue_strategy: Literal["concat", "latest", "buffer"] = "latest",
+    wait_for_completion: bool = True,
+    name: str | None = None,
+) -> str:
+    """Connect two nodes to enable message flow between them.
+
+    Nodes can be agents or teams.
+
+    Args:
+        source: Name of the source node
+        target: Name of the target node
+        connection_type: How messages should be handled:
+            - run: Execute message as a new run in target
+            - context: Add message as context to target
+            - forward: Forward message to target's outbox
+        priority: Task priority (lower = higher priority)
+        delay_seconds: Optional delay before processing messages
+        queued: Whether messages should be queued for manual processing
+        queue_strategy: How to process queued messages:
+            - concat: Combine all messages with newlines
+            - latest: Use only the most recent message
+            - buffer: Process all messages individually
+        wait_for_completion: Whether to wait for target to complete
+        name: Optional name for this connection
+
+    Returns:
+        Description of the created connection
+    """
+    if not ctx.pool:
+        msg = "No agent pool available"
+        raise ToolError(msg)
+
+    # Get the nodes
+    if source not in ctx.pool.nodes:
+        msg = (
+            f"No agent or team found with name: {source}. "
+            f"Available nodes: {', '.join(ctx.pool.nodes.keys())}"
+        )
+        raise ModelRetry(msg)
+    if target not in ctx.pool.nodes:
+        msg = (
+            f"No agent or team found with name: {target}. "
+            f"Available nodes: {', '.join(ctx.pool.nodes.keys())}"
+        )
+        raise ModelRetry(msg)
+
+    source_node = ctx.pool.nodes[source]
+    target_node = ctx.pool.nodes[target]
+
+    # Create the connection
+    delay = timedelta(seconds=delay_seconds) if delay_seconds is not None else None
+    _talk = source_node.connect_to(
+        target_node,
+        connection_type=connection_type,
+        priority=priority,
+        delay=delay,
+        queued=queued,
+        queue_strategy=queue_strategy,
+        name=name,
+    )
+    source_node.connections.set_wait_state(target_node, wait=wait_for_completion)
+
+    return (
+        f"Created connection from **{source}** to **{target}** "
+        f"*(type={connection_type}, queued={queued}, "
+        f"strategy={queue_strategy if queued else 'n/a'})*"
+    )
+
+
+class AgentManagementTools(StaticResourceProvider):
+    """Provider for agent pool building tools."""
+
+    def __init__(self, name: str = "agent_management") -> None:
+        super().__init__(name=name)
+        for tool in [
+            self.create_tool(create_worker_agent, category="other", destructive=False),
+            self.create_tool(add_agent, category="other", destructive=False),
+            self.create_tool(add_team, category="other", destructive=False),
+            self.create_tool(connect_nodes, category="other", destructive=False),
+        ]:
+            self.add_tool(tool)
+
+
+if __name__ == "__main__":
+    # import logging
+    from agentpool import AgentPool
+
+    user_prompt = """Add a stdio MCP server:
+// 	"command": "npx",
+// 	"args": ["mcp-graphql"],
+// 	"env": { "ENDPOINT": "https://diego.one/graphql" }
+
+."""
+
+    async def main() -> None:
+        from agentpool_config.toolsets import IntegrationToolsetConfig
+
+        async with AgentPool() as pool:
+            toolsets = [IntegrationToolsetConfig()]
+            toolset_providers = [config.get_provider() for config in toolsets]
+            agent = await pool.add_agent(
+                "X",
+                toolsets=toolset_providers,
+                model="openai:gpt-5-nano",
+            )
+            result = await agent.run(user_prompt)
+            print(result)
+            result = await agent.run("Which tools does it have?")
+            print(result)
+
+    anyio.run(main)