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

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

@@ -0,0 +1,25 @@
+export type ToastTone = 'info' | 'warning' | 'error' | 'success';
+/** Window event that asks the app-level toast host to show a toast. Lets
+ * deeply nested components (markdown links, artifact actions) report failures
+ * without prop-drilling the toast callback. */
+export declare const TOAST_REQUEST_EVENT = "qwen:toast-request";
+export interface ToastRequestDetail {
+    tone: ToastTone;
+    message: string;
+}
+export declare function requestToast(tone: ToastTone, message: string): void;
+export interface WebShellToast {
+    id: string;
+    tone: ToastTone;
+    message: string;
+    /** Epoch ms when the toast auto-dismisses; survives host remounts. */
+    dismissAt: number;
+}
+interface ToastHostProps {
+    toasts: readonly WebShellToast[];
+    onDismiss: (id: string) => void;
+    /** Paint above dialog-backdrop-tier surfaces (fullscreen artifact panel). */
+    elevated?: boolean;
+}
+export declare function ToastHost({ toasts, onDismiss, elevated, }: ToastHostProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type MessageListHandle, type MessageListProps } from './MessageList';
+export interface TurnFollowRange {
+    start: number;
+    end: number;
+    current: number;
+}
+export declare function followRangeFromRows(rows: readonly {
+    top: number;
+    bottom: number;
+    ordinal?: number;
+}[], viewportTop: number, viewportBottom: number): TurnFollowRange | undefined;
+export declare const TranscriptViewport: import("react").ForwardRefExoticComponent<MessageListProps & import("react").RefAttributes<MessageListHandle>>;

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

@@ -0,0 +1,38 @@
+import '../styles/globals.css';
+import 'katex/dist/katex.min.css';
+import { type CSSProperties, type ReactElement } from 'react';
+import type { DaemonTranscriptBlock, SessionSource, DaemonSessionAttachmentReference } from '@qwen-code/sdk/daemon';
+import { type AssistantTurnFooterRenderer, type WebShellArtifactCustomization, type ComposerTagRenderer, type MarkdownTableMode, type ToolHeaderExtraRenderer, type UserMessageContentParser, type UserMessageContentRenderer, type WebShellComposerTagIconMap, type WebShellMarkdownCustomization, type WebShellSource, type WebShellSourceReference, type WebShellSourceIconResolver } from '../customization';
+import { type WebShellTheme } from '../themeContext';
+export interface WebShellTranscriptProps {
+    blocks: readonly DaemonTranscriptBlock[];
+    renderMode?: 'readonly' | 'document';
+    theme?: WebShellTheme;
+    language?: 'en' | 'zh-CN' | 'zh' | 'zh-cn';
+    className?: string;
+    style?: CSSProperties;
+    chatMaxWidth?: number;
+    workspaceCwd?: string;
+    compactThinking?: boolean;
+    documentExpanded?: boolean;
+    collapseCompletedTurns?: boolean;
+    markdownTableMode?: MarkdownTableMode;
+    virtualScrollThreshold?: number;
+    markdown?: WebShellMarkdownCustomization;
+    sourceSessionId?: string;
+    sources?: readonly SessionSource[];
+    sourceAttachments?: readonly DaemonSessionAttachmentReference[];
+    sourceReferences?: readonly WebShellSourceReference[];
+    getAssistantSourcesIcon?: WebShellSourceIconResolver;
+    onSourceOpen?: (source: WebShellSource) => void;
+    composerTagIcons?: WebShellComposerTagIconMap;
+    renderToolHeaderExtra?: ToolHeaderExtraRenderer;
+    artifact?: WebShellArtifactCustomization;
+    parseUserMessageContent?: UserMessageContentParser;
+    renderUserMessageContent?: UserMessageContentRenderer;
+    renderComposerTag?: ComposerTagRenderer;
+    renderComposerTagTooltip?: ComposerTagRenderer;
+    renderAssistantTurnFooter?: AssistantTurnFooterRenderer;
+    mcpAppBaseUrl?: string;
+}
+export declare function WebShellTranscript(props: WebShellTranscriptProps): ReactElement;

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

@@ -0,0 +1,8 @@
+export interface WelcomeHeaderProps {
+    version: string;
+    cwd: string;
+    currentModel: string;
+    currentMode: string;
+    hideTips?: boolean;
+}
+export declare function WelcomeHeader(props: WelcomeHeaderProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonSessionGroupPresetColor } from '@qwen-code/sdk/daemon';
+/**
+ * A compact, non-interactive chip naming the workspace a split-view pane's
+ * session belongs to. Mirrors {@link GitBranchIndicator}; both sit in the
+ * composer toolbar. Shown only on a multi-workspace daemon (the pane composer
+ * opts into the `workspace` toolbar action) so it's clear which workspace a
+ * message goes to. The full cwd stays in a hover tooltip — matching the git
+ * branch chip — so it's still discoverable once the name ellipsizes or
+ * collapses to an icon on a narrow (split-screen / mobile) composer.
+ *
+ * A stable per-workspace `color` (same palette as the pane header and the
+ * sidebar session-group dots) tints the folder icon and the chip background, so
+ * the chip stays distinguishable from other panes' chips even in the icon-only
+ * compact state — where every workspace would otherwise show the same folder.
+ */
+export declare function WorkspaceIndicator({ name, title, ariaLabel, color, compact, }: {
+    name: string;
+    title: string;
+    ariaLabel: string;
+    color?: DaemonSessionGroupPresetColor;
+    compact?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,29 @@
+export interface WorkspaceSelectorOption {
+    id: string;
+    cwd: string;
+    label: string;
+    primary: boolean;
+    trusted: boolean;
+}
+interface WorkspaceSelectorProps {
+    workspaces: WorkspaceSelectorOption[];
+    selectedWorkspaceCwd?: string;
+    disabled?: boolean;
+    busy?: boolean;
+    scratchSupported: boolean;
+    existingFolderSupported: boolean;
+    /** Offer a projectless (standalone) target alongside the workspaces. */
+    standaloneSupported?: boolean;
+    selectedStandalone?: boolean;
+    className?: string;
+    onSelectWorkspace: (cwd: string | undefined) => void;
+    onSelectStandalone?: () => void;
+    onCreateScratch: () => void;
+    onOpenExistingFolder: () => void;
+}
+/**
+ * Composer workspace menu. Capability-gated creation actions and disabled
+ * untrusted entries keep presentation aligned with daemon authorization.
+ */
+export declare function WorkspaceSelector({ workspaces, selectedWorkspaceCwd, disabled, busy, scratchSupported, existingFolderSupported, standaloneSupported, selectedStandalone, className, onSelectWorkspace, onSelectStandalone, onCreateScratch, onOpenExistingFolder, }: WorkspaceSelectorProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,19 @@
+import { type DaemonProductSessionContext } from '@qwen-code/web-shell/daemon-react-sdk';
+import { type WebShellProps } from '../App';
+import { type WebShellLanguage } from '../i18n';
+import { type WebShellTheme } from '../themeContext';
+interface WorkspaceSessionProviderProps {
+    sessionId?: string;
+    workspaceId?: string;
+    workspaceCwd?: string;
+    sessionContext?: DaemonProductSessionContext;
+    lockWorkspaceCwd?: string;
+    clientId?: string;
+    restartSseOnPrompt?: boolean;
+    historyPageSize?: number;
+    chromeTheme?: WebShellTheme;
+    chromeLanguage?: WebShellLanguage;
+    webShellProps: WebShellProps;
+}
+export declare function WorkspaceSessionProvider(props: WorkspaceSessionProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react';
+interface WorkspaceUnavailableStateProps {
+    title: string;
+    description: string;
+    actionLabel?: string;
+    onAction?: () => void;
+    theme?: 'dark' | 'light';
+    icon?: ReactNode;
+}
+export declare function WorkspaceUnavailableState({ title, description, actionLabel, onAction, theme, icon, }: WorkspaceUnavailableStateProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/agents/AgentCreatePage.d.ts

@@ -0,0 +1,9 @@
+import { type DaemonWorkspaceAgentDetail } from '@qwen-code/web-shell/daemon-react-sdk';
+interface AgentCreatePageProps {
+    initialScope?: 'workspace' | 'global';
+    agent?: DaemonWorkspaceAgentDetail;
+    onCancel: () => void;
+    onCreated: (name: string) => void;
+}
+export declare function AgentCreatePage({ initialScope, agent, onCancel, onCreated, }: AgentCreatePageProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/agents/AgentsManagerPage.d.ts

@@ -0,0 +1,8 @@
+import type { EmbeddedManagerPage } from '../plugins/manager-page';
+interface AgentsManagerPageProps {
+    onClose: () => void;
+    embedded?: EmbeddedManagerPage;
+    initialCreateScope?: 'workspace' | 'global' | null;
+}
+export declare function AgentsManagerPage({ onClose, embedded, initialCreateScope, }: AgentsManagerPageProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/agents/agent-tool-options.d.ts

@@ -0,0 +1,9 @@
+import type { DaemonWorkspaceMcpToolStatus, DaemonWorkspaceToolStatus } from '@qwen-code/web-shell/daemon-react-sdk';
+export declare function canAddSelection(selection: ReadonlySet<string>, value: string): boolean;
+export declare function selectBuiltInTools(tools: DaemonWorkspaceToolStatus[], mcpTools: Record<string, DaemonWorkspaceMcpToolStatus[]>): DaemonWorkspaceToolStatus[];
+export declare function selectDiscoverableMcpServerNames(servers: Array<{
+    name: string;
+    disabled: boolean;
+    status: string;
+    mcpStatus?: 'connected' | 'connecting' | 'disconnected';
+}>): string[];

package/dist/types/components/agents/agents-manager-logic.d.ts

@@ -0,0 +1,8 @@
+import type { DaemonWorkspaceAgentSummary } from '@qwen-code/web-shell/daemon-react-sdk';
+export type AgentLevelFilter = 'all' | DaemonWorkspaceAgentSummary['level'];
+export type AgentSelection = Pick<DaemonWorkspaceAgentSummary, 'name' | 'level'>;
+export declare function filterAgents(agents: readonly DaemonWorkspaceAgentSummary[], query: string, level?: AgentLevelFilter): DaemonWorkspaceAgentSummary[];
+export declare function preserveAgentSelection(selection: AgentSelection | null, agents: readonly DaemonWorkspaceAgentSummary[]): DaemonWorkspaceAgentSummary | null;
+export declare function isOverridden(agent: DaemonWorkspaceAgentSummary, allAgents: readonly DaemonWorkspaceAgentSummary[]): boolean;
+export declare function canModifyAgent(agent: DaemonWorkspaceAgentSummary): boolean;
+export declare function scopeForLevel(level: string): 'workspace' | 'global' | undefined;

package/dist/types/components/artifacts/AgentWorkflow.d.ts

@@ -0,0 +1,7 @@
+import type { EnvironmentAgentTask } from '../panels/EnvironmentPanel';
+export declare function AgentWorkflow({ tasks, loading, error, onOpenAgent, }: {
+    tasks: readonly EnvironmentAgentTask[];
+    loading?: boolean;
+    error?: string;
+    onOpenAgent?: (task: EnvironmentAgentTask) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/artifacts/ArtifactIcon.d.ts

@@ -0,0 +1,9 @@
+import type { DaemonSessionArtifact } from '@qwen-code/sdk/daemon';
+import type { ReactNode } from 'react';
+export type ArtifactIconKind = 'csv' | 'file' | 'html' | 'image' | 'link' | 'md' | 'pdf' | 'spreadsheet' | 'video' | 'word';
+export declare const ARTIFACT_ICON_URLS: Readonly<Record<ArtifactIconKind, string>>;
+export declare function getArtifactIconKind(artifact?: Pick<DaemonSessionArtifact, 'kind' | 'title' | 'workspacePath' | 'url' | 'mimeType'>): ArtifactIconKind;
+export declare function ArtifactIcon({ artifact, className, }: {
+    artifact?: DaemonSessionArtifact;
+    className?: string;
+}): ReactNode;

package/dist/types/components/artifacts/ArtifactPanel.d.ts

@@ -0,0 +1,229 @@
+import type { DaemonSessionArtifact, SessionSource, DaemonSessionMonitorTaskStatus, DaemonSessionShellTaskStatus, DaemonSessionTaskStatus } from '@qwen-code/sdk/daemon';
+import type { ACPToolCall, TodoItem } from '../../adapters/types';
+import type { WebShellRightPanelItem } from '../../customization';
+import { type DaemonSessionOwnerSnapshot, type DaemonSessionActions } from '@qwen-code/web-shell/daemon-react-sdk';
+import { type TurnOutputFileChange, type TurnOutputOpenRequest, type TurnOutputScheduledTask } from './TurnOutputs';
+import type { EnvironmentAgentTask } from '../panels/EnvironmentPanel';
+import type { WebPreviewState } from '../preview/web-preview';
+import type { ContextUsageControls } from '../../hooks/useContextUsageControls';
+export type ImageTabSource = {
+    kind: 'attachment';
+    attachmentId: string;
+    sessionId?: string;
+};
+export type ArtifactPanelTab = (WebPreviewState & {
+    id: string;
+    kind: 'web_preview';
+    title: string;
+}) | {
+    id: string;
+    kind: 'source';
+    title: string;
+    source: SessionSource;
+    sourceSessionId: string;
+    workspaceCwd?: string;
+    workspaceId?: string;
+    owner: DaemonSessionOwnerSnapshot;
+    sessionActions: DaemonSessionActions;
+} | {
+    id: string;
+    kind: 'review';
+    title: string;
+    workspaceCwd?: string;
+    workspaceId?: string;
+    changes?: readonly TurnOutputFileChange[];
+    selectedPath?: string;
+    sourceTurnId?: string;
+    sourceSessionId?: string;
+    sourceToolCallIds?: readonly string[];
+} | {
+    id: string;
+    kind: 'file';
+    title: string;
+    previewVersion?: number;
+    workspacePath: string;
+    workspaceCwd?: string;
+    workspaceId?: string;
+    previewContent?: string;
+    previewData?: Blob;
+    previewMimeType?: string;
+    previewOnly?: boolean;
+    sourcePreview?: boolean;
+    sourceSessionId?: string;
+    /**
+     * Set for attachment-backed previews so the tab can re-fetch its bytes
+     * after a reload instead of persisting the Blob.
+     */
+    attachmentId?: string;
+    loadError?: string;
+} | {
+    id: string;
+    kind: 'artifact';
+    title: string;
+    artifactId: string;
+    workspaceCwd?: string;
+    workspaceId?: string;
+    sourceSessionId?: string;
+    previewContent?: string;
+} | {
+    id: string;
+    kind: 'scheduled_task';
+    title: string;
+    task: TurnOutputScheduledTask;
+    workspaceCwd?: string;
+    workspaceId?: string;
+    sourceSessionId?: string;
+} | {
+    id: string;
+    kind: 'image';
+    title: string;
+    src: string;
+    alt?: string;
+    /**
+     * Where the image bytes come from, so the tab can be rehydrated after a
+     * reload without persisting the data URL itself.
+     */
+    source?: ImageTabSource;
+    loadError?: string;
+} | {
+    id: string;
+    kind: 'subagent';
+    title: string;
+    sessionId: string;
+    rootToolCallId: string;
+    rootTool: ACPToolCall;
+    workspaceCwd?: string;
+} | {
+    id: string;
+    kind: 'pending';
+    title: string;
+    targetKind: 'review' | 'artifact' | 'scheduled_task' | 'subagent' | 'monitor' | 'shell';
+    sourceSessionId: string;
+    sourceTurnId?: string;
+    sourceToolCallIds?: readonly string[];
+    artifactId?: string;
+    selectedPath?: string;
+    toolCallId?: string;
+    rootToolCallId?: string;
+    taskId?: string;
+    workspaceCwd?: string;
+    workspaceId?: string;
+    loadError?: string;
+} | {
+    id: string;
+    kind: 'monitor';
+    title: string;
+    task: DaemonSessionMonitorTaskStatus;
+    sessionId?: string;
+    sessionActions?: DaemonSessionActions;
+} | {
+    id: string;
+    kind: 'shell';
+    title: string;
+    task: DaemonSessionShellTaskStatus;
+    sessionId?: string;
+    sessionActions?: DaemonSessionActions;
+} | {
+    id: string;
+    kind: 'side_task';
+    title: string;
+    sessionId?: string;
+    parentSessionId: string;
+    workspaceCwd?: string;
+    nameFromFirstPrompt?: boolean;
+    initialPrompt?: string;
+} | {
+    id: string;
+    kind: 'terminal';
+    title: string;
+    workspaceCwd?: string;
+    initialized?: boolean;
+} | {
+    id: string;
+    kind: 'token_usage';
+    title: string;
+    sessionId?: string;
+    sessionActions?: DaemonSessionActions;
+    closeWithPane?: boolean;
+} | {
+    id: string;
+    kind: 'context_usage';
+    title: string;
+    sessionId: string;
+    sessionActions?: DaemonSessionActions;
+    closeWithPane?: boolean;
+} | {
+    id: string;
+    kind: 'workflow';
+    title: string;
+    sessionId?: string;
+};
+export interface SideTaskListItem {
+    sessionId: string;
+    title: string;
+    workspaceCwd?: string;
+    updatedAt?: string;
+}
+interface ArtifactPanelProps {
+    contextUsageControls?: Readonly<Record<string, ContextUsageControls>>;
+    artifacts: readonly DaemonSessionArtifact[];
+    tabs: readonly ArtifactPanelTab[];
+    activeTabId: string | null;
+    reviewChanges: readonly TurnOutputFileChange[];
+    selectedReviewPath: string | null;
+    panelWidth?: number;
+    workspaceCwd?: string;
+    loading?: boolean;
+    restoring?: boolean;
+    error?: string | null;
+    onSelectTab: (tabId: string) => void;
+    onCloseTab: (tabId: string) => void;
+    onOpenFilePreview: (change: TurnOutputFileChange, workspaceCwd?: string, workspaceId?: string) => void;
+    latestReviewAvailable?: boolean;
+    onOpenLatestReview?: () => void;
+    /** Open an interactive terminal tab in this panel (shown as an empty-state action). */
+    onOpenTerminal?: () => void;
+    onOpenWebPreview?: () => void;
+    onWebPreviewChange?: (tabId: string, state: WebPreviewState) => void;
+    items?: readonly WebShellRightPanelItem[];
+    sideTaskAvailable?: boolean;
+    sideTasks?: readonly SideTaskListItem[];
+    sideTasksLoading?: boolean;
+    onCreateSideTask?: () => void;
+    onOpenSideTask?: (sideTask: SideTaskListItem) => void;
+    onCreateSideTaskSession?: (tabId: string, parentSessionId: string, title: string) => Promise<{
+        sessionId: string;
+        displayName?: string;
+    }>;
+    onSideTaskCreated?: (tabId: string, sessionId: string) => void;
+    onSideTaskTitleChange?: (tabId: string, title: string, fromFirstPrompt?: boolean) => void;
+    onNestedRightPanelOpen?: (request: TurnOutputOpenRequest) => void;
+    onNestedArtifactsChange?: (sessionId: string, artifacts: readonly DaemonSessionArtifact[]) => void;
+    onOpenNestedSubagent?: (tool: ACPToolCall, sessionId: string, workspaceCwd?: string) => void;
+    agentTasks?: readonly EnvironmentAgentTask[];
+    agentTraceLoading?: boolean;
+    agentTraceError?: string;
+    onOpenWorkflowAgent?: (task: EnvironmentAgentTask) => void;
+    onError?: (error: unknown, fallback: string) => void;
+    sessionWorkflowEnabled?: boolean;
+    workflow?: {
+        todos: readonly TodoItem[];
+        tools: readonly ACPToolCall[];
+        tasks: readonly DaemonSessionTaskStatus[];
+        artifacts: readonly DaemonSessionArtifact[];
+        selectedTodoId?: string;
+        onSelectedTodoIdChange: (todoId: string | undefined) => void;
+        onExpandGraph: () => void;
+        onOpenSubagent: (tool: ACPToolCall) => void;
+        onOpenArtifact?: (artifactId: string) => void;
+        canvasMode?: boolean;
+    };
+    onImageIngestionNotice?: (tone: 'warning' | 'error', message: string) => void;
+    deferSubagentMount?: boolean;
+    onClose: () => void;
+    variant?: 'docked' | 'drawer';
+    fullscreen?: boolean;
+    onToggleFullscreen?: () => void;
+}
+export declare function ArtifactPanel({ contextUsageControls, artifacts, tabs, activeTabId, reviewChanges, selectedReviewPath, panelWidth, workspaceCwd, loading, restoring, error, onSelectTab, onCloseTab, onOpenFilePreview, latestReviewAvailable, onOpenLatestReview, onOpenTerminal, onOpenWebPreview, onWebPreviewChange, items, sideTaskAvailable, sideTasks, sideTasksLoading, onCreateSideTask, onOpenSideTask, onCreateSideTaskSession, onSideTaskCreated, onSideTaskTitleChange, onNestedRightPanelOpen, onNestedArtifactsChange, onOpenNestedSubagent, agentTasks, agentTraceLoading, agentTraceError, onOpenWorkflowAgent, onError, sessionWorkflowEnabled, workflow, onImageIngestionNotice, deferSubagentMount, onClose, variant, fullscreen, onToggleFullscreen, }: ArtifactPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/artifacts/CodeReviewArtifactDetail.d.ts

@@ -0,0 +1,63 @@
+import type { ArtifactWorkspaceActions } from './useArtifactWorkspaceTarget';
+declare const SEVERITIES: readonly ["Critical", "Suggestion", "Nice to have"];
+declare const CONFIDENCES: readonly ["high", "low"];
+declare const SOURCES: readonly ["review", "build", "test", "probe", "lint"];
+declare const OUTCOMES: readonly ["fixed", "skipped", "no_change_needed"];
+type Severity = (typeof SEVERITIES)[number];
+type Confidence = (typeof CONFIDENCES)[number];
+type Source = (typeof SOURCES)[number];
+type Outcome = (typeof OUTCOMES)[number];
+interface FindingLocation {
+    file: string;
+    line?: number;
+    anchor?: string;
+}
+interface ReviewFinding {
+    id: string;
+    severity: Severity;
+    confidence: Confidence;
+    source: Source;
+    summary: string;
+    shortSummary: string;
+    failureScenario: string;
+    /** The executed evidence that settled the verdict, or its `not run` line. */
+    witness?: string;
+    suggestedFix?: string;
+    category?: string;
+    locations: FindingLocation[];
+    /** Local evidence paths; rendered as workspace images where possible. */
+    assetFiles?: string[];
+    assets?: string[];
+    outcome?: Outcome;
+    outcomeNote?: string;
+    heldByMeasurement?: {
+        file: string;
+    };
+}
+interface ReviewCounts {
+    total: number;
+    bySeverity: Record<Severity, number>;
+    byConfidence: Record<Confidence, number>;
+    held: number;
+}
+interface CodeReviewDocument {
+    schemaVersion: 1;
+    target: string;
+    effort: string;
+    verdict: {
+        event: 'APPROVE' | 'COMMENT' | 'REQUEST_CHANGES';
+        verdictLine: string;
+        baseEvent: 'APPROVE' | 'COMMENT' | 'REQUEST_CHANGES';
+        cappedBy: string[];
+    };
+    findings: ReviewFinding[];
+    counts: ReviewCounts;
+    markdownReportPath: string;
+}
+export declare function parseCodeReviewDocument(content: string): CodeReviewDocument;
+export declare function CodeReviewArtifactDetail({ workspacePath, artifactVersion, workspaceActions, }: {
+    workspacePath: string;
+    artifactVersion?: string;
+    workspaceActions: ArtifactWorkspaceActions;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/artifacts/ContextUsagePanel.d.ts

@@ -0,0 +1,7 @@
+import type { DaemonSessionActions } from '@qwen-code/web-shell/daemon-react-sdk';
+import type { ContextUsageControls } from '../../hooks/useContextUsageControls';
+export declare function ContextUsagePanel({ sessionActions, sessionId, controls, }: {
+    sessionActions?: DaemonSessionActions;
+    sessionId: string;
+    controls?: Omit<ContextUsageControls, 'captureOwner'>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/artifacts/LineStats.d.ts

@@ -0,0 +1,12 @@
+import type { TurnOutputFileChange } from './TurnOutputs';
+export declare function LineStats({ additions, deletions, className, additionsClassName, deletionsClassName, }: {
+    additions: number | undefined;
+    deletions: number | undefined;
+    className: string;
+    additionsClassName: string;
+    deletionsClassName: string;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function sumLineStats(changes: readonly TurnOutputFileChange[]): {
+    additions: number;
+    deletions: number;
+} | undefined;

package/dist/types/components/artifacts/SideTaskPanel.d.ts

@@ -0,0 +1,24 @@
+import type { TurnOutputOpenRequest } from './TurnOutputs';
+import type { DaemonSessionArtifact } from '@qwen-code/sdk/daemon';
+interface SideTaskPanelProps {
+    tabId: string;
+    sessionId?: string;
+    parentSessionId: string;
+    workspaceCwd?: string;
+    title: string;
+    shouldNameFromFirstPrompt?: boolean;
+    initialPrompt?: string;
+    createSession: (tabId: string, parentSessionId: string, title: string) => Promise<{
+        sessionId: string;
+        displayName?: string;
+    }>;
+    onCreated: (tabId: string, sessionId: string) => void;
+    onTitleChange: (tabId: string, title: string, fromFirstPrompt?: boolean) => void;
+    onRightPanelOpen?: (request: TurnOutputOpenRequest) => void;
+    onArtifactsChange?: (sessionId: string, artifacts: readonly DaemonSessionArtifact[]) => void;
+    onError?: (error: unknown, fallback: string) => void;
+    sessionWorkflowEnabled?: boolean;
+    onImageIngestionNotice?: (tone: 'warning' | 'error', message: string) => void;
+}
+export declare function SideTaskPanel({ tabId, sessionId, parentSessionId, workspaceCwd, title, shouldNameFromFirstPrompt, initialPrompt, createSession, onCreated, onTitleChange, onRightPanelOpen, onArtifactsChange, onError, sessionWorkflowEnabled, onImageIngestionNotice, }: SideTaskPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/artifacts/SubagentDetail.d.ts

@@ -0,0 +1,14 @@
+import type { DaemonSessionArtifact } from '@qwen-code/sdk/daemon';
+import type { ACPToolCall, Message } from '../../adapters/types';
+import type { TurnOutputOpenRequest } from './TurnOutputs';
+export declare function findSubagentRootTool(messages: readonly Message[], rootToolCallId: string): ACPToolCall | undefined;
+export declare function SubagentDetail({ sessionId, rootToolCallId, initialRootTool, workspaceCwd, onRightPanelOpen, onArtifactsChange, onOpenSubagent, onError, }: {
+    sessionId: string;
+    rootToolCallId: string;
+    initialRootTool: ACPToolCall;
+    workspaceCwd?: string;
+    onRightPanelOpen?: (request: TurnOutputOpenRequest) => void;
+    onArtifactsChange?: (sessionId: string, artifacts: readonly DaemonSessionArtifact[]) => void;
+    onOpenSubagent?: (tool: ACPToolCall, sessionId: string, workspaceCwd?: string) => void;
+    onError?: (error: unknown, fallback: string) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/artifacts/TokenUsagePanel.d.ts

@@ -0,0 +1,7 @@
+import type { DaemonSessionActions } from '@qwen-code/web-shell/daemon-react-sdk';
+interface TokenUsagePanelProps {
+    sessionActions?: DaemonSessionActions;
+    sessionId?: string;
+}
+export declare function TokenUsagePanel({ sessionActions, sessionId, }: TokenUsagePanelProps): import("react/jsx-runtime").JSX.Element;
+export {};