agentpool 2.1.9__py3-none-any.whl

agentpool_config/workers.py

@@ -0,0 +1,86 @@
+"""Worker configuration models."""
+
+from __future__ import annotations
+
+from typing import Annotated, Literal
+
+from pydantic import ConfigDict, Field
+from schemez import Schema
+
+
+class BaseWorkerConfig(Schema):
+    """Base configuration for workers.
+
+    Workers are nodes that can be registered as tools with a parent node.
+    This allows building hierarchies of specialized nodes.
+    """
+
+    name: str = Field(
+        examples=["web_agent", "code_analyzer", "data_processor"],
+        title="Worker node name",
+    )
+    """Name of the node to use as a worker."""
+
+    model_config = ConfigDict(frozen=True)
+
+
+class TeamWorkerConfig(BaseWorkerConfig):
+    """Configuration for team workers.
+
+    Team workers allow using entire teams as tools for other nodes.
+    """
+
+    type: Literal["team"] = Field("team", init=False)
+    """Team worker configuration."""
+
+
+class AgentWorkerConfig(BaseWorkerConfig):
+    """Configuration for agent workers.
+
+    Agent workers provide advanced features like history management and
+    context sharing between agents.
+    """
+
+    type: Literal["agent"] = Field("agent", init=False)
+    """Agent worker configuration."""
+
+    reset_history_on_run: bool = Field(default=True, title="Reset history on run")
+    """Whether to clear worker's conversation history before each run.
+    True (default): Fresh conversation each time
+    False: Maintain conversation context between runs
+    """
+
+    pass_message_history: bool = Field(default=False, title="Pass message history")
+    """Whether to pass parent agent's message history to worker.
+    True: Worker sees parent's conversation context
+    False (default): Worker only sees current request
+    """
+
+
+class ACPAgentWorkerConfig(BaseWorkerConfig):
+    """Configuration for ACP agent workers.
+
+    ACP agent workers allow using external ACP-compatible agents as tools.
+    Unlike regular agents, ACP agents manage their own history server-side,
+    so history options are not available.
+    """
+
+    type: Literal["acp_agent"] = Field("acp_agent", init=False)
+    """ACP agent worker configuration."""
+
+
+class AGUIAgentWorkerConfig(BaseWorkerConfig):
+    """Configuration for AG-UI agent workers.
+
+    AG-UI agent workers allow using remote AG-UI protocol servers as tools.
+    Like ACP agents, they manage their own state server-side.
+    """
+
+    type: Literal["agui_agent"] = Field("agui_agent", init=False)
+    """AG-UI agent worker configuration."""
+
+
+WorkerConfig = Annotated[
+    TeamWorkerConfig | AgentWorkerConfig | ACPAgentWorkerConfig | AGUIAgentWorkerConfig,
+    Field(discriminator="type"),
+]

agentpool_prompts/__init__.py

@@ -0,0 +1 @@
+"""Prompts package."""

agentpool_prompts/braintrust_hub.py

@@ -0,0 +1,235 @@
+"""Braintrust prompt provider implementation."""
+
+from __future__ import annotations
+
+import contextlib
+from dataclasses import dataclass
+from datetime import datetime
+import os
+from typing import Any
+
+from braintrust import init_logger, load_prompt
+import httpx
+
+from agentpool.prompts.base import BasePromptProvider
+from agentpool_config.prompt_hubs import BraintrustConfig
+
+
+@dataclass
+class BraintrustPromptMetadata:
+    """Metadata for a Braintrust prompt."""
+
+    id: str
+    """Unique identifier for the prompt."""
+
+    name: str
+    """Name of the prompt."""
+
+    slug: str
+    """Unique slug identifier for the prompt."""
+
+    description: str | None
+    """Textual description of the prompt."""
+
+    project_id: str
+    """Project ID the prompt belongs to."""
+
+    org_id: str
+    """Organization ID."""
+
+    created: datetime | None
+    """Creation timestamp."""
+
+    tags: list[str]
+    """List of tags associated with the prompt."""
+
+    function_type: str | None
+    """Type of function (llm, scorer, task, tool)."""
+
+    has_variables: bool
+    """Whether the prompt contains template variables."""
+
+    model: str | None
+    """Default model specified in prompt options."""
+
+    @property
+    def web_url(self) -> str:
+        """URL to view this prompt in Braintrust web interface."""
+        return f"https://www.braintrustdata.com/app/prompt/{self.slug}"
+
+    @classmethod
+    def from_api_object(cls, obj: dict[str, Any]) -> BraintrustPromptMetadata:
+        """Create metadata from Braintrust API response object."""
+        created = None
+        if obj.get("created"):
+            with contextlib.suppress(ValueError, AttributeError):
+                created = datetime.fromisoformat(obj["created"].replace("Z", "+00:00"))
+
+        # Extract model from prompt_data.options.model if available
+        model = None
+        if prompt_data := obj.get("prompt_data"):  # noqa: SIM102
+            if options := prompt_data.get("options"):
+                model = options.get("model")
+
+        # Check for template variables in prompt content
+        has_variables = False
+        if prompt_data := obj.get("prompt_data"):  # noqa: SIM102
+            if prompt := prompt_data.get("prompt"):
+                if prompt.get("type") == "chat" and prompt.get("messages"):
+                    # Check for Jinja2 template variables in message content
+                    for msg in prompt["messages"]:
+                        content = msg.get("content", "")
+                        if isinstance(content, str) and ("{{" in content or "{%" in content):
+                            has_variables = True
+                            break
+                elif prompt.get("type") == "completion":
+                    content = prompt.get("content", "")
+                    if isinstance(content, str) and ("{{" in content or "{%" in content):
+                        has_variables = True
+
+        return cls(
+            id=obj["id"],
+            name=obj["name"],
+            slug=obj["slug"],
+            description=obj.get("description"),
+            project_id=obj["project_id"],
+            org_id=obj["org_id"],
+            created=created,
+            tags=obj.get("tags") or [],
+            function_type=obj.get("function_type"),
+            has_variables=has_variables,
+            model=model,
+        )
+
+
+class BraintrustPromptHub(BasePromptProvider):
+    """Braintrust prompt provider implementation."""
+
+    def __init__(self, config: BraintrustConfig) -> None:
+        self.config = config or BraintrustConfig()
+        api_key = self.config.api_key.get_secret_value() if self.config.api_key else None
+        key = api_key or os.getenv("BRAINTRUST_API_KEY")
+        init_logger(api_key=key, project=self.config.project)
+        self.api_key = key
+        self._prompt_metadata: dict[str, BraintrustPromptMetadata] = {}
+
+    async def get_prompt(
+        self,
+        name: str,
+        version: str | None = None,
+        variables: dict[str, Any] | None = None,
+    ) -> str:
+        """Get and optionally compile a prompt from Braintrust."""
+        import jinjarope
+
+        env = jinjarope.Environment(enable_async=True)
+        prompt = load_prompt(slug=name, version=version, project=self.config.project)
+        assert prompt.prompt
+        string = prompt.prompt.messages[0].content  # type: ignore
+        assert isinstance(string, str)
+        return await env.render_string_async(string, **(variables or {}))
+
+    async def list_prompts(self) -> list[str]:
+        """List available prompts from Braintrust with pagination support."""
+        if not self.api_key:
+            raise RuntimeError("API key is required to list prompts")
+
+        params: dict[str, Any] = {"limit": 100}  # Get up to 100 per page
+        if self.config.project:  # Add project filter if specified
+            params["project_name"] = self.config.project
+
+        all_prompts = []
+        async with httpx.AsyncClient() as client:
+            while True:
+                url = "https://api.braintrust.dev/v1/prompt"
+                headers = {"Authorization": f"Bearer {self.api_key}"}
+                response = await client.get(url, headers=headers, params=params)
+                match response.status_code:
+                    case 401:
+                        raise RuntimeError("Unauthorized: Check your Braintrust API key")
+                    case 403:
+                        msg = "Forbidden: API key doesn't have permission to list prompts"
+                        raise RuntimeError(msg)
+                    case 200:
+                        msg = f"Failed to list prompts: {response.status_code} - {response.text}"
+                        raise RuntimeError(msg)
+                try:
+                    data = response.json()
+                except Exception as e:
+                    msg = f"Failed to parse response JSON: {e}"
+                    raise RuntimeError(msg) from e
+
+                objects = data.get("objects", [])
+                if not objects:
+                    break
+
+                # Parse metadata and collect prompt names
+                for obj in objects:
+                    if obj.get("name") or obj.get("slug"):
+                        metadata = BraintrustPromptMetadata.from_api_object(obj)
+                        prompt_name = metadata.name or metadata.slug
+                        self._prompt_metadata[prompt_name] = metadata
+                        all_prompts.append(prompt_name)
+
+                # Check if there are more pages
+                if len(objects) < params["limit"]:
+                    break
+
+                # Set up pagination for next request
+                last_id = objects[-1].get("id")
+                if last_id:
+                    params["starting_after"] = last_id
+                else:
+                    break
+
+        return all_prompts
+
+    def get_prompt_metadata(self, name: str) -> BraintrustPromptMetadata | None:
+        """Get metadata for a specific prompt."""
+        return self._prompt_metadata.get(name)
+
+    def get_all_metadata(self) -> dict[str, BraintrustPromptMetadata]:
+        """Get all parsed prompt metadata."""
+        return self._prompt_metadata.copy()
+
+    def filter_prompts_by_tag(self, tag: str) -> list[str]:
+        """Filter prompts by tag."""
+        return [name for name, metadata in self._prompt_metadata.items() if tag in metadata.tags]
+
+    def filter_prompts_by_function_type(self, function_type: str) -> list[str]:
+        """Filter prompts by function type (llm, scorer, task, tool)."""
+        return [
+            name
+            for name, metadata in self._prompt_metadata.items()
+            if metadata.function_type == function_type
+        ]
+
+    def filter_prompts_with_variables(self) -> list[str]:
+        """Get prompts that contain template variables."""
+        return [name for name, metadata in self._prompt_metadata.items() if metadata.has_variables]
+
+    def get_prompts_by_model(self, model: str) -> list[str]:
+        """Get prompts configured for a specific model."""
+        return [name for name, metadata in self._prompt_metadata.items() if metadata.model == model]
+
+
+if __name__ == "__main__":
+    import anyio
+
+    from agentpool_config.prompt_hubs import BraintrustConfig
+
+    config = BraintrustConfig(project="test")
+    prompt_hub = BraintrustPromptHub(config)
+
+    async def main() -> None:
+        # List available prompts
+        print("Available prompts:")
+        try:
+            prompts = await prompt_hub.list_prompts()
+            print(f"Found {len(prompts)} prompts:")
+            for prompt in prompts[:10]:  # Show first 10
+                print(f"- {prompt}")
+        except Exception as e:  # noqa: BLE001
+            print(f"Error listing prompts: {e}")
+
+    anyio.run(main)

agentpool_prompts/fabric.py

@@ -0,0 +1,75 @@
+"""Fabric GitHub prompt provider implementation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import httpx
+
+from agentpool.prompts.base import BasePromptProvider
+
+
+if TYPE_CHECKING:
+    from agentpool_config.prompt_hubs import FabricConfig
+
+
+class FabricPromptHub(BasePromptProvider):
+    """Provider for prompts from Fabric GitHub repository."""
+
+    _BASE_URL = "https://raw.githubusercontent.com/danielmiessler/fabric/main"
+    _API_URL = "https://api.github.com/repos/danielmiessler/fabric/contents/data/patterns"
+
+    def __init__(self, config: FabricConfig) -> None:
+        self.config = config
+
+    async def get_prompt(
+        self,
+        name: str,
+        version: str | None = None,  # Ignored for Fabric
+        variables: dict[str, Any] | None = None,
+    ) -> str:
+        """Get prompt from Fabric GitHub repository."""
+        system_url = f"{self._BASE_URL}/data/patterns/{name}/system.md"
+        user_url = f"{self._BASE_URL}/data/patterns/{name}/user.md"
+
+        async with httpx.AsyncClient() as client:
+            # Try system prompt first
+            if (response := await client.get(system_url)).status_code == 200:  # noqa: PLR2004
+                return response.text
+            if (response := await client.get(user_url)).status_code == 200:  # noqa: PLR2004
+                return response.text
+            msg = f"Template {name!r} not found in Fabric repository"
+            raise ValueError(msg)
+
+    async def list_prompts(self) -> list[str]:
+        """List available prompts from Fabric repository."""
+        headers = {"Accept": "application/vnd.github.v3+json"}
+
+        async with httpx.AsyncClient() as client:
+            response = await client.get(self._API_URL, headers=headers)
+
+            if response.status_code != 200:  # noqa: PLR2004
+                raise RuntimeError(f"Failed to list prompts: {response.status_code}")
+
+            content = response.json()
+            return [item["name"] for item in content if item["type"] == "dir"]
+
+
+if __name__ == "__main__":
+    import anyio
+
+    from agentpool_config.prompt_hubs import FabricConfig
+
+    async def main() -> None:
+        hub = FabricPromptHub(FabricConfig())
+        # List available prompts
+        print("Available prompts:")
+        prompts = await hub.list_prompts()
+        print("\n".join(f"- {p}" for p in prompts[:5]))  # Show first 5
+
+        # Get a specific prompt
+        print("\nFetching 'summarize' prompt:")
+        prompt = await hub.get_prompt("summarize")
+        print(f"\n{prompt[:200]}...")  # Show first 200 chars
+
+    anyio.run(main)

agentpool_prompts/langfuse_hub.py

@@ -0,0 +1,79 @@
+"""Langfuse prompt provider implementation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langfuse import Langfuse  # pyright: ignore
+
+from agentpool.prompts.base import BasePromptProvider
+
+
+if TYPE_CHECKING:
+    from agentpool_config.prompt_hubs import LangfuseConfig
+
+
+class LangfusePromptHub(BasePromptProvider):
+    """Langfuse prompt provider implementation."""
+
+    name = "langfuse"
+    supports_versions = True
+    supports_variables = True
+
+    def __init__(self, config: LangfuseConfig) -> None:
+        self.config = config
+        secret = config.secret_key.get_secret_value()
+        pub = config.public_key.get_secret_value()
+        self._client = Langfuse(secret_key=secret, public_key=pub, host=str(config.host))
+
+        from langfuse.api.client import FernLangfuse
+
+        self._api_client = FernLangfuse(
+            base_url=str(config.host),
+            x_langfuse_public_key=pub,
+            username=pub,
+            password=secret,
+        )
+
+    async def get_prompt(
+        self,
+        name: str,
+        version: str | None = None,
+        variables: dict[str, Any] | None = None,
+    ) -> str:
+        """Get and optionally compile a prompt from Langfuse."""
+        prompt = self._client.get_prompt(
+            name,
+            type="text",
+            version=int(version) if version else None,
+            cache_ttl_seconds=self.config.cache_ttl_seconds,
+            max_retries=self.config.max_retries,
+            fetch_timeout_seconds=self.config.fetch_timeout_seconds,
+        )
+        if variables:
+            return prompt.compile(**variables)
+        return prompt.prompt
+
+    async def list_prompts(self) -> list[str]:
+        """List available prompts from Langfuse."""
+        try:
+            response = self._api_client.prompts.list()
+            return [prompt_meta.name for prompt_meta in response.data]
+        except Exception:  # noqa: BLE001
+            # Fallback to empty list if listing fails
+            return []
+
+
+if __name__ == "__main__":
+    import anyio
+    from pydantic import SecretStr
+
+    from agentpool_config.prompt_hubs import LangfuseConfig
+
+    config = LangfuseConfig(secret_key=SecretStr("test"), public_key=SecretStr(""))
+    prompt_hub = LangfusePromptHub(config)
+
+    async def main() -> None:
+        print(await prompt_hub.list_prompts())
+
+    anyio.run(main)

agentpool_prompts/promptlayer_provider.py

@@ -0,0 +1,59 @@
+"""PromptLayer prompt provider implementation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from promptlayer import PromptLayer  # type: ignore[import-untyped]
+
+from agentpool.prompts.base import BasePromptProvider
+
+
+if TYPE_CHECKING:
+    from agentpool_config.prompt_hubs import PromptLayerConfig
+
+
+class PromptLayerProvider(BasePromptProvider):
+    """PromptLayer provider."""
+
+    name = "promptlayer"
+    supports_versions = True
+
+    def __init__(self, config: PromptLayerConfig) -> None:
+        self.client = PromptLayer(
+            api_key=config.api_key.get_secret_value() if config.api_key else None
+        )
+
+    async def get_prompt(
+        self,
+        name: str,
+        version: str | None = None,
+        variables: dict[str, Any] | None = None,
+    ) -> str:
+        # PromptLayer primarily tracks prompts used with their API
+        # But also allows template management
+        dct = self.client.templates.get(name)
+        template = dct["prompt_template"]
+        return (
+            str(template.get("content")) if "content" in template else str(template.get("messages"))
+        )
+
+    async def list_prompts(self) -> list[str]:
+        """List available prompts from Fabric repository."""
+        dct = self.client.templates.all()
+        return [prompt["prompt_name"] for prompt in dct]
+
+
+if __name__ == "__main__":
+    import anyio
+    from pydantic import SecretStr
+
+    from agentpool_config.prompt_hubs import PromptLayerConfig
+
+    async def main() -> None:
+        config = PromptLayerConfig(api_key=SecretStr("pl_480ead79b098fc25c63cdb4c95115deb"))
+        provider = PromptLayerProvider(config)
+        prompt = await provider.list_prompts()
+        print(prompt)
+
+    anyio.run(main)

agentpool_server/__init__.py

@@ -0,0 +1,9 @@
+"""AgentPool Server implementations."""
+
+from agentpool_server.a2a_server import A2AServer
+from agentpool_server.aggregating_server import AggregatingServer
+from agentpool_server.agui_server import AGUIServer
+from agentpool_server.base import BaseServer
+from agentpool_server.http_server import HTTPServer
+
+__all__ = ["A2AServer", "AGUIServer", "AggregatingServer", "BaseServer", "HTTPServer"]

agentpool_server/a2a_server/__init__.py

@@ -0,0 +1,5 @@
+"""A2A server."""
+
+from .server import A2AServer
+
+__all__ = ["A2AServer"]

agentpool_server/a2a_server/a2a_types.py

@@ -0,0 +1,41 @@
+"""A2A types."""
+
+from __future__ import annotations
+
+from typing import Any, TypedDict
+
+
+class A2ARequest(TypedDict):
+    """A2A JSON-RPC request format."""
+
+    jsonrpc: str
+    method: str
+    params: dict[str, Any]
+    id: str | int | None
+
+
+class A2AResponse(TypedDict):
+    """A2A JSON-RPC response format."""
+
+    jsonrpc: str
+    id: str | int | None
+    result: dict[str, Any]
+
+
+class TaskData(TypedDict):
+    """Task storage data format."""
+
+    id: str
+    status: str
+    data: A2ARequest
+    result: dict[str, Any] | None
+    error: str | None
+    context_id: str | None
+
+
+class TaskStatus(TypedDict):
+    """Task status response format."""
+
+    status: str
+    result: dict[str, Any] | None
+    error: str | None