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

agentpool_toolsets/builtin/agent_management.py

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

agentpool_toolsets/builtin/history.py

@@ -1,36 +0,0 @@
-"""Provider for history tools."""
-
-from __future__ import annotations
-
-from agentpool.agents.context import AgentContext  # noqa: TC001
-from agentpool.resource_providers import StaticResourceProvider
-
-
-async def search_history(
-    ctx: AgentContext,
-    query: str | None = None,
-    hours: int = 24,
-    limit: int = 5,
-) -> str:
-    """Search conversation history."""
-    from agentpool_storage.formatters import format_output
-
-    if not ctx.pool:
-        return "No agent pool available for history search"
-    provider = ctx.pool.storage.get_history_provider()
-    results = await provider.get_filtered_conversations(
-        query=query,
-        period=f"{hours}h",
-        limit=limit,
-    )
-    return format_output(results)
-
-
-class HistoryTools(StaticResourceProvider):
-    """Provider for history tools."""
-
-    def __init__(self, name: str = "history") -> None:
-        super().__init__(name=name)
-        self._tools = [
-            self.create_tool(search_history, category="search", read_only=True, idempotent=True),
-        ]

agentpool_toolsets/builtin/integration.py

@@ -1,85 +0,0 @@
-"""Provider for integration tools."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Literal
-
-from pydantic import HttpUrl
-
-from agentpool.agents.context import AgentContext  # noqa: TC001
-from agentpool.resource_providers import ResourceProvider
-
-
-if TYPE_CHECKING:
-    from agentpool.tools.base import Tool
-    from agentpool_config.mcp_server import MCPServerConfig
-
-
-async def add_local_mcp_server(  # noqa: D417
-    ctx: AgentContext,
-    name: str,
-    command: str,
-    args: list[str] | None = None,
-    env_vars: dict[str, str] | None = None,
-) -> str:
-    """Add a local MCP server via stdio transport.
-
-    Args:
-        name: Unique name for the MCP server
-        command: Command to execute for the server
-        args: Command arguments
-        env_vars: Environment variables to pass to the server
-
-    Returns:
-        Confirmation message about the added server
-    """
-    from agentpool_config.mcp_server import StdioMCPServerConfig
-
-    env = env_vars or {}
-    config = StdioMCPServerConfig(name=name, command=command, args=args or [], env=env)
-    await ctx.agent.mcp.setup_server_runtime(config)
-    # New provider automatically available via aggregating provider
-    return f"Added local MCP server **{name}** with command: **{command}**"
-
-
-async def add_remote_mcp_server(  # noqa: D417
-    ctx: AgentContext,
-    name: str,
-    url: str,
-    transport: Literal["sse", "streamable-http"] = "streamable-http",
-) -> str:
-    """Add a remote MCP server via HTTP-based transport.
-
-    Args:
-        name: Unique name for the MCP server
-        url: Server URL endpoint
-        transport: HTTP transport type to use (http is preferred)
-
-    Returns:
-        Confirmation message about the added server
-    """
-    from agentpool_config.mcp_server import SSEMCPServerConfig, StreamableHTTPMCPServerConfig
-
-    match transport:
-        case "sse":
-            config: MCPServerConfig = SSEMCPServerConfig(name=name, url=HttpUrl(url))
-        case "streamable-http":
-            config = StreamableHTTPMCPServerConfig(name=name, url=HttpUrl(url))
-
-    await ctx.agent.mcp.setup_server_runtime(config)
-    # New provider automatically available via aggregating provider
-    return f"Added remote MCP server **{name}** at *{url}* using {transport} transport"
-
-
-class IntegrationTools(ResourceProvider):
-    """Provider for integration tools."""
-
-    def __init__(self, name: str = "integrations") -> None:
-        super().__init__(name)
-
-    async def get_tools(self) -> list[Tool]:
-        """Get integration tools."""
-        return [
-            self.create_tool(add_local_mcp_server, category="other"),
-            self.create_tool(add_remote_mcp_server, category="other", open_world=True),
-        ]

agentpool_toolsets/builtin/tool_management.py

@@ -1,90 +0,0 @@
-"""Provider for tool management tools."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from agentpool.agents.context import AgentContext  # noqa: TC001
-from agentpool.resource_providers import StaticResourceProvider
-from agentpool.tools.base import Tool
-
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-
-async def register_tool(  # noqa: D417
-    ctx: AgentContext,
-    tool: str | Callable[..., Any],
-    name: str | None = None,
-    description: str | None = None,
-    enabled: bool = True,
-) -> str:
-    """Register a new tool from callable or import path.
-
-    Args:
-        tool: Callable function or import path string to register as tool
-        name: Optional name override for the tool
-        description: Optional description override for the tool
-        enabled: Whether the tool should be enabled initially
-
-    Returns:
-        Confirmation message with registered tool name
-    """
-    # Create tool from callable/import path
-    tool_obj = Tool.from_callable(
-        tool,
-        name_override=name,
-        description_override=description,
-        source="dynamic",
-        enabled=enabled,
-    )
-
-    # Register with the agent's tool manager
-    registered_tool = ctx.agent.tools.register_tool(tool_obj)
-
-    return f"Successfully registered tool: {registered_tool.name}"
-
-
-async def register_code_tool(  # noqa: D417
-    ctx: AgentContext,
-    code: str,
-    name: str | None = None,
-    description: str | None = None,
-    enabled: bool = True,
-) -> str:
-    """Register a new tool from code string.
-
-    Args:
-        code: Python code string containing a callable function
-        name: Optional name override for the tool
-        description: Optional description override for the tool
-        enabled: Whether the tool should be enabled initially
-
-    Returns:
-        Confirmation message with registered tool name
-    """
-    # Create tool from code
-    tool_obj = Tool.from_code(
-        code,
-        name=name,
-        description=description,
-    )
-    tool_obj.enabled = enabled
-    tool_obj.source = "dynamic"
-
-    # Register with the agent's tool manager
-    registered_tool = ctx.agent.tools.register_tool(tool_obj)
-
-    return f"Successfully registered code tool: {registered_tool.name}"
-
-
-class ToolManagementTools(StaticResourceProvider):
-    """Provider for tool management tools."""
-
-    def __init__(self, name: str = "tool_management") -> None:
-        super().__init__(name=name)
-        self._tools = [
-            self.create_tool(register_tool, category="other"),
-            self.create_tool(register_code_tool, category="other"),
-        ]