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

package/dist/types/components/messages/PlanExecutionView.d.ts

@@ -0,0 +1,91 @@
+import type { DaemonSessionAgentTaskStatus, DaemonSessionTaskStatus } from '@qwen-code/sdk/daemon';
+import type { ACPToolCall, TodoItem } from '../../adapters/types';
+export type PlanNodeStatus = 'running' | 'paused' | 'completed' | 'blocked' | 'in_progress' | 'ready';
+/**
+ * Status is carried by a glyph as well as a colour so the graph survives
+ * colour-blindness, high-contrast mode, and a greyscale screenshot. Every
+ * surface showing plan status uses the same glyph for the same status.
+ */
+export declare const PLAN_STATUS_GLYPH: Record<PlanNodeStatus, string>;
+export declare function layerPlanTodos(todos: readonly TodoItem[]): TodoItem[][];
+export interface TaskExecutionIndex {
+    rootByToolCallId: ReadonlyMap<string, DaemonSessionAgentTaskStatus>;
+    childrenByParentId: ReadonlyMap<string, DaemonSessionAgentTaskStatus[]>;
+    nestedByRootId: Map<string, Array<{
+        task: DaemonSessionAgentTaskStatus;
+        depth: number;
+    }>>;
+}
+export declare function createTaskExecutionIndex(tasks: readonly DaemonSessionTaskStatus[]): TaskExecutionIndex;
+export declare function nestedTasksFromIndex(tool: ACPToolCall, taskIndex: TaskExecutionIndex): Array<{
+    task: DaemonSessionAgentTaskStatus;
+    depth: number;
+}>;
+export declare function nestedTasksForTool(tool: ACPToolCall, tasks: readonly DaemonSessionTaskStatus[]): Array<{
+    task: DaemonSessionAgentTaskStatus;
+    depth: number;
+}>;
+/**
+ * Deliberately uncached. Keying on the tool object would be wrong the moment
+ * a reused object gains a sub-tool — `appendSubTool` mutates `subTools` in
+ * place — and the only thing standing between that and a stale render is
+ * `useMessages`' prefix-reuse rule in another module. The callers' own
+ * derivations are memoized, so the repetition this would remove is bounded to
+ * a single derivation; a silent wrong subtree is not worth that.
+ */
+export declare function nestedAgentToolsForTool(tool: ACPToolCall): Array<{
+    tool: ACPToolCall;
+    depth: number;
+}>;
+/**
+ * Same agent-status walk as {@link attentionAgentStatuses}, for callers that
+ * hold the raw task list instead of a prebuilt index (the cockpit's stats
+ * strip, which must tally exactly what the attention queue shows).
+ */
+export declare function getAttentionAgentStatuses(tool: ACPToolCall, tasks: readonly DaemonSessionTaskStatus[]): string[];
+/**
+ * One entry per agent the overview strip reports as active, and the single
+ * source the workflow inspector summary counts: the live daemon task when
+ * one exists, otherwise a transcript-derived stand-in for an in-flight tool
+ * call with no live task (the replay shape). The walk mirrors the node
+ * badges (executionStatus), so the strip, the badges, and the inspector can
+ * never contradict each other. An agent observed through BOTH a live task
+ * and a persisted transcript tool counts once (dedup by toolUseId).
+ */
+export declare function getActiveAgents(tools: readonly ACPToolCall[], tasks: readonly DaemonSessionTaskStatus[]): DaemonSessionAgentTaskStatus[];
+/**
+ * {@link getActiveAgents} for callers that already hold an index. Building the
+ * index is O(tasks); doing it per todo and per tool — as the workflow
+ * projection used to — makes the walk O((todos + tools) x tasks) for a result
+ * that never varies with the todo or the tool.
+ */
+export declare function getActiveAgentsFromIndex(tools: readonly ACPToolCall[], taskIndex: TaskExecutionIndex): DaemonSessionAgentTaskStatus[];
+export declare function getPlanNodeStateFromIndex(todo: TodoItem, todosById: ReadonlyMap<string, TodoItem>, tools: readonly ACPToolCall[], taskIndex: TaskExecutionIndex): {
+    status: PlanNodeStatus;
+    attention: boolean;
+};
+export declare function getPlanNodeState(todo: TodoItem, todosById: ReadonlyMap<string, TodoItem>, tools: readonly ACPToolCall[], tasks: readonly DaemonSessionTaskStatus[]): {
+    status: PlanNodeStatus;
+    attention: boolean;
+};
+/** The plan step a tool call was issued for, when it declares one. */
+export declare function todoIdOf(tool: ACPToolCall): string | undefined;
+export declare function getAttentionAgentTool(tool: ACPToolCall, tasks: readonly DaemonSessionTaskStatus[]): ACPToolCall | undefined;
+export declare function PlanExecutionView({ todos, tools, tasks, onOpenSubagent, hideTitle, selection, showStepDetails, }: {
+    todos: readonly TodoItem[];
+    tools: readonly ACPToolCall[];
+    tasks: readonly DaemonSessionTaskStatus[];
+    onOpenSubagent?: (tool: ACPToolCall) => void;
+    /**
+     * Drop the "Plan execution" caption when the host already titles the region.
+     * The locate control stays either way — it is an action, not a label.
+     */
+    hideTitle?: boolean;
+    /** Lets a larger host keep graph selection in sync with an adjacent detail surface. */
+    selection?: {
+        value: string | undefined;
+        onChange: (todoId: string | undefined) => void;
+    };
+    /** The full Workflow canvas renders selected-step detail in the right panel. */
+    showStepDetails?: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/messages/PlanMessage.d.ts

@@ -0,0 +1,8 @@
+import type { TodoItem } from '../../adapters/types';
+interface PlanMessageProps {
+    id: string;
+    todos: TodoItem[];
+    isLocateFlashing?: boolean;
+}
+export declare const PlanMessage: import("react").NamedExoticComponent<PlanMessageProps>;
+export {};

package/dist/types/components/messages/QuestionAnswerMessage.d.ts

@@ -0,0 +1,7 @@
+import type { ACPToolCall } from '../../adapters/types';
+import type { getQuestionAnswerResult } from './toolFormatting';
+export declare function QuestionAnswerMessage({ tool, result, isLocateFlashing, }: {
+    tool: ACPToolCall;
+    result: NonNullable<ReturnType<typeof getQuestionAnswerResult>>;
+    isLocateFlashing?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/messages/SettingsMessage.d.ts

@@ -0,0 +1,46 @@
+import type { DaemonSettingDescriptor, DaemonSettingUpdateResult, DaemonWorkspaceSettingsStatus } from '@qwen-code/web-shell/daemon-react-sdk';
+import { type WebShellLanguage } from '../../i18n';
+import type { UseLiveVoiceSetupResult } from '../../live/useLiveVoiceSetup';
+import { type WebShellTheme } from '../../themeContext';
+import { type ModelManagementProps } from './ModelManagementSection';
+import { type WebShellSettingsOptions } from '../../settings';
+type ChatWidthMode = '1000' | 'wide';
+interface SettingsMessageProps {
+    settingsState: SettingsMessageSettingsState;
+    presentation?: WebShellSettingsOptions;
+    onLanguageChange: (language: WebShellLanguage, scope: Scope) => void;
+    onSubDialog: (settingKey: string, scope: Scope) => void;
+    onThemeChange: (theme: WebShellTheme) => void;
+    chatWidthMode: ChatWidthMode;
+    onChatWidthModeChange: (mode: ChatWidthMode) => void;
+    /** Model list/add/delete/select, rendered inside the Model category. */
+    modelManagement?: ModelManagementProps;
+    embedded?: boolean;
+    /** Category to select on open (deep link, e.g. 'Daemon'). */
+    initialCategory?: string;
+}
+export interface SettingsMessageSettingsState {
+    status: DaemonWorkspaceSettingsStatus | undefined;
+    settings: DaemonSettingDescriptor[];
+    loading: boolean;
+    error: Error | undefined;
+    reload: () => Promise<DaemonWorkspaceSettingsStatus | undefined>;
+    setValue: (scope: 'workspace' | 'user', key: string, value: unknown) => Promise<DaemonSettingUpdateResult>;
+    liveSetup?: UseLiveVoiceSetupResult;
+}
+type Scope = 'user' | 'workspace';
+type Translator = (key: string, vars?: Record<string, string | number>) => string;
+export declare function formatSettingLabel(setting: DaemonSettingDescriptor, t: Translator): string;
+export type FlatRow = {
+    type: 'header';
+    category: string;
+} | {
+    type: 'setting';
+    setting: DaemonSettingDescriptor;
+} | {
+    type: 'local';
+    localKey: 'chatWidth' | 'browserNotifications';
+};
+export declare function nextSettingIdx(rows: FlatRow[], current: number, dir: 1 | -1): number;
+export declare function SettingsMessage({ settingsState, presentation, onLanguageChange, onSubDialog, onThemeChange, chatWidthMode, onChatWidthModeChange, modelManagement, embedded, initialCategory, }: SettingsMessageProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/messages/StatsMessage.d.ts

@@ -0,0 +1,14 @@
+import type { DaemonSessionStatsStatus } from '@qwen-code/web-shell/daemon-react-sdk';
+export type StatsView = 'overview' | 'model' | 'tools';
+interface ParsedStats {
+    view: StatsView;
+    status: DaemonSessionStatsStatus;
+}
+export declare function serializeStatsMessage(status: DaemonSessionStatsStatus, view?: StatsView): string;
+export declare function parseStatsMessage(content: string): ParsedStats | null;
+export declare function formatDuration(ms: number): string;
+export declare function StatsMessage({ view, status, }: {
+    view: StatsView;
+    status: DaemonSessionStatsStatus;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/messages/StatusMessage.d.ts

@@ -0,0 +1,18 @@
+export interface StatusInfo {
+    cliVersion: string;
+    runtime: string;
+    platform: string;
+    auth: string;
+    baseUrl: string;
+    model: string;
+    fastModel: string;
+    sessionId: string;
+    sandbox: string;
+    proxy: string;
+    memoryUsage: string;
+}
+declare const serializeStatusMessage: (data: StatusInfo) => string, parseStatusMessage: (content: string) => StatusInfo | null;
+export { serializeStatusMessage, parseStatusMessage };
+export declare function StatusMessage({ info }: {
+    info: StatusInfo;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/messages/SystemMessage.d.ts

@@ -0,0 +1,29 @@
+interface SystemMessageProps {
+    content: string;
+    variant: 'info' | 'error' | 'warning';
+    source?: string;
+    data?: unknown;
+    images?: Array<{
+        data: string;
+        mimeType: string;
+    }>;
+    files?: Array<{
+        name: string;
+        mimeType: string;
+        attachmentId?: string;
+    }>;
+    /** Run /context detail, exactly like typing it (context-usage panels). */
+    onShowContextDetail?: () => void;
+    onLocateBackgroundSource?: (messageId: string, callId?: string) => boolean;
+    /** Click an image to preview it in the right panel. */
+    onImagePreview?: (src: string, alt?: string) => void;
+    onAttachmentPreview?: (file: {
+        name: string;
+        mimeType?: string;
+        attachmentId?: string;
+    }) => void;
+    showRetryHint?: boolean;
+    onRetryClick?: () => void;
+}
+export declare const SystemMessage: import("react").NamedExoticComponent<SystemMessageProps>;
+export {};

package/dist/types/components/messages/TasksStatusMessage.d.ts

@@ -0,0 +1,38 @@
+import type { DaemonSessionMonitorTaskStatus, DaemonSessionShellTaskStatus, DaemonSessionWorkflowTasksStatus } from '@qwen-code/sdk/daemon';
+import { type DaemonSessionActions } from '@qwen-code/web-shell/daemon-react-sdk';
+import type { ACPToolCall, TodoItem } from '../../adapters/types';
+declare const ACTIVE_EVENT = "web-shell:tasks-panel-active";
+type DaemonSessionTasksStatus = DaemonSessionWorkflowTasksStatus;
+export interface SerializedTasksMessage {
+    snapshot: DaemonSessionTasksStatus;
+}
+export type TasksStatusView = 'all' | 'workflow-active' | 'workflow-history';
+declare const serializeTasksStatusMessage: (data: SerializedTasksMessage) => string;
+declare function parseTasksStatusMessage(content: string): SerializedTasksMessage | null;
+export { serializeTasksStatusMessage, parseTasksStatusMessage };
+export declare function TasksStatusMessage({ message, embedded, manageActiveEvent, keyboardShortcuts, syncSnapshot, includeWorkflows, taskView, emptyLabel, onWorkflowRunStarted, onTasksChange, onClose, planTodos, agentTools, onOpenSubagent, onOpenMonitor, }: {
+    message: SerializedTasksMessage;
+    embedded?: boolean;
+    manageActiveEvent?: boolean;
+    keyboardShortcuts?: boolean;
+    syncSnapshot?: boolean;
+    includeWorkflows?: boolean;
+    taskView?: TasksStatusView;
+    emptyLabel?: string;
+    onWorkflowRunStarted?: () => void;
+    onTasksChange?: (snapshot: DaemonSessionTasksStatus) => void;
+    onClose?: () => void;
+    planTodos?: readonly TodoItem[];
+    agentTools?: readonly ACPToolCall[];
+    onOpenSubagent?: (tool: ACPToolCall) => void;
+    onOpenMonitor?: (task: DaemonSessionMonitorTaskStatus) => void;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function MonitorTaskDetail({ task, actions: providedActions, }: {
+    task: DaemonSessionMonitorTaskStatus;
+    actions?: DaemonSessionActions;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ShellTaskDetail({ task, actions: providedActions, }: {
+    task: DaemonSessionShellTaskStatus;
+    actions?: DaemonSessionActions;
+}): import("react/jsx-runtime").JSX.Element;
+export { ACTIVE_EVENT as TASKS_STATUS_ACTIVE_EVENT };

package/dist/types/components/messages/TodoView.d.ts

@@ -0,0 +1,17 @@
+import type { TodoItem } from '../../adapters/types';
+import { type TodoEvent } from '../../utils/todos';
+/**
+ * Collapsed view: the change a single snapshot introduced — items that just
+ * completed and items that just started. With no tracked change (an unchanged
+ * re-emit, or a snapshot rendered without a timeline) it falls back to the
+ * current focus item so the row is never empty.
+ */
+export declare function TodoEventSummary({ todos, events, }: {
+    todos: TodoItem[];
+    events: readonly TodoEvent[];
+}): import("react/jsx-runtime").JSX.Element | null;
+/** Expanded view: the full list. `numbered` adds the 1. 2. 3. index column. */
+export declare function TodoFullList({ todos, numbered, }: {
+    todos: TodoItem[];
+    numbered?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/messages/ToolApproval.d.ts

@@ -0,0 +1,28 @@
+import type { PermissionRequest, TodoItem } from '../../adapters/types';
+import { type SessionContentGenerator } from './AssistantMessage';
+interface ToolApprovalProps {
+    request: PermissionRequest;
+    onConfirm: (id: string, selectedOption: string) => void | Promise<void>;
+    variant?: 'inline' | 'floating';
+    disabled?: boolean;
+    /**
+     * Whether this approval should pull keyboard focus to its safe-default option
+     * when it becomes the topmost (visible) one — on appearance, or when a panel/
+     * dialog that was covering it closes. Defaults to true. Split-view panes pass
+     * false: each pane's approval stays visible side-by-side, so auto-focusing one
+     * would steal focus from the pane the user is working in. Keyboard handling
+     * itself is focus-scoped (an onKeyDown on the panel), so a keyboardActive=false
+     * approval is still fully operable by keyboard once the user tabs/clicks into
+     * it — it just never grabs focus on its own.
+     */
+    keyboardActive?: boolean;
+    planTodos?: readonly TodoItem[];
+    planExecutionMode?: string;
+    generateContent?: SessionContentGenerator;
+}
+export declare function parseTitle(title?: string): {
+    toolName: string;
+    description: string;
+};
+export declare function ToolApproval({ request, onConfirm, variant, disabled, keyboardActive, planTodos, planExecutionMode, generateContent, }: ToolApprovalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/messages/ToolFilePreviewButton.d.ts

@@ -0,0 +1,7 @@
+import type { ACPToolCall } from '../../adapters/types';
+import type { TurnOutputOpenRequest } from '../artifacts/TurnOutputs';
+export declare function ToolFilePreviewButton({ tool, workspaceCwd, onOpen, }: {
+    tool: ACPToolCall;
+    workspaceCwd?: string;
+    onOpen?: (request: TurnOutputOpenRequest) => void;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/messages/ToolGroup.d.ts

@@ -0,0 +1,50 @@
+import type { ACPToolCall, PermissionRequest } from '../../adapters/types';
+import type { SessionContentGenerator } from './AssistantMessage';
+import { useI18n } from '../../i18n';
+import { type ToolHeaderKind } from '../../customization';
+import type { TurnOutputOpenRequest } from '../artifacts/TurnOutputs';
+interface ToolGroupProps {
+    tools: ACPToolCall[];
+    compactSummary?: boolean;
+    /**
+     * Thinking aggregated with the tools in this summary (compact mode), in
+     * the original order. Streaming entries drive the "Thinking…" summary;
+     * each entry renders as a click-to-expand row.
+     */
+    thoughts?: Array<{
+        content: string;
+        isStreaming?: boolean;
+        beforeToolCallId?: string;
+    }>;
+    pendingApproval?: PermissionRequest | null;
+    workspaceCwd?: string;
+    onTurnOutputOpen?: (request: TurnOutputOpenRequest) => void;
+    isLocateFlashing?: boolean;
+    /** Powers the translate action on completed thinking rows (zh-CN). */
+    generateContent?: SessionContentGenerator;
+}
+export declare function extractDiff(tool: ACPToolCall): string;
+export declare function getRawFileDiff(tool: ACPToolCall): string;
+export declare function buildUnifiedDiff(oldText: string, newText: string): string;
+export declare function languageForPath(filePath: string): string;
+export declare function fencedCodeBlock(language: string, code: string): string;
+interface ToolLineProps {
+    tool: ACPToolCall;
+    approval?: PermissionRequest | null;
+    workspaceCwd?: string;
+    onTurnOutputOpen?: (request: TurnOutputOpenRequest) => void;
+    summaryOnly?: boolean;
+    forceExpanded?: boolean;
+    detailsVisible?: boolean;
+    hideHeader?: boolean;
+    hideCollapsedOutput?: boolean;
+}
+export declare function shouldAutoExpand(tool: ACPToolCall): boolean;
+export declare function getToolHeaderKind(tool: ACPToolCall): ToolHeaderKind;
+export declare function getActiveTool(tools: ACPToolCall[]): ACPToolCall;
+export declare function formatToolGroupSummary(tools: ACPToolCall[], t: ReturnType<typeof useI18n>['t'], workspaceCwd?: string, summarizeAgents?: boolean): string;
+export declare function formatSingleToolSummary(tool: ACPToolCall, t: ReturnType<typeof useI18n>['t'], workspaceCwd?: string): string;
+export declare function isWebFetchToolName(toolName: string): boolean;
+export declare const ToolLine: import("react").NamedExoticComponent<ToolLineProps>;
+export declare const ToolGroup: import("react").NamedExoticComponent<ToolGroupProps>;
+export {};

package/dist/types/components/messages/UserMessage.d.ts

@@ -0,0 +1,46 @@
+import type { DaemonInputAnnotation } from '@qwen-code/sdk/daemon';
+import type { ComposerTagClickHandler, ComposerTagRenderer, WebShellComposerTag, WebShellComposerTagIconMap } from '../../customization';
+import type { AttachmentPreviewRequest } from '../../adapters/messageTypes';
+import type { ImageTabSource } from '../artifacts/ArtifactPanel';
+interface UserMessageImage {
+    data: string;
+    mimeType: string;
+    attachmentId?: string;
+}
+interface UserMessageFile {
+    name: string;
+    mimeType: string;
+    data?: Blob;
+    text?: string;
+    attachmentId?: string;
+}
+interface UserMessageProps {
+    content: string;
+    images?: UserMessageImage[];
+    files?: UserMessageFile[];
+    inputAnnotations?: readonly DaemonInputAnnotation[];
+    isLocateFlashing?: boolean;
+    sendFailed?: boolean;
+    onRetrySend?: () => void;
+    /** Render the message as an in-place editor instead of rendered content. */
+    editing?: boolean;
+    /** The edited text is being sent; the editor stays open and inert. */
+    submittingEdit?: boolean;
+    /** Submit trimmed text; attachment-only messages may have empty text. */
+    onEditSubmit?: (content: string) => void;
+    onEditCancel?: () => void;
+    /** Click an uploaded image to preview it in the right panel. */
+    onImagePreview?: (src: string, alt?: string, source?: ImageTabSource) => void;
+    onAttachmentPreview?: (file: AttachmentPreviewRequest) => void;
+}
+export declare const UserMessage: import("react").NamedExoticComponent<UserMessageProps>;
+export declare function ReadonlyComposerTag({ tag, composerTagIcons, renderComposerTag, renderComposerTagTooltip, onComposerTagClick, title, preserveCustomKindLabel, }: {
+    tag: WebShellComposerTag;
+    composerTagIcons: WebShellComposerTagIconMap | undefined;
+    renderComposerTag: ComposerTagRenderer | undefined;
+    renderComposerTagTooltip: ComposerTagRenderer | undefined;
+    onComposerTagClick: ComposerTagClickHandler | undefined;
+    title?: string;
+    preserveCustomKindLabel?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/messages/UserShellMessage.d.ts

@@ -0,0 +1,6 @@
+interface UserShellMessageProps {
+    command: string;
+    output: string;
+}
+export declare const UserShellMessage: import("react").NamedExoticComponent<UserShellMessageProps>;
+export {};

package/dist/types/components/messages/WorkflowExecutionView.d.ts

@@ -0,0 +1,48 @@
+import { type ReactNode } from 'react';
+import type { DaemonSessionWorkflowTaskStatus, DaemonWorkflowDispatchStatus, DaemonWorkflowDispatchStatusEntry } from '@qwen-code/sdk/daemon';
+export declare const WORKFLOW_GRAPH_RENDER_LIMITS: {
+    readonly lanes: 64;
+    readonly nodes: 240;
+    readonly edges: 400;
+};
+interface WorkflowGraphNode {
+    dispatch: DaemonWorkflowDispatchStatusEntry;
+    x: number;
+    y: number;
+}
+interface WorkflowGraphEdge {
+    from: string;
+    to: string;
+    d: string;
+}
+export interface WorkflowGraphLayout {
+    width: number;
+    height: number;
+    laneWidth: number;
+    nodeWidth: number;
+    lanes: Array<{
+        id: string | null;
+        title: string;
+        index: number;
+    }>;
+    nodes: WorkflowGraphNode[];
+    edges: WorkflowGraphEdge[];
+    dispatchCountByLaneId: ReadonlyMap<string | null, number>;
+    dispatchStatusById: ReadonlyMap<string, DaemonWorkflowDispatchStatus>;
+    omittedLanes: number;
+    omittedNodes: number;
+    omittedEdges: number;
+}
+export declare function buildWorkflowGraphLayout(task: DaemonSessionWorkflowTaskStatus, options?: {
+    laneWidth?: number;
+}): WorkflowGraphLayout;
+export declare function WorkflowExecutionView({ task, sourceTask, historyTasks, historyActionBusy, onDeleteHistory, actions, }: {
+    task: DaemonSessionWorkflowTaskStatus;
+    sourceTask?: DaemonSessionWorkflowTaskStatus;
+    historyTasks?: readonly DaemonSessionWorkflowTaskStatus[];
+    historyActionBusy?: boolean;
+    onDeleteHistory?: (runId: string) => void;
+    /** Run controls (pause / stop / rerun …) shown at the end of the metrics strip. */
+    actions?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/messages/agentForest.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * agentForest — pure helpers for rendering nested sub-agents as a tree
+ * in the tasks panel.
+ *
+ * Sub-agents may spawn sub-agents (bounded by `maxSubagentDepth`), and every
+ * agent in the tree appears in the same flat tasks snapshot
+ * (`DaemonSessionTasksStatus`, polled from `GET /session/:id/tasks`). These
+ * helpers turn that flat roster into a parent-grouped display order plus
+ * per-row tree metadata, without assuming the full tree is visible: entries
+ * appear and leave the snapshot independently (foreground agents unregister
+ * on completion, registries cap retained terminal entries), so every function
+ * here treats a missing parent as a normal case, not an error.
+ *
+ * The reorder is a post-pass over an already-sorted list on purpose: the
+ * panel sorts active-then-terminal, and a tree can span those buckets — a
+ * running parent with a just-completed child, or vice versa. Grouping
+ * children under whichever position their parent already earned preserves
+ * the sort semantics for roots while keeping trees contiguous.
+ *
+ * Focused port of the TUI's helpers
+ * (`packages/cli/src/ui/components/background-view/agent-forest.ts`); no
+ * package importable from both surfaces exists, so the two files share
+ * semantics via their collocated tests. Keep behavior changes in sync.
+ */
+/**
+ * Minimal structural view of a task entry — satisfied by
+ * `DaemonSessionTaskStatus` union members, so the helpers stay decoupled
+ * from the SDK types. For agent tasks `id` IS the agent id (the daemon
+ * serializer guarantees it), which is what `parentAgentId` references.
+ */
+export interface AgentForestNode {
+    kind: string;
+    id?: string;
+    parentAgentId?: string | null;
+    isBackgrounded?: boolean;
+}
+/** Per-agent tree metadata for row rendering. */
+export interface AgentTreeInfo {
+    /**
+     * Structural depth among the *visible* entries (0 = rendered at root
+     * level). An agent whose ancestors left the snapshot renders closer to
+     * the root than its launch depth — the tree indents only what the user
+     * can actually see, so connectors never dangle.
+     */
+    visibleDepth: number;
+    /**
+     * True when the entry claims a parent (`parentAgentId` set) that is not
+     * in the visible set — the row is promoted to root level and annotated
+     * ("from <parent>") instead of indented under nothing.
+     */
+    orphaned: boolean;
+}
+export declare const TREE_INDENT_MAX_LEVELS = 3;
+/**
+ * Regroups agent entries so each agent renders directly beneath its parent
+ * (depth-first), while every non-agent entry keeps its exact position: the
+ * k-th agent slot in the input is filled by the k-th agent of the grouped
+ * order. Agents whose parent is absent (top-level, departed parent, or a
+ * parent-cycle) keep their original relative order as roots; siblings keep
+ * their original relative order under their parent.
+ */
+export declare function reorderChildrenUnderParents<T extends AgentForestNode>(entries: readonly T[]): T[];
+/** How an ancestor walk ended — see {@link ancestorChain}. */
+export type AncestorTermination = 'root' | 'missing' | 'cycle';
+/**
+ * Walks `node`'s parent chain through `lookup`, collecting the ancestors
+ * that are actually present (immediate parent first). The walk stops —
+ * without error, per the module contract — at a top-level ancestor
+ * (`'root'`), at a departed/unknown parent id (`'missing'`), or on a
+ * repeated id (`'cycle'`). Single home of the eviction/cycle policy shared
+ * by tree depth and the `[blocking]` verdict.
+ */
+export declare function ancestorChain<T extends AgentForestNode>(node: AgentForestNode, lookup: (id: string) => T | undefined): {
+    chain: T[];
+    terminatedBy: AncestorTermination;
+};
+/**
+ * Computes {@link AgentTreeInfo} for every agent entry in the visible set.
+ * Depth is the length of the parent chain that is actually present.
+ */
+export declare function computeAgentTreeInfo(entries: readonly AgentForestNode[]): Map<string, AgentTreeInfo>;
+/**
+ * The agent ids whose cancellation would end the USER's current turn — a
+ * foreground entry whose entire ancestor chain is foreground up to the
+ * top-level session. A foreground child awaited by a *background* parent
+ * blocks that parent, not the user, so it is not tagged; the `[blocking]`
+ * warning exists solely to flag "cancelling this ends your turn". When the
+ * chain cannot be proven (departed ancestor, cycle), the entry is not
+ * tagged — a missing warning is a milder failure than a wrong one.
+ */
+export declare function computeUserBlockingIds(entries: readonly AgentForestNode[]): Set<string>;

package/dist/types/components/messages/codeHighlighter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type Highlighter } from 'shiki';
+export declare const SHIKI_CACHE_MAX = 128;
+/** Returns previously-highlighted HTML for this exact code/lang/theme, or null. */
+export declare function getCachedHtml(code: string, lang: string, theme: string): string | null;
+/** Returns the shared highlighter with `lang` loaded (lazily, cached). */
+export declare function getCodeHighlighter(lang: string): Promise<Highlighter>;
+export declare const MAX_HIGHLIGHT_TOTAL_CHARS = 100000;
+export declare const MAX_HIGHLIGHT_LINE_CHARS = 20000;
+export declare function isTooLargeToHighlight(code: string): boolean;
+/**
+ * Synchronously highlights code to HTML *iff* the highlighter and language are
+ * already warm (e.g. right after a streaming block settles). Returns null
+ * otherwise, so the caller can fall back to the async path (or plain text).
+ *
+ * The size policy (isTooLargeToHighlight) lives at the caller, which already
+ * gates before reaching this function — so it is not re-checked here.
+ */
+export declare function highlightToHtmlSync(code: string, lang: string, theme: string, persist?: boolean): string | null;
+/** Resets all module-level highlighter state (incl. the HTML cache). Tests only. */
+export declare function __resetForTesting(): void;

package/dist/types/components/messages/rehype-footnote-cards.d.ts

@@ -0,0 +1,22 @@
+import type { Element, Root } from 'hast';
+import type { WebShellFootnote } from '../../customization';
+export interface FootnotePreview extends WebShellFootnote {
+    linkNode?: Element;
+}
+export interface FootnoteElement extends Element {
+    data?: Element['data'] & {
+        footnoteCards?: FootnotePreview[];
+        hasVisibleFootnotes?: boolean;
+    };
+}
+interface FootnoteOptions {
+    prefix: string;
+    group: boolean;
+    safeHref: (url: string) => boolean;
+    safeImage: (url: string) => boolean;
+    transformUrl: (url: string) => string;
+}
+export declare function rehypeFootnoteCards(options: FootnoteOptions): (tree: Root, file: {
+    value: unknown;
+}) => void;
+export {};