@aceshooting/lyra-ui 4.2.0 → 5.0.0

package/dist/components/agent-tools/thinking-panel/thinking-panel.class.js

@@ -0,0 +1,278 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { html, nothing } from 'lit';
+import { property } from 'lit/decorators.js';
+import { LyraElement } from '../../../internal/lyra-element.js';
+import { nextId } from '../../../internal/a11y.js';
+import { chevronIcon } from '../../../internal/icons.js';
+import { finiteRange } from '../../../internal/numbers.js';
+import { styles } from './thinking-panel.styles.js';
+/** "Close enough to the body's own max scroll position to count as anchored
+ *  there" -- comfortably larger than one line of streamed text, so a user
+ *  who has barely nudged the scrollbar while reading the latest line isn't
+ *  mistaken for having deliberately scrolled away to read earlier content. */
+const NEAR_BOTTOM_PX = 48;
+/** `820` -> `"820ms"`; `1500` -> `"1.5s"`; `2000` -> `"2s"`. Identical
+ *  algorithm to lr-tool-call-chip's and lr-tool-result-dialog's own
+ *  `formatDuration` -- duplicated rather than imported (three independent,
+ *  separately-consumable components) but kept in lockstep so the same
+ *  elapsed time reads identically everywhere it's shown in this library. */
+function formatDuration(ms) {
+    if (!Number.isFinite(ms) || ms < 1000) {
+        return `${Math.round(Math.max(0, ms))}ms`;
+    }
+    const seconds = ms / 1000;
+    const rounded = Math.round(seconds * 10) / 10;
+    return `${Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1)}s`;
+}
+/**
+ * `<lr-thinking-panel>` — a collapsible panel for an AI agent's
+ * intermediate reasoning/"thinking" transcript, kept visually and
+ * semantically distinct from its final response. Same collapsible
+ * header-button-plus-region shape as `<lr-source-list>`; the default slot
+ * is entirely free-form (a consumer-composed `<lr-streaming-text>`,
+ * `<lr-markdown>`, or plain text) — this component has no dependency on
+ * either and imposes no structure on what's slotted.
+ *
+ * `mode` (`'live'` while reasoning is actively streaming in, `'post-hoc'`
+ * once it's complete and being reviewed after the fact) drives two concrete
+ * behavior differences, not just a styling hook:
+ * - **Header hint.** While `duration-ms` is unset, `'live'` shows a pulsing
+ *   "Thinking…" placeholder in `[part="duration"]`; `'post-hoc'` shows
+ *   nothing there instead (a finished review with no known duration has
+ *   nothing useful to say in that slot). Once `duration-ms` is set, both
+ *   modes show the same static `"Thought for …"` text — a `'post-hoc'`
+ *   consumer that captured a duration is free to supply it too.
+ * - **Auto-scroll.** Only `'live'` mode auto-follows new content appended to
+ *   the default slot while `expanded` (see below); `'post-hoc'` never
+ *   scrolls on its own, since reviewing finished reasoning is expected to
+ *   start from the top like reading any other completed document. This
+ *   library otherwise defaults to *not* editorializing about a host's data
+ *   (see `<lr-empty>`'s plain-`description` stance), but scroll position
+ *   is presentation, not data, so this one behavior difference earns its
+ *   keep rather than being left as a bare visual/semantic hint the host
+ *   would have to reimplement identically itself.
+ *
+ * Live-mode auto-scroll ("stick to bottom") is the classic chat-transcript
+ * convention: while `mode="live"` and `expanded`, new content keeps the
+ * panel scrolled to its latest line — *unless* the user has manually
+ * scrolled up to (re-)read earlier content, in which case their position is
+ * never yanked away from them. This is tracked continuously via a `scroll`
+ * listener on `[part="body"]` (not recomputed from the mutation itself,
+ * which necessarily observes the DOM only *after* it has already changed):
+ * every user-driven scroll records whether the body was left within
+ * `NEAR_BOTTOM_PX` of its own max scroll position, and only a mutation that
+ * arrives while that's still true triggers a follow-up scroll-to-bottom.
+ * Opening an already-`'live'` panel (or one that later becomes `'live'`)
+ * always resets this to "anchored" and jumps to the latest content, the same
+ * way a chat app's own transcript does when you re-open it.
+ *
+ * New content is detected via a `MutationObserver` on this element's own
+ * light DOM (`childList`+`subtree`+`characterData`) rather than the default
+ * slot's `slotchange` event, because `slotchange` only fires when the set of
+ * top-level assigned nodes changes — never for a text node mutating *inside*
+ * an already-slotted element, which is the more likely shape for streamed
+ * reasoning (a consumer appending chunks to an existing node's `textContent`
+ * rather than re-slotting a whole new element per token). The one thing this
+ * can't see is a mutation entirely inside a slotted custom element's own
+ * shadow root (e.g. a `<lr-markdown>` re-rendering its shadow tree after a
+ * `content` property change) — Shadow DOM encapsulation blocks that by
+ * design, and there is no way for this component to reach across that
+ * boundary. A slotted element whose *own* internal updates should drive this
+ * panel's auto-scroll needs to append/mutate visible light-DOM text itself
+ * (as `<lr-streaming-text>` is expected to), or the host can call this
+ * panel's own `scrollToBottom()` directly.
+ *
+ * `aria-controls` linking the header to the body region uses `nextId()`
+ * (`../../internal/a11y.js`) for a collision-safe id, the same convention
+ * `<lr-source-list>` and `<lr-widget>` already establish for every
+ * toggle-controls-region pairing in this library.
+ *
+ * @customElement lr-thinking-panel
+ * @slot - The reasoning/thinking content.
+ * @event lr-toggle - The header was activated, expanding or collapsing the
+ * panel. `detail: { expanded }` — same event name and shape as
+ * `<lr-source-list>`'s own `lr-toggle`.
+ * @csspart base - The outer container.
+ * @csspart header - The clickable header (`<button>`) toggling `expanded`.
+ * @csspart label - The `label` text.
+ * @csspart duration - The formatted duration / "Thinking…" placeholder, when shown.
+ * @csspart toggle - The chevron indicator inside the header.
+ * @csspart body - The wrapper around the default slot, `hidden` while
+ * collapsed. Independently keyboard-focusable (`tabindex="0"`, `role="group"`
+ * named from `label`) since it's its own capped-height scrollable region.
+ */
+export class LyraThinkingPanel extends LyraElement {
+    constructor() {
+        super(...arguments);
+        /** Header text. Localized (`thinkingPanelLabel`) when left at its default
+         *  `'Thinking'`; any other value is shown as-is. */
+        this.label = 'Thinking';
+        /** Whether the reasoning transcript is currently shown. Starts collapsed,
+         *  matching `<lr-source-list>`'s default -- a consumer running `'live'`
+         *  reasoning sets this `true` itself to stream it in view as it arrives. */
+        this.expanded = false;
+        /** `'live'` while reasoning is actively streaming in right now; `'post-hoc'`
+         *  once it's complete and being reviewed after the fact. See the class doc
+         *  for the concrete behavior differences this drives. */
+        this.mode = 'live';
+        this.bodyId = nextId('thinking-panel-body');
+        // Whether the body was left within NEAR_BOTTOM_PX of its own max scroll
+        // position the last time a real (user-driven) scroll was recorded -- see
+        // onScroll(). Starts `true` so a panel that mounts already `expanded` and
+        // `mode="live"` follows its very first streamed content by default,
+        // before any scroll event has ever fired.
+        this.stickToBottom = true;
+        this.onScroll = (e) => {
+            const body = e.currentTarget;
+            this.stickToBottom = body.scrollHeight - body.scrollTop - body.clientHeight <= NEAR_BOTTOM_PX;
+        };
+        this.onContentMutated = () => {
+            if (this.mode !== 'live' || !this.expanded || !this.stickToBottom)
+                return;
+            // Coalesce to at most one scroll-to-bottom per animation frame -- a fast
+            // token stream can otherwise fire many mutation records in quick
+            // succession, each individually cheap to react to but wasteful (and
+            // visually janky) to lay out for separately.
+            if (this.scrollRafId !== undefined)
+                return;
+            this.scrollRafId = requestAnimationFrame(() => {
+                this.scrollRafId = undefined;
+                // Re-check the same guard here, not just in the caller: mode/expanded/
+                // stickToBottom can all change in the ~1-frame window between this
+                // mutation being observed and this callback actually firing (e.g. the
+                // reader scrolling away mid-frame), and this is the only place that
+                // reflects state as of the moment the scroll would actually happen.
+                if (this.mode === 'live' && this.expanded && this.stickToBottom)
+                    this.scrollToBottom();
+            });
+        };
+        this.toggle = () => {
+            this.expanded = !this.expanded;
+            this.emit('lr-toggle', { expanded: this.expanded });
+        };
+    }
+    static { this.styles = [LyraElement.styles, styles]; }
+    connectedCallback() {
+        super.connectedCallback();
+        // Watches this element's own light-DOM subtree, not the shadow-DOM
+        // [part="body"] wrapper -- the slotted reasoning content actually lives
+        // here, as this element's children. See the class doc for why this
+        // (rather than `slotchange`) is what detects streamed-in content.
+        this.contentObserver = new MutationObserver(this.onContentMutated);
+        this.contentObserver.observe(this, { childList: true, subtree: true, characterData: true });
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.contentObserver?.disconnect();
+        this.contentObserver = undefined;
+        if (this.scrollRafId !== undefined) {
+            cancelAnimationFrame(this.scrollRafId);
+            this.scrollRafId = undefined;
+        }
+    }
+    updated(changed) {
+        if ((changed.has('expanded') || changed.has('mode')) && this.expanded && this.mode === 'live') {
+            // Opening a live panel -- or a still-expanded panel later becoming
+            // `'live'` -- always jumps straight to the newest content and resets
+            // the sticky-bottom flag, so it starts following again regardless of
+            // wherever the body happened to be scrolled beforehand. `'post-hoc'`
+            // deliberately skips this -- see the class doc's Auto-scroll section.
+            this.stickToBottom = true;
+            this.scrollToBottom();
+        }
+    }
+    /** Scrolls the body to its current bottom immediately (no smooth-scroll
+     *  animation, deliberately -- see onContentMutated()'s rAF-coalescing
+     *  comment for why an instant jump reads better than a stack of competing
+     *  smooth scrolls under a fast token stream). Safe to call directly, e.g.
+     *  from a host that wants to force a jump-to-latest action of its own. */
+    scrollToBottom() {
+        const body = this.renderRoot.querySelector('[part="body"]');
+        if (!body)
+            return;
+        body.scrollTop = body.scrollHeight;
+    }
+    /** `durationMs` normalized to a finite, non-negative value, or `null` -- `null`/`undefined`
+     *  and a non-finite raw value (e.g. a stray `NaN` assignment) both mean "no duration known yet,"
+     *  matching this property's own "omitted entirely while unset" contract, rather than rendering
+     *  a literal "NaN ms". A finite negative value clamps to `0` instead of rendering a nonsensical
+     *  negative duration. */
+    get safeDurationMs() {
+        return this.durationMs != null && Number.isFinite(this.durationMs) ? finiteRange(this.durationMs, 0, 0) : null;
+    }
+    get durationDisplay() {
+        const durationMs = this.safeDurationMs;
+        if (durationMs != null) {
+            return {
+                text: this.localize('thoughtFor', undefined, { duration: formatDuration(durationMs) }),
+                pending: false,
+            };
+        }
+        return this.mode === 'live' ? { text: this.localize('thinking'), pending: true } : null;
+    }
+    // `[part="body"]` is `tabindex="0"` because it's a capped-height,
+    // independently-scrollable region -- with no other focusable content of
+    // its own (e.g. plain text, or a non-interactive `<lr-streaming-text>`),
+    // it would otherwise be unreachable by keyboard, same reasoning
+    // code-block.ts's and virtual-list.ts's own identical `[part="body"]`/
+    // `[part="base"]` tabindex document. `role="group"` (rather than a page
+    // landmark role) plus `aria-label` gives it an accessible name without
+    // claiming navigation significance for what is, structurally, just one
+    // part of a larger message.
+    render() {
+        const duration = this.durationDisplay;
+        // `this.localize()` checks `.strings` overrides before any fallback, so
+        // passing `this.label` as a fallback wouldn't stop a `.strings.thinkingPanelLabel`
+        // override from winning over an explicitly-customized `label` -- bypass
+        // localize() entirely once `label` has been changed from its built-in default.
+        const label = this.label === 'Thinking' ? this.localize('thinkingPanelLabel') : this.label;
+        return html `
+      <div part="base">
+        <button
+          part="header"
+          type="button"
+          aria-expanded=${this.expanded ? 'true' : 'false'}
+          aria-controls=${this.bodyId}
+          @click=${this.toggle}
+        >
+          <span part="toggle" aria-hidden="true">${chevronIcon()}</span>
+          <span part="label">${label}</span>
+          ${duration
+            ? html `<span part="duration" ?data-pending=${duration.pending}
+                >${duration.pending ? html `<span class="pending-dot" aria-hidden="true"></span>` : nothing}${duration.text}</span
+              >`
+            : nothing}
+        </button>
+        <div
+          part="body"
+          id=${this.bodyId}
+          role="group"
+          aria-label=${label}
+          tabindex="0"
+          ?hidden=${!this.expanded}
+          @scroll=${this.onScroll}
+        >
+          <slot></slot>
+        </div>
+      </div>
+    `;
+    }
+}
+__decorate([
+    property()
+], LyraThinkingPanel.prototype, "label", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], LyraThinkingPanel.prototype, "expanded", void 0);
+__decorate([
+    property({ reflect: true })
+], LyraThinkingPanel.prototype, "mode", void 0);
+__decorate([
+    property({ type: Number, attribute: 'duration-ms' })
+], LyraThinkingPanel.prototype, "durationMs", void 0);
+//# sourceMappingURL=thinking-panel.class.js.map

package/dist/components/agent-tools/thinking-panel/thinking-panel.class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-panel.class.js","sourceRoot":"","sources":["../../../../src/components/agent-tools/thinking-panel/thinking-panel.class.ts"],"names":[],"mappings":"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"}

package/dist/components/agent-tools/thinking-panel/thinking-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-panel.d.ts","sourceRoot":"","sources":["../../../../src/components/agent-tools/thinking-panel/thinking-panel.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dist/components/agent-tools/thinking-panel/thinking-panel.js

@@ -0,0 +1,5 @@
+export * from './thinking-panel.class.js';
+import { LyraThinkingPanel } from './thinking-panel.class.js';
+import { defineElement } from '../../../internal/prefix.js';
+defineElement('thinking-panel', LyraThinkingPanel);
+//# sourceMappingURL=thinking-panel.js.map

package/dist/components/agent-tools/thinking-panel/thinking-panel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-panel.js","sourceRoot":"","sources":["../../../../src/components/agent-tools/thinking-panel/thinking-panel.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,aAAa,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC"}

package/dist/components/agent-tools/thinking-panel/thinking-panel.styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-panel.styles.d.ts","sourceRoot":"","sources":["../../../../src/components/agent-tools/thinking-panel/thinking-panel.styles.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,MAAM,yBA+HlB,CAAC"}

package/dist/components/agent-tools/thinking-panel/thinking-panel.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-panel.styles.js","sourceRoot":"","sources":["../../../../src/components/agent-tools/thinking-panel/thinking-panel.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,2EAA2E;AAC3E,4EAA4E;AAC5E,uEAAuE;AACvE,2EAA2E;AAC3E,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+HxB,CAAC"}

package/dist/components/agent-tools/tool-approval-dialog/tool-approval-dialog.class.d.ts

@@ -0,0 +1,156 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../../internal/lyra-element.js';
+import '../../utility/json-viewer/json-viewer.class.js';
+export type ToolApprovalDialogWrap = 'hard' | 'soft' | 'off';
+/**
+ * Reason the dialog was dismissed, forwarded as the `lr-close` event detail
+ * -- mirrors `<lr-dialog>`'s own `DialogCloseReason` shape. `'escape'`/
+ * `'backdrop'` come from the dialog's own built-in dismiss triggers,
+ * `'approve'`/`'deny'` from the built-in action buttons (fired in addition
+ * to, and immediately after, their own dedicated `lr-approve`/`lr-deny`
+ * event -- see the class doc), and any other string is whatever a caller
+ * passes to `close()` directly.
+ */
+export type ToolApprovalDialogCloseReason = 'escape' | 'backdrop' | 'approve' | 'deny' | 'api' | (string & Record<never, never>);
+export interface LyraToolApprovalDialogEventMap {
+    'lr-approve': CustomEvent<{
+        args: unknown;
+    }>;
+    'lr-deny': CustomEvent<undefined>;
+    'lr-close': CustomEvent<ToolApprovalDialogCloseReason>;
+    blur: CustomEvent<undefined>;
+    focus: CustomEvent<undefined>;
+}
+/**
+ * `<lr-tool-approval-dialog>` — a human-in-the-loop gate: presents one
+ * proposed tool/function call (`toolName` + `args`) and blocks an agent from
+ * executing it until a person explicitly approves or denies it, with an
+ * optional inline "edit the arguments before approving" step.
+ *
+ * This renders its own dialog panel rather than nesting a `<lr-dialog>` in
+ * its shadow template. Shared overlay infrastructure coordinates stacking,
+ * focus trapping, Escape/backdrop dismissal, and focus return with every
+ * other overlay in the same document.
+ *
+ * Approve/Deny/Edit are built-in chrome (not a `footer` slot a consumer must
+ * assemble) — this component's interaction shape is fixed enough (there is
+ * exactly one correct set of actions for "approve this call") that requiring
+ * every consumer to re-build it would just be boilerplate. A `footer` slot is
+ * still offered for *supplementary* content a consumer wants alongside those
+ * buttons (e.g. a "remember this choice for this tool" checkbox) — its
+ * content renders to the start of the action row, before Deny/Edit/Approve.
+ *
+ * Editing: while `editable`, an Edit button swaps the read-only
+ * `<lr-json-viewer>` for a plain `<textarea>` pre-filled with
+ * `JSON.stringify(args, null, 2)`. Every keystroke is re-validated with
+ * `JSON.parse` — the Approve button is `disabled` for as long as the current
+ * textarea content fails to parse, so a malformed edit can never be silently
+ * approved as either the broken text or a stale copy of the original args.
+ * The editor defaults to `spellcheck="false"`, `autocapitalize="off"`,
+ * `autocorrect="off"`, and `autocomplete="off"` because its content is raw
+ * JSON, never prose. The corresponding native editing properties remain
+ * configurable for integrations that need different browser behavior.
+ * The same button relabels to "Cancel" while editing; clicking it discards
+ * the draft entirely and returns to the read-only view of the *original*
+ * `args` — there is no separate "save" step independent of Approve itself.
+ * Both `editing` and any in-progress draft reset back to the read-only view
+ * every time the dialog transitions from closed to open, so a reused
+ * instance never leaks one proposal's half-finished edit into the next.
+ * `editable` flipping to `false` mid-edit does the same (see `willUpdate()`)
+ * and, if the textarea it unmounts still held focus, `updated()` refocuses
+ * Deny so the focus trap keeps engaging instead of silently letting focus
+ * fall through to the document.
+ *
+ * Initial focus deliberately does *not* land on Approve:
+ * approving a tool call is a consequential, potentially irreversible action,
+ * so a user who opens this dialog and reflexively presses Enter/Space before
+ * reading anything should deny, not approve. Deny gets the initial focus
+ * instead — the same "focus the safe action" convention a native destructive-
+ * confirmation dialog (delete, discard, etc.) typically follows for its own
+ * Cancel button — rather than the inert dialog panel, which would need an
+ * extra Tab press before *any* action is reachable at all.
+ *
+ * @customElement lr-tool-approval-dialog
+ * @slot footer - Optional supplementary content (e.g. a "remember this
+ * choice" checkbox), rendered before the built-in Deny/Edit/Approve buttons.
+ * @event lr-approve - The call was approved. `detail: { args }` — the
+ * current, already-parsed arguments object: the original `args` prop, or (if
+ * an edit was in progress) the user's edited-and-validated version. Always
+ * followed by `lr-close` with reason `'approve'`.
+ * @event lr-deny - The call was denied (no detail). Always followed by
+ * `lr-close` with reason `'deny'`.
+ * @event lr-close - `detail: ToolApprovalDialogCloseReason`. Fired exactly
+ * once per dismissal — via Escape, a backdrop click, the Approve/Deny
+ * buttons, or a `close()` call — so there is one consistent "this dialog is
+ * now closed" signal regardless of which path triggered it.
+ * @csspart backdrop - The full-viewport scrim behind the panel.
+ * @csspart panel - The dialog panel itself (`role="dialog"` while open).
+ * @csspart header - The wrapper around the heading.
+ * @csspart tool-name - The `toolName` text within the heading.
+ * @csspart body - The wrapper around the args view/editor.
+ * @csspart args-view - The read-only `<lr-json-viewer>` shown while not editing.
+ * @csspart args-editor - The raw-JSON `<textarea>` shown while editing.
+ * @csspart error - The inline "invalid JSON" message, shown only while editing with unparseable content.
+ * @csspart footer - The action row wrapping the `footer` slot and the built-in buttons.
+ * @csspart deny-button - The built-in Deny button.
+ * @csspart edit-button - The built-in Edit/Cancel toggle button (only rendered while `editable`).
+ * @csspart approve-button - The built-in Approve button — `disabled` while an in-progress edit is invalid JSON.
+ */
+export declare class LyraToolApprovalDialog extends LyraElement<LyraToolApprovalDialogEventMap> {
+    static styles: import("lit").CSSResultGroup[];
+    /** Whether the dialog is open. Set this (or call `close()`) — there is no separate `show()`/`hide()` pair. */
+    open: boolean;
+    /** The proposed tool/function's name, e.g. `web_search`. Drives the heading and the dialog's accessible name. */
+    toolName: string;
+    /** The proposed call's arguments — any JSON-serializable value, rendered via `<lr-json-viewer>` (or, while editing, stringified into the textarea). */
+    args: unknown;
+    /** Whether an "Edit" affordance is offered at all. When `false`, `args` is always shown read-only and can never be changed before approval. */
+    editable: boolean;
+    /** Native editing-assistance attributes forwarded to the raw-JSON textarea. */
+    spellcheck: boolean;
+    autocapitalize: string;
+    autoCorrect: string;
+    autocomplete: string;
+    wrap: ToolApprovalDialogWrap;
+    inputMode: string;
+    enterKeyHint: string;
+    private editing;
+    /** The textarea's current raw text while editing — deliberately independent of `args` until Approve is pressed, so a malformed in-progress edit never overwrites it. */
+    private draftText;
+    /** `JSON.parse` failure message for `draftText`, or `''` while it parses cleanly. Empty string (not `undefined`) so it can drive `?hidden` directly. */
+    private draftError;
+    private releaseScrollLock?;
+    private overlay?;
+    private readonly titleId;
+    private readonly errorId;
+    protected willUpdate(changed: PropertyValues): void;
+    protected updated(changed: PropertyValues): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private activateOverlay;
+    /**
+     * Close the dialog and return focus to whatever had it before the dialog
+     * opened. `reason` is forwarded as the `lr-close` detail — built-in
+     * triggers pass `'escape'`/`'backdrop'`/`'approve'`/`'deny'`; a consumer's
+     * own close affordance (e.g. a footer-slotted button) should call this
+     * directly with its own reason string, so every dismissal path funnels
+     * through the same event instead of the consumer having to also toggle
+     * `open` itself.
+     */
+    close(reason?: ToolApprovalDialogCloseReason): void;
+    private onBackdropClick;
+    private stringifyArgs;
+    private toggleEdit;
+    private onDraftInput;
+    private onEditorFocus;
+    private onEditorBlur;
+    private onApprove;
+    private onDeny;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lr-tool-approval-dialog': LyraToolApprovalDialog;
+    }
+}
+//# sourceMappingURL=tool-approval-dialog.class.d.ts.map

package/dist/components/agent-tools/tool-approval-dialog/tool-approval-dialog.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-approval-dialog.class.d.ts","sourceRoot":"","sources":["../../../../src/components/agent-tools/tool-approval-dialog/tool-approval-dialog.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAE9E,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAKhE,OAAO,gDAAgD,CAAC;AAWxD,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAE7D;;;;;;;;GAQG;AACH,MAAM,MAAM,6BAA6B,GACrC,QAAQ,GACR,UAAU,GACV,SAAS,GACT,MAAM,GACN,KAAK,GACL,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAEpC,MAAM,WAAW,8BAA8B;IAC7C,YAAY,EAAE,WAAW,CAAC;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC7C,SAAS,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAClC,UAAU,EAAE,WAAW,CAAC,6BAA6B,CAAC,CAAC;IACvD,IAAI,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAC7B,KAAK,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;CAC/B;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,qBAAa,sBAAuB,SAAQ,WAAW,CAAC,8BAA8B,CAAC;IACrF,MAAM,CAAC,MAAM,iCAAgC;IAE7C,8GAA8G;IAClE,IAAI,UAAS;IAEzD,iHAAiH;IAC3E,QAAQ,SAAM;IAEpD,uJAAuJ;IACvH,IAAI,EAAE,OAAO,CAAM;IAEnD,+IAA+I;IACnG,QAAQ,UAAQ;IAE5D,+EAA+E;IACjC,UAAU,UAAS;IACrD,cAAc,SAAS;IACK,WAAW,SAAS;IAChD,YAAY,SAAS;IACrB,IAAI,EAAE,sBAAsB,CAAU;IACZ,SAAS,SAAM;IACZ,YAAY,SAAM;IAElD,OAAO,CAAC,OAAO,CAAS;IACjC,wKAAwK;IAC/J,OAAO,CAAC,SAAS,CAAM;IAChC,wJAAwJ;IAC/I,OAAO,CAAC,UAAU,CAAM;IAEjC,OAAO,CAAC,iBAAiB,CAAC,CAAa;IACvC,OAAO,CAAC,OAAO,CAAC,CAAgB;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwC;IAChE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwC;IAEhE,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CA2BlD;IAKD,SAAS,CAAC,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAqB/C;IAED,iBAAiB,IAAI,IAAI,CAOxB;IAED,oBAAoB,IAAI,IAAI,CAK3B;IAED,OAAO,CAAC,eAAe;IAevB;;;;;;;;OAQG;IACH,KAAK,CAAC,MAAM,GAAE,6BAAqC,GAAG,IAAI,CAIzD;IAED,OAAO,CAAC,eAAe,CAErB;IAEF,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,UAAU,CAUhB;IAEF,OAAO,CAAC,YAAY,CASlB;IACF,OAAO,CAAC,aAAa,CAAuC;IAC5D,OAAO,CAAC,YAAY,CAAsC;IAE1D,OAAO,CAAC,SAAS,CAcf;IAEF,OAAO,CAAC,MAAM,CAGZ;IAEF,MAAM,IAAI,cAAc,CAyDvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,yBAAyB,EAAE,sBAAsB,CAAC;KACnD;CACF"}