toolcraft 0.0.232 → 0.0.233

package/node_modules/tiny-stdio-mcp-server/dist/jsonrpc.d.ts

@@ -1,4 +1,5 @@
 import type { JSONRPCRequest, JSONRPCError, JSONRPCNotification } from "./types.js";
+export declare function isRequestId(value: unknown): value is string | number;
 export interface ParseResult {
     success: true;
     request: JSONRPCRequest | JSONRPCNotification;

package/node_modules/tiny-stdio-mcp-server/dist/jsonrpc.js

@@ -1,4 +1,8 @@
 import { JSON_RPC_ERROR_CODES } from "./types.js";
+import { MODERN_PROTOCOL_VERSION } from "./protocol.js";
+export function isRequestId(value) {
+    return typeof value === "string" || (typeof value === "number" && Number.isSafeInteger(value));
+}
 export function parseMessage(line) {
     let parsed;
     try {
@@ -9,24 +13,35 @@ export function parseMessage(line) {
             success: false,
             error: {
                 code: JSON_RPC_ERROR_CODES.PARSE_ERROR,
-                message: "Parse error",
+                message: "Parse error"
             },
-            id: null,
+            id: null
         };
     }
-    if (typeof parsed !== "object" ||
-        parsed === null ||
-        Array.isArray(parsed)) {
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
         return {
             success: false,
             error: {
                 code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-                message: "Invalid Request",
+                message: "Invalid Request"
             },
-            id: null,
+            id: null
         };
     }
     const obj = parsed;
+    const metadata = obj.params?._meta;
+    if (typeof metadata === "object" &&
+        metadata !== null &&
+        metadata["io.modelcontextprotocol/protocolVersion"] ===
+            MODERN_PROTOCOL_VERSION &&
+        "id" in obj &&
+        !isRequestId(obj.id)) {
+        return {
+            success: false,
+            error: { code: JSON_RPC_ERROR_CODES.INVALID_REQUEST, message: "Invalid Request ID" },
+            id: null
+        };
+    }
     const hasId = "id" in obj;
     const id = typeof obj.id === "string"
         ? obj.id
@@ -35,17 +50,15 @@ export function parseMessage(line) {
             : obj.id === null
                 ? null
                 : null;
-    if ("params" in obj
-        && (typeof obj.params !== "object"
-            || obj.params === null
-            || Array.isArray(obj.params))) {
+    if ("params" in obj &&
+        (typeof obj.params !== "object" || obj.params === null || Array.isArray(obj.params))) {
         return {
             success: false,
             error: {
                 code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-                message: "Invalid Request",
+                message: "Invalid Request"
             },
-            id,
+            id
         };
     }
     if (obj.jsonrpc !== "2.0") {
@@ -53,9 +66,9 @@ export function parseMessage(line) {
             success: false,
             error: {
                 code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-                message: "Invalid Request",
+                message: "Invalid Request"
             },
-            id,
+            id
         };
     }
     if (typeof obj.method !== "string") {
@@ -63,9 +76,9 @@ export function parseMessage(line) {
             success: false,
             error: {
                 code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-                message: "Invalid Request",
+                message: "Invalid Request"
             },
-            id,
+            id
         };
     }
     if (!hasId) {
@@ -75,8 +88,8 @@ export function parseMessage(line) {
             request: {
                 jsonrpc: "2.0",
                 method: obj.method,
-                params: obj.params,
-            },
+                params: obj.params
+            }
         };
     }
     if (obj.id !== null && id === null) {
@@ -84,9 +97,9 @@ export function parseMessage(line) {
             success: false,
             error: {
                 code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
-                message: "Invalid Request",
+                message: "Invalid Request"
             },
-            id: null,
+            id: null
         };
     }
     return {
@@ -96,15 +109,15 @@ export function parseMessage(line) {
             jsonrpc: "2.0",
             id,
             method: obj.method,
-            params: obj.params,
-        },
+            params: obj.params
+        }
     };
 }
 export function formatSuccessResponse(id, result) {
     const response = {
         jsonrpc: "2.0",
         id,
-        result,
+        result
     };
     return JSON.stringify(response);
 }
@@ -112,7 +125,7 @@ export function formatErrorResponse(id, error) {
     const response = {
         jsonrpc: "2.0",
         id,
-        error,
+        error
     };
     return JSON.stringify(response);
 }

package/node_modules/tiny-stdio-mcp-server/dist/metadata.d.ts

@@ -0,0 +1,2 @@
+export declare function isValidMetadataKey(key: string): boolean;
+export declare function isValidMetadata(value: unknown): value is Record<string, unknown>;

package/node_modules/tiny-stdio-mcp-server/dist/metadata.js

@@ -0,0 +1,37 @@
+import { isJsonValue } from "toolcraft-schema";
+function isLetter(code) {
+    return (code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a);
+}
+function isAlphanumeric(code) {
+    return isLetter(code) || (code >= 0x30 && code <= 0x39);
+}
+export function isValidMetadataKey(key) {
+    const slash = key.indexOf("/");
+    let name = key;
+    if (slash !== -1) {
+        if (key.indexOf("/", slash + 1) !== -1)
+            return false;
+        for (const label of key.slice(0, slash).split(".")) {
+            if (label.length === 0 || !isLetter(label.charCodeAt(0)) || !isAlphanumeric(label.charCodeAt(label.length - 1)))
+                return false;
+            for (let index = 1; index < label.length - 1; index++) {
+                if (!isAlphanumeric(label.charCodeAt(index)) && label[index] !== "-")
+                    return false;
+            }
+        }
+        name = key.slice(slash + 1);
+    }
+    if (name.length === 0)
+        return true;
+    if (!isAlphanumeric(name.charCodeAt(0)) || !isAlphanumeric(name.charCodeAt(name.length - 1)))
+        return false;
+    for (let index = 1; index < name.length - 1; index++) {
+        if (!isAlphanumeric(name.charCodeAt(index)) && name[index] !== "-" && name[index] !== "_" && name[index] !== ".")
+            return false;
+    }
+    return true;
+}
+export function isValidMetadata(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        && isJsonValue(value) && Object.keys(value).every(isValidMetadataKey);
+}

package/node_modules/tiny-stdio-mcp-server/dist/protocol-validation.d.ts

@@ -0,0 +1,4 @@
+type ProtocolDefinition = "InputRequest" | "InputResponses" | "ClientCapabilities" | "ElicitResult" | "CreateMessageResult" | "ListRootsResult" | "DiscoverResult" | "ListToolsResult" | "CallToolResult" | "ListPromptsResult" | "GetPromptResult" | "ListResourcesResult" | "ListResourceTemplatesResult" | "ReadResourceResult" | "CompleteResult" | "Result";
+export declare function validateServerResult(method: string, value: unknown): boolean;
+export declare function validateProtocolValue(definition: ProtocolDefinition, value: unknown): boolean;
+export {};

package/node_modules/tiny-stdio-mcp-server/dist/protocol-validation.js

@@ -0,0 +1,53 @@
+import { isBase64 } from "./base64.js";
+import { isValidMetadataKey } from "./metadata.js";
+import { isValidUri } from "./uri.js";
+import { compileJsonSchema } from "toolcraft-schema";
+import { inputRequestSchema } from "./input-request-schema.js";
+import { isJsonValue } from "toolcraft-schema";
+const validators = new Map();
+const protocolSchema = structuredClone(inputRequestSchema);
+const protocolDefinitions = protocolSchema.$defs;
+for (const definition of ["MetaObject", "ResultMetaObject"]) {
+    Object.assign(protocolDefinitions[definition], { propertyNames: { format: "mcp-metadata-key" } });
+}
+for (const definition of ["ClientCapabilities", "ServerCapabilities"]) {
+    const properties = protocolDefinitions[definition].properties;
+    Object.assign(properties.extensions, { propertyNames: { format: "mcp-extension-key" } });
+}
+const resultDefinitions = {
+    "server/discover": "DiscoverResult",
+    "tools/list": "ListToolsResult",
+    "tools/call": "CallToolResult",
+    "prompts/list": "ListPromptsResult",
+    "prompts/get": "GetPromptResult",
+    "resources/list": "ListResourcesResult",
+    "resources/templates/list": "ListResourceTemplatesResult",
+    "resources/read": "ReadResourceResult",
+    "completion/complete": "CompleteResult",
+    "ping": "Result",
+    "logging/setLevel": "Result"
+};
+export function validateServerResult(method, value) {
+    const definition = Object.hasOwn(resultDefinitions, method) ? resultDefinitions[method] : undefined;
+    return definition === undefined || validateProtocolValue(definition, value);
+}
+export function validateProtocolValue(definition, value) {
+    if (!isJsonValue(value))
+        return false;
+    if (definition === "ListRootsResult" && typeof value === "object" && value !== null &&
+        Array.isArray(value.roots) &&
+        !value.roots.every((root) => typeof root?.uri === "string" && root.uri.startsWith("file://") && isValidUri(root.uri)))
+        return false;
+    let validator = validators.get(definition);
+    if (validator === undefined) {
+        validator = compileJsonSchema({ ...protocolSchema, $ref: `#/$defs/${definition}` }, {
+            formats: {
+                "mcp-metadata-key": isValidMetadataKey,
+                "mcp-extension-key": (key) => key.includes("/") && isValidMetadataKey(key),
+                uri: isValidUri, byte: isBase64
+            }
+        });
+        validators.set(definition, validator);
+    }
+    return validator.validate(value).ok;
+}

package/node_modules/tiny-stdio-mcp-server/dist/protocol.d.ts

@@ -0,0 +1,17 @@
+import { type HandleResult, type JSONRPCError } from "./types.js";
+export declare const MODERN_PROTOCOL_VERSION = "2026-07-28";
+export declare function selectRequestProtocol(method: string, params: Record<string, unknown> | undefined, legacyVersions: ReadonlySet<string>): {
+    modern: boolean;
+    error?: JSONRPCError;
+};
+export declare function validateInputRequiredResult(method: string, value: Record<string, unknown>, clientCapabilities: Record<string, unknown>): HandleResult | undefined;
+export declare function validateCacheMetadata(method: string, value: Record<string, unknown>): string | undefined;
+export declare function decorateModernResult(method: string, handled: HandleResult, serverInfo: {
+    name: string;
+    version: string;
+}, clientCapabilities?: Record<string, unknown>): HandleResult;
+export { validateProtocolValue, validateServerResult } from "./protocol-validation.js";
+export { isJsonValue } from "toolcraft-schema";
+export { isBase64 } from "./base64.js";
+export { isValidUri } from "./uri.js";
+export { isValidMetadata } from "./metadata.js";

package/node_modules/tiny-stdio-mcp-server/dist/protocol.js

@@ -0,0 +1,228 @@
+import { isValidMetadata } from "./metadata.js";
+import { JSON_RPC_ERROR_CODES } from "./types.js";
+import { isJsonValue } from "toolcraft-schema";
+import { validateProtocolValue } from "./protocol-validation.js";
+import { inspectSamplingMessages } from "./sampling-messages.js";
+export const MODERN_PROTOCOL_VERSION = "2026-07-28";
+const removedMethods = new Set([
+    "initialize",
+    "notifications/initialized",
+    "ping",
+    "logging/setLevel",
+    "resources/subscribe",
+    "resources/unsubscribe",
+    "notifications/roots/list_changed"
+]);
+const cacheableMethods = new Set([
+    "server/discover",
+    "tools/list",
+    "prompts/list",
+    "resources/list",
+    "resources/templates/list",
+    "resources/read"
+]);
+const inputRequiredMethods = new Set(["tools/call", "prompts/get", "resources/read"]);
+const inputRequestCapabilities = {
+    "roots/list": "roots",
+    "sampling/createMessage": "sampling",
+    "elicitation/create": "elicitation"
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function selectRequestProtocol(method, params, legacyVersions) {
+    const invalid = {
+        modern: false,
+        error: {
+            code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+            message: "Request metadata must include protocolVersion and clientCapabilities"
+        }
+    };
+    const property = Object.getOwnPropertyDescriptor(params ?? {}, "_meta");
+    if (property === undefined || property.enumerable !== true)
+        return method === "server/discover" ? invalid : { modern: false };
+    if (!("value" in property))
+        return invalid;
+    const metadata = property.value;
+    if (!isRecord(metadata))
+        return invalid;
+    if (!isValidMetadata(metadata))
+        return { modern: false, error: {
+                code: JSON_RPC_ERROR_CODES.INVALID_PARAMS, message: "Invalid MCP metadata keys"
+            } };
+    const versionKey = "io.modelcontextprotocol/protocolVersion";
+    const capabilitiesKey = "io.modelcontextprotocol/clientCapabilities";
+    if (!(versionKey in metadata) && !(capabilitiesKey in metadata) && method !== "server/discover") {
+        return { modern: false };
+    }
+    const version = metadata[versionKey];
+    if (!Object.prototype.hasOwnProperty.call(metadata, versionKey) ||
+        typeof version !== "string" ||
+        !Object.prototype.hasOwnProperty.call(metadata, capabilitiesKey) ||
+        !isRecord(metadata[capabilitiesKey]))
+        return invalid;
+    if (version !== MODERN_PROTOCOL_VERSION && !legacyVersions.has(version)) {
+        return {
+            modern: false,
+            error: {
+                code: JSON_RPC_ERROR_CODES.UNSUPPORTED_PROTOCOL_VERSION,
+                message: "Unsupported protocol version",
+                data: { requested: version, supported: [...legacyVersions].reverse() }
+            }
+        };
+    }
+    const modern = version === MODERN_PROTOCOL_VERSION;
+    if (modern && !validateProtocolValue("ClientCapabilities", metadata[capabilitiesKey])) {
+        return { modern, error: {
+                code: JSON_RPC_ERROR_CODES.INVALID_PARAMS, message: "Invalid MCP clientCapabilities"
+            } };
+    }
+    if (modern &&
+        ((params?.requestState !== undefined && typeof params.requestState !== "string") ||
+            (params?.inputResponses !== undefined && !validateProtocolValue("InputResponses", params.inputResponses)))) {
+        return {
+            modern,
+            error: { code: JSON_RPC_ERROR_CODES.INVALID_PARAMS, message: "Invalid MCP retry parameters" }
+        };
+    }
+    if (modern && removedMethods.has(method)) {
+        return {
+            modern,
+            error: { code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND, message: "Method not found" }
+        };
+    }
+    return { modern };
+}
+export function validateInputRequiredResult(method, value, clientCapabilities) {
+    const requests = value.inputRequests;
+    const requiredCapabilities = {};
+    const invalidRequests = requests !== undefined &&
+        (!isRecord(requests) || !isJsonValue(requests) ||
+            Object.values(requests).some((request) => {
+                if (!isRecord(request) || typeof request.method !== "string")
+                    return true;
+                if (!validateProtocolValue("InputRequest", request))
+                    return true;
+                const sampling = request.method === "sampling/createMessage"
+                    ? inspectSamplingMessages(request.params.messages)
+                    : undefined;
+                if (sampling?.valid === false)
+                    return true;
+                if (request.method === "elicitation/create" &&
+                    request.params.mode === "url") {
+                    try {
+                        new URL(request.params.url);
+                    }
+                    catch {
+                        return true;
+                    }
+                }
+                const capability = Object.prototype.hasOwnProperty.call(inputRequestCapabilities, request.method)
+                    ? inputRequestCapabilities[request.method]
+                    : undefined;
+                if (capability === undefined || (request.params !== undefined && !isRecord(request.params)))
+                    return true;
+                const supported = Object.prototype.hasOwnProperty.call(clientCapabilities, capability)
+                    ? clientCapabilities[capability] : undefined;
+                if (!isRecord(supported))
+                    requiredCapabilities[capability] = {};
+                else if (capability === "elicitation") {
+                    const mode = request.params.mode ?? "form";
+                    const implicitForm = mode === "form" && Object.keys(supported).length === 0;
+                    if (!implicitForm && (typeof mode !== "string" ||
+                        !Object.prototype.hasOwnProperty.call(supported, mode) || !isRecord(supported[mode]))) {
+                        const required = requiredCapabilities.elicitation ??= {};
+                        required[String(mode)] = {};
+                    }
+                }
+                else if (capability === "sampling") {
+                    const params = request.params;
+                    if ((params.tools !== undefined || params.toolChoice !== undefined || sampling?.usesTools === true) &&
+                        (!Object.prototype.hasOwnProperty.call(supported, "tools") || !isRecord(supported.tools))) {
+                        const required = requiredCapabilities.sampling ??= {};
+                        required.tools = {};
+                    }
+                }
+                return false;
+            }));
+    if (!inputRequiredMethods.has(method) ||
+        (requests === undefined && value.requestState === undefined) ||
+        (value.requestState !== undefined && typeof value.requestState !== "string") ||
+        invalidRequests) {
+        return {
+            error: {
+                code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: "Invalid MCP input_required result"
+            }
+        };
+    }
+    if (Object.keys(requiredCapabilities).length > 0) {
+        return { error: {
+                code: -32021,
+                message: "Missing required client capability",
+                data: { requiredCapabilities }
+            } };
+    }
+}
+export function validateCacheMetadata(method, value) {
+    if (!cacheableMethods.has(method))
+        return undefined;
+    if (!Number.isSafeInteger(value.ttlMs) || value.ttlMs < 0) {
+        return "MCP cache ttlMs must be a nonnegative safe integer";
+    }
+    if (value.cacheScope !== "public" && value.cacheScope !== "private") {
+        return "MCP cacheScope must be public or private";
+    }
+    return undefined;
+}
+export function decorateModernResult(method, handled, serverInfo, clientCapabilities = {}) {
+    if (handled.error !== undefined) {
+        return handled.error.code === JSON_RPC_ERROR_CODES.RESOURCE_NOT_FOUND
+            ? { error: { ...handled.error, code: JSON_RPC_ERROR_CODES.INVALID_PARAMS } }
+            : handled;
+    }
+    if (handled.result === undefined && method.startsWith("notifications/"))
+        return handled;
+    const value = handled.result;
+    if (!isRecord(value))
+        return {
+            error: {
+                code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: "MCP result must be an object"
+            }
+        };
+    if (value.resultType !== undefined &&
+        value.resultType !== "complete" &&
+        value.resultType !== "input_required") {
+        return {
+            error: { code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR, message: "Unrecognized MCP resultType" }
+        };
+    }
+    if (value.resultType === "input_required") {
+        const invalid = validateInputRequiredResult(method, value, clientCapabilities);
+        if (invalid !== undefined)
+            return invalid;
+    }
+    const result = {
+        ...value,
+        resultType: value.resultType ?? "complete",
+        _meta: {
+            ...(isRecord(value._meta) ? value._meta : {}),
+            "io.modelcontextprotocol/serverInfo": { ...serverInfo }
+        }
+    };
+    if (cacheableMethods.has(method) && result.resultType === "complete") {
+        const cacheableResult = { ...result, ttlMs: value.ttlMs === undefined ? 0 : value.ttlMs, cacheScope: value.cacheScope === undefined ? "private" : value.cacheScope };
+        const cacheError = validateCacheMetadata(method, cacheableResult);
+        if (cacheError !== undefined) {
+            return { error: { code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR, message: cacheError } };
+        }
+        return { result: cacheableResult };
+    }
+    return { result };
+}
+export { validateProtocolValue, validateServerResult } from "./protocol-validation.js";
+export { isJsonValue } from "toolcraft-schema";
+export { isBase64 } from "./base64.js";
+export { isValidUri } from "./uri.js";
+export { isValidMetadata } from "./metadata.js";

package/node_modules/tiny-stdio-mcp-server/dist/request-cancellation.d.ts

@@ -0,0 +1 @@
+export declare function waitForRequest<T>(operation: Promise<T>, signal: AbortSignal): Promise<T | undefined>;

package/node_modules/tiny-stdio-mcp-server/dist/request-cancellation.js

@@ -0,0 +1,18 @@
+export function waitForRequest(operation, signal) {
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            signal.removeEventListener("abort", abort);
+            resolve(undefined);
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted)
+            abort();
+        operation.then((value) => {
+            signal.removeEventListener("abort", abort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", abort);
+            reject(error);
+        });
+    });
+}

package/node_modules/tiny-stdio-mcp-server/dist/sampling-messages.d.ts

@@ -0,0 +1,18 @@
+type SamplingContent = {
+    type: "tool_use";
+    id: string;
+} | {
+    type: "tool_result";
+    toolUseId: string;
+} | {
+    type: "text" | "image" | "audio";
+};
+export interface SamplingMessage {
+    role: "user" | "assistant";
+    content: SamplingContent | SamplingContent[];
+}
+export declare function inspectSamplingMessages(messages: readonly SamplingMessage[]): {
+    valid: boolean;
+    usesTools: boolean;
+};
+export {};

package/node_modules/tiny-stdio-mcp-server/dist/sampling-messages.js

@@ -0,0 +1,34 @@
+// Field schemas must be validated before checking cross-message invariants.
+export function inspectSamplingMessages(messages) {
+    let pending;
+    let usesTools = false;
+    const seenIds = new Set();
+    for (const message of messages) {
+        const content = Array.isArray(message.content) ? message.content : [message.content];
+        if (pending !== undefined) {
+            if (message.role !== "user")
+                return { valid: false, usesTools };
+            for (const block of content) {
+                if (block.type !== "tool_result" || !pending.delete(block.toolUseId))
+                    return { valid: false, usesTools };
+            }
+            if (pending.size > 0)
+                return { valid: false, usesTools };
+            pending = undefined;
+            continue;
+        }
+        for (const block of content) {
+            if (block.type === "tool_result")
+                return { valid: false, usesTools };
+            if (block.type !== "tool_use")
+                continue;
+            if (message.role !== "assistant" || seenIds.has(block.id))
+                return { valid: false, usesTools };
+            seenIds.add(block.id);
+            pending ??= new Set();
+            pending.add(block.id);
+            usesTools = true;
+        }
+    }
+    return { valid: pending === undefined, usesTools };
+}

package/node_modules/tiny-stdio-mcp-server/dist/schema.d.ts

@@ -1,4 +1,4 @@
-import type { JSONSchema } from "./types.js";
+import type { JSONSchema, OutputSchema } from "./types.js";
 type SchemaPropertyType = "string" | "number" | "integer" | "boolean" | "object" | "array";
 interface SchemaPropertyDef {
     type: SchemaPropertyType;
@@ -16,5 +16,8 @@ type InferSchema<T extends SchemaDefinition> = {
 export interface TypedSchema<T> extends JSONSchema {
     __type?: T;
 }
+export interface TypedOutputSchema<T> extends OutputSchema {
+    __type?: T;
+}
 export declare function defineSchema<T extends SchemaDefinition>(definition: T): TypedSchema<InferSchema<T>>;
 export {};

package/node_modules/tiny-stdio-mcp-server/dist/server.d.ts

@@ -1,7 +1,7 @@
 import type { ServerOptions, ToolDefinition, ToolHandler, HandleResult, Prompt, PromptHandler, Resource, ResourceHandler, ResourceTemplate, Transport, SDKTransport, JSONRPCNotification } from "./types.js";
-import type { TypedSchema } from "./schema.js";
+import type { TypedSchema, TypedOutputSchema } from "./schema.js";
 export interface Server {
-    tool<TIn, TOut = never>(name: string, description: string, inputSchema: TypedSchema<TIn>, handler: ToolHandler<TIn, TOut>, outputSchema?: TypedSchema<TOut>): Server;
+    tool<TIn, TOut = never>(name: string, description: string, inputSchema: TypedSchema<TIn>, handler: ToolHandler<TIn, TOut>, outputSchema?: TypedOutputSchema<TOut>): Server;
     registerTool<TIn, TOut = never>(definition: Omit<ToolDefinition<TIn, TOut>, "handler">, handler: ToolHandler<TIn, TOut>): Server;
     prompt(definition: Prompt, handler: PromptHandler): Server;
     resource(definition: Resource, handler: ResourceHandler): Server;
@@ -17,7 +17,7 @@ export interface Server {
     notifyResourcesChanged(): Promise<void>;
     notifyResourceUpdated(uri: string): Promise<void>;
     createMessageSession(listener?: (notification: JSONRPCNotification) => void | Promise<void>): MessageSession;
-    handleMessage(method: string, params?: Record<string, unknown>): Promise<HandleResult>;
+    handleMessage(method: string, params?: Record<string, unknown>, context?: MessageRequestContext): Promise<HandleResult>;
     listen(): Promise<void>;
     connect(transport: Transport): Promise<void>;
     connectSDK(transport: SDKTransport): Promise<void>;
@@ -26,8 +26,13 @@ export interface MessageSessionContext {
     readonly signal: AbortSignal;
     notify(method: string, params?: Record<string, unknown>): Promise<void>;
 }
+export interface MessageRequestContext {
+    requestId?: string | number;
+    signal?: AbortSignal;
+    parameterHeaders?: Record<string, string | string[] | undefined>;
+}
 export type CustomMethodHandler = (params: Record<string, unknown> | undefined, session: MessageSessionContext) => unknown | Promise<unknown>;
-export type MessageHandler = (method: string, params?: Record<string, unknown>) => Promise<HandleResult>;
+export type MessageHandler = (method: string, params?: Record<string, unknown>, context?: MessageRequestContext) => Promise<HandleResult>;
 export interface MessageSession {
     handleMessage: MessageHandler;
     close(): void;