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

agentpool_storage/text_log_provider.py

@@ -1,276 +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,
-        parent_id: 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/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/user_interaction.py

@@ -1,52 +0,0 @@
-"""Provider for user interaction tools."""
-
-from __future__ import annotations
-
-from typing import Any, assert_never
-
-from agentpool.agents.context import AgentContext  # noqa: TC001
-from agentpool.resource_providers import StaticResourceProvider
-
-
-async def ask_user(  # noqa: D417
-    ctx: AgentContext,
-    prompt: str,
-    response_schema: dict[str, Any] | None = None,
-) -> str:
-    """Allow LLM to ask user a clarifying question during processing.
-
-    This tool enables agents to ask users for additional information or clarification
-    when needed to complete a task effectively.
-
-    Args:
-        prompt: Question to ask the user
-        response_schema: Optional JSON schema for structured response (defaults to string)
-
-    Returns:
-        The user's response as a string
-    """
-    from mcp.types import ElicitRequestFormParams, ElicitResult, ErrorData
-
-    schema = response_schema or {"type": "string"}  # string schema if no none provided
-    params = ElicitRequestFormParams(message=prompt, requestedSchema=schema)
-    result = await ctx.handle_elicitation(params)
-
-    match result:
-        case ElicitResult(action="accept", content=content):
-            return str(content)
-        case ElicitResult(action="cancel"):
-            return "User cancelled the request"
-        case ElicitResult():
-            return "User declined to answer"
-        case ErrorData(message=message):
-            return f"Error: {message}"
-        case _ as unreachable:
-            assert_never(unreachable)
-
-
-class UserInteractionTools(StaticResourceProvider):
-    """Provider for user interaction tools."""
-
-    def __init__(self, name: str = "user_interaction") -> None:
-        super().__init__(name=name)
-        self._tools = [self.create_tool(ask_user, category="other", open_world=True)]