@visma-swno/gaia-chat-ui 5.0.1 → 5.2.0

package/dist/app/app.d.ts

@@ -1,7 +1,7 @@
 import { PropertyValues } from 'lit';
 import { StrategyType } from '../core/store';
 import { TokenFetcher } from '../services/auth-service';
-import { FrontendTool, HostContextProvider } from '../types';
+import { FrontendTool, HostContext, HostContextProvider } from '../types';
 import { BaseElement } from '../components/shared/base-element';
 /**
  * Root chat widget component.
@@ -12,6 +12,7 @@ import { BaseElement } from '../components/shared/base-element';
  * @element gaia-chat
  *
  * @fires {ConversationClearedEvent} conversation-cleared - When the user clears the conversation
+ * @fires {ConversationRestoredEvent} conversation-restored - When a conversation is restored from history, carrying the persisted host-context snapshot so the host app can re-orient to the tenant / customer / company it was about.
  * @fires {MessageSentEvent} message-sent - When the user sends a message
  * @fires {ToolCallApprovedEvent} tool-call-approved - When the user approves a tool call
  * @fires {ToolCallDeclinedEvent} tool-call-declined - When the user declines a tool call
@@ -27,6 +28,24 @@ import { BaseElement } from '../components/shared/base-element';
  *   auth-strategy="visitor"
  * ></gaia-chat>
  * ```
+ *
+ * ### Host-provided conversation id
+ *
+ * Setting the `conversation-id` attribute opens that conversation as a
+ * **scoped view** without overwriting the user's normal stored session. This
+ * is for host apps that need to deep-link back into a specific conversation
+ * — e.g. a report designer reopening the chat that produced a given report.
+ * Removing the attribute restores the localStorage-backed conversation.
+ *
+ * ```html
+ * <gaia-chat conversation-id="d4f9..." profile-id="default"></gaia-chat>
+ * ```
+ *
+ * If the user clears the chat while a host-provided `conversation-id` is set,
+ * `conversation-cleared` fires with `previousConversationId` matching the
+ * pinned value. Treat that as the user opting out of the deep-link — typical
+ * responses are to clear/update the attribute, or leave it pinned and accept
+ * that the next mount will re-restore the deep-linked conversation.
  */
 export declare class ChatApp extends BaseElement {
     static styles: import('lit').CSSResult[];
@@ -42,10 +61,22 @@ export declare class ChatApp extends BaseElement {
     authStrategy: StrategyType;
     /** Whether to show a close button in the header. */
     closeable: boolean;
-    /** Override the default AI model. Must be in the profile's allowed overrides list. */
-    selectedModel: string;
+    /** Whether to show the conversation history button in the header. */
+    enableHistory: boolean;
+    /**
+     * Host-provided conversation id (#2644). When set, this conversation is
+     * restored instead of the one persisted in localStorage. The localStorage
+     * value is **not** overwritten — clearing the attribute returns the widget
+     * to that previous conversation. Empty string is treated as unset.
+     */
+    conversationId: string;
     /** Frontend tool definitions sent to the agent. */
     tools: FrontendTool[];
+    /**
+     * Readonly mode: hides the composer, header actions, and connection overlay.
+     * Use `setReadonlyMessages()` to inject messages for display.
+     */
+    readonlyMode: boolean;
     private get activeLang();
     private langObserver?;
     private store;
@@ -54,20 +85,69 @@ export declare class ChatApp extends BaseElement {
     private canvasActive;
     private canvasExpanded;
     private supportSessionEnded;
+    private historyOpen;
+    private settingsOpen;
+    private attachmentsEnabled;
+    private supportConnected;
+    private isDraggingOver;
+    private dragDepth;
     private disposables;
     private ctx;
     private handleInlineQuestionClick;
     connectedCallback(): void;
     disconnectedCallback(): void;
     private handleAuthChanged;
+    /**
+     * Reconcile the chat surface with the current `conversation-id` attribute
+     * when no auth-related prop changed alongside it. Non-empty value → scoped
+     * restore (no localStorage write). Empty/absent → fall back to the
+     * localStorage-backed conversation via `loadHistory`.
+     */
+    private applyConversationIdOverride;
     willUpdate(changedProperties: PropertyValues): void;
-    private applySelectedModel;
     private toggleHostAttribute;
     private handleKeyDown;
+    /**
+     * Retroactively update the host-context snapshot for the most recent user
+     * message. Call this after a mid-run context confirmation (e.g. a frontend
+     * tool) so the "Context changed" divider renders immediately.
+     */
+    patchCurrentMessageHostContext(props: Record<string, unknown>): void;
+    /**
+     * Returns the host-context snapshot persisted for the active conversation,
+     * shaped as a {@link HostContext}, or `null` when none is available.
+     *
+     * The localStorage-backed restore path (`loadHistory`) hydrates this snapshot
+     * but does not emit {@link ConversationRestoredEvent}, so a host app that
+     * supplies context via `hostContextProvider` can read it here to keep
+     * follow-up messages scoped to the restored tenant/company after a refresh.
+     */
+    getActiveHostContext(): HostContext | null;
+    /** Whether a file dragged over the widget can currently be attached. */
+    private get canAcceptDrop();
+    private get composer();
+    private dragContainsFiles;
+    private handleDragEnter;
+    private handleDragOver;
+    private handleDragLeave;
+    private handleDrop;
     /** Clears the current conversation and resets the chat. */
     clearConversation(): void;
     /** Stops any active support session. */
     stopSupport(): void;
+    /** Sends a message programmatically after the chat has initialized. */
+    sendMessage(message: string): Promise<void>;
+    /**
+     * Inject messages for readonly display. Accepts AG-UI format messages
+     * (as returned by the inspect API) and runs them through the full message
+     * pipeline so tool calls, search results, reasoning, and citations all
+     * render correctly.
+     *
+     * @param messages - AG-UI format message objects from the backend.
+     * @param thumbs - Optional map of messageId → "up" | "down" for feedback indicators.
+     */
+    setReadonlyMessages(messages: ReadonlyArray<Record<string, unknown>>, thumbs?: Readonly<Record<string, string>>): void;
+    private waitForInitialization;
     render(): import('lit-html').TemplateResult<1>;
 }
 declare global {

package/dist/components/canvas/iframe-preview/iframe-preview.d.ts

@@ -41,13 +41,64 @@ export declare class IframePreview extends BaseElement {
     private handleRendererReady;
     private transpileAndSend;
     private updateIframeHtml;
+    /**
+     * Single source of truth for report sanitization. Branches on whether the
+     * LLM produced a full document or a fragment, runs DOMPurify with the
+     * matching options, then runs the defense-in-depth post-pass. Both the
+     * chart-bundle precheck in `updateIframeHtml` and the final `buildHtml`
+     * call site consume the same output, so detection and rendering can never
+     * disagree about what survives sanitisation.
+     */
+    private sanitizeContent;
     private loadChartsScript;
     /**
-     * Error harness script injected into the report iframe.
-     * Catches JS errors and scans the DOM for chart rendering errors,
-     * then reports render status back to the parent via postMessage.
+     * Returns the error harness script tag with a per-render CSP nonce.
+     * The nonce matches the one embedded in the Content-Security-Policy meta
+     * tag, so `script-src 'unsafe-inline'` is not required.
+     */
+    private static errorHarness;
+    /**
+     * Returns the CSP meta tag for the report iframe, scoped to a per-render
+     * nonce.
+     *
+     * Using a nonce eliminates the need for `script-src 'unsafe-inline'`:
+     * only `<script nonce="…">` elements whose nonce matches the policy are
+     * executed, so a DOMPurify zero-day that lets an inline `<script>` survive
+     * sanitization cannot execute — it would have no nonce.
+     *
+     * The iframe is loaded via `srcdoc`, which does not receive the server's
+     * HTTP-header CSP applied to /canvas/*. The policy therefore lives inside
+     * the document itself and mirrors the transpile-renderer policy
+     * (assistant/src/Api/Program.cs). `connect-src 'none'` is the critical
+     * directive — it blocks fetch/XHR/beacon so surviving scripts cannot
+     * exfiltrate report contents to an external host.
+     */
+    private static buildCspMeta;
+    /** Tags stripped from LLM-authored report HTML. Script/handler removal is
+     * already covered by DOMPurify defaults; these add belt-and-braces against
+     * tags that can navigate, load external resources, or submit data.
+     *
+     * Notably *not* forbidden — these are intended report features:
+     *   - `<svg>`: pdf-report skill instructs the LLM to inline SVG icons
+     *     and diagrams (see `assistant/src/Plugins/PdfReport/skills/.../SKILL.md`).
+     *     The script-execution risk from SVG-mediated DOMPurify mXSS is
+     *     neutralised by the per-render CSP nonce — a surviving inline `<script>`
+     *     would have no nonce and the browser would refuse to run it.
+     *   - `<img>`: pdf-report supports PNG data URIs (`src="data:image/png;…"`),
+     *     and the iframe CSP already restricts `img-src` to `data: blob:`.
+     *   - `<style>`: pdf-report embeds all CSS in `<style>` blocks. The element
+     *     itself is safe; CSS-injection-via-attribute is blocked by
+     *     `REPORT_FORBID_ATTRS` below.
      */
-    private static readonly ERROR_HARNESS;
+    private static readonly REPORT_FORBID_TAGS;
+    /** Attributes stripped from LLM-authored report HTML. The inline `style`
+     * attribute is the main UI-spoofing vector left after `<script>`/handler
+     * removal — e.g. `<div style="position:fixed;inset:0;background:#fff;
+     * z-index:9999">…fake content…</div>` could mask the rest of the report
+     * inside the iframe. The pdf-report skill never instructs the LLM to use
+     * inline `style` attributes (it embeds all CSS in a `<style>` block), so
+     * forbidding the attribute does not regress intended functionality. */
+    private static readonly REPORT_FORBID_ATTRS;
     private buildHtml;
     private escapeHtml;
     render(): import('lit-html').TemplateResult<1>;

package/dist/components/composer/message-composer.d.ts

@@ -21,28 +21,78 @@ export declare class GaiaMessageComposer extends BaseElement {
     textareaWrap: HTMLDivElement;
     textarea: HTMLTextAreaElement;
     autosize: HTMLDivElement;
+    attachmentInput?: HTMLInputElement;
     private value;
     private invalid;
+    private pendingAttachments;
+    private attachmentError;
+    private uploadingCount;
+    private isRecording;
+    private speechSupported;
+    private recognition;
     profileId: string;
     hostContextProvider?: HostContextProvider;
     rows: number;
     maxRows: number;
     connectedCallback(): void;
     disconnectedCallback(): void;
+    /** Whether an attachment upload is currently in flight. */
+    private get uploadingAttachment();
     private get notAllowedToSendMessage();
+    private get canUseVoiceDictation();
     private isMessageNotAllowed;
     private validateInput;
+    private initSpeechRecognition;
+    private toggleRecording;
     private handleChange;
     private handleInput;
     private handleFeedbackClosed;
     private closeFeedbackIfOpen;
     private handleSendMessage;
+    private handleStopMessage;
     private resolveHostContext;
     private dispatchToSupport;
     private dispatchToAssistant;
+    private handleAttachmentButtonClick;
+    private clearPendingAttachments;
+    /** Dismisses the attachment error banner without discarding staged attachments. */
+    private dismissAttachmentError;
+    private removePendingAttachment;
+    private handleAttachmentSelected;
+    private processAttachmentFiles;
+    private uploadAttachmentFile;
+    /**
+     * Whether a file can currently be accepted as a pending attachment.
+     *
+     * False when attachments are disabled for the profile, the support channel
+     * is active, or the composer is disabled/loading. Callers should check this
+     * before suppressing native browser behaviour (e.g. paste) so they don't
+     * swallow the event without effect. Multiple attachments may be queued, so
+     * an in-flight upload does not block accepting further files.
+     */
+    get canAcceptAttachment(): boolean;
+    /**
+     * Uploads files dropped anywhere on the chat surface as pending attachments.
+     *
+     * Called by the root chat component, which owns the drag-and-drop overlay so
+     * files can be dropped over the entire widget rather than only the composer.
+     * Guards against uploads while attachments are unavailable for the active
+     * channel/profile.
+     */
+    acceptDroppedFiles(files: File[]): Promise<void>;
+    /**
+     * Uploads a single dropped file as a pending attachment.
+     *
+     * Thin wrapper around {@link acceptDroppedFiles} retained for callers that
+     * only have a single file to hand.
+     */
+    acceptDroppedFile(file: File): Promise<void>;
     private handleSuggestedQuestionClick;
     private handleKeyDown;
+    private handlePaste;
     private maybeEmitTyping;
+    private createPreviewUrl;
+    private revokeAllPreviewUrls;
     protected updated(changed: PropertyValues): Promise<void>;
     /** Sets focus on the textarea. */
     focus(options?: FocusOptions): void;
@@ -51,6 +101,9 @@ export declare class GaiaMessageComposer extends BaseElement {
     /** Selects all the text in the textarea. */
     select(): void;
     render(): import('lit-html').TemplateResult<1>;
+    private getPendingAttachmentPreviews;
+    private renderPendingAttachmentPreviews;
+    private renderAttachmentError;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/dist/components/conversation/context-changed-divider/context-changed-divider.d.ts

@@ -0,0 +1,40 @@
+import { BaseElement } from '../../shared/base-element';
+/**
+ * Per-key diff between two adjacent host-context snapshots. Drives the expanded
+ * comparison view that the divider reveals on click. Mirrors the shape produced
+ * by `describeHostContextDiff()` in the conversation renderer — the divider is
+ * purely presentational and trusts its caller to compute the diff.
+ */
+export type HostContextDiff = {
+    added: Record<string, unknown>;
+    removed: Record<string, unknown>;
+    changed: Record<string, {
+        from: unknown;
+        to: unknown;
+    }>;
+};
+/**
+ * Visual divider rendered between two adjacent user messages whose host-supplied
+ * context differs (e.g. the host app pivoted from one customer to another mid-chat).
+ *
+ * Renders a centered "Context changed" disclosure button between two horizontal
+ * rules. Clicking the button toggles a panel below that lists the per-key diff —
+ * added / changed / removed entries — so the user can compare what shifted.
+ *
+ * @element gaia-context-changed-divider
+ */
+export declare class GaiaContextChangedDivider extends BaseElement {
+    /** Per-key diff of host context. Drives the expanded comparison view. */
+    diff?: HostContextDiff;
+    private expanded;
+    static styles: import('lit').CSSResult[];
+    private toggle;
+    private renderEntries;
+    private renderDetails;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'gaia-context-changed-divider': GaiaContextChangedDivider;
+    }
+}

package/dist/components/conversation/context-divider.d.ts

@@ -0,0 +1,55 @@
+import { HostContextDiff } from './context-changed-divider/context-changed-divider';
+import { UiMessage } from '../../core/adapters/message-types';
+import { HostContextSnapshot } from '../../core/types';
+/**
+ * Pure helpers that decide when the `<gaia-context-changed-divider>` fires and what
+ * diff it should display. Extracted from `<gaia-conversation>` so the gating
+ * invariants — "first user message never fires", "baseline advances on every user
+ * message even with no context", "transitions to/from no-context still fire" — can
+ * be unit-tested without mounting the conversation component. The renderer just
+ * consumes the Map this module produces.
+ */
+/**
+ * Decide whether a "Context changed" divider should fire between two adjacent user
+ * messages' host-context snapshots. Fires whenever the two snapshots differ, treating
+ * `undefined`/`null` as a first-class "no host context" state — so a transition from
+ * `{ companyId: 123 }` to `undefined` (e.g. user switched profile and the host stopped
+ * forwarding companyId) draws a line, just like any other change. The first user
+ * message in a conversation never fires; that gating happens in
+ * `computeContextChangedMessageIds`, not here.
+ *
+ * Both ends of the pipeline serialize via JSON-shaped objects, so a key-sorted
+ * recursive deep-equal is sufficient — we don't need to handle Maps, Dates, or other
+ * non-JSON types.
+ */
+export declare function shouldFireContextChangedDivider(previous: HostContextSnapshot | undefined, current: HostContextSnapshot | undefined): boolean;
+/**
+ * Classify the differences between two host-context snapshots into added / removed /
+ * changed keys. The result is passed straight into `<gaia-context-changed-divider>`,
+ * which renders it as the expandable comparison view shown when the user opens the
+ * divider.
+ */
+export declare function describeHostContextDiff(previous: HostContextSnapshot | undefined, current: HostContextSnapshot | undefined): HostContextDiff;
+/**
+ * Identify user messages that need a "Context changed" divider rendered above them,
+ * paired with the summary the divider should display. A user message qualifies when
+ * its recorded host-context differs from the previous user message's — including
+ * transitions to/from "no recorded context". The very first user message never
+ * qualifies because there's no prior turn to compare to.
+ *
+ * Works identically for live sends (snapshot written by the run-coordinator) and
+ * rehydrated chats (snapshot loaded from `conversation_v2_messages` via the restore
+ * path) — both populate the same `messageHostContexts` map.
+ *
+ * Returns a Map of message id → diff describing the per-key change. The divider
+ * uses the diff to render its expanded comparison view on demand. O(1) lookup per
+ * group.
+ */
+export declare function computeContextChangedMessageIds(messages: UiMessage[], contexts: Record<string, HostContextSnapshot>): Map<string, HostContextDiff>;
+/**
+ * Internal JSON-shape deep-equal. Exported solely for unit tests that lock in the
+ * key-order-independence and array-vs-object behavior the divider gating depends on.
+ * Not part of the module's public API — callers should use `shouldFireContextChangedDivider`
+ * or `describeHostContextDiff` instead of comparing snapshots directly.
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;

package/dist/components/conversation/conversation.d.ts

@@ -14,10 +14,14 @@ export declare class GaiaConversation extends BaseElement {
     private containerRef;
     private scrollViewRef;
     private lastMessageRef;
+    private selectConversationState;
     private ctrl;
+    private sharingCtrl;
+    private sharingPromptTriggered;
     private handleThumb;
     private scrollCtrl;
     protected updated(): Promise<void>;
+    private handleSharingPromptResponse;
     /**
      * Whether the thinking indicator should be visible.
      * Hidden when the last message is a pending tool call with a visible
@@ -29,6 +33,7 @@ export declare class GaiaConversation extends BaseElement {
      */
     private isMessageInActiveRun;
     private renderRunGroup;
+    private renderRunGroupBody;
     render(): import('lit-html').TemplateResult<1>;
 }
 declare global {

package/dist/components/conversation/welcome-message/welcome-message.d.ts

@@ -1,17 +1,25 @@
 import { WelcomeMessage } from '../../../core/types';
 import { BaseElement } from '../../shared/base-element';
+export interface SharingPromptResponseEvent {
+    accepted: boolean;
+}
 /**
  * Welcome screen shown when the conversation is empty.
  *
  * Renders a greeting title, optional body text, a call-to-action prompt,
- * and optional informational cards driven by the `blocks` field.
+ * optional informational cards, and an optional inline consent prompt.
  *
  * @element gaia-welcome-message
  */
 export declare class GaiaWelcomeMessage extends BaseElement {
     static styles: import('lit').CSSResult[][];
     welcomeMessage?: WelcomeMessage;
+    /** Whether to show the inline sharing consent prompt below block cards. */
+    showSharingPrompt: boolean;
+    private handleYes;
+    private handleNo;
     render(): import('lit-html').TemplateResult<1>;
+    private renderSharingPrompt;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/dist/components/feedback/feedback-confirmation.d.ts

@@ -11,10 +11,13 @@ import { BaseElement } from '../shared/base-element';
 export declare class GaiaFeedbackConfirmation extends BaseElement {
     static styles: import('lit').CSSResult[];
     private ctrl;
+    private copyTimeoutId;
     private copied;
+    disconnectedCallback(): void;
     private get visitorUserId();
     private get shouldShowPrivacyId();
     private handleClose;
+    private clearCopyTimeout;
     private handleCopyPrivacyId;
     render(): import('lit-html').TemplateResult<1>;
 }

package/dist/components/feedback/feedback.d.ts

@@ -29,6 +29,7 @@ export declare class GaiaFeedback extends BaseElement {
     private handleCommentChange;
     private handleSubmit;
     private handleConsentConfirmed;
+    private submitAndClose;
     protected firstUpdated(_changedProperties: PropertyValues): void;
     private handleKeyDown;
     private handleClose;

package/dist/components/history/history-item.d.ts

@@ -0,0 +1,40 @@
+import { ConversationSummary } from '../../core/types';
+import { BaseElement } from '../shared/base-element';
+/**
+ * A single row in {@link GaiaHistoryView}. Shows the title, a context label
+ * when available (customer / company / partner), a relative timestamp, and
+ * row-level rename / delete actions.
+ *
+ * Stays stateless w.r.t. the store — actions bubble up as CustomEvents and
+ * are handled by the parent `<gaia-history-view>` which forwards them to
+ * `HistoryCoordinator`. Rename uses a minimal inline edit mode to keep the
+ * MVP scope small (no modal component dependency).
+ *
+ * @element gaia-history-item
+ *
+ * @fires history-item-select - When the row is activated. Detail: `{ summary }`.
+ * @fires history-item-rename - After the user confirms a new title. Detail: `{ id, title }`.
+ * @fires history-item-delete - After the user confirms deletion. Detail: `{ id }`.
+ */
+export declare class GaiaHistoryItem extends BaseElement {
+    static styles: import('lit').CSSResult[];
+    summary: ConversationSummary;
+    active: boolean;
+    private editing;
+    private draftTitle;
+    private handleSelect;
+    private handleKeyDown;
+    private startRename;
+    private cancelRename;
+    private confirmRename;
+    private handleEditKey;
+    private handleInput;
+    private handleDelete;
+    private getContextLabel;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'gaia-history-item': GaiaHistoryItem;
+    }
+}

package/dist/components/history/history-view.d.ts

@@ -0,0 +1,41 @@
+import { PropertyValues } from 'lit';
+import { BaseElement } from '../shared/base-element';
+/**
+ * Full-area conversation history panel. Replaces the chat area inside
+ * `<gaia-chat>` when `historyOpen` is true.
+ *
+ * Renders a profile-scoped list of previous conversations. Row actions (rename,
+ * delete) are delegated to `<gaia-history-item>`. Clicking a row restores the
+ * conversation into the active chat and fires a `conversation-restored` event
+ * via {@link ChatStore.restoreConversationById}.
+ *
+ * @element gaia-history-view
+ */
+export declare class GaiaHistoryView extends BaseElement {
+    static styles: import('lit').CSSResult[];
+    private ctrl;
+    private sentinelObserver?;
+    private observedSentinel?;
+    private handleClose;
+    private handleRetry;
+    private handleSelect;
+    private handleRename;
+    private handleDelete;
+    disconnectedCallback(): void;
+    protected updated(_changed: PropertyValues): void;
+    /**
+     * Attach or tear down the IntersectionObserver that watches the bottom-of-list
+     * sentinel. The sentinel is only rendered while more pages are available, so
+     * this runs on every update and follows the DOM: observe when the sentinel is
+     * present, detach when it isn't. The observer's root is the scrollable list
+     * container, not the viewport, so nested scroll regions (embedded widget) fire
+     * correctly.
+     */
+    private syncSentinelObserver;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'gaia-history-view': GaiaHistoryView;
+    }
+}

package/dist/components/layout/app-header/app-header.d.ts

@@ -1,11 +1,7 @@
 import { PropertyValues } from 'lit';
 import { BaseElement } from '../../shared/base-element';
 /**
- * Application header bar with feedback, new-chat, and close actions.
- *
- * Renders a toolbar with icon buttons for opening the feedback form,
- * clearing the conversation, and closing the chat widget. Actions are
- * disabled while the chat is initializing or a run is in progress.
+ * Application header bar with data settings, feedback, new-chat, and close actions.
  *
  * @element gaia-app-header
  *
@@ -17,15 +13,19 @@ export declare class GaiaAppHeader extends BaseElement {
     private ctrl;
     private toolbar;
     closeable: boolean;
+    enableHistory: boolean;
     connectedCallback(): void;
     disconnectedCallback(): void;
     protected updated(changed: PropertyValues): void;
     private getToolbarButtons;
     private handleFeedbackClosed;
     private handleClearConversation;
+    private handleToggleHistory;
     private handleToggleFeedback;
     private handleCloseChat;
+    private toggleDataSettings;
     render(): import('lit-html').TemplateResult<1>;
+    private renderDataSettingsButton;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/dist/components/message/assistant-message.d.ts

@@ -1,19 +1,16 @@
 import { nothing } from 'lit';
-import { UiAssistantMessage } from '../../core/adapters';
-import { SearchCitation } from '../../core/adapters/tool-utils';
+import { UiAssistantMessage } from '../../core/adapters/message-types';
 import { BaseElement } from '../shared/base-element';
 export declare class GaiaAssistantMessage extends BaseElement {
     static styles: import('lit').CSSResult[][];
     message: UiAssistantMessage;
-    citations: SearchCitation[];
     isStreaming: boolean;
     private bodyEl;
-    /** Cached result of extractSuggestedQuestions for the current content. */
-    private cachedExtraction;
-    private getExtractedContent;
+    private expandedToolCallIds;
     render(): import('lit-html').TemplateResult<1> | typeof nothing;
-    private renderToolCalls;
+    private renderPart;
     private renderToolCall;
+    private toggleToolCall;
     private handleInlineQuestionClick;
 }
 declare global {

package/dist/components/message/message-actions.d.ts

@@ -27,6 +27,10 @@ export declare class GaiaMessageActions extends BaseElement {
     copyContent: string;
     /** Whether this message belongs to the currently active run. Hides actions while active. */
     inActiveRun: boolean;
+    /** Readonly mode: shows static feedback indicator instead of interactive buttons. */
+    readonly: boolean;
+    /** Persisted feedback state from API. Used in readonly mode to display the thumb icon. */
+    thumb: 'up' | 'down' | null;
     /** Callback for submitting message thumbs. Set by parent message component. */
     onThumb?: (messageId: string, isPositive: boolean | null) => Promise<boolean>;
     private isCopied;
@@ -37,6 +41,7 @@ export declare class GaiaMessageActions extends BaseElement {
     render(): import('lit-html').TemplateResult<1> | typeof nothing;
     private renderCopyButton;
     private renderFeedbackButtons;
+    private renderFeedbackIndicator;
     private handleCopyClick;
     private handleFeedbackClick;
 }

package/dist/components/message/message-attachments.d.ts

@@ -0,0 +1,36 @@
+import { nothing } from 'lit';
+import { MessageAttachment } from '../../types';
+import { BaseElement } from '../shared/base-element';
+export declare class GaiaMessageAttachments extends BaseElement {
+    static styles: import('lit').CSSResult[];
+    attachments: MessageAttachment[];
+    onRemoveAttachment?: (attachment: MessageAttachment) => void;
+    fullWidth: boolean;
+    compact: boolean;
+    render(): import('lit-html').TemplateResult<1> | typeof nothing;
+    private renderCompactAttachment;
+    private renderAttachment;
+    private renderRemoveButton;
+    private handleRemoveClick;
+    private isImageAttachment;
+    private isPdfAttachment;
+    /**
+     * Splits a file name so the tail (extension and a few trailing characters)
+     * stays pinned while the start truncates with an ellipsis, yielding a
+     * middle-truncated name such as `Screens…nal.pdf`.
+     */
+    private splitFileName;
+    /** Formats a byte count into a compact, locale-aware size (e.g. `1.2 MB`). */
+    private formatFileSize;
+    /**
+     * Formats a magnitude and byte unit using the active locale, falling back to
+     * a plain `value unit` string if the runtime lacks `Intl.NumberFormat` unit
+     * support.
+     */
+    private formatSizeNumber;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'gaia-message-attachments': GaiaMessageAttachments;
+    }
+}