agentpool 2.1.9__py3-none-any.whl → 2.5.0__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/chain.py

@@ -1,288 +0,0 @@
-"""Tool to chain multiple function calls."""
-
-from __future__ import annotations
-
-import asyncio
-from dataclasses import dataclass
-from enum import StrEnum
-from typing import Any, Literal, assert_never
-
-import anyio
-from pydantic import Field
-from pydantic_ai import ModelRetry
-from schemez import Schema
-
-from agentpool.agents.context import AgentContext  # noqa: TC001
-
-
-class ErrorStrategy(StrEnum):
-    """Strategy for handling errors in the pipeline."""
-
-    STOP = "stop"  # Stop pipeline on error
-    SKIP = "skip"  # Skip failed step, continue with previous result
-    DEFAULT = "default"  # Use provided default value
-    RETRY = "retry"  # Retry the step
-
-
-class StepCondition(Schema):
-    """Condition for conditional execution."""
-
-    field: str  # Field to check in result
-    operator: Literal["eq", "gt", "lt", "contains", "exists"]
-    value: Any = None
-
-    def evaluate_with_value(self, value: Any) -> bool:
-        """Evaluate this condition against a value.
-
-        Args:
-            value: The value to evaluate against the condition.
-
-        Returns:
-            bool: True if the condition is met, False otherwise.
-        """
-        field_value = value.get(self.field) if isinstance(value, dict) else value
-
-        match self.operator:
-            case "eq":
-                return bool(field_value == self.value)
-            case "gt":
-                return bool(field_value > self.value)
-            case "lt":
-                return bool(field_value < self.value)
-            case "contains":
-                try:
-                    return self.value in field_value  # type: ignore[operator]
-                except TypeError:
-                    return False
-            case "exists":
-                return field_value is not None
-            case _ as unreachable:
-                assert_never(unreachable)
-
-
-@dataclass
-class StepResult:
-    """Result of a pipeline step execution."""
-
-    success: bool
-    result: Any
-    error: Exception | None = None
-    retries: int = 0
-    duration: float = 0.0
-
-
-# Type alias for step results during execution
-type StepResults = dict[str, StepResult]
-
-
-class PipelineStep(Schema):
-    """Single step in a tool pipeline."""
-
-    tool: str
-    input_kwarg: str = "text"
-    keyword_args: dict[str, Any] = Field(default_factory=dict)
-    name: str | None = None  # Optional step name for referencing
-    condition: StepCondition | None = None  # Conditional execution
-    error_strategy: ErrorStrategy = ErrorStrategy.STOP
-    default_value: Any = None  # Used with ErrorStrategy.DEFAULT
-    max_retries: int = 0
-    retry_delay: float = 1.0
-    timeout: float | None = None
-    depends_on: list[str] = Field(default_factory=list)  # Step dependencies
-
-
-class Pipeline(Schema):
-    """A pipeline of tool operations."""
-
-    input: str | dict[str, Any]
-    steps: list[PipelineStep]
-    mode: Literal["sequential", "parallel"] = "sequential"
-    max_parallel: int = 5  # Max concurrent steps
-    collect_metrics: bool = False  # Collect execution metrics
-
-
-async def _execute_step(
-    ctx: AgentContext,
-    step: PipelineStep,
-    input_value: Any,
-    results: StepResults,
-) -> StepResult:
-    """Execute a single pipeline step."""
-    start_time = asyncio.get_event_loop().time()
-    retries = 0
-
-    while True:
-        try:
-            # Check condition if any
-            if step.condition and not step.condition.evaluate_with_value(input_value):
-                return StepResult(success=True, result=input_value, duration=0)
-
-            tool_info = await ctx.agent.tools.get_tool(step.tool)  # Get the tool
-            if isinstance(input_value, dict):  # Prepare kwargs
-                kwargs = {**input_value, **step.keyword_args}
-            else:
-                kwargs = {step.input_kwarg: input_value, **step.keyword_args}
-
-            # Execute with timeout if specified
-            if step.timeout:
-                fut = tool_info.execute(ctx, **kwargs)
-                result = await asyncio.wait_for(fut, timeout=step.timeout)
-            else:
-                result = await tool_info.execute(ctx, **kwargs)
-
-            duration = asyncio.get_event_loop().time() - start_time
-            return StepResult(success=True, result=result, duration=duration)
-
-        except Exception as exc:
-            match step.error_strategy:
-                case ErrorStrategy.STOP:
-                    raise
-
-                case ErrorStrategy.SKIP:
-                    duration = asyncio.get_event_loop().time() - start_time
-                    return StepResult(
-                        success=False,
-                        result=input_value,
-                        error=exc,
-                        duration=duration,
-                    )
-
-                case ErrorStrategy.DEFAULT:
-                    duration = asyncio.get_event_loop().time() - start_time
-                    return StepResult(
-                        success=False,
-                        result=step.default_value,
-                        error=exc,
-                        duration=duration,
-                    )
-
-                case ErrorStrategy.RETRY:
-                    retries += 1
-                    if retries <= step.max_retries:
-                        await anyio.sleep(step.retry_delay)
-                        continue
-                    raise  # Max retries exceeded
-
-
-async def _execute_sequential(ctx: AgentContext, pipeline: Pipeline, results: StepResults) -> Any:
-    """Execute steps sequentially."""
-    current = pipeline.input
-    for step in pipeline.steps:
-        result = await _execute_step(ctx, step, current, results)
-        if step.name:
-            results[step.name] = result
-        current = result.result
-    return current
-
-
-async def _execute_parallel(ctx: AgentContext, pipeline: Pipeline, results: StepResults) -> Any:
-    """Execute independent steps in parallel."""
-    semaphore = asyncio.Semaphore(pipeline.max_parallel)
-
-    async def run_step(step: PipelineStep) -> None:
-        async with semaphore:
-            # Wait for dependencies
-            for dep in step.depends_on:
-                while dep not in results:
-                    await anyio.sleep(0.1)
-
-            # Get input from dependency or pipeline input
-            input_value = results[step.depends_on[-1]].result if step.depends_on else pipeline.input
-            result = await _execute_step(ctx, step, input_value, results)
-            if step.name:
-                results[step.name] = result
-
-    # Create tasks for all steps
-    tasks = [run_step(step) for step in pipeline.steps]
-    await asyncio.gather(*tasks)
-    # Return last result
-    return results[name].result if (name := pipeline.steps[-1].name) else None
-
-
-async def chain_tools(
-    ctx: AgentContext,
-    input_data: str | dict[str, Any],
-    steps: list[dict[str, Any]],
-    mode: Literal["sequential", "parallel"] = "sequential",
-    max_parallel: int = 5,
-    collect_metrics: bool = False,
-) -> Any:
-    """Execute multiple tool operations in sequence or parallel.
-
-    WHEN TO USE THIS TOOL:
-    - Use this when you can plan multiple operations confidently in advance
-    - Use this for common sequences you've successfully used before
-    - Use this to reduce interaction rounds for known operation patterns
-    - Use this when all steps are independent of intermediate results
-
-    DO NOT USE THIS TOOL:
-    - When you need to inspect intermediate results
-    - When next steps depend on analyzing previous results
-    - When you're unsure about the complete sequence
-    - When you need to handle errors at each step individually
-
-    Args:
-        ctx: Agent context for tool execution
-        input_data: Initial input for the pipeline
-        steps: List of step configurations, each containing:
-            - tool: Name of the tool to execute
-            - input_kwarg: Keyword argument name for input (default: "text")
-            - keyword_args: Additional keyword arguments
-            - name: Optional step name for referencing
-            - condition: Optional execution condition
-            - error_strategy: How to handle errors ("stop", "skip", "default", "retry")
-            - default_value: Value to use with "default" error strategy
-            - max_retries: Maximum retry attempts
-            - retry_delay: Delay between retries in seconds
-            - timeout: Step timeout in seconds
-            - depends_on: List of step names this depends on
-        mode: Execution mode - "sequential" or "parallel"
-        max_parallel: Maximum concurrent steps for parallel mode
-        collect_metrics: Whether to collect execution metrics
-
-    Examples:
-        # Sequential processing
-        await chain_tools(
-            ctx,
-            input_data="main.py",
-            steps=[
-                {"tool": "load_resource", "input_kwarg": "name"},
-                {"tool": "analyze_code", "input_kwarg": "code"},
-                {"tool": "format_output", "input_kwarg": "text"}
-            ]
-        )
-
-        # Parallel processing with dependencies
-        await chain_tools(
-            ctx,
-            input_data="test.py",
-            mode="parallel",
-            steps=[
-                {"tool": "load_resource", "input_kwarg": "name", "name": "load"},
-                {"tool": "analyze_code", "input_kwarg": "code", "depends_on": ["load"]},
-                {"tool": "count_tokens", "input_kwarg": "text", "depends_on": ["load"]}
-            ]
-        )
-    """
-    try:
-        pipeline = Pipeline(
-            input=input_data,
-            steps=[PipelineStep.model_validate(step) for step in steps],
-            mode=mode,
-            max_parallel=max_parallel,
-            collect_metrics=collect_metrics,
-        )
-    except Exception as e:
-        msg = f"Invalid pipeline configuration: {e}"
-        raise ModelRetry(msg) from e
-    results: StepResults = {}
-
-    try:
-        match pipeline.mode:
-            case "sequential":
-                return await _execute_sequential(ctx, pipeline, results)
-            case "parallel":
-                return await _execute_parallel(ctx, pipeline, results)
-    except Exception as e:
-        msg = f"Failed to execute pipeline: {e}"
-        raise ModelRetry(msg) from e

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),
-        ]