rift-ds 1.7.0 → 1.8.0

package/chat/server.js

@@ -0,0 +1,488 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { SUGGESTION_MAX_CHARS, fitsChip } from "./suggestions.js";
+const DEFAULT_CHAT_LIMITS = {
+  maxTurns: 10,
+  maxMessageChars: 4e3,
+  maxTotalChars: 4e4,
+  maxBodyChars: 64 * 1024,
+  maxTracePoints: 8
+};
+const DEFAULT_CHAT_COPY = {
+  disabled: "This chat is switched off at the moment.",
+  tooLong: "That message is longer than this chat can take. Trim it to the essentials and send it again.",
+  refusal: "That one is outside what this chat covers.",
+  cutOff: "\n\n(Cut off at the length limit.)",
+  reading: "Reading",
+  thinking: "Thinking",
+  lookingUp: "Looking it up",
+  busy: "The model is busy right now. Give it a moment and ask again.",
+  unauthorised: "This chat is not configured correctly at the moment.",
+  failed: "Something went wrong reaching the model. Try that again in a moment."
+};
+const NDJSON_HEADERS = {
+  "Content-Type": "application/x-ndjson; charset=utf-8",
+  "Cache-Control": "no-store",
+  // Proxies that buffer by default would hold the whole reply and destroy the
+  // streaming choreography the widget exists to show.
+  "X-Accel-Buffering": "no"
+};
+const encoder = new TextEncoder();
+const serialise = (event) => encoder.encode(`${JSON.stringify(event)}
+`);
+function ndjson(...events) {
+  return new Response(events.map((event) => `${JSON.stringify(event)}
+`).join(""), {
+    headers: NDJSON_HEADERS
+  });
+}
+function sanitisePath(value) {
+  if (typeof value !== "string") return null;
+  if (value === "/") return "/";
+  return /^\/[a-z0-9-]+(?:\/[a-z0-9-]+){0,3}$/.test(value) && value.length <= 64 ? value : null;
+}
+function parseBody(payload, limits, models, sanitise) {
+  if (typeof payload !== "object" || payload === null) {
+    return { ok: false, status: 400, reason: "body must be an object" };
+  }
+  const { messages, path, model } = payload;
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return { ok: false, status: 400, reason: "messages must be a non-empty array" };
+  }
+  const parsed = [];
+  for (const entry of messages) {
+    if (typeof entry !== "object" || entry === null) {
+      return { ok: false, status: 400, reason: "each message must be an object" };
+    }
+    const { role, content } = entry;
+    if (role !== "user" && role !== "assistant") {
+      return { ok: false, status: 400, reason: "role must be 'user' or 'assistant'" };
+    }
+    if (typeof content !== "string") {
+      return { ok: false, status: 400, reason: "content must be a string" };
+    }
+    if (content.trim()) parsed.push({ role, content });
+  }
+  if (parsed.length === 0) return { ok: false, status: 400, reason: "no messages with content" };
+  const trimmed = parsed.slice(-limits.maxTurns);
+  while (trimmed.length > 0 && trimmed[0].role === "assistant") trimmed.shift();
+  if (trimmed.length === 0) {
+    return { ok: false, status: 400, reason: "no user message in the recent turns" };
+  }
+  const totalChars = trimmed.reduce((sum, message) => sum + message.content.length, 0);
+  if (totalChars > limits.maxTotalChars) {
+    return { ok: false, status: 413, reason: "conversation is too large" };
+  }
+  const requested = typeof model === "string" ? models.find((option) => option.value === model) ?? null : null;
+  return { ok: true, messages: trimmed, path: sanitise(path), model: requested };
+}
+function cleanPoint(text) {
+  const flat = text.replace(/\*\*/g, "").replace(/\s+/g, " ").trim();
+  if (flat.length <= 200) return flat;
+  const cut = flat.slice(0, 200);
+  return `${cut.slice(0, cut.lastIndexOf(" ")) || cut}…`;
+}
+function createReasoningBuffer(limit, emit) {
+  let buffer = "";
+  let emitted = 0;
+  const flush = (final) => {
+    if (emitted >= limit) {
+      buffer = "";
+      return;
+    }
+    const sentences = buffer.split(new RegExp("(?<=[.!?])\\s+"));
+    buffer = final ? "" : sentences.pop() ?? "";
+    for (const sentence of sentences) {
+      if (emitted >= limit) break;
+      const point = cleanPoint(sentence);
+      if (point.length < 12) continue;
+      emit(point);
+      emitted += 1;
+    }
+  };
+  return {
+    push(text) {
+      buffer += text;
+      flush(false);
+    },
+    close() {
+      flush(true);
+    }
+  };
+}
+function friendlyError(error, copy) {
+  const status = error?.status;
+  if (status === 429 || status === 529) return copy.busy;
+  if (status === 401 || status === 403) return copy.unauthorised;
+  return copy.failed;
+}
+const toBlocks = (system) => typeof system === "string" ? [{ type: "text", text: system }] : system;
+function createChatHandler(options) {
+  const limits = { ...DEFAULT_CHAT_LIMITS, ...options.limits };
+  const copy = { ...DEFAULT_CHAT_COPY, ...options.copy };
+  const sanitise = options.sanitiseContext ?? sanitisePath;
+  const tools = options.tools ?? [];
+  const toolDefinitions = tools.map((tool) => tool.definition);
+  const toolByName = new Map(tools.map((tool) => [tool.definition.name, tool]));
+  const maxModelCalls = options.maxModelCalls ?? 3;
+  const maxTokens = options.maxTokens ?? 3e3;
+  const effort = options.effort ?? "low";
+  const guardrails = options.guardrails ?? {};
+  const contextBlock = options.contextBlock ?? ((path) => `The visitor is currently on the page ${path}.`);
+  const client = options.client ?? (options.apiKey ? new Anthropic({ apiKey: options.apiKey }) : null);
+  const enabled = options.enabled ?? client !== null;
+  const defaultModel = options.models.find((option) => option.value === options.defaultModel) ?? options.models[0];
+  const budgetModel = options.models.find((option) => option.value === options.budgetModel) ?? defaultModel;
+  if (!defaultModel) throw new Error("createChatHandler: `models` must name at least one model.");
+  const resolveServingModel = (requested, tier) => {
+    if (tier === "locked") return budgetModel;
+    if (requested) return requested;
+    return tier === "reduced" ? budgetModel : defaultModel;
+  };
+  const runTool = async (name, input) => {
+    const args = typeof input === "object" && input !== null ? input : {};
+    const tool = toolByName.get(name);
+    if (!tool) return { text: JSON.stringify({ error: `Unknown tool ${JSON.stringify(name)}.` }) };
+    try {
+      const result = await tool.execute(args);
+      return typeof result === "string" ? { text: result } : result;
+    } catch (error) {
+      return { text: JSON.stringify({ error: String(error?.message ?? error) }) };
+    }
+  };
+  return async function chatHandler(request) {
+    if (!enabled || !client) {
+      return ndjson({ type: "notice", text: copy.disabled }, { type: "done" });
+    }
+    let payload;
+    try {
+      const raw = await request.text();
+      if (raw.length > limits.maxBodyChars) {
+        return Response.json({ error: "request body too large" }, { status: 413 });
+      }
+      payload = JSON.parse(raw);
+    } catch {
+      return Response.json({ error: "invalid JSON" }, { status: 400 });
+    }
+    const parsed = parseBody(payload, limits, options.models, sanitise);
+    if (!parsed.ok) return Response.json({ error: parsed.reason }, { status: parsed.status });
+    const latest = parsed.messages[parsed.messages.length - 1];
+    if (latest.content.length > limits.maxMessageChars) {
+      return ndjson({ type: "notice", text: copy.tooLong }, { type: "done" });
+    }
+    const startedAt = Date.now();
+    const visitor = await guardrails.visitorKey?.(request) ?? "anonymous";
+    const question = latest.content;
+    const exchangeId = crypto.randomUUID();
+    const log = (entry) => {
+      if (!guardrails.onExchange) return Promise.resolve();
+      return guardrails.onExchange(entry).catch(() => {
+      });
+    };
+    const verdict = await guardrails.check?.(request) ?? { allowed: true, tier: "open" };
+    if (!verdict.allowed) {
+      const logged = log({
+        id: exchangeId,
+        question,
+        answer: verdict.notice,
+        path: parsed.path,
+        latencyMs: Date.now() - startedAt,
+        firstTextMs: null,
+        notice: true,
+        visitor
+      });
+      options.waitUntil?.(logged);
+      return ndjson({ type: "notice", text: verdict.notice }, { type: "done" });
+    }
+    const serving = resolveServingModel(parsed.model, verdict.tier);
+    const tierDefault = verdict.tier === "open" ? defaultModel.value : budgetModel.value;
+    const lockedValues = verdict.tier === "locked" ? options.models.filter((option) => option !== budgetModel).map((option) => option.value) : [];
+    const upstream = new AbortController();
+    request.signal.addEventListener("abort", () => upstream.abort());
+    const systemBase = toBlocks(
+      typeof options.system === "function" ? options.system({ path: parsed.path }) : options.system
+    );
+    const trailing = parsed.path ? contextBlock(parsed.path) : null;
+    const system = trailing ? [...systemBase, { type: "text", text: trailing }] : systemBase;
+    const body = new ReadableStream({
+      async start(controller) {
+        let closed = false;
+        const send = (event) => {
+          if (closed) return;
+          try {
+            controller.enqueue(serialise(event));
+          } catch {
+            closed = true;
+          }
+        };
+        let streamedText = false;
+        let answerText = "";
+        let noticeText = null;
+        let firstTextMs = null;
+        try {
+          send({ type: "status", label: copy.reading });
+          send({ type: "model", label: serving.label });
+          send({ type: "models", default: tierDefault, locked: lockedValues });
+          const reasoning = createReasoningBuffer(
+            limits.maxTracePoints,
+            (point) => send({ type: "status", label: copy.thinking, point })
+          );
+          const working = parsed.messages.map(({ role, content }) => ({
+            role,
+            content
+          }));
+          let final;
+          for (let call = 0; ; call += 1) {
+            const lastCall = call === maxModelCalls - 1;
+            const stream = client.messages.stream(
+              {
+                model: serving.id,
+                max_tokens: maxTokens,
+                // A model that predates adaptive thinking and the effort dial
+                // rejects both, so it gets a plain request.
+                ...serving.adaptiveThinking ? {
+                  thinking: { type: "adaptive", display: "summarized" },
+                  output_config: { effort }
+                } : {},
+                ...toolDefinitions.length > 0 ? { tools: toolDefinitions } : {},
+                ...lastCall && toolDefinitions.length > 0 ? { tool_choice: { type: "none" } } : {},
+                system,
+                messages: working
+              },
+              { signal: upstream.signal }
+            );
+            for await (const event of stream) {
+              if (upstream.signal.aborted) break;
+              if (event.type !== "content_block_delta") continue;
+              if (event.delta.type === "text_delta") {
+                if (!streamedText) {
+                  reasoning.close();
+                  streamedText = true;
+                  firstTextMs = Date.now() - startedAt;
+                }
+                answerText += event.delta.text;
+                send({ type: "delta", text: event.delta.text });
+              } else if (event.delta.type === "thinking_delta") {
+                reasoning.push(event.delta.thinking);
+              }
+            }
+            final = await stream.finalMessage();
+            await guardrails.onUsage?.(final.usage, serving.id).catch(() => {
+            });
+            if (final.stop_reason !== "tool_use" || lastCall || upstream.signal.aborted) break;
+            const toolUses = final.content.filter(
+              (block) => block.type === "tool_use"
+            );
+            const results = [];
+            for (const block of toolUses) {
+              const args = typeof block.input === "object" && block.input !== null ? block.input : {};
+              send({
+                type: "status",
+                label: copy.lookingUp,
+                point: toolByName.get(block.name)?.tracePoint?.(args) ?? `Used ${block.name}`
+              });
+              const result = await runTool(block.name, block.input);
+              if (result.card) send({ type: "card", card: result.card });
+              results.push({ type: "tool_result", tool_use_id: block.id, content: result.text });
+            }
+            working.push(
+              // The full content blocks go back, thinking included: the API
+              // requires the thinking blocks intact on a tool-using turn.
+              { role: "assistant", content: final.content },
+              { role: "user", content: results }
+            );
+          }
+          if (final.stop_reason === "refusal" && !streamedText) {
+            noticeText = copy.refusal;
+            send({ type: "notice", text: noticeText });
+          } else if (final.stop_reason === "max_tokens") {
+            send({ type: "delta", text: copy.cutOff });
+          }
+          if (guardrails.onExchange) {
+            await log({
+              id: exchangeId,
+              question,
+              answer: noticeText ?? answerText,
+              path: parsed.path,
+              model: serving.id,
+              usage: final.usage,
+              latencyMs: Date.now() - startedAt,
+              firstTextMs,
+              notice: noticeText !== null,
+              visitor
+            });
+            send({ type: "exchange", id: exchangeId });
+          }
+        } catch (error) {
+          const aborted = upstream.signal.aborted || error instanceof Error && error.name === "AbortError";
+          if (!aborted && !streamedText) {
+            console.error("[chat] upstream failed before any text:", error);
+            send({ type: "error", message: friendlyError(error, copy) });
+          } else if (!aborted) {
+            console.error("[chat] upstream failed mid-stream, keeping the partial:", error);
+          }
+        } finally {
+          send({ type: "done" });
+          if (!closed) {
+            try {
+              controller.close();
+            } catch {
+            }
+          }
+        }
+      },
+      cancel() {
+        upstream.abort();
+      }
+    });
+    return new Response(body, { headers: NDJSON_HEADERS });
+  };
+}
+const DEFAULT_FOLLOWUP_EXAMPLES = [
+  "How do I get started?",
+  "What does the Team plan include?",
+  "Can you show me an example?"
+];
+function followupsSystemPrompt({
+  about,
+  candidates,
+  examples
+}) {
+  return `You write the follow-up questions offered under an answer from a chat assistant about ${about}.
+
+You are given the visitor's last question and the answer they just read. Write the ${candidates} questions that visitor is most likely to want to ask next, best first.
+
+Length matters more than anything else here. Each question is shown on a chip, on one line, in a narrow panel. It must be at most ${SUGGESTION_MAX_CHARS} characters including spaces, which is about six words. A question over that length is thrown away and never shown, so write the short version of the question rather than the complete one. Count the characters before you write each line.
+
+Ask the plain question. Cut any phrase that does not change what is being asked: how long the answer should take, how many points it should have, how simple it should be, and the polite run-up to the question itself. A chip is a question, not a request.
+
+Questions in the length and plainness wanted:
+${examples.join("\n")}
+
+The rest of the rules:
+- Each question must be answerable by the assistant, about ${about}.
+- Move the conversation forward. Never re-ask the question just asked, and never ask something the answer already covered.
+- The visitor is asking the assistant: "What does the plan include?", never "What did you build?".
+- Plain words, sentence case. No em dashes, no emoji, no quotation marks, no numbering, no markdown.
+- Different angles on what was just said, not one question phrased several ways.
+
+Output exactly ${candidates} lines, one question per line, and nothing else.`;
+}
+function parseFollowups(text, wanted = 3) {
+  const seen = /* @__PURE__ */ new Set();
+  const suggestions = [];
+  for (const line of text.split("\n")) {
+    const cleaned = line.replace(/^\s*(?:[-*•]|\d+[.)])\s*/, "").replace(/[*_`#]/g, "").replace(/^["'“”‘’]+|["'“”‘’]+$/g, "").replace(/\s+/g, " ").trim();
+    if (cleaned.length < 12 || !fitsChip(cleaned)) continue;
+    if (!cleaned.endsWith("?")) continue;
+    const key = cleaned.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    suggestions.push(cleaned);
+    if (suggestions.length === wanted) break;
+  }
+  return suggestions;
+}
+function createFollowupsHandler(options) {
+  const wanted = options.wanted ?? 3;
+  const candidates = options.candidates ?? 5;
+  const timeoutMs = options.timeoutMs ?? 8e3;
+  const client = options.client ?? (options.apiKey ? new Anthropic({ apiKey: options.apiKey, timeout: timeoutMs, maxRetries: 0 }) : null);
+  const enabled = options.enabled ?? client !== null;
+  const system = options.system ?? followupsSystemPrompt({
+    about: options.about ?? "this product",
+    candidates,
+    examples: options.examples ?? DEFAULT_FOLLOWUP_EXAMPLES
+  });
+  const empty = () => Response.json({ suggestions: [] });
+  return async function followupsHandler(request) {
+    if (!enabled || !client) return empty();
+    let payload;
+    try {
+      payload = await request.json();
+    } catch {
+      return Response.json({ error: "invalid JSON" }, { status: 400 });
+    }
+    if (typeof payload !== "object" || payload === null) {
+      return Response.json({ error: "body must be an object" }, { status: 400 });
+    }
+    const { question, answer } = payload;
+    if (typeof question !== "string" || question.trim() === "") {
+      return Response.json({ error: "question must be a non-empty string" }, { status: 400 });
+    }
+    if (typeof answer !== "string" || answer.trim() === "") {
+      return Response.json({ error: "answer must be a non-empty string" }, { status: 400 });
+    }
+    if (options.guardrails?.checkFollowups && !await options.guardrails.checkFollowups(request)) {
+      return empty();
+    }
+    try {
+      const message = await client.messages.create(
+        {
+          model: options.model,
+          max_tokens: 200,
+          // Thinking would spend the small token cap before the questions are written.
+          thinking: { type: "disabled" },
+          system,
+          messages: [
+            {
+              role: "user",
+              content: `The visitor asked:
+${question.slice(0, 4e3)}
+
+The assistant answered:
+${answer.slice(0, 4e3)}`
+            }
+          ]
+        },
+        // The visitor moving on stops this being billed; nothing waits on it.
+        { signal: request.signal }
+      );
+      await options.guardrails?.onUsage?.(message.usage, options.model).catch(() => {
+      });
+      const text = message.content.map((block) => block.type === "text" ? block.text : "").join("");
+      return Response.json({ suggestions: parseFollowups(text, wanted) });
+    } catch (error) {
+      if (!request.signal.aborted) console.error("[chat] follow-up suggestions failed:", error);
+      return empty();
+    }
+  };
+}
+const EXCHANGE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function createFeedbackHandler(options = {}) {
+  const guardrails = options.guardrails ?? {};
+  return async function feedbackHandler(request) {
+    let payload;
+    try {
+      payload = await request.json();
+    } catch {
+      return Response.json({ error: "invalid JSON" }, { status: 400 });
+    }
+    if (typeof payload !== "object" || payload === null) {
+      return Response.json({ error: "body must be an object" }, { status: 400 });
+    }
+    const { id, verdict } = payload;
+    if (typeof id !== "string" || !EXCHANGE_ID.test(id)) {
+      return Response.json({ error: "id must be an exchange id" }, { status: 400 });
+    }
+    if (verdict !== "up" && verdict !== "down") {
+      return Response.json({ error: "verdict must be 'up' or 'down'" }, { status: 400 });
+    }
+    if (guardrails.checkFeedback && !await guardrails.checkFeedback(request)) {
+      return new Response(null, { status: 429 });
+    }
+    const visitor = await guardrails.visitorKey?.(request) ?? "anonymous";
+    await guardrails.onFeedback?.(id, verdict, visitor).catch(() => {
+    });
+    return new Response(null, { status: 204 });
+  };
+}
+export {
+  DEFAULT_CHAT_COPY,
+  DEFAULT_CHAT_LIMITS,
+  createChatHandler,
+  createFeedbackHandler,
+  createFollowupsHandler,
+  followupsSystemPrompt,
+  parseFollowups,
+  sanitisePath
+};

package/chat/sim.d.ts

@@ -0,0 +1,71 @@
+import { ReactNode } from 'react';
+import { ChatCard, ChatTransport } from './types';
+/** One status beat shown while the scripted reply "thinks". */
+export interface ScriptStep {
+    /** The AgentStatus label. */
+    status: string;
+    /** The reasoning trace point that collects under it. */
+    point?: string;
+}
+/** What a scripted assistant says back, and what rides with it. */
+export interface ScriptedReply {
+    /** The status beats before the text, one per `statusMs`. */
+    steps?: ScriptStep[];
+    /** The reply, as markdown. */
+    text: string;
+    /** Rich content the provider's renderers draw with the turn. */
+    card?: ChatCard;
+    /** Rich content as a React node, for a script that lives beside its components. */
+    content?: ReactNode;
+    /** The chips offered under the reply. Each should be a scripted prompt so no path dead-ends. */
+    followups?: string[];
+}
+/** A prompt the visitor can send, and the reply it routes to. */
+export interface ScriptNode extends ScriptedReply {
+    /** The exact chip text that routes here; matching forgives case and punctuation. */
+    prompt: string;
+}
+/** A whole scripted conversation, the input to `createSimTransport`. */
+export interface ChatScript {
+    nodes: ScriptNode[];
+    /** Replies for free text that matches no prompt, rotated per exchange. */
+    fallbacks: ScriptedReply[];
+    /** The reply to a turn that carried files and matched no prompt. */
+    filesReply?: (names: string[]) => ScriptedReply;
+}
+/** The beats the player keeps. Schedule timings, not animation: reduced motion leaves them be. */
+export interface SimTiming {
+    /** Milliseconds per status step. */
+    statusMs: number;
+    /** The pause between the last step and the first word. */
+    handoffMs: number;
+    /** Milliseconds per word of the reply. */
+    streamMs: number;
+}
+export declare const DEFAULT_SIM_TIMING: SimTiming;
+/** The reply to a turn that carried files and matched no scripted prompt. */
+export declare function defaultFilesReply(names: string[]): ScriptedReply;
+/** What a script with no fallbacks says to free text. */
+export declare const DEFAULT_FALLBACK_REPLY: ScriptedReply;
+/**
+ * Plays a `ChatScript` as a transport.
+ *
+ * `followups` on a reply default to the first few scripted prompts that fit
+ * a chip, so a script never ends on a reply with nowhere to go.
+ */
+export declare function createSimTransport(script: ChatScript, timing?: Partial<SimTiming>): ChatTransport;
+export interface ChatScriptBuilder {
+    /** The next prompt the visitor can send. Must be followed by `.assistant()`. */
+    user(prompt: string): ChatScriptBuilder;
+    /** The reply to the last `.user()` prompt. */
+    assistant(text: string, options?: Omit<ScriptedReply, 'text'>): ChatScriptBuilder;
+    /** A reply for typed text that matches no prompt. Several rotate per exchange. */
+    fallback(text: string, options?: Omit<ScriptedReply, 'text'>): ChatScriptBuilder;
+    /** The reply to a turn that carried files and matched no prompt. */
+    onFiles(reply: (names: string[]) => ScriptedReply): ChatScriptBuilder;
+    /** The finished script, for `createSimTransport` or inspection. */
+    build(): ChatScript;
+    /** The finished script as a transport, ready for `ChatProvider`. */
+    transport(timing?: Partial<SimTiming>): ChatTransport;
+}
+export declare function scriptChat(): ChatScriptBuilder;

package/chat/sim.js

@@ -0,0 +1,125 @@
+import { STARTER_COUNT } from "./starters.js";
+import { fitsChip } from "./suggestions.js";
+const DEFAULT_SIM_TIMING = {
+  statusMs: 1600,
+  handoffMs: 350,
+  streamMs: 30
+};
+const normalize = (text) => text.toLowerCase().replace(/[^a-z0-9 ]/g, "").replace(/\s+/g, " ").trim();
+class SimAbortError extends Error {
+  constructor() {
+    super("Scripted response aborted");
+    this.name = "AbortError";
+  }
+}
+const delay = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal.aborted) {
+    reject(new SimAbortError());
+    return;
+  }
+  const timer = setTimeout(() => {
+    signal.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(new SimAbortError());
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+});
+function defaultFilesReply(names) {
+  const shown = names.slice(0, 3).join(", ");
+  const rest = names.length > 3 ? ` and ${names.length - 3} more` : "";
+  const one = names.length === 1;
+  return {
+    steps: [
+      {
+        status: one ? "Looking at the file" : "Looking at the files",
+        point: `${names.length} attached; note what each one is before answering.`
+      }
+    ],
+    text: `Got ${one ? "it" : "them"}: ${shown}${rest}. This chat is scripted, so ${one ? "the file" : "the files"} stayed in your browser and nothing was uploaded or read. A live assistant would answer from the contents here.`
+  };
+}
+const DEFAULT_FALLBACK_REPLY = {
+  steps: [{ status: "Reading the question", point: "Nothing scripted matches this one." }],
+  text: "This chat is a scripted preview, so it only has answers written for the suggestions it offers. Pick one of them to see the conversation play out."
+};
+function createSimTransport(script, timing = {}) {
+  const beats = { ...DEFAULT_SIM_TIMING, ...timing };
+  const byPrompt = new Map(script.nodes.map((node) => [normalize(node.prompt), node]));
+  const fallbacks = script.fallbacks.length > 0 ? script.fallbacks : [DEFAULT_FALLBACK_REPLY];
+  const filesReply = script.filesReply ?? defaultFilesReply;
+  const defaultFollowups = script.nodes.map((node) => node.prompt).filter(fitsChip).slice(0, STARTER_COUNT);
+  let exchangeCount = 0;
+  return async function* simTransport(messages, signal) {
+    const lastUser = [...messages].reverse().find((m) => m.role === "user");
+    const node = lastUser ? byPrompt.get(normalize(lastUser.content)) : void 0;
+    const attached = !node ? lastUser?.attachments ?? [] : [];
+    const reply = node ?? (attached.length > 0 ? filesReply(attached.map((file) => file.name)) : fallbacks[exchangeCount % fallbacks.length]);
+    if (!node && attached.length === 0) exchangeCount += 1;
+    for (const step of reply.steps ?? []) {
+      yield { type: "status", label: step.status, point: step.point };
+      await delay(beats.statusMs, signal);
+    }
+    await delay(beats.handoffMs, signal);
+    const words = reply.text.split(" ");
+    for (let i = 0; i < words.length; i += 1) {
+      yield { type: "delta", text: i === 0 ? words[i] : ` ${words[i]}` };
+      await delay(beats.streamMs, signal);
+    }
+    if (reply.content) yield { type: "content", node: reply.content };
+    if (reply.card) yield { type: "card", card: reply.card };
+    const followups = (reply.followups ?? defaultFollowups).filter(fitsChip);
+    if (followups.length > 0) yield { type: "followups", items: followups };
+    yield { type: "done" };
+  };
+}
+function scriptChat() {
+  const nodes = [];
+  const fallbacks = [];
+  let filesReply;
+  let pendingPrompt = null;
+  const builder = {
+    user(prompt) {
+      if (pendingPrompt !== null) {
+        throw new Error(`scriptChat: "${pendingPrompt}" has no .assistant() reply.`);
+      }
+      pendingPrompt = prompt;
+      return builder;
+    },
+    assistant(text, options = {}) {
+      if (pendingPrompt === null) {
+        throw new Error("scriptChat: .assistant() needs a .user() prompt before it.");
+      }
+      nodes.push({ prompt: pendingPrompt, text, ...options });
+      pendingPrompt = null;
+      return builder;
+    },
+    fallback(text, options = {}) {
+      fallbacks.push({ text, ...options });
+      return builder;
+    },
+    onFiles(reply) {
+      filesReply = reply;
+      return builder;
+    },
+    build() {
+      if (pendingPrompt !== null) {
+        throw new Error(`scriptChat: "${pendingPrompt}" has no .assistant() reply.`);
+      }
+      return { nodes: [...nodes], fallbacks: [...fallbacks], filesReply };
+    },
+    transport(timing) {
+      return createSimTransport(builder.build(), timing);
+    }
+  };
+  return builder;
+}
+export {
+  DEFAULT_FALLBACK_REPLY,
+  DEFAULT_SIM_TIMING,
+  createSimTransport,
+  defaultFilesReply,
+  scriptChat
+};