client

type Audio struct {
	Data     []byte
	MIMEType string
}

type CallOpts struct {
	// Progress, when non-nil, receives the call's progress notifications.
	//
	// Installing it is what asks the server for them: a server may only send
	// progress for a request that carries a progress token, and a token is only
	// attached when this is set. So a nil Progress does not merely discard the
	// notifications — it stops them being generated.
	//
	// It is invoked on the connection's notification goroutine and blocks it,
	// so it must not do work. Hand off anything expensive.
	//
	// Progress NEVER extends the call's deadline. See Deadline.
	Progress func(Progress)

	// Deadline bounds this call. Zero means now plus the binding's
	// Timeouts.Request.
	//
	// It is an absolute instant, fixed before the request is sent, and nothing
	// the server does afterwards moves it. In particular progress notifications
	// do not: a deadline that reset on activity would be a deadline the server
	// controls, and any server — hostile or merely stuck in a retry loop —
	// could hold a call, a goroutine and a permission open indefinitely just by
	// remaining chatty. A long-running tool needs a long deadline, which the
	// caller sets here, deliberately and in advance.
	//
	// The caller's ctx applies as well; whichever expires first wins.
	Deadline time.Time
}

type Catalog struct {
	// Binding names the server binding.
	Binding Name
	// Generation is the generation's ordinal within the binding. It is 0 in the
	// zero Catalog and 1 or more in any real one.
	Generation uint64
	// Digest is the hex canonical catalog digest. Two catalogs with the same
	// digest describe the same server offering; it does not depend on this
	// host's filter or policy.
	Digest string

	// ProtocolVersion is the version negotiated at initialize.
	ProtocolVersion string
	// Server is what the server claims to be. Cosmetic: it names a peer, it
	// never authorizes one.
	Server ServerIdentity
	// Capabilities is what the server advertised.
	Capabilities ServerCapabilities
	// Instructions is the server's bounded usage hint.
	//
	// It is reported, never applied. Concatenating it into a host's system
	// instructions would let any connected server acquire instruction authority
	// merely by being connected; an application that wants it must install it
	// deliberately.
	Instructions string

	// Tools are the tools this binding's ToolFilter permits, in a stable order.
	Tools []ToolSpec
	// Prompts are the prompts the server advertises.
	Prompts []PromptSpec
	// Resources are the concrete resources the server advertises.
	Resources []ResourceSpec
	// ResourceTemplates are the resource templates the server advertises.
	ResourceTemplates []ResourceTemplateSpec

	// Warnings records defects tolerated during discovery, such as a dropped
	// tool. It is bounded.
	Warnings []string
	// AppliedTolerances are the compatibility tolerances this generation
	// actually needed, in a deterministic order. It is empty for a server that
	// implements the specification faithfully — it reports what was bent, not
	// what the binding's profile would have allowed.
	AppliedTolerances []Tolerance
}

type CatalogAdopted struct {
	// Binding names the binding.
	Binding Name
	// Generation is the newly adopted ordinal.
	Generation uint64
	// Digest is its hex catalog digest.
	Digest string
	// Previous is the ordinal it replaced, or 0 if there was none.
	Previous uint64
	// At is when adoption happened.
	At time.Time
}

type CatalogCandidate struct {
	// Binding names the binding.
	Binding Name
	// Generation is the candidate's ordinal, and the value Adopt takes.
	Generation uint64
	// Digest is the candidate's hex catalog digest.
	Digest string
	// Adopted is the ordinal of the generation still in force.
	Adopted uint64
	// At is when the candidate was published.
	At time.Time
}

type CatalogRefreshed struct {
	// Binding names the binding.
	Binding Name
	// Generation is the ordinal of the generation still in force.
	Generation uint64
	// Digest is its hex catalog digest.
	Digest string
	// At is when the refresh completed.
	At time.Time
}

type CatalogRejected struct {
	// Binding names the binding.
	Binding Name
	// Class classifies why the refresh failed.
	Class FailureClass
	// Message is the failure's bounded, normalized text.
	Message string
	// Adopted is the ordinal of the generation still in force.
	Adopted uint64
	// Retrying reports whether the binding will try again under its policy.
	Retrying bool
	// At is when the refresh failed.
	At time.Time
}

type CatalogStale struct {
	// Binding names the binding whose catalog went stale.
	Binding Name
	// Family is the catalog family the server says changed: "tools",
	// "prompts", or "resources".
	Family string
	// At is when the notification was observed.
	At time.Time
}

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

type ClientCapabilities struct {
	// Elicitation lets the server ask the human for input mid-operation. The
	// server-initiated form of this feature is deprecated in spec revision
	// 2026-07-28 (SEP-2577) and served via multi-round-trip requests there; it
	// remains fully functional against peers negotiating ≤2025-11-25.
	Elicitation bool
	// Sampling lets the server request LLM completions from the client. The
	// server-initiated form of this feature is deprecated in spec revision
	// 2026-07-28 (SEP-2577) and served via multi-round-trip requests there; it
	// remains fully functional against peers negotiating ≤2025-11-25.
	Sampling bool
	// Roots exposes filesystem roots to the server. The server-initiated form
	// of this feature is deprecated in spec revision 2026-07-28 (SEP-2577)
	// and served via multi-round-trip requests there; it remains fully
	// functional against peers negotiating ≤2025-11-25.
	Roots bool
}

type ConnectionLost struct {
	// Binding names the binding.
	Binding Name
	// Class classifies the failure that ended the connection.
	Class FailureClass
	// Message is the failure's bounded, normalized text.
	Message string
	// Adopted is the ordinal of the generation still in force. It survives a
	// lost connection.
	Adopted uint64
	// Retrying reports whether the binding will try to reconnect. It is false
	// when policy forbids it, and false on the last report when the retry
	// budget is spent.
	Retrying bool
	// At is when the loss was observed.
	At time.Time
}

type ConnectionRestored struct {
	// Binding names the binding.
	Binding Name
	// Server is what the reconnected server claims to be. Cosmetic: it names a
	// peer, it never authorizes one.
	Server ServerIdentity
	// Drift is bounded text describing how the server's identity differs from
	// the one this binding first connected to, or empty when it is the same
	// server. It is reported, never enforced — a restarted server with a new
	// version is the ordinary reason to be reconnecting.
	Drift string
	// Adopted is the ordinal of the generation still in force, which the
	// reconnect did not touch.
	Adopted uint64
	// Generation is the ordinal of the generation discovered over the new
	// connection. It is a candidate unless it was identical to the adopted one,
	// in which case there is nothing to adopt.
	Generation uint64
	// At is when the connection was restored.
	At time.Time
}

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

type Definition struct {
	// Name is the binding this server is mounted under.
	Name Name
	// Transport produces connections. Required.
	Transport TransportFactory
	// Timeouts holds per-connection deadlines; zero fields select defaults.
	Timeouts Timeouts
	// Limits bounds resource consumption; zero fields select defaults.
	Limits Limits
	// Capabilities declares the optional client capabilities to advertise.
	Capabilities ClientCapabilities
	// ToolFilter restricts which tools are visible and callable.
	ToolFilter ToolFilter
	// AllowParallelCalls opts in to bounded parallel tool calls.
	AllowParallelCalls bool
	// Compat is the named, versioned compatibility profile: how far this
	// binding will bend for a server that does not implement the specification
	// perfectly. The zero value selects ProfileDefault.
	//
	// It is part of the binding's secret-free configuration identity; see
	// Profile.Digest.
	Compat Profile
	// Reconnect governs rebuilding a connection that failed transiently. The
	// zero value reconnects under the default bounds.
	Reconnect ReconnectPolicy
	// Refresh bounds the retries of a catalog refresh that failed. Zero fields
	// select their defaults.
	//
	// A refresh is triggered by the server announcing a change to one of its
	// lists (see Client.Candidate). Failing one costs the binding its view of
	// that change, never its adopted catalog, so the policy here decides how
	// hard a binding tries to catch up — not whether it stays usable.
	Refresh RetryPolicy
	// LogLevel is the minimum severity of server log message to request. Zero
	// means DefaultLogLevel.
	//
	// It only takes effect when Handlers.Log is installed and the server
	// advertises logging: a server sends nothing until a level is set, so this
	// is what turns its logs on, and there is no point turning them on with
	// nowhere to deliver them.
	LogLevel LogLevel
}

type ElicitAction uint8

type ElicitMode uint8

type ElicitRequest struct {
	// Binding names the server that asked.
	Binding Name
	// Mode is the kind of elicitation. It is always a declared mode.
	Mode ElicitMode
	// Message is the bounded prompt to show the human.
	Message string
	// Schema is the JSON Schema the answer must satisfy, in form mode only; nil
	// otherwise. It is raw JSON because a schema is a serialization-boundary
	// document, not domain data.
	Schema json.RawMessage
	// URL is the action's URL, in url mode only; empty otherwise. It is bounded
	// but not otherwise vetted: whether it is safe to show, or to open, is the
	// host's decision and nothing the server says can make it.
	URL string
	// ElicitationID is the server's correlation id, in url mode only. It may be
	// empty even there: MCP does not require one.
	ElicitationID string
}

type ElicitResult struct {
	Action  ElicitAction
	Content json.RawMessage
}

type ElicitationHandler interface {
	Elicit(ctx context.Context, req ElicitRequest) (ElicitResult, error)
}

type ElicitationRequested struct {
	// Binding names the server that asked.
	Binding Name
	// Mode is the kind of elicitation.
	Mode ElicitMode
	// At is when the request reached the handler.
	At time.Time
}

type ElicitationResolved struct {
	// Binding names the server that asked.
	Binding Name
	// Mode is the kind of elicitation, repeated from the request so an observer
	// need not correlate to know what was answered.
	Mode ElicitMode
	// Action is what the server was told, or the zero action when the
	// elicitation failed instead of being answered.
	Action ElicitAction
	// Duration is how long the handler took: the time a person was being waited
	// on, which is the figure an operator wants and the only one this event can
	// honestly report.
	Duration time.Duration
	// At is when the outcome was observed.
	At time.Time
}

type EmbeddedResource struct {
	// URI is the resource's opaque protocol identifier. It is not a host path
	// and must never be resolved as one.
	URI       string
	MIMEType  string
	Text      string
	Data      []byte
	Truncated bool
}

type Error struct {
	// Class states what kind of failure occurred.
	Class FailureClass
	// Binding names the server binding the failure belongs to, if any.
	Binding Name
	// Op names the operation that failed (e.g. "initialize", "call_tool").
	Op string
	// Msg is a bounded, normalized human-readable description.
	Msg string
	// Err is the wrapped cause, if any.
	Err error
}

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

type EventHandler func(Event)

type Failure struct {
	// Class states what kind of failure occurred.
	Class FailureClass
	// Message is bounded, normalized human-readable text.
	Message string
}

type FailureClass uint8

type Handlers struct {
	// Elicitation serves human-input requests. Nil means the elicitation
	// capability is not advertised.
	Elicitation ElicitationHandler
	// Sampling serves LLM completion requests. Nil means the sampling
	// capability is not advertised.
	Sampling SamplingHandler
	// Roots supplies filesystem roots. Nil means the roots capability is not
	// advertised.
	Roots RootsProvider
	// Log receives server log messages. Nil drops them.
	Log LogHandler
	// Event receives binding events. Nil drops them.
	Event EventHandler
}

type Image struct {
	Data     []byte
	MIMEType string
}

type Limits struct {
	// MaxConcurrentRequests caps in-flight requests on one connection.
	MaxConcurrentRequests int
	// MaxCatalogPages caps list-pagination round trips per catalog fetch.
	MaxCatalogPages int
	// MaxCatalogItems caps total tools accepted from one server.
	MaxCatalogItems int

	// MaxFrameBytes caps a single wire frame (one JSON-RPC message).
	MaxFrameBytes int
	// MaxBodyBytes caps a whole HTTP response body.
	MaxBodyBytes int
	// MaxSchemaBytes caps one tool's input/output schema document.
	MaxSchemaBytes int
	// MaxSchemaDepth caps schema nesting to bound recursive traversal.
	MaxSchemaDepth int

	// MaxTextResultBytes caps the text content of one tool result.
	MaxTextResultBytes int
	// MaxStructuredBytes caps the structured content of one tool result.
	MaxStructuredBytes int
	// MaxBinaryItemBytes caps one binary (image/audio/blob) result item.
	MaxBinaryItemBytes int
	// MaxBinaryItems caps how many binary items one result may carry.
	MaxBinaryItems int

	// MaxLogMessageBytes caps one server log notification's payload.
	MaxLogMessageBytes int
	// MaxElicitMessageBytes caps one elicitation prompt: its message, and in
	// url mode the URL and correlation id shown with it. A server that exceeds
	// it has its request refused, not trimmed — see internal/protocol's
	// FromSDKElicitParams for why a prompt is the one server text this module
	// will not truncate.
	MaxElicitMessageBytes int
	// MaxElicitSchemaBytes caps the schema an elicitation may request. It is
	// separate from MaxSchemaBytes because a form a person fills in is not a
	// tool's interface, and raising one must not raise the other.
	MaxElicitSchemaBytes int
	// MaxPromptCount caps prompts accepted from one server.
	MaxPromptCount int
	// MaxResourceCount caps resources accepted from one server.
	MaxResourceCount int

	// MaxSamplingDepth caps nested sampling (sampling issued while serving
	// a sampling request).
	MaxSamplingDepth int
	// MaxSamplingConcurrency caps concurrent sampling requests.
	MaxSamplingConcurrency int
	// MaxSamplingTokens caps tokens per sampling completion.
	MaxSamplingTokens int
}

type LogHandler func(LogMessage)

type LogLevel string

type LogMessage struct {
	// Binding names the server that logged.
	Binding Name
	// Level is the severity the server claimed.
	Level LogLevel
	// Logger is the server-side logger name, if it sent one.
	Logger string
	// Text is the bounded message.
	Text string
}

type Name string

type Profile struct {
	// Name identifies the profile. It is a stable identifier, not prose.
	Name string
	// Version distinguishes revisions of a profile under one name. Bump it
	// whenever the tolerances change, so that a record of "default v1" keeps
	// meaning what it meant.
	Version int
	// Tolerances are the deviations this profile permits. Order and duplicates
	// are not significant; Digest canonicalizes both.
	Tolerances []Tolerance
}

type Progress struct {
	// Binding names the server reporting progress.
	Binding Name
	// Progress is how far the server claims to have got.
	Progress float64
	// Total is the server's claimed total, or 0 when it did not say.
	Total float64
	// Message is the server's bounded description of what it is doing.
	Message string
}

type Prompt struct {
	Description string
	Messages    []PromptMessage
}

type PromptArg struct {
	Name        string
	Title       string
	Description string
	Required    bool
}

type PromptMessage struct {
	Role    string
	Content Content
}

type PromptSpec struct {
	Name        string
	Title       string
	Description string
	Arguments   []PromptArg
}

type ReconnectPolicy struct {
	// Disabled refuses reconnection entirely. A binding whose connection is
	// lost then stays degraded until its owner closes it.
	//
	// It is a negative flag because the zero value must mean "the default", as
	// it does everywhere else in a Definition, and the default is to reconnect.
	// An application disables this when re-establishing the connection costs
	// something it would rather decide about itself — a subprocess with side
	// effects at startup, a metered endpoint, an auth flow that prompts a human.
	Disabled bool

	// RetryPolicy bounds the attempts. Zero fields select their defaults.
	//
	// It is embedded rather than named because a reconnect policy *is* a retry
	// policy plus the decision to retry at all; there is no second dimension for
	// a field name to distinguish.
	RetryPolicy
}

type RequestProgress struct {
	// Binding names the server reporting progress.
	Binding Name
	// Progress is how far the server claims to have got.
	Progress float64
	// Total is the server's claimed total, or 0 when it did not say.
	Total float64
	// Message is the server's bounded description of what it is doing.
	Message string
	// At is when the report was observed.
	At time.Time
}

type Resource struct {
	Contents []ResourceContent
}

type ResourceContent struct {
	// URI is the item's opaque protocol identifier.
	URI       string
	MIMEType  string
	Text      string
	Data      []byte
	Truncated bool
}

type ResourceSpec struct {
	// URI is the resource's opaque protocol identifier — not a host path.
	URI         string
	Name        string
	Title       string
	Description string
	MIMEType    string
}

type ResourceTemplateSpec struct {
	URITemplate string
	Name        string
	Title       string
	Description string
	MIMEType    string
}

type ResourceUpdated struct {
	// Binding names the binding whose subscribed resource changed.
	Binding Name
	// URI names the resource the server says changed. It may be a sub-resource
	// of the one that was subscribed to.
	URI string
	// At is when the notification was observed.
	At time.Time
}

type RetryPolicy struct {
	// Attempts is the total number of tries, including the first. 1 means try
	// once and do not retry. Zero means DefaultRetryAttempts.
	Attempts int
	// BaseDelay is the delay before the second attempt. Zero means
	// DefaultRetryBaseDelay.
	BaseDelay time.Duration
	// MaxDelay caps one delay. Zero means DefaultRetryMaxDelay.
	MaxDelay time.Duration
	// MaxTotal caps the loop's total wall-clock span. Zero means
	// DefaultRetryMaxTotal.
	MaxTotal time.Duration
}

type Root struct {
	// URI is the root's file:// URI.
	URI string
	// Name is a display name for the root.
	Name string
}

type RootsProvider interface {
	Roots(ctx context.Context) ([]Root, error)
}

type SampleMessage struct {
	Role SampleRole
	Text string
}

type SampleOutcome uint8

type SampleRequest struct {
	// Binding names the server that asked.
	Binding Name
	// SystemPrompt is the server's requested system prompt, bounded.
	SystemPrompt string
	// Messages is the bounded conversation to complete.
	Messages []SampleMessage
	// MaxTokens is the server's requested completion budget. The host caps it
	// against Limits.MaxSamplingTokens; a server never raises the ceiling.
	MaxTokens int
}

type SampleResult struct {
	// Model names the model the host actually used, which need not be one the
	// server asked for.
	Model string
	// Text is the completion.
	Text string
	// StopReason is why generation stopped, verbatim from the host.
	StopReason string
}

type SampleRole uint8

type SamplingHandler interface {
	Sample(ctx context.Context, req SampleRequest) (SampleResult, error)
}

type SamplingRequested struct {
	// Binding names the server that asked.
	Binding Name
	// Messages is how many messages the conversation carried.
	Messages int
	// MaxTokens is the budget the host granted, after capping the server's
	// request against Limits.MaxSamplingTokens. It is what the handler was told
	// it may spend, not what the server asked for.
	MaxTokens int
	// Depth is this request's position in a sampling chain: 1 for a request the
	// binding was not already doing sampling work for, and n+1 for one that
	// arrived while an outbound request issued from a depth-n sampling handler
	// was in flight. See sampleGate for what this can and cannot see.
	Depth int
	// At is when the request arrived.
	At time.Time
}

type SamplingResolved struct {
	// Binding names the server that asked.
	Binding Name
	// Outcome is how it ended.
	Outcome SampleOutcome
	// Model is the model the host used, or empty when none ran.
	Model string
	// Duration is how long the host was working: the figure an operator wants
	// when the question is what a server is costing them.
	Duration time.Duration
	// At is when the outcome was observed.
	At time.Time
}

type ServerCapabilities struct {
	// Tools reports whether the server exposes tools.
	Tools bool
	// Prompts reports whether the server exposes prompts.
	Prompts bool
	// Resources reports whether the server exposes resources.
	Resources bool
	// ResourcesSubscribe reports whether the server supports subscribing to
	// resource updates. Only meaningful when Resources is set.
	ResourcesSubscribe bool
	// Logging reports whether the server sends log messages.
	Logging bool
	// Completions reports whether the server supports argument autocompletion.
	Completions bool
}

type ServerIdentity struct {
	Name    string
	Version string
	Title   string
}

type ServerLog struct {
	// Binding names the server that logged.
	Binding Name
	// Level is the severity the server claimed.
	Level LogLevel
	// Logger is the server-side logger name, if it sent one.
	Logger string
	// Text is the bounded message.
	Text string
	// At is when the record was observed.
	At time.Time
}

type State uint8

type StateChanged struct {
	// Binding names the binding that moved.
	Binding Name
	// From and To are the transition.
	From, To State
	// At is when the transition was observed.
	At time.Time
}

type Status struct {
	// Binding names the server binding.
	Binding Name
	// State is the lifecycle state at the moment of the call.
	State State
	// ProtocolVersion is the version negotiated at initialize. Empty before
	// the handshake completes.
	ProtocolVersion string
	// Server is what the server said it is. Zero before the handshake.
	Server ServerIdentity
	// TransportKind names the transport, e.g. "stdio".
	TransportKind string
	// RedactedOrigin is a display origin that never contains credentials.
	RedactedOrigin string
	// Failure summarizes the last failure, or nil when there is none.
	Failure *Failure
	// LastChange is when the state last changed.
	LastChange time.Time

	// CatalogGeneration is the ordinal of the adopted catalog, or 0 before one
	// is adopted.
	CatalogGeneration uint64
	// CatalogDigest is the hex digest of the adopted catalog, empty before one
	// is adopted. It identifies the server's offering independently of this
	// host's policy, so two bindings reporting the same digest are looking at
	// the same catalog.
	CatalogDigest string

	// CandidateGeneration is the ordinal of the validated candidate awaiting
	// adoption, or 0 when there is none. See Client.Candidate.
	CandidateGeneration uint64
	// CandidateDigest is the candidate's hex catalog digest, empty when there
	// is no candidate.
	CandidateDigest string
	// StaleFamilies names the catalog families a server has announced a change
	// to and which have not been refetched since, as stable identifiers
	// ("tools", "prompts", "resources") in a deterministic order.
	//
	// It is normally empty even on a binding whose server changes constantly: a
	// family is stale only between the notification and the refetch that
	// answers it. A family that stays here is a binding whose refreshes are
	// failing — which State (degraded) and Failure describe.
	StaleFamilies []string

	// CompatProfile is the binding's compatibility profile as "name/vN". It is
	// part of the binding's configuration identity; Profile.Digest is the
	// checkable form.
	CompatProfile string

	// ReconnectAttempt is the reconnect attempt currently in flight, counting
	// from 1, or 0 when the binding is not reconnecting. It is the retry state
	// an operator reads to tell "trying" from "stuck": a binding that stays on
	// attempt 1 is dialing a server that never answers, and one whose attempts
	// climb is being refused repeatedly.
	ReconnectAttempt int
}

type Text struct {
	Text      string
	Truncated bool
}

type Timeouts struct {
	// Startup bounds connect plus initialize. Zero means
	// DefaultStartupTimeout.
	Startup time.Duration
	// Request bounds one request/response exchange. Zero means
	// DefaultRequestTimeout.
	Request time.Duration
	// Elicitation bounds a server-initiated elicitation round trip. Zero
	// means DefaultElicitationTimeout.
	Elicitation time.Duration
}

type Tolerance uint8

type ToolAnnotations struct {
	Title           string
	ReadOnlyHint    bool
	IdempotentHint  bool
	DestructiveHint *bool
	OpenWorldHint   *bool
}

type ToolFilter struct {
	// Allow, when non-empty, is the complete set of permitted raw names.
	Allow []string
	// Deny lists raw names that are always rejected.
	Deny []string
}

type ToolResult struct {
	// IsError reports that the tool itself failed.
	IsError bool
	// Content is the unstructured result, already bounded and converted.
	Content []Content
	// Structured is the tool's structured result, within
	// Limits.MaxStructuredBytes. Nil when the server sent none or an
	// over-bound one was dropped; see Warnings.
	Structured json.RawMessage
	// Warnings records defects tolerated while converting the result.
	Warnings []string
}

type ToolSpec struct {
	// RawName is the server's own name for the tool. It is what goes on the
	// wire, and what CallTool takes.
	RawName string
	// ModelName is the sanitized, binding-qualified identity to show a model.
	// It is deterministic, unique within the catalog, and bounded to fit
	// inference-provider limits.
	//
	// It must never be parsed to recover RawName: sanitization is lossy, so the
	// mapping only holds in this direction. Resolve it with
	// Catalog.ToolByModelName.
	ModelName string

	Title       string
	Description string

	// InputSchema is the JSON Schema a model's arguments must satisfy. It is
	// raw JSON because a schema is a serialization-boundary document, not
	// domain data. It is always present.
	InputSchema json.RawMessage
	// OutputSchema describes the tool's result, when the server supplied a
	// usable one. Nil otherwise; see Warnings.
	OutputSchema json.RawMessage

	// InputSchemaDigest is the hex digest of InputSchema, for detecting a
	// schema change across generations without comparing documents.
	InputSchemaDigest string
	// OutputSchemaDigest is the hex digest of OutputSchema, empty when there is
	// no output schema.
	OutputSchemaDigest string

	// Annotations are the server's hints, or nil.
	Annotations *ToolAnnotations
	// Warnings records defects tolerated for this tool, such as a dropped
	// output schema.
	Warnings []string
}

type TransportFactory interface {
	// Kind names the transport, e.g. "stdio", "streamablehttp", "sse".
	Kind() string
	// RedactedOrigin returns a safe display origin. It must never contain
	// credentials.
	RedactedOrigin() string
	// Connect establishes one connection using cfg.
	Connect(ctx context.Context, cfg protocol.ConnectConfig) (protocol.Conn, error)
}

type Unsupported struct {
	// Kind is the content kind that was refused, one of the Kind* constants.
	Kind string
	// Bytes is the size of the refused payload. It is exact for an item dropped
	// on a size bound and a diagnostic lower bound for a kind dropped as
	// unsupported. Treat it as a diagnostic, never as an accounting figure.
	Bytes int
}