stitchkit 0.93.0 → 0.94.0

package/dist/index-xsqjkha9.js

@@ -0,0 +1,281 @@
+import {
+  AgentAdmissionReceiptSchema,
+  AgentHistoryMutationSchema,
+  AgentRuntimeHeadSchema,
+  AgentSeedReceiptSchema,
+  AgentStoredRunSchema,
+  createAgentRuntimeStore,
+  isActiveRunState,
+  replaceMessage
+} from "./index-58k4fp34.js";
+import {
+  AgentRecoverablePageSchema,
+  AgentStoreEventEnvelopeSchema,
+  AgentStoreEventPageSchema
+} from "./index-1nd48tm9.js";
+import {
+  AgentMessageSchema,
+  AgentRecordIdSchema
+} from "./index-gtj3zc53.js";
+
+// src/agent-runtime/store-memory.ts
+import { z } from "zod";
+var RecoverableCursorSchema = z.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
+function recoverableCursor(input) {
+  return JSON.stringify([input.conversationId, input.run.id]);
+}
+function parseRecoverableCursor(cursor) {
+  return RecoverableCursorSchema.parse(JSON.parse(cursor));
+}
+function cloneHeadMap(source) {
+  return new Map([...source].map(([key, value]) => [
+    key,
+    AgentRuntimeHeadSchema.parse(structuredClone(value))
+  ]));
+}
+function cloneNestedMap(source, clone) {
+  return new Map([...source].map(([outerKey, values]) => [
+    outerKey,
+    new Map([...values].map(([innerKey, value]) => [innerKey, clone(value)]))
+  ]));
+}
+function cloneHistoryMap(source) {
+  return new Map([...source].map(([key, value]) => [
+    key,
+    value.map((message) => AgentMessageSchema.parse(structuredClone(message)))
+  ]));
+}
+var memoryConversations = {
+  async isPurged(transaction, conversationId) {
+    return transaction.purged.has(conversationId);
+  },
+  async remove(transaction, conversationId) {
+    transaction.purged.add(conversationId);
+    transaction.heads.delete(conversationId);
+    transaction.runs.delete(conversationId);
+    transaction.admissions.delete(conversationId);
+    transaction.seeds.delete(conversationId);
+    transaction.histories.delete(conversationId);
+    transaction.events.delete(conversationId);
+  }
+};
+var memoryHead = {
+  async load(transaction, conversationId) {
+    const head = transaction.heads.get(conversationId);
+    return head ? AgentRuntimeHeadSchema.parse(structuredClone(head)) : undefined;
+  },
+  async compareAndSwap(transaction, input) {
+    const current = transaction.heads.get(input.conversationId);
+    const actualVersion = current?.version ?? 0;
+    if (actualVersion !== input.expectedVersion) {
+      return { outcome: "conflict", actualVersion };
+    }
+    transaction.heads.set(input.conversationId, AgentRuntimeHeadSchema.parse(structuredClone(input.next)));
+    return { outcome: "applied" };
+  }
+};
+var memoryRuns = {
+  async load(transaction, input) {
+    const record = transaction.runs.get(input.conversationId)?.get(input.runId);
+    return record ? AgentStoredRunSchema.parse(structuredClone(record)) : undefined;
+  },
+  async loadByAssistantMessageId(transaction, input) {
+    const record = [...transaction.runs.get(input.conversationId)?.values() ?? []].find((candidate) => candidate.run.assistantMessageId === input.assistantMessageId);
+    return record ? AgentStoredRunSchema.parse(structuredClone(record)) : undefined;
+  },
+  async loadMany(transaction, input) {
+    const records = transaction.runs.get(input.conversationId);
+    return input.runIds.flatMap((runId) => {
+      const record = records?.get(runId);
+      return record ? [AgentStoredRunSchema.parse(structuredClone(record))] : [];
+    });
+  },
+  async listActive(transaction, conversationId) {
+    return [...transaction.runs.get(conversationId)?.values() ?? []].filter((record) => isActiveRunState(record.run.state)).map((record) => AgentStoredRunSchema.parse(structuredClone(record)));
+  },
+  async save(transaction, rawRecord) {
+    const record = AgentStoredRunSchema.parse(structuredClone(rawRecord));
+    const conversationRuns = transaction.runs.get(record.run.conversationId) ?? new Map;
+    const collision = [...conversationRuns.values()].find((candidate) => candidate.run.id !== record.run.id && candidate.run.assistantMessageId === record.run.assistantMessageId);
+    if (collision)
+      throw new TypeError("Assistant message identity is already reserved");
+    conversationRuns.set(record.run.id, record);
+    transaction.runs.set(record.run.conversationId, conversationRuns);
+  }
+};
+var memoryAdmissions = {
+  async load(transaction, input) {
+    const receipt = transaction.admissions.get(input.conversationId)?.get(input.idempotencyKey);
+    return receipt ? AgentAdmissionReceiptSchema.parse(structuredClone(receipt)) : undefined;
+  },
+  async loadByInputMessageId(transaction, input) {
+    const receipt = [
+      ...transaction.admissions.get(input.conversationId)?.values() ?? []
+    ].find((candidate) => candidate.input.id === input.inputMessageId);
+    return receipt ? AgentAdmissionReceiptSchema.parse(structuredClone(receipt)) : undefined;
+  },
+  async create(transaction, rawReceipt) {
+    const receipt = AgentAdmissionReceiptSchema.parse(structuredClone(rawReceipt));
+    const conversationAdmissions = transaction.admissions.get(receipt.conversationId) ?? new Map;
+    if (conversationAdmissions.has(receipt.idempotencyKey) || [...conversationAdmissions.values()].some((candidate) => candidate.input.id === receipt.input.id)) {
+      throw new TypeError("Admission identity is already reserved");
+    }
+    conversationAdmissions.set(receipt.idempotencyKey, receipt);
+    transaction.admissions.set(receipt.conversationId, conversationAdmissions);
+  }
+};
+var memorySeeds = {
+  async load(transaction, input) {
+    const receipt = transaction.seeds.get(input.conversationId)?.get(input.seedKey);
+    return receipt ? AgentSeedReceiptSchema.parse(structuredClone(receipt)) : undefined;
+  },
+  async create(transaction, rawReceipt) {
+    const receipt = AgentSeedReceiptSchema.parse(structuredClone(rawReceipt));
+    const conversationSeeds = transaction.seeds.get(receipt.conversationId) ?? new Map;
+    if (conversationSeeds.has(receipt.seedKey)) {
+      throw new TypeError("Conversation seed identity is already reserved");
+    }
+    conversationSeeds.set(receipt.seedKey, receipt);
+    transaction.seeds.set(receipt.conversationId, conversationSeeds);
+  }
+};
+var memoryHistory = {
+  async load(transaction, conversationId) {
+    return (transaction.histories.get(conversationId) ?? []).map((message) => AgentMessageSchema.parse(structuredClone(message)));
+  },
+  async hasMessage(transaction, input) {
+    return (transaction.histories.get(input.conversationId) ?? []).some((message) => message.id === input.messageId);
+  },
+  async apply(transaction, rawMutation) {
+    const mutation = AgentHistoryMutationSchema.parse(rawMutation);
+    const conversationId = mutation.type === "admit" ? mutation.input.conversationId : mutation.type === "upsert-assistant" ? mutation.message.conversationId : mutation.type === "seed" ? mutation.message.conversationId : mutation.summary.conversationId;
+    const current = transaction.histories.get(conversationId) ?? [];
+    if (mutation.type === "admit") {
+      transaction.histories.set(conversationId, [...current, mutation.input]);
+      return;
+    }
+    if (mutation.type === "upsert-assistant") {
+      transaction.histories.set(conversationId, replaceMessage(current, mutation.message));
+      return;
+    }
+    if (mutation.type === "seed") {
+      const existingIndex = current.findIndex((message) => message.id === mutation.message.id);
+      if (existingIndex === -1) {
+        transaction.histories.set(conversationId, [mutation.message, ...current]);
+      } else {
+        const next = [...current];
+        next[existingIndex] = mutation.message;
+        transaction.histories.set(conversationId, next);
+      }
+      return;
+    }
+    const replaced = new Set(mutation.replacedMessageIds);
+    const positions = current.map((message, index) => replaced.has(message.id) ? index : undefined).filter((index) => index !== undefined);
+    const first = positions[0];
+    if (first === undefined)
+      throw new Error("Compaction history range disappeared");
+    transaction.histories.set(conversationId, [
+      ...current.slice(0, first),
+      mutation.summary,
+      ...current.slice(first + positions.length)
+    ]);
+  }
+};
+var memoryEvents = {
+  async append(transaction, draft) {
+    const current = transaction.events.get(draft.conversationId) ?? [];
+    const event = AgentStoreEventEnvelopeSchema.parse({
+      ...draft,
+      seq: (current.at(-1)?.seq ?? 0) + 1
+    });
+    if (current.some((candidate) => candidate.eventId === event.eventId)) {
+      throw new TypeError("Agent store event identity is already present");
+    }
+    transaction.events.set(draft.conversationId, [...current, event]);
+    return event;
+  },
+  async list(transaction, input) {
+    const selected = (transaction.events.get(input.conversationId) ?? []).filter((event) => (input.fromSeq === undefined || event.seq >= input.fromSeq) && (input.toSeq === undefined || event.seq <= input.toSeq));
+    const items = selected.slice(0, input.limit);
+    const last = items.at(-1);
+    return AgentStoreEventPageSchema.parse({
+      items,
+      ...selected.length > items.length && last ? { nextSeq: last.seq + 1 } : {}
+    });
+  }
+};
+function scanMemoryRecoverable(runs, input) {
+  const descriptors = [...runs].flatMap(([conversationId, conversationRuns]) => [...conversationRuns.values()].filter((record) => isActiveRunState(record.run.state)).map((record) => ({ conversationId, run: record.run }))).sort((left, right) => left.conversationId.localeCompare(right.conversationId) || left.run.id.localeCompare(right.run.id));
+  const cursorTuple = input.cursor ? parseRecoverableCursor(input.cursor) : undefined;
+  const start = cursorTuple ? descriptors.findIndex((item) => item.conversationId.localeCompare(cursorTuple[0]) > 0 || item.conversationId === cursorTuple[0] && item.run.id.localeCompare(cursorTuple[1]) > 0) : 0;
+  if (start === -1) {
+    return AgentRecoverablePageSchema.parse({ items: [] });
+  }
+  const items = descriptors.slice(start, start + input.limit);
+  const last = items.at(-1);
+  const hasMore = start + items.length < descriptors.length;
+  return AgentRecoverablePageSchema.parse({
+    items,
+    ...hasMore && last && { nextCursor: recoverableCursor(last) }
+  });
+}
+function createMemoryAgentRuntimeStore() {
+  let purged = new Set;
+  let heads = new Map;
+  let runs = new Map;
+  let admissions = new Map;
+  let seeds = new Map;
+  let histories = new Map;
+  let events = new Map;
+  let transactionTail = Promise.resolve();
+  const driver = {
+    async transaction(work) {
+      const previous = transactionTail;
+      const release = Promise.withResolvers();
+      transactionTail = previous.catch(() => {
+        return;
+      }).then(() => release.promise);
+      await previous.catch(() => {
+        return;
+      });
+      const transaction = {
+        purged: new Set(purged),
+        heads: cloneHeadMap(heads),
+        runs: cloneNestedMap(runs, (record) => AgentStoredRunSchema.parse(structuredClone(record))),
+        admissions: cloneNestedMap(admissions, (receipt) => AgentAdmissionReceiptSchema.parse(structuredClone(receipt))),
+        seeds: cloneNestedMap(seeds, (receipt) => AgentSeedReceiptSchema.parse(structuredClone(receipt))),
+        histories: cloneHistoryMap(histories),
+        events: new Map([...events].map(([conversationId, stored]) => [
+          conversationId,
+          stored.map((event) => AgentStoreEventEnvelopeSchema.parse(structuredClone(event)))
+        ]))
+      };
+      try {
+        const result = await work(transaction);
+        purged = transaction.purged;
+        heads = transaction.heads;
+        runs = transaction.runs;
+        admissions = transaction.admissions;
+        seeds = transaction.seeds;
+        histories = transaction.histories;
+        events = transaction.events;
+        return result;
+      } finally {
+        release.resolve();
+      }
+    },
+    conversations: memoryConversations,
+    head: memoryHead,
+    runs: memoryRuns,
+    admissions: memoryAdmissions,
+    seeds: memorySeeds,
+    history: memoryHistory,
+    events: memoryEvents,
+    async scanRecoverable(input) {
+      return scanMemoryRecoverable(runs, input);
+    }
+  };
+  return createAgentRuntimeStore(driver);
+}
+
+export { createMemoryAgentRuntimeStore };

package/dist/{index-6kyksz9y.js → index-yw4fzmdz.js}

@@ -3,7 +3,7 @@ import {
 } from "./index-kzfs85xp.js";
 import {
   isRecord
-} from "./index-77fekveh.js";
+} from "./index-hffjpmq9.js";
 
 // src/observability/sanitize.ts
 var SENSITIVE_WORDS = new Set([

package/dist/{index-3xwxfj4z.js → index-zeemqhqx.js}

@@ -5,7 +5,7 @@ import {
 import {
   isRecord,
   transportResult
-} from "./index-77fekveh.js";
+} from "./index-hffjpmq9.js";
 
 // src/browser/http.ts
 import ky, {

package/dist/{index-tmwcrptx.js → index-zfrhfn82.js}

@@ -1,7 +1,7 @@
 import {
   getClientInfo,
   resolveSocketIp
-} from "./index-f9mb610r.js";
+} from "./index-35mh5bhj.js";
 import {
   resolveTraceContext
 } from "./index-zcgf3gqf.js";

package/dist/index-znfs20ss.js

@@ -0,0 +1,98 @@
+import {
+  formatZodError,
+  zodIssues
+} from "./index-p5r7qpdd.js";
+import {
+  AppError
+} from "./index-2vtcmrj9.js";
+import {
+  isRecord
+} from "./index-hffjpmq9.js";
+
+// src/contract/normalize.ts
+import { z } from "zod";
+var MAX_DETAIL_ISSUES = 20;
+function errorCode(err) {
+  if (AppError.is(err))
+    return err.code;
+  if (err instanceof z.ZodError)
+    return "VALIDATION_ERROR";
+  return;
+}
+function recordedErrorMessage(code, envelopeMessage, thrown) {
+  if ((code === "INTERNAL_SERVER_ERROR" || code === "REALTIME_CONTRACT_VIOLATION") && thrown !== undefined) {
+    if (thrown instanceof Error)
+      return thrown.message;
+    if (typeof thrown === "string")
+      return thrown;
+  }
+  return envelopeMessage;
+}
+function normalizeError(err) {
+  if (AppError.is(err)) {
+    if (err.code === "REALTIME_CONTRACT_VIOLATION") {
+      return new AppError("REALTIME_CONTRACT_VIOLATION", "Realtime contract violation", 500);
+    }
+    return err;
+  }
+  if (err instanceof z.ZodError) {
+    return new AppError("VALIDATION_ERROR", formatZodError(err), 400, {
+      issues: zodIssues(err).slice(0, MAX_DETAIL_ISSUES)
+    });
+  }
+  console.error("[stitchkit] unhandled error:", err);
+  return new AppError("INTERNAL_SERVER_ERROR", "Internal server error", 500);
+}
+function strippedPaths(before, after, prefix) {
+  if (Array.isArray(before)) {
+    if (!Array.isArray(after))
+      return [];
+    return before.flatMap((item, i) => strippedPaths(item, after[i], `${prefix}[${i}]`));
+  }
+  if (!isRecord(before) || !isRecord(after))
+    return [];
+  const paths = [];
+  for (const [key, value] of Object.entries(before)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (!(key in after)) {
+      paths.push(path);
+      continue;
+    }
+    paths.push(...strippedPaths(value, after[key], path));
+  }
+  return paths;
+}
+function validateHandlerOutput(schema, data, onStripped) {
+  const parsed = schema.safeParse(data);
+  if (parsed.success) {
+    if (onStripped) {
+      const paths = strippedPaths(data, parsed.data, "");
+      if (paths.length > 0)
+        onStripped(paths);
+    }
+    return { ok: true, data: parsed.data };
+  }
+  return {
+    ok: false,
+    message: `Handler output does not match the contract: ${formatZodError(parsed.error)}`
+  };
+}
+function validateDeclaredOutput(schema, data, onStripped) {
+  if (!schema) {
+    if (data === undefined || data === null)
+      return { ok: true, data };
+    return {
+      ok: false,
+      message: "Handler returned data but the contract declares no output"
+    };
+  }
+  if (data === undefined) {
+    return {
+      ok: false,
+      message: "Handler returned undefined but the contract declares an output"
+    };
+  }
+  return validateHandlerOutput(schema, data, onStripped);
+}
+
+export { errorCode, recordedErrorMessage, normalizeError, validateDeclaredOutput };

package/dist/internal/backoff.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const BackoffPolicySchema: z.ZodReadonly<z.ZodObject<{
+    minDelayMs: z.ZodNumber;
+    maxDelayMs: z.ZodNumber;
+    jitter: z.ZodNumber;
+}, z.core.$strict>>;
+export type BackoffPolicy = z.infer<typeof BackoffPolicySchema>;
+/**
+ * The delay before retry number `attempt` (1-based) under `policy`: doubling
+ * from `minDelayMs`, capped at `maxDelayMs`, with `jitter` subtracted. The one
+ * formula behind `createBackoff` and every attempt-numbered retry schedule.
+ */
+export declare function backoffDelay(policy: BackoffPolicy, attempt: number, random?: () => number): number;
+export interface Backoff {
+    /** The next delay in milliseconds, doubling from `minDelayMs` and jittered. */
+    next(): number;
+    reset(): void;
+}
+/**
+ * Exponential backoff with jitter, as a value.
+ *
+ * Jitter is the part that is easy to leave out and expensive to leave out: without it every
+ * consumer that lost the same server retries at the same instant, and the recovering server is
+ * hit by the whole fleet at once instead of a spread. The randomisation is subtractive — a delay
+ * is never longer than the ceiling the caller declared, only shorter — so `maxDelayMs` remains a
+ * real bound rather than an average.
+ */
+export declare function createBackoff(policy: BackoffPolicy, random?: () => number): Backoff;
+//# sourceMappingURL=backoff.d.ts.map

package/dist/internal/backoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../src/internal/backoff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,mBAAmB;;;;mBAW5B,CAAC;AACL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,MAAM,MAAoB,GACjC,MAAM,CAOR;AAED,MAAM,WAAW,OAAO;IACtB,+EAA+E;IAC/E,IAAI,IAAI,MAAM,CAAC;IACf,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,aAAa,EACrB,MAAM,GAAE,MAAM,MAAoB,GACjC,OAAO,CAYT"}

package/dist/internal/canonical-json.d.ts

@@ -1,20 +1,30 @@
 /**
- * Codepoint order, not locale order.
+ * UTF-16 code-unit order — the order `Array.prototype.sort` uses without a
+ * comparator, and deliberately not code-point or locale order.
  *
- * `Array.prototype.sort` without a comparator is codepoint order already, but
- * `localeCompare` is what a reader reaches for — and it would make a digest
- * depend on the machine's locale, which is the one input a fingerprint must
- * never have.
+ * Locale order would make a digest depend on the machine it ran on. Code-point
+ * order would be defensible, but every digest this package has ever written —
+ * CLI manifest signatures, agent-store event and checkpoint hashes, archives,
+ * committed surface snapshots — was taken in code-unit order, and the two
+ * disagree on keys outside the Basic Multilingual Plane. Changing it would
+ * report drift in data that never changed.
  */
-export declare function compareCodepoints(left: string, right: string): number;
+export declare function compareCodeUnits(left: string, right: string): number;
 /**
  * Canonical bytes for a JSON value — object keys sorted, array order kept.
  *
- * The single serialisation behind every digest this repository takes of a
- * declared surface: the committed manifest snapshot and the live MCP catalog
- * stamp. Two implementations of "the same bytes" would eventually disagree,
- * and a fingerprint that disagrees with itself reports drift that never
- * happened.
+ * The one serialisation behind every digest and identity in the package: the
+ * surface snapshot and the MCP catalog stamp, CLI manifest signatures, the
+ * agent store's hashes and archives, watched-read and MCP-round argument keys,
+ * and schema comparison in union flattening. Two implementations of "the same
+ * bytes" would eventually disagree, and a fingerprint that disagrees with
+ * itself reports drift that never happened.
+ *
+ * What `JSON.stringify` drops or transforms is dropped or transformed here too:
+ * an `undefined` member disappears, a `Date` becomes `{}` (its own keys, none). A caller that must
+ * refuse such values validates before calling (the agent store parses with
+ * `z.json()` first). A top-level `undefined` answers `'undefined'`, so the
+ * result is always a string.
  */
 export declare function serializeCanonicalJson(value: unknown): string;
 //# sourceMappingURL=canonical-json.d.ts.map

package/dist/internal/canonical-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canonical-json.d.ts","sourceRoot":"","sources":["../../src/internal/canonical-json.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAIrE;AAYD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE7D"}
+{"version":3,"file":"canonical-json.d.ts","sourceRoot":"","sources":["../../src/internal/canonical-json.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAIpE;AAyBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE7D"}

package/dist/internal/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../src/internal/channel.ts"],"names":[],"mappings":"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"}

package/dist/internal/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/internal/logger.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxD,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxD,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACzD,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC1D"}

package/dist/internal/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../src/internal/request.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,6EAA6E;AAC7E,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CASnD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAejF;AAED,iDAAiD;AACjD,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE,eAAoB,GAAG,MAAM,CAQ7E;AAED,6EAA6E;AAC7E,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,EACZ,OAAO,GAAE,eAAoB,GAC5B;IACD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAKA;AAED,qEAAqE;AACrE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAU5E;AAgGD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CA+BjD"}

package/dist/internal/stable-digest.d.ts

@@ -1,46 +1,3 @@
-/**
- * A stable identity for a call's arguments — one implementation, two callers.
- *
- * Two callers need the same thing for different reasons. The MCP round keys a
- * tool invocation by `(operation, arguments)` so a retry is recognised as the
- * same round; a watched read keys its shared source by `(operation, arguments)`
- * so two browsers asking the same question are one read on the server. If those
- * two computed the key differently, the same arguments would be the same round
- * and two different watches — and nothing would say so.
- *
- * The stability that matters is key order: `{a:1,b:2}` and `{b:2,a:1}` are the
- * same arguments and `JSON.stringify` disagrees, so a naive key silently splits
- * one shared source into two whenever a caller builds its object in a different
- * order. That is not a hypothetical: object literal order follows the source
- * that wrote it, and two components asking the same question rarely share one.
- *
- * ## Why this is not SHA-256
- *
- * It was, and that made every watched read fail on an ordinary intranet. Web
- * Crypto — `crypto.subtle` — exists only in a **secure context**, so a page
- * served over plain HTTP from a LAN name has no `crypto.subtle` at all and the
- * first digest throws `Cannot read properties of undefined`. `localhost` is
- * secure by definition, which is exactly why nothing caught it until a browser
- * opened the app by its name.
- *
- * The fix is not a fallback, it is admitting what this is for: **identity, not
- * secrecy**. Nothing here resists an adversary — an attacker who can choose your
- * watch arguments can already ask the question directly. So the requirement is
- * distribution and determinism, both ends agreeing, and no ambient capability;
- * a cryptographic hash bought none of that and cost the entire non-secure web.
- *
- * Being synchronous is the second thing it buys. A promise for a key made the
- * first subscription of a question asynchronous, which meant a component could
- * not be handed a retained value in the same turn it subscribed.
- */
-/**
- * The value with every object's keys sorted, recursively — arrays keep their
- * order, because in an array order *is* the value.
- *
- * `Object.keys` returns own enumerable keys only, so nothing from a prototype
- * reaches the digest.
- */
-export declare function stableValue(value: unknown): unknown;
 /**
  * A bounded, order-independent identity for a call's arguments.
  *

package/dist/internal/stable-digest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stable-digest.d.ts","sourceRoot":"","sources":["../../src/internal/stable-digest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAQnD;AAyCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAGrE"}
+{"version":3,"file":"stable-digest.d.ts","sourceRoot":"","sources":["../../src/internal/stable-digest.ts"],"names":[],"mappings":"AA6EA;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAGrE"}

package/dist/internal/typed.d.ts

@@ -1,5 +1,3 @@
-import type { SurfaceAgentRuntimeToolDefinition } from '../tools/internal/surface-projector.js';
-import type { RuntimeToolDefinition } from '../tools/runtime-tool.js';
 export declare function typedEntries<T extends object>(value: T): Array<{
     [K in keyof T]: [K, T[K]];
 }[keyof T]>;
@@ -7,12 +5,6 @@ export declare function typedEntries<T extends object>(value: T): Array<{
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 /** Invoke a runtime-discovered handler after a fail-first function check. */
 export declare function callRuntimeHandler(handler: unknown, context: unknown): unknown;
-/**
- * Agent-only public declarations use a peer-free structural tool definition.
- * Construction validates executable functions before this boundary restores
- * the richer internal definition consumed by the canonical mount.
- */
-export declare function executableAgentRuntimeTools(tools: readonly SurfaceAgentRuntimeToolDefinition[]): readonly RuntimeToolDefinition[];
 /**
  * Isolated loose-to-typed adapter boundary for transports whose decoder is
  * selected at runtime while the contract fixes the generic result type.

package/dist/internal/typed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typed.d.ts","sourceRoot":"","sources":["../../src/internal/typed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,qCAAqC,CAAC;AAC7F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAC3C,KAAK,EAAE,CAAC,GACP,KAAK,CAAC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAE/C;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,6EAA6E;AAC7E,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAK9E;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,SAAS,iCAAiC,EAAE,GAClD,SAAS,qBAAqB,EAAE,CAelC;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,CAEpD;AAED,wBAAgB,SAAS,CACvB,OAAO,SAAS,MAAM,EACtB,OAAO,SAAS;KAAG,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,EAAE,OAAO;CAAE,EAElD,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,GACrF,OAAO,CAOT;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,SAAS,MAAM,EACtB,OAAO,SAAS;KAAG,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,EAAE,OAAO;CAAE,EAElD,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,MAAM,OAAO,CAAC,KAAK,OAAO,GACrE,OAAO,CAKT"}
+{"version":3,"file":"typed.d.ts","sourceRoot":"","sources":["../../src/internal/typed.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAC3C,KAAK,EAAE,CAAC,GACP,KAAK,CAAC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAE/C;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,6EAA6E;AAC7E,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAK9E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,CAEpD;AAED,wBAAgB,SAAS,CACvB,OAAO,SAAS,MAAM,EACtB,OAAO,SAAS;KAAG,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,EAAE,OAAO;CAAE,EAElD,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,GACrF,OAAO,CAOT;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,SAAS,MAAM,EACtB,OAAO,SAAS;KAAG,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,EAAE,OAAO;CAAE,EAElD,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,MAAM,OAAO,CAAC,KAAK,OAAO,GACrE,OAAO,CAKT"}

package/dist/internal/zod-issues.d.ts

@@ -0,0 +1,38 @@
+import type { z } from 'zod';
+/** One field-level validation issue — the structured sibling of `formatZodError`. */
+export interface ZodIssueSummary {
+    /** Dotted path to the offending field (`(root)` for a top-level issue). */
+    path: string;
+    /** Zod issue code (e.g. `invalid_type`, `too_small`). */
+    code: string;
+    /** Human-readable message for this field. */
+    message: string;
+    /**
+     * 1-based index of the union branch that produced this issue, counted within
+     * the nearest enclosing union. Absent when no union was involved.
+     */
+    branch?: number;
+}
+/**
+ * Project a `ZodError` into structured, wire-safe field issues — path / code /
+ * message (and a union branch, where one applies) — nothing server-internal.
+ * For a machine client that matches on fields rather than parsing the text
+ * `message`. Returns every issue; a caller that bounds response size slices it
+ * (see `normalizeError`).
+ *
+ * A failed union contributes its own issue AND one issue per branch failure, so
+ * the refusal names the branch and the path instead of only `(root)`.
+ */
+export declare function zodIssues(error: z.ZodError): ZodIssueSummary[];
+/**
+ * The text a person reads, which is a different job from the structured list.
+ *
+ * `zodIssues` keeps every branch failure, including the several that sit at the
+ * union's own path — a machine addresses them by branch number and wants them
+ * all. A reader gains nothing from the same path twice: the union's own line
+ * already quotes those reasons, and each repeat costs one of the few lines the
+ * cap allows. So the text keeps the first issue at each path and drops the
+ * rest, which is what leaves room for the line naming the field.
+ */
+export declare function formatZodError(error: z.ZodError): string;
+//# sourceMappingURL=zod-issues.d.ts.map

package/dist/internal/zod-issues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-issues.d.ts","sourceRoot":"","sources":["../../src/internal/zod-issues.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAO7B,qFAAqF;AACrF,MAAM,WAAW,eAAe;IAC9B,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAwID;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,QAAQ,GAAG,eAAe,EAAE,CAI9D;AAKD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC,QAAQ,GAAG,MAAM,CAgBxD"}

package/dist/{tools/json-schema-dialect.d.ts → json-schema/dialect.d.ts}

@@ -14,4 +14,4 @@ export declare function declaresDraft07(dialect: unknown): boolean;
  * leaving it where the author put it.
  */
 export declare function withDefsDialect(schema: Record<string, unknown>): Record<string, unknown>;
-//# sourceMappingURL=json-schema-dialect.d.ts.map
+//# sourceMappingURL=dialect.d.ts.map

package/dist/json-schema/dialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../../src/json-schema/dialect.ts"],"names":[],"mappings":"AAQA,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAEzD;AAeD;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUxF"}

package/dist/json-schema/json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../../src/json-schema/json-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,+EAA+E;AAC/E,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE9C;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,CAAC,CAAC,OAAO,EACjB,EAAE,EAAE,YAAY,EAChB,eAAe,GAAE,OAAO,GAAG,KAAe,EAC1C,MAAM,GAAE,UAAU,GAAG,eAAiC,GACrD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAOzB;AAED,uDAAuD;AACvD,MAAM,WAAW,eAAe;IAC9B,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,+DAA+D;IAC/D,QAAQ,EAAE,OAAO,CAAC;IAClB,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAOD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,EAAE,CA+CvF"}