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

package/dist/index.d.mts

@@ -1,336 +1,1496 @@
-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 GetTaskPayloadResult, $n as TaskAugmentedRequestParams, $t as PaginatedRequestParams, A as CreateMessageRequestParams, An as ResourceTemplateReference, Ar as LATEST_PROTOCOL_VERSION, At as ListResourcesRequest, B as ElicitRequestFormParams, Bn as SamplingMessage, Bt as LoggingMessageNotificationParams, C as CompleteRequest, Cn as RequestParams, Cr as CLIENT_CAPABILITIES_META_KEY, Ct as ListChangedCallback, D as CompleteResult, Dn as ResourceLink, Dr as INVALID_PARAMS, Dt as ListPromptsResult, E as CompleteRequestResourceTemplate, En as ResourceContents, Er as INTERNAL_ERROR, Et as ListPromptsRequest, F as CreateTaskResult, Fn as ResultTypeMap, Fr as RELATED_TASK_META_KEY, Ft as ListTasksResult, G as ElicitationCompleteNotificationParams, Gn as ServerResult, Gt as ModelPreferences, H as ElicitRequestURLParams, Hn as ServerCapabilities, Ht as MetaObject, I as Cursor, In as Role, Ir as SUPPORTED_PROTOCOL_VERSIONS, It as ListToolsRequest, J as EnumSchema, Jn as SingleSelectEnumSchema, Jt as NotificationMethod, K as EmbeddedResource, Kn as SetLevelRequest, Kt as MultiSelectEnumSchema, L as DiscoverRequest, Ln as Root, Lr as TRACEPARENT_META_KEY, Lt as ListToolsResult, M as CreateMessageRequestParamsWithTools, Mn as ResourceUpdatedNotification, Mr as METHOD_NOT_FOUND, Mt as ListRootsRequest, N as CreateMessageResult, Nn as ResourceUpdatedNotificationParams, Nr as PARSE_ERROR, Nt as ListRootsResult, O as ContentBlock, On as ResourceListChangedNotification, Or as INVALID_REQUEST, Ot as ListResourceTemplatesRequest, P as CreateMessageResultWithTools, Pn as Result$1, Pr as PROTOCOL_VERSION_META_KEY, Pt as ListTasksRequest, Q as GetTaskPayloadRequest, Qn as Task, Qt as PaginatedRequest, R as DiscoverResult, Rn as RootsListChangedNotification, Rr as TRACESTATE_META_KEY, Rt as LoggingLevel, S as CompatibilityCallToolResult, Sn as RequestMethod, Sr as BAGGAGE_META_KEY, St as LegacyTitledEnumSchema, T as CompleteRequestPrompt, Tn as Resource, Tr as DEFAULT_NEGOTIATED_PROTOCOL_VERSION, Tt as ListChangedOptions, U as ElicitResult, Un as ServerNotification, Ut as MethodNotFoundError, V as ElicitRequestParams, Vn as SamplingMessageContentBlock, Vt as MessageExtraInfo, W as ElicitationCompleteNotification, Wn as ServerRequest, Wt as ModelHint, X as GetPromptRequestParams, Xn as SubscribeRequest, Xt as NotificationTypeMap, Y as GetPromptRequest, Yn as StringSchema, Yt as NotificationParams, Z as GetPromptResult, Zn as SubscribeRequestParams, Zt as NumberSchema, _ as CancelledNotificationParams, _n as Request$1, _r as UnsubscribeRequestParams, _t as JSONRPCNotification, a as Annotations, an as ProgressNotification, ar as TextContent, at as Implementation, b as ClientRequest, bn as RequestMetaEnvelope, br as UntitledSingleSelectEnumSchema, bt as JSONRPCResultResponse, c as BaseMetadata, cn as Prompt, cr as TitledSingleSelectEnumSchema, ct as InitializeResult, d as CallToolRequest, dn as PromptMessage, dr as ToolChoice, dt as InvalidParamsError, en as PaginatedResult, er as TaskCreationParams, et as GetTaskRequest, f as CallToolRequestParams, fn as PromptReference, fr as ToolExecution, ft as InvalidRequestError, g as CancelledNotification, gn as RelatedTaskMetadata, gr as UnsubscribeRequest, gt as JSONRPCMessage, h as CancelTaskResult, hn as ReadResourceResult, hr as ToolUseContent, ht as JSONRPCErrorResponse, i as createFetchWithInit, in as Progress, ir as TaskStatusNotificationParams, it as ImageContent, j as CreateMessageRequestParamsBase, jn as ResourceTemplateType, jr as LOG_LEVEL_META_KEY, jt as ListResourcesResult, k as CreateMessageRequest, kn as ResourceRequestParams, kr as JSONRPC_VERSION, kt as ListResourceTemplatesResult, l as BlobResourceContents, ln as PromptArgument, lr as Tool, lt as InitializedNotification, m as CancelTaskRequest, mn as ReadResourceRequestParams, mr as ToolResultContent, mt as JSONObject, n as Transport, nn as PingRequest, nr as TaskStatus, nt as Icon, o as AudioContent, on as ProgressNotificationParams, or as TextResourceContents, ot as InitializeRequest, p as CallToolResult, pn as ReadResourceRequest, pr as ToolListChangedNotification, pt as JSONArray, q as EmptyResult, qn as SetLevelRequestParams, qt as Notification, r as TransportSendOptions, rn as PrimitiveSchemaDefinition, rr as TaskStatusNotification, rt as Icons, s as AuthInfo, sn as ProgressToken, sr as TitledMultiSelectEnumSchema, st as InitializeRequestParams, t as FetchLike, tn as ParseError, tr as TaskMetadata, tt as GetTaskResult, u as BooleanSchema, un as PromptListChangedNotification, ur as ToolAnnotations, ut as InternalError, v as ClientCapabilities, vn as RequestId, vr as UnsupportedProtocolVersionErrorData, vt as JSONRPCRequest, w as CompleteRequestParams, wn as RequestTypeMap, wr as CLIENT_INFO_META_KEY, wt as ListChangedHandlers, x as ClientResult, xn as RequestMetaObject, xr as schemas_d_exports, xt as JSONValue, y as ClientNotification, yn as RequestMeta, yr as UntitledMultiSelectEnumSchema, yt as JSONRPCResponse, z as ElicitRequest, zn as SamplingContent, zt as LoggingMessageNotification } from "./transport-DMKhEchd.mjs";
+import { t as AjvJsonSchemaValidator } from "./ajvProvider-DZ_siXcF.mjs";
+import { i as jsonSchemaValidator, n as JsonSchemaValidator, r as JsonSchemaValidatorResult, t as JsonSchemaType } from "./types-R2RTIcjk.mjs";
+import { n as CfWorkerSchemaDraft, t as CfWorkerJsonSchemaValidator } from "./cfWorkerProvider-DUhk5Ewx.mjs";
+import * as z from "zod/v4";
+
+//#region ../core-internal/src/shared/auth.d.ts
 
-//#region src/server/completable.d.ts
-declare const COMPLETABLE_SYMBOL: unique symbol;
-type CompleteCallback<T extends StandardSchemaWithJSON = StandardSchemaWithJSON> = (value: StandardSchemaWithJSON.InferInput<T>, context?: {
-  arguments?: Record<string, string>;
-}) => StandardSchemaWithJSON.InferInput<T>[] | Promise<StandardSchemaWithJSON.InferInput<T>[]>;
-type CompletableMeta<T extends StandardSchemaWithJSON = StandardSchemaWithJSON> = {
-  complete: CompleteCallback<T>;
-};
-type CompletableSchema<T extends StandardSchemaWithJSON> = T & {
-  [COMPLETABLE_SYMBOL]: CompletableMeta<T>;
-};
 /**
- * Wraps a schema to provide autocompletion capabilities. Useful for, e.g., prompt arguments in MCP.
+ * RFC 9728 OAuth Protected Resource Metadata
+ */
+declare const OAuthProtectedResourceMetadataSchema: z.ZodObject<{
+  resource: z.ZodString;
+  authorization_servers: z.ZodOptional<z.ZodArray<z.ZodURL>>;
+  jwks_uri: z.ZodOptional<z.ZodString>;
+  scopes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  bearer_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  resource_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  resource_name: z.ZodOptional<z.ZodString>;
+  resource_documentation: z.ZodOptional<z.ZodString>;
+  resource_policy_uri: z.ZodOptional<z.ZodString>;
+  resource_tos_uri: z.ZodOptional<z.ZodString>;
+  tls_client_certificate_bound_access_tokens: z.ZodOptional<z.ZodBoolean>;
+  authorization_details_types_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  dpop_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  dpop_bound_access_tokens_required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * RFC 8414 OAuth 2.0 Authorization Server Metadata
+ */
+declare const OAuthMetadataSchema: z.ZodObject<{
+  issuer: z.ZodString;
+  authorization_endpoint: z.ZodURL;
+  token_endpoint: z.ZodURL;
+  registration_endpoint: z.ZodOptional<z.ZodURL>;
+  scopes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  response_types_supported: z.ZodArray<z.ZodString>;
+  response_modes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  grant_types_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  token_endpoint_auth_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  token_endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  service_documentation: z.ZodOptional<z.ZodURL>;
+  revocation_endpoint: z.ZodOptional<z.ZodURL>;
+  revocation_endpoint_auth_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  revocation_endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  introspection_endpoint: z.ZodOptional<z.ZodString>;
+  introspection_endpoint_auth_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  introspection_endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  code_challenge_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  client_id_metadata_document_supported: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * OpenID Connect Discovery 1.0 Provider Metadata
  *
- * @example
- * ```ts source="./completable.examples.ts#completable_basicUsage"
- * server.registerPrompt(
- *     'review-code',
- *     {
- *         title: 'Code Review',
- *         argsSchema: z.object({
- *             language: completable(z.string().describe('Programming language'), value =>
- *                 ['typescript', 'javascript', 'python', 'rust', 'go'].filter(lang => lang.startsWith(value))
- *             )
- *         })
- *     },
- *     ({ language }) => ({
- *         messages: [
- *             {
- *                 role: 'user' as const,
- *                 content: {
- *                     type: 'text' as const,
- *                     text: `Review this ${language} code.`
- *                 }
- *             }
- *         ]
- *     })
- * );
- * ```
+ * @see https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderMetadata
+ */
+declare const OpenIdProviderMetadataSchema: z.ZodObject<{
+  issuer: z.ZodString;
+  authorization_endpoint: z.ZodURL;
+  token_endpoint: z.ZodURL;
+  userinfo_endpoint: z.ZodOptional<z.ZodURL>;
+  jwks_uri: z.ZodURL;
+  registration_endpoint: z.ZodOptional<z.ZodURL>;
+  scopes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  response_types_supported: z.ZodArray<z.ZodString>;
+  response_modes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  grant_types_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  acr_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  subject_types_supported: z.ZodArray<z.ZodString>;
+  id_token_signing_alg_values_supported: z.ZodArray<z.ZodString>;
+  id_token_encryption_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  id_token_encryption_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  userinfo_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  userinfo_encryption_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  userinfo_encryption_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  request_object_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  request_object_encryption_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  request_object_encryption_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  token_endpoint_auth_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  token_endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  display_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  claim_types_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  claims_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  service_documentation: z.ZodOptional<z.ZodString>;
+  claims_locales_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  ui_locales_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  claims_parameter_supported: z.ZodOptional<z.ZodBoolean>;
+  request_parameter_supported: z.ZodOptional<z.ZodBoolean>;
+  request_uri_parameter_supported: z.ZodOptional<z.ZodBoolean>;
+  require_request_uri_registration: z.ZodOptional<z.ZodBoolean>;
+  op_policy_uri: z.ZodOptional<z.ZodURL>;
+  op_tos_uri: z.ZodOptional<z.ZodURL>;
+  client_id_metadata_document_supported: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * OpenID Connect Discovery metadata that may include OAuth 2.0 fields
+ * This schema represents the real-world scenario where OIDC providers
+ * return a mix of OpenID Connect and OAuth 2.0 metadata fields
+ */
+declare const OpenIdProviderDiscoveryMetadataSchema: z.ZodObject<{
+  code_challenge_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  issuer: z.ZodString;
+  authorization_endpoint: z.ZodURL;
+  token_endpoint: z.ZodURL;
+  userinfo_endpoint: z.ZodOptional<z.ZodURL>;
+  jwks_uri: z.ZodURL;
+  registration_endpoint: z.ZodOptional<z.ZodURL>;
+  scopes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  response_types_supported: z.ZodArray<z.ZodString>;
+  response_modes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  grant_types_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  acr_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  subject_types_supported: z.ZodArray<z.ZodString>;
+  id_token_signing_alg_values_supported: z.ZodArray<z.ZodString>;
+  id_token_encryption_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  id_token_encryption_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  userinfo_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  userinfo_encryption_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  userinfo_encryption_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  request_object_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  request_object_encryption_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  request_object_encryption_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  token_endpoint_auth_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  token_endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  display_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  claim_types_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  claims_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  service_documentation: z.ZodOptional<z.ZodString>;
+  claims_locales_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  ui_locales_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  claims_parameter_supported: z.ZodOptional<z.ZodBoolean>;
+  request_parameter_supported: z.ZodOptional<z.ZodBoolean>;
+  request_uri_parameter_supported: z.ZodOptional<z.ZodBoolean>;
+  require_request_uri_registration: z.ZodOptional<z.ZodBoolean>;
+  op_policy_uri: z.ZodOptional<z.ZodURL>;
+  op_tos_uri: z.ZodOptional<z.ZodURL>;
+  client_id_metadata_document_supported: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * OAuth 2.1 token response
+ */
+declare const OAuthTokensSchema: z.ZodObject<{
+  access_token: z.ZodString;
+  id_token: z.ZodOptional<z.ZodString>;
+  token_type: z.ZodString;
+  expires_in: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  scope: z.ZodOptional<z.ZodString>;
+  refresh_token: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * RFC 8693 §2.2.1 Token Exchange response for ID-JAG tokens.
  *
- * @see {@linkcode server/mcp.McpServer.registerPrompt | McpServer.registerPrompt} for using completable schemas in prompt argument definitions
+ * `token_type` is intentionally optional: per RFC 8693 §2.2.1 it is informational when
+ * the issued token is not an access token, and per RFC 6749 §5.1 it is case-insensitive,
+ * so strict checking rejects conformant IdPs.
  */
-declare function completable<T extends StandardSchemaWithJSON>(schema: T, complete: CompleteCallback<T>): CompletableSchema<T>;
+declare const IdJagTokenExchangeResponseSchema: z.ZodObject<{
+  issued_token_type: z.ZodLiteral<"urn:ietf:params:oauth:token-type:id-jag">;
+  access_token: z.ZodString;
+  token_type: z.ZodOptional<z.ZodString>;
+  expires_in: z.ZodOptional<z.ZodNumber>;
+  scope: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type IdJagTokenExchangeResponse = z.infer<typeof IdJagTokenExchangeResponseSchema>;
 /**
- * Checks if a schema is completable (has completion metadata).
+ * OAuth 2.1 error response
  */
-declare function isCompletable(schema: unknown): schema is CompletableSchema<StandardSchemaWithJSON>;
-//#endregion
-//#region src/experimental/tasks/interfaces.d.ts
+declare const OAuthErrorResponseSchema: z.ZodObject<{
+  error: z.ZodString;
+  error_description: z.ZodOptional<z.ZodString>;
+  error_uri: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /**
- * Handler for creating a task.
- * @experimental
+ * RFC 7591 OAuth 2.0 Dynamic Client Registration metadata
  */
-type CreateTaskRequestHandler<SendResultT extends Result, Args extends StandardSchemaWithJSON | undefined = undefined> = BaseToolCallback<SendResultT, CreateTaskServerContext, Args>;
+declare const OAuthClientMetadataSchema: z.ZodObject<{
+  redirect_uris: z.ZodArray<z.ZodURL>;
+  token_endpoint_auth_method: z.ZodOptional<z.ZodString>;
+  grant_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  response_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  client_name: z.ZodOptional<z.ZodString>;
+  client_uri: z.ZodOptional<z.ZodURL>;
+  logo_uri: z.ZodUnion<[z.ZodOptional<z.ZodURL>, z.ZodPipe<z.ZodLiteral<"">, z.ZodTransform<undefined, "">>]>;
+  scope: z.ZodOptional<z.ZodString>;
+  contacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  tos_uri: z.ZodUnion<[z.ZodOptional<z.ZodURL>, z.ZodPipe<z.ZodLiteral<"">, z.ZodTransform<undefined, "">>]>;
+  policy_uri: z.ZodOptional<z.ZodString>;
+  jwks_uri: z.ZodOptional<z.ZodURL>;
+  jwks: z.ZodOptional<z.ZodAny>;
+  software_id: z.ZodOptional<z.ZodString>;
+  software_version: z.ZodOptional<z.ZodString>;
+  software_statement: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /**
- * Handler for task operations (`get`, `getResult`).
- * @experimental
+ * RFC 7591 OAuth 2.0 Dynamic Client Registration client information
  */
-type TaskRequestHandler<SendResultT extends Result, Args extends StandardSchemaWithJSON | undefined = undefined> = BaseToolCallback<SendResultT, TaskServerContext, Args>;
+declare const OAuthClientInformationSchema: z.ZodObject<{
+  client_id: z.ZodString;
+  client_secret: z.ZodOptional<z.ZodString>;
+  client_id_issued_at: z.ZodOptional<z.ZodNumber>;
+  client_secret_expires_at: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 /**
- * 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
+ * RFC 7591 OAuth 2.0 Dynamic Client Registration full response (client information plus metadata)
+ */
+declare const OAuthClientInformationFullSchema: z.ZodObject<{
+  redirect_uris: z.ZodArray<z.ZodURL>;
+  token_endpoint_auth_method: z.ZodOptional<z.ZodString>;
+  grant_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  response_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  client_name: z.ZodOptional<z.ZodString>;
+  client_uri: z.ZodOptional<z.ZodURL>;
+  logo_uri: z.ZodUnion<[z.ZodOptional<z.ZodURL>, z.ZodPipe<z.ZodLiteral<"">, z.ZodTransform<undefined, "">>]>;
+  scope: z.ZodOptional<z.ZodString>;
+  contacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  tos_uri: z.ZodUnion<[z.ZodOptional<z.ZodURL>, z.ZodPipe<z.ZodLiteral<"">, z.ZodTransform<undefined, "">>]>;
+  policy_uri: z.ZodOptional<z.ZodString>;
+  jwks_uri: z.ZodOptional<z.ZodURL>;
+  jwks: z.ZodOptional<z.ZodAny>;
+  software_id: z.ZodOptional<z.ZodString>;
+  software_version: z.ZodOptional<z.ZodString>;
+  software_statement: z.ZodOptional<z.ZodString>;
+  client_id: z.ZodString;
+  client_secret: z.ZodOptional<z.ZodString>;
+  client_id_issued_at: z.ZodOptional<z.ZodNumber>;
+  client_secret_expires_at: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * RFC 7591 OAuth 2.0 Dynamic Client Registration error response
+ */
+declare const OAuthClientRegistrationErrorSchema: z.ZodObject<{
+  error: z.ZodString;
+  error_description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * RFC 7009 OAuth 2.0 Token Revocation request
  */
-interface ToolTaskHandler<Args extends StandardSchemaWithJSON | undefined = undefined> {
+declare const OAuthTokenRevocationRequestSchema: z.ZodObject<{
+  token: z.ZodString;
+  token_type_hint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type OAuthMetadata = z.infer<typeof OAuthMetadataSchema>;
+type OpenIdProviderMetadata = z.infer<typeof OpenIdProviderMetadataSchema>;
+type OpenIdProviderDiscoveryMetadata = z.infer<typeof OpenIdProviderDiscoveryMetadataSchema>;
+type OAuthTokens = z.infer<typeof OAuthTokensSchema>;
+type OAuthErrorResponse = z.infer<typeof OAuthErrorResponseSchema>;
+type OAuthClientMetadata = z.infer<typeof OAuthClientMetadataSchema>;
+type OAuthClientInformation = z.infer<typeof OAuthClientInformationSchema>;
+type OAuthClientInformationFull = z.infer<typeof OAuthClientInformationFullSchema>;
+type OAuthClientInformationMixed = OAuthClientInformation | OAuthClientInformationFull;
+type OAuthClientRegistrationError = z.infer<typeof OAuthClientRegistrationErrorSchema>;
+type OAuthTokenRevocationRequest = z.infer<typeof OAuthTokenRevocationRequestSchema>;
+type OAuthProtectedResourceMetadata = z.infer<typeof OAuthProtectedResourceMetadataSchema>;
+type AuthorizationServerMetadata = OAuthMetadata | OpenIdProviderDiscoveryMetadata;
+//#endregion
+//#region ../core-internal/src/auth/errors.d.ts
+/**
+ * OAuth error codes as defined by {@link https://datatracker.ietf.org/doc/html/rfc6749#section-5.2 | RFC 6749}
+ * and extensions.
+ */
+declare enum OAuthErrorCode {
   /**
-   * Called on the initial `tools/call` request.
-   *
-   * Creates a task via `ctx.task.store.createTask(...)`, starts any
-   * background work, and returns the task object.
+   * The request is missing a required parameter, includes an invalid parameter value,
+   * includes a parameter more than once, or is otherwise malformed.
+   */
+  InvalidRequest = "invalid_request",
+  /**
+   * Client authentication failed (e.g., unknown client, no client authentication included,
+   * or unsupported authentication method).
+   */
+  InvalidClient = "invalid_client",
+  /**
+   * The provided authorization grant or refresh token is invalid, expired, revoked,
+   * does not match the redirection URI used in the authorization request, or was issued to another client.
    */
-  createTask: CreateTaskRequestHandler<CreateTaskResult, Args>;
+  InvalidGrant = "invalid_grant",
   /**
-   * Handler for `tasks/get` requests.
+   * The authenticated client is not authorized to use this authorization grant type.
    */
-  getTask: TaskRequestHandler<GetTaskResult, Args>;
+  UnauthorizedClient = "unauthorized_client",
   /**
-   * Handler for `tasks/result` requests.
+   * The authorization grant type is not supported by the authorization server.
    */
-  getTaskResult: TaskRequestHandler<CallToolResult, Args>;
+  UnsupportedGrantType = "unsupported_grant_type",
+  /**
+   * The requested scope is invalid, unknown, malformed, or exceeds the scope granted by the resource owner.
+   */
+  InvalidScope = "invalid_scope",
+  /**
+   * The resource owner or authorization server denied the request.
+   */
+  AccessDenied = "access_denied",
+  /**
+   * The authorization server encountered an unexpected condition that prevented it from fulfilling the request.
+   */
+  ServerError = "server_error",
+  /**
+   * The authorization server is currently unable to handle the request due to temporary overloading or maintenance.
+   */
+  TemporarilyUnavailable = "temporarily_unavailable",
+  /**
+   * The authorization server does not support obtaining an authorization code using this method.
+   */
+  UnsupportedResponseType = "unsupported_response_type",
+  /**
+   * The authorization server does not support the requested token type.
+   */
+  UnsupportedTokenType = "unsupported_token_type",
+  /**
+   * The access token provided is expired, revoked, malformed, or invalid for other reasons.
+   */
+  InvalidToken = "invalid_token",
+  /**
+   * The HTTP method used is not allowed for this endpoint. (Custom, non-standard error)
+   */
+  MethodNotAllowed = "method_not_allowed",
+  /**
+   * Rate limit exceeded. (Custom, non-standard error based on RFC 6585)
+   */
+  TooManyRequests = "too_many_requests",
+  /**
+   * The client metadata is invalid. (Custom error for dynamic client registration - RFC 7591)
+   */
+  InvalidClientMetadata = "invalid_client_metadata",
+  /**
+   * The request requires higher privileges than provided by the access token.
+   */
+  InsufficientScope = "insufficient_scope",
+  /**
+   * The requested resource is invalid, missing, unknown, or malformed. (Custom error for resource indicators - RFC 8707)
+   */
+  InvalidTarget = "invalid_target",
+}
+/**
+ * OAuth error class for all OAuth-related errors.
+ */
+declare class OAuthError extends Error {
+  readonly code: OAuthErrorCode | string;
+  readonly errorUri?: string | undefined;
+  constructor(code: OAuthErrorCode | string, message: string, errorUri?: string | undefined);
+  /**
+   * Converts the error to a standard OAuth error response object.
+   */
+  toResponseObject(): OAuthErrorResponse;
+  /**
+   * Creates an {@linkcode OAuthError} from an OAuth error response.
+   */
+  static fromResponse(response: OAuthErrorResponse): OAuthError;
 }
 //#endregion
-//#region src/experimental/tasks/mcpServer.d.ts
+//#region ../core-internal/src/errors/sdkErrors.d.ts
 /**
- * Experimental task features for {@linkcode McpServer}.
+ * Error codes for SDK errors (local errors that never cross the wire).
+ * Unlike {@linkcode ProtocolErrorCode} which uses numeric JSON-RPC codes, `SdkErrorCode` uses
+ * descriptive string values for better developer experience.
  *
- * Access via `server.experimental.tasks`:
- * ```typescript
- * server.experimental.tasks.registerToolTask('long-running', config, handler);
+ * These errors are thrown locally by the SDK and are never serialized as
+ * JSON-RPC error responses.
+ */
+declare enum SdkErrorCode {
+  /** Transport is not connected */
+  NotConnected = "NOT_CONNECTED",
+  /** Transport is already connected */
+  AlreadyConnected = "ALREADY_CONNECTED",
+  /** Protocol is not initialized */
+  NotInitialized = "NOT_INITIALIZED",
+  /** Required capability is not supported by the remote side */
+  CapabilityNotSupported = "CAPABILITY_NOT_SUPPORTED",
+  /** Request timed out waiting for response */
+  RequestTimeout = "REQUEST_TIMEOUT",
+  /** Connection was closed */
+  ConnectionClosed = "CONNECTION_CLOSED",
+  /** Failed to send message */
+  SendFailed = "SEND_FAILED",
+  /** Response result failed local schema validation */
+  InvalidResult = "INVALID_RESULT",
+  ClientHttpNotImplemented = "CLIENT_HTTP_NOT_IMPLEMENTED",
+  ClientHttpAuthentication = "CLIENT_HTTP_AUTHENTICATION",
+  ClientHttpForbidden = "CLIENT_HTTP_FORBIDDEN",
+  ClientHttpUnexpectedContent = "CLIENT_HTTP_UNEXPECTED_CONTENT",
+  ClientHttpFailedToOpenStream = "CLIENT_HTTP_FAILED_TO_OPEN_STREAM",
+  ClientHttpFailedToTerminateSession = "CLIENT_HTTP_FAILED_TO_TERMINATE_SESSION",
+}
+/**
+ * SDK errors are local errors that never cross the wire.
+ * They are distinct from {@linkcode ProtocolError} which represents JSON-RPC protocol errors
+ * that are serialized and sent as error responses.
+ *
+ * @example
+ * ```ts source="./sdkErrors.examples.ts#SdkError_basicUsage"
+ * try {
+ *     // Throwing an SDK error
+ *     throw new SdkError(SdkErrorCode.NotConnected, 'Transport is not connected');
+ * } catch (error) {
+ *     // Checking error type by code
+ *     if (error instanceof SdkError && error.code === SdkErrorCode.RequestTimeout) {
+ *         // Handle timeout
+ *     }
+ * }
+ * ```
+ */
+declare class SdkError extends Error {
+  readonly code: SdkErrorCode;
+  readonly data?: unknown | undefined;
+  constructor(code: SdkErrorCode, message: string, data?: unknown | undefined);
+}
+/**
+ * Typed shape for HTTP error data carried by {@linkcode SdkHttpError}.
+ */
+interface SdkHttpErrorData {
+  status: number;
+  statusText?: string;
+  [key: string]: unknown;
+}
+/**
+ * An {@linkcode SdkError} subclass for HTTP transport failures.
+ *
+ * Thrown by the streamable HTTP transport when the server responds with a
+ * non-OK status code. Narrows {@linkcode SdkError.data | data} to
+ * {@linkcode SdkHttpErrorData} so consumers can inspect the HTTP status
+ * without unsafe casting.
+ *
+ * @example
+ * ```ts source="./sdkErrors.examples.ts#SdkHttpError_basicUsage"
+ * if (error instanceof SdkHttpError) {
+ *     console.log(error.status); // number
+ *     console.log(error.statusText); // string | undefined
+ * }
  * ```
+ */
+declare class SdkHttpError extends SdkError {
+  readonly data: SdkHttpErrorData;
+  constructor(code: SdkErrorCode, message: string, data: SdkHttpErrorData);
+  get status(): number;
+  get statusText(): string | undefined;
+}
+//#endregion
+//#region ../core-internal/src/shared/authUtils.d.ts
+/**
+ * Utilities for handling OAuth resource URIs.
+ */
+/**
+ * Converts a server URL to a resource URL by removing the fragment.
+ * {@link https://datatracker.ietf.org/doc/html/rfc8707#section-2 | RFC 8707 section 2}
+ * states that resource URIs "MUST NOT include a fragment component".
+ * Keeps everything else unchanged (scheme, domain, port, path, query).
+ */
+declare function resourceUrlFromServerUrl(url: URL | string): URL;
+/**
+ * Checks if a requested resource URL matches a configured resource URL.
+ * A requested resource matches if it has the same scheme, domain, port,
+ * and its path starts with the configured resource's path.
  *
- * @experimental
+ * @param options - The options object
+ * @param options.requestedResource - The resource URL being requested
+ * @param options.configuredResource - The resource URL that has been configured
+ * @returns true if the requested resource matches the configured resource, false otherwise
+ */
+declare function checkResourceAllowed({
+  requestedResource,
+  configuredResource
+}: {
+  requestedResource: URL | string;
+  configuredResource: URL | string;
+}): boolean;
+//#endregion
+//#region ../core-internal/src/types/enums.d.ts
+/**
+ * Error codes for protocol errors that cross the wire as JSON-RPC error responses.
+ * These follow the JSON-RPC specification and MCP-specific extensions.
  */
-declare class ExperimentalMcpServerTasks {
-  private readonly _mcpServer;
-  constructor(_mcpServer: McpServer);
+declare enum ProtocolErrorCode {
+  ParseError = -32700,
+  InvalidRequest = -32600,
+  MethodNotFound = -32601,
+  InvalidParams = -32602,
+  InternalError = -32603,
+  ResourceNotFound = -32002,
   /**
-   * 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
+   * Processing the request requires a capability the client did not declare
+   * in the request's `clientCapabilities` (protocol revision 2026-07-28).
    */
-  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;
+  MissingRequiredClientCapability = -32003,
+  /**
+   * The request's protocol version is unknown to the server or unsupported
+   * by it (protocol revision 2026-07-28).
+   */
+  UnsupportedProtocolVersion = -32004,
+  UrlElicitationRequired = -32042,
 }
 //#endregion
-//#region src/experimental/tasks/server.d.ts
+//#region ../core-internal/src/types/errors.d.ts
+/**
+ * Protocol errors are JSON-RPC errors that cross the wire as error responses.
+ * They use numeric error codes from the {@linkcode ProtocolErrorCode} enum.
+ */
+declare class ProtocolError extends Error {
+  readonly code: number;
+  readonly data?: unknown | undefined;
+  constructor(code: number, message: string, data?: unknown | undefined);
+  /**
+   * Factory method to create the appropriate error type based on the error code and data
+   */
+  static fromError(code: number, message: string, data?: unknown): ProtocolError;
+}
+/**
+ * Specialized error type when a tool requires a URL mode elicitation.
+ * This makes it nicer for the client to handle since there is specific data to work with instead of just a code to check against.
+ */
+declare class UrlElicitationRequiredError extends ProtocolError {
+  constructor(elicitations: ElicitRequestURLParams[], message?: string);
+  get elicitations(): ElicitRequestURLParams[];
+}
+/**
+ * Error type for the `-32004` UnsupportedProtocolVersion protocol error (protocol
+ * revision 2026-07-28): the request's protocol version is unknown to the server or
+ * unsupported by it.
+ *
+ * The error data lists the protocol versions the receiver supports (`supported`),
+ * so the sender can choose a mutually supported version and retry, and echoes the
+ * version that was requested (`requested`).
+ */
+declare class UnsupportedProtocolVersionError extends ProtocolError {
+  constructor(data: UnsupportedProtocolVersionErrorData, message?: string);
+  /**
+   * Protocol versions the receiver supports.
+   */
+  get supported(): string[];
+  /**
+   * The protocol version that was requested.
+   */
+  get requested(): string;
+}
+//#endregion
+//#region ../core-internal/src/types/guards.d.ts
+/**
+ * Validates and parses an unknown value as a JSON-RPC message.
+ *
+ * Use this to validate incoming messages in custom transport implementations.
+ * Throws if the value does not conform to the JSON-RPC message schema.
+ *
+ * @param value - The value to validate (typically a parsed JSON object).
+ * @returns The validated {@linkcode JSONRPCMessage}.
+ * @throws If validation fails.
+ */
+declare function parseJSONRPCMessage(value: unknown): JSONRPCMessage;
+declare const isJSONRPCRequest: (value: unknown) => value is JSONRPCRequest;
+declare const isJSONRPCNotification: (value: unknown) => value is JSONRPCNotification;
+/**
+ * Checks if a value is a valid {@linkcode JSONRPCResultResponse}.
+ * @param value - The value to check.
+ *
+ * @returns True if the value is a valid {@linkcode JSONRPCResultResponse}, false otherwise.
+ */
+declare const isJSONRPCResultResponse: (value: unknown) => value is JSONRPCResultResponse;
+/**
+ * Checks if a value is a valid {@linkcode JSONRPCErrorResponse}.
+ * @param value - The value to check.
+ *
+ * @returns True if the value is a valid {@linkcode JSONRPCErrorResponse}, false otherwise.
+ */
+declare const isJSONRPCErrorResponse: (value: unknown) => value is JSONRPCErrorResponse;
+/**
+ * Checks if a value is a valid {@linkcode JSONRPCResponse} (either a result or error response).
+ * @param value - The value to check.
+ *
+ * @returns True if the value is a valid {@linkcode JSONRPCResponse}, false otherwise.
+ */
+declare const isJSONRPCResponse: (value: unknown) => value is JSONRPCResponse;
+/**
+ * Checks if a value is a valid {@linkcode CallToolResult}.
+ * @param value - The value to check.
+ *
+ * @returns True if the value is a valid {@linkcode CallToolResult}, false otherwise.
+ */
+declare const isCallToolResult: (value: unknown) => value is CallToolResult;
+/**
+ * Checks if a value is a valid {@linkcode TaskAugmentedRequestParams}.
+ * @param value - The value to check.
+ *
+ * @returns True if the value is a valid {@linkcode TaskAugmentedRequestParams}, false otherwise.
+ */
+declare const isTaskAugmentedRequestParams: (value: unknown) => value is TaskAugmentedRequestParams;
+declare const isInitializeRequest: (value: unknown) => value is InitializeRequest;
+declare const isInitializedNotification: (value: unknown) => value is InitializedNotification;
+declare function assertCompleteRequestPrompt(request: CompleteRequest): asserts request is CompleteRequestPrompt;
+declare function assertCompleteRequestResourceTemplate(request: CompleteRequest): asserts request is CompleteRequestResourceTemplate;
+//#endregion
+//#region ../core-internal/src/util/standardSchema.d.ts
+/**
+ * Standard Schema utilities for user-provided schemas.
+ * Supports Zod v4, Valibot, ArkType, and other Standard Schema implementations.
+ * @see https://standardschema.dev
+ */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  readonly '~standard': StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  interface Props<Input = unknown, Output = Input> {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  interface Types<Input = unknown, Output = Input> {
+    readonly input: Input;
+    readonly output: Output;
+  }
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['input'];
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    readonly validate: (value: unknown, options?: Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  interface Options {
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  interface SuccessResult<Output> {
+    readonly value: Output;
+    readonly issues?: undefined;
+  }
+  interface FailureResult {
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  interface Issue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  interface PathSegment {
+    readonly key: PropertyKey;
+  }
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  readonly '~standard': StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    readonly jsonSchema: Converter;
+  }
+  interface Converter {
+    readonly input: (options: Options) => Record<string, unknown>;
+    readonly output: (options: Options) => Record<string, unknown>;
+  }
+  type Target = 'draft-2020-12' | 'draft-07' | 'openapi-3.0' | (object & string);
+  interface Options {
+    readonly target: Target;
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
 /**
- * Experimental task features for low-level MCP servers.
+ * Combined interface for schemas with both validation and JSON Schema conversion —
+ * the intersection of {@linkcode StandardSchemaV1} and {@linkcode StandardJSONSchemaV1}.
  *
- * Access via `server.experimental.tasks`:
- * ```typescript
- * const stream = server.experimental.tasks.requestStream(request, options);
+ * This is the type accepted by `registerTool` / `registerPrompt`. The SDK needs
+ * `~standard.jsonSchema` to advertise the tool's argument shape in `tools/list`, and
+ * `~standard.validate` to check incoming arguments when a `tools/call` arrives.
+ *
+ * Zod v4, ArkType, and Valibot (via `@valibot/to-json-schema`'s `toStandardJsonSchema`)
+ * all implement both interfaces.
+ *
+ * @see https://standardschema.dev/ for the Standard Schema specification
+ */
+interface StandardSchemaWithJSON<Input = unknown, Output = Input> {
+  readonly '~standard': StandardSchemaV1.Props<Input, Output> & StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaWithJSON {
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/**
+ * Narrowing of {@linkcode StandardSchemaV1} whose `validate` is guaranteed synchronous.
+ *
+ * The Zod schemas backing `specTypeSchemas` contain no async refinements or transforms,
+ * so every entry satisfies this interface. Consumers can call `validate()` and access
+ * `.issues` / `.value` on the result without `await`.
+ *
+ * `StandardSchemaV1Sync` is assignable to `StandardSchemaV1` — it is a strict subtype.
+ */
+interface StandardSchemaV1Sync<Input = unknown, Output = Input> extends StandardSchemaV1<Input, Output> {
+  readonly '~standard': StandardSchemaV1Sync.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1Sync {
+  interface Props<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output> {
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => StandardSchemaV1.Result<Output>;
+  }
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+//#endregion
+//#region ../core-internal/src/types/specTypeSchema.d.ts
+/**
+ * Explicit allowlist of protocol Zod schemas that correspond to a public spec type in `types.ts`.
+ *
+ * This intentionally excludes internal helper schemas exported from `schemas.ts` that have no
+ * matching public type (e.g. `ListChangedOptionsBaseSchema`, `BaseRequestParamsSchema`,
+ * `NotificationsParamsSchema`, `ClientTasksCapabilitySchema`, `ServerTasksCapabilitySchema`).
+ * Keeping the list explicit means new public spec types must be added here deliberately, and
+ * internals never leak into `SpecTypeName`.
+ *
+ * `ResourceTemplateSchema` is included; its public type is exported as `ResourceTemplateType`
+ * (the bare name collides with the server package's `ResourceTemplate` class), so
+ * `SpecTypes['ResourceTemplate']` is structurally equal to `ResourceTemplateType` rather than to
+ * a type literally named `ResourceTemplate`.
+ */
+declare const SPEC_SCHEMA_KEYS: readonly ["AnnotationsSchema", "AudioContentSchema", "BaseMetadataSchema", "BlobResourceContentsSchema", "BooleanSchemaSchema", "CallToolRequestSchema", "CallToolRequestParamsSchema", "CallToolResultSchema", "CancelledNotificationSchema", "CancelledNotificationParamsSchema", "CancelTaskRequestSchema", "CancelTaskResultSchema", "ClientCapabilitiesSchema", "ClientNotificationSchema", "ClientRequestSchema", "ClientResultSchema", "CompatibilityCallToolResultSchema", "CompleteRequestSchema", "CompleteRequestParamsSchema", "CompleteResultSchema", "ContentBlockSchema", "CreateMessageRequestSchema", "CreateMessageRequestParamsSchema", "CreateMessageResultSchema", "CreateMessageResultWithToolsSchema", "CreateTaskResultSchema", "CursorSchema", "DiscoverRequestSchema", "DiscoverResultSchema", "ElicitationCompleteNotificationSchema", "ElicitationCompleteNotificationParamsSchema", "ElicitRequestSchema", "ElicitRequestFormParamsSchema", "ElicitRequestParamsSchema", "ElicitRequestURLParamsSchema", "ElicitResultSchema", "EmbeddedResourceSchema", "EmptyResultSchema", "EnumSchemaSchema", "GetPromptRequestSchema", "GetPromptRequestParamsSchema", "GetPromptResultSchema", "GetTaskPayloadRequestSchema", "GetTaskPayloadResultSchema", "GetTaskRequestSchema", "GetTaskResultSchema", "IconSchema", "IconsSchema", "ImageContentSchema", "ImplementationSchema", "InitializedNotificationSchema", "InitializeRequestSchema", "InitializeRequestParamsSchema", "InitializeResultSchema", "JSONArraySchema", "JSONObjectSchema", "JSONRPCErrorResponseSchema", "JSONRPCMessageSchema", "JSONRPCNotificationSchema", "JSONRPCRequestSchema", "JSONRPCResponseSchema", "JSONRPCResultResponseSchema", "JSONValueSchema", "LegacyTitledEnumSchemaSchema", "ListPromptsRequestSchema", "ListPromptsResultSchema", "ListResourcesRequestSchema", "ListResourcesResultSchema", "ListResourceTemplatesRequestSchema", "ListResourceTemplatesResultSchema", "ListRootsRequestSchema", "ListRootsResultSchema", "ListTasksRequestSchema", "ListTasksResultSchema", "ListToolsRequestSchema", "ListToolsResultSchema", "LoggingLevelSchema", "LoggingMessageNotificationSchema", "LoggingMessageNotificationParamsSchema", "ModelHintSchema", "ModelPreferencesSchema", "MultiSelectEnumSchemaSchema", "NotificationSchema", "NumberSchemaSchema", "PaginatedRequestSchema", "PaginatedRequestParamsSchema", "PaginatedResultSchema", "PingRequestSchema", "PrimitiveSchemaDefinitionSchema", "ProgressSchema", "ProgressNotificationSchema", "ProgressNotificationParamsSchema", "ProgressTokenSchema", "PromptSchema", "PromptArgumentSchema", "PromptListChangedNotificationSchema", "PromptMessageSchema", "PromptReferenceSchema", "ReadResourceRequestSchema", "ReadResourceRequestParamsSchema", "ReadResourceResultSchema", "RelatedTaskMetadataSchema", "RequestSchema", "RequestIdSchema", "RequestMetaEnvelopeSchema", "RequestMetaSchema", "ResourceSchema", "ResourceContentsSchema", "ResourceLinkSchema", "ResourceListChangedNotificationSchema", "ResourceRequestParamsSchema", "ResourceTemplateSchema", "ResourceTemplateReferenceSchema", "ResourceUpdatedNotificationSchema", "ResourceUpdatedNotificationParamsSchema", "ResultSchema", "RoleSchema", "RootSchema", "RootsListChangedNotificationSchema", "SamplingContentSchema", "SamplingMessageSchema", "SamplingMessageContentBlockSchema", "ServerCapabilitiesSchema", "ServerNotificationSchema", "ServerRequestSchema", "ServerResultSchema", "SetLevelRequestSchema", "SetLevelRequestParamsSchema", "SingleSelectEnumSchemaSchema", "StringSchemaSchema", "SubscribeRequestSchema", "SubscribeRequestParamsSchema", "TaskSchema", "TaskAugmentedRequestParamsSchema", "TaskCreationParamsSchema", "TaskMetadataSchema", "TaskStatusSchema", "TaskStatusNotificationSchema", "TaskStatusNotificationParamsSchema", "TextContentSchema", "TextResourceContentsSchema", "TitledMultiSelectEnumSchemaSchema", "TitledSingleSelectEnumSchemaSchema", "ToolSchema", "ToolAnnotationsSchema", "ToolChoiceSchema", "ToolExecutionSchema", "ToolListChangedNotificationSchema", "ToolResultContentSchema", "ToolUseContentSchema", "UnsubscribeRequestSchema", "UnsubscribeRequestParamsSchema", "UntitledMultiSelectEnumSchemaSchema", "UntitledSingleSelectEnumSchemaSchema"];
+declare const authSchemas: {
+  readonly IdJagTokenExchangeResponseSchema: z.ZodObject<{
+    issued_token_type: z.ZodLiteral<"urn:ietf:params:oauth:token-type:id-jag">;
+    access_token: z.ZodString;
+    token_type: z.ZodOptional<z.ZodString>;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+    scope: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  readonly OAuthClientInformationFullSchema: z.ZodObject<{
+    redirect_uris: z.ZodArray<z.ZodURL>;
+    token_endpoint_auth_method: z.ZodOptional<z.ZodString>;
+    grant_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    response_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    client_name: z.ZodOptional<z.ZodString>;
+    client_uri: z.ZodOptional<z.ZodURL>;
+    logo_uri: z.ZodUnion<[z.ZodOptional<z.ZodURL>, z.ZodPipe<z.ZodLiteral<"">, z.ZodTransform<undefined, "">>]>;
+    scope: z.ZodOptional<z.ZodString>;
+    contacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tos_uri: z.ZodUnion<[z.ZodOptional<z.ZodURL>, z.ZodPipe<z.ZodLiteral<"">, z.ZodTransform<undefined, "">>]>;
+    policy_uri: z.ZodOptional<z.ZodString>;
+    jwks_uri: z.ZodOptional<z.ZodURL>;
+    jwks: z.ZodOptional<z.ZodAny>;
+    software_id: z.ZodOptional<z.ZodString>;
+    software_version: z.ZodOptional<z.ZodString>;
+    software_statement: z.ZodOptional<z.ZodString>;
+    client_id: z.ZodString;
+    client_secret: z.ZodOptional<z.ZodString>;
+    client_id_issued_at: z.ZodOptional<z.ZodNumber>;
+    client_secret_expires_at: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+  readonly OAuthClientInformationSchema: z.ZodObject<{
+    client_id: z.ZodString;
+    client_secret: z.ZodOptional<z.ZodString>;
+    client_id_issued_at: z.ZodOptional<z.ZodNumber>;
+    client_secret_expires_at: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+  readonly OAuthClientMetadataSchema: z.ZodObject<{
+    redirect_uris: z.ZodArray<z.ZodURL>;
+    token_endpoint_auth_method: z.ZodOptional<z.ZodString>;
+    grant_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    response_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    client_name: z.ZodOptional<z.ZodString>;
+    client_uri: z.ZodOptional<z.ZodURL>;
+    logo_uri: z.ZodUnion<[z.ZodOptional<z.ZodURL>, z.ZodPipe<z.ZodLiteral<"">, z.ZodTransform<undefined, "">>]>;
+    scope: z.ZodOptional<z.ZodString>;
+    contacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tos_uri: z.ZodUnion<[z.ZodOptional<z.ZodURL>, z.ZodPipe<z.ZodLiteral<"">, z.ZodTransform<undefined, "">>]>;
+    policy_uri: z.ZodOptional<z.ZodString>;
+    jwks_uri: z.ZodOptional<z.ZodURL>;
+    jwks: z.ZodOptional<z.ZodAny>;
+    software_id: z.ZodOptional<z.ZodString>;
+    software_version: z.ZodOptional<z.ZodString>;
+    software_statement: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  readonly OAuthClientRegistrationErrorSchema: z.ZodObject<{
+    error: z.ZodString;
+    error_description: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  readonly OAuthErrorResponseSchema: z.ZodObject<{
+    error: z.ZodString;
+    error_description: z.ZodOptional<z.ZodString>;
+    error_uri: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  readonly OAuthMetadataSchema: z.ZodObject<{
+    issuer: z.ZodString;
+    authorization_endpoint: z.ZodURL;
+    token_endpoint: z.ZodURL;
+    registration_endpoint: z.ZodOptional<z.ZodURL>;
+    scopes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    response_types_supported: z.ZodArray<z.ZodString>;
+    response_modes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    grant_types_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    token_endpoint_auth_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    token_endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    service_documentation: z.ZodOptional<z.ZodURL>;
+    revocation_endpoint: z.ZodOptional<z.ZodURL>;
+    revocation_endpoint_auth_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    revocation_endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    introspection_endpoint: z.ZodOptional<z.ZodString>;
+    introspection_endpoint_auth_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    introspection_endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    code_challenge_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    client_id_metadata_document_supported: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$loose>;
+  readonly OAuthProtectedResourceMetadataSchema: z.ZodObject<{
+    resource: z.ZodString;
+    authorization_servers: z.ZodOptional<z.ZodArray<z.ZodURL>>;
+    jwks_uri: z.ZodOptional<z.ZodString>;
+    scopes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    bearer_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    resource_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    resource_name: z.ZodOptional<z.ZodString>;
+    resource_documentation: z.ZodOptional<z.ZodString>;
+    resource_policy_uri: z.ZodOptional<z.ZodString>;
+    resource_tos_uri: z.ZodOptional<z.ZodString>;
+    tls_client_certificate_bound_access_tokens: z.ZodOptional<z.ZodBoolean>;
+    authorization_details_types_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dpop_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dpop_bound_access_tokens_required: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$loose>;
+  readonly OAuthTokenRevocationRequestSchema: z.ZodObject<{
+    token: z.ZodString;
+    token_type_hint: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  readonly OAuthTokensSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    id_token: z.ZodOptional<z.ZodString>;
+    token_type: z.ZodString;
+    expires_in: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    scope: z.ZodOptional<z.ZodString>;
+    refresh_token: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  readonly OpenIdProviderDiscoveryMetadataSchema: z.ZodObject<{
+    code_challenge_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    issuer: z.ZodString;
+    authorization_endpoint: z.ZodURL;
+    token_endpoint: z.ZodURL;
+    userinfo_endpoint: z.ZodOptional<z.ZodURL>;
+    jwks_uri: z.ZodURL;
+    registration_endpoint: z.ZodOptional<z.ZodURL>;
+    scopes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    response_types_supported: z.ZodArray<z.ZodString>;
+    response_modes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    grant_types_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    acr_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subject_types_supported: z.ZodArray<z.ZodString>;
+    id_token_signing_alg_values_supported: z.ZodArray<z.ZodString>;
+    id_token_encryption_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id_token_encryption_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    userinfo_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    userinfo_encryption_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    userinfo_encryption_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    request_object_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    request_object_encryption_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    request_object_encryption_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    token_endpoint_auth_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    token_endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    display_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    claim_types_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    claims_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    service_documentation: z.ZodOptional<z.ZodString>;
+    claims_locales_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ui_locales_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    claims_parameter_supported: z.ZodOptional<z.ZodBoolean>;
+    request_parameter_supported: z.ZodOptional<z.ZodBoolean>;
+    request_uri_parameter_supported: z.ZodOptional<z.ZodBoolean>;
+    require_request_uri_registration: z.ZodOptional<z.ZodBoolean>;
+    op_policy_uri: z.ZodOptional<z.ZodURL>;
+    op_tos_uri: z.ZodOptional<z.ZodURL>;
+    client_id_metadata_document_supported: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>;
+  readonly OpenIdProviderMetadataSchema: z.ZodObject<{
+    issuer: z.ZodString;
+    authorization_endpoint: z.ZodURL;
+    token_endpoint: z.ZodURL;
+    userinfo_endpoint: z.ZodOptional<z.ZodURL>;
+    jwks_uri: z.ZodURL;
+    registration_endpoint: z.ZodOptional<z.ZodURL>;
+    scopes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    response_types_supported: z.ZodArray<z.ZodString>;
+    response_modes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    grant_types_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    acr_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subject_types_supported: z.ZodArray<z.ZodString>;
+    id_token_signing_alg_values_supported: z.ZodArray<z.ZodString>;
+    id_token_encryption_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id_token_encryption_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    userinfo_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    userinfo_encryption_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    userinfo_encryption_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    request_object_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    request_object_encryption_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    request_object_encryption_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    token_endpoint_auth_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    token_endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    display_values_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    claim_types_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    claims_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    service_documentation: z.ZodOptional<z.ZodString>;
+    claims_locales_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ui_locales_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    claims_parameter_supported: z.ZodOptional<z.ZodBoolean>;
+    request_parameter_supported: z.ZodOptional<z.ZodBoolean>;
+    request_uri_parameter_supported: z.ZodOptional<z.ZodBoolean>;
+    require_request_uri_registration: z.ZodOptional<z.ZodBoolean>;
+    op_policy_uri: z.ZodOptional<z.ZodURL>;
+    op_tos_uri: z.ZodOptional<z.ZodURL>;
+    client_id_metadata_document_supported: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$loose>;
+};
+type ProtocolSchemaKey = (typeof SPEC_SCHEMA_KEYS)[number];
+type AuthSchemaKey = keyof typeof authSchemas;
+type SchemaKey = ProtocolSchemaKey | AuthSchemaKey;
+type SchemaFor<K$1 extends SchemaKey> = K$1 extends ProtocolSchemaKey ? (typeof schemas_d_exports)[K$1] : K$1 extends AuthSchemaKey ? (typeof authSchemas)[K$1] : never;
+type StripSchemaSuffix<K$1> = K$1 extends `${infer N}Schema` ? N : never;
+/**
+ * Union of every named type in the SDK's protocol and OAuth schemas (e.g. `'CallToolResult'`,
+ * `'ContentBlock'`, `'Tool'`, `'OAuthTokens'`). Derived from the internal Zod schemas, so it stays
+ * in sync with the spec.
+ */
+type SpecTypeName = StripSchemaSuffix<SchemaKey>;
+/**
+ * Maps each {@linkcode SpecTypeName} to its TypeScript type.
+ *
+ * `SpecTypes['CallToolResult']` is equivalent to importing the `CallToolResult` type directly.
+ */
+type SpecTypes = { [K in SchemaKey as StripSchemaSuffix<K>]: SchemaFor<K> extends z.ZodType ? z.output<SchemaFor<K>> : never };
+/**
+ * Input shape for each {@linkcode SpecTypeName}. For most types this equals {@linkcode SpecTypes},
+ * but a few schemas apply defaults/preprocessing, so the accepted input may be looser than the
+ * resulting output type.
+ */
+type SpecTypeInputs = { [K in SchemaKey as StripSchemaSuffix<K>]: SchemaFor<K> extends z.ZodType ? z.input<SchemaFor<K>> : never };
+type SchemaRecord = { readonly [K in SpecTypeName]: StandardSchemaV1Sync<SpecTypeInputs[K], SpecTypes[K]> };
+type GuardRecord = { readonly [K in SpecTypeName]: (value: unknown) => value is SpecTypeInputs[K] };
+/**
+ * Runtime validators for every MCP spec type, keyed by type name.
+ *
+ * Use this when you need to validate a spec-defined shape at a boundary the SDK does not own, for
+ * example an extension's custom-method payload that embeds a `CallToolResult`, or a value read from
+ * storage that should be a `Tool`.
+ *
+ * Each entry implements the Standard Schema interface, so it composes with any
+ * Standard-Schema-aware library. For a simple boolean check, use {@linkcode isSpecType} instead.
+ *
+ * @example
+ * ```ts source="./specTypeSchema.examples.ts#specTypeSchemas_basicUsage"
+ * const result = specTypeSchemas.CallToolResult['~standard'].validate(untrusted);
+ * if (result.issues === undefined) {
+ *     // result.value is CallToolResult
+ * }
  * ```
+ */
+declare const specTypeSchemas: SchemaRecord;
+/**
+ * Type predicates for every MCP spec type, keyed by type name.
+ *
+ * Returns `true` if the value satisfies the schema's input type (`z.input<>`, before defaults and
+ * transforms are applied), and narrows to that input type. For schemas with `.default()` or
+ * `.preprocess()`, this may accept values that do not structurally match the named output type;
+ * for example `isSpecType.CallToolResult({})` is `true` because `content` has a default. Use
+ * `specTypeSchemas.X['~standard'].validate(value)` when you need the validated output value.
  *
- * For high-level server usage with task-based tools, use {@linkcode index.McpServer | McpServer}.experimental.tasks instead.
+ * Each guard is a standalone function, so it can be passed directly as a callback.
+ *
+ * @example
+ * ```ts source="./specTypeSchema.examples.ts#isSpecType_basicUsage"
+ * if (isSpecType.ContentBlock(value)) {
+ *     // value is ContentBlock
+ * }
  *
- * @experimental
+ * const blocks = mixed.filter(isSpecType.ContentBlock);
+ * ```
+ */
+declare const isSpecType: GuardRecord;
+//#endregion
+//#region ../core-internal/src/shared/metadataUtils.d.ts
+/**
+ * Utilities for working with {@linkcode BaseMetadata} objects.
+ */
+/**
+ * Gets the display name for an object with {@linkcode BaseMetadata}.
+ * For tools, the precedence is: `title` → {@linkcode index.ToolAnnotations | annotations}.`title` → `name`
+ * For other objects: `title` → `name`
+ * This implements the spec requirement: "if no title is provided, name should be used for display purposes"
+ */
+declare function getDisplayName(metadata: BaseMetadata | (BaseMetadata & {
+  annotations?: {
+    title?: string;
+  };
+})): string;
+//#endregion
+//#region ../core-internal/src/shared/protocol.d.ts
+/**
+ * Callback for progress notifications.
  */
-declare class ExperimentalServerTasks {
-  private readonly _server;
-  constructor(_server: Server);
-  private get _module();
+type ProgressCallback = (progress: Progress) => void;
+/**
+ * Additional initialization options.
+ */
+type ProtocolOptions = {
   /**
-   * Sends a request and returns an AsyncGenerator that yields response messages.
-   * The generator is guaranteed to end with either a `'result'` or `'error'` message.
+   * Protocol versions supported. First version is preferred (sent by client,
+   * used as fallback by server). Passed to transport during {@linkcode Protocol.connect | connect()}.
    *
-   * This method provides streaming access to request processing, allowing you to
-   * observe intermediate task status updates for task-augmented requests.
+   * @default {@linkcode SUPPORTED_PROTOCOL_VERSIONS}
+   */
+  supportedProtocolVersions?: string[];
+  /**
+   * Whether to restrict emitted requests to only those that the remote side has indicated that they can handle, through their advertised capabilities.
    *
-   * @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
+   * Note that this DOES NOT affect checking of _local_ side capabilities, as it is considered a logic error to mis-specify those.
    *
-   * @experimental
+   * Currently this defaults to `false`, for backwards compatibility with SDK versions that did not advertise capabilities correctly. In future, this will default to `true`.
    */
-  requestStream<M extends RequestMethod>(request: {
-    method: M;
-    params?: Record<string, unknown>;
-  }, options?: RequestOptions): AsyncGenerator<ResponseMessage<ResultTypeMap[M]>, void, void>;
+  enforceStrictCapabilities?: boolean;
   /**
-   * 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.
+   * An array of notification method names that should be automatically debounced.
+   * Any notifications with a method in this list will be coalesced if they
+   * occur in the same tick of the event loop.
+   * e.g., `['notifications/tools/list_changed']`
+   */
+  debouncedNotificationMethods?: string[];
+};
+/**
+ * The default request timeout, in milliseconds.
+ */
+declare const DEFAULT_REQUEST_TIMEOUT_MSEC = 60000;
+/**
+ * Options that can be given per request.
+ */
+type RequestOptions = {
+  /**
+   * If set, requests progress notifications from the remote end (if supported). When progress notifications are received, this callback will be invoked.
+   */
+  onprogress?: ProgressCallback;
+  /**
+   * Can be used to cancel an in-flight request. This will cause an `AbortError` to be raised from {@linkcode Protocol.request | request()}.
+   */
+  signal?: AbortSignal;
+  /**
+   * A timeout (in milliseconds) for this request. If exceeded, an {@linkcode SdkError} with code {@linkcode SdkErrorCode.RequestTimeout} will be raised from {@linkcode Protocol.request | request()}.
    *
-   * @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);
-   *     }
-   * });
+   * If not specified, {@linkcode DEFAULT_REQUEST_TIMEOUT_MSEC} will be used as the timeout.
+   */
+  timeout?: number;
+  /**
+   * If `true`, receiving a progress notification will reset the request timeout.
+   * This is useful for long-running operations that send periodic progress updates.
+   * Default: `false`
+   */
+  resetTimeoutOnProgress?: boolean;
+  /**
+   * Maximum total time (in milliseconds) to wait for a response.
+   * If exceeded, an {@linkcode SdkError} with code {@linkcode SdkErrorCode.RequestTimeout} will be raised, regardless of progress notifications.
+   * If not specified, there is no maximum total timeout.
+   */
+  maxTotalTimeout?: number;
+} & TransportSendOptions;
+/**
+ * Options that can be given per notification.
+ */
+type NotificationOptions = {
+  /**
+   * May be used to indicate to the transport which incoming request to associate this outgoing notification with.
+   */
+  relatedRequestId?: RequestId;
+};
+/**
+ * Base context provided to all request handlers.
+ */
+type BaseContext = {
+  /**
+   * The session ID from the transport, if available.
+   */
+  sessionId?: string;
+  /**
+   * Information about the MCP request being handled.
+   */
+  mcpReq: {
+    /**
+     * The JSON-RPC ID of the request being handled.
+     */
+    id: RequestId;
+    /**
+     * The method name of the request (e.g., 'tools/call', 'ping').
+     */
+    method: string;
+    /**
+     * Metadata from the original request.
+     */
+    _meta?: RequestMeta;
+    /**
+     * An abort signal used to communicate if the request was cancelled from the sender's side.
+     */
+    signal: AbortSignal;
+    /**
+     * Sends a request that relates to the current request being handled.
+     *
+     * This is used by certain transports to correctly associate related messages.
+     *
+     * For spec methods the result type is inferred from the method name.
+     * For custom (non-spec) methods, pass a result schema as the second argument.
+     */
+    send: {
+      <M extends RequestMethod>(request: {
+        method: M;
+        params?: Record<string, unknown>;
+      }, options?: RequestOptions): Promise<ResultTypeMap[M]>;
+      <T extends StandardSchemaV1>(request: Request$1, resultSchema: T, options?: RequestOptions): Promise<StandardSchemaV1.InferOutput<T>>;
+    };
+    /**
+     * Sends a notification that relates to the current request being handled.
+     *
+     * This is used by certain transports to correctly associate related messages.
+     */
+    notify: (notification: Notification) => Promise<void>;
+  };
+  /**
+   * HTTP transport information, only available when using an HTTP-based transport.
+   */
+  http?: {
+    /**
+     * Information about a validated access token, provided to request handlers.
+     */
+    authInfo?: AuthInfo;
+  };
+};
+/**
+ * Context provided to server-side request handlers, extending {@linkcode BaseContext} with server-specific fields.
+ */
+type ServerContext = BaseContext & {
+  mcpReq: {
+    /**
+     * Send a log message notification to the client.
+     * Respects the client's log level filter set via logging/setLevel.
+     *
+     * @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+     * Remains functional during the deprecation window (at least twelve months).
+     * Migrate to stderr logging (STDIO servers) or OpenTelemetry.
+     */
+    log: (level: LoggingLevel, data: unknown, logger?: string) => Promise<void>;
+    /**
+     * Send an elicitation request to the client, requesting user input.
+     */
+    elicitInput: (params: ElicitRequestFormParams | ElicitRequestURLParams, options?: RequestOptions) => Promise<ElicitResult>;
+    /**
+     * Request LLM sampling from the client.
+     *
+     * @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+     * Remains functional during the deprecation window (at least twelve months).
+     * Migrate to calling LLM provider APIs directly.
+     */
+    requestSampling: (params: CreateMessageRequest['params'], options?: RequestOptions) => Promise<CreateMessageResult | CreateMessageResultWithTools>;
+  };
+  http?: {
+    /**
+     * The original HTTP request.
+     */
+    req?: globalThis.Request;
+    /**
+     * Closes the SSE stream for this request, triggering client reconnection.
+     * Only available when using a StreamableHTTPServerTransport with eventStore configured.
+     */
+    closeSSE?: () => void;
+    /**
+     * Closes the standalone GET SSE stream, triggering client reconnection.
+     * Only available when using a StreamableHTTPServerTransport with eventStore configured.
+     */
+    closeStandaloneSSE?: () => void;
+  };
+};
+/**
+ * Context provided to client-side request handlers.
+ */
+type ClientContext = BaseContext;
+/**
+ * Implements MCP protocol framing on top of a pluggable transport, including
+ * features like request/response linking, notifications, and progress.
+ *
+ * `Protocol` is abstract; `Client` and `Server` are the concrete role-specific
+ * implementations most code should use.
+ */
+declare abstract class Protocol<ContextT extends BaseContext> {
+  private _options?;
+  private _transport?;
+  private _requestMessageId;
+  private _requestHandlers;
+  private _requestHandlerAbortControllers;
+  private _notificationHandlers;
+  private _responseHandlers;
+  private _progressHandlers;
+  private _timeoutInfo;
+  private _pendingDebouncedNotifications;
+  protected _supportedProtocolVersions: string[];
+  /**
+   * Callback for when the connection is closed for any reason.
    *
-   * 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;
-   *     }
-   * }
-   * ```
+   * This is invoked when {@linkcode Protocol.close | close()} is called as well.
+   */
+  onclose?: () => void;
+  /**
+   * Callback for when an error occurs.
    *
-   * @param params - The sampling request parameters
-   * @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
-   * @returns AsyncGenerator that yields ResponseMessage objects
+   * Note that errors are not necessarily fatal; they are used for reporting any kind of exceptional condition out of band.
+   */
+  onerror?: (error: Error) => void;
+  /**
+   * A handler to invoke for any request types that do not have their own handler installed.
+   */
+  fallbackRequestHandler?: (request: JSONRPCRequest, ctx: ContextT) => Promise<Result$1>;
+  /**
+   * A handler to invoke for any notification types that do not have their own handler installed.
+   */
+  fallbackNotificationHandler?: (notification: Notification) => Promise<void>;
+  constructor(_options?: ProtocolOptions | undefined);
+  /**
+   * Builds the context object for request handlers. Subclasses must override
+   * to return the appropriate context type (e.g., ServerContext adds HTTP request info).
+   */
+  protected abstract buildContext(ctx: BaseContext, transportInfo?: MessageExtraInfo): ContextT;
+  private _oncancel;
+  private _setupTimeout;
+  private _resetTimeout;
+  private _cleanupTimeout;
+  /**
+   * Attaches to the given transport, starts it, and starts listening for messages.
    *
-   * @experimental
+   * The caller 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.
    */
-  createMessageStream(params: CreateMessageRequestParams, options?: RequestOptions): AsyncGenerator<ResponseMessage<CreateMessageResult>, void, void>;
+  connect(transport: Transport): Promise<void>;
+  private _onclose;
+  private _onerror;
+  private _onnotification;
+  private _onrequest;
+  private _onprogress;
+  private _onresponse;
+  get transport(): Transport | undefined;
   /**
-   * 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.
+   * Closes the connection.
+   */
+  close(): Promise<void>;
+  /**
+   * A method to check if a capability is supported by the remote side, for the given method to be called.
    *
-   * For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
-   * and 'taskStatus' messages before the final result.
+   * This should be implemented by subclasses.
+   */
+  protected abstract assertCapabilityForMethod(method: RequestMethod | string): void;
+  /**
+   * A method to check if a notification is supported by the local side, for the given method to be sent.
    *
-   * @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
-   * });
+   * This should be implemented by subclasses.
+   */
+  protected abstract assertNotificationCapability(method: NotificationMethod | string): void;
+  /**
+   * A method to check if a request handler is supported by the local side, for the given method to be handled.
    *
-   * 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;
-   *     }
-   * }
-   * ```
+   * This should be implemented by subclasses.
+   */
+  protected abstract assertRequestHandlerCapability(method: string): void;
+  /**
+   * Sends a request and waits for a response.
    *
-   * @param params - The elicitation request parameters
-   * @param options - Optional request options (timeout, signal, task creation params, etc.)
-   * @returns AsyncGenerator that yields ResponseMessage objects
+   * For spec methods the result schema is resolved automatically from the method name
+   * and the return type is method-keyed. For custom (non-spec) methods, pass a
+   * `resultSchema` as the second argument; the response is validated against it and
+   * the return type is inferred from the schema.
    *
-   * @experimental
+   * Do not use this method to emit notifications! Use {@linkcode Protocol.notification | notification()} instead.
    */
-  elicitInputStream(params: ElicitRequestFormParams | ElicitRequestURLParams, options?: RequestOptions): AsyncGenerator<ResponseMessage<ElicitResult>, void, void>;
+  request<M extends RequestMethod>(request: {
+    method: M;
+    params?: Record<string, unknown>;
+  }, options?: RequestOptions): Promise<ResultTypeMap[M]>;
+  request<T extends StandardSchemaV1>(request: Request$1, resultSchema: T, options?: RequestOptions): Promise<StandardSchemaV1.InferOutput<T>>;
   /**
-   * Gets the current status of a task.
-   *
-   * @param taskId - The task identifier
-   * @param options - Optional request options
-   * @returns The task status
+   * Sends a request and waits for a response, using the provided schema for validation.
    *
-   * @experimental
+   * This is the internal implementation used by SDK methods that need to specify
+   * a particular result schema (e.g., for compatibility schemas).
    */
-  getTask(taskId: string, options?: RequestOptions): Promise<GetTaskResult>;
+  protected _requestWithSchema<T extends StandardSchemaV1>(request: Request$1, resultSchema: T, options?: RequestOptions): Promise<StandardSchemaV1.InferOutput<T>>;
   /**
-   * Retrieves the result of a completed task.
+   * Emits a notification, which is a one-way message that does not expect a response.
+   */
+  notification(notification: Notification, options?: NotificationOptions): Promise<void>;
+  /**
+   * Registers a handler to invoke when this protocol object receives a request with the given method.
+   *
+   * Note that this will replace any previous request handler for the same method.
+   *
+   * For spec methods, pass `(method, handler)`; the request is parsed with the spec
+   * schema and the handler receives the typed `Request`. For custom (non-spec)
+   * methods, pass `(method, schemas, handler)`; `params` are validated against
+   * `schemas.params` and the handler receives the parsed params object directly.
+   * Supplying `schemas.result` types the handler's return value.
    *
-   * @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`).
+   * @example Custom request method
+   * ```ts source="./protocol.examples.ts#Protocol_setRequestHandler_customMethod"
+   * const SearchParams = z.object({ query: z.string(), limit: z.number().optional() });
+   * const SearchResult = z.object({ hits: z.array(z.string()) });
    *
-   * @experimental
+   * protocol.setRequestHandler('acme/search', { params: SearchParams, result: SearchResult }, async (params, _ctx) => {
+   *     return { hits: [`result for ${params.query}`] };
+   * });
+   * ```
    */
-  getTaskResult(taskId: string, options?: RequestOptions): Promise<GetTaskPayloadResult>;
+  setRequestHandler<M extends RequestMethod>(method: M, handler: (request: RequestTypeMap[M], ctx: ContextT) => ResultTypeMap[M] | Promise<ResultTypeMap[M]>): void;
+  setRequestHandler<P extends StandardSchemaV1, R extends StandardSchemaV1 | undefined = undefined>(method: string, schemas: {
+    params: P;
+    result?: R;
+  }, handler: (params: StandardSchemaV1.InferOutput<P>, ctx: ContextT) => InferHandlerResult<R> | Promise<InferHandlerResult<R>>): void;
   /**
-   * Lists tasks with optional pagination.
-   *
-   * @param cursor - Optional pagination cursor
-   * @param options - Optional request options
-   * @returns List of tasks with optional next cursor
+   * Hook for subclasses to wrap a registered request handler with role-specific
+   * validation or behavior (e.g. `Server` validates `tools/call` results, `Client`
+   * validates `elicitation/create` mode and result). Runs for both the 2-arg and
+   * 3-arg registration paths. The default implementation is identity.
    *
-   * @experimental
+   * Subclasses overriding this hook avoid redeclaring `setRequestHandler`'s overload set.
    */
-  listTasks(cursor?: string, options?: RequestOptions): Promise<ListTasksResult>;
+  protected _wrapHandler(_method: string, handler: (request: JSONRPCRequest, ctx: ContextT) => Promise<Result$1>): (request: JSONRPCRequest, ctx: ContextT) => Promise<Result$1>;
   /**
-   * Cancels a running task.
+   * Removes the request handler for the given method.
+   */
+  removeRequestHandler(method: RequestMethod | string): void;
+  /**
+   * Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed.
+   */
+  assertCanSetRequestHandler(method: RequestMethod | string): void;
+  /**
+   * Registers a handler to invoke when this protocol object receives a notification with the given method.
    *
-   * @param taskId - The task identifier
-   * @param options - Optional request options
+   * Note that this will replace any previous notification handler for the same method.
    *
-   * @experimental
+   * For spec methods, pass `(method, handler)`; the notification is parsed with the
+   * spec schema. For custom (non-spec) methods, pass `(method, schemas, handler)`;
+   * `params` are validated against `schemas.params` and the handler receives the
+   * parsed params object directly. The raw notification is passed as the second
+   * argument; `_meta` is recoverable via `notification.params?._meta`.
    */
-  cancelTask(taskId: string, options?: RequestOptions): Promise<CancelTaskResult>;
+  setNotificationHandler<M extends NotificationMethod>(method: M, handler: (notification: NotificationTypeMap[M]) => void | Promise<void>): void;
+  setNotificationHandler<P extends StandardSchemaV1>(method: string, schemas: {
+    params: P;
+  }, handler: (params: StandardSchemaV1.InferOutput<P>, notification: Notification) => void | Promise<void>): void;
+  /**
+   * Removes the notification handler for the given method.
+   */
+  removeNotificationHandler(method: NotificationMethod | string): void;
 }
+/**
+ * Schema bundle accepted by {@linkcode Protocol.setRequestHandler | setRequestHandler}'s 3-arg form.
+ *
+ * `params` is required and validates the inbound `request.params`. `result` is optional;
+ * when supplied it types the handler's return value (no runtime validation is performed
+ * on the result).
+ */
+interface RequestHandlerSchemas<P extends StandardSchemaV1 = StandardSchemaV1, R extends StandardSchemaV1 | undefined = StandardSchemaV1 | undefined> {
+  params: P;
+  result?: R;
+}
+type InferHandlerResult<R extends StandardSchemaV1 | undefined> = R extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<R> : Result$1;
 //#endregion
-//#region src/server/server.d.ts
+//#region ../core-internal/src/shared/stdio.d.ts
+declare const STDIO_DEFAULT_MAX_BUFFER_SIZE: number;
 /**
- * Extended tasks capability that includes runtime configuration (store, messageQueue).
- * The runtime-only fields are stripped before advertising capabilities to clients.
+ * Buffers a continuous stdio stream into discrete JSON-RPC messages.
  */
-type ServerTasksCapabilityWithRuntime = NonNullable<ServerCapabilities['tasks']> & TaskManagerOptions;
+declare class ReadBuffer {
+  private _buffer?;
+  private _maxBufferSize;
+  constructor(options?: {
+    maxBufferSize?: number;
+  });
+  append(chunk: Buffer): void;
+  readMessage(): JSONRPCMessage | null;
+  clear(): void;
+}
+declare function deserializeMessage(line: string): JSONRPCMessage;
+declare function serializeMessage(message: JSONRPCMessage): string;
+//#endregion
+//#region ../core-internal/src/shared/uriTemplate.d.ts
+type Variables = Record<string, string | string[]>;
+declare class UriTemplate {
+  /**
+   * Returns true if the given string contains any URI template expressions.
+   * A template expression is a sequence of characters enclosed in curly braces,
+   * like `{foo}` or `{?bar}`.
+   */
+  static isTemplate(str: string): boolean;
+  private static validateLength;
+  private readonly template;
+  private readonly parts;
+  get variableNames(): string[];
+  constructor(template: string);
+  toString(): string;
+  private parse;
+  private getOperator;
+  private getNames;
+  private encodeValue;
+  private expandPart;
+  expand(variables: Variables): string;
+  private escapeRegExp;
+  private partToRegExp;
+  match(uri: string): Variables | null;
+}
+//#endregion
+//#region ../core-internal/src/util/inMemory.d.ts
+/**
+ * In-memory transport for creating clients and servers that talk to each other within the same process.
+ *
+ * Intended for testing and development. For production in-process connections, use
+ * `StreamableHTTPClientTransport` against a local server URL.
+ */
+declare class InMemoryTransport implements Transport {
+  private _otherTransport?;
+  private _messageQueue;
+  private _closed;
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage, extra?: {
+    authInfo?: AuthInfo;
+  }) => void;
+  sessionId?: string;
+  /**
+   * Creates a pair of linked in-memory transports that can communicate with each other. One should be passed to a {@linkcode @modelcontextprotocol/client!client/client.Client | Client} and one to a {@linkcode @modelcontextprotocol/server!server/server.Server | Server}.
+   */
+  static createLinkedPair(): [InMemoryTransport, InMemoryTransport];
+  start(): Promise<void>;
+  close(): Promise<void>;
+  /**
+   * Sends a message with optional auth info.
+   * This is useful for testing authentication scenarios.
+   */
+  send(message: JSONRPCMessage, options?: {
+    relatedRequestId?: RequestId;
+    authInfo?: AuthInfo;
+  }): Promise<void>;
+}
+//#endregion
+//#region src/server/completable.d.ts
+declare const COMPLETABLE_SYMBOL: unique symbol;
+type CompleteCallback<T extends StandardSchemaV1 = StandardSchemaV1> = (value: StandardSchemaV1.InferInput<T>, context?: {
+  arguments?: Record<string, string>;
+}) => StandardSchemaV1.InferInput<T>[] | Promise<StandardSchemaV1.InferInput<T>[]>;
+type CompletableMeta<T extends StandardSchemaV1 = StandardSchemaV1> = {
+  complete: CompleteCallback<T>;
+};
+type CompletableSchema<T extends StandardSchemaV1> = T & {
+  [COMPLETABLE_SYMBOL]: CompletableMeta<T>;
+};
+/**
+ * Wraps a schema to provide autocompletion capabilities. Useful for, e.g., prompt arguments in MCP.
+ *
+ * @example
+ * ```ts source="./completable.examples.ts#completable_basicUsage"
+ * server.registerPrompt(
+ *     'review-code',
+ *     {
+ *         title: 'Code Review',
+ *         argsSchema: z.object({
+ *             language: completable(z.string().describe('Programming language'), value =>
+ *                 ['typescript', 'javascript', 'python', 'rust', 'go'].filter(lang => lang.startsWith(value))
+ *             )
+ *         })
+ *     },
+ *     ({ language }) => ({
+ *         messages: [
+ *             {
+ *                 role: 'user' as const,
+ *                 content: {
+ *                     type: 'text' as const,
+ *                     text: `Review this ${language} code.`
+ *                 }
+ *             }
+ *         ]
+ *     })
+ * );
+ * ```
+ *
+ * @see {@linkcode server/mcp.McpServer.registerPrompt | McpServer.registerPrompt} for using completable schemas in prompt argument definitions
+ */
+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<StandardSchemaV1>;
+//#endregion
+//#region src/server/server.d.ts
 type ServerOptions = ProtocolOptions & {
   /**
    * Capabilities to advertise as being supported by this server.
+   *
+   * Note: per the MCP spec, a server that declares a capability MUST respond to that
+   * capability's requests (e.g. `tools/list` for `tools`) — potentially with an empty
+   * result — rather than with a "Method not found" error. {@linkcode server/mcp.McpServer | McpServer}
+   * handles this automatically for capabilities declared here; when using the low-level
+   * {@linkcode Server} directly, you are responsible for registering a request handler for
+   * every capability you declare.
    */
-  capabilities?: Omit<ServerCapabilities, 'tasks'> & {
-    tasks?: ServerTasksCapabilityWithRuntime;
-  };
+  capabilities?: ServerCapabilities;
   /**
    * Optional instructions describing how to use the server and its features.
    */
@@ -341,7 +1501,7 @@ type ServerOptions = ProtocolOptions & {
    * 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)
+   * @default Runtime-selected validator (AJV-backed on Node.js, `@cfworker/json-schema`-backed on browser/workerd runtimes)
    */
   jsonSchemaValidator?: jsonSchemaValidator;
 };
@@ -356,10 +1516,10 @@ declare class Server extends Protocol<ServerContext> {
   private _serverInfo;
   private _clientCapabilities?;
   private _clientVersion?;
+  private _negotiatedProtocolVersion?;
   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).
    */
@@ -368,18 +1528,15 @@ declare class Server extends Protocol<ServerContext> {
    * 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.
+   * Registers the built-in `logging/setLevel` request handler.
    *
-   * @experimental
+   * @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+   * Remains functional during the deprecation window (at least twelve months).
+   * Migrate to stderr logging (STDIO servers) or OpenTelemetry.
    */
-  get experimental(): {
-    tasks: ExperimentalServerTasks;
-  };
+  private _registerLoggingHandler;
+  protected buildContext(ctx: BaseContext, transportInfo?: MessageExtraInfo): ServerContext;
   private _loggingLevels;
   private readonly LOG_LEVEL_SEVERITY;
   private isMessageIgnored;
@@ -390,14 +1547,13 @@ declare class Server extends Protocol<ServerContext> {
    */
   registerCapabilities(capabilities: ServerCapabilities): void;
   /**
-   * Override request handler registration to enforce server-side validation for `tools/call`.
+   * Enforces server-side validation for `tools/call` results regardless of how the
+   * handler was registered.
    */
-  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 _wrapHandler(method: string, handler: (request: JSONRPCRequest, ctx: ServerContext) => Promise<Result$1>): (request: JSONRPCRequest, ctx: ServerContext) => Promise<Result$1>;
+  protected assertCapabilityForMethod(method: RequestMethod | string): void;
+  protected assertNotificationCapability(method: NotificationMethod | string): 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.
@@ -407,6 +1563,12 @@ declare class Server extends Protocol<ServerContext> {
    * After initialization has completed, this will be populated with information about the client's name and version.
    */
   getClientVersion(): Implementation | undefined;
+  /**
+   * After initialization has completed, this will be populated with the protocol version negotiated
+   * with the client (the version the server responded with during the initialize handshake), or
+   * `undefined` before initialization.
+   */
+  getNegotiatedProtocolVersion(): string | undefined;
   /**
    * Returns the current server capabilities.
    */
@@ -419,20 +1581,33 @@ declare class Server extends Protocol<ServerContext> {
         taskId: string;
       } | undefined;
     } | undefined;
+    resultType?: string | undefined;
   }>;
   /**
    * Request LLM sampling from the client (without tools).
    * Returns single content block for backwards compatibility.
+   *
+   * @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+   * Remains functional during the deprecation window (at least twelve months).
+   * Migrate to calling LLM provider APIs directly.
    */
   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).
+   *
+   * @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+   * Remains functional during the deprecation window (at least twelve months).
+   * Migrate to calling LLM provider APIs directly.
    */
   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.
+   *
+   * @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+   * Remains functional during the deprecation window (at least twelve months).
+   * Migrate to calling LLM provider APIs directly.
    */
   createMessage(params: CreateMessageRequest['params'], options?: RequestOptions): Promise<CreateMessageResult | CreateMessageResultWithTools>;
   /**
@@ -452,6 +1627,13 @@ declare class Server extends Protocol<ServerContext> {
    * @returns A function that emits the completion notification when awaited.
    */
   createElicitationCompletionNotifier(elicitationId: string, options?: NotificationOptions): () => Promise<void>;
+  /**
+   * Requests the list of roots from the client.
+   *
+   * @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+   * Remains functional during the deprecation window (at least twelve months).
+   * Migrate to passing paths via tool parameters, resource URIs, or configuration.
+   */
   listRoots(params?: ListRootsRequest['params'], options?: RequestOptions): Promise<{
     [x: string]: unknown;
     roots: {
@@ -466,6 +1648,7 @@ declare class Server extends Protocol<ServerContext> {
         taskId: string;
       } | undefined;
     } | undefined;
+    resultType?: string | undefined;
   }>;
   /**
    * Sends a logging message to the client, if connected.
@@ -473,6 +1656,10 @@ declare class Server extends Protocol<ServerContext> {
    * @see {@linkcode LoggingMessageNotification}
    * @param params
    * @param sessionId Optional for stateless transports and backward compatibility.
+   *
+   * @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+   * Remains functional during the deprecation window (at least twelve months).
+   * Migrate to stderr logging (STDIO servers) or OpenTelemetry.
    */
   sendLoggingMessage(params: LoggingMessageNotification['params'], sessionId?: string): Promise<void>;
   sendResourceUpdated(params: ResourceUpdatedNotification['params']): Promise<void>;
@@ -504,18 +1691,7 @@ declare class McpServer {
   private _registeredResourceTemplates;
   private _registeredTools;
   private _registeredPrompts;
-  private _experimental?;
   constructor(serverInfo: Implementation, options?: ServerOptions);
-  /**
-   * Access experimental features.
-   *
-   * WARNING: These APIs are experimental and may change without notice.
-   *
-   * @experimental
-   */
-  get experimental(): {
-    tasks: ExperimentalMcpServerTasks;
-  };
   /**
    * Attaches to the given transport, starts it, and starts listening for messages.
    *
@@ -551,13 +1727,9 @@ declare class McpServer {
    */
   private validateToolOutput;
   /**
-   * Executes a tool handler (either regular or task-based).
+   * Executes a tool handler.
    */
   private executeToolHandler;
-  /**
-   * Handles automatic task polling for tools with `taskSupport` `'optional'`.
-   */
-  private handleAutomaticTaskPolling;
   private _completionHandlerInitialized;
   private setCompletionRequestHandler;
   private handlePromptCompletion;
@@ -623,8 +1795,19 @@ declare class McpServer {
     inputSchema?: InputArgs;
     outputSchema?: OutputArgs;
     annotations?: ToolAnnotations;
+    icons?: Icon[];
     _meta?: Record<string, unknown>;
   }, cb: ToolCallback<InputArgs>): RegisteredTool;
+  /** @deprecated Wrap with `z.object({...})` instead. Raw-shape form: `inputSchema`/`outputSchema` may be a plain `{ field: z.string() }` record; it is auto-wrapped with `z.object()`. */
+  registerTool<InputArgs extends ZodRawShape, OutputArgs extends ZodRawShape | StandardSchemaWithJSON | undefined = undefined>(name: string, config: {
+    title?: string;
+    description?: string;
+    inputSchema?: InputArgs;
+    outputSchema?: OutputArgs;
+    annotations?: ToolAnnotations;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+  }, cb: LegacyToolCallback<InputArgs>): RegisteredTool;
   /**
    * Registers a prompt with a config object and callback.
    *
@@ -655,8 +1838,17 @@ declare class McpServer {
     title?: string;
     description?: string;
     argsSchema?: Args;
+    icons?: Icon[];
     _meta?: Record<string, unknown>;
   }, cb: PromptCallback<Args>): RegisteredPrompt;
+  /** @deprecated Wrap with `z.object({...})` instead. Raw-shape form: `argsSchema` may be a plain `{ field: z.string() }` record; it is auto-wrapped with `z.object()`. */
+  registerPrompt<Args extends ZodRawShape>(name: string, config: {
+    title?: string;
+    description?: string;
+    argsSchema?: Args;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+  }, cb: LegacyPromptCallback<Args>): RegisteredPrompt;
   /**
    * Checks if the server is connected to a transport.
    * @returns `true` if the server is connected
@@ -676,6 +1868,10 @@ declare class McpServer {
    *     data: 'Processing complete'
    * });
    * ```
+   *
+   * @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+   * Remains functional during the deprecation window (at least twelve months).
+   * Migrate to stderr logging (STDIO servers) or OpenTelemetry.
    */
   sendLoggingMessage(params: LoggingMessageNotification['params'], sessionId?: string): Promise<void>;
   /**
@@ -729,25 +1925,38 @@ declare class ResourceTemplate {
    */
   completeCallback(variable: string): CompleteResourceTemplateCallback | undefined;
 }
-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>;
+/**
+ * A plain record of Zod field schemas, e.g. `{ name: z.string() }`. Accepted by
+ * `registerTool`/`registerPrompt` as a shorthand; auto-wrapped with `z.object()`.
+ * Zod schemas only — `z.object()` cannot wrap other Standard Schema libraries.
+ */
+type ZodRawShape = Record<string, z.ZodType>;
+/** Infers the parsed-output type of a {@linkcode ZodRawShape}. */
+type InferRawShape<S extends ZodRawShape> = z.infer<z.ZodObject<S>>;
+/** {@linkcode ToolCallback} variant used when `inputSchema` is a {@linkcode ZodRawShape}. */
+type LegacyToolCallback<Args extends ZodRawShape | undefined> = Args extends ZodRawShape ? (args: InferRawShape<Args>, ctx: ServerContext) => CallToolResult | Promise<CallToolResult> : (ctx: ServerContext) => CallToolResult | Promise<CallToolResult>;
+/** {@linkcode PromptCallback} variant used when `argsSchema` is a {@linkcode ZodRawShape}. */
+type LegacyPromptCallback<Args extends ZodRawShape | undefined> = Args extends ZodRawShape ? (args: InferRawShape<Args>, ctx: ServerContext) => GetPromptResult | Promise<GetPromptResult> : (ctx: ServerContext) => GetPromptResult | Promise<GetPromptResult>;
+type BaseToolCallback<SendResultT extends Result$1, 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).
+ * Tool handler callback type.
  */
-type AnyToolHandler<Args extends StandardSchemaWithJSON | undefined = undefined> = ToolCallback<Args> | ToolTaskHandler<Args>;
+type AnyToolHandler<Args extends StandardSchemaWithJSON | undefined = undefined> = ToolCallback<Args>;
 /**
  * Internal executor type that encapsulates handler invocation with proper types.
  */
-type ToolExecutor = (args: unknown, ctx: ServerContext) => Promise<CallToolResult | CreateTaskResult>;
+type ToolExecutor = (args: unknown, ctx: ServerContext) => Promise<CallToolResult>;
 type RegisteredTool = {
   title?: string;
   description?: string;
   inputSchema?: StandardSchemaWithJSON;
   outputSchema?: StandardSchemaWithJSON;
   annotations?: ToolAnnotations;
+  icons?: Icon[];
   execution?: ToolExecution;
   _meta?: Record<string, unknown>;
   handler: AnyToolHandler<StandardSchemaWithJSON | undefined>;
@@ -763,6 +1972,7 @@ type RegisteredTool = {
     paramsSchema?: StandardSchemaWithJSON;
     outputSchema?: StandardSchemaWithJSON;
     annotations?: ToolAnnotations;
+    icons?: Icon[];
     _meta?: Record<string, unknown>;
     callback?: ToolCallback<StandardSchemaWithJSON>;
     enabled?: boolean;
@@ -831,6 +2041,7 @@ type RegisteredPrompt = {
   title?: string;
   description?: string;
   argsSchema?: StandardSchemaWithJSON;
+  icons?: Icon[];
   _meta?: Record<string, unknown>;
   /** @hidden */
   handler: PromptHandler;
@@ -842,6 +2053,7 @@ type RegisteredPrompt = {
     title?: string;
     description?: string;
     argsSchema?: Args;
+    icons?: Icon[];
     _meta?: Record<string, unknown>;
     callback?: PromptCallback<Args>;
     enabled?: boolean;
@@ -880,41 +2092,6 @@ declare function localhostAllowedHostnames(): string[];
  */
 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`.
- *
- * This transport is only available in Node.js environments.
- *
- * @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);
- * ```
- */
-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>;
-}
-//#endregion
 //#region src/server/streamableHttp.d.ts
 type StreamId = string;
 type EventId = string;
@@ -954,7 +2131,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 +2139,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 +2150,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 +2266,7 @@ interface HandleRequestOptions {
 declare class WebStandardStreamableHTTPServerTransport implements Transport {
   private sessionIdGenerator;
   private _started;
+  private _closed;
   private _streamMapping;
   private _requestToStreamMapping;
   private _requestResponseMap;
@@ -1132,10 +2310,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 +2394,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 { AjvJsonSchemaValidator, Annotations, type AnyToolHandler, AudioContent, AuthInfo, AuthorizationServerMetadata, BAGGAGE_META_KEY, BaseContext, BaseMetadata, type BaseToolCallback, BlobResourceContents, BooleanSchema, CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, CallToolRequest, CallToolRequestParams, CallToolResult, CancelTaskRequest, CancelTaskResult, CancelledNotification, CancelledNotificationParams, CfWorkerJsonSchemaValidator, CfWorkerSchemaDraft, ClientCapabilities, ClientContext, ClientNotification, ClientRequest, ClientResult, CompatibilityCallToolResult, type CompletableSchema, type CompleteCallback, CompleteRequest, CompleteRequestParams, CompleteRequestPrompt, CompleteRequestResourceTemplate, type CompleteResourceTemplateCallback, CompleteResult, ContentBlock, 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, FetchLike, GetPromptRequest, GetPromptRequestParams, GetPromptResult, GetTaskPayloadRequest, GetTaskPayloadResult, GetTaskRequest, GetTaskResult, type HandleRequestOptions, type HostHeaderValidationResult, INTERNAL_ERROR, INVALID_PARAMS, INVALID_REQUEST, Icon, Icons, IdJagTokenExchangeResponse, ImageContent, Implementation, InMemoryTransport, InitializeRequest, InitializeRequestParams, InitializeResult, InitializedNotification, InternalError, InvalidParamsError, InvalidRequestError, JSONArray, JSONObject, JSONRPCErrorResponse, JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, JSONRPCResultResponse, JSONRPC_VERSION, JSONValue, JsonSchemaType, JsonSchemaValidator, JsonSchemaValidatorResult, LATEST_PROTOCOL_VERSION, LOG_LEVEL_META_KEY, 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, NotificationOptions, NotificationParams, NotificationTypeMap, NumberSchema, OAuthClientInformation, OAuthClientInformationFull, OAuthClientInformationMixed, OAuthClientMetadata, OAuthClientRegistrationError, OAuthError, OAuthErrorCode, OAuthErrorResponse, OAuthMetadata, OAuthProtectedResourceMetadata, OAuthTokenRevocationRequest, OAuthTokens, OpenIdProviderDiscoveryMetadata, OpenIdProviderMetadata, PARSE_ERROR, PROTOCOL_VERSION_META_KEY, PaginatedRequest, PaginatedRequestParams, PaginatedResult, ParseError, PingRequest, PrimitiveSchemaDefinition, Progress, ProgressCallback, ProgressNotification, ProgressNotificationParams, ProgressToken, Prompt, PromptArgument, type PromptCallback, PromptListChangedNotification, PromptMessage, PromptReference, ProtocolError, ProtocolErrorCode, 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, RequestHandlerSchemas, RequestId, RequestMeta, RequestMetaEnvelope, RequestMetaObject, RequestMethod, RequestOptions, RequestParams, RequestTypeMap, Resource, ResourceContents, ResourceLink, ResourceListChangedNotification, type ResourceMetadata, ResourceRequestParams, ResourceTemplate, ResourceTemplateReference, ResourceTemplateType, ResourceUpdatedNotification, ResourceUpdatedNotificationParams, Result$1 as Result, ResultTypeMap, Role, Root, RootsListChangedNotification, STDIO_DEFAULT_MAX_BUFFER_SIZE, SUPPORTED_PROTOCOL_VERSIONS, SamplingContent, SamplingMessage, SamplingMessageContentBlock, SdkError, SdkErrorCode, SdkHttpError, SdkHttpErrorData, Server, ServerCapabilities, ServerContext, ServerNotification, type ServerOptions, ServerRequest, ServerResult, SetLevelRequest, SetLevelRequestParams, SingleSelectEnumSchema, SpecTypeName, SpecTypes, StandardSchemaV1, StandardSchemaV1Sync, StandardSchemaWithJSON, type StreamId, StringSchema, SubscribeRequest, SubscribeRequestParams, 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, Transport, TransportSendOptions, UnsubscribeRequest, UnsubscribeRequestParams, UnsupportedProtocolVersionError, UnsupportedProtocolVersionErrorData, UntitledMultiSelectEnumSchema, UntitledSingleSelectEnumSchema, UriTemplate, UrlElicitationRequiredError, Variables, WebStandardStreamableHTTPServerTransport, type WebStandardStreamableHTTPServerTransportOptions, assertCompleteRequestPrompt, assertCompleteRequestResourceTemplate, checkResourceAllowed, completable, createFetchWithInit, deserializeMessage, fromJsonSchema, getDisplayName, hostHeaderValidationResponse, isCallToolResult, isCompletable, isInitializeRequest, isInitializedNotification, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse, isJSONRPCResultResponse, isSpecType, isTaskAugmentedRequestParams, jsonSchemaValidator, localhostAllowedHostnames, parseJSONRPCMessage, resourceUrlFromServerUrl, serializeMessage, specTypeSchemas, validateHostHeader };
 //# sourceMappingURL=index.d.mts.map