@syntrologie/adapt-chatbot 2.8.0-canary.42 → 2.8.0-canary.420

package/dist/AdaptiveChatBar.d.ts

@@ -0,0 +1,161 @@
+/**
+ * AdaptiveChatBar — the canvas lid composition for the chat-canvas
+ * experience. Renders the bubble-up trail on top and an always-visible
+ * input row below.
+ *
+ * Wiring contract (events out):
+ *   - `chat-message-sent` ({ text }): the user submitted text via Enter
+ *     or the send button. The owning code is responsible for pushing
+ *     this into the conversation history and producing a reply.
+ *
+ * Wiring contract (props in):
+ *   - `messages`: the conversation trail, passed straight through to
+ *     `<adaptive-chat-trail>`.
+ *   - `placeholder`: input placeholder copy. Defaults to a generic
+ *     "Ask, find, or navigate…" — the host (typically the slot's lid
+ *     widget mount) can override to a context-specific string.
+ *
+ * Light DOM. Glassmorphism is applied at the input-row level so the
+ * trail above floats over the host page without chrome. See PRD §4.4.
+ */
+import { LitElement } from 'lit';
+import './AdaptiveChatTrail.js';
+import type { InlineTrailWidget, InlineWidgetMounter, TileReceipt, TrailMessage } from './AdaptiveChatTrail.js';
+export declare class AdaptiveChatBar extends LitElement {
+    static properties: {
+        messages: {
+            attribute: boolean;
+        };
+        placeholder: {
+            type: StringConstructor;
+        };
+        assistantName: {
+            type: StringConstructor;
+        };
+        greeting: {
+            type: StringConstructor;
+        };
+        inFlight: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        thinkingText: {
+            attribute: boolean;
+        };
+        introSuggestion: {
+            attribute: boolean;
+        };
+        forceExpanded: {
+            type: BooleanConstructor;
+            reflect: boolean;
+        };
+        maximized: {
+            type: BooleanConstructor;
+        };
+        tileReceipts: {
+            attribute: boolean;
+        };
+        inlineWidgets: {
+            attribute: boolean;
+        };
+        mountInlineWidget: {
+            attribute: boolean;
+        };
+        _input: {
+            state: boolean;
+        };
+    };
+    messages: TrailMessage[];
+    maximized: boolean;
+    tileReceipts: TileReceipt[];
+    /** Widgets rendered inline in the trail (reco carousel), sourced from
+     *  the store's `chat-inline` slot mounts. Forwarded to the trail. */
+    inlineWidgets: InlineTrailWidget[];
+    /** Registry-backed mounter for inline widgets whose id is not their
+     *  custom-element tag (product card, comparison, FAQ). Set by the
+     *  mountable from `runtime.widgets`; forwarded to the trail. */
+    mountInlineWidget: InlineWidgetMounter | undefined;
+    /**
+     * Live reasoning narration from the model — streamed in via
+     * AG-UI THINKING_TEXT_MESSAGE_CONTENT events and forwarded by
+     * the ChatSession subscription on the host (mountable).
+     * Forwarded verbatim to the trail, which renders it in place of
+     * the silent loading dots between turns. Empty string when no
+     * thinking turn is active.
+     */
+    thinkingText: string;
+    /**
+     * Pre-conversation suggestion button — forwarded to the trail's
+     * empty-state pane. When the visitor clicks it the trail emits
+     * `trail-intro-suggestion`; we catch that here and submit the
+     * configured prompt through the normal send path.
+     */
+    introSuggestion: {
+        label: string;
+        prompt: string;
+    } | undefined;
+    /** Pass-through to {@link AdaptiveChatTrail}'s ``forceExpanded`` prop.
+     *  Hosts that mount the chat-bar in a full-screen surface (mobile
+     *  panel, agent app, etc.) set this to skip the collapse affordance
+     *  — there is no smaller state to fall back to. */
+    forceExpanded: boolean;
+    placeholder: string;
+    /**
+     * Name shown in the (forceExpanded) header. Defaults to a generic
+     * "Assistant". Hosts can override per-workspace (e.g. Vela sets
+     * "Vela Concierge") without inventing new SDK surface — it threads
+     * through the same mount config the placeholder does.
+     */
+    assistantName: string;
+    /**
+     * Initial assistant message shown before any real conversation
+     * starts. Renders inside the trail as a phantom assistant chip
+     * when messages.length === 0; auto-disappears as soon as the
+     * first user message lands. Mirrors ChatAssistantLit's greeting.
+     */
+    greeting: string | undefined;
+    /**
+     * Whether a chat round-trip is in flight (request sent, awaiting
+     * reply). The single send/stop button morphs accordingly: ↑ when
+     * ready, ⏹ when in-flight. Parent owns this state — set true after
+     * `chat-message-sent` fires, false when the reply lands or the
+     * request is aborted. Enter is inert while in-flight.
+     */
+    inFlight: boolean;
+    _input: string;
+    createRenderRoot(): HTMLElement;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onInput;
+    private _onKeyDown;
+    private _onSendOrInterrupt;
+    private _onTileReceiptActivate;
+    private _onAlertReceiptActivate;
+    private _onMaximizeToggle;
+    private _send;
+    /**
+     * Visitor tapped the intro suggestion button in the empty-state
+     * trail. Submit the configured prompt through the same channel as
+     * a typed message so listeners (mountable → chatSession.send) see
+     * a uniform shape — no need for a parallel "suggestion-sent" path.
+     * The trail's intro pane auto-disappears the moment the first
+     * message lands, so this also closes the empty state in one go.
+     */
+    private _onIntroSuggestion;
+    /**
+     * Visitor tapped an inline `suggest_replies` chip in the trail. Submit
+     * the chip text through the SAME `chat-message-sent` channel a typed
+     * message uses, so the reply rides the existing send path (mountable →
+     * chatSession.send → transport) — no fabricated AG-UI events. The
+     * trail clears the chips on its own once the reply lands and a newer
+     * assistant turn becomes the latest.
+     */
+    private _onSuggestedReply;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'adaptive-chat-bar': AdaptiveChatBar;
+    }
+}
+//# sourceMappingURL=AdaptiveChatBar.d.ts.map

package/dist/AdaptiveChatBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveChatBar.d.ts","sourceRoot":"","sources":["../src/AdaptiveChatBar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAQ,UAAU,EAAW,MAAM,KAAK,CAAC;AAGhD,OAAO,wBAAwB,CAAC;AAChC,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EACnB,WAAW,EACX,YAAY,EACb,MAAM,wBAAwB,CAAC;AAMhC,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,OAAgB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAcxB;IAEF,QAAQ,EAAE,YAAY,EAAE,CAAM;IAC9B,SAAS,UAAS;IAClB,YAAY,EAAE,WAAW,EAAE,CAAM;IACjC;yEACqE;IACrE,aAAa,EAAE,iBAAiB,EAAE,CAAM;IACxC;;oEAEgE;IAChE,iBAAiB,EAAE,mBAAmB,GAAG,SAAS,CAAa;IAE/D;;;;;;;OAOG;IACH,YAAY,SAAM;IAClB;;;;;OAKG;IACH,eAAe,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAa;IAE3E;;;uDAGmD;IACnD,aAAa,UAAS;IACtB,WAAW,SAAuB;IAClC;;;;;OAKG;IACH,aAAa,SAA0B;IACvC;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAa;IACzC;;;;;;OAMG;IACH,QAAQ,UAAS;IACjB,MAAM,SAAM;IAEH,gBAAgB,IAAI,WAAW;IAI/B,iBAAiB,IAAI,IAAI;IASzB,oBAAoB,IAAI,IAAI;IAYrC,OAAO,CAAC,QAAQ,CAEd;IAEF,OAAO,CAAC,UAAU,CAShB;IAKF,OAAO,CAAC,kBAAkB,CAMxB;IAEF,OAAO,CAAC,sBAAsB,CAM5B;IAEF,OAAO,CAAC,uBAAuB,CAK7B;IAEF,OAAO,CAAC,iBAAiB,CAEvB;IAEF,OAAO,CAAC,KAAK;IAoBb;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB,CAmBxB;IAEF;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB,CAiBvB;IAEO,MAAM;CAkDhB;AA8OD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,mBAAmB,EAAE,eAAe,CAAC;KACtC;CACF"}

package/dist/AdaptiveChatBar.js

@@ -0,0 +1,11 @@
+import {
+  AdaptiveChatBar
+} from "./chunk-2NX6765N.js";
+import "./chunk-EWPPVPJ4.js";
+import "./chunk-LSJFN2BR.js";
+import "./chunk-QF7ZTKXA.js";
+import "./chunk-UVKRO5ER.js";
+export {
+  AdaptiveChatBar
+};
+//# sourceMappingURL=AdaptiveChatBar.js.map

package/dist/AdaptiveChatBar.js.map

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

package/dist/AdaptiveChatBarMountable.d.ts

@@ -0,0 +1,45 @@
+/**
+ * AdaptiveChatBarMountable — `MountableWidget` adapter that turns the
+ * standalone `<adaptive-chat-bar>` Lit element into something the
+ * runtime widget registry can mount.
+ *
+ * Registered as widget id `adaptive-chatbot:chat-bar`. Customers
+ * reference it from canvas config — either as a slot's `lid` widget
+ * (replaces the launcher when referenced from `slots.drawer.lid`) or
+ * as a regular tile widget.
+ *
+ * The bar is a VIEW. State lives in the singleton `chatSession` —
+ * whether the bar mounts in the mini-canvas lid, the drawer lid, or
+ * both, they're all views of the same conversation. The mountable:
+ *   - subscribes to chatSession.subscribe() and pushes state into
+ *     the bar's `messages` + `inFlight` props on every change
+ *   - routes the bar's `chat-message-sent` event → chatSession.send()
+ *   - routes the bar's `chat-interrupt` event → chatSession.interrupt()
+ *   - bubbles the bar's `canvas-close` event → optional onClose
+ *     callback (canvas-level concern, not session-level)
+ *
+ * Props (passed via mountConfig):
+ *   - `placeholder?: string` — input placeholder copy
+ *   - `onClose?: () => void` — fires on ✕ click (canvas-level)
+ *
+ * Note: messages and inFlight are NOT props. They flow from chatSession.
+ * A canvas-config author who wants to pre-seed messages should do so
+ * via the session directly (e.g. via a startup action) — but typical
+ * use is to let the conversation start empty.
+ */
+import './AdaptiveChatBar';
+/**
+ * Test-only: drop the warm store singleton (and its hydration latch) so each
+ * test can wire a fresh store to its own event bus / registry. Without this,
+ * the first test in a file permanently binds the store to ITS bus and the
+ * per-instance version dedup silently drops every later test's re-mounts.
+ * Mirrors `observer/index.ts` `_resetObserverForTests`.
+ */
+export declare function _resetElementStoreForTests(): void;
+export declare function resolveTileWidget(templateId: string): string | undefined;
+export declare function refreshTemplateWidgetMap(uiTemplates: Record<string, unknown> | undefined): void;
+export declare const AdaptiveChatBarMountable: {
+    mount(container: HTMLElement, mountConfig?: Record<string, unknown>): () => void;
+    update(container: HTMLElement, mountConfig?: Record<string, unknown>): void;
+};
+//# sourceMappingURL=AdaptiveChatBarMountable.d.ts.map

package/dist/AdaptiveChatBarMountable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveChatBarMountable.d.ts","sourceRoot":"","sources":["../src/AdaptiveChatBarMountable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,mBAAmB,CAAC;AAoJ3B;;;;;;GAMG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAIjD;AA6BD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAExE;AAED,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI,CAgB/F;AA0SD,eAAO,MAAM,wBAAwB;qBAClB,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,IAAI;sBA2F9D,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;CAQ5E,CAAC"}

package/dist/AdaptiveChatTrail.anchor-scroll.test.d.ts

@@ -0,0 +1,2 @@
+import './AdaptiveChatTrail';
+//# sourceMappingURL=AdaptiveChatTrail.anchor-scroll.test.d.ts.map

package/dist/AdaptiveChatTrail.anchor-scroll.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveChatTrail.anchor-scroll.test.d.ts","sourceRoot":"","sources":["../src/AdaptiveChatTrail.anchor-scroll.test.ts"],"names":[],"mappings":"AA0BA,OAAO,qBAAqB,CAAC"}

package/dist/AdaptiveChatTrail.d.ts

@@ -0,0 +1,402 @@
+/**
+ * AdaptiveChatTrail — the "bubble-up" message column that sits above the
+ * chat bar in the canvas lid.
+ *
+ * Messages appear immediately above the chat bar and drift upward as
+ * newer ones arrive. Each stack position carries an opacity + blur
+ * falloff so older messages read as fading from the page. Beyond a
+ * `visibleCount` cap (default 3) the trail collapses into an "N more ·
+ * expand" affordance — clicking emits `trail-expand`.
+ *
+ * Shadow DOM (default Lit open root) so chip styles, markdown reset
+ * rules, and animation @keyframes are scoped to this element's tree.
+ * Theme CSS variables (--sc-tile-text-color, --sc-content-bubble-*,
+ * etc.) inherit through the shadow boundary, so canvas-level theming
+ * still reaches the chips. The earlier light-DOM render-root override
+ * silently broke @keyframes lookup once the trail was hosted inside
+ * any shadow root (sc-mount, velvet-mobile, etc.) — keyframes injected
+ * into `document.head` aren't visible from another tree scope.
+ *
+ * See PRD §4.3 (chat trail) for the canonical motion + falloff spec.
+ */
+import { LitElement, nothing } from 'lit';
+export interface TrailToolCall {
+    id: string;
+    name: string;
+    status: 'args-streaming' | 'pending' | 'running' | 'done' | 'error';
+    /**
+     * Parsed tool-call arguments, when available. Threaded through from
+     * the AG-UI `ToolCall.args` so the trail can render argument-derived
+     * affordances WITHOUT a new transport: an activity receipt for a
+     * `primary_response_action` mount (derives type + label from
+     * `template_id` / `content.title`) and inline reply chips for a
+     * `suggest_replies` call (reads the `replies` array). Undefined while
+     * args are still streaming or for tools whose args we don't surface.
+     */
+    args?: Record<string, unknown>;
+}
+export interface TrailMessage {
+    /** Stable identity for keyed rendering (must be unique within the trail). */
+    id: number | string;
+    role: 'user' | 'assistant' | 'system';
+    text: string;
+    /** Streaming → assistant text still arriving from backend. Complete → final. Error → fatal during stream. */
+    status?: 'streaming' | 'complete' | 'error';
+    /** Tool calls attached to an assistant message (rendered as compact chips). */
+    toolCalls?: TrailToolCall[];
+}
+export type TileReceipt = {
+    kind: 'tile';
+    instanceId: string;
+    title: string;
+    dismissed: boolean;
+} | {
+    kind: 'alert';
+    instanceId: string;
+    title: string;
+};
+/**
+ * A widget the backend wants rendered INLINE IN THE CHAT TRAIL (in the
+ * conversation flow, like a rich message) — currently the reco carousel.
+ * Sourced from `ElementInstanceStore.listInlineWidgets()` (backend
+ * `chat-inline` slot mounts) and forwarded by AdaptiveChatBar.
+ *
+ * The trail mounts `tag` by name via `document.createElement` and assigns
+ * the payload as one `props` object property (`el.props = props`, the
+ * standard tile-widget mount contract) — it never imports the widget package (the
+ * element self-defines when its own bundle loads; on demos both bundles
+ * are present). If `tag` is not a defined custom element, the trail
+ * renders NOTHING for it (no broken box).
+ */
+export interface InlineTrailWidget {
+    instanceId: string;
+    /**
+     * The mount identifier for the widget. For self-defining, server-mounted
+     * widgets this IS the custom-element tag (e.g. `syntro-product-reco-carousel`)
+     * and the trail creates it directly. For admin-template widgets it is the
+     * runtime widget-id (e.g. `adaptive-product:card`, `adaptive-faq:accordion`),
+     * which is NOT a valid custom-element tag — those mount through the runtime
+     * widget registry via {@link InlineWidgetMounter}, which resolves the id to
+     * its real element exactly like the deck `SyntroTileCard` path.
+     */
+    tag: string;
+    props: Record<string, unknown>;
+}
+/**
+ * Mounts a registry-registered widget (by its runtime widget-id) into
+ * `container` and returns the created element plus an unmount cleanup.
+ * Injected from the chat-bar mountable, bound to `runtime.widgets`. Lets the
+ * trail render inline tiles whose widget-id is not their custom-element tag
+ * (product card, comparison, FAQ accordion) — the registry owns the
+ * id → element resolution. Returns `null` when the id is not registered.
+ */
+export type InlineWidgetMounter = (widgetId: string, container: HTMLElement, props: Record<string, unknown>) => {
+    element: HTMLElement;
+    cleanup: () => void;
+} | null;
+export declare class AdaptiveChatTrail extends LitElement {
+    static styles: import("lit").CSSResult;
+    static properties: {
+        messages: {
+            attribute: boolean;
+        };
+        visibleCount: {
+            type: NumberConstructor;
+        };
+        expanded: {
+            type: BooleanConstructor;
+        };
+        greeting: {
+            type: StringConstructor;
+        };
+        /** When true: trail renders fully expanded AND the
+         *  expand/collapse affordance is hidden. Used by hosts that mount
+         *  the chat in a full-screen surface (the mobile panel) where
+         *  collapse makes no sense — there's nothing to collapse INTO. */
+        forceExpanded: {
+            type: BooleanConstructor;
+        };
+        /**
+         * Mirrors `chatSession.inFlight` — true between `send()` and the
+         * assistant's first `receiveStart`/`receiveDelta`, OR while a
+         * stream is in progress. Drives the "thinking" indicator that
+         * fills the gap between the user's just-sent message and the
+         * first assistant token. Wired through AdaptiveChatBar (it owns
+         * the chatSession subscription and forwards inFlight as a prop).
+         */
+        inFlight: {
+            type: BooleanConstructor;
+        };
+        /**
+         * Live reasoning narration streamed from the model via AG-UI
+         * `THINKING_TEXT_MESSAGE_CONTENT`. When non-empty, the thinking
+         * chip renders this in place of the bouncing dots so the visitor
+         * sees what the model is actually doing instead of staring at
+         * silent loading state during a tool-call gap.
+         */
+        thinkingText: {
+            attribute: boolean;
+        };
+        /**
+         * Pre-conversation suggestion chip. When the visitor opens the
+         * chat and `messages` is empty, the trail renders this as a
+         * button beneath the greeting. Clicking it dispatches a
+         * `trail-intro-suggestion` event with the configured prompt —
+         * the parent (chat-bar) forwards that to chatSession.send().
+         * Disappears the moment the first message lands.
+         */
+        introSuggestion: {
+            attribute: boolean;
+        };
+        /**
+         * Tappable tile-receipt chips rendered once at the end of the
+         * trail. Produced from the store by Task 3 (AdaptiveChatBar).
+         * Each chip emits `tile-receipt-activate` with its instanceId.
+         */
+        tileReceipts: {
+            attribute: boolean;
+        };
+        /**
+         * Widgets rendered INLINE in the trail (reco carousel etc.),
+         * anchored to a message position like receipts. Sourced from the
+         * store's `chat-inline` slot mounts via AdaptiveChatBar.
+         */
+        inlineWidgets: {
+            attribute: boolean;
+        };
+        /**
+         * Registry-backed mounter for inline widgets whose id is not their
+         * custom-element tag. Injected from the chat-bar mountable.
+         */
+        mountInlineWidget: {
+            attribute: boolean;
+        };
+        _messagesBelow: {
+            state: boolean;
+        };
+    };
+    messages: TrailMessage[];
+    tileReceipts: TileReceipt[];
+    inlineWidgets: InlineTrailWidget[];
+    mountInlineWidget: InlineWidgetMounter | undefined;
+    visibleCount: number;
+    expanded: boolean;
+    forceExpanded: boolean;
+    inFlight: boolean;
+    thinkingText: string;
+    introSuggestion: {
+        label: string;
+        prompt: string;
+    } | undefined;
+    /**
+     * Pre-conversation phantom assistant message. Rendered only when
+     * `messages` is empty. NOT injected into chatSession state — the
+     * greeting is configuration, not conversation, so it disappears
+     * automatically when the first real message arrives.
+     */
+    greeting: string | undefined;
+    /** Follow the bottom on content growth. On by default (history
+     * browsing); off from a new user message until the visitor opts back in
+     * (pill tap or a user-gesture scroll that reaches the bottom). */
+    private _stickToBottom;
+    /** The user message the current turn is anchored to. */
+    private _anchorMsgId;
+    /** Whether a turn anchor is live (drives expand-mid-turn landing). */
+    private _anchorActive;
+    /** Keep enforcing chip-at-top on updates (late geometry, mode flips)
+     * until the user scrolls or opts into following. */
+    private _anchorHold;
+    /** Number of messages whose BOTTOM edge is still below the viewport —
+     * messages the visitor hasn't scrolled past yet. Drives the
+     * "⌄ N messages" pill and stays accurate as they scroll (one long
+     * streaming reply counts as 1 until its end has been read). Reactive. */
+    private _messagesBelow;
+    /** Timestamp of the last user scroll gesture (wheel/touch): scroll
+     * events outside this window are programmatic (our own pin/anchor) and
+     * must not re-engage following — anchoring the newest message clamps AT
+     * the bottom in any longer conversation. */
+    private _lastUserScrollIntentTs;
+    private static readonly _AT_BOTTOM_EPSILON_PX;
+    private static readonly _USER_SCROLL_INTENT_WINDOW_MS;
+    private get _scrollable();
+    private _trailContainer;
+    private _isAtBottom;
+    /** Count chips whose bottom edge hasn't entered the viewport yet. */
+    private _countMessagesBelow;
+    private _syncContentBelow;
+    private _markUserScrollIntent;
+    private _onTrailScroll;
+    /** Pill tap: jump to the newest content and follow for the rest of the turn. */
+    private _onScrollToRecent;
+    /** Scroll so the anchored user chip sits at the top of the trail
+     * viewport. Idempotent — safe to re-apply on every update while the
+     * hold is live (content grows BELOW the anchor, so the target is
+     * stable; re-applying also covers late geometry, e.g. expanding
+     * mid-turn from the ambient strip). */
+    private _applyAnchor;
+    private _pinToBottom;
+    private _onExpand;
+    /**
+     * Approve a pending client tool call. The trail emits a generic
+     * event so the host can decide whether to forward to chatSession
+     * (the common path) or override. Keeps the trail itself free of
+     * direct chatSession coupling — it's a pure view component.
+     */
+    private _onToolCallClick;
+    private _onCollapse;
+    /**
+     * Whether to render the thinking-dots chip after the last message.
+     * True iff a request is in flight AND the assistant hasn't started
+     * streaming a reply yet — once the first delta lands, the streaming
+     * chip's caret takes over and the thinking indicator hides so the
+     * visitor isn't shown both at once. Also hidden when the last
+     * message is an error/system message, because the request that
+     * "errored" is already over from the user's perspective.
+     */
+    private _shouldShowThinking;
+    /**
+     * instanceId → id of the message that was newest when the receipt first
+     * appeared. This is what makes a receipt read like a chat bubble: it renders
+     * inline right after its anchor message, so newer messages push it up into
+     * history instead of it staying pinned below everything. Assigned once per
+     * instanceId (in willUpdate, the only place that sees both `messages` and
+     * `tileReceipts` at the moment a tile mounts) and never re-homed — a
+     * dismiss/bring-back keeps the chip where it was created. `null` = the tile
+     * mounted before the first chat message (canvas replay); those fall to the
+     * tail strip (see render).
+     */
+    private readonly _receiptAnchors;
+    /**
+     * instanceId → anchor message id for inline widgets — same mechanism as
+     * `_receiptAnchors`. The inline carousel renders right after the message
+     * that was newest when it mounted, so it reads like a rich reply and
+     * drifts up into history as later messages append.
+     */
+    private readonly _inlineAnchors;
+    /**
+     * instanceId → the cached inline widget entry (render node + props target +
+     * optional registry cleanup). Cached so a prop patch (same instanceId, new
+     * props) updates the EXISTING element instead of tearing it down and
+     * re-creating it — which would reset the carousel's scroll position +
+     * internal state. Created lazily the first time we see the widget:
+     * `document.createElement(tag)` for a defined tag, or a registry mount for a
+     * widget-id. An unresolvable widget caches `null` so the fail-safe renders
+     * nothing without re-checking the registry.
+     */
+    private readonly _inlineElements;
+    disconnectedCallback(): void;
+    willUpdate(changed: Map<string, unknown>): void;
+    /**
+     * Create (once) or refresh the cached element for an inline widget.
+     *
+     * Two mount paths, both keeping the chat bundle free of any widget-package
+     * import:
+     *   - Direct tag (self-defining, server-mounted widgets like the reco
+     *     carousel whose declared `widget` IS its custom-element tag):
+     *     `document.createElement(tag)`.
+     *   - Widget-id (admin-template widgets like `adaptive-product:card` or
+     *     `adaptive-faq:accordion`, whose `widget` is a runtime widget-id, NOT a
+     *     valid custom-element tag): mount through the runtime widget registry
+     *     via {@link mountInlineWidget}, which resolves the id to its real
+     *     element exactly like the deck `SyntroTileCard` path. Without this,
+     *     `createElement('adaptive-product:card')` yields an inert unknown
+     *     element and the tile renders permanently blank (the "inline mode
+     *     shows nothing but the reco" bug).
+     *
+     * Fail-safe: an id that resolves to neither a defined tag nor a registered
+     * widget caches `null` and renders nothing (no broken box).
+     */
+    private _ensureInlineElement;
+    updated(changed: Map<string, unknown>): void;
+    private _onTileReceiptClick;
+    private _onAlertReceiptClick;
+    /** Render a set of inline widgets (reco carousel etc.) as
+     *  `[data-trail-widget]` blocks, anchored to a message position like
+     *  receipts. Each block hosts the cached custom element for that
+     *  instanceId — a defined tag mounts inline; an undefined tag renders
+     *  nothing (fail-safe). Rendered at every trail site (inline per anchor,
+     *  tail, empty-state) so placement can't diverge. */
+    private _renderInlineWidgetStrip;
+    /** A row of receipt chips, used at every trail render site (inline per
+     *  anchor message, the tail fallback, and the empty-state branches) so the
+     *  markup + styling can never diverge. Returns `nothing` for an empty list. */
+    private _renderReceiptStrip;
+    /** One receipt chip — a single, unified, single-line design for both kinds
+     *  (nav "alert" + mounted "tile"). Same container/title/action style so they
+     *  read as one chip family; the icon + action label carry the kind. No
+     *  subtitle: the old "Brought up earlier" line was hardcoded (wrong for
+     *  same-turn mounts) and made the chip taller — dropping it is the "shorter"
+     *  chip. Rendered at every trail site so the kinds can't diverge. */
+    private _renderReceiptChip;
+    private _onIntroSuggestionClick;
+    /**
+     * Visitor tapped a `suggest_replies` inline chip. Emit
+     * `trail-suggested-reply` carrying the chip text — the parent
+     * (AdaptiveChatBar) re-dispatches it as `chat-message-sent`, the
+     * SAME channel the input row uses, so the reply rides the existing
+     * send path (mountable → chatSession.send → transport). No fabricated
+     * AG-UI events; this is exactly what typing the text and hitting
+     * Enter would do. The chips clear on their own once the reply lands
+     * and a newer assistant message becomes the latest.
+     */
+    private _onSuggestedReplyClick;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+}
+/**
+ * Discriminated visual state for a chip. Replaces the older
+ * `(role, { isStreaming, isError })` triple whose interaction order
+ * could produce nonsense combinations (e.g. an assistant chip
+ * accidentally reading as a user bubble because `isStreaming` was
+ * checked before role). Each kind below is a real conversational
+ * state with a single visual identity:
+ *
+ *   - `settled`    — a complete message; the user-vs-assistant
+ *                    identity comes from `role`
+ *   - `streaming`  — the assistant chip currently receiving tokens;
+ *                    keeps assistant identity (the blinking caret
+ *                    inside the chip carries "in progress")
+ *   - `pending`    — the thinking chip shown between the user's
+ *                    just-sent message and the assistant's first
+ *                    token; assistant identity (the bouncing dots
+ *                    inside carry "in progress")
+ *   - `error`      — a chip whose stream failed mid-flight, OR any
+ *                    system-role message (system messages render
+ *                    with the error identity by convention)
+ *
+ * Bug history: an earlier branch-ladder design checked `isStreaming`
+ * before `role`, so the `pending`/thinking chip inherited the user
+ * bubble border. On hosts whose chat panel sits over a light surface
+ * that read as a "white div" pasted into the assistant slot. The
+ * discriminated state prevents that combination from being expressible.
+ */
+export type ChipVisualState = {
+    kind: 'settled';
+    role: 'user' | 'assistant' | 'system';
+} | {
+    kind: 'streaming';
+} | {
+    kind: 'pending';
+} | {
+    kind: 'error';
+    role: 'user' | 'assistant' | 'system';
+};
+/**
+ * A misbehaving model can emit a raw SERIALIZED response payload as plain TEXT
+ * on a spurious trailing turn — e.g.
+ * `(Empty response: {'content': [{'type': 'thinking', …}], 'stop_reason': …})`.
+ * Backstop for model degeneration (Kimi); the prompt (S-14) also asks for one
+ * brief closing, but copy can't be trusted on the very turn that degenerates.
+ *
+ * Detection avoids false positives (which are WORSE than the dump — the visitor
+ * would see nothing): a turn is dropped only if it OPENS with the literal
+ * "(Empty response" marker, OR it carries ≥2 serialization tokens at once. A
+ * single token (a product about a "signature blend", the agent quoting one JSON
+ * key) never trips it; a real response dump carries all of them.
+ */
+export declare function looksLikeSerializedModelResponse(text: string): boolean;
+declare global {
+    interface HTMLElementTagNameMap {
+        'adaptive-chat-trail': AdaptiveChatTrail;
+    }
+}
+//# sourceMappingURL=AdaptiveChatTrail.d.ts.map

package/dist/AdaptiveChatTrail.d.ts.map

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

package/dist/AdaptiveChatTrail.js

@@ -0,0 +1,11 @@
+import {
+  AdaptiveChatTrail,
+  looksLikeSerializedModelResponse
+} from "./chunk-LSJFN2BR.js";
+import "./chunk-QF7ZTKXA.js";
+import "./chunk-UVKRO5ER.js";
+export {
+  AdaptiveChatTrail,
+  looksLikeSerializedModelResponse
+};
+//# sourceMappingURL=AdaptiveChatTrail.js.map