stitchkit 0.100.2 → 0.101.0

package/dist/{index-bm5rx7n6.js → index-n9tyz8z3.js}

@@ -1,16 +1,16 @@
 import {
-  executeToolMethod,
-  toolErrorFromResult
-} from "./index-8qt2m66q.js";
+  isRetryableStatus2
+} from "./index-n53mswt3.js";
 import {
-  assertToolExtensionCompatible,
+  rebuildObject,
   mergeSchemas,
-  projectToolSurface,
-  rebuildObject
-} from "./index-0r0fbk7z.js";
+  assertToolExtensionCompatible,
+  projectToolSurface
+} from "./index-7z9ym7t8.js";
 import {
-  isRetryableStatus
-} from "./index-2vtcmrj9.js";
+  toolErrorFromResult,
+  executeToolMethod
+} from "./index-dvwj1f43.js";
 
 // src/tools/mount.ts
 import { z } from "zod";
@@ -33,7 +33,7 @@ function contractToolMountable(projected, extend) {
     shouldExtend: projected.shouldExtend
   };
 }
-function collectTools(service, transport, config = {}) {
+function collectTools2(service, transport, config = {}) {
   const { extend, flattenUnionInput = false, assertNames = true } = config;
   const tools = [];
   for (const projected of projectToolSurface({ services: [service] }, transport === "HTTP" ? "AGENT" : transport, {
@@ -72,7 +72,7 @@ function createToolRunner(config) {
 function formatToolError(result, toolName, errorHint) {
   const err = {
     error: result.code,
-    retryable: result.retryable ?? isRetryableStatus(toolErrorFromResult(result).status)
+    retryable: result.retryable ?? isRetryableStatus2(toolErrorFromResult(result).status)
   };
   if (result.details)
     err.details = result.details;
@@ -89,4 +89,4 @@ function formatToolError(result, toolName, errorHint) {
   return err;
 }
 
-export { contractToolMountable, collectTools, createToolRunner, formatToolError };
+export { contractToolMountable, collectTools2, createToolRunner, formatToolError };

package/dist/index-nmaqxdx7.js

@@ -0,0 +1,463 @@
+// src/telegram/html/nodes.ts
+var TELEGRAM_TEXT_LIMIT2 = 4096;
+var TELEGRAM_CAPTION_LIMIT2 = 1024;
+var STYLES = new Set([
+  "b",
+  "i",
+  "u",
+  "s",
+  "tg-spoiler"
+]);
+function isStyle(tag) {
+  return STYLES.has(tag);
+}
+function holdsOnlyText(tag) {
+  return tag === "code" || tag === "pre" || tag === "tg-emoji" || tag === "tg-time";
+}
+function isAtomic(tag) {
+  return tag === "tg-emoji" || tag === "tg-time";
+}
+function mayOpenInside(tag, ancestors) {
+  if (isStyle(tag))
+    return !ancestors.some(holdsOnlyText);
+  return ancestors.every(isStyle);
+}
+function textOf(nodes) {
+  let text = "";
+  for (const node of nodes)
+    text += node.kind === "text" ? node.text : textOf(node.children);
+  return text;
+}
+function withChildren(element, children) {
+  return { ...element, children };
+}
+
+// src/telegram/html/parse.ts
+var TAG = /<(\/?)([a-zA-Z][a-zA-Z0-9-]*)((?:\s[^<>]*?)?)\s*\/?>/y;
+var ATTRIBUTE = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+var ENTITY = /&(?:(amp|lt|gt|quot|apos|nbsp)|#(\d{1,7})|#[xX]([0-9a-fA-F]{1,6}));/y;
+var NAMED = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " "
+};
+var SYNONYMS = {
+  strong: "b",
+  em: "i",
+  ins: "u",
+  strike: "s",
+  del: "s"
+};
+var BLOCK_BREAKS = {
+  p: 2,
+  h1: 2,
+  h2: 2,
+  h3: 2,
+  h4: 2,
+  h5: 2,
+  h6: 2,
+  div: 1,
+  li: 1,
+  ul: 1,
+  ol: 1,
+  tr: 1,
+  table: 1,
+  section: 1,
+  article: 1,
+  header: 1,
+  footer: 1
+};
+var LINK_SCHEMES = new Set(["http:", "https:", "tg:", "mailto:"]);
+var TIME_FORMAT = /^(?:r|w?[dD]?[tT]?)$/;
+function decodeEntity(match) {
+  const [, named, decimal, hex] = match;
+  if (named !== undefined)
+    return NAMED[named];
+  const code = Number.parseInt(decimal ?? hex ?? "", decimal === undefined ? 16 : 10);
+  const valid = code > 0 && code <= 1114111 && (code < 55296 || code > 57343);
+  return valid ? String.fromCodePoint(code) : undefined;
+}
+function attributesOf(source) {
+  const attributes = new Map;
+  for (const [, name = "", double, single, bare] of source.matchAll(ATTRIBUTE)) {
+    attributes.set(name.toLowerCase(), decodeText(double ?? single ?? bare ?? ""));
+  }
+  return attributes;
+}
+function* tokenize(markup) {
+  let index = 0;
+  let textStart = 0;
+  const flush = function* () {
+    if (index > textStart)
+      yield { type: "text", text: markup.slice(textStart, index) };
+  };
+  while (index < markup.length) {
+    const char = markup[index];
+    if (char === "<") {
+      TAG.lastIndex = index;
+      const tag = TAG.exec(markup);
+      yield* flush();
+      if (tag) {
+        yield {
+          type: "tag",
+          closing: tag[1] === "/",
+          name: (tag[2] ?? "").toLowerCase(),
+          attributes: attributesOf(tag[3] ?? "")
+        };
+        index = TAG.lastIndex;
+      } else {
+        yield { type: "bare", char };
+        index += 1;
+      }
+      textStart = index;
+    } else if (char === "&") {
+      ENTITY.lastIndex = index;
+      const entity = ENTITY.exec(markup);
+      const text = entity ? decodeEntity(entity) : undefined;
+      yield* flush();
+      if (entity && text !== undefined) {
+        const named = entity[1];
+        yield {
+          type: "entity",
+          text,
+          named: named !== undefined,
+          telegram: named !== "apos" && named !== "nbsp"
+        };
+        index = ENTITY.lastIndex;
+      } else {
+        yield { type: "bare", char };
+        index += 1;
+      }
+      textStart = index;
+    } else if (char === ">") {
+      yield* flush();
+      yield { type: "bare", char };
+      index += 1;
+      textStart = index;
+    } else {
+      index += 1;
+    }
+  }
+  yield* flush();
+}
+function decodeText(value) {
+  let text = "";
+  for (const token of tokenize(value)) {
+    if (token.type === "text" || token.type === "entity")
+      text += token.text;
+    else if (token.type === "bare")
+      text += token.char;
+  }
+  return text;
+}
+var KNOWN = new Set([
+  "b",
+  "i",
+  "u",
+  "s",
+  "tg-spoiler",
+  "code",
+  "a",
+  "pre",
+  "blockquote",
+  "tg-emoji",
+  "tg-time",
+  "span"
+]);
+function linkOf(href) {
+  const value = href?.trim();
+  if (!value || !URL.canParse(value))
+    return;
+  return LINK_SCHEMES.has(new URL(value).protocol) ? value : undefined;
+}
+function elementFor(tag, attributes) {
+  const children = [];
+  if (isStyle(tag) || tag === "code")
+    return { kind: "element", tag, children };
+  if (tag === "span") {
+    const spoiler = (attributes.get("class") ?? "").split(/\s+/).includes("tg-spoiler");
+    return spoiler ? { kind: "element", tag: "tg-spoiler", children } : undefined;
+  }
+  if (tag === "a") {
+    const href = linkOf(attributes.get("href"));
+    return href === undefined ? undefined : { kind: "element", tag, href, children };
+  }
+  if (tag === "pre")
+    return { kind: "element", tag, children };
+  if (tag === "blockquote") {
+    return { kind: "element", tag, expandable: attributes.has("expandable"), children };
+  }
+  if (tag === "tg-emoji") {
+    const emojiId = attributes.get("emoji-id") ?? "";
+    return /^\d{1,32}$/.test(emojiId) ? { kind: "element", tag, emojiId, children } : undefined;
+  }
+  if (tag === "tg-time") {
+    const unix = attributes.get("unix") ?? "";
+    const format = attributes.get("format");
+    if (!/^\d{1,12}$/.test(unix))
+      return;
+    return {
+      kind: "element",
+      tag,
+      unix: Number(unix),
+      ...format !== undefined && TIME_FORMAT.test(format) && { format },
+      children
+    };
+  }
+  return;
+}
+
+class TreeBuilder {
+  root = [];
+  #frames = [];
+  #trailing = 0;
+  #needed = 0;
+  #started = false;
+  #innermost() {
+    for (let index = this.#frames.length - 1;index >= 0; index -= 1) {
+      const draft = this.#frames[index]?.draft;
+      if (draft)
+        return draft;
+    }
+    return;
+  }
+  text(value) {
+    if (value === "")
+      return;
+    this.#append(this.#pendingBreaks() + value);
+    this.#started = true;
+  }
+  #pendingBreaks() {
+    const breaks = this.#started ? `
+`.repeat(Math.max(0, this.#needed - this.#trailing)) : "";
+    this.#needed = 0;
+    return breaks;
+  }
+  #append(text) {
+    if (text === "")
+      return;
+    const trailing = /\n*$/.exec(text)?.[0].length ?? 0;
+    this.#trailing = trailing === text.length ? this.#trailing + trailing : trailing;
+    const children = this.#innermost()?.children ?? this.root;
+    const last = children.at(-1);
+    if (last?.kind === "text")
+      children[children.length - 1] = { kind: "text", text: last.text + text };
+    else
+      children.push({ kind: "text", text });
+  }
+  lineBreaks(count, cumulative) {
+    this.#needed = cumulative ? Math.max(this.#needed, this.#trailing) + count : Math.max(this.#needed, count);
+  }
+  openTag(name, attributes) {
+    const tag = SYNONYMS[name] ?? name;
+    if (!KNOWN.has(tag))
+      return;
+    const parent = this.#innermost();
+    if (tag === "code" && parent?.element.tag === "pre") {
+      const language = /(?:^|\s)language-([\w+#.-]{1,64})(?:\s|$)/.exec(attributes.get("class") ?? "");
+      if (language?.[1] && parent.element.language === undefined) {
+        parent.element = { ...parent.element, language: language[1] };
+      }
+      this.#frames.push({ name: tag, draft: undefined });
+      return;
+    }
+    const element = elementFor(tag, attributes);
+    const open = this.#frames.flatMap((frame) => frame.draft ? [frame.draft.element.tag] : []);
+    if (!element || !mayOpenInside(element.tag, open)) {
+      this.#frames.push({ name: tag, draft: undefined });
+      return;
+    }
+    this.#append(this.#pendingBreaks());
+    const draft = { kind: "element", element, children: [] };
+    (parent?.children ?? this.root).push(draft);
+    this.#frames.push({ name: tag, draft });
+  }
+  closeTag(name) {
+    const tag = SYNONYMS[name] ?? name;
+    for (let index = this.#frames.length - 1;index >= 0; index -= 1) {
+      if (this.#frames[index]?.name === tag) {
+        this.#frames.length = index;
+        return;
+      }
+    }
+  }
+}
+function finish(nodes) {
+  const result = [];
+  for (const node of nodes) {
+    if (node.kind === "text") {
+      const last = result.at(-1);
+      if (last?.kind === "text")
+        result[result.length - 1] = { kind: "text", text: last.text + node.text };
+      else
+        result.push(node);
+      continue;
+    }
+    const children = finish(node.children);
+    if (children.length > 0)
+      result.push({ ...node.element, children });
+  }
+  return result;
+}
+function parseTelegramHtml2(markup) {
+  const builder = new TreeBuilder;
+  for (const token of tokenize(markup)) {
+    if (token.type === "text" || token.type === "entity")
+      builder.text(token.text);
+    else if (token.type === "bare")
+      builder.text(token.char);
+    else if (token.name === "br") {
+      if (!token.closing)
+        builder.lineBreaks(1, true);
+    } else if (BLOCK_BREAKS[token.name] !== undefined) {
+      builder.lineBreaks(BLOCK_BREAKS[token.name] ?? 1, false);
+    } else if (token.closing)
+      builder.closeTag(token.name);
+    else
+      builder.openTag(token.name, token.attributes);
+  }
+  return finish(builder.root);
+}
+
+// src/telegram/html/render.ts
+function escapeTelegramHtml2(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function openingTag(element) {
+  switch (element.tag) {
+    case "a":
+      return `<a href="${escapeTelegramHtml2(element.href)}">`;
+    case "pre":
+      return element.language === undefined ? "<pre>" : `<pre><code class="language-${escapeTelegramHtml2(element.language)}">`;
+    case "blockquote":
+      return element.expandable ? "<blockquote expandable>" : "<blockquote>";
+    case "tg-emoji":
+      return `<tg-emoji emoji-id="${element.emojiId}">`;
+    case "tg-time":
+      return element.format === undefined ? `<tg-time unix="${element.unix}">` : `<tg-time unix="${element.unix}" format="${element.format}">`;
+    default:
+      return `<${element.tag}>`;
+  }
+}
+function closingTag(element) {
+  if (element.tag === "pre" && element.language !== undefined)
+    return "</code></pre>";
+  return `</${element.tag}>`;
+}
+function renderTelegramHtml2(nodes) {
+  let markup = "";
+  for (const node of nodes) {
+    markup += node.kind === "text" ? escapeTelegramHtml2(node.text) : openingTag(node) + renderTelegramHtml2(node.children) + closingTag(node);
+  }
+  return markup;
+}
+function sanitizeTelegramHtml2(markup) {
+  return renderTelegramHtml2(parseTelegramHtml2(markup));
+}
+function telegramHtmlText2(markup) {
+  return textOf(parseTelegramHtml2(markup));
+}
+function slice(nodes, from, to, start = 0) {
+  const result = [];
+  let offset = start;
+  for (const node of nodes) {
+    const length = node.kind === "text" ? node.text.length : textOf(node.children).length;
+    const end = offset + length;
+    if (end > from && offset < to) {
+      if (node.kind === "text") {
+        result.push({
+          kind: "text",
+          text: node.text.slice(Math.max(0, from - offset), to - offset)
+        });
+      } else if (isAtomic(node.tag)) {
+        if (offset >= from)
+          result.push(node);
+      } else {
+        const children = slice(node.children, from, to, offset);
+        if (children.length > 0)
+          result.push(withChildren(node, children));
+      }
+    }
+    offset = end;
+  }
+  return result;
+}
+function atomicRanges(nodes, start = 0) {
+  const ranges = [];
+  let offset = start;
+  for (const node of nodes) {
+    const length = node.kind === "text" ? node.text.length : textOf(node.children).length;
+    if (node.kind === "element") {
+      if (isAtomic(node.tag))
+        ranges.push([offset, offset + length]);
+      else
+        ranges.push(...atomicRanges(node.children, offset));
+    }
+    offset += length;
+  }
+  return ranges;
+}
+function cutWithin(text, from, limit, atomic, structural) {
+  const last = from + limit;
+  const allowed = (index) => {
+    const code = text.charCodeAt(index - 1);
+    if (code >= 55296 && code <= 56319)
+      return false;
+    return !atomic.some(([start, end]) => index > start && index < end);
+  };
+  const find = (matches) => {
+    for (let index = last;index > from; index -= 1) {
+      const skip = matches(index);
+      if (skip >= 0 && allowed(index))
+        return { end: index, next: index + skip };
+    }
+    return;
+  };
+  const paragraph = () => find((index) => text.startsWith(`
+
+`, index) ? 2 : -1);
+  const line = () => find((index) => text[index] === `
+` ? 1 : -1);
+  return (structural ? paragraph() ?? line() : undefined) ?? find((index) => /\s/.test(text[index] ?? "") ? 1 : -1) ?? find(() => 0) ?? { end: last, next: last };
+}
+function checkedLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit < 2) {
+    throw new RangeError("[stitchkit] telegram html: a limit is an integer of at least 2");
+  }
+  return limit;
+}
+function splitTelegramHtml2(markup, options = {}) {
+  const limit = checkedLimit(options.limit ?? TELEGRAM_TEXT_LIMIT2);
+  const nodes = parseTelegramHtml2(markup);
+  const text = textOf(nodes);
+  const atomic = atomicRanges(nodes);
+  const parts = [];
+  let from = 0;
+  while (from < text.length) {
+    const cut = text.length - from <= limit ? { end: text.length, next: text.length } : cutWithin(text, from, limit, atomic, true);
+    if (text.slice(from, cut.end).trim() !== "") {
+      parts.push(renderTelegramHtml2(slice(nodes, from, cut.end)));
+    }
+    from = cut.next;
+  }
+  return parts;
+}
+function truncateTelegramHtml2(markup, options = {}) {
+  const limit = checkedLimit(options.limit ?? TELEGRAM_TEXT_LIMIT2);
+  const ellipsis = options.ellipsis ?? "…";
+  const nodes = parseTelegramHtml2(markup);
+  const text = textOf(nodes);
+  if (text.length <= limit)
+    return renderTelegramHtml2(nodes);
+  const room = limit - ellipsis.length;
+  if (room < 1)
+    throw new RangeError("[stitchkit] telegram html: the ellipsis leaves no room");
+  const { end } = cutWithin(text, 0, room, atomicRanges(nodes), false);
+  const kept = slice(nodes, 0, end);
+  return renderTelegramHtml2(kept).trimEnd() + escapeTelegramHtml2(ellipsis);
+}
+
+export { TELEGRAM_TEXT_LIMIT2, TELEGRAM_CAPTION_LIMIT2, tokenize, parseTelegramHtml2, escapeTelegramHtml2, renderTelegramHtml2, sanitizeTelegramHtml2, telegramHtmlText2, splitTelegramHtml2, truncateTelegramHtml2 };

package/dist/{index-mqv3b5rh.js → index-nx6eazt0.js}

@@ -1,68 +1,68 @@
 // src/agent-runtime/models.ts
 import { z } from "zod";
-var AgentModelCapabilitySchema = z.enum(["tools", "vision", "reasoning", "files"]);
-var AgentModelDescriptorSchema = z.object({
+var AgentModelCapabilitySchema2 = z.enum(["tools", "vision", "reasoning", "files"]);
+var AgentModelDescriptorSchema2 = z.object({
   provider: z.string().min(1),
   modelId: z.string().min(1),
   contextWindow: z.int().positive(),
-  capabilities: z.array(AgentModelCapabilitySchema),
+  capabilities: z.array(AgentModelCapabilitySchema2),
   observedAt: z.iso.datetime({ offset: true }).optional(),
   source: z.string().min(1).optional(),
   availability: z.enum(["available", "unavailable"]).optional()
 });
-var AgentModelRegistrySnapshotSchema = z.object({
+var AgentModelRegistrySnapshotSchema2 = z.object({
   schemaVersion: z.literal(1),
   source: z.string().min(1),
   observedAt: z.iso.datetime({ offset: true }),
-  models: z.record(z.string().min(1), AgentModelDescriptorSchema)
+  models: z.record(z.string().min(1), AgentModelDescriptorSchema2)
 });
-var AgentModelPriceSchema = z.object({
+var AgentModelPriceSchema2 = z.object({
   currency: z.string().length(3),
   inputPerToken: z.string().regex(/^\d+(?:\.\d+)?$/).optional(),
   outputPerToken: z.string().regex(/^\d+(?:\.\d+)?$/).optional()
 }).strict();
-var AgentModelMetricSchema = z.object({
+var AgentModelMetricSchema2 = z.object({
   metric: z.string().min(1),
   value: z.number(),
   unit: z.enum(["index", "elo", "percent", "milliseconds"]),
   source: z.string().min(1),
   observedAt: z.iso.datetime({ offset: true })
 }).strict();
-var AgentModelPopularitySchema = z.object({
+var AgentModelPopularitySchema2 = z.object({
   rank: z.int().positive(),
   window: z.literal("week"),
   source: z.string().min(1),
   observedAt: z.iso.datetime({ offset: true })
 }).strict();
-var AgentModelCatalogEntrySchema = z.object({
+var AgentModelCatalogEntrySchema2 = z.object({
   id: z.string().min(1),
   name: z.string().min(1),
-  descriptor: AgentModelDescriptorSchema,
+  descriptor: AgentModelDescriptorSchema2,
   description: z.string().optional(),
-  price: AgentModelPriceSchema.optional(),
-  popularity: AgentModelPopularitySchema.optional(),
-  metrics: z.array(AgentModelMetricSchema)
+  price: AgentModelPriceSchema2.optional(),
+  popularity: AgentModelPopularitySchema2.optional(),
+  metrics: z.array(AgentModelMetricSchema2)
 }).strict();
-var AgentModelCatalogSchema = z.object({
+var AgentModelCatalogSchema2 = z.object({
   schemaVersion: z.literal(1),
   source: z.string().min(1),
   observedAt: z.iso.datetime({ offset: true }),
   completeness: z.enum(["complete", "partial"]),
-  models: z.array(AgentModelCatalogEntrySchema),
+  models: z.array(AgentModelCatalogEntrySchema2),
   diagnostics: z.array(z.string())
 }).strict();
-var AgentModelSelectionSchema = z.object({
+var AgentModelSelectionSchema2 = z.object({
   modelId: z.string().min(1),
   selectedAt: z.iso.datetime({ offset: true })
 }).strict();
-var AgentModelSearchInputSchema = z.object({ query: z.string().max(256).default(""), limit: z.int().positive().max(200) }).strict();
-var AgentModelSearchResultSchema = z.object({
-  models: z.array(AgentModelCatalogEntrySchema),
+var AgentModelSearchInputSchema2 = z.object({ query: z.string().max(256).default(""), limit: z.int().positive().max(200) }).strict();
+var AgentModelSearchResultSchema2 = z.object({
+  models: z.array(AgentModelCatalogEntrySchema2),
   total: z.int().nonnegative(),
   truncated: z.boolean()
 }).strict();
-function searchAgentModelCatalog(catalog, rawInput) {
-  const input = AgentModelSearchInputSchema.parse(rawInput);
+function searchAgentModelCatalog2(catalog, rawInput) {
+  const input = AgentModelSearchInputSchema2.parse(rawInput);
   const terms = input.query.toLocaleLowerCase().trim().split(/\s+/).filter(Boolean);
   const matches = catalog.models.filter((model) => {
     const searchable = `${model.id}
@@ -70,27 +70,27 @@ ${model.name}
 ${model.description ?? ""}`.toLocaleLowerCase();
     return terms.every((term) => searchable.includes(term));
   });
-  return AgentModelSearchResultSchema.parse({
+  return AgentModelSearchResultSchema2.parse({
     models: matches.slice(0, input.limit),
     total: matches.length,
     truncated: matches.length > input.limit
   });
 }
-function createMemoryAgentModelSelectionStore() {
+function createMemoryAgentModelSelectionStore2() {
   const selections = new Map;
   return {
     load: (conversationId) => selections.get(conversationId),
     save(conversationId, rawSelection) {
-      selections.set(conversationId, AgentModelSelectionSchema.parse(rawSelection));
+      selections.set(conversationId, AgentModelSelectionSchema2.parse(rawSelection));
     }
   };
 }
-function defineModelRegistry(config) {
+function defineModelRegistry2(config) {
   const descriptors = new Map;
   for (const key in config.models) {
     const declaration = config.models[key];
     if (declaration)
-      descriptors.set(key, AgentModelDescriptorSchema.parse(declaration));
+      descriptors.set(key, AgentModelDescriptorSchema2.parse(declaration));
   }
   const descriptor = (key) => {
     const found = descriptors.get(key);
@@ -135,7 +135,7 @@ function defineModelRegistry(config) {
       };
     },
     snapshot(input) {
-      return AgentModelRegistrySnapshotSchema.parse({
+      return AgentModelRegistrySnapshotSchema2.parse({
         schemaVersion: 1,
         source: input.source,
         observedAt: input.observedAt,
@@ -144,11 +144,11 @@ function defineModelRegistry(config) {
     }
   };
 }
-function validateAgentModelSnapshot(input, policy) {
+function validateAgentModelSnapshot2(input, policy) {
   if (!Number.isSafeInteger(policy.maxAgeMs) || policy.maxAgeMs < 0) {
     throw new TypeError("maxAgeMs must be a non-negative safe integer");
   }
-  const snapshot = AgentModelRegistrySnapshotSchema.parse(input);
+  const snapshot = AgentModelRegistrySnapshotSchema2.parse(input);
   const now = policy.now?.() ?? new Date;
   const age = now.getTime() - new Date(snapshot.observedAt).getTime();
   if (age < 0 || age > policy.maxAgeMs) {
@@ -157,4 +157,4 @@ function validateAgentModelSnapshot(input, policy) {
   return snapshot;
 }
 
-export { AgentModelCapabilitySchema, AgentModelDescriptorSchema, AgentModelRegistrySnapshotSchema, AgentModelPriceSchema, AgentModelMetricSchema, AgentModelPopularitySchema, AgentModelCatalogEntrySchema, AgentModelCatalogSchema, AgentModelSelectionSchema, AgentModelSearchInputSchema, AgentModelSearchResultSchema, searchAgentModelCatalog, createMemoryAgentModelSelectionStore, defineModelRegistry, validateAgentModelSnapshot };
+export { AgentModelCapabilitySchema2, AgentModelDescriptorSchema2, AgentModelRegistrySnapshotSchema2, AgentModelPriceSchema2, AgentModelMetricSchema2, AgentModelPopularitySchema2, AgentModelCatalogEntrySchema2, AgentModelCatalogSchema2, AgentModelSelectionSchema2, AgentModelSearchInputSchema2, AgentModelSearchResultSchema2, searchAgentModelCatalog2, createMemoryAgentModelSelectionStore2, defineModelRegistry2, validateAgentModelSnapshot2 };