@syntrologie/adapt-chatbot 2.8.0-canary.43 → 2.8.0-canary.430

package/dist/AdaptiveChatTrail.d.ts

@@ -0,0 +1,415 @@
+/**
+ * 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;
+    /**
+     * The id of the newest message the render will actually PAINT — the only
+     * valid anchor target. Anchoring to the raw last message is wrong-by-
+     * construction for tool-call turns: mid-turn the newest message is often a
+     * whitespace-only assistant shell (some providers emit whitespace text
+     * deltas around tool calls) that the empty-bubble filter drops, so an
+     * anchor recorded on it can never be in the painted set and the receipt
+     * falls to the tail strip forever — resurrecting BUG-1783015943 (seen live
+     * on vela desktop, BUG-1783630187). `isSuggestionHost=false` here: a
+     * message whose ONLY content is reply chips is too ephemeral to anchor on
+     * (the chips clear when the visitor answers), so walk past it too.
+     */
+    private _newestRenderableMessageId;
+    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: 'notice';
+    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-HVGQJZMP.js";
+import "./chunk-7WSMNAKW.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"}