agentpool 2.1.9__py3-none-any.whl

agentpool/observability/observability_registry.py

@@ -0,0 +1,97 @@
+"""Simplified observability registry using Logfire with single backend."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+import logfire
+
+from agentpool.log import get_logger
+
+
+if TYPE_CHECKING:
+    from agentpool_config.observability import BaseObservabilityConfig, ObservabilityConfig
+
+logger = get_logger(__name__)
+
+
+class ObservabilityRegistry:
+    """Simplified registry that configures Logfire for single backend export."""
+
+    def __init__(self) -> None:
+        self._configured = False
+
+    def configure_observability(self, observability_config: ObservabilityConfig) -> None:
+        """Configure Logfire for single backend export.
+
+        Args:
+            observability_config: Configuration for observability
+        """
+        if not observability_config.enabled or not observability_config.provider:
+            logger.debug("Observability disabled or no provider configured")
+            return
+
+        if self._configured:
+            logger.warning("Observability already configured, skipping")
+            return
+
+        config = observability_config.provider
+        if not config.enabled:
+            logger.debug("Provider is disabled", provider=config.type)
+            return
+
+        _setup_otel_environment(config)  # Configure OTEL env variables based on provider
+        logfire.configure(
+            service_name=config.service_name,
+            environment=config.environment,
+            console=False,
+            send_to_logfire=(config.type == "logfire"),
+        )
+        logfire.instrument_pydantic_ai()
+        logfire.instrument_mcp()
+        # Note: structlog logs are captured via StructlogProcessor in log.py
+
+        self._configured = True
+        logger.info("Configured observability", provider=config.type)
+
+
+def _setup_otel_environment(config: BaseObservabilityConfig) -> None:
+    """Set up OTEL environment variables for the configured backend."""
+    # Get endpoint and headers from config
+    endpoint = getattr(config, "_endpoint", getattr(config, "endpoint", None))
+    headers = getattr(config, "_headers", getattr(config, "headers", {}))
+
+    if not endpoint:
+        logger.warning("No endpoint found", provider=config.type)
+        return
+
+    # Set standard OTEL environment variables
+    os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = endpoint
+    os.environ["OTEL_EXPORTER_OTLP_PROTOCOL"] = config.protocol
+
+    # Set headers if available
+    if headers:
+        header_str = ",".join(f"{k}={v}" for k, v in headers.items())
+        os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = header_str
+
+    # Set resource attributes
+    resource_attrs = []
+    if config.service_name:
+        resource_attrs.append(f"service.name={config.service_name}")
+    if config.environment:
+        resource_attrs.append(f"deployment.environment.name={config.environment}")
+
+    if resource_attrs:
+        os.environ["OTEL_RESOURCE_ATTRIBUTES"] = ",".join(resource_attrs)
+
+    logger.debug(
+        "Set OTEL environment",
+        endpoint=endpoint,
+        protocol=config.protocol,
+        headers=headers,
+    )
+
+
+# Global registry instance
+registry = ObservabilityRegistry()

agentpool/prompts/__init__.py

@@ -0,0 +1 @@
+"""Prompt template management."""

agentpool/prompts/base.py

@@ -0,0 +1,27 @@
+"""Prompt models for agent configuration."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, ClassVar
+
+
+class BasePromptProvider(ABC):
+    """Base class for external prompt providers."""
+
+    name: ClassVar[str]
+    supports_versions: ClassVar[bool] = False
+    supports_variables: ClassVar[bool] = False
+
+    @abstractmethod
+    async def get_prompt(
+        self,
+        name: str,
+        version: str | None = None,
+        variables: dict[str, Any] | None = None,
+    ) -> str:
+        """Get a prompt by ID."""
+
+    async def list_prompts(self) -> list[str]:
+        """List available prompts."""
+        return []  # Default implementation returns empty list

agentpool/prompts/builtin_provider.py

@@ -0,0 +1,75 @@
+"""Builtin prompt provider."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from agentpool.prompts.base import BasePromptProvider
+from agentpool_config.system_prompts import StaticPromptConfig
+
+
+if TYPE_CHECKING:
+    from agentpool_config.system_prompts import StaticPromptConfig
+
+
+class BuiltinPromptProvider(BasePromptProvider):
+    """Default provider using system prompts."""
+
+    supports_variables = True
+    name = "builtin"
+
+    def __init__(self, manifest_prompts: dict[str, StaticPromptConfig]) -> None:
+        from jinjarope import Environment
+
+        self.prompts = manifest_prompts
+        self.env = Environment(autoescape=False, enable_async=True)
+
+    async def get_prompt(
+        self,
+        name: str,
+        version: str | None = None,
+        variables: dict[str, Any] | None = None,
+    ) -> str:
+        """Get prompt content as string."""
+        from jinja2 import Template, meta
+
+        if name not in self.prompts:
+            msg = f"Prompt not found: {name}"
+            raise KeyError(msg)
+
+        prompt = self.prompts[name]
+        content = prompt.content
+
+        # Parse template to find required variables
+        ast = self.env.parse(content)
+        required_vars = meta.find_undeclared_variables(ast)
+        if variables and (unknown_vars := (set(variables) - required_vars)):
+            vars_ = ", ".join(unknown_vars)
+            msg = f"Unknown variables for prompt {name}: {vars_}"
+            raise KeyError(msg)
+
+        if required_vars:
+            if not variables:
+                req = ", ".join(required_vars)
+                msg = f"Prompt {name} requires variables: {req}"
+                raise KeyError(msg)
+
+            # Check for missing required variables
+            missing_vars = required_vars - set(variables or {})
+            if missing_vars:
+                vars_ = ", ".join(missing_vars)
+                msg = f"Missing required variables for prompt {name}: {vars_}"
+                raise KeyError(msg)
+
+            try:
+                template = Template(content, enable_async=True)
+                content = await template.render_async(**variables)
+            except Exception as e:
+                msg = f"Failed to render prompt {name}: {e}"
+                raise ValueError(msg) from e
+
+        return content
+
+    async def list_prompts(self) -> list[str]:
+        """List available prompt identifiers."""
+        return list(self.prompts.keys())

agentpool/prompts/conversion_manager.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import TYPE_CHECKING, Any
+
+from agentpool.mime_utils import guess_type
+from agentpool_config.converters import ConversionConfig
+
+
+if TYPE_CHECKING:
+    from docler.converters.base import DocumentConverter
+    from upathtools import JoinablePathLike
+
+
+class ConversionManager:
+    """Manages document conversion using configured providers.
+
+    In order to not make things super complex, all Converters will be implemented as sync.
+    The manager will handle async I/O and thread pooling.
+    """
+
+    def __init__(self, config: ConversionConfig | list[DocumentConverter]) -> None:
+        if isinstance(config, list):
+            self.config = ConversionConfig()
+            self._converters = config
+        else:
+            self.config = config
+            self._converters = self._setup_converters()
+        self._executor = ThreadPoolExecutor(max_workers=3)
+
+    def __del__(self) -> None:
+        self._executor.shutdown(wait=False)
+
+    def supports_file(self, path: JoinablePathLike) -> bool:
+        """Check if any converter supports the file."""
+        mime_type = guess_type(str(path)) or "application/octet-stream"
+        return any(c.supports_mime_type(mime_type) for c in self._converters)
+
+    def supports_content(self, content: Any, mime_type: str | None = None) -> bool:
+        """Check if any converter supports the file."""
+        return any(c.supports_mime_type(content) for c in self._converters)
+
+    def _setup_converters(self) -> list[DocumentConverter]:
+        """Create converter instances from config."""
+        return [i.get_provider() for i in self.config.providers or []]
+        # Always add PlainConverter as fallback
+        # if it gets configured by user, that one gets preference.
+
+    async def convert_file(self, path: JoinablePathLike) -> str:
+        """Convert file using first supporting converter."""
+        loop = asyncio.get_running_loop()
+        mime_type = guess_type(str(path)) or "text/plain"
+
+        for converter in self._converters:
+            # Run support check in thread pool
+            supports = await loop.run_in_executor(
+                self._executor, converter.supports_mime_type, mime_type
+            )
+            if not supports:
+                continue
+            # Run conversion in thread pool
+
+            content = await loop.run_in_executor(
+                self._executor,
+                converter.convert_file,
+                path,
+            )
+        return str(content)
+
+    async def convert_content(self, content: Any, mime_type: str | None = None) -> str:
+        """Convert content using first supporting converter."""
+        loop = asyncio.get_running_loop()
+
+        for converter in self._converters:
+            # Run support check in thread pool
+            supports = await loop.run_in_executor(
+                self._executor, converter.supports_mime_type, mime_type or "text/plain"
+            )
+            if not supports:
+                continue
+
+            doc = await converter.convert_content(content, mime_type or "text/plain")
+            return doc.content
+
+        return str(content)  # Fallback for unsupported content
+
+
+if __name__ == "__main__":
+    from docler.configs.converter_configs import MarkItDownConfig
+
+    from agentpool_config.converters import ConversionConfig
+
+    config = ConversionConfig(providers=[MarkItDownConfig()])
+    manager = ConversionManager(config)

agentpool/prompts/convert.py

@@ -0,0 +1,96 @@
+"""The main Agent. Can do all sort of crazy things."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+from pydantic_ai import AudioUrl, BinaryContent, BinaryImage, DocumentUrl, ImageUrl, VideoUrl
+from toprompt import to_prompt
+from upathtools import UPath, read_path, to_upath
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from pydantic_ai import UserContent
+
+    from agentpool.common_types import PromptCompatible
+
+
+async def convert_prompts(
+    prompts: Sequence[PromptCompatible],
+) -> list[UserContent]:
+    """Convert prompts to pydantic-ai UserContent format.
+
+    Handles:
+    - PIL Images -> BinaryImage
+    - UPath/PathLike -> Auto-detect and convert to appropriate Content
+    - Regular prompts -> str via to_prompt
+    - pydantic-ai content objects -> pass through
+    """
+    result: list[UserContent] = []
+    for p in prompts:
+        match p:
+            case os.PathLike() | UPath():
+                from agentpool.mime_utils import guess_type
+
+                path_obj = to_upath(p)
+                mime_type = guess_type(str(path_obj))
+
+                match mime_type:
+                    case "application/pdf":
+                        # For http(s) URLs, use DocumentUrl; otherwise read binary
+                        if path_obj.protocol in {"http", "https"}:
+                            result.append(DocumentUrl(url=str(path_obj)))
+                        else:
+                            data = await read_path(path_obj, mode="rb")
+                            result.append(BinaryContent(data=data, media_type="application/pdf"))
+                    case str() if mime_type.startswith("image/"):
+                        if path_obj.protocol in {"http", "https"}:
+                            result.append(ImageUrl(url=str(path_obj)))
+                        else:
+                            data = await read_path(path_obj, mode="rb")
+                            result.append(BinaryImage(data=data, media_type=mime_type))
+                    case str() if mime_type.startswith("audio/"):
+                        if path_obj.protocol in {"http", "https"}:
+                            result.append(AudioUrl(url=str(path_obj)))
+                        else:
+                            data = await read_path(path_obj, mode="rb")
+                            result.append(BinaryContent(data=data, media_type=mime_type))
+                    case str() if mime_type.startswith("video/"):
+                        if path_obj.protocol in {"http", "https"}:
+                            result.append(VideoUrl(url=str(path_obj)))
+                        else:
+                            # Video as binary content
+                            data = await read_path(path_obj, mode="rb")
+                            result.append(BinaryContent(data=data, media_type=mime_type))
+                    case _:
+                        # Non-media or unknown type - read as text
+                        text = await read_path(path_obj)
+                        result.append(text)
+
+            case (
+                str()
+                | ImageUrl()
+                | AudioUrl()
+                | DocumentUrl()
+                | VideoUrl()
+                | BinaryContent()
+                | BinaryImage()
+            ):
+                # Already a valid UserContent type
+                result.append(p)
+
+            case _:
+                # Use to_prompt for anything else (PIL images, pydantic models, etc.)
+                result.append(await to_prompt(p))
+    return result
+
+
+async def format_prompts(prompts: Sequence[UserContent]) -> str:
+    """Format prompts for human readability using to_prompt."""
+    from toprompt import to_prompt
+
+    parts = [await to_prompt(p) for p in prompts]
+    return "\n\n".join(parts)

agentpool/prompts/manager.py

@@ -0,0 +1,204 @@
+"""Prompt Manager."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Any
+
+from anyenv import method_spawner
+
+from agentpool.log import get_logger
+from agentpool.prompts.builtin_provider import BuiltinPromptProvider
+from agentpool.utils.tasks import TaskManager
+from agentpool_config.prompt_hubs import (
+    BraintrustConfig,
+    FabricConfig,
+    LangfuseConfig,
+    PromptLayerConfig,
+)
+
+
+if TYPE_CHECKING:
+    from agentpool.prompts.base import BasePromptProvider
+    from agentpool_config.system_prompts import PromptLibraryConfig
+
+logger = get_logger(__name__)
+
+
+def parse_prompt_reference(reference: str) -> tuple[str, str, str | None, dict[str, str]]:
+    """Parse a prompt reference string.
+
+    Args:
+        reference: Format [provider:]name[@version][?var1=val1,var2=val2]
+
+    Returns:
+        Tuple of (provider, identifier, version, variables)
+        Provider defaults to "builtin" if not specified
+    """
+    provider = "builtin"
+    version = None
+    variables: dict[str, str] = {}
+
+    # Split provider and rest
+    if ":" in reference:
+        provider, identifier = reference.split(":", 1)
+    else:
+        identifier = reference
+
+    # Handle version
+    if "@" in identifier:
+        identifier, version = identifier.split("@", 1)
+
+    # Handle query parameters
+    if "?" in identifier:
+        identifier, query = identifier.split("?", 1)
+        for pair in query.split(","):
+            if "=" not in pair:
+                continue
+            key, value = pair.split("=", 1)
+            variables[key.strip()] = value.strip()
+
+    return provider, identifier.strip(), version, variables
+
+
+class PromptManager:
+    """Manages multiple prompt providers.
+
+    Handles:
+    - Provider initialization and cleanup
+    - Prompt reference parsing and resolution
+    - Access to prompts from different sources
+    """
+
+    def __init__(self, config: PromptLibraryConfig) -> None:
+        """Initialize prompt manager.
+
+        Args:
+            config: Prompt configuration including providers
+        """
+        super().__init__()
+        self.config = config
+        self.task_manager = TaskManager()
+        self.providers: dict[str, BasePromptProvider] = {}
+
+        # Always register builtin provider
+        self.providers["builtin"] = BuiltinPromptProvider(config.system_prompts)
+
+        # Register configured providers
+        for provider_config in config.providers:
+            match provider_config:
+                case LangfuseConfig():
+                    from agentpool_prompts.langfuse_hub import LangfusePromptHub
+
+                    self.providers["langfuse"] = LangfusePromptHub(provider_config)
+
+                case FabricConfig():
+                    from agentpool_prompts.fabric import FabricPromptHub
+
+                    self.providers["fabric"] = FabricPromptHub(provider_config)
+
+                case BraintrustConfig():
+                    from agentpool_prompts.braintrust_hub import BraintrustPromptHub
+
+                    self.providers["braintrust"] = BraintrustPromptHub(provider_config)
+
+                case PromptLayerConfig():
+                    from agentpool_prompts.promptlayer_provider import (
+                        PromptLayerProvider,
+                    )
+
+                    self.providers["promptlayer"] = PromptLayerProvider(provider_config)
+
+    async def get_from(
+        self,
+        identifier: str,
+        *,
+        provider: str | None = None,
+        version: str | None = None,
+        variables: dict[str, Any] | None = None,
+    ) -> str:
+        """Get a prompt.
+
+        Args:
+            identifier: Prompt identifier/name
+            provider: Provider name (None = builtin)
+            version: Optional version string
+            variables: Optional template variables
+
+        Examples:
+            await prompts.get_from("code_review", variables={"language": "python"})
+            await prompts.get_from(
+                "expert",
+                provider="langfuse",
+                version="v2",
+                variables={"domain": "ML"}
+            )
+        """
+        provider_name = provider or "builtin"
+        if provider_name not in self.providers:
+            msg = f"Unknown prompt provider: {provider_name}"
+            raise KeyError(msg)
+
+        provider_instance = self.providers[provider_name]
+        try:
+            kwargs: dict[str, Any] = {}
+            if provider_instance.supports_versions and version:
+                kwargs["version"] = version
+            if provider_instance.supports_variables and variables:
+                kwargs["variables"] = variables
+
+            return await provider_instance.get_prompt(identifier, **kwargs)
+        except Exception as e:
+            msg = f"Failed to get prompt {identifier!r} from {provider_name}"
+            raise RuntimeError(msg) from e
+
+    @method_spawner
+    async def get(self, reference: str) -> str:
+        """Get a prompt using identifier syntax.
+
+        Args:
+            reference: Prompt identifier in format:
+                      [provider:]name[@version][?var1=val1,var2=val2]
+
+        Examples:
+            await prompts.get("error_handler")  # Builtin prompt
+            await prompts.get("langfuse:code_review@v2?style=detailed")
+        """
+        provider_name, id_, version, vars_ = parse_prompt_reference(reference)
+        prov = provider_name if provider_name != "builtin" else None
+        return await self.get_from(id_, provider=prov, version=version, variables=vars_)
+
+    async def list_prompts(self, provider: str | None = None) -> dict[str, list[str]]:
+        """List available prompts.
+
+        Args:
+            provider: Optional provider name to filter by
+
+        Returns:
+            Dict mapping provider names to their available prompts
+        """
+        providers = {provider: self.providers[provider]} if provider else self.providers
+
+        if not providers:
+            return {}
+        # Get prompts from providers concurrently
+        result = {}
+        coros = [p.list_prompts() for p in providers.values()]
+        gathered_results = await asyncio.gather(*coros, return_exceptions=True)
+        for (name, _), prompts in zip(providers.items(), gathered_results, strict=False):
+            if isinstance(prompts, BaseException):
+                logger.exception("Failed to list prompts", source=name)
+                continue
+            result[name] = prompts
+        return result
+
+    def cleanup(self) -> None:
+        """Clean up providers."""
+        self.providers.clear()
+
+    def get_default_provider(self) -> str:
+        """Get default provider name.
+
+        Returns configured default or "builtin"
+        """
+        return "builtin"

agentpool/prompts/parts/zed.md

@@ -0,0 +1,33 @@
+## Code References
+
+When referencing code locations in responses, use markdown links with `file://` URLs:
+
+- **File**: `[filename](file:///absolute/path/to/file.py)`
+- **Line range**: `[filename#L10-25](file:///absolute/path/to/file.py#L10:25)`
+- **Single line**: `[filename#L10](file:///absolute/path/to/file.py#L10:10)`
+- **Directory**: `[dirname/](file:///absolute/path/to/dir/)`
+
+Line range format is `#L<start>:<end>` (1-based, inclusive).
+
+Examples:
+- [toolset.py](file:///home/phil65/dev/oss/agentpool/src/agentpool_toolsets/openapi/toolset.py)
+- [OpenAPITools class](file:///home/phil65/dev/oss/agentpool/src/agentpool_toolsets/openapi/toolset.py#L19:80)
+
+Use these clickable references when pointing to specific code locations. For showing actual code content, still use fenced code blocks with the path-based syntax.
+
+## Zed-specific URLs
+
+In addition to `file://` URLs, these `zed://` URLs work in the agent context:
+
+- **File reference**: `[text](zed:///agent/file?path=/absolute/path/to/file.py)`
+- **Selection**: `[text](zed:///agent/selection?path=/absolute/path/to/file.py#L10:25)`
+- **Symbol**: `[text](zed:///agent/symbol/function_name?path=/absolute/path/to/file.py#L10:25)`
+- **Directory**: `[text](zed:///agent/directory?path=/absolute/path/to/dir)`
+
+These may require existing context to work:
+- **Thread reference**: `[text](zed:///agent/thread/SESSION_ID?name=Thread%20Name)`
+- **Rule reference**: `[text](zed:///agent/rule/UUID?name=Rule%20Name)`
+- **Pasted image**: `[text](zed:///agent/pasted-image)`
+- **Untitled buffer**: `[text](zed:///agent/untitled-buffer#L10:20)`
+
+Query params must be URL-encoded (spaces → `%20`). Paths must be absolute.