agentpool 2.1.9__py3-none-any.whl

agentpool_config/task.py

@@ -0,0 +1,162 @@
+"""Task configuration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from pydantic import ConfigDict, Field, ImportString
+from schemez import Schema
+
+from agentpool.prompts.prompts import BasePrompt
+from agentpool.tools.base import Tool
+from agentpool_config.knowledge import Knowledge
+from agentpool_config.tools import ImportToolConfig
+
+
+if TYPE_CHECKING:
+    from agentpool.agents import Agent
+
+
+class Job[TDeps, TResult = str](Schema):
+    """A task is a piece of work that can be executed by an agent.
+
+    Requirements:
+    - The agent must have compatible dependencies (required_dependency)
+    - The agent must produce the specified result type (required_return_type)
+
+    Equipment:
+    - The task provides necessary tools for execution (tools)
+    - Tools are temporarily available during task execution
+    """
+
+    name: str | None = Field(
+        default=None,
+        examples=["analyze_code", "generate_summary", "translate_text"],
+        title="Task name",
+    )
+    """Technical identifier (automatically set from config key during registration)"""
+
+    description: str | None = Field(
+        default=None,
+        examples=[
+            "Analyze code for issues",
+            "Generate a summary",
+            "Translate text to target language",
+        ],
+        title="Task description",
+    )
+    """Human-readable description of what this task does"""
+
+    prompt: str | ImportString[str] | BasePrompt = Field(
+        examples=["Analyze the following code", "agentpool.prompts.prompts:BasePrompt"],
+        title="Task prompt",
+    )
+    """The task instruction/prompt."""
+
+    required_return_type: ImportString[type[TResult]] = Field(
+        default="str",
+        validate_default=True,
+        examples=["str", "dict", "builtins:str"],
+        title="Required return type",
+    )
+    """Expected type of the task result."""
+
+    required_dependency: ImportString[type[TDeps]] | None = Field(
+        default=None,
+        validate_default=True,
+        examples=["agentpool.agents.context:AgentContext"],
+        title="Required dependencies",
+    )
+    """Dependencies or context data needed for task execution"""
+
+    requires_vision: bool = Field(default=False, title="Requires vision capabilities")
+    """Whether the agent requires vision"""
+
+    knowledge: Knowledge | None = Field(default=None, title="Task knowledge sources")
+    """Optional knowledge sources for this task:
+    - Simple file/URL paths
+    - Rich resource definitions
+    - Prompt templates
+    """
+
+    tools: list[ImportString[Callable[..., Any]] | ImportToolConfig] = Field(
+        default_factory=list,
+        examples=[
+            [
+                {
+                    "type": "import",
+                    "import_path": "webbrowser:open",
+                    "name": "web_browser",
+                }
+            ],
+            ["builtins:print"],
+            [
+                {
+                    "type": "import",
+                    "import_path": "builtins:print",
+                    "requires_confirmation": True,
+                }
+            ],
+        ],
+        title="Task tools",
+    )
+    """Tools needed for this task."""
+
+    min_context_tokens: int | None = Field(
+        default=None,
+        examples=[1000, 4000, 8000],
+        title="Minimum context tokens",
+    )
+    """Minimum amount of required context size."""
+
+    model_config = ConfigDict(frozen=True)
+
+    async def can_be_executed_by(self, agent: Agent[Any, Any]) -> bool:
+        """Check if agent meets all requirements for this task."""
+        # Check dependencies
+        if self.required_dependency and not issubclass(
+            agent.deps_type or type(None), self.required_dependency
+        ):
+            return False
+
+        if agent._output_type != self.required_return_type:
+            return False
+
+        # Check vision capabilities
+        if self.requires_vision:
+            from agentpool.utils.model_capabilities import supports_vision
+
+            if not await supports_vision(agent.model_name):
+                return False
+
+        return True
+
+    @property
+    def tool_configs(self) -> list[ImportToolConfig]:
+        """Get all tools as ToolConfig instances."""
+        return [
+            tool if isinstance(tool, ImportToolConfig) else ImportToolConfig(import_path=tool)
+            for tool in self.tools
+        ]
+
+    async def get_prompt(self) -> str:
+        if isinstance(self.prompt, BasePrompt):
+            messages = await self.prompt.format()
+            return "\n\n".join(m.get_text_content() for m in messages)
+        return self.prompt
+
+    def get_tools(self) -> list[Tool]:
+        """Get all tools as Tool instances."""
+        tools: list[Tool] = []
+        for tool in self.tools:
+            match tool:
+                case str():
+                    tools.append(Tool.from_callable(tool))
+                case ImportToolConfig() as config:
+                    tools.append(config.get_tool())
+                case Tool():
+                    tools.append(tool)
+                case _:
+                    raise ValueError(f"Invalid tool type: {type(tool)}")
+        return tools

agentpool_config/teams.py

@@ -0,0 +1,52 @@
+"""Team configuration models."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import ConfigDict, Field
+
+from agentpool_config.nodes import NodeConfig
+
+
+ExecutionMode = Literal["parallel", "sequential"]
+
+
+class TeamConfig(NodeConfig):
+    """Configuration for a team or chain of message nodes.
+
+    Teams can be either parallel execution groups or sequential chains.
+    They can contain both agents and other teams as members.
+
+    Docs: https://phil65.github.io/agentpool/YAML%20Configuration/team_configuration/
+    """
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "x-icon": "fluent:people-team-24-regular",
+            "x-doc-title": "Team Configuration",
+        }
+    )
+
+    mode: ExecutionMode = Field(examples=["parallel", "sequential"], title="Execution mode")
+    """Execution mode for team members."""
+
+    members: list[str] = Field(
+        examples=[["agent1", "agent2"], ["web_searcher", "data_analyzer", "reporter"]],
+        title="Team members",
+    )
+    """Names of agents or other teams that are part of this team."""
+
+    shared_prompt: str | None = Field(
+        default=None,
+        examples=["Work together to solve this problem", "Follow the team guidelines"],
+        title="Shared prompt",
+    )
+    """Optional shared prompt for this team."""
+
+    # Future extensions:
+    # tools: list[str] | None = None
+    # """Tools available to all team members."""
+
+    # knowledge: Knowledge | None = None
+    # """Knowledge sources shared by all team members."""

agentpool_config/tools.py

@@ -0,0 +1,112 @@
+"""Models for tools."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Annotated, Any, Literal
+
+from pydantic import ConfigDict, Field, ImportString
+from schemez import Schema
+
+
+if TYPE_CHECKING:
+    from agentpool.tools.base import Tool
+
+
+class ToolHints(Schema):
+    """Configuration for tool execution hints."""
+
+    read_only: bool | None = Field(default=None, title="Read-only operation")
+    """Hints that this tool only reads data without modifying anything"""
+
+    destructive: bool | None = Field(default=None, title="Destructive operation")
+    """Hints that this tool performs destructive operations that cannot be undone"""
+
+    idempotent: bool | None = Field(default=None, title="Idempotent operation")
+    """Hints that this tool has idempotent behaviour"""
+
+    open_world: bool | None = Field(default=None, title="External resource access")
+    """Hints that this tool can access / interact with external resources beyond the
+    current system"""
+
+
+class BaseToolConfig(Schema):
+    """Base configuration for agent tools."""
+
+    type: str = Field(init=False)
+    """Type discriminator for tool configs."""
+
+    name: str | None = Field(
+        default=None,
+        examples=["search_web", "file_reader", "calculator"],
+        title="Tool name override",
+    )
+    """Optional override for the tool name."""
+
+    description: str | None = Field(
+        default=None,
+        examples=["Search the web for information", "Read file contents"],
+        title="Tool description override",
+    )
+    """Optional override for the tool description."""
+
+    enabled: bool = Field(default=True, title="Tool enabled")
+    """Whether this tool is initially enabled."""
+
+    requires_confirmation: bool = Field(default=False, title="Requires confirmation")
+    """Whether tool execution needs confirmation."""
+
+    metadata: dict[str, str] = Field(
+        default_factory=dict,
+        examples=[
+            {"category": "web", "version": "1.0"},
+            {"author": "system", "tags": "search,utility"},
+            {"priority": "high", "environment": "production"},
+        ],
+        title="Tool metadata",
+    )
+    """Additional tool metadata."""
+
+    hints: ToolHints | None = Field(
+        default=None,
+        title="Execution hints",
+        examples=[
+            {"read_only": True, "destructive": False, "open_world": True, "idempotent": False},
+        ],
+    )
+    """Hints for tool execution."""
+
+    model_config = ConfigDict(frozen=True)
+
+    def get_tool(self) -> Tool:
+        """Convert config to Tool instance."""
+        raise NotImplementedError
+
+
+class ImportToolConfig(BaseToolConfig):
+    """Configuration for importing tools from Python modules."""
+
+    type: Literal["import"] = Field("import", init=False)
+    """Import path based tool."""
+
+    import_path: ImportString[Callable[..., Any]] = Field(
+        examples=["webbrowser:open", "builtins:print"],
+        title="Import path",
+    )
+    """Import path to the tool function."""
+
+    def get_tool(self) -> Tool:
+        """Import and create tool from configuration."""
+        from agentpool.tools.base import Tool
+
+        return Tool.from_callable(
+            self.import_path,
+            name_override=self.name,
+            description_override=self.description,
+            enabled=self.enabled,
+            requires_confirmation=self.requires_confirmation,
+            metadata=self.metadata,
+        )
+
+
+ToolConfig = Annotated[ImportToolConfig, Field(discriminator="type")]