@agentskit/chat 0.1.0

package/dist/index.js

@@ -0,0 +1,1614 @@
+// src/index.ts
+import { ConfigError, ErrorCodes } from "@agentskit/core";
+import { createStatechartInstance, defineStatechart, StatechartError, transitionStatechart } from "@agentskit/statechart";
+import {
+  ComponentFallbackSchema,
+  ComponentKeySchema,
+  createInteractionEvent,
+  createSelectionEvent,
+  decodeComponentFrame as decodeComponentFrame2,
+  decodeSessionSnapshot,
+  SESSION_PROTOCOL,
+  SESSION_PROTOCOL_VERSION,
+  SessionSnapshotSchema
+} from "@agentskit/chat-protocol";
+import { z as z2 } from "zod";
+
+// src/catalog.ts
+import { z } from "zod";
+var CHOICE_LIST_COMPONENT_KEY = "choice-list";
+var IdSchema = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var TextSchema = z.string().min(1).max(4096);
+var LabelSchema = z.string().min(1).max(256);
+var JsonRecordSchema = z.record(z.string().max(128), z.json());
+var isPortableUrl = (value) => {
+  if (/[\u0000-\u001F\u007F\\]/u.test(value)) return false;
+  if (/^\/(?!\/)/.test(value)) return true;
+  try {
+    const url = new URL(value);
+    return ["http:", "https:"].includes(url.protocol) && url.username === "" && url.password === "";
+  } catch {
+    return false;
+  }
+};
+var PortableUrlSchema = z.string().max(2048).refine(isPortableUrl, "URL must be relative or use HTTP(S).");
+var ActionSchema = z.object({ name: IdSchema, input: JsonRecordSchema }).strict().readonly();
+var OptionSchema = z.object({ id: IdSchema, label: LabelSchema }).strict().readonly();
+var itemIdsUnique = (items, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  items.forEach((item, index) => {
+    if (ids.has(item.id)) context.addIssue({ code: "custom", path: [index, "id"], message: "Item ids must be unique." });
+    ids.add(item.id);
+  });
+};
+var ChoiceListPropsSchema = z.object({
+  prompt: TextSchema,
+  choices: z.array(z.object({ id: IdSchema, label: LabelSchema, description: TextSchema.optional(), action: ActionSchema.optional() }).strict().readonly()).min(1).max(20).superRefine(itemIdsUnique)
+}).strict().readonly();
+var ButtonGroupPropsSchema = z.object({
+  label: LabelSchema,
+  buttons: z.array(z.object({ id: IdSchema, label: LabelSchema, disabled: z.boolean().optional(), variant: z.enum(["primary", "secondary", "danger"]).optional() }).strict().readonly()).min(1).max(12).superRefine(itemIdsUnique)
+}).strict().readonly();
+var FormFieldSchema = z.object({
+  id: IdSchema,
+  label: LabelSchema,
+  type: z.enum(["text", "email", "number", "checkbox", "select"]),
+  required: z.boolean().optional(),
+  placeholder: z.string().max(256).optional(),
+  options: z.array(OptionSchema).min(1).max(50).optional()
+}).strict().readonly().superRefine((field, context) => {
+  if (field.type === "select" && field.options === void 0) context.addIssue({ code: "custom", path: ["options"], message: "Select fields require options." });
+  if (field.type !== "select" && field.options !== void 0) context.addIssue({ code: "custom", path: ["options"], message: "Only select fields accept options." });
+});
+var FormPropsSchema = z.object({ title: LabelSchema.optional(), fields: z.array(FormFieldSchema).min(1).max(30).superRefine(itemIdsUnique), submitLabel: LabelSchema }).strict().readonly();
+var ConfirmationPropsSchema = z.object({ title: LabelSchema, message: TextSchema, confirmLabel: LabelSchema, cancelLabel: LabelSchema }).strict().readonly();
+var ProgressPropsSchema = z.object({ label: LabelSchema, value: z.number().finite().min(0).max(100), status: TextSchema.optional() }).strict().readonly();
+var SourceListPropsSchema = z.object({ label: LabelSchema, sources: z.array(z.object({ id: IdSchema, title: LabelSchema, url: PortableUrlSchema.optional(), snippet: TextSchema.optional() }).strict().readonly()).min(1).max(50).superRefine(itemIdsUnique) }).strict().readonly();
+var LinkCardPropsSchema = z.object({ title: LabelSchema, description: TextSchema.optional(), href: PortableUrlSchema, label: LabelSchema.optional() }).strict().readonly();
+var ErrorNoticePropsSchema = z.object({ title: LabelSchema, message: TextSchema, code: z.string().max(128).optional(), retryLabel: LabelSchema.optional() }).strict().readonly();
+var ToolCallPropsSchema = z.object({ name: LabelSchema, status: z.enum(["pending", "running", "complete", "error"]), arguments: JsonRecordSchema.optional(), result: z.json().optional() }).strict().readonly();
+var ApprovalRequestPropsSchema = z.object({ title: LabelSchema, description: TextSchema, approveLabel: LabelSchema, denyLabel: LabelSchema }).strict().readonly();
+var TableCellSchema = z.union([z.string().max(4096), z.number().finite(), z.boolean(), z.null()]);
+var TablePropsSchema = z.object({ caption: LabelSchema, columns: z.array(z.object({ key: IdSchema, label: LabelSchema }).strict().readonly()).min(1).max(30).superRefine((columns, context) => itemIdsUnique(columns.map((column) => ({ id: column.key })), context)), rows: z.array(z.record(z.string(), TableCellSchema)).max(1e3) }).strict().readonly();
+var FileAttachmentPropsSchema = z.object({ name: LabelSchema, mimeType: z.string().min(1).max(256), sizeBytes: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(), url: PortableUrlSchema.optional() }).strict().readonly();
+var define = (definition) => Object.freeze({
+  ...definition,
+  events: Object.freeze((definition.events ?? []).map((event) => Object.freeze({ ...event }))),
+  capabilities: Object.freeze([...definition.capabilities ?? []]),
+  ...definition.accessibility === void 0 ? {} : { accessibility: Object.freeze({ ...definition.accessibility }) }
+});
+var display = (role, live = "none") => ({ role, keyboard: false, live });
+var interactive = (role) => ({ role, keyboard: true, live: "none" });
+var ChoiceListComponent = define({ key: CHOICE_LIST_COMPONENT_KEY, propsSchema: ChoiceListPropsSchema, events: [{ name: "select", value: "id" }], accessibility: interactive("group"), capabilities: ["display", "selection"], fallback: (props) => `${props.prompt} ${props.choices.map((choice) => choice.label).join(", ")}.` });
+var ButtonGroupComponent = define({ key: "button-group", propsSchema: ButtonGroupPropsSchema, events: [{ name: "select", value: "id" }], accessibility: interactive("group"), capabilities: ["display", "selection"], fallback: (props) => `${props.label}: ${props.buttons.map((button) => button.label).join(", ")}.` });
+var FormComponent = define({ key: "form", propsSchema: FormPropsSchema, events: [{ name: "submit", value: "form" }], accessibility: interactive("form"), capabilities: ["display", "input"], fallback: (props) => `${props.title ?? "Form"}: ${props.fields.map((field) => field.label).join(", ")}.` });
+var ConfirmationComponent = define({ key: "confirmation", propsSchema: ConfirmationPropsSchema, events: [{ name: "confirm", value: "none" }, { name: "cancel", value: "none" }], accessibility: interactive("group"), capabilities: ["display", "action"], fallback: (props) => `${props.title}: ${props.message}` });
+var ProgressComponent = define({ key: "progress", propsSchema: ProgressPropsSchema, events: [], accessibility: display("progressbar", "polite"), capabilities: ["display", "progress"], fallback: (props) => `${props.label}: ${props.value}%.` });
+var SourceListComponent = define({ key: "source-list", propsSchema: SourceListPropsSchema, events: [{ name: "open", value: "id" }], accessibility: interactive("list"), capabilities: ["display", "navigation"], fallback: (props) => `${props.label}: ${props.sources.map((source) => source.title).join(", ")}.` });
+var LinkCardComponent = define({ key: "link-card", propsSchema: LinkCardPropsSchema, events: [{ name: "open", value: "url" }], accessibility: interactive("link"), capabilities: ["display", "navigation"], fallback: (props) => `${props.title}: ${props.description ?? props.href}` });
+var ErrorNoticeComponent = define({ key: "error-notice", propsSchema: ErrorNoticePropsSchema, events: [{ name: "retry", value: "none" }], accessibility: interactive("alert"), capabilities: ["display", "action"], fallback: (props) => `${props.title}: ${props.message}` });
+var ToolCallComponent = define({ key: "tool-call", propsSchema: ToolCallPropsSchema, events: [], accessibility: display("status", "polite"), capabilities: ["display"], fallback: (props) => `${props.name}: ${props.status}.` });
+var ApprovalRequestComponent = define({ key: "approval-request", propsSchema: ApprovalRequestPropsSchema, events: [{ name: "approve", value: "none" }, { name: "deny", value: "none" }], accessibility: interactive("group"), capabilities: ["display", "action"], fallback: (props) => `${props.title}: ${props.description}` });
+var TableComponent = define({ key: "table", propsSchema: TablePropsSchema, events: [], accessibility: display("table"), capabilities: ["display"], fallback: (props) => `${props.caption}: ${props.rows.length} rows.` });
+var FileAttachmentComponent = define({ key: "file-attachment", propsSchema: FileAttachmentPropsSchema, events: [{ name: "open", value: "url" }], accessibility: interactive("link"), capabilities: ["display", "download"], fallback: (props) => `${props.name} (${props.mimeType}).` });
+var StandardComponentCatalog = Object.freeze([
+  ButtonGroupComponent,
+  ChoiceListComponent,
+  FormComponent,
+  ConfirmationComponent,
+  ProgressComponent,
+  SourceListComponent,
+  LinkCardComponent,
+  ErrorNoticeComponent,
+  ToolCallComponent,
+  ApprovalRequestComponent,
+  TableComponent,
+  FileAttachmentComponent
+]);
+var STANDARD_COMPONENT_KEYS = Object.freeze(StandardComponentCatalog.map((component) => component.key));
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var validateStandardComponentInteraction = (componentKey, props, event, value) => {
+  switch (componentKey) {
+    case "button-group": {
+      const parsed = ButtonGroupPropsSchema.safeParse(props);
+      return parsed.success && event === "select" && typeof value === "string" && parsed.data.buttons.some((button) => button.id === value && button.disabled !== true);
+    }
+    case "form": {
+      const parsed = FormPropsSchema.safeParse(props);
+      if (!parsed.success || event !== "submit" || !isRecord(value)) return false;
+      if (Object.keys(value).some((key) => !parsed.data.fields.some((field) => field.id === key))) return false;
+      return parsed.data.fields.every((field) => {
+        const fieldValue = value[field.id];
+        if (fieldValue === void 0 || fieldValue === "") return field.required !== true;
+        if (field.type === "checkbox") return typeof fieldValue === "boolean";
+        if (field.type === "number") return typeof fieldValue === "number" && Number.isFinite(fieldValue) || typeof fieldValue === "string" && fieldValue.trim() !== "" && Number.isFinite(Number(fieldValue));
+        if (field.type === "select") return typeof fieldValue === "string" && field.options?.some((option) => option.id === fieldValue) === true;
+        return typeof fieldValue === "string";
+      });
+    }
+    case "confirmation":
+      return (event === "confirm" || event === "cancel") && value === void 0;
+    case "source-list": {
+      const parsed = SourceListPropsSchema.safeParse(props);
+      return parsed.success && event === "open" && typeof value === "string" && parsed.data.sources.some((source) => source.id === value && source.url !== void 0);
+    }
+    case "link-card": {
+      const parsed = LinkCardPropsSchema.safeParse(props);
+      return parsed.success && event === "open" && value === parsed.data.href;
+    }
+    case "error-notice": {
+      const parsed = ErrorNoticePropsSchema.safeParse(props);
+      return parsed.success && event === "retry" && parsed.data.retryLabel !== void 0 && value === void 0;
+    }
+    case "approval-request":
+      return (event === "approve" || event === "deny") && value === void 0;
+    case "file-attachment": {
+      const parsed = FileAttachmentPropsSchema.safeParse(props);
+      return parsed.success && event === "open" && parsed.data.url !== void 0 && value === parsed.data.url;
+    }
+    default:
+      return false;
+  }
+};
+
+// src/ask.ts
+import { createWebStorageMemory } from "@agentskit/memory/web-storage";
+import {
+  ASK_EVENT_MAX_BYTES,
+  ASSISTANT_CONTENT_MAX_BYTES,
+  ASSISTANT_CONTENT_MAX_RECORDS,
+  ComponentRenderFrameSchema,
+  createAssistantContentEncoder,
+  decodeAskEvents,
+  decodeAssistantContent
+} from "@agentskit/chat-protocol";
+import { AskEventSchema as AskEventSchema2, decodeAskEvents as decodeAskEvents2 } from "@agentskit/chat-protocol";
+var MAX_TEXT_CHARS = 16384;
+var DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
+var DEFAULT_ENDPOINT = "https://ask.agentskit.io/v1/ask";
+var safeId = (value, fallback) => {
+  const normalized = value.replace(/[^A-Za-z0-9._:-]/g, "-").slice(0, 128);
+  return /^[A-Za-z0-9]/.test(normalized) ? normalized : fallback;
+};
+var safeHref = (path, anchor) => {
+  const fragment = anchor?.replace(/^#/, "");
+  const hasScheme = /^[A-Za-z][A-Za-z0-9+.-]*:/.test(path);
+  if (!hasScheme && !path.startsWith("//")) {
+    const url = new URL(path.startsWith("/") ? path : `/${path}`, "https://agentskit.invalid");
+    if (url.origin !== "https://agentskit.invalid") return void 0;
+    if (fragment !== void 0) url.hash = fragment;
+    const href = `${url.pathname}${url.search}${url.hash}`;
+    return href.length <= 2048 ? href : void 0;
+  }
+  try {
+    const url = new URL(path);
+    if (!["http:", "https:"].includes(url.protocol) || url.username !== "" || url.password !== "") return void 0;
+    if (fragment !== void 0) url.hash = fragment;
+    const href = url.toString();
+    return href.length <= 2048 ? href : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var sourceListFrame = (event) => {
+  if (!Array.isArray(event.args.sources)) return void 0;
+  const sources = event.args.sources.flatMap((candidate, index) => {
+    if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) return [];
+    const source = candidate;
+    if (typeof source.title !== "string" || source.title.trim() === "" || typeof source.path !== "string") return [];
+    const url = safeHref(source.path, typeof source.anchor === "string" ? source.anchor : void 0);
+    return url === void 0 ? [] : [{ id: `source-${index + 1}`, title: source.title.slice(0, 256), url }];
+  }).slice(0, 50);
+  if (sources.length === 0) return void 0;
+  return ComponentRenderFrameSchema.parse({
+    protocol: "agentskit.chat.component",
+    version: 1,
+    type: "render",
+    componentKey: "source-list",
+    instanceId: safeId(event.id, "sources"),
+    props: { label: "Sources", sources },
+    fallback: {
+      kind: "source-list",
+      summary: `Sources: ${sources.map((source) => source.title).join(", ")}.`.slice(0, 4096)
+    }
+  });
+};
+function projectAskEvent(event, projectTool) {
+  if (event.type === "text") return event.delta === "" ? void 0 : { kind: "text", text: event.delta };
+  if (event.type === "error") return { kind: "error", message: event.message };
+  if (event.type === "done") return { kind: "done" };
+  if (event.name === "answer" && typeof event.args.markdown === "string") {
+    return event.args.markdown === "" ? void 0 : { kind: "text", text: event.args.markdown };
+  }
+  if (event.name === "cite") {
+    const frame = sourceListFrame(event);
+    return frame === void 0 ? void 0 : { kind: "component", frame };
+  }
+  try {
+    const custom = projectTool?.(event);
+    const parsed = ComponentRenderFrameSchema.safeParse(custom);
+    return parsed.success ? { kind: "component", frame: parsed.data } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function projectAskMessages(messages) {
+  const projected = [];
+  for (const message of messages) {
+    if (message.role !== "user" && message.role !== "assistant") continue;
+    if (message.role === "user") {
+      projected.push({ role: message.role, content: message.content });
+      continue;
+    }
+    const decoded = decodeAssistantContent(message.content);
+    const content = decoded.ok ? decoded.parts.map((part) => part.kind === "text" ? part.text : `[${part.frame.componentKey}]`).join("\n").trim() : message.content;
+    projected.push({ role: message.role, content });
+  }
+  return projected;
+}
+var endpointWithParams = ({ endpoint = DEFAULT_ENDPOINT, corpus, persona }) => {
+  const relative = endpoint.startsWith("/");
+  const origin = typeof globalThis.location === "undefined" ? "http://localhost" : globalThis.location.origin;
+  const url = new URL(endpoint, origin);
+  if (corpus?.trim()) url.searchParams.set("corpus", corpus);
+  if (persona?.trim()) url.searchParams.set("persona", persona);
+  return relative ? `${url.pathname}${url.search}${url.hash}` : url.toString();
+};
+var createBoundedAssistantEncoder = () => {
+  const encoder = createAssistantContentEncoder();
+  let bytes = 0;
+  let records = 0;
+  return (part) => {
+    if (records >= ASSISTANT_CONTENT_MAX_RECORDS) throw new Error("Ask response exceeded the assistant content record limit.");
+    const encoded = encoder.encode(part);
+    const nextBytes = bytes + new TextEncoder().encode(encoded).byteLength;
+    if (nextBytes > ASSISTANT_CONTENT_MAX_BYTES) throw new Error("Ask response exceeded the assistant content byte limit.");
+    bytes = nextBytes;
+    records += 1;
+    return encoded;
+  };
+};
+var encodeText = function* (encode, text) {
+  for (let offset = 0; offset < text.length; offset += MAX_TEXT_CHARS) {
+    yield { type: "text", content: encode({ kind: "text", text: text.slice(offset, offset + MAX_TEXT_CHARS) }) };
+  }
+};
+function createAskAdapter(options = {}) {
+  return {
+    capabilities: { streaming: true, structuredOutput: true },
+    createSource(request) {
+      const controller = new AbortController();
+      return {
+        abort: () => controller.abort(),
+        async *stream() {
+          const encode = createBoundedAssistantEncoder();
+          try {
+            const connection = new AbortController();
+            const timeout = setTimeout(() => connection.abort(), DEFAULT_CONNECTION_TIMEOUT_MS);
+            let response;
+            try {
+              response = await fetch(endpointWithParams(options), {
+                method: "POST",
+                signal: AbortSignal.any([controller.signal, connection.signal]),
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ messages: projectAskMessages(request.messages) })
+              });
+            } finally {
+              clearTimeout(timeout);
+            }
+            if (!response.ok || response.body === null) throw new Error(`Ask request failed (${response.status}).`);
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+            let mode = contentType.includes("text/plain") ? "text" : contentType.includes("ndjson") ? "ndjson" : "unknown";
+            let discardingOversizedLine = false;
+            while (true) {
+              const result = await reader.read();
+              let incoming = decoder.decode(result.value, { stream: !result.done });
+              if (discardingOversizedLine) {
+                const lineEnd = incoming.indexOf("\n");
+                if (lineEnd < 0) {
+                  if (result.done) break;
+                  continue;
+                }
+                incoming = incoming.slice(lineEnd + 1);
+                discardingOversizedLine = false;
+              }
+              buffer += incoming;
+              if (mode === "unknown" && buffer.trimStart() !== "") {
+                if (!buffer.trimStart().startsWith("{")) mode = "text";
+                else {
+                  const lineEnd = buffer.indexOf("\n");
+                  if (lineEnd >= 0 || result.done) {
+                    const firstLine = lineEnd >= 0 ? buffer.slice(0, lineEnd + 1) : `${buffer}
+`;
+                    mode = decodeAskEvents(firstLine).events.length > 0 ? "ndjson" : "text";
+                  } else if (new TextEncoder().encode(buffer).byteLength > ASK_EVENT_MAX_BYTES) {
+                    buffer = "";
+                    discardingOversizedLine = true;
+                  }
+                }
+              }
+              if (mode === "unknown" && !result.done) continue;
+              if (mode === "text") {
+                yield* encodeText(encode, buffer);
+                buffer = "";
+                if (result.done) break;
+                continue;
+              }
+              const decoded = decodeAskEvents(result.done ? `${buffer}
+` : buffer);
+              buffer = decoded.rest;
+              discardingOversizedLine = decoded.discardedPartial;
+              for (const event of decoded.events) {
+                const projected = projectAskEvent(event, options.projectTool);
+                if (projected?.kind === "error") {
+                  void reader.cancel().catch(() => void 0);
+                  yield { type: "error", content: projected.message };
+                  return;
+                }
+                if (projected?.kind === "done") {
+                  void reader.cancel().catch(() => void 0);
+                  yield { type: "done" };
+                  return;
+                }
+                if (projected?.kind === "text") yield* encodeText(encode, projected.text);
+                if (projected?.kind === "component") {
+                  yield { type: "text", content: encode({ kind: "component", frame: projected.frame }) };
+                }
+              }
+              if (result.done) break;
+            }
+            yield { type: "done" };
+          } catch (cause) {
+            if (!controller.signal.aborted) {
+              yield { type: "error", content: cause instanceof Error ? cause.message : "Ask request failed." };
+            }
+          }
+        }
+      };
+    }
+  };
+}
+var legacyContent = (record, projectTool) => {
+  const direct = typeof record.content === "string" ? record.content : typeof record.text === "string" ? record.text : void 0;
+  if (direct !== void 0) return direct;
+  if (record.role !== "assistant" || !Array.isArray(record.parts)) return void 0;
+  const encode = createBoundedAssistantEncoder();
+  const encoded = [];
+  for (const candidate of record.parts) {
+    if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) continue;
+    const part = candidate;
+    let projected;
+    if (part.kind === "text" && typeof part.text === "string") {
+      if (part.text === "") continue;
+      for (let offset = 0; offset < part.text.length; offset += MAX_TEXT_CHARS) {
+        try {
+          encoded.push(encode({ kind: "text", text: part.text.slice(offset, offset + MAX_TEXT_CHARS) }));
+        } catch {
+          return encoded.join("");
+        }
+      }
+      continue;
+    } else if (part.kind === "tool" && typeof part.id === "string" && typeof part.name === "string" && typeof part.args === "object" && part.args !== null && !Array.isArray(part.args)) {
+      const result = projectAskEvent({ type: "tool", id: part.id, name: part.name, args: part.args }, projectTool);
+      if (result?.kind === "text") {
+        for (let offset = 0; offset < result.text.length; offset += MAX_TEXT_CHARS) {
+          try {
+            encoded.push(encode({ kind: "text", text: result.text.slice(offset, offset + MAX_TEXT_CHARS) }));
+          } catch {
+            return encoded.length > 0 ? encoded.join("") : void 0;
+          }
+        }
+        continue;
+      }
+      if (result?.kind === "component") projected = { kind: "component", frame: result.frame };
+    } else continue;
+    if (projected !== void 0) {
+      try {
+        encoded.push(encode(projected));
+      } catch {
+        return encoded.length > 0 ? encoded.join("") : void 0;
+      }
+    }
+  }
+  return encoded.length > 0 || record.parts.length === 0 ? encoded.join("") : void 0;
+};
+var migrateLegacyMessages = (value, projectTool) => {
+  if (!Array.isArray(value)) return void 0;
+  const messages = [];
+  for (const [index, candidate] of value.entries()) {
+    if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) continue;
+    const record = candidate;
+    if (record.role !== "user" && record.role !== "assistant") continue;
+    const content = legacyContent(record, projectTool);
+    if (content === void 0) continue;
+    messages.push({
+      id: safeId(typeof record.id === "string" ? record.id : "", `legacy-${index + 1}`),
+      role: record.role,
+      content,
+      status: "complete",
+      createdAt: new Date(index)
+    });
+  }
+  return messages.length > 0 || value.length === 0 ? messages : void 0;
+};
+function createAskSessionMemory({
+  key,
+  legacyKeys = [],
+  maxMessages = 20,
+  maxRecordBytes = ASK_EVENT_MAX_BYTES,
+  getStorage = () => {
+    try {
+      return typeof globalThis.sessionStorage === "undefined" ? void 0 : globalThis.sessionStorage;
+    } catch {
+      return void 0;
+    }
+  },
+  projectTool
+}) {
+  return createWebStorageMemory({
+    key,
+    getStorage,
+    maxMessages,
+    maxRecordBytes,
+    migration: {
+      keys: legacyKeys,
+      read: (value) => migrateLegacyMessages(value, projectTool)
+    }
+  });
+}
+
+// src/deterministic.ts
+import {
+  ANSWER_PROTOCOL,
+  ANSWER_PROTOCOL_VERSION,
+  AnswerCitationSchema,
+  AnswerResponseSchema,
+  COMPONENT_PROTOCOL,
+  COMPONENT_PROTOCOL_VERSION,
+  createAssistantContentEncoder as createAssistantContentEncoder2,
+  decodeAssistantContent as decodeAssistantContent2,
+  isAssistantContentCandidate,
+  verifyLocalKnowledgeArtifactSync,
+  normalizeKnowledgeKey
+} from "@agentskit/chat-protocol";
+var normalizeDeterministicQuery = normalizeKnowledgeKey;
+var baseResponse = (query) => ({
+  protocol: ANSWER_PROTOCOL,
+  version: ANSWER_PROTOCOL_VERSION,
+  query: query.slice(0, 512),
+  normalizedQuery: normalizeDeterministicQuery(query.slice(0, 512)).slice(0, 512)
+});
+var escalation = (query, reason, message) => AnswerResponseSchema.parse({
+  ...baseResponse(query),
+  outcome: "escalation",
+  message,
+  reason,
+  confidence: { level: "low", basis: reason }
+});
+var createDeterministicAnswerResolver = (artifactInput, options) => {
+  const verified = verifyLocalKnowledgeArtifactSync(artifactInput, options);
+  if (!verified.ok) return Object.freeze({
+    resolve: (query) => escalation(query, "corrupt", "Local knowledge is corrupt. A backend answer is required."),
+    resolveChoice: (_choiceId, query) => escalation(query, "corrupt", "Local knowledge is corrupt. A backend answer is required.")
+  });
+  const artifact = verified.value;
+  const index = /* @__PURE__ */ new Map();
+  const entriesById = new Map(artifact.entries.map((entry) => [entry.id, entry]));
+  for (const entry of artifact.entries) {
+    for (const value of entry.match.values) {
+      const key = normalizeDeterministicQuery(value);
+      const entries = index.get(key) ?? [];
+      if (!entries.some((candidate) => candidate.id === entry.id)) entries.push(entry);
+      index.set(key, entries);
+    }
+  }
+  const now = options.now ?? Date.now;
+  const isStale = () => artifact.expiresAt !== void 0 && Date.parse(artifact.expiresAt) <= now();
+  const answerForEntry = (entry, query) => AnswerResponseSchema.parse({
+    ...baseResponse(query),
+    outcome: "answer",
+    answer: entry.answer,
+    provenance: { source: "local", artifactId: artifact.artifactId, contentHash: artifact.contentHash, entryIds: [entry.id] },
+    confidence: { level: "high", basis: "exact" }
+  });
+  const uniqueValue = (entry) => entry.match.values.find((value) => (index.get(normalizeDeterministicQuery(value))?.length ?? 0) === 1) ?? entry.match.values[0] ?? entry.id;
+  return Object.freeze({
+    resolve(query) {
+      if (isStale()) {
+        return escalation(query, "stale", "Local knowledge is stale. A backend answer is required.");
+      }
+      if (query.length > 512) {
+        return escalation(query, "miss", "No exact local answer was found. A backend answer is required.");
+      }
+      const normalizedQuery = normalizeDeterministicQuery(query);
+      if (normalizedQuery.length > 512) return escalation(query, "miss", "No exact local answer was found. A backend answer is required.");
+      const base = { ...baseResponse(query), normalizedQuery };
+      const entries = index.get(base.normalizedQuery) ?? [];
+      if (entries.length === 0) return escalation(query, "miss", "No exact local answer was found. A backend answer is required.");
+      if (entries.length > 1) {
+        return AnswerResponseSchema.parse({
+          ...base,
+          outcome: "choices",
+          message: "More than one exact local answer matches. Choose one to continue.",
+          suggestions: entries.slice(0, 8).map((entry2) => ({ id: entry2.id, label: entry2.label, value: uniqueValue(entry2) })),
+          provenance: { source: "local", artifactId: artifact.artifactId, contentHash: artifact.contentHash, entryIds: entries.slice(0, 8).map((entry2) => entry2.id) },
+          confidence: { level: "medium", basis: "ambiguous" }
+        });
+      }
+      const entry = entries[0];
+      if (entry === void 0) return escalation(query, "miss", "No exact local answer was found. A backend answer is required.");
+      return answerForEntry(entry, query);
+    },
+    resolveChoice(choiceId, query) {
+      if (isStale()) return escalation(query, "stale", "Local knowledge is stale. A backend answer is required.");
+      if (query.length > 512) return escalation(query, "miss", "The selected local answer is unavailable. A backend answer is required.");
+      const normalizedQuery = normalizeDeterministicQuery(query);
+      const candidates = normalizedQuery.length <= 512 ? (index.get(normalizedQuery) ?? []).slice(0, 8) : [];
+      const entry = candidates.some((candidate) => candidate.id === choiceId) ? entriesById.get(choiceId) : void 0;
+      return entry === void 0 ? escalation(query, "miss", "The selected local answer is unavailable. A backend answer is required.") : answerForEntry(entry, query);
+    }
+  });
+};
+var latestUserInput = (request) => {
+  const message = request.messages.filter((candidate) => candidate.role === "user").at(-1);
+  return { content: message?.content ?? "", messageId: message?.id ?? "deterministic" };
+};
+var safeInstanceId = (value, fallback) => {
+  const normalized = value.replace(/[^A-Za-z0-9._:-]/g, "-").slice(0, 128);
+  return /^[A-Za-z0-9]/.test(normalized) ? normalized : fallback;
+};
+var projectDecision = (decision, messageId, rememberChoices) => {
+  const encoder = createAssistantContentEncoder2();
+  const content = [];
+  if (decision.outcome === "answer") {
+    content.push(encoder.encode({ kind: "text", text: decision.answer.markdown }));
+    if (decision.answer.citations.length > 0) {
+      const props = SourceListPropsSchema.parse({
+        label: "Sources",
+        sources: decision.answer.citations.map((citation) => ({ id: citation.id, title: citation.title, url: citation.href }))
+      });
+      content.push(encoder.encode({ kind: "component", frame: {
+        protocol: COMPONENT_PROTOCOL,
+        version: COMPONENT_PROTOCOL_VERSION,
+        type: "render",
+        componentKey: "source-list",
+        instanceId: safeInstanceId(`sources-${messageId}`, "deterministic-sources"),
+        props,
+        fallback: { kind: "source-list", summary: `Sources: ${props.sources.map((source) => source.title).join(", ")}.` }
+      } }));
+    }
+  } else if (decision.outcome === "choices") {
+    content.push(encoder.encode({ kind: "text", text: decision.message }));
+    const props = ChoiceListPropsSchema.parse({
+      prompt: decision.message,
+      choices: decision.suggestions.map((suggestion) => ({ id: suggestion.id, label: suggestion.label, description: suggestion.value }))
+    });
+    const frame = {
+      protocol: COMPONENT_PROTOCOL,
+      version: COMPONENT_PROTOCOL_VERSION,
+      type: "render",
+      componentKey: "choice-list",
+      instanceId: safeInstanceId(`deterministic-choices-${messageId}`, "deterministic-choices"),
+      props,
+      fallback: { kind: "choice-list", summary: `${decision.message} ${props.choices.map((choice) => choice.label).join(", ")}.` }
+    };
+    rememberChoices(frame, decision);
+    content.push(encoder.encode({ kind: "component", frame }));
+  } else {
+    content.push(encoder.encode({ kind: "text", text: decision.message }));
+  }
+  return content.join("");
+};
+var localSource = (decision, messageId, rememberChoices) => {
+  let aborted = false;
+  return {
+    async *stream() {
+      if (aborted) return;
+      yield { type: "text", content: projectDecision(decision, messageId, rememberChoices), metadata: { answer: decision } };
+      if (!aborted) yield { type: "done" };
+    },
+    abort() {
+      aborted = true;
+    }
+  };
+};
+var observe = (observer, decision) => {
+  try {
+    void Promise.resolve(observer?.(decision)).catch(() => void 0);
+  } catch {
+  }
+};
+var backendAnswer = (query, content, backend) => {
+  const decoded = decodeAssistantContent2(content);
+  if (!decoded.ok && isAssistantContentCandidate(content)) {
+    return escalation(query, "corrupt", "Backend answer contained invalid ordered content.");
+  }
+  if (decoded.ok && !decoded.complete) {
+    return escalation(query, "corrupt", "Backend answer ended with incomplete ordered content.");
+  }
+  const markdown = (decoded.ok ? decoded.parts.flatMap((part) => part.kind === "text" ? [part.text] : []).join("") : content).trim();
+  if (markdown === "") return void 0;
+  if (markdown.length > 16384) {
+    return escalation(query, "corrupt", "Backend answer exceeded the unified response limit.");
+  }
+  const citations = decoded.ok ? decoded.parts.flatMap((part) => {
+    if (part.kind !== "component" || part.frame.componentKey !== "source-list") return [];
+    const sources = SourceListPropsSchema.safeParse(part.frame.props);
+    if (!sources.success) return [];
+    return sources.data.sources.flatMap((source) => {
+      if (source.url === void 0) return [];
+      const citation = AnswerCitationSchema.safeParse({ id: source.id, title: source.title, href: source.url });
+      return citation.success ? [citation.data] : [];
+    });
+  }).slice(0, 8) : [];
+  return AnswerResponseSchema.parse({
+    ...baseResponse(query),
+    outcome: "answer",
+    answer: { markdown, citations },
+    provenance: { source: "backend", ...backend },
+    confidence: { level: "high", basis: "backend" }
+  });
+};
+var observeBackendSource = (source, query, backend, observer) => ({
+  abort: () => source.abort(),
+  async *stream() {
+    let content = "";
+    let overflowed = false;
+    let completed = false;
+    let failed = false;
+    const finalize = () => overflowed ? escalation(query, "corrupt", "Backend stream exceeded the observation limit.") : backendAnswer(query, content, backend);
+    for await (const chunk of source.stream()) {
+      if (chunk.type === "text") {
+        const incoming = chunk.content ?? "";
+        const remaining = 262144 - content.length;
+        if (incoming.length > remaining) overflowed = true;
+        if (remaining > 0) content += incoming.slice(0, remaining);
+      }
+      if (chunk.type === "error") failed = true;
+      if (chunk.type !== "done") {
+        yield chunk;
+        continue;
+      }
+      completed = true;
+      if (failed) {
+        yield chunk;
+        continue;
+      }
+      const answer = finalize();
+      if (answer === void 0) {
+        yield chunk;
+      } else {
+        observe(observer, answer);
+        yield { ...chunk, metadata: { ...chunk.metadata, answer } };
+      }
+    }
+    if (!completed && !failed) {
+      const answer = finalize();
+      if (answer !== void 0) {
+        observe(observer, answer);
+        yield { type: "done", metadata: { answer } };
+      }
+    }
+  }
+});
+var createDeterministicAnswerAdapter = (options) => {
+  const resolver = createDeterministicAnswerResolver(options.artifact, options);
+  const MAX_CHOICE_SESSIONS = 256;
+  const MAX_SESSION_CHOICES = 256;
+  const choices = /* @__PURE__ */ new Map();
+  const rememberChoices = (sessionId, frame, decision) => {
+    let sessionChoices = choices.get(sessionId);
+    if (sessionChoices === void 0) {
+      if (choices.size >= MAX_CHOICE_SESSIONS) {
+        const evictable = [...choices].find(
+          ([, authorizations]) => [...authorizations.values()].every((authorization) => !authorization.claimed)
+        )?.[0];
+        if (evictable === void 0) return;
+        choices.delete(evictable);
+      }
+      sessionChoices = /* @__PURE__ */ new Map();
+    } else {
+      choices.delete(sessionId);
+    }
+    const previous = sessionChoices.get(frame.instanceId);
+    if (previous?.claimed) {
+      choices.set(sessionId, sessionChoices);
+      return;
+    }
+    if (previous === void 0 && sessionChoices.size >= MAX_SESSION_CHOICES) {
+      const evictable = [...sessionChoices].find(([, authorization]) => !authorization.claimed)?.[0];
+      if (evictable === void 0) {
+        choices.set(sessionId, sessionChoices);
+        return;
+      }
+      sessionChoices.delete(evictable);
+    }
+    sessionChoices.set(frame.instanceId, {
+      props: JSON.stringify(frame.props),
+      values: new Map(decision.suggestions.map((suggestion) => [suggestion.id, suggestion.value])),
+      claimed: false
+    });
+    choices.set(sessionId, sessionChoices);
+  };
+  const createSourceForSession = (request, sessionId) => {
+    const rememberSessionChoices = (frame, decision2) => rememberChoices(sessionId, frame, decision2);
+    const user = latestUserInput(request);
+    const decision = resolver.resolve(user.content);
+    if (decision.outcome !== "escalation") {
+      observe(options.onDecision, decision);
+      return localSource(decision, user.messageId, rememberSessionChoices);
+    }
+    if (options.fallbackMode === "disabled" || options.fallback === void 0) {
+      const unavailable = decision.reason === "miss" ? escalation(decision.query, "offline", "This question needs the backend, which is not available.") : decision;
+      observe(options.onDecision, unavailable);
+      return localSource(unavailable, user.messageId, rememberSessionChoices);
+    }
+    observe(options.onDecision, decision);
+    const source = options.fallback.createSource({
+      ...request,
+      context: {
+        ...request.context,
+        metadata: { ...request.context?.metadata, "agentskit.chat.escalation": decision }
+      }
+    });
+    return observeBackendSource(source, decision.query, options.backend, options.onDecision);
+  };
+  return {
+    capabilities: options.fallbackMode === "backend" ? options.fallback?.capabilities ?? { streaming: true, structuredOutput: true } : { streaming: true, structuredOutput: true },
+    createSource: (request) => createSourceForSession(request, "unscoped"),
+    createSourceForSession,
+    releaseChoiceSession: (sessionId) => {
+      choices.delete(sessionId);
+    },
+    resolveChoiceSubmission(frame, choiceId, context) {
+      const unavailable = () => frame.instanceId.startsWith("deterministic-choices-") ? { unavailable: true } : void 0;
+      const sessionChoices = choices.get(context.sessionId);
+      if (sessionChoices === void 0) return unavailable();
+      const remembered = sessionChoices.get(frame.instanceId);
+      if (remembered === void 0 || remembered.claimed || remembered.props !== JSON.stringify(frame.props)) return unavailable();
+      const value = remembered.values.get(choiceId);
+      if (value === void 0) return unavailable();
+      choices.delete(context.sessionId);
+      choices.set(context.sessionId, sessionChoices);
+      remembered.claimed = true;
+      let settled = false;
+      return {
+        value,
+        commit() {
+          if (settled) return;
+          settled = true;
+          sessionChoices.delete(frame.instanceId);
+          if (sessionChoices.size === 0 && choices.get(context.sessionId) === sessionChoices) choices.delete(context.sessionId);
+        },
+        release() {
+          if (settled) return;
+          settled = true;
+          remembered.claimed = false;
+        }
+      };
+    }
+  };
+};
+
+// src/presentation.ts
+import {
+  decodeAssistantContent as decodeAssistantContent3,
+  decodeComponentFrame,
+  isAssistantContentCandidate as isAssistantContentCandidate2,
+  isComponentFrameCandidate
+} from "@agentskit/chat-protocol";
+var presentChatMessage = (message) => {
+  if (message.role === "assistant" && isAssistantContentCandidate2(message.content)) {
+    const decoded = decodeAssistantContent3(message.content);
+    if (!decoded.ok) return [{ kind: "diagnostic", code: decoded.diagnostic.code, message: decoded.diagnostic.message }];
+    const parts = [];
+    for (const part of decoded.parts) {
+      if (part.kind === "component") {
+        parts.push({ kind: "component", frame: part.frame });
+        continue;
+      }
+      const previous = parts.at(-1);
+      if (previous?.kind === "message") {
+        parts[parts.length - 1] = { kind: "message", message: { ...previous.message, content: previous.message.content + part.text } };
+      } else {
+        parts.push({ kind: "message", message: { ...message, content: part.text } });
+      }
+    }
+    return parts;
+  }
+  if (message.role === "assistant" && isComponentFrameCandidate(message.content)) {
+    const decoded = decodeComponentFrame(message.content);
+    return decoded.ok ? [{ kind: "component", frame: decoded.frame }] : [{ kind: "diagnostic", code: decoded.diagnostic.code, message: decoded.diagnostic.message }];
+  }
+  return [{ kind: "message", message }];
+};
+
+// src/index.ts
+var ThemeColorSchema = z2.string().regex(/^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, "Theme colors must use portable hex notation.");
+var ThemeLengthSchema = z2.number().finite().nonnegative().max(1e3);
+var ThemeFontFamilySchema = z2.string().regex(/^(?:system|[A-Za-z0-9][A-Za-z0-9 _-]{0,127})$/, "Theme fontFamily must be system or one portable family name.");
+var ChatThemeColorsSchema = z2.object({
+  background: ThemeColorSchema,
+  surface: ThemeColorSchema,
+  border: ThemeColorSchema,
+  text: ThemeColorSchema,
+  muted: ThemeColorSchema,
+  accent: ThemeColorSchema,
+  onAccent: ThemeColorSchema,
+  danger: ThemeColorSchema
+}).strict();
+var ChatThemeSpacingSchema = z2.object({ small: ThemeLengthSchema, medium: ThemeLengthSchema, large: ThemeLengthSchema }).strict();
+var ChatThemeRadiusSchema = z2.object({ medium: ThemeLengthSchema, large: ThemeLengthSchema }).strict();
+var ChatThemeSchema = z2.object({
+  colors: ChatThemeColorsSchema.readonly(),
+  spacing: ChatThemeSpacingSchema.readonly(),
+  radius: ChatThemeRadiusSchema.readonly(),
+  fontFamily: ThemeFontFamilySchema
+}).strict().readonly();
+var defaultChatTheme = ChatThemeSchema.parse({
+  colors: { background: "#ffffff", surface: "#f3f4f6", border: "#d1d5db", text: "#111827", muted: "#6b7280", accent: "#2563eb", onAccent: "#ffffff", danger: "#dc2626" },
+  spacing: { small: 8, medium: 12, large: 16 },
+  radius: { medium: 8, large: 12 },
+  fontFamily: "system"
+});
+var resolveChatTheme = (input = {}) => {
+  const candidate = z2.object({
+    colors: ChatThemeColorsSchema.partial().strict().optional(),
+    spacing: ChatThemeSpacingSchema.partial().strict().optional(),
+    radius: ChatThemeRadiusSchema.partial().strict().optional(),
+    fontFamily: ThemeFontFamilySchema.optional()
+  }).strict().parse(input);
+  return ChatThemeSchema.parse({
+    colors: { ...defaultChatTheme.colors, ...candidate.colors },
+    spacing: { ...defaultChatTheme.spacing, ...candidate.spacing },
+    radius: { ...defaultChatTheme.radius, ...candidate.radius },
+    fontFamily: candidate.fontFamily ?? defaultChatTheme.fontFamily
+  });
+};
+var getLifecycleTargets = (messages) => {
+  const assistant = messages.at(-1);
+  if (assistant?.role !== "assistant") return { userId: void 0, assistantId: void 0 };
+  const userId = messages.slice(0, -1).reverse().find((message) => message.role === "user")?.id;
+  return userId === void 0 ? { userId: void 0, assistantId: void 0 } : { userId, assistantId: assistant.id };
+};
+var createCapabilityPolicy = ({ sessionId, getContext, requirements, onTrace, now = Date.now }) => {
+  if (sessionId.length === 0) invalidConfirmation("Action policy session is invalid.");
+  const required = new Map(Object.entries(requirements).map(([action, capabilities]) => {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(action) || capabilities.some((capability) => !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(capability))) {
+      return invalidConfirmation("Action policy requirements are invalid.");
+    }
+    return [action, Object.freeze([...new Set(capabilities)])];
+  }));
+  const traces = [];
+  let sequence = 0;
+  const record = (call, phase, capabilities, reason) => {
+    const trace = Object.freeze({
+      id: `policy-${++sequence}`,
+      toolCallId: call.id,
+      action: call.name,
+      phase,
+      decision: reason === "allowed" ? "allow" : "deny",
+      reason,
+      requiredCapabilities: capabilities,
+      timestamp: now()
+    });
+    traces.push(trace);
+    try {
+      void Promise.resolve(onTrace?.(trace)).catch(() => void 0);
+    } catch {
+    }
+    return trace;
+  };
+  const decide = (call) => {
+    const capabilities = required.get(call.name);
+    let trusted;
+    try {
+      const candidate = getContext();
+      if (candidate !== void 0 && (typeof candidate.sessionId !== "string" || !Array.isArray(candidate.capabilities) || !candidate.capabilities.every((capability) => typeof capability === "string"))) throw new TypeError("Invalid trusted context");
+      trusted = candidate === void 0 ? void 0 : {
+        sessionId: candidate.sessionId,
+        capabilities: Object.freeze([...candidate.capabilities])
+      };
+    } catch {
+      return { capabilities: capabilities ?? Object.freeze([]), reason: "policy-failure" };
+    }
+    return {
+      capabilities: capabilities ?? Object.freeze([]),
+      reason: capabilities === void 0 ? "action-unregistered" : trusted === void 0 ? "missing-context" : trusted.sessionId !== sessionId ? "session-mismatch" : capabilities.some((capability) => !trusted.capabilities.includes(capability)) ? "missing-capability" : "allowed"
+    };
+  };
+  return {
+    async authorizeToolCall(call, context) {
+      const { capabilities, reason } = decide(call);
+      const trace = record(call, context.phase, capabilities, reason);
+      return { allowed: trace.decision === "allow", ...trace.decision === "deny" ? { reason: trace.reason } : {} };
+    },
+    compose: (authorizer) => async (call, context) => {
+      let local = decide(call);
+      let reason = local.reason;
+      if (reason === "allowed" && authorizer) {
+        try {
+          if (!(await authorizer(call, context)).allowed) reason = "composed-policy-denied";
+          else {
+            local = decide(call);
+            reason = local.reason;
+          }
+        } catch {
+          reason = "policy-failure";
+        }
+      }
+      const trace = record(call, context.phase, local.capabilities, reason);
+      return { allowed: trace.decision === "allow", ...trace.decision === "deny" ? { reason: trace.reason } : {} };
+    },
+    getTrace: () => Object.freeze([...traces])
+  };
+};
+var withActionPolicy = (chat, policy) => {
+  return {
+    ...chat,
+    authorizeToolCall: policy.compose(chat.authorizeToolCall)
+  };
+};
+var resolveChoiceAction = (frame, choiceId) => {
+  const props = ChoiceListPropsSchema.parse(frame.props);
+  return props.choices.find((choice) => choice.id === choiceId)?.action;
+};
+var invalidConfirmation = (message) => {
+  throw new ConfigError({
+    code: ErrorCodes.AK_CONFIG_INVALID,
+    message,
+    hint: "Use the pending confirmation token in the session that created it."
+  });
+};
+var freezeJson = (value) => {
+  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const child of Object.values(value)) freezeJson(child);
+    Object.freeze(value);
+  }
+  return value;
+};
+var createActionConfirmation = ({
+  sessionId,
+  chat,
+  ttlMs = 3e5,
+  now = Date.now,
+  createId,
+  initialRecords = [],
+  onChange,
+  claimStatus
+}) => {
+  if (sessionId.length === 0 || !Number.isSafeInteger(ttlMs) || ttlMs <= 0) invalidConfirmation("Action confirmation options are invalid.");
+  let sequence = 0;
+  const nextId = createId ?? (() => `${(++sequence).toString(36)}-${now().toString(36)}`);
+  const records = /* @__PURE__ */ new Map();
+  const tokensByCall = /* @__PURE__ */ new Map();
+  const operations = /* @__PURE__ */ new Map();
+  const snapshot = (record, status) => Object.freeze({ ...record, status });
+  const requireRecord = (token, requestedSession) => {
+    const record = records.get(token);
+    if (!record || record.sessionId !== requestedSession) return invalidConfirmation("Action confirmation token is invalid for this session.");
+    return record;
+  };
+  const runOnce = (token, operation) => {
+    const current = operations.get(token);
+    if (current) return current;
+    const pending = operation().finally(() => operations.delete(token));
+    operations.set(token, pending);
+    return pending;
+  };
+  const changed = async () => {
+    await onChange?.(Object.freeze([...records.values()]));
+  };
+  const claim = async (record, status) => {
+    const terminal = snapshot(record, status);
+    if (claimStatus && !await claimStatus(record, status)) invalidConfirmation("Action confirmation was already resolved by another client.");
+    records.set(record.token, terminal);
+    if (!claimStatus) await changed();
+    return terminal;
+  };
+  for (const persisted of initialRecords) {
+    const record = freezeJson({ ...persisted, sessionId });
+    records.set(record.token, record);
+    tokensByCall.set(record.toolCallId, record.token);
+  }
+  return {
+    async propose(action) {
+      const suffix = nextId();
+      if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/.test(suffix)) invalidConfirmation("Action confirmation id is invalid.");
+      const call = await chat.proposeToolCall({ id: `app-${suffix}`, name: action.name, args: action.input });
+      const token = `confirm-${suffix}`;
+      const record = Object.freeze({
+        token,
+        sessionId,
+        action: call.name,
+        input: freezeJson(structuredClone(call.args)),
+        toolCallId: call.id,
+        expiresAt: now() + ttlMs,
+        status: call.status === "requires_confirmation" ? "pending" : "rejected"
+      });
+      records.set(token, record);
+      tokensByCall.set(call.id, token);
+      await changed();
+      return record;
+    },
+    approve(token, requestedSession) {
+      return runOnce(token, async () => {
+        const record = requireRecord(token, requestedSession);
+        if (record.status !== "pending") return record;
+        if (now() >= record.expiresAt) {
+          const expiring = await claim(record, "expiring");
+          try {
+            await chat.deny(record.toolCallId, "confirmation expired");
+          } catch (error) {
+            if (!claimStatus) {
+              records.set(token, record);
+              await changed();
+            }
+            ;
+            throw error;
+          }
+          return claim(expiring, "expired");
+        }
+        const approving = await claim(record, "approving");
+        try {
+          await chat.approve(record.toolCallId);
+        } catch (error) {
+          if (!claimStatus) {
+            records.set(token, record);
+            await changed();
+          }
+          ;
+          throw error;
+        }
+        return claim(approving, "approved");
+      });
+    },
+    reject(token, requestedSession, reason) {
+      return runOnce(token, async () => {
+        const record = requireRecord(token, requestedSession);
+        if (record.status !== "pending") return record;
+        const rejecting = await claim(record, "rejecting");
+        try {
+          await chat.deny(record.toolCallId, reason);
+        } catch (error) {
+          if (!claimStatus) {
+            records.set(token, record);
+            await changed();
+          }
+          ;
+          throw error;
+        }
+        return claim(rejecting, "rejected");
+      });
+    },
+    getByToolCall(toolCallId) {
+      const token = tokensByCall.get(toolCallId);
+      return token === void 0 ? void 0 : records.get(token);
+    },
+    getSnapshot: () => Object.freeze([...records.values()])
+  };
+};
+var defineComponentManifest = (components) => {
+  const manifest = /* @__PURE__ */ Object.create(null);
+  for (const component of components) {
+    const standardDefinition = StandardComponentCatalog.find((candidate) => candidate.key === component.key);
+    if (!ComponentKeySchema.safeParse(component.key).success || Object.hasOwn(manifest, component.key) || standardDefinition !== void 0 && standardDefinition !== component) {
+      throw new ConfigError({
+        code: ErrorCodes.AK_CONFIG_INVALID,
+        message: "Component manifest keys must be non-empty, unique, and must not override standard catalog keys.",
+        hint: "Register each application component exactly once and use the canonical definition for standard keys."
+      });
+    }
+    manifest[component.key] = component;
+  }
+  return manifest;
+};
+var resolveComponentFrame = (input, manifest) => {
+  const decoded = decodeComponentFrame2(input);
+  if (!decoded.ok) return decoded;
+  if (!Object.hasOwn(manifest, decoded.frame.componentKey)) return {
+    ok: false,
+    diagnostic: { code: "COMPONENT_UNKNOWN", message: "Component is not registered.", retryable: false }
+  };
+  const component = manifest[decoded.frame.componentKey];
+  const props = component.propsSchema.safeParse(decoded.frame.props);
+  return props.success ? { ok: true, frame: decoded.frame, props: props.data } : {
+    ok: false,
+    diagnostic: { code: "COMPONENT_INVALID_PROPS", message: "Component props are invalid.", retryable: false }
+  };
+};
+var createComponentInteraction = (frame, manifest, event, value) => {
+  const resolved = resolveComponentFrame(frame, manifest);
+  const definition = resolved.ok ? manifest[resolved.frame.componentKey] : void 0;
+  const declared = definition?.events?.find((candidate) => candidate.name === event);
+  const isStandard = STANDARD_COMPONENT_KEYS.includes(frame.componentKey);
+  const validValue = isStandard ? resolved.ok && validateStandardComponentInteraction(frame.componentKey, resolved.props, event, value) : declared?.value === "none" ? value === void 0 : declared?.value === "id" ? typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value) : declared?.value === "url" ? typeof value === "string" && (/^\/(?!\/)/.test(value) || (() => {
+    try {
+      const url = new URL(value);
+      return ["http:", "https:"].includes(url.protocol) && url.username === "" && url.password === "";
+    } catch {
+      return false;
+    }
+  })()) : declared?.value === "form" ? value !== null && typeof value === "object" && !Array.isArray(value) : false;
+  if (!resolved.ok || !declared || !validValue) {
+    throw new ConfigError({
+      code: ErrorCodes.AK_CONFIG_INVALID,
+      message: "Component interaction is not declared by the resolved component.",
+      hint: "Emit only catalog events with the declared value shape."
+    });
+  }
+  return createInteractionEvent(frame, event, value);
+};
+var resolveComponentFallback = (input, manifest) => {
+  const resolved = resolveComponentFrame(input, manifest);
+  if (!resolved.ok) return void 0;
+  return manifest[resolved.frame.componentKey]?.fallback?.(resolved.props);
+};
+var resolveChoiceListFrame = (input, manifest) => {
+  const resolved = resolveComponentFrame(input, manifest);
+  if (!resolved.ok) return resolved;
+  if (resolved.frame.componentKey !== CHOICE_LIST_COMPONENT_KEY) return {
+    ok: false,
+    diagnostic: { code: "COMPONENT_UNKNOWN", message: "Component is not a ChoiceList.", retryable: false }
+  };
+  const props = ChoiceListPropsSchema.safeParse(resolved.props);
+  return props.success ? { ok: true, frame: resolved.frame, props: props.data } : {
+    ok: false,
+    diagnostic: { code: "COMPONENT_INVALID_PROPS", message: "ChoiceList props are invalid.", retryable: false }
+  };
+};
+var selectChoice = (frame, choiceId) => {
+  if (frame.componentKey !== CHOICE_LIST_COMPONENT_KEY) {
+    throw new ConfigError({
+      code: ErrorCodes.AK_CONFIG_INVALID,
+      message: "Selection frame is not a ChoiceList.",
+      hint: "Resolve the frame through ChoiceListComponent before emitting a selection."
+    });
+  }
+  const props = ChoiceListPropsSchema.parse(frame.props);
+  if (!props.choices.some((choice) => choice.id === choiceId)) {
+    throw new ConfigError({
+      code: ErrorCodes.AK_CONFIG_INVALID,
+      message: "Selected choice is not present in the ChoiceList.",
+      hint: "Emit only choice ids declared by the validated render frame."
+    });
+  }
+  return createSelectionEvent(frame, choiceId);
+};
+var defineChat = (definition) => definition;
+var SessionConflictError = class extends Error {
+  constructor() {
+    super("Session snapshot changed in another client.");
+    this.name = "SessionConflictError";
+  }
+};
+var invalidConversation = (message) => {
+  throw new ConfigError({
+    code: ErrorCodes.AK_CONFIG_INVALID,
+    message,
+    hint: "Define valid conversation states, routes, and transition targets."
+  });
+};
+var compileConversation = (definitionId, revision, conversation) => {
+  const stateNames = new Set(Object.keys(conversation.states));
+  const routeIds = /* @__PURE__ */ new Set();
+  for (const route of conversation.routes) {
+    if (route.id.length === 0 || route.event.length === 0) invalidConversation("Conversation route identity is invalid.");
+    if (routeIds.has(route.id)) invalidConversation("Conversation route ids must be unique.");
+    routeIds.add(route.id);
+    for (const state of route.states ?? []) {
+      if (!stateNames.has(state)) invalidConversation("Conversation route state is unknown.");
+    }
+  }
+  const states = {};
+  for (const [stateName, state] of Object.entries(conversation.states)) {
+    const on = {};
+    for (const [event, target] of Object.entries(state.on ?? {})) on[event] = { target };
+    states[stateName] = Object.keys(on).length > 0 ? { on } : {};
+  }
+  try {
+    return defineStatechart({
+      id: `${definitionId}.conversation`,
+      version: String(revision),
+      initial: conversation.initial,
+      parseContext: (input) => {
+        if (input === null || typeof input !== "object" || Array.isArray(input) || Object.keys(input).length > 0) {
+          throw new TypeError("Conversation statechart context must be empty.");
+        }
+        return {};
+      },
+      states
+    });
+  } catch (error) {
+    if (error instanceof StatechartError) invalidConversation(error.message);
+    return invalidConversation("Conversation statechart definition is invalid.");
+  }
+};
+var latestUserInput2 = (request) => request.messages.filter((message) => message.role === "user").at(-1)?.content ?? "";
+var deterministicSource = (content) => {
+  let aborted = false;
+  return {
+    async *stream() {
+      if (aborted) return;
+      yield { type: "text", content };
+      if (!aborted) yield { type: "done" };
+    },
+    abort() {
+      aborted = true;
+    }
+  };
+};
+var routeErrorSource = () => ({
+  async *stream() {
+    yield { type: "error", content: "Deterministic route failed." };
+  },
+  abort() {
+  }
+});
+var wrappedAdapters = /* @__PURE__ */ new WeakMap();
+var createChatSession = (definition, options = {}) => {
+  const revision = definition.revision ?? 1;
+  if (!Number.isSafeInteger(revision) || revision <= 0) invalidConversation("Chat definition revision is invalid.");
+  const sessionId = options.sessionId ?? `${definition.id}:${Date.now().toString(36)}`;
+  if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(sessionId)) invalidConversation("Chat session identity is invalid.");
+  const restored = options.snapshot;
+  let confirmations = restored?.confirmations ?? [];
+  let cursor = restored?.cursor ?? 0;
+  let exists = restored !== void 0;
+  let activeTurn = restored?.activeTurn;
+  let terminalTurns = restored?.terminalTurns ?? [];
+  let persistQueue = Promise.resolve();
+  const conversation = definition.conversation;
+  const machine = conversation ? compileConversation(definition.id, revision, conversation) : void 0;
+  if (!conversation && restored?.conversation) invalidConversation("Session conversation metadata is incompatible with this chat definition.");
+  const decisions = /* @__PURE__ */ new Map();
+  for (const decision of restored?.conversation?.decisions ?? []) {
+    decisions.set(decision.messageId, decision);
+  }
+  const statechartNow = () => (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const createInitialMachineInstance = () => {
+    if (!machine) return void 0;
+    try {
+      return createStatechartInstance(machine, {}, { instanceId: sessionId, now: statechartNow() });
+    } catch (error) {
+      if (error instanceof StatechartError) invalidConversation(error.message);
+      return invalidConversation("Conversation statechart instance is invalid.");
+    }
+  };
+  const transitionDecision = (instance, decision) => {
+    if (!conversation || !machine || decision.fromState !== instance.state) return void 0;
+    const route = conversation.routes.find((candidate) => candidate.id === decision.routeId);
+    if (!route || route.states !== void 0 && !route.states.includes(instance.state)) return void 0;
+    const result = transitionStatechart(machine, instance, { type: route.event }, { now: statechartNow() });
+    return result.status === "accepted" && result.to === decision.toState ? result.instance : void 0;
+  };
+  let machineInstance = createInitialMachineInstance();
+  if (machineInstance && restored?.conversation) {
+    let restoredInstance = machineInstance;
+    for (const decision of restored.conversation.decisions) {
+      const next = transitionDecision(restoredInstance, decision) ?? invalidConversation("Session conversation metadata is incompatible with this chat definition.");
+      restoredInstance = next;
+    }
+    if (restoredInstance.state !== restored.conversation.state) {
+      invalidConversation("Session conversation metadata is incompatible with this chat definition.");
+    }
+    machineInstance = restoredInstance;
+  }
+  const getMachineInstance = () => machineInstance ?? invalidConversation("Conversation statechart instance is missing.");
+  const buildSnapshot = (nextCursor) => SessionSnapshotSchema.parse({
+    protocol: SESSION_PROTOCOL,
+    version: SESSION_PROTOCOL_VERSION,
+    sessionId,
+    definitionId: definition.id,
+    definitionRevision: revision,
+    updatedAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+    cursor: nextCursor,
+    ...activeTurn ? { activeTurn } : {},
+    ...terminalTurns.length > 0 ? { terminalTurns } : {},
+    ...conversation ? {
+      conversation: {
+        state: getMachineInstance().state,
+        decisions: [...decisions].map(([messageId, decision]) => ({ messageId, ...decision }))
+      }
+    } : {},
+    confirmations
+  });
+  const persist = (signal) => {
+    if (!options.storage) {
+      cursor += 1;
+      return Promise.resolve();
+    }
+    persistQueue = persistQueue.catch(() => void 0).then(async () => {
+      const expectedCursor = exists ? cursor : void 0;
+      const snapshot = buildSnapshot(cursor + 1);
+      if (!await options.storage.save(snapshot, expectedCursor, signal ?? options.signal)) throw new SessionConflictError();
+      cursor = snapshot.cursor;
+      exists = true;
+    });
+    return persistQueue;
+  };
+  const createConfirmation = (confirmationOptions) => createActionConfirmation({
+    ...confirmationOptions,
+    sessionId,
+    initialRecords: confirmations,
+    onChange: async (records) => {
+      const previous = confirmations;
+      confirmations = records.map(({ sessionId: _sessionId, ...record }) => record);
+      try {
+        await persist();
+      } catch (error) {
+        confirmations = previous;
+        throw error;
+      }
+      try {
+        void Promise.resolve(options.onConfirmationChange?.(records)).catch(() => void 0);
+      } catch {
+      }
+    },
+    ...options.storage ? { claimStatus: async (record, status) => {
+      const previous = confirmations;
+      confirmations = confirmations.map((candidate) => candidate.token === record.token ? { ...candidate, status } : candidate);
+      try {
+        await persist();
+        const observed = Object.freeze(confirmations.map((record2) => Object.freeze({ ...record2, sessionId })));
+        try {
+          void Promise.resolve(options.onConfirmationChange?.(observed)).catch(() => void 0);
+        } catch {
+        }
+        ;
+        return true;
+      } catch (error) {
+        confirmations = previous;
+        throw error;
+      }
+    } } : {}
+  });
+  const scopeAdapter = (adapter) => {
+    const sessionAware = adapter;
+    return {
+      ...adapter,
+      createSource: (request) => sessionAware.createSourceForSession?.(request, sessionId) ?? adapter.createSource(request)
+    };
+  };
+  const claimTurn = async (turnId, leaseMs, signal) => {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(turnId) || !Number.isSafeInteger(leaseMs) || leaseMs <= 0) invalidConversation("Turn claim is invalid.");
+    const now = (options.now?.() ?? /* @__PURE__ */ new Date()).getTime();
+    if (terminalTurns.some((turn) => turn.turnId === turnId) || activeTurn && activeTurn.expiresAt > now) return false;
+    activeTurn = { turnId, expiresAt: now + leaseMs };
+    await persist(signal);
+    return true;
+  };
+  const releaseTurn = async (turnId, outcome, signal) => {
+    if (activeTurn?.turnId !== turnId) return;
+    activeTurn = void 0;
+    terminalTurns = [...terminalTurns.filter((candidate) => candidate.turnId !== turnId), { turnId, outcome }].slice(-64);
+    await persist(signal);
+  };
+  if (!conversation) return {
+    sessionId,
+    definitionId: definition.id,
+    definitionRevision: revision,
+    chat: { ...definition.chat, adapter: scopeAdapter(definition.chat.adapter) },
+    updateChat: (chat) => ({ ...chat, adapter: scopeAdapter(chat.adapter) }),
+    getConversationSnapshot: () => void 0,
+    createConfirmation,
+    persist,
+    getCursor: () => cursor,
+    claimTurn,
+    releaseTurn
+  };
+  const conversationMachine = machine ?? invalidConversation("Conversation statechart instance is missing.");
+  machineInstance ??= invalidConversation("Conversation statechart instance is missing.");
+  const emitTrace = (trace) => {
+    try {
+      void Promise.resolve(conversation.onTrace?.(trace)).catch(() => void 0);
+    } catch {
+    }
+  };
+  const rebuildState = (messages) => {
+    let rebuilt = createInitialMachineInstance() ?? invalidConversation("Conversation statechart instance is missing.");
+    for (const message of messages) {
+      if (message.role !== "user") continue;
+      const decision = decisions.get(message.id);
+      if (decision?.input !== message.content) continue;
+      const next = transitionDecision(rebuilt, decision);
+      if (next) rebuilt = next;
+    }
+    machineInstance = rebuilt;
+  };
+  const getConversationSnapshot = () => {
+    const instance = getMachineInstance();
+    const state = conversation.states[instance.state];
+    return {
+      state: instance.state,
+      events: Object.keys(state.on ?? {}),
+      actions: [...state.actions ?? []]
+    };
+  };
+  const schedulePersist = () => {
+    void persist().catch(() => void 0);
+  };
+  const createSource = (adapter, request) => {
+    const userMessages = request.messages.filter((message) => message.role === "user");
+    const userIds = new Set(userMessages.map((message) => message.id));
+    for (const id of decisions.keys()) {
+      if (!userIds.has(id)) decisions.delete(id);
+    }
+    const userMessage = userMessages.at(-1);
+    const input = latestUserInput2(request);
+    rebuildState(userMessages.slice(0, -1));
+    const replay = userMessage === void 0 ? void 0 : decisions.get(userMessage.id);
+    if (userMessage !== void 0 && replay?.input === input && replay.fromState === getMachineInstance().state) {
+      const next = transitionDecision(getMachineInstance(), replay);
+      if (!next) {
+        decisions.delete(userMessage.id);
+        schedulePersist();
+        return routeErrorSource();
+      }
+      machineInstance = next;
+      emitTrace({ kind: replay.kind, routeId: replay.routeId, fromState: replay.fromState, toState: replay.toState });
+      schedulePersist();
+      return deterministicSource(replay.content);
+    }
+    if (userMessage !== void 0) decisions.delete(userMessage.id);
+    const currentState = getMachineInstance().state;
+    const state = conversationMachine.states[currentState];
+    let route;
+    try {
+      route = conversation.routes.find(
+        (candidate) => (candidate.states === void 0 || candidate.states.includes(currentState)) && state.on?.[candidate.event] !== void 0 && candidate.match(input)
+      );
+    } catch {
+      schedulePersist();
+      return routeErrorSource();
+    }
+    if (!route) {
+      emitTrace({ kind: "agentic", fromState: currentState, toState: currentState });
+      schedulePersist();
+      return adapter.createSource(request);
+    }
+    const fromState = currentState;
+    let content;
+    try {
+      content = route.response(input, { sessionId, ...userMessage ? { messageId: userMessage.id } : {} });
+    } catch {
+      schedulePersist();
+      return routeErrorSource();
+    }
+    const transition = transitionStatechart(conversationMachine, getMachineInstance(), { type: route.event }, { now: statechartNow() });
+    if (transition.status !== "accepted") {
+      schedulePersist();
+      return routeErrorSource();
+    }
+    machineInstance = transition.instance;
+    const kind = route.traceKind ?? "deterministic";
+    if (userMessage !== void 0) decisions.set(userMessage.id, {
+      input,
+      routeId: route.id,
+      kind,
+      content,
+      fromState,
+      toState: transition.to
+    });
+    emitTrace({
+      kind,
+      routeId: route.id,
+      fromState,
+      toState: transition.to
+    });
+    schedulePersist();
+    return deterministicSource(content);
+  };
+  const updateChat = (chat) => {
+    const adapter = wrappedAdapters.get(chat.adapter) ?? chat.adapter;
+    const scoped = scopeAdapter(adapter);
+    const wrapped = { ...adapter, createSource: (request) => createSource(scoped, request) };
+    wrappedAdapters.set(wrapped, adapter);
+    return { ...chat, adapter: wrapped };
+  };
+  return {
+    sessionId,
+    definitionId: definition.id,
+    definitionRevision: revision,
+    chat: updateChat(definition.chat),
+    updateChat,
+    getConversationSnapshot,
+    createConfirmation,
+    persist,
+    getCursor: () => cursor,
+    claimTurn,
+    releaseTurn
+  };
+};
+var resumeChatSession = async (definition, options) => {
+  const input = await options.storage.load(options.sessionId, options.signal);
+  if (input === void 0 || input === null) return createChatSession(definition, options);
+  const decoded = decodeSessionSnapshot(input);
+  if (!decoded.ok) return invalidConversation(decoded.diagnostic.message);
+  const snapshot = decoded.snapshot;
+  if (snapshot.sessionId !== options.sessionId || snapshot.definitionId !== definition.id || snapshot.definitionRevision !== (definition.revision ?? 1)) {
+    invalidConversation("Session snapshot is incompatible with this chat definition.");
+  }
+  return createChatSession(definition, { ...options, snapshot });
+};
+var resolveChatSession = (definition, session) => {
+  if (!session) return createChatSession(definition);
+  if (session.definitionId !== definition.id || session.definitionRevision !== (definition.revision ?? 1)) {
+    invalidConversation("Prepared session is incompatible with this chat definition.");
+  }
+  return session;
+};
+var commandRoute = (options) => {
+  if (options.command.length === 0) invalidConversation("Conversation command cannot be empty.");
+  const { command, ...route } = options;
+  return { ...route, match: (input) => input === command };
+};
+var SemanticFallbackSchema = ComponentFallbackSchema;
+var parseSemanticFallback = (input) => SemanticFallbackSchema.parse(input);
+var formatSemanticFallback = (fallback) => `[unsupported visual: ${fallback.kind}] ${fallback.summary}`;
+export {
+  ApprovalRequestComponent,
+  ApprovalRequestPropsSchema,
+  AskEventSchema2 as AskEventSchema,
+  ButtonGroupComponent,
+  ButtonGroupPropsSchema,
+  CHOICE_LIST_COMPONENT_KEY,
+  ChatThemeSchema,
+  ChoiceListComponent,
+  ChoiceListPropsSchema,
+  ConfirmationComponent,
+  ConfirmationPropsSchema,
+  ErrorNoticeComponent,
+  ErrorNoticePropsSchema,
+  FileAttachmentComponent,
+  FileAttachmentPropsSchema,
+  FormComponent,
+  FormPropsSchema,
+  LinkCardComponent,
+  LinkCardPropsSchema,
+  ProgressComponent,
+  ProgressPropsSchema,
+  STANDARD_COMPONENT_KEYS,
+  SemanticFallbackSchema,
+  SessionConflictError,
+  SourceListComponent,
+  SourceListPropsSchema,
+  StandardComponentCatalog,
+  TableComponent,
+  TablePropsSchema,
+  ToolCallComponent,
+  ToolCallPropsSchema,
+  commandRoute,
+  createActionConfirmation,
+  createAskAdapter,
+  createAskSessionMemory,
+  createCapabilityPolicy,
+  createChatSession,
+  createComponentInteraction,
+  createDeterministicAnswerAdapter,
+  createDeterministicAnswerResolver,
+  decodeAskEvents2 as decodeAskEvents,
+  defaultChatTheme,
+  defineChat,
+  defineComponentManifest,
+  formatSemanticFallback,
+  getLifecycleTargets,
+  normalizeDeterministicQuery,
+  parseSemanticFallback,
+  presentChatMessage,
+  projectAskEvent,
+  projectAskMessages,
+  resolveChatSession,
+  resolveChatTheme,
+  resolveChoiceAction,
+  resolveChoiceListFrame,
+  resolveComponentFallback,
+  resolveComponentFrame,
+  resumeChatSession,
+  selectChoice,
+  validateStandardComponentInteraction,
+  withActionPolicy
+};