acp-sdk 0.0.6__py3-none-any.whl → 1.0.0rc1__py3-none-any.whl

acp/server/highlevel/tools/base.py

@@ -1,83 +0,0 @@
-import inspect
-from typing import TYPE_CHECKING, Any, Callable
-
-from pydantic import BaseModel, Field
-
-import acp.server.highlevel
-from acp.server.highlevel.exceptions import ToolError
-from acp.server.highlevel.utilities.func_metadata import FuncMetadata, func_metadata
-
-if TYPE_CHECKING:
-    from acp.server.highlevel.server import Context
-
-
-class Tool(BaseModel):
-    """Internal tool registration info."""
-
-    fn: Callable = Field(exclude=True)
-    name: str = Field(description="Name of the tool")
-    description: str = Field(description="Description of what the tool does")
-    parameters: dict = Field(description="JSON schema for tool parameters")
-    fn_metadata: FuncMetadata = Field(
-        description="Metadata about the function including a pydantic model for tool"
-        " arguments"
-    )
-    is_async: bool = Field(description="Whether the tool is async")
-    context_kwarg: str | None = Field(
-        None, description="Name of the kwarg that should receive context"
-    )
-
-    @classmethod
-    def from_function(
-        cls,
-        fn: Callable,
-        name: str | None = None,
-        description: str | None = None,
-        context_kwarg: str | None = None,
-    ) -> "Tool":
-        """Create a Tool from a function."""
-        func_name = name or fn.__name__
-
-        if func_name == "<lambda>":
-            raise ValueError("You must provide a name for lambda functions")
-
-        func_doc = description or fn.__doc__ or ""
-        is_async = inspect.iscoroutinefunction(fn)
-
-        # Find context parameter if it exists
-        if context_kwarg is None:
-            sig = inspect.signature(fn)
-            for param_name, param in sig.parameters.items():
-                if param.annotation is acp.server.highlevel.Context:
-                    context_kwarg = param_name
-                    break
-
-        func_arg_metadata = func_metadata(
-            fn,
-            skip_names=[context_kwarg] if context_kwarg is not None else [],
-        )
-        parameters = func_arg_metadata.arg_model.model_json_schema()
-
-        return cls(
-            fn=fn,
-            name=func_name,
-            description=func_doc,
-            parameters=parameters,
-            fn_metadata=func_arg_metadata,
-            is_async=is_async,
-            context_kwarg=context_kwarg,
-        )
-
-    async def run(self, arguments: dict, context: "Context | None" = None) -> Any:
-        """Run the tool with arguments."""
-        try:
-            return await self.fn_metadata.call_fn_with_arg_validation(
-                self.fn,
-                self.is_async,
-                arguments,
-                {self.context_kwarg: context}
-                if self.context_kwarg is not None
-                else None,
-            )
-        except Exception as e:
-            raise ToolError(f"Error executing tool {self.name}: {e}") from e

acp/server/highlevel/tools/tool_manager.py

@@ -1,53 +0,0 @@
-from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
-
-from acp.server.highlevel.exceptions import ToolError
-from acp.server.highlevel.tools.base import Tool
-from acp.server.highlevel.utilities.logging import get_logger
-
-if TYPE_CHECKING:
-    from acp.server.highlevel.server import Context
-
-logger = get_logger(__name__)
-
-
-class ToolManager:
-    """Manages FastMCP tools."""
-
-    def __init__(self, warn_on_duplicate_tools: bool = True):
-        self._tools: dict[str, Tool] = {}
-        self.warn_on_duplicate_tools = warn_on_duplicate_tools
-
-    def get_tool(self, name: str) -> Tool | None:
-        """Get tool by name."""
-        return self._tools.get(name)
-
-    def list_tools(self) -> list[Tool]:
-        """List all registered tools."""
-        return list(self._tools.values())
-
-    def add_tool(
-        self,
-        fn: Callable,
-        name: str | None = None,
-        description: str | None = None,
-    ) -> Tool:
-        """Add a tool to the server."""
-        tool = Tool.from_function(fn, name=name, description=description)
-        existing = self._tools.get(tool.name)
-        if existing:
-            if self.warn_on_duplicate_tools:
-                logger.warning(f"Tool already exists: {tool.name}")
-            return existing
-        self._tools[tool.name] = tool
-        return tool
-
-    async def call_tool(
-        self, name: str, arguments: dict, context: "Context | None" = None
-    ) -> Any:
-        """Call a tool by name with arguments."""
-        tool = self.get_tool(name)
-        if not tool:
-            raise ToolError(f"Unknown tool: {name}")
-
-        return await tool.run(arguments, context=context)

acp/server/highlevel/utilities/__init__.py

@@ -1 +0,0 @@
-"""FastMCP utility modules."""

acp/server/highlevel/utilities/func_metadata.py

@@ -1,210 +0,0 @@
-import inspect
-import json
-from collections.abc import Awaitable, Callable, Sequence
-from typing import (
-    Annotated,
-    Any,
-    ForwardRef,
-)
-
-from pydantic import BaseModel, ConfigDict, Field, WithJsonSchema, create_model
-from pydantic._internal._typing_extra import eval_type_backport
-from pydantic.fields import FieldInfo
-from pydantic_core import PydanticUndefined
-
-from acp.server.highlevel.exceptions import InvalidSignature
-from acp.server.highlevel.utilities.logging import get_logger
-
-logger = get_logger(__name__)
-
-
-class ArgModelBase(BaseModel):
-    """A model representing the arguments to a function."""
-
-    def model_dump_one_level(self) -> dict[str, Any]:
-        """Return a dict of the model's fields, one level deep.
-
-        That is, sub-models etc are not dumped - they are kept as pydantic models.
-        """
-        kwargs: dict[str, Any] = {}
-        for field_name in self.model_fields.keys():
-            kwargs[field_name] = getattr(self, field_name)
-        return kwargs
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-
-class FuncMetadata(BaseModel):
-    arg_model: Annotated[type[ArgModelBase], WithJsonSchema(None)]
-    # We can add things in the future like
-    #  - Maybe some args are excluded from attempting to parse from JSON
-    #  - Maybe some args are special (like context) for dependency injection
-
-    async def call_fn_with_arg_validation(
-        self,
-        fn: Callable[..., Any] | Awaitable[Any],
-        fn_is_async: bool,
-        arguments_to_validate: dict[str, Any],
-        arguments_to_pass_directly: dict[str, Any] | None,
-    ) -> Any:
-        """Call the given function with arguments validated and injected.
-
-        Arguments are first attempted to be parsed from JSON, then validated against
-        the argument model, before being passed to the function.
-        """
-        arguments_pre_parsed = self.pre_parse_json(arguments_to_validate)
-        arguments_parsed_model = self.arg_model.model_validate(arguments_pre_parsed)
-        arguments_parsed_dict = arguments_parsed_model.model_dump_one_level()
-
-        arguments_parsed_dict |= arguments_to_pass_directly or {}
-
-        if fn_is_async:
-            if isinstance(fn, Awaitable):
-                return await fn
-            return await fn(**arguments_parsed_dict)
-        if isinstance(fn, Callable):
-            return fn(**arguments_parsed_dict)
-        raise TypeError("fn must be either Callable or Awaitable")
-
-    def pre_parse_json(self, data: dict[str, Any]) -> dict[str, Any]:
-        """Pre-parse data from JSON.
-
-        Return a dict with same keys as input but with values parsed from JSON
-        if appropriate.
-
-        This is to handle cases like `["a", "b", "c"]` being passed in as JSON inside
-        a string rather than an actual list. Claude desktop is prone to this - in fact
-        it seems incapable of NOT doing this. For sub-models, it tends to pass
-        dicts (JSON objects) as JSON strings, which can be pre-parsed here.
-        """
-        new_data = data.copy()  # Shallow copy
-        for field_name, field_info in self.arg_model.model_fields.items():
-            if field_name not in data.keys():
-                continue
-            if isinstance(data[field_name], str):
-                try:
-                    pre_parsed = json.loads(data[field_name])
-                except json.JSONDecodeError:
-                    continue  # Not JSON - skip
-                if isinstance(pre_parsed, str):
-                    # This is likely that the raw value is e.g. `"hello"` which we
-                    # Should really be parsed as '"hello"' in Python - but if we parse
-                    # it as JSON it'll turn into just 'hello'. So we skip it.
-                    continue
-                new_data[field_name] = pre_parsed
-        assert new_data.keys() == data.keys()
-        return new_data
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-
-def func_metadata(func: Callable, skip_names: Sequence[str] = ()) -> FuncMetadata:
-    """Given a function, return metadata including a pydantic model representing its
-    signature.
-
-    The use case for this is
-    ```
-    meta = func_to_pyd(func)
-    validated_args = meta.arg_model.model_validate(some_raw_data_dict)
-    return func(**validated_args.model_dump_one_level())
-    ```
-
-    **critically** it also provides pre-parse helper to attempt to parse things from
-    JSON.
-
-    Args:
-        func: The function to convert to a pydantic model
-        skip_names: A list of parameter names to skip. These will not be included in
-            the model.
-    Returns:
-        A pydantic model representing the function's signature.
-    """
-    sig = _get_typed_signature(func)
-    params = sig.parameters
-    dynamic_pydantic_model_params: dict[str, Any] = {}
-    globalns = getattr(func, "__globals__", {})
-    for param in params.values():
-        if param.name.startswith("_"):
-            raise InvalidSignature(
-                f"Parameter {param.name} of {func.__name__} cannot start with '_'"
-            )
-        if param.name in skip_names:
-            continue
-        annotation = param.annotation
-
-        # `x: None` / `x: None = None`
-        if annotation is None:
-            annotation = Annotated[
-                None,
-                Field(
-                    default=param.default
-                    if param.default is not inspect.Parameter.empty
-                    else PydanticUndefined
-                ),
-            ]
-
-        # Untyped field
-        if annotation is inspect.Parameter.empty:
-            annotation = Annotated[
-                Any,
-                Field(),
-                # 🤷
-                WithJsonSchema({"title": param.name, "type": "string"}),
-            ]
-
-        field_info = FieldInfo.from_annotated_attribute(
-            _get_typed_annotation(annotation, globalns),
-            param.default
-            if param.default is not inspect.Parameter.empty
-            else PydanticUndefined,
-        )
-        dynamic_pydantic_model_params[param.name] = (field_info.annotation, field_info)
-        continue
-
-    arguments_model = create_model(
-        f"{func.__name__}Arguments",
-        **dynamic_pydantic_model_params,
-        __base__=ArgModelBase,
-    )
-    resp = FuncMetadata(arg_model=arguments_model)
-    return resp
-
-
-def _get_typed_annotation(annotation: Any, globalns: dict[str, Any]) -> Any:
-    def try_eval_type(value, globalns, localns):
-        try:
-            return eval_type_backport(value, globalns, localns), True
-        except NameError:
-            return value, False
-
-    if isinstance(annotation, str):
-        annotation = ForwardRef(annotation)
-        annotation, status = try_eval_type(annotation, globalns, globalns)
-
-        # This check and raise could perhaps be skipped, and we (FastMCP) just call
-        # model_rebuild right before using it 🤷
-        if status is False:
-            raise InvalidSignature(f"Unable to evaluate type annotation {annotation}")
-
-    return annotation
-
-
-def _get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
-    """Get function signature while evaluating forward references"""
-    signature = inspect.signature(call)
-    globalns = getattr(call, "__globals__", {})
-    typed_params = [
-        inspect.Parameter(
-            name=param.name,
-            kind=param.kind,
-            default=param.default,
-            annotation=_get_typed_annotation(param.annotation, globalns),
-        )
-        for param in signature.parameters.values()
-    ]
-    typed_signature = inspect.Signature(typed_params)
-    return typed_signature

acp/server/highlevel/utilities/logging.py

@@ -1,43 +0,0 @@
-"""Logging utilities for FastMCP."""
-
-import logging
-from typing import Literal
-
-
-def get_logger(name: str) -> logging.Logger:
-    """Get a logger nested under MCPnamespace.
-
-    Args:
-        name: the name of the logger, which will be prefixed with 'FastMCP.'
-
-    Returns:
-        a configured logger instance
-    """
-    return logging.getLogger(name)
-
-
-def configure_logging(
-    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO",
-) -> None:
-    """Configure logging for MCP.
-
-    Args:
-        level: the log level to use
-    """
-    handlers = []
-    try:
-        from rich.console import Console
-        from rich.logging import RichHandler
-
-        handlers.append(RichHandler(console=Console(stderr=True), rich_tracebacks=True))
-    except ImportError:
-        pass
-
-    if not handlers:
-        handlers.append(logging.StreamHandler())
-
-    logging.basicConfig(
-        level=level,
-        format="%(message)s",
-        handlers=handlers,
-    )

acp/server/highlevel/utilities/types.py

@@ -1,54 +0,0 @@
-"""Common types used across FastMCP."""
-
-import base64
-from pathlib import Path
-
-from acp.types import ImageContent
-
-
-class Image:
-    """Helper class for returning images from tools."""
-
-    def __init__(
-        self,
-        path: str | Path | None = None,
-        data: bytes | None = None,
-        format: str | None = None,
-    ):
-        if path is None and data is None:
-            raise ValueError("Either path or data must be provided")
-        if path is not None and data is not None:
-            raise ValueError("Only one of path or data can be provided")
-
-        self.path = Path(path) if path else None
-        self.data = data
-        self._format = format
-        self._mime_type = self._get_mime_type()
-
-    def _get_mime_type(self) -> str:
-        """Get MIME type from format or guess from file extension."""
-        if self._format:
-            return f"image/{self._format.lower()}"
-
-        if self.path:
-            suffix = self.path.suffix.lower()
-            return {
-                ".png": "image/png",
-                ".jpg": "image/jpeg",
-                ".jpeg": "image/jpeg",
-                ".gif": "image/gif",
-                ".webp": "image/webp",
-            }.get(suffix, "application/octet-stream")
-        return "image/png"  # default for raw binary data
-
-    def to_image_content(self) -> ImageContent:
-        """Convert to MCP ImageContent."""
-        if self.path:
-            with open(self.path, "rb") as f:
-                data = base64.b64encode(f.read()).decode()
-        elif self.data is not None:
-            data = base64.b64encode(self.data).decode()
-        else:
-            raise ValueError("No image data available")
-
-        return ImageContent(type="image", data=data, mimeType=self._mime_type)

acp/server/lowlevel/__init__.py

@@ -1,3 +0,0 @@
-from .server import NotificationOptions, Server
-
-__all__ = ["Server", "NotificationOptions"]

acp/server/lowlevel/helper_types.py

@@ -1,9 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class ReadResourceContents:
-    """Contents returned from a read_resource call."""
-
-    content: str | bytes
-    mime_type: str | None = None