@syntrologie/adapt-chatbot 2.28.0 → 2.29.0

package/dist/runtime.js

@@ -9,52 +9,87 @@ import {
   decodeMutationEnvelope,
   fetchMountedElements,
   renderFallbackHtml
-} from "./chunk-KUO67E2W.js";
-import "./chunk-QELVKBQV.js";
-import "./chunk-DOMEUJR7.js";
-import "./chunk-UC4XU6GH.js";
-import "./chunk-AUER7ZCK.js";
-import "./chunk-435KJD27.js";
+} from "./chunk-ZXV4GXMO.js";
+import {
+  pickPersona
+} from "./chunk-FXHYE6FY.js";
+import {
+  getElementInstanceStore,
+  setElementInstanceStore
+} from "./chunk-EWPPVPJ4.js";
+import "./chunk-A7RBZLIX.js";
+import "./chunk-VZIUXXAM.js";
+import "./chunk-OIGVZGSX.js";
+import {
+  DIVE_DEEPER_EVENT,
+  TILE_MOUNTED_EVENT,
+  TILE_UNMOUNTED_EVENT
+} from "./chunk-EACGDSJI.js";
 import "./chunk-UVKRO5ER.js";
 
 // src/ChatSession.ts
-var CHAT_SESSION_STORAGE_KEY = "syntro:chat:v1";
-function isValidMessage(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const m = value;
-  return (typeof m.id === "number" || typeof m.id === "string") && (m.role === "user" || m.role === "assistant" || m.role === "system") && typeof m.text === "string";
-}
-function loadFromStorage() {
-  try {
-    const raw = globalThis.localStorage?.getItem(CHAT_SESSION_STORAGE_KEY);
-    if (!raw) return null;
-    const parsed = JSON.parse(raw);
-    if (!parsed || !Array.isArray(parsed.messages)) return null;
-    const messages = parsed.messages.filter(isValidMessage);
-    const nextId = typeof parsed.nextId === "number" ? parsed.nextId : messages.length + 1;
-    return { messages, nextId };
-  } catch {
-    return null;
-  }
+var _userIdCounter = 0;
+function generateUserMessageId() {
+  return `user-${Date.now()}-${++_userIdCounter}`;
 }
 var ChatSession = class {
   constructor() {
     this._messages = [];
     this._inFlight = false;
+    this._runActive = false;
+    this._thinkingText = "";
     this._nextId = 1;
     this.subscribers = /* @__PURE__ */ new Set();
     this.sendListeners = /* @__PURE__ */ new Set();
     this.interruptListeners = /* @__PURE__ */ new Set();
     this.toolResultListeners = /* @__PURE__ */ new Set();
-    const restored = loadFromStorage();
-    if (restored) {
-      this._messages = restored.messages;
-      this._nextId = restored.nextId;
-    }
   }
   /** Snapshot the current state. Always returns a fresh immutable view. */
   getState() {
-    return { messages: [...this._messages], inFlight: this._inFlight };
+    return {
+      messages: [...this._messages],
+      inFlight: this._inFlight || this._runActive,
+      thinkingText: this._thinkingText
+    };
+  }
+  /**
+   * Append a delta to the active thinking turn's narration buffer.
+   * Forwarded from the AG-UI THINKING_TEXT_MESSAGE_CONTENT event so
+   * the chat trail can render the model's own reasoning instead of
+   * silent loading dots between turns.
+   */
+  appendThinkingDelta(delta) {
+    if (!delta) return;
+    this._thinkingText += delta;
+    this.notify();
+  }
+  /**
+   * Replace the active thinking narration outright (vs. appendThinkingDelta's
+   * streaming accumulation). Used to surface tool-call progress — e.g.
+   * "Searching…" while the agent works a tool — so a long tool phase shows
+   * what's happening instead of silent dots. No-op if unchanged.
+   */
+  setThinkingText(text) {
+    if (this._thinkingText === text) return;
+    this._thinkingText = text;
+    this.notify();
+  }
+  /**
+   * End the active thinking turn — drop any narration so the trail
+   * stops showing it. Fires on real text-message-start and on
+   * tool-call-start, the moment the model switches from reasoning
+   * to visible output.
+   */
+  clearThinking() {
+    if (!this._thinkingText) return;
+    this._thinkingText = "";
+    this.notify();
+  }
+  setRunActive(active) {
+    if (this._runActive === active) return;
+    this._runActive = active;
+    if (!active) this._thinkingText = "";
+    this.notify();
   }
   /**
    * Subscribe to state changes. Called immediately with the current
@@ -76,11 +111,13 @@ var ChatSession = class {
   send(text, opts) {
     const trimmed = text.trim();
     if (!trimmed) return;
-    this._messages.push({ id: this._nextId++, role: "user", text: trimmed });
+    const id = generateUserMessageId();
+    this._messages.push({ id, role: "user", text: trimmed });
     this._inFlight = true;
     this.notify();
-    const event = { text: trimmed };
+    const event = { text: trimmed, id };
     if (opts?.activeLidSlot) event.activeLidSlot = opts.activeLidSlot;
+    if (opts?.forwardedProps) event.forwardedProps = opts.forwardedProps;
     for (const listener of this.sendListeners) listener(event);
   }
   /**
@@ -133,7 +170,9 @@ var ChatSession = class {
    * message as 'error' (so the trail can render a styled error chip
    * instead of pretending the partial text was a complete answer),
    * appends a system-role message with the error text for visibility,
-   * and clears inFlight.
+   * and clears inFlight. Also drops any pending thinking narration
+   * — leaving stale "Let me check…" alongside an error chip reads
+   * as if the assistant is still working when it isn't.
    */
   error(message) {
     for (const m of this._messages) {
@@ -146,16 +185,23 @@ var ChatSession = class {
       status: "error"
     });
     this._inFlight = false;
+    this._runActive = false;
+    this._thinkingText = "";
     this.notify();
   }
   /**
    * User clicked the in-flight stop button. Clears inFlight and
    * fires an "interrupt" event so transports can cancel their
-   * in-flight request. No-op if not in-flight (idempotent).
+   * in-flight request. No-op if not in-flight (idempotent). Drops
+   * any pending thinking narration for the same reason as error():
+   * the visitor explicitly asked the assistant to stop, so it
+   * shouldn't keep narrating in the trail.
    */
   interrupt() {
-    if (!this._inFlight) return;
+    if (!this._inFlight && !this._runActive) return;
     this._inFlight = false;
+    this._runActive = false;
+    this._thinkingText = "";
     this.notify();
     for (const listener of this.interruptListeners) listener();
   }
@@ -166,6 +212,8 @@ var ChatSession = class {
   reset() {
     this._messages = [];
     this._inFlight = false;
+    this._runActive = false;
+    this._thinkingText = "";
     this._nextId = 1;
     this.notify();
   }
@@ -260,26 +308,61 @@ var ChatSession = class {
       listener({ toolCallId, result, approved });
     }
   }
+  /**
+   * Hydrate from the server transcript (the /session SSE's
+   * messages-snapshot) — the server is the transcript of record
+   * (FEAT-1783701440). Snapshot order is truth: shared ids keep the
+   * LOCAL object (it may carry richer live tool-call state) but take the
+   * snapshot's position; snapshot-only messages (history on reload, a
+   * nudge missed during an SSE gap) are inserted; local-only messages
+   * (an in-flight turn, the greeting) float after in local order.
+   *
+   * Deploy-boundary guard: a user message persisted under a pre-Phase-2
+   * transport id (before ids were threaded) would arrive as
+   * "snapshot-only" next to its local twin — skip snapshot USER messages
+   * whose exact text already exists locally under a different id.
+   */
+  hydrate(snapshotMessages) {
+    if (!snapshotMessages.length) return;
+    const localById = new Map(this._messages.map((m) => [String(m.id), m]));
+    const twinBudget = /* @__PURE__ */ new Map();
+    for (const m of this._messages) {
+      if (m.role === "user") twinBudget.set(m.text, (twinBudget.get(m.text) ?? 0) + 1);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const sm of snapshotMessages) {
+      const key = String(sm.id);
+      const local = localById.get(key);
+      if (local) {
+        seen.add(key);
+        merged.push(local);
+        continue;
+      }
+      if (sm.role === "user") {
+        const budget = twinBudget.get(sm.text) ?? 0;
+        if (budget > 0) {
+          twinBudget.set(sm.text, budget - 1);
+          continue;
+        }
+      }
+      merged.push(sm);
+    }
+    for (const m of this._messages) {
+      if (!seen.has(String(m.id))) merged.push(m);
+    }
+    this._messages = merged;
+    this.notify();
+  }
   notify() {
     const state = this.getState();
-    this.persist();
     for (const sub of this.subscribers) sub(state);
   }
-  persist() {
-    try {
-      if (this._messages.length === 0) {
-        globalThis.localStorage?.removeItem(CHAT_SESSION_STORAGE_KEY);
-        return;
-      }
-      const payload = { messages: this._messages, nextId: this._nextId };
-      globalThis.localStorage?.setItem(CHAT_SESSION_STORAGE_KEY, JSON.stringify(payload));
-    } catch {
-    }
-  }
 };
 var chatSession = new ChatSession();
 
 // src/ChatTransport.ts
+var SESSION_READ_DEADLINE_MS = 6e4;
 var FALLBACK_DEBOUNCE_MS = 1500;
 function readSyntroToken() {
   if (typeof window === "undefined") return void 0;
@@ -293,6 +376,38 @@ function debug(...args) {
     console.debug("[chat-transport]", ...args);
   }
 }
+function parseToolCallArgs(toolCall) {
+  if (toolCall.args && typeof toolCall.args === "object") return toolCall.args;
+  const buf = toolCall.argsBuffer;
+  if (!buf) return null;
+  try {
+    const parsed = JSON.parse(buf);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function toolNarrationVariants(name) {
+  const n = (name || "").toLowerCase();
+  if (n.includes("search") || n.includes("retrieve"))
+    return ["Assembling relevant information", "Pulling together what matters for you"];
+  if (n.includes("route"))
+    return ["Diving deeper on specific products for you", "Exploring the best options for you"];
+  if (n.includes("read") || n.includes("section") || n.includes("overview"))
+    return ["Buttoning up details to point the right way", "Lining up the details for you"];
+  if (n.includes("selector"))
+    return ["Finalizing where to guide you", "Pinpointing the right spot for you"];
+  if (n.includes("wiki"))
+    return ["Looking that up for you", "Checking the knowledge base for you"];
+  if (n.includes("mount") || n.includes("unmount") || n.includes("element") || n.includes("response") || n.includes("primary") || n.includes("action"))
+    return ["Materializing the information for you", "Bringing it onto your screen"];
+  return ["Putting your answer together for you", "Almost there"];
+}
+function mergeForwardedProps(prev, next) {
+  if (next.forwardedProps !== void 0) return next;
+  if (!prev?.forwardedProps) return next;
+  return { ...next, forwardedProps: prev.forwardedProps };
+}
 var ChatTransport = class {
   constructor() {
     this._config = null;
@@ -305,6 +420,12 @@ var ChatTransport = class {
     this._connectInFlight = null;
     /** Bounded streaming-message id for the currently-being-typed assistant turn. */
     this._currentAssistantMessageId = null;
+    /** Intent messageIds this transport actually dispatched (BUG-1784021805).
+     *  The server's `suppressToast` hint assumes the intent frame reached us —
+     *  but that frame is fire-and-forget, and a fresh visitor's connection gap
+     *  loses it. Only the transport knows what it dispatched, so suppression is
+     *  honored ONLY when the sibling intent (`{id}-intent`) went through here. */
+    this._dispatchedNudgeIntentIds = /* @__PURE__ */ new Set();
     /** Outcome bookkeeping for telemetry. */
     this._hadTurnstileToken = null;
     /** Count of successful round-trips for telemetry payloads. */
@@ -324,8 +445,28 @@ var ChatTransport = class {
      * pins the header to the bar that actually sent the message.
      */
     this._pendingLidSlot = null;
+    /**
+     * Per-send forwardedProps override. Set in the ``chatSession.onSend``
+     * listener before each ``_forwardUserMessage`` and spread OVER the
+     * config-level forwardedProps for that one request (see
+     * ``_resolveForwardedProps``). Overwritten on EVERY send — ``null`` when
+     * the send carried no envelope — so turn provenance can never leak onto a
+     * later typed message and make it look synthetic. Same lifecycle as
+     * ``_pendingLidSlot``.
+     */
+    this._pendingForwardedProps = null;
     /** Active debounce timer; null when no debounce pending. */
     this._errorDebounceTimer = null;
+    /** Rotates thinking-chip phrasings during a long/looping tool phase (C9). */
+    this._thinkingCycleTimer = null;
+    /**
+     * Per-class rotation counter, keyed by the narration set's first variant.
+     * A NEW tool class shows its primary (variant A) so it's recognizable; a
+     * REPEATED same-class call advances to the next variant, so a research loop
+     * of (e.g.) several searches reads as different thinking, not one repeated
+     * label. Bounded to ~6 keys (one per tool class).
+     */
+    this._thinkingClassSeq = /* @__PURE__ */ new Map();
     /** Most recent error payload, captured so debounced fallback can attach it. */
     this._lastErrorPayload = null;
     this._fallbackListeners = /* @__PURE__ */ new Set();
@@ -337,6 +478,14 @@ var ChatTransport = class {
      */
     this._transportId = `tx_${Math.random().toString(36).slice(2, 8)}`;
     this._configuredAt = 0;
+    // -------------------------------------------------------------------------
+    // Session stream — server-initiated events (proactive nudges)
+    // -------------------------------------------------------------------------
+    /** AbortController for the live /session SSE reader; null = not running. */
+    this._sessionStreamAbort = null;
+    // (read-deadline constant lives at module scope: SESSION_READ_DEADLINE_MS)
+    /** Capped reconnect backoff for the session stream. */
+    this._sessionStreamBackoffMs = 2e3;
   }
   /**
    * Configure the transport. Idempotent — calling again with the same
@@ -346,7 +495,7 @@ var ChatTransport = class {
   configure(config) {
     const same = this._config && this._config.backendUrl === config.backendUrl && this._config.threadId === config.threadId;
     if (same) {
-      this._config = { ...this._config, ...config };
+      this._config = { ...this._config, ...mergeForwardedProps(this._config, config) };
       return;
     }
     this._disconnect();
@@ -394,6 +543,22 @@ var ChatTransport = class {
   simulateError(payload) {
     this._handleErrorEvent(payload);
   }
+  /**
+   * Test seam — drive the FULL server-error path (fallback kernel + the
+   * visitor-facing chip), exactly what the `case 'error'` transport-event
+   * branch does. `midAnswer` simulates an assistant message having been
+   * mid-stream when the connection died.
+   */
+  simulateServerError(payload) {
+    if (payload.midAnswer) this._currentAssistantMessageId = "test-mid-answer";
+    this._onTransportEvent({
+      type: "error",
+      message: payload.message ?? "boom",
+      status: payload.status ?? null,
+      body: payload.body ?? null,
+      errorName: payload.errorName ?? null
+    });
+  }
   /**
    * Test seam — register a synthetic successful message-complete so
    * the hasSucceeded gate flips without a real AgUi round-trip.
@@ -440,6 +605,8 @@ var ChatTransport = class {
       this._agui = null;
     }
     this._clearDebounceTimer();
+    this._stopThinkingCycle();
+    this._thinkingClassSeq.clear();
     this._config = null;
     this._status = "idle";
     this._connectInFlight = null;
@@ -450,6 +617,7 @@ var ChatTransport = class {
     this._fallbackRendered = false;
     this._lastErrorPayload = null;
     this._pendingLidSlot = null;
+    this._pendingForwardedProps = null;
   }
   /**
    * Tear everything down — connection state PLUS host listeners.
@@ -460,6 +628,142 @@ var ChatTransport = class {
   reset() {
     this._disconnect();
     this._fallbackListeners.clear();
+    this._dispatchedNudgeIntentIds.clear();
+    this.stopSessionStream();
+  }
+  /**
+   * Open the persistent `/api/adaptive/session` SSE and feed its frames
+   * through the SAME `_onTransportEvent` switch the AG-UI path uses
+   * (FEAT-1783640628 — proactive nudges).
+   *
+   * The AG-UI cutover left this endpoint with no client consumer, so
+   * server-INITIATED events had nowhere to land. A fetch-based reader —
+   * unlike EventSource — can send the SDK token, and the visitor ids that
+   * write the server's nudge identity bridge. Idempotent; reconnects with
+   * capped backoff; `reset()`/`stopSessionStream()` tears it down.
+   */
+  async startSessionStream() {
+    if (this._sessionStreamAbort || !this._config) return;
+    const abort = new AbortController();
+    this._sessionStreamAbort = abort;
+    const baseUrl = this._config.backendUrl.replace(/\/$/, "");
+    const url = `${baseUrl}/api/adaptive/session`;
+    const headers = {};
+    const token = readSyntroToken();
+    if (token) headers.Authorization = `Bearer ${token}`;
+    const cft = await this._acquireTurnstileWithChallenge();
+    if (cft) headers["CF-Turnstile-Token"] = cft;
+    if (abort.signal.aborted) return;
+    const readIds = () => {
+      try {
+        const rt = this._config?.runtime;
+        const did = rt?.telemetry?.getDistinctId?.();
+        const sid = rt?.telemetry?.getSessionId?.();
+        return {
+          did: typeof did === "string" && did.length > 0 ? did : void 0,
+          sid: typeof sid === "string" && sid.length > 0 ? sid : void 0
+        };
+      } catch {
+        return {};
+      }
+    };
+    const hasTelemetryAccessor = () => {
+      try {
+        const rt = this._config?.runtime;
+        return typeof rt?.telemetry?.getDistinctId === "function";
+      } catch {
+        return false;
+      }
+    };
+    let ids = readIds();
+    for (let i = 0; i < 80 && hasTelemetryAccessor() && !ids.did && !abort.signal.aborted; i++) {
+      await new Promise((r) => setTimeout(r, 250));
+      ids = readIds();
+    }
+    if (abort.signal.aborted) return;
+    if (ids.did) headers["X-Distinct-Id"] = ids.did;
+    if (ids.sid) headers["X-Syntro-Session"] = ids.sid;
+    const runReader = async () => {
+      const connAbort = new AbortController();
+      const onOuterAbort = () => connAbort.abort();
+      abort.signal.addEventListener("abort", onOuterAbort, { once: true });
+      const abortRejection = new Promise((_, reject) => {
+        connAbort.signal.addEventListener(
+          "abort",
+          () => reject(new Error("session stream read deadline exceeded")),
+          { once: true }
+        );
+      });
+      abortRejection.catch(() => {
+      });
+      try {
+        const response = await fetch(url, {
+          headers,
+          credentials: "include",
+          signal: connAbort.signal
+        });
+        if (!response.ok || !response.body) {
+          throw new Error(`session stream connect failed: ${response.status}`);
+        }
+        this._sessionStreamBackoffMs = 2e3;
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        for (; ; ) {
+          const deadline = setTimeout(() => connAbort.abort(), SESSION_READ_DEADLINE_MS);
+          let result;
+          try {
+            result = await Promise.race([reader.read(), abortRejection]);
+          } catch (err) {
+            void reader.cancel().catch(() => {
+            });
+            throw err;
+          } finally {
+            clearTimeout(deadline);
+          }
+          const { done, value } = result;
+          if (done) return;
+          buffer += decoder.decode(value, { stream: true });
+          let sep = buffer.indexOf("\n\n");
+          while (sep >= 0) {
+            const frame = buffer.slice(0, sep);
+            buffer = buffer.slice(sep + 2);
+            sep = buffer.indexOf("\n\n");
+            const data = frame.split("\n").filter((l) => l.startsWith("data: ")).map((l) => l.slice(6)).join("");
+            if (!data) continue;
+            try {
+              this._onTransportEvent(JSON.parse(data));
+            } catch (err) {
+              console.warn("[adaptive-chatbot] session-stream frame parse failed", err);
+            }
+          }
+        }
+      } finally {
+        abort.signal.removeEventListener("abort", onOuterAbort);
+      }
+    };
+    void (async () => {
+      while (!abort.signal.aborted) {
+        try {
+          await runReader();
+        } catch (err) {
+          if (abort.signal.aborted) return;
+          console.warn("[adaptive-chatbot] session stream dropped; reconnecting", err);
+        }
+        if (abort.signal.aborted) return;
+        await new Promise((r) => setTimeout(r, this._sessionStreamBackoffMs));
+        this._sessionStreamBackoffMs = Math.min(this._sessionStreamBackoffMs * 2, 3e4);
+        const fresh = readIds();
+        if (fresh.did) headers["X-Distinct-Id"] = fresh.did;
+        if (fresh.sid) headers["X-Syntro-Session"] = fresh.sid;
+      }
+    })();
+    await Promise.resolve();
+  }
+  stopSessionStream() {
+    this._sessionStreamAbort?.abort();
+    this._sessionStreamAbort = null;
+    this._sessionStreamBackoffMs = 2e3;
   }
   _clearDebounceTimer() {
     if (this._errorDebounceTimer) {
@@ -467,6 +771,36 @@ var ChatTransport = class {
       this._errorDebounceTimer = null;
     }
   }
+  /**
+   * Show a per-call rotating variant in the thinking chip immediately (so
+   * consecutive tool calls differ), then rotate through the remaining phrasings
+   * every 4s while the same tool phase runs (C9). A
+   * single tool call can sit for tens of seconds (the model reasoning about the
+   * next step, or a slow retrieval); a static chip reads as frozen and hides a
+   * loop. Cycling makes a long/looping phase read as live progress. Restarting
+   * (a new tool), any output (message/thinking), or teardown clears the cycle.
+   */
+  _startThinkingCycle(variants) {
+    this._stopThinkingCycle();
+    const key = variants[0] ?? "";
+    const seq = this._thinkingClassSeq.get(key) ?? 0;
+    this._thinkingClassSeq.set(key, seq + 1);
+    let i = variants.length > 0 ? seq % variants.length : 0;
+    chatSession.setThinkingText(variants[i] ?? "Working on it\u2026");
+    if (variants.length < 2) return;
+    const id = setInterval(() => {
+      if (this._thinkingCycleTimer !== id) return;
+      i = (i + 1) % variants.length;
+      chatSession.setThinkingText(variants[i]);
+    }, 4e3);
+    this._thinkingCycleTimer = id;
+  }
+  _stopThinkingCycle() {
+    if (this._thinkingCycleTimer) {
+      clearInterval(this._thinkingCycleTimer);
+      this._thinkingCycleTimer = null;
+    }
+  }
   /**
    * Shared error-handling kernel — called by the AG-UI subscriber and
    * by the simulateError test seam. Publishes transport_error
@@ -484,6 +818,7 @@ var ChatTransport = class {
       body,
       errorName: payload.errorName ?? null
     };
+    this._stopThinkingCycle();
     this._config?.runtime.events.publish("chatbot.transport_error", {
       source: "chat-transport",
       transportId: this._transportId,
@@ -534,10 +869,25 @@ var ChatTransport = class {
   // -------------------------------------------------------------------------
   // Internal: chatSession wiring
   // -------------------------------------------------------------------------
+  /**
+   * forwardedProps for the NEXT outbound AG-UI request: the config-level
+   * value (late-bound — `configure()` can update uiTemplates /
+   * elementsEnabled mid-session without a reconnect, so this must be
+   * resolved per request, not captured at construction) with the per-send
+   * envelope spread over it. Shallow merge; per-send wins per top-level key.
+   */
+  _resolveForwardedProps() {
+    const raw = this._config?.forwardedProps;
+    const base = typeof raw === "function" ? raw() : raw;
+    const pending = this._pendingForwardedProps;
+    if (!pending) return base;
+    return { ...base ?? {}, ...pending };
+  }
   _wireSession() {
-    this._sessionUnsubSend = chatSession.onSend(({ text, activeLidSlot }) => {
+    this._sessionUnsubSend = chatSession.onSend(({ text, id, activeLidSlot, forwardedProps }) => {
       this._pendingLidSlot = typeof activeLidSlot === "string" && activeLidSlot.length > 0 ? activeLidSlot : null;
-      void this._forwardUserMessage(text);
+      this._pendingForwardedProps = forwardedProps ?? null;
+      void this._forwardUserMessage(text, id);
     });
     this._sessionUnsubInterrupt = chatSession.onInterrupt(() => {
       this._agui?.send({ type: "stop-generation" });
@@ -546,13 +896,22 @@ var ChatTransport = class {
       this._agui?.send({ type: "tool-result", toolCallId, result, approved });
     });
   }
-  async _forwardUserMessage(text) {
-    const ok = await this._ensureConnected();
+  async _forwardUserMessage(text, id) {
+    let ok = false;
+    try {
+      ok = await this._ensureConnected();
+    } catch (err) {
+      this._status = "error";
+      this._handleErrorEvent({
+        message: err instanceof Error ? err.message : String(err),
+        errorName: err instanceof Error ? err.name : null
+      });
+    }
     if (!ok || !this._agui) {
       chatSession.error("Couldn't connect to chat. Please try again.");
       return;
     }
-    this._agui.send({ type: "user-message", text });
+    this._agui.send({ type: "user-message", text, ...id ? { id } : {} });
   }
   // -------------------------------------------------------------------------
   // Internal: connect (lazy, Turnstile-gated)
@@ -582,23 +941,30 @@ var ChatTransport = class {
         if (typeof lidSlot === "string" && lidSlot.length > 0) {
           h["X-Active-Lid-Slot"] = lidSlot;
         }
+        const asciiSafe = (v, max) => (v ?? "").replace(/[^\x20-\x7e]/g, "").slice(0, max).trim();
+        const pid = asciiSafe(this._config?.personaId, 32);
+        const pname = asciiSafe(this._config?.personaName, 24);
+        if (pid && pname) {
+          h["X-Syntro-Persona-Id"] = pid;
+          h["X-Syntro-Persona-Name"] = pname;
+          const prole = asciiSafe(this._config?.personaRole, 48);
+          if (prole) h["X-Syntro-Persona-Role"] = prole;
+        }
         try {
           const rt = this._config?.runtime;
-          const fromRuntime = rt?.telemetry?.getDistinctId?.();
-          const fromWindow = window.posthog?.get_distinct_id?.();
-          const did = fromRuntime || fromWindow;
+          const did = rt?.telemetry?.getDistinctId?.();
           if (typeof did === "string" && did.length > 0) {
             h["X-Distinct-Id"] = did;
           }
+          const sid = rt?.telemetry?.getSessionId?.();
+          if (typeof sid === "string" && sid.length > 0) {
+            h["X-Syntro-Session"] = sid;
+          }
         } catch {
         }
         return h;
       };
-      const runtime2 = this._config.runtime;
-      const resolveForwardedProps = () => {
-        const raw = this._config?.forwardedProps;
-        return typeof raw === "function" ? raw() : raw;
-      };
+      const resolveForwardedProps = () => this._resolveForwardedProps();
       this._agui = new AgUiTransport({
         url: streamUrl,
         headers: buildHeaders,
@@ -612,6 +978,8 @@ var ChatTransport = class {
         credentials: "include",
         forwardedProps: resolveForwardedProps,
         onA2UIEvent: (payload) => {
+          const runtime2 = this._config?.runtime;
+          if (!runtime2) return;
           const mutations = decodeMutationEnvelope(payload);
           if (mutations !== null) {
             const handler = this._config?.onElementMutation;
@@ -676,6 +1044,50 @@ var ChatTransport = class {
     }
     return null;
   }
+  /**
+   * Convert one server-transcript message (the session store shape:
+   * ``{id, role, content, timestamp, status, toolCalls?}`` with toolCalls
+   * in AG-UI wire shape) into a TrailMessage. Returns null for entries the
+   * trail can't render (missing id, system/tool roles, empty content with
+   * no tool receipts) — the transcript may legitimately contain them.
+   */
+  _snapshotToTrailMessage(raw) {
+    if (typeof raw !== "object" || raw === null) return null;
+    const m = raw;
+    const id = m.id;
+    const role = m.role;
+    if (typeof id !== "string" || !id) return null;
+    if (role !== "user" && role !== "assistant") return null;
+    const text = String(m.content ?? m.text ?? "");
+    const toolCalls = this._snapshotToolCalls(m.toolCalls);
+    if (!text && toolCalls.length === 0) return null;
+    const message = { id, role, text, status: "complete" };
+    if (toolCalls.length) message.toolCalls = toolCalls;
+    return message;
+  }
+  /** AG-UI wire-shape toolCalls → settled TrailToolCall receipts. */
+  _snapshotToolCalls(raw) {
+    if (!Array.isArray(raw)) return [];
+    const out = [];
+    for (const entry of raw) {
+      if (typeof entry !== "object" || entry === null) continue;
+      const tc = entry;
+      const fn = tc.function ?? {};
+      if (typeof tc.id !== "string" || typeof fn.name !== "string" || !fn.name) continue;
+      let args;
+      if (typeof fn.arguments === "string" && fn.arguments) {
+        try {
+          const parsed = JSON.parse(fn.arguments);
+          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            args = parsed;
+          }
+        } catch {
+        }
+      }
+      out.push({ id: tc.id, name: fn.name, status: "done", ...args ? { args } : {} });
+    }
+    return out;
+  }
   /** Map AG-UI ToolCallStatus to TrailToolCall status. */
   _mapToolCallStatus(status) {
     switch (status) {
@@ -694,18 +1106,29 @@ var ChatTransport = class {
     }
   }
   _onTransportEvent(event) {
-    const runtime2 = this._config?.runtime;
     switch (event.type) {
       case "session-ready":
-      case "messages-snapshot":
+        return;
+      case "messages-snapshot": {
+        const converted = (event.messages ?? []).map((m) => this._snapshotToTrailMessage(m)).filter((m) => m !== null);
+        if (converted.length) chatSession.hydrate(converted);
+        return;
+      }
       case "typing":
+        if (!event.isTyping) this._stopThinkingCycle();
+        chatSession.setRunActive(event.isTyping);
         return;
       case "message-append": {
+        this._stopThinkingCycle();
+        chatSession.clearThinking();
         this._currentAssistantMessageId = event.message.id;
         chatSession.receiveStart(event.message.id);
         if (event.message.content && event.message.content.length > 0) {
           chatSession.receiveDelta(event.message.id, event.message.content);
         }
+        if (event.message.status === "complete") {
+          chatSession.receiveEnd(event.message.id);
+        }
         return;
       }
       case "message-delta": {
@@ -714,9 +1137,54 @@ var ChatTransport = class {
         chatSession.receiveDelta(id, event.delta);
         return;
       }
+      case "nudge-intent": {
+        try {
+          if (event.messageId) this._dispatchedNudgeIntentIds.add(event.messageId);
+          document.dispatchEvent(
+            new CustomEvent("syntro:nudge", {
+              detail: {
+                pattern: event.pattern,
+                confidence: event.confidence,
+                messageId: event.messageId,
+                phase: "intent"
+              }
+            })
+          );
+        } catch {
+        }
+        return;
+      }
+      case "nudge": {
+        const id = event.messageId ?? this._currentAssistantMessageId;
+        if (id) chatSession.receiveEnd(id);
+        try {
+          const intentDispatched = id != null && this._dispatchedNudgeIntentIds.has(`${id}-intent`);
+          document.dispatchEvent(
+            new CustomEvent("syntro:nudge", {
+              detail: {
+                pattern: event.pattern,
+                confidence: event.confidence,
+                messageId: id,
+                suppressToast: event.suppressToast === true && intentDispatched
+              }
+            })
+          );
+        } catch {
+        }
+        return;
+      }
+      case "thinking-delta": {
+        return;
+      }
+      case "thinking-clear": {
+        this._stopThinkingCycle();
+        chatSession.clearThinking();
+        return;
+      }
       case "message-complete": {
         const id = event.messageId ?? this._currentAssistantMessageId;
         if (!id) return;
+        this._stopThinkingCycle();
         chatSession.receiveEnd(id);
         this._currentAssistantMessageId = null;
         this._messagesSucceeded += 1;
@@ -725,19 +1193,25 @@ var ChatTransport = class {
         return;
       }
       case "tool-call": {
+        const existing = this._findToolCallStatus(event.toolCall.id);
+        if (!existing) {
+          this._startThinkingCycle(toolNarrationVariants(event.toolCall.name));
+        }
         const targetMessageId = event.messageId ?? this._currentAssistantMessageId;
         if (!targetMessageId) return;
-        const existing = this._findToolCallStatus(event.toolCall.id);
+        const parsedArgs = parseToolCallArgs(event.toolCall);
         if (!existing) {
           chatSession.addToolCall(targetMessageId, {
             id: event.toolCall.id,
             name: event.toolCall.name,
-            status: this._mapToolCallStatus(event.toolCall.status)
+            status: this._mapToolCallStatus(event.toolCall.status),
+            ...parsedArgs ? { args: parsedArgs } : {}
           });
         } else {
           chatSession.updateToolCall(event.toolCall.id, {
             name: event.toolCall.name,
-            status: this._mapToolCallStatus(event.toolCall.status)
+            status: this._mapToolCallStatus(event.toolCall.status),
+            ...parsedArgs ? { args: parsedArgs } : {}
           });
         }
         return;
@@ -745,9 +1219,14 @@ var ChatTransport = class {
       case "tool-call-args-delta":
         debug("tool-call-args-delta", event);
         return;
-      case "tool-call-done":
-        chatSession.updateToolCall(event.toolCallId, { status: "done" });
+      case "tool-call-done": {
+        const doneArgs = parseToolCallArgs(event);
+        chatSession.updateToolCall(event.toolCallId, {
+          status: "done",
+          ...doneArgs ? { args: doneArgs } : {}
+        });
         return;
+      }
       case "a2ui":
         return;
       case "error": {
@@ -763,7 +1242,10 @@ var ChatTransport = class {
           body,
           errorName: event.errorName ?? null
         });
-        chatSession.error(event.message ?? "Chat connection failed");
+        const wasMidAnswer = this._currentAssistantMessageId != null;
+        chatSession.error(
+          wasMidAnswer ? "The connection dropped partway through \u2014 ask again and I'll pick it back up." : "Hmm, that didn't go through. Please try again."
+        );
         this._currentAssistantMessageId = null;
         if (this._agui) {
           this._agui.disconnect();
@@ -852,7 +1334,7 @@ function matchEvent(raw, opts = {}) {
         ts: raw.timestamp,
         kind: "nav",
         text: truncate(`navigated to ${path}`),
-        ref: path
+        ref: truncate(path)
       };
     }
     case "$autocapture": {
@@ -904,7 +1386,7 @@ function matchEvent(raw, opts = {}) {
         ts: raw.timestamp,
         kind: "view",
         text: truncate(`viewed the '${section}' section`),
-        ref: section
+        ref: truncate(section)
       };
     }
     case "nav.scroll_depth": {
@@ -940,12 +1422,17 @@ function matchEvent(raw, opts = {}) {
         text: truncate(`hovered on '${text}'`)
       };
     }
-    case "ui.hesitation": {
-      const text = elementText(props) || elementTag(props);
+    // Canonical name is 'ui.hesitate' (StandardEvents.UI_HESITATE) — the rrweb
+    // hesitation detector emits coordinates + duration_ms, no element chain, so
+    // the summary is duration-based. (BUG-1784146789: this case was spelled
+    // 'ui.hesitation', a name nothing emits, so the signal never arrived.)
+    case "ui.hesitate": {
+      const ms = typeof props.duration_ms === "number" ? props.duration_ms : null;
+      const secs = ms !== null ? Math.round(ms / 1e3) : null;
       return {
         ts: raw.timestamp,
         kind: "hesitation",
-        text: truncate(`hesitated near '${text}'`)
+        text: secs !== null ? `hesitated in place for ${secs}s` : "hesitated in place"
       };
     }
     case "ui.focus_bounce": {
@@ -1005,6 +1492,28 @@ var ObserverQueue = class {
     this._clearInterval();
     await this._flush();
   }
+  /**
+   * Synchronously hand the newest backend-sized batch to an unload-safe sender.
+   * Returns false when the sender rejected delivery and restores the batch so
+   * the caller can fall back to fetch({ keepalive: true }).
+   */
+  flushOnPageHide(send) {
+    if (this._disabled || this._buffer.length === 0) return true;
+    this._clearInterval();
+    const overflow = Math.max(0, this._buffer.length - 50);
+    if (overflow > 0) {
+      this._buffer.splice(0, overflow);
+      this._dropped += overflow;
+    }
+    const batch = this._buffer.splice(0, 50);
+    if (!send(batch)) {
+      this._buffer.unshift(...batch);
+      return false;
+    }
+    this._sent += batch.length;
+    this._lastError = null;
+    return true;
+  }
   stats() {
     return {
       queued: this._buffer.length,
@@ -1067,14 +1576,16 @@ var ObserverQueue = class {
 };
 
 // src/observer/transport.ts
-function buildBody(distinctId, batch) {
-  const body = { distinct_id: distinctId, batch };
+function buildBody(distinctId, sessionId, batch) {
+  if (!distinctId || !sessionId) return null;
+  const body = { distinct_id: distinctId, session_id: sessionId, batch };
   return JSON.stringify(body);
 }
 function createTransport(opts) {
   return {
     async send(batch) {
-      const body = buildBody(opts.getDistinctId(), batch);
+      const body = buildBody(opts.getDistinctId(), opts.getSessionId(), batch);
+      if (body === null) return;
       const resp = await fetch(opts.url, {
         method: "POST",
         headers: {
@@ -1094,11 +1605,14 @@ function createTransport(opts) {
       }
     },
     sendBeacon(batch) {
-      const body = buildBody(opts.getDistinctId(), batch);
+      const body = buildBody(opts.getDistinctId(), opts.getSessionId(), batch);
+      if (body === null) return false;
       const blob = new Blob([body], { type: "application/json" });
       const beacon = navigator?.sendBeacon;
       if (typeof beacon !== "function") return false;
-      return beacon.call(navigator, opts.url, blob);
+      const separator = opts.url.includes("?") ? "&" : "?";
+      const url = `${opts.url}${separator}syn=${encodeURIComponent(opts.token())}`;
+      return beacon.call(navigator, url, blob);
     }
   };
 }
@@ -1124,11 +1638,15 @@ function _attachPostHog(ingest, _observableEvents) {
   return () => {
   };
 }
-function _attachPageHide(_transport, queue) {
+function _attachPageHide(transport, queue) {
   const handler = () => {
     const stats = queue.stats();
     if (stats.queued > 0) {
-      void queue.flushNow();
+      queue.flushOnPageHide((batch) => {
+        if (transport.sendBeacon(batch)) return true;
+        void transport.send(batch);
+        return true;
+      });
     }
   };
   window.addEventListener("pagehide", handler, { capture: true });
@@ -1137,7 +1655,7 @@ function _attachPageHide(_transport, queue) {
 function startObserver(opts) {
   if (_active) {
     _active.refCount += 1;
-    return _makeHandle();
+    return _makeHandle(_active);
   }
   const transport = opts.transport ?? createTransport(opts);
   const queue = new ObserverQueue({
@@ -1147,14 +1665,14 @@ function startObserver(opts) {
     flush: (batch) => transport.send(batch)
   });
   const ingest = (raw) => {
-    const ev = matchEvent(raw, { observableEvents: opts.observableEvents });
-    if (ev !== null) {
-      queue.push(ev);
+    const matched = matchEvent(raw, { observableEvents: opts.observableEvents });
+    if (matched !== null) {
+      queue.push(opts.enrich ? opts.enrich(matched, raw) : matched);
     }
   };
   const unsubscribePh = _attachPostHog(ingest, opts.observableEvents ?? []);
   const unsubscribePageHide = _attachPageHide(transport, queue);
-  _active = {
+  const active = {
     refCount: 1,
     queue,
     unsubscribe: () => {
@@ -1163,20 +1681,21 @@ function startObserver(opts) {
     },
     options: opts
   };
-  return _makeHandle();
+  _active = active;
+  return _makeHandle(active);
 }
-function _makeHandle() {
+function _makeHandle(owner) {
   return {
     stop() {
-      if (!_active) return;
-      _active.refCount -= 1;
-      if (_active.refCount <= 0) {
-        _active.unsubscribe();
+      if (_active !== owner) return;
+      owner.refCount -= 1;
+      if (owner.refCount <= 0) {
+        owner.unsubscribe();
         _active = null;
       }
     },
     stats() {
-      return _active?.queue.stats() ?? {
+      return (_active === owner ? owner.queue.stats() : null) ?? {
         queued: 0,
         sent: 0,
         dropped: 0,
@@ -1185,18 +1704,52 @@ function _makeHandle() {
       };
     },
     ingest(raw) {
-      if (!_active) return;
-      const ev = matchEvent(raw, {
-        observableEvents: _active.options.observableEvents
+      if (_active !== owner) return;
+      const matched = matchEvent(raw, {
+        observableEvents: owner.options.observableEvents
       });
-      if (ev !== null) _active.queue.push(ev);
+      if (matched !== null) {
+        owner.queue.push(owner.options.enrich ? owner.options.enrich(matched, raw) : matched);
+      }
     },
     flushNow() {
-      return _active?.queue.flushNow() ?? Promise.resolve();
+      return _active === owner ? owner.queue.flushNow() : Promise.resolve();
     }
   };
 }
 
+// src/observer/bus-translate.ts
+function eventTypeFromName(name) {
+  switch (name) {
+    case "ui.click":
+      return "click";
+    case "ui.submit":
+      return "submit";
+    case "ui.change":
+      return "change";
+    default:
+      return void 0;
+  }
+}
+function busEventToRawEvent(e) {
+  if (!e?.name) return null;
+  const ts = typeof e.ts === "number" ? e.ts : Date.now();
+  if (e.source === "posthog") {
+    const original = e.props?.originalEvent;
+    if (typeof original !== "string" || original.length === 0) return null;
+    const src = e.props ?? {};
+    const properties = { ...src };
+    if (Array.isArray(src.elements)) properties.$elements = src.elements;
+    if (typeof src.tagName === "string") properties.$element_tag_name = src.tagName;
+    if (typeof src.pathname === "string") properties.$pathname = src.pathname;
+    if (typeof src.url === "string") properties.$current_url = src.url;
+    const eventType = eventTypeFromName(e.name);
+    if (eventType) properties.$event_type = eventType;
+    return { event: original, timestamp: ts, properties };
+  }
+  return { event: e.name, timestamp: ts, properties: { ...e.props ?? {} } };
+}
+
 // src/AdaptiveChatBarMountable.ts
 var STATE_KEY = "__syntroChatBarMount";
 function getState(container) {
@@ -1207,15 +1760,27 @@ function setState(container, state) {
 }
 function applyPlaceholder(bar, cfg) {
   if (cfg.placeholder !== void 0) bar.placeholder = cfg.placeholder;
+  if (cfg.assistantName !== void 0) bar.assistantName = cfg.assistantName;
+  if (cfg.personas !== void 0) bar.personas = cfg.personas;
   if (cfg.greeting !== void 0) bar.greeting = cfg.greeting;
+  if (cfg.voiceInput !== void 0) bar.voiceInput = cfg.voiceInput;
+  bar.introSuggestion = cfg.introSuggestion;
+  bar.forceExpanded = cfg.forceExpanded === true;
+  if (typeof cfg.maximized === "boolean") {
+    bar.maximized = cfg.maximized;
+  }
 }
 var _elementStore = null;
 var _templateWidgetMap = /* @__PURE__ */ new Map();
+var SERVER_MOUNTED_TILE_WIDGETS = ["syntro-product-reco-carousel"];
 function resolveTileWidget(templateId) {
   return _templateWidgetMap.get(templateId);
 }
 function refreshTemplateWidgetMap(uiTemplates) {
   _templateWidgetMap.clear();
+  for (const tag of SERVER_MOUNTED_TILE_WIDGETS) {
+    _templateWidgetMap.set(tag, tag);
+  }
   if (!uiTemplates) return;
   const tiles = uiTemplates.tiles;
   if (!Array.isArray(tiles)) return;
@@ -1239,6 +1804,7 @@ function getOrCreateElementStore(runtime2) {
     handlers: [new TileHandler(resolveTileWidget), new ActionHandler(), new ItemHandler()],
     resolveTileWidget
   });
+  setElementInstanceStore(_elementStore);
   return _elementStore;
 }
 var _hydrationStarted = false;
@@ -1253,68 +1819,192 @@ function hydrateOnce(runtime2, backendUrl) {
     void store.hydrate(response.mounted_elements);
   });
 }
+var PAGE_LEVEL_KINDS = /* @__PURE__ */ new Set(["view", "scroll", "idle", "hesitation", "hover", "nav"]);
+function buildObserverEnrich(runtimeRef) {
+  return (ev, raw) => {
+    const extract = runtimeRef.getProductIdentity;
+    if (typeof extract !== "function") return ev;
+    if (ev.kind === "click") {
+      const chain = raw.properties.$elements;
+      if (!Array.isArray(chain)) return ev;
+      const id = extract(chain);
+      if (!id) return ev;
+      return {
+        ...ev,
+        product: {
+          handle: id.productHandle,
+          url: id.productUrl,
+          ...id.productTitle ? { title: id.productTitle } : {}
+        }
+      };
+    }
+    if (!ev.product && PAGE_LEVEL_KINDS.has(ev.kind) && typeof location !== "undefined") {
+      const id = extract([{ href: location.pathname }]);
+      if (!id) return ev;
+      return {
+        ...ev,
+        product: {
+          handle: id.productHandle,
+          url: id.productUrl,
+          ...id.productTitle ? { title: id.productTitle } : {}
+        }
+      };
+    }
+    return ev;
+  };
+}
+var _nudgeSurfaceWired = false;
+var _nudgeListener = null;
+function wireNudgeSurface(runtime2, backendUrl) {
+  if (_nudgeSurfaceWired || typeof document === "undefined") return;
+  _nudgeSurfaceWired = true;
+  _nudgeListener = (e) => {
+    try {
+      const detail = e.detail;
+      const isIntent = detail?.phase === "intent";
+      if (!isIntent) {
+        const store = getOrCreateElementStore(runtime2);
+        const trimmed = backendUrl.replace(/\/$/, "");
+        const endpoint = trimmed ? `${trimmed}/api/adaptive/mounted_elements` : "/api/adaptive/mounted_elements";
+        void fetchMountedElements({ endpoint }).then((response) => {
+          if (!response) return;
+          void store.hydrate(response.mounted_elements);
+        });
+      }
+      if (detail?.suppressToast === true) return;
+      const findCanvas = (root) => {
+        const direct = root.querySelector("smart-canvas");
+        if (direct) return direct;
+        for (const el of root.querySelectorAll("*")) {
+          const sr = el.shadowRoot;
+          if (sr) {
+            const found = findCanvas(sr);
+            if (found) return found;
+          }
+        }
+        return null;
+      };
+      const canvas = findCanvas(document);
+      const messageId = e.detail?.messageId;
+      const nudgeText = messageId ? (chatSession.getState().messages.find((m) => m.id === messageId)?.text ?? "").trim() : "";
+      const title = nudgeText ? nudgeText.length > 140 ? `${nudgeText.slice(0, 137)}\u2026` : nudgeText : "I put something together for you";
+      canvas?.previewNotification?.({
+        title,
+        body: "Tap to take a look"
+      });
+    } catch (err) {
+      console.warn("[adaptive-chatbot] nudge surface reaction failed", err);
+    }
+  };
+  document.addEventListener("syntro:nudge", _nudgeListener);
+}
 function configureTransportIfPossible(cfg) {
-  if (cfg.backendUrl === void 0 || !cfg.runtime) return;
+  if (!cfg.runtime) return;
+  const backendUrl = cfg.runtime.backendUrl;
+  if (!backendUrl) return;
   const elementsActive = cfg.elementsEnabled === true && cfg.uiTemplates != null;
   refreshTemplateWidgetMap(elementsActive ? cfg.uiTemplates : void 0);
   const forwardedProps = elementsActive ? { elementsEnabled: true, uiTemplates: cfg.uiTemplates } : void 0;
+  if (elementsActive) publishTemplatesIfPossible(backendUrl, cfg.uiTemplates);
   const runtime2 = cfg.runtime;
   const onElementMutation = elementsActive ? (mutations) => {
     void getOrCreateElementStore(runtime2).apply(mutations);
   } : void 0;
   if (elementsActive) {
-    hydrateOnce(runtime2, cfg.backendUrl);
+    hydrateOnce(runtime2, backendUrl);
   }
+  const persona = pickPersona(cfg.personas ?? null);
   chatTransport.configure({
     ...cfg,
+    backendUrl,
     forwardedProps,
     onElementMutation,
-    activeLidSlot: cfg._syntroSlotName
+    activeLidSlot: cfg._syntroSlotName,
+    personaId: persona?.id,
+    personaName: persona?.name,
+    personaRole: persona?.role_title
   });
+  void chatTransport.startSessionStream();
+  wireNudgeSurface(runtime2, backendUrl);
   startObserverIfPossible(cfg);
 }
+var _templatesPublished = false;
+function publishTemplatesIfPossible(backendUrl, uiTemplates) {
+  if (_templatesPublished || typeof window === "undefined") return;
+  if (!uiTemplates || typeof uiTemplates !== "object") return;
+  _templatesPublished = true;
+  const cfg = window.__SYNTRO_CONFIG__;
+  const token = typeof cfg?.token === "string" && cfg.token.length > 0 ? cfg.token : void 0;
+  const headers = { "Content-Type": "application/json" };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const trimmed = backendUrl.replace(/\/$/, "");
+  void fetch(`${trimmed}/api/adaptive/templates`, {
+    method: "POST",
+    headers,
+    credentials: "include",
+    body: JSON.stringify({ ui_templates: uiTemplates })
+  }).catch(() => {
+  });
+}
+var _diveDeeperWired = false;
+function wireDiveDeeperListener() {
+  if (_diveDeeperWired || typeof window === "undefined") return;
+  _diveDeeperWired = true;
+  window.addEventListener(DIVE_DEEPER_EVENT, (e) => {
+    const detail = e.detail ?? {};
+    const prompt = typeof detail.prompt === "string" && detail.prompt.trim() ? detail.prompt : detail.title ? "I'd like to dive deeper on this, I didn't see what I needed." : "";
+    if (!prompt) return;
+    const origin = { kind: "dive-deeper" };
+    if (detail.title) origin.title = detail.title;
+    if (detail.context) origin.context = detail.context;
+    chatSession.send(prompt, { forwardedProps: { origin } });
+    if (!chatSession.hasTransport()) {
+      chatSession.error("Chat backend not configured \u2014 set backendUrl in the canvas config.");
+    }
+  });
+}
 var _observerStarted = false;
+var _observerRuntime = null;
+var _observerHandle = null;
+var _observerBusUnsubscribe = null;
 function startObserverIfPossible(cfg) {
-  if (_observerStarted) return;
   if (typeof window === "undefined") return;
-  const runtime2 = cfg.runtime;
-  if (!runtime2?.events?.subscribe) return;
-  const trimmed = (cfg.backendUrl ?? "").replace(/\/$/, "");
+  const runtimeRef = cfg.runtime;
+  if (!runtimeRef?.events?.subscribe) return;
+  if (_observerStarted && _observerRuntime === runtimeRef) return;
+  if (_observerStarted) {
+    _observerBusUnsubscribe?.();
+    _observerHandle?.stop();
+    _observerBusUnsubscribe = null;
+    _observerHandle = null;
+    _observerStarted = false;
+  }
+  const trimmed = (runtimeRef.backendUrl ?? "").replace(/\/$/, "");
   const url = trimmed ? `${trimmed}/api/adaptive/observation` : "/api/adaptive/observation";
-  const getDistinctId = () => {
-    const ph = window.posthog;
+  const runtimeId = (method) => {
     try {
-      const v = ph?.get_distinct_id?.();
+      const v = runtimeRef.telemetry?.[method]?.();
       return typeof v === "string" && v.length > 0 ? v : null;
     } catch {
       return null;
     }
   };
+  const getDistinctId = () => runtimeId("getDistinctId");
+  const getSessionId = () => runtimeId("getSessionId");
   const token = () => {
     const c = window.__SYNTRO_CONFIG__;
     return typeof c?.token === "string" ? c.token : "";
   };
-  const handle = startObserver({ url, token, getDistinctId });
+  const enrich = buildObserverEnrich(runtimeRef);
+  const handle = startObserver({ url, token, getDistinctId, getSessionId, enrich });
   window.__syntroObserverStats = () => handle.stats();
-  runtime2.events.subscribe({}, (evt) => {
-    const e = evt;
-    if (!e?.name) return;
-    const ts = typeof e.ts === "number" ? e.ts : Date.now();
-    if (e.source === "posthog") {
-      const original = e.props?.originalEvent;
-      if (typeof original !== "string" || original.length === 0) return;
-      const properties = { ...e.props ?? {} };
-      if (typeof e.props?.pathname === "string") properties.$pathname = e.props.pathname;
-      if (typeof e.props?.url === "string") properties.$current_url = e.props.url;
-      handle.ingest({ event: original, timestamp: ts, properties });
-      return;
-    }
-    handle.ingest({
-      event: e.name,
-      timestamp: ts,
-      properties: { ...e.props ?? {} }
-    });
+  const unsubscribe = runtimeRef.events.subscribe({}, (evt) => {
+    const raw = busEventToRawEvent(evt);
+    if (raw) handle.ingest(raw);
   });
+  _observerRuntime = runtimeRef;
+  _observerHandle = handle;
+  _observerBusUnsubscribe = unsubscribe;
   _observerStarted = true;
 }
 function wireListeners(bar, state) {
@@ -1350,12 +2040,43 @@ var AdaptiveChatBarMountable = {
   mount(container, mountConfig) {
     const cfg = mountConfig ?? {};
     configureTransportIfPossible(cfg);
+    wireDiveDeeperListener();
     const bar = document.createElement("adaptive-chat-bar");
     applyPlaceholder(bar, cfg);
+    const widgets = cfg.runtime?.widgets;
+    if (widgets) {
+      bar.mountInlineWidget = (widgetId, container2, props) => {
+        if (!widgets.has(widgetId)) return null;
+        const handle = widgets.mount(widgetId, container2, props);
+        const element = container2.firstElementChild;
+        if (!element) {
+          handle.unmount?.();
+          return null;
+        }
+        return { element, cleanup: () => handle.unmount?.() };
+      };
+    }
     const unsubSession = chatSession.subscribe((s) => {
       bar.messages = [...s.messages];
       bar.inFlight = s.inFlight;
+      bar.thinkingText = s.thinkingText;
     });
+    const runtimeEvents = cfg.runtime ? cfg.runtime.events : void 0;
+    const refreshReceipts = () => {
+      const store = _elementStore;
+      if (store) {
+        bar.tileReceipts = store.listTileReceipts();
+        bar.inlineWidgets = store.listInlineWidgets();
+      }
+    };
+    let unsubReceipts;
+    if (runtimeEvents?.subscribe) {
+      unsubReceipts = runtimeEvents.subscribe(
+        { names: [TILE_MOUNTED_EVENT, TILE_UNMOUNTED_EVENT] },
+        refreshReceipts
+      );
+    }
+    refreshReceipts();
     const state = { bar, cleanup: () => {
     }, cfg };
     const unwireListeners = wireListeners(bar, state);
@@ -1367,6 +2088,7 @@ var AdaptiveChatBarMountable = {
     state.cleanup = () => {
       unsubSession();
       unsubFallback();
+      unsubReceipts?.();
       unwireListeners();
       bar.remove();
       setState(container, null);
@@ -1456,6 +2178,7 @@ var AdaptiveChipsStripMountable = {
 
 // src/NavLinkMountable.ts
 var STATE_KEY3 = "__syntroNavLinkMount";
+var SAFE_NAVIGATION_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
 function getState3(container) {
   return container[STATE_KEY3] ?? null;
 }
@@ -1471,7 +2194,7 @@ function navigateTo(rawUrl) {
     return;
   }
   if (resolved.origin !== window.location.origin) return;
-  if (resolved.protocol !== "http:" && resolved.protocol !== "https:") return;
+  if (!SAFE_NAVIGATION_PROTOCOLS.has(resolved.protocol)) return;
   window.history.pushState(null, "", resolved.toString());
   window.dispatchEvent(new PopStateEvent("popstate"));
 }
@@ -1639,7 +2362,11 @@ var runtime = {
 };
 var runtime_default = runtime;
 export {
+  ElementInstanceStore,
+  TileHandler,
   runtime_default as default,
-  runtime
+  getElementInstanceStore,
+  runtime,
+  setElementInstanceStore
 };
 //# sourceMappingURL=runtime.js.map