@agentskit/chat-protocol 0.1.0

package/dist/index.cjs

@@ -0,0 +1,902 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ANSWER_MAX_CITATIONS: () => ANSWER_MAX_CITATIONS,
+  ANSWER_MAX_SUGGESTIONS: () => ANSWER_MAX_SUGGESTIONS,
+  ANSWER_PROTOCOL: () => ANSWER_PROTOCOL,
+  ANSWER_PROTOCOL_VERSION: () => ANSWER_PROTOCOL_VERSION,
+  ASK_EVENT_MAX_BYTES: () => ASK_EVENT_MAX_BYTES,
+  ASK_EVENT_MAX_RECORDS: () => ASK_EVENT_MAX_RECORDS,
+  ASK_SERVICE_PROTOCOL_VERSION: () => ASK_SERVICE_PROTOCOL_VERSION,
+  ASSISTANT_CONTENT_MAX_BYTES: () => ASSISTANT_CONTENT_MAX_BYTES,
+  ASSISTANT_CONTENT_MAX_RECORDS: () => ASSISTANT_CONTENT_MAX_RECORDS,
+  ASSISTANT_CONTENT_PREFIX: () => ASSISTANT_CONTENT_PREFIX,
+  ASSISTANT_CONTENT_PROTOCOL: () => ASSISTANT_CONTENT_PROTOCOL,
+  ASSISTANT_CONTENT_PROTOCOL_VERSION: () => ASSISTANT_CONTENT_PROTOCOL_VERSION,
+  AnswerCitationSchema: () => AnswerCitationSchema,
+  AnswerConfidenceSchema: () => AnswerConfidenceSchema,
+  AnswerResponseSchema: () => AnswerResponseSchema,
+  AnswerSuggestionSchema: () => AnswerSuggestionSchema,
+  AskEventSchema: () => AskEventSchema,
+  AssistantComponentPartSchema: () => AssistantComponentPartSchema,
+  AssistantContentPartSchema: () => AssistantContentPartSchema,
+  AssistantTextPartSchema: () => AssistantTextPartSchema,
+  COMPONENT_PROTOCOL: () => COMPONENT_PROTOCOL,
+  COMPONENT_PROTOCOL_VERSION: () => COMPONENT_PROTOCOL_VERSION,
+  ComponentFallbackSchema: () => ComponentFallbackSchema,
+  ComponentInteractionEventSchema: () => ComponentInteractionEventSchema,
+  ComponentKeySchema: () => ComponentKeySchema,
+  ComponentRenderFrameSchema: () => ComponentRenderFrameSchema,
+  ComponentSelectionEventSchema: () => ComponentSelectionEventSchema,
+  DETERMINISTIC_ARTIFACT_MAX_BYTES: () => DETERMINISTIC_ARTIFACT_MAX_BYTES,
+  DETERMINISTIC_ARTIFACT_MAX_ENTRIES: () => DETERMINISTIC_ARTIFACT_MAX_ENTRIES,
+  DETERMINISTIC_KNOWLEDGE_PROTOCOL: () => DETERMINISTIC_KNOWLEDGE_PROTOCOL,
+  DETERMINISTIC_KNOWLEDGE_PROTOCOL_VERSION: () => DETERMINISTIC_KNOWLEDGE_PROTOCOL_VERSION,
+  DETERMINISTIC_MATCH_MAX_VALUES: () => DETERMINISTIC_MATCH_MAX_VALUES,
+  DETERMINISTIC_QUERY_MAX_CHARS: () => DETERMINISTIC_QUERY_MAX_CHARS,
+  DETERMINISTIC_SITE_PROTOCOL: () => DETERMINISTIC_SITE_PROTOCOL,
+  DETERMINISTIC_SITE_PROTOCOL_VERSION: () => DETERMINISTIC_SITE_PROTOCOL_VERSION,
+  DeterministicKnowledgeEntrySchema: () => DeterministicKnowledgeEntrySchema,
+  DeterministicSiteConfigSchema: () => DeterministicSiteConfigSchema,
+  LocalKnowledgeArtifactSchema: () => LocalKnowledgeArtifactSchema,
+  SESSION_PROTOCOL: () => SESSION_PROTOCOL,
+  SESSION_PROTOCOL_VERSION: () => SESSION_PROTOCOL_VERSION,
+  SessionConfirmationSchema: () => SessionConfirmationSchema,
+  SessionSnapshotSchema: () => SessionSnapshotSchema,
+  TURN_PROTOCOL: () => TURN_PROTOCOL,
+  TURN_PROTOCOL_VERSION: () => TURN_PROTOCOL_VERSION,
+  TokenUsageSchema: () => TokenUsageSchema,
+  TurnDiagnosticSchema: () => TurnDiagnosticSchema,
+  TurnEventSchema: () => TurnEventSchema,
+  canonicalizeLocalKnowledgeArtifact: () => canonicalizeLocalKnowledgeArtifact,
+  computeLocalKnowledgeArtifactContentHash: () => computeLocalKnowledgeArtifactContentHash,
+  createAssistantContentEncoder: () => createAssistantContentEncoder,
+  createInteractionEvent: () => createInteractionEvent,
+  createSelectionEvent: () => createSelectionEvent,
+  createSnapshotEvent: () => createSnapshotEvent,
+  createTurnSnapshotCursor: () => createTurnSnapshotCursor,
+  decodeAnswerResponse: () => decodeAnswerResponse,
+  decodeAskEvents: () => decodeAskEvents,
+  decodeAssistantContent: () => decodeAssistantContent,
+  decodeComponentFrame: () => decodeComponentFrame,
+  decodeDeterministicSiteConfig: () => decodeDeterministicSiteConfig,
+  decodeLocalKnowledgeArtifact: () => decodeLocalKnowledgeArtifact,
+  decodeSessionSnapshot: () => decodeSessionSnapshot,
+  decodeTurnEvent: () => decodeTurnEvent,
+  encodeTurnEvent: () => encodeTurnEvent,
+  isAssistantContentCandidate: () => isAssistantContentCandidate,
+  isComponentFrameCandidate: () => isComponentFrameCandidate,
+  normalizeKnowledgeKey: () => normalizeKnowledgeKey,
+  snapshotMessages: () => snapshotMessages,
+  verifyLocalKnowledgeArtifact: () => verifyLocalKnowledgeArtifact,
+  verifyLocalKnowledgeArtifactSync: () => verifyLocalKnowledgeArtifactSync
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@agentskit/core");
+var import_memory_validation = require("@agentskit/core/memory-validation");
+var import_zod3 = require("zod");
+
+// src/ask.ts
+var import_zod = require("zod");
+var ASK_EVENT_MAX_BYTES = 1048576;
+var ASK_EVENT_MAX_RECORDS = 4096;
+var ASK_SERVICE_PROTOCOL_VERSION = 1;
+var AskArgsSchema = import_zod.z.record(import_zod.z.string().max(128), import_zod.z.unknown());
+var AskEventSchema = import_zod.z.discriminatedUnion("type", [
+  import_zod.z.object({ type: import_zod.z.literal("text"), delta: import_zod.z.string().max(ASK_EVENT_MAX_BYTES) }).strict(),
+  import_zod.z.object({ type: import_zod.z.literal("tool"), id: import_zod.z.string().max(256), name: import_zod.z.string().max(128), args: AskArgsSchema }).strict(),
+  import_zod.z.object({ type: import_zod.z.literal("done"), model: import_zod.z.string().max(256).optional() }).strict(),
+  import_zod.z.object({ type: import_zod.z.literal("error"), message: import_zod.z.string().min(1).max(4096) }).strict()
+]);
+var byteLength = (value) => new TextEncoder().encode(value).byteLength;
+function decodeAskEvents(buffer) {
+  const events = [];
+  let cursor = 0;
+  let records = 0;
+  while (records < ASK_EVENT_MAX_RECORDS) {
+    const lineEnd = buffer.indexOf("\n", cursor);
+    if (lineEnd < 0) break;
+    const line = buffer.slice(cursor, lineEnd);
+    cursor = lineEnd + 1;
+    records += 1;
+    const candidate = line.trim();
+    if (candidate === "" || byteLength(candidate) > ASK_EVENT_MAX_BYTES) continue;
+    try {
+      const parsed = AskEventSchema.safeParse(JSON.parse(candidate));
+      if (parsed.success) events.push(parsed.data);
+    } catch {
+    }
+  }
+  if (records === ASK_EVENT_MAX_RECORDS) {
+    const lastLineEnd = buffer.lastIndexOf("\n");
+    if (lastLineEnd >= cursor) cursor = lastLineEnd + 1;
+  }
+  const partial = buffer.slice(cursor);
+  const discardedPartial = byteLength(partial) > ASK_EVENT_MAX_BYTES;
+  return { events: Object.freeze(events), rest: discardedPartial ? "" : partial, discardedPartial };
+}
+
+// src/deterministic.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_utils = require("@noble/hashes/utils.js");
+var import_zod2 = require("zod");
+var DETERMINISTIC_SITE_PROTOCOL = "agentskit.chat.site";
+var DETERMINISTIC_SITE_PROTOCOL_VERSION = 1;
+var DETERMINISTIC_KNOWLEDGE_PROTOCOL = "agentskit.chat.knowledge";
+var DETERMINISTIC_KNOWLEDGE_PROTOCOL_VERSION = 1;
+var ANSWER_PROTOCOL = "agentskit.chat.answer";
+var ANSWER_PROTOCOL_VERSION = 1;
+var DETERMINISTIC_ARTIFACT_MAX_BYTES = 524288;
+var DETERMINISTIC_ARTIFACT_MAX_ENTRIES = 1024;
+var DETERMINISTIC_MATCH_MAX_VALUES = 16;
+var DETERMINISTIC_QUERY_MAX_CHARS = 512;
+var ANSWER_MAX_CITATIONS = 8;
+var ANSWER_MAX_SUGGESTIONS = 8;
+var SafeIdentifierSchema = import_zod2.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var ContentHashSchema = import_zod2.z.string().regex(/^sha256:[a-f0-9]{64}$/);
+var DateTimeSchema = import_zod2.z.string().datetime({ offset: true });
+var isSafeHref = (value) => {
+  if (/[\u0000-\u001F\u007F\\]/u.test(value)) return false;
+  if (value.startsWith("//")) return false;
+  if (!/^[A-Za-z][A-Za-z0-9+.-]*:/.test(value)) {
+    return /^\/(?!\/)/.test(value);
+  }
+  try {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:") && url.username === "" && url.password === "";
+  } catch {
+    return false;
+  }
+};
+var SafeHrefSchema = import_zod2.z.string().min(1).max(2048).refine(isSafeHref, "Link must be a safe relative, HTTP, or HTTPS URL.");
+var normalizeKnowledgeKey = (value) => value.normalize("NFKC").trim().replace(/\s+/gu, " ").toLocaleLowerCase("en-US");
+var DeterministicSiteConfigSchema = import_zod2.z.object({
+  protocol: import_zod2.z.literal(DETERMINISTIC_SITE_PROTOCOL),
+  version: import_zod2.z.literal(DETERMINISTIC_SITE_PROTOCOL_VERSION),
+  siteId: SafeIdentifierSchema,
+  artifact: import_zod2.z.object({
+    href: SafeHrefSchema,
+    contentHash: ContentHashSchema
+  }).readonly(),
+  fallback: import_zod2.z.object({ mode: import_zod2.z.enum(["backend", "disabled"]) }).readonly()
+}).readonly();
+var AnswerCitationSchema = import_zod2.z.object({
+  id: SafeIdentifierSchema,
+  title: import_zod2.z.string().trim().min(1).max(256),
+  href: SafeHrefSchema
+}).readonly();
+var DeterministicKnowledgeEntrySchema = import_zod2.z.object({
+  id: SafeIdentifierSchema,
+  kind: import_zod2.z.enum(["command", "package", "navigation", "contribution", "ecosystem", "restricted-faq", "document"]),
+  label: import_zod2.z.string().trim().min(1).max(256),
+  match: import_zod2.z.object({
+    type: import_zod2.z.literal("exact"),
+    values: import_zod2.z.array(import_zod2.z.string().trim().min(1).max(DETERMINISTIC_QUERY_MAX_CHARS)).min(1).max(DETERMINISTIC_MATCH_MAX_VALUES).superRefine((values, context) => {
+      const seen = /* @__PURE__ */ new Set();
+      values.forEach((value, index) => {
+        const normalized = normalizeKnowledgeKey(value);
+        if (normalized.length > DETERMINISTIC_QUERY_MAX_CHARS) {
+          context.addIssue({ code: "custom", path: [index], message: "Normalized match values must fit the deterministic query limit." });
+        }
+        if (seen.has(normalized)) context.addIssue({ code: "custom", path: [index], message: "Match values must be unique after normalization." });
+        seen.add(normalized);
+      });
+    }).readonly()
+  }).readonly(),
+  answer: import_zod2.z.object({
+    markdown: import_zod2.z.string().trim().min(1).max(16384),
+    citations: import_zod2.z.array(AnswerCitationSchema).max(ANSWER_MAX_CITATIONS).readonly()
+  }).readonly()
+}).readonly();
+var LocalKnowledgeArtifactSchema = import_zod2.z.object({
+  protocol: import_zod2.z.literal(DETERMINISTIC_KNOWLEDGE_PROTOCOL),
+  version: import_zod2.z.literal(DETERMINISTIC_KNOWLEDGE_PROTOCOL_VERSION),
+  artifactId: SafeIdentifierSchema,
+  siteId: SafeIdentifierSchema,
+  contentHash: ContentHashSchema,
+  generatedAt: DateTimeSchema,
+  expiresAt: DateTimeSchema.optional(),
+  entries: import_zod2.z.array(DeterministicKnowledgeEntrySchema).max(DETERMINISTIC_ARTIFACT_MAX_ENTRIES).readonly()
+}).superRefine((artifact, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  const aliases = /* @__PURE__ */ new Map();
+  artifact.entries.forEach((entry, index) => {
+    if (ids.has(entry.id)) context.addIssue({ code: "custom", path: ["entries", index, "id"], message: "Entry ids must be unique." });
+    ids.add(entry.id);
+    for (const value of entry.match.values) {
+      const key = normalizeKnowledgeKey(value);
+      const entryIds = aliases.get(key) ?? /* @__PURE__ */ new Set();
+      entryIds.add(entry.id);
+      aliases.set(key, entryIds);
+    }
+  });
+  artifact.entries.forEach((entry, index) => {
+    if (!entry.match.values.some((value) => aliases.get(normalizeKnowledgeKey(value))?.size === 1)) {
+      context.addIssue({ code: "custom", path: ["entries", index, "match", "values"], message: "Every entry must have at least one globally unique exact alias." });
+    }
+  });
+  if (artifact.expiresAt !== void 0 && Date.parse(artifact.expiresAt) <= Date.parse(artifact.generatedAt)) {
+    context.addIssue({ code: "custom", path: ["expiresAt"], message: "Expiration must be after generation." });
+  }
+}).readonly();
+var AnswerConfidenceSchema = import_zod2.z.object({
+  level: import_zod2.z.enum(["high", "medium", "low"]),
+  basis: import_zod2.z.enum(["exact", "ambiguous", "miss", "stale", "corrupt", "offline", "backend"])
+}).readonly();
+var LocalProvenanceSchema = import_zod2.z.object({
+  source: import_zod2.z.literal("local"),
+  artifactId: SafeIdentifierSchema,
+  contentHash: ContentHashSchema,
+  entryIds: import_zod2.z.array(SafeIdentifierSchema).min(1).max(ANSWER_MAX_SUGGESTIONS).readonly()
+}).readonly();
+var BackendProvenanceSchema = import_zod2.z.object({
+  source: import_zod2.z.literal("backend"),
+  provider: import_zod2.z.string().trim().min(1).max(128).optional(),
+  model: import_zod2.z.string().trim().min(1).max(128).optional()
+}).readonly();
+var AnswerSuggestionSchema = import_zod2.z.object({
+  id: SafeIdentifierSchema,
+  label: import_zod2.z.string().trim().min(1).max(256),
+  value: import_zod2.z.string().trim().min(1).max(DETERMINISTIC_QUERY_MAX_CHARS)
+}).readonly();
+var AnswerQuerySchema = import_zod2.z.string().max(DETERMINISTIC_QUERY_MAX_CHARS);
+var AnswerResponseSchema = import_zod2.z.discriminatedUnion("outcome", [
+  import_zod2.z.object({
+    protocol: import_zod2.z.literal(ANSWER_PROTOCOL),
+    version: import_zod2.z.literal(ANSWER_PROTOCOL_VERSION),
+    outcome: import_zod2.z.literal("answer"),
+    query: AnswerQuerySchema,
+    normalizedQuery: AnswerQuerySchema,
+    answer: import_zod2.z.object({ markdown: import_zod2.z.string().min(1).max(16384), citations: import_zod2.z.array(AnswerCitationSchema).max(ANSWER_MAX_CITATIONS).readonly() }).readonly(),
+    provenance: import_zod2.z.union([LocalProvenanceSchema, BackendProvenanceSchema]),
+    confidence: AnswerConfidenceSchema
+  }).readonly(),
+  import_zod2.z.object({
+    protocol: import_zod2.z.literal(ANSWER_PROTOCOL),
+    version: import_zod2.z.literal(ANSWER_PROTOCOL_VERSION),
+    outcome: import_zod2.z.literal("choices"),
+    query: AnswerQuerySchema,
+    normalizedQuery: AnswerQuerySchema,
+    message: import_zod2.z.string().min(1).max(4096),
+    suggestions: import_zod2.z.array(AnswerSuggestionSchema).min(2).max(ANSWER_MAX_SUGGESTIONS).readonly(),
+    provenance: LocalProvenanceSchema,
+    confidence: AnswerConfidenceSchema
+  }).readonly(),
+  import_zod2.z.object({
+    protocol: import_zod2.z.literal(ANSWER_PROTOCOL),
+    version: import_zod2.z.literal(ANSWER_PROTOCOL_VERSION),
+    outcome: import_zod2.z.literal("escalation"),
+    query: AnswerQuerySchema,
+    normalizedQuery: AnswerQuerySchema,
+    message: import_zod2.z.string().min(1).max(4096),
+    reason: import_zod2.z.enum(["miss", "stale", "corrupt", "offline"]),
+    candidateEntryIds: import_zod2.z.array(SafeIdentifierSchema).max(ANSWER_MAX_SUGGESTIONS).readonly().optional(),
+    confidence: AnswerConfidenceSchema
+  }).readonly()
+]).superRefine((response, context) => {
+  if (response.normalizedQuery !== normalizeKnowledgeKey(response.query).slice(0, DETERMINISTIC_QUERY_MAX_CHARS)) {
+    context.addIssue({ code: "custom", path: ["normalizedQuery"], message: "Normalized query must match the canonical normalization rule." });
+  }
+  if (response.outcome === "answer") {
+    const validLocal = response.provenance.source === "local" && response.confidence.level === "high" && response.confidence.basis === "exact" && response.provenance.entryIds.length === 1;
+    const validBackend = response.provenance.source === "backend" && response.confidence.level === "high" && response.confidence.basis === "backend";
+    if (!validLocal && !validBackend) context.addIssue({ code: "custom", path: ["confidence"], message: "Answer confidence must match its provenance." });
+  } else if (response.outcome === "choices") {
+    if (response.confidence.level !== "medium" || response.confidence.basis !== "ambiguous") {
+      context.addIssue({ code: "custom", path: ["confidence"], message: "Choices require medium ambiguous confidence." });
+    }
+    const suggestionIds = response.suggestions.map((suggestion) => suggestion.id);
+    if (suggestionIds.length !== response.provenance.entryIds.length || suggestionIds.some((id, index) => id !== response.provenance.entryIds[index])) {
+      context.addIssue({ code: "custom", path: ["provenance", "entryIds"], message: "Choice provenance must match suggestions in order." });
+    }
+  } else if (response.confidence.level !== "low" || response.confidence.basis !== response.reason) {
+    context.addIssue({ code: "custom", path: ["confidence"], message: "Escalation confidence must match its reason." });
+  }
+});
+var failure = (code, message) => ({
+  ok: false,
+  diagnostic: { code, message, retryable: false }
+});
+var parseBoundedInput = (input, schema, protocol, version, maxBytes) => {
+  let candidate = input;
+  if (typeof input === "string") {
+    if (maxBytes !== void 0 && new TextEncoder().encode(input).byteLength > maxBytes) {
+      return failure("DETERMINISTIC_LIMIT_EXCEEDED", "Deterministic payload exceeds its safety limit.");
+    }
+    try {
+      candidate = JSON.parse(input);
+    } catch {
+      return failure("DETERMINISTIC_INVALID_PAYLOAD", "Deterministic payload is not valid JSON.");
+    }
+  }
+  try {
+    if (typeof candidate === "object" && candidate !== null && !Array.isArray(candidate)) {
+      const record = candidate;
+      if (record.protocol === protocol && typeof record.version === "number" && record.version !== version) {
+        return failure("DETERMINISTIC_UNSUPPORTED_VERSION", "Deterministic payload uses an unsupported version.");
+      }
+    }
+    const parsed = schema.safeParse(candidate);
+    if (!parsed.success) return failure("DETERMINISTIC_INVALID_PAYLOAD", "Deterministic payload is invalid.");
+    if (maxBytes !== void 0 && typeof input !== "string" && new TextEncoder().encode(JSON.stringify(parsed.data)).byteLength > maxBytes) {
+      return failure("DETERMINISTIC_LIMIT_EXCEEDED", "Deterministic payload exceeds its safety limit.");
+    }
+    return { ok: true, value: parsed.data };
+  } catch {
+    return failure("DETERMINISTIC_INVALID_PAYLOAD", "Deterministic payload is invalid.");
+  }
+};
+var decodeDeterministicSiteConfig = (input) => parseBoundedInput(input, DeterministicSiteConfigSchema, DETERMINISTIC_SITE_PROTOCOL, DETERMINISTIC_SITE_PROTOCOL_VERSION, 16384);
+var decodeLocalKnowledgeArtifact = (input, options = {}) => {
+  const decoded = parseBoundedInput(input, LocalKnowledgeArtifactSchema, DETERMINISTIC_KNOWLEDGE_PROTOCOL, DETERMINISTIC_KNOWLEDGE_PROTOCOL_VERSION, DETERMINISTIC_ARTIFACT_MAX_BYTES);
+  if (!decoded.ok) return decoded;
+  if (options.expectedContentHash !== void 0 && decoded.value.contentHash !== options.expectedContentHash) {
+    return failure("DETERMINISTIC_HASH_MISMATCH", "Deterministic artifact does not match the configured content hash.");
+  }
+  if (options.expectedSiteId !== void 0 && decoded.value.siteId !== options.expectedSiteId) {
+    return failure("DETERMINISTIC_INVALID_PAYLOAD", "Deterministic artifact belongs to a different site.");
+  }
+  return decoded;
+};
+var canonicalizeLocalKnowledgeArtifact = (artifact) => JSON.stringify({
+  protocol: artifact.protocol,
+  version: artifact.version,
+  artifactId: artifact.artifactId,
+  siteId: artifact.siteId,
+  generatedAt: artifact.generatedAt,
+  ...artifact.expiresAt === void 0 ? {} : { expiresAt: artifact.expiresAt },
+  entries: artifact.entries.map((entry) => ({
+    id: entry.id,
+    kind: entry.kind,
+    label: entry.label,
+    match: { type: entry.match.type, values: [...entry.match.values] },
+    answer: {
+      markdown: entry.answer.markdown,
+      citations: entry.answer.citations.map((citation) => ({ id: citation.id, title: citation.title, href: citation.href }))
+    }
+  }))
+});
+var HASH_PLACEHOLDER = `sha256:${"0".repeat(64)}`;
+var calculateLocalKnowledgeArtifactContentHash = (artifactInput) => {
+  const decoded = decodeLocalKnowledgeArtifact({ ...artifactInput, contentHash: HASH_PLACEHOLDER });
+  if (!decoded.ok) throw new TypeError(decoded.diagnostic.message);
+  const digest = (0, import_sha2.sha256)(new TextEncoder().encode(canonicalizeLocalKnowledgeArtifact(decoded.value)));
+  return `sha256:${(0, import_utils.bytesToHex)(digest)}`;
+};
+var computeLocalKnowledgeArtifactContentHash = async (artifactInput) => calculateLocalKnowledgeArtifactContentHash(artifactInput);
+var TrustedArtifactOptionsSchema = import_zod2.z.object({
+  expectedContentHash: ContentHashSchema,
+  expectedSiteId: SafeIdentifierSchema
+}).readonly();
+var verifyLocalKnowledgeArtifactSync = (input, options) => {
+  const trusted = TrustedArtifactOptionsSchema.safeParse(options);
+  if (!trusted.success) return failure("DETERMINISTIC_INVALID_PAYLOAD", "Trusted deterministic artifact configuration is invalid.");
+  const decoded = decodeLocalKnowledgeArtifact(input, trusted.data);
+  if (!decoded.ok) return decoded;
+  try {
+    const actual = calculateLocalKnowledgeArtifactContentHash(decoded.value);
+    if (actual !== decoded.value.contentHash) {
+      return failure("DETERMINISTIC_HASH_MISMATCH", "Deterministic artifact content does not match its SHA-256 hash.");
+    }
+    return { ok: true, value: decoded.value };
+  } catch {
+    return failure("DETERMINISTIC_INVALID_PAYLOAD", "Deterministic artifact integrity could not be verified.");
+  }
+};
+var verifyLocalKnowledgeArtifact = async (input, options) => verifyLocalKnowledgeArtifactSync(input, options);
+var decodeAnswerResponse = (input) => parseBoundedInput(input, AnswerResponseSchema, ANSWER_PROTOCOL, ANSWER_PROTOCOL_VERSION, 262144);
+
+// src/index.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isBoundedJsonValue = (input) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  let nodes = 0;
+  const visit = (value, depth) => {
+    nodes += 1;
+    if (nodes > 1e3 || depth > 20) return false;
+    if (value === null || typeof value === "boolean") return true;
+    if (typeof value === "string") return value.length <= 16384;
+    if (typeof value === "number") return Number.isFinite(value);
+    if (typeof value !== "object") return false;
+    if (seen.has(value)) return false;
+    seen.add(value);
+    if (Array.isArray(value)) return value.length <= 1e3 && value.every((item) => visit(item, depth + 1));
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return false;
+    const entries = Object.entries(value);
+    return entries.length <= 1e3 && entries.every(([key, item]) => key.length <= 256 && visit(item, depth + 1));
+  };
+  try {
+    return visit(input, 0);
+  } catch {
+    return false;
+  }
+};
+var TURN_PROTOCOL = "agentskit.chat.turn";
+var TURN_PROTOCOL_VERSION = 1;
+var COMPONENT_PROTOCOL = "agentskit.chat.component";
+var COMPONENT_PROTOCOL_VERSION = 1;
+var ASSISTANT_CONTENT_PROTOCOL = "agentskit.chat.content";
+var ASSISTANT_CONTENT_PROTOCOL_VERSION = 1;
+var ASSISTANT_CONTENT_PREFIX = `${ASSISTANT_CONTENT_PROTOCOL}/${ASSISTANT_CONTENT_PROTOCOL_VERSION}
+`;
+var ASSISTANT_CONTENT_PREFIX_ROOT = `${ASSISTANT_CONTENT_PROTOCOL}/`;
+var ASSISTANT_CONTENT_MAX_BYTES = 262144;
+var ASSISTANT_CONTENT_MAX_RECORDS = 512;
+var ComponentKeySchema = import_zod3.z.string().regex(/^[a-z][a-z0-9-]{0,63}$/);
+var ComponentFallbackSchema = import_zod3.z.object({
+  kind: import_zod3.z.string().min(1).max(64),
+  summary: import_zod3.z.string().min(1).max(4096)
+}).readonly();
+var ComponentRenderFrameSchema = import_zod3.z.object({
+  protocol: import_zod3.z.literal(COMPONENT_PROTOCOL),
+  version: import_zod3.z.literal(COMPONENT_PROTOCOL_VERSION),
+  type: import_zod3.z.literal("render"),
+  componentKey: ComponentKeySchema,
+  instanceId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  props: import_zod3.z.unknown().refine(isBoundedJsonValue),
+  fallback: ComponentFallbackSchema
+}).readonly();
+var ComponentSelectionEventSchema = import_zod3.z.object({
+  protocol: import_zod3.z.literal(COMPONENT_PROTOCOL),
+  version: import_zod3.z.literal(COMPONENT_PROTOCOL_VERSION),
+  type: import_zod3.z.literal("select"),
+  componentKey: ComponentKeySchema,
+  instanceId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  choiceId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)
+}).readonly();
+var ComponentInteractionEventSchema = import_zod3.z.object({
+  protocol: import_zod3.z.literal(COMPONENT_PROTOCOL),
+  version: import_zod3.z.literal(COMPONENT_PROTOCOL_VERSION),
+  type: import_zod3.z.literal("interact"),
+  componentKey: ComponentKeySchema,
+  instanceId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  event: import_zod3.z.string().regex(/^[a-z][a-z0-9-]{0,63}$/),
+  value: import_zod3.z.unknown().refine(isBoundedJsonValue).optional()
+}).readonly();
+var AssistantTextPartSchema = import_zod3.z.object({
+  kind: import_zod3.z.literal("text"),
+  text: import_zod3.z.string().min(1).max(16384)
+}).readonly();
+var AssistantComponentPartSchema = import_zod3.z.object({
+  kind: import_zod3.z.literal("component"),
+  frame: ComponentRenderFrameSchema
+}).readonly();
+var AssistantContentPartSchema = import_zod3.z.discriminatedUnion("kind", [AssistantTextPartSchema, AssistantComponentPartSchema]);
+var createAssistantContentEncoder = () => {
+  let started = false;
+  return {
+    encode: (part) => {
+      const parsed = AssistantContentPartSchema.parse(part);
+      const prefix = started ? "" : ASSISTANT_CONTENT_PREFIX;
+      started = true;
+      return `${prefix}${JSON.stringify(parsed)}
+`;
+    }
+  };
+};
+var assistantContentFailure = (code, message) => ({
+  ok: false,
+  diagnostic: { code, message, retryable: false }
+});
+var isAssistantContentCandidate = (input) => typeof input === "string" && input.startsWith("");
+var decodeAssistantContent = (input) => {
+  if (typeof input !== "string" || !input.startsWith("")) {
+    return assistantContentFailure("ASSISTANT_CONTENT_INVALID_RECORD", "Assistant content envelope is invalid.");
+  }
+  if (!input.startsWith(ASSISTANT_CONTENT_PREFIX_ROOT) && ASSISTANT_CONTENT_PREFIX_ROOT.startsWith(input)) {
+    return { ok: true, parts: [], complete: false };
+  }
+  if (!input.startsWith(ASSISTANT_CONTENT_PREFIX_ROOT)) {
+    return assistantContentFailure("ASSISTANT_CONTENT_INVALID_RECORD", "Assistant content envelope is invalid.");
+  }
+  if (ASSISTANT_CONTENT_PREFIX.startsWith(input)) {
+    return { ok: true, parts: [], complete: false };
+  }
+  if (!input.startsWith(ASSISTANT_CONTENT_PREFIX)) {
+    return assistantContentFailure("ASSISTANT_CONTENT_UNSUPPORTED_VERSION", "Assistant content envelope uses an unsupported version.");
+  }
+  if (new TextEncoder().encode(input).byteLength > ASSISTANT_CONTENT_MAX_BYTES) {
+    return assistantContentFailure("ASSISTANT_CONTENT_LIMIT_EXCEEDED", "Assistant content envelope exceeds its safety limit.");
+  }
+  const payload = input.slice(ASSISTANT_CONTENT_PREFIX.length);
+  const complete = payload.endsWith("\n");
+  const records = payload.split("\n");
+  if (!complete) records.pop();
+  else records.pop();
+  if (records.length > ASSISTANT_CONTENT_MAX_RECORDS) {
+    return assistantContentFailure("ASSISTANT_CONTENT_LIMIT_EXCEEDED", "Assistant content envelope exceeds its record limit.");
+  }
+  const parts = [];
+  try {
+    for (const record of records) {
+      if (record === "") return assistantContentFailure("ASSISTANT_CONTENT_INVALID_RECORD", "Assistant content record is invalid.");
+      const parsed = AssistantContentPartSchema.safeParse(JSON.parse(record));
+      if (!parsed.success) return assistantContentFailure("ASSISTANT_CONTENT_INVALID_RECORD", "Assistant content record is invalid.");
+      parts.push(parsed.data);
+    }
+    return { ok: true, parts: Object.freeze(parts), complete };
+  } catch {
+    return assistantContentFailure("ASSISTANT_CONTENT_INVALID_RECORD", "Assistant content record is invalid.");
+  }
+};
+var decodeComponentFrame = (input) => {
+  let candidate = input;
+  if (typeof input === "string") {
+    try {
+      candidate = JSON.parse(input);
+    } catch {
+      return {
+        ok: false,
+        diagnostic: { code: "COMPONENT_INVALID_FRAME", message: "Component frame is not valid JSON.", retryable: false }
+      };
+    }
+  }
+  try {
+    if (isRecord(candidate) && candidate.protocol === COMPONENT_PROTOCOL) {
+      if (typeof candidate.version === "number" && candidate.version !== COMPONENT_PROTOCOL_VERSION) {
+        return {
+          ok: false,
+          diagnostic: { code: "COMPONENT_UNSUPPORTED_VERSION", message: "Component frame uses an unsupported version.", retryable: false }
+        };
+      }
+      if (candidate.type !== "render") {
+        return {
+          ok: false,
+          diagnostic: { code: "COMPONENT_UNKNOWN_TYPE", message: "Component frame type is unknown.", retryable: false }
+        };
+      }
+    }
+    const parsed = ComponentRenderFrameSchema.safeParse(candidate);
+    return parsed.success ? { ok: true, frame: parsed.data } : {
+      ok: false,
+      diagnostic: { code: "COMPONENT_INVALID_FRAME", message: "Component frame payload is invalid.", retryable: false }
+    };
+  } catch {
+    return {
+      ok: false,
+      diagnostic: { code: "COMPONENT_INVALID_FRAME", message: "Component frame payload is invalid.", retryable: false }
+    };
+  }
+};
+var isComponentFrameCandidate = (input) => {
+  try {
+    const candidate = typeof input === "string" ? JSON.parse(input) : input;
+    return isRecord(candidate) && candidate.protocol === COMPONENT_PROTOCOL;
+  } catch {
+    return false;
+  }
+};
+var createSelectionEvent = (frame, choiceId) => ComponentSelectionEventSchema.parse({
+  protocol: COMPONENT_PROTOCOL,
+  version: COMPONENT_PROTOCOL_VERSION,
+  type: "select",
+  componentKey: frame.componentKey,
+  instanceId: frame.instanceId,
+  choiceId
+});
+var createInteractionEvent = (frame, event, value) => ComponentInteractionEventSchema.parse({
+  protocol: COMPONENT_PROTOCOL,
+  version: COMPONENT_PROTOCOL_VERSION,
+  type: "interact",
+  componentKey: frame.componentKey,
+  instanceId: frame.instanceId,
+  event,
+  ...value === void 0 ? {} : { value }
+});
+var TokenUsageSchema = import_zod3.z.object({
+  promptTokens: import_zod3.z.number().int().nonnegative(),
+  completionTokens: import_zod3.z.number().int().nonnegative(),
+  totalTokens: import_zod3.z.number().int().nonnegative()
+});
+var TurnDiagnosticSchema = import_zod3.z.object({
+  version: import_zod3.z.literal(1),
+  code: import_zod3.z.string().regex(/^[A-Z][A-Z0-9_]*$/),
+  message: import_zod3.z.string().min(1),
+  retryable: import_zod3.z.boolean()
+});
+var SafeIdentifierSchema2 = import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var EnvelopeFields = {
+  protocol: import_zod3.z.literal(TURN_PROTOCOL),
+  version: import_zod3.z.literal(TURN_PROTOCOL_VERSION),
+  eventId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  sessionId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  turnId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  sequence: import_zod3.z.number().int().nonnegative(),
+  emittedAt: import_zod3.z.string().datetime({ offset: true })
+};
+var MemoryMessagesSchema = import_zod3.z.array(import_zod3.z.unknown()).transform((messages, context) => {
+  try {
+    return (0, import_memory_validation.validateMemoryRecord)({ version: 1, messages }).messages;
+  } catch {
+    context.addIssue({ code: "custom", message: "Messages are not a valid AgentsKit memory record." });
+    return import_zod3.z.NEVER;
+  }
+});
+var TurnLineageSchema = import_zod3.z.discriminatedUnion("operation", [
+  import_zod3.z.object({ operation: import_zod3.z.literal("submit") }),
+  import_zod3.z.object({ operation: import_zod3.z.enum(["retry", "edit", "regenerate"]), parentTurnId: SafeIdentifierSchema2, sourceMessageId: SafeIdentifierSchema2 })
+]);
+var SubmitEventSchema = import_zod3.z.object({
+  ...EnvelopeFields,
+  event: import_zod3.z.literal("client.turn.submit"),
+  payload: import_zod3.z.object({
+    input: import_zod3.z.string().min(1).refine((value) => value.trim().length > 0)
+  })
+});
+var SnapshotEventSchema = import_zod3.z.object({
+  ...EnvelopeFields,
+  event: import_zod3.z.literal("server.turn.snapshot"),
+  payload: import_zod3.z.object({
+    messages: MemoryMessagesSchema,
+    status: import_zod3.z.enum(["idle", "streaming", "complete", "error"]),
+    usage: TokenUsageSchema,
+    error: TurnDiagnosticSchema.optional(),
+    lineage: TurnLineageSchema.optional()
+  })
+});
+var DiagnosticEventSchema = import_zod3.z.object({
+  ...EnvelopeFields,
+  event: import_zod3.z.literal("server.turn.diagnostic"),
+  payload: TurnDiagnosticSchema
+});
+var TurnEventSchema = import_zod3.z.discriminatedUnion("event", [
+  SubmitEventSchema,
+  SnapshotEventSchema,
+  DiagnosticEventSchema
+]);
+var deepFreeze = (value) => {
+  if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+};
+var createSnapshotEvent = (options) => SnapshotEventSchema.parse({
+  protocol: TURN_PROTOCOL,
+  version: TURN_PROTOCOL_VERSION,
+  eventId: options.eventId,
+  sessionId: options.sessionId,
+  turnId: options.turnId,
+  sequence: options.sequence,
+  emittedAt: options.emittedAt,
+  event: "server.turn.snapshot",
+  payload: {
+    messages: (0, import_core.serializeMessages)([...options.messages]).messages,
+    status: options.status,
+    usage: options.usage,
+    ...options.lineage === void 0 ? {} : { lineage: options.lineage },
+    ...options.error === void 0 ? {} : { error: options.error }
+  }
+});
+var createTurnSnapshotCursor = (sessionId) => {
+  const expectedSessionId = SafeIdentifierSchema2.parse(sessionId);
+  let snapshot;
+  return {
+    apply(input) {
+      const decoded = decodeTurnEvent(input);
+      if (!decoded.ok || decoded.event.event !== "server.turn.snapshot") return false;
+      const next = decoded.event;
+      if (next.sessionId !== expectedSessionId || snapshot && next.sequence <= snapshot.sequence) return false;
+      snapshot = deepFreeze(next);
+      return true;
+    },
+    getSnapshot: () => snapshot
+  };
+};
+var eventNames = /* @__PURE__ */ new Set(["client.turn.submit", "server.turn.snapshot", "server.turn.diagnostic"]);
+var safeEventId = (input) => {
+  try {
+    if (!isRecord(input)) return void 0;
+    const parsed = SafeIdentifierSchema2.safeParse(input.eventId);
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var diagnostic = (code, message, input) => {
+  const eventId = safeEventId(input);
+  return {
+    ok: false,
+    diagnostic: {
+      code,
+      message,
+      retryable: false,
+      ...eventId === void 0 ? {} : { eventId }
+    }
+  };
+};
+var decodeTurnEvent = (input) => {
+  let candidate = input;
+  if (typeof input === "string") {
+    try {
+      candidate = JSON.parse(input);
+    } catch {
+      return diagnostic("PROTOCOL_INVALID_PAYLOAD", "Turn event is not valid JSON.", input);
+    }
+  }
+  try {
+    if (isRecord(candidate) && candidate.protocol === TURN_PROTOCOL && typeof candidate.version === "number" && candidate.version !== TURN_PROTOCOL_VERSION) {
+      return diagnostic(
+        "PROTOCOL_UNSUPPORTED_VERSION",
+        "Turn event uses an unsupported protocol version.",
+        candidate
+      );
+    }
+    if (isRecord(candidate) && candidate.protocol === TURN_PROTOCOL && candidate.version === TURN_PROTOCOL_VERSION && typeof candidate.event === "string" && !eventNames.has(candidate.event)) {
+      return diagnostic(
+        "PROTOCOL_UNKNOWN_EVENT",
+        "Turn event kind is unknown.",
+        candidate
+      );
+    }
+    const parsed = TurnEventSchema.safeParse(candidate);
+    return parsed.success ? { ok: true, event: parsed.data } : diagnostic("PROTOCOL_INVALID_PAYLOAD", "Turn event payload is invalid.", candidate);
+  } catch {
+    return diagnostic("PROTOCOL_INVALID_PAYLOAD", "Turn event payload is invalid.", candidate);
+  }
+};
+var encodeTurnEvent = (event) => JSON.stringify(TurnEventSchema.parse(event));
+var snapshotMessages = (event) => {
+  const validated = SnapshotEventSchema.parse(event);
+  return (0, import_core.deserializeMessages)({ version: 1, messages: validated.payload.messages });
+};
+var SESSION_PROTOCOL = "agentskit.chat.session";
+var SESSION_PROTOCOL_VERSION = 1;
+var SessionDecisionSchema = import_zod3.z.object({
+  messageId: SafeIdentifierSchema2,
+  input: import_zod3.z.string().max(16384),
+  routeId: SafeIdentifierSchema2,
+  kind: import_zod3.z.enum(["deterministic", "repaired", "fallback"]),
+  content: import_zod3.z.string().max(65536),
+  fromState: import_zod3.z.string().min(1).max(128),
+  toState: import_zod3.z.string().min(1).max(128)
+}).readonly();
+var SessionConfirmationSchema = import_zod3.z.object({
+  token: SafeIdentifierSchema2,
+  action: SafeIdentifierSchema2,
+  input: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).refine(isBoundedJsonValue),
+  toolCallId: SafeIdentifierSchema2,
+  expiresAt: import_zod3.z.number().int().nonnegative(),
+  status: import_zod3.z.enum(["pending", "approving", "rejecting", "expiring", "approved", "rejected", "expired"])
+}).readonly();
+var uniqueBy = (items, key, context, path) => {
+  const seen = /* @__PURE__ */ new Set();
+  items.forEach((item, index) => {
+    const value = key(item);
+    if (seen.has(value)) context.addIssue({ code: "custom", path: [index, path], message: `${path} must be unique.` });
+    seen.add(value);
+  });
+};
+var SessionDecisionsSchema = import_zod3.z.array(SessionDecisionSchema).max(1e3).superRefine((items, context) => uniqueBy(items, (item) => item.messageId, context, "messageId"));
+var SessionConfirmationsSchema = import_zod3.z.array(SessionConfirmationSchema).max(1e3).superRefine((items, context) => {
+  uniqueBy(items, (item) => item.token, context, "token");
+  uniqueBy(items, (item) => item.toolCallId, context, "toolCallId");
+});
+var SessionSnapshotObjectSchema = import_zod3.z.object({
+  protocol: import_zod3.z.literal(SESSION_PROTOCOL),
+  version: import_zod3.z.literal(SESSION_PROTOCOL_VERSION),
+  sessionId: SafeIdentifierSchema2,
+  definitionId: SafeIdentifierSchema2,
+  definitionRevision: import_zod3.z.number().int().positive(),
+  updatedAt: import_zod3.z.string().datetime({ offset: true }),
+  cursor: import_zod3.z.number().int().nonnegative(),
+  activeTurn: import_zod3.z.object({ turnId: SafeIdentifierSchema2, expiresAt: import_zod3.z.number().int().nonnegative() }).readonly().optional(),
+  terminalTurns: import_zod3.z.array(import_zod3.z.object({ turnId: SafeIdentifierSchema2, outcome: import_zod3.z.enum(["completed", "indeterminate"]) }).readonly()).max(64).superRefine((items, context) => uniqueBy(items, (item) => item.turnId, context, "turnId")).readonly().optional(),
+  conversation: import_zod3.z.object({
+    state: import_zod3.z.string().min(1).max(128),
+    decisions: SessionDecisionsSchema
+  }).readonly().optional(),
+  confirmations: SessionConfirmationsSchema
+});
+var SessionSnapshotSchema = SessionSnapshotObjectSchema.readonly();
+var LegacySessionSnapshotSchema = SessionSnapshotObjectSchema.omit({ protocol: true, version: true }).extend({ version: import_zod3.z.literal(0) });
+var decodeSessionSnapshot = (input) => {
+  let candidate = input;
+  if (typeof input === "string") {
+    try {
+      candidate = JSON.parse(input);
+    } catch {
+      return { ok: false, diagnostic: { code: "SESSION_INVALID_SNAPSHOT", message: "Session snapshot is not valid JSON.", retryable: false } };
+    }
+  }
+  try {
+    if (isRecord(candidate) && typeof candidate.version === "number" && candidate.version !== 0 && candidate.version !== SESSION_PROTOCOL_VERSION) {
+      return { ok: false, diagnostic: { code: "SESSION_UNSUPPORTED_VERSION", message: "Session snapshot uses an unsupported version.", retryable: false } };
+    }
+    const current = SessionSnapshotSchema.safeParse(candidate);
+    if (current.success) return { ok: true, snapshot: current.data };
+    const legacy = LegacySessionSnapshotSchema.safeParse(candidate);
+    return legacy.success ? { ok: true, snapshot: SessionSnapshotSchema.parse({ ...legacy.data, protocol: SESSION_PROTOCOL, version: SESSION_PROTOCOL_VERSION }) } : { ok: false, diagnostic: { code: "SESSION_INVALID_SNAPSHOT", message: "Session snapshot payload is invalid.", retryable: false } };
+  } catch {
+    return { ok: false, diagnostic: { code: "SESSION_INVALID_SNAPSHOT", message: "Session snapshot payload is invalid.", retryable: false } };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ANSWER_MAX_CITATIONS,
+  ANSWER_MAX_SUGGESTIONS,
+  ANSWER_PROTOCOL,
+  ANSWER_PROTOCOL_VERSION,
+  ASK_EVENT_MAX_BYTES,
+  ASK_EVENT_MAX_RECORDS,
+  ASK_SERVICE_PROTOCOL_VERSION,
+  ASSISTANT_CONTENT_MAX_BYTES,
+  ASSISTANT_CONTENT_MAX_RECORDS,
+  ASSISTANT_CONTENT_PREFIX,
+  ASSISTANT_CONTENT_PROTOCOL,
+  ASSISTANT_CONTENT_PROTOCOL_VERSION,
+  AnswerCitationSchema,
+  AnswerConfidenceSchema,
+  AnswerResponseSchema,
+  AnswerSuggestionSchema,
+  AskEventSchema,
+  AssistantComponentPartSchema,
+  AssistantContentPartSchema,
+  AssistantTextPartSchema,
+  COMPONENT_PROTOCOL,
+  COMPONENT_PROTOCOL_VERSION,
+  ComponentFallbackSchema,
+  ComponentInteractionEventSchema,
+  ComponentKeySchema,
+  ComponentRenderFrameSchema,
+  ComponentSelectionEventSchema,
+  DETERMINISTIC_ARTIFACT_MAX_BYTES,
+  DETERMINISTIC_ARTIFACT_MAX_ENTRIES,
+  DETERMINISTIC_KNOWLEDGE_PROTOCOL,
+  DETERMINISTIC_KNOWLEDGE_PROTOCOL_VERSION,
+  DETERMINISTIC_MATCH_MAX_VALUES,
+  DETERMINISTIC_QUERY_MAX_CHARS,
+  DETERMINISTIC_SITE_PROTOCOL,
+  DETERMINISTIC_SITE_PROTOCOL_VERSION,
+  DeterministicKnowledgeEntrySchema,
+  DeterministicSiteConfigSchema,
+  LocalKnowledgeArtifactSchema,
+  SESSION_PROTOCOL,
+  SESSION_PROTOCOL_VERSION,
+  SessionConfirmationSchema,
+  SessionSnapshotSchema,
+  TURN_PROTOCOL,
+  TURN_PROTOCOL_VERSION,
+  TokenUsageSchema,
+  TurnDiagnosticSchema,
+  TurnEventSchema,
+  canonicalizeLocalKnowledgeArtifact,
+  computeLocalKnowledgeArtifactContentHash,
+  createAssistantContentEncoder,
+  createInteractionEvent,
+  createSelectionEvent,
+  createSnapshotEvent,
+  createTurnSnapshotCursor,
+  decodeAnswerResponse,
+  decodeAskEvents,
+  decodeAssistantContent,
+  decodeComponentFrame,
+  decodeDeterministicSiteConfig,
+  decodeLocalKnowledgeArtifact,
+  decodeSessionSnapshot,
+  decodeTurnEvent,
+  encodeTurnEvent,
+  isAssistantContentCandidate,
+  isComponentFrameCandidate,
+  normalizeKnowledgeKey,
+  snapshotMessages,
+  verifyLocalKnowledgeArtifact,
+  verifyLocalKnowledgeArtifactSync
+});