stitchkit 0.91.2 → 0.93.0

package/dist/tools/mcp-progress.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Progress for a call that is still running.
+ *
+ * A tool that takes ten minutes tells a text host nothing today: the call is
+ * made, and the next thing the host sees is the answer. The protocol has the
+ * channel for this — the host sends a `progressToken` in the request's `_meta`
+ * and the server relates `notifications/progress` to that request — and the
+ * framework simply never read the token.
+ *
+ * Both places that can report live here, so there is one implementation of
+ * "what a progress update is": the contract-tool path (`mcp-round.ts`, which
+ * hands `reportProgress` to the handler) and the native wait tool
+ * (`mount-wait.ts`, which reports its own poll ticks).
+ */
+import type { ServerContext } from '@modelcontextprotocol/server';
+import type { McpReportProgress } from '../contract/index.js';
+/**
+ * The host's progress token, or `undefined` when it asked for none.
+ *
+ * It rides in the request's own `_meta`, beside the trace keys, and survives
+ * the SDK's envelope lift because it is not an envelope key. `_meta` itself can
+ * be absent entirely — the SDK drops it when the lift empties it — so "no
+ * `_meta`" and "`_meta` without a token" have to mean the same thing here.
+ */
+export declare function mcpProgressToken(context: ServerContext): string | number | undefined;
+/**
+ * Build the reporter for one call.
+ *
+ * Without a token it is a no-op, so nothing upstream has to ask whether the
+ * host is listening. With one, every update is a `notifications/progress`
+ * related to this request.
+ *
+ * `progress` is required by the protocol and is often the one thing a handler
+ * does not know — it has a stage to name and no scale to name it on. An
+ * omitted one becomes the ordinal of this update, which is a fact about what
+ * happened; a synthesised percentage would be a claim nobody measured. `total`
+ * stays absent in that case, so a host renders an unbounded counter rather
+ * than a bar stuck at 3%.
+ *
+ * Nothing here can fail the call. A transport that refuses the notification
+ * leaves the host without progress, which is exactly the state of every host
+ * that never asked for it — and a message about work must not be able to kill
+ * the work it describes.
+ */
+export declare function createMcpProgressReporter(context: ServerContext): McpReportProgress;
+//# sourceMappingURL=mcp-progress.d.ts.map

package/dist/tools/mcp-progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-progress.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-progress.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAqB,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAExE;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAGpF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,aAAa,GAAG,iBAAiB,CA4BnF"}

package/dist/tools/mcp-round-policy.d.ts

@@ -1,4 +1,13 @@
-import type { EndpointMcpPolicy } from '../contract/index.js';
+import type { EndpointMcpInputRequired, EndpointMcpPolicy } from '../contract/index.js';
+/**
+ * The declared rounds, when the declaration is a fixed list.
+ *
+ * A resolver has nothing to read at declaration time — that is the whole point
+ * of it — so everything that inspects a policy statically (surface projection,
+ * the surface fingerprint, mount-time validation) asks this first and treats
+ * `undefined` as "known only per call".
+ */
+export declare function staticInputRounds(policy: EndpointMcpPolicy): readonly EndpointMcpInputRequired[] | undefined;
 /** Validate declarative multi-round policy without importing the optional MCP SDK. */
 export declare function validateMcpRoundPolicy(tool: {
     name: string;
@@ -6,4 +15,19 @@ export declare function validateMcpRoundPolicy(tool: {
     stateConfigured: boolean;
     maxRounds: number;
 }): void;
+/**
+ * Validate what a resolver actually returned, on the call that returned it.
+ *
+ * The same two rules the static list is held to — unique keys, no more rounds
+ * than the runtime allows — because a resolver can break both, and a policy
+ * that is only checked when it happens to be written down is not checked.
+ *
+ * An empty list is legal here and only here: for a resolver it means "this call
+ * needs nothing", which is the answer the feature exists to allow. Declaring
+ * zero rounds statically still means the author wrote a policy that can never
+ * ask anything, and that stays an error.
+ */
+export declare function validateResolvedInputRounds(tool: {
+    name: string;
+}, resolved: readonly EndpointMcpInputRequired[], maxRounds: number): void;
 //# sourceMappingURL=mcp-round-policy.d.ts.map

package/dist/tools/mcp-round-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-round-policy.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-round-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,sFAAsF;AACtF,wBAAgB,sBAAsB,CACpC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EACtB,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE;IAAE,eAAe,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACxD,IAAI,CA6BN"}
+{"version":3,"file":"mcp-round-policy.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-round-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAE/E;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,iBAAiB,GACxB,SAAS,wBAAwB,EAAE,GAAG,SAAS,CAEjD;AAED,sFAAsF;AACtF,wBAAgB,sBAAsB,CACpC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EACtB,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE;IAAE,eAAe,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACxD,IAAI,CAqBN;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EACtB,QAAQ,EAAE,SAAS,wBAAwB,EAAE,EAC7C,SAAS,EAAE,MAAM,GAChB,IAAI,CAEN"}

package/dist/tools/mcp-round.d.ts

@@ -1,6 +1,6 @@
 import { type CallToolResult, type InputRequiredResult, type RequestStateCodec, type ServerContext } from '@modelcontextprotocol/server';
 import { type EndpointMcpPolicy } from '../contract/index.js';
-import type { ToolResult } from './execute.js';
+import { type ToolResult } from './execute.js';
 import type { MountableTool } from './mount.js';
 interface RoundOperationIdentity {
     toolName: string;
@@ -15,6 +15,23 @@ export interface McpRoundState {
     argumentsDigest: string;
     round: number;
     accepted: Record<string, unknown>;
+    /**
+     * Fingerprint of the question plan this conversation started with.
+     *
+     * `argumentsDigest` proves the ARGUMENTS did not change; it says nothing
+     * about the questions, and those are now allowed to be computed. Between two
+     * rounds there is a full round trip to the host, and a resolver that reads
+     * anything outside its arguments — which is exactly the case this feature
+     * exists for — can answer differently the second time. Every other check
+     * would still pass: same principal, same operation, same digest, `round`
+     * still in range. Round 2's question would be asked under round 1's key, the
+     * answer would be accepted if the schemas happened to be compatible, and the
+     * handler would receive an answer to a question nobody asked.
+     *
+     * So the plan is fingerprinted when it is minted and re-checked on every
+     * round. A plan that moved is a refusal, not a different question.
+     */
+    planDigest: string;
 }
 export interface McpRoundRuntime {
     codec: RequestStateCodec<McpRoundState>;
@@ -37,6 +54,8 @@ export declare function resolveMcpRound(options: {
     runtime?: McpRoundRuntime;
     runTool: ToolRunner;
     formatFailure: (result: ToolResult) => CallToolResult;
+    /** The mount's JSON-coercion setting, so the resolver parses as the call does. */
+    coerceJsonArgs?: boolean;
 }): Promise<McpRoundResolution>;
 export {};
 //# sourceMappingURL=mcp-round.d.ts.map

package/dist/tools/mcp-round.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-round.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-round.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAEnB,KAAK,mBAAmB,EAIxB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EACnB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAEL,KAAK,iBAAiB,EAGvB,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,UAAU,sBAAsB;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,sBAAsB,CAAC;IACjC,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,iBAAiB,CAAC,aAAa,CAAC,CAAC;IACxC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,KAAK,UAAU,GAAG,CAChB,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B,OAAO,CAAC,UAAU,CAAC,CAAC;AAEzB,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,cAAc,GAAG,mBAAmB,CAAA;CAAE,CAAC;AAwHzE,qFAAqF;AACrF,wBAAsB,eAAe,CAAC,OAAO,EAAE;IAC7C,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,OAAO,EAAE,UAAU,CAAC;IACpB,aAAa,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,cAAc,CAAC;CACvD,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAmK9B"}
+{"version":3,"file":"mcp-round.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-round.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAEnB,KAAK,mBAAmB,EAIxB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EACnB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAGL,KAAK,iBAAiB,EAKvB,MAAM,aAAa,CAAC;AAGrB,OAAO,EAA0B,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AAOpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,UAAU,sBAAsB;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,sBAAsB,CAAC;IACjC,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC;;;;;;;;;;;;;;;OAeG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,iBAAiB,CAAC,aAAa,CAAC,CAAC;IACxC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,KAAK,UAAU,GAAG,CAChB,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B,OAAO,CAAC,UAAU,CAAC,CAAC;AAEzB,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,cAAc,GAAG,mBAAmB,CAAA;CAAE,CAAC;AAmMzE,qFAAqF;AACrF,wBAAsB,eAAe,CAAC,OAAO,EAAE;IAC7C,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,OAAO,EAAE,UAAU,CAAC;IACpB,aAAa,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,cAAc,CAAC;IACtD,kFAAkF;IAClF,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAuO9B"}

package/dist/tools/mcp-trace.d.ts

@@ -1,4 +1,12 @@
 import { type ServerContext } from '@modelcontextprotocol/server';
-/** Run one SDK-dispatched MCP request inside an isolated propagation context. */
+/**
+ * Run one SDK-dispatched MCP request inside an isolated propagation context.
+ *
+ * `method: 'MCP'` and `path: '/mcp/<tool>'` are written here deliberately, and
+ * they are NOT the fabricated transport fields that `kind: 'job'` exists to
+ * replace. An MCP tool call arrives as a request, over a transport, naming an
+ * operation — it has a verb-shaped thing to say and a path-shaped thing to say.
+ * Background work has neither, which is why it now records their absence.
+ */
 export declare function runInMcpRequestContext<T>(context: ServerContext, toolName: string, body: () => Promise<T>): Promise<T>;
 //# sourceMappingURL=mcp-trace.d.ts.map

package/dist/tools/mcp-trace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-trace.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-trace.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAGnB,MAAM,8BAA8B,CAAC;AAQtC,iFAAiF;AACjF,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACrB,OAAO,CAAC,CAAC,CAAC,CA0BZ"}
+{"version":3,"file":"mcp-trace.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-trace.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAGnB,MAAM,8BAA8B,CAAC;AAQtC;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACrB,OAAO,CAAC,CAAC,CAAC,CA0BZ"}

package/dist/tools/mount-wait.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mount-wait.d.ts","sourceRoot":"","sources":["../../src/tools/mount-wait.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,MAAM,WAAW,cAAc;IAC7B,mCAAmC;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,WAAW,EAAE,CAAC,CAAC,WAAW,CAAC;IAC3B,mEAAmE;IACnE,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1D,yCAAyC;IACzC,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAClC,uDAAuD;IACvD,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,GAAG,SAAS,CAAC;IACxE,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,kCAAkC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,KAAK;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CACpF;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,GAAG,IAAI,CAgCzE"}
+{"version":3,"file":"mount-wait.d.ts","sourceRoot":"","sources":["../../src/tools/mount-wait.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,MAAM,WAAW,cAAc;IAC7B,mCAAmC;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,WAAW,EAAE,CAAC,CAAC,WAAW,CAAC;IAC3B,mEAAmE;IACnE,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1D,yCAAyC;IACzC,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAClC,uDAAuD;IACvD,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,GAAG,SAAS,CAAC;IACxE,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,kCAAkC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,KAAK;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CACpF;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,GAAG,IAAI,CA8DzE"}

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-pena034b.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-axvavfr4.js";
+} from "./index-bx75zwt7.js";
 import {
   WaitTimeoutError,
   createCli,
@@ -55,27 +48,35 @@ import {
   fetchPinnedDocument,
   readCapped,
   runWaitOperation
-} from "./index-seyy8dvn.js";
+} from "./index-3bmnp41g.js";
+import {
+  compareCodepoints,
+  serializeCanonicalJson
+} from "./index-0j3vcp5m.js";
 import"./index-sbdmyz75.js";
 import {
   collectToolSurface
-} from "./index-a2nzz56k.js";
+} from "./index-2c2bjw3s.js";
+import {
+  argumentsDigest
+} from "./index-a916km3r.js";
 import {
   collectTools,
   createToolRunner,
   formatToolError
-} from "./index-4x809vqd.js";
+} from "./index-mzvgxp0n.js";
 import {
   ToolExecutionControlError,
   executeToolMethod,
   isToolExecutionControlError,
+  parseToolCallArguments,
   toolResultFromError
-} from "./index-s3dssqxp.js";
+} from "./index-yn8remb1.js";
 import {
   getRequestContext,
   getTraceId,
   runWithRequestContext
-} from "./index-vsbzgd7b.js";
+} from "./index-tmwcrptx.js";
 import"./index-f9mb610r.js";
 import {
   normalizeError
@@ -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);