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

package/dist/types/adapters/parallelAgentGrouping.d.ts

@@ -0,0 +1,18 @@
+import type { ACPToolCall, Message } from './types.js';
+export type ParallelAgentDisplayItem = {
+    type: 'message';
+    key: string;
+    message: Message;
+} | {
+    type: 'parallel_agents';
+    key: string;
+    turnId: string;
+    agents: ACPToolCall[];
+    /**
+     * Wall-clock time of the first grouped launch, carried so the grouped
+     * box reveals its time on hover exactly like a standalone message row.
+     */
+    timestamp?: number;
+};
+export declare function isAgentOnlyToolGroup(message: Message): boolean;
+export declare function groupParallelAgents(messages: Message[]): ParallelAgentDisplayItem[];

package/dist/types/adapters/promptTypes.d.ts

@@ -0,0 +1,12 @@
+export interface PromptImage {
+    data: string;
+    media_type: string;
+}
+export interface PromptFile {
+    name: string;
+    media_type: string;
+    data?: Blob;
+    text?: string;
+    size?: number;
+    attachmentId?: string;
+}

package/dist/types/adapters/toolClassification.d.ts

@@ -0,0 +1,10 @@
+import type { ACPToolCall } from './types.js';
+export declare function isActiveToolStatus(status: ACPToolCall['status'] | string): boolean;
+export type TerminalBackgroundAgentStatus = 'completed' | 'failed' | 'cancelled' | 'canceled';
+export declare function isTerminalBackgroundAgentStatus(status: unknown): status is TerminalBackgroundAgentStatus;
+export declare function hasActiveAgents(agents: readonly ACPToolCall[]): boolean;
+export declare function isTaskExecutionRaw(raw: unknown): boolean;
+export declare function isSubAgentToolCall(tool: ACPToolCall): boolean;
+export declare function isBackgroundSubAgentToolCall(tool: ACPToolCall): boolean;
+export declare function projectTerminalBackgroundAgentTool(tool: ACPToolCall, status: unknown, endTime?: number, safeToolProjection?: boolean): ACPToolCall;
+export declare function backgroundShellTaskId(tool: ACPToolCall): string | undefined;

package/dist/types/adapters/transcriptAdapter.d.ts

@@ -0,0 +1,3 @@
+import type { DaemonTranscriptBlock } from '@qwen-code/web-shell/daemon-react-sdk';
+import type { PermissionRequest } from './types';
+export declare function extractPendingPermission(blocks: readonly DaemonTranscriptBlock[]): PermissionRequest | null;

package/dist/types/adapters/transcriptToMessages.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonTranscriptBlock } from '@qwen-code/sdk/daemon';
+import type { DaemonMessage } from './messageTypes.js';
+interface TranscriptMessageLabels {
+    promptCancelled?: string;
+    branchSuccess?: (name: string) => string;
+    modelStreamInterrupted?: string;
+    loopDetected?: string;
+}
+interface TranscriptMessageOptions {
+    labels?: TranscriptMessageLabels;
+    includeSourceIdentity?: boolean;
+    safeToolProjection?: boolean;
+}
+export declare function isRetryableTurnErrorKind(errorKind: string | undefined): boolean;
+export declare function transcriptBlocksToDaemonMessages(blocks: readonly DaemonTranscriptBlock[], options?: TranscriptMessageOptions): DaemonMessage[];
+type ParsedInsight = {
+    type: 'insight_progress';
+    stage: string;
+    progress: number;
+    detail?: string;
+} | {
+    type: 'insight_ready';
+    path: string;
+} | {
+    type: 'insight_error';
+    error: string;
+};
+type InsightSegment = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'insight';
+    data: ParsedInsight;
+};
+export declare function splitInsightSegments(text: string): InsightSegment[] | null;
+export {};

package/dist/types/adapters/types.d.ts

@@ -0,0 +1,123 @@
+import type { DaemonMessage, DaemonMessageToolCall, DaemonMessageToolCallContent, DaemonMessageToolCallStatus, DaemonMessageToolKind, DaemonMessageToolCallLocation, DaemonMessageTodoItem, DaemonAssistantMessage, DaemonInsightErrorMessage, DaemonInsightProgressMessage, DaemonInsightReadyMessage, DaemonPlanMessage, DaemonSystemMessage, DaemonThinkingMessage, DaemonToolGroupMessage, DaemonUserMessage, DaemonUserShellMessage } from './messageTypes.js';
+import type { DaemonStreamingState } from '@qwen-code/web-shell/daemon-react-sdk';
+export type Message = DaemonMessage;
+export type ACPToolCall = DaemonMessageToolCall;
+export type ToolCallContent = DaemonMessageToolCallContent;
+export type ToolCallStatus = DaemonMessageToolCallStatus;
+export type ToolKind = DaemonMessageToolKind;
+export type ToolCallLocation = DaemonMessageToolCallLocation;
+export type TodoItem = DaemonMessageTodoItem;
+export type StreamingState = DaemonStreamingState;
+export type UserMessage = DaemonUserMessage;
+export type AssistantMessage = DaemonAssistantMessage;
+export type ThinkingMessage = DaemonThinkingMessage;
+export type InsightErrorMessage = DaemonInsightErrorMessage;
+export type InsightProgressMessage = DaemonInsightProgressMessage;
+export type InsightReadyMessage = DaemonInsightReadyMessage;
+export type ToolGroupMessage = DaemonToolGroupMessage;
+export type PlanMessage = DaemonPlanMessage;
+export type SystemMessage = DaemonSystemMessage;
+export type UserShellMessage = DaemonUserShellMessage;
+/**
+ * Collapse state attached to a turn's leading user-message row. A "turn" spans
+ * one user message up to (but not including) the next, and when collapsed its
+ * intermediate steps (thinking, tool calls, mid-turn assistant text) are hidden,
+ * leaving only the prompt and the final answer. Carried on the user
+ * `DisplayItem` so the row can render its own expand/collapse toggle.
+ */
+export interface TurnCollapseHead {
+    /** id of the turn's user message; the key used to toggle the turn. */
+    turnId: string;
+    /** whether the turn's intermediate steps are currently hidden. */
+    collapsed: boolean;
+    /** number of display rows hidden behind the toggle while collapsed. */
+    hiddenCount: number;
+    /**
+     * Wall-clock span from the prompt to the turn's last step, in ms. Derived
+     * from block timestamps (so it survives replay); undefined when either end
+     * lacks a timestamp. Approximate — a step's own runtime past its start is not
+     * captured.
+     */
+    elapsedMs?: number;
+    /**
+     * Per-turn token usage, summed from the main assistant messages and root
+     * subagent execution summaries. Both fields are present together or the pair
+     * is undefined (older sessions stamp no usage).
+     */
+    inputTokens?: number;
+    outputTokens?: number;
+    /** Cached-read tokens — a subset of inputTokens, surfaced only when > 0. */
+    cachedTokens?: number;
+    /** Number of tool calls shown in this turn. */
+    toolCallCount?: number;
+    /** Number of assistant thinking blocks shown in this turn. */
+    thinkingCount?: number;
+    /**
+     * Prompt wall-clock (ms) for a still-running turn. Present only while the turn
+     * is active; the row ticks `now - liveStartedAt` once a second so the elapsed
+     * advances smoothly instead of jumping per step. Absent once complete, when
+     * the frozen `elapsedMs` is shown.
+     */
+    liveStartedAt?: number;
+}
+export interface ContentBlock {
+    type: 'text' | 'image';
+    text?: string;
+    source?: {
+        type: string;
+        media_type: string;
+        data: string;
+    };
+}
+export type PermissionOptionKind = 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
+export interface PermissionOption {
+    id: string;
+    label: string;
+    kind?: PermissionOptionKind;
+}
+export interface PermissionRequest {
+    id: string;
+    sessionId?: string;
+    toolCallId?: string;
+    title?: string;
+    toolKind?: string;
+    /** Canonical tool name (from the ACP frame's `_meta.toolName`). */
+    toolName?: string;
+    /** Whether this permission includes a diff the host can preview. */
+    hasDiffPreview?: boolean;
+    todoPlan?: {
+        planId: string;
+        sourceCallId: string;
+    };
+    content: ContentBlock[];
+    options: PermissionOption[];
+    contentIsInput?: boolean;
+    rawInput?: Record<string, unknown>;
+    kind?: string;
+}
+export interface CommandInfo {
+    name: string;
+    description: string;
+    completionLabel?: string;
+    completionSection?: string;
+    completionPriority?: number;
+    argumentHint?: string;
+    subcommands?: string[];
+    source?: string;
+    displayCategory?: 'custom' | 'skill' | 'system';
+    autoSubmit?: boolean;
+}
+export interface ModelInfo {
+    id: string;
+    baseModelId?: string;
+    label?: string;
+    authType?: string;
+    contextWindow?: number;
+    modalities?: {
+        image?: boolean;
+        pdf?: boolean;
+        audio?: boolean;
+        video?: boolean;
+    };
+    isRuntime?: boolean;
+}

package/dist/types/brandContext.d.ts

@@ -0,0 +1,44 @@
+import { type ReactNode } from 'react';
+/**
+ * Product branding the shell presents. An empty value means "use the built-in
+ * brand", so a deployment that configures nothing renders exactly what it
+ * rendered before branding was configurable.
+ */
+export interface WebShellBrand {
+    /**
+     * Product name. Absent *or empty* means {@link DEFAULT_BRAND_NAME} — the
+     * settings surface documents an empty value as "use the built-in name", and a
+     * host mirroring that convention must not blank the sidebar.
+     */
+    name?: string;
+    /**
+     * Logo node rendered in place of the built-in mark. Only an embedding host
+     * can supply this; the daemon-resolved brand carries `logoDataUri` instead.
+     */
+    logo?: ReactNode;
+    /**
+     * Logo as a `data:image/svg+xml` URI.
+     *
+     * Always render it as an `img` src, never as injected markup. SVG loaded as
+     * an image cannot run script; SVG injected into the document can, and the
+     * daemon does not sanitize the file it read. This is the invariant that makes
+     * the absence of a sanitizer on the server correct.
+     */
+    logoDataUri?: string;
+}
+export declare const DEFAULT_BRAND_NAME = "Qwen Code";
+/**
+ * The payload of `onBrandResolved` — the subset of `WebShellBrand` a host
+ * document can act on. `logo` (a React node) is deliberately absent: a document
+ * can apply a title and a favicon URI but never renders a node, and the node
+ * has no stable identity to key a change notification on.
+ */
+export type WebShellResolvedBrand = Pick<WebShellBrand, 'name' | 'logoDataUri'>;
+/**
+ * Stable identity for "no brand configured". Returning a fresh `{}` from a hook
+ * would change the provider value on every render and re-render every consumer.
+ */
+export declare const EMPTY_BRAND: WebShellBrand;
+export declare const BrandProvider: import("react").Provider<WebShellBrand>;
+export declare function useBrand(): WebShellBrand;
+export declare function useBrandName(): string;

package/dist/types/browser-turn-notifications.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type ReactNode } from 'react';
+import { type WebShellLanguage } from './i18n';
+export declare const BROWSER_NOTIFICATIONS_STORAGE_KEY = "qwen-code-web-shell-browser-notifications";
+export interface WebShellBrowserNotificationsOptions {
+    /** Initial preference when none is saved. Defaults to false; never requests permission automatically. */
+    defaultEnabled?: boolean;
+    /** Application name prefixed to notification titles. Defaults to QwenCode. */
+    appName?: string;
+    /** Image URL, including HTTPS CDN URLs. Defaults to the bundled Qwen Code icon. */
+    iconUrl?: string;
+}
+interface BrowserTurnNotificationsProps {
+    children: ReactNode;
+    language: WebShellLanguage;
+    options?: WebShellBrowserNotificationsOptions;
+    active?: boolean;
+}
+type Permission = NotificationPermission | 'unavailable';
+interface BrowserNotificationSettings {
+    enabled: boolean;
+    permission: Permission;
+    pending: boolean;
+    persistent: boolean;
+    error: boolean;
+    setEnabled(enabled: boolean): Promise<void>;
+    refreshPermission(): void;
+    syncLanguage(language: WebShellLanguage): void;
+}
+export declare function useBrowserNotificationSettings(): BrowserNotificationSettings | undefined;
+export declare function BrowserTurnNotifications({ children, language, options, active, }: BrowserTurnNotificationsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/completions/slashCompletion.d.ts

@@ -0,0 +1,35 @@
+import type { CompletionContext, CompletionResult } from '@codemirror/autocomplete';
+import type { CommandInfo } from '../adapters/types';
+import type { WebShellLanguage } from '../i18n';
+import { type CommandDisplayCategory, type CommandDisplayCategoryOrder } from '../utils/commandDisplay';
+export interface SkillInfo {
+    name: string;
+    description: string;
+    argumentHint?: string;
+}
+export type SlashCommandCompletionKind = 'command' | 'subcommand';
+export interface SlashCommandCompletionItem {
+    id: string;
+    label: string;
+    apply: string;
+    detail?: string;
+    argumentHint?: string;
+    category?: CommandDisplayCategory;
+    section?: string;
+    type?: 'command-info' | 'skill';
+    autoSubmit?: boolean;
+}
+export interface SlashCommandCompletionResult {
+    kind: SlashCommandCompletionKind;
+    from: number;
+    to: number;
+    query: string;
+    items: SlashCommandCompletionItem[];
+}
+type Translate = (key: string) => string;
+export declare function getMissingSlashPrefixCompletion(text: string, commands: CommandInfo[]): string | null;
+export declare function getImplicitTabCompletion(text: string, commands: CommandInfo[], language: WebShellLanguage): string | null;
+export declare function getSlashCommandArgumentHint(text: string, commands: CommandInfo[], language: WebShellLanguage): string | null;
+export declare function getSlashCommandCompletionResult(text: string, cursor: number, commands: CommandInfo[], skills?: SkillInfo[], language?: WebShellLanguage, translate?: Translate, categoryOrder?: CommandDisplayCategoryOrder, includeEmpty?: boolean): SlashCommandCompletionResult | null;
+export declare function slashCompletionSource(getCommands: () => CommandInfo[], getSkills?: () => SkillInfo[], getLanguage?: () => WebShellLanguage, translate?: Translate, getCategoryOrder?: () => CommandDisplayCategoryOrder | undefined): (context: CompletionContext) => CompletionResult | null;
+export {};

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

@@ -0,0 +1,13 @@
+import { type RefObject } from 'react';
+import { type AtMentionMenuState } from '../hooks/useAtMentionMenu';
+export declare function AtMentionPanel({ menu, anchorRef, panelRef, compact, onSelect, onAccept, onBack, onSearch, onSelectTab, }: {
+    menu: AtMentionMenuState;
+    anchorRef: RefObject<HTMLElement | null>;
+    panelRef: RefObject<HTMLDivElement | null>;
+    compact?: boolean;
+    onSelect: (index: number) => boolean;
+    onAccept: (index?: number) => boolean;
+    onBack: () => boolean;
+    onSearch: (query: string) => boolean;
+    onSelectTab: (tabId: string) => boolean;
+}): import("react").ReactPortal | null;

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

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonGitBranchesResult, DaemonWorkspaceGitStatus } from '@qwen-code/sdk/daemon';
+import { useI18n } from '../i18n';
+export declare const GIT_REMOTE_MUTATION_FETCH_TIMEOUT_MS = 600000;
+interface BranchPickerPopoverProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    workspaceCwd: string;
+    gitCwd?: string;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    onBranchChanged?: () => void;
+    /**
+     * Working-tree summary from the trigger chip. Seeds the hints beside the
+     * Update / Commit / Push actions (dirty counts, in-progress operation) until
+     * the popover's own on-open fetch lands; whichever of the two carries the
+     * newer `computedAt` wins.
+     */
+    status?: DaemonWorkspaceGitStatus;
+    /**
+     * Receives the status the popover fetches for itself on open, so a caller
+     * that renders a chip from the same object can update it in step.
+     */
+    onStatusRefreshed?: (status: DaemonWorkspaceGitStatus) => void;
+    onOpenDiff?: () => void;
+    onOpenCommit?: () => void;
+    children: React.ReactNode;
+}
+type HintTone = 'muted' | 'info' | 'warning';
+interface ActionHint {
+    text: string;
+    tone: HintTone;
+}
+interface ActionHints {
+    pull?: ActionHint;
+    pullDisabled: boolean;
+    commit?: ActionHint;
+    push?: ActionHint;
+    pushDisabled: boolean;
+}
+type TranslateFn = ReturnType<typeof useI18n>['t'];
+/**
+ * Derive the per-action hints shown beside Update / Commit / Push so the user
+ * can judge before clicking.
+ *
+ * Disabling is reserved for what is provable from the local repository
+ * alone: `git pull` during a merge/rebase/cherry-pick, with unmerged
+ * entries, on a detached HEAD, or without a usable upstream; `git push` only
+ * on a detached HEAD. Whether a remote will accept a push is *not* locally
+ * decidable — the destination depends on config git itself sometimes
+ * declines to resolve (`push.default=simple` in triangular shapes),
+ * `remote.<name>.push` refspecs and forcing refspecs change the answer, and
+ * every count is a snapshot of the last fetch — so a push the counts call
+ * doomed is warned about on an enabled row, and the click surfaces git's own
+ * authoritative message. Soft states (up to date, nothing to push, clean
+ * tree) only dim the row since the action is still harmless.
+ *
+ * The branch listing (fetched on open) provides ahead/behind/upstream; the
+ * status provides the tree counters and the in-progress operation. When the
+ * listing has no head entry the status fills in. Exported for tests.
+ */
+export declare function deriveActionHints(t: TranslateFn, data: DaemonGitBranchesResult | null, status: DaemonWorkspaceGitStatus | undefined): ActionHints;
+/**
+ * True when a status disagrees with the branch listing on a field the hints
+ * take from the listing — the signal that the listing is stale and should be
+ * re-fetched. Exported for tests.
+ */
+export declare function listingContradictsStatus(data: DaemonGitBranchesResult, status: DaemonWorkspaceGitStatus): boolean;
+export declare function BranchPickerPopover({ open, onOpenChange, workspaceCwd, gitCwd, side, onBranchChanged, status, onStatusRefreshed, onOpenDiff, onOpenCommit, children, }: BranchPickerPopoverProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+interface ChatContextHeaderProps {
+    content: ReactNode;
+    environmentOpen: boolean;
+    environmentAvailable: boolean;
+    rightPanelOpen: boolean;
+    rightPanelAvailable: boolean;
+    onToggleEnvironment: () => void;
+    onToggleRightPanel: () => void;
+    /** Opens the session token-usage panel; hidden when omitted. */
+    onOpenTokenUsage?: () => void;
+    /** Opens the session context panel; hidden when omitted. */
+    onOpenContextUsage?: () => void;
+    /** Shows the Local Control QR entry; hidden when omitted. */
+    onOpenLocalControlSettings?: () => void;
+}
+export declare function ChatContextHeader({ content, environmentOpen, environmentAvailable, rightPanelOpen, rightPanelAvailable, onToggleEnvironment, onToggleRightPanel, onOpenTokenUsage, onOpenContextUsage, onOpenLocalControlSettings, }: ChatContextHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,134 @@
+import type { CommandInfo } from '../adapters/types';
+import type { AttachmentPreviewRequest } from '../adapters/messageTypes';
+import type { UseDaemonFollowupSuggestionReturn } from '@qwen-code/web-shell/daemon-react-sdk';
+import type { DaemonSessionGroupPresetColor, DaemonWorkspaceGitStatus, ReasoningSelection } from '@qwen-code/sdk/daemon';
+import type { CommandDisplayCategoryOrder } from '../utils/commandDisplay';
+import type { SkillInfo } from '../completions/slashCompletion';
+import type { DaemonReasoningControls } from '@qwen-code/web-shell/daemon-react-sdk';
+import { type WebShellComposerInput, type WebShellComposerTagIconMap, type WebShellAtProvider, type WebShellBuiltinAtProvidersConfig } from '../customization';
+import { type ComposerSubmitMetadata, type EditorHandle } from '../hooks/useComposerCore';
+import type { ContextUsageControls } from '../hooks/useContextUsageControls';
+import type { VoiceStatusRevision, VoiceWorkspaceTarget } from '../voice/voice-workspace-target';
+import { type SessionGitIntent } from './GitModePopover';
+export type ComposerToolbarAction = 'approvalMode' | 'plan' | 'contextUsage' | 'gitBranch' | 'model' | 'commands' | 'files' | 'widthMode' | 'voice' | 'workspace' | 'addMenu';
+interface ChatEditorProps {
+    onSubmit: (text: string, images?: import('../adapters/promptTypes').PromptImage[], files?: import('../adapters/promptTypes').PromptFile[], commitAccepted?: import('../hooks/useComposerCore').ComposerSubmitCommit, metadata?: ComposerSubmitMetadata) => boolean | void;
+    onInputTextChange?: (text: string) => void;
+    onAttachmentsChange?: (hasAttachments: boolean) => void;
+    onCycleMode?: () => void;
+    cycleModeOnTab?: boolean;
+    onToggleShortcuts?: () => void;
+    onCancel?: () => void;
+    isRunning?: boolean;
+    isPreparing?: boolean;
+    /** First Esc armed a cancel — the send button shows an "Esc to stop" hint. */
+    cancelArmed?: boolean;
+    disabled?: boolean;
+    placeholderText?: string;
+    commands: CommandInfo[];
+    skills?: SkillInfo[];
+    onSkillsOpenChange?: (open: boolean) => void;
+    skillsLoading?: boolean;
+    skillsLoadError?: boolean;
+    skillsLoaded?: boolean;
+    slashCommandCategoryOrder?: CommandDisplayCategoryOrder;
+    autoSubmitSlashCommands?: boolean;
+    queuedMessages?: string[];
+    onPopQueuedMessages?: () => boolean;
+    onClearQueuedMessages?: () => boolean;
+    currentMode?: string;
+    planMode?: boolean;
+    modeControlsDisabled?: boolean;
+    onTogglePlan?: () => void;
+    sessionWorkflowEnabled?: boolean;
+    currentModel?: string;
+    gitBranch?: string;
+    /** Whether the session is in a worktree (styles the git chip purple). */
+    gitWorktree?: boolean;
+    /** Git working directory for worktree sessions; targets git operations. */
+    gitCwd?: string;
+    /** Git mode intent for the empty-state composer chip (branch/worktree selection). */
+    gitModeIntent?: SessionGitIntent;
+    /** Callback when the user changes the git mode intent via the composer chip popover. */
+    onGitModeIntentChange?: (intent: SessionGitIntent) => void;
+    /** Enriched working-tree summary (dirty / ahead-behind / stash / operation). */
+    gitStatus?: DaemonWorkspaceGitStatus;
+    /** Opens the working-tree Changes dialog; makes the git chip clickable. */
+    onOpenGitDiff?: () => void;
+    /** Opens the commit dialog. */
+    onOpenCommit?: () => void;
+    /** Workspace name shown in the pane composer's `workspace` toolbar chip. */
+    workspaceName?: string;
+    /** Full workspace cwd, used as the chip's tooltip. */
+    workspaceTitle?: string;
+    /**
+     * Stable per-workspace accent color for the chip, so it stays distinguishable
+     * from other panes' chips even when it collapses to an icon on a narrow split.
+     */
+    workspaceColor?: DaemonSessionGroupPresetColor;
+    chatWidthMode?: '1000' | 'wide';
+    showChatWidthToggle?: boolean;
+    chatWidthToggleMin?: number;
+    visibleToolbarActions?: readonly ComposerToolbarAction[];
+    /** Current context-window occupancy for the `contextUsage` toolbar ring. */
+    tokenCount?: number;
+    contextWindow?: number;
+    /** Keep Context Usage available before a restored session reports usage. */
+    contextUsageAlwaysVisible?: boolean;
+    /** Show the context-usage breakdown, exactly like typing /context. */
+    onShowContextUsage?: () => void;
+    onOpenContextUsage?: () => void;
+    contextUsageControls?: ContextUsageControls;
+    availableModels?: Array<{
+        id: string;
+        label?: string;
+    }>;
+    onSelectMode?: (mode: string) => void;
+    onSelectModel?: (model: string) => void;
+    reasoning?: DaemonReasoningControls;
+    onSelectReasoningEffort?: (value: ReasoningSelection, source?: 'toggle') => Promise<void> | void;
+    workspaces?: Array<{
+        id: string;
+        cwd: string;
+        label: string;
+        primary: boolean;
+        trusted: boolean;
+    }>;
+    selectedWorkspaceCwd?: string;
+    workspaceSelectionDisabled?: boolean;
+    onSelectWorkspace?: (workspaceCwd: string | undefined) => void;
+    scratchWorkspaceSupported?: boolean;
+    existingFolderWorkspaceSupported?: boolean;
+    standaloneTargetSupported?: boolean;
+    selectedStandaloneTarget?: boolean;
+    onSelectStandaloneTarget?: () => void;
+    workspaceMutationBusy?: boolean;
+    onCreateScratchWorkspace?: () => void;
+    onOpenExistingWorkspace?: () => void;
+    atWorkspaceCwd?: string;
+    composerScopeKey?: string;
+    workspaceFeaturesEnabled?: boolean;
+    attachmentsEnabled?: boolean;
+    onChatWidthModeChange?: (mode: '1000' | 'wide') => void;
+    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[];
+    composerTagIcons?: WebShellComposerTagIconMap;
+    voiceTarget?: VoiceWorkspaceTarget;
+    voiceStatusRevision?: VoiceStatusRevision;
+    onImageIngestionNotice?: (tone: 'warning' | 'error', message: string) => void;
+    /** Click a pasted image in the composer to preview it in the right panel. */
+    onImagePreview?: (src: string, alt?: string) => void;
+    onAttachmentPreview?: (file: AttachmentPreviewRequest) => void;
+    compactOverlays?: boolean;
+}
+export declare const ChatEditor: import("react").NamedExoticComponent<ChatEditorProps & import("react").RefAttributes<EditorHandle>>;
+export {};