@qwen-code/web-shell 0.24.1-preview.0

package/dist/types/hooks/useComposerCore.d.ts

@@ -0,0 +1,226 @@
+import { type ReactNode, type ClipboardEventHandler, type DragEventHandler } from 'react';
+import { EditorView } from '@codemirror/view';
+import { Compartment } from '@codemirror/state';
+import type { CommandInfo } from '../adapters/types';
+import type { PromptFile, PromptImage } from '../adapters/promptTypes';
+import { type UseDaemonFollowupSuggestionReturn } from '@qwen-code/web-shell/daemon-react-sdk';
+import { type SkillInfo, type SlashCommandCompletionResult } from '../completions/slashCompletion';
+import { type CommandDisplayCategoryOrder } from '../utils/commandDisplay';
+import { type AtMentionMenuState, type AtMentionWorkspaceActions } from './useAtMentionMenu';
+export { getComposerTagDisplay, getComposerTagLabel, getComposerTagValue, } from '../utils/composerTag';
+import type { DaemonInputAnnotation } from '@qwen-code/sdk/daemon';
+import type { ComposerTagClickHandler, ComposerTagRenderer, UserMessageContentParser, WebShellComposerApi, WebShellComposerInput, WebShellComposerTag, WebShellComposerTagIconMap, WebShellComposerTagOptions, WebShellComposerTextOptions, WebShellBuiltinAtProvidersConfig, WebShellAtProvider } from '../customization';
+export declare function serializeComposerTag(tag: WebShellComposerTag): string;
+export declare function buildComposerPrompt(text: string, tags: readonly WebShellComposerTag[]): string;
+export interface InlineTagPlacement {
+    start: number;
+    end: number;
+    tag: WebShellComposerTag;
+}
+export declare function buildComposerPromptWithInlineTagPlacements(text: string, topTags: readonly WebShellComposerTag[], inlineTags: readonly InlineTagPlacement[]): string;
+export declare function replaceInlineTagPlacements(text: string, inlineTags: readonly InlineTagPlacement[]): string;
+interface InlineTagRange {
+    from: number;
+    to: number;
+    tag: InlineComposerTag;
+}
+type InlineComposerTag = WebShellComposerTag & {
+    iconUrl?: string;
+    renderContent?: ComposerTagRenderer;
+    tooltip?: ReactNode;
+    tooltipText?: string;
+    onClick?: ComposerTagClickHandler;
+};
+export declare const addInlineTagEffect: import("@codemirror/state").StateEffectType<InlineTagRange>;
+export declare const removeInlineTagEffect: import("@codemirror/state").StateEffectType<{
+    predicate?: (tag: WebShellComposerTag) => boolean;
+}>;
+export declare const clearInlineTagsEffect: import("@codemirror/state").StateEffectType<void>;
+export declare function getInlineComposerTags(view: EditorView): WebShellComposerTag[];
+export interface EditorHandle extends WebShellComposerApi {
+    clearText(): void;
+    focus(): void;
+    getText(): string;
+    hasAttachments(): boolean;
+    hasInput(): boolean;
+    retryLast(): void;
+    restoreImages(images: readonly PromptImage[]): void;
+    restoreFiles(files: readonly PromptFile[]): void;
+    restoreInputAnnotations?(inputAnnotations: readonly DaemonInputAnnotation[]): void;
+}
+export declare const editableCompartment: Compartment;
+export declare const placeholderCompartment: Compartment;
+export declare const followupGhostCompartment: Compartment;
+export declare function getFollowupCompletion(text: string, suggestion: string | null | undefined): string | null;
+export declare function mapRestoredInputAnnotationsAfterTextChange(annotations: readonly DaemonInputAnnotation[], previousText: string, nextText: string): DaemonInputAnnotation[];
+export type ComposerSubmitCommit = () => void;
+export interface ComposerSubmitMetadata {
+    inputAnnotations?: DaemonInputAnnotation[];
+}
+export interface UseComposerCoreOptions {
+    onSubmit: (text: string, images?: PromptImage[], files?: PromptFile[], commitAccepted?: ComposerSubmitCommit, metadata?: ComposerSubmitMetadata) => boolean | void;
+    onInputTextChange?: (text: string) => void;
+    onCycleMode?: () => void;
+    cycleModeOnTab?: boolean;
+    onToggleShortcuts?: () => void;
+    disabled?: boolean;
+    /**
+     * Whether the composer may react to FILE drags at all (drag highlight and
+     * drop ingestion on the inline image/text lane). `false` leaves paste
+     * working but makes attachment drag-and-drop inert. Defaults to `true`.
+     */
+    fileDragEnabled?: boolean;
+    placeholderText?: string;
+    commands: CommandInfo[];
+    skills?: SkillInfo[];
+    allowEmptySlashMenu?: boolean;
+    slashCommandCategoryOrder?: CommandDisplayCategoryOrder;
+    autoSubmitSlashCommands?: boolean;
+    queuedMessages?: string[];
+    onPopQueuedMessages?: () => boolean;
+    onClearQueuedMessages?: () => boolean;
+    currentMode?: string;
+    onFocusFooter?: () => boolean;
+    dialogOpen?: boolean;
+    followupState?: UseDaemonFollowupSuggestionReturn['followupState'];
+    onAcceptFollowup?: UseDaemonFollowupSuggestionReturn['onAcceptFollowup'];
+    onDismissFollowup?: UseDaemonFollowupSuggestionReturn['onDismissFollowup'];
+    sessionId?: string;
+    sessionName?: string;
+    composerInput?: WebShellComposerInput;
+    composerInputVersion?: number;
+    builtinAtProviders?: WebShellBuiltinAtProvidersConfig;
+    atProviders?: readonly WebShellAtProvider[];
+    atWorkspaceCwd?: string;
+    composerScopeKey?: string;
+    disableLegacyHistoryFallback?: boolean;
+    attachmentsEnabled?: boolean;
+    workspaceFeaturesEnabled?: boolean;
+    composerTagIcons?: WebShellComposerTagIconMap;
+    parseUserMessageContent?: UserMessageContentParser;
+    renderComposerTag?: ComposerTagRenderer;
+    renderComposerTagTooltip?: ComposerTagRenderer;
+    onComposerTagClick?: ComposerTagClickHandler;
+    onFileTagClick?: ComposerTagClickHandler;
+    onImageIngestionNotice?: (tone: 'warning' | 'error', message: string) => void;
+    /**
+     * Invoked when the user selects the @ panel's "Upload file" item, with the
+     * directory currently being browsed and a callback that re-inserts the
+     * removed mention query when the picker closes without an upload. The
+     * composer opens a file picker and uploads into that directory. When
+     * absent, the upload item is hidden.
+     */
+    onFileUploadRequest?: (targetDir: string, restoreQuery?: () => void) => void;
+    /**
+     * True while a workspace file upload is pending or in flight. Gates
+     * submit exactly like the image lane's pending batches, so a prompt cannot
+     * go out before the upload's `@file` reference has been inserted.
+     */
+    workspaceUploadBusy?: boolean;
+    /** CodeMirror theme extension for the editor view. Each variant provides its own. */
+    editorTheme: Parameters<typeof EditorView.theme>[0];
+}
+export interface SearchState {
+    searchMode: boolean;
+    searchQuery: string;
+    searchMatches: string[];
+    searchActiveIndex: number;
+    searchInputRef: React.RefObject<HTMLInputElement | null>;
+    searchUiRef: React.RefObject<HTMLDivElement | null>;
+    openHistorySearch: () => void;
+    closeSearch: (restoreDraft: boolean, keepFocus?: boolean) => void;
+    submitSearchMatch: (match: string) => void;
+    restoreSearchMatch?: (match: string) => void;
+    handleSearchKeyDown: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    handleSearchInput: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    handleSearchCompositionEnd: (e: React.CompositionEvent<HTMLInputElement>) => void;
+}
+export interface SlashMenuState extends SlashCommandCompletionResult {
+    selectedIndex: number;
+}
+/**
+ * Editor backend for touch devices: instead of a CodeMirror EditorView, the
+ * composer renders a plain controlled `<textarea>` wired to these fields.
+ * Mobile virtual keyboards and IMEs interact poorly with CodeMirror's
+ * contenteditable (see #5958), while a native textarea gets the platform's
+ * full input stack for free. Null on desktop.
+ */
+export interface MobileComposerBackend {
+    textareaRef: React.RefObject<HTMLTextAreaElement | null>;
+    value: string;
+    onChange: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
+    onBlur: () => void;
+    placeholder: string;
+}
+export interface ComposerImageTransferHandlers {
+    onPasteCapture: ClipboardEventHandler<HTMLDivElement>;
+    onDragEnterCapture: DragEventHandler<HTMLDivElement>;
+    onDragOverCapture: DragEventHandler<HTMLDivElement>;
+    onDragLeaveCapture: DragEventHandler<HTMLDivElement>;
+    onDropCapture: DragEventHandler<HTMLDivElement>;
+}
+export interface UseComposerCoreReturn {
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    viewRef: React.RefObject<EditorView | null>;
+    workspaceActionsRef: React.RefObject<AtMentionWorkspaceActions | undefined>;
+    mobileComposer: MobileComposerBackend | null;
+    focus: () => void;
+    submitText: () => void;
+    clearText: () => void;
+    getText: () => string;
+    hasInput: () => boolean;
+    hasAttachments: boolean;
+    hasContent: boolean;
+    canSubmit: boolean;
+    pendingImageBatchCount: number;
+    imageDragActive: boolean;
+    clearImageDragState: () => void;
+    ingestFiles: (files: readonly File[]) => boolean;
+    imageTransferHandlers: ComposerImageTransferHandlers;
+    handle: EditorHandle;
+    pastedImages: PromptImage[];
+    removeImage: (index: number) => void;
+    pastedFiles: PromptFile[];
+    removeFile: (index: number) => void;
+    expandPastedText: (index: number) => void;
+    composerTags: WebShellComposerTag[];
+    removeTopTag: (id: string) => void;
+    addTags: (tags: readonly WebShellComposerTag[], options?: WebShellComposerTagOptions) => void;
+    removeInlineTags: (predicate?: (tag: WebShellComposerTag) => boolean) => void;
+    insertText: (text: string, options?: WebShellComposerTextOptions) => void;
+    setText: (text: string) => void;
+    submit: (input?: WebShellComposerInput) => void;
+    clear: (options?: {
+        text?: boolean;
+        tags?: boolean;
+    }) => void;
+    retryLast: () => void;
+    replaceEditorText: (text: string) => void;
+    shellMode: boolean;
+    setShellMode: React.Dispatch<React.SetStateAction<boolean>>;
+    toggleShellMode: () => void;
+    currentMode: string;
+    sessionName: string | undefined;
+    searchState: SearchState;
+    navigatePrevHistory: () => void;
+    navigateNextHistory: () => void;
+    showShortcutHints: boolean;
+    followupState: UseDaemonFollowupSuggestionReturn['followupState'];
+    disabled: boolean;
+    onAcceptFollowup: UseDaemonFollowupSuggestionReturn['onAcceptFollowup'];
+    onDismissFollowup: UseDaemonFollowupSuggestionReturn['onDismissFollowup'];
+    slashMenu: SlashMenuState | null;
+    openSlashMenu: () => boolean;
+    closeSlashMenu: () => void;
+    selectSlashCompletion: (index: number) => boolean;
+    acceptSlashCompletion: (index?: number, submit?: boolean) => boolean;
+    atMenu: AtMentionMenuState | null;
+    closeAtMenu: () => void;
+    selectAtCompletion: (index: number) => boolean;
+    acceptAtCompletion: (index?: number) => boolean;
+    enterAtCategory: (index?: number) => boolean;
+    backAtCategories: () => false | 'items' | 'categories';
+    updateAtSearch: (query: string) => boolean;
+    selectAtTab: (tabId: string) => boolean;
+}
+export declare function useComposerCore(options: UseComposerCoreOptions): UseComposerCoreReturn;

package/dist/types/hooks/useContextUsageControls.d.ts

@@ -0,0 +1,26 @@
+import type { DaemonConnectionState, DaemonSessionActions, DaemonSessionContextUsageStatus, DaemonSessionOwnerGuard, DaemonSessionOwnerSnapshot } from '@qwen-code/web-shell/daemon-react-sdk';
+type CompressionResult = {
+    kind: 'completed';
+    usage: DaemonSessionContextUsageStatus;
+} | {
+    kind: 'failed' | 'cancelled' | 'refreshFailed' | 'interrupted';
+};
+export interface ContextUsageControls {
+    sessionId: string;
+    canCompress: boolean;
+    compressing: boolean;
+    result?: CompressionResult;
+    compress(): Promise<void>;
+    captureOwner(): DaemonSessionOwnerSnapshot;
+    getContextUsage: DaemonSessionActions['getContextUsage'];
+}
+export type RegisterContextUsageControls = (controls: ContextUsageControls) => () => void;
+export declare function useContextUsageControls({ connection, actions, ownerGuard, busy, writeBlocked, onBeforeCompress, }: {
+    connection: DaemonConnectionState;
+    actions: DaemonSessionActions;
+    ownerGuard: DaemonSessionOwnerGuard;
+    busy: boolean;
+    writeBlocked: boolean;
+    onBeforeCompress: () => void;
+}): ContextUsageControls | undefined;
+export {};

package/dist/types/hooks/useCopiedFlash.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The transient "copied" feedback every copy button shows: `flash()` turns
+ * the flag on and schedules the reset. The pending reset is cleared on
+ * unmount — a leaked timer fires after a test file's environment is torn
+ * down and, since the unit suites fail on unhandled errors, turns an
+ * all-green run red (`window is not defined` out of the reset callback).
+ * A re-flash restarts the window instead of letting the older reset cut
+ * the newer feedback short.
+ */
+export declare function useCopiedFlash(resetMs?: number): [copied: boolean, flash: () => void];

package/dist/types/hooks/useDelayedGlobalKeyDown.d.ts

@@ -0,0 +1 @@
+export declare function useDelayedGlobalKeyDown(handler: (event: KeyboardEvent) => void, deps: readonly unknown[], delayMs?: number): void;

package/dist/types/hooks/useExternalLinkOpener.d.ts

@@ -0,0 +1,11 @@
+import type { MouseEvent } from 'react';
+/**
+ * Opens external link clicks through the shell's explicit desktop opener.
+ *
+ * The desktop webview's implicit `target="_blank"` handling can silently
+ * drop new-window requests, so anchored external URLs should be routed
+ * through this handler in the packaged shell; failures surface as error
+ * toasts. Plain browsers keep native anchor behavior (the handler is a
+ * no-op there).
+ */
+export declare function useExternalLinkOpener(): (event: MouseEvent<HTMLAnchorElement>, url: string | undefined) => void;

package/dist/types/hooks/useFileUpload.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonWorkspaceFileUploadRequest, DaemonWorkspaceFileUploadResult } from '@qwen-code/sdk/daemon';
+/**
+ * Minimal structural client for uploads. Both `DaemonClient`
+ * (legacy-primary) and `WorkspaceDaemonClient` (workspace-qualified) satisfy
+ * it; the caller resolves the correct target before constructing the hook.
+ */
+export interface FileUploadClient {
+    uploadWorkspaceFile(req: DaemonWorkspaceFileUploadRequest, clientId?: string): Promise<DaemonWorkspaceFileUploadResult>;
+}
+export type FileUploadStatus = 'pending' | 'uploading' | 'done' | 'error';
+/** Machine-readable failure codes; the render site localizes them. */
+export type FileUploadErrorCode = 'tooLarge' | 'noDaemon' | 'tooManyFiles';
+export interface FileUploadItem {
+    id: string;
+    file: File;
+    /** Requested relative path in the target workspace. */
+    targetPath: string;
+    status: FileUploadStatus;
+    /** 0–1. */
+    progress: number;
+    /** Set for locally classified failures; localized at the render site. */
+    errorCode?: FileUploadErrorCode;
+    /** Raw failure message (server-side errors). */
+    error?: string;
+    /** Server-confirmed final path (may be auto-numbered). */
+    resultPath?: string;
+    /** Set on a `tooManyFiles` notice row: how many files were not queued. */
+    skippedCount?: number;
+}
+export interface UseFileUploadOptions {
+    client: FileUploadClient | undefined;
+    maxBytes: number;
+    /**
+     * Identity of the target workspace AND the session composing into it.
+     * When it changes (or the hook unmounts), in-flight uploads are aborted
+     * and the queue is cleared, so an upload started for workspace A cannot
+     * insert a path into workspace B, and an upload started in one session
+     * cannot append its reference to another session's draft after a switch.
+     */
+    targetKey: string;
+}
+export interface UseFileUploadReturn {
+    uploads: FileUploadItem[];
+    /** True while any item is pending or in flight; gates composer submit. */
+    isBusy: boolean;
+    /**
+     * Queue `files` for sequential upload into `targetDir` (relative to the
+     * target workspace root; `'.'` for the root). `onUploaded` fires exactly
+     * once per successful upload with the server-confirmed final path.
+     * Returns how many files were actually queued (locally rejected files,
+     * e.g. oversized ones, become error rows without queueing).
+     */
+    uploadFiles: (files: File[], targetDir: string, onUploaded?: (path: string) => void) => number;
+    /** Remove a row and abort it if it is pending or in flight. */
+    removeUpload: (id: string) => void;
+}
+export declare function useFileUpload(options: UseFileUploadOptions): UseFileUploadReturn;

package/dist/types/hooks/useFilterInput.d.ts

@@ -0,0 +1,27 @@
+import { type ChangeEvent, type CompositionEvent } from 'react';
+export interface FilterInputProps {
+    value: string;
+    onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    onCompositionStart: () => void;
+    onCompositionEnd: (event: CompositionEvent<HTMLInputElement>) => void;
+}
+export interface UseFilterInputResult {
+    /**
+     * Committed value to filter by. Only changes once a keystroke is committed,
+     * never while an IME composition is in flight, so filtering a list by this
+     * value does not refilter/relayout on every intermediate pinyin character.
+     */
+    filterValue: string;
+    /** Spread onto the search `<input>` (carries the raw value + IME handlers). */
+    inputProps: FilterInputProps;
+}
+/**
+ * Search-field state for filterable list dialogs, hardened against IME
+ * composition jitter: the field reflects every keystroke while the committed
+ * `filterValue` (used to filter) updates only on non-composition input and on
+ * `compositionend`.
+ *
+ * `onFilterChange` fires with the committed value whenever it changes — dialogs
+ * use it to reset their own selection/cursor state.
+ */
+export declare function useFilterInput(onFilterChange?: (value: string) => void): UseFilterInputResult;

package/dist/types/hooks/useInputHistory.d.ts

@@ -0,0 +1,17 @@
+export declare function getPromptHistoryStorageKey(workspaceCwd?: string): string;
+export declare function pushInputHistoryEntry(storageKey: string, text: string, fallbackStorageKey?: string): void;
+export declare function useInputHistory(storageKey?: string, fallbackStorageKey?: string): {
+    push: (text: string) => void;
+    navigateUp: (currentText: string) => string | null;
+    navigateDown: () => string | null;
+    isNavigating: () => boolean;
+    reset: () => void;
+    searchReverse: (query: string) => string | null;
+    getReverseMatches: (query: string) => string[];
+    getLastEntry: (filter?: (entry: string) => boolean) => string | null;
+    resetSearch: () => void;
+    nav: {
+        canUp: boolean;
+        canDown: boolean;
+    };
+};

package/dist/types/hooks/useIsLargeScreen.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The width at or above which the app is considered a "large screen" for
+ * layouts such as split view.
+ */
+export declare const LARGE_SCREEN_QUERY = "(min-width: 1024px)";
+/**
+ * Tracks whether the viewport currently matches a large-screen media query.
+ *
+ * Mirrors the inline `matchMedia` pattern already used for the mobile drawer:
+ * seed synchronously from `matchMedia().matches` so the first render is correct
+ * (no flash), then subscribe to `change`. Degrades to `false` when `matchMedia`
+ * is unavailable (SSR / the jsdom test default), which keeps large-screen-only
+ * entry points hidden unless a test explicitly opts in.
+ */
+export declare function useIsLargeScreen(query?: string): boolean;

package/dist/types/hooks/useIsTouchComposer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Matches devices whose primary interaction is a touchscreen with no hover —
+ * phones and tablets. The AND of both features deliberately excludes touch
+ * laptops (hover-capable trackpad + touchscreen), which keep the desktop
+ * CodeMirror editor.
+ */
+export declare const TOUCH_COMPOSER_QUERY = "(hover: none) and (pointer: coarse)";
+/**
+ * Raw device detection, ignoring the URL override. Used to gate programmatic
+ * (non-gesture) `view.focus()` calls: on iOS, focusing an editable element
+ * outside a user gesture does not open the keyboard but does claim
+ * `document.activeElement`, after which user taps may no longer fire a fresh
+ * focus event — the keyboard never appears. That must stay suppressed even
+ * when the user forces the CodeMirror path via `?composer=codemirror`.
+ *
+ * The media query alone decides — deliberately no `navigator.maxTouchPoints`
+ * requirement: Playwright's stock WebKit iPhone profiles (and some TV
+ * browsers) match the query while reporting zero touch points, and the
+ * textarea is a safe fallback wherever the primary pointer is coarse and
+ * cannot hover.
+ */
+export declare function isCoarsePointerDevice(): boolean;
+/**
+ * Decides once, at mount, whether the composer should use the plain
+ * `<textarea>` backend instead of CodeMirror. Intentionally NOT reactive:
+ * swapping editor backends mid-session would drop the draft, tags, and
+ * pasted images, so the choice is frozen for the lifetime of the component.
+ * Degrades to `false` (CodeMirror) when `matchMedia` is unavailable
+ * (SSR / the jsdom test default).
+ */
+export declare function useIsTouchComposer(): boolean;

package/dist/types/hooks/useListboxKeyboard.d.ts

@@ -0,0 +1,42 @@
+export interface ListboxKeyboardOptions {
+    /** Number of selectable items in the list. */
+    itemCount: number;
+    /** Currently highlighted index, or -1 when no row is highlighted. */
+    activeIndex: number;
+    /** Called with the next index when the user moves the highlight. */
+    onActiveIndexChange: (index: number) => void;
+    /** Called with an index when the user confirms it (Enter). */
+    onConfirm: (index: number) => void;
+    /** Disable the listener without unmounting the host component. */
+    enabled?: boolean;
+}
+export interface ListboxKeyboardResult {
+    /**
+     * True while the user is navigating by keyboard. Dialogs use this to suppress
+     * the CSS `:hover` highlight so a cursor that happens to rest over a row —
+     * e.g. when the dialog opens under the pointer — does not fight the keyboard
+     * highlight. It flips back to false on a real `mousemove` (which never fires
+     * from a dialog merely appearing under a stationary cursor).
+     */
+    keyboardMode: boolean;
+}
+/**
+ * Keyboard navigation for listbox-style dialogs (model/theme/approval/resume/…).
+ *
+ * Selection is driven by `activeIndex` state rather than DOM focus, so it works
+ * whether focus sits on the dialog panel/listbox or on a search input. The
+ * visual highlight + `scrollIntoView` already implemented by each dialog
+ * reflects the active index; this hook only moves that index and confirms it.
+ *
+ * Enter confirms the active row, unless focus is on a control that owns Enter
+ * (see {@link focusOwnsEnter}) — so, e.g., Enter on a focused "Delete" button
+ * activates the button — or no row is highlighted (`activeIndex < 0`).
+ * Searchable dialogs rely on the latter: they open with no highlight and reset
+ * to none whenever the filter text changes, so a reflexive Enter in the search
+ * box never confirms a row the user didn't visibly pick first; the first
+ * ArrowDown lands on the first row. Space mirrors Enter (per the ARIA listbox
+ * pattern) but additionally yields to text fields, where it types a space.
+ * Escape is intentionally NOT handled here — {@link DialogShell} owns dialog
+ * dismissal.
+ */
+export declare function useListboxKeyboard({ itemCount, activeIndex, onActiveIndexChange, onConfirm, enabled, }: ListboxKeyboardOptions): ListboxKeyboardResult;

package/dist/types/hooks/useMessages.d.ts

@@ -0,0 +1,20 @@
+import { type DaemonTranscriptBlock, type DaemonTranscriptBlockChangeSummary } from '@qwen-code/sdk/daemon';
+import { type Translator } from '../adapters/localizedMessages';
+import type { Message } from '../adapters/types';
+export { transcriptBlocksToLocalizedMessages, type Translator, } from '../adapters/localizedMessages';
+interface MessageProjection {
+    blocks: readonly DaemonTranscriptBlock[];
+    messages: Message[];
+    t: Translator;
+    blockChangeSummary?: DaemonTranscriptBlockChangeSummary;
+}
+export interface BackgroundAgentResolution {
+    status: string;
+    durationMs?: number;
+}
+export declare function projectStreamingTailMessages(previous: MessageProjection | undefined, blocks: readonly DaemonTranscriptBlock[], t: Translator, blockChangeSummary?: DaemonTranscriptBlockChangeSummary): Message[] | undefined;
+export declare function getBackgroundAgentNotificationKey(blocks: readonly DaemonTranscriptBlock[]): string;
+export declare function getPendingBackgroundAgentKey(messages: readonly Message[]): string;
+export declare function reconcileBackgroundAgentResolutions(messages: Message[], resolutions: ReadonlyMap<string, BackgroundAgentResolution>): Message[];
+export declare function useMessagesFromBlocks(t: Translator, blocks: readonly DaemonTranscriptBlock[], blockChangeSummary?: DaemonTranscriptBlockChangeSummary): Message[];
+export declare function useMessages(t: Translator): Message[];

package/dist/types/hooks/useModelConfigurations.d.ts

@@ -0,0 +1,11 @@
+export declare function useModelConfigurations(enabled: boolean): {
+    models: import("@qwen-code/sdk/daemon").DaemonModelConfiguration[];
+    reload: () => Promise<{
+        models: import("@qwen-code/sdk/daemon").DaemonModelConfiguration[];
+    } | undefined>;
+    data: {
+        models: import("@qwen-code/sdk/daemon").DaemonModelConfiguration[];
+    } | undefined;
+    loading: boolean;
+    error: Error | undefined;
+};

package/dist/types/hooks/useNewSessionSuggestion.d.ts

@@ -0,0 +1,26 @@
+import type { Message } from '../adapters/types';
+import type { DaemonSessionActions } from '@qwen-code/web-shell/daemon-react-sdk';
+type SuggestionKind = 'btw' | 'new_session' | 'none';
+export interface NewSessionSuggestionState {
+    suggestion: Exclude<SuggestionKind, 'none'>;
+    classifiedInput: string;
+    sourceSessionId: string;
+}
+export interface UseNewSessionSuggestionOptions {
+    enabled: boolean;
+    messages: Message[];
+    sessionId?: string;
+    contextUsageRatio: number;
+    isRunning: boolean;
+    dialogOpen: boolean;
+    hasAttachments: boolean | null;
+    generateContent?: DaemonSessionActions['generateSessionContent'];
+}
+export interface UseNewSessionSuggestionReturn {
+    suggestion: NewSessionSuggestionState | null;
+    updateInput: (inputText: string) => void;
+    dismiss: () => void;
+    suppress: () => void;
+}
+export declare function useNewSessionSuggestion({ enabled, messages, sessionId, contextUsageRatio, isRunning, dialogOpen, hasAttachments, generateContent, }: UseNewSessionSuggestionOptions): UseNewSessionSuggestionReturn;
+export {};

package/dist/types/hooks/useOtherWorkspaceSessions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonSessionSummary } from '@qwen-code/sdk/daemon';
+export interface OtherWorkspaceSessionsResult {
+    sessions: DaemonSessionSummary[];
+    reload: () => Promise<void>;
+}
+export declare function useOtherWorkspaceSessions(enabled?: boolean, pollIntervalMs?: number): OtherWorkspaceSessionsResult;

package/dist/types/hooks/usePrefersReducedMotion.d.ts

@@ -0,0 +1 @@
+export declare function usePrefersReducedMotion(): boolean;

package/dist/types/hooks/useQueuedPrompts.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type DaemonSessionActions, type DaemonStreamingState, type DaemonWorkspaceActions } from '@qwen-code/web-shell/daemon-react-sdk';
+import type { DaemonInputAnnotation, DaemonTranscriptStore } from '@qwen-code/sdk/daemon';
+import type { PromptFile, PromptImage } from '../adapters/promptTypes';
+import type { EditorHandle } from './useComposerCore';
+import type { getTranslator } from '../i18n';
+import type { QueuedPrompt } from '../components/QueuedPromptDisplay';
+interface RefBox<T> {
+    current: T;
+}
+interface UseQueuedPromptsArgs {
+    connected: boolean;
+    writeBlocked?: boolean;
+    sessionId?: string;
+    workspaceCwd?: string;
+    clientId?: string;
+    /**
+     * Whether the daemon advertises `session_mid_turn_message_mutation`. Gates the
+     * mid-turn delete/edit mutations — including the keyboard path, which the view
+     * layer's hidden buttons can't reach — so an older daemon that mints message
+     * ids without the route isn't sent a DELETE it answers with a 404.
+     */
+    canMutateMidTurn: boolean;
+    /**
+     * Whether the daemon advertises `session_mid_turn_message_query`. Gates the
+     * daemon-owned queue lifecycle. With it, accepted messages are restored and
+     * reconciled by id across drain or idle promotion; without it the hook keeps
+     * the legacy local fallback used by older daemons.
+     */
+    canQueryMidTurn: boolean;
+    /**
+     * Whether the daemon advertises `session_attachments`. With it,
+     * attachments travel with a mid-turn message and are injected into the
+     * running turn; without it they stay queued for the next turn.
+     */
+    canInjectMidTurnMedia: boolean;
+    workspaceFileActions?: Pick<DaemonWorkspaceActions, 'readFileBytes' | 'stat'>;
+    streamingState: DaemonStreamingState;
+    sessionHasActivePrompt?: boolean;
+    /** Keep ordinary submissions local until the Goal is paused, cleared, or the
+     * user explicitly inserts one into the current turn. */
+    holdQueuedPromptsLocally?: boolean;
+    sessionActions: DaemonSessionActions;
+    store: DaemonTranscriptStore;
+    editorRef: RefBox<EditorHandle | null>;
+    reportError: (error: unknown, fallback: string) => void;
+    t: ReturnType<typeof getTranslator>;
+}
+/**
+ * Merge a restored prompt's text into the editor content. Restoration paths
+ * (failed submits, failed mid-turn inserts, queue clears) prepend the prompt
+ * above whatever the user is currently typing — but several of them can fire
+ * for the same prompt across reconnects/refreshes, and a user retrying an
+ * identical message produces the same text twice. Stacking those copies is
+ * what #7128 reports as "inputs concatenated after refresh", so restoring
+ * text that is already present at the top of the editor is a no-op.
+ */
+export declare function mergeRestoredPromptText(current: string, text: string): string;
+export interface UseQueuedPromptsResult {
+    queuedPrompts: QueuedPrompt[];
+    queuedTexts: string[];
+    enqueuePrompt: (text: string, images?: PromptImage[], files?: PromptFile[], onComplete?: () => void, inputAnnotations?: DaemonInputAnnotation[], onAdmitted?: () => void, submittedPrompt?: string) => boolean;
+    removeQueuedPrompt: (id: number) => void;
+    insertQueuedPrompt: (id: number) => Promise<void>;
+    editQueuedPrompt: (id: number) => Promise<void>;
+    editLastQueuedPrompt: () => boolean;
+    clearQueuedPrompts: () => boolean;
+}
+export declare function useQueuedPrompts({ connected, writeBlocked, sessionId, workspaceCwd, clientId, canMutateMidTurn, canQueryMidTurn, canInjectMidTurnMedia, workspaceFileActions, streamingState, sessionHasActivePrompt, holdQueuedPromptsLocally, sessionActions, store, editorRef, reportError, t, }: UseQueuedPromptsArgs): UseQueuedPromptsResult;
+export {};