mcp-types 0.0.1__py3-none-any.whl

mcp_types/errors.py

@@ -0,0 +1,10 @@
+from __future__ import annotations as _annotations
+
+from typing import Literal
+from mcp_types.jsonrpc import JSONRPCError
+
+MethodNotFoundCode = Literal[-32601]
+InternalErrorCode = Literal[-32603]
+
+ListRootNotFound = JSONRPCError[MethodNotFoundCode]
+ListRootInternalError = JSONRPCError[InternalErrorCode]

mcp_types/jsonrpc.py

@@ -0,0 +1,74 @@
+"""This module contains the JSON RPC types for the MCP.
+
+The request types are `TypedDict`s, while the response types are `BaseModel`s.
+
+This not only provides the best developer experience, but also conceptually, there's no
+need to validate the request types using a type checker. On the other hand, you need to
+make sure the data that you receive in the response is valid.
+"""
+
+from __future__ import annotations as _annotations
+
+from typing import Annotated, Any, Generic, Literal, TypeVar
+from pydantic import BaseModel, Field
+from typing_extensions import TypedDict, NotRequired
+
+RequestId = Annotated[int | str, Field(union_mode="left_to_right")]
+
+
+MethodT = TypeVar("MethodT", bound=str)
+ParamsT = TypeVar("ParamsT", default=None)
+
+
+class JSONRPCRequest(TypedDict, Generic[MethodT, ParamsT]):
+    """A JSON RPC request."""
+
+    jsonrpc: Literal["2.0"]
+    """The JSON RPC version."""
+
+    id: RequestId
+
+    method: MethodT
+    """The method to call."""
+
+    params: NotRequired[ParamsT]
+    """The parameters to pass to the method."""
+
+
+CodeT = TypeVar("CodeT", bound=int)
+MessageT = TypeVar("MessageT", bound=str, default=str)
+
+
+class ErrorData(BaseModel, Generic[CodeT, MessageT]):
+    """A JSON RPC error."""
+
+    code: CodeT
+    message: MessageT
+    data: Any = None
+
+
+ResultT = TypeVar("ResultT", bound=BaseModel)
+
+
+class _BaseJSONRPCResponse(BaseModel):
+    """A base class for JSON RPC responses."""
+
+    jsonrpc: Literal["2.0"]
+    """The JSON RPC version."""
+
+    id: RequestId
+
+
+class JSONRPCResponse(_BaseJSONRPCResponse, Generic[ResultT]):
+    """A JSON RPC response."""
+
+    result: ResultT
+
+
+ErrorT = TypeVar("ErrorT")
+
+
+class JSONRPCError(_BaseJSONRPCResponse, Generic[CodeT, MessageT]):
+    """A JSON RPC response that indicates an error occurred."""
+
+    error: ErrorData[CodeT, MessageT]

mcp_types/requests.py

@@ -0,0 +1,421 @@
+from __future__ import annotations as _annotations
+
+from typing import Any, Literal, NotRequired
+from pydantic import BaseModel, Discriminator, Field
+from typing_extensions import Annotated, TypedDict
+from mcp_types.jsonrpc import JSONRPCRequest
+
+
+class RootsCapability(TypedDict, total=False):
+    """Ability to provide filesystem roots.
+
+    See more on <https://modelcontextprotocol.io/specification/2025-06-18/client/roots>.
+    """
+
+    list_changed: bool
+    """indicates whether the client will emit notifications when the list of roots changes."""
+
+
+class SamplingCapability(TypedDict):
+    """Support for LLM sampling requests.
+
+    See more on <https://modelcontextprotocol.io/specification/2025-06-18/client/sampling>.
+    """
+
+
+class ElicitationCapability(BaseModel):
+    """Capability for elicitation operations.
+
+    See more on <https://modelcontextprotocol.io/specification/2025-06-18/client/elicitation>.
+    """
+
+
+class ClientCapabilities(TypedDict):
+    """Capabilities a client may support.
+
+    Known capabilities are defined here, in this schema, but this is not a closed set:
+    any client can define its own, additional capabilities.
+    """
+
+    roots: NotRequired[RootsCapability]
+    """Ability to provide filesystem roots.
+
+    See more on <https://modelcontextprotocol.io/specification/2025-06-18/client/roots>.
+    """
+
+    sampling: NotRequired[SamplingCapability]
+    """Support for LLM sampling requests.
+
+    See more on <https://modelcontextprotocol.io/specification/2025-06-18/client/sampling>.
+    """
+
+    elicitation: NotRequired[ElicitationCapability]
+    """Support for elicitation requests.
+
+    See more on <https://modelcontextprotocol.io/specification/2025-06-18/client/elicitation>.
+    """
+
+    experimental: NotRequired[dict[str, dict[str, Any]]]
+    """Experimental, non-standard capabilities that the client supports."""
+
+
+class Implementation(BaseModel):
+    name: str
+    title: str | None = None
+    version: str
+
+
+class InitializeRequestParams(TypedDict):
+    """Parameters for the initialize request."""
+
+    protocol_version: Annotated[Literal["2025-06-18"], Field(alias="protocolVersion")]
+    """The latest version of the Model Context Protocol that the client supports."""
+
+    capabilities: ClientCapabilities
+
+    client_info: Annotated[Implementation, Field(alias="clientInfo")]
+
+
+class TextContent(TypedDict):
+    """A text content."""
+
+    type: Literal["text"]
+    """The type of content."""
+
+    text: str
+    """The text content."""
+
+
+class ImageContent(TypedDict):
+    """An image content."""
+
+    type: Literal["image"]
+    """The type of content."""
+
+    data: str
+    """Base64 encoded image data."""
+
+    mime_type: Annotated[str, Field(alias="mimeType")]
+    """The MIME type of the image."""
+
+
+class AudioContent(TypedDict):
+    """An audio content."""
+
+    type: Literal["audio"]
+    """The type of content."""
+
+    data: str
+    """Base64 encoded audio data."""
+
+    mime_type: Annotated[str, Field(alias="mimeType")]
+    """The MIME type of the audio."""
+
+
+class TextResourceContents(TypedDict):
+    """Text resource contents."""
+
+    uri: str
+    """The URI of this resource."""
+
+    text: str
+    """The text content of the resource."""
+
+    mime_type: Annotated[NotRequired[str], Field(alias="mimeType")]
+    """The MIME type of this resource, if known."""
+
+
+class BlobResourceContents(TypedDict):
+    """Binary resource contents."""
+
+    uri: str
+    """The URI of this resource."""
+
+    blob: str
+    """A base64-encoded string representing the binary data."""
+
+    mime_type: Annotated[NotRequired[str], Field(alias="mimeType")]
+    """The MIME type of this resource, if known."""
+
+
+class EmbeddedResource(TypedDict):
+    """An embedded resource."""
+
+    type: Literal["resource"]
+    """The type of resource."""
+
+    resource: TextResourceContents | BlobResourceContents
+
+
+Role = Literal["user", "assistant"]
+Content = Annotated[TextContent | ImageContent | AudioContent | EmbeddedResource, Discriminator("type")]
+
+
+class SamplingMessage(TypedDict):
+    role: Role
+    content: Content
+
+
+class ModelHint(TypedDict):
+    """A hint for the model to use."""
+
+    name: str
+    """The name of the model."""
+
+
+class ModelPreferences(TypedDict):
+    """The server's preferences for which model to select."""
+
+    cost_priority: Annotated[NotRequired[float], Field(alias="costPriority")]
+    """How important is minimizing costs? Higher values prefer cheaper models."""
+
+    speed_priority: Annotated[NotRequired[float], Field(alias="speedPriority")]
+    """How important is low latency? Higher values prefer faster models."""
+
+    intelligence_priority: Annotated[NotRequired[float], Field(alias="intelligencePriority")]
+    """How important are advanced capabilities? Higher values prefer more capable models."""
+
+    hints: NotRequired[list[ModelHint]]
+
+
+class CreateMessageSamplingRequestParams(TypedDict):
+    """Parameters for creating a message."""
+
+    messages: list[SamplingMessage]
+
+    model_preferences: Annotated[NotRequired[ModelPreferences], Field(alias="modelPreferences")]
+    """The server's preferences for which model to select.
+
+    The client MAY ignore these preferences.
+
+    See more on <https://modelcontextprotocol.io/specification/2025-06-18/client/sampling#model-preferences>.
+    """
+    system_prompt: Annotated[NotRequired[str], Field(alias="systemPrompt")]
+    """An optional system prompt the server wants to use for sampling."""
+
+    temperature: NotRequired[float]
+    """The temperature to use for sampling."""
+
+    max_tokens: Annotated[int, Field(alias="maxTokens")]
+    """The maximum number of tokens to sample, as requested by the server."""
+
+    stop_sequences: Annotated[NotRequired[list[str]], Field(alias="stopSequences")]
+    """Stop sequences for sampling."""
+
+
+class GetPromptRequestParams(TypedDict):
+    """Parameters for getting a message."""
+
+    name: str
+    """The name of the message to get."""
+
+    arguments: NotRequired[dict[str, str]]
+    """Arguments to use for templating the message."""
+
+
+class ListResourcesRequestParams(TypedDict, total=False):
+    """Parameters for listing resources."""
+
+    cursor: str
+    """An opaque token representing the current pagination position."""
+
+
+class ReadResourceRequestParams(TypedDict):
+    """Parameters for reading a resource."""
+
+    uri: str
+    """The URI of the resource to read."""
+
+
+class ListResourceTemplatesRequestParams(TypedDict, total=False):
+    """Parameters for listing resource templates."""
+
+    cursor: str
+    """An opaque token representing the current pagination position."""
+
+
+class SubscribeRequestParams(TypedDict):
+    """Parameters for subscribing to resource updates."""
+
+    uri: str
+    """The URI of the resource to subscribe to."""
+
+
+class UnsubscribeRequestParams(TypedDict):
+    """Parameters for unsubscribing from resource updates."""
+
+    uri: str
+    """The URI of the resource to unsubscribe from."""
+
+
+class ListPromptsRequestParams(TypedDict, total=False):
+    """Parameters for listing prompts."""
+
+    cursor: str
+    """An opaque token representing the current pagination position."""
+
+
+class ListToolsRequestParams(TypedDict, total=False):
+    """Parameters for listing tools."""
+
+    cursor: str
+    """An opaque token representing the current pagination position."""
+
+
+class CallToolRequestParams(TypedDict):
+    """Parameters for calling a tool."""
+
+    name: str
+    """The name of the tool to call."""
+
+    arguments: NotRequired[dict[str, Any]]
+    """Arguments to pass to the tool."""
+
+
+class SetLevelRequestParams(TypedDict):
+    """Parameters for setting logging level."""
+
+    level: str
+    """The logging level to set."""
+
+
+class CompleteRequestParams(TypedDict):
+    """Parameters for completion request."""
+
+    ref: dict[str, Any]
+    """Reference to the resource being completed."""
+
+    argument: dict[str, str]
+    """The argument information for completion."""
+
+    context: NotRequired[dict[str, Any]]
+    """Additional context for completion."""
+
+
+class PingRequestParams(TypedDict):
+    """A ping, issued by either the server or the client, to check that the other party is still alive.
+
+    The receiver must promptly respond, or else may be disconnected.
+    """
+
+
+class CreateMessageRequestParams(TypedDict):
+    """Parameters for creating a message."""
+
+    messages: list[SamplingMessage]
+    """The messages to send to the LLM."""
+
+    max_tokens: Annotated[int, Field(alias="maxTokens")]
+    """The maximum number of tokens to sample."""
+
+    model_preferences: Annotated[NotRequired[ModelPreferences], Field(alias="modelPreferences")]
+    """The server's preferences for which model to select."""
+
+    system_prompt: Annotated[NotRequired[str], Field(alias="systemPrompt")]
+    """An optional system prompt the server wants to use for sampling."""
+
+    temperature: NotRequired[float]
+    """The temperature to use for sampling."""
+
+    stop_sequences: Annotated[NotRequired[list[str]], Field(alias="stopSequences")]
+    """Stop sequences for sampling."""
+
+    include_context: Annotated[NotRequired[str], Field(alias="includeContext")]
+    """A request to include context from MCP servers."""
+
+    metadata: NotRequired[dict[str, Any]]
+    """Optional metadata to pass through to the LLM provider."""
+
+
+class ListRootsRequestParams(TypedDict, total=False):
+    """Parameters for listing roots."""
+
+
+class ElicitRequestParams(TypedDict):
+    """Parameters for elicitation requests."""
+
+    message: str
+    """The message to present to the user."""
+    requested_schema: Annotated[dict[str, Any], Field(alias="requestedSchema")]
+    """A restricted subset of JSON Schema."""
+
+
+InitializeRequest = JSONRPCRequest[Literal["initialize"], InitializeRequestParams]
+"""This request is sent from the client to the server when it first connects, asking it to begin initialization."""
+
+PingRequest = JSONRPCRequest[Literal["ping"], PingRequestParams]
+"""A ping, issued by either the server or the client, to check that the other party is still alive.
+
+The receiver must promptly respond, or else may be disconnected.
+"""
+
+InitializedNotification = JSONRPCRequest[Literal["notifications/initialized"]]
+"""his notification is sent from the client to the server after initialization has finished."""
+
+ListRootsRequest = JSONRPCRequest[Literal["roots/list"]]
+"""Retrieve the list of filesystem roots."""
+
+ListChangedRootsNotification = JSONRPCRequest[Literal["notifications/roots/list_changed"]]
+"""A notification that the list of filesystem roots has changed."""
+
+CreateMessageSamplingRequest = JSONRPCRequest[Literal["sampling/createMessage"], CreateMessageSamplingRequestParams]
+
+GetPromptRequest = JSONRPCRequest[Literal["prompts/get"], GetPromptRequestParams]
+
+ListResourcesRequest = JSONRPCRequest[Literal["resources/list"], ListResourcesRequestParams]
+"""Sent from the client to request a list of resources the server has."""
+
+ReadResourceRequest = JSONRPCRequest[Literal["resources/read"], ReadResourceRequestParams]
+"""Sent from the client to the server, to read a specific resource URI."""
+
+ListResourceTemplatesRequest = JSONRPCRequest[Literal["resources/templates/list"], ListResourceTemplatesRequestParams]
+"""Sent from the client to request a list of resource templates the server has."""
+
+SubscribeRequest = JSONRPCRequest[Literal["resources/subscribe"], SubscribeRequestParams]
+"""Sent from the client to request resources/updated notifications from the server."""
+
+UnsubscribeRequest = JSONRPCRequest[Literal["resources/unsubscribe"], UnsubscribeRequestParams]
+"""Sent from the client to request cancellation of resources/updated notifications."""
+
+ListPromptsRequest = JSONRPCRequest[Literal["prompts/list"], ListPromptsRequestParams]
+"""Sent from the client to request a list of prompts and prompt templates the server has."""
+
+ListToolsRequest = JSONRPCRequest[Literal["tools/list"], ListToolsRequestParams]
+"""Sent from the client to request a list of tools the server has."""
+
+CallToolRequest = JSONRPCRequest[Literal["tools/call"], CallToolRequestParams]
+"""Used by the client to invoke a tool provided by the server."""
+
+SetLevelRequest = JSONRPCRequest[Literal["logging/setLevel"], SetLevelRequestParams]
+"""A request from the client to the server, to enable or adjust logging."""
+
+CompleteRequest = JSONRPCRequest[Literal["completion/complete"], CompleteRequestParams]
+"""A request from the client to the server, to ask for completion options."""
+
+
+CreateMessageRequest = JSONRPCRequest[Literal["sampling/createMessage"], CreateMessageRequestParams]
+"""A request from the server to sample an LLM via the client."""
+
+ListRootsRequest = JSONRPCRequest[Literal["roots/list"], ListRootsRequestParams]
+"""Sent from the server to request a list of root URIs from the client."""
+
+ElicitRequest = JSONRPCRequest[Literal["elicitation/create"], ElicitRequestParams]
+"""A request from the server to elicit additional information from the user via the client."""
+
+ClientNotification = InitializedNotification | ListChangedRootsNotification
+ClientRequest = (
+    InitializeRequest
+    | PingRequest
+    | ListResourcesRequest
+    | ListResourceTemplatesRequest
+    | ReadResourceRequest
+    | SubscribeRequest
+    | UnsubscribeRequest
+    | ListPromptsRequest
+    | GetPromptRequest
+    | ListToolsRequest
+    | CallToolRequest
+    | SetLevelRequest
+    | CompleteRequest
+)
+ServerRequest = PingRequest | CreateMessageRequest | ListRootsRequest | ElicitRequest

mcp_types/responses.py

@@ -0,0 +1,373 @@
+from __future__ import annotations as _annotations
+from typing import Annotated, Any, Literal
+
+from pydantic import BaseModel, Field
+
+from mcp_types.jsonrpc import JSONRPCResponse
+from mcp_types.requests import Role, TextResourceContents, BlobResourceContents
+
+PROTOCOL_VERSION = "2025-06-18"
+
+
+class BaseResult(BaseModel):
+    """Base result for all responses."""
+
+    _meta: dict[str, Any] | None = None
+    """See [specification/2025-06-18/basic/index#general-fields] for notes on _meta usage."""
+
+
+class CompletionsCapability(BaseModel, extra="allow"): ...
+
+
+class LoggingCapability(BaseModel, extra="allow"): ...
+
+
+class PromptsCapability(BaseModel):
+    """Present if the server offers any prompt templates."""
+
+    list_changed: Annotated[bool | None, Field(alias="listChanged")] = None
+    """Whether this server supports notifications for changes to the prompt list."""
+
+
+class ResourcesCapability(BaseModel):
+    """Present if the server offers any resources to read."""
+
+    list_changed: Annotated[bool | None, Field(alias="listChanged")] = None
+    """Whether this server supports notifications for changes to the resource list."""
+
+    subscribe: bool | None = None
+    """Whether this server supports subscribing to resource updates."""
+
+
+class ToolsCapability(BaseModel):
+    """Present if the server offers any tools to call."""
+
+    list_changed: Annotated[bool | None, Field(alias="listChanged")] = None
+    """Whether this server supports notifications for changes to the tool list."""
+
+
+class ServerCapabilities(BaseModel):
+    """Capabilities that a server may support.
+
+    Known capabilities are defined here, in this schema, but this is not a closed set:
+    any server can define its own, additional capabilities.
+    """
+
+    completions: CompletionsCapability | None = None
+    """Present if the server supports argument autocompletion suggestions."""
+
+    logging: LoggingCapability | None = None
+    """Present if the server supports sending log messages to the client."""
+
+    prompts: PromptsCapability | None = None
+    """Present if the server offers any prompt templates."""
+
+    resources: ResourcesCapability | None = None
+    """Present if the server offers any resources to read."""
+
+    tools: ToolsCapability | None = None
+    """Present if the server offers any tools to call."""
+
+    experimental: dict[str, dict[str, Any]] | None = None
+    """Experimental, non-standard capabilities that the server supports."""
+
+
+class Implementation(BaseModel):
+    name: str
+    title: str | None = None
+    version: str
+
+
+class InitializeResult(BaseResult):
+    """After receiving an initialize request from the client, the server sends this response."""
+
+    capabilities: ServerCapabilities
+    """Capabilities that a server may support.
+
+    Known capabilities are defined here, in this schema, but this is not a closed set:
+    any server can define its own, additional capabilities.
+    """
+
+    instructions: str | None = None
+    """Instructions describing how to use the server and its features.
+
+    This can be used by clients to improve the LLM's understanding of available tools,
+    resources, etc. It can be thought of like a "hint" to the model. For example, this
+    information MAY be added to the system prompt.
+    """
+
+    protocol_version: Annotated[str, Field(alias="protocolVersion")] = PROTOCOL_VERSION
+    """The version of the Model Context Protocol that the server wants to use.
+
+    This may not match the version that the client requested. If the client cannot support
+    this version, it MUST disconnect.
+    """
+
+    server_info: Annotated[Implementation, Field(alias="serverInfo")]
+    """Describes the name and version of an MCP implementation, with an optional title for UI representation."""
+
+
+class TextContent(BaseModel):
+    """A text content."""
+
+    type: Literal["text"] = "text"
+    """The type of content."""
+    text: str
+
+
+class ImageContent(BaseModel):
+    """An image content."""
+
+    type: Literal["image"] = "image"
+    """The type of content."""
+    data: str
+    """Base64 encoded image data."""
+    mime_type: Annotated[str, Field(alias="mimeType")]
+
+
+class AudioContent(BaseModel):
+    """An audio content."""
+
+    type: Literal["audio"] = "audio"
+    """The type of content."""
+    data: str
+    """Base64 encoded audio data."""
+    mime_type: Annotated[str, Field(alias="mimeType")]
+
+
+ContentBlock = TextContent | ImageContent | AudioContent
+StopReason = Literal["endTurn", "stopSequence", "maxTokens"]
+
+
+class Resource(BaseModel):
+    """A known resource that the server is capable of reading."""
+
+    uri: str
+    """The URI of this resource."""
+    name: str
+    """The name of the resource."""
+    title: str | None = None
+    """The title of the resource."""
+    description: str | None = None
+    """A description of what this resource represents."""
+    mime_type: Annotated[str | None, Field(alias="mimeType")] = None
+    """The MIME type of this resource, if known."""
+    size: int | None = None
+    """The size of the resource in bytes."""
+    _meta: dict[str, Any] | None = None
+
+
+class ResourceTemplate(BaseModel):
+    """A template description for resources available on the server."""
+
+    uri_template: Annotated[str, Field(alias="uriTemplate")]
+    """A URI template that can be used to construct resource URIs."""
+    name: str
+    """The name of the template."""
+    title: str | None = None
+    """The title of the template."""
+    description: str | None = None
+    """A description of what this template is for."""
+    mime_type: Annotated[str | None, Field(alias="mimeType")] = None
+    """The MIME type for all resources that match this template."""
+    _meta: dict[str, Any] | None = None
+
+
+class ListResourcesResult(BaseResult):
+    """The server's response to a resources/list request from the client."""
+
+    resources: list[Resource]
+    """List of resources available."""
+    next_cursor: Annotated[str | None, Field(alias="nextCursor")] = None
+    """An opaque token for pagination."""
+
+
+class ListResourceTemplatesResult(BaseResult):
+    """The server's response to a resources/templates/list request from the client."""
+
+    resource_templates: Annotated[list[ResourceTemplate], Field(alias="resourceTemplates")]
+    """List of resource templates available."""
+    next_cursor: Annotated[str | None, Field(alias="nextCursor")] = None
+    """An opaque token for pagination."""
+
+
+class ReadResourceResult(BaseResult):
+    """The server's response to a resources/read request from the client."""
+
+    contents: list[TextResourceContents | BlobResourceContents]
+    """The contents of the resource."""
+
+
+class CreateMessageSamplingResult(BaseModel):
+    """The client's response to a sampling/create_message request from the server."""
+
+    role: Role
+    content: TextContent | ImageContent | AudioContent
+    model: str
+    """The name of the model that generated the message."""
+    stop_reason: Annotated[StopReason | None, Field(alias="stopReason")] = None
+    """The reason why sampling stopped, if known."""
+
+
+class Tool(BaseModel):
+    """Definition for a tool the client can call."""
+
+    name: str
+    """The name of the tool."""
+    title: str | None = None
+    """The title of the tool."""
+    description: str | None = None
+    """A description of the tool."""
+    input_schema: Annotated[dict[str, Any], Field(alias="inputSchema")]
+    """A JSON Schema object defining the expected parameters for the tool."""
+    output_schema: Annotated[dict[str, Any] | None, Field(alias="outputSchema")] = None
+    """An optional JSON Schema object defining the structure of the tool's output."""
+    _meta: dict[str, Any] | None = None
+
+
+class ListToolsResult(BaseResult):
+    """The server's response to a tools/list request from the client."""
+
+    tools: list[Tool]
+    """List of tools available."""
+    next_cursor: Annotated[str | None, Field(alias="nextCursor")] = None
+    """An opaque token for pagination."""
+
+
+class CallToolResult(BaseResult):
+    """The server's response to a tool call."""
+
+    content: list[ContentBlock]
+    """A list of content objects that represent the unstructured result of the tool call."""
+    is_error: Annotated[bool | None, Field(alias="isError")] = None
+    """Whether the tool call ended in an error."""
+    structured_content: Annotated[dict[str, Any] | None, Field(alias="structuredContent")] = None
+    """An optional JSON object that represents the structured result of the tool call."""
+
+
+class PromptArgument(BaseModel):
+    """Describes an argument that a prompt can accept."""
+
+    name: str
+    """The name of the argument."""
+    title: str | None = None
+    """The title of the argument."""
+    description: str | None = None
+    """A description of the argument."""
+    required: bool | None = None
+    """Whether this argument must be provided."""
+
+
+class Prompt(BaseModel):
+    """A prompt or prompt template that the server offers."""
+
+    name: str
+    """The name of the prompt."""
+    title: str | None = None
+    """The title of the prompt."""
+    description: str | None = None
+    """An optional description of what this prompt provides."""
+    arguments: list[PromptArgument] | None = None
+    """A list of arguments to use for templating the prompt."""
+    _meta: dict[str, Any] | None = None
+
+
+class PromptMessage(BaseModel):
+    """Describes a message returned as part of a prompt."""
+
+    role: Role
+    """The role of the message sender."""
+    content: ContentBlock
+    """The content of the message."""
+
+
+class ListPromptsResult(BaseResult):
+    """The server's response to a prompts/list request from the client."""
+
+    prompts: list[Prompt]
+    """List of prompts available."""
+    next_cursor: Annotated[str | None, Field(alias="nextCursor")] = None
+    """An opaque token for pagination."""
+
+
+class GetPromptResult(BaseResult):
+    """The server's response to a prompts/get request from the client."""
+
+    description: str | None = None
+    """An optional description for the prompt."""
+    messages: list[PromptMessage]
+    """The messages that make up the prompt."""
+
+
+class CompleteResult(BaseResult):
+    """The server's response to a completion/complete request."""
+
+    completion: dict[str, Any]
+    """The completion information."""
+
+
+class Root(BaseModel):
+    """Represents a root directory or file that the server can operate on."""
+
+    uri: str
+    """The URI identifying the root."""
+    name: str | None = None
+    """An optional name for the root."""
+    _meta: dict[str, Any] | None = None
+
+
+class ListRootsResult(BaseResult):
+    """The client's response to a roots/list request from the server."""
+
+    roots: list[Root]
+    """List of root directories or files."""
+
+
+class ElicitResult(BaseResult):
+    """The client's response to an elicitation request."""
+
+    action: Literal["accept", "decline", "cancel"]
+    """The user action in response to the elicitation."""
+    content: dict[str, str | int | bool] | None = None
+    """The submitted form data, only present when action is 'accept'."""
+
+
+class CreateMessageResult(BaseResult):
+    """The client's response to a sampling/createMessage request from the server."""
+
+    role: Role
+    """The role of the message."""
+    content: ContentBlock
+    """The content of the message."""
+    model: str
+    """The name of the model that generated the message."""
+    stop_reason: Annotated[str | None, Field(alias="stopReason")] = None
+    """The reason why sampling stopped, if known."""
+
+
+InitializeResponse = JSONRPCResponse[InitializeResult]
+ListResourcesResponse = JSONRPCResponse[ListResourcesResult]
+ListResourceTemplatesResponse = JSONRPCResponse[ListResourceTemplatesResult]
+ReadResourceResponse = JSONRPCResponse[ReadResourceResult]
+ListPromptsResponse = JSONRPCResponse[ListPromptsResult]
+GetPromptResponse = JSONRPCResponse[GetPromptResult]
+ListToolsResponse = JSONRPCResponse[ListToolsResult]
+CallToolResponse = JSONRPCResponse[CallToolResult]
+CompleteResponse = JSONRPCResponse[CompleteResult]
+ListRootsResponse = JSONRPCResponse[ListRootsResult]
+ElicitResponse = JSONRPCResponse[ElicitResult]
+CreateMessageResponse = JSONRPCResponse[CreateMessageResult]
+
+ClientResponse = CreateMessageResponse | ListRootsResponse | ElicitResponse
+
+ServerResponse = (
+    InitializeResponse
+    | ListResourcesResponse
+    | ListResourceTemplatesResponse
+    | ReadResourceResponse
+    | ListPromptsResponse
+    | GetPromptResponse
+    | ListToolsResponse
+    | CallToolResponse
+    | CompleteResponse
+)

mcp_types-0.0.1.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: mcp-types
+Version: 0.0.1
+Summary: Add your description here
+Requires-Python: >=3.13
+Requires-Dist: pydantic>=2.11.3
+Requires-Dist: typing-extensions>=4.13.2

mcp_types-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+mcp_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_types/errors.py,sha256=Ru9YF_VODCKUNHzyGO5FyRw8OHIdN_xRzCYGmnaE_AM,305
+mcp_types/jsonrpc.py,sha256=HiSM-itij9kXGIRrJESfUzS5LzEpEnfe2fX3dlk8vGk,1815
+mcp_types/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_types/requests.py,sha256=uhGwlnsXf06n_D51om2rMhTNWrxilX6wS0kwGPOcONw,13418
+mcp_types/responses.py,sha256=5FgspuQajfAfSFdN2EBA8vC_ivNTWWMwpZDANvlI2Ak,12469
+mcp_types-0.0.1.dist-info/METADATA,sha256=_TGx7Z9sTPv6iWNkMzVeId713zU3OT58PTxqnpFphTo,185
+mcp_types-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_types-0.0.1.dist-info/RECORD,,

mcp_types-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any