@emseepea/server 0.7.0 → 0.9.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import { createMcpFastifyApp } from "@modelcontextprotocol/fastify";
 import { GetPromptResultSchema, ReadResourceResultSchema, } from "@modelcontextprotocol/core";
 import { toNodeHandler } from "@modelcontextprotocol/node";
-import { McpServer, InMemoryServerEventBus, OAuthError, OAuthErrorCode, ProtocolError, ProtocolErrorCode, ResourceTemplate, bearerAuthChallengeResponse, buildOAuthProtectedResourceMetadata, checkResourceAllowed, completable, createMcpHandler, getOAuthProtectedResourceMetadataUrl, inputRequired as sdkInputRequired, acceptedContent as sdkAcceptedContent, inputResponse as sdkInputResponse, isInputRequiredResult, oauthMetadataResponse, specTypeSchemas, verifyBearerToken, } from "@modelcontextprotocol/server";
+import { McpServer, InMemoryServerEventBus, OAuthError, OAuthErrorCode, ProtocolError, ProtocolErrorCode, ResourceTemplate, bearerAuthChallengeResponse, buildOAuthProtectedResourceMetadata, checkResourceAllowed, classifyInboundRequest, completable, createMcpHandler, createRequestStateCodec, getOAuthProtectedResourceMetadataUrl, inputRequired as sdkInputRequired, acceptedContent as sdkAcceptedContent, inputResponse as sdkInputResponse, isInputRequiredResult, oauthMetadataResponse, specTypeSchemas, verifyBearerToken, } from "@modelcontextprotocol/server";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash } from "node:crypto";
 import { readdir, realpath } from "node:fs/promises";
@@ -12,7 +12,7 @@ import { z } from "zod";
 import { installObservability, } from "./telemetry.js";
 export { openTelemetry, structuredLogging, } from "./telemetry.js";
 export * from "./ui.js";
-export const inputRequired = Object.assign((spec) => sdkInputRequired({ inputRequests: spec.inputRequests }), {
+export const inputRequired = Object.assign((spec) => sdkInputRequired(spec), {
     elicit: sdkInputRequired.elicit,
     elicitUrl: sdkInputRequired.elicitUrl,
 });
@@ -24,6 +24,14 @@ export function inputResponse(responses, key) {
     return response.kind === "elicit" ? response : { kind: "missing" };
 }
 const PROTOCOL_VERSION = "2026-07-28";
+const LEGACY_PROTOCOL_VERSIONS = Object.freeze([
+    "2025-11-25",
+    "2025-06-18",
+    "2025-03-26",
+    "2024-11-05",
+    "2024-10-07",
+]);
+const SUPPORTED_PROTOCOLS = Object.freeze([PROTOCOL_VERSION, ...LEGACY_PROTOCOL_VERSIONS]);
 const REGISTER = Symbol("register");
 const DISCOVERABLE = Symbol("discoverable");
 const TOOL_NAME = Symbol("toolName");
@@ -51,6 +59,45 @@ const CACHEABLE_METHODS = [
 ];
 const runtimes = new WeakMap();
 const requestOperations = new AsyncLocalStorage();
+function createRequestStateRuntime(options) {
+    if (typeof options.key !== "string" && !(options.key instanceof Uint8Array)) {
+        throw new TypeError("requestState.key must be a string or Uint8Array");
+    }
+    const ttlSeconds = positiveInteger("requestState.ttlSeconds", options.ttlSeconds);
+    const maxBytes = positiveInteger("requestState.maxBytes", options.maxBytes ?? 4 * 1024);
+    const codec = createRequestStateCodec({
+        key: typeof options.key === "string" ? options.key : Uint8Array.from(options.key),
+        ttlSeconds,
+        bind(context) {
+            const operation = requestOperations.getStore();
+            if (!operation?.capability)
+                throw new Error("request state has no capability binding");
+            const principal = operation.principal;
+            return JSON.stringify([
+                context.mcpReq.method,
+                operation.capability,
+                principal
+                    ? [principal.clientId, [...principal.permissions].sort(), principal.resource ?? null]
+                    : null,
+            ]);
+        },
+    });
+    const assertWireSize = (state) => {
+        if (Buffer.byteLength(state, "utf8") > maxBytes)
+            throw new Error("request state is oversized");
+    };
+    return Object.freeze({
+        async mint(payload, context) {
+            const state = await codec.mint(payload, context);
+            assertWireSize(state);
+            return state;
+        },
+        async verify(state, context) {
+            assertWireSize(state);
+            return codec.verify(state, context);
+        },
+    });
+}
 export function defineTool(definition) {
     const handler = definition.handler;
     return createCheckedTool(definition, handler, false, true);
@@ -126,21 +173,16 @@ export function defineResource(definition) {
             value: listing,
         }),
         [HAS_COMPLETION]: false,
-        [REGISTER](server, timeoutMs, maxApplicationResultBytes) {
+        [REGISTER](server, timeoutMs, maxApplicationResultBytes, requestState, clientLogging) {
             server.registerResource(name, uri, cacheHint ? { ...metadata, cacheHint } : metadata, async (_requestedUri, context) => {
                 try {
                     const deadlineMs = requestOperations.getStore()?.deadlineMs ?? Date.now() + timeoutMs;
                     return await runWithDeadline(context.mcpReq.signal, deadlineMs, async (signal) => {
                         signal.throwIfAborted();
-                        const result = await handler({
-                            signal,
-                            deadlineMs,
-                            principal: access === "public" ? undefined : principalFrom(context.http?.authInfo),
-                            inputResponses: checkedInputResponses(context.mcpReq.inputResponses),
-                        });
+                        const result = await withClientLogReporter(context, signal, clientLogging, (reportLog) => handler(directHandlerContext(access, context, signal, deadlineMs, requestState, reportLog)));
                         signal.throwIfAborted();
                         if (isInputRequiredResult(result)) {
-                            assertStatelessInputRequired(result);
+                            await assertInputRequired(result, requestState, context);
                             assertResultSize(result, maxApplicationResultBytes, deadlineMs, signal);
                             return result;
                         }
@@ -203,7 +245,7 @@ export function defineResourceTemplate(definition) {
             value: listing,
         }),
         [HAS_COMPLETION]: completions.size > 0,
-        [REGISTER](server, timeoutMs, maxApplicationResultBytes) {
+        [REGISTER](server, timeoutMs, maxApplicationResultBytes, requestState, clientLogging) {
             const registeredTemplate = completions.size === 0
                 ? template
                 : new ResourceTemplate(uriTemplate, {
@@ -218,15 +260,10 @@ export function defineResourceTemplate(definition) {
                     const deadlineMs = requestOperations.getStore()?.deadlineMs ?? Date.now() + timeoutMs;
                     return await runWithDeadline(context.mcpReq.signal, deadlineMs, async (signal) => {
                         signal.throwIfAborted();
-                        const result = await handler({ uri: requestedUri.href, variables }, {
-                            signal,
-                            deadlineMs,
-                            principal: access === "public" ? undefined : principalFrom(context.http?.authInfo),
-                            inputResponses: checkedInputResponses(context.mcpReq.inputResponses),
-                        });
+                        const result = await withClientLogReporter(context, signal, clientLogging, (reportLog) => handler({ uri: requestedUri.href, variables }, directHandlerContext(access, context, signal, deadlineMs, requestState, reportLog)));
                         signal.throwIfAborted();
                         if (isInputRequiredResult(result)) {
-                            assertStatelessInputRequired(result);
+                            await assertInputRequired(result, requestState, context);
                             assertResultSize(result, maxApplicationResultBytes, deadlineMs, signal);
                             return result;
                         }
@@ -274,7 +311,7 @@ export function definePrompt(definition) {
         [PROMPT_ACCESS]: access,
         [HAS_COMPLETION]: completions.size > 0,
         [PROMPT_LISTING]: listing,
-        [REGISTER](server, timeoutMs, maxApplicationResultBytes) {
+        [REGISTER](server, timeoutMs, maxApplicationResultBytes, requestState, clientLogging) {
             server.registerPrompt(name, {
                 ...metadata,
                 argsSchema: sdkPromptMetadataSchema(argsSchema, completions, argumentNames, timeoutMs, maxApplicationResultBytes),
@@ -286,15 +323,10 @@ export function definePrompt(definition) {
                         if (!parsedArgs.success)
                             throw new Error("Prompt received invalid arguments");
                         signal.throwIfAborted();
-                        const result = await handler(parsedArgs.data, {
-                            signal,
-                            deadlineMs,
-                            principal: access === "public" ? undefined : principalFrom(context.http?.authInfo),
-                            inputResponses: checkedInputResponses(context.mcpReq.inputResponses),
-                        });
+                        const result = await withClientLogReporter(context, signal, clientLogging, (reportLog) => handler(parsedArgs.data, directHandlerContext(access, context, signal, deadlineMs, requestState, reportLog)));
                         signal.throwIfAborted();
                         if (isInputRequiredResult(result)) {
-                            assertStatelessInputRequired(result);
+                            await assertInputRequired(result, requestState, context);
                             assertResultSize(result, maxApplicationResultBytes, deadlineMs, signal);
                             return result;
                         }
@@ -464,7 +496,10 @@ function createCheckedTool(definition, execute, streaming, allowsInputRequired)
         [TOOL_ACCESS]: access,
         [TOOL_STREAMING]: streaming,
         [TOOL_LISTING]: listing,
-        [REGISTER](server, timeoutMs, maxApplicationResultBytes, maxProgressEvents, maxProgressEventBytes) {
+        [REGISTER](server, timeoutMs, maxApplicationResultBytes, maxProgressEvents, maxProgressEventBytes, requestState, clientLogging) {
+            const runLoggedTool = clientLogging
+                ? createLoggedToolRunner(clientLogging, execute, allowsInputRequired, access, requestState)
+                : undefined;
             server.registerTool(name, metadata, async (input, context) => {
                 try {
                     const deadlineMs = requestOperations.getStore()?.deadlineMs ?? Date.now() + timeoutMs;
@@ -478,26 +513,32 @@ function createCheckedTool(definition, execute, streaming, allowsInputRequired)
                             ? progressReporter(context, signal, maxProgressEvents, maxProgressEventBytes)
                             : undefined;
                         let result;
-                        try {
-                            result = await execute(parsedInput.data, {
-                                signal,
-                                deadlineMs,
-                                principal: access === "public" ? undefined : principalFrom(context.http?.authInfo),
-                                ...(allowsInputRequired
-                                    ? {
-                                        inputResponses: checkedInputResponses(context.mcpReq.inputResponses),
-                                    }
-                                    : {}),
-                                ...(reporter ? { reportProgress: reporter.report } : {}),
-                            });
+                        if (runLoggedTool) {
+                            result = await runLoggedTool(parsedInput.data, context, signal, deadlineMs, reporter);
                         }
-                        finally {
-                            await reporter?.finish();
+                        else {
+                            try {
+                                const handlerContext = allowsInputRequired
+                                    ? directHandlerContext(access, context, signal, deadlineMs, requestState)
+                                    : {
+                                        signal,
+                                        deadlineMs,
+                                        principal: access === "public"
+                                            ? undefined
+                                            : principalFrom(context.http?.authInfo),
+                                    };
+                                if (reporter)
+                                    Object.assign(handlerContext, { reportProgress: reporter.report });
+                                result = await execute(parsedInput.data, handlerContext);
+                            }
+                            finally {
+                                await reporter?.finish();
+                            }
+                            reporter?.throwIfFailed();
                         }
-                        reporter?.throwIfFailed();
                         if (allowsInputRequired && isInputRequiredResult(result)) {
                             signal.throwIfAborted();
-                            assertStatelessInputRequired(result);
+                            await assertInputRequired(result, requestState, context);
                             assertResultSize(result, maxApplicationResultBytes, deadlineMs, signal);
                             return result;
                         }
@@ -528,6 +569,33 @@ function createCheckedTool(definition, execute, streaming, allowsInputRequired)
     };
     return Object.freeze(registration);
 }
+function createLoggedToolRunner(clientLogging, execute, allowsInputRequired, access, requestState) {
+    return async (input, context, signal, deadlineMs, reporter) => {
+        const logReporter = clientLogReporter(context, signal, clientLogging.maxEvents, clientLogging.maxEventBytes);
+        let result;
+        try {
+            result = await execute(input, {
+                ...(allowsInputRequired
+                    ? directHandlerContext(access, context, signal, deadlineMs, requestState, logReporter.report)
+                    : {
+                        signal,
+                        deadlineMs,
+                        principal: access === "public"
+                            ? undefined
+                            : principalFrom(context.http?.authInfo),
+                        reportLog: logReporter.report,
+                    }),
+                ...(reporter ? { reportProgress: reporter.report } : {}),
+            });
+        }
+        finally {
+            await Promise.all([reporter?.finish(), logReporter.finish()]);
+        }
+        reporter?.throwIfFailed();
+        logReporter.throwIfFailed();
+        return result;
+    };
+}
 function progressReporter(context, signal, maxEvents, maxEventBytes) {
     const token = context.mcpReq._meta?.progressToken;
     let closed = false;
@@ -583,6 +651,74 @@ function progressReporter(context, signal, maxEvents, maxEventBytes) {
             throw failure; },
     };
 }
+function clientLogReporter(context, signal, maxEvents, maxEventBytes) {
+    let closed = false;
+    let failure;
+    let attempts = 0;
+    const pending = new Set();
+    return {
+        report(message) {
+            if (closed)
+                return Promise.reject(new Error("Client logging is no longer available"));
+            if (failure)
+                return Promise.reject(failure);
+            const operation = (async () => {
+                try {
+                    signal.throwIfAborted();
+                    attempts += 1;
+                    if (attempts > maxEvents)
+                        throw new Error("Client log event limit exceeded");
+                    const notification = {
+                        method: "notifications/message",
+                        params: {
+                            level: message.level,
+                            data: message.data,
+                            ...(message.logger === undefined ? {} : { logger: message.logger }),
+                        },
+                    };
+                    assertJsonValue(notification, new WeakSet());
+                    const encoded = JSON.stringify(notification);
+                    if (Buffer.byteLength(encoded, "utf8") > maxEventBytes) {
+                        throw new Error("Client log event exceeds configured size limit");
+                    }
+                    const parsed = specTypeSchemas.LoggingMessageNotification["~standard"].validate(JSON.parse(encoded));
+                    if (parsed instanceof Promise || "issues" in parsed) {
+                        throw new Error("Client log event is invalid");
+                    }
+                    const params = parsed.value.params;
+                    await context.mcpReq.log(params.level, params.data, params.logger);
+                }
+                catch (error) {
+                    failure = error instanceof Error ? error : new Error("Client log emission failed");
+                    throw failure;
+                }
+            })();
+            pending.add(operation);
+            void operation.then(() => pending.delete(operation), () => pending.delete(operation));
+            return operation;
+        },
+        async finish() {
+            closed = true;
+            await Promise.allSettled(pending);
+        },
+        throwIfFailed() { if (failure)
+            throw failure; },
+    };
+}
+async function withClientLogReporter(context, signal, options, run) {
+    const reporter = options
+        ? clientLogReporter(context, signal, options.maxEvents, options.maxEventBytes)
+        : undefined;
+    let result;
+    try {
+        result = await run(reporter?.report);
+    }
+    finally {
+        await reporter?.finish();
+    }
+    reporter?.throwIfFailed();
+    return result;
+}
 function catalogueListings(tools, resources, prompts, supportedTools = tools, supportedResources = resources, supportedPrompts = prompts) {
     const catalogues = new Map();
     if (supportedTools.length)
@@ -745,7 +881,20 @@ export function createEmseepea(options) {
         ? normalizeListPagination(options.listPagination)
         : undefined;
     const maxRequestBytes = positiveInteger("maxRequestBytes", options.maxRequestBytes ?? 1024 * 1024);
+    const requestState = options.requestState
+        ? createRequestStateRuntime(options.requestState)
+        : undefined;
     const maxApplicationResultBytes = positiveInteger("maxApplicationResultBytes", options.maxApplicationResultBytes ?? 1024 * 1024);
+    const clientLoggingOptions = options.clientLogging;
+    if (clientLoggingOptions !== undefined && !isRecord(clientLoggingOptions)) {
+        throw new TypeError("clientLogging must be an object");
+    }
+    const clientLogging = clientLoggingOptions === undefined
+        ? undefined
+        : Object.freeze({
+            maxEvents: positiveInteger("clientLogging.maxEvents", clientLoggingOptions.maxEvents ?? 32),
+            maxEventBytes: positiveInteger("clientLogging.maxEventBytes", clientLoggingOptions.maxEventBytes ?? 8 * 1024),
+        });
     const maxProgressEvents = positiveInteger("maxProgressEvents", options.maxProgressEvents ?? 32);
     const maxProgressEventBytes = positiveInteger("maxProgressEventBytes", options.maxProgressEventBytes ?? 8 * 1024);
     const operationTimeoutMs = positiveInteger("operationTimeoutMs", options.operationTimeoutMs ?? 30_000);
@@ -825,26 +974,34 @@ export function createEmseepea(options) {
             : discoverablePrompts;
         const activeHasCompletion = activeResources.some((resource) => resource[HAS_COMPLETION]) ||
             activePrompts.some((prompt) => prompt[HAS_COMPLETION]);
+        const activeClientLogging = request?.legacy ? undefined : clientLogging;
         const server = new McpServer(serverInfo, {
             capabilities: {
                 ...(activeTools.length ? { tools: { listChanged: false } } : {}),
                 ...(activeResources.length ? {
-                    resources: { subscribe: Boolean(resourceSubscriptions), listChanged: false },
+                    resources: {
+                        subscribe: Boolean(resourceSubscriptions) && !request?.legacy,
+                        listChanged: false,
+                    },
                 } : {}),
                 ...(activePrompts.length ? { prompts: { listChanged: false } } : {}),
                 ...(activeHasCompletion ? { completions: {} } : {}),
+                ...(activeClientLogging ? { logging: {} } : {}),
             },
             instructions: options.instructions,
-            cacheHints: request?.filterCatalogues ? undefined : cacheHints,
-            supportedProtocolVersions: [PROTOCOL_VERSION],
+            cacheHints: request?.filterCatalogues || request?.legacy ? undefined : cacheHints,
+            supportedProtocolVersions: [...SUPPORTED_PROTOCOLS],
+            ...(requestState && !request?.legacy ? { requestState: { verify: requestState.verify } } : {}),
         });
         for (const tool of activeTools) {
-            tool[REGISTER](server, operationTimeoutMs, maxApplicationResultBytes, maxProgressEvents, maxProgressEventBytes);
+            tool[REGISTER](server, operationTimeoutMs, maxApplicationResultBytes, maxProgressEvents, maxProgressEventBytes, requestState, activeClientLogging);
+        }
+        for (const resource of activeResources) {
+            resource[REGISTER](server, operationTimeoutMs, maxApplicationResultBytes, requestState, activeClientLogging);
+        }
+        for (const prompt of activePrompts) {
+            prompt[REGISTER](server, operationTimeoutMs, maxApplicationResultBytes, requestState, activeClientLogging);
         }
-        for (const resource of activeResources)
-            resource[REGISTER](server, operationTimeoutMs, maxApplicationResultBytes);
-        for (const prompt of activePrompts)
-            prompt[REGISTER](server, operationTimeoutMs, maxApplicationResultBytes);
         const filteredCatalogues = request?.filterCatalogues
             ? catalogueListings(activeDiscoverableTools, activeDiscoverableResources, activeDiscoverablePrompts, activeTools, activeResources, activePrompts)
             : undefined;
@@ -861,8 +1018,7 @@ export function createEmseepea(options) {
             installListPagination(server, pagination);
         return server;
     }, {
-        legacy: "reject",
-        responseMode: hasStreaming || resourceSubscriptions ? "auto" : "json",
+        responseMode: hasStreaming || resourceSubscriptions || clientLogging ? "auto" : "json",
         keepAliveMs: 0,
     });
     const nodeHandler = toNodeHandler(sdkHandler);
@@ -979,16 +1135,40 @@ export function createEmseepea(options) {
         if (deployment.mode === "production-behind-proxy" &&
             !validateProductionRequest(request, reply, deployment, limiter))
             return;
-        if (!await validateMcpRequestHeaders(request, reply))
+        const protocolVersionHeader = singleHeader(request.raw.rawHeaders, "mcp-protocol-version");
+        const mcpMethodHeader = singleHeader(request.raw.rawHeaders, "mcp-method");
+        const mcpNameHeader = singleHeader(request.raw.rawHeaders, "mcp-name");
+        if (protocolVersionHeader === null || mcpMethodHeader === null || mcpNameHeader === null) {
+            await sendRpcError(reply, 400, -32020, "Conflicting MCP headers", requestId(isRecord(request.body) ? request.body.id : undefined));
+            return;
+        }
+        const classification = classifyInboundRequest({
+            httpMethod: request.method,
+            ...(protocolVersionHeader ? { protocolVersionHeader } : {}),
+            ...(mcpMethodHeader ? { mcpMethodHeader } : {}),
+            ...(mcpNameHeader ? { mcpNameHeader } : {}),
+            body: request.body,
+        });
+        if (classification.kind === "reject") {
+            await sendRpcError(reply, classification.httpStatus, classification.code, classification.message, requestId(isRecord(request.body) ? request.body.id : undefined), isRecord(classification.data) ? classification.data : undefined);
             return;
-        if (isRecord(request.body) && typeof request.body.method === "string" &&
+        }
+        const legacy = classification.kind === "legacy";
+        if (legacy && classification.requestedVersion &&
+            !LEGACY_PROTOCOL_VERSIONS.includes(classification.requestedVersion)) {
+            await sendRpcError(reply, 400, ProtocolErrorCode.UnsupportedProtocolVersion, `Unsupported protocol version: ${classification.requestedVersion}`, requestId(isRecord(request.body) ? request.body.id : undefined), { requested: classification.requestedVersion, supported: [...SUPPORTED_PROTOCOLS] });
+            return;
+        }
+        if (!await validateMcpRequestHeaders(request, reply, legacy))
+            return;
+        if (!legacy && isRecord(request.body) && typeof request.body.method === "string" &&
             !enabledMethods.has(request.body.method)) {
             await sendRpcError(reply, 404, -32601, "Method not found", requestId(request.body.id));
             return;
         }
         const protectsCatalogue = authentication?.discovery === "protected";
         let subscriptionTarget;
-        if (isRecord(request.body) && request.body.method === "subscriptions/listen") {
+        if (!legacy && isRecord(request.body) && request.body.method === "subscriptions/listen") {
             try {
                 subscriptionTarget = resourceSubscriptionTarget(request.body, resourceSubscriptions.maxUriBytes, resourcesByUri, resourceTemplates);
             }
@@ -1030,6 +1210,7 @@ export function createEmseepea(options) {
             await serveResourceSubscription(request, reply, subscriptionTarget.uri);
             return;
         }
+        const capability = capabilityNameForRequest(request.body, toolsByName, resourcesByUri, resourceTemplates, promptsByName);
         const disconnected = new AbortController();
         const abort = () => disconnected.abort();
         request.raw.once("aborted", abort);
@@ -1043,6 +1224,8 @@ export function createEmseepea(options) {
                 signal: disconnected.signal,
                 principal,
                 filterCatalogues: protectsCatalogue,
+                capability,
+                legacy,
             }, () => nodeHandler(request.raw, reply.raw, request.body));
         }
         finally {
@@ -1503,14 +1686,14 @@ function singleHeader(rawHeaders, name) {
     }
     return values.length === 0 ? undefined : values.length === 1 ? values[0] : null;
 }
-async function validateMcpRequestHeaders(request, reply) {
+async function validateMcpRequestHeaders(request, reply, legacy) {
     const body = request.body;
     const id = isRecord(body) ? requestId(body.id) : null;
     if (!acceptsMcpResponses(request.headers.accept)) {
         await sendRpcError(reply, 406, -32000, "Not Acceptable: Client must accept both application/json and text/event-stream", id);
         return false;
     }
-    if (!isRecord(body) || typeof body.method !== "string")
+    if (legacy || !isRecord(body) || typeof body.method !== "string")
         return true;
     const header = (name) => singleHeader(request.raw.rawHeaders, name);
     const rejectMismatch = async (name) => {
@@ -2015,13 +2198,31 @@ function nonNegativePort(value) {
     }
     return value;
 }
-function assertStatelessInputRequired(result) {
-    if (!result.inputRequests || result.requestState !== undefined) {
-        throw new Error("Client-input requests must be stateless");
+function directHandlerContext(access, context, signal, deadlineMs, requestState, reportLog) {
+    return {
+        signal,
+        deadlineMs,
+        principal: access === "public" ? undefined : principalFrom(context.http?.authInfo),
+        inputResponses: checkedInputResponses(context.mcpReq.inputResponses),
+        ...(requestState ? {
+            requestState: context.mcpReq.requestState(),
+            mintRequestState: (payload) => requestState.mint(payload, context),
+        } : {}),
+        ...(reportLog ? { reportLog } : {}),
+    };
+}
+async function assertInputRequired(result, requestState, context) {
+    if (!result.inputRequests && result.requestState === undefined) {
+        throw new Error("Client-input result must include requests or state");
     }
-    if (Object.values(result.inputRequests).some((request) => request.method !== "elicitation/create")) {
+    if (result.inputRequests && Object.values(result.inputRequests).some((request) => request.method !== "elicitation/create")) {
         throw new Error("Client-input request kind is not supported");
     }
+    if (result.requestState !== undefined) {
+        if (!requestState)
+            throw new Error("Client-input request state is not configured");
+        await requestState.verify(result.requestState, context);
+    }
 }
 function assertResultSize(result, maxApplicationResultBytes, deadlineMs, signal) {
     let serialized;