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

package/dist/types/components/MessageList.d.ts

@@ -0,0 +1,222 @@
+import { type ReactNode } from 'react';
+import type { DaemonSessionArtifact } from '@qwen-code/sdk/daemon';
+import type { Message, TurnCollapseHead } from '../adapters/types';
+import type { PermissionRequest } from '../adapters/types';
+import { type ParallelAgentDisplayItem } from '../adapters/parallelAgentGrouping';
+import { type WebShellSource } from '../customization';
+import type { SessionContentGenerator } from './messages/AssistantMessage';
+import { type TurnOutputFileChange, type TurnOutputOpenRequest, type TurnOutputScheduledTask } from './artifacts/TurnOutputs';
+import type { AttachmentPreviewRequest } from '../adapters/messageTypes';
+export interface MessageListProps {
+    messages: Message[];
+    frozenViewport?: boolean;
+    terminalBackgroundShellTaskIds?: ReadonlySet<string>;
+    pendingApproval: PermissionRequest | null;
+    /** Run /context detail, exactly like typing it (context-usage panels). */
+    onShowContextDetail?: () => void;
+    /** Click an uploaded image in a user message to preview it in the right panel. */
+    onImagePreview?: (src: string, alt?: string) => void;
+    onAttachmentPreview?: (file: AttachmentPreviewRequest) => void;
+    onInsightReportOpen?: (path: string) => void;
+    /** Open the in-place editor; return true when a host owns the lifecycle. */
+    onEditUserMessage?: (targetTurnIndex: number, content: string) => boolean | void;
+    /** Send the text confirmed in the in-place editor. `false` keeps it open. */
+    onSubmitUserMessageEdit?: (targetTurnIndex: number, content: string) => boolean | void | Promise<boolean | void>;
+    loadingTranscript?: boolean;
+    catchingUp?: boolean;
+    hasOlderHistory?: boolean;
+    loadingOlderHistory?: boolean;
+    historyCapacityReached?: boolean;
+    historyPaginationError?: boolean;
+    onLoadOlderHistory?: (options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    /**
+     * Identity of the session whose transcript `messages` show. Block ids are
+     * per-session ordinals, so changing it resets every session-scoped UI state
+     * (collapse overrides, pagination keep-open, pending page snapshots, the
+     * scroll anchor) — a direct session switch never renders empty messages.
+     */
+    sessionKey?: string;
+    transcriptBlockCount?: number;
+    transcriptActivity?: {
+        getSnapshot(): {
+            lastEventId?: number;
+            blocks?: {
+                readonly length: number;
+            };
+        };
+        subscribe(listener: () => void): () => void;
+    };
+    onReloadTranscript?: (signal: AbortSignal) => Promise<void>;
+    transcriptReloadPaused?: boolean;
+    /**
+     * True while the agent is still answering. The newest turn then stays
+     * expanded and un-collapsible so streaming output is never hidden.
+     */
+    isResponding?: boolean;
+    welcomeHeader?: ReactNode;
+    centerWelcomeHeader?: boolean;
+    workspaceCwd?: string;
+    tailContent?: ReactNode;
+    tailKey?: string;
+    virtualScrollThreshold?: number;
+    activeTurnStartedAt?: number;
+    /**
+     * When true, scroll the tail content into view the moment it first appears
+     * even if the user had scrolled up. Opt-in per caller so unrelated inline
+     * panels don't yank the reader to the bottom. Defaults to false.
+     */
+    autoScrollTailIntoView?: boolean;
+    /**
+     * Height reserved for app-level floating UI below the transcript, such as the
+     * bottom todo/status panel. When it changes while the transcript is following
+     * the bottom, perform one more bottom alignment after layout settles.
+     */
+    bottomOverlayInset?: number;
+    hideSessionTimeline?: boolean;
+    hideFirstUserMessage?: boolean;
+    firstTurnMetrics?: {
+        durationMs?: number;
+        inputTokens?: number;
+        outputTokens?: number;
+        cachedTokens?: number;
+    };
+    includeSubagentToolUsageInMetrics?: boolean;
+    showRetryHint?: boolean;
+    onRetryClick?: () => void;
+    failedPromptMessageId?: string;
+    onRetryFailedPrompt?: () => void;
+    onBranchSession?: (branchRecordId?: string) => void | Promise<void>;
+    onCanScrollToBottomChange?: (canScrollToBottom: boolean) => void;
+    turnFileChanges?: ReadonlyMap<string, readonly TurnOutputFileChange[]>;
+    turnArtifacts?: ReadonlyMap<string, readonly DaemonSessionArtifact[]>;
+    sourceEntries?: readonly WebShellSource[];
+    sourceSessionId?: string;
+    onSourceOpen?: (source: WebShellSource) => void;
+    turnScheduledTasks?: ReadonlyMap<string, readonly TurnOutputScheduledTask[]>;
+    onReviewChanges?: (changes: readonly TurnOutputFileChange[], selectedPath?: string) => void;
+    onOpenArtifact?: (artifactId: string, previewContent?: string) => void;
+    onOpenScheduledTask?: (task: TurnOutputScheduledTask) => void;
+    onTurnOutputOpen?: (request: TurnOutputOpenRequest) => void;
+    onError?: (error: unknown, fallback: string) => void;
+    generateContent?: SessionContentGenerator;
+}
+export type DisplayItem = (Extract<ParallelAgentDisplayItem, {
+    type: 'message';
+}> & {
+    /** Metrics info for the final answer assistant message. */
+    turnCollapse?: TurnCollapseHead;
+}) | Extract<ParallelAgentDisplayItem, {
+    type: 'parallel_agents';
+}> | {
+    type: 'turn_collapse';
+    key: string;
+    turnCollapse: TurnCollapseHead;
+} | {
+    type: 'turn_outputs';
+    key: string;
+    turnId: string;
+    changes: readonly TurnOutputFileChange[];
+    artifacts: readonly DaemonSessionArtifact[];
+    scheduledTasks: readonly TurnOutputScheduledTask[];
+};
+export type TurnTimelineNodeKind = 'thought' | 'commentary' | 'tool' | 'agents' | 'plan' | 'status' | 'none';
+export interface TurnTimelineNode {
+    kind: TurnTimelineNodeKind;
+    timestamp?: number;
+    label?: string;
+}
+export interface SessionTimelineEntry {
+    id: string;
+    label: string;
+    detail: string;
+    timestamp?: number;
+    nodeKinds: TurnTimelineNodeKind[];
+    isScheduledTask?: boolean;
+}
+export interface SessionTimelineRange {
+    startIndex: number;
+    endIndex: number;
+    currentIndex: number;
+}
+export declare function groupParallelAgents(sourceMessages: Message[]): DisplayItem[];
+export declare function getDisplayItemVirtualKey(item: DisplayItem): string;
+export declare function attachTurnOutputs(items: DisplayItem[], isResponding: boolean, turnFileChanges?: ReadonlyMap<string, readonly TurnOutputFileChange[]>, turnArtifacts?: ReadonlyMap<string, readonly DaemonSessionArtifact[]>, turnScheduledTasks?: ReadonlyMap<string, readonly TurnOutputScheduledTask[]>): DisplayItem[];
+export declare function pinActiveParallelAgentsToTurnEnd(items: DisplayItem[], automaticallyExpandedKeys?: ReadonlySet<string>): DisplayItem[];
+export interface ApplyTurnCollapseOptions {
+    /**
+     * Per-turn user override keyed by the turn's user-message id:
+     * `true` = forced expanded, `false` = forced collapsed. Turns absent from the
+     * map follow the default (completed turns collapse).
+     */
+    overrides: ReadonlyMap<string, boolean>;
+    /**
+     * True while the agent is still answering. The final turn then stays expanded
+     * and un-collapsible so live output is never hidden.
+     */
+    isResponding: boolean;
+    activeTurnStartedAt?: number;
+    backgroundSummaryGraceActive?: boolean;
+    /**
+     * Whether the final turn's collapse should keep waiting for unmatched
+     * background-agent completions. Pass false once the bounded grace expires
+     * so a lost notification cannot pin the turn expanded forever.
+     */
+    waitForUnmatchedAgentCompletions?: boolean;
+    /**
+     * Bound the matched-notification ordering wait (final answer already on
+     * screen before the completion landed, summary narration still expected).
+     * Pass false once the caller's grace window expires so a summary that never
+     * arrives cannot pin the turn (and its parallel-agents group) open forever.
+     */
+    waitForOrderedNarration?: boolean;
+    terminalBackgroundShellTaskIds?: ReadonlySet<string>;
+    automaticallyExpandedAgentKeys?: ReadonlySet<string>;
+    /**
+     * Tool-call id of a pending approval, if any. The turn containing it is
+     * force-expanded so the inline approve/reject UI is never folded away (mirrors
+     * compact mode's `isForceExpandGroup`).
+     */
+    pendingApprovalCallId?: string | null;
+    includeSubagentToolUsageInMetrics?: boolean;
+    /**
+     * Turns kept expanded despite being complete. Two sources: pagination
+     * split-turn detection (the tail was on screen before pagination completed
+     * the user prompt), and the anchor fallback (a turn collapsed while a
+     * history anchor sat on it). Entries persist until the user toggles the
+     * turn or the screen is cleared; an explicit user toggle always wins.
+     */
+    paginatedExpanded?: ReadonlySet<string>;
+    /** Master switch; when false the items pass through untouched. */
+    enabled: boolean;
+}
+export declare function getTurnTimelineNode(item: DisplayItem, t?: (key: string, vars?: Record<string, string | number>) => string): TurnTimelineNode;
+export declare function getSessionTimelineEntries(messages: readonly Message[], t?: (key: string, vars?: Record<string, string | number>) => string): SessionTimelineEntry[];
+export declare function getSessionTimelineSignature(messages: readonly Message[]): string;
+/**
+ * Walk backwards from `index` to the user-message row that heads its turn and
+ * return that turn's id, or null when `index` precedes the first turn.
+ */
+export declare function findTurnIdForIndex(items: readonly DisplayItem[], index: number): string | null;
+export declare function getTurnIdByDisplayIndex(items: readonly DisplayItem[]): Array<string | null>;
+export declare function getSessionTimelineRangeForIndexes(visibleItems: readonly DisplayItem[], visibleItemIndexes: readonly number[], entryIndexById: ReadonlyMap<string, number>, currentItemIndex?: number | null, turnIdByDisplayIndex?: readonly (string | null)[]): SessionTimelineRange | null;
+export declare function applyTurnCollapse(items: DisplayItem[], { overrides, isResponding, activeTurnStartedAt, backgroundSummaryGraceActive, waitForUnmatchedAgentCompletions, waitForOrderedNarration, terminalBackgroundShellTaskIds, automaticallyExpandedAgentKeys, pendingApprovalCallId, includeSubagentToolUsageInMetrics, paginatedExpanded, enabled, }: ApplyTurnCollapseOptions): DisplayItem[];
+/**
+ * Locate a tool by call id when available because compacting or splitting can
+ * move it under a different message id. Otherwise locate the message itself.
+ */
+export declare function findDisplayItemIndex(items: readonly DisplayItem[], messageId: string, callId?: string): number;
+export interface MessageListHandle {
+    /**
+     * Scroll the transcript so the given message is visible and briefly
+     * highlight it. Returns false when the message is not in the list.
+     */
+    scrollToMessage: (messageId: string, callId?: string) => boolean;
+    /** Resume bottom-follow mode and scroll to the latest output. */
+    scrollToBottom: (behavior?: ScrollBehavior) => void;
+}
+export declare const VIRTUAL_SCROLL_THRESHOLD = 200;
+export declare function shouldUseVirtualScroll(totalCount: number, threshold?: number): boolean;
+export declare function shouldAdjustVirtualScrollPosition(itemEnd: number, scrollOffset: number): boolean;
+export declare const MessageList: import("react").NamedExoticComponent<MessageListProps & import("react").RefAttributes<MessageListHandle>>;

package/dist/types/components/MessageTimestamp.d.ts

@@ -0,0 +1,32 @@
+import { type ReactNode } from 'react';
+interface MessageTimestampProps {
+    /** Wall-clock epoch ms of the message; omitted for synthetic messages. */
+    timestamp?: number;
+    hideTimestamp?: boolean;
+    children: ReactNode;
+    /** When true, show the timestamp permanently at bottom-right instead of hover tooltip. */
+    chatMode?: boolean;
+    /** Use the larger vertical rhythm for tool summaries in thinking-hidden mode. */
+    toolGroupSpacing?: boolean;
+    copyText?: string;
+    copyTitle?: string;
+    /** When set, render an edit action after the copy button. */
+    onEdit?: () => void;
+    editTitle?: string;
+}
+/**
+ * Wraps a rendered history message and reveals its wall-clock time as a
+ * CSS-only tooltip on hover.
+ */
+export declare function MessageTimestamp({ timestamp, hideTimestamp, children, chatMode, toolGroupSpacing, copyText, copyTitle, onEdit, editTitle, }: MessageTimestampProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Local-time clock, dropping the date only for same-day timestamps:
+ * - same day → `HH:mm:ss`
+ * - earlier  → `yyyy-MM-dd HH:mm:ss`
+ *
+ * Fixed order and zero-padded (unlike toLocaleString) so stacked timestamps
+ * align. `now` is injectable so the branch logic is unit-testable without
+ * depending on the wall clock.
+ */
+export declare function formatTimestamp(ts: number, now?: Date): string;
+export {};

package/dist/types/components/ModeIcon.d.ts

@@ -0,0 +1,3 @@
+export declare function ModeIcon({ mode }: {
+    mode: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/MonitorIcon.d.ts

@@ -0,0 +1,2 @@
+import type { SVGProps } from 'react';
+export declare function MonitorIcon(props: SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/PaneHeaderActions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type ReactNode } from 'react';
+export interface PaneHeaderActionsProps {
+    /** Host-provided actions for this pane; omit or null when none. */
+    children?: ReactNode;
+    /** Built-in trailing controls (e.g. close) that stay outside the overflow. */
+    trailing?: ReactNode;
+}
+/**
+ * Renders pane-header host actions inline when they fit, otherwise collapses
+ * them into a `…` menu. Measures against the header width so split-pane
+ * resizing / add-remove does not crush the title.
+ *
+ * Host actions stay mounted in one host slot across collapse so stateful
+ * actions are not reset. Each action is wrapped in a stable slot; the overflow
+ * menu proxies clicks to the interactive descendant inside that slot so opaque
+ * host components do not need to forward internal props.
+ */
+export declare function PaneHeaderActions({ children, trailing, }: PaneHeaderActionsProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/PromptChevron.d.ts

@@ -0,0 +1,7 @@
+import type { CSSProperties } from 'react';
+interface PromptChevronProps {
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function PromptChevron({ className, style }: PromptChevronProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/QueuedPromptDisplay.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { PromptFile, PromptImage } from '../adapters/promptTypes';
+import type { AttachmentPreviewRequest } from '../adapters/messageTypes';
+import type { DaemonInputAnnotation } from '@qwen-code/sdk/daemon';
+import type { getTranslator } from '../i18n';
+export interface QueuedPrompt {
+    submittedPrompt?: string;
+    id: number;
+    sessionId?: string;
+    text: string;
+    images?: PromptImage[];
+    files?: PromptFile[];
+    inputAnnotations?: DaemonInputAnnotation[];
+    onComplete?: () => void;
+    onAdmitted?: () => void;
+    serverPromptId?: string;
+    serverState?: 'submitting' | 'queued' | 'running';
+    /**
+     * The pending-prompts refresh sequence at the moment a submit body bound
+     * this row to `serverPromptId`; a bind the sync performed itself leaves it
+     * unset. A flight dispatched before that binding may have been served
+     * before the daemon admitted the prompt, so its snapshot can omit the row
+     * without the row having been removed: the sync's retention filter keeps a
+     * row bound at or after that flight's dispatch.
+     */
+    boundAtSeq?: number;
+    /**
+     * Provenance, not state: the daemon refused this message once with
+     * `session_idle`. A row carrying it is confirmed against a pending-prompt
+     * snapshot when it is eventually submitted — immediately, or later when a
+     * hold lifts and the drain releases it — instead of being echoed on the
+     * activity mirror's say-so, which another client's queued prompt can lag.
+     */
+    resubmittedAfterIdleRejection?: boolean;
+    midTurnState?: 'submitting' | 'queued';
+    midTurnMessageId?: string;
+    midTurnFailedAction?: 'delete' | 'edit';
+    isInserting?: boolean;
+    isEditing?: boolean;
+    isRemoving?: boolean;
+    payloadCompleteness?: 'complete' | 'summary-only';
+}
+export declare function QueuedPromptDisplay({ prompts, t, canMutateMidTurn, canInsertMidTurn, onDelete, onInsert, onEdit, onImagePreview, onAttachmentPreview, }: {
+    prompts: readonly QueuedPrompt[];
+    t: ReturnType<typeof getTranslator>;
+    canMutateMidTurn?: boolean;
+    canInsertMidTurn?: boolean;
+    onDelete: (id: number) => void;
+    onInsert: (id: number) => void;
+    onEdit: (id: number) => void;
+    onImagePreview?: (src: string, alt?: string) => void;
+    onAttachmentPreview?: (file: AttachmentPreviewRequest) => void;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/RootErrorFallback.d.ts

@@ -0,0 +1,21 @@
+import type { WebShellLanguage } from '../i18n';
+interface RootErrorFallbackProps {
+    error: Error;
+    onRetry: () => void;
+    /** Selects the fallback copy. Defaults to English when omitted. */
+    language?: WebShellLanguage;
+    /**
+     * What the retry button does, so its label stays honest. Defaults to
+     * 'reset' (an in-place boundary retry); 'reload' is for callers whose
+     * retry navigates (e.g. the standalone root boundary reloads the page).
+     */
+    retryMode?: 'reset' | 'reload';
+}
+/**
+ * Last-resort surface for the top-level boundary. Self-contained (no provider,
+ * theme-token, or i18n dependency) so it survives even when the whole App tree
+ * fails to mount. Offers a retry instead of forcing a host-page reload, which
+ * would be hostile in embedded integrations.
+ */
+export declare function RootErrorFallback({ error, onRetry, language, retryMode, }: RootErrorFallbackProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/SessionOverviewPanel.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonSessionGroupPresetColor, DaemonSessionPrInfo, DaemonSessionSummary, DaemonStatusReportSession } from '@qwen-code/sdk/daemon';
+export type SessionCardStatus = 'needsApproval' | 'askUserQuestion' | 'running' | 'idle';
+export interface SessionCard {
+    sessionId: string;
+    label: string;
+    status: SessionCardStatus;
+    updatedAt?: string;
+    color?: DaemonSessionGroupPresetColor | null;
+    isCurrent: boolean;
+    /** GitHub PRs bound to the session, in binding order (last = latest). */
+    prs?: DaemonSessionPrInfo[];
+    gitBranch?: string;
+    /** The workspace the session lives in. */
+    workspaceCwd: string;
+}
+type SessionIdentity = Pick<SessionCard, 'sessionId' | 'workspaceCwd'>;
+/**
+ * Derive the ranked card set from the session list. The volatile live state
+ * (`hasActivePrompt`, `isWaitingForPermission`, `isWaitingForUserQuestion`)
+ * arrives on the summaries themselves — merged in by the shared session
+ * catalog's live-state channel when the daemon advertises it, and carried on
+ * plain list responses otherwise. `needsApproval` and `askUserQuestion` are
+ * the actionable states (the session is blocked waiting for the user) and take
+ * precedence over `running`. Sorted needs-approval → question → running →
+ * idle, then most-recent first, so sessions that want attention float to the
+ * top of a 10+ session grid.
+ */
+export declare function deriveSessionCards(sessions: DaemonSessionSummary[], currentSessionId: string | undefined, statusSessions?: DaemonStatusReportSession[], currentWorkspaceCwd?: string): SessionCard[];
+/**
+ * A malformed daemon payload must not white-screen the shell; contain any
+ * render throw to the panel, mirroring DaemonStatusDialog.
+ */
+export declare function SessionOverviewPanel({ onOpenSession, onOpenSplit, onCurrentSessionRemoved, includeOtherWorkspaces, workspaceCwd, manageLiveState, }: {
+    onOpenSession: (sessionId: string, workspaceCwd?: string) => void;
+    onOpenSplit?: (sessionIds: string[]) => void;
+    onCurrentSessionRemoved?: (session: SessionIdentity) => Promise<boolean | void> | boolean | void;
+    includeOtherWorkspaces?: boolean;
+    workspaceCwd?: string;
+    manageLiveState?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/SessionPrBadge.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonSessionPrInfo } from '@qwen-code/sdk/daemon';
+interface SessionPrBadgeProps {
+    /** Bound PRs in binding order (last = latest). */
+    prs: DaemonSessionPrInfo[];
+    /**
+     * Override when the badge sits inside a listbox `role="option"` row that
+     * owns roving-tabindex keyboard navigation (e.g. picker dialogs).
+     */
+    tabIndex?: number;
+}
+/**
+ * The `#N (+M)` pull-request badge shared by the sidebar session row, the
+ * session overview card, and the picker dialogs. Renders the latest bound
+ * PR with an overflow count and opens it through the desktop-aware
+ * external-link opener. Non-http(s) bindings are filtered out as a
+ * defense-in-depth measure on top of the daemon-side validators.
+ */
+export declare function SessionPrBadge({ prs, tabIndex }: SessionPrBadgeProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/components/SessionPrStateIcon.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonSessionIssueInfo, DaemonSessionPrInfo } from '@qwen-code/sdk/daemon';
+/**
+ * GitHub-style PR state icon shared by the session-row badge and the session
+ * details tooltip: open=green pull-request, merged=purple merge, closed=red
+ * closed-pull-request. A state-less binding renders the neutral pull-request
+ * glyph with no state color.
+ */
+export declare function SessionPrStateIcon({ state, }: {
+    state?: DaemonSessionPrInfo['state'];
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Localized state name for assistive tech (badge aria-label, tooltip sr-only
+ * text). Only merged/closed carry a label; open and state-less bindings read
+ * as the bare PR reference. Keyed beside STATE_ICONS so a new state forces
+ * both the icon and the label mapping to be updated together.
+ */
+export declare function sessionPrStateLabel(t: (key: string) => string, state?: DaemonSessionPrInfo['state']): string | undefined;
+/**
+ * GitHub-style issue state icon for the issues a bound PR closes:
+ * open=green circle-dot, completed=purple check, not planned=muted slash. A
+ * state-less issue renders the neutral circle-dot glyph.
+ */
+export declare function SessionIssueStateIcon({ state, }: {
+    state?: DaemonSessionIssueInfo['state'];
+}): import("react/jsx-runtime").JSX.Element;
+/** Issue counterpart of {@link sessionPrStateLabel}; open reads as bare. */
+export declare function sessionIssueStateLabel(t: (key: string) => string, state?: DaemonSessionIssueInfo['state']): string | undefined;

package/dist/types/components/SessionRecoveryBanner.d.ts

@@ -0,0 +1,3 @@
+export declare function SessionRecoveryBanner({ blocked, }: {
+    blocked?: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/ShadowDomBoundary.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode, type RefObject } from 'react';
+interface ShadowDomBoundaryProps {
+    children: ReactNode;
+    enabled: boolean;
+    language: string;
+    themeClassName: string;
+    styles?: string;
+    initialFocusRef?: RefObject<HTMLElement | null>;
+}
+export declare function ShadowDomBoundary({ children, enabled, language, themeClassName, styles, initialFocusRef, }: ShadowDomBoundaryProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+export {};

package/dist/types/components/SplitView.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type DaemonSessionActions } from '@qwen-code/web-shell/daemon-react-sdk';
+import type { DaemonSessionArtifact, DaemonSessionMonitorTaskStatus, DaemonWorkspaceCapability } from '@qwen-code/sdk/daemon';
+import type { WebShellSlashCommandHandler } from '../App';
+import type { RegisterContextUsageControls } from '../hooks/useContextUsageControls';
+import { type PaneHeaderActionsRenderer } from './ChatPane';
+import type { TurnOutputKind, TurnOutputOpenRequest } from './artifacts/TurnOutputs';
+export interface SplitViewProps {
+    /** Sessions to show in the split view. */
+    sessionIds?: string[];
+    /** Respect the host's session-details action allowlist. */
+    showSessionDetails?: boolean;
+    /**
+     * Report the live pane set (after every add / remove) up to the parent so it
+     * survives this view unmounting. Switching away from the split and back must
+     * restore exactly the panes the user had, not reseed from a stale selection.
+     * Must be referentially stable (e.g. a `useState` setter) — a fresh callback
+     * each render would re-fire the reporting effect and loop.
+     */
+    onPanesChange?: (sessionIds: string[]) => void;
+    /**
+     * Report panes surfacing approvals, including hidden panes. Keep stable while
+     * consumer inputs are unchanged; a new callback receives the current list.
+     */
+    onPendingPanesChange?: (sessionIds: string[]) => void;
+    /** Leave the split view (back to the single-session chat). */
+    onExit: () => void;
+    onError?: (error: unknown, fallback: string) => void;
+    onImageIngestionNotice?: (tone: 'warning' | 'error', message: string) => void;
+    onSlashCommand?: WebShellSlashCommandHandler;
+    onOpenGoals?: () => void;
+    onRightPanelOpen?: (request: TurnOutputOpenRequest) => void;
+    onOpenMonitor?: (task: DaemonSessionMonitorTaskStatus, sessionId: string, sessionActions: DaemonSessionActions) => void;
+    registerContextUsageControls?: RegisterContextUsageControls;
+    onBeforeContextCompress?: (sessionId: string) => void;
+    onOpenContextUsage?: (sessionId: string, sessionActions: DaemonSessionActions) => void;
+    onPaneArtifactsChange?: (sessionId: string, artifacts: readonly DaemonSessionArtifact[]) => void;
+    messageTurnOutputs?: readonly TurnOutputKind[];
+    /**
+     * Extra actions rendered in each pane header, before the built-in close
+     * button. See `ChatPaneProps.renderHeaderActions`.
+     */
+    renderPaneHeaderActions?: PaneHeaderActionsRenderer;
+    /** Include active sessions from every trusted registered workspace. */
+    includeOtherWorkspaces?: boolean;
+    /** Limit session discovery and pane attachment to this workspace. */
+    workspaceCwd?: string;
+    /** Restart each pane's SSE event stream after an accepted prompt. */
+    restartSseOnPrompt?: boolean;
+    /** Persisted transcript records requested per page by each pane. */
+    historyPageSize?: number;
+    voiceUserRevision?: number;
+    voiceWorkspaceRevisions?: Readonly<Record<string, number>>;
+    voiceWorkspaces?: readonly DaemonWorkspaceCapability[];
+    sessionWorkflowEnabled?: boolean;
+    planControlVisible?: boolean;
+}
+/**
+ * Shows 2+ independent interactive chats side by side in one window. Each pane
+ * is its own `DaemonSessionProvider` (own session, SSE, transcript, approvals),
+ * all sharing the one `DaemonWorkspaceProvider` above the app. Browser focus
+ * naturally scopes the keyboard to the pane the user clicks into, so panes never
+ * fight over which session an approval or Enter belongs to.
+ */
+export declare function SplitView({ sessionIds, showSessionDetails, onPanesChange, onPendingPanesChange, onExit, onError, onImageIngestionNotice, onSlashCommand, onOpenGoals, onRightPanelOpen, onOpenMonitor, onPaneArtifactsChange, registerContextUsageControls, onBeforeContextCompress, onOpenContextUsage, messageTurnOutputs, renderPaneHeaderActions, includeOtherWorkspaces, workspaceCwd, restartSseOnPrompt, historyPageSize, voiceUserRevision, voiceWorkspaceRevisions, voiceWorkspaces, sessionWorkflowEnabled, planControlVisible, }: SplitViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/StandaloneAuth.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+import type { WebShellLanguage } from '../i18n';
+import { type WebShellTheme } from '../themeContext';
+export declare function StandaloneAuth({ baseUrl, initialToken, initialAddress, language, theme, invalidTarget, unconfirmedTarget, onChangeTarget, children, }: {
+    baseUrl: string;
+    initialToken?: string;
+    initialAddress?: string;
+    /** Selects the gate copy. Defaults to English when omitted. */
+    language?: WebShellLanguage;
+    /** Selects the theme palette the app root will apply after mount. */
+    theme?: WebShellTheme;
+    invalidTarget?: boolean;
+    /** The daemon came from a link to an origin this browser has not used. */
+    unconfirmedTarget?: boolean;
+    onChangeTarget?: (daemonOrigin: string, token?: string) => boolean | void;
+    children: (token: string | undefined) => ReactNode;
+}): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;

package/dist/types/components/StatusBar.d.ts

@@ -0,0 +1,26 @@
+import type { DaemonSessionTaskWithWorkflowStatus } from '@qwen-code/sdk/daemon';
+import { useI18n } from '../i18n';
+export interface StatusBarHandle {
+    focusTaskPill(): boolean;
+}
+interface StatusBarProps {
+    onSelectMode: () => void;
+    /** Open the model picker so the model can be chosen with the mouse. */
+    onSelectModel: () => void;
+    /** Show the context-usage breakdown, exactly like typing /context. */
+    onShowContext: () => void;
+    /** Open the settings dialog so settings are reachable with the mouse. */
+    onOpenSettings: () => void;
+    onOpenTasks?: () => void;
+    onReturnToInput?: (text?: string) => void;
+    tasks: readonly DaemonSessionTaskWithWorkflowStatus[];
+    /** Hide the settings gear button (e.g. when /settings is in hiddenSlashCommands). */
+    hideSettings?: boolean;
+    /** Toggle the keyboard-shortcuts panel (same as typing `?` in the editor). */
+    onToggleShortcuts?: () => void;
+    /** Hide secondary footer hints/details for the chat composer layout. */
+    compact?: boolean;
+}
+export declare function getTaskPillLabel(tasks: readonly DaemonSessionTaskWithWorkflowStatus[], t: ReturnType<typeof useI18n>['t']): string;
+export declare const StatusBar: import("react").ForwardRefExoticComponent<StatusBarProps & import("react").RefAttributes<StatusBarHandle>>;
+export {};

package/dist/types/components/StreamingStatus.d.ts

@@ -0,0 +1,20 @@
+interface StreamingStatusProps {
+    startedAt?: number;
+    backgroundLabel?: string;
+    /**
+     * When false, hide the rotating "witty" loading phrase and skip its rotation
+     * timer entirely — the spinner, elapsed time, token count, and cancel hint
+     * still render. Split-view panes pass false to keep each pane's composer
+     * status compact. Defaults to true (the main chat shows the phrase).
+     */
+    showPhrase?: boolean;
+    /**
+     * When true, the daemon reports the session has an in-flight prompt. The
+     * indicator stays visible even while streamingState is idle, so long tool
+     * calls that produce >3s silent gaps do not hide the loading state mid-turn
+     * (#9487). The daemon's session live state is the authoritative source.
+     */
+    hasActivePrompt?: boolean;
+}
+export declare function StreamingStatus({ startedAt, backgroundLabel, showPhrase, hasActivePrompt, }: StreamingStatusProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/components/Tips.d.ts

@@ -0,0 +1 @@
+export declare function Tips(): import("react/jsx-runtime").JSX.Element;