agentpool 2.1.9__py3-none-any.whl

agentpool_toolsets/mcp_run_toolset.py

@@ -0,0 +1,61 @@
+"""McpRun based toolset implementation."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any, cast
+
+from schemez import OpenAIFunctionDefinition
+
+from agentpool.resource_providers import ResourceProvider
+
+
+if TYPE_CHECKING:
+    from mcp.types import CallToolResult
+
+    from agentpool.tools.base import Tool
+
+
+class McpRunTools(ResourceProvider):
+    """Provider for MCP.run tools."""
+
+    def __init__(self, entity_id: str, session_id: str | None = None) -> None:
+        from mcp_run import Client, ClientConfig  # type: ignore[import-untyped]
+
+        super().__init__(name=entity_id)
+        id_ = session_id or os.environ.get("MCP_RUN_SESSION_ID")
+        config = ClientConfig()
+        self.client = Client(session_id=id_, config=config)
+        self._tools: list[Tool] | None = None
+
+    async def get_tools(self) -> list[Tool]:
+        """Get tools from MCP.run."""
+        # Return cached tools if available
+        if self._tools is not None:
+            return self._tools
+
+        self._tools = []
+        for name, tool in self.client.tools.items():
+
+            async def run(tool_name: str = name, **input_dict: Any) -> CallToolResult:
+                async with self.client.mcp_sse().connect() as session:
+                    return await session.call_tool(tool_name, arguments=input_dict)  # type: ignore[no-any-return]
+
+            run.__name__ = name
+            wrapped_tool = self.create_tool(
+                run, schema_override=cast(OpenAIFunctionDefinition, tool.input_schema)
+            )
+            self._tools.append(wrapped_tool)
+
+        return self._tools
+
+
+if __name__ == "__main__":
+    import anyio
+
+    async def main() -> None:
+        tools = McpRunTools("default")
+        fns = await tools.get_tools()
+        print(fns)
+
+    anyio.run(main)

agentpool_toolsets/notifications.py

@@ -0,0 +1,146 @@
+"""Apprise-based notifications toolset implementation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from schemez.functionschema.typedefs import OpenAIFunctionDefinition
+
+from agentpool.log import get_logger
+from agentpool.resource_providers import ResourceProvider
+
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from agentpool.tools.base import Tool
+
+
+logger = get_logger(__name__)
+
+
+class NotificationsTools(ResourceProvider):
+    """Provider for Apprise-based notification tools.
+
+    Provides a send_notification tool that can send messages via
+    various notification services (Slack, Telegram, Email, etc.)
+    configured through Apprise URLs.
+    """
+
+    def __init__(
+        self,
+        channels: Mapping[str, str | list[str]],
+        name: str = "notifications",
+    ) -> None:
+        """Initialize notifications provider.
+
+        Args:
+            channels: Named notification channels mapping to Apprise URL(s).
+                      Values can be a single URL string or list of URLs.
+            name: Provider name
+        """
+        import apprise
+
+        super().__init__(name=name)
+        self.channels = channels
+        self._tools: list[Tool] | None = None
+        self._apprise = apprise.Apprise()
+        for channel_name, urls in self.channels.items():
+            # Normalize to list
+            url_list = [urls] if isinstance(urls, str) else urls
+            for url in url_list:
+                # Tag each URL with the channel name for filtering
+                self._apprise.add(url, tag=channel_name)
+                logger.debug("Added notification URL", channel=channel_name, url=url[:30] + "...")
+
+    async def get_tools(self) -> list[Tool]:
+        """Get notification tools with dynamic schema based on configured channels."""
+        if self._tools is not None:
+            return self._tools
+
+        channel_names = sorted(self.channels.keys())
+        # Build schema with enum for available channels
+        properties: dict[str, Any] = {
+            "message": {"type": "string", "description": "The notification message body"},
+            "title": {"type": "string", "description": "Optional notification title"},
+        }
+
+        if channel_names:
+            properties["channel"] = {
+                "type": "string",
+                "enum": channel_names,
+                "description": "Send to a specific channel. If not specified, sends to all channels.",  # noqa: E501
+            }
+        else:
+            properties["channel"] = {
+                "type": "string",
+                "description": "Send to a specific channel. If not specified, sends to all channels.",  # noqa: E501
+            }
+
+        schema_override = OpenAIFunctionDefinition(
+            name="send_notification",
+            description=(
+                "Send a notification via configured channels. "
+                "Specify a channel name to send to that channel only, "
+                "or omit to broadcast to all channels."
+            ),
+            parameters={"type": "object", "properties": properties, "required": ["message"]},
+        )
+
+        self._tools = [
+            self.create_tool(
+                self.send_notification, schema_override=schema_override, open_world=True
+            )
+        ]
+        return self._tools
+
+    async def send_notification(
+        self,
+        message: str,
+        title: str | None = None,
+        channel: str | None = None,
+    ) -> dict[str, Any]:
+        """Send a notification via configured channels.
+
+        Args:
+            message: The notification message body
+            title: Optional notification title
+            channel: Send to specific channel, or all if not specified
+
+        Returns:
+            Result dict with success status and details
+        """
+        if channel:
+            if channel not in self.channels:
+                return {
+                    "success": False,
+                    "error": f"Unknown channel: {channel}",
+                    "available_channels": list(self.channels.keys()),
+                }
+            notify_tag = channel
+            target_desc = f"channel '{channel}'"
+        else:
+            notify_tag = "all"
+            target_desc = "all channels"
+
+        logger.info("Sending notification", target=target_desc, title=title, length=len(message))
+
+        try:
+            success = self._apprise.notify(body=message, title=title or "", tag=notify_tag)
+        except Exception as e:
+            logger.exception("Failed to send notification")
+            return {"success": False, "error": str(e), "target": target_desc}
+
+        if success:
+            logger.info("Notification sent successfully", target=target_desc)
+            return {
+                "success": True,
+                "target": target_desc,
+                "message": "Notification sent successfully",
+            }
+        logger.warning("Notification may have partially failed", target=target_desc)
+        return {
+            "success": False,
+            "target": target_desc,
+            "message": "Notification delivery may have failed for some channels",
+        }

agentpool_toolsets/openapi.py

@@ -0,0 +1,118 @@
+"""OpenAPI toolset provider."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from schemez.openapi.callable_factory import OpenAPICallableFactory
+from schemez.openapi.loader import load_openapi_spec, parse_operations
+from upathtools import read_path, to_upath
+
+from agentpool.log import get_logger
+from agentpool.resource_providers import ResourceProvider
+
+
+if TYPE_CHECKING:
+    import httpx
+    from upathtools import JoinablePathLike
+
+    from agentpool.tools.base import Tool
+
+logger = get_logger(__name__)
+
+
+class OpenAPITools(ResourceProvider):
+    """Provider for OpenAPI-based tools."""
+
+    def __init__(
+        self,
+        spec: JoinablePathLike,
+        base_url: str = "",
+        name: str | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        super().__init__(name=name or f"openapi_{base_url}")
+        self.spec_url = spec
+        self.base_url = base_url
+        self.headers = headers or {}
+        self._client: httpx.AsyncClient | None = None
+        self._spec: dict[str, Any] | None = None
+        self._schemas: dict[str, dict[str, Any]] = {}
+        self._operations: dict[str, Any] = {}
+        self._factory: OpenAPICallableFactory | None = None
+
+    async def get_tools(self) -> list[Tool]:
+        """Get all API operations as tools."""
+        if not self._spec:
+            await self._load_spec()
+
+        if not self._factory:
+            return []
+
+        tools = []
+        for op_id, config in self._operations.items():
+            method = self._factory.create_callable(op_id, config)
+            tool = self.create_tool(method, metadata={"operation": op_id})
+            tools.append(tool)
+        return tools
+
+    async def _load_spec(self) -> dict[str, Any]:
+        import httpx
+
+        if not self._client:
+            self._client = httpx.AsyncClient(base_url=self.base_url, headers=self.headers)
+
+        try:
+            spec_str = str(self.spec_url)
+            if spec_str.startswith(("http://", "https://")):
+                self._spec = load_openapi_spec(spec_str)
+            else:
+                path = to_upath(self.spec_url)
+                if path.exists():
+                    self._spec = load_openapi_spec(path)
+                else:
+                    # Try reading via upathtools for remote/special paths
+                    content = await read_path(self.spec_url)
+                    import tempfile
+
+                    with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+                        f.write(content)
+                        temp_path = f.name
+                    try:
+                        self._spec = load_openapi_spec(temp_path)
+                    finally:
+                        to_upath(temp_path).unlink(missing_ok=True)
+
+            if not self._spec:
+                msg = f"Empty or invalid OpenAPI spec from {self.spec_url}"
+                raise ValueError(msg)  # noqa: TRY301
+
+            self._schemas = self._spec.get("components", {}).get("schemas", {})
+            self._operations = parse_operations(self._spec.get("paths", {}))
+            self._factory = OpenAPICallableFactory(self._schemas, self._make_request)
+
+            if not self._operations:
+                logger.warning("No operations found in spec %s.", self.spec_url)
+
+        except Exception as e:
+            msg = f"Failed to load OpenAPI spec from {self.spec_url}"
+            raise ValueError(msg) from e
+        else:
+            return self._spec
+
+    async def _make_request(
+        self,
+        method: str,
+        path: str,
+        params: dict[str, Any],
+        body: dict[str, Any] | None,
+    ) -> dict[str, Any]:
+        """Perform HTTP request to the API."""
+        if not self._client:
+            import httpx
+
+            self._client = httpx.AsyncClient(base_url=self.base_url, headers=self.headers)
+
+        response = await self._client.request(method=method, url=path, params=params, json=body)
+        response.raise_for_status()
+        return response.json()  # type: ignore[no-any-return]

agentpool_toolsets/search_toolset.py

@@ -0,0 +1,202 @@
+"""Search toolset implementation using searchly providers."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from agentpool.log import get_logger
+from agentpool.resource_providers import ResourceProvider
+
+
+if TYPE_CHECKING:
+    from searchly.base import (
+        CountryCode,
+        LanguageCode,
+        NewsSearchProvider,
+        NewsSearchResponse,
+        WebSearchProvider,
+        WebSearchResponse,
+    )
+
+    from agentpool.agents.context import AgentContext
+    from agentpool.tools.base import Tool
+
+
+logger = get_logger(__name__)
+
+
+def format_web_results(response: WebSearchResponse, query: str) -> str:
+    """Format web search results as markdown."""
+    if not response.results:
+        return f"No results found for: {query}"
+
+    lines = [f"## Web Search Results for: {query}\n"]
+    for i, result in enumerate(response.results, 1):
+        lines.append(f"### {i}. [{result.title}]({result.url})")
+        lines.append(f"{result.snippet}\n")
+    return "\n".join(lines)
+
+
+def format_news_results(response: NewsSearchResponse, query: str) -> str:
+    """Format news search results as markdown."""
+    if not response.results:
+        return f"No news results found for: {query}"
+
+    lines = [f"## News Search Results for: {query}\n"]
+    for i, result in enumerate(response.results, 1):
+        # Build header with source/date if available
+        header = f"### {i}. [{result.title}]({result.url})"
+        lines.append(header)
+
+        meta_parts = []
+        if result.source:
+            meta_parts.append(f"*{result.source}*")
+        if result.published:
+            meta_parts.append(f"({result.published})")
+        if meta_parts:
+            lines.append(" ".join(meta_parts))
+
+        lines.append(f"{result.snippet}\n")
+    return "\n".join(lines)
+
+
+class SearchTools(ResourceProvider):
+    """Provider for web and news search tools."""
+
+    def __init__(
+        self,
+        web_search: WebSearchProvider | None = None,
+        news_search: NewsSearchProvider | None = None,
+    ) -> None:
+        """Initialize search tools provider.
+
+        Args:
+            web_search: Web search provider instance.
+            news_search: News search provider instance.
+        """
+        super().__init__(name="search")
+        self._web_provider = web_search
+        self._news_provider = news_search
+
+    async def web_search(  # noqa: D417
+        self,
+        agent_ctx: AgentContext,
+        query: str,
+        *,
+        max_results: int = 10,
+        country: CountryCode | None = None,
+        language: LanguageCode | None = None,
+        **kwargs: Any,
+    ) -> str:
+        """Search the web for information.
+
+        Args:
+            query: Search query string.
+            max_results: Maximum number of results to return.
+            country: Country code for regional results.
+            language: Language code for results.
+            **kwargs: Provider-specific options.
+
+        Returns:
+            Formatted markdown search results.
+        """
+        from agentpool.agents.events import TextContentItem
+
+        assert self._web_provider is not None
+
+        await agent_ctx.events.tool_call_progress(
+            title=f"Searching: {query}",
+            items=[TextContentItem(text=f"Searching web for: {query}")],
+        )
+
+        response = await self._web_provider.web_search(
+            query,
+            max_results=max_results,
+            country=country,
+            language=language,
+            **kwargs,
+        )
+
+        result_count = len(response.results)
+        formatted = format_web_results(response, query)
+
+        await agent_ctx.events.tool_call_progress(
+            title=f"Found {result_count} results",
+            items=[TextContentItem(text=formatted)],
+            replace_content=True,
+        )
+
+        return formatted
+
+    async def news_search(  # noqa: D417
+        self,
+        agent_ctx: AgentContext,
+        query: str,
+        *,
+        max_results: int = 10,
+        country: CountryCode | None = None,
+        language: LanguageCode | None = None,
+        **kwargs: Any,
+    ) -> str:
+        """Search for news articles.
+
+        Args:
+            query: Search query string.
+            max_results: Maximum number of results to return.
+            country: Country code for regional results.
+            language: Language code for results.
+            **kwargs: Provider-specific options.
+
+        Returns:
+            Formatted markdown news results.
+        """
+        from agentpool.agents.events import TextContentItem
+
+        assert self._news_provider is not None
+
+        await agent_ctx.events.tool_call_progress(
+            title=f"Searching news: {query}",
+            items=[TextContentItem(text=f"Searching news for: {query}")],
+        )
+
+        response = await self._news_provider.news_search(
+            query,
+            max_results=max_results,
+            country=country,
+            language=language,
+            **kwargs,
+        )
+
+        result_count = len(response.results)
+        formatted = format_news_results(response, query)
+
+        await agent_ctx.events.tool_call_progress(
+            title=f"Found {result_count} articles",
+            items=[TextContentItem(text=formatted)],
+            replace_content=True,
+        )
+
+        return formatted
+
+    async def get_tools(self) -> list[Tool]:
+        """Get search tools from configured providers."""
+        tools: list[Tool] = []
+        if self._web_provider:
+            tools.append(
+                self.create_tool(
+                    self.web_search,
+                    read_only=True,
+                    idempotent=True,
+                    open_world=True,
+                )
+            )
+        if self._news_provider:
+            tools.append(
+                self.create_tool(
+                    self.news_search,
+                    read_only=True,
+                    idempotent=True,
+                    open_world=True,
+                )
+            )
+        return tools