@syntrologie/adapt-chatbot 2.8.0-canary.41 → 2.8.0-canary.410

package/dist/AdaptiveChatBar.d.ts

@@ -0,0 +1,154 @@
+/**
+ * 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, 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;
+        };
+        _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[];
+    /**
+     * 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,EAAE,iBAAiB,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAM3F,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,OAAgB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAaxB;IAEF,QAAQ,EAAE,YAAY,EAAE,CAAM;IAC9B,SAAS,UAAS;IAClB,YAAY,EAAE,WAAW,EAAE,CAAM;IACjC;yEACqE;IACrE,aAAa,EAAE,iBAAiB,EAAE,CAAM;IAExC;;;;;;;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;CAiDhB;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-L3LR2J3L.js";
+import "./chunk-EWPPVPJ4.js";
+import "./chunk-I73UT22O.js";
+import "./chunk-5PW6T3QF.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,37 @@
+/**
+ * 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';
+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;AA6K3B,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;AA4QD,eAAO,MAAM,wBAAwB;qBAClB,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,IAAI;sBAuE9D,WAAW,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;CAQ5E,CAAC"}

package/dist/AdaptiveChatTrail.d.ts

@@ -0,0 +1,314 @@
+/**
+ * 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
+ * `props` onto the element — 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;
+    /** Custom-element tag (e.g. `syntro-product-reco-carousel`). */
+    tag: string;
+    props: Record<string, unknown>;
+}
+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;
+        };
+    };
+    messages: TrailMessage[];
+    tileReceipts: TileReceipt[];
+    inlineWidgets: InlineTrailWidget[];
+    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;
+    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 live custom element mounted for an inline widget.
+     * 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.
+     * The element is created lazily via `document.createElement(tag)` the
+     * first time we see a defined tag; an undefined tag caches `null` so
+     * the fail-safe renders nothing without re-checking the registry.
+     */
+    private readonly _inlineElements;
+    willUpdate(changed: Map<string, unknown>): void;
+    /**
+     * Create (once) or refresh the cached custom element for an inline
+     * widget. Mounts by tag name so the chat bundle never imports the
+     * widget package. Fail-safe: if the tag is not a defined custom
+     * element, cache `null` and render 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":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,EAAa,UAAU,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAIrD,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,gBAAgB,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;IACpE;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,6EAA6E;IAC7E,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,CAAC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,6GAA6G;IAC7G,MAAM,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,OAAO,CAAC;IAC5C,+EAA+E;IAC/E,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;CAC7B;AAED,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,GACvE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,gEAAgE;IAChE,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AA8BD,qBAAa,iBAAkB,SAAQ,UAAU;IAsB/C,OAAgB,MAAM,0BA8FpB;IAEF,OAAgB,UAAU;;;;;;;;;;;;;QAKxB;;;0EAGkE;;;;QAElE;;;;;;;WAOG;;;;QAEH;;;;;;WAMG;;;;QAEH;;;;;;;WAOG;;;;QAEH;;;;WAIG;;;;QAEH;;;;WAIG;;;;MAEH;IAEF,QAAQ,EAAE,YAAY,EAAE,CAAM;IAC9B,YAAY,EAAE,WAAW,EAAE,CAAM;IACjC,aAAa,EAAE,iBAAiB,EAAE,CAAM;IACxC,YAAY,SAAmB;IAC/B,QAAQ,UAAS;IACjB,aAAa,UAAS;IACtB,QAAQ,UAAS;IACjB,YAAY,SAAM;IAClB,eAAe,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAa;IAC3E;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAa;IAQzC,OAAO,CAAC,SAAS,CAMf;IAEF;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB,CAStB;IAEF,OAAO,CAAC,WAAW,CAMjB;IAEF;;;;;;;;OAQG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAgD;IAEhF;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgD;IAE/E;;;;;;;;OAQG;IACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAyC;IAEhE,UAAU,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAyCxD;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAmBnB,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAyBrD,OAAO,CAAC,mBAAmB,CAQzB;IAEF,OAAO,CAAC,oBAAoB,CAQ1B;IAEF;;;;;yDAKqD;IACrD,OAAO,CAAC,wBAAwB;IAmBhC;;mFAE+E;IAC/E,OAAO,CAAC,mBAAmB;IAO3B;;;;;yEAKqE;IACrE,OAAO,CAAC,kBAAkB;IAgC1B,OAAO,CAAC,uBAAuB,CAU7B;IAEF;;;;;;;;;OASG;IACH,OAAO,CAAC,sBAAsB,CAU5B;IAEO,MAAM;CAyehB;AA+BD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,CAAA;CAAE,CAAC;AAoT7D;;;;;;;;;;;;GAYG;AACH,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAStE;AAmaD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,qBAAqB,EAAE,iBAAiB,CAAC;KAC1C;CACF"}

package/dist/AdaptiveChatTrail.js

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

package/dist/AdaptiveChatTrail.js.map

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

package/dist/AdaptiveChatTrail.test.d.ts

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

package/dist/AdaptiveChatTrail.test.d.ts.map

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