@tanstack/ai 0.41.0 → 0.43.0

package/dist/esm/interrupt-serialization.js

@@ -0,0 +1,178 @@
+//#region src/interrupt-serialization.ts
+var SHA256_K = new Uint32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+function rotr(x, n) {
+	return x >>> n | x << 32 - n;
+}
+function sha256Hex(input) {
+	const msg = new TextEncoder().encode(input);
+	const bitLen = msg.length * 8;
+	const withOne = msg.length + 1;
+	const total = withOne + (56 - withOne % 64 + 64) % 64 + 8;
+	const bytes = new Uint8Array(total);
+	bytes.set(msg);
+	bytes[msg.length] = 128;
+	const view = new DataView(bytes.buffer);
+	view.setUint32(total - 8, Math.floor(bitLen / 4294967296));
+	view.setUint32(total - 4, bitLen >>> 0);
+	let h0 = 1779033703;
+	let h1 = 3144134277;
+	let h2 = 1013904242;
+	let h3 = 2773480762;
+	let h4 = 1359893119;
+	let h5 = 2600822924;
+	let h6 = 528734635;
+	let h7 = 1541459225;
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	for (let offset = 0; offset < total; offset += 64) {
+		for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4);
+		for (let i = 16; i < 64; i++) {
+			const x15 = w[i - 15] ?? 0;
+			const x2 = w[i - 2] ?? 0;
+			const s0 = rotr(x15, 7) ^ rotr(x15, 18) ^ x15 >>> 3;
+			const s1 = rotr(x2, 17) ^ rotr(x2, 19) ^ x2 >>> 10;
+			w[i] = (w[i - 16] ?? 0) + s0 + (w[i - 7] ?? 0) + s1 >>> 0;
+		}
+		let a = h0;
+		let b = h1;
+		let c = h2;
+		let d = h3;
+		let e = h4;
+		let f = h5;
+		let g = h6;
+		let hh = h7;
+		for (let i = 0; i < 64; i++) {
+			const bigS1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const t1 = hh + bigS1 + ch + (SHA256_K[i] ?? 0) + (w[i] ?? 0) >>> 0;
+			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+			hh = g;
+			g = f;
+			f = e;
+			e = d + t1 >>> 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 >>> 0;
+		}
+		h0 = h0 + a >>> 0;
+		h1 = h1 + b >>> 0;
+		h2 = h2 + c >>> 0;
+		h3 = h3 + d >>> 0;
+		h4 = h4 + e >>> 0;
+		h5 = h5 + f >>> 0;
+		h6 = h6 + g >>> 0;
+		h7 = h7 + hh >>> 0;
+	}
+	const hex = (n) => (n >>> 0).toString(16).padStart(8, "0");
+	return hex(h0) + hex(h1) + hex(h2) + hex(h3) + hex(h4) + hex(h5) + hex(h6) + hex(h7);
+}
+/** The built-in default: SHA-256, prefixed so the algorithm is self-describing. */
+function defaultInterruptHash(canonicalJson) {
+	return `sha256:${sha256Hex(canonicalJson)}`;
+}
+function canonical(value, active) {
+	if (value === null) return "null";
+	if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+	if (typeof value === "number" && Number.isFinite(value)) return JSON.stringify(value);
+	if (typeof value !== "object") throw new TypeError("Interrupt values must be JSON-compatible.");
+	if (active.has(value)) throw new TypeError("Interrupt values must not cycle.");
+	if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new TypeError("Interrupt values must use plain JSON objects.");
+	active.add(value);
+	let encoded;
+	if (Array.isArray(value)) {
+		const items = [];
+		for (let index = 0; index < value.length; index++) items.push(canonical(value[index], active));
+		encoded = `[${items.join(",")}]`;
+	} else {
+		const record = value;
+		encoded = `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key], active)}`).join(",")}}`;
+	}
+	active.delete(value);
+	return encoded;
+}
+function canonicalInterruptJson(value) {
+	return canonical(value, /* @__PURE__ */ new WeakSet());
+}
+function digestInterruptJson(canonicalJson, hash = defaultInterruptHash) {
+	if (typeof canonicalJson !== "string") throw new TypeError("Interrupt digests require canonical JSON text.");
+	return hash(canonicalJson);
+}
+function freezeTree(value) {
+	if (value === null || typeof value !== "object" || Object.isFrozen(value)) return;
+	Object.values(value).forEach(freezeTree);
+	Object.freeze(value);
+}
+function cloneAndDeepFreezeJson(value) {
+	const clone = JSON.parse(canonicalInterruptJson(value));
+	freezeTree(clone);
+	return clone;
+}
+//#endregion
+export { canonicalInterruptJson, cloneAndDeepFreezeJson, defaultInterruptHash, digestInterruptJson };
+
+//# sourceMappingURL=interrupt-serialization.js.map

package/dist/esm/interrupt-serialization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt-serialization.js","names":[],"sources":["../../src/interrupt-serialization.ts"],"sourcesContent":["// Dependency-free SHA-256 (FIPS 180-4). Sync and isomorphic (Node + browser)\n// so interrupt hashing needs no crypto library. Users can replace the whole\n// algorithm through the `interrupts.hash` option; this is only the default.\n// ponytail: bundled ~60-line hash, swap via interrupts.hash if you need more.\nconst SHA256_K = new Uint32Array([\n  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,\n  0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,\n  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,\n  0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,\n  0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,\n  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,\n  0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,\n  0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\n  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,\n])\n\nfunction rotr(x: number, n: number): number {\n  return (x >>> n) | (x << (32 - n))\n}\n\nfunction sha256Hex(input: string): string {\n  const msg = new TextEncoder().encode(input)\n\n  const bitLen = msg.length * 8\n  const withOne = msg.length + 1\n  const total = withOne + ((56 - (withOne % 64) + 64) % 64) + 8\n  const bytes = new Uint8Array(total)\n  bytes.set(msg)\n  bytes[msg.length] = 0x80\n  const view = new DataView(bytes.buffer)\n  view.setUint32(total - 8, Math.floor(bitLen / 0x100000000))\n  view.setUint32(total - 4, bitLen >>> 0)\n\n  let h0 = 0x6a09e667\n  let h1 = 0xbb67ae85\n  let h2 = 0x3c6ef372\n  let h3 = 0xa54ff53a\n  let h4 = 0x510e527f\n  let h5 = 0x9b05688c\n  let h6 = 0x1f83d9ab\n  let h7 = 0x5be0cd19\n\n  const w = new Uint32Array(64)\n  for (let offset = 0; offset < total; offset += 64) {\n    for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4)\n    for (let i = 16; i < 64; i++) {\n      const x15 = w[i - 15] ?? 0\n      const x2 = w[i - 2] ?? 0\n      const s0 = rotr(x15, 7) ^ rotr(x15, 18) ^ (x15 >>> 3)\n      const s1 = rotr(x2, 17) ^ rotr(x2, 19) ^ (x2 >>> 10)\n      w[i] = ((w[i - 16] ?? 0) + s0 + (w[i - 7] ?? 0) + s1) >>> 0\n    }\n\n    let a = h0\n    let b = h1\n    let c = h2\n    let d = h3\n    let e = h4\n    let f = h5\n    let g = h6\n    let hh = h7\n    for (let i = 0; i < 64; i++) {\n      const bigS1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)\n      const ch = (e & f) ^ (~e & g)\n      const t1 = (hh + bigS1 + ch + (SHA256_K[i] ?? 0) + (w[i] ?? 0)) >>> 0\n      const bigS0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)\n      const maj = (a & b) ^ (a & c) ^ (b & c)\n      const t2 = (bigS0 + maj) >>> 0\n      hh = g\n      g = f\n      f = e\n      e = (d + t1) >>> 0\n      d = c\n      c = b\n      b = a\n      a = (t1 + t2) >>> 0\n    }\n    h0 = (h0 + a) >>> 0\n    h1 = (h1 + b) >>> 0\n    h2 = (h2 + c) >>> 0\n    h3 = (h3 + d) >>> 0\n    h4 = (h4 + e) >>> 0\n    h5 = (h5 + f) >>> 0\n    h6 = (h6 + g) >>> 0\n    h7 = (h7 + hh) >>> 0\n  }\n\n  const hex = (n: number): string => (n >>> 0).toString(16).padStart(8, '0')\n  return (\n    hex(h0) +\n    hex(h1) +\n    hex(h2) +\n    hex(h3) +\n    hex(h4) +\n    hex(h5) +\n    hex(h6) +\n    hex(h7)\n  )\n}\n\n/**\n * A hash function for interrupt bindings and resolution fingerprints. Receives\n * canonical JSON text and returns an opaque string. Must be deterministic; the\n * server compares hashes it computed against the ones in a binding, so the same\n * function has to run wherever a given binding is produced and checked.\n */\nexport type InterruptHash = (canonicalJson: string) => string\n\n/** The built-in default: SHA-256, prefixed so the algorithm is self-describing. */\nexport function defaultInterruptHash(canonicalJson: string): string {\n  return `sha256:${sha256Hex(canonicalJson)}`\n}\n\nfunction canonical(value: unknown, active: WeakSet<object>): string {\n  if (value === null) return 'null'\n  if (typeof value === 'string' || typeof value === 'boolean') {\n    return JSON.stringify(value)\n  }\n  if (typeof value === 'number' && Number.isFinite(value)) {\n    return JSON.stringify(value)\n  }\n  if (typeof value !== 'object') {\n    throw new TypeError('Interrupt values must be JSON-compatible.')\n  }\n  if (active.has(value)) {\n    throw new TypeError('Interrupt values must not cycle.')\n  }\n  if (\n    !Array.isArray(value) &&\n    Object.getPrototypeOf(value) !== Object.prototype &&\n    Object.getPrototypeOf(value) !== null\n  ) {\n    throw new TypeError('Interrupt values must use plain JSON objects.')\n  }\n\n  active.add(value)\n  let encoded: string\n  if (Array.isArray(value)) {\n    const items: Array<string> = []\n    for (let index = 0; index < value.length; index++) {\n      items.push(canonical(value[index], active))\n    }\n    encoded = `[${items.join(',')}]`\n  } else {\n    const record = value as Record<string, unknown>\n    encoded = `{${Object.keys(record)\n      .sort()\n      .map((key) => `${JSON.stringify(key)}:${canonical(record[key], active)}`)\n      .join(',')}}`\n  }\n  active.delete(value)\n  return encoded\n}\n\nexport function canonicalInterruptJson(value: unknown): string {\n  return canonical(value, new WeakSet<object>())\n}\n\nexport function digestInterruptJson(\n  canonicalJson: string,\n  hash: InterruptHash = defaultInterruptHash,\n): string {\n  if (typeof canonicalJson !== 'string') {\n    throw new TypeError('Interrupt digests require canonical JSON text.')\n  }\n  return hash(canonicalJson)\n}\n\nfunction freezeTree(value: unknown): void {\n  if (value === null || typeof value !== 'object' || Object.isFrozen(value)) {\n    return\n  }\n  Object.values(value).forEach(freezeTree)\n  Object.freeze(value)\n}\n\nexport function cloneAndDeepFreezeJson<T>(value: T): T {\n  const clone: T = JSON.parse(canonicalInterruptJson(value))\n  freezeTree(clone)\n  return clone\n}\n"],"mappings":"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"}

package/dist/esm/interrupts.d.ts

@@ -0,0 +1,84 @@
+import { RunAgentResumeItem } from './types.js';
+export interface InterruptCorrelation {
+    threadId: string;
+    interruptedRunId: string;
+    generation: number;
+    submissionId?: string;
+    continuationRunId?: string;
+}
+export type ItemInterruptErrorCode = 'invalid-payload' | 'invalid-edited-args' | 'invalid-tool-output' | 'invalid-response-schema' | 'unknown-interrupt' | 'expired' | 'stale' | 'conflict' | 'legacy-unsupported';
+export type BatchInterruptErrorCode = 'incomplete-batch' | 'item-validation-failed' | 'unsupported-bulk-operation' | 'async-resolver' | 'inactive-transaction' | 'mixed-provenance' | 'transport' | 'server' | 'protocol' | 'invalid-response-schema' | 'expired' | 'stale' | 'conflict' | 'legacy-submit-failed';
+export interface ItemInterruptError extends InterruptCorrelation {
+    scope: 'item';
+    interruptId: string;
+    code: ItemInterruptErrorCode;
+    message: string;
+    path?: ReadonlyArray<string | number>;
+    source: 'client' | 'server';
+    retryable: boolean;
+}
+export interface BatchInterruptError extends InterruptCorrelation {
+    scope: 'batch';
+    code: BatchInterruptErrorCode;
+    message: string;
+    source: 'client' | 'server' | 'transport';
+    retryable: boolean;
+    interruptIds: ReadonlyArray<string>;
+}
+export type InterruptSubmissionError = ItemInterruptError | BatchInterruptError;
+/**
+ * Wire version of {@link InterruptBinding}.
+ *
+ * The binding is the only part of an AG-UI `Interrupt` that this package
+ * claims — it rides in `metadata` under
+ * {@link INTERRUPT_BINDING_METADATA_KEY} and tells the resume path how to
+ * correlate an answer back to a paused run. Producers stamp `v`; readers
+ * reject any version they don't understand rather than duck-typing the fields.
+ *
+ * That matters because an AG-UI `Interrupt` is a shared envelope. Another
+ * producer — a workflow engine projecting a durable approval, a third-party
+ * agent — can legitimately put its own binding in the same envelope. Versioning
+ * makes "not mine" a clean rejection instead of a partial match that resumes
+ * against the wrong owner.
+ */
+export declare const INTERRUPT_BINDING_VERSION: 1;
+interface InterruptBindingBase {
+    /** @see INTERRUPT_BINDING_VERSION */
+    v: typeof INTERRUPT_BINDING_VERSION;
+    interruptId: string;
+    interruptedRunId: string;
+    generation: number;
+    responseSchemaHash: string;
+    expiresAt?: string;
+}
+export type InterruptBinding = (InterruptBindingBase & {
+    kind: 'tool-approval';
+    toolName: string;
+    toolCallId: string;
+    originalArgs: unknown;
+    inputSchemaHash: string;
+    approvalSchemaHash: string;
+}) | (InterruptBindingBase & {
+    kind: 'client-tool-execution';
+    toolName: string;
+    toolCallId: string;
+    outputSchemaHash: string;
+}) | (InterruptBindingBase & {
+    kind: 'generic';
+});
+export type UnopenedInterruptBinding = InterruptBinding extends infer TBinding ? TBinding extends InterruptBinding ? Omit<TBinding, 'interruptedRunId' | 'generation'> : never : never;
+export type ToolApprovalResolution = boolean | {
+    approved: true;
+    editedArgs?: unknown;
+    payload?: unknown;
+} | {
+    approved: false;
+    payload?: unknown;
+    editedArgs?: never;
+};
+export declare function canonicalizeInterruptResolutions(resolutions: ReadonlyArray<RunAgentResumeItem>): {
+    resolutions: ReadonlyArray<RunAgentResumeItem>;
+    canonicalResolutions: string;
+    fingerprint: string;
+};
+export {};

package/dist/esm/interrupts.js

@@ -0,0 +1,31 @@
+import { canonicalInterruptJson, cloneAndDeepFreezeJson, digestInterruptJson } from "./interrupt-serialization.js";
+//#region src/interrupts.ts
+/**
+* Wire version of {@link InterruptBinding}.
+*
+* The binding is the only part of an AG-UI `Interrupt` that this package
+* claims — it rides in `metadata` under
+* {@link INTERRUPT_BINDING_METADATA_KEY} and tells the resume path how to
+* correlate an answer back to a paused run. Producers stamp `v`; readers
+* reject any version they don't understand rather than duck-typing the fields.
+*
+* That matters because an AG-UI `Interrupt` is a shared envelope. Another
+* producer — a workflow engine projecting a durable approval, a third-party
+* agent — can legitimately put its own binding in the same envelope. Versioning
+* makes "not mine" a clean rejection instead of a partial match that resumes
+* against the wrong owner.
+*/
+var INTERRUPT_BINDING_VERSION = 1;
+function canonicalizeInterruptResolutions(resolutions) {
+	const frozen = cloneAndDeepFreezeJson([...resolutions].sort((left, right) => left.interruptId.localeCompare(right.interruptId)));
+	const canonicalResolutions = canonicalInterruptJson(frozen);
+	return Object.freeze({
+		resolutions: frozen,
+		canonicalResolutions,
+		fingerprint: digestInterruptJson(canonicalResolutions)
+	});
+}
+//#endregion
+export { INTERRUPT_BINDING_VERSION, canonicalizeInterruptResolutions };
+
+//# sourceMappingURL=interrupts.js.map

package/dist/esm/interrupts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupts.js","names":[],"sources":["../../src/interrupts.ts"],"sourcesContent":["import {\n  canonicalInterruptJson,\n  cloneAndDeepFreezeJson,\n  digestInterruptJson,\n} from './interrupt-serialization'\nimport type { RunAgentResumeItem } from './types'\n\nexport interface InterruptCorrelation {\n  threadId: string\n  interruptedRunId: string\n  generation: number\n  submissionId?: string\n  continuationRunId?: string\n}\n\nexport type ItemInterruptErrorCode =\n  | 'invalid-payload'\n  | 'invalid-edited-args'\n  | 'invalid-tool-output'\n  | 'invalid-response-schema'\n  | 'unknown-interrupt'\n  | 'expired'\n  | 'stale'\n  | 'conflict'\n  | 'legacy-unsupported'\n\nexport type BatchInterruptErrorCode =\n  | 'incomplete-batch'\n  | 'item-validation-failed'\n  | 'unsupported-bulk-operation'\n  | 'async-resolver'\n  | 'inactive-transaction'\n  | 'mixed-provenance'\n  | 'transport'\n  | 'server'\n  | 'protocol'\n  | 'invalid-response-schema'\n  | 'expired'\n  | 'stale'\n  | 'conflict'\n  | 'legacy-submit-failed'\n\nexport interface ItemInterruptError extends InterruptCorrelation {\n  scope: 'item'\n  interruptId: string\n  code: ItemInterruptErrorCode\n  message: string\n  path?: ReadonlyArray<string | number>\n  source: 'client' | 'server'\n  retryable: boolean\n}\n\nexport interface BatchInterruptError extends InterruptCorrelation {\n  scope: 'batch'\n  code: BatchInterruptErrorCode\n  message: string\n  source: 'client' | 'server' | 'transport'\n  retryable: boolean\n  interruptIds: ReadonlyArray<string>\n}\n\nexport type InterruptSubmissionError = ItemInterruptError | BatchInterruptError\n\n/**\n * Wire version of {@link InterruptBinding}.\n *\n * The binding is the only part of an AG-UI `Interrupt` that this package\n * claims — it rides in `metadata` under\n * {@link INTERRUPT_BINDING_METADATA_KEY} and tells the resume path how to\n * correlate an answer back to a paused run. Producers stamp `v`; readers\n * reject any version they don't understand rather than duck-typing the fields.\n *\n * That matters because an AG-UI `Interrupt` is a shared envelope. Another\n * producer — a workflow engine projecting a durable approval, a third-party\n * agent — can legitimately put its own binding in the same envelope. Versioning\n * makes \"not mine\" a clean rejection instead of a partial match that resumes\n * against the wrong owner.\n */\nexport const INTERRUPT_BINDING_VERSION = 1 as const\n\ninterface InterruptBindingBase {\n  /** @see INTERRUPT_BINDING_VERSION */\n  v: typeof INTERRUPT_BINDING_VERSION\n  interruptId: string\n  interruptedRunId: string\n  generation: number\n  responseSchemaHash: string\n  expiresAt?: string\n}\n\nexport type InterruptBinding =\n  | (InterruptBindingBase & {\n      kind: 'tool-approval'\n      toolName: string\n      toolCallId: string\n      originalArgs: unknown\n      inputSchemaHash: string\n      approvalSchemaHash: string\n    })\n  | (InterruptBindingBase & {\n      kind: 'client-tool-execution'\n      toolName: string\n      toolCallId: string\n      outputSchemaHash: string\n    })\n  | (InterruptBindingBase & {\n      kind: 'generic'\n    })\n\nexport type UnopenedInterruptBinding = InterruptBinding extends infer TBinding\n  ? TBinding extends InterruptBinding\n    ? Omit<TBinding, 'interruptedRunId' | 'generation'>\n    : never\n  : never\n\nexport type ToolApprovalResolution =\n  | boolean\n  | {\n      approved: true\n      editedArgs?: unknown\n      payload?: unknown\n    }\n  | {\n      approved: false\n      payload?: unknown\n      editedArgs?: never\n    }\n\nexport function canonicalizeInterruptResolutions(\n  resolutions: ReadonlyArray<RunAgentResumeItem>,\n): {\n  resolutions: ReadonlyArray<RunAgentResumeItem>\n  canonicalResolutions: string\n  fingerprint: string\n} {\n  const sorted = [...resolutions].sort((left, right) =>\n    left.interruptId.localeCompare(right.interruptId),\n  )\n  const frozen = cloneAndDeepFreezeJson(sorted)\n  const canonicalResolutions = canonicalInterruptJson(frozen)\n  return Object.freeze({\n    resolutions: frozen,\n    canonicalResolutions,\n    fingerprint: digestInterruptJson(canonicalResolutions),\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA8EA,IAAa,4BAA4B;AAkDzC,SAAgB,iCACd,aAKA;CAIA,MAAM,SAAS,uBAHA,CAAC,GAAG,WAAW,CAAC,CAAC,MAAM,MAAM,UAC1C,KAAK,YAAY,cAAc,MAAM,WAAW,CAEZ,CAAM;CAC5C,MAAM,uBAAuB,uBAAuB,MAAM;CAC1D,OAAO,OAAO,OAAO;EACnB,aAAa;EACb;EACA,aAAa,oBAAoB,oBAAoB;CACvD,CAAC;AACH"}

package/dist/esm/locks.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Distributed-mutex primitive — coordination, not state persistence.
+ *
+ * Its own subpath (`@tanstack/ai/locks`) so it stays out of the main barrel and
+ * consumers opt in explicitly. Provide a store with `withLocks`; downstream
+ * middleware (e.g. `@tanstack/ai-sandbox`'s `ensure`) reads it via `getLocks` /
+ * `LocksCapability`. Import from here, not from `@tanstack/ai-persistence`.
+ */
+export { LocksCapability, getLocks, provideLocks, InMemoryLockStore, withLocks, defineLock, } from './activities/chat/middleware/index.js';
+export type { LockStore } from './activities/chat/middleware/index.js';

package/dist/esm/locks.js

@@ -0,0 +1,2 @@
+import { InMemoryLockStore, LocksCapability, defineLock, getLocks, provideLocks, withLocks } from "./activities/chat/middleware/locks.js";
+export { InMemoryLockStore, LocksCapability, defineLock, getLocks, provideLocks, withLocks };

package/dist/esm/logger/console-logger.js

@@ -1,83 +1,106 @@
-const DIR_OPTIONS = { depth: null, colors: true };
+//#region src/logger/console-logger.ts
+/**
+* `util.inspect` options used with `console.dir` on Node so deeply nested
+* structures (e.g. provider chunk payloads with `usage`, `output`,
+* `reasoning`, `tools`) render in full instead of truncating to
+* `[Object]` / `[Array]`.
+*/
+var DIR_OPTIONS = {
+	depth: null,
+	colors: true
+};
 function resolveMetaStrategy() {
-  try {
-    if (globalThis.navigator?.userAgent === "Cloudflare-Workers") return "json";
-  } catch {
-  }
-  if (typeof process !== "undefined" && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- a partial process global (bundler shims) may lack versions
-  typeof process.versions?.node === "string") {
-    return "dir";
-  }
-  return "arg";
+	try {
+		if (globalThis.navigator?.userAgent === "Cloudflare-Workers") return "json";
+	} catch {}
+	if (typeof process !== "undefined" && typeof process.versions?.node === "string") return "dir";
+	return "arg";
 }
+/**
+* `JSON.stringify` hardened for debug payloads: circular references collapse
+* to `"[Circular]"`, `Error` instances expand to `name`/`message`/`stack`
+* (they would otherwise stringify to `{}`), and `bigint` values become
+* strings (they would otherwise throw). Never throws — falls back to
+* `String(value)` and, if even that coercion throws, a placeholder.
+*/
 function stringifyMetaSafely(value) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  try {
-    return JSON.stringify(
-      value,
-      (_key, entry) => {
-        if (typeof entry === "bigint") return entry.toString();
-        if (entry instanceof Error) {
-          return {
-            name: entry.name,
-            message: entry.message,
-            stack: entry.stack
-          };
-        }
-        if (typeof entry === "object" && entry !== null) {
-          if (seen.has(entry)) return "[Circular]";
-          seen.add(entry);
-        }
-        return entry;
-      },
-      2
-    );
-  } catch {
-    try {
-      return String(value);
-    } catch {
-      return "[Unserializable meta]";
-    }
-  }
-}
-class ConsoleLogger {
-  /** Log a debug-level message; forwards to `console.debug`. */
-  debug(message, meta) {
-    this.emit("debug", message, meta);
-  }
-  /** Log an info-level message; forwards to `console.info`. */
-  info(message, meta) {
-    this.emit("info", message, meta);
-  }
-  /** Log a warning-level message; forwards to `console.warn`. */
-  warn(message, meta) {
-    this.emit("warn", message, meta);
-  }
-  /** Log an error-level message; forwards to `console.error`. */
-  error(message, meta) {
-    this.emit("error", message, meta);
-  }
-  emit(level, message, meta) {
-    if (meta === void 0) {
-      console[level](message);
-      return;
-    }
-    switch (resolveMetaStrategy()) {
-      case "dir":
-        console[level](message);
-        console.dir(meta, DIR_OPTIONS);
-        break;
-      case "json":
-        console[level](`${message}
-${stringifyMetaSafely(meta)}`);
-        break;
-      case "arg":
-        console[level](message, meta);
-        break;
-    }
-  }
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		return JSON.stringify(value, (_key, entry) => {
+			if (typeof entry === "bigint") return entry.toString();
+			if (entry instanceof Error) return {
+				name: entry.name,
+				message: entry.message,
+				stack: entry.stack
+			};
+			if (typeof entry === "object" && entry !== null) {
+				if (seen.has(entry)) return "[Circular]";
+				seen.add(entry);
+			}
+			return entry;
+		}, 2);
+	} catch {
+		try {
+			return String(value);
+		} catch {
+			return "[Unserializable meta]";
+		}
+	}
 }
-export {
-  ConsoleLogger
+/**
+* Default `Logger` implementation that routes each level to the matching
+* `console` method:
+*
+* - `debug` → `console.debug`
+* - `info` → `console.info`
+* - `warn` → `console.warn`
+* - `error` → `console.error`
+*
+* When a `meta` object is supplied it is rendered with the strategy that
+* actually surfaces it on the current runtime (see {@link MetaStrategy}):
+* depth-unlimited `console.dir` on Node, circular-safe JSON on Cloudflare
+* Workers, and an extra console argument everywhere else.
+*
+* This is the logger used when `debug` is enabled on any activity and no
+* custom `logger` is supplied via `debug: { logger }`.
+*/
+var ConsoleLogger = class {
+	/** Log a debug-level message; forwards to `console.debug`. */
+	debug(message, meta) {
+		this.emit("debug", message, meta);
+	}
+	/** Log an info-level message; forwards to `console.info`. */
+	info(message, meta) {
+		this.emit("info", message, meta);
+	}
+	/** Log a warning-level message; forwards to `console.warn`. */
+	warn(message, meta) {
+		this.emit("warn", message, meta);
+	}
+	/** Log an error-level message; forwards to `console.error`. */
+	error(message, meta) {
+		this.emit("error", message, meta);
+	}
+	emit(level, message, meta) {
+		if (meta === void 0) {
+			console[level](message);
+			return;
+		}
+		switch (resolveMetaStrategy()) {
+			case "dir":
+				console[level](message);
+				console.dir(meta, DIR_OPTIONS);
+				break;
+			case "json":
+				console[level](`${message}\n${stringifyMetaSafely(meta)}`);
+				break;
+			case "arg":
+				console[level](message, meta);
+				break;
+		}
+	}
 };
-//# sourceMappingURL=console-logger.js.map
+//#endregion
+export { ConsoleLogger };
+
+//# sourceMappingURL=console-logger.js.map

package/dist/esm/logger/console-logger.js.map

@@ -1 +1 @@
-{"version":3,"file":"console-logger.js","sources":["../../../src/logger/console-logger.ts"],"sourcesContent":["import type { Logger } from './types'\n\n/**\n * `util.inspect` options used with `console.dir` on Node so deeply nested\n * structures (e.g. provider chunk payloads with `usage`, `output`,\n * `reasoning`, `tools`) render in full instead of truncating to\n * `[Object]` / `[Array]`.\n */\nconst DIR_OPTIONS = { depth: null, colors: true } as const\n\n/**\n * How `meta` should be rendered on the current runtime:\n *\n * - `dir` — Node. `console.dir(meta, { depth: null, colors: true })` gives a\n *   depth-unlimited, colored inspect dump.\n * - `json` — Cloudflare Workers / workerd. workerd never forwards\n *   `console.dir` output to the terminal (with or without options), and its\n *   own inspect of extra console arguments truncates nested objects, so the\n *   payload is appended as circular-safe pretty-printed JSON instead.\n * - `arg` — everything else (browsers, Deno, Bun). `meta` is passed as an\n *   extra console argument: devtools keep collapsible object trees and the\n *   runtime's inspect handles circular references natively.\n */\ntype MetaStrategy = 'dir' | 'json' | 'arg'\n\nfunction resolveMetaStrategy(): MetaStrategy {\n  // workerd must be detected before the Node check: under the `nodejs_compat`\n  // flag it emulates `process.versions.node`, but still drops `console.dir`.\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- navigator is missing on Node < 21 despite the DOM lib typing it as always present\n    if (globalThis.navigator?.userAgent === 'Cloudflare-Workers') return 'json'\n  } catch {\n    // A locked-down runtime with a throwing `userAgent` getter is not workerd;\n    // fall through to the remaining checks rather than crash the log call.\n  }\n  if (\n    typeof process !== 'undefined' &&\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- a partial process global (bundler shims) may lack versions\n    typeof process.versions?.node === 'string'\n  ) {\n    return 'dir'\n  }\n  return 'arg'\n}\n\n/**\n * `JSON.stringify` hardened for debug payloads: circular references collapse\n * to `\"[Circular]\"`, `Error` instances expand to `name`/`message`/`stack`\n * (they would otherwise stringify to `{}`), and `bigint` values become\n * strings (they would otherwise throw). Never throws — falls back to\n * `String(value)` and, if even that coercion throws, a placeholder.\n */\nfunction stringifyMetaSafely(value: unknown): string {\n  const seen = new WeakSet<object>()\n  try {\n    return JSON.stringify(\n      value,\n      (_key, entry: unknown) => {\n        if (typeof entry === 'bigint') return entry.toString()\n        if (entry instanceof Error) {\n          return {\n            name: entry.name,\n            message: entry.message,\n            stack: entry.stack,\n          }\n        }\n        if (typeof entry === 'object' && entry !== null) {\n          if (seen.has(entry)) return '[Circular]'\n          seen.add(entry)\n        }\n        return entry\n      },\n      2,\n    )\n  } catch {\n    try {\n      return String(value)\n    } catch {\n      return '[Unserializable meta]'\n    }\n  }\n}\n\n/**\n * Default `Logger` implementation that routes each level to the matching\n * `console` method:\n *\n * - `debug` → `console.debug`\n * - `info` → `console.info`\n * - `warn` → `console.warn`\n * - `error` → `console.error`\n *\n * When a `meta` object is supplied it is rendered with the strategy that\n * actually surfaces it on the current runtime (see {@link MetaStrategy}):\n * depth-unlimited `console.dir` on Node, circular-safe JSON on Cloudflare\n * Workers, and an extra console argument everywhere else.\n *\n * This is the logger used when `debug` is enabled on any activity and no\n * custom `logger` is supplied via `debug: { logger }`.\n */\nexport class ConsoleLogger implements Logger {\n  /** Log a debug-level message; forwards to `console.debug`. */\n  debug(message: string, meta?: Record<string, unknown>): void {\n    this.emit('debug', message, meta)\n  }\n\n  /** Log an info-level message; forwards to `console.info`. */\n  info(message: string, meta?: Record<string, unknown>): void {\n    this.emit('info', message, meta)\n  }\n\n  /** Log a warning-level message; forwards to `console.warn`. */\n  warn(message: string, meta?: Record<string, unknown>): void {\n    this.emit('warn', message, meta)\n  }\n\n  /** Log an error-level message; forwards to `console.error`. */\n  error(message: string, meta?: Record<string, unknown>): void {\n    this.emit('error', message, meta)\n  }\n\n  private emit(\n    level: 'debug' | 'info' | 'warn' | 'error',\n    message: string,\n    meta?: Record<string, unknown>,\n  ): void {\n    if (meta === undefined) {\n      console[level](message)\n      return\n    }\n    switch (resolveMetaStrategy()) {\n      case 'dir':\n        console[level](message)\n        console.dir(meta, DIR_OPTIONS)\n        break\n      case 'json':\n        console[level](`${message}\\n${stringifyMetaSafely(meta)}`)\n        break\n      case 'arg':\n        console[level](message, meta)\n        break\n    }\n  }\n}\n"],"names":[],"mappings":"AAQA,MAAM,cAAc,EAAE,OAAO,MAAM,QAAQ,KAAA;AAiB3C,SAAS,sBAAoC;AAG3C,MAAI;AAEF,QAAI,WAAW,WAAW,cAAc,qBAAsB,QAAO;AAAA,EACvE,QAAQ;AAAA,EAGR;AACA,MACE,OAAO,YAAY;AAAA,EAEnB,OAAO,QAAQ,UAAU,SAAS,UAClC;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;AASA,SAAS,oBAAoB,OAAwB;AACnD,QAAM,2BAAW,QAAA;AACjB,MAAI;AACF,WAAO,KAAK;AAAA,MACV;AAAA,MACA,CAAC,MAAM,UAAmB;AACxB,YAAI,OAAO,UAAU,SAAU,QAAO,MAAM,SAAA;AAC5C,YAAI,iBAAiB,OAAO;AAC1B,iBAAO;AAAA,YACL,MAAM,MAAM;AAAA,YACZ,SAAS,MAAM;AAAA,YACf,OAAO,MAAM;AAAA,UAAA;AAAA,QAEjB;AACA,YAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C,cAAI,KAAK,IAAI,KAAK,EAAG,QAAO;AAC5B,eAAK,IAAI,KAAK;AAAA,QAChB;AACA,eAAO;AAAA,MACT;AAAA,MACA;AAAA,IAAA;AAAA,EAEJ,QAAQ;AACN,QAAI;AACF,aAAO,OAAO,KAAK;AAAA,IACrB,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAmBO,MAAM,cAAgC;AAAA;AAAA,EAE3C,MAAM,SAAiB,MAAsC;AAC3D,SAAK,KAAK,SAAS,SAAS,IAAI;AAAA,EAClC;AAAA;AAAA,EAGA,KAAK,SAAiB,MAAsC;AAC1D,SAAK,KAAK,QAAQ,SAAS,IAAI;AAAA,EACjC;AAAA;AAAA,EAGA,KAAK,SAAiB,MAAsC;AAC1D,SAAK,KAAK,QAAQ,SAAS,IAAI;AAAA,EACjC;AAAA;AAAA,EAGA,MAAM,SAAiB,MAAsC;AAC3D,SAAK,KAAK,SAAS,SAAS,IAAI;AAAA,EAClC;AAAA,EAEQ,KACN,OACA,SACA,MACM;AACN,QAAI,SAAS,QAAW;AACtB,cAAQ,KAAK,EAAE,OAAO;AACtB;AAAA,IACF;AACA,YAAQ,uBAAoB;AAAA,MAC1B,KAAK;AACH,gBAAQ,KAAK,EAAE,OAAO;AACtB,gBAAQ,IAAI,MAAM,WAAW;AAC7B;AAAA,MACF,KAAK;AACH,gBAAQ,KAAK,EAAE,GAAG,OAAO;AAAA,EAAK,oBAAoB,IAAI,CAAC,EAAE;AACzD;AAAA,MACF,KAAK;AACH,gBAAQ,KAAK,EAAE,SAAS,IAAI;AAC5B;AAAA,IAAA;AAAA,EAEN;AACF;"}
+{"version":3,"file":"console-logger.js","names":[],"sources":["../../../src/logger/console-logger.ts"],"sourcesContent":["import type { Logger } from './types'\n\n/**\n * `util.inspect` options used with `console.dir` on Node so deeply nested\n * structures (e.g. provider chunk payloads with `usage`, `output`,\n * `reasoning`, `tools`) render in full instead of truncating to\n * `[Object]` / `[Array]`.\n */\nconst DIR_OPTIONS = { depth: null, colors: true } as const\n\n/**\n * How `meta` should be rendered on the current runtime:\n *\n * - `dir` — Node. `console.dir(meta, { depth: null, colors: true })` gives a\n *   depth-unlimited, colored inspect dump.\n * - `json` — Cloudflare Workers / workerd. workerd never forwards\n *   `console.dir` output to the terminal (with or without options), and its\n *   own inspect of extra console arguments truncates nested objects, so the\n *   payload is appended as circular-safe pretty-printed JSON instead.\n * - `arg` — everything else (browsers, Deno, Bun). `meta` is passed as an\n *   extra console argument: devtools keep collapsible object trees and the\n *   runtime's inspect handles circular references natively.\n */\ntype MetaStrategy = 'dir' | 'json' | 'arg'\n\nfunction resolveMetaStrategy(): MetaStrategy {\n  // workerd must be detected before the Node check: under the `nodejs_compat`\n  // flag it emulates `process.versions.node`, but still drops `console.dir`.\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- navigator is missing on Node < 21 despite the DOM lib typing it as always present\n    if (globalThis.navigator?.userAgent === 'Cloudflare-Workers') return 'json'\n  } catch {\n    // A locked-down runtime with a throwing `userAgent` getter is not workerd;\n    // fall through to the remaining checks rather than crash the log call.\n  }\n  if (\n    typeof process !== 'undefined' &&\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- a partial process global (bundler shims) may lack versions\n    typeof process.versions?.node === 'string'\n  ) {\n    return 'dir'\n  }\n  return 'arg'\n}\n\n/**\n * `JSON.stringify` hardened for debug payloads: circular references collapse\n * to `\"[Circular]\"`, `Error` instances expand to `name`/`message`/`stack`\n * (they would otherwise stringify to `{}`), and `bigint` values become\n * strings (they would otherwise throw). Never throws — falls back to\n * `String(value)` and, if even that coercion throws, a placeholder.\n */\nfunction stringifyMetaSafely(value: unknown): string {\n  const seen = new WeakSet<object>()\n  try {\n    return JSON.stringify(\n      value,\n      (_key, entry: unknown) => {\n        if (typeof entry === 'bigint') return entry.toString()\n        if (entry instanceof Error) {\n          return {\n            name: entry.name,\n            message: entry.message,\n            stack: entry.stack,\n          }\n        }\n        if (typeof entry === 'object' && entry !== null) {\n          if (seen.has(entry)) return '[Circular]'\n          seen.add(entry)\n        }\n        return entry\n      },\n      2,\n    )\n  } catch {\n    try {\n      return String(value)\n    } catch {\n      return '[Unserializable meta]'\n    }\n  }\n}\n\n/**\n * Default `Logger` implementation that routes each level to the matching\n * `console` method:\n *\n * - `debug` → `console.debug`\n * - `info` → `console.info`\n * - `warn` → `console.warn`\n * - `error` → `console.error`\n *\n * When a `meta` object is supplied it is rendered with the strategy that\n * actually surfaces it on the current runtime (see {@link MetaStrategy}):\n * depth-unlimited `console.dir` on Node, circular-safe JSON on Cloudflare\n * Workers, and an extra console argument everywhere else.\n *\n * This is the logger used when `debug` is enabled on any activity and no\n * custom `logger` is supplied via `debug: { logger }`.\n */\nexport class ConsoleLogger implements Logger {\n  /** Log a debug-level message; forwards to `console.debug`. */\n  debug(message: string, meta?: Record<string, unknown>): void {\n    this.emit('debug', message, meta)\n  }\n\n  /** Log an info-level message; forwards to `console.info`. */\n  info(message: string, meta?: Record<string, unknown>): void {\n    this.emit('info', message, meta)\n  }\n\n  /** Log a warning-level message; forwards to `console.warn`. */\n  warn(message: string, meta?: Record<string, unknown>): void {\n    this.emit('warn', message, meta)\n  }\n\n  /** Log an error-level message; forwards to `console.error`. */\n  error(message: string, meta?: Record<string, unknown>): void {\n    this.emit('error', message, meta)\n  }\n\n  private emit(\n    level: 'debug' | 'info' | 'warn' | 'error',\n    message: string,\n    meta?: Record<string, unknown>,\n  ): void {\n    if (meta === undefined) {\n      console[level](message)\n      return\n    }\n    switch (resolveMetaStrategy()) {\n      case 'dir':\n        console[level](message)\n        console.dir(meta, DIR_OPTIONS)\n        break\n      case 'json':\n        console[level](`${message}\\n${stringifyMetaSafely(meta)}`)\n        break\n      case 'arg':\n        console[level](message, meta)\n        break\n    }\n  }\n}\n"],"mappings":";;;;;;;AAQA,IAAM,cAAc;CAAE,OAAO;CAAM,QAAQ;AAAK;AAiBhD,SAAS,sBAAoC;CAG3C,IAAI;EAEF,IAAI,WAAW,WAAW,cAAc,sBAAsB,OAAO;CACvE,QAAQ,CAGR;CACA,IACE,OAAO,YAAY,eAEnB,OAAO,QAAQ,UAAU,SAAS,UAElC,OAAO;CAET,OAAO;AACT;;;;;;;;AASA,SAAS,oBAAoB,OAAwB;CACnD,MAAM,uBAAO,IAAI,QAAgB;CACjC,IAAI;EACF,OAAO,KAAK,UACV,QACC,MAAM,UAAmB;GACxB,IAAI,OAAO,UAAU,UAAU,OAAO,MAAM,SAAS;GACrD,IAAI,iBAAiB,OACnB,OAAO;IACL,MAAM,MAAM;IACZ,SAAS,MAAM;IACf,OAAO,MAAM;GACf;GAEF,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM;IAC/C,IAAI,KAAK,IAAI,KAAK,GAAG,OAAO;IAC5B,KAAK,IAAI,KAAK;GAChB;GACA,OAAO;EACT,GACA,CACF;CACF,QAAQ;EACN,IAAI;GACF,OAAO,OAAO,KAAK;EACrB,QAAQ;GACN,OAAO;EACT;CACF;AACF;;;;;;;;;;;;;;;;;;AAmBA,IAAa,gBAAb,MAA6C;;CAE3C,MAAM,SAAiB,MAAsC;EAC3D,KAAK,KAAK,SAAS,SAAS,IAAI;CAClC;;CAGA,KAAK,SAAiB,MAAsC;EAC1D,KAAK,KAAK,QAAQ,SAAS,IAAI;CACjC;;CAGA,KAAK,SAAiB,MAAsC;EAC1D,KAAK,KAAK,QAAQ,SAAS,IAAI;CACjC;;CAGA,MAAM,SAAiB,MAAsC;EAC3D,KAAK,KAAK,SAAS,SAAS,IAAI;CAClC;CAEA,KACE,OACA,SACA,MACM;EACN,IAAI,SAAS,KAAA,GAAW;GACtB,QAAQ,MAAM,CAAC,OAAO;GACtB;EACF;EACA,QAAQ,oBAAoB,GAA5B;GACE,KAAK;IACH,QAAQ,MAAM,CAAC,OAAO;IACtB,QAAQ,IAAI,MAAM,WAAW;IAC7B;GACF,KAAK;IACH,QAAQ,MAAM,CAAC,GAAG,QAAQ,IAAI,oBAAoB,IAAI,GAAG;IACzD;GACF,KAAK;IACH,QAAQ,MAAM,CAAC,SAAS,IAAI;IAC5B;EACJ;CACF;AACF"}