stitchkit 0.91.1 → 0.92.0

package/dist/tools.js

@@ -1,14 +1,10 @@
-import {
-  compareCodepoints,
-  serializeCanonicalJson
-} from "./index-0j3vcp5m.js";
 import {
   ManagedFileError
 } from "./index-actkayzn.js";
 import {
   signJwt,
   verifyPkce
-} from "./index-bv7mytab.js";
+} from "./index-sr93cwf9.js";
 import"./index-hr4tzbwq.js";
 import {
   DEFAULT_CORS_ALLOW_HEADERS,
@@ -18,7 +14,7 @@ import {
   guardSignalCallback,
   mediaTypeEssence,
   reportSignalError
-} from "./index-709nh7z7.js";
+} from "./index-cxqhvq21.js";
 import {
   redact
 } from "./index-6kyksz9y.js";
@@ -26,15 +22,12 @@ import {
   buildToolManifest,
   describeToolCatalog,
   mountAgent
-} from "./index-f4p4b8f6.js";
+} from "./index-e42wzzz5.js";
 import {
   AgentToolError,
   createLocalStepDurability,
   isAgentToolError
 } from "./index-kw9t5ayn.js";
-import {
-  argumentsDigest
-} from "./index-a916km3r.js";
 import {
   AsyncOperationCancelResultSchema,
   McpAnnotationsSchema,
@@ -46,7 +39,7 @@ import {
 } from "./index-4fpa9dy2.js";
 import {
   createToolInvoker
-} from "./index-bh70rk41.js";
+} from "./index-bx75zwt7.js";
 import {
   WaitTimeoutError,
   createCli,
@@ -55,31 +48,39 @@ import {
   fetchPinnedDocument,
   readCapped,
   runWaitOperation
-} from "./index-ya611vx3.js";
+} from "./index-7n145nbe.js";
+import {
+  compareCodepoints,
+  serializeCanonicalJson
+} from "./index-0j3vcp5m.js";
 import"./index-sbdmyz75.js";
 import {
   collectToolSurface
-} from "./index-qrbdq8jk.js";
+} from "./index-2c2bjw3s.js";
+import {
+  argumentsDigest
+} from "./index-a916km3r.js";
 import {
   collectTools,
   createToolRunner,
   formatToolError
-} from "./index-1qvdwnp2.js";
+} from "./index-mzvgxp0n.js";
 import {
   ToolExecutionControlError,
   executeToolMethod,
   isToolExecutionControlError,
+  parseToolCallArguments,
   toolResultFromError
-} from "./index-mqhjmadk.js";
+} from "./index-yn8remb1.js";
 import {
   getRequestContext,
   getTraceId,
   runWithRequestContext
-} from "./index-vsbzgd7b.js";
+} from "./index-tmwcrptx.js";
 import"./index-f9mb610r.js";
 import {
   normalizeError
-} from "./index-13cjtmrw.js";
+} from "./index-e0znv5gn.js";
 import {
   defineContract
 } from "./index-0a349c33.js";
@@ -97,7 +98,7 @@ import {
 import {
   createRuntimeToolFactory,
   defineRuntimeTool
-} from "./index-8z9we758.js";
+} from "./index-vjpvjqpn.js";
 import {
   PORTABLE_JSON_SCHEMA_FORMATS,
   assertToolName,
@@ -107,8 +108,10 @@ import {
   flattenToolJsonSchema,
   prepareProjectedMcpTools,
   presentationMetadata,
-  validateMcpRoundPolicy
-} from "./index-fenaekmk.js";
+  staticInputRounds,
+  validateMcpRoundPolicy,
+  validateResolvedInputRounds
+} from "./index-h9etkkyk.js";
 import {
   toJsonSchema
 } from "./index-cby4ar3v.js";
@@ -933,7 +936,7 @@ import {
   createRequestStateCodec,
   McpServer
 } from "@modelcontextprotocol/server";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/tools/mcp-app.ts
 import { readFileSync } from "node:fs";
@@ -1110,11 +1113,46 @@ import {
   inputResponse,
   PROTOCOL_VERSION_META_KEY
 } from "@modelcontextprotocol/server";
+import { z as z3 } from "zod";
+
+// src/tools/mcp-progress.ts
+function mcpProgressToken(context) {
+  const token = context.mcpReq._meta?.progressToken;
+  return typeof token === "string" || typeof token === "number" ? token : undefined;
+}
+function createMcpProgressReporter(context) {
+  const token = mcpProgressToken(context);
+  if (token === undefined)
+    return async () => {
+      return;
+    };
+  let sent = 0;
+  let highWater = 0;
+  return async (update) => {
+    sent += 1;
+    const value = update.progress ?? Math.max(sent, highWater + 1);
+    highWater = Math.max(highWater, value);
+    try {
+      await context.mcpReq.notify({
+        method: "notifications/progress",
+        params: {
+          progressToken: token,
+          progress: value,
+          ...update.total !== undefined && { total: update.total },
+          ...update.message !== undefined && { message: update.message }
+        }
+      });
+    } catch {}
+  };
+}
+
+// src/tools/mcp-round.ts
 function transportContext(context, toolName, outcome, round) {
   const protocolVersionValue = isRecord(context.mcpReq.envelope) ? Reflect.get(context.mcpReq.envelope, PROTOCOL_VERSION_META_KEY) : undefined;
   const protocolVersion = typeof protocolVersionValue === "string" ? protocolVersionValue : undefined;
   const clientInfoValue = isRecord(context.mcpReq.envelope) ? Reflect.get(context.mcpReq.envelope, CLIENT_INFO_META_KEY) : undefined;
   const clientInfo = isRecord(clientInfoValue) && typeof clientInfoValue.name === "string" && typeof clientInfoValue.version === "string" ? { name: clientInfoValue.name, version: clientInfoValue.version } : undefined;
+  const token = mcpProgressToken(context);
   return {
     signal: context.mcpReq.signal,
     mcp: {
@@ -1124,8 +1162,10 @@ function transportContext(context, toolName, outcome, round) {
       ...protocolVersion !== undefined && { protocolVersion },
       ...clientInfo !== undefined && { clientInfo },
       ...outcome !== undefined && { outcome },
-      ...round !== undefined && { round }
-    }
+      ...round !== undefined && { round },
+      ...token !== undefined && { progressToken: token }
+    },
+    reportProgress: createMcpProgressReporter(context)
   };
 }
 function operationIdentity(tool) {
@@ -1168,6 +1208,28 @@ async function failedResolution(options) {
   const result = await runRoundFailure(options.tool, options.rawArgs, options.runTool, options.context, options.code, options.message);
   return { kind: "response", response: options.formatFailure(result) };
 }
+function roundPlanDigest(requests) {
+  return argumentsDigest({
+    plan: requests.map((request) => ({
+      key: request.key,
+      message: request.message,
+      schema: z3.toJSONSchema(request.schema, { io: "input", unrepresentable: "any" })
+    }))
+  });
+}
+async function resolveRequests(options, policy) {
+  const declared = staticInputRounds(policy);
+  if (declared)
+    return { requests: declared, guarded: false };
+  const parsed = parseToolCallArguments(options.tool.method, options.rawArgs, options.coerceJsonArgs ?? true);
+  if (!parsed.ok) {
+    return { requests: [], guarded: false };
+  }
+  const resolver = policy.inputRequired;
+  const resolved = await resolver({ params: parsed.params, input: parsed.input });
+  validateResolvedInputRounds(options.tool, resolved, options.runtime?.maxRounds ?? 1);
+  return { requests: resolved, guarded: false };
+}
 async function resolveMcpRound(options) {
   const { policy } = options;
   if (!policy) {
@@ -1183,9 +1245,37 @@ async function resolveMcpRound(options) {
     stateConfigured: true,
     maxRounds: options.runtime.maxRounds
   });
-  const requests = policy.inputRequired;
   const state = options.context.mcpReq.requestState();
   const digest = argumentsDigest(options.rawArgs);
+  if (state) {
+    const mismatched = !sameIdentity(state.identity, operationIdentity(options.tool)) || state.argumentsDigest !== digest || !Number.isInteger(state.round) || state.round < 0 || state.round >= options.runtime.maxRounds || !isRecord(state.accepted);
+    if (mismatched) {
+      return failedResolution({
+        ...options,
+        context: transportContext(options.context, options.tool.name, "invalid", Number.isInteger(state.round) ? state.round : 0),
+        code: "INVALID_REQUEST_STATE",
+        message: "Continuation state does not match this operation, arguments or round"
+      });
+    }
+  }
+  const dynamic = staticInputRounds(policy) === undefined;
+  if (dynamic) {
+    const guarded = await runRoundSuccess(options.tool, options.rawArgs, options.runTool, transportContext(options.context, options.tool.name, "input_required", state?.round ?? 0));
+    if (!guarded.ok)
+      return { kind: "response", response: options.formatFailure(guarded) };
+  }
+  const resolution = await resolveRequests(options, policy);
+  if ("failure" in resolution)
+    return resolution.failure;
+  const requests = resolution.requests;
+  const alreadyGuarded = dynamic;
+  const planDigest = roundPlanDigest(requests);
+  if (requests.length === 0 && !state) {
+    return {
+      kind: "continue",
+      context: transportContext(options.context, options.tool.name)
+    };
+  }
   if (!state) {
     if (isRecord(options.context.mcpReq.inputResponses)) {
       return failedResolution({
@@ -1195,9 +1285,11 @@ async function resolveMcpRound(options) {
         message: "Input responses require a valid continuation state"
       });
     }
-    const guarded = await runRoundSuccess(options.tool, options.rawArgs, options.runTool, transportContext(options.context, options.tool.name, "input_required", 0));
-    if (!guarded.ok) {
-      return { kind: "response", response: options.formatFailure(guarded) };
+    if (!alreadyGuarded) {
+      const guarded = await runRoundSuccess(options.tool, options.rawArgs, options.runTool, transportContext(options.context, options.tool.name, "input_required", 0));
+      if (!guarded.ok) {
+        return { kind: "response", response: options.formatFailure(guarded) };
+      }
     }
     const request2 = requests[0];
     if (!request2)
@@ -1206,7 +1298,8 @@ async function resolveMcpRound(options) {
       identity: operationIdentity(options.tool),
       argumentsDigest: digest,
       round: 0,
-      accepted: {}
+      accepted: {},
+      planDigest
     }, options.context);
     return {
       kind: "response",
@@ -1221,13 +1314,12 @@ async function resolveMcpRound(options) {
       })
     };
   }
-  const invalidState = !sameIdentity(state.identity, operationIdentity(options.tool)) || state.argumentsDigest !== digest || !Number.isInteger(state.round) || state.round < 0 || state.round >= requests.length || state.round >= options.runtime.maxRounds || !isRecord(state.accepted);
-  if (invalidState) {
+  if (state.planDigest !== planDigest || state.round >= requests.length) {
     return failedResolution({
       ...options,
       context: transportContext(options.context, options.tool.name, "invalid", state.round),
       code: "INVALID_REQUEST_STATE",
-      message: "Continuation state does not match this operation, arguments or round"
+      message: state.round >= requests.length ? "Continuation state does not match this operation, arguments or round" : "The questions for this call changed between rounds"
     });
   }
   const request = requests[state.round];
@@ -1264,15 +1356,18 @@ async function resolveMcpRound(options) {
   const nextRound = state.round + 1;
   const nextRequest = requests[nextRound];
   if (nextRequest) {
-    const guarded = await runRoundSuccess(options.tool, options.rawArgs, options.runTool, transportContext(options.context, options.tool.name, "input_required", nextRound));
-    if (!guarded.ok) {
-      return { kind: "response", response: options.formatFailure(guarded) };
+    if (!alreadyGuarded) {
+      const guarded = await runRoundSuccess(options.tool, options.rawArgs, options.runTool, transportContext(options.context, options.tool.name, "input_required", nextRound));
+      if (!guarded.ok) {
+        return { kind: "response", response: options.formatFailure(guarded) };
+      }
     }
     const requestState = await options.runtime.codec.mint({
       identity: state.identity,
       argumentsDigest: state.argumentsDigest,
       round: nextRound,
-      accepted
+      accepted,
+      planDigest
     }, options.context);
     return {
       kind: "response",
@@ -1332,13 +1427,13 @@ function runInMcpRequestContext(context, toolName, body) {
 import {
   isCallToolResult
 } from "@modelcontextprotocol/server";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 function mountPreparedRuntimeMcp(server, tools, config) {
   for (const { definition, descriptor } of tools) {
     const { mountable } = descriptor;
     const toolConfig = {
       description: definition.description,
-      inputSchema: z3.looseObject({}).meta(presentationMetadata(descriptor.inputSchema))
+      inputSchema: z4.looseObject({}).meta(presentationMetadata(descriptor.inputSchema))
     };
     if (descriptor.outputSchema)
       toolConfig.outputSchema = descriptor.outputSchema;
@@ -1430,7 +1525,7 @@ function mountPreparedMcp(mcpServer, prepared, config = {}) {
     const { mountable } = descriptor;
     const toolConfig = {
       description: mountable.method.desc,
-      inputSchema: z4.looseObject({}).meta(presentationMetadata(descriptor.inputSchema))
+      inputSchema: z5.looseObject({}).meta(presentationMetadata(descriptor.inputSchema))
     };
     if (descriptor.outputSchema)
       toolConfig.outputSchema = descriptor.outputSchema;
@@ -1868,7 +1963,7 @@ function bindStdioProcessSignals(handle, options = {}) {
   return { promise, close };
 }
 // src/tools/mount-download.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/tools/native-result.ts
 function textResult(text, isError = false) {
@@ -1880,7 +1975,7 @@ function textResult(text, isError = false) {
 function mountDownload(server, config) {
   const name = config.name ?? "download";
   assertToolName(name, "<native>", "download");
-  server.registerTool(name, { description: config.description, inputSchema: z5.object(config.inputSchema) }, async (rawArgs) => {
+  server.registerTool(name, { description: config.description, inputSchema: z6.object(config.inputSchema) }, async (rawArgs) => {
     const args = isRecord(rawArgs) ? rawArgs : {};
     try {
       const url = await config.resolveUrl(args);
@@ -1928,19 +2023,33 @@ function mountUpload(server, config) {
   });
 }
 // src/tools/mount-wait.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function mountWait(server, config) {
   const name = config.name ?? "wait";
   assertToolName(name, "<native>", "wait");
-  server.registerTool(name, { description: config.description, inputSchema: z6.object(config.inputSchema) }, async (rawArgs) => {
+  server.registerTool(name, { description: config.description, inputSchema: z7.object(config.inputSchema) }, async (rawArgs, mcpContext) => {
     const args = isRecord(rawArgs) ? rawArgs : {};
+    const report = createMcpProgressReporter(mcpContext);
+    let last;
     try {
       const { state, timedOut } = await runWaitOperation({
         input: args,
-        poll: (input) => config.poll(input),
+        poll: async (input) => {
+          last = await config.poll(input);
+          return last;
+        },
         done: config.done,
         backoff: config.backoff,
-        timeoutSec: config.timeoutFromArgs?.(args) ?? config.defaultTimeout
+        timeoutSec: config.timeoutFromArgs?.(args) ?? config.defaultTimeout,
+        onTick: (attempt, elapsedSec) => {
+          const snapshot = isRecord(last) ? last : undefined;
+          const phase = typeof snapshot?.phase === "string" ? snapshot.phase : undefined;
+          const measured = typeof snapshot?.progress === "number" && Number.isFinite(snapshot.progress) ? snapshot.progress : undefined;
+          report({
+            progress: measured ?? attempt,
+            message: phase ? `${phase} — poll ${attempt}, ${Math.round(elapsedSec)}s elapsed` : `poll ${attempt}, ${Math.round(elapsedSec)}s elapsed`
+          });
+        }
       });
       const rendered = config.render ? config.render(state, timedOut) : { text: JSON.stringify(state, null, 2), isError: timedOut };
       return textResult(rendered.text, rendered.isError);
@@ -1951,19 +2060,19 @@ function mountWait(server, config) {
 }
 // src/tools/oauth-provider.ts
 import { randomUUID } from "node:crypto";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function isPlainDisplayCharacter(character) {
   const codePoint = character.codePointAt(0);
   return codePoint !== undefined && codePoint >= 32 && codePoint !== 127 && character !== "<" && character !== ">";
 }
-var CimdClientMetadataSchema = z7.object({
-  client_id: z7.url(),
-  redirect_uris: z7.array(z7.url()).min(1),
-  client_name: z7.string().trim().min(1).max(200).refine((value) => Array.from(value).every(isPlainDisplayCharacter), {
+var CimdClientMetadataSchema = z8.object({
+  client_id: z8.url(),
+  redirect_uris: z8.array(z8.url()).min(1),
+  client_name: z8.string().trim().min(1).max(200).refine((value) => Array.from(value).every(isPlainDisplayCharacter), {
     message: "client_name must be plain display text"
   }),
-  token_endpoint_auth_method: z7.literal("none"),
-  application_type: z7.enum(["native", "web"]).optional()
+  token_endpoint_auth_method: z8.literal("none"),
+  application_type: z8.enum(["native", "web"]).optional()
 });
 function createSecureClientMetadataFetcher(policy = {}) {
   assertPositiveInteger("cimd.maxBytes", policy.maxBytes ?? DEFAULT_CIMD_MAX_BYTES);