glirastes 0.4.0 → 0.5.1

package/dist/cjs/react/hooks/use-floating-panel.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFloatingPanel = useFloatingPanel;
+const react_1 = require("react");
+const INTERACTIVE = 'button,a,input,select,textarea,[contenteditable="true"],[role="combobox"],[role="separator"],[data-no-drag]';
+function viewport() {
+    return { width: window.innerWidth, height: window.innerHeight };
+}
+/** Size within the limits and the viewport, then position within the viewport. */
+function fit(rect, limits) {
+    const view = viewport();
+    const roomX = Math.max(0, view.width - limits.margin * 2);
+    const roomY = Math.max(0, view.height - limits.margin * 2);
+    const width = Math.round(Math.min(Math.max(rect.width, limits.minWidth), limits.maxWidth, roomX));
+    const height = Math.round(Math.min(Math.max(rect.height, limits.minHeight), limits.maxHeight, roomY));
+    const x = Math.round(Math.min(Math.max(rect.x, limits.margin), Math.max(limits.margin, view.width - limits.margin - width)));
+    const y = Math.round(Math.min(Math.max(rect.y, limits.margin), Math.max(limits.margin, view.height - limits.margin - height)));
+    return { x, y, width, height };
+}
+/** The rect after dragging `edge` by the given distance; the opposite edge stays put. */
+function resized(start, edge, dx, dy, limits) {
+    const view = viewport();
+    let left = start.x;
+    let top = start.y;
+    let right = start.x + start.width;
+    let bottom = start.y + start.height;
+    const clampWidth = (width) => Math.min(Math.max(width, limits.minWidth), limits.maxWidth);
+    const clampHeight = (height) => Math.min(Math.max(height, limits.minHeight), limits.maxHeight);
+    if (edge.includes('e'))
+        right = Math.min(left + clampWidth(start.width + dx), view.width - limits.margin);
+    if (edge.includes('w'))
+        left = Math.max(right - clampWidth(start.width - dx), limits.margin);
+    if (edge.includes('s'))
+        bottom = Math.min(top + clampHeight(start.height + dy), view.height - limits.margin);
+    if (edge.includes('n'))
+        top = Math.max(bottom - clampHeight(start.height - dy), limits.margin);
+    return { x: Math.round(left), y: Math.round(top), width: Math.round(right - left), height: Math.round(bottom - top) };
+}
+function readStored(key) {
+    if (!key)
+        return null;
+    try {
+        const value = JSON.parse(localStorage.getItem(key) ?? 'null');
+        if (!value)
+            return null;
+        const { x, y, width, height } = value;
+        return [x, y, width, height].every((n) => typeof n === 'number' && Number.isFinite(n))
+            ? { x: x, y: y, width: width, height: height }
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Position and size of a floating panel: moved by a handle, resized from any
+ * edge or corner, by pointer (mouse, touch, pen) or keyboard.
+ *
+ * A gesture writes straight to the element once per frame and commits to
+ * React state when it ends, so the panel's content does not render while it
+ * follows the pointer. The panel stays inside the viewport, also when the
+ * window shrinks.
+ */
+function useFloatingPanel(options) {
+    const { enabled = true, minWidth = 0, minHeight = 0, maxWidth = Number.POSITIVE_INFINITY, maxHeight = Number.POSITIVE_INFINITY, margin = 8, storageKey, keyboardStep = 16, } = options;
+    const ref = (0, react_1.useRef)(null);
+    const [rect, setRect] = (0, react_1.useState)(null);
+    const rectRef = (0, react_1.useRef)(null);
+    const endGesture = (0, react_1.useRef)(null);
+    const limits = (0, react_1.useMemo)(() => ({ minWidth, minHeight, maxWidth, maxHeight, margin }), [minWidth, minHeight, maxWidth, maxHeight, margin]);
+    const defaultRectRef = (0, react_1.useRef)(options.defaultRect);
+    defaultRectRef.current = options.defaultRect;
+    const resolveDefault = (0, react_1.useCallback)(() => {
+        const value = defaultRectRef.current;
+        return typeof value === 'function' ? value() : value;
+    }, []);
+    const commit = (0, react_1.useCallback)((next) => {
+        const fitted = fit(next, limits);
+        rectRef.current = fitted;
+        setRect(fitted);
+        if (storageKey) {
+            try {
+                localStorage.setItem(storageKey, JSON.stringify(fitted));
+            }
+            catch { /* storage unavailable */ }
+        }
+    }, [limits, storageKey]);
+    // Storage and viewport are read after mount, never during the first render.
+    (0, react_1.useEffect)(() => {
+        if (!enabled) {
+            endGesture.current?.();
+            rectRef.current = null;
+            setRect(null);
+            return;
+        }
+        const initial = fit(readStored(storageKey) ?? resolveDefault(), limits);
+        rectRef.current = initial;
+        setRect(initial);
+        const refit = () => {
+            if (rectRef.current && !endGesture.current)
+                commit(rectRef.current);
+        };
+        window.addEventListener('resize', refit);
+        return () => window.removeEventListener('resize', refit);
+    }, [enabled, storageKey, limits, resolveDefault, commit]);
+    (0, react_1.useEffect)(() => () => endGesture.current?.(), []);
+    const startGesture = (0, react_1.useCallback)((event, edge) => {
+        const element = ref.current;
+        const start = rectRef.current;
+        if (!enabled || !element || !start || event.button !== 0)
+            return;
+        if (!edge && event.target.closest(INTERACTIVE))
+            return;
+        event.preventDefault();
+        endGesture.current?.();
+        const handle = event.currentTarget;
+        const { pointerId, clientX: startX, clientY: startY } = event;
+        let next = start;
+        let frame = 0;
+        const body = document.body;
+        const previousSelect = body.style.userSelect;
+        const previousCursor = body.style.cursor;
+        body.style.userSelect = 'none';
+        if (!edge)
+            body.style.cursor = 'grabbing';
+        element.dataset.floatingGesture = edge ? 'resize' : 'move';
+        try {
+            handle.setPointerCapture?.(pointerId);
+        }
+        catch { /* pointer already gone */ }
+        const paint = () => {
+            frame = 0;
+            if (edge) {
+                element.style.left = `${next.x}px`;
+                element.style.top = `${next.y}px`;
+                element.style.width = `${next.width}px`;
+                element.style.height = `${next.height}px`;
+            }
+            else {
+                element.style.transform = `translate3d(${next.x - start.x}px, ${next.y - start.y}px, 0)`;
+            }
+        };
+        const move = (e) => {
+            if (e.pointerId !== undefined && e.pointerId !== pointerId)
+                return;
+            const dx = e.clientX - startX;
+            const dy = e.clientY - startY;
+            next = edge
+                ? resized(start, edge, dx, dy, limits)
+                : fit({ ...start, x: start.x + dx, y: start.y + dy }, limits);
+            if (!frame)
+                frame = requestAnimationFrame(paint);
+        };
+        const finish = () => {
+            if (frame)
+                cancelAnimationFrame(frame);
+            handle.removeEventListener('pointermove', move);
+            handle.removeEventListener('pointerup', finish);
+            handle.removeEventListener('pointercancel', finish);
+            handle.removeEventListener('lostpointercapture', finish);
+            window.removeEventListener('blur', finish);
+            try {
+                handle.releasePointerCapture?.(pointerId);
+            }
+            catch { /* not captured */ }
+            body.style.userSelect = previousSelect;
+            body.style.cursor = previousCursor;
+            delete element.dataset.floatingGesture;
+            endGesture.current = null;
+            // Land on the final rect in the same frame the transform goes away.
+            element.style.transform = '';
+            element.style.left = `${next.x}px`;
+            element.style.top = `${next.y}px`;
+            commit(next);
+        };
+        endGesture.current = finish;
+        handle.addEventListener('pointermove', move);
+        handle.addEventListener('pointerup', finish);
+        handle.addEventListener('pointercancel', finish);
+        handle.addEventListener('lostpointercapture', finish);
+        window.addEventListener('blur', finish);
+    }, [enabled, limits, commit]);
+    const reset = (0, react_1.useCallback)(() => {
+        if (enabled)
+            commit(resolveDefault());
+    }, [enabled, commit, resolveDefault]);
+    const dragHandleProps = (0, react_1.useMemo)(() => ({
+        onPointerDown: (event) => startGesture(event, null),
+        onKeyDown: (event) => {
+            const current = rectRef.current;
+            if (!enabled || !current || event.target !== event.currentTarget)
+                return;
+            const direction = { ArrowLeft: [-1, 0], ArrowRight: [1, 0], ArrowUp: [0, -1], ArrowDown: [0, 1] }[event.key];
+            if (!direction)
+                return;
+            event.preventDefault();
+            const step = keyboardStep * (event.shiftKey ? 4 : 1);
+            const [dx, dy] = [direction[0] * step, direction[1] * step];
+            commit(event.altKey
+                ? resized(current, 'se', dx, dy, limits)
+                : { ...current, x: current.x + dx, y: current.y + dy });
+        },
+        onDoubleClick: (event) => {
+            if (event.target instanceof HTMLElement && event.target.closest(INTERACTIVE))
+                return;
+            reset();
+        },
+    }), [enabled, keyboardStep, limits, commit, reset, startGesture]);
+    const getResizeHandleProps = (0, react_1.useCallback)((edge) => ({
+        onPointerDown: (event) => startGesture(event, edge),
+        'data-resize-edge': edge,
+    }), [startGesture]);
+    const style = (0, react_1.useMemo)(() => rect
+        ? { position: 'fixed', left: rect.x, top: rect.y, width: rect.width, height: rect.height }
+        : undefined, [rect]);
+    return { ref, rect, style, dragHandleProps, getResizeHandleProps, reset };
+}

package/dist/cjs/react/hooks/use-keyboard-shortcut.js

@@ -37,7 +37,8 @@ function matches(event, combo) {
         return false;
     if (combo.alt !== event.altKey)
         return false;
-    const key = event.key.toLowerCase();
+    // Synthetic keydowns, such as Chrome autofill's, can lack `key`.
+    const key = typeof event.key === 'string' ? event.key.toLowerCase() : '';
     if (combo.key === 'escape')
         return key === 'escape' || key === 'esc';
     return key === combo.key;

package/dist/cjs/react/hooks/use-push-to-talk-hotkey.d.ts

@@ -0,0 +1,24 @@
+/** Hold to talk; `mod` is ⌘ on macOS and Ctrl elsewhere. */
+export declare const DEFAULT_PUSH_TO_TALK_HOTKEY = "mod+shift+space";
+interface HoldCombo {
+    key: string;
+    mod: boolean;
+    shift: boolean;
+    alt: boolean;
+}
+export declare function parseHoldCombo(combo: string): HoldCombo | null;
+/**
+ * Calls `onPress` when the combo goes down and `onRelease` when any key of
+ * it is released, the window blurs or the hook unmounts. macOS does not
+ * deliver keyup for other keys while ⌘ is held, so releasing ⌘ also ends
+ * the hold. Fires inside text fields: the combo always has a modifier or is
+ * explicitly chosen by the app. A letter or digit matches the typed character,
+ * or the physical key when Option or a dead key composes another one.
+ */
+export declare function usePushToTalkHotkey(options: {
+    hotkey: string | false | undefined;
+    enabled: boolean;
+    onPress: () => void;
+    onRelease: () => void;
+}): void;
+export {};

package/dist/cjs/react/hooks/use-push-to-talk-hotkey.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PUSH_TO_TALK_HOTKEY = void 0;
+exports.parseHoldCombo = parseHoldCombo;
+exports.usePushToTalkHotkey = usePushToTalkHotkey;
+const react_1 = require("react");
+/** Hold to talk; `mod` is ⌘ on macOS and Ctrl elsewhere. */
+exports.DEFAULT_PUSH_TO_TALK_HOTKEY = 'mod+shift+space';
+function isMac() {
+    if (typeof navigator === 'undefined')
+        return false;
+    return /Mac|iPhone|iPad|iPod/.test(navigator.platform || navigator.userAgent || '');
+}
+function parseHoldCombo(combo) {
+    const parts = combo.toLowerCase().split('+').map((part) => part.trim()).filter(Boolean);
+    const result = { key: '', mod: false, shift: false, alt: false };
+    for (const part of parts) {
+        if (['mod', 'cmd', 'ctrl', 'meta', 'control'].includes(part))
+            result.mod = true;
+        else if (part === 'shift')
+            result.shift = true;
+        else if (['alt', 'option', 'opt'].includes(part))
+            result.alt = true;
+        else
+            result.key = part;
+    }
+    return result.key ? result : null;
+}
+const PLAIN_LETTER_OR_DIGIT = /^[a-z0-9]$/;
+const PHYSICAL_LETTER_OR_DIGIT = /^(?:Key([A-Z])|Digit([0-9]))$/;
+/** Lower-cased `event.key`; empty for key-less events, which autofill dispatches. */
+function keyName(event) {
+    if (event.key === ' ' || event.code === 'Space')
+        return 'space';
+    return typeof event.key === 'string' ? event.key.toLowerCase() : '';
+}
+/**
+ * Whether the event is the combo's main key. A typed letter or digit wins, so
+ * AZERTY and Dvorak users get the key they see. When the event carries some
+ * other character, the physical key decides: macOS Option composes 'µ' for
+ * Option+M, and dead keys and non-Latin layouts report no ASCII letter either.
+ */
+function isComboKey(event, key) {
+    const name = keyName(event);
+    if (name === key)
+        return true;
+    if (PLAIN_LETTER_OR_DIGIT.test(name) || typeof event.code !== 'string')
+        return false;
+    const physical = PHYSICAL_LETTER_OR_DIGIT.exec(event.code);
+    return physical !== null && (physical[1] ?? physical[2]).toLowerCase() === key;
+}
+/**
+ * Calls `onPress` when the combo goes down and `onRelease` when any key of
+ * it is released, the window blurs or the hook unmounts. macOS does not
+ * deliver keyup for other keys while ⌘ is held, so releasing ⌘ also ends
+ * the hold. Fires inside text fields: the combo always has a modifier or is
+ * explicitly chosen by the app. A letter or digit matches the typed character,
+ * or the physical key when Option or a dead key composes another one.
+ */
+function usePushToTalkHotkey(options) {
+    const pressRef = (0, react_1.useRef)(options.onPress);
+    pressRef.current = options.onPress;
+    const releaseRef = (0, react_1.useRef)(options.onRelease);
+    releaseRef.current = options.onRelease;
+    (0, react_1.useEffect)(() => {
+        if (!options.enabled || !options.hotkey)
+            return;
+        const combo = parseHoldCombo(options.hotkey);
+        if (!combo)
+            return;
+        let holding = false;
+        const matches = (event) => isComboKey(event, combo.key)
+            && (isMac() ? event.metaKey : event.ctrlKey) === combo.mod
+            && event.shiftKey === combo.shift
+            && event.altKey === combo.alt;
+        const end = () => {
+            if (!holding)
+                return;
+            holding = false;
+            releaseRef.current();
+        };
+        const down = (event) => {
+            if (holding) {
+                if (isComboKey(event, combo.key))
+                    event.preventDefault();
+                return;
+            }
+            if (event.repeat || !matches(event))
+                return;
+            event.preventDefault();
+            holding = true;
+            pressRef.current();
+        };
+        const up = (event) => {
+            if (!holding)
+                return;
+            const name = keyName(event);
+            if (isComboKey(event, combo.key)
+                || (combo.mod && (name === 'meta' || name === 'control'))
+                || (combo.shift && name === 'shift')
+                || (combo.alt && name === 'alt')) {
+                event.preventDefault();
+                end();
+            }
+        };
+        window.addEventListener('keydown', down);
+        window.addEventListener('keyup', up);
+        window.addEventListener('blur', end);
+        return () => {
+            window.removeEventListener('keydown', down);
+            window.removeEventListener('keyup', up);
+            window.removeEventListener('blur', end);
+            end();
+        };
+    }, [options.enabled, options.hotkey]);
+}

package/dist/cjs/react/hooks/use-sidebar-resize.d.ts

@@ -0,0 +1,19 @@
+import { type KeyboardEvent, type PointerEvent } from 'react';
+interface SidebarResizeOptions {
+    active: boolean;
+    width: number;
+    minWidth: number;
+    maxWidth: number;
+    storageKey?: string;
+    onWidthChange?: (width: number) => void;
+}
+/** Independent right-sidebar geometry; never mutates floating position/size. */
+export declare function useSidebarResize({ active, width: initialWidth, minWidth, maxWidth, storageKey, onWidthChange }: SidebarResizeOptions): {
+    width: number;
+    minimum: number;
+    maximum: number;
+    onPointerDown: (event: PointerEvent<HTMLElement>) => void;
+    onKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
+    onDoubleClick: () => void;
+};
+export {};

package/dist/cjs/react/hooks/use-sidebar-resize.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSidebarResize = useSidebarResize;
+const react_1 = require("react");
+function restoreWidth(key, fallback) {
+    try {
+        const stored = key && typeof window !== 'undefined' ? window.sessionStorage.getItem(key) : null;
+        const value = stored === null ? fallback : Number(stored);
+        return Number.isFinite(value) ? value : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+/** Independent right-sidebar geometry; never mutates floating position/size. */
+function useSidebarResize({ active, width: initialWidth, minWidth, maxWidth, storageKey, onWidthChange }) {
+    const minimum = Number.isFinite(minWidth) ? Math.max(44, minWidth) : 320;
+    const maximum = Number.isFinite(maxWidth) ? Math.max(minimum, maxWidth) : Math.max(minimum, 800);
+    const fallback = Number.isFinite(initialWidth) ? initialWidth : 420;
+    const clamp = (value) => Math.min(maximum, Math.max(minimum, value));
+    const [state, setState] = (0, react_1.useState)(() => ({ key: storageKey, initial: fallback, value: restoreWidth(storageKey, fallback) }));
+    let value = state.value;
+    if (state.key !== storageKey || state.initial !== fallback) {
+        value = state.key !== storageKey ? restoreWidth(storageKey, fallback) : fallback;
+        setState({ key: storageKey, initial: fallback, value });
+    }
+    const width = clamp(value);
+    const cleanupRef = (0, react_1.useRef)(null);
+    const requestedWidthRef = (0, react_1.useRef)(undefined);
+    const release = (0, react_1.useCallback)(() => {
+        cleanupRef.current?.();
+        cleanupRef.current = null;
+    }, []);
+    // A changed configuration must terminate the old pointer closure, including
+    // its captured bounds, width, and storage scope.
+    (0, react_1.useEffect)(() => release, [active, minimum, maximum, storageKey, release]);
+    (0, react_1.useEffect)(() => {
+        // Parent state may echo every onWidthChange during a gesture. Only an
+        // independent width change should interrupt it, not our own last update.
+        if (fallback !== requestedWidthRef.current)
+            release();
+    }, [fallback, release]);
+    (0, react_1.useEffect)(() => {
+        if (!storageKey)
+            return;
+        try {
+            window.sessionStorage.setItem(storageKey, String(width));
+        }
+        catch { /* Optional browser persistence. */ }
+    }, [storageKey, width]);
+    const resize = (next) => {
+        const bounded = clamp(next);
+        requestedWidthRef.current = bounded;
+        setState({ key: storageKey, initial: fallback, value: bounded });
+        onWidthChange?.(bounded);
+    };
+    const onPointerDown = (event) => {
+        if (!active || event.button !== 0)
+            return;
+        release();
+        const startX = event.clientX;
+        const startWidth = width;
+        const pointerId = event.pointerId;
+        const previousSelection = document.body.style.userSelect;
+        document.body.style.userSelect = 'none';
+        const move = (next) => {
+            if (next.pointerId !== pointerId)
+                return;
+            resize(startWidth + startX - next.clientX);
+            next.preventDefault();
+        };
+        const end = (next) => {
+            if (next.pointerId === pointerId)
+                release();
+        };
+        document.addEventListener('pointermove', move, { passive: false });
+        document.addEventListener('pointerup', end);
+        document.addEventListener('pointercancel', end);
+        window.addEventListener('blur', release);
+        cleanupRef.current = () => {
+            document.removeEventListener('pointermove', move);
+            document.removeEventListener('pointerup', end);
+            document.removeEventListener('pointercancel', end);
+            window.removeEventListener('blur', release);
+            document.body.style.userSelect = previousSelection;
+        };
+        event.currentTarget.focus();
+        event.preventDefault();
+    };
+    const onKeyDown = (event) => {
+        if (!active || event.altKey || event.ctrlKey || event.metaKey)
+            return;
+        const step = event.shiftKey ? 50 : 20;
+        const next = { ArrowLeft: width + step, ArrowRight: width - step, Home: minimum, End: maximum }[event.key];
+        if (next === undefined)
+            return;
+        release();
+        resize(next);
+        event.preventDefault();
+        event.stopPropagation();
+    };
+    return {
+        width, minimum, maximum, onPointerDown, onKeyDown,
+        onDoubleClick: () => { if (active) {
+            release();
+            resize(fallback);
+        } },
+    };
+}

package/dist/cjs/react/index.d.ts

@@ -1,6 +1,7 @@
-export type { ChatMessage, MessagePart, TextPart, ToolInvocationPart, ToolResultPart, TruncationInfo, PipelineStepUsage, PipelineStepReport, PipelineStatus, PipelineState, MentionResult, MentionData, MentionConfig, MentionSerializationConfig, SessionConfig, SessionSummary, WireChatMessage, ChatTheme, ChatThemePreset, ChatThemeOverride, ChatThemeColors, ChatLocale, ChatSize, ChatSizePreset, SuggestionsConfig, ToolLabelConfig, ToolResultDisplayMode, ToolResultDisplayConfig, VoiceInputConfig, Mention, MentionChipProps, MentionChipListProps, ChatClassNames, ChatComponents, OnBeforeSend, OnToolResult, ApprovalDescriptionFn, PipelineMessageTranslator, StepSummaryFormatter, AiChatProviderConfig, UseAiChatReturn, PendingApproval, UseApprovalsReturn, UseMentionsReturn, UseSuggestionsReturn, AiChatPanelProps, MessageListProps, MessageBubbleProps, ChatInputProps, MentionInputProps, RichMentionInputHandle, RichMentionInputProps, RichMentionInputComponents, MentionDropdownItemProps, ChatWindowHeaderRenderProps, ChatWindowProps, ApprovalCardProps, BulkApprovalCardProps, PipelineTimelineProps, SuggestionChipProps, SuggestionBarProps, AiTriggerButtonProps, ToolResultBlockProps, MarkdownProps, ChatTransport, ChatTransportConfig, ChatTransportDataPart, ChatTransportDataHandler, ChatTransportApprovalResponse, } from './types.js';
+export type { ChatMessage, MessagePart, TextPart, ToolInvocationPart, ToolResultPart, TruncationInfo, PipelineStepUsage, PipelineStepReport, PipelineStatus, PipelineState, MentionResult, MentionData, MentionConfig, MentionSerializationConfig, ChatCompletionProvider, CompletionItem, CompletionItemAction, CompletionPermissionContext, CommandArgumentsFormProps, CompletionSearchRequest, UiToolCommandSource, SessionConfig, SessionSummary, WireChatMessage, ChatTheme, ChatThemePreset, ChatThemeOverride, ChatThemeColors, ChatLocale, ChatSize, ChatSizePreset, SuggestionsConfig, ToolLabelConfig, ToolResultDisplayMode, ToolResultDisplayConfig, VoiceInputConfig, VoicePushToTalkConfig, Mention, MentionChipProps, MentionChipListProps, ChatClassNames, ChatComponents, OnBeforeSend, OnToolResult, ApprovalDescriptionFn, ApprovalDescriptionContext, PipelineMessageTranslator, StepSummaryFormatter, AiChatProviderConfig, UseAiChatReturn, PendingApproval, UseApprovalsReturn, UseMentionsReturn, UseSuggestionsReturn, AiChatPanelProps, MessageListProps, MessageBubbleProps, ChatInputProps, MentionInputProps, RichMentionInputHandle, RichMentionInputProps, RichMentionInputComponents, MentionDropdownItemProps, ChatWindowHeaderRenderProps, ChatWindowProps, ApprovalCardProps, BulkApprovalCardProps, PipelineTimelineProps, SuggestionChipProps, SuggestionBarProps, AiTriggerButtonProps, ToolResultBlockProps, ClarificationCardProps, ClarificationOption, ClarificationRequest, ClarificationTarget, MarkdownProps, ChatTransport, ChatTransportConfig, ChatTransportDataPart, ChatTransportDataHandler, ChatTransportApprovalResponse, } from './types.js';
 export type { UseDeepgramTranscriptionOptions, UseDeepgramTranscriptionReturn, VoiceInputButtonProps, RecordingBarProps, } from './types.js';
 export { AiChatProvider, type AiChatProviderProps } from './provider/ai-chat-provider.js';
+export { deChatLocale } from './locale-de.js';
 export { useChatContext } from './provider/chat-context.js';
 export type { ChatContextValue } from './provider/chat-context.js';
 export { useAiChat } from './hooks/use-ai-chat.js';
@@ -8,12 +9,23 @@ export { useApprovals } from './hooks/use-approvals.js';
 export { useMentions } from './hooks/use-mentions.js';
 export { useSuggestions } from './hooks/use-suggestions.js';
 export { useDeepgramTranscription } from './hooks/use-deepgram-transcription.js';
+export { useStt, type UseSttOptions, type UseSttReturn } from './stt/use-stt.js';
+export { SttSessionController, type SttProviderAdapter, type SttProviderConnection, type SttProviderEvents, type SttSessionPhase, type SttSessionSnapshot, } from './stt/controller.js';
+export { RecordedSttAdapter, encodeWav, type RecordedSttAdapterOptions, } from './stt/recorded.js';
+export { DeepgramSttAdapter, createDeepgramSegmentParser, type DeepgramSttAdapterOptions, } from './stt/deepgram.js';
 export { useDragResizePanel } from './hooks/use-drag-resize-panel.js';
 export type { UseDragResizePanelOptions, UseDragResizePanelReturn, ResizeEdge, } from './hooks/use-drag-resize-panel.js';
 export { useDraggablePosition } from './hooks/use-draggable-position.js';
 export { useKeyboardShortcut } from './hooks/use-keyboard-shortcut.js';
+export { useFloatingPanel, type FloatingRect, type FloatingResizeEdge, type UseFloatingPanelOptions, type UseFloatingPanelReturn, } from './hooks/use-floating-panel.js';
+export { DEFAULT_CHAT_SHORTCUTS, formatShortcut, matchesShortcut, resolveChatShortcuts, useChatShortcuts, type ChatShortcutAction, type ChatShortcutMap, type UseChatShortcutsOptions, } from './hooks/use-chat-shortcuts.js';
+export { DEFAULT_PUSH_TO_TALK_HOTKEY, usePushToTalkHotkey, } from './hooks/use-push-to-talk-hotkey.js';
 export type { UseKeyboardShortcutOptions } from './hooks/use-keyboard-shortcut.js';
 export type { UseDraggablePositionOptions, UseDraggablePositionReturn, } from './hooks/use-draggable-position.js';
+export { AssistantLayoutProvider, useAssistantLayout, parseAssistantLayout, defaultAssistantLayout, clampAssistantWidth, DEFAULT_ASSISTANT_LAYOUT_KEY, DEFAULT_ASSISTANT_LAYOUT_LIMITS, type AssistantLayout, type AssistantLayoutLimits, type AssistantLayoutMode, type AssistantLayoutProviderProps, type AssistantLayoutState, } from './assistant/assistant-layout.js';
+export { AssistantShell, AssistantToggle, DEFAULT_ASSISTANT_SHELL_ICONS, DEFAULT_ASSISTANT_SHELL_LABELS, DE_ASSISTANT_SHELL_LABELS, type AssistantShellAction, type AssistantShellButtonProps, type AssistantShellClassNames, type AssistantShellIcons, type AssistantShellLabels, type AssistantShellProps, type AssistantShellWindowOptions, } from './assistant/assistant-shell.js';
+export { assistantShortcutList, DEFAULT_ASSISTANT_SHORTCUT_LABELS, DE_ASSISTANT_SHORTCUT_LABELS, type AssistantShortcutEntry, type AssistantShortcutLabels, type AssistantShortcutListOptions, } from './assistant/assistant-shortcut-list.js';
+export { AssistantWorkspace, type AssistantWorkspaceProps } from './assistant/assistant-workspace.js';
 export { AiChatPanel } from './components/ai-chat-panel.js';
 export { FloatingChatUI, type FloatingChatUIProps } from './components/floating-chat-ui.js';
 export { MessageList } from './components/message-list.js';
@@ -25,6 +37,8 @@ export { ChatWindow } from './components/chat-window.js';
 export { ApprovalCard } from './components/approval-card.js';
 export { BulkApprovalCard } from './components/bulk-approval-card.js';
 export { PipelineTimeline } from './components/pipeline-timeline.js';
+export { ActivityLog, type ActivityLogProps } from './components/activity-log.js';
+export { PlanChecklist, type PlanChecklistProps } from './components/plan-checklist.js';
 export { SuggestionChip } from './components/suggestion-chip.js';
 export { SuggestionBar } from './components/suggestion-bar.js';
 export { MentionChip, MentionChipList } from './components/mention-chip.js';
@@ -32,12 +46,27 @@ export { VoiceInputButton } from './components/voice-input-button.js';
 export { RecordingBar } from './components/recording-bar.js';
 export { AiTriggerButton } from './components/ai-trigger-button.js';
 export { SessionSwitcher, type SessionSwitcherProps } from './components/session-switcher.js';
+export { ClarificationCard } from './components/clarification-card.js';
+export { createToolResultRendererRegistry, defineToolResultRenderer, type AnyToolResultRenderer, type ResolvedToolResultRenderer, type ToolResultRenderer, type ToolResultRendererProps, type ToolResultRendererRegistry, } from './tool-renderers/registry.js';
+export { createCompletionSearch, type CompletionSearch, type CompletionSearchOptions, } from './completions/completion-search.js';
+export { createUiToolCommandProvider } from './completions/ui-tool-command-provider.js';
+export { CommandArgumentsForm } from './components/command-arguments-form.js';
+export { defineChatCommand, defineChatEntity, entitiesFromData, type ChatCommandDefinition, type ChatEntityAction, type ChatEntityCard, type ChatEntityDefinition, type ChatEntityItem, type ChatEntitySearchContext, type DerivedEntityOptions, } from './interactions/definitions.js';
+export { createChatInteractionRegistry, type ChatInteractionRegistry, type ChatInteractionsConfig, type ChatSendPlan, type PendingChatCommand, } from './interactions/registry.js';
+export { useChatInteractionsData, type UseChatInteractionsDataOptions, } from './interactions/use-chat-interactions-data.js';
+export { formatChatCommandMessage, parseChatCommandMessage, stripChatCommandMarkers, type ChatCommandInvocation, } from '../contracts/chat-command.js';
+export { chatText, mergeChatInteractions, parseChatInteractionOverrides, parseChatInteractions, type ChatCommandData, type ChatCommandRun, type ChatEntityActionData, type ChatEntityData, type ChatInteractionArg, type ChatInteractionOverrides, type ChatInteractionsData, type ChatLocaleCode, type ChatText, type ChatToolRun, } from '../contracts/chat-interactions.js';
 export { createRestSessionBridge, type RestSessionBridgeOptions, type HeadersResolver, } from './bridges/rest-session-bridge.js';
 export { getThemeVars, CHAT_THEME_PRESETS, DEFAULT_THEME_PRESET } from './themes.js';
 export { mergePipelineSteps } from './utils/merge-pipeline-steps.js';
+export { readActivitySteps, readLatestPlan, type ActivityStep, type ActivityStepStatus, } from './utils/activity.js';
+export type { PlanItem, PlanItemStatus } from '../contracts/plan.js';
 export { sanitizeStoredMessages } from './utils/sanitize-stored-messages.js';
+export { createLocalSessionStore, type LocalSessionStoreOptions } from './utils/local-session-store.js';
 export { stripContextBlocks, parseMentionSegments, serializeMentionsForSend, inferMentionPrefix, normalizeMentionSlug, } from './utils/mention-markup.js';
 export { createToolResultHandler, type ToolResultHandlerConfig, } from './utils/create-tool-result-handler.js';
 export { createApprovalDescriptionGenerator, type ApprovalDescriptionConfig, } from './utils/create-approval-description.js';
+export { findOpenClarification, readClarificationPart, type ClarificationPart, } from './utils/clarification.js';
+export { formatClarificationAnswer, stripClarificationMarkers, } from '../contracts/clarification.js';
 export * from './ui.js';
 export * from './template.js';