@modelcontextprotocol/server 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/index.d.mts

@@ -1,15 +1,17 @@
-import { $ as TaskStore, $i as OAuthTokenRevocationRequest, $n as ModelPreferences, $r as SetLevelRequest, $t as ElicitationCompleteNotificationParams, A as createFetchWithInit, Ai as INVALID_PARAMS, An as LegacyTitledEnumSchema, Ar as RequestParams, At as ClientRequest, B as TaskStatusMessage, Bi as SdkError, Bn as ListRootsRequest, Br as ResourceUpdatedNotificationParams, Bt as CreateMessageRequestParams, C as Protocol, Ci as UnsubscribeRequest, Cn as JSONRPCErrorResponse, Cr as ReadResourceResult, Ct as CallToolResult, D as FetchLike, Di as ProtocolErrorCode, Dn as JSONRPCResponse, Dr as RequestMeta, Dt as CancelledNotificationParams, E as ServerContext, Ei as UntitledSingleSelectEnumSchema, En as JSONRPCRequest, Er as RequestId, Et as CancelledNotification, F as BaseResponseMessage, Fi as PARSE_ERROR, Fn as ListPromptsResult, Fr as ResourceListChangedNotification, Ft as CompleteRequestPrompt, G as CreateTaskServerContext, Gi as OAuthClientInformation, Gn as ListToolsResult, Gr as RootsListChangedNotification, Gt as CreateTaskResult, H as toArrayAsync, Hi as OAuthError, Hn as ListTasksRequest, Hr as ResultTypeMap, Ht as CreateMessageRequestParamsWithTools, I as ErrorMessage, Ii as RELATED_TASK_META_KEY, In as ListResourceTemplatesRequest, Ir as ResourceRequestParams, It as CompleteRequestResourceTemplate, J as QueuedNotification, Ji as OAuthClientMetadata, Jn as LoggingMessageNotificationParams, Jr as SamplingMessageContentBlock, Jt as ElicitRequestFormParams, K as QueuedError, Ki as OAuthClientInformationFull, Kn as LoggingLevel, Kr as SamplingContent, Kt as Cursor, L as ResponseMessage, Li as SUPPORTED_PROTOCOL_VERSIONS, Ln as ListResourceTemplatesResult, Lr as ResourceTemplateReference, Lt as CompleteResult, M as TaskContext, Mi as JSONRPC_VERSION, Mn as ListChangedHandlers, Mr as Resource, Mt as CompatibilityCallToolResult, N as TaskManagerOptions, Ni as LATEST_PROTOCOL_VERSION, Nn as ListChangedOptions, Nr as ResourceContents, Nt as CompleteRequest, O as Transport, Oi as DEFAULT_NEGOTIATED_PROTOCOL_VERSION, On as JSONRPCResultResponse, Or as RequestMetaObject, Ot as ClientCapabilities, P as TaskRequestOptions, Pi as METHOD_NOT_FOUND, Pn as ListPromptsRequest, Pr as ResourceLink, Pt as CompleteRequestParams, Q as TaskServerContext, Qi as OAuthProtectedResourceMetadata, Qn as ModelHint, Qr as ServerResult, Qt as ElicitationCompleteNotification, R as ResultMessage, Ri as checkResourceAllowed, Rn as ListResourcesRequest, Rr as ResourceTemplateType, Rt as ContentBlock, S as ProgressCallback, Si as ToolUseContent, Sn as JSONObject, Sr as ReadResourceRequestParams, St as CallToolRequestParams, T as RequestOptions, Ti as UntitledMultiSelectEnumSchema, Tn as JSONRPCNotification, Tr as Request$1, Tt as CancelTaskResult, U as BaseQueuedMessage, Ui as OAuthErrorCode, Un as ListTasksResult, Ur as Role, Ut as CreateMessageResult, V as takeResult, Vi as SdkErrorCode, Vn as ListRootsResult, Vr as Result, Vt as CreateMessageRequestParamsBase, W as CreateTaskOptions, Wi as AuthorizationServerMetadata, Wn as ListToolsRequest, Wr as Root, Wt as CreateMessageResultWithTools, X as QueuedResponse, Xi as OAuthErrorResponse, Xn as MetaObject, Xr as ServerNotification, Xt as ElicitRequestURLParams, Y as QueuedRequest, Yi as OAuthClientRegistrationError, Yn as MessageExtraInfo, Yr as ServerCapabilities, Yt as ElicitRequestParams, Z as TaskMessageQueue, Zi as OAuthMetadata, Zn as MethodNotFoundError, Zr as ServerRequest, Zt as ElicitResult, _ as serializeMessage, _i as ToolAnnotations, _n as InitializedNotification, _r as PromptArgument, _t as AuthInfo, a as JsonSchemaValidator, ai as Task, an as GetPromptResult, ar as NumberSchema, at as isInitializeRequest, b as DEFAULT_REQUEST_TIMEOUT_MSEC, bi as ToolListChangedNotification, bn as InvalidRequestError, br as PromptReference, bt as BooleanSchema, c as InMemoryTaskMessageQueue, ci as TaskMetadata, cn as GetTaskRequest, cr as PaginatedResult, ct as isJSONRPCNotification, d as assertToolsCallTaskCapability, di as TaskStatusNotificationParams, dn as Icons, dr as PrimitiveSchemaDefinition, dt as isTaskAugmentedRequestParams, ea as OAuthTokens, ei as SetLevelRequestParams, en as EmbeddedResource, er as MultiSelectEnumSchema, et as TaskToolExecution, f as StandardSchemaWithJSON, fi as TextContent, fn as ImageContent, fr as Progress, ft as parseJSONRPCMessage, g as deserializeMessage, gi as Tool, gn as InitializeResult, gr as Prompt, gt as AudioContent, h as ReadBuffer, hi as TitledSingleSelectEnumSchema, hn as InitializeRequestParams, hr as ProgressToken, ht as Annotations, i as JsonSchemaType, ii as SubscribeRequestParams, in as GetPromptRequestParams, ir as NotificationTypeMap, it as assertCompleteRequestResourceTemplate, j as RequestTaskStore, ji as INVALID_REQUEST, jn as ListChangedCallback, jr as RequestTypeMap, jt as ClientResult, k as TransportSendOptions, ki as INTERNAL_ERROR, kn as JSONValue, kr as RequestMethod, kt as ClientNotification, l as InMemoryTaskStore, li as TaskStatus, ln as GetTaskResult, lr as ParseError, lt as isJSONRPCRequest, m as Variables, mi as TitledMultiSelectEnumSchema, mn as InitializeRequest, mr as ProgressNotificationParams, mt as UrlElicitationRequiredError, n as CfWorkerSchemaDraft, na as OpenIdProviderMetadata, ni as StringSchema, nn as EnumSchema, nr as NotificationMethod, nt as getDisplayName, o as JsonSchemaValidatorResult, oi as TaskAugmentedRequestParams, on as GetTaskPayloadRequest, or as PaginatedRequest, ot as isInitializedNotification, p as UriTemplate, pi as TextResourceContents, pn as Implementation, pr as ProgressNotification, pt as ProtocolError, q as QueuedMessage, qi as OAuthClientInformationMixed, qn as LoggingMessageNotification, qr as SamplingMessage, qt as ElicitRequest, r as AjvJsonSchemaValidator, ri as SubscribeRequest, rn as GetPromptRequest, rr as NotificationParams, rt as assertCompleteRequestPrompt, s as jsonSchemaValidator, si as TaskCreationParams, sn as GetTaskPayloadResult, sr as PaginatedRequestParams, st as isJSONRPCErrorResponse, t as CfWorkerJsonSchemaValidator, ta as OpenIdProviderDiscoveryMetadata, ti as SingleSelectEnumSchema, tn as EmptyResult, tr as Notification, tt as isTerminal, u as assertClientRequestTaskCapability, ui as TaskStatusNotification, un as Icon, ur as PingRequest, ut as isJSONRPCResultResponse, v as BaseContext, vi as ToolChoice, vn as InternalError, vr as PromptListChangedNotification, vt as BaseMetadata, w as ProtocolOptions, wi as UnsubscribeRequestParams, wn as JSONRPCMessage, wr as RelatedTaskMetadata, wt as CancelTaskRequest, x as NotificationOptions, xi as ToolResultContent, xn as JSONArray, xr as ReadResourceRequest, xt as CallToolRequest, y as ClientContext, yi as ToolExecution, yn as InvalidParamsError, yr as PromptMessage, yt as BlobResourceContents, z as TaskCreatedMessage, zi as resourceUrlFromServerUrl, zn as ListResourcesResult, zr as ResourceUpdatedNotification, zt as CreateMessageRequest } from "./index-Bhfkexnj.mjs";
-import { Readable, Writable } from "node:stream";
+import { $ as RequestOptions, $a as OAuthClientMetadata, $i as Task, $n as InputRequiredResult, $r as ProgressNotification, $t as CallToolResult, A as ResourceMetadata, Aa as LATEST_PROTOCOL_VERSION, Ai as Role, An as ElicitationCompleteNotification, Ar as LoggingLevel, At as InputResponseView, B as deserializeMessage, Ba as checkResourceAllowed, Bi as SetLevelRequest, Bn as GetTaskRequest, Br as MultiSelectEnumSchema, Bt as InboundLegacyRoute, C as PromptCallback, Ca as CLIENT_CAPABILITIES_META_KEY, Ci as ResourceRequestParams, Cn as DiscoverRequest, Cr as ListResourcesResult, Ct as MissingRequiredClientCapabilityError, D as RegisteredResource, Da as INVALID_PARAMS, Di as ResourceUpdatedNotificationParams, Dn as ElicitRequestParams, Dr as ListTasksResult, Dt as UrlElicitationRequiredError, E as RegisteredPrompt, Ea as INTERNAL_ERROR, Ei as ResourceUpdatedNotification, En as ElicitRequestFormParams, Er as ListTasksRequest, Et as UnsupportedProtocolVersionError, F as InMemoryTransport, Fa as RELATED_TASK_META_KEY, Fi as SamplingMessageContentBlock, Fn as GetPromptRequest, Fr as MetaObject, Ft as StandardSchemaV1Sync, G as getDisplayName, Ga as SdkHttpErrorData, Gi as SubscribeRequestParams, Gn as ImageContent, Gr as NumberSchema, Gt as Annotations, H as CacheHint, Ha as SdkError, Hi as SingleSelectEnumSchema, Hn as HandlerResultTypeMap, Hr as NotificationMethod, Ht as InboundModernRoute, I as UriTemplate, Ia as SUBSCRIPTION_ID_META_KEY, Ii as ServerCapabilities, In as GetPromptRequestParams, Ir as MethodNotFoundError, It as StandardSchemaWithJSON, J as DEFAULT_REQUEST_TIMEOUT_MSEC, Ja as AuthorizationServerMetadata, Ji as SubscriptionsAcknowledgedNotificationParams, Jn as InitializeRequestParams, Jr as PaginatedResult, Jt as BaseMetadata, K as BaseContext, Ka as OAuthError, Ki as SubscriptionFilter, Kn as Implementation, Kr as PaginatedRequest, Kt as AudioContent, L as Variables, La as SUPPORTED_PROTOCOL_VERSIONS, Li as ServerNotification, Ln as GetPromptResult, Lr as MissingRequiredClientCapabilityErrorData, Lt as InboundClassificationOutcome, M as ToolCallback, Ma as METHOD_NOT_FOUND, Mi as RootsListChangedNotification, Mn as EmbeddedResource, Mr as LoggingMessageNotificationParams, Mt as inputRequired, N as Server, Na as PARSE_ERROR, Ni as SamplingContent, Nn as EmptyResult, Nr as MessageClassification, Nt as inputResponse, O as RegisteredResourceTemplate, Oa as INVALID_REQUEST, Oi as Result, On as ElicitRequestURLParams, Or as ListToolsRequest, Ot as ProtocolErrorCode, P as ServerOptions, Pa as PROTOCOL_VERSION_META_KEY, Pi as SamplingMessage, Pn as EnumSchema, Pr as MessageExtraInfo, Pt as StandardSchemaV1, Q as RequestHandlerSchemas, Qa as OAuthClientInformationMixed, Qi as SubscriptionsListenResultMeta, Qn as InputRequests, Qr as Progress, Qt as CallToolRequestParams, R as ReadBuffer, Ra as TRACEPARENT_META_KEY, Ri as ServerRequest, Rn as GetTaskPayloadRequest, Rr as ModelHint, Rt as InboundHttpRequest, S as McpServer, Sa as BAGGAGE_META_KEY, Si as ResourceListChangedNotification, Sn as Cursor, Sr as ListResourcesRequest, St as parseJSONRPCMessage, T as ReadResourceTemplateCallback, Ta as DEFAULT_NEGOTIATED_PROTOCOL_VERSION, Ti as ResourceTemplateType, Tn as ElicitRequest, Tr as ListRootsResult, Tt as ResourceNotFoundError, U as CacheScope, Ua as SdkErrorCode, Ui as StringSchema, Un as Icon, Ur as NotificationParams, Ut as InboundValidationRung, V as serializeMessage, Va as resourceUrlFromServerUrl, Vi as SetLevelRequestParams, Vn as GetTaskResult, Vr as Notification, Vt as InboundLegacyRouteReason, W as ProtocolEra, Wa as SdkHttpError, Wi as SubscribeRequest, Wn as Icons, Wr as NotificationTypeMap, Wt as classifyInboundRequest, X as ProgressCallback, Xa as OAuthClientInformation, Xi as SubscriptionsListenRequestParams, Xn as InitializedNotification, Xr as PingRequest, Xt as BooleanSchema, Y as NotificationOptions, Ya as IdJagTokenExchangeResponse, Yi as SubscriptionsListenRequest, Yn as InitializeResult, Yr as ParseError, Yt as BlobResourceContents, Z as ProtocolOptions, Za as OAuthClientInformationFull, Zi as SubscriptionsListenResult, Zn as InputRequest, Zr as PrimitiveSchemaDefinition, Zt as CallToolRequest, _ as PerRequestResponseMode, _a as UnsubscribeRequest, _i as RequestParams, _n as CreateMessageRequestParamsBase, _r as ListChangedOptions, _t as isJSONRPCNotification, a as McpRequestContext, aa as TaskStatusNotificationParams, ai as PromptMessage, an as ClientNotification, ao as OAuthTokens, ar as JSONArray, at as createFetchWithInit, b as CompleteResourceTemplateCallback, ba as UntitledMultiSelectEnumSchema, bi as ResourceContents, bn as CreateMessageResultWithTools, br as ListResourceTemplatesRequest, bt as isJSONRPCResultResponse, c as isLegacyRequest, ca as TitledMultiSelectEnumSchema, ci as ReadResourceRequestParams, cn as CompatibilityCallToolResult, co as StoredOAuthClientInformation, cr as JSONRPCMessage, ct as isSpecType, d as ServerEvent, da as ToolAnnotations, di as Request$1, dn as CompleteRequestPrompt, dr as JSONRPCResponse, dt as assertCompleteRequestResourceTemplate, ea as TaskAugmentedRequestParams, ei as ProgressNotificationParams, en as CancelTaskRequest, eo as OAuthClientRegistrationError, er as InputResponse, et as RequestStateAccessor, f as ServerEventBus, fa as ToolChoice, fi as RequestId, fn as CompleteRequestResourceTemplate, fr as JSONRPCResultResponse, ft as isCallToolResult, g as PerRequestMessageExtra, ga as ToolUseContent, gi as RequestMethod, gn as CreateMessageRequestParams, gr as ListChangedHandlers, gt as isJSONRPCErrorResponse, h as PerRequestHTTPServerTransportOptions, ha as ToolResultContent, hi as RequestMetaObject, hn as CreateMessageRequest, hr as ListChangedCallback, ht as isInputRequiredResult, i as McpHttpHandler, ia as TaskStatusNotification, ii as PromptListChangedNotification, in as ClientCapabilities, io as OAuthTokenRevocationRequest, ir as InvalidRequestError, it as TransportSendOptions, j as ResourceTemplate, ja as LOG_LEVEL_META_KEY, ji as Root, jn as ElicitationCompleteNotificationParams, jr as LoggingMessageNotification, jt as acceptedContent, k as RegisteredTool, ka as JSONRPC_VERSION, ki as ResultTypeMap, kn as ElicitResult, kr as ListToolsResult, kt as InputRequiredSpec, l as legacyStatelessFallback, la as TitledSingleSelectEnumSchema, li as ReadResourceResult, ln as CompleteRequest, lo as StoredOAuthTokens, lr as JSONRPCNotification, lt as specTypeSchemas, m as PerRequestHTTPServerTransport, ma as ToolListChangedNotification, mi as RequestMetaEnvelope, mn as ContentBlock, mr as LegacyTitledEnumSchema, mt as isInitializedNotification, n as LegacyHttpHandler, na as TaskMetadata, ni as Prompt, nn as CancelledNotification, no as OAuthMetadata, nr as InternalError, nt as FetchLike, o as McpServerFactory, oa as TextContent, oi as PromptReference, on as ClientRequest, oo as OpenIdProviderDiscoveryMetadata, or as JSONObject, ot as SpecTypeName, p as ServerNotifier, pa as ToolExecution, pi as RequestMeta, pn as CompleteResult, pr as JSONValue, pt as isInitializeRequest, q as ClientContext, qa as OAuthErrorCode, qi as SubscriptionsAcknowledgedNotification, qn as InitializeRequest, qr as PaginatedRequestParams, qt as AuthInfo, r as McpHandlerRequestOptions, ra as TaskStatus, ri as PromptArgument, rn as CancelledNotificationParams, ro as OAuthProtectedResourceMetadata, rr as InvalidParamsError, rt as Transport, s as createMcpHandler, sa as TextResourceContents, si as ReadResourceRequest, sn as ClientResult, so as OpenIdProviderMetadata, sr as JSONRPCErrorResponse, st as SpecTypes, t as CreateMcpHandlerOptions, ta as TaskCreationParams, ti as ProgressToken, tn as CancelTaskResult, to as OAuthErrorResponse, tr as InputResponses, tt as ServerContext, u as InMemoryServerEventBus, ua as Tool, ui as RelatedTaskMetadata, un as CompleteRequestParams, ur as JSONRPCRequest, ut as assertCompleteRequestPrompt, v as AnyToolHandler, va as UnsubscribeRequestParams, vi as RequestTypeMap, vn as CreateMessageRequestParamsWithTools, vr as ListPromptsRequest, vt as isJSONRPCRequest, w as ReadResourceCallback, wa as CLIENT_INFO_META_KEY, wi as ResourceTemplateReference, wn as DiscoverResult, wr as ListRootsRequest, wt as ProtocolError, x as ListResourcesCallback, xa as UntitledSingleSelectEnumSchema, xi as ResourceLink, xn as CreateTaskResult, xr as ListResourceTemplatesResult, xt as isTaskAugmentedRequestParams, y as BaseToolCallback, ya as UnsupportedProtocolVersionErrorData, yi as Resource, yn as CreateMessageResult, yr as ListPromptsResult, yt as isJSONRPCResponse, z as STDIO_DEFAULT_MAX_BUFFER_SIZE, za as TRACESTATE_META_KEY, zi as ServerResult, zn as GetTaskPayloadResult, zr as ModelPreferences, zt as InboundLadderRejection } from "./createMcpHandler-Du3hjXvf.mjs";
+import { t as AjvJsonSchemaValidator } from "./ajvProvider-Dzgk80kq.mjs";
+import { i as jsonSchemaValidator, n as JsonSchemaValidator, r as JsonSchemaValidatorResult, t as JsonSchemaType } from "./types-DBYdVs-n.mjs";
+import { n as CfWorkerSchemaDraft, t as CfWorkerJsonSchemaValidator } from "./cfWorkerProvider-DmvjVsvQ.mjs";
 
 //#region src/server/completable.d.ts
 declare const COMPLETABLE_SYMBOL: unique symbol;
-type CompleteCallback<T extends StandardSchemaWithJSON = StandardSchemaWithJSON> = (value: StandardSchemaWithJSON.InferInput<T>, context?: {
+type CompleteCallback<T extends StandardSchemaV1 = StandardSchemaV1> = (value: StandardSchemaV1.InferInput<T>, context?: {
   arguments?: Record<string, string>;
-}) => StandardSchemaWithJSON.InferInput<T>[] | Promise<StandardSchemaWithJSON.InferInput<T>[]>;
-type CompletableMeta<T extends StandardSchemaWithJSON = StandardSchemaWithJSON> = {
+}) => StandardSchemaV1.InferInput<T>[] | Promise<StandardSchemaV1.InferInput<T>[]>;
+type CompletableMeta<T extends StandardSchemaV1 = StandardSchemaV1> = {
   complete: CompleteCallback<T>;
 };
-type CompletableSchema<T extends StandardSchemaWithJSON> = T & {
+type CompletableSchema<T extends StandardSchemaV1> = T & {
   [COMPLETABLE_SYMBOL]: CompletableMeta<T>;
 };
 /**
@@ -43,877 +45,204 @@ type CompletableSchema<T extends StandardSchemaWithJSON> = T & {
  *
  * @see {@linkcode server/mcp.McpServer.registerPrompt | McpServer.registerPrompt} for using completable schemas in prompt argument definitions
  */
-declare function completable<T extends StandardSchemaWithJSON>(schema: T, complete: CompleteCallback<T>): CompletableSchema<T>;
+declare function completable<T extends StandardSchemaV1>(schema: T, complete: CompleteCallback<T>): CompletableSchema<T>;
 /**
  * Checks if a schema is completable (has completion metadata).
  */
-declare function isCompletable(schema: unknown): schema is CompletableSchema<StandardSchemaWithJSON>;
+declare function isCompletable(schema: unknown): schema is CompletableSchema<StandardSchemaV1>;
 //#endregion
-//#region src/experimental/tasks/interfaces.d.ts
+//#region src/server/middleware/hostHeaderValidation.d.ts
+type HostHeaderValidationResult = {
+  ok: true;
+  hostname: string;
+} | {
+  ok: false;
+  errorCode: 'missing_host' | 'invalid_host_header' | 'invalid_host';
+  message: string;
+  hostHeader?: string;
+  hostname?: string;
+};
 /**
- * Handler for creating a task.
- * @experimental
+ * Parse and validate a `Host` header against an allowlist of hostnames (port-agnostic).
+ *
+ * - Input host header may include a port (e.g. `localhost:3000`) or IPv6 brackets (e.g. `[::1]:3000`).
+ * - Allowlist items should be hostnames only (no ports). For IPv6, include brackets (e.g. `[::1]`).
  */
-type CreateTaskRequestHandler<SendResultT extends Result, Args extends StandardSchemaWithJSON | undefined = undefined> = BaseToolCallback<SendResultT, CreateTaskServerContext, Args>;
+declare function validateHostHeader(hostHeader: string | null | undefined, allowedHostnames: string[]): HostHeaderValidationResult;
 /**
- * Handler for task operations (`get`, `getResult`).
- * @experimental
+ * Convenience allowlist for `localhost` DNS rebinding protection.
  */
-type TaskRequestHandler<SendResultT extends Result, Args extends StandardSchemaWithJSON | undefined = undefined> = BaseToolCallback<SendResultT, TaskServerContext, Args>;
+declare function localhostAllowedHostnames(): string[];
 /**
- * Interface for task-based tool handlers.
- *
- * Task-based tools split a long-running operation into three phases:
- * `createTask`, `getTask`, and `getTaskResult`.
- *
- * @see {@linkcode @modelcontextprotocol/server!experimental/tasks/mcpServer.ExperimentalMcpServerTasks#registerToolTask | registerToolTask} for registration.
- * @experimental
+ * Web-standard `Request` helper for DNS rebinding protection.
+ * @example
+ * ```ts source="./hostHeaderValidation.examples.ts#hostHeaderValidationResponse_basicUsage"
+ * const result = validateHostHeader(req.headers.get('host'), ['localhost']);
+ * ```
  */
-interface ToolTaskHandler<Args extends StandardSchemaWithJSON | undefined = undefined> {
-  /**
-   * Called on the initial `tools/call` request.
-   *
-   * Creates a task via `ctx.task.store.createTask(...)`, starts any
-   * background work, and returns the task object.
-   */
-  createTask: CreateTaskRequestHandler<CreateTaskResult, Args>;
-  /**
-   * Handler for `tasks/get` requests.
-   */
-  getTask: TaskRequestHandler<GetTaskResult, Args>;
-  /**
-   * Handler for `tasks/result` requests.
-   */
-  getTaskResult: TaskRequestHandler<CallToolResult, Args>;
-}
+declare function hostHeaderValidationResponse(req: Request, allowedHostnames: string[]): Response | undefined;
 //#endregion
-//#region src/experimental/tasks/mcpServer.d.ts
+//#region src/server/middleware/originValidation.d.ts
 /**
- * Experimental task features for {@linkcode McpServer}.
+ * Framework-agnostic Origin header validation helpers.
  *
- * Access via `server.experimental.tasks`:
- * ```typescript
- * server.experimental.tasks.registerToolTask('long-running', config, handler);
- * ```
+ * Browsers attach an `Origin` header to cross-origin requests; validating it
+ * against an allowlist (alongside Host header validation) protects local and
+ * development MCP servers against DNS rebinding and cross-site request
+ * forgery. The framework middleware packages (`@modelcontextprotocol/express`,
+ * `@modelcontextprotocol/hono`, `@modelcontextprotocol/fastify`,
+ * `@modelcontextprotocol/node`) wrap these helpers; use them directly when
+ * mounting a handler bare on a fetch-native runtime.
  *
- * @experimental
+ * Validation is deny-on-failure: a present `Origin` value that cannot be
+ * parsed (including the opaque `null` origin) is rejected, never passed
+ * through. Requests without an `Origin` header pass — non-browser MCP clients
+ * do not send one.
  */
-declare class ExperimentalMcpServerTasks {
-  private readonly _mcpServer;
-  constructor(_mcpServer: McpServer);
-  /**
-   * Registers a task-based tool with a config object and handler.
-   *
-   * Task-based tools support long-running operations that can be polled for status
-   * and results. The handler must implement {@linkcode ToolTaskHandler.createTask | createTask}, {@linkcode ToolTaskHandler.getTask | getTask}, and {@linkcode ToolTaskHandler.getTaskResult | getTaskResult}
-   * methods.
-   *
-   * @example
-   * ```typescript
-   * server.experimental.tasks.registerToolTask('long-computation', {
-   *   description: 'Performs a long computation',
-   *   inputSchema: z.object({ input: z.string() }),
-   *   execution: { taskSupport: 'required' }
-   * }, {
-   *   createTask: async (args, ctx) => {
-   *     const task = await ctx.task.store.createTask({ ttl: 300000 });
-   *     startBackgroundWork(task.taskId, args);
-   *     return { task };
-   *   },
-   *   getTask: async (args, ctx) => {
-   *     return ctx.task.store.getTask(ctx.task.id);
-   *   },
-   *   getTaskResult: async (args, ctx) => {
-   *     return ctx.task.store.getTaskResult(ctx.task.id);
-   *   }
-   * });
-   * ```
-   *
-   * @param name - The tool name
-   * @param config - Tool configuration (description, schemas, etc.)
-   * @param handler - Task handler with {@linkcode ToolTaskHandler.createTask | createTask}, {@linkcode ToolTaskHandler.getTask | getTask}, {@linkcode ToolTaskHandler.getTaskResult | getTaskResult} methods
-   * @returns {@linkcode server/mcp.RegisteredTool | RegisteredTool} for managing the tool's lifecycle
-   *
-   * @experimental
-   */
-  registerToolTask<OutputArgs extends StandardSchemaWithJSON | undefined>(name: string, config: {
-    title?: string;
-    description?: string;
-    outputSchema?: OutputArgs;
-    annotations?: ToolAnnotations;
-    execution?: TaskToolExecution;
-    _meta?: Record<string, unknown>;
-  }, handler: ToolTaskHandler<undefined>): RegisteredTool;
-  registerToolTask<InputArgs extends StandardSchemaWithJSON, OutputArgs extends StandardSchemaWithJSON | undefined>(name: string, config: {
-    title?: string;
-    description?: string;
-    inputSchema: InputArgs;
-    outputSchema?: OutputArgs;
-    annotations?: ToolAnnotations;
-    execution?: TaskToolExecution;
-    _meta?: Record<string, unknown>;
-  }, handler: ToolTaskHandler<InputArgs>): RegisteredTool;
-}
-//#endregion
-//#region src/experimental/tasks/server.d.ts
+type OriginValidationResult = {
+  ok: true;
+  origin?: string;
+  hostname?: string;
+} | {
+  ok: false;
+  errorCode: 'invalid_origin_header' | 'invalid_origin';
+  message: string;
+  originHeader?: string;
+  hostname?: string;
+};
 /**
- * Experimental task features for low-level MCP servers.
- *
- * Access via `server.experimental.tasks`:
- * ```typescript
- * const stream = server.experimental.tasks.requestStream(request, options);
- * ```
+ * Validate an `Origin` header against an allowlist of hostnames (port-agnostic).
  *
- * For high-level server usage with task-based tools, use {@linkcode index.McpServer | McpServer}.experimental.tasks instead.
- *
- * @experimental
+ * - A missing/empty `Origin` header passes: non-browser clients do not send one,
+ *   and only browser-originated requests carry the header this check defends against.
+ * - Allowlist items are hostnames only (no scheme, no port), the same convention as
+ *   `validateHostHeader`. For IPv6, include brackets (e.g. `[::1]`).
+ * - Any present value that cannot be parsed as an origin URL — including the literal
+ *   `null` origin browsers send for opaque contexts — is rejected (deny on failure).
  */
-declare class ExperimentalServerTasks {
-  private readonly _server;
-  constructor(_server: Server);
-  private get _module();
-  /**
-   * Sends a request and returns an AsyncGenerator that yields response messages.
-   * The generator is guaranteed to end with either a `'result'` or `'error'` message.
-   *
-   * This method provides streaming access to request processing, allowing you to
-   * observe intermediate task status updates for task-augmented requests.
-   *
-   * @param request - The request to send (method name determines the result schema)
-   * @param options - Optional request options (timeout, signal, task creation params, etc.)
-   * @returns AsyncGenerator that yields {@linkcode ResponseMessage} objects
-   *
-   * @experimental
-   */
-  requestStream<M extends RequestMethod>(request: {
-    method: M;
-    params?: Record<string, unknown>;
-  }, options?: RequestOptions): AsyncGenerator<ResponseMessage<ResultTypeMap[M]>, void, void>;
-  /**
-   * Sends a sampling request and returns an AsyncGenerator that yields response messages.
-   * The generator is guaranteed to end with either a 'result' or 'error' message.
-   *
-   * For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages
-   * before the final result.
-   *
-   * @example
-   * ```typescript
-   * const stream = server.experimental.tasks.createMessageStream({
-   *     messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
-   *     maxTokens: 100
-   * }, {
-   *     onprogress: (progress) => {
-   *         // Handle streaming tokens via progress notifications
-   *         console.log('Progress:', progress.message);
-   *     }
-   * });
-   *
-   * for await (const message of stream) {
-   *     switch (message.type) {
-   *         case 'taskCreated':
-   *             console.log('Task created:', message.task.taskId);
-   *             break;
-   *         case 'taskStatus':
-   *             console.log('Task status:', message.task.status);
-   *             break;
-   *         case 'result':
-   *             console.log('Final result:', message.result);
-   *             break;
-   *         case 'error':
-   *             console.error('Error:', message.error);
-   *             break;
-   *     }
-   * }
-   * ```
-   *
-   * @param params - The sampling request parameters
-   * @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
-   * @returns AsyncGenerator that yields ResponseMessage objects
-   *
-   * @experimental
-   */
-  createMessageStream(params: CreateMessageRequestParams, options?: RequestOptions): AsyncGenerator<ResponseMessage<CreateMessageResult>, void, void>;
-  /**
-   * Sends an elicitation request and returns an AsyncGenerator that yields response messages.
-   * The generator is guaranteed to end with either a 'result' or 'error' message.
-   *
-   * For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
-   * and 'taskStatus' messages before the final result.
-   *
-   * @example
-   * ```typescript
-   * const stream = server.experimental.tasks.elicitInputStream({
-   *     mode: 'url',
-   *     message: 'Please authenticate',
-   *     elicitationId: 'auth-123',
-   *     url: 'https://example.com/auth'
-   * }, {
-   *     task: { ttl: 300000 } // Task-augmented for long-running auth flow
-   * });
-   *
-   * for await (const message of stream) {
-   *     switch (message.type) {
-   *         case 'taskCreated':
-   *             console.log('Task created:', message.task.taskId);
-   *             break;
-   *         case 'taskStatus':
-   *             console.log('Task status:', message.task.status);
-   *             break;
-   *         case 'result':
-   *             console.log('User action:', message.result.action);
-   *             break;
-   *         case 'error':
-   *             console.error('Error:', message.error);
-   *             break;
-   *     }
-   * }
-   * ```
-   *
-   * @param params - The elicitation request parameters
-   * @param options - Optional request options (timeout, signal, task creation params, etc.)
-   * @returns AsyncGenerator that yields ResponseMessage objects
-   *
-   * @experimental
-   */
-  elicitInputStream(params: ElicitRequestFormParams | ElicitRequestURLParams, options?: RequestOptions): AsyncGenerator<ResponseMessage<ElicitResult>, void, void>;
-  /**
-   * Gets the current status of a task.
-   *
-   * @param taskId - The task identifier
-   * @param options - Optional request options
-   * @returns The task status
-   *
-   * @experimental
-   */
-  getTask(taskId: string, options?: RequestOptions): Promise<GetTaskResult>;
-  /**
-   * Retrieves the result of a completed task.
-   *
-   * @param taskId - The task identifier
-   * @param options - Optional request options
-   * @returns The task result. The payload structure matches the result type of the
-   *   original request (e.g., a `tools/call` task returns a `CallToolResult`).
-   *
-   * @experimental
-   */
-  getTaskResult(taskId: string, options?: RequestOptions): Promise<GetTaskPayloadResult>;
-  /**
-   * Lists tasks with optional pagination.
-   *
-   * @param cursor - Optional pagination cursor
-   * @param options - Optional request options
-   * @returns List of tasks with optional next cursor
-   *
-   * @experimental
-   */
-  listTasks(cursor?: string, options?: RequestOptions): Promise<ListTasksResult>;
-  /**
-   * Cancels a running task.
-   *
-   * @param taskId - The task identifier
-   * @param options - Optional request options
-   *
-   * @experimental
-   */
-  cancelTask(taskId: string, options?: RequestOptions): Promise<CancelTaskResult>;
-}
-//#endregion
-//#region src/server/server.d.ts
+declare function validateOriginHeader(originHeader: string | null | undefined, allowedOriginHostnames: string[]): OriginValidationResult;
 /**
- * Extended tasks capability that includes runtime configuration (store, messageQueue).
- * The runtime-only fields are stripped before advertising capabilities to clients.
+ * Convenience allowlist of localhost-class origin hostnames, mirroring
+ * `localhostAllowedHostnames`.
  */
-type ServerTasksCapabilityWithRuntime = NonNullable<ServerCapabilities['tasks']> & TaskManagerOptions;
-type ServerOptions = ProtocolOptions & {
-  /**
-   * Capabilities to advertise as being supported by this server.
-   */
-  capabilities?: Omit<ServerCapabilities, 'tasks'> & {
-    tasks?: ServerTasksCapabilityWithRuntime;
-  };
-  /**
-   * Optional instructions describing how to use the server and its features.
-   */
-  instructions?: string;
-  /**
-   * JSON Schema validator for elicitation response validation.
-   *
-   * The validator is used to validate user input returned from elicitation
-   * requests against the requested schema.
-   *
-   * @default {@linkcode DefaultJsonSchemaValidator} ({@linkcode index.AjvJsonSchemaValidator | AjvJsonSchemaValidator} on Node.js, {@linkcode index.CfWorkerJsonSchemaValidator | CfWorkerJsonSchemaValidator} on Cloudflare Workers)
-   */
-  jsonSchemaValidator?: jsonSchemaValidator;
-};
+declare function localhostAllowedOrigins(): string[];
 /**
- * An MCP server on top of a pluggable transport.
- *
- * This server will automatically respond to the initialization flow as initiated from the client.
+ * Web-standard `Request` helper for Origin validation: returns a `403` JSON-RPC
+ * error response when the request's `Origin` header is not allowed, and
+ * `undefined` when the request may proceed.
  *
- * @deprecated Use {@linkcode server/mcp.McpServer | McpServer} instead for the high-level API. Only use `Server` for advanced use cases.
+ * ```ts
+ * const rejected = originValidationResponse(request, localhostAllowedOrigins());
+ * if (rejected) return rejected;
+ * ```
  */
-declare class Server extends Protocol<ServerContext> {
-  private _serverInfo;
-  private _clientCapabilities?;
-  private _clientVersion?;
-  private _capabilities;
-  private _instructions?;
-  private _jsonSchemaValidator;
-  private _experimental?;
-  /**
-   * Callback for when initialization has fully completed (i.e., the client has sent an `notifications/initialized` notification).
-   */
-  oninitialized?: () => void;
-  /**
-   * Initializes this server with the given name and version information.
-   */
-  constructor(_serverInfo: Implementation, options?: ServerOptions);
-  private _registerLoggingHandler;
-  protected buildContext(ctx: BaseContext, transportInfo?: MessageExtraInfo): ServerContext;
-  /**
-   * Access experimental features.
-   *
-   * WARNING: These APIs are experimental and may change without notice.
-   *
-   * @experimental
-   */
-  get experimental(): {
-    tasks: ExperimentalServerTasks;
-  };
-  private _loggingLevels;
-  private readonly LOG_LEVEL_SEVERITY;
-  private isMessageIgnored;
-  /**
-   * Registers new capabilities. This can only be called before connecting to a transport.
-   *
-   * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
-   */
-  registerCapabilities(capabilities: ServerCapabilities): void;
-  /**
-   * Override request handler registration to enforce server-side validation for `tools/call`.
-   */
-  setRequestHandler<M extends RequestMethod>(method: M, handler: (request: RequestTypeMap[M], ctx: ServerContext) => ResultTypeMap[M] | Promise<ResultTypeMap[M]>): void;
-  protected assertCapabilityForMethod(method: RequestMethod): void;
-  protected assertNotificationCapability(method: NotificationMethod): void;
-  protected assertRequestHandlerCapability(method: string): void;
-  protected assertTaskCapability(method: string): void;
-  protected assertTaskHandlerCapability(method: string): void;
-  private _oninitialize;
-  /**
-   * After initialization has completed, this will be populated with the client's reported capabilities.
-   */
-  getClientCapabilities(): ClientCapabilities | undefined;
-  /**
-   * After initialization has completed, this will be populated with information about the client's name and version.
-   */
-  getClientVersion(): Implementation | undefined;
-  /**
-   * Returns the current server capabilities.
-   */
-  getCapabilities(): ServerCapabilities;
-  ping(): Promise<{
-    _meta?: {
-      [x: string]: unknown;
-      progressToken?: string | number | undefined;
-      "io.modelcontextprotocol/related-task"?: {
-        taskId: string;
-      } | undefined;
-    } | undefined;
-  }>;
-  /**
-   * Request LLM sampling from the client (without tools).
-   * Returns single content block for backwards compatibility.
-   */
-  createMessage(params: CreateMessageRequestParamsBase, options?: RequestOptions): Promise<CreateMessageResult>;
-  /**
-   * Request LLM sampling from the client with tool support.
-   * Returns content that may be a single block or array (for parallel tool calls).
-   */
-  createMessage(params: CreateMessageRequestParamsWithTools, options?: RequestOptions): Promise<CreateMessageResultWithTools>;
-  /**
-   * Request LLM sampling from the client.
-   * When tools may or may not be present, returns the union type.
-   */
-  createMessage(params: CreateMessageRequest['params'], options?: RequestOptions): Promise<CreateMessageResult | CreateMessageResultWithTools>;
-  /**
-   * Creates an elicitation request for the given parameters.
-   * For backwards compatibility, `mode` may be omitted for form requests and will default to `"form"`.
-   * @param params The parameters for the elicitation request.
-   * @param options Optional request options.
-   * @returns The result of the elicitation request.
-   */
-  elicitInput(params: ElicitRequestFormParams | ElicitRequestURLParams, options?: RequestOptions): Promise<ElicitResult>;
-  /**
-   * Creates a reusable callback that, when invoked, will send a `notifications/elicitation/complete`
-   * notification for the specified elicitation ID.
-   *
-   * @param elicitationId The ID of the elicitation to mark as complete.
-   * @param options Optional notification options. Useful when the completion notification should be related to a prior request.
-   * @returns A function that emits the completion notification when awaited.
-   */
-  createElicitationCompletionNotifier(elicitationId: string, options?: NotificationOptions): () => Promise<void>;
-  listRoots(params?: ListRootsRequest['params'], options?: RequestOptions): Promise<{
-    [x: string]: unknown;
-    roots: {
-      uri: string;
-      name?: string | undefined;
-      _meta?: Record<string, unknown> | undefined;
-    }[];
-    _meta?: {
-      [x: string]: unknown;
-      progressToken?: string | number | undefined;
-      "io.modelcontextprotocol/related-task"?: {
-        taskId: string;
-      } | undefined;
-    } | undefined;
-  }>;
-  /**
-   * Sends a logging message to the client, if connected.
-   * Note: You only need to send the parameters object, not the entire JSON-RPC message.
-   * @see {@linkcode LoggingMessageNotification}
-   * @param params
-   * @param sessionId Optional for stateless transports and backward compatibility.
-   */
-  sendLoggingMessage(params: LoggingMessageNotification['params'], sessionId?: string): Promise<void>;
-  sendResourceUpdated(params: ResourceUpdatedNotification['params']): Promise<void>;
-  sendResourceListChanged(): Promise<void>;
-  sendToolListChanged(): Promise<void>;
-  sendPromptListChanged(): Promise<void>;
-}
+declare function originValidationResponse(req: Request, allowedOriginHostnames: string[]): Response | undefined;
 //#endregion
-//#region src/server/mcp.d.ts
+//#region src/server/requestStateCodec.d.ts
 /**
- * High-level MCP server that provides a simpler API for working with resources, tools, and prompts.
- * For advanced usage (like sending notifications or setting custom request handlers), use the underlying
- * {@linkcode Server} instance available via the {@linkcode McpServer.server | server} property.
- *
- * @example
- * ```ts source="./mcp.examples.ts#McpServer_basicUsage"
- * const server = new McpServer({
- *     name: 'my-server',
- *     version: '1.0.0'
- * });
- * ```
+ * Options for {@linkcode createRequestStateCodec}.
  */
-declare class McpServer {
+interface RequestStateCodecOptions {
   /**
-   * The underlying {@linkcode Server} instance, useful for advanced operations like sending notifications.
+   * The HMAC secret. A `string` value is UTF-8-encoded. MUST be at least
+   * 32 bytes (256 bits) long; a `RangeError` is thrown at
+   * construction otherwise. The same key must be available to every server
+   * instance that may receive an echoed `requestState` (so a per-process
+   * random key only works when one process serves every round of a flow).
    */
-  readonly server: Server;
-  private _registeredResources;
-  private _registeredResourceTemplates;
-  private _registeredTools;
-  private _registeredPrompts;
-  private _experimental?;
-  constructor(serverInfo: Implementation, options?: ServerOptions);
+  key: Uint8Array | string;
   /**
-   * Access experimental features.
-   *
-   * WARNING: These APIs are experimental and may change without notice.
-   *
-   * @experimental
+   * How long a minted `requestState` stays valid, in seconds. An echoed
+   * value past its expiry is rejected by {@linkcode RequestStateCodec.verify}.
+   * Defaults to `600` (ten minutes).
    */
-  get experimental(): {
-    tasks: ExperimentalMcpServerTasks;
-  };
+  ttlSeconds?: number;
   /**
-   * Attaches to the given transport, starts it, and starts listening for messages.
-   *
-   * The `server` object assumes ownership of the {@linkcode Transport}, replacing any callbacks that have already been set, and expects that it is the only user of the {@linkcode Transport} instance going forward.
+   * Optional context binding. Called at mint time and again at verify time;
+   * a `requestState` minted under one binding value is rejected when echoed
+   * under a different one. Use this to bind state to the authenticated
+   * principal and/or the originating method (the spec's user-binding MUST
+   * for state that influences authorization), for example:
    *
-   * @example
-   * ```ts source="./mcp.examples.ts#McpServer_connect_stdio"
-   * const server = new McpServer({ name: 'my-server', version: '1.0.0' });
-   * const transport = new StdioServerTransport();
-   * await server.connect(transport);
+   * ```ts
+   * bind: ctx => `${ctx.mcpReq.method}\0${ctx.http?.authInfo?.clientId ?? ''}`
    * ```
-   */
-  connect(transport: Transport): Promise<void>;
-  /**
-   * Closes the connection.
-   */
-  close(): Promise<void>;
-  private _toolHandlersInitialized;
-  private setToolRequestHandlers;
-  /**
-   * Creates a tool error result.
    *
-   * @param errorMessage - The error message.
-   * @returns The tool error result.
-   */
-  private createToolError;
-  /**
-   * Validates tool input arguments against the tool's input schema.
-   */
-  private validateToolInput;
-  /**
-   * Validates tool output against the tool's output schema.
-   */
-  private validateToolOutput;
-  /**
-   * Executes a tool handler (either regular or task-based).
-   */
-  private executeToolHandler;
-  /**
-   * Handles automatic task polling for tools with `taskSupport` `'optional'`.
-   */
-  private handleAutomaticTaskPolling;
-  private _completionHandlerInitialized;
-  private setCompletionRequestHandler;
-  private handlePromptCompletion;
-  private handleResourceCompletion;
-  private _resourceHandlersInitialized;
-  private setResourceRequestHandlers;
-  private _promptHandlersInitialized;
-  private setPromptRequestHandlers;
-  /**
-   * Registers a resource with a config object and callback.
-   * For static resources, use a URI string. For dynamic resources, use a {@linkcode ResourceTemplate}.
+   * The returned value is stored in the envelope as a domain-separated HMAC
+   * tag (keyed by the codec's `key`), not the raw string — so a principal
+   * identifier in the binding does not appear in the wire value the client
+   * holds.
    *
-   * @example
-   * ```ts source="./mcp.examples.ts#McpServer_registerResource_static"
-   * server.registerResource(
-   *     'config',
-   *     'config://app',
-   *     {
-   *         title: 'Application Config',
-   *         mimeType: 'text/plain'
-   *     },
-   *     async uri => ({
-   *         contents: [{ uri: uri.href, text: 'App configuration here' }]
-   *     })
-   * );
-   * ```
+   * When configured, {@linkcode RequestStateCodec.mint} requires its `ctx`
+   * argument.
    */
-  registerResource(name: string, uriOrTemplate: string, config: ResourceMetadata, readCallback: ReadResourceCallback): RegisteredResource;
-  registerResource(name: string, uriOrTemplate: ResourceTemplate, config: ResourceMetadata, readCallback: ReadResourceTemplateCallback): RegisteredResourceTemplate;
-  private _createRegisteredResource;
-  private _createRegisteredResourceTemplate;
-  private _createRegisteredPrompt;
-  private _createRegisteredTool;
-  /**
-   * Registers a tool with a config object and callback.
-   *
-   * @example
-   * ```ts source="./mcp.examples.ts#McpServer_registerTool_basic"
-   * server.registerTool(
-   *     'calculate-bmi',
-   *     {
-   *         title: 'BMI Calculator',
-   *         description: 'Calculate Body Mass Index',
-   *         inputSchema: z.object({
-   *             weightKg: z.number(),
-   *             heightM: z.number()
-   *         }),
-   *         outputSchema: z.object({ bmi: z.number() })
-   *     },
-   *     async ({ weightKg, heightM }) => {
-   *         const output = { bmi: weightKg / (heightM * heightM) };
-   *         return {
-   *             content: [{ type: 'text', text: JSON.stringify(output) }],
-   *             structuredContent: output
-   *         };
-   *     }
-   * );
-   * ```
-   */
-  registerTool<OutputArgs extends StandardSchemaWithJSON, InputArgs extends StandardSchemaWithJSON | undefined = undefined>(name: string, config: {
-    title?: string;
-    description?: string;
-    inputSchema?: InputArgs;
-    outputSchema?: OutputArgs;
-    annotations?: ToolAnnotations;
-    _meta?: Record<string, unknown>;
-  }, cb: ToolCallback<InputArgs>): RegisteredTool;
-  /**
-   * Registers a prompt with a config object and callback.
-   *
-   * @example
-   * ```ts source="./mcp.examples.ts#McpServer_registerPrompt_basic"
-   * server.registerPrompt(
-   *     'review-code',
-   *     {
-   *         title: 'Code Review',
-   *         description: 'Review code for best practices',
-   *         argsSchema: z.object({ code: z.string() })
-   *     },
-   *     ({ code }) => ({
-   *         messages: [
-   *             {
-   *                 role: 'user' as const,
-   *                 content: {
-   *                     type: 'text' as const,
-   *                     text: `Please review this code:\n\n${code}`
-   *                 }
-   *             }
-   *         ]
-   *     })
-   * );
-   * ```
-   */
-  registerPrompt<Args extends StandardSchemaWithJSON>(name: string, config: {
-    title?: string;
-    description?: string;
-    argsSchema?: Args;
-    _meta?: Record<string, unknown>;
-  }, cb: PromptCallback<Args>): RegisteredPrompt;
-  /**
-   * Checks if the server is connected to a transport.
-   * @returns `true` if the server is connected
-   */
-  isConnected(): boolean;
-  /**
-   * Sends a logging message to the client, if connected.
-   * Note: You only need to send the parameters object, not the entire JSON-RPC message.
-   * @see {@linkcode LoggingMessageNotification}
-   * @param params
-   * @param sessionId Optional for stateless transports and backward compatibility.
-   *
-   * @example
-   * ```ts source="./mcp.examples.ts#McpServer_sendLoggingMessage_basic"
-   * await server.sendLoggingMessage({
-   *     level: 'info',
-   *     data: 'Processing complete'
-   * });
-   * ```
-   */
-  sendLoggingMessage(params: LoggingMessageNotification['params'], sessionId?: string): Promise<void>;
-  /**
-   * Sends a resource list changed event to the client, if connected.
-   */
-  sendResourceListChanged(): void;
-  /**
-   * Sends a tool list changed event to the client, if connected.
-   */
-  sendToolListChanged(): void;
-  /**
-   * Sends a prompt list changed event to the client, if connected.
-   */
-  sendPromptListChanged(): void;
+  bind?: (ctx: ServerContext) => string;
 }
 /**
- * A callback to complete one variable within a resource template's URI template.
- */
-type CompleteResourceTemplateCallback = (value: string, context?: {
-  arguments?: Record<string, string>;
-}) => string[] | Promise<string[]>;
-/**
- * A resource template combines a URI pattern with optional functionality to enumerate
- * all resources matching that pattern.
+ * The codec returned by {@linkcode createRequestStateCodec}: `mint` seals a
+ * JSON-serializable payload into the wire string a handler returns from
+ * `inputRequired({ requestState })`; `verify` is the function to drop into
+ * {@linkcode server/server.ServerOptions | ServerOptions}`.requestState.verify`
+ * (it throws on any failure, which the seam answers as the frozen `-32602`).
+ * The decoded payload `verify` resolves with is handed to the handler by the
+ * seam via the typed `ctx.mcpReq.requestState<T>()` accessor — `mint<T>` and
+ * `requestState<T>()` are the typed encode/read pair.
  */
-declare class ResourceTemplate {
-  private _callbacks;
-  private _uriTemplate;
-  constructor(uriTemplate: string | UriTemplate, _callbacks: {
-    /**
-     * A callback to list all resources matching this template. This is required to be specified, even if `undefined`, to avoid accidentally forgetting resource listing.
-     */
-    list: ListResourcesCallback | undefined;
-    /**
-     * An optional callback to autocomplete variables within the URI template. Useful for clients and users to discover possible values.
-     */
-    complete?: {
-      [variable: string]: CompleteResourceTemplateCallback;
-    };
-  });
-  /**
-   * Gets the URI template pattern.
-   */
-  get uriTemplate(): UriTemplate;
+interface RequestStateCodec<T = unknown> {
   /**
-   * Gets the list callback, if one was provided.
+   * Seal `payload` into an opaque wire string. The result is what the
+   * handler returns from `inputRequired({ requestState })`.
+   *
+   * @param ctx The handler's context. Required when the codec was created
+   *            with a {@linkcode RequestStateCodecOptions.bind | bind}
+   *            callback; ignored otherwise.
    */
-  get listCallback(): ListResourcesCallback | undefined;
+  mint(payload: T, ctx?: ServerContext): Promise<string>;
   /**
-   * Gets the callback for completing a specific URI template variable, if one was provided.
+   * Verify an echoed `requestState` and return the original payload. Throws
+   * on any failure (bad MAC, expired, bind mismatch, malformed). The thrown
+   * message is a fixed opaque reason code (`'malformed'` / `'mac'` /
+   * `'expired'` / `'bind'`) — never the decoded payload, the binding value,
+   * or any other context-derived field.
+   *
+   * Pass this directly as `ServerOptions.requestState.verify`.
    */
-  completeCallback(variable: string): CompleteResourceTemplateCallback | undefined;
+  verify(state: string, ctx: ServerContext): Promise<T>;
 }
-type BaseToolCallback<SendResultT extends Result, Ctx extends ServerContext, Args extends StandardSchemaWithJSON | undefined> = Args extends StandardSchemaWithJSON ? (args: StandardSchemaWithJSON.InferOutput<Args>, ctx: Ctx) => SendResultT | Promise<SendResultT> : (ctx: Ctx) => SendResultT | Promise<SendResultT>;
-/**
- * Callback for a tool handler registered with {@linkcode McpServer.registerTool}.
- */
-type ToolCallback<Args extends StandardSchemaWithJSON | undefined = undefined> = BaseToolCallback<CallToolResult, ServerContext, Args>;
-/**
- * Supertype that can handle both regular tools (simple callback) and task-based tools (task handler object).
- */
-type AnyToolHandler<Args extends StandardSchemaWithJSON | undefined = undefined> = ToolCallback<Args> | ToolTaskHandler<Args>;
-/**
- * Internal executor type that encapsulates handler invocation with proper types.
- */
-type ToolExecutor = (args: unknown, ctx: ServerContext) => Promise<CallToolResult | CreateTaskResult>;
-type RegisteredTool = {
-  title?: string;
-  description?: string;
-  inputSchema?: StandardSchemaWithJSON;
-  outputSchema?: StandardSchemaWithJSON;
-  annotations?: ToolAnnotations;
-  execution?: ToolExecution;
-  _meta?: Record<string, unknown>;
-  handler: AnyToolHandler<StandardSchemaWithJSON | undefined>;
-  /** @hidden */
-  executor: ToolExecutor;
-  enabled: boolean;
-  enable(): void;
-  disable(): void;
-  update(updates: {
-    name?: string | null;
-    title?: string;
-    description?: string;
-    paramsSchema?: StandardSchemaWithJSON;
-    outputSchema?: StandardSchemaWithJSON;
-    annotations?: ToolAnnotations;
-    _meta?: Record<string, unknown>;
-    callback?: ToolCallback<StandardSchemaWithJSON>;
-    enabled?: boolean;
-  }): void;
-  remove(): void;
-};
 /**
- * Additional, optional information for annotating a resource.
- */
-type ResourceMetadata = Omit<Resource, 'uri' | 'name'>;
-/**
- * Callback to list all resources matching a given template.
- */
-type ListResourcesCallback = (ctx: ServerContext) => ListResourcesResult | Promise<ListResourcesResult>;
-/**
- * Callback to read a resource at a given URI.
- */
-type ReadResourceCallback = (uri: URL, ctx: ServerContext) => ReadResourceResult | Promise<ReadResourceResult>;
-type RegisteredResource = {
-  name: string;
-  title?: string;
-  metadata?: ResourceMetadata;
-  readCallback: ReadResourceCallback;
-  enabled: boolean;
-  enable(): void;
-  disable(): void;
-  update(updates: {
-    name?: string;
-    title?: string;
-    uri?: string | null;
-    metadata?: ResourceMetadata;
-    callback?: ReadResourceCallback;
-    enabled?: boolean;
-  }): void;
-  remove(): void;
-};
-/**
- * Callback to read a resource at a given URI, following a filled-in URI template.
- */
-type ReadResourceTemplateCallback = (uri: URL, variables: Variables, ctx: ServerContext) => ReadResourceResult | Promise<ReadResourceResult>;
-type RegisteredResourceTemplate = {
-  resourceTemplate: ResourceTemplate;
-  title?: string;
-  metadata?: ResourceMetadata;
-  readCallback: ReadResourceTemplateCallback;
-  enabled: boolean;
-  enable(): void;
-  disable(): void;
-  update(updates: {
-    name?: string | null;
-    title?: string;
-    template?: ResourceTemplate;
-    metadata?: ResourceMetadata;
-    callback?: ReadResourceTemplateCallback;
-    enabled?: boolean;
-  }): void;
-  remove(): void;
-};
-type PromptCallback<Args extends StandardSchemaWithJSON | undefined = undefined> = Args extends StandardSchemaWithJSON ? (args: StandardSchemaWithJSON.InferOutput<Args>, ctx: ServerContext) => GetPromptResult | Promise<GetPromptResult> : (ctx: ServerContext) => GetPromptResult | Promise<GetPromptResult>;
-/**
- * Internal handler type that encapsulates parsing and callback invocation.
- * This allows type-safe handling without runtime type assertions.
- */
-type PromptHandler = (args: Record<string, unknown> | undefined, ctx: ServerContext) => Promise<GetPromptResult>;
-type RegisteredPrompt = {
-  title?: string;
-  description?: string;
-  argsSchema?: StandardSchemaWithJSON;
-  _meta?: Record<string, unknown>;
-  /** @hidden */
-  handler: PromptHandler;
-  enabled: boolean;
-  enable(): void;
-  disable(): void;
-  update<Args extends StandardSchemaWithJSON>(updates: {
-    name?: string | null;
-    title?: string;
-    description?: string;
-    argsSchema?: Args;
-    _meta?: Record<string, unknown>;
-    callback?: PromptCallback<Args>;
-    enabled?: boolean;
-  }): void;
-  remove(): void;
-};
-//#endregion
-//#region src/server/middleware/hostHeaderValidation.d.ts
-type HostHeaderValidationResult = {
-  ok: true;
-  hostname: string;
-} | {
-  ok: false;
-  errorCode: 'missing_host' | 'invalid_host_header' | 'invalid_host';
-  message: string;
-  hostHeader?: string;
-  hostname?: string;
-};
-/**
- * Parse and validate a `Host` header against an allowlist of hostnames (port-agnostic).
+ * Create an opt-in HMAC-SHA256 codec for the multi-round-trip `requestState`
+ * (protocol revision 2026-07-28).
  *
- * - Input host header may include a port (e.g. `localhost:3000`) or IPv6 brackets (e.g. `[::1]:3000`).
- * - Allowlist items should be hostnames only (no ports). For IPv6, include brackets (e.g. `[::1]`).
- */
-declare function validateHostHeader(hostHeader: string | null | undefined, allowedHostnames: string[]): HostHeaderValidationResult;
-/**
- * Convenience allowlist for `localhost` DNS rebinding protection.
- */
-declare function localhostAllowedHostnames(): string[];
-/**
- * Web-standard `Request` helper for DNS rebinding protection.
- * @example
- * ```ts source="./hostHeaderValidation.examples.ts#hostHeaderValidationResponse_basicUsage"
- * const result = validateHostHeader(req.headers.get('host'), ['localhost']);
- * ```
- */
-declare function hostHeaderValidationResponse(req: Request, allowedHostnames: string[]): Response | undefined;
-//#endregion
-//#region src/server/stdio.d.ts
-/**
- * Server transport for stdio: this communicates with an MCP client by reading from the current process' `stdin` and writing to `stdout`.
+ * `requestState` round-trips through the client and is attacker-controlled
+ * input on re-entry. The SDK applies no protection of its own; this helper is
+ * the convenience implementation of the spec's integrity MUST so authors don't
+ * hand-roll HMAC. Wire shape:
  *
- * This transport is only available in Node.js environments.
+ *     "v1." b64url({"p":<payload>,"exp":<unixSeconds>,"b":<bindTag>?}) "." b64url(mac)
  *
- * @example
- * ```ts source="./stdio.examples.ts#StdioServerTransport_basicUsage"
- * const server = new McpServer({ name: 'my-server', version: '1.0.0' });
- * const transport = new StdioServerTransport();
- * await server.connect(transport);
- * ```
+ * where `bindTag` is `b64url(HMAC(key, "mcp.requestState.bind:" + bind(ctx))[:16])`
+ * — the binding value is never embedded raw.
+ *
+ * The codec is **signed, not encrypted**: the body is integrity-protected but
+ * the client can base64url-decode it and read the payload (`p`) in clear. Do
+ * not put secrets in the payload; use an AEAD construction if confidentiality
+ * is required. The handler reads its payload back via the typed
+ * `ctx.mcpReq.requestState<T>()` accessor — the seam has already run `verify`
+ * (integrity proven, payload decoded) by the time the handler is entered.
+ *
+ * Verification is fail-closed and constant-time (WebCrypto `subtle.verify` for
+ * the body MAC; a fixed-length XOR-accumulator compare for the bind tag).
+ * See `examples/mrtr/server.ts` for a worked end-to-end example.
+ *
+ * Design comparison (mcp.d `secureRequestState`, the peer SDK's reference
+ * implementation): mcp.d additionally offers an AES-256-GCM encrypted mode and
+ * derives independent cipher / bind-HMAC sub-keys from the operator secret via
+ * HKDF-SHA256, with an auto-generated per-process ephemeral key when none is
+ * supplied. This codec deliberately ships only the signed mode and a single
+ * keyed HMAC (domain-separated by input prefix) — HKDF sub-key derivation and
+ * an encrypted mode are intentionally out of scope for the initial release.
  */
-declare class StdioServerTransport implements Transport {
-  private _stdin;
-  private _stdout;
-  private _readBuffer;
-  private _started;
-  private _closed;
-  constructor(_stdin?: Readable, _stdout?: Writable);
-  onclose?: () => void;
-  onerror?: (error: Error) => void;
-  onmessage?: (message: JSONRPCMessage) => void;
-  _ondata: (chunk: Buffer) => void;
-  _onerror: (error: Error) => void;
-  _onstdouterror: (error: Error) => void;
-  /**
-   * Starts listening for messages on `stdin`.
-   */
-  start(): Promise<void>;
-  private processReadBuffer;
-  close(): Promise<void>;
-  send(message: JSONRPCMessage): Promise<void>;
-}
+declare function createRequestStateCodec<T = unknown>(options: RequestStateCodecOptions): RequestStateCodec<T>;
 //#endregion
 //#region src/server/streamableHttp.d.ts
 type StreamId = string;
@@ -954,7 +283,7 @@ interface WebStandardStreamableHTTPServerTransportOptions {
    *
    * If not provided, session management is disabled (stateless mode).
    */
-  sessionIdGenerator?: () => string;
+  sessionIdGenerator?: (() => string) | undefined;
   /**
    * A callback for session initialization events
    * This is called when the server initializes a new session.
@@ -962,7 +291,7 @@ interface WebStandardStreamableHTTPServerTransportOptions {
    * and need to keep track of them.
    * @param sessionId The generated session ID
    */
-  onsessioninitialized?: (sessionId: string) => void | Promise<void>;
+  onsessioninitialized?: ((sessionId: string) => void | Promise<void>) | undefined;
   /**
    * A callback for session close events
    * This is called when the server closes a session due to a `DELETE` request.
@@ -973,7 +302,7 @@ interface WebStandardStreamableHTTPServerTransportOptions {
    * session open/running.
    * @param sessionId The session ID that was closed
    */
-  onsessionclosed?: (sessionId: string) => void | Promise<void>;
+  onsessionclosed?: ((sessionId: string) => void | Promise<void>) | undefined;
   /**
    * If `true`, the server will return JSON responses instead of starting an SSE stream.
    * This can be useful for simple request/response scenarios without streaming.
@@ -1089,6 +418,7 @@ interface HandleRequestOptions {
 declare class WebStandardStreamableHTTPServerTransport implements Transport {
   private sessionIdGenerator;
   private _started;
+  private _closed;
   private _streamMapping;
   private _requestToStreamMapping;
   private _requestResponseMap;
@@ -1132,10 +462,24 @@ declare class WebStandardStreamableHTTPServerTransport implements Transport {
    * Returns a `Response` object (Web Standard)
    */
   handleRequest(req: Request, options?: HandleRequestOptions): Promise<Response>;
+  /**
+   * Returns true if the client's protocol version supports empty SSE data in
+   * priming events (the fix shipped with protocol version `2025-11-25`).
+   *
+   * The version is checked for membership in this transport instance's
+   * supported protocol versions rather than with an open-ended
+   * `>= '2025-11-25'` comparison: the value may come from an `initialize`
+   * request body, which (unlike the `MCP-Protocol-Version` header) is not
+   * validated against `supportedProtocolVersions` before reaching this
+   * check. An unknown future version string must not silently enable
+   * behavior reserved for versions this transport actually supports.
+   */
+  private supportsEmptySSEData;
   /**
    * Writes a priming event to establish resumption capability.
    * Only sends if `eventStore` is configured (opt-in for resumability) and
-   * the client's protocol version supports empty SSE data (>= `2025-11-25`).
+   * the client's protocol version supports empty SSE data (a supported
+   * version that is >= `2025-11-25`).
    */
   private writePrimingEvent;
   /**
@@ -1202,5 +546,5 @@ declare class WebStandardStreamableHTTPServerTransport implements Transport {
 //#region src/fromJsonSchema.d.ts
 declare function fromJsonSchema<T = unknown>(schema: JsonSchemaType, validator?: jsonSchemaValidator): StandardSchemaWithJSON<T, T>;
 //#endregion
-export { AjvJsonSchemaValidator, Annotations, type AnyToolHandler, AudioContent, AuthInfo, type AuthorizationServerMetadata, type BaseContext, BaseMetadata, type BaseQueuedMessage, type BaseResponseMessage, type BaseToolCallback, BlobResourceContents, BooleanSchema, CallToolRequest, CallToolRequestParams, CallToolResult, CancelTaskRequest, CancelTaskResult, CancelledNotification, CancelledNotificationParams, CfWorkerJsonSchemaValidator, type CfWorkerSchemaDraft, ClientCapabilities, type ClientContext, ClientNotification, ClientRequest, ClientResult, CompatibilityCallToolResult, type CompletableSchema, type CompleteCallback, CompleteRequest, CompleteRequestParams, CompleteRequestPrompt, CompleteRequestResourceTemplate, type CompleteResourceTemplateCallback, CompleteResult, ContentBlock, CreateMessageRequest, CreateMessageRequestParams, CreateMessageRequestParamsBase, CreateMessageRequestParamsWithTools, CreateMessageResult, CreateMessageResultWithTools, type CreateTaskOptions, type CreateTaskRequestHandler, CreateTaskResult, type CreateTaskServerContext, Cursor, DEFAULT_NEGOTIATED_PROTOCOL_VERSION, DEFAULT_REQUEST_TIMEOUT_MSEC, ElicitRequest, ElicitRequestFormParams, ElicitRequestParams, ElicitRequestURLParams, ElicitResult, ElicitationCompleteNotification, ElicitationCompleteNotificationParams, EmbeddedResource, EmptyResult, EnumSchema, type ErrorMessage, type EventId, type EventStore, ExperimentalMcpServerTasks, ExperimentalServerTasks, type FetchLike, GetPromptRequest, GetPromptRequestParams, GetPromptResult, GetTaskPayloadRequest, GetTaskPayloadResult, GetTaskRequest, GetTaskResult, type HandleRequestOptions, type HostHeaderValidationResult, INTERNAL_ERROR, INVALID_PARAMS, INVALID_REQUEST, Icon, Icons, ImageContent, Implementation, InMemoryTaskMessageQueue, InMemoryTaskStore, InitializeRequest, InitializeRequestParams, InitializeResult, InitializedNotification, InternalError, InvalidParamsError, InvalidRequestError, JSONArray, JSONObject, JSONRPCErrorResponse, JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, JSONRPCResultResponse, JSONRPC_VERSION, JSONValue, type JsonSchemaType, type JsonSchemaValidator, type JsonSchemaValidatorResult, LATEST_PROTOCOL_VERSION, LegacyTitledEnumSchema, ListChangedCallback, ListChangedHandlers, ListChangedOptions, ListPromptsRequest, ListPromptsResult, ListResourceTemplatesRequest, ListResourceTemplatesResult, type ListResourcesCallback, ListResourcesRequest, ListResourcesResult, ListRootsRequest, ListRootsResult, ListTasksRequest, ListTasksResult, ListToolsRequest, ListToolsResult, LoggingLevel, LoggingMessageNotification, LoggingMessageNotificationParams, METHOD_NOT_FOUND, McpServer, MessageExtraInfo, MetaObject, MethodNotFoundError, ModelHint, ModelPreferences, MultiSelectEnumSchema, Notification, NotificationMethod, type NotificationOptions, NotificationParams, NotificationTypeMap, NumberSchema, type OAuthClientInformation, type OAuthClientInformationFull, type OAuthClientInformationMixed, type OAuthClientMetadata, type OAuthClientRegistrationError, OAuthError, OAuthErrorCode, type OAuthErrorResponse, type OAuthMetadata, type OAuthProtectedResourceMetadata, type OAuthTokenRevocationRequest, type OAuthTokens, type OpenIdProviderDiscoveryMetadata, type OpenIdProviderMetadata, PARSE_ERROR, PaginatedRequest, PaginatedRequestParams, PaginatedResult, ParseError, PingRequest, PrimitiveSchemaDefinition, Progress, type ProgressCallback, ProgressNotification, ProgressNotificationParams, ProgressToken, Prompt, PromptArgument, type PromptCallback, PromptListChangedNotification, PromptMessage, PromptReference, ProtocolError, ProtocolErrorCode, type ProtocolOptions, type QueuedError, type QueuedMessage, type QueuedNotification, type QueuedRequest, type QueuedResponse, RELATED_TASK_META_KEY, ReadBuffer, type ReadResourceCallback, ReadResourceRequest, ReadResourceRequestParams, ReadResourceResult, type ReadResourceTemplateCallback, type RegisteredPrompt, type RegisteredResource, type RegisteredResourceTemplate, type RegisteredTool, RelatedTaskMetadata, Request$1 as Request, RequestId, RequestMeta, RequestMetaObject, RequestMethod, type RequestOptions, RequestParams, type RequestTaskStore, RequestTypeMap, Resource, ResourceContents, ResourceLink, ResourceListChangedNotification, type ResourceMetadata, ResourceRequestParams, ResourceTemplate, ResourceTemplateReference, ResourceTemplateType, ResourceUpdatedNotification, ResourceUpdatedNotificationParams, type ResponseMessage, Result, type ResultMessage, ResultTypeMap, Role, Root, RootsListChangedNotification, SUPPORTED_PROTOCOL_VERSIONS, SamplingContent, SamplingMessage, SamplingMessageContentBlock, SdkError, SdkErrorCode, Server, ServerCapabilities, type ServerContext, ServerNotification, type ServerOptions, ServerRequest, ServerResult, SetLevelRequest, SetLevelRequestParams, SingleSelectEnumSchema, type StandardSchemaWithJSON, StdioServerTransport, type StreamId, StringSchema, SubscribeRequest, SubscribeRequestParams, Task, TaskAugmentedRequestParams, type TaskContext, type TaskCreatedMessage, TaskCreationParams, type TaskManagerOptions, type TaskMessageQueue, TaskMetadata, type TaskRequestHandler, type TaskRequestOptions, type TaskServerContext, TaskStatus, type TaskStatusMessage, TaskStatusNotification, TaskStatusNotificationParams, type TaskStore, type TaskToolExecution, TextContent, TextResourceContents, TitledMultiSelectEnumSchema, TitledSingleSelectEnumSchema, Tool, ToolAnnotations, type ToolCallback, ToolChoice, ToolExecution, ToolListChangedNotification, ToolResultContent, type ToolTaskHandler, ToolUseContent, type Transport, type TransportSendOptions, UnsubscribeRequest, UnsubscribeRequestParams, UntitledMultiSelectEnumSchema, UntitledSingleSelectEnumSchema, UriTemplate, UrlElicitationRequiredError, type Variables, WebStandardStreamableHTTPServerTransport, type WebStandardStreamableHTTPServerTransportOptions, assertClientRequestTaskCapability, assertCompleteRequestPrompt, assertCompleteRequestResourceTemplate, assertToolsCallTaskCapability, checkResourceAllowed, completable, createFetchWithInit, deserializeMessage, fromJsonSchema, getDisplayName, hostHeaderValidationResponse, isCompletable, isInitializeRequest, isInitializedNotification, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResultResponse, isTaskAugmentedRequestParams, isTerminal, type jsonSchemaValidator, localhostAllowedHostnames, parseJSONRPCMessage, resourceUrlFromServerUrl, serializeMessage, takeResult, toArrayAsync, validateHostHeader };
+export { type AjvJsonSchemaValidator, Annotations, type AnyToolHandler, AudioContent, AuthInfo, type AuthorizationServerMetadata, BAGGAGE_META_KEY, type BaseContext, BaseMetadata, type BaseToolCallback, BlobResourceContents, BooleanSchema, CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, type CacheHint, type CacheScope, CallToolRequest, CallToolRequestParams, CallToolResult, CancelTaskRequest, CancelTaskResult, CancelledNotification, CancelledNotificationParams, type CfWorkerJsonSchemaValidator, type CfWorkerSchemaDraft, ClientCapabilities, type ClientContext, ClientNotification, ClientRequest, ClientResult, CompatibilityCallToolResult, type CompletableSchema, type CompleteCallback, CompleteRequest, CompleteRequestParams, CompleteRequestPrompt, CompleteRequestResourceTemplate, type CompleteResourceTemplateCallback, CompleteResult, ContentBlock, type CreateMcpHandlerOptions, CreateMessageRequest, CreateMessageRequestParams, CreateMessageRequestParamsBase, CreateMessageRequestParamsWithTools, CreateMessageResult, CreateMessageResultWithTools, CreateTaskResult, Cursor, DEFAULT_NEGOTIATED_PROTOCOL_VERSION, DEFAULT_REQUEST_TIMEOUT_MSEC, DiscoverRequest, DiscoverResult, ElicitRequest, ElicitRequestFormParams, ElicitRequestParams, ElicitRequestURLParams, ElicitResult, ElicitationCompleteNotification, ElicitationCompleteNotificationParams, EmbeddedResource, EmptyResult, EnumSchema, type EventId, type EventStore, type FetchLike, GetPromptRequest, GetPromptRequestParams, GetPromptResult, GetTaskPayloadRequest, GetTaskPayloadResult, GetTaskRequest, GetTaskResult, type HandleRequestOptions, HandlerResultTypeMap, type HostHeaderValidationResult, INTERNAL_ERROR, INVALID_PARAMS, INVALID_REQUEST, Icon, Icons, type IdJagTokenExchangeResponse, ImageContent, Implementation, InMemoryServerEventBus, InMemoryTransport, type InboundClassificationOutcome, type InboundHttpRequest, type InboundLadderRejection, type InboundLegacyRoute, type InboundLegacyRouteReason, type InboundModernRoute, type InboundValidationRung, InitializeRequest, InitializeRequestParams, InitializeResult, InitializedNotification, InputRequest, InputRequests, InputRequiredResult, type InputRequiredSpec, InputResponse, type InputResponseView, InputResponses, InternalError, InvalidParamsError, InvalidRequestError, JSONArray, JSONObject, JSONRPCErrorResponse, JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, JSONRPCResultResponse, JSONRPC_VERSION, JSONValue, type JsonSchemaType, type JsonSchemaValidator, type JsonSchemaValidatorResult, LATEST_PROTOCOL_VERSION, LOG_LEVEL_META_KEY, type LegacyHttpHandler, LegacyTitledEnumSchema, ListChangedCallback, ListChangedHandlers, ListChangedOptions, ListPromptsRequest, ListPromptsResult, ListResourceTemplatesRequest, ListResourceTemplatesResult, type ListResourcesCallback, ListResourcesRequest, ListResourcesResult, ListRootsRequest, ListRootsResult, ListTasksRequest, ListTasksResult, ListToolsRequest, ListToolsResult, LoggingLevel, LoggingMessageNotification, LoggingMessageNotificationParams, METHOD_NOT_FOUND, type McpHandlerRequestOptions, type McpHttpHandler, type McpRequestContext, McpServer, type McpServerFactory, MessageClassification, MessageExtraInfo, MetaObject, MethodNotFoundError, MissingRequiredClientCapabilityError, MissingRequiredClientCapabilityErrorData, ModelHint, ModelPreferences, MultiSelectEnumSchema, Notification, NotificationMethod, type NotificationOptions, NotificationParams, NotificationTypeMap, NumberSchema, type OAuthClientInformation, type OAuthClientInformationFull, type OAuthClientInformationMixed, type OAuthClientMetadata, type OAuthClientRegistrationError, OAuthError, OAuthErrorCode, type OAuthErrorResponse, type OAuthMetadata, type OAuthProtectedResourceMetadata, type OAuthTokenRevocationRequest, type OAuthTokens, type OpenIdProviderDiscoveryMetadata, type OpenIdProviderMetadata, type OriginValidationResult, PARSE_ERROR, PROTOCOL_VERSION_META_KEY, PaginatedRequest, PaginatedRequestParams, PaginatedResult, ParseError, PerRequestHTTPServerTransport, type PerRequestHTTPServerTransportOptions, type PerRequestMessageExtra, type PerRequestResponseMode, PingRequest, PrimitiveSchemaDefinition, Progress, type ProgressCallback, ProgressNotification, ProgressNotificationParams, ProgressToken, Prompt, PromptArgument, type PromptCallback, PromptListChangedNotification, PromptMessage, PromptReference, type ProtocolEra, ProtocolError, ProtocolErrorCode, type ProtocolOptions, RELATED_TASK_META_KEY, ReadBuffer, type ReadResourceCallback, ReadResourceRequest, ReadResourceRequestParams, ReadResourceResult, type ReadResourceTemplateCallback, type RegisteredPrompt, type RegisteredResource, type RegisteredResourceTemplate, type RegisteredTool, RelatedTaskMetadata, Request$1 as Request, type RequestHandlerSchemas, RequestId, RequestMeta, RequestMetaEnvelope, RequestMetaObject, RequestMethod, type RequestOptions, RequestParams, type RequestStateAccessor, type RequestStateCodec, type RequestStateCodecOptions, RequestTypeMap, Resource, ResourceContents, ResourceLink, ResourceListChangedNotification, type ResourceMetadata, ResourceNotFoundError, ResourceRequestParams, ResourceTemplate, ResourceTemplateReference, ResourceTemplateType, ResourceUpdatedNotification, ResourceUpdatedNotificationParams, Result, ResultTypeMap, Role, Root, RootsListChangedNotification, STDIO_DEFAULT_MAX_BUFFER_SIZE, SUBSCRIPTION_ID_META_KEY, SUPPORTED_PROTOCOL_VERSIONS, SamplingContent, SamplingMessage, SamplingMessageContentBlock, SdkError, SdkErrorCode, SdkHttpError, type SdkHttpErrorData, Server, ServerCapabilities, type ServerContext, type ServerEvent, type ServerEventBus, ServerNotification, type ServerNotifier, type ServerOptions, ServerRequest, ServerResult, SetLevelRequest, SetLevelRequestParams, SingleSelectEnumSchema, type SpecTypeName, type SpecTypes, type StandardSchemaV1, type StandardSchemaV1Sync, type StandardSchemaWithJSON, type StoredOAuthClientInformation, type StoredOAuthTokens, type StreamId, StringSchema, SubscribeRequest, SubscribeRequestParams, SubscriptionFilter, SubscriptionsAcknowledgedNotification, SubscriptionsAcknowledgedNotificationParams, SubscriptionsListenRequest, SubscriptionsListenRequestParams, SubscriptionsListenResult, SubscriptionsListenResultMeta, TRACEPARENT_META_KEY, TRACESTATE_META_KEY, Task, TaskAugmentedRequestParams, TaskCreationParams, TaskMetadata, TaskStatus, TaskStatusNotification, TaskStatusNotificationParams, TextContent, TextResourceContents, TitledMultiSelectEnumSchema, TitledSingleSelectEnumSchema, Tool, ToolAnnotations, type ToolCallback, ToolChoice, ToolExecution, ToolListChangedNotification, ToolResultContent, ToolUseContent, type Transport, type TransportSendOptions, UnsubscribeRequest, UnsubscribeRequestParams, UnsupportedProtocolVersionError, UnsupportedProtocolVersionErrorData, UntitledMultiSelectEnumSchema, UntitledSingleSelectEnumSchema, UriTemplate, UrlElicitationRequiredError, type Variables, WebStandardStreamableHTTPServerTransport, type WebStandardStreamableHTTPServerTransportOptions, acceptedContent, assertCompleteRequestPrompt, assertCompleteRequestResourceTemplate, checkResourceAllowed, classifyInboundRequest, completable, createFetchWithInit, createMcpHandler, createRequestStateCodec, deserializeMessage, fromJsonSchema, getDisplayName, hostHeaderValidationResponse, inputRequired, inputResponse, isCallToolResult, isCompletable, isInitializeRequest, isInitializedNotification, isInputRequiredResult, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse, isJSONRPCResultResponse, isLegacyRequest, isSpecType, isTaskAugmentedRequestParams, type jsonSchemaValidator, legacyStatelessFallback, localhostAllowedHostnames, localhostAllowedOrigins, originValidationResponse, parseJSONRPCMessage, resourceUrlFromServerUrl, serializeMessage, specTypeSchemas, validateHostHeader, validateOriginHeader };
 //# sourceMappingURL=index.d.mts.map