mcp

type Annotated struct {
	Annotations *Annotations `json:"annotations,omitempty"`
}

type Annotations struct {
	// Describes who the intended customer of this object or data is.
	//
	// It can include multiple entries to indicate content useful for multiple
	// audiences (e.g., `["user", "assistant"]`).
	Audience []Role `json:"audience,omitempty"`

	// Describes how important this data is for operating the server.
	//
	// A value of 1 means "most important," and indicates that the data is
	// effectively required, while 0 means "least important," and indicates that
	// the data is entirely optional.
	// Priority ranges from 0.0 to 1.0 (1 = most important, 0 = least important).
	Priority *float64 `json:"priority,omitempty"`
	// ISO 8601 formatted timestamp (e.g., "2025-01-12T15:00:58Z")
	LastModified string `json:"lastModified,omitempty"`
}

type ArgumentOption func(*PromptArgument)

type AudioContent struct {
	Annotated
	// Meta is a metadata object that is reserved by MCP for storing additional information.
	Meta *Meta  `json:"_meta,omitempty"`
	Type string `json:"type"` // Must be "audio"
	// The base64-encoded audio data.
	Data string `json:"data"`
	// The MIME type of the audio. Different providers may support different audio types.
	MIMEType string `json:"mimeType"`
}

type BlobResourceContents struct {
	// Raw per‑resource metadata; pass‑through as defined by MCP. Not the same as mcp.Meta.
	// Allows _meta to be used for MCP-UI features for example. Does not assume any specific format.
	Meta map[string]any `json:"_meta,omitempty"`
	// The URI of this resource.
	URI string `json:"uri"`
	// The MIME type of this resource, if known.
	MIMEType string `json:"mimeType,omitempty"`
	// A base64-encoded string representing the binary data of the item.
	Blob string `json:"blob"`
}

type CacheHintSetter interface {
	SetCacheHints(ttlMs int64, scope CacheScope)
}

type CacheScope string

type CacheableResult struct {
	Result

	// TTLMs is a hint indicating how long, in milliseconds, the client may
	// cache this response before re-fetching. Semantics are analogous to HTTP
	// Cache-Control max-age. Zero means the response should be considered
	// immediately stale.
	//
	// It is a pointer so that an explicit zero can be distinguished from an
	// unset value; use [CacheableResult.SetCacheHints] to populate it.
	TTLMs *int64 `json:"ttlMs,omitempty"`

	// CacheScope controls whether shared intermediaries may cache the
	// response.
	CacheScope CacheScope `json:"cacheScope,omitempty"`
}

type CallToolParams struct {
	Name      string      `json:"name"`
	Arguments any         `json:"arguments,omitempty"`
	Meta      *Meta       `json:"_meta,omitempty"`
	Task      *TaskParams `json:"task,omitempty"`
	MultiRoundTripParams
	// RawArguments preserves the original JSON bytes for arguments when unmarshaled
	// from a wire message. This avoids precision loss for integers above 2^53.
	RawArguments json.RawMessage `json:"-"`
}

type CallToolRequest struct {
	Request
	Header http.Header    `json:"-"` // HTTP headers from the original request
	Params CallToolParams `json:"params"`
}

type CallToolResult struct {
	Result
	MultiRoundTripResult
	Content []Content `json:"content"` // Can be TextContent, ImageContent, AudioContent, or EmbeddedResource
	// Structured content returned as a JSON object in the structuredContent field of a result.
	// For backwards compatibility, a tool that returns structured content SHOULD also return
	// functionally equivalent unstructured content.
	StructuredContent any `json:"structuredContent,omitempty"`
	// RawStructuredContent preserves the original JSON bytes for structuredContent when
	// unmarshaled from a wire message.
	RawStructuredContent json.RawMessage `json:"-"`
	// Whether the tool call ended in an error.
	//
	// If not set, this is assumed to be false (the call was successful).
	IsError bool `json:"isError,omitempty"`
}

type CancelTaskParams struct {
	TaskId string `json:"taskId"`
}

type CancelTaskRequest struct {
	Request
	Header http.Header      `json:"-"`
	Params CancelTaskParams `json:"params"`
}

type CancelTaskResult struct {
	Result
	Task
}

type CancelledNotification struct {
	Notification
	Params CancelledNotificationParams `json:"params"`
}

type CancelledNotificationParams struct {
	// The ID of the request to cancel.
	//
	// This MUST correspond to the ID of a request previously issued
	// in the same direction.
	RequestId RequestId `json:"requestId"`

	// An optional string describing the reason for the cancellation. This MAY
	// be logged or presented to the user.
	Reason string `json:"reason,omitempty"`
}

type ClientCapabilities struct {
	// Optional, present if the client is advertising extension support.
	Extensions map[string]any `json:"extensions,omitempty"`
	// Experimental, non-standard capabilities that the client supports.
	Experimental map[string]any `json:"experimental,omitempty"`
	// Present if the client supports listing roots.
	Roots *struct {
		// Whether the client supports notifications for changes to the roots list.
		ListChanged bool `json:"listChanged,omitempty"`
	} `json:"roots,omitempty"`
	// Present if the client supports sampling from an LLM.
	Sampling *SamplingCapability `json:"sampling,omitempty"`
	// Present if the client supports elicitation requests from the server.
	Elicitation *ElicitationCapability `json:"elicitation,omitempty"`
	// Present if the client supports task-based execution.
	Tasks *TasksCapability `json:"tasks,omitempty"`
}

type ClientNotification any

type ClientRequest any

type ClientResult any

type CompleteArgument struct {
	// The name of the argument
	Name string `json:"name"`
	// The value of the argument to use for completion matching.
	Value string `json:"value"`
}

type CompleteContext struct {
	Arguments map[string]string `json:"arguments"`
}

type CompleteParams struct {
	Ref      any              `json:"ref"` // Can be PromptReference or ResourceReference
	Argument CompleteArgument `json:"argument"`
	Context  CompleteContext  `json:"context"`
}

type CompleteRequest struct {
	Request
	Params CompleteParams `json:"params"`
	Header http.Header    `json:"-"`
}

type CompleteResult struct {
	Result
	Completion Completion `json:"completion"`
}

type Completion struct {
	// An array of completion values. Must not exceed 100 items.
	Values []string `json:"values"`
	// The total number of completion options available. This can exceed the
	// number of values actually sent in the response.
	Total int `json:"total,omitempty"`
	// Indicates whether there are additional completion options beyond those
	// provided in the current response, even if the exact total is unknown.
	HasMore bool `json:"hasMore,omitempty"`
}

type Content interface {
	// contains filtered or unexported methods
}

type CreateMessageParams struct {
	Messages         []SamplingMessage `json:"messages"`
	ModelPreferences *ModelPreferences `json:"modelPreferences,omitempty"`
	SystemPrompt     string            `json:"systemPrompt,omitempty"`
	IncludeContext   string            `json:"includeContext,omitempty"`
	Temperature      float64           `json:"temperature,omitempty"`
	MaxTokens        int               `json:"maxTokens"`
	StopSequences    []string          `json:"stopSequences,omitempty"`
	Metadata         any               `json:"metadata,omitempty"`
	// Tools the model may use during generation.
	//
	// Per the 2025-11-25 spec, the client MUST return an error if this field
	// is provided but ClientCapabilities.Sampling.Tools is not declared.
	Tools []Tool `json:"tools,omitempty"`
	// ToolChoice controls how the model uses tools during generation.
	//
	// Per the 2025-11-25 spec, the client MUST return an error if this field
	// is provided but ClientCapabilities.Sampling.Tools is not declared.
	// When omitted the client defaults to {Mode: ToolChoiceModeAuto}.
	ToolChoice *ToolChoice `json:"toolChoice,omitempty"`
}

type CreateMessageRequest struct {
	Request
	CreateMessageParams `json:"params"`
}

type CreateMessageResult struct {
	Result
	SamplingMessage
	// The name of the model that generated the message.
	Model string `json:"model"`
	// The reason why sampling stopped, if known.
	StopReason string `json:"stopReason,omitempty"`
}

type CreateTaskResult struct {
	Result
	Task              Task      `json:"task"`
	Content           []Content `json:"-"`
	StructuredContent any       `json:"-"`
	IsError           bool      `json:"-"`
}

type Cursor string

type DiscoverParams struct {
	// Meta carries the per-request protocol metadata.
	Meta *Meta `json:"_meta,omitempty"`
}

type DiscoverRequest struct {
	Request
	Header http.Header    `json:"-"`
	Params DiscoverParams `json:"params,omitzero"`
}

type DiscoverResult struct {
	CacheableResult

	// SupportedVersions lists the MCP protocol versions this server supports,
	// newest first. The client should choose one for subsequent requests.
	SupportedVersions []string `json:"supportedVersions"`

	// Capabilities describes the server's capabilities.
	Capabilities ServerCapabilities `json:"capabilities"`

	// Instructions is natural-language guidance describing the server and its
	// features, for inclusion in an LLM system prompt.
	Instructions string `json:"instructions,omitempty"`
}

type ElicitationCapability struct {
	Form *struct{} `json:"form,omitempty"` // Supports form mode
	URL  *struct{} `json:"url,omitempty"`  // Supports URL mode
}

type ElicitationParams struct {
	Meta *Meta `json:"_meta,omitempty"`
	// Mode specifies the type of elicitation: "form" or "url". Defaults to "form".
	Mode string `json:"mode,omitempty"`
	// A human-readable message explaining what information is being requested and why.
	Message string `json:"message"`

	// A JSON Schema defining the expected structure of the user's response.
	RequestedSchema any `json:"requestedSchema,omitempty"`

	// ElicitationID is a unique identifier for the elicitation request.
	ElicitationID string `json:"elicitationId,omitempty"`
	// URL is the URL to be opened by the user.
	URL string `json:"url,omitempty"`
}

type ElicitationRequest struct {
	Request
	Params ElicitationParams `json:"params"`
}

type ElicitationResponse struct {
	// Action indicates whether the user accepted, declined, or cancelled.
	Action ElicitationResponseAction `json:"action"`
	// Content contains the user's response data if they accepted.
	// Should conform to the requestedSchema from the ElicitationRequest.
	Content any `json:"content,omitempty"`
}

type ElicitationResponseAction string

type ElicitationResult struct {
	Result
	ElicitationResponse
}

type EmbeddedResource struct {
	Annotated
	// Meta is a metadata object that is reserved by MCP for storing additional information.
	Meta     *Meta            `json:"_meta,omitempty"`
	Type     string           `json:"type"`
	Resource ResourceContents `json:"resource"`
}

type EmptyResult Result

type GetPromptParams struct {
	// The name of the prompt or prompt template.
	Name string `json:"name"`
	// Arguments to use for templating the prompt.
	Arguments map[string]string `json:"arguments,omitempty"`
	// Meta carries protocol-level metadata (e.g. W3C traceparent, progressToken).
	Meta *Meta `json:"_meta,omitempty"`
	MultiRoundTripParams
}

type GetPromptRequest struct {
	Request
	Params GetPromptParams `json:"params"`
	Header http.Header     `json:"-"`
}

type GetPromptResult struct {
	Result
	MultiRoundTripResult
	// An optional description for the prompt.
	Description string          `json:"description,omitempty"`
	Messages    []PromptMessage `json:"messages"`
}

type GetTaskParams struct {
	TaskId string `json:"taskId"`
}

type GetTaskRequest struct {
	Request
	Header http.Header   `json:"-"`
	Params GetTaskParams `json:"params"`
}

type GetTaskResult struct {
	Result
	Task
}

type HeaderMismatchError struct {
	// Header is the offending header name.
	Header string
	// Reason describes the mismatch.
	Reason string
}

type Icon struct {
	// URI pointing to the icon resource (HTTPS URL or data URI)
	Src string `json:"src"`

	// Optional MIME type (e.g., "image/png", "image/svg+xml")
	MIMEType string `json:"mimeType,omitempty"`

	// Optional size specifications (e.g., ["48x48"], ["any"] for SVG)
	Sizes []string `json:"sizes,omitempty"`

	// Theme is an optional specifier for the background theme this icon is designed for.
	// Use IconThemeLight for light backgrounds or IconThemeDark for dark backgrounds.
	Theme IconTheme `json:"theme,omitempty"`
}

type IconTheme string

type ImageContent struct {
	Annotated
	// Meta is a metadata object that is reserved by MCP for storing additional information.
	Meta *Meta  `json:"_meta,omitempty"`
	Type string `json:"type"` // Must be "image"
	// The base64-encoded image data.
	Data string `json:"data"`
	// The MIME type of the image. Different providers may support different image types.
	MIMEType string `json:"mimeType"`
}

type Implementation struct {
	Name        string `json:"name"`
	Version     string `json:"version"`
	Title       string `json:"title,omitempty"`
	Description string `json:"description,omitempty"`
	WebsiteURL  string `json:"websiteUrl,omitempty"`
	// Icons provides visual identifiers for the implementation
	Icons []Icon `json:"icons,omitempty"`
}

type InitializeParams struct {
	// The latest version of the Model Context Protocol that the client supports.
	// The client MAY decide to support older versions as well.
	ProtocolVersion string             `json:"protocolVersion"`
	Capabilities    ClientCapabilities `json:"capabilities"`
	ClientInfo      Implementation     `json:"clientInfo"`
}

type InitializeRequest struct {
	Request
	Params InitializeParams `json:"params"`
	Header http.Header      `json:"-"`
}

type InitializeResult struct {
	Result
	// 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.
	ProtocolVersion string             `json:"protocolVersion"`
	Capabilities    ServerCapabilities `json:"capabilities"`
	ServerInfo      Implementation     `json:"serverInfo"`
	// 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.
	Instructions string `json:"instructions,omitempty"`
}

type InitializedNotification struct {
	Notification
}

type InputRequest struct {
	// Method is the JSON-RPC method of the embedded request: one of
	// [MethodElicitationCreate], [MethodSamplingCreateMessage], or
	// [MethodListRoots].
	Method MCPMethod `json:"method"`

	// Elicitation is set when Method is elicitation/create.
	Elicitation *ElicitationParams `json:"-"`
	// Sampling is set when Method is sampling/createMessage.
	Sampling *CreateMessageParams `json:"-"`
	// Roots is set when Method is roots/list. The roots/list request takes no
	// parameters, so this is an empty struct used only as a presence marker.
	Roots *ListRootsParams `json:"-"`
}

type InputRequests map[string]InputRequest

type InputRequiredResult struct {
	Result
	MultiRoundTripResult
}

type InputResponse struct {
	// Elicitation answers an elicitation/create input request.
	Elicitation *ElicitationResult `json:"-"`
	// Sampling answers a sampling/createMessage input request.
	Sampling *CreateMessageResult `json:"-"`
	// Roots answers a roots/list input request.
	Roots *ListRootsResult `json:"-"`
	// contains filtered or unexported fields
}

type InputResponses map[string]InputResponse

type JSONRPCError struct {
	JSONRPC string              `json:"jsonrpc"`
	ID      RequestId           `json:"id"`
	Error   JSONRPCErrorDetails `json:"error"`
}

type JSONRPCErrorDetails struct {
	// The error type that occurred.
	Code int `json:"code"`
	// A short description of the error. The message SHOULD be limited
	// to a concise single sentence.
	Message string `json:"message"`
	// Additional information about the error. The value of this member
	// is defined by the sender (e.g. detailed error information, nested errors etc.).
	Data any `json:"data,omitempty"`
}

type JSONRPCMessage any

type JSONRPCNotification struct {
	JSONRPC string `json:"jsonrpc"`
	Notification
}

type JSONRPCRequest struct {
	JSONRPC string    `json:"jsonrpc"`
	ID      RequestId `json:"id"`
	Params  any       `json:"params,omitempty"`
	Request
}

type JSONRPCResponse struct {
	JSONRPC string    `json:"jsonrpc"`
	ID      RequestId `json:"id"`
	Result  any       `json:"result"`
}

type ListPromptsRequest struct {
	PaginatedRequest
	Header http.Header `json:"-"`
}

type ListPromptsResult struct {
	PaginatedResult
	Prompts []Prompt `json:"prompts"`
}

type ListResourceTemplatesRequest struct {
	PaginatedRequest
	Header http.Header `json:"-"`
}

type ListResourceTemplatesResult struct {
	PaginatedResult
	ResourceTemplates []ResourceTemplate `json:"resourceTemplates"`
}

type ListResourcesRequest struct {
	PaginatedRequest
	Header http.Header `json:"-"`
}

type ListResourcesResult struct {
	PaginatedResult
	Resources []Resource `json:"resources"`
}

type ListRootsParams struct{}

type ListRootsRequest struct {
	Request
}

type ListRootsResult struct {
	Result
	Roots []Root `json:"roots"`
}

type ListTasksRequest struct {
	PaginatedRequest
	Header http.Header `json:"-"`
}

type ListTasksResult struct {
	PaginatedResult
	Tasks []Task `json:"tasks"`
}

type ListToolsRequest struct {
	PaginatedRequest
	Header http.Header `json:"-"`
}

type ListToolsResult struct {
	PaginatedResult
	Tools []Tool `json:"tools"`
}

type LoggingLevel string

type LoggingMessageNotification struct {
	Notification
	Params LoggingMessageNotificationParams `json:"params"`
}

type LoggingMessageNotificationParams struct {
	// The severity of this log message.
	Level LoggingLevel `json:"level"`
	// An optional name of the logger issuing this message.
	Logger string `json:"logger,omitempty"`
	// The data to be logged, such as a string message or an object. Any JSON
	// serializable type is allowed here.
	Data any `json:"data"`
}

type MCPMethod string

type Meta struct {
	// If specified, the caller is requesting out-of-band progress
	// notifications for this request (as represented by
	// notifications/progress). The value of this parameter is an
	// opaque token that will be attached to any subsequent
	// notifications. The receiver is not obligated to provide these
	// notifications.
	ProgressToken ProgressToken

	// AdditionalFields are any fields present in the Meta that are not
	// otherwise defined in the protocol.
	AdditionalFields map[string]any
}

type MissingRequiredClientCapabilityError struct {
	// Capability names the missing capability, e.g. "elicitation".
	Capability string
}

type ModelHint struct {
	// A hint for a model name.
	//
	// The client SHOULD treat this as a substring of a model name; for example:
	//  - `claude-3-5-sonnet` should match `claude-3-5-sonnet-20241022`
	//  - `sonnet` should match `claude-3-5-sonnet-20241022`, `claude-3-sonnet-20240229`, etc.
	//  - `claude` should match any Claude model
	//
	// The client MAY also map the string to a different provider's model name or
	// a different model family, as long as it fills a similar niche; for example:
	//  - `gemini-1.5-flash` could match `claude-3-haiku-20240307`
	Name string `json:"name,omitempty"`
}

type ModelPreferences struct {
	// Optional hints to use for model selection.
	//
	// If multiple hints are specified, the client MUST evaluate them in order
	// (such that the first match is taken).
	//
	// The client SHOULD prioritize these hints over the numeric priorities, but
	// MAY still use the priorities to select from ambiguous matches.
	Hints []ModelHint `json:"hints,omitempty"`

	// How much to prioritize cost when selecting a model. A value of 0 means cost
	// is not important, while a value of 1 means cost is the most important
	// factor.
	CostPriority float64 `json:"costPriority,omitempty"`

	// How much to prioritize sampling speed (latency) when selecting a model. A
	// value of 0 means speed is not important, while a value of 1 means speed is
	// the most important factor.
	SpeedPriority float64 `json:"speedPriority,omitempty"`

	// How much to prioritize intelligence and capabilities when selecting a
	// model. A value of 0 means intelligence is not important, while a value of 1
	// means intelligence is the most important factor.
	IntelligencePriority float64 `json:"intelligencePriority,omitempty"`
}

type MultiRoundTripParams struct {
	// InputResponses answers the requests from a previous
	// [InputRequiredResult]. Each key present in that result's InputRequests
	// map must appear here.
	InputResponses InputResponses `json:"inputResponses,omitempty"`

	// RequestState echoes back, verbatim, the opaque state from a previous
	// [InputRequiredResult].
	RequestState string `json:"requestState,omitempty"`
}

type MultiRoundTripResult struct {
	// InputRequests are the requests the client must fulfil before retrying.
	// Present only when ResultType is [ResultTypeInputRequired].
	InputRequests InputRequests `json:"inputRequests,omitempty"`

	// RequestState is an opaque token the client must pass back verbatim when
	// it retries the original request. Clients MUST NOT interpret it.
	RequestState string `json:"requestState,omitempty"`
}

type Named interface {
	GetName() string
}

type Notification struct {
	Method string             `json:"method"`
	Params NotificationParams `json:"params,omitzero"`
}

type NotificationParams struct {
	// This parameter name is reserved by MCP to allow clients and
	// servers to attach additional metadata to their notifications.
	Meta map[string]any `json:"_meta,omitempty"`

	// Additional fields can be added to this map
	AdditionalFields map[string]any `json:"-"`
}

type PaginatedParams struct {
	// An opaque token representing the current pagination position.
	// If provided, the server should return results starting after this cursor.
	Cursor Cursor `json:"cursor,omitempty"`
	// Meta carries protocol-level metadata. PaginatedRequest embeds Request
	// and shadows its Params with this type, so Meta must be declared here
	// to be marshaled on paginated requests (tools/list, resources/list,
	// resources/templates/list, prompts/list, tasks/list).
	Meta *Meta `json:"_meta,omitempty"`
}

type PaginatedRequest struct {
	Request
	Params PaginatedParams `json:"params,omitzero"`
}

type PaginatedResult struct {
	CacheableResult
	// An opaque token representing the pagination position after the last
	// returned result.
	// If present, there may be more results available.
	NextCursor Cursor `json:"nextCursor,omitempty"`
}

type ParamHeaderBinding struct {
	// Path is the property-name path from the root of the arguments object.
	Path []string
	// Header is the x-mcp-header annotation value, without the Mcp-Param-
	// prefix.
	Header string
}

type Params map[string]any

type PingRequest struct {
	Request
	Header http.Header `json:"-"`
}

type ProgressNotification struct {
	Notification
	Params ProgressNotificationParams `json:"params"`
}

type ProgressNotificationParams struct {
	// The progress token which was given in the initial request, used to
	// associate this notification with the request that is proceeding.
	ProgressToken ProgressToken `json:"progressToken"`
	// The progress thus far. This should increase every time progress is made,
	// even if the total is unknown.
	Progress float64 `json:"progress"`
	// Total number of items to process (or total progress required), if known.
	Total float64 `json:"total,omitempty"`
	// Message related to progress. This should provide relevant human-readable
	// progress information.
	Message string `json:"message,omitempty"`
}

type ProgressToken any

type Prompt struct {
	// Meta is a metadata object that is reserved by MCP for storing additional information.
	Meta *Meta `json:"_meta,omitempty"`
	// The name of the prompt or prompt template.
	Name string `json:"name"`
	// Title is an optional human-readable, UI-friendly display name for the prompt.
	// If not provided, clients should fall back to Name.
	Title string `json:"title,omitempty"`
	// An optional description of what this prompt provides
	Description string `json:"description,omitempty"`
	// A list of arguments to use for templating the prompt.
	// The presence of arguments indicates this is a template prompt.
	Arguments []PromptArgument `json:"arguments,omitempty"`
	// Icons provides visual identifiers for the prompt
	Icons []Icon `json:"icons,omitempty"`
}

type PromptArgument struct {
	// The name of the argument.
	Name string `json:"name"`
	// Title is an optional human-readable, UI-friendly display name for the argument.
	// If not provided, clients should fall back to Name.
	Title string `json:"title,omitempty"`
	// A human-readable description of the argument.
	Description string `json:"description,omitempty"`
	// Whether this argument must be provided.
	// If true, clients must include this argument when calling prompts/get.
	Required bool `json:"required,omitempty"`
}

type PromptListChangedNotification struct {
	Notification
}

type PromptMessage struct {
	Role    Role    `json:"role"`
	Content Content `json:"content"` // Can be TextContent, ImageContent, AudioContent or EmbeddedResource
}

type PromptOption func(*Prompt)

type PromptReference struct {
	Type string `json:"type"`
	// The name of the prompt or prompt template
	Name string `json:"name"`
}

type PropertyOption func(map[string]any)

type ReadResourceParams struct {
	// The URI of the resource to read. The URI can use any protocol; it is up
	// to the server how to interpret it.
	URI string `json:"uri"`
	// Arguments to pass to the resource handler
	Arguments map[string]any `json:"arguments,omitempty"`
	// Meta carries protocol-level metadata (e.g. W3C traceparent, progressToken).
	Meta *Meta `json:"_meta,omitempty"`
	MultiRoundTripParams
}

type ReadResourceRequest struct {
	Request
	Header http.Header        `json:"-"`
	Params ReadResourceParams `json:"params"`
}

type ReadResourceResult struct {
	CacheableResult
	MultiRoundTripResult
	Contents []ResourceContents `json:"contents"` // Can be TextResourceContents or BlobResourceContents
}

type Request struct {
	Method string        `json:"method"`
	Params RequestParams `json:"params,omitzero"`
}

type RequestId struct {
	// contains filtered or unexported fields
}

type RequestParams struct {
	Meta *Meta `json:"_meta,omitempty"`
}

type Resource struct {
	Annotated
	// Meta is a metadata object that is reserved by MCP for storing additional information.
	Meta *Meta `json:"_meta,omitempty"`
	// The URI of this resource.
	URI string `json:"uri"`
	// A human-readable name for this resource.
	//
	// This can be used by clients to populate UI elements.
	Name string `json:"name"`
	// Title is an optional human-readable, UI-friendly display name for this resource.
	// If not provided, clients should fall back to Name.
	Title string `json:"title,omitempty"`
	// A description of what this resource represents.
	//
	// This can be used by clients to improve the LLM's understanding of
	// available resources. It can be thought of like a "hint" to the model.
	Description string `json:"description,omitempty"`
	// The MIME type of this resource, if known.
	MIMEType string `json:"mimeType,omitempty"`
	// Icons provides visual identifiers for the resource
	Icons []Icon `json:"icons,omitempty"`
	// Size is the size of the raw resource content, in bytes (i.e., before base64
	// encoding or any tokenization), if known. This can be used by hosts to
	// display file sizes and estimate context window usage.
	//
	// A pointer is used so that an explicit zero size remains distinguishable
	// from an unset value.
	Size *int64 `json:"size,omitempty"`
}

type ResourceContents interface {
	// contains filtered or unexported methods
}

type ResourceLink struct {
	Annotated
	// Meta is a metadata object that is reserved by MCP for storing additional information.
	Meta *Meta  `json:"_meta,omitempty"`
	Type string `json:"type"` // Must be "resource_link"
	// The URI of the resource.
	URI string `json:"uri"`
	// The name of the resource.
	Name string `json:"name"`
	// Title is an optional human-readable, UI-friendly display name for this resource.
	// If not provided, clients should fall back to Name.
	Title string `json:"title,omitempty"`
	// The description of the resource.
	Description string `json:"description"`
	// The MIME type of the resource.
	MIMEType string `json:"mimeType"`
	// Size is the size of the raw resource content, in bytes (i.e., before base64
	// encoding or any tokenization), if known. This can be used by hosts to
	// display file sizes and estimate context window usage.
	//
	// A pointer is used so that an explicit zero size remains distinguishable
	// from an unset value.
	Size *int64 `json:"size,omitempty"`
}

type ResourceListChangedNotification struct {
	Notification
}

type ResourceOption func(*Resource)

type ResourceReference struct {
	Type string `json:"type"`
	// The URI or URI template of the resource.
	URI string `json:"uri"`
}

type ResourceTemplate struct {
	Annotated
	// Meta is a metadata object that is reserved by MCP for storing additional information.
	Meta *Meta `json:"_meta,omitempty"`
	// A URI template (according to RFC 6570) that can be used to construct
	// resource URIs.
	URITemplate *URITemplate `json:"uriTemplate"`
	// A human-readable name for the type of resource this template refers to.
	//
	// This can be used by clients to populate UI elements.
	Name string `json:"name"`
	// Title is an optional human-readable, UI-friendly display name for this resource template.
	// If not provided, clients should fall back to Name.
	Title string `json:"title,omitempty"`
	// A description of what this template is for.
	//
	// This can be used by clients to improve the LLM's understanding of
	// available resources. It can be thought of like a "hint" to the model.
	Description string `json:"description,omitempty"`
	// The MIME type for all resources that match this template. This should only
	// be included if all resources matching this template have the same type.
	MIMEType string `json:"mimeType,omitempty"`
	// Icons provides visual identifiers for the resource template
	Icons []Icon `json:"icons,omitempty"`
}

type ResourceTemplateOption func(*ResourceTemplate)

type ResourceUpdatedNotification struct {
	Notification
	Params ResourceUpdatedNotificationParams `json:"params"`
}

type ResourceUpdatedNotificationParams struct {
	// The URI of the resource that has been updated. This might be a sub-
	// resource of the one that the client actually subscribed to.
	URI string `json:"uri"`
}

type Result struct {
	// This result property is reserved by the protocol to allow clients and
	// servers to attach additional metadata to their responses.
	Meta *Meta `json:"_meta,omitempty"`

	// ResultType indicates how the client should interpret this result.
	//
	// Servers implementing protocol version 2026-07-28 or later MUST populate
	// it. It is omitted when responding to a request that used an earlier
	// protocol version; clients MUST treat an absent value as
	// [ResultTypeComplete].
	ResultType ResultType `json:"resultType,omitempty"`
}

type ResultMetadata interface {
	// SetResultType records how the client should interpret the result.
	SetResultType(ResultType)
	// GetResultType returns the recorded result type.
	GetResultType() ResultType
	// SetResultMeta replaces the result's _meta.
	SetResultMeta(*Meta)
	// GetResultMeta returns the result's _meta, which may be nil.
	GetResultMeta() *Meta
	// EnsureResultMeta returns the result's _meta, allocating it when absent.
	EnsureResultMeta() *Meta
}

type ResultType string

type Role string

type Root struct {
	// Meta is a metadata object that is reserved by MCP for storing additional information.
	Meta *Meta `json:"_meta,omitempty"`
	// The URI identifying the root. This *must* start with file:// for now.
	// This restriction may be relaxed in future versions of the protocol to allow
	// other URI schemes.
	URI string `json:"uri"`
	// An optional name for the root. This can be used to provide a human-readable
	// identifier for the root, which may be useful for display purposes or for
	// referencing the root in other parts of the application.
	Name string `json:"name,omitempty"`
}

type RootsListChangedNotification struct {
	Notification
}

type SamplingCapability struct {
	// Context, if non-nil, advertises that the client honours the
	// CreateMessageParams.IncludeContext field. If a peer does not declare this
	// sub-capability, servers SHOULD only use IncludeContext "none" or omit it.
	Context *struct{} `json:"context,omitempty"`
	// Tools, if non-nil, advertises that the client honours the
	// CreateMessageParams.Tools and CreateMessageParams.ToolChoice fields
	// (sampling with tools). Servers MUST NOT send those fields unless this
	// sub-capability is declared.
	Tools *struct{} `json:"tools,omitempty"`
}

type SamplingMessage struct {
	Role    Role `json:"role"`
	Content any  `json:"content"` // Can be TextContent, ImageContent, AudioContent, ToolUseContent or ToolResultContent
}

type SchemaCache struct {
	// contains filtered or unexported fields
}

type ServerCapabilities struct {
	// Optional, present if the server is advertising extension support.
	Extensions map[string]any `json:"extensions,omitempty"`
	// Experimental, non-standard capabilities that the server supports.
	Experimental map[string]any `json:"experimental,omitempty"`
	// Present if the server supports sending log messages to the client.
	Logging *struct{} `json:"logging,omitempty"`
	// Present if the server offers any prompt templates.
	Prompts *struct {
		// Whether this server supports notifications for changes to the prompt list.
		ListChanged bool `json:"listChanged,omitempty"`
	} `json:"prompts,omitempty"`
	// Present if the server offers any resources to read.
	Resources *struct {
		// Whether this server supports subscribing to resource updates.
		Subscribe bool `json:"subscribe,omitempty"`
		// Whether this server supports notifications for changes to the resource
		// list.
		ListChanged bool `json:"listChanged,omitempty"`
	} `json:"resources,omitempty"`
	// Present if the server supports sending sampling requests to clients.
	Sampling *SamplingCapability `json:"sampling,omitempty"`
	// Present if the server offers any tools to call.
	Tools *struct {
		// Whether this server supports notifications for changes to the tool list.
		ListChanged bool `json:"listChanged,omitempty"`
	} `json:"tools,omitempty"`
	// Present if the server supports elicitation requests to the client.
	Elicitation *ElicitationCapability `json:"elicitation,omitempty"`
	// Present if the server supports roots requests to the client.
	Roots *struct{} `json:"roots,omitempty"`
	// Present if the server supports task-based execution.
	Tasks *TasksCapability `json:"tasks,omitempty"`
	// Present if the server supports completions requests to the client.
	Completions *struct{} `json:"completions,omitempty"`
}

type ServerNotification any

type ServerRequest any

type ServerResult any

type SetLevelParams struct {
	// The level of logging that the client wants to receive from the server.
	// The server should send all logs at this level and higher (i.e., more severe) to
	// the client as notifications/logging/message.
	Level LoggingLevel `json:"level"`
}

type SetLevelRequest struct {
	Request
	Params SetLevelParams `json:"params"`
	Header http.Header    `json:"-"`
}

type StructuredToolHandlerFunc[TArgs any, TResult any] func(ctx context.Context, request CallToolRequest, args TArgs) (TResult, error)

type SubscribeParams struct {
	// The URI of the resource to subscribe to. The URI can use any protocol; it
	// is up to the server how to interpret it.
	URI string `json:"uri"`
}

type SubscribeRequest struct {
	Request
	Params SubscribeParams `json:"params"`
	Header http.Header     `json:"-"`
}

type SubscriptionFilter struct {
	// ToolsListChanged opts in to notifications/tools/list_changed.
	ToolsListChanged bool `json:"toolsListChanged,omitempty"`
	// PromptsListChanged opts in to notifications/prompts/list_changed.
	PromptsListChanged bool `json:"promptsListChanged,omitempty"`
	// ResourcesListChanged opts in to notifications/resources/list_changed.
	ResourcesListChanged bool `json:"resourcesListChanged,omitempty"`
	// ResourceSubscriptions opts in to notifications/resources/updated for the
	// listed resource URIs. It replaces the resources/subscribe RPC.
	ResourceSubscriptions []string `json:"resourceSubscriptions,omitempty"`
}

type SubscriptionsAcknowledgedNotification struct {
	Notification
	Params SubscriptionsAcknowledgedParams `json:"params"`
}

type SubscriptionsAcknowledgedParams struct {
	// Notifications is the subset of the requested filter that the server
	// established, after intersecting it with the server's capabilities.
	Notifications SubscriptionFilter `json:"notifications"`
	// Meta carries [MetaKeySubscriptionID].
	Meta map[string]any `json:"_meta,omitempty"`
}

type SubscriptionsListenParams struct {
	// Notifications selects the notification types the client opts in to.
	Notifications SubscriptionFilter `json:"notifications"`
	// Meta carries the per-request protocol metadata.
	Meta *Meta `json:"_meta,omitempty"`
}

type SubscriptionsListenRequest struct {
	Request
	Header http.Header               `json:"-"`
	Params SubscriptionsListenParams `json:"params"`
}

type SubscriptionsListenResult struct {
	Result
}

type Task struct {
	// Unique identifier for the task.
	TaskId string `json:"taskId"`
	// Current state of the task execution.
	Status TaskStatus `json:"status"`
	// Optional human-readable message describing the current state.
	StatusMessage string `json:"statusMessage,omitempty"`
	// ISO 8601 timestamp when the task was created.
	CreatedAt string `json:"createdAt"`
	// ISO 8601 timestamp when the task was last updated.
	LastUpdatedAt string `json:"lastUpdatedAt"`
	// Time in milliseconds from creation before task may be deleted.
	// If null, the task has no expiration.
	TTL *int64 `json:"ttl"`
	// Suggested time in milliseconds between status checks.
	PollInterval *int64 `json:"pollInterval,omitempty"`
}