agentpool 2.1.9__py3-none-any.whl

agentpool_config/pool_server.py

@@ -0,0 +1,267 @@
+"""Pool server configuration."""
+
+from __future__ import annotations
+
+from typing import Annotated, Literal, assert_never
+
+from pydantic import ConfigDict, Field, SecretStr
+from schemez import Schema
+
+
+TransportType = Literal["stdio", "sse", "streamable-http"]
+
+
+class BasePoolServerConfig(Schema):
+    """Base configuration for pool servers."""
+
+    type: str = Field(title="Server type")
+    """Type discriminator for server configurations."""
+
+    enabled: bool = Field(default=False, title="Server enabled")
+    """Whether this server is currently enabled."""
+
+
+class MCPPoolServerConfig(BasePoolServerConfig):
+    """Configuration for pool-based MCP server."""
+
+    type: Literal["mcp"] = Field("mcp", init=False)
+    """MCP server type."""
+
+    # Resource exposure control
+    serve_nodes: list[str] | bool = Field(
+        default=True,
+        title="Serve nodes",
+        examples=[["node1", "node2"], ["analysis", "transform"]],
+    )
+    """Which nodes to expose as tools:
+    - True: All nodes
+    - False: No nodes
+    - list[str]: Specific node names
+    """
+
+    serve_prompts: list[str] | bool = Field(
+        default=True,
+        title="Serve prompts",
+        examples=[["prompt1", "prompt2"], ["system", "user"]],
+    )
+    """Which prompts to expose:
+    - True: All prompts from manifest
+    - False: No prompts
+    - list[str]: Specific prompt names
+    """
+
+    transport: TransportType = Field(
+        default="stdio",
+        title="Transport type",
+        examples=["stdio", "sse", "streamable-http"],
+    )
+    """Transport type to use."""
+
+    host: str = Field(
+        default="localhost",
+        title="Server host",
+        examples=["localhost", "0.0.0.0", "127.0.0.1"],
+    )
+    """Host to bind server to (SSE / Streamable-HTTP only)."""
+
+    port: int = Field(
+        default=3001,
+        gt=0,
+        title="Server port",
+        examples=[3001, 8080, 9000],
+    )
+    """Port to listen on (SSE / Streamable-HTTP only)."""
+
+    cors_origins: list[str] = Field(
+        default_factory=lambda: ["*"],
+        title="CORS origins",
+        examples=[["*"], ["https://example.com", "https://app.com"]],
+    )
+    """Allowed CORS origins (SSE / Streamable-HTTP only)."""
+
+    zed_mode: bool = Field(default=False, title="Zed editor mode")
+    """Enable Zed editor compatibility mode."""
+
+    model_config = ConfigDict(frozen=True)
+
+    def should_serve_node(self, name: str) -> bool:
+        """Check if a node should be exposed."""
+        match self.serve_nodes:
+            case True:
+                return True
+            case False:
+                return False
+            case list():
+                return name in self.serve_nodes
+            case _ as unreachable:
+                assert_never(unreachable)
+
+    def should_serve_prompt(self, name: str) -> bool:
+        """Check if a prompt should be exposed."""
+        match self.serve_prompts:
+            case True:
+                return True
+            case False:
+                return False
+            case list():
+                return name in self.serve_prompts
+            case _ as unreachable:
+                assert_never(unreachable)
+
+
+class A2APoolServerConfig(BasePoolServerConfig):
+    """Configuration for A2A (Agent-to-Agent) server."""
+
+    type: Literal["a2a"] = Field("a2a", init=False)
+    """A2A server type."""
+
+    host: str = Field(
+        default="localhost",
+        title="Server host",
+        examples=["localhost", "0.0.0.0", "127.0.0.1"],
+    )
+    """Host to bind server to."""
+
+    port: int = Field(
+        default=8001,
+        gt=0,
+        title="Server port",
+        examples=[8001, 8080, 9000],
+    )
+    """Port to listen on."""
+
+    raise_exceptions: bool = Field(
+        default=False,
+        title="Raise exceptions",
+    )
+    """Whether to raise exceptions during server start."""
+
+    cors_origins: list[str] = Field(
+        default_factory=lambda: ["*"],
+        title="CORS origins",
+        examples=[["*"], ["https://example.com", "https://app.com"]],
+    )
+    """Allowed CORS origins."""
+
+    serve_docs: bool = Field(default=True, title="Serve documentation")
+    """Whether to serve API documentation endpoints."""
+
+
+class ACPPoolServerConfig(BasePoolServerConfig):
+    """Configuration for ACP (Agent Client Protocol) server."""
+
+    type: Literal["acp"] = Field("acp", init=False)
+    """ACP server type."""
+
+    file_access: bool = Field(
+        default=True,
+        title="File access",
+    )
+    """Whether to allow file system access."""
+
+    terminal_access: bool = Field(
+        default=True,
+        title="Terminal access",
+    )
+    """Whether to allow terminal/shell access."""
+
+    raise_exceptions: bool = Field(
+        default=False,
+        title="Raise exceptions",
+    )
+    """Whether to raise exceptions during server start."""
+
+
+class AGUIPoolServerConfig(BasePoolServerConfig):
+    """Configuration for AGUI (AG-UI) server."""
+
+    type: Literal["agui"] = Field("agui", init=False)
+    """AGUI server type."""
+
+    host: str = Field(
+        default="localhost",
+        title="Server host",
+        examples=["localhost", "0.0.0.0", "127.0.0.1"],
+    )
+    """Host to bind server to."""
+
+    port: int = Field(
+        default=8002,
+        gt=0,
+        title="Server port",
+        examples=[8002, 8080, 9000],
+    )
+    """Port to listen on."""
+
+    raise_exceptions: bool = Field(
+        default=False,
+        title="Raise exceptions",
+    )
+    """Whether to raise exceptions during server start."""
+
+    cors_origins: list[str] = Field(
+        default_factory=lambda: ["*"],
+        title="CORS origins",
+        examples=[["*"], ["https://example.com", "https://app.com"]],
+    )
+    """Allowed CORS origins."""
+
+    serve_docs: bool = Field(default=True, title="Serve documentation")
+    """Whether to serve API documentation endpoints."""
+
+
+class OpenAIAPIPoolServerConfig(BasePoolServerConfig):
+    """Configuration for OpenAI-compatible API server."""
+
+    type: Literal["openai-api"] = Field("openai-api", init=False)
+    """OpenAI API server type."""
+
+    host: str = Field(
+        default="0.0.0.0",
+        title="Server host",
+        examples=["localhost", "0.0.0.0", "127.0.0.1"],
+    )
+    """Host to bind server to."""
+
+    port: int = Field(
+        default=8000,
+        gt=0,
+        title="Server port",
+        examples=[8000, 8080, 9000],
+    )
+    """Port to listen on."""
+
+    cors: bool = Field(default=True, title="Enable CORS")
+    """Whether to enable CORS middleware."""
+
+    docs: bool = Field(default=True, title="Enable API docs")
+    """Whether to enable API documentation endpoints."""
+
+    api_key: SecretStr | None = Field(
+        default=None,
+        title="API key",
+    )
+    """Optional API key for authentication."""
+
+    raise_exceptions: bool = Field(
+        default=False,
+        title="Raise exceptions",
+    )
+    """Whether to raise exceptions during server start."""
+
+    cors_origins: list[str] = Field(
+        default_factory=lambda: ["*"],
+        title="CORS origins",
+        examples=[["*"], ["https://example.com", "https://app.com"]],
+    )
+    """Allowed CORS origins."""
+
+
+PoolServerConfig = Annotated[
+    MCPPoolServerConfig
+    | A2APoolServerConfig
+    | ACPPoolServerConfig
+    | AGUIPoolServerConfig
+    | OpenAIAPIPoolServerConfig,
+    Field(discriminator="type"),
+]

agentpool_config/prompt_hubs.py

@@ -0,0 +1,105 @@
+"""Prompt models for agent configuration."""
+
+from __future__ import annotations
+
+from typing import Annotated, Literal
+
+from pydantic import ConfigDict, Field, SecretStr  # noqa: TC002
+from pydantic.networks import HttpUrl
+from schemez.schema import Schema
+
+
+class BasePromptHubConfig(Schema):
+    """Configuration for prompt providers."""
+
+    type: str = Field(init=False, title="Prompt hub type")
+    """Base prompt configuration."""
+
+    model_config = ConfigDict(frozen=True, use_attribute_docstrings=True, extra="forbid")
+
+
+class PromptLayerConfig(BasePromptHubConfig):
+    """Configuration for PromptLayer prompt provider."""
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "PromptLayer"})
+
+    type: Literal["promptlayer"] = Field("promptlayer", init=False)
+    """Configuration for PromptLayer prompt provider."""
+
+    api_key: SecretStr = Field(title="PromptLayer API key")
+    """API key for the PromptLayer API."""
+
+
+class LangfuseConfig(BasePromptHubConfig):
+    """Configuration for Langfuse prompt provider."""
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "Langfuse"})
+
+    type: Literal["langfuse"] = Field("langfuse", init=False)
+    """Configuration for Langfuse prompt provider."""
+
+    secret_key: SecretStr = Field(title="Langfuse secret key")
+    """Secret key for the Langfuse API."""
+
+    public_key: SecretStr = Field(title="Langfuse public key")
+    """Public key for the Langfuse API."""
+
+    host: HttpUrl = Field(
+        default=HttpUrl("https://cloud.langfuse.com"),
+        examples=["https://cloud.langfuse.com", "https://langfuse.example.com"],
+        title="Langfuse host",
+    )
+    """Langfuse host address."""
+
+    cache_ttl_seconds: int = Field(
+        default=60,
+        ge=0,
+        examples=[60, 300, 3600],
+        title="Cache TTL seconds",
+    )
+    """Cache TTL for responses in seconds."""
+
+    max_retries: int = Field(default=2, ge=0, examples=[1, 2, 5], title="Maximum retries")
+    """Maximum number of retries for failed requests."""
+
+    fetch_timeout_seconds: int = Field(
+        default=20,
+        ge=0,
+        examples=[10, 20, 60],
+        title="Fetch timeout seconds",
+    )
+    """Timeout for fetching responses in seconds."""
+
+
+class BraintrustConfig(BasePromptHubConfig):
+    """Configuration for Braintrust prompt provider."""
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "Braintrust"})
+
+    type: Literal["braintrust"] = Field("braintrust", init=False)
+    """Configuration for Braintrust prompt provider."""
+
+    api_key: SecretStr | None = Field(default=None, title="Braintrust API key")
+    """API key for the Braintrust API. Defaults to BRAINTRUST_API_KEY env var"""
+
+    project: str | None = Field(
+        default=None,
+        examples=["my_project", "ai_agents", "production"],
+        title="Braintrust project",
+    )
+    """Braintrust Project name."""
+
+
+class FabricConfig(BasePromptHubConfig):
+    """Configuration for Fabric GitHub prompt provider."""
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "Fabric"})
+
+    type: Literal["fabric"] = Field("fabric", init=False)
+    """Configuration for Fabric GitHub prompt provider."""
+
+
+PromptHubConfig = Annotated[
+    PromptLayerConfig | LangfuseConfig | FabricConfig | BraintrustConfig,
+    Field(discriminator="type"),
+]

agentpool_config/prompts.py

@@ -0,0 +1,185 @@
+"""Prompt models for AgentPool."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+import os
+from typing import Annotated, Any, Literal
+
+from pydantic import ConfigDict, Field, ImportString
+from schemez import Schema
+from upathtools import UPath
+
+from agentpool.log import get_logger
+
+
+logger = get_logger(__name__)
+
+MessageContentType = Literal["text", "resource", "image_url", "image_base64"]
+# Our internal role type (could include more roles)
+MessageRole = Literal["system", "user", "assistant", "tool"]
+
+
+class MessageContent(Schema):
+    """Content item in a message."""
+
+    type: MessageContentType = Field(
+        title="Content type",
+        examples=["text", "resource", "image_url"],
+    )
+    """Message content type."""
+
+    content: str = Field(
+        title="Content value",
+        examples=["Hello world", "file:///path/to/file.txt", "data:image/png;base64,..."],
+    )  # The actual content (text/uri/url/base64)
+    """The actual content (text/uri/url/base64)."""
+
+    alt_text: str | None = Field(
+        default=None,
+        title="Alternative text",
+        examples=["Image description", "Resource summary"],
+    )
+    """Alternative text for the content."""
+
+    model_config = ConfigDict(frozen=True)
+
+
+class PromptParameter(Schema):
+    """Prompt argument with validation information."""
+
+    name: str = Field(
+        title="Parameter name",
+        examples=["user_name", "task_description", "max_tokens"],
+    )
+    """Name of the argument as used in the prompt."""
+
+    description: str | None = Field(
+        default=None,
+        title="Parameter description",
+        examples=["Name of the user", "Description of the task to perform"],
+    )
+    """Human-readable description of the argument."""
+
+    required: bool = Field(default=False, title="Required parameter")
+    """Whether this argument must be provided when formatting the prompt."""
+
+    type_hint: ImportString[Any] = Field(
+        default="str",
+        title="Type hint",
+        examples=["str", "int", "bool", "list[str]"],
+    )
+    """Type annotation for the argument, defaults to str."""
+
+    default: Any | None = Field(default=None, title="Default value")
+    """Default value if argument is optional."""
+
+
+class PromptMessage(Schema):
+    """A message in a prompt template."""
+
+    role: MessageRole = Field(title="Message role", examples=["system", "user", "assistant"])
+    """Role of the message."""
+
+    content: str | MessageContent | list[MessageContent] = Field(
+        default="",
+        title="Message content",
+        examples=["You are a helpful assistant", "What is the weather like?"],
+    )
+    """Content of the message."""
+
+
+class BasePromptConfig(Schema):
+    """Base class for all prompts."""
+
+    name: str = Field(title="Prompt name", examples=["greeting", "code_review", "summarize_text"])
+    """Technical identifier (automatically set from config key during registration)."""
+
+    title: str | None = Field(
+        default=None,
+        title="Prompt title",
+        examples=["Greeting Assistant", "Code Review Helper", "Text Summarizer"],
+    )
+    """Title of the prompt."""
+
+    description: str = Field(
+        title="Prompt description",
+        examples=["A friendly greeting prompt", "Reviews code for best practices"],
+    )
+    """Human-readable description of what this prompt does."""
+
+    arguments: list[PromptParameter] = Field(default_factory=list, title="Prompt arguments")
+    """List of arguments that this prompt accepts."""
+
+    metadata: dict[str, Any] = Field(default_factory=dict, title="Prompt metadata")
+    """Additional metadata for storing custom prompt information."""
+    # messages: list[PromptMessage]
+
+
+class StaticPromptConfig(BasePromptConfig):
+    """Static prompt defined by message list."""
+
+    messages: list[PromptMessage] = Field(title="Prompt messages")
+    """List of messages that make up this prompt."""
+
+    type: Literal["text"] = Field(default="text", init=False, title="Prompt type")
+    """Discriminator field identifying this as a static text prompt."""
+
+
+class DynamicPromptConfig(BasePromptConfig):
+    """Dynamic prompt loaded from callable."""
+
+    import_path: str | Callable[..., Any] = Field(
+        title="Import path",
+        examples=["mymodule.create_prompt", "utils.prompts:generate_greeting"],
+    )
+    """Dotted import path to the callable that generates the prompt."""
+
+    template: str | None = Field(
+        default=None,
+        title="Template string",
+        examples=["Hello {{ name }}!", "Task: {{ task }}\nInstructions: {{ instructions }}"],
+    )
+    """Optional template string for formatting the callable's output."""
+
+    completions: dict[str, str] | None = Field(default=None, title="Completion mappings")
+    """Optional mapping of argument names to completion functions."""
+
+    type: Literal["function"] = Field(default="function", init=False, title="Prompt type")
+    """Discriminator field identifying this as a function-based prompt."""
+
+
+class FilePromptConfig(BasePromptConfig):
+    """Prompt loaded from a file.
+
+    This type of prompt loads its content from a file, allowing for longer or more
+    complex prompts to be managed in separate files. The file content is loaded
+    and parsed according to the specified format.
+    """
+
+    path: str | os.PathLike[str] | UPath = Field(
+        title="File path",
+        examples=["prompts/greeting.txt", "/path/to/prompt.md", "templates/system.j2"],
+    )
+    """Path to the file containing the prompt content."""
+
+    fmt: Literal["text", "markdown", "jinja2"] = Field(
+        default="text",
+        alias="format",
+        title="File format",
+        examples=["text", "markdown", "jinja2"],
+    )
+    """Format of the file content (text, markdown, or jinja2 template)."""
+
+    type: Literal["file"] = Field(default="file", init=False, title="Prompt type")
+    """Discriminator field identifying this as a file-based prompt."""
+
+    watch: bool = Field(default=False, title="Watch for changes")
+    """Whether to watch the file for changes and reload automatically."""
+
+
+# Type to use in configuration
+PromptConfig = Annotated[
+    StaticPromptConfig | DynamicPromptConfig | FilePromptConfig,
+    Field(discriminator="type"),
+]

agentpool_config/resources.py

@@ -0,0 +1,33 @@
+"""Models for resource information."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Self
+
+
+if TYPE_CHECKING:
+    from mcp.types import Resource as MCPResource
+
+
+@dataclass
+class ResourceInfo:
+    """Information about an available resource.
+
+    This class provides essential information about a resource that can be loaded.
+    Use the resource name with load_resource() to access the actual content.
+    """
+
+    name: str
+    """Name of the resource, use this with load_resource()"""
+
+    uri: str
+    """URI identifying the resource location"""
+
+    description: str | None = None
+    """Optional description of the resource's content or purpose"""
+
+    @classmethod
+    async def from_mcp_resource(cls, resource: MCPResource) -> Self:
+        """Create ResourceInfo from MCP resource."""
+        return cls(name=resource.name, uri=str(resource.uri), description=resource.description)