@syntrologie/adapt-chatbot 2.26.0 → 2.28.0

package/dist/AdaptiveChipsStrip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveChipsStrip.d.ts","sourceRoot":"","sources":["../src/AdaptiveChipsStrip.ts"],"names":[],"mappings":"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"}

package/dist/AdaptiveChipsStrip.js

@@ -0,0 +1,11 @@
+import {
+  AdaptiveChipsStrip,
+  SuggestionChipSchema
+} from "./chunk-AUER7ZCK.js";
+import "./chunk-435KJD27.js";
+import "./chunk-UVKRO5ER.js";
+export {
+  AdaptiveChipsStrip,
+  SuggestionChipSchema
+};
+//# sourceMappingURL=AdaptiveChipsStrip.js.map

package/dist/AdaptiveChipsStrip.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/AdaptiveChipsStripMountable.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AdaptiveChipsStripMountable — `MountableWidget` adapter for
+ * `<adaptive-chips-strip>`. Registered as widget id
+ * `adaptive-chatbot:chips-strip`.
+ *
+ * Mirrors `AdaptiveChatBarMountable`: creates the Lit element, forwards
+ * props, bridges DOM events → prop callbacks, cleans up on unmount.
+ *
+ * Props (passed via mountConfig):
+ *   - `chips: SuggestionChip[]` — the strip's contents (required)
+ *   - `onChipRevealed?: ({id, payload}) => void` — fires when a chip
+ *     is opened
+ *   - `onChipDismissed?: ({id}) => void` — fires when × is clicked
+ *
+ * The runtime registry injects `runtime` into mountConfig (see
+ * `WidgetRegistry.mount`). We forward it as `runtimeRef` on the strip
+ * so it can mount chip payload widgets through the same registry.
+ */
+import './AdaptiveChipsStrip';
+export declare const AdaptiveChipsStripMountable: {
+    mount(container: HTMLElement, mountConfig?: Record<string, unknown>): () => void;
+    update(container: HTMLElement, mountConfig?: Record<string, unknown>): void;
+};
+//# sourceMappingURL=AdaptiveChipsStripMountable.d.ts.map

package/dist/AdaptiveChipsStripMountable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveChipsStripMountable.d.ts","sourceRoot":"","sources":["../src/AdaptiveChipsStripMountable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,sBAAsB,CAAC;AA0C9B,eAAO,MAAM,2BAA2B;qBACrB,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,IAAI;sBAqC9D,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;CAqB5E,CAAC"}

package/dist/ChatAssistantLit.d.ts

@@ -11,13 +11,23 @@
  *    `window.__SYNTRO_CONFIG__.token` (set by runtime-config.js) — we read
  *    it at mount time and forward it via `Authorization: Bearer` header.
  *
- * 2. Cloudflare Turnstile bot-check token. When `TURNSTILE_SITEKEY` is set
- *    (hardcoded at the top of this file — operator updates after running
- *    terraform apply on cloudflare/turnstile in the infra repo), the
- *    widget dynamically loads Cloudflare's Turnstile JS, renders an
- *    invisible widget, and acquires a token before the first message.
- *    The token is forwarded via `CF-Turnstile-Token` header.
- *    If sitekey is empty (default), this step is skipped entirely.
+ * 2. Cloudflare Turnstile bot-check token. When `TURNSTILE_SITEKEY` is
+ *    set, render a single `size: 'flexible'` widget with
+ *    `appearance: 'interaction-only'` against a `managed`-mode sitekey:
+ *      • Clean traffic: CF passive-grades silently, token resolves in
+ *        ~100ms, no UI is ever shown.
+ *      • Flagged traffic (datacenter IP, automation, strict-privacy):
+ *        CF renders an "I am human" checkbox inside the in-chat verify
+ *        panel; on solve, swap to the chat UI.
+ *      • Total failure (CSP blocks CF, network error, user dismisses):
+ *        fall through with no token; backend enforcement 403s and the
+ *        existing fallback card renders.
+ *    The widget mode MUST be `managed` on the CF side — see
+ *    cloudflare/turnstile/main.tf in syntro-infra. (`mode = 'invisible'`
+ *    rejects any `size` other than `invisible`, and `size: 'invisible'`
+ *    against `mode = 'managed'` fails with a synchronous TurnstileError —
+ *    don't mix.)
+ *    If sitekey is empty, this step is skipped entirely.
  *
  * 3. Fallback card. If the first agent run fails (Cloudflare Turnstile
  *    bot-check failure, CORS / network error, or a server-side rejection),
@@ -31,27 +41,19 @@
  *    inside the chat surface.
  */
 import '@syntrologie/chat';
-import type { ChatbotConfig, ChatbotWidgetRuntime } from './types.js';
+import type { ChatbotConfig, ChatbotFallback, ChatbotWidgetRuntime } from './types.js';
 export interface ChatAssistantLitProps {
     config: ChatbotConfig;
     runtime: ChatbotWidgetRuntime;
     tileId?: string;
 }
 /**
- * Acquire a Cloudflare Turnstile token. Returns null when:
- *   • TURNSTILE_SITEKEY is empty (Turnstile disabled at build time)
- *   • the script fails to load (customer CSP blocks Cloudflare, etc.)
- *   • the render callback doesn't fire within TURNSTILE_ACQUIRE_TIMEOUT_MS
- *   • Cloudflare returns an error-callback (e.g., rate-limited, bad sitekey)
- *
- * When null is returned, the widget proceeds WITHOUT a Turnstile token.
- * If backend enforcement is on, the request 403s and the fallback card
- * renders via the existing failure-detection path. If enforcement is off,
- * the request succeeds.
- *
- * Exported for tests; the production code path goes through `mount()`.
+ * Build the inline HTML for the fallback card. Customer-supplied copy wins;
+ * everything else falls back to generic copy. The card avoids any reference
+ * to Cloudflare or Turnstile so the end-user is never confronted with our
+ * implementation details.
  */
-export declare function acquireTurnstileToken(): Promise<string | null>;
+export declare function renderFallbackHtml(fallback: ChatbotFallback | undefined): string;
 export declare const ChatAssistantLitMountable: {
     mount(container: HTMLElement, mountConfig?: Record<string, unknown>): () => void;
 };

package/dist/ChatAssistantLit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ChatAssistantLit.d.ts","sourceRoot":"","sources":["../src/ChatAssistantLit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,mBAAmB,CAAC;AAK3B,OAAO,KAAK,EAAE,aAAa,EAAmB,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvF,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,oBAAoB,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAqGD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkDpE;AAiGD,eAAO,MAAM,yBAAyB;qBACnB,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CA2LpE,CAAC"}
+{"version":3,"file":"ChatAssistantLit.d.ts","sourceRoot":"","sources":["../src/ChatAssistantLit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAGH,OAAO,mBAAmB,CAAC;AAa3B,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvF,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,oBAAoB,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA8CD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,eAAe,GAAG,SAAS,GAAG,MAAM,CAiEhF;AAED,eAAO,MAAM,yBAAyB;qBACnB,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAgbpE,CAAC"}

package/dist/ChatAssistantLit.js

@@ -1,10 +1,12 @@
 import {
   ChatAssistantLitMountable,
-  acquireTurnstileToken
-} from "./chunk-O7RWNUVU.js";
+  renderFallbackHtml
+} from "./chunk-KUO67E2W.js";
+import "./chunk-UC4XU6GH.js";
+import "./chunk-435KJD27.js";
 import "./chunk-UVKRO5ER.js";
 export {
   ChatAssistantLitMountable,
-  acquireTurnstileToken
+  renderFallbackHtml
 };
 //# sourceMappingURL=ChatAssistantLit.js.map

package/dist/ChatSession.d.ts

@@ -0,0 +1,178 @@
+/**
+ * ChatSession — singleton holder of the chat conversation state.
+ *
+ * The chat is conceptually one thing. Whether it's rendered in the
+ * mini-canvas's lid, the drawer's lid, or as a tile inside any slot,
+ * they're all VIEWS of the same conversation. This module owns that
+ * shared state.
+ *
+ * Why a module-level singleton (not on `runtime`):
+ *   - Per-page scope is the right granularity for a chat (one user,
+ *     one conversation, however many canvas instances on the page).
+ *   - Avoids a new SmartCanvasRuntime API surface for now. Easy to
+ *     promote to `runtime.chat` later without breaking the widget API.
+ *   - Module identity is stable per page; multiple imports return the
+ *     same instance.
+ *
+ * Separation of concerns:
+ *   - `ChatSession` owns state: messages, inFlight.
+ *   - Views (AdaptiveChatBar via AdaptiveChatBarMountable) subscribe
+ *     to state changes and dispatch user actions back via send() /
+ *     interrupt().
+ *   - Transports (the LLM call, SSE pipeline, stub timers) listen
+ *     for "send" / "interrupt" events and eventually call receive()
+ *     with the assistant's reply. Transports are NOT owned by this
+ *     module — adapters live separately.
+ *
+ * No persistence in this slice. Future: snapshot to runtime.state
+ * for cross-session continuity.
+ */
+import type { TrailMessage, TrailToolCall } from './AdaptiveChatTrail';
+export interface ChatSessionState {
+    readonly messages: readonly TrailMessage[];
+    readonly inFlight: boolean;
+}
+export interface ToolResultEvent {
+    toolCallId: string;
+    result: unknown;
+    approved: boolean;
+}
+export type ChatSessionSubscriber = (state: ChatSessionState) => void;
+export type SendListener = (event: {
+    text: string;
+    activeLidSlot?: string;
+}) => void;
+export type InterruptListener = () => void;
+export type ToolResultListener = (event: ToolResultEvent) => void;
+/** Optional per-send envelope. */
+export interface SendOptions {
+    /**
+     * The slot the calling chat-bar lives in (e.g. ``"drawer"``,
+     * ``"adaptive-chat"``). Forwarded to transport listeners so the
+     * outbound request can tag the correct ``X-Active-Lid-Slot`` regardless
+     * of which bar most recently configured the singleton transport.
+     * Without per-send threading, two coexisting chat-bars race over the
+     * transport's cached ``activeLidSlot`` and the user-facing routing
+     * silently follows whichever bar configured last.
+     */
+    activeLidSlot?: string;
+}
+export type Unsubscribe = () => void;
+export declare const CHAT_SESSION_STORAGE_KEY = "syntro:chat:v1";
+export declare class ChatSession {
+    private _messages;
+    private _inFlight;
+    private _nextId;
+    private subscribers;
+    private sendListeners;
+    private interruptListeners;
+    private toolResultListeners;
+    constructor();
+    /** Snapshot the current state. Always returns a fresh immutable view. */
+    getState(): ChatSessionState;
+    /**
+     * Subscribe to state changes. Called immediately with the current
+     * state, then again on every change. Returns an unsubscribe function.
+     */
+    subscribe(cb: ChatSessionSubscriber): Unsubscribe;
+    /**
+     * User submitted a message. Appends a user-role message, sets
+     * inFlight=true, notifies state subscribers, and fires a "send"
+     * event so transports can pick it up. Empty/whitespace text is a
+     * no-op (matches the chat bar's local guard).
+     */
+    send(text: string, opts?: SendOptions): void;
+    /**
+     * Single-shot assistant reply (no streaming). Equivalent to
+     * receiveStart + receiveDelta + receiveEnd in one call. Useful for
+     * stub transports and tests that don't model streaming.
+     */
+    receive(text: string): void;
+    /**
+     * Begin a streaming assistant message. Appends an empty assistant
+     * message with status='streaming'. Caller (transport adapter) feeds
+     * deltas via receiveDelta(id, text) and signals completion via
+     * receiveEnd(id). `inFlight` stays true through the stream.
+     */
+    receiveStart(id: string): void;
+    /**
+     * Append a delta to a streaming message. No-op when the id is
+     * unknown (race between transport events and reset, etc.) — never
+     * throws so transports can fire-and-forget.
+     */
+    receiveDelta(id: string, delta: string): void;
+    /**
+     * Mark a streaming message complete and clear inFlight. No-op when
+     * the id is unknown (defensive against transport double-fires).
+     */
+    receiveEnd(id: string): void;
+    /**
+     * Transport reports a fatal error. Marks any in-flight streaming
+     * 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.
+     */
+    error(message: string): void;
+    /**
+     * 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).
+     */
+    interrupt(): void;
+    /**
+     * Wipe state. Used by the canvas-close path (start a fresh
+     * conversation next time) and by tests.
+     */
+    reset(): void;
+    /** Register a transport's send listener. Returns unsubscribe. */
+    onSend(listener: SendListener): Unsubscribe;
+    /**
+     * True when at least one transport has wired itself to the session's
+     * send pipeline. Views can use this to surface "no chat backend
+     * connected" affordances instead of hanging in `inFlight` after a
+     * send fires into the void.
+     */
+    hasTransport(): boolean;
+    /** Register a transport's interrupt listener. Returns unsubscribe. */
+    onInterrupt(listener: InterruptListener): Unsubscribe;
+    /**
+     * Register a transport's tool-result listener. The transport
+     * forwards `tool-result` actions back to the agent after the user
+     * approves or rejects a client-tool call. Returns unsubscribe.
+     */
+    onToolResult(listener: ToolResultListener): Unsubscribe;
+    /**
+     * Attach a tool call to a streaming assistant message. No-op when
+     * the message id is unknown (race between transport events and
+     * reset / late mount).
+     */
+    addToolCall(messageId: string | number, toolCall: TrailToolCall): void;
+    /**
+     * Partially update a tool call by id. Used by the transport to
+     * advance status (args-streaming → running → done) as AG-UI events
+     * arrive. No-op when the id is unknown.
+     */
+    updateToolCall(toolCallId: string, patch: Partial<TrailToolCall>): void;
+    /**
+     * Resolve a (client-) tool call. Marks the call done, persists, and
+     * fires onToolResult so the transport can forward the result + the
+     * user's approve/reject decision back to the agent. No-op when the
+     * id is unknown.
+     */
+    resolveToolCall(toolCallId: string, result: unknown, approved: boolean): void;
+    private notify;
+    private persist;
+}
+/**
+ * The module-level singleton. Every `<adaptive-chat-bar>` (regardless
+ * of which slot it lives in) reads from and writes to this instance.
+ * Multiple imports of this module return the same object.
+ *
+ * Scope: per-page. Correct for the canonical case (one user, one
+ * conversation, however many canvas views surface it). Multiple
+ * `<smart-canvas>` instances on the same page will share state —
+ * tracked in project_future_work.md for per-runtime scoping.
+ */
+export declare const chatSession: ChatSession;
+//# sourceMappingURL=ChatSession.d.ts.map

package/dist/ChatSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatSession.d.ts","sourceRoot":"","sources":["../src/ChatSession.ts"],"names":[],"mappings":"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"}

package/dist/ChatTransport.d.ts

@@ -0,0 +1,283 @@
+/**
+ * ChatTransport — singleton transport adapter that bridges chatSession
+ * (the view-side state holder) to the real backend chat pipeline
+ * (AG-UI SSE at `/api/adaptive/stream`).
+ *
+ * This is the unification of two formerly separate paths:
+ *   - `ChatAssistantLit` (old) owns the transport plumbing —
+ *     AgUiTransport, Cloudflare Turnstile, headers, A2UI passthrough,
+ *     telemetry, fallback card.
+ *   - `AdaptiveChatBar` + `chatSession` (new) owns the canvas-lid UX —
+ *     glassmorphism bar, bubble-up trail, per-page persistence.
+ *
+ * This module ports every transport-side concern from ChatAssistantLit
+ * into a session-shaped adapter so the new bar gets full backend
+ * parity. The bar stays a pure view; the transport stays a pure pipe.
+ *
+ * Lifecycle:
+ *   - `configure({ backendUrl, runtime, ... })` — called once by the
+ *     SDK runtime at bootstrap from chat config. Idempotent; second
+ *     call with the same backendUrl is a no-op.
+ *   - Connection is LAZY. The transport doesn't acquire Turnstile or
+ *     open the SSE until the first chatSession.send() — saves cost
+ *     on pages where the user never opens chat.
+ *   - On chatSession.send → transport ensures connected (acquires
+ *     Turnstile token, builds AgUiTransport) then forwards
+ *     `{type:'user-message', text}` to the agent.
+ *   - On chatSession.onInterrupt → transport sends stop-generation.
+ *   - AgUi events stream into chatSession via receiveStart / Delta /
+ *     End / error.
+ *   - A2UI custom events forward to runtime.actions.applyBatch so the
+ *     agent can drive canvas updates.
+ *
+ * Telemetry parity with ChatAssistantLit:
+ *   - chatbot.transport_error (every error, with status/body/name)
+ *   - chatbot.a2ui_applied
+ *   - chatbot.fallback_rendered — emitted when the transport gives up
+ *     (Turnstile failed AND backend rejected) so existing PostHog
+ *     queries keep working.
+ *
+ * Threading model: single-flight per page. Multiple concurrent sends
+ * are queued by AgUiTransport itself. Multiple bar mounts share this
+ * one transport via chatSession.
+ */
+import type { ElementMutation } from './elements';
+import type { ChatbotWidgetRuntime } from './types';
+/**
+ * Per-customer "chat unavailable" card config. Surfaced via onFallback
+ * when the transport gives up after repeated failures. Mirrors
+ * ChatbotFallback in types.ts so consumers can pass the same config.
+ */
+export interface ChatbotFallbackConfig {
+    title?: string;
+    message?: string;
+    ctaLabel?: string;
+    ctaHref?: string;
+}
+export interface ChatTransportConfig {
+    /** Backend host, e.g. "https://demo-api.syntrologie.com" or "" for same-origin. */
+    backendUrl: string;
+    /** Runtime hooks for A2UI apply + telemetry. */
+    runtime: ChatbotWidgetRuntime;
+    /** Optional thread id for conversation continuity across reloads. */
+    threadId?: string;
+    /**
+     * Optional set of client-tool names the transport should treat as
+     * "needs user approval" (surfaced via chatSession.toolCalls instead
+     * of auto-executed server-side). Empty by default — all tool calls
+     * are server-driven and the transport just emits the "tool call
+     * happened" event.
+     */
+    clientTools?: Set<string>;
+    /**
+     * Per-customer "chat unavailable" card. Rendered by the host
+     * (typically AdaptiveChatBarMountable) after repeated connect
+     * failures wipe the chat surface — exactly the same UX
+     * ChatAssistantLit's fallback path provides.
+     */
+    fallback?: ChatbotFallbackConfig;
+    /**
+     * Arbitrary JSON object attached to every AG-UI request as
+     * `forwardedProps`. Used by the adaptive chat surface to ship the
+     * LLM-authored UI element config (`uiTemplates`, `elementsEnabled`)
+     * per request — the backend reads these to enable the
+     * `mount_element` / `patch_element` / `unmount_element` tools.
+     * Callable form is re-evaluated on every turn so a config edit can
+     * land mid-conversation.
+     */
+    forwardedProps?: Record<string, unknown> | (() => Record<string, unknown> | undefined);
+    /**
+     * Optional callback for `syntro.element.mutation` AG-UI custom events.
+     * The transport decodes the envelope on receipt; if it matches the
+     * element-mutation schema, mutations are routed here instead of the
+     * generic `runtime.actions.applyBatch` legacy path. Consumers are
+     * expected to forward to `ElementInstanceStore.apply(mutations)` —
+     * we don't take a store reference directly so the transport stays
+     * agnostic of which surface owns the store (the chat-bar widget
+     * may own one; ChatAssistantLit owns its own; both share this
+     * singleton transport).
+     *
+     * When unset, element-mutation envelopes fall back to applyBatch,
+     * matching legacy behaviour (which would no-op since applyBatch
+     * doesn't know about MutationEnvelope).
+     */
+    onElementMutation?: (mutations: ElementMutation[]) => void;
+    /**
+     * Slot the chat-bar widget is mounted into (e.g. ``"drawer"``,
+     * ``"adaptive-chat"``). Forwarded as ``X-Active-Lid-Slot`` on every
+     * ``/api/adaptive/stream`` request so the backend can route mounts to
+     * the canvas next to whichever lid the visitor sent from. Optional —
+     * omitting it falls back to the template's static ``default_slot``
+     * server-side, which is the pre-change behaviour.
+     */
+    activeLidSlot?: string;
+}
+/**
+ * Debounce window for connect errors. Single transient errors
+ * (cold-start 502, brief CORS preflight failure) should NOT swap the
+ * chat to the fallback card; only sustained failure should. Matches
+ * ChatAssistantLit's ERROR_DEBOUNCE_MS.
+ */
+export declare const FALLBACK_DEBOUNCE_MS = 1500;
+export interface FallbackPayload {
+    reason: 'connect_failed' | 'connect_timeout';
+    fallback: ChatbotFallbackConfig;
+    transportId: string;
+    transportAgeMs: number;
+    messagesSucceeded: number;
+    hadTurnstileToken: boolean | null;
+    errorStatus: number | null;
+    errorBody: string | null;
+    errorMessage: string | null;
+    errorName: string | null;
+}
+export type FallbackListener = (payload: FallbackPayload) => void;
+export declare class ChatTransport {
+    private _config;
+    private _status;
+    private _agui;
+    private _transportUnsub;
+    private _sessionUnsubSend;
+    private _sessionUnsubInterrupt;
+    private _sessionUnsubToolResult;
+    private _connectInFlight;
+    /** Bounded streaming-message id for the currently-being-typed assistant turn. */
+    private _currentAssistantMessageId;
+    /** Outcome bookkeeping for telemetry. */
+    private _hadTurnstileToken;
+    /** Count of successful round-trips for telemetry payloads. */
+    private _messagesSucceeded;
+    /** True once a successful assistant message has landed — gates fallback. */
+    private _hasSucceeded;
+    /** True once fallback has fired (one-shot). */
+    private _fallbackRendered;
+    /**
+     * Per-send override for ``X-Active-Lid-Slot``. Set in the
+     * ``chatSession.onSend`` listener immediately before each
+     * ``_forwardUserMessage`` and consumed by ``buildHeaders`` on the
+     * outbound request. The singleton transport is shared by every
+     * mounted chat-bar (drawer + inline) so cached ``_config.activeLidSlot``
+     * follows whichever bar last reconfigured — using that for routing
+     * silently misroutes tiles when both bars coexist. Per-send threading
+     * pins the header to the bar that actually sent the message.
+     */
+    private _pendingLidSlot;
+    /** Active debounce timer; null when no debounce pending. */
+    private _errorDebounceTimer;
+    /** Most recent error payload, captured so debounced fallback can attach it. */
+    private _lastErrorPayload;
+    private _fallbackListeners;
+    /**
+     * Per-configure-cycle id for correlating telemetry events from a
+     * single transport lifetime. Mirrors ChatAssistantLit's mountId
+     * but scoped to configure cycles since the transport is a
+     * singleton across mounts.
+     */
+    private _transportId;
+    private _configuredAt;
+    /**
+     * Configure the transport. Idempotent — calling again with the same
+     * backendUrl is a no-op; calling with a different backendUrl tears
+     * the connection down and re-arms.
+     */
+    configure(config: ChatTransportConfig): void;
+    /** ms since the most recent configure() call. 0 before any configure. */
+    private _ageMs;
+    /** True when configure() has been called and we're ready to lazy-connect on send. */
+    get isConfigured(): boolean;
+    /** True when AgUiTransport is up. */
+    get isConnected(): boolean;
+    /**
+     * Subscribe to fallback events — fires once per configure cycle
+     * when the transport gives up after sustained failure. Hosts
+     * (typically AdaptiveChatBarMountable) use this to swap the chat
+     * bar for a static "contact support" card.
+     */
+    onFallback(listener: FallbackListener): () => void;
+    /**
+     * Test seam — drive a synthetic error event through the transport's
+     * error handling without standing up a real AgUi transport. Production
+     * code path uses _onTransportEvent. Exported as a public method to
+     * keep the test isolation simple; not part of the documented API.
+     */
+    simulateError(payload: {
+        message?: string;
+        status?: number | null;
+        body?: string | null;
+        errorName?: string | null;
+    }): void;
+    /**
+     * Test seam — register a synthetic successful message-complete so
+     * the hasSucceeded gate flips without a real AgUi round-trip.
+     */
+    simulateSuccessfulMessage(): void;
+    /**
+     * Test seam — return the lid slot that the next outbound request
+     * WOULD tag ``X-Active-Lid-Slot`` with, given current state. Mirrors
+     * the exact resolution buildHeaders uses (per-send slot wins over
+     * cached config). Not part of the documented API.
+     */
+    getActiveLidSlotForTest(): string | null;
+    /**
+     * Tear connection-level state down. Used internally by configure()
+     * to swap backends; preserves host-registered fallback listeners
+     * because the host UI handler (e.g. AdaptiveChatBarMountable's
+     * "swap to fallback card" callback) is configuration-independent.
+     */
+    private _disconnect;
+    /**
+     * Tear everything down — connection state PLUS host listeners.
+     * Use this in test teardown or when fully shutting the transport
+     * (page unload, integration test reset). The mountable calls
+     * _disconnect indirectly via reconfigure.
+     */
+    reset(): void;
+    private _clearDebounceTimer;
+    /**
+     * Shared error-handling kernel — called by the AG-UI subscriber and
+     * by the simulateError test seam. Publishes transport_error
+     * telemetry, captures lastErrorPayload, and starts the debounce
+     * timer that will fire fallback if no successful message arrives
+     * before it expires. Gated by hasSucceeded (post-success errors
+     * never fallback) and _fallbackRendered (one-shot).
+     */
+    private _handleErrorEvent;
+    /**
+     * Fire the fallback. One-shot per configure cycle. Notifies all
+     * fallback listeners with the per-customer card config and the
+     * diagnostic snapshot for telemetry/debug.
+     */
+    private _renderFallback;
+    private _wireSession;
+    private _forwardUserMessage;
+    /**
+     * Ensure AgUiTransport is up. Idempotent — multiple concurrent calls
+     * dedupe to a single Turnstile acquisition + transport setup.
+     * Returns true on success, false on terminal failure.
+     */
+    private _ensureConnected;
+    /**
+     * Acquire a Turnstile token via the managed-challenge flow.
+     * Delegates to the shared Turnstile helper that owns the verify
+     * panel lifecycle. Returns null when Turnstile is disabled at
+     * build time or acquisition fails.
+     */
+    private _acquireTurnstileWithChallenge;
+    /**
+     * Look up a tool call's current chatSession-side status by id.
+     * Used to decide between addToolCall (first sighting) and
+     * updateToolCall (subsequent updates) when AG-UI re-emits
+     * `tool-call` events for client tools transitioning to 'pending'.
+     */
+    private _findToolCallStatus;
+    /** Map AG-UI ToolCallStatus to TrailToolCall status. */
+    private _mapToolCallStatus;
+    private _onTransportEvent;
+}
+/**
+ * The module-level singleton. Imported by both the SDK runtime
+ * bootstrap (to call configure) and any code that needs to read
+ * transport state. Mirrors the chatSession singleton shape.
+ */
+export declare const chatTransport: ChatTransport;
+//# sourceMappingURL=ChatTransport.d.ts.map

package/dist/ChatTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatTransport.d.ts","sourceRoot":"","sources":["../src/ChatTransport.ts"],"names":[],"mappings":"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"}

package/dist/NavLinkMountable.d.ts

@@ -0,0 +1,25 @@
+/**
+ * NavLinkMountable — `MountableWidget` used as the payload of an
+ * LLM-authored navigation chip.
+ *
+ * Flow:
+ *   LLM mounts `suggest-navigation` ItemTemplate with `{title, url}`
+ *   → backend builds chip with payload `{widget: 'adaptive-chatbot:nav-link', props: {url}}`
+ *   → user clicks the chip → chips-strip mounts THIS widget into the
+ *     chip's drawer
+ *   → user clicks the "Go to <url>" button this widget renders
+ *   → same-origin SPA navigation via pushState + popstate (matches
+ *     `adaptive-nav`'s `executeNavigate` path for SPA-router compatibility)
+ *
+ * Registered as widget id `adaptive-chatbot:nav-link`.
+ *
+ * Security note: only http(s), same-origin destinations are honored.
+ * `javascript:`, `data:`, and cross-origin URLs are silently dropped at
+ * URL construction. The ItemTemplate's EnumField allowlist is the
+ * primary constraint; this is defense-in-depth.
+ */
+export declare const NavLinkMountable: {
+    mount(container: HTMLElement, mountConfig?: Record<string, unknown>): () => void;
+    update(container: HTMLElement, mountConfig?: Record<string, unknown>): void;
+};
+//# sourceMappingURL=NavLinkMountable.d.ts.map

package/dist/NavLinkMountable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavLinkMountable.d.ts","sourceRoot":"","sources":["../src/NavLinkMountable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAmEH,eAAO,MAAM,gBAAgB;qBACV,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,IAAI;sBAkB9D,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;CAO5E,CAAC"}