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

acp/server/__main__.py

@@ -1,50 +0,0 @@
-import importlib.metadata
-import logging
-import sys
-
-import anyio
-
-from acp.server.models import InitializationOptions
-from acp.server.session import ServerSession
-from acp.server.stdio import stdio_server
-from acp.types import ServerCapabilities
-
-if not sys.warnoptions:
-    import warnings
-
-    warnings.simplefilter("ignore")
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("server")
-
-
-async def receive_loop(session: ServerSession):
-    logger.info("Starting receive loop")
-    async for message in session.incoming_messages:
-        if isinstance(message, Exception):
-            logger.error("Error: %s", message)
-            continue
-
-        logger.info("Received message from client: %s", message)
-
-
-async def main():
-    version = importlib.metadata.version("mcp")
-    async with stdio_server() as (read_stream, write_stream):
-        async with (
-            ServerSession(
-                read_stream,
-                write_stream,
-                InitializationOptions(
-                    server_name="mcp",
-                    server_version=version,
-                    capabilities=ServerCapabilities(),
-                ),
-            ) as session,
-            write_stream,
-        ):
-            await receive_loop(session)
-
-
-if __name__ == "__main__":
-    anyio.run(main, backend="trio")

acp/server/highlevel/__init__.py

@@ -1,9 +0,0 @@
-"""FastMCP - A more ergonomic interface for MCP servers."""
-
-from importlib.metadata import version
-
-from .server import Context, Server
-from .utilities.types import Image
-
-__version__ = version("acp-sdk")
-__all__ = ["Server", "Context", "Image"]

acp/server/highlevel/agents/__init__.py

@@ -1,5 +0,0 @@
-from .agent_manager import AgentManager
-from .base import Agent
-from .templates import AgentTemplate
-
-__all__ = ["Agent", "AgentTemplate", "AgentManager"]

acp/server/highlevel/agents/agent_manager.py

@@ -1,110 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from acp.server.highlevel.agents.base import Agent
-from acp.server.highlevel.agents.templates import AgentTemplate
-from acp.server.highlevel.exceptions import AgentError
-from acp.server.highlevel.utilities.logging import get_logger
-
-if TYPE_CHECKING:
-    from acp.server.highlevel.server import Context
-
-logger = get_logger(__name__)
-
-
-class AgentManager:
-    """Manages FastMCP agents."""
-
-    def __init__(self, warn_on_duplicate_agents: bool = True):
-        self._agents: dict[str, Agent] = {}
-        self._templates: dict[str, AgentTemplate] = {}
-        self.warn_on_duplicate_agents = warn_on_duplicate_agents
-
-    def get_template(self, name: str) -> AgentTemplate | None:
-        """Get agent template by name."""
-        return self._templates.get(name)
-
-    def list_templates(self) -> list[AgentTemplate]:
-        """List all registered agent templates."""
-        return list(self._templates.values())
-
-    def add_template(
-        self,
-        template: AgentTemplate,
-    ) -> AgentTemplate:
-        """Add a template to the server."""
-        existing = self._templates.get(template.name)
-        if existing:
-            if self.warn_on_duplicate_agents:
-                logger.warning(f"Agent template already exists: {template.name}")
-            return existing
-        self._templates[template.name] = template
-        return template
-
-    def get_agent(self, name: str) -> Agent | None:
-        """Get agent by name."""
-        return self._agents.get(name)
-
-    def list_agents(self) -> list[Agent]:
-        """List all registered agents."""
-        return list(self._agents.values())
-
-    def add_agent(
-        self,
-        agent: Agent,
-    ) -> Agent:
-        """Add an agent to the server."""
-        existing = self._agents.get(agent.name)
-        if existing:
-            if self.warn_on_duplicate_agents:
-                logger.warning(f"Agent already exists: {agent.name}")
-            return existing
-        self._agents[agent.name] = agent
-        return agent
-
-    async def create_agent(
-        self, name: str, config: dict[str, Any], context: "Context"
-    ) -> Agent:
-        """Call an agent by name with arguments."""
-        template = self.get_template(name)
-        if not template:
-            raise AgentError(f"Unknown agent template: {name}")
-
-        agent = await template.create_fn(template.model_validate(config), context)
-        existing = self._agents.get(agent.name)
-        if existing:
-            if self.warn_on_duplicate_agents:
-                logger.warning(f"Agent already exists: {agent.name}")
-            return existing
-        self._agents[agent.name] = agent
-        return agent
-
-    async def destroy_agent(self, name: str, context: "Context") -> None:
-        """Call an agent by name with arguments."""
-        agent = self.get_agent(name)
-        if not agent:
-            raise AgentError(f"Unknown agent: {name}")
-
-        if not agent.destroy_fn:
-            raise AgentError(f"Agent cannot be destroyed: {name}")
-
-        try:
-            await agent.destroy_fn(context)
-        except Exception as e:
-            logger.warning(f"Error destroying agent {name}: {e}")
-        finally:
-            del self._agents[name]
-        return
-
-    async def run_agent(
-        self, name: str, input: dict[str, Any], *, context: "Context"
-    ) -> Any:
-        """Run an agent by name with input."""
-        agent = self.get_agent(name)
-        if not agent:
-            raise AgentError(f"Unknown agent: {name}")
-
-        try:
-            output = await agent.run_fn(agent.input.model_validate(input), ctx=context)  # type: ignore
-            return output.model_dump()
-        except Exception as e:
-            raise AgentError(f"Error running agent {name}: {e}") from e

acp/server/highlevel/agents/base.py

@@ -1,20 +0,0 @@
-from typing import Awaitable, Callable, Type
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from acp.server.highlevel.context import Context
-
-
-class Agent(BaseModel):
-    """Internal agent info."""
-
-    name: str = Field(description="Name of the agent")
-    description: str | None = Field(description="Description of what the agent does")
-
-    input: Type[BaseModel] = Field(description="Model for input")
-    output: Type[BaseModel] = Field(description="Model for output")
-
-    run_fn: Callable[[BaseModel, "Context"], Awaitable[BaseModel]] = Field(exclude=True)
-    destroy_fn: Callable[["Context"], Awaitable[None]] | None = Field(exclude=True)
-
-    model_config = ConfigDict(extra="allow")

acp/server/highlevel/agents/templates.py

@@ -1,21 +0,0 @@
-from typing import Awaitable, Callable, Type
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from acp.server.highlevel.agents.base import Agent
-from acp.server.highlevel.context import Context
-
-
-class AgentTemplate(BaseModel):
-    """A template for creating agents."""
-
-    name: str = Field(description="Name of the agent")
-    description: str | None = Field(description="Description of what the agent does")
-
-    config: Type[BaseModel] = Field(description="Model for config")
-    input: Type[BaseModel] = Field(description="Model for run input")
-    output: Type[BaseModel] = Field(description="Model for run output")
-
-    create_fn: Callable[[BaseModel, "Context"], Awaitable[Agent]] = Field(exclude=True)
-
-    model_config = ConfigDict(extra="allow")

acp/server/highlevel/context.py

@@ -1,185 +0,0 @@
-from typing import TYPE_CHECKING, Any, Literal
-
-from pydantic import BaseModel
-from pydantic.networks import AnyUrl
-
-from acp.server.lowlevel.helper_types import ReadResourceContents
-from acp.shared.context import RequestContext
-
-if TYPE_CHECKING:
-    from acp.server.highlevel.server import Server
-
-
-class Context(BaseModel):
-    """Context object providing access to MCP capabilities.
-
-    This provides a cleaner interface to MCP's RequestContext functionality.
-    It gets injected into tool and resource functions that request it via type hints.
-
-    To use context in a tool function, add a parameter with the Context type annotation:
-
-    ```python
-    @server.tool()
-    def my_tool(x: int, ctx: Context) -> str:
-        # Log messages to the client
-        ctx.info(f"Processing {x}")
-        ctx.debug("Debug info")
-        ctx.warning("Warning message")
-        ctx.error("Error message")
-
-        # Report progress
-        ctx.report_progress(50, 100)
-
-        # Access resources
-        data = ctx.read_resource("resource://data")
-
-        # Get request info
-        request_id = ctx.request_id
-        client_id = ctx.client_id
-
-        return str(x)
-    ```
-
-    The context parameter name can be anything as long as it's annotated with Context.
-    The context is optional - tools that don't need it can omit the parameter.
-    """
-
-    _request_context: RequestContext | None
-    _fastmcp: "Server | None"
-
-    def __init__(
-        self,
-        *,
-        request_context: RequestContext | None = None,
-        fastmcp: "Server | None" = None,
-        **kwargs: Any,
-    ):
-        super().__init__(**kwargs)
-        self._request_context = request_context
-        self._fastmcp = fastmcp
-
-    @property
-    def fastmcp(self) -> "Server":
-        """Access to the FastMCP server."""
-        if self._fastmcp is None:
-            raise ValueError("Context is not available outside of a request")
-        return self._fastmcp
-
-    @property
-    def request_context(self) -> RequestContext:
-        """Access to the underlying request context."""
-        if self._request_context is None:
-            raise ValueError("Context is not available outside of a request")
-        return self._request_context
-
-    async def report_progress(
-        self, progress: float, total: float | None = None
-    ) -> None:
-        """Report progress for the current operation.
-
-        Args:
-            progress: Current progress value e.g. 24
-            total: Optional total value e.g. 100
-        """
-
-        progress_token = (
-            self.request_context.meta.progressToken
-            if self.request_context.meta
-            else None
-        )
-
-        if progress_token is None:
-            return
-
-        await self.request_context.session.send_progress_notification(
-            progress_token=progress_token, progress=progress, total=total
-        )
-
-    async def report_agent_run_progress(self, delta: BaseModel) -> None:
-        """Report progress for the agent run operation.
-
-        Args:
-            delta: partial run output
-        """
-
-        progress_token = (
-            self.request_context.meta.progressToken
-            if self.request_context.meta
-            else None
-        )
-
-        if not progress_token:
-            return
-
-        await self.request_context.session.send_agent_run_progress(
-            progress_token=progress_token, delta=delta.model_dump()
-        )
-
-    async def read_resource(self, uri: str | AnyUrl) -> ReadResourceContents:
-        """Read a resource by URI.
-
-        Args:
-            uri: Resource URI to read
-
-        Returns:
-            The resource content as either text or bytes
-        """
-        assert self._fastmcp is not None, (
-            "Context is not available outside of a request"
-        )
-        return await self._fastmcp.read_resource(uri)
-
-    async def log(
-        self,
-        level: Literal["debug", "info", "warning", "error"],
-        message: str,
-        *,
-        logger_name: str | None = None,
-    ) -> None:
-        """Send a log message to the client.
-
-        Args:
-            level: Log level (debug, info, warning, error)
-            message: Log message
-            logger_name: Optional logger name
-            **extra: Additional structured data to include
-        """
-        await self.request_context.session.send_log_message(
-            level=level, data=message, logger=logger_name
-        )
-
-    @property
-    def client_id(self) -> str | None:
-        """Get the client ID if available."""
-        return (
-            getattr(self.request_context.meta, "client_id", None)
-            if self.request_context.meta
-            else None
-        )
-
-    @property
-    def request_id(self) -> str:
-        """Get the unique ID for this request."""
-        return str(self.request_context.request_id)
-
-    @property
-    def session(self):
-        """Access to the underlying session for advanced usage."""
-        return self.request_context.session
-
-    # Convenience methods for common log levels
-    async def debug(self, message: str, **extra: Any) -> None:
-        """Send a debug log message."""
-        await self.log("debug", message, **extra)
-
-    async def info(self, message: str, **extra: Any) -> None:
-        """Send an info log message."""
-        await self.log("info", message, **extra)
-
-    async def warning(self, message: str, **extra: Any) -> None:
-        """Send a warning log message."""
-        await self.log("warning", message, **extra)
-
-    async def error(self, message: str, **extra: Any) -> None:
-        """Send an error log message."""
-        await self.log("error", message, **extra)

acp/server/highlevel/exceptions.py

@@ -1,25 +0,0 @@
-"""Custom exceptions for FastMCP."""
-
-
-class FastMCPError(Exception):
-    """Base error for FastMCP."""
-
-
-class ValidationError(FastMCPError):
-    """Error in validating parameters or return values."""
-
-
-class ResourceError(FastMCPError):
-    """Error in resource operations."""
-
-
-class ToolError(FastMCPError):
-    """Error in tool operations."""
-
-
-class AgentError(FastMCPError):
-    """Error in agent operations."""
-
-
-class InvalidSignature(Exception):
-    """Invalid signature for use with FastMCP."""

acp/server/highlevel/prompts/__init__.py

@@ -1,4 +0,0 @@
-from .base import Prompt
-from .manager import PromptManager
-
-__all__ = ["Prompt", "PromptManager"]

acp/server/highlevel/prompts/base.py

@@ -1,167 +0,0 @@
-"""Base classes for FastMCP prompts."""
-
-import inspect
-import json
-from collections.abc import Callable
-from typing import Any, Awaitable, Literal, Sequence
-
-import pydantic_core
-from pydantic import BaseModel, Field, TypeAdapter, validate_call
-
-from acp.types import EmbeddedResource, ImageContent, TextContent
-
-CONTENT_TYPES = TextContent | ImageContent | EmbeddedResource
-
-
-class Message(BaseModel):
-    """Base class for all prompt messages."""
-
-    role: Literal["user", "assistant"]
-    content: CONTENT_TYPES
-
-    def __init__(self, content: str | CONTENT_TYPES, **kwargs):
-        if isinstance(content, str):
-            content = TextContent(type="text", text=content)
-        super().__init__(content=content, **kwargs)
-
-
-class UserMessage(Message):
-    """A message from the user."""
-
-    role: Literal["user", "assistant"] = "user"
-
-    def __init__(self, content: str | CONTENT_TYPES, **kwargs):
-        super().__init__(content=content, **kwargs)
-
-
-class AssistantMessage(Message):
-    """A message from the assistant."""
-
-    role: Literal["user", "assistant"] = "assistant"
-
-    def __init__(self, content: str | CONTENT_TYPES, **kwargs):
-        super().__init__(content=content, **kwargs)
-
-
-message_validator = TypeAdapter(UserMessage | AssistantMessage)
-
-SyncPromptResult = (
-    str | Message | dict[str, Any] | Sequence[str | Message | dict[str, Any]]
-)
-PromptResult = SyncPromptResult | Awaitable[SyncPromptResult]
-
-
-class PromptArgument(BaseModel):
-    """An argument that can be passed to a prompt."""
-
-    name: str = Field(description="Name of the argument")
-    description: str | None = Field(
-        None, description="Description of what the argument does"
-    )
-    required: bool = Field(
-        default=False, description="Whether the argument is required"
-    )
-
-
-class Prompt(BaseModel):
-    """A prompt template that can be rendered with parameters."""
-
-    name: str = Field(description="Name of the prompt")
-    description: str | None = Field(
-        None, description="Description of what the prompt does"
-    )
-    arguments: list[PromptArgument] | None = Field(
-        None, description="Arguments that can be passed to the prompt"
-    )
-    fn: Callable = Field(exclude=True)
-
-    @classmethod
-    def from_function(
-        cls,
-        fn: Callable[..., PromptResult],
-        name: str | None = None,
-        description: str | None = None,
-    ) -> "Prompt":
-        """Create a Prompt from a function.
-
-        The function can return:
-        - A string (converted to a message)
-        - A Message object
-        - A dict (converted to a message)
-        - A sequence of any of the above
-        """
-        func_name = name or fn.__name__
-
-        if func_name == "<lambda>":
-            raise ValueError("You must provide a name for lambda functions")
-
-        # Get schema from TypeAdapter - will fail if function isn't properly typed
-        parameters = TypeAdapter(fn).json_schema()
-
-        # Convert parameters to PromptArguments
-        arguments = []
-        if "properties" in parameters:
-            for param_name, param in parameters["properties"].items():
-                required = param_name in parameters.get("required", [])
-                arguments.append(
-                    PromptArgument(
-                        name=param_name,
-                        description=param.get("description"),
-                        required=required,
-                    )
-                )
-
-        # ensure the arguments are properly cast
-        fn = validate_call(fn)
-
-        return cls(
-            name=func_name,
-            description=description or fn.__doc__ or "",
-            arguments=arguments,
-            fn=fn,
-        )
-
-    async def render(self, arguments: dict[str, Any] | None = None) -> list[Message]:
-        """Render the prompt with arguments."""
-        # Validate required arguments
-        if self.arguments:
-            required = {arg.name for arg in self.arguments if arg.required}
-            provided = set(arguments or {})
-            missing = required - provided
-            if missing:
-                raise ValueError(f"Missing required arguments: {missing}")
-
-        try:
-            # Call function and check if result is a coroutine
-            result = self.fn(**(arguments or {}))
-            if inspect.iscoroutine(result):
-                result = await result
-
-            # Validate messages
-            if not isinstance(result, (list, tuple)):
-                result = [result]
-
-            # Convert result to messages
-            messages = []
-            for msg in result:
-                try:
-                    if isinstance(msg, Message):
-                        messages.append(msg)
-                    elif isinstance(msg, dict):
-                        msg = message_validator.validate_python(msg)
-                        messages.append(msg)
-                    elif isinstance(msg, str):
-                        messages.append(
-                            UserMessage(content=TextContent(type="text", text=msg))
-                        )
-                    else:
-                        msg = json.dumps(pydantic_core.to_jsonable_python(msg))
-                        messages.append(Message(role="user", content=msg))
-                except Exception:
-                    raise ValueError(
-                        f"Could not convert prompt result to message: {msg}"
-                    )
-
-            return messages
-        except Exception as e:
-            raise ValueError(f"Error rendering prompt {self.name}: {e}")

acp/server/highlevel/prompts/manager.py

@@ -1,50 +0,0 @@
-"""Prompt management functionality."""
-
-from typing import Any
-
-from acp.server.highlevel.prompts.base import Message, Prompt
-from acp.server.highlevel.utilities.logging import get_logger
-
-logger = get_logger(__name__)
-
-
-class PromptManager:
-    """Manages FastMCP prompts."""
-
-    def __init__(self, warn_on_duplicate_prompts: bool = True):
-        self._prompts: dict[str, Prompt] = {}
-        self.warn_on_duplicate_prompts = warn_on_duplicate_prompts
-
-    def get_prompt(self, name: str) -> Prompt | None:
-        """Get prompt by name."""
-        return self._prompts.get(name)
-
-    def list_prompts(self) -> list[Prompt]:
-        """List all registered prompts."""
-        return list(self._prompts.values())
-
-    def add_prompt(
-        self,
-        prompt: Prompt,
-    ) -> Prompt:
-        """Add a prompt to the manager."""
-
-        # Check for duplicates
-        existing = self._prompts.get(prompt.name)
-        if existing:
-            if self.warn_on_duplicate_prompts:
-                logger.warning(f"Prompt already exists: {prompt.name}")
-            return existing
-
-        self._prompts[prompt.name] = prompt
-        return prompt
-
-    async def render_prompt(
-        self, name: str, arguments: dict[str, Any] | None = None
-    ) -> list[Message]:
-        """Render a prompt by name with arguments."""
-        prompt = self.get_prompt(name)
-        if not prompt:
-            raise ValueError(f"Unknown prompt: {name}")
-
-        return await prompt.render(arguments)

acp/server/highlevel/prompts/prompt_manager.py

@@ -1,33 +0,0 @@
-"""Prompt management functionality."""
-
-from acp.server.highlevel.prompts.base import Prompt
-from acp.server.highlevel.utilities.logging import get_logger
-
-logger = get_logger(__name__)
-
-
-class PromptManager:
-    """Manages FastMCP prompts."""
-
-    def __init__(self, warn_on_duplicate_prompts: bool = True):
-        self._prompts: dict[str, Prompt] = {}
-        self.warn_on_duplicate_prompts = warn_on_duplicate_prompts
-
-    def add_prompt(self, prompt: Prompt) -> Prompt:
-        """Add a prompt to the manager."""
-        logger.debug(f"Adding prompt: {prompt.name}")
-        existing = self._prompts.get(prompt.name)
-        if existing:
-            if self.warn_on_duplicate_prompts:
-                logger.warning(f"Prompt already exists: {prompt.name}")
-            return existing
-        self._prompts[prompt.name] = prompt
-        return prompt
-
-    def get_prompt(self, name: str) -> Prompt | None:
-        """Get prompt by name."""
-        return self._prompts.get(name)
-
-    def list_prompts(self) -> list[Prompt]:
-        """List all registered prompts."""
-        return list(self._prompts.values())