mcp

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

type FileRule struct {
	SideEffect        agentrt.SideEffect         `json:"side_effect"`
	Timeout           string                     `json:"timeout,omitempty"`
	Terminal          bool                       `json:"terminal,omitempty"`
	Description       string                     `json:"description,omitempty"`
	Deny              []string                   `json:"deny,omitempty"`
	Fixed             map[string]json.RawMessage `json:"fixed,omitempty"`
	Rename            string                     `json:"rename,omitempty"`
	AllowHintMismatch bool                       `json:"allow_hint_mismatch,omitempty"`
}

type Manifest struct {
	Server   string                `json:"server"`
	PinnedAt time.Time             `json:"pinned_at"`
	Tools    map[string]PinnedTool `json:"tools"`
}

type PinnedTool struct {
	Name            string          `json:"name"`
	Description     string          `json:"description"`
	InputSchema     json.RawMessage `json:"input_schema"`
	SchemaHash      string          `json:"schema_hash"`
	DescriptionHash string          `json:"description_hash"`
	// Annotations are the server's own hints, recorded as received and nil
	// when it sent none. They are never trusted: they can only contradict an
	// operator's classification, never relax it. They are outside the
	// hashes, so a change to them alone does not refuse a tool.
	Annotations *sdk.ToolAnnotations `json:"annotations,omitempty"`
}

type Refusal struct {
	Tool   string `json:"tool"`
	Reason string `json:"reason"`
}

type Registration struct {
	// Tool is the server's own name and Name is what the model sees.
	Tool       string             `json:"tool"`
	Name       string             `json:"name"`
	SideEffect agentrt.SideEffect `json:"side_effect"`
	// HintMismatch is the contradiction AllowHintMismatch let through, if
	// any.
	HintMismatch string `json:"hint_mismatch,omitempty"`
}

type Report struct {
	Server string `json:"server"`
	// Connection is the session the registered tools share. The consumer
	// closes it when the run is over; Load closes it itself when it returns
	// an error.
	Connection *Connection `json:"-"`
	// Registered is what the model may call.
	Registered []Registration `json:"registered,omitempty"`
	// Refused is a pinned, classified tool that failed a check, with the
	// reason.
	Refused []Refusal `json:"refused,omitempty"`
	// Unpinned tools are offered by the live server and absent from the
	// manifest; Unclassified tools are pinned and have no Rule. Both are
	// ignored.
	Unpinned     []string `json:"unpinned,omitempty"`
	Unclassified []string `json:"unclassified,omitempty"`
}

type Rule struct {
	// SideEffect is required.
	SideEffect agentrt.SideEffect
	// Timeout bounds one call. It is required unless the Server names a
	// DefaultTimeout.
	Timeout time.Duration
	// Terminal completes the run with this tool's result when it succeeds.
	Terminal bool
	// Description, when set, replaces the server's description in what the
	// model sees.
	Description string
	// Deny names parameters the model may not set: they are removed from the
	// schema it is shown and a call that carries one anyway fails.
	Deny []string
	// Fixed names parameters the operator sets. They are removed from the
	// schema the model sees and injected into every call, and a call that
	// carries one anyway fails rather than being overridden. A fixed value is
	// operator configuration rather than part of the request, so it sits
	// outside the approval hash on purpose: the approval binds what the model
	// asked for, and the operator already knows their own configuration.
	//
	// A Deny or Fixed name must be a top-level property of the pinned input
	// schema. The tool is refused when anything but properties and required
	// refers to it (allOf, anyOf, oneOf, not, if, then, else,
	// dependentRequired, dependentSchemas, dependencies, $defs, definitions)
	// and whenever the schema has patternProperties.
	Fixed map[string]json.RawMessage
	// Rename is the name the model sees instead of "<server>_<tool>".
	Rename string
	// AllowHintMismatch registers a tool whose annotations contradict this
	// classification. The Report records the override.
	AllowHintMismatch bool
}

type Rules map[string]Rule

type Server struct {
	// Name is required. It prefixes the names the model sees and names the
	// manifest, so tools from two servers cannot collide.
	Name string
	// Command is a stdio server's argv. Exactly one of Command or Endpoint
	// is set.
	Command []string
	// A stdio server does not inherit this process's environment. It gets
	// PATH, HOME, and TMPDIR (on Windows PATH, PATHEXT, SystemRoot,
	// SystemDrive, ComSpec, TEMP, TMP, USERPROFILE, APPDATA, LOCALAPPDATA,
	// and HOME) when they are set here, then every variable InheritEnv names
	// that is set here, then Env, entries of the form NAME=value. A later
	// entry replaces an earlier one of the same name. A server that needs a
	// token is handed that token and no other.
	Env        []string
	InheritEnv []string
	// Stderr receives a stdio server's stderr. When it is nil the last
	// StderrTailBytes are kept and added to a failed connect or tool
	// listing.
	Stderr io.Writer
	// Endpoint is a streamable HTTP server's URL, and HTTPClient is the
	// client used to reach it. The client is copied, never modified, and
	// its transport is wrapped so that no response body exceeds
	// MaxResponseBodyBytes; with no HTTPClient a fresh client is used, not
	// http.DefaultClient. No redirect is followed unless the client has a
	// CheckRedirect of its own, and then where it sends a credential is the
	// operator's responsibility. The standalone SSE stream a server could push
	// notifications on is not opened, since nothing here listens to them.
	Endpoint   string
	HTTPClient *http.Client
	// DefaultTimeout bounds a call for a Rule that names no timeout.
	DefaultTimeout time.Duration
	// ConnectTimeout bounds connecting, the initialize handshake, and the
	// first tool listing, together, as one phase; zero means
	// DefaultConnectTimeout. It does not shorten the life of the session Pin
	// or Load returns: once the phase completes, the connection keeps
	// working past this deadline under the caller's own context, because the
	// SDK does not tie a client session's lifetime to the context passed to
	// Connect for either a stdio or a streamable HTTP transport. On expiry
	// the error names which step timed out and, for a stdio server, includes
	// the stderr tail.
	ConnectTimeout time.Duration
	// MaxContentBytes caps one result's recorded content: the JSON the
	// runtime records, truncation marker included. Zero means
	// DefaultMaxContentBytes.
	MaxContentBytes int
	// Logger, when set, receives the MCP client's own logging.
	Logger *slog.Logger
	// contains filtered or unexported fields
}