@salesforce/b2c-dx-mcp 3.0.1 → 3.1.0

package/dist/tools/scapi/execution-registry.d.ts

@@ -0,0 +1,62 @@
+import type { ScapiConfirmation, ScapiRuntimeControl } from '@salesforce/b2c-tooling-sdk/scapi';
+import type { ToolContext, ToolResult } from '../../utils/types.js';
+declare function deferred<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: Error) => void;
+};
+interface OperationRecord {
+    kind: 'auth' | 'request';
+    method?: string;
+    path?: string;
+    status: 'awaiting_confirmation' | 'completed' | 'failed' | 'in_flight' | 'not_sent' | 'unknown';
+    httpStatus?: number;
+}
+interface ApprovalRound {
+    state: string;
+    key: string;
+    prompt: ToolResult;
+    decision: ReturnType<typeof deferred<void>>;
+    responded?: boolean;
+}
+/** One worker survives protocol round trips; none of its code is replayed. */
+export declare class ScapiExecution {
+    readonly digest: string;
+    private readonly supportsElicitation;
+    private readonly mintState;
+    control?: ScapiRuntimeControl;
+    readonly controller: AbortController;
+    done: Promise<void>;
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    readonly operations: OperationRecord[];
+    result?: ToolResult;
+    readonly rounds: Map<string, ApprovalRound>;
+    private cancellation?;
+    private cancellationListeners;
+    private dispatched;
+    private event;
+    private pending?;
+    private queue;
+    constructor(digest: string, supportsElicitation: boolean, mintState: (round: number) => string);
+    cancel(reason?: string): void;
+    confirm(request: ScapiConfirmation): Promise<void>;
+    finish(result: ToolResult): void;
+    markDispatched(): void;
+    retry(state: string, context: ToolContext): Promise<ToolResult>;
+    runCall<T>(kind: OperationRecord['kind'], input: unknown, operation: () => Promise<T>): Promise<T>;
+    wait(context?: ToolContext): Promise<ToolResult>;
+}
+/** Stdio-server-owned continuations. Terminal records are bounded; tokens never start new work. */
+export declare class ScapiExecutionRegistry {
+    private readonly options;
+    private readonly executions;
+    private readonly secret;
+    constructor(options?: {
+        maxActive?: number;
+    });
+    cancel(id: string): Promise<ToolResult>;
+    destroyAll(): Promise<void>;
+    retry(args: unknown, context: ToolContext): Promise<ToolResult>;
+    start(args: unknown, context: ToolContext | undefined, run: (execution: ScapiExecution) => Promise<ToolResult>): Promise<ToolResult>;
+}
+export {};

package/dist/tools/scapi/execution-registry.js

@@ -0,0 +1,303 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { createHash, createHmac, randomBytes, randomUUID } from 'node:crypto';
+import { inputRequired } from '@modelcontextprotocol/server';
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((yes, no) => {
+        resolve = yes;
+        reject = no;
+    });
+    return { promise, resolve, reject };
+}
+function fingerprint(args) {
+    const canonical = (value) => {
+        if (Array.isArray(value))
+            return value.map((item) => canonical(item));
+        if (value && typeof value === 'object')
+            return Object.fromEntries(Object.entries(value)
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([k, v]) => [k, canonical(v)]));
+        return value;
+    };
+    return createHash('sha256')
+        .update(JSON.stringify(canonical(args)))
+        .digest('hex');
+}
+function errorResult(message) {
+    return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: message }) }] };
+}
+function preview(value) {
+    const json = JSON.stringify(value, (key, item) => (/password|secret|token|authorization|credential/i.test(key) ? '[redacted]' : item), 2) ?? 'none';
+    const excerpt = json.split('\n').slice(0, 5).join('\n');
+    if (excerpt.length === json.length && json.length <= 400)
+        return json;
+    const notice = ' ... [truncated; approval covers full request]';
+    return excerpt.slice(0, 400 - notice.length).trimEnd() + notice;
+}
+/** One worker survives protocol round trips; none of its code is replayed. */
+export class ScapiExecution {
+    digest;
+    supportsElicitation;
+    mintState;
+    control;
+    controller = new AbortController();
+    done;
+    id = randomUUID();
+    operations = [];
+    result;
+    rounds = new Map();
+    cancellation;
+    cancellationListeners = new Map();
+    dispatched = new WeakSet();
+    event = deferred();
+    pending;
+    queue = Promise.resolve();
+    constructor(digest, supportsElicitation, mintState) {
+        this.digest = digest;
+        this.supportsElicitation = supportsElicitation;
+        this.mintState = mintState;
+    }
+    cancel(reason = 'SCAPI_EXECUTION_CANCELLED: explicitly cancelled.') {
+        if (this.result || this.cancellation)
+            return;
+        this.cancellation = reason;
+        const error = new Error(reason);
+        this.controller.abort(error);
+        this.pending?.decision.reject(error);
+    }
+    async confirm(request) {
+        this.controller.signal.throwIfAborted();
+        const record = this.operations.at(-1);
+        if (record)
+            record.status = 'awaiting_confirmation';
+        if (!this.supportsElicitation) {
+            this.cancel('SCAPI_CONFIRMATION_UNSUPPORTED: Confirmation required; this client does not support form elicitation.');
+            this.controller.signal.throwIfAborted();
+        }
+        const roundNumber = this.rounds.size + 1;
+        const state = this.mintState(roundNumber);
+        const key = `approve_${roundNumber}`;
+        const path = new URL(request.url).pathname;
+        const organizationId = path.match(/\/organizations\/([^/]+)/)?.[1];
+        const earlierWrites = this.operations.filter((item) => item.kind === 'request' && !['GET', 'HEAD', 'OPTIONS'].includes(item.method ?? '') && this.dispatched.has(item)).length;
+        const message = [
+            `Approve SCAPI operation: ${request.operationId}`,
+            ...(organizationId ? [`Organization: ${organizationId}`] : []),
+            `${request.method} ${path}`,
+            ...(Object.keys(request.query).length > 0 ? [`Query:\n${preview(request.query)}`] : []),
+            ...(request.body === undefined ? [] : [`Body:\n${preview(request.body)}`]),
+            'Safety Mode requires approval. Declining stops this execution.',
+            earlierWrites ? `Earlier write requests sent: ${earlierWrites}; no rollback.` : 'No earlier writes.',
+            `Execution: ${this.id}`,
+        ].join('\n');
+        const prompt = {
+            ...inputRequired({
+                requestState: state,
+                inputRequests: {
+                    [key]: inputRequired.elicit({
+                        message,
+                        requestedSchema: {
+                            type: 'object',
+                            properties: { approve: { type: 'boolean', title: 'Approve this request only', default: false } },
+                            required: ['approve'],
+                        },
+                    }),
+                },
+            }),
+            // Keep the local tool result shape; the SDK dispatches by resultType before content.
+            content: [],
+            _meta: {
+                executionId: this.id,
+                status: 'awaiting_confirmation',
+                operations: structuredClone(this.operations),
+            },
+        };
+        const round = { state, key, prompt, decision: deferred() };
+        this.pending = round;
+        this.rounds.set(state, round);
+        this.control?.pauseTimeout();
+        this.event.resolve(prompt);
+        try {
+            await round.decision.promise;
+            this.controller.signal.throwIfAborted();
+            if (record)
+                record.status = 'in_flight';
+        }
+        finally {
+            this.pending = undefined;
+            this.control?.resumeTimeout();
+        }
+    }
+    finish(result) {
+        this.controller.abort(new Error('SCAPI_EXECUTION_FINISHED'));
+        for (const [signal, listener] of this.cancellationListeners)
+            signal.removeEventListener('abort', listener);
+        this.cancellationListeners.clear();
+        this.pending?.decision.reject(new Error('SCAPI_EXECUTION_FINISHED'));
+        for (const record of this.operations) {
+            if (record.status === 'awaiting_confirmation')
+                record.status = 'not_sent';
+            else if (record.status === 'in_flight')
+                record.status = this.dispatched.has(record) ? 'unknown' : 'not_sent';
+        }
+        const output = this.cancellation ? { ...result, isError: true } : result;
+        const first = output.content[0];
+        const data = first?.type === 'text' ? JSON.parse(first.text) : {};
+        if (this.cancellation) {
+            delete data.result;
+            data.error = this.cancellation + ' Check earlier writes before retrying; no rollback is performed.';
+        }
+        this.result = {
+            ...output,
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        ...data,
+                        executionId: this.id,
+                        status: this.cancellation ? 'cancelled' : output.isError ? 'failed' : 'completed',
+                        operations: this.operations,
+                    }),
+                },
+            ],
+        };
+        this.event.resolve(this.result);
+    }
+    markDispatched() {
+        const record = this.operations.at(-1);
+        if (record)
+            this.dispatched.add(record);
+    }
+    async retry(state, context) {
+        const round = this.rounds.get(state);
+        if (!round)
+            throw new Error('SCAPI_CONTINUATION_INVALID: unknown or altered continuation.');
+        if (this.cancellation)
+            await this.done;
+        if (this.result)
+            return this.result;
+        if (round.responded)
+            return this.wait(context);
+        if (round !== this.pending)
+            throw new Error('SCAPI_CONTINUATION_STALE: approval round is no longer pending.');
+        const response = context.inputResponses?.[round.key];
+        if (!response)
+            return this.wait(context);
+        this.event = deferred();
+        round.responded = true;
+        const result = this.wait(context);
+        if (!context.supportsElicitation || response.action !== 'accept' || response.content?.approve !== true) {
+            this.cancel('SCAPI_APPROVAL_DECLINED: execution cancelled without sending the pending request.');
+        }
+        else {
+            round.decision.resolve();
+        }
+        return result;
+    }
+    async runCall(kind, input, operation) {
+        const previous = this.queue;
+        const call = previous.then(async () => {
+            this.controller.signal.throwIfAborted();
+            const args = input;
+            const record = {
+                kind,
+                ...(typeof args?.method === 'string' ? { method: args.method.toUpperCase() } : {}),
+                ...(typeof args?.path === 'string' ? { path: args.path.slice(0, 500) } : {}),
+                status: 'in_flight',
+            };
+            this.operations.push(record);
+            try {
+                const result = await operation();
+                record.status = 'completed';
+                if (result && typeof result === 'object' && 'status' in result && typeof result.status === 'number')
+                    record.httpStatus = result.status;
+                return result;
+            }
+            catch (error) {
+                record.status = kind === 'auth' ? 'failed' : this.dispatched.has(record) ? 'unknown' : 'not_sent';
+                throw error;
+            }
+        });
+        this.queue = call.catch(() => { });
+        return call;
+    }
+    async wait(context) {
+        const signal = context?.signal;
+        if (signal && !this.cancellationListeners.has(signal)) {
+            const cancel = () => this.cancel('SCAPI_EXECUTION_CANCELLED: client cancelled the request.');
+            this.cancellationListeners.set(signal, cancel);
+            signal.addEventListener('abort', cancel, { once: true });
+            if (signal.aborted)
+                cancel();
+        }
+        try {
+            return this.result ?? (await this.event.promise);
+        }
+        finally {
+            if (signal && (!context?.keepCancellation || this.result)) {
+                signal.removeEventListener('abort', this.cancellationListeners.get(signal));
+                this.cancellationListeners.delete(signal);
+            }
+        }
+    }
+}
+/** Stdio-server-owned continuations. Terminal records are bounded; tokens never start new work. */
+export class ScapiExecutionRegistry {
+    options;
+    executions = new Map();
+    secret = randomBytes(32);
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async cancel(id) {
+        const execution = this.executions.get(id);
+        if (!execution)
+            throw new Error('SCAPI_EXECUTION_NOT_FOUND: execution is unavailable in this server session.');
+        execution.cancel();
+        await execution.done;
+        return execution.result;
+    }
+    async destroyAll() {
+        for (const execution of this.executions.values())
+            execution.cancel('SCAPI_EXECUTION_CANCELLED: server shutting down.');
+        await Promise.allSettled([...this.executions.values()].map((execution) => execution.done));
+        this.executions.clear();
+    }
+    async retry(args, context) {
+        const state = context.requestState;
+        if (typeof state !== 'string')
+            throw new Error('SCAPI_CONTINUATION_INVALID: expected server-issued requestState.');
+        const execution = this.executions.get(state.split('.')[0]);
+        // Exact server-side lookup validates the MAC and binds state to this server, round and original arguments.
+        if (!execution || !execution.rounds.has(state))
+            throw new Error('SCAPI_CONTINUATION_INVALID: execution unavailable, server restarted, or state was altered.');
+        if (execution.digest !== fingerprint(args))
+            throw new Error('SCAPI_CONTINUATION_MISMATCH: original code, input and target arguments must be unchanged. Start new code with a fresh call.');
+        return execution.retry(state, context);
+    }
+    async start(args, context, run) {
+        if ([...this.executions.values()].filter((execution) => !execution.result).length >= (this.options.maxActive ?? 4))
+            throw new Error('SCAPI_EXECUTION_LIMIT: cancel an existing execution or wait for it to finish.');
+        const digest = fingerprint(args);
+        const execution = new ScapiExecution(digest, context?.supportsElicitation === true, (round) => {
+            const prefix = `${execution.id}.${round}`;
+            return `${prefix}.${createHmac('sha256', this.secret).update(`${prefix}.${digest}`).digest('base64url')}`;
+        });
+        this.executions.set(execution.id, execution);
+        execution.done = Promise.resolve()
+            .then(() => run(execution))
+            .then((result) => execution.finish(result), (error) => execution.finish(errorResult(error instanceof Error ? error.message : String(error))))
+            .then(() => {
+            const terminal = [...this.executions.values()].filter((item) => item.result);
+            for (const item of terminal.slice(0, Math.max(0, terminal.length - 50)))
+                this.executions.delete(item.id);
+        });
+        return execution.wait(context);
+    }
+}
+//# sourceMappingURL=execution-registry.js.map

package/dist/tools/scapi/index.d.ts

@@ -8,10 +8,11 @@
  */
 import type { McpTool } from '../../utils/index.js';
 import type { Services } from '../../services.js';
+import type { ScapiExecutionRegistry } from './execution-registry.js';
 /**
  * Creates all tools for the SCAPI toolset.
  *
  * @param loadServices - Function that loads configuration and returns Services instance
  * @returns Array of MCP tools
  */
-export declare function createScapiTools(loadServices: () => Promise<Services> | Services): McpTool[];
+export declare function createScapiTools(loadServices: () => Promise<Services> | Services, executions?: ScapiExecutionRegistry): McpTool[];

package/dist/tools/scapi/index.js

@@ -13,9 +13,9 @@ import { createScapiCodeTools } from './scapi-code.js';
  * @param loadServices - Function that loads configuration and returns Services instance
  * @returns Array of MCP tools
  */
-export function createScapiTools(loadServices) {
+export function createScapiTools(loadServices, executions) {
     return [
-        ...createScapiCodeTools(loadServices),
+        ...createScapiCodeTools(loadServices, undefined, executions),
         createMetricsGetTool(loadServices),
         createScapiCustomApisStatusTool(loadServices),
         createScapiSchemasListTool(loadServices),

package/dist/tools/scapi/scapi-code.d.ts

@@ -1,3 +1,4 @@
 import type { McpTool } from '../../utils/types.js';
 import type { ServicesLoader } from '../adapter.js';
-export declare function createScapiCodeTools(loadServices: ServicesLoader, snippetDirectory?: string): McpTool[];
+import { ScapiExecutionRegistry } from './execution-registry.js';
+export declare function createScapiCodeTools(loadServices: ServicesLoader, snippetDirectory?: string, registry?: ScapiExecutionRegistry): McpTool[];

package/dist/tools/scapi/scapi-code.js

@@ -4,7 +4,6 @@
  * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
  */
 import { z } from 'zod';
-import { randomUUID } from 'node:crypto';
 import { loadScapiSchemas, runScapiCode, createScapiRequest, createScapiAuth, loadScapiSnippets, saveScapiSnippet, } from '@salesforce/b2c-tooling-sdk/scapi';
 import { toOrganizationId } from '@salesforce/b2c-tooling-sdk/clients';
 import { getB2CConfigDirectory } from '@salesforce/b2c-tooling-sdk/config';
@@ -12,6 +11,7 @@ import { resolveEffectiveSafetyConfig, loadGlobalSafetyConfig } from '@salesforc
 import { createProjectContextInputSchema } from '../project-context.js';
 import { jsonResult, attachResolution } from '../adapter.js';
 import { MCP_SKILL_REFERENCES } from '../../skill-references.js';
+import { ScapiExecutionRegistry } from './execution-registry.js';
 const code = z
     .string()
     .min(1)
@@ -60,7 +60,8 @@ async () => {
 const executeDescription = `Read, create, update, or delete Commerce records through SCAPI Admin APIs when no dedicated tool fits. Discover standard endpoints with scapi_search; for custom APIs, fetch the live contract through scapi.request() in the same program first. Requests authenticate automatically. JSON requests; no Shopper execution or binary transfers.
 Read skill://mcp/scapi/SKILL.md first.
 
-Reuse workflows with await codemode.run(name, input); describe before first use. Snippets share this execution's limits and configuration. async (input) receives the tool's input. executionId enables scapi_snippet_save; inspect the outcome before saving.
+Reuse workflows with await codemode.run(name, input); describe first. async (input) receives input. Completed executionId enables scapi_snippet_save.
+Safety confirmation uses MCP elicitation. Protocol retries resume retained code; never replay it. Approval has no server deadline. Decline or cancel terminates execution without rollback. action:cancel needs executionId only (plus skillRead).
 
 Available in your code:
 declare const organizationId: string | undefined; // resolved tenant
@@ -70,7 +71,7 @@ declare const scapi: {
     Promise<{status: number; ok: boolean; data: any; diagnostic?: {code: string; message: string}}>;
 };
 
-Compose known dependent requests in one async arrow function; await requests and pass intermediate results directly. Responses can be huge: filter/map/slice in code; return counts, selected rows, and verification fields. Preserve failures and diagnostics. HTTP failures return ok:false; transport/auth/safety failures throw. SDK safety governs scapi.request. fetch/WebSocket are disabled. Optional auth.accountManager()/auth.slas() export tokens for external clients; see skill. Check writes before retrying.
+Compose dependent requests; await each. Responses can be huge: filter/map/slice; return counts, selected rows and verification. Preserve failures. HTTP failures return ok:false; transport/auth/safety failures throw. SDK safety governs scapi.request. fetch/WebSocket are disabled. Optional auth.accountManager()/auth.slas() export tokens for external clients; see skill. Check writes before retrying.
 
 Example: inspect a campaign's promotions
 async () => codemode.run('builtin/campaign-promotions', {campaignId: 'selected-campaign', limit: 4})`;
@@ -92,7 +93,7 @@ function failure(error, resolution) {
         isError: true,
     };
 }
-export function createScapiCodeTools(loadServices, snippetDirectory) {
+export function createScapiCodeTools(loadServices, snippetDirectory, registry = new ScapiExecutionRegistry()) {
     // Retain only source for the last 50 completed executions, until this server ends.
     const executions = new Map();
     const searchInput = {
@@ -106,7 +107,16 @@ export function createScapiCodeTools(loadServices, snippetDirectory) {
     };
     const executeInput = {
         ...createProjectContextInputSchema('configuration'),
-        code,
+        action: z
+            .enum(['execute', 'cancel'])
+            .optional()
+            .describe('Defaults to execute. Cancel terminates retained work; no rollback.'),
+        executionId: z
+            .string()
+            .uuid()
+            .optional()
+            .describe('Required for cancel; forbidden for execute. Protocol continuation uses requestState, not this field.'),
+        code: code.optional(),
         skillRead,
         input: z.unknown().optional().describe('JSON input for async (input); kept separate from saved source.'),
     };
@@ -164,6 +174,20 @@ export function createScapiCodeTools(loadServices, snippetDirectory) {
                 try {
                     const input = z.object(executeInput).strict().parse(args);
                     requireScapiSkill(input.skillRead);
+                    if (input.action === 'cancel') {
+                        if (!input.executionId ||
+                            Object.keys(args).some((key) => !['action', 'executionId', 'skillRead'].includes(key)) ||
+                            context?.requestState !== undefined ||
+                            context?.inputResponses !== undefined)
+                            throw new Error('SCAPI_CANCEL_ARGUMENT_INVALID: cancel requires executionId and skillRead only; omit code, input, project overrides and protocol continuation.');
+                        return await registry.cancel(input.executionId);
+                    }
+                    if (!input.code || input.executionId !== undefined)
+                        throw new Error('SCAPI_EXECUTE_ARGUMENT_INVALID: execute requires code; omit executionId.');
+                    if (context?.requestState !== undefined)
+                        return await registry.retry(input, context);
+                    if (context?.inputResponses !== undefined)
+                        throw new Error('SCAPI_CONTINUATION_INVALID: inputResponses require server-issued requestState.');
                     const services = await loadServices(input);
                     resolution = services.getResolution();
                     const config = services.getResolvedConfig();
@@ -172,36 +196,49 @@ export function createScapiCodeTools(loadServices, snippetDirectory) {
                         name,
                         services.getEnvironmentVariable(name),
                     ]));
-                    let managedRequest;
-                    const request = async (options, signal) => {
-                        if (!shortCode || !tenantId)
-                            throw new Error('SCAPI requires configured shortCode and tenantId. Use config_inspect.');
-                        managedRequest ??= createScapiRequest({
-                            shortCode,
-                            tenantId,
-                            siteId,
-                            auth: () => config.createOAuth(),
-                            documents: loadScapiSchemas(),
-                            safety: resolveEffectiveSafetyConfig(config.values.safety, loadGlobalSafetyConfig(getB2CConfigDirectory(), safetyEnvironment, resolution?.projectDirectory?.path), safetyEnvironment),
-                        });
-                        return managedRequest(options, signal);
-                    };
-                    const result = await runScapiCode({
-                        code: input.code,
-                        request,
-                        auth: createScapiAuth(config.values, resolution.projectDirectory?.path),
-                        organizationId: tenantId ? toOrganizationId(tenantId) : undefined,
-                        siteId,
-                        cwd: resolution.projectDirectory?.path,
-                        signal: context?.signal,
-                        input: input.input,
-                        snippets: loadScapiSnippets(snippetDirectory),
+                    return await registry.start(input, context, async (execution) => {
+                        let managedRequest;
+                        const request = async (options, signal) => {
+                            if (!shortCode || !tenantId)
+                                throw new Error('SCAPI requires configured shortCode and tenantId. Use config_inspect.');
+                            managedRequest ??= createScapiRequest({
+                                shortCode,
+                                tenantId,
+                                siteId,
+                                auth: () => config.createOAuth(),
+                                documents: loadScapiSchemas(),
+                                confirm: (request) => execution.confirm(request),
+                                onDispatch: () => execution.markDispatched(),
+                                safety: resolveEffectiveSafetyConfig(config.values.safety, loadGlobalSafetyConfig(getB2CConfigDirectory(), safetyEnvironment, resolution?.projectDirectory?.path), safetyEnvironment),
+                            });
+                            return managedRequest(options, signal);
+                        };
+                        const auth = createScapiAuth(config.values, resolution?.projectDirectory?.path);
+                        try {
+                            const result = await runScapiCode({
+                                code: input.code,
+                                request: (options, signal) => execution.runCall('request', options, () => request(options, signal)),
+                                auth: (operation, options, signal) => execution.runCall('auth', undefined, () => auth(operation, options, signal)),
+                                organizationId: tenantId ? toOrganizationId(tenantId) : undefined,
+                                siteId,
+                                cwd: resolution?.projectDirectory?.path,
+                                signal: execution.controller.signal,
+                                onControl(control) {
+                                    execution.control = control;
+                                },
+                                input: input.input,
+                                snippets: loadScapiSnippets(snippetDirectory),
+                            });
+                            const executionId = execution.id;
+                            executions.set(executionId, input.code);
+                            if (executions.size > 50)
+                                executions.delete(executions.keys().next().value);
+                            return codeResult({ result, executionId }, resolution);
+                        }
+                        catch (error) {
+                            return failure(error, resolution);
+                        }
                     });
-                    const executionId = randomUUID();
-                    executions.set(executionId, input.code);
-                    if (executions.size > 50)
-                        executions.delete(executions.keys().next().value);
-                    return codeResult({ result, executionId }, resolution);
                 }
                 catch (error) {
                     return failure(error, resolution);

package/dist/utils/types.d.ts

@@ -6,6 +6,15 @@ import type { Toolset } from './constants.js';
  * Matches the MCP SDK's CallToolResult type.
  */
 export type ToolResult = CallToolResult;
+/** Protocol input stays separate from model-supplied tool arguments. */
+export interface ToolContext {
+    signal?: AbortSignal;
+    requestState?: unknown;
+    inputResponses?: Record<string, unknown>;
+    supportsElicitation?: boolean;
+    /** Legacy elicitation keeps the originating request open between handler entries. */
+    keepCancellation?: boolean;
+}
 /** Effects of advertised operations; annotations are derived at registration. */
 export interface ToolEffects {
     effect: 'destructive' | 'read' | 'write';
@@ -35,9 +44,7 @@ export interface McpToolConfig<T extends ZodRawShape = ZodRawShape> extends Tool
  */
 export interface McpTool<T extends ZodRawShape = ZodRawShape> extends McpToolConfig<T> {
     /** Handler function that executes the tool */
-    handler: (args: z.infer<z.ZodObject<T>>, context?: {
-        signal?: AbortSignal;
-    }) => Promise<ToolResult>;
+    handler: (args: z.infer<z.ZodObject<T>>, context?: ToolContext) => Promise<ToolResult>;
 }
 /**
  * Startup flags passed to the MCP server.

package/node_modules/@modelcontextprotocol/server/dist/createMcpHandler-CLhGwQTn.d.mts

@@ -2001,6 +2001,7 @@ type RequestOptions = {
   /**
    * 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()}.
    *
+   * Zero disables the timeout; explicit cancellation remains available.
    * If not specified, {@linkcode DEFAULT_REQUEST_TIMEOUT_MSEC} will be used as the timeout.
    */
   timeout?: number;
@@ -2819,7 +2820,7 @@ type ServerOptions = ProtocolOptions & {
     /**
      * Per-leg timeout (ms) for the shim's embedded server→client
      * requests, sent with `resetTimeoutOnProgress: true`. Human-paced —
-     * deliberately far above the 60s protocol default.
+     * deliberately far above the 60s protocol default. Zero disables the timeout.
      * @default 600_000
      */
     roundTimeoutMs?: number;

package/node_modules/@modelcontextprotocol/server/dist/createMcpHandler-dBHMsxwf.d.cts

@@ -2003,6 +2003,7 @@ type RequestOptions = {
   /**
    * 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()}.
    *
+   * Zero disables the timeout; explicit cancellation remains available.
    * If not specified, {@linkcode DEFAULT_REQUEST_TIMEOUT_MSEC} will be used as the timeout.
    */
   timeout?: number;
@@ -2821,7 +2822,7 @@ type ServerOptions = ProtocolOptions & {
     /**
      * Per-leg timeout (ms) for the shim's embedded server→client
      * requests, sent with `resetTimeoutOnProgress: true`. Human-paced —
-     * deliberately far above the 60s protocol default.
+     * deliberately far above the 60s protocol default. Zero disables the timeout.
      * @default 600_000
      */
     roundTimeoutMs?: number;

package/node_modules/@modelcontextprotocol/server/dist/mcp-D7GmuPnv.cjs

@@ -488,7 +488,7 @@ const DEFAULT_LEGACY_SHIM_ROUND_TIMEOUT_MS = 6e5;
 /** Resolves and validates `ServerOptions.inputRequired`, failing loudly at construction time. */
 function resolveLegacyShimOptions(options) {
 	if (options?.maxRounds !== void 0 && (!Number.isInteger(options.maxRounds) || options.maxRounds < 1)) throw new RangeError(`inputRequired.maxRounds must be a positive integer (got ${options.maxRounds})`);
-	if (options?.roundTimeoutMs !== void 0 && (!Number.isFinite(options.roundTimeoutMs) || options.roundTimeoutMs <= 0)) throw new RangeError(`inputRequired.roundTimeoutMs must be a positive number (got ${options.roundTimeoutMs})`);
+	if (options?.roundTimeoutMs !== void 0 && (!Number.isFinite(options.roundTimeoutMs) || options.roundTimeoutMs < 0)) throw new RangeError(`inputRequired.roundTimeoutMs must be a non-negative number (got ${options.roundTimeoutMs})`);
 	return {
 		maxRounds: options?.maxRounds ?? DEFAULT_LEGACY_SHIM_MAX_ROUNDS,
 		roundTimeoutMs: options?.roundTimeoutMs ?? DEFAULT_LEGACY_SHIM_ROUND_TIMEOUT_MS,

package/node_modules/@modelcontextprotocol/server/dist/mcp-DXXb3Vv3.mjs

@@ -486,7 +486,7 @@ const DEFAULT_LEGACY_SHIM_ROUND_TIMEOUT_MS = 6e5;
 /** Resolves and validates `ServerOptions.inputRequired`, failing loudly at construction time. */
 function resolveLegacyShimOptions(options) {
 	if (options?.maxRounds !== void 0 && (!Number.isInteger(options.maxRounds) || options.maxRounds < 1)) throw new RangeError(`inputRequired.maxRounds must be a positive integer (got ${options.maxRounds})`);
-	if (options?.roundTimeoutMs !== void 0 && (!Number.isFinite(options.roundTimeoutMs) || options.roundTimeoutMs <= 0)) throw new RangeError(`inputRequired.roundTimeoutMs must be a positive number (got ${options.roundTimeoutMs})`);
+	if (options?.roundTimeoutMs !== void 0 && (!Number.isFinite(options.roundTimeoutMs) || options.roundTimeoutMs < 0)) throw new RangeError(`inputRequired.roundTimeoutMs must be a non-negative number (got ${options.roundTimeoutMs})`);
 	return {
 		maxRounds: options?.maxRounds ?? DEFAULT_LEGACY_SHIM_MAX_ROUNDS,
 		roundTimeoutMs: options?.roundTimeoutMs ?? DEFAULT_LEGACY_SHIM_ROUND_TIMEOUT_MS,

package/node_modules/@modelcontextprotocol/server/dist/src-CX2iR2pK.mjs

@@ -6251,6 +6251,8 @@ var Protocol = class {
 		this._requestHandlerAbortControllers.get(notification.params.requestId)?.abort(notification.params.reason);
 	}
 	_setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
+		// Zero disables the deadline for human-paced elicitation; cancellation remains active.
+		if (timeout === 0) return;
 		this._timeoutInfo.set(messageId, {
 			timeoutId: setTimeout(onTimeout, timeout),
 			startTime: Date.now(),