@guideai/react-native 0.0.0-stage → 0.2.0

package/dist/useOnboarding-DAEGoYSs.js

@@ -0,0 +1,3592 @@
+import { useContext, createContext, useState, useRef, useEffect, useCallback } from "react";
+const DRAWING_URL = /^https:\/\/res\.cloudinary\.com\/[\w-]+\/image\/upload\//;
+const IMAGE_BLOCK = /```image[ \t]*\n([\s\S]*?)```/g;
+function headlessImages(text) {
+  const images = [];
+  const out = (text || "").replace(IMAGE_BLOCK, (_block, raw) => {
+    let data;
+    try {
+      data = JSON.parse(raw.trim());
+    } catch {
+      return "";
+    }
+    if (typeof data.url !== "string" || !DRAWING_URL.test(data.url)) return "";
+    const image = {
+      url: data.url,
+      svg: typeof data.svg === "string" && DRAWING_URL.test(data.svg) ? data.svg : null,
+      alt: typeof data.alt === "string" ? data.alt.slice(0, 200) : "",
+      width: Math.round(Number(data.width)) || 1600,
+      height: Math.round(Number(data.height)) || 900
+    };
+    images.push(image);
+    return `![${image.alt.replace(/[[\]]/g, "")}](${image.url})`;
+  });
+  return { text: out, images };
+}
+const NAME_PREFIXES = [
+  /^api[\s_-]*v?\d*[\s_-]*/i,
+  /^(get|fetch|list|read|retrieve|show|query|search|find|lookup|look up)[\s_-]+/i,
+  /^(create|add|post|new|insert|register)[\s_-]+/i,
+  /^(update|patch|put|edit|modify|set)[\s_-]+/i,
+  /^(delete|remove|destroy|archive)[\s_-]+/i,
+  /^(check|verify|validate|count|send|export|download)[\s_-]+/i
+];
+const METHOD_VERBS = {
+  GET: "Retrieving",
+  POST: "Creating",
+  PUT: "Updating",
+  PATCH: "Updating",
+  DELETE: "Removing"
+};
+const NAME_VERBS = [
+  { pattern: /^(search|find|lookup|look_up|query)/i, verb: "Looking up" },
+  { pattern: /^(list|get_all|getall)/i, verb: "Retrieving" },
+  { pattern: /^(count|stats|statistics|summary|analytics|metrics|usage|report)/i, verb: "Gathering" },
+  { pattern: /^(check|verify|validate|status)/i, verb: "Checking" },
+  { pattern: /^(create|add|new|insert|register)/i, verb: "Creating" },
+  { pattern: /^(update|edit|modify|set|patch)/i, verb: "Updating" },
+  { pattern: /^(delete|remove|destroy|archive)/i, verb: "Removing" },
+  { pattern: /^(send|email|notify|invite)/i, verb: "Sending" },
+  { pattern: /^(export|download)/i, verb: "Preparing" }
+];
+const SELF_DESCRIBING = /\b(information|details|data|summary|stats|statistics|activity|history|settings|status|usage|overview|report|list|metrics|analytics|breakdown)\b/i;
+function humanizeName(name) {
+  let out = name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-/]+/g, " ").replace(/\bapi\s*v?\d+\b/gi, " ").replace(/\s+(get|post|put|patch|delete)$/i, "").replace(/\s+/g, " ").trim().toLowerCase();
+  for (const prefix of NAME_PREFIXES) {
+    out = out.replace(prefix, "");
+  }
+  const kept = [];
+  for (const word of out.trim().split(" ").reverse()) {
+    const stem = word.replace(/s$/, "");
+    if (!word || stem === "id" || stem === "uuid") continue;
+    if (kept.some((k) => k.replace(/s$/, "") === stem)) continue;
+    kept.push(word);
+  }
+  return kept.reverse().join(" ");
+}
+function pickVerb(toolName, noun, method) {
+  const bare = toolName.replace(NAME_PREFIXES[0], "");
+  for (const { pattern, verb } of NAME_VERBS) {
+    if (pattern.test(bare)) return verb;
+  }
+  for (const { pattern, verb } of NAME_VERBS) {
+    if (pattern.test(noun)) return verb;
+  }
+  return METHOD_VERBS[method.toUpperCase()] || "Retrieving";
+}
+function describeToolCall(toolCall) {
+  const supplied = (toolCall.label || "").trim();
+  if (supplied) return supplied;
+  let noun = humanizeName(toolCall.tool || "");
+  if (!noun) return "Retrieving information";
+  const verb = pickVerb(toolCall.tool || "", noun, toolCall.method || "GET");
+  const ownScope = /\s+(me|self|current|mine)$/.test(noun);
+  if (ownScope) noun = `your ${noun.replace(/\s+(me|self|current|mine)$/, "")}`;
+  if (SELF_DESCRIBING.test(noun) || ownScope) return `${verb} ${noun}`;
+  const singular = noun.replace(/([a-z])(?<!s|u|i)s$/, "$1");
+  return `${verb} ${singular} information`;
+}
+function describeToolBatch(toolCalls) {
+  if (toolCalls.length === 0) return "Working on it";
+  if (toolCalls.length === 1) return describeToolCall(toolCalls[0]);
+  return `Gathering information from ${toolCalls.length} sources`;
+}
+class MemoryKVStore {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  getItem(key) {
+    const value = this.entries.get(key);
+    return value === void 0 ? null : value;
+  }
+  setItem(key, value) {
+    this.entries.set(key, String(value));
+  }
+  removeItem(key) {
+    this.entries.delete(key);
+  }
+  /** Test convenience — not part of the KVStore contract. */
+  clear() {
+    this.entries.clear();
+  }
+}
+const MAX_MESSAGE_LENGTH = 2e3;
+const MAX_TOOL_RESULT_SIZE = 5e4;
+const VALID_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "CLIENT"]);
+const INJECTION_PATTERN = /<script|javascript:|on\w+\s*=|union\s+select|drop\s+table|insert\s+into|delete\s+from/i;
+const CREDENTIAL_PATTERN$1 = /sk[_-]live[_-]\w{10,}|pk[_-]live[_-]\w{10,}|Bearer\s+\S{20,}/g;
+const THINKING_BLOCK_PATTERN = /<thinking\b[^>]*>[\s\S]*?<\/thinking>/gi;
+const THINKING_LINE_PATTERN = /^\s*<\/?thinking\b[^>]*>\s*$/gim;
+const GUIDE_FENCE_PATTERN = /```(?:guide|guideai-guide)\s*\n?[\s\S]*?(?:```|$)/gi;
+const GENERIC_SELECTORS = /* @__PURE__ */ new Set([
+  "a",
+  "button",
+  "input",
+  "select",
+  "textarea",
+  "div",
+  "span",
+  "li",
+  "p",
+  "form",
+  "table",
+  "img",
+  "label"
+]);
+class HarnessValidator {
+  constructor() {
+    this.registeredTools = [];
+  }
+  /** Update the list of registered tools (called after harness init). */
+  setRegisteredTools(tools) {
+    this.registeredTools = tools;
+  }
+  // ----------------------------------------------------------------
+  // Input validation
+  // ----------------------------------------------------------------
+  /**
+   * Validate and sanitize user input before sending to the backend.
+   *
+   * Checks:
+   * - Not empty
+   * - Within max length
+   * - No obvious injection patterns
+   */
+  validateUserInput(question) {
+    if (!question || !question.trim()) {
+      return { valid: false, error: "Message cannot be empty." };
+    }
+    const trimmed = question.trim();
+    if (trimmed.length > MAX_MESSAGE_LENGTH) {
+      return {
+        valid: true,
+        sanitized: trimmed.slice(0, MAX_MESSAGE_LENGTH)
+      };
+    }
+    if (INJECTION_PATTERN.test(trimmed)) {
+      console.warn("[GuideAI] Potential injection pattern detected in user input.");
+    }
+    return { valid: true, sanitized: trimmed };
+  }
+  // ----------------------------------------------------------------
+  // Tool call validation
+  // ----------------------------------------------------------------
+  /**
+   * Validate a tool call response from the backend before execution.
+   *
+   * Checks:
+   * - Required fields present (tool, method, path)
+   * - Method is a valid HTTP method
+   * - Tool exists in the registered tools list
+   * - Path looks valid (starts with /)
+   */
+  validateToolCall(toolCall) {
+    if (!toolCall) {
+      return { valid: false, error: "Tool call is missing." };
+    }
+    if (!toolCall.tool || typeof toolCall.tool !== "string") {
+      return { valid: false, error: 'Tool call missing "tool" name.' };
+    }
+    if (!toolCall.method || typeof toolCall.method !== "string") {
+      return { valid: false, error: 'Tool call missing "method".' };
+    }
+    const method = toolCall.method.toUpperCase();
+    if (!VALID_METHODS.has(method)) {
+      return {
+        valid: false,
+        error: `Invalid tool method "${toolCall.method}". Expected one of: ${[...VALID_METHODS].join(", ")}.`
+      };
+    }
+    if (!toolCall.path || typeof toolCall.path !== "string") {
+      return { valid: false, error: 'Tool call missing "path".' };
+    }
+    if (!toolCall.path.startsWith("/")) {
+      return {
+        valid: false,
+        error: `Tool path must start with "/". Got: "${toolCall.path}".`
+      };
+    }
+    if (this.registeredTools.length > 0) {
+      const found = this.registeredTools.some(
+        (t) => t.name === toolCall.tool
+      );
+      if (!found) {
+        return {
+          valid: false,
+          error: `Tool "${toolCall.tool}" is not registered. Available: ${this.registeredTools.map((t) => t.name).slice(0, 5).join(", ")}...`
+        };
+      }
+    }
+    return { valid: true };
+  }
+  // ----------------------------------------------------------------
+  // Response validation
+  // ----------------------------------------------------------------
+  /**
+   * Validate and sanitize the backend response before showing to user.
+   *
+   * - Strip leaked credentials from answer text
+   * - Validate response structure
+   */
+  validateResponse(response) {
+    if (!response || typeof response !== "object") {
+      return { valid: false, error: "Invalid response from server." };
+    }
+    const resp = response;
+    if (typeof resp.answer !== "string") {
+      return { valid: false, error: 'Response missing "answer" field.' };
+    }
+    const sanitizedAnswer = this.sanitizeAnswer(resp.answer);
+    if (sanitizedAnswer !== resp.answer) {
+      console.warn("[GuideAI] Sanitized hidden reasoning or leaked credentials from response.");
+    }
+    return { valid: true, sanitized: sanitizedAnswer };
+  }
+  /**
+   * Sanitize the answer text — strip leaked credentials, hidden reasoning
+   * and machine payload the visitor should never read.
+   */
+  sanitizeAnswer(answer) {
+    return answer.replace(THINKING_BLOCK_PATTERN, "").replace(THINKING_LINE_PATTERN, "").replace(GUIDE_FENCE_PATTERN, "").replace(CREDENTIAL_PATTERN$1, "[REDACTED]").trim();
+  }
+  // ----------------------------------------------------------------
+  // Tool result validation
+  // ----------------------------------------------------------------
+  /**
+   * Validate a tool execution result before sending to the format endpoint.
+   *
+   * - Check structure
+   * - Truncate oversized results
+   * - Strip credential-looking values
+   */
+  validateToolResult(result) {
+    if (!result) {
+      return { valid: false, error: "Tool result is missing." };
+    }
+    if (typeof result.success !== "boolean") {
+      return { valid: false, error: 'Tool result missing "success" field.' };
+    }
+    if (result.data) {
+      const serialized = JSON.stringify(result.data);
+      if (serialized.length > MAX_TOOL_RESULT_SIZE) {
+        result.data = this._truncateData(result.data);
+      }
+    }
+    return { valid: true };
+  }
+  /**
+   * Enhanced tool result validation — classifies errors and detects empty-success.
+   *
+   * Returns errorType for contextual UI messages and warning for
+   * success-but-empty scenarios.
+   */
+  validateToolResultEnhanced(result) {
+    if (!result) {
+      return { valid: false, error: "Tool result is missing.", errorType: "unknown" };
+    }
+    if (typeof result.success !== "boolean") {
+      return { valid: false, error: 'Tool result missing "success" field.', errorType: "unknown" };
+    }
+    if (!result.success) {
+      const errorType = this._classifyError(result);
+      const friendlyMsg = this._friendlyErrorMessage(errorType);
+      const raw = (result.error || "").trim();
+      return {
+        valid: false,
+        error: friendlyMsg,
+        errorType,
+        detail: raw ? `${friendlyMsg} (${raw})` : friendlyMsg
+      };
+    }
+    if (this._isEmptyData(result.data)) {
+      return {
+        valid: true,
+        warning: "That went through, but there was nothing to show for it yet."
+      };
+    }
+    if (result.data) {
+      const serialized = JSON.stringify(result.data);
+      if (serialized.length > MAX_TOOL_RESULT_SIZE) {
+        result.data = this._truncateData(result.data);
+      }
+    }
+    return { valid: true };
+  }
+  // ----------------------------------------------------------------
+  // Formatted response validation
+  // ----------------------------------------------------------------
+  /**
+   * Validate that an LLM-formatted answer is substantial and relevant.
+   * Returns the answer as-is if OK, or a fallback if not.
+   */
+  validateFormattedResponse(answer, toolResult) {
+    if (!answer || answer.trim().length < 15) {
+      return "I retrieved the data but couldn't generate a complete summary. Please try again.";
+    }
+    const refusalPatterns = /^(i cannot|i'm unable|i don't have|sorry, i can't)/i;
+    if (refusalPatterns.test(answer.trim()) && (toolResult == null ? void 0 : toolResult.success) && toolResult.data) {
+      return "The data was fetched successfully. Please rephrase your question for a better summary.";
+    }
+    return this.sanitizeAnswer(answer);
+  }
+  // ----------------------------------------------------------------
+  // Guide step validation
+  // ----------------------------------------------------------------
+  /**
+   * Validate guide steps before rendering the walkthrough button.
+   * Ensures steps have minimum required fields and catches generic selectors.
+   */
+  validateGuideSteps(steps) {
+    if (!steps || steps.length === 0) {
+      return { valid: false, steps: [], warnings: ["No guide steps returned."] };
+    }
+    const warnings = [];
+    const validSteps = [];
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
+      const title = step.title;
+      const body = step.body;
+      const selector = step.target_selector;
+      const action = step.action;
+      if (!title && !body) {
+        warnings.push(`Step ${i + 1} has no title or body — skipped.`);
+        continue;
+      }
+      if (selector && GENERIC_SELECTORS.has(selector.trim())) {
+        warnings.push(
+          `Step ${i + 1} has a generic selector "${selector}" — it may not highlight correctly.`
+        );
+        step.target_selector = void 0;
+        if (action && action !== "none") {
+          step.action = "none";
+        }
+      }
+      validSteps.push(step);
+    }
+    return {
+      valid: validSteps.length > 0,
+      steps: validSteps,
+      warnings
+    };
+  }
+  // ----------------------------------------------------------------
+  // Private helpers
+  // ----------------------------------------------------------------
+  _classifyError(result) {
+    const status = result.status;
+    const error = (result.error || "").toLowerCase();
+    if (status === 401 || status === 403) return "auth";
+    if (status === 404) return "not_found";
+    if (status === 429) return "rate_limit";
+    if (status && status >= 500) return "server";
+    if (status === 400 || status === 422) return "validation";
+    if (error.includes("timed out") || error.includes("timeout")) return "timeout";
+    if (error.includes("connect") || error.includes("network")) return "connection";
+    if (status && status >= 400) return "client";
+    return result.error_type || "unknown";
+  }
+  /**
+   * What a person reads when a request fails.
+   *
+   * No status codes, no endpoint names, no field paths — those belong to the
+   * model (see `detail`), which can act on them. A person can only be told,
+   * plainly, that the thing did not work and roughly why.
+   */
+  _friendlyErrorMessage(errorType) {
+    switch (errorType) {
+      case "auth":
+        return "Your session has expired. Please log in again and retry.";
+      case "not_found":
+        return "I couldn't find that record. It may have been removed.";
+      case "rate_limit":
+        return "Too many requests right now. Please try again in a moment.";
+      case "timeout":
+        return "That took too long to respond. Please try again.";
+      case "connection":
+        return "I couldn't reach the service. Please check your connection and try again.";
+      case "server":
+        return "The service ran into a problem. Please try again shortly.";
+      case "validation":
+        return "Some of the details in that request weren't accepted.";
+      default:
+        return "I wasn't able to complete that request.";
+    }
+  }
+  _isEmptyData(data) {
+    if (data === null || data === void 0) return true;
+    if (Array.isArray(data)) return data.length === 0;
+    if (typeof data === "string") return data.trim().length === 0;
+    if (typeof data === "object") {
+      const obj = data;
+      const keys = Object.keys(obj).filter((k) => !k.startsWith("_"));
+      if (keys.length === 0) return true;
+      return keys.every((k) => {
+        const v = obj[k];
+        return v === null || v === void 0 || v === "" || Array.isArray(v) && v.length === 0 || typeof v === "object" && v !== null && Object.keys(v).length === 0;
+      });
+    }
+    return false;
+  }
+  /**
+   * Truncate large data payloads to prevent token waste at the format endpoint.
+   */
+  _truncateData(data) {
+    if (Array.isArray(data)) {
+      return data.slice(0, 25);
+    }
+    if (data && typeof data === "object") {
+      const obj = data;
+      for (const key of ["data", "results", "items", "records", "rows"]) {
+        if (Array.isArray(obj[key])) {
+          return {
+            ...obj,
+            [key]: obj[key].slice(0, 25),
+            _truncated: true
+          };
+        }
+      }
+    }
+    return data;
+  }
+}
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+const DEFAULT_MAX_MESSAGES = 50;
+const SENSITIVE_KEY_PATTERN = /^(password|passwd|secret|token|api[_-]?key|admin[_-]?key|access[_-]?key|private[_-]?key|authorization|ssn|credit[_-]?card|cvv|cvc|pin)$/i;
+const CREDENTIAL_PATTERN = /sk[_-]live[_-]\w{10,}|pk[_-]live[_-]\w{10,}|Bearer\s+\S{20,}/g;
+class ConversationMemory {
+  /**
+   * @param store Where history lives. Defaults to memory so core never
+   *   reaches for a global; the web SDK passes its localStorage adapter.
+   */
+  constructor(siteId, ttlMs, maxMessages, store = new MemoryKVStore()) {
+    this.listener = null;
+    this.store = store;
+    this.storageKey = `guideai_chat_${siteId}`;
+    this.ttlMs = ttlMs != null ? ttlMs : DEFAULT_TTL_MS;
+    this.maxMessages = maxMessages != null ? maxMessages : DEFAULT_MAX_MESSAGES;
+  }
+  /** Get all messages, checking TTL. Returns empty array if expired. */
+  getMessages() {
+    try {
+      const raw = this.store.getItem(this.storageKey);
+      if (!raw) return [];
+      const data = JSON.parse(raw);
+      if (Date.now() - data.updated_at > this.ttlMs) {
+        this.clear();
+        return [];
+      }
+      return data.messages || [];
+    } catch {
+      return [];
+    }
+  }
+  /** Add a message and persist to the store. Auto-generates an ID if not provided. */
+  addMessage(message) {
+    var _a;
+    if (!message.id) {
+      message.id = `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    }
+    const messages = this.getMessages();
+    messages.push(message);
+    const trimmed = messages.slice(-this.maxMessages);
+    this._save(trimmed);
+    try {
+      (_a = this.listener) == null ? void 0 : _a.call(this, message);
+    } catch {
+    }
+  }
+  /** Called with every message added from now on; null stops it. */
+  onMessage(listener) {
+    this.listener = listener;
+  }
+  /**
+   * Get recent messages formatted for LLM context.
+   * Includes tool result summaries so the LLM knows what data was
+   * previously returned and can make informed follow-up tool calls.
+   * Caps total payload to ~4000 chars to stay within token budget.
+   */
+  getRecentForLLM(count = 10) {
+    const messages = this.getMessages();
+    const MAX_MSG_CHARS = 500;
+    const MAX_TOOL_RESULT_CHARS = 800;
+    const MAX_TOTAL_CHARS = 4e3;
+    const recent = messages.slice(-count).map((msg) => {
+      var _a;
+      let content = msg.content;
+      if (msg.role === "assistant" && content.length > MAX_MSG_CHARS) {
+        content = content.slice(0, MAX_MSG_CHARS) + "...";
+      }
+      if (((_a = msg.toolResult) == null ? void 0 : _a.success) && msg.toolResult.data) {
+        const summary = this._summarizeToolResult(msg.toolResult.data, MAX_TOOL_RESULT_CHARS);
+        if (summary) {
+          content += `
+
+[Tool result data: ${summary}]`;
+        }
+      }
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        const callSummary = msg.toolCalls.map((tc) => {
+          const route = tc.method && tc.path ? ` ${tc.method} ${tc.path}` : "";
+          const detail = tc.summary ? ` - ${tc.summary}` : "";
+          return `${tc.tool}${route}: ${tc.success ? "ok" : "failed"}${detail}`;
+        }).join("; ");
+        content += `
+[Tool calls: ${callSummary}]`;
+      }
+      content = content.replace(CREDENTIAL_PATTERN, "[REDACTED]");
+      return { role: msg.role, content };
+    });
+    let total = recent.reduce((sum, m) => sum + m.content.length, 0);
+    while (recent.length > 2 && total > MAX_TOTAL_CHARS) {
+      const removed = recent.shift();
+      total -= removed.content.length;
+    }
+    return recent;
+  }
+  /**
+   * Create a compact summary of tool result data for LLM context.
+   * Extracts key fields, array lengths, and available resource names.
+   */
+  _summarizeToolResult(data, maxChars) {
+    try {
+      const cleaned = this._stripSensitiveFields(data);
+      const json = JSON.stringify(cleaned);
+      if (json.length <= maxChars) {
+        return json;
+      }
+      if (Array.isArray(cleaned)) {
+        const total = cleaned.length;
+        const pickFields = (item) => {
+          if (typeof item === "object" && item !== null) {
+            const obj = item;
+            const picked = {};
+            for (const key of ["name", "id", "title", "path", "endpoint", "url", "type", "method", "label", "slug", "status"]) {
+              if (key in obj) picked[key] = obj[key];
+            }
+            return Object.keys(picked).length > 0 ? picked : Object.keys(obj).slice(0, 4).reduce((acc, k) => ({ ...acc, [k]: obj[k] }), {});
+          }
+          return item;
+        };
+        const compactItems = cleaned.map(pickFields);
+        let itemsToShow = compactItems;
+        let summary = JSON.stringify({ total_count: total, items: itemsToShow });
+        if (summary.length > maxChars) {
+          let lo = 1, hi = compactItems.length;
+          while (lo < hi) {
+            const mid = Math.ceil((lo + hi) / 2);
+            const test = JSON.stringify({ total_count: total, items_shown: mid, items: compactItems.slice(0, mid) });
+            if (test.length <= maxChars) {
+              lo = mid;
+            } else {
+              hi = mid - 1;
+            }
+          }
+          itemsToShow = compactItems.slice(0, lo);
+          summary = JSON.stringify({ total_count: total, items_shown: lo, items: itemsToShow });
+        }
+        return summary.length <= maxChars ? summary : summary.slice(0, maxChars) + "...";
+      }
+      if (typeof cleaned === "object" && cleaned !== null) {
+        const keys = Object.keys(cleaned);
+        const summary = JSON.stringify({ keys, preview: json.slice(0, maxChars - 100) });
+        return summary.slice(0, maxChars);
+      }
+      return json.slice(0, maxChars);
+    } catch {
+      return "";
+    }
+  }
+  /** Recursively strip fields with sensitive-looking keys (defense-in-depth). */
+  _stripSensitiveFields(data, depth = 0) {
+    if (depth > 5) return data;
+    if (Array.isArray(data)) {
+      return data.slice(0, 50).map((item) => this._stripSensitiveFields(item, depth + 1));
+    }
+    if (typeof data === "object" && data !== null) {
+      const result = {};
+      for (const [key, value] of Object.entries(data)) {
+        result[key] = SENSITIVE_KEY_PATTERN.test(key) ? "[REDACTED]" : this._stripSensitiveFields(value, depth + 1);
+      }
+      return result;
+    }
+    return data;
+  }
+  /** Clear all conversation history. */
+  clear() {
+    try {
+      this.store.removeItem(this.storageKey);
+    } catch {
+    }
+  }
+  /** Check if there is any conversation history. */
+  hasHistory() {
+    return this.getMessages().length > 0;
+  }
+  _save(messages) {
+    try {
+      const data = {
+        messages,
+        updated_at: Date.now()
+      };
+      this.store.setItem(this.storageKey, JSON.stringify(data));
+    } catch {
+    }
+  }
+}
+function encodeParam(value) {
+  return encodeURIComponent(value).replace(/%20/g, "+").replace(/[!'()~]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+const MAX_ERROR_DETAIL_CHARS = 400;
+const MAX_ERROR_DETAIL_ITEMS = 5;
+class ToolExecutor {
+  /**
+   * @param transport How this platform reaches the customer's API.
+   *   Defaults to the browser's, so existing callers are unaffected.
+   */
+  constructor(authConfig, baseUrl, credentials, transport) {
+    this.credentials = credentials;
+    this.transport = transport;
+    this.authConfig = authConfig;
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  /** Read the user's auth token from the configured browser storage. */
+  getAuthToken() {
+    var _a, _b;
+    if (this.authConfig.type === "none") return null;
+    try {
+      const supplied = this.authConfig.type === "bearer" ? (_b = (_a = this.credentials).authToken) == null ? void 0 : _b.call(_a) : null;
+      if (supplied) return supplied;
+      let raw = null;
+      const storageKey = this.authConfig.key;
+      if (storageKey && this.authConfig.source) {
+        raw = this.credentials.read(this.authConfig.source, storageKey);
+      }
+      if (raw) {
+        const token = this._extractToken(raw);
+        if (token) return token;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Extract the actual JWT from a raw storage value.
+   *
+   * Handles all common storage formats automatically:
+   *  - Plain JWT string: "eyJhbGciOi..."
+   *  - JSON with known field: {"access_token": "eyJ..."} or {"token": "eyJ..."}
+   *  - JSON with any string field that looks like a JWT
+   *
+   * If token_field is configured, it takes priority and extracts that specific field.
+   */
+  _extractToken(raw) {
+    if (raw.startsWith("eyJ")) return raw;
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        if (this.authConfig.token_field) {
+          const value = this._readObjectPath(parsed, this.authConfig.token_field);
+          return typeof value === "string" ? value : null;
+        }
+        const commonFields = ["access_token", "token", "jwt", "id_token", "auth_token", "accessToken", "idToken", "authToken"];
+        for (const field of commonFields) {
+          if (typeof parsed[field] === "string" && parsed[field]) {
+            return parsed[field];
+          }
+        }
+        for (const value of Object.values(parsed)) {
+          if (typeof value === "string" && value.startsWith("eyJ")) {
+            return value;
+          }
+        }
+      }
+      if (typeof parsed === "string") return parsed;
+    } catch {
+    }
+    return raw;
+  }
+  /** Execute an API tool call client-side using the user's auth. */
+  async execute(toolCall) {
+    try {
+      const method = toolCall.method.toUpperCase();
+      const unresolved = [
+        ...this._unresolvedPathParams(toolCall),
+        ...this._unresolvedHeaders(toolCall)
+      ];
+      if (unresolved.length > 0) {
+        return {
+          success: false,
+          error: `Missing ${unresolved.join(", ")} — this needs data from another request first.`
+        };
+      }
+      const url = this._buildUrl(toolCall);
+      const headers = this._buildHeaders(toolCall);
+      let body;
+      if (toolCall.body && method !== "GET") {
+        body = JSON.stringify(toolCall.body);
+      } else if (toolCall.params && method !== "GET") {
+        body = JSON.stringify(toolCall.params);
+      }
+      const response = await this.transport.request({
+        url,
+        // The tool's own verb, not a coerced one: rewriting a DELETE as a
+        // POST would silently change what the customer's API is asked to do.
+        method,
+        headers,
+        body
+      });
+      let data;
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        data = await response.json();
+      } else {
+        data = await response.text();
+      }
+      const ok = response.status >= 200 && response.status < 300;
+      return {
+        success: ok,
+        data,
+        status: response.status,
+        error: ok ? void 0 : response.status === 401 || response.status === 403 ? "Your session has expired. Please refresh the page or log in again." : this._describeHttpError(response.status, data)
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Unknown error executing tool call"
+      };
+    }
+  }
+  /**
+   * Turn a failed response into an error the model can act on.
+   *
+   * "HTTP 422: Unprocessable Entity" tells nobody which field was wrong, so a
+   * rejected write used to end the chain with a status line the user could do
+   * nothing with. The body almost always names the problem — FastAPI puts a
+   * loc/msg list in `detail`, most other APIs use `message`, `error` or an
+   * `errors` array — so surface that alongside the status.
+   */
+  _describeHttpError(status, data) {
+    const base = `HTTP ${status}`;
+    const detail = this._extractErrorDetail(data);
+    return detail ? `${base} — ${detail}` : base;
+  }
+  _extractErrorDetail(data) {
+    if (typeof data === "string") {
+      const text = data.trim();
+      return text ? text.slice(0, MAX_ERROR_DETAIL_CHARS) : null;
+    }
+    if (!data || typeof data !== "object") return null;
+    const body = data;
+    const parts = [];
+    for (const key of ["detail", "message", "error", "errors", "error_description"]) {
+      const value = body[key];
+      if (value === void 0 || value === null) continue;
+      if (typeof value === "string") {
+        if (value.trim()) parts.push(value.trim());
+      } else if (Array.isArray(value)) {
+        for (const entry of value.slice(0, MAX_ERROR_DETAIL_ITEMS)) {
+          const described = this._describeFieldError(entry);
+          if (described) parts.push(described);
+        }
+      } else if (typeof value === "object") {
+        for (const [field, msg] of Object.entries(value).slice(0, MAX_ERROR_DETAIL_ITEMS)) {
+          const text = Array.isArray(msg) ? msg.join(", ") : String(msg);
+          parts.push(`${field}: ${text}`);
+        }
+      }
+      if (parts.length > 0) break;
+    }
+    if (parts.length === 0) return null;
+    return parts.join("; ").slice(0, MAX_ERROR_DETAIL_CHARS);
+  }
+  /** One entry of a validation-error list, e.g. FastAPI's {loc, msg, type}. */
+  _describeFieldError(entry) {
+    var _a, _b, _c, _d, _e;
+    if (typeof entry === "string") return entry.trim() || null;
+    if (!entry || typeof entry !== "object") return null;
+    const item = entry;
+    const message = (_c = (_b = (_a = item.msg) != null ? _a : item.message) != null ? _b : item.error) != null ? _c : item.detail;
+    const location = Array.isArray(item.loc) ? item.loc.filter((part) => part !== "body").join(".") : (_e = (_d = item.field) != null ? _d : item.param) != null ? _e : item.name;
+    if (!message) return location ? `${location}: invalid` : null;
+    return location ? `${location}: ${message}` : String(message);
+  }
+  /**
+   * Execute several independent tool calls concurrently.
+   *
+   * The model batches only calls that do not depend on each other's results,
+   * so a batch of four costs roughly one call's wall-clock time instead of
+   * four sequential round trips. Results come back in request order.
+   *
+   * A rejected promise is impossible here — `execute` already converts thrown
+   * errors into a failed ToolExecutionResult — but the settled form is used
+   * anyway so one exception can never discard the whole batch.
+   */
+  async executeBatch(toolCalls, onEach) {
+    const settled = await Promise.allSettled(
+      toolCalls.map(async (toolCall) => {
+        const result = await this.execute(toolCall);
+        onEach == null ? void 0 : onEach(toolCall, result);
+        return result;
+      })
+    );
+    return settled.map((outcome, i) => {
+      if (outcome.status === "fulfilled") return outcome.value;
+      const result = {
+        success: false,
+        error: outcome.reason instanceof Error ? outcome.reason.message : "Unknown error executing tool call"
+      };
+      onEach == null ? void 0 : onEach(toolCalls[i], result);
+      return result;
+    });
+  }
+  _buildHeaders(toolCall) {
+    var _a;
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    const blocked = /* @__PURE__ */ new Set([
+      "authorization",
+      "cookie",
+      "host",
+      "origin",
+      "referer",
+      "x-forwarded-for",
+      "x-real-ip",
+      "content-length",
+      "transfer-encoding",
+      "connection"
+    ]);
+    const canonical = /* @__PURE__ */ new Map();
+    const mergeHeader = (name, value) => {
+      const lower = name.toLowerCase();
+      if (!value || blocked.has(lower)) return;
+      const existing = canonical.get(lower);
+      if (existing !== void 0 && existing !== name) delete headers[existing];
+      canonical.set(lower, name);
+      headers[name] = value;
+    };
+    for (const name of Object.keys(headers)) canonical.set(name.toLowerCase(), name);
+    if (this.authConfig.type === "none") ;
+    else if (this.authConfig.type === "bearer") {
+      const token = this.getAuthToken();
+      if (!token) {
+        throw new Error("No auth token found in browser storage. The user may not be logged in.");
+      }
+      headers.Authorization = `Bearer ${token}`;
+    } else if (this.authConfig.type === "api_key" && this.authConfig.key && this.authConfig.header) {
+      mergeHeader(this.authConfig.header, this.authConfig.key);
+    }
+    if (this.authConfig.headers && typeof this.authConfig.headers === "object") {
+      for (const [name, rawValue] of Object.entries(this.authConfig.headers)) {
+        mergeHeader(name, this._resolveHeaderValue(rawValue));
+      }
+    }
+    if (toolCall.headers && typeof toolCall.headers === "object") {
+      for (const [name, value] of Object.entries(toolCall.headers)) {
+        mergeHeader(name, value);
+      }
+    }
+    for (const declared of (_a = this.authConfig.app_headers) != null ? _a : []) {
+      if (!(declared == null ? void 0 : declared.name)) continue;
+      let value = null;
+      try {
+        value = this.credentials.read("app", declared.name);
+      } catch {
+        value = null;
+      }
+      mergeHeader(declared.name, value);
+    }
+    return headers;
+  }
+  _resolveHeaderValue(value) {
+    if (typeof value === "string") return value;
+    let raw = null;
+    try {
+      raw = this.credentials.read(value.source, value.key);
+    } catch {
+      return null;
+    }
+    if (!raw) return null;
+    if (value.token_field) {
+      try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          const selected = this._readObjectPath(parsed, value.token_field);
+          return typeof selected === "string" ? selected : null;
+        }
+      } catch {
+        return raw;
+      }
+    }
+    return this._extractToken(raw) || raw;
+  }
+  /**
+   * Path template segments that `_buildUrl` would leave unsubstituted.
+   *
+   * A value that is itself a placeholder ("{id}", "<site_id>", "TBD") counts
+   * as unresolved too — substituting it would produce a URL that looks valid
+   * but addresses nothing.
+   */
+  _unresolvedPathParams(toolCall) {
+    const segments = (toolCall.path || "").match(/\{(\w+)\}/g) || [];
+    if (segments.length === 0) return [];
+    const params = toolCall.params || {};
+    const placeholder = /^\s*(?:[{<[].*[}>\]]|[$:].+|tbd|todo|placeholder|unknown|none|null|n\/a)\s*$/i;
+    return segments.map((segment) => segment.slice(1, -1)).filter((name) => {
+      const value = params[name];
+      if (value === void 0 || value === null || value === "") return true;
+      return typeof value === "string" && placeholder.test(value);
+    });
+  }
+  /**
+   * Headers whose value is still a placeholder the model never filled in.
+   *
+   * Worse than an unresolved path segment: a scoping header like X-Site-Id
+   * sent as "{site_id}" does not 404, it answers about whatever the default
+   * record is. Failing the call here is what makes the mistake visible.
+   */
+  _unresolvedHeaders(toolCall) {
+    const headers = toolCall.headers;
+    if (!headers) return [];
+    const placeholder = /^\s*(?:[{<[].*[}>\]]|[$:].+|tbd|todo|placeholder|unknown|none|null|n\/a)\s*$/i;
+    return Object.entries(headers).filter(([, value]) => typeof value === "string" && placeholder.test(value)).map(([name]) => name);
+  }
+  _buildUrl(toolCall) {
+    let path = toolCall.path;
+    const method = toolCall.method.toUpperCase();
+    if (toolCall.params) {
+      for (const [key, value] of Object.entries(toolCall.params)) {
+        const placeholder = `{${key}}`;
+        if (path.includes(placeholder)) {
+          path = path.replace(placeholder, encodeURIComponent(String(value)));
+        }
+      }
+    }
+    let url;
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(path)) {
+      url = path;
+    } else {
+      const origin = this._origin(this.baseUrl);
+      url = path.startsWith("/") ? `${origin}${path}` : `${this.baseUrl}/${path}`;
+    }
+    if (toolCall.params && method === "GET") {
+      const pairs = [];
+      for (const [key, value] of Object.entries(toolCall.params)) {
+        if (!toolCall.path.includes(`{${key}}`)) {
+          pairs.push(`${encodeParam(key)}=${encodeParam(String(value))}`);
+        }
+      }
+      if (pairs.length > 0) {
+        url += (url.includes("?") ? "&" : "?") + pairs.join("&");
+      }
+    }
+    return url;
+  }
+  /** Scheme + authority of a base URL, without its path. */
+  _origin(base) {
+    const match = /^([a-z][a-z0-9+.-]*:\/\/[^/]+)/i.exec(base);
+    return match ? match[1] : base;
+  }
+  _readObjectPath(source, path) {
+    const segments = path.split(".").map((segment) => segment.trim()).filter(Boolean);
+    let current = source;
+    for (const segment of segments) {
+      if (!current || typeof current !== "object" || Array.isArray(current)) {
+        return void 0;
+      }
+      current = current[segment];
+    }
+    return current;
+  }
+}
+class AuthError extends Error {
+  constructor(status) {
+    super("Your session has expired. Please refresh the page or log in again.");
+    this.name = "AuthError";
+    this.status = status;
+  }
+}
+class UsageLimitError extends Error {
+  constructor(detail) {
+    super(detail.message);
+    this.name = "UsageLimitError";
+    this.status = 429;
+    this.limitType = detail.limit_type || "unknown";
+    this.plan = detail.plan || "unknown";
+    this.current = detail.current || 0;
+    this.limit = detail.limit || 0;
+    this.upgradeHint = detail.upgrade_hint || "";
+  }
+}
+class PlanAccessError extends Error {
+  constructor(detail) {
+    super(detail.message || "This feature is not available on the current plan.");
+    this.status = 402;
+    this.name = "PlanAccessError";
+    this.feature = detail.feature || "unknown";
+    this.plan = detail.plan || "unknown";
+    this.upgradeHint = detail.upgrade_hint || "";
+  }
+}
+const _j = (parts) => parts.join("/");
+const _v = ["", "api", "v1"];
+const EP = {
+  feedback: () => _j([..._v, "ml", "feedback"]),
+  weights: () => _j([..._v, "ml", "weights"]),
+  modelInfo: () => _j([..._v, "ml", "model-info"]),
+  guides: () => _j([..._v, "guides", "published"]),
+  guidesRecord: () => _j([..._v, "guides", "record"]),
+  events: () => _j([..._v, "events"]),
+  chatAsk: () => _j([..._v, "chat", "ask"]),
+  chatExecuteTool: () => _j([..._v, "chat", "execute-tool"]),
+  onboardingCurrent: (userId) => `${_j([..._v, "onboarding", "current"])}?user_id=${encodeURIComponent(userId)}`,
+  onboardingObserve: () => _j([..._v, "onboarding", "observe"]),
+  onboardingDismiss: () => _j([..._v, "onboarding", "dismiss"]),
+  onboardingEnroll: () => _j([..._v, "onboarding", "enroll"]),
+  onboardingSkip: () => _j([..._v, "onboarding", "skip"]),
+  onboardingComplete: () => _j([..._v, "onboarding", "complete"]),
+  onboardingWatched: () => _j([..._v, "onboarding", "watched"]),
+  demoSearch: () => _j([..._v, "demos", "search"]),
+  chatRoute: () => _j([..._v, "chat", "route"]),
+  chatOpener: () => _j([..._v, "chat", "opener"]),
+  chatOpenerSpeech: () => _j([..._v, "chat", "opener", "speech"]),
+  chatIntro: () => _j([..._v, "chat", "intro"]),
+  chatEscalate: () => _j([..._v, "chat", "escalate"]),
+  chatEscalationConfig: () => _j([..._v, "chat", "escalate", "config"]),
+  chatConversationWebhook: () => _j([..._v, "chat", "conversation-webhook"]),
+  chatFeedback: () => _j([..._v, "chat", "feedback"]),
+  coachScreen: () => _j([..._v, "chat", "coach", "screen"]),
+  coachAsk: () => _j([..._v, "chat", "coach", "ask"]),
+  coachExplain: () => _j([..._v, "chat", "coach", "explain"]),
+  coachReplan: () => _j([..._v, "chat", "coach", "replan"]),
+  coachConfirm: () => _j([..._v, "chat", "coach", "confirm"]),
+  coachSpeech: () => _j([..._v, "chat", "coach", "speech"]),
+  paymentCheckout: () => _j([..._v, "connectors", "payments", "checkout"]),
+  chatContinue: () => _j([..._v, "chat", "continue-tool-chain"]),
+  /** A Do it run: plan a screen, act, look again (the agent service). */
+  doItRuns: () => _j([..._v, "guide-executions"]),
+  doItRun: (runId, op) => _j([..._v, "guide-executions", encodeURIComponent(runId), ...op ? [op] : []]),
+  chatFormat: () => _j([..._v, "chat", "format-tool-result"]),
+  copilotTools: () => _j([..._v, "copilot-tools", "active"]),
+  copilotStream: () => _j([..._v, "copilot", "stream"]),
+  resolveScore: () => _j([..._v, "resolve", "score"]),
+  resolveLocate: () => _j([..._v, "resolve", "locate"]),
+  resolveRoute: () => _j([..._v, "resolve", "route"]),
+  resolveGraph: () => _j([..._v, "resolve", "graph"]),
+  visitors: () => _j([..._v, "visitors", "register"]),
+  announcements: () => _j([..._v, "announcements"]),
+  pageScan: () => _j([..._v, "page-scan", "scan"]),
+  pageScanReveal: () => _j([..._v, "page-scan", "reveal"]),
+  supportStatus: () => _j([..._v, "support", "public", "status"]),
+  supportConvs: () => _j([..._v, "support", "public", "conversations"]),
+  supportMsgs: (conversationId) => _j([..._v, "support", "public", "conversations", conversationId, "messages"]),
+  realtimeSession: () => _j([..._v, "realtime", "session"]),
+  realtimeTranscriptionSession: () => _j([..._v, "realtime", "transcription", "session"]),
+  realtimeSpeech: () => _j([..._v, "realtime", "speech"]),
+  listenSession: () => _j([..._v, "realtime", "listen", "session"]),
+  speakSession: () => _j([..._v, "realtime", "speak", "session"]),
+  liveSession: () => _j([..._v, "realtime", "live", "session"]),
+  // v=2: neutral voice codes (stream / pipeline / live / live-rtc).
+  voiceCapabilities: () => `${_j([..._v, "realtime", "capabilities"])}?v=2`,
+  liveVoiceMinute: () => _j([..._v, "realtime", "live", "minute"]),
+  batchVoiceTranscribe: () => _j([..._v, "realtime", "batch", "transcribe"]),
+  documentFormSuggestions: () => _j([..._v, "realtime", "document", "form-suggestions"])
+};
+const MAX_CHAIN_ROUNDS = 5;
+const MAX_TOTAL_TOOL_CALLS = 10;
+const MAX_REPAIR_ROUNDS = 1;
+const REPAIRABLE_ERROR_TYPES = /* @__PURE__ */ new Set(["validation", "client", "not_found"]);
+function isServerTool(toolCall) {
+  return (toolCall.method || "").toUpperCase() === "MCP";
+}
+class CopilotHarness {
+  /**
+   * @param tools  How this platform actually touches the screen. Defaults to
+   *   the browser registry so every existing caller is unaffected; a mobile
+   *   runtime passes one that dispatches native effects instead. The loop
+   *   below never learns which it is holding.
+   */
+  constructor(api, config, tools, storage, transport, credentials) {
+    this.toolExecutor = null;
+    this.activeTools = null;
+    this.initialized = false;
+    this.lastPlanFingerprint = null;
+    this.api = api;
+    this.config = config;
+    this.tools = tools;
+    this.transport = transport;
+    this.credentials = credentials;
+    this.memory = new ConversationMemory(
+      config.siteId,
+      config.memoryTtlMs,
+      config.maxMemoryMessages,
+      storage
+    );
+    this.validator = new HarnessValidator();
+    this.validator.setRegisteredTools(this.tools.copilotDefinitions());
+  }
+  /** Hear every turn the conversation records (typed, spoken, replies). */
+  onMessageRecorded(listener) {
+    this.memory.onMessage(listener);
+  }
+  /** Initialize the harness — fetch active tools for the site. */
+  async initialize() {
+    if (this.initialized) return this.isEnabled();
+    try {
+      const response = await this.api.get(
+        EP.copilotTools()
+      );
+      if (response && response.tools && response.tools.length > 0) {
+        this.activeTools = response;
+        this.validator.setRegisteredTools([
+          ...response.tools,
+          ...this.tools.copilotDefinitions()
+        ]);
+        this.toolExecutor = new ToolExecutor(
+          response.auth_config,
+          response.base_url,
+          this.credentials,
+          this.transport
+        );
+      }
+    } catch {
+    }
+    this.initialized = true;
+    return this.isEnabled();
+  }
+  /**
+   * Register the listener that renders the assistant's plan.
+   *
+   * Set on the harness rather than passed per message: `processMessage` is
+   * already called positionally from several places, and a plan belongs to
+   * the UI for the whole session, not to one call.
+   */
+  setPlanCallback(callback) {
+    this.onPlan = callback;
+  }
+  /**
+   * Values the host page supplies for tool inputs.
+   *
+   * Sent with every turn, including chain rounds — a later round builds calls
+   * too, and dropping it there is how a chain that started on the right
+   * record finishes on the default one.
+   */
+  /** Bind to the SDK's analytics session. Carries no message content. */
+  setAnalyticsSessionId(sessionId) {
+    this.config.analyticsSessionId = sessionId;
+  }
+  /** Read the analytics bundle's ids on every question. Ids only. */
+  setAnalyticsIds(read) {
+    this.config.analyticsIds = read;
+  }
+  setToolContext(values) {
+    this.toolContext = values && Object.keys(values).length > 0 ? values : void 0;
+  }
+  /**
+   * The app's tool inputs as the API names them. A value declared in Copilot
+   * Tools as filling other inputs (app key `course` fills `content_id`) is
+   * sent under those names too; one the app set by that name already wins.
+   */
+  contextForTools() {
+    var _a, _b, _c, _d;
+    if (!this.toolContext) return void 0;
+    const out = { ...this.toolContext };
+    for (const input of (_c = (_b = (_a = this.activeTools) == null ? void 0 : _a.auth_config) == null ? void 0 : _b.app_inputs) != null ? _c : []) {
+      const value = (input == null ? void 0 : input.key) ? this.toolContext[input.key] : void 0;
+      if (value === void 0) continue;
+      for (const name of (_d = input.fills) != null ? _d : []) {
+        if (name && !(name in out)) out[name] = value;
+      }
+    }
+    return out;
+  }
+  /** Whether copilot action tools are available for this site. */
+  isEnabled() {
+    return this.tools.definitions().length > 0 || this.activeTools !== null && this.activeTools.tools.length > 0;
+  }
+  /**
+   * Process a user message through the harness.
+   *
+   * 1. Sends question + history + page context to backend /ask
+   * 2. If backend returns SSE stream (agent loop running), reads events in real-time
+   * 3. Calls onStatus callback with progress updates during the loop
+   * 4. Returns the final response when the stream completes
+   * 5. For non-tool queries, returns JSON response directly
+   */
+  async processMessage(question, pageUrl, pageSnapshot, chatMode, onStatus, onTextDelta, onToolCallEvent, abortSignal, userContext, onboardingUserId) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j2, _k;
+    const inputCheck = this.validator.validateUserInput(question);
+    if (!inputCheck.valid) {
+      return this._errorResponse(inputCheck.error || "Invalid input.");
+    }
+    const sanitizedQuestion = inputCheck.sanitized || question;
+    this.lastPlanFingerprint = null;
+    this.currentPlan = void 0;
+    this.memory.addMessage({
+      role: "user",
+      content: sanitizedQuestion,
+      timestamp: Date.now()
+    });
+    const conversationHistory = this.memory.getRecentForLLM(10);
+    const mayForwardToken = ((_b = (_a = this.activeTools) == null ? void 0 : _a.auth_config) == null ? void 0 : _b.forward_user_token) === true;
+    const userToken = mayForwardToken ? (_d = (_c = this.toolExecutor) == null ? void 0 : _c.getAuthToken()) != null ? _d : null : null;
+    let analytics = {};
+    try {
+      analytics = (_g = (_f = (_e = this.config).analyticsIds) == null ? void 0 : _f.call(_e)) != null ? _g : {};
+    } catch {
+    }
+    const requestBody = {
+      question: sanitizedQuestion,
+      page_url: pageUrl,
+      session_id: analytics.session_id || this.config.analyticsSessionId || void 0,
+      distinct_id: analytics.distinct_id || void 0,
+      page_snapshot: pageSnapshot,
+      chat_mode: chatMode || "guidance",
+      assistant_label: ((_h = this.config.assistantLabel) == null ? void 0 : _h.trim()) || void 0,
+      delegate_instruction: ((_i = this.config.delegationInstruction) == null ? void 0 : _i.trim().slice(0, 1e3)) || void 0,
+      conversation_history: conversationHistory,
+      stream: this.api.supportsStreaming,
+      user_token: userToken || void 0,
+      prefer_client_tool_execution: !!this.toolExecutor || this.tools.definitions().length > 0,
+      client_tools: chatMode === "assistant" ? this.tools.definitions() : void 0,
+      user_context: userContext,
+      onboarding_user_id: onboardingUserId,
+      tool_context: this.contextForTools(),
+      client_capabilities: ((_j2 = this.config.clientCapabilities) == null ? void 0 : _j2.length) ? this.config.clientCapabilities : void 0
+    };
+    let rawResponse;
+    try {
+      rawResponse = await this.api.postRaw(EP.chatAsk(), requestBody, abortSignal);
+    } catch (err) {
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        return this._errorResponse("Response cancelled.");
+      }
+      if (err instanceof AuthError) {
+        return this._errorResponse(err.message);
+      }
+      if (err instanceof UsageLimitError || err instanceof PlanAccessError) {
+        throw err;
+      }
+      return this._errorResponse("Failed to get response from server.");
+    }
+    const contentType = rawResponse.headers.get("content-type") || "";
+    if (contentType.includes("text/event-stream")) {
+      return this._readSSEStream(
+        rawResponse,
+        sanitizedQuestion,
+        onStatus,
+        onTextDelta,
+        onToolCallEvent,
+        abortSignal
+      );
+    }
+    let response;
+    try {
+      response = await rawResponse.json();
+    } catch {
+      return this._errorResponse("Failed to parse server response.");
+    }
+    if (onTextDelta && response.answer) {
+      this._emitAnswerText(response.answer, onTextDelta, abortSignal);
+    }
+    const harnessResponse = this._handleJsonResponse(response, chatMode);
+    if (harnessResponse.autoExecuteToolCall && harnessResponse.pendingToolCall) {
+      return this._executePendingToolCall(
+        (_k = harnessResponse.pendingToolCalls) != null ? _k : [harnessResponse.pendingToolCall],
+        sanitizedQuestion,
+        onStatus,
+        onTextDelta,
+        onToolCallEvent
+      );
+    }
+    return harnessResponse;
+  }
+  /**
+   * Execute a confirmed tool call after user approval.
+   * Called when user clicks "Yes, do it" for write/destructive actions.
+   * Executes in the browser when possible, then formats the result with LLM.
+   */
+  async executeToolCall(toolCall, originalQuestion, onStatus, onTextDelta) {
+    if (!this.canExecuteTool(toolCall)) {
+      const errorMsg = "Tool execution is unavailable in this browser context.";
+      this.memory.addMessage({
+        role: "assistant",
+        content: errorMsg,
+        timestamp: Date.now()
+      });
+      return {
+        mode: "answer",
+        answer: errorMsg,
+        toolResult: {
+          success: false,
+          error: errorMsg
+        },
+        autoExecute: false
+      };
+    }
+    const result = await this.executeLocalTool(toolCall);
+    const resultCheck = this.validator.validateToolResultEnhanced(result);
+    if (!resultCheck.valid) {
+      if (REPAIRABLE_ERROR_TYPES.has(resultCheck.errorType || "")) {
+        onStatus == null ? void 0 : onStatus("That did not go through — adjusting the request...");
+        const repaired = await this._continueToolChain(
+          toolCall.tool,
+          { error: resultCheck.detail || result.error || resultCheck.error },
+          originalQuestion,
+          [{
+            tool_name: toolCall.tool,
+            tool_result: { error: resultCheck.detail || result.error || resultCheck.error }
+          }],
+          onStatus,
+          onTextDelta
+        );
+        if (repaired.pendingToolCall || repaired.answer) {
+          return repaired;
+        }
+      }
+      const errorMsg = resultCheck.error || "Tool execution failed.";
+      this.memory.addMessage({
+        role: "assistant",
+        content: errorMsg,
+        toolResult: result,
+        timestamp: Date.now()
+      });
+      return {
+        mode: "answer",
+        answer: errorMsg,
+        toolResult: result,
+        autoExecute: false
+      };
+    }
+    if (resultCheck.warning) {
+      this.memory.addMessage({
+        role: "assistant",
+        content: resultCheck.warning,
+        toolResult: result,
+        timestamp: Date.now()
+      });
+      return {
+        mode: "answer",
+        answer: resultCheck.warning,
+        toolResult: result,
+        autoExecute: false
+      };
+    }
+    return this._formatToolResult(
+      toolCall.tool,
+      result.data,
+      originalQuestion,
+      onStatus,
+      onTextDelta
+    );
+  }
+  /** Alias for executeToolCall. */
+  async confirmAndExecute(toolCall, originalQuestion) {
+    return this.executeToolCall(toolCall, originalQuestion);
+  }
+  /** Get conversation history for display in chat. */
+  getConversationHistory() {
+    return this.memory.getMessages();
+  }
+  /** Recent redacted context for semantic conversational follow-ups. */
+  getRecentConversationContext(count = 8) {
+    return this.memory.getRecentForLLM(count);
+  }
+  /** Persist a completed Realtime turn so voice and text share one history. */
+  recordRealtimeTurn(role, content) {
+    const normalized = content.trim().slice(0, 4e3);
+    if (!normalized) return;
+    this.memory.addMessage({ role, content: normalized, timestamp: Date.now() });
+  }
+  /** Check if there is existing conversation history. */
+  hasHistory() {
+    return this.memory.hasHistory();
+  }
+  /** Clear conversation history. */
+  clearHistory() {
+    this.memory.clear();
+  }
+  // ----------------------------------------------------------------
+  // Private methods
+  // ----------------------------------------------------------------
+  /**
+   * Read SSE events from the backend agent loop stream.
+   * Supports incremental text streaming, tool call display events, and cancellation.
+   * Updates status via callback and resolves with the final response.
+   */
+  async _readSSEStream(rawResponse, originalQuestion, onStatus, onTextDelta, onToolCallEvent, abortSignal) {
+    var _a, _b;
+    if (!rawResponse.stream) {
+      return this._handleJsonResponse(
+        await rawResponse.json(),
+        void 0
+      );
+    }
+    let buffer = "";
+    let finalResponse = null;
+    let accumulatedText = "";
+    const toolCallRecords = [];
+    try {
+      for await (const chunk of rawResponse.stream) {
+        if (abortSignal == null ? void 0 : abortSignal.aborted) break;
+        buffer += chunk;
+        const eventBlocks = buffer.split("\n\n");
+        buffer = eventBlocks.pop() || "";
+        for (const block of eventBlocks) {
+          const trimmedBlock = block.trim();
+          if (!trimmedBlock) continue;
+          for (const rawLine of trimmedBlock.split("\n")) {
+            const line2 = rawLine.trim();
+            if (!line2.startsWith("data: ")) continue;
+            const jsonStr = line2.slice(6);
+            let event;
+            try {
+              event = JSON.parse(jsonStr);
+            } catch {
+              continue;
+            }
+            switch (event.type) {
+              case "status":
+                onStatus == null ? void 0 : onStatus(event.message || "Processing...");
+                break;
+              case "text_delta":
+                if (event.delta) {
+                  accumulatedText += event.delta;
+                  onTextDelta == null ? void 0 : onTextDelta(event.delta);
+                }
+                break;
+              case "tool_call_start":
+                if (event.tool) {
+                  onToolCallEvent == null ? void 0 : onToolCallEvent({
+                    type: "start",
+                    tool: event.tool,
+                    description: event.description
+                  });
+                }
+                onStatus == null ? void 0 : onStatus(event.description ? `${event.description}...` : "Looking up data...");
+                break;
+              case "tool_call_done":
+                if (event.tool) {
+                  toolCallRecords.push({
+                    tool: event.tool,
+                    description: event.description || "",
+                    success: (_a = event.success) != null ? _a : true,
+                    summary: event.summary
+                  });
+                  onToolCallEvent == null ? void 0 : onToolCallEvent({
+                    type: "done",
+                    tool: event.tool,
+                    success: event.success,
+                    summary: event.summary
+                  });
+                }
+                break;
+              case "tool_result":
+                onStatus == null ? void 0 : onStatus(
+                  event.success ? `Got data from ${(event.tool || "").replace(/_/g, " ").slice(0, 40)}...` : "Tool call failed."
+                );
+                break;
+              case "error":
+                finalResponse = {
+                  mode: "answer",
+                  answer: event.message || "An error occurred.",
+                  autoExecute: false
+                };
+                break;
+              case "done":
+                if (event.response) {
+                  finalResponse = this._parseStreamedResponse(event.response);
+                  if (!finalResponse.answer && accumulatedText) {
+                    const stripped = this._stripToolCallArtifacts(accumulatedText);
+                    finalResponse.answer = stripped || "Here is the result of your request.";
+                  }
+                }
+                break;
+            }
+          }
+        }
+      }
+    } catch (err) {
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        if (accumulatedText) {
+          const stripped = this._stripToolCallArtifacts(accumulatedText);
+          const partialResponse = {
+            mode: "answer",
+            answer: stripped || "Response cancelled.",
+            autoExecute: false
+          };
+          this.memory.addMessage({
+            role: "assistant",
+            content: accumulatedText,
+            toolCalls: toolCallRecords.length > 0 ? toolCallRecords : void 0,
+            timestamp: Date.now()
+          });
+          return partialResponse;
+        }
+        return this._errorResponse("Response cancelled.");
+      }
+      console.error("[GuideAI] SSE stream error:", err);
+    }
+    if (!finalResponse && accumulatedText) {
+      const stripped = this._stripToolCallArtifacts(accumulatedText);
+      finalResponse = {
+        mode: "answer",
+        answer: stripped || "Here is the result of your request.",
+        autoExecute: false
+      };
+    }
+    if (finalResponse) {
+      if (finalResponse.autoExecuteToolCall && finalResponse.pendingToolCall) {
+        return this._executePendingToolCall(
+          (_b = finalResponse.pendingToolCalls) != null ? _b : [finalResponse.pendingToolCall],
+          originalQuestion,
+          onStatus,
+          onTextDelta,
+          onToolCallEvent
+        );
+      }
+      this.memory.addMessage({
+        role: "assistant",
+        content: finalResponse.answer,
+        toolResult: finalResponse.toolResult,
+        toolCalls: toolCallRecords.length > 0 ? toolCallRecords : void 0,
+        guideSteps: finalResponse.guideSteps,
+        guideTitle: finalResponse.guideTitle,
+        navigation: finalResponse.navigation,
+        mode: finalResponse.mode,
+        confirmationNeeded: finalResponse.confirmationNeeded,
+        pendingToolCall: finalResponse.pendingToolCall,
+        demo: finalResponse.demo,
+        timestamp: Date.now()
+      });
+      return finalResponse;
+    }
+    return this._errorResponse("Agent loop completed but no response was received.");
+  }
+  /**
+   * Parse the ChatAskResponse from a streamed "done" event into HarnessResponse.
+   */
+  /**
+   * Strip tool_call artifacts from streamed text so raw JSON is never shown.
+   *
+   * Handles:
+   * - Fenced code blocks: ```tool_call\n{...}```
+   * - Bare JSON objects with a "tool" key: {"tool":"list_guides","params":{}}
+   * - Standalone mode: lines (mode: execute)
+   */
+  _stripToolCallArtifacts(text) {
+    let stripped = text.replace(/<thinking\b[^>]*>[\s\S]*?<\/thinking>/gi, "").replace(/^\s*<\/?thinking\b[^>]*>\s*$/gim, "");
+    stripped = stripped.replace(/```tool_\w+\s*\n[\s\S]*?```/g, "").replace(/```tool_\w+[\s\S]*?```/g, "");
+    let result = "";
+    let i = 0;
+    while (i < stripped.length) {
+      if (stripped[i] === "{") {
+        let depth = 0;
+        let j = i;
+        while (j < stripped.length) {
+          if (stripped[j] === "{") depth++;
+          else if (stripped[j] === "}") {
+            depth--;
+            if (depth === 0) break;
+          }
+          j++;
+        }
+        if (depth === 0 && j < stripped.length) {
+          const block = stripped.slice(i, j + 1);
+          let parsed = null;
+          try {
+            parsed = JSON.parse(block);
+          } catch {
+            if (block.includes("{{")) {
+              try {
+                parsed = JSON.parse(block.replace(/\{\{/g, "{").replace(/\}\}/g, "}"));
+              } catch {
+              }
+            }
+          }
+          if (parsed && typeof parsed === "object" && "tool" in parsed) {
+            i = j + 1;
+            continue;
+          }
+        }
+      }
+      result += stripped[i];
+      i++;
+    }
+    result = result.replace(/^\s*mode:\s*\w+\s*$/gm, "");
+    return result.trim();
+  }
+  _parseStreamedResponse(response) {
+    var _a, _b, _c, _d, _e;
+    const respCheck = this.validator.validateResponse(response);
+    const answer = respCheck.sanitized || response.answer || "";
+    if ((_a = response.tool_call) == null ? void 0 : _a.requires_confirm) {
+      return {
+        mode: "answer",
+        answer,
+        confirmationNeeded: true,
+        pendingToolCall: response.tool_call,
+        autoExecute: false
+      };
+    }
+    if (response.tool_call) {
+      return {
+        mode: "answer",
+        answer,
+        pendingToolCall: response.tool_call,
+        pendingToolCalls: ((_b = response.tool_calls) == null ? void 0 : _b.length) ? response.tool_calls : [response.tool_call],
+        autoExecuteToolCall: true,
+        autoExecute: false
+      };
+    }
+    let guideSteps = response.guide_steps || void 0;
+    if (guideSteps && guideSteps.length > 0) {
+      const stepCheck = this.validator.validateGuideSteps(guideSteps);
+      guideSteps = stepCheck.valid ? stepCheck.steps : void 0;
+    }
+    let toolResult;
+    if (response.tool_result) {
+      toolResult = {
+        success: (_c = response.tool_result.success) != null ? _c : true,
+        data: response.tool_result.data,
+        error: response.tool_result.error,
+        status: response.tool_result.status
+      };
+    }
+    return {
+      mode: response.mode || "answer",
+      answer,
+      intent: response.intent,
+      intentReason: response.intent_reason || void 0,
+      guideSteps,
+      guideTitle: response.guide_title || void 0,
+      navigation: response.navigation || void 0,
+      toolResult,
+      autoExecute: false,
+      // disabled — never auto-click/scroll/fill on user's page
+      escalation: response.escalation || void 0,
+      demo: response.demo || void 0,
+      point: response.point || void 0,
+      actions: ((_d = response.actions) == null ? void 0 : _d.length) ? response.actions : void 0,
+      payment: response.payment || void 0,
+      coach: response.coach || void 0,
+      quickReplies: ((_e = response.quick_replies) == null ? void 0 : _e.length) ? response.quick_replies : void 0
+    };
+  }
+  /**
+   * Handle a regular JSON response (non-streaming).
+   */
+  /**
+   * Surface a plan to the UI once per chain.
+   *
+   * The chain revisits the server on every round, and a mid-chain response
+   * may restate the plan. Re-announcing an identical plan would redraw it and
+   * make the assistant look like it had started over, so only a changed plan
+   * is emitted.
+   */
+  _announcePlan(plan) {
+    var _a;
+    if (!plan || !Array.isArray(plan.steps) || plan.steps.length === 0) {
+      return void 0;
+    }
+    const fingerprint = JSON.stringify(plan.steps.map((s) => [s.title, s.tool]));
+    if (fingerprint !== this.lastPlanFingerprint) {
+      this.lastPlanFingerprint = fingerprint;
+      this.currentPlan = plan;
+      (_a = this.onPlan) == null ? void 0 : _a.call(this, plan);
+    }
+    return plan;
+  }
+  _handleJsonResponse(response, chatMode, toolResult) {
+    var _a, _b, _c, _d;
+    const respCheck = this.validator.validateResponse(response);
+    if (!respCheck.valid) {
+      return this._errorResponse(respCheck.error || "Invalid server response.");
+    }
+    const answer = respCheck.sanitized || response.answer;
+    const plan = (_a = this._announcePlan(response.plan)) != null ? _a : this.currentPlan;
+    if (response.tool_call && response.tool_call.requires_confirm) {
+      return {
+        mode: "answer",
+        answer,
+        plan,
+        confirmationNeeded: true,
+        pendingToolCall: response.tool_call,
+        autoExecute: false
+      };
+    }
+    if (response.tool_call) {
+      return {
+        mode: "answer",
+        answer,
+        plan,
+        pendingToolCall: response.tool_call,
+        pendingToolCalls: ((_b = response.tool_calls) == null ? void 0 : _b.length) ? response.tool_calls : [response.tool_call],
+        autoExecuteToolCall: true,
+        autoExecute: false
+      };
+    }
+    let guideSteps = response.guide_steps || void 0;
+    if (guideSteps && guideSteps.length > 0) {
+      const stepCheck = this.validator.validateGuideSteps(guideSteps);
+      if (stepCheck.warnings.length > 0) {
+        console.warn("[GuideAI] Guide step warnings:", stepCheck.warnings);
+      }
+      guideSteps = stepCheck.valid ? stepCheck.steps : void 0;
+    }
+    const harnessResult = {
+      mode: response.mode || "guide",
+      answer,
+      plan,
+      intent: response.intent,
+      intentReason: response.intent_reason || void 0,
+      guideSteps,
+      guideTitle: response.guide_title || void 0,
+      navigation: response.navigation || void 0,
+      toolResult,
+      autoExecute: false,
+      // disabled — never auto-click/scroll/fill on user's page
+      escalation: response.escalation || void 0,
+      demo: response.demo || void 0,
+      point: response.point || void 0,
+      actions: ((_c = response.actions) == null ? void 0 : _c.length) ? response.actions : void 0,
+      payment: response.payment || void 0,
+      coach: response.coach || void 0,
+      quickReplies: ((_d = response.quick_replies) == null ? void 0 : _d.length) ? response.quick_replies : void 0
+    };
+    this.memory.addMessage({
+      role: "assistant",
+      content: answer,
+      toolResult,
+      guideSteps: harnessResult.guideSteps,
+      guideTitle: harnessResult.guideTitle,
+      navigation: harnessResult.navigation,
+      mode: harnessResult.mode,
+      escalation: harnessResult.escalation,
+      demo: harnessResult.demo,
+      timestamp: Date.now()
+    });
+    return harnessResult;
+  }
+  async _continueToolChain(latestToolName, latestToolResult, originalQuestion, toolHistory, onStatus, onTextDelta, latestBatch, budget) {
+    var _a;
+    const conversationHistory = this.memory.getRecentForLLM(6);
+    if (onStatus) {
+      onStatus(
+        (budget == null ? void 0 : budget.forceAnswer) ? "Writing up what I found..." : latestBatch && latestBatch.length > 1 ? "Compiling the information together..." : "Reviewing what came back..."
+      );
+    }
+    const response = await this.api.post(
+      EP.chatContinue(),
+      {
+        original_question: originalQuestion,
+        latest_tool_name: latestToolName,
+        latest_tool_result: latestToolResult,
+        latest_batch: latestBatch != null ? latestBatch : [],
+        conversation_history: conversationHistory,
+        tool_history: toolHistory,
+        tools_remaining: budget == null ? void 0 : budget.toolsRemaining,
+        force_answer: (_a = budget == null ? void 0 : budget.forceAnswer) != null ? _a : false,
+        tool_context: this.contextForTools(),
+        client_tools: this.tools.definitions()
+      }
+    );
+    const harnessResponse = this._handleJsonResponse(
+      response,
+      "assistant",
+      { success: true, data: latestToolResult }
+    );
+    if (!harnessResponse.autoExecuteToolCall && onTextDelta && harnessResponse.answer) {
+      this._emitAnswerText(harnessResponse.answer, onTextDelta);
+    }
+    return harnessResponse;
+  }
+  /**
+   * Remove calls that have already been made in this chain.
+   *
+   * The model is told not to repeat itself, and mostly does not, but a long
+   * chain occasionally re-requests an endpoint it already has — which costs a
+   * request and a model round trip to learn nothing new.
+   */
+  _dropRepeats(toolCalls, executed, callKey) {
+    return toolCalls.filter((call) => !executed.has(callKey(call)));
+  }
+  /**
+   * Run a client-executed tool chain.
+   *
+   * Each round the model may request either one tool or a batch of
+   * independent tools. A batch is executed concurrently, so the wall-clock
+   * cost of gathering four unrelated resources is one request plus one model
+   * round trip, rather than four of each. Dependent calls still arrive one at
+   * a time — the model only batches what it can run without waiting.
+   */
+  async _runClientToolChain(initialToolCalls, originalQuestion, onStatus, onTextDelta, onToolCallEvent) {
+    var _a;
+    if (!this.hasAnyLocalTools()) {
+      return this._errorResponse("Tool execution is unavailable in this browser context.");
+    }
+    const toolHistory = [];
+    const executed = /* @__PURE__ */ new Set();
+    const callKey = (call) => {
+      var _a2, _b;
+      return `${call.tool}:${JSON.stringify((_a2 = call.params) != null ? _a2 : {})}:${JSON.stringify((_b = call.body) != null ? _b : {})}`;
+    };
+    let currentBatch = this._dropRepeats(initialToolCalls, executed, callKey);
+    let toolsRun = 0;
+    let repairsUsed = 0;
+    for (let iteration = 0; currentBatch.length > 0 && iteration < MAX_CHAIN_ROUNDS; iteration += 1) {
+      if (toolsRun + currentBatch.length > MAX_TOTAL_TOOL_CALLS) {
+        currentBatch = currentBatch.slice(0, Math.max(0, MAX_TOTAL_TOOL_CALLS - toolsRun));
+        if (currentBatch.length === 0) break;
+      }
+      currentBatch.forEach((call) => executed.add(callKey(call)));
+      toolsRun += currentBatch.length;
+      const results = await this.executeLocalToolBatch(
+        currentBatch,
+        (toolCall, result) => {
+          const check = this.validator.validateToolResultEnhanced(result);
+          onToolCallEvent == null ? void 0 : onToolCallEvent({
+            type: "done",
+            tool: toolCall.tool,
+            success: check.valid,
+            // The card's badge already shows Complete/Error and its title
+            // already shows the label, so only send extra detail worth
+            // reading — a warning, or why it failed.
+            summary: check.valid ? check.warning : check.error || "Failed"
+          });
+        }
+      );
+      const batchSteps = [];
+      const failures = [];
+      let anyRepairable = false;
+      let lastGoodResult;
+      results.forEach((rawResult, i) => {
+        const toolCall = currentBatch[i];
+        const check = this.validator.validateToolResultEnhanced(rawResult);
+        if (!check.valid) {
+          failures.push(check.error || "Tool execution failed.");
+          if (REPAIRABLE_ERROR_TYPES.has(check.errorType || "")) anyRepairable = true;
+          batchSteps.push({
+            tool_name: toolCall.tool,
+            tool_result: {
+              error: check.detail || rawResult.error || check.error || "Tool execution failed."
+            }
+          });
+          return;
+        }
+        lastGoodResult = rawResult;
+        batchSteps.push({ tool_name: toolCall.tool, tool_result: rawResult.data });
+      });
+      const allFailed = failures.length === results.length;
+      const canRepair = allFailed && anyRepairable && repairsUsed < MAX_REPAIR_ROUNDS;
+      if (allFailed && !canRepair) {
+        const errorMsg = failures[0] || "Tool execution failed.";
+        this.memory.addMessage({
+          role: "assistant",
+          content: errorMsg,
+          toolResult: results[0],
+          timestamp: Date.now()
+        });
+        if (onTextDelta) {
+          onTextDelta(errorMsg);
+        }
+        return {
+          mode: "answer",
+          answer: errorMsg,
+          toolResult: results[0],
+          autoExecute: false
+        };
+      }
+      if (canRepair) {
+        repairsUsed += 1;
+        onStatus == null ? void 0 : onStatus("That did not go through — adjusting and trying again...");
+      }
+      toolHistory.push(...batchSteps);
+      const latestStep = batchSteps[batchSteps.length - 1];
+      const toolsRemaining = Math.max(0, MAX_TOTAL_TOOL_CALLS - toolsRun);
+      const forceAnswer = toolsRemaining === 0 || iteration === MAX_CHAIN_ROUNDS - 1;
+      const continued = await this._continueToolChain(
+        latestStep.tool_name,
+        latestStep.tool_result,
+        originalQuestion,
+        toolHistory,
+        onStatus,
+        onTextDelta,
+        batchSteps,
+        { toolsRemaining, forceAnswer }
+      );
+      const nextBatch = this._dropRepeats(
+        (_a = continued.pendingToolCalls) != null ? _a : continued.pendingToolCall ? [continued.pendingToolCall] : [],
+        executed,
+        callKey
+      );
+      if (continued.autoExecuteToolCall && nextBatch.length > 0) {
+        currentBatch = nextBatch;
+        onStatus == null ? void 0 : onStatus(describeToolBatch(currentBatch));
+        for (const toolCall of currentBatch) {
+          onToolCallEvent == null ? void 0 : onToolCallEvent({
+            type: "start",
+            tool: toolCall.tool,
+            description: describeToolCall(toolCall)
+          });
+        }
+        continue;
+      }
+      if (!continued.toolResult && lastGoodResult) {
+        continued.toolResult = lastGoodResult;
+      }
+      return continued;
+    }
+    if (toolHistory.length > 0) {
+      const last = toolHistory[toolHistory.length - 1];
+      return this._continueToolChain(
+        last.tool_name,
+        last.tool_result,
+        originalQuestion,
+        toolHistory,
+        onStatus,
+        onTextDelta,
+        void 0,
+        { toolsRemaining: 0, forceAnswer: true }
+      );
+    }
+    const fallback = "I gathered several data points but hit the maximum number of tool steps.";
+    this.memory.addMessage({
+      role: "assistant",
+      content: fallback,
+      timestamp: Date.now()
+    });
+    return {
+      mode: "answer",
+      answer: fallback,
+      autoExecute: false
+    };
+  }
+  hasAnyLocalTools() {
+    return !!this.toolExecutor || this.tools.definitions().length > 0;
+  }
+  canExecuteTool(toolCall) {
+    if (isServerTool(toolCall)) return true;
+    if (this.tools.canExecute(toolCall.tool)) {
+      return this.tools.canExecuteCall(toolCall);
+    }
+    return !!this.toolExecutor;
+  }
+  executeLocalTool(toolCall) {
+    if (isServerTool(toolCall)) return this.executeOnServer(toolCall);
+    if (this.tools.canExecute(toolCall.tool)) {
+      return this.tools.execute(toolCall);
+    }
+    if (this.toolExecutor) return this.toolExecutor.execute(toolCall);
+    return Promise.resolve({
+      success: false,
+      error: "Tool execution is unavailable in this browser context.",
+      error_type: "tool_unavailable"
+    });
+  }
+  /**
+   * An MCP tool, after the user approved it: we cannot call it — it is
+   * reached from GuideAI's network with a secret the client never holds —
+   * so the backend runs it, told who the user is by their token.
+   */
+  async executeOnServer(toolCall) {
+    var _a, _b;
+    try {
+      return await this.api.post(EP.chatExecuteTool(), {
+        tool: toolCall.tool,
+        method: toolCall.method,
+        path: toolCall.path,
+        params: toolCall.params,
+        body: toolCall.body,
+        user_token: (_b = (_a = this.toolExecutor) == null ? void 0 : _a.getAuthToken()) != null ? _b : void 0
+      });
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "The tool could not be run.",
+        error_type: "tool_unavailable"
+      };
+    }
+  }
+  executeLocalToolBatch(toolCalls, onComplete) {
+    return Promise.all(toolCalls.map(async (toolCall) => {
+      const result = await this.executeLocalTool(toolCall);
+      onComplete == null ? void 0 : onComplete(toolCall, result);
+      return result;
+    }));
+  }
+  async _formatToolResult(toolName, toolResult, originalQuestion, onStatus, onTextDelta) {
+    const conversationHistory = this.memory.getRecentForLLM(3);
+    try {
+      if (onStatus) {
+        onStatus("Processing results...");
+      }
+      const rawResponse = await this.api.postRaw(
+        EP.chatFormat(),
+        {
+          tool_name: toolName,
+          tool_result: toolResult,
+          original_question: originalQuestion,
+          conversation_history: conversationHistory,
+          stream: this.api.supportsStreaming
+        }
+      );
+      const contentType = rawResponse.headers.get("content-type") || "";
+      if (contentType.includes("text/event-stream")) {
+        return this._readFormatToolResultStream(
+          rawResponse,
+          toolResult,
+          onStatus,
+          onTextDelta
+        );
+      }
+      const formatted = await rawResponse.json();
+      const rawAnswer = (formatted == null ? void 0 : formatted.answer) || "Here is the result of your request.";
+      const answer = this.validator.validateFormattedResponse(
+        rawAnswer,
+        { success: true, data: toolResult }
+      );
+      const navigation = (formatted == null ? void 0 : formatted.navigation) || void 0;
+      const guideSteps = (formatted == null ? void 0 : formatted.guide_steps) || void 0;
+      const guideTitle = (formatted == null ? void 0 : formatted.guide_title) || void 0;
+      const mode = (formatted == null ? void 0 : formatted.mode) === "execute" ? "execute" : "answer";
+      this.memory.addMessage({
+        role: "assistant",
+        content: answer,
+        toolResult: { success: true, data: toolResult },
+        guideSteps,
+        guideTitle,
+        navigation,
+        mode,
+        timestamp: Date.now()
+      });
+      return {
+        mode,
+        answer,
+        guideSteps,
+        guideTitle,
+        navigation,
+        toolResult: { success: true, data: toolResult },
+        autoExecute: false
+      };
+    } catch {
+      const fallback = "I fetched the data successfully but had trouble formatting it.";
+      this.memory.addMessage({
+        role: "assistant",
+        content: fallback,
+        timestamp: Date.now()
+      });
+      return {
+        mode: "answer",
+        answer: fallback,
+        toolResult: { success: true, data: toolResult },
+        autoExecute: false
+      };
+    }
+  }
+  async _readFormatToolResultStream(rawResponse, toolResult, onStatus, onTextDelta) {
+    var _a;
+    let buffer = "";
+    let accumulatedText = "";
+    let finalResponse = null;
+    let streamError = null;
+    if (!rawResponse.stream) {
+      try {
+        finalResponse = await rawResponse.json();
+      } catch {
+        streamError = "I got the data but had trouble formatting it.";
+      }
+    }
+    try {
+      for await (const chunk of (_a = rawResponse.stream) != null ? _a : []) {
+        buffer += chunk;
+        const eventBlocks = buffer.split("\n\n");
+        buffer = eventBlocks.pop() || "";
+        for (const block of eventBlocks) {
+          const trimmedBlock = block.trim();
+          if (!trimmedBlock) continue;
+          for (const rawLine of trimmedBlock.split("\n")) {
+            const line2 = rawLine.trim();
+            if (!line2.startsWith("data: ")) continue;
+            let event;
+            try {
+              event = JSON.parse(line2.slice(6));
+            } catch {
+              continue;
+            }
+            switch (event.type) {
+              case "status":
+                onStatus == null ? void 0 : onStatus(event.message || "Processing results...");
+                break;
+              case "text_delta":
+                if (event.delta) {
+                  accumulatedText += event.delta;
+                  onTextDelta == null ? void 0 : onTextDelta(event.delta);
+                }
+                break;
+              case "error":
+                streamError = event.message || "I got the data but had trouble formatting it.";
+                break;
+              case "done":
+                if (event.format_response) {
+                  finalResponse = event.format_response;
+                }
+                break;
+            }
+          }
+        }
+      }
+    } catch {
+      streamError = "I got the data but had trouble formatting it.";
+    }
+    if (streamError) {
+      this.memory.addMessage({
+        role: "assistant",
+        content: streamError,
+        timestamp: Date.now()
+      });
+      return {
+        mode: "answer",
+        answer: streamError,
+        toolResult: { success: true, data: toolResult },
+        autoExecute: false
+      };
+    }
+    const rawAnswer = (finalResponse == null ? void 0 : finalResponse.answer) || accumulatedText || "Here is the result of your request.";
+    const answer = this.validator.validateFormattedResponse(
+      rawAnswer,
+      { success: true, data: toolResult }
+    );
+    const navigation = (finalResponse == null ? void 0 : finalResponse.navigation) || void 0;
+    const guideSteps = (finalResponse == null ? void 0 : finalResponse.guide_steps) || void 0;
+    const guideTitle = (finalResponse == null ? void 0 : finalResponse.guide_title) || void 0;
+    const mode = (finalResponse == null ? void 0 : finalResponse.mode) === "execute" ? "execute" : "answer";
+    this.memory.addMessage({
+      role: "assistant",
+      content: answer,
+      toolResult: { success: true, data: toolResult },
+      guideSteps,
+      guideTitle,
+      navigation,
+      mode,
+      timestamp: Date.now()
+    });
+    return {
+      mode,
+      answer,
+      guideSteps,
+      guideTitle,
+      navigation,
+      toolResult: { success: true, data: toolResult },
+      autoExecute: false
+    };
+  }
+  async _executePendingToolCall(toolCalls, originalQuestion, onStatus, onTextDelta, onToolCallEvent) {
+    if (toolCalls.length === 0) {
+      return this._errorResponse("No tool call to execute.");
+    }
+    onStatus == null ? void 0 : onStatus(describeToolBatch(toolCalls));
+    for (const toolCall of toolCalls) {
+      onToolCallEvent == null ? void 0 : onToolCallEvent({
+        type: "start",
+        tool: toolCall.tool,
+        description: describeToolCall(toolCall)
+      });
+    }
+    const result = await this._runClientToolChain(
+      toolCalls,
+      originalQuestion,
+      onStatus,
+      onTextDelta,
+      onToolCallEvent
+    );
+    if (!result.toolResult) {
+      onToolCallEvent == null ? void 0 : onToolCallEvent({
+        type: "done",
+        tool: toolCalls[0].tool,
+        success: false,
+        summary: result.answer || "Failed"
+      });
+    }
+    return result;
+  }
+  /**
+   * Emit a fully-buffered answer to the UI.
+   *
+   * This used to fake a typing effect by releasing one word every 12ms. The
+   * response has already arrived in full by this point, so that delay was pure
+   * added latency — a 250-word answer sat behind three seconds of animation
+   * after the data was on the client. Real streaming still arrives token by
+   * token over SSE; a buffered answer is shown as soon as we have it.
+   */
+  _emitAnswerText(text, onTextDelta, abortSignal) {
+    if (abortSignal == null ? void 0 : abortSignal.aborted) return;
+    onTextDelta(text);
+  }
+  _errorResponse(message) {
+    return {
+      mode: "guide",
+      answer: message,
+      autoExecute: false
+    };
+  }
+}
+const REQUEST_ORIGIN_HEADER = "x-guideai-request-origin";
+function parseHeaders(raw) {
+  const map = /* @__PURE__ */ new Map();
+  for (const line2 of (raw != null ? raw : "").split(/\r?\n/)) {
+    const colon = line2.indexOf(":");
+    if (colon <= 0) continue;
+    map.set(line2.slice(0, colon).trim().toLowerCase(), line2.slice(colon + 1).trim());
+  }
+  return { get: (name) => {
+    var _a;
+    return (_a = map.get(name.toLowerCase())) != null ? _a : null;
+  } };
+}
+const RESPONSE_START_TIMEOUT_MS = 2e4;
+class RNHttpTransport {
+  constructor(options = {}) {
+    this.options = options;
+    this.supportsStreaming = typeof XMLHttpRequest !== "undefined";
+  }
+  request(req) {
+    return new Promise((resolve, reject) => {
+      var _a;
+      const xhr = new XMLHttpRequest();
+      xhr.open(req.method, req.url);
+      const headers = { ...req.headers };
+      if (this.options.requestOrigin && !headers[REQUEST_ORIGIN_HEADER]) {
+        headers[REQUEST_ORIGIN_HEADER] = this.options.requestOrigin;
+      }
+      for (const [name, value] of Object.entries(headers)) {
+        xhr.setRequestHeader(name, value);
+      }
+      const doneCallbacks = [];
+      let delivered = 0;
+      let pending = [];
+      let finished = false;
+      let failure2 = null;
+      let wake = null;
+      const push = (chunk) => {
+        if (chunk) pending.push(chunk);
+        wake == null ? void 0 : wake();
+        wake = null;
+      };
+      const drainResponseText = () => {
+        const text = xhr.responseText;
+        if (text.length > delivered) {
+          const slice = text.slice(delivered);
+          delivered = text.length;
+          push(slice);
+        }
+      };
+      let startTimer = null;
+      const clearStartTimer = () => {
+        if (startTimer === null) return;
+        clearTimeout(startTimer);
+        startTimer = null;
+      };
+      const fail = (error) => {
+        clearStartTimer();
+        if (finished) return;
+        failure2 = error;
+        finished = true;
+        push("");
+        reject(error);
+      };
+      let resolved = false;
+      const resolveOnce = () => {
+        if (resolved) return;
+        resolved = true;
+        clearStartTimer();
+        const stream = {
+          async *[Symbol.asyncIterator]() {
+            while (true) {
+              if (pending.length) {
+                const batch = pending;
+                pending = [];
+                for (const chunk of batch) yield chunk;
+                continue;
+              }
+              if (failure2) throw failure2;
+              if (finished) return;
+              await new Promise((wakeUp) => {
+                wake = wakeUp;
+              });
+            }
+          }
+        };
+        const whenDone = new Promise((done, error) => {
+          const settle = () => {
+            if (failure2) error(failure2);
+            else done(xhr.responseText);
+          };
+          if (finished) settle();
+          else doneCallbacks.push(settle);
+        });
+        resolve({
+          status: xhr.status,
+          headers: parseHeaders(xhr.getAllResponseHeaders()),
+          json: async () => JSON.parse(await whenDone),
+          text: () => whenDone,
+          stream
+        });
+      };
+      xhr.onreadystatechange = () => {
+        if (xhr.readyState === 2) {
+          resolveOnce();
+        } else if (xhr.readyState === 3) {
+          resolveOnce();
+          drainResponseText();
+        } else if (xhr.readyState === 4) {
+          resolveOnce();
+          drainResponseText();
+          finished = true;
+          push("");
+          for (const callback of doneCallbacks) callback();
+        }
+      };
+      xhr.onerror = () => fail(new Error(`Network request failed: ${req.method} ${req.url}`));
+      xhr.ontimeout = () => fail(new Error(`Request timed out: ${req.url}`));
+      xhr.onabort = () => fail(new Error(`Request aborted: ${req.url}`));
+      if (req.signal) {
+        if (req.signal.aborted) {
+          fail(new Error(`Request aborted: ${req.url}`));
+          return;
+        }
+      }
+      startTimer = setTimeout(() => {
+        startTimer = null;
+        fail(new Error(
+          `No response after ${RESPONSE_START_TIMEOUT_MS}ms: ${req.method} ${req.url}`
+        ));
+        try {
+          xhr.abort();
+        } catch {
+        }
+      }, RESPONSE_START_TIMEOUT_MS);
+      xhr.send((_a = req.body) != null ? _a : null);
+    });
+  }
+}
+class NativeKVStore {
+  constructor(store) {
+    this.store = store;
+  }
+  getItem(key) {
+    var _a;
+    return (_a = this.store.getString(key)) != null ? _a : null;
+  }
+  setItem(key, value) {
+    this.store.set(key, value);
+  }
+  removeItem(key) {
+    this.store.delete(key);
+  }
+}
+class MemoryStore {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  getItem(key) {
+    var _a;
+    return (_a = this.map.get(key)) != null ? _a : null;
+  }
+  setItem(key, value) {
+    this.map.set(key, value);
+  }
+  removeItem(key) {
+    this.map.delete(key);
+  }
+}
+class RNCredentialSource {
+  constructor(storage, session) {
+    this.storage = storage;
+    this.session = session;
+    this.hostToken = null;
+    this.appValues = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Set by the runtime from `getAuthToken()` before every turn, so the
+   * synchronous read inside a tool call sees the host's current login.
+   */
+  setAuthToken(token) {
+    this.hostToken = (token == null ? void 0 : token.trim()) || null;
+  }
+  authToken() {
+    return this.hostToken;
+  }
+  /** Set from `getRequestHeaders()` before every turn. */
+  setAppValues(values) {
+    this.appValues = new Map(Object.entries(values).map(([k, v]) => [k.toLowerCase(), v]));
+  }
+  read(source, key) {
+    var _a;
+    switch (source) {
+      case "localStorage":
+        return this.storage.getItem(key);
+      case "sessionStorage":
+        return this.session.getItem(key);
+      // A header the toolset declares as supplied by the app.
+      case "app":
+        return (_a = this.appValues.get(key.toLowerCase())) != null ? _a : null;
+      // No cookie jar on a device. Saying so is the honest answer.
+      case "cookie":
+        return null;
+      default:
+        return null;
+    }
+  }
+}
+function rnPlatform(options = {}) {
+  const storage = options.store ? new NativeKVStore(options.store) : new MemoryStore();
+  const session = new MemoryStore();
+  return { storage, session, credentials: new RNCredentialSource(storage, session) };
+}
+const RESERVED_HEADERS = /* @__PURE__ */ new Set(["authorization", "host", "content-length", "cookie"]);
+class HostAuth {
+  constructor(credentials, options = {}) {
+    this.credentials = credentials;
+    this.options = options;
+    this.pendingRenewal = null;
+  }
+  get enabled() {
+    return Boolean(this.options.getAuthToken);
+  }
+  current() {
+    return this.credentials.authToken();
+  }
+  /** Read the host's token and extra headers now. Never throws. */
+  async refresh() {
+    var _a;
+    if (this.options.getRequestHeaders) {
+      let raw = null;
+      try {
+        raw = await this.options.getRequestHeaders();
+      } catch (error) {
+        console.warn("[GuideAI] getRequestHeaders failed; sending none:", error);
+      }
+      const clean = {};
+      for (const [name, value] of Object.entries(raw != null ? raw : {})) {
+        if (/^[A-Za-z0-9-]{1,64}$/.test(name) && !RESERVED_HEADERS.has(name.toLowerCase()) && typeof value === "string" && value && !/[\r\n]/.test(value)) {
+          clean[name] = value;
+        }
+      }
+      this.credentials.setAppValues(clean);
+    }
+    if (!this.options.getAuthToken) return null;
+    let token = null;
+    try {
+      token = ((_a = await this.options.getAuthToken()) == null ? void 0 : _a.trim()) || null;
+    } catch (error) {
+      console.warn("[GuideAI] getAuthToken failed; continuing signed out:", error);
+    }
+    this.credentials.setAuthToken(token);
+    return token;
+  }
+  /**
+   * A new token after a 401, or null when there is none to be had.
+   *
+   * Shared while in flight: a batch of parallel tool calls that all hit an
+   * expired token triggers one refresh, not one per call.
+   */
+  renew() {
+    var _a;
+    if (!this.pendingRenewal) {
+      const ask = (_a = this.options.onAuthExpired) != null ? _a : this.options.getAuthToken;
+      this.pendingRenewal = (async () => {
+        var _a2;
+        let token = null;
+        try {
+          token = ask ? ((_a2 = await ask()) == null ? void 0 : _a2.trim()) || null : null;
+        } catch (error) {
+          console.warn("[GuideAI] onAuthExpired failed:", error);
+        }
+        this.credentials.setAuthToken(token);
+        return token;
+      })().finally(() => {
+        this.pendingRenewal = null;
+      });
+    }
+    return this.pendingRenewal;
+  }
+}
+function bearerOf(headers) {
+  const name = Object.keys(headers).find((key) => key.toLowerCase() === "authorization");
+  const value = name ? headers[name] : "";
+  return (value == null ? void 0 : value.startsWith("Bearer ")) ? value.slice(7) : null;
+}
+class HostAuthTransport {
+  constructor(inner, auth) {
+    this.inner = inner;
+    this.auth = auth;
+  }
+  get supportsStreaming() {
+    return this.inner.supportsStreaming;
+  }
+  async request(req) {
+    const response = await this.inner.request(req);
+    if (response.status !== 401 || !this.auth.enabled) return response;
+    const sent = bearerOf(req.headers);
+    if (!sent || sent !== this.auth.current()) return response;
+    const renewed = await this.auth.renew();
+    if (!renewed || renewed === sent) return response;
+    const headers = { ...req.headers };
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() === "authorization") delete headers[key];
+    }
+    headers.Authorization = `Bearer ${renewed}`;
+    return this.inner.request({ ...req, headers });
+  }
+}
+const KIND_TO_TAG = {
+  button: "button",
+  link: "a",
+  input: "input",
+  text: "p",
+  toggle: "input",
+  image: "img"
+};
+class ScreenRegistry {
+  constructor() {
+    this.elements = /* @__PURE__ */ new Map();
+  }
+  register(element, handlers = {}) {
+    this.elements.set(element.id, { ...element, handlers });
+    return () => {
+      var _a;
+      if (((_a = this.elements.get(element.id)) == null ? void 0 : _a.handlers) === handlers) {
+        this.elements.delete(element.id);
+      }
+    };
+  }
+  get(id) {
+    return this.elements.get(id);
+  }
+  /** Resolve by id first, then by visible label — the model may send either. */
+  find(request) {
+    var _a, _b, _c;
+    if (request.selector) {
+      const byId = this.elements.get(request.selector);
+      if (byId) return byId;
+    }
+    const name = ((_b = (_a = request.name) != null ? _a : request.selector) != null ? _b : "").trim().toLowerCase();
+    if (!name) return void 0;
+    for (const element of this.elements.values()) {
+      if (element.label.trim().toLowerCase() === name) return element;
+      if (((_c = element.accessibilityLabel) == null ? void 0 : _c.trim().toLowerCase()) === name) return element;
+    }
+    return void 0;
+  }
+  all() {
+    return Array.from(this.elements.values());
+  }
+  clear() {
+    this.elements.clear();
+  }
+}
+function toPageElement(element) {
+  var _a;
+  const tag = KIND_TO_TAG[(_a = element.kind) != null ? _a : "button"];
+  return {
+    tag,
+    text: element.label,
+    selector: element.id,
+    ...element.accessibilityLabel ? { aria_label: element.accessibilityLabel } : {},
+    ...element.value !== void 0 ? { value: element.value } : {},
+    ...element.placeholder ? { placeholder: element.placeholder } : {},
+    ...element.hidden ? { hidden: true } : {},
+    ...element.sectionTitle ? { section_title: element.sectionTitle } : {}
+  };
+}
+function buildSnapshot(input) {
+  const elements = input.registry.all().map(toPageElement);
+  return {
+    url: input.path,
+    title: input.title,
+    elements
+  };
+}
+const CLIENT_PATH_PREFIX = "/__guideai/client/";
+const elementProperties = {
+  selector: {
+    type: "string",
+    description: "An element id from the current screen snapshot."
+  },
+  name: {
+    type: "string",
+    description: "Visible text or accessible name when a reliable id is unavailable."
+  }
+};
+const RN_AGENT_TOOL_DEFINITIONS = [
+  {
+    name: "guideai_fill_field",
+    description: "Fill one non-sensitive field on the current screen using its id, label, or accessible name.",
+    consequential: true,
+    parameters: {
+      type: "object",
+      properties: {
+        fieldName: { type: "string", description: "Label, accessible name, or placeholder of the field." },
+        selector: elementProperties.selector,
+        value: { type: "string", description: "The value the user explicitly asked to enter." }
+      },
+      required: ["value"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "guideai_fill_form",
+    description: "Fill several non-sensitive fields on the current screen in order and report each outcome.",
+    consequential: true,
+    parameters: {
+      type: "object",
+      properties: {
+        fields: {
+          type: "array",
+          maxItems: 25,
+          items: {
+            type: "object",
+            properties: {
+              fieldName: { type: "string" },
+              selector: { type: "string" },
+              value: { type: "string" }
+            },
+            required: ["value"]
+          }
+        }
+      },
+      required: ["fields"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "guideai_scroll_to_element",
+    description: "Scroll an element on the current screen into view.",
+    parameters: { type: "object", properties: elementProperties, additionalProperties: false }
+  },
+  {
+    name: "guideai_click_element",
+    description: "Tap one enabled control on the current screen after user confirmation.",
+    consequential: true,
+    parameters: { type: "object", properties: elementProperties, additionalProperties: false }
+  },
+  {
+    name: "guideai_navigate",
+    description: "Navigate to another screen in the app.",
+    consequential: true,
+    parameters: {
+      type: "object",
+      properties: { url: { type: "string", description: "The destination screen name." } },
+      required: ["url"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "guideai_go_back",
+    description: "Go back one screen in the app navigation stack.",
+    consequential: true,
+    parameters: { type: "object", properties: {}, additionalProperties: false }
+  }
+];
+function failure(error, errorType = "action_failed") {
+  return { success: false, error, error_type: errorType };
+}
+function stringArg(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+class RNAgentToolRegistry {
+  constructor(options) {
+    this.options = options;
+    this.queue = Promise.resolve();
+  }
+  definitions() {
+    const available = RN_AGENT_TOOL_DEFINITIONS.filter((tool) => {
+      if (tool.name === "guideai_navigate" || tool.name === "guideai_go_back") {
+        return Boolean(this.options.navigation);
+      }
+      return true;
+    });
+    return available.map((tool) => ({ ...tool, parameters: { ...tool.parameters } }));
+  }
+  copilotDefinitions() {
+    return this.definitions().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      method: "CLIENT",
+      path: `${CLIENT_PATH_PREFIX}${tool.name}`,
+      body_schema: tool.parameters,
+      risk_level: tool.consequential ? "write" : "read"
+    }));
+  }
+  canExecute(name) {
+    return this.definitions().some((tool) => tool.name === name);
+  }
+  canExecuteCall(toolCall) {
+    return toolCall.method.toUpperCase() === "CLIENT" && toolCall.path === `${CLIENT_PATH_PREFIX}${toolCall.tool}` && this.canExecute(toolCall.tool);
+  }
+  execute(toolCall) {
+    var _a, _b;
+    if (!this.canExecuteCall(toolCall)) {
+      return Promise.resolve(failure("Native tool is not registered.", "tool_not_found"));
+    }
+    const args = { ...(_a = toolCall.params) != null ? _a : {}, ...(_b = toolCall.body) != null ? _b : {} };
+    const run = async () => this.executeNow(toolCall.tool, args);
+    const result = this.queue.then(run, run);
+    this.queue = result.then(() => void 0, () => void 0);
+    return result;
+  }
+  executeBatch(toolCalls, onComplete) {
+    return Promise.all(toolCalls.map(async (toolCall) => {
+      const result = await this.execute(toolCall);
+      onComplete == null ? void 0 : onComplete(toolCall, result);
+      return result;
+    }));
+  }
+  async fillOne(field) {
+    var _a, _b;
+    const label = (_b = (_a = field.fieldName) != null ? _a : field.selector) != null ? _b : "field";
+    const registry = this.options.getRegistry();
+    if (!registry) return { field: label, filled: false, error: "no_active_screen" };
+    const element = registry.find({ selector: field.selector, name: field.fieldName });
+    if (!element) return { field: label, filled: false, error: "element_not_found" };
+    if (!element.handlers.setValue) {
+      return { field: label, filled: false, error: "element_not_fillable" };
+    }
+    await element.handlers.setValue(field.value);
+    return { field: element.label, filled: true };
+  }
+  async executeNow(name, args) {
+    var _a;
+    try {
+      const registry = this.options.getRegistry();
+      switch (name) {
+        case "guideai_fill_field": {
+          const outcome = await this.fillOne({
+            fieldName: stringArg(args.fieldName),
+            selector: stringArg(args.selector),
+            value: String((_a = args.value) != null ? _a : "")
+          });
+          return { success: outcome.filled, data: outcome, error: outcome.error };
+        }
+        case "guideai_fill_form": {
+          const requested = Array.isArray(args.fields) ? args.fields.slice(0, 25) : [];
+          const outcomes = [];
+          for (let index = 0; index < requested.length; index += 1) {
+            const entry = requested[index];
+            if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+              outcomes.push({ index, field: `field ${index + 1}`, filled: false, error: "invalid_field" });
+              continue;
+            }
+            if (entry.value == null) {
+              outcomes.push({ index, field: `field ${index + 1}`, filled: false, error: "value_required" });
+              continue;
+            }
+            outcomes.push({ index, ...await this.fillOne({
+              fieldName: stringArg(entry.fieldName),
+              selector: stringArg(entry.selector),
+              value: String(entry.value)
+            }) });
+          }
+          const filledCount = outcomes.filter((outcome) => outcome.filled).length;
+          return {
+            // Matches the browser registry: the tool completed even when a
+            // field was refused. The model needs per-field outcomes to
+            // explain a partial result rather than a transport error.
+            success: outcomes.length > 0,
+            data: { success: outcomes.length > 0 && filledCount === outcomes.length, filledCount, outcomes },
+            error: outcomes.length === 0 ? "fields_required" : void 0
+          };
+        }
+        case "guideai_click_element": {
+          if (!registry) return failure("no_active_screen", "element_not_found");
+          const element = registry.find({ selector: stringArg(args.selector), name: stringArg(args.name) });
+          if (!element) return failure("element_not_found", "element_not_found");
+          if (!element.handlers.press) return failure("element_not_pressable");
+          await element.handlers.press();
+          return { success: true, data: { pressed: element.label } };
+        }
+        case "guideai_scroll_to_element": {
+          if (!registry) return failure("no_active_screen", "element_not_found");
+          const element = registry.find({ selector: stringArg(args.selector), name: stringArg(args.name) });
+          if (!element) return failure("element_not_found", "element_not_found");
+          if (!element.handlers.scrollTo) return failure("element_not_scrollable");
+          await element.handlers.scrollTo();
+          return { success: true, data: { scrolledTo: element.label } };
+        }
+        case "guideai_navigate": {
+          const destination = stringArg(args.url);
+          if (!destination) return failure("url_required");
+          if (!this.options.navigation) return failure("navigation_unavailable");
+          await this.options.navigation.navigate(destination);
+          return { success: true, data: { navigatedTo: destination } };
+        }
+        case "guideai_go_back": {
+          const navigation = this.options.navigation;
+          if (!navigation) return failure("navigation_unavailable");
+          if (navigation.canGoBack && !navigation.canGoBack()) {
+            return failure("no_history");
+          }
+          await navigation.goBack();
+          return { success: true, data: { wentBack: true } };
+        }
+        default:
+          return failure(`Unknown native tool: ${name}`, "tool_not_found");
+      }
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+class GuideAIRuntime {
+  constructor(options = {}) {
+    const platform = rnPlatform({ store: options.store });
+    this.storage = platform.storage;
+    this.credentials = platform.credentials;
+    this.auth = new HostAuth(this.credentials, options.auth);
+    this.transport = new HostAuthTransport(
+      new RNHttpTransport({ requestOrigin: options.requestOrigin }),
+      this.auth
+    );
+    this.tools = new RNAgentToolRegistry({
+      getRegistry: () => {
+        var _a;
+        return (_a = this.active) == null ? void 0 : _a.registry;
+      },
+      navigation: options.navigation
+    });
+  }
+  /**
+   * Called on every navigation. Replacing the whole screen (rather than
+   * merging) is deliberate: elements from the previous screen are gone,
+   * and leaving them visible to the model would have it offer controls
+   * that are no longer mounted.
+   */
+  setActiveScreen(screen) {
+    this.active = screen;
+  }
+  getActiveScreen() {
+    return this.active;
+  }
+  /**
+   * What the host passes as the page snapshot on each turn.
+   *
+   * Returns undefined when no screen is registered — not an empty
+   * snapshot. The difference matters: an empty snapshot asserts "this
+   * screen has no controls", while undefined says "nothing was declared",
+   * and only the second lets the backend fall back to route-level
+   * guidance rather than concluding the screen is bare.
+   */
+  captureSnapshot() {
+    if (!this.active) return void 0;
+    return buildSnapshot({
+      path: this.active.path,
+      title: this.active.title,
+      registry: this.active.registry
+    });
+  }
+}
+const DEFAULT_TIMEOUT_MS = 3e4;
+async function raiseForStatus(response, path) {
+  var _a, _b, _c, _d, _e;
+  if (response.status >= 200 && response.status < 300) return;
+  if (response.status === 401 || response.status === 403) {
+    throw new AuthError(response.status);
+  }
+  let detail = {};
+  try {
+    detail = (_a = await response.json()) != null ? _a : {};
+  } catch {
+    detail = {};
+  }
+  if (response.status === 402) {
+    throw new PlanAccessError({
+      feature: String((_b = detail.feature) != null ? _b : "assistant"),
+      plan: String((_c = detail.plan) != null ? _c : "unknown"),
+      message: typeof detail.message === "string" ? detail.message : void 0
+    });
+  }
+  if (response.status === 429) {
+    throw new UsageLimitError({
+      message: typeof detail.message === "string" ? detail.message : "Usage limit reached",
+      limit_type: String((_d = detail.limit_type) != null ? _d : "requests"),
+      plan: String((_e = detail.plan) != null ? _e : "unknown")
+    });
+  }
+  throw new Error(`HTTP ${response.status} for ${path}`);
+}
+class UploadError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "UploadError";
+  }
+}
+class RNApiClient {
+  constructor(options) {
+    var _a;
+    this.options = options;
+    this.transport = new RNHttpTransport({ requestOrigin: options.requestOrigin });
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.timeoutMs = (_a = options.timeoutMs) != null ? _a : DEFAULT_TIMEOUT_MS;
+  }
+  get supportsStreaming() {
+    return this.transport.supportsStreaming;
+  }
+  headers() {
+    const headers = {
+      "content-type": "application/json",
+      "x-api-key": this.options.publicKey
+    };
+    if (this.options.siteId) headers["x-site-id"] = this.options.siteId;
+    if (this.options.agent) headers["x-guideai-agent"] = this.options.agent;
+    return headers;
+  }
+  url(path) {
+    return path.startsWith("http") ? path : `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+  }
+  /**
+   * Time budget for JSON calls.
+   *
+   * Core's AbortSignal is declared with only `aborted` — it never
+   * originates cancellation — so the deadline is enforced here by racing
+   * rather than by constructing a controller inside the loop.
+   */
+  async withTimeout(work, timeoutMs, path) {
+    let timer;
+    try {
+      return await Promise.race([
+        work,
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(new Error(`Request timed out after ${timeoutMs}ms: ${path}`)),
+            timeoutMs
+          );
+        })
+      ]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
+  async get(path, timeoutMs) {
+    const request = async () => {
+      const response = await this.transport.request({
+        url: this.url(path),
+        method: "GET",
+        headers: this.headers()
+      });
+      await raiseForStatus(response, path);
+      return response.json();
+    };
+    return this.withTimeout(request(), timeoutMs != null ? timeoutMs : this.timeoutMs, path);
+  }
+  async post(path, body, timeoutMs) {
+    const request = async () => {
+      const response = await this.transport.request({
+        url: this.url(path),
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(body != null ? body : {})
+      });
+      await raiseForStatus(response, path);
+      return response.json();
+    };
+    return this.withTimeout(request(), timeoutMs != null ? timeoutMs : this.timeoutMs, path);
+  }
+  /**
+   * Upload a file the device already wrote (a voice recording) as
+   * multipart. XHR rather than fetch: it is the transport this package
+   * already trusts on RN, and it takes RN's `{ uri, name, type }` parts.
+   */
+  async postFile(path, field, file, fields = {}, timeoutMs) {
+    const form = new FormData();
+    form.append(field, file);
+    for (const [name, value] of Object.entries(fields)) form.append(name, value);
+    const headers = this.headers();
+    delete headers["content-type"];
+    if (this.options.requestOrigin) headers[REQUEST_ORIGIN_HEADER] = this.options.requestOrigin;
+    const request = new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.open("POST", this.url(path));
+      for (const [name, value] of Object.entries(headers)) xhr.setRequestHeader(name, value);
+      xhr.onreadystatechange = () => {
+        if (xhr.readyState === 4) resolve({ status: xhr.status, body: xhr.responseText });
+      };
+      xhr.onerror = () => reject(new Error(`Network error for ${path}`));
+      xhr.send(form);
+    });
+    const { status, body } = await this.withTimeout(request, timeoutMs != null ? timeoutMs : this.timeoutMs, path);
+    let parsed = null;
+    try {
+      parsed = body ? JSON.parse(body) : null;
+    } catch {
+      parsed = null;
+    }
+    if (status < 200 || status >= 300) {
+      const detail = parsed == null ? void 0 : parsed.detail;
+      throw new UploadError(status, typeof detail === "string" ? detail : `HTTP ${status} for ${path}`);
+    }
+    return parsed;
+  }
+  async postRaw(path, body, signal) {
+    const response = await this.transport.request({
+      url: this.url(path),
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(body != null ? body : {}),
+      signal
+    });
+    await raiseForStatus(response, path);
+    return response;
+  }
+}
+const RuntimeContext = createContext(void 0);
+const RegistryContext = createContext(void 0);
+let moduleRuntime;
+function configureGuideAI(runtime) {
+  moduleRuntime = runtime;
+}
+function useGuideAIRuntime() {
+  const fromContext = useContext(RuntimeContext);
+  const runtime = fromContext != null ? fromContext : moduleRuntime;
+  if (!runtime) {
+    throw new Error(
+      "GuideAI is not configured. Call configureGuideAI(new GuideAIRuntime({...})) at app startup, or wrap your app in <GuideAIProvider>."
+    );
+  }
+  return runtime;
+}
+function useScreenRegistry() {
+  return useContext(RegistryContext);
+}
+function navigationBridge(source) {
+  const resolve = () => typeof source === "function" ? source() : source;
+  return {
+    navigate(screen) {
+      const ref = resolve();
+      if (!ref || ref.isReady && !ref.isReady()) {
+        throw new Error("navigation_not_ready");
+      }
+      ref.navigate(screen);
+    },
+    goBack() {
+      const ref = resolve();
+      if (!ref || ref.isReady && !ref.isReady()) {
+        throw new Error("navigation_not_ready");
+      }
+      ref.goBack();
+    },
+    canGoBack() {
+      const ref = resolve();
+      if (!ref || ref.isReady && !ref.isReady()) return false;
+      return ref.canGoBack ? ref.canGoBack() : true;
+    }
+  };
+}
+const stamp = () => (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+let seq = 0;
+const next = () => seq += 1;
+function dump(label, value) {
+  let text;
+  try {
+    text = typeof value === "string" ? value : JSON.stringify(value, null, 2);
+  } catch {
+    text = String(value);
+  }
+  console.log(`${label}
+${text}`);
+}
+function line(icon, text) {
+  console.log(`[${stamp()}] ${icon} ${text}`);
+}
+function traceApi(api) {
+  return {
+    supportsStreaming: api.supportsStreaming,
+    async get(path, timeoutMs) {
+      const id = next();
+      line("→", `#${id} GET ${path}`);
+      try {
+        const result = await api.get(path, timeoutMs);
+        dump(`[${stamp()}] ← #${id} GET ${path} responded:`, result);
+        return result;
+      } catch (error) {
+        line("✗", `#${id} GET ${path} FAILED: ${describeError(error)}`);
+        throw error;
+      }
+    },
+    async post(path, body, timeoutMs) {
+      const id = next();
+      dump(`[${stamp()}] → #${id} POST ${path} body:`, body);
+      try {
+        const result = await api.post(path, body, timeoutMs);
+        dump(`[${stamp()}] ← #${id} POST ${path} responded:`, result);
+        return result;
+      } catch (error) {
+        line("✗", `#${id} POST ${path} FAILED: ${describeError(error)}`);
+        throw error;
+      }
+    },
+    async postRaw(path, body, signal) {
+      var _a;
+      const id = next();
+      dump(`[${stamp()}] → #${id} POST ${path} body:`, body);
+      try {
+        const response = await api.postRaw(path, body, signal);
+        line("←", `#${id} ${response.status} ${path} (${(_a = response.headers.get("content-type")) != null ? _a : "no content-type"})`);
+        if (response.stream) {
+          return { ...response, stream: teeStream(response.stream, id) };
+        }
+        return response;
+      } catch (error) {
+        line("✗", `#${id} POST ${path} FAILED: ${describeError(error)}`);
+        throw error;
+      }
+    }
+  };
+}
+function teeStream(stream, id) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      var _a;
+      let buffer = "";
+      for await (const chunk of stream) {
+        buffer += chunk;
+        const parts = buffer.split("\n\n");
+        buffer = (_a = parts.pop()) != null ? _a : "";
+        for (const frame of parts) {
+          const trimmed = frame.trim();
+          if (trimmed) console.log(`[${stamp()}]   ⋯ #${id} frame: ${trimmed}`);
+        }
+        yield chunk;
+      }
+      if (buffer.trim()) console.log(`[${stamp()}]   ⋯ #${id} frame: ${buffer.trim()}`);
+      line("⋯", `#${id} stream ended`);
+    }
+  };
+}
+function traceTransport(transport) {
+  return {
+    supportsStreaming: transport.supportsStreaming,
+    async request(req) {
+      var _a;
+      const id = next();
+      console.log(
+        `[${stamp()}] ⇢ #${id} ${req.method} ${req.url}
+           headers: ${JSON.stringify(req.headers)}
+           body:    ${(_a = req.body) != null ? _a : "(none)"}`
+      );
+      try {
+        const response = await transport.request(req);
+        line("⇠", `#${id} ${response.status} ${req.url}`);
+        return response;
+      } catch (error) {
+        line("✗", `#${id} ${req.method} ${req.url} FAILED: ${describeError(error)}`);
+        throw error;
+      }
+    }
+  };
+}
+function traceTools(tools) {
+  const report = (call, result) => {
+    var _a;
+    if (result.success) {
+      dump(`[${stamp()}] ✓ executed ${call.tool} →`, result.data);
+    } else {
+      line("✗", `${call.tool} FAILED: ${(_a = result.error) != null ? _a : "unknown"}${result.error_type ? ` (${result.error_type})` : ""}`);
+    }
+  };
+  return {
+    definitions: () => tools.definitions(),
+    copilotDefinitions: () => tools.copilotDefinitions(),
+    canExecute: (name) => tools.canExecute(name),
+    canExecuteCall: (call) => tools.canExecuteCall(call),
+    execute: async (call) => {
+      dump(`[${stamp()}] ⚙ TOOL CALL ${call.tool} (${call.method} ${call.path}):`, {
+        params: call.params,
+        body: call.body,
+        requires_confirm: call.requires_confirm
+      });
+      const result = await tools.execute(call);
+      report(call, result);
+      return result;
+    },
+    executeBatch: async (calls, onComplete) => {
+      line("⚙", `BATCH of ${calls.length}: ${calls.map((c) => c.tool).join(", ")}`);
+      return tools.executeBatch(calls, (call, result) => {
+        report(call, result);
+        onComplete == null ? void 0 : onComplete(call, result);
+      });
+    },
+    destroy: tools.destroy ? () => {
+      var _a;
+      return (_a = tools.destroy) == null ? void 0 : _a.call(tools);
+    } : void 0
+  };
+}
+function describeError(error) {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return String(error);
+}
+function traceUserMessage(text) {
+  console.log(`
+${"═".repeat(60)}`);
+  console.log(`[${stamp()}] 👤 YOU: ${text}`);
+  console.log("═".repeat(60));
+}
+function traceAssistantAnswer(text, mode) {
+  console.log(`[${stamp()}] 🤖 ASSISTANT${mode ? ` (${mode})` : ""}:
+${text}`);
+  console.log(`${"═".repeat(60)}
+`);
+}
+const DEFAULT_BASE_URL = "https://cdn.3guideai.com";
+let configured = null;
+function configure(config) {
+  var _a, _b, _c, _d, _e, _f;
+  const debug = (_a = config.debug) != null ? _a : false;
+  const baseApi = new RNApiClient({
+    baseUrl: (_b = config.baseUrl) != null ? _b : DEFAULT_BASE_URL,
+    publicKey: config.apiKey,
+    requestOrigin: config.origin,
+    agent: ((_c = config.agent) == null ? void 0 : _c.trim()) || void 0
+  });
+  const runtime = new GuideAIRuntime({
+    requestOrigin: config.origin,
+    store: config.store,
+    auth: {
+      getAuthToken: config.getAuthToken,
+      onAuthExpired: config.onAuthExpired,
+      getRequestHeaders: config.getRequestHeaders
+    },
+    navigation: config.navigation ? navigationBridge(
+      typeof config.navigation === "function" ? config.navigation : () => config.navigation
+    ) : void 0
+  });
+  configureGuideAI(runtime);
+  const harness = new CopilotHarness(
+    debug ? traceApi(baseApi) : baseApi,
+    {
+      // The site id is resolved server-side from the API key; the
+      // harness only needs a stable string to key its local memory.
+      // Per agent too: a tutor and a course builder in one app must not
+      // read each other's conversation.
+      siteId: ((_d = config.agent) == null ? void 0 : _d.trim()) ? `${config.apiKey}:${config.agent.trim()}` : config.apiKey,
+      assistantLabel: config.assistantName
+    },
+    debug ? traceTools(runtime.tools) : runtime.tools,
+    runtime.storage,
+    debug ? traceTransport(runtime.transport) : runtime.transport,
+    runtime.credentials
+  );
+  if (config.toolContext) harness.setToolContext(config.toolContext);
+  configured = {
+    runtime,
+    harness,
+    api: baseApi,
+    debug,
+    visitorId: (_e = config.visitorId) != null ? _e : null,
+    profile: (_f = config.userProfile) != null ? _f : null
+  };
+}
+function identify(userId) {
+  if (!configured) throw new Error("Call GuideAI.configure() before identify().");
+  configured.visitorId = (userId == null ? void 0 : userId.trim()) || null;
+}
+function setToolContext(values) {
+  if (!configured) throw new Error("Call GuideAI.configure() before setToolContext().");
+  configured.harness.setToolContext(values != null ? values : void 0);
+}
+function setUserProfile(profile) {
+  if (!configured) throw new Error("Call GuideAI.configure() before setUserProfile().");
+  configured.profile = profile;
+}
+function requireConfigured() {
+  if (!configured) {
+    throw new Error(
+      "GuideAI is not configured. Call GuideAI.configure({ apiKey, origin }) at app startup, before rendering <GuideAIChat />."
+    );
+  }
+  return configured;
+}
+function isConfigured() {
+  return configured !== null;
+}
+function reset() {
+  configured = null;
+}
+const GuideAI = { configure, identify, setUserProfile, setToolContext, isConfigured, reset };
+const AUDIO_TYPES = {
+  m4a: "audio/m4a",
+  mp4: "audio/mp4",
+  aac: "audio/aac",
+  caf: "audio/x-caf",
+  wav: "audio/wav",
+  mp3: "audio/mpeg",
+  webm: "audio/webm",
+  ogg: "audio/ogg",
+  "3gp": "audio/3gpp"
+};
+function audioType(uri) {
+  var _a, _b;
+  const extension = ((_a = uri.split("?")[0].split(".").pop()) != null ? _a : "").toLowerCase();
+  const type = (_b = AUDIO_TYPES[extension]) != null ? _b : "audio/m4a";
+  return { type, name: `voice.${AUDIO_TYPES[extension] ? extension : "m4a"}` };
+}
+function replyFields(result, streamed) {
+  var _a, _b;
+  const { text, images } = headlessImages(answerText(result, streamed));
+  const call = result.confirmationNeeded ? result.pendingToolCall : void 0;
+  return {
+    content: text,
+    images: images.length ? images : void 0,
+    suggestions: ((_a = result.quickReplies) == null ? void 0 : _a.length) ? result.quickReplies.slice(0, 4) : void 0,
+    pendingAction: call ? { label: ((_b = call.label) == null ? void 0 : _b.trim()) || describeToolCall(call), tool: call.tool } : void 0
+  };
+}
+let nextId = 0;
+const nextMessageId = () => `m${nextId += 1}`;
+function answerText(result, fallback) {
+  var _a, _b;
+  const answer = ((_a = result.answer) != null ? _a : "").trim();
+  if (answer) return answer;
+  const first = (_b = result.guideSteps) == null ? void 0 : _b[0];
+  const body = typeof (first == null ? void 0 : first.body) === "string" ? first.body.trim() : "";
+  if (body) return body;
+  const title = typeof (first == null ? void 0 : first.title) === "string" ? first.title.trim() : "";
+  if (title) return title;
+  return fallback || "Done.";
+}
+const FAILURE_MESSAGE = "I'm sorry, I can't complete your request right now. Would you like to talk to a human?";
+function useGuideAI(options = {}) {
+  var _a, _b;
+  const runtime = useGuideAIRuntime();
+  const configured2 = requireConfigured();
+  const harness = (_a = options.harness) != null ? _a : configured2.harness;
+  const trace = (_b = options.trace) != null ? _b : configured2.debug;
+  const mode = "assistant";
+  const [messages, setMessages] = useState([]);
+  const [input, setInput] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [status, setStatus] = useState(null);
+  const [transcribing, setTranscribing] = useState(false);
+  const lastQuestion = useRef(null);
+  const pending = useRef(/* @__PURE__ */ new Map());
+  const mounted = useRef(true);
+  useEffect(() => () => {
+    mounted.current = false;
+  }, []);
+  useEffect(() => {
+    if (typeof harness.hasHistory !== "function" || typeof harness.getConversationHistory !== "function") return;
+    if (!harness.hasHistory()) return;
+    setMessages((previous) => {
+      if (previous.length > 0) return previous;
+      return harness.getConversationHistory().filter((entry) => typeof entry.content === "string" && entry.content.trim()).map((entry, index) => {
+        var _a2;
+        return {
+          id: (_a2 = entry.id) != null ? _a2 : `h${index}`,
+          role: entry.role,
+          content: entry.content
+        };
+      });
+    });
+  }, [harness]);
+  const initialized = useRef(null);
+  const ensureInitialized = useCallback(() => {
+    if (!initialized.current) initialized.current = harness.initialize();
+    return initialized.current;
+  }, [harness]);
+  const runTurn = useCallback(async (replyId, question, work) => {
+    var _a2, _b2;
+    setBusy(true);
+    setStatus(null);
+    let streamed = "";
+    const appendDelta = (delta) => {
+      streamed += delta;
+      if (!mounted.current) return;
+      setMessages((prev) => prev.map((message) => message.id === replyId ? { ...message, content: message.content + delta } : message));
+    };
+    try {
+      await ((_a2 = runtime.auth) == null ? void 0 : _a2.refresh());
+      const result = await work((next2) => {
+        if (mounted.current) setStatus(next2);
+      }, appendDelta);
+      if (trace) traceAssistantAnswer((_b2 = result.answer) != null ? _b2 : "(empty)", result.mode);
+      if (result.confirmationNeeded && result.pendingToolCall) {
+        pending.current.set(replyId, { call: result.pendingToolCall, question });
+      }
+      if (!mounted.current) return;
+      setMessages((prev) => prev.map((message) => message.id === replyId ? { ...message, ...replyFields(result, streamed), streaming: false } : message));
+    } catch (error) {
+      console.log("[GuideAI] ✗ turn failed:", error);
+      if (error instanceof Error && error.stack) {
+        console.log("[GuideAI]   stack:", error.stack);
+      }
+      if (!mounted.current) return;
+      setMessages((prev) => prev.map((message) => message.id === replyId ? {
+        ...message,
+        content: FAILURE_MESSAGE,
+        streaming: false,
+        error: true
+      } : message));
+    } finally {
+      if (mounted.current) {
+        setBusy(false);
+        setStatus(null);
+      }
+    }
+  }, [runtime, trace]);
+  const send = useCallback(async (question) => {
+    const text = (question != null ? question : input).trim();
+    if (!text || busy) return;
+    lastQuestion.current = text;
+    if (question === void 0) setInput("");
+    if (trace) traceUserMessage(text);
+    const replyId = nextMessageId();
+    setMessages((prev) => [
+      ...prev,
+      { id: nextMessageId(), role: "user", content: text },
+      { id: replyId, role: "assistant", content: "", streaming: true }
+    ]);
+    await runTurn(replyId, text, async (onStatus, onDelta) => {
+      await ensureInitialized();
+      const screen = runtime.getActiveScreen();
+      const { profile, visitorId } = requireConfigured();
+      return harness.processMessage(
+        text,
+        screen == null ? void 0 : screen.path,
+        runtime.captureSnapshot(),
+        mode,
+        onStatus,
+        onDelta,
+        void 0,
+        void 0,
+        // Who is asking, as the app knows them; the agent pitches to it.
+        profile ? { profile } : void 0,
+        visitorId != null ? visitorId : void 0
+      );
+    });
+  }, [busy, input, harness, mode, runtime, ensureInitialized, trace, runTurn]);
+  const retry = useCallback(async () => {
+    if (!lastQuestion.current || busy) return;
+    setMessages((prev) => prev.slice(0, -2));
+    await send(lastQuestion.current);
+  }, [busy, send]);
+  const clear = useCallback(() => {
+    setMessages([]);
+    lastQuestion.current = null;
+    pending.current.clear();
+  }, []);
+  const settleAction = useCallback((messageId) => {
+    const action = pending.current.get(messageId);
+    pending.current.delete(messageId);
+    setMessages((prev) => prev.map((message) => message.id === messageId ? { ...message, pendingAction: void 0 } : message));
+    return action;
+  }, []);
+  const confirm = useCallback(async (messageId) => {
+    if (busy) return;
+    const action = settleAction(messageId);
+    if (!action) return;
+    const replyId = nextMessageId();
+    setMessages((prev) => [...prev, { id: replyId, role: "assistant", content: "", streaming: true }]);
+    await runTurn(replyId, action.question, async (onStatus, onDelta) => {
+      await ensureInitialized();
+      return harness.executeToolCall(action.call, action.question, onStatus, onDelta);
+    });
+  }, [busy, settleAction, runTurn, ensureInitialized, harness]);
+  const cancel = useCallback((messageId) => {
+    if (!settleAction(messageId)) return;
+    setMessages((prev) => [...prev, { id: nextMessageId(), role: "assistant", content: "Okay, I haven't changed anything." }]);
+  }, [settleAction]);
+  const sendVoice = useCallback(async (recording) => {
+    var _a2;
+    if (busy || transcribing) return { text: null, error: "Wait for the current reply to finish." };
+    const guessed = audioType(recording.uri);
+    setTranscribing(true);
+    try {
+      const result = await requireConfigured().api.postFile(
+        EP.batchVoiceTranscribe(),
+        "audio",
+        { uri: recording.uri, name: guessed.name, type: recording.mimeType || guessed.type },
+        { language_code: recording.languageCode || "en-US" },
+        45e3
+      );
+      const heard = ((_a2 = result == null ? void 0 : result.text) == null ? void 0 : _a2.trim()) || "";
+      if (!heard) return { text: null, error: "I didn't catch that. Please try again." };
+      if (mounted.current) setTranscribing(false);
+      await send(heard);
+      return { text: heard };
+    } catch (error) {
+      console.log("[GuideAI] ✗ voice transcription failed:", error);
+      const message = error instanceof UploadError && error.status === 422 ? error.message : "I couldn't process that recording. Please try again or type your message.";
+      return { text: null, error: message };
+    } finally {
+      if (mounted.current) setTranscribing(false);
+    }
+  }, [busy, transcribing, send]);
+  return {
+    messages,
+    input,
+    setInput,
+    send,
+    busy,
+    canSend: Boolean(input.trim()) && !busy,
+    status,
+    retry,
+    clear,
+    confirm,
+    cancel,
+    sendVoice,
+    transcribing
+  };
+}
+function useOnboarding() {
+  const runtime = useGuideAIRuntime();
+  const [checklist, setChecklist] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const refresh = useCallback(async () => {
+    var _a;
+    const { api, visitorId } = requireConfigured();
+    if (!visitorId) {
+      setChecklist(null);
+      setLoading(false);
+      return;
+    }
+    try {
+      const current = await api.get(EP.onboardingCurrent(visitorId));
+      const screen = (_a = runtime.getActiveScreen()) == null ? void 0 : _a.path;
+      const updated = current && !current.completed && !current.dismissed && screen ? await api.post(EP.onboardingObserve(), { user_id: visitorId, screen }) : current;
+      setChecklist(updated);
+    } catch {
+    } finally {
+      setLoading(false);
+    }
+  }, [runtime]);
+  const dismiss = useCallback(async () => {
+    const { api, visitorId } = requireConfigured();
+    if (!visitorId) return;
+    const updated = await api.post(EP.onboardingDismiss(), { user_id: visitorId });
+    setChecklist(updated);
+  }, []);
+  useEffect(() => {
+    void refresh();
+    const timer = setInterval(() => void refresh(), 5e3);
+    return () => clearInterval(timer);
+  }, [refresh]);
+  return { checklist, loading, refresh, dismiss };
+}
+export {
+  EP as E,
+  GuideAI as G,
+  RegistryContext as R,
+  ScreenRegistry as S,
+  useScreenRegistry as a,
+  useGuideAI as b,
+  useOnboarding as c,
+  requireConfigured as r,
+  useGuideAIRuntime as u
+};
+//# sourceMappingURL=useOnboarding-DAEGoYSs.js.map