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

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

@@ -0,0 +1,121 @@
+import type { DaemonBackgroundTurn, DaemonSessionArtifact } from '@qwen-code/sdk/daemon';
+import type { ACPToolCall } from '../../adapters/types';
+export interface TurnOutputFileChange {
+    path: string;
+    status: 'created' | 'modified';
+    toolCallId: string;
+    isArtifact: boolean;
+    additions?: number;
+    deletions?: number;
+    diffs: TurnOutputFileDiff[];
+}
+export interface TurnOutputFileDiff {
+    oldText: string;
+    newText: string;
+    fileDiff?: string;
+    fullContent?: boolean;
+}
+export interface TurnOutputScheduledTask {
+    id: string;
+    toolCallId: string;
+    title: string;
+    cron: string;
+    prompt: string;
+    recurring: boolean;
+    durable: boolean;
+    workspaceId?: string;
+    display?: string;
+}
+export type TurnOutputKind = 'file' | 'artifact' | 'scheduled_task';
+export declare const TURN_OUTPUT_KINDS: readonly TurnOutputKind[];
+export declare const TURN_OUTPUT_VISIBLE_LIMIT = 3;
+export declare function visibleTurnOutputs<T>(items: readonly T[], expanded: boolean): readonly T[];
+export type TurnOutputOpenRequest = ({
+    id: string;
+    kind: 'background_task';
+    title: string;
+    turnId: string;
+    backgroundTurn: DaemonBackgroundTurn;
+    workspaceCwd?: string;
+} | {
+    id: 'review';
+    kind: 'review';
+    title: string;
+    turnId: string;
+    changes: readonly TurnOutputFileChange[];
+    selectedPath?: string;
+    workspaceCwd?: string;
+    workspaceId?: string;
+} | {
+    id: 'image';
+    kind: 'image';
+    title: string;
+    turnId: string;
+    src: string;
+    alt?: string;
+    attachmentId?: string;
+} | {
+    id: string;
+    kind: 'attachment';
+    silentUnavailable?: boolean;
+    title: string;
+    turnId: string;
+    mimeType?: string;
+    data?: Blob;
+    text?: string;
+    attachmentId?: string;
+    workspacePath?: string;
+    workspaceCwd?: string;
+} | {
+    id: string;
+    kind: 'artifact';
+    title: string;
+    turnId: string;
+    artifactId: string;
+    managedId?: string;
+    artifact: DaemonSessionArtifact;
+    workspaceCwd?: string;
+    workspaceId?: string;
+    previewContent?: string;
+} | {
+    id: string;
+    kind: 'scheduled_task';
+    title: string;
+    turnId: string;
+    task: TurnOutputScheduledTask;
+    workspaceCwd?: string;
+    workspaceId?: string;
+} | {
+    id: string;
+    kind: 'subagent';
+    title: string;
+    turnId: string;
+    tool: ACPToolCall;
+    sessionId: string;
+    workspaceCwd?: string;
+}) & {
+    /** Session whose transcript produced this output. */
+    sourceSessionId?: string;
+};
+interface TurnOutputsProps {
+    turnId: string;
+    changes: readonly TurnOutputFileChange[];
+    artifacts: readonly DaemonSessionArtifact[];
+    scheduledTasks: readonly TurnOutputScheduledTask[];
+    workspaceCwd?: string;
+    onOpenRequest?: (request: TurnOutputOpenRequest) => void;
+    onReviewChanges: (changes: readonly TurnOutputFileChange[], selectedPath?: string) => void;
+    onOpenArtifact: (artifactId: string, previewContent?: string) => void;
+    onOpenScheduledTask: (task: TurnOutputScheduledTask) => void;
+    onError?: (error: unknown, fallback: string) => void;
+}
+declare function TurnOutputsComponent({ turnId, changes, artifacts, scheduledTasks, workspaceCwd, onOpenRequest, onReviewChanges, onOpenArtifact, onOpenScheduledTask, onError, }: TurnOutputsProps): import("react/jsx-runtime").JSX.Element | null;
+export declare const TurnOutputs: import("react").MemoExoticComponent<typeof TurnOutputsComponent>;
+export declare function getArtifactPreviewContent(artifact: DaemonSessionArtifact, changes: readonly TurnOutputFileChange[], workspaceCwd?: string): string | undefined;
+export declare function getFileChangePreviewContent(change: TurnOutputFileChange): string | undefined;
+export declare function isRenderedFilePath(value: string): boolean;
+export declare function isDownloadableReviewFilePath(value: string): boolean;
+export declare function canOpenWorkspaceArtifact(artifact: DaemonSessionArtifact): boolean;
+export declare function getWorkspaceArtifactOpenBlockReason(artifact: DaemonSessionArtifact, t: (key: string, vars?: Record<string, string | number>) => string): string | undefined;
+export declare function displayPath(path: string, workspaceCwd?: string): string;
+export {};

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

@@ -0,0 +1,37 @@
+import type { DaemonSessionArtifact, DaemonWorkspaceFileBytes } from '@qwen-code/sdk/daemon';
+import type { DaemonWorkspaceActions } from '@qwen-code/web-shell/daemon-react-sdk';
+export declare function artifactKindLabel(kind: string, workspacePath?: string): string;
+export declare function isOfficeDocumentPath(workspacePath?: string): boolean;
+export declare function isDownloadOnlyWorkspaceArtifact(artifact: {
+    kind?: string;
+    workspacePath?: string;
+    mimeType?: string;
+}): boolean;
+export declare function pathExtension(workspacePath?: string): string;
+export declare function isAudioArtifact(workspacePath?: string, mimeType?: string): boolean;
+export declare function getArtifactFreshnessKey(artifact: Pick<DaemonSessionArtifact, 'status' | 'updatedAt' | 'metadata'>): string;
+export declare function getArtifactTypeLabel(artifact: DaemonSessionArtifact): string;
+export declare function formatArtifactSize(sizeBytes: number | undefined): string;
+export declare function normalizeArtifactMimeType(mimeType?: string): string;
+export declare function getArtifactImageMimeType(artifact: Pick<DaemonSessionArtifact, 'mimeType' | 'workspacePath'>): string | undefined;
+export declare function getImageMimeTypeFromPath(path: string): string | undefined;
+export declare function getReviewDownloadMimeType(value: string): string;
+export declare function readWorkspaceFileAsBlob(readFileBytes: (filePath: string, opts?: {
+    offset?: number;
+    maxBytes?: number;
+}) => Promise<Pick<DaemonWorkspaceFileBytes, 'contentBase64' | 'offset' | 'returnedBytes' | 'sizeBytes'>>, filePath: string, mimeType: string, options: {
+    statFile: (filePath: string) => Promise<{
+        sizeBytes: number;
+        modifiedMs: number;
+        type?: string;
+    }>;
+    isCancelled?: () => boolean;
+    maxBytes?: number;
+}): Promise<Blob>;
+export declare function downloadWorkspaceFile(workspaceActions: Pick<DaemonWorkspaceActions, 'readFileBytes' | 'stat'>, workspacePath: string, mimeType?: string, isCancelled?: () => boolean): Promise<void>;
+export declare function getArtifactLocation(artifact: DaemonSessionArtifact): string;
+export declare function normalizePath(value: string | undefined): string;
+export declare function stripWorkspacePath(path: string, workspaceCwd?: string): string;
+export declare function isSamePath(left: string | undefined, right: string | undefined, workspaceCwd?: string): boolean;
+export declare function artifactPreviewDocument(html: string, title: string): string;
+export declare function withArtifactPreviewCsp(html: string): string;

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

@@ -0,0 +1,7 @@
+import type { DaemonSessionArtifact } from '@qwen-code/sdk/daemon';
+import type { ACPToolCall, Message } from '../../adapters/types';
+import type { TurnOutputFileChange, TurnOutputScheduledTask } from './TurnOutputs';
+export declare function getArtifactsByTurn(messages: readonly Message[], artifacts: readonly DaemonSessionArtifact[], workspaceCwd?: string): ReadonlyMap<string, readonly DaemonSessionArtifact[]>;
+export declare function getFileChangesByTurn(messages: readonly Message[], artifactsByTurn: ReadonlyMap<string, readonly DaemonSessionArtifact[]>, workspaceCwd?: string): ReadonlyMap<string, readonly TurnOutputFileChange[]>;
+export declare function getScheduledTasksByTurn(messages: readonly Message[]): ReadonlyMap<string, readonly TurnOutputScheduledTask[]>;
+export declare function getToolFilePath(tool: ACPToolCall): string | undefined;

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

@@ -0,0 +1,16 @@
+import type { DaemonCapabilities } from '@qwen-code/sdk/daemon';
+import { type DaemonWorkspaceActions } from '@qwen-code/web-shell/daemon-react-sdk';
+export type ArtifactWorkspaceActions = Pick<DaemonWorkspaceActions, 'readWorkspaceFile' | 'readFileBytes' | 'stat' | 'listScheduledTasks' | 'updateScheduledTask' | 'deleteScheduledTask'>;
+interface ArtifactWorkspaceOwner {
+    cwd: string;
+    id?: string;
+    primary: boolean;
+}
+export interface ArtifactWorkspaceTarget {
+    workspaceCwd: string;
+    workspaceId?: string;
+    actions: ArtifactWorkspaceActions;
+}
+export declare function resolveArtifactWorkspaceOwner(capabilities: DaemonCapabilities | undefined, workspaceCwd: string | undefined): ArtifactWorkspaceOwner | undefined;
+export declare function useArtifactWorkspaceTarget(workspaceCwd: string | undefined): ArtifactWorkspaceTarget | undefined;
+export {};

package/dist/types/components/channels/ChannelEditorDialog.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonChannelInstanceSnapshot, DaemonChannelPairingApprovalResult, DaemonChannelPairingApprovalsSnapshot, DaemonChannelPairingRequestsSnapshot, DaemonChannelPairingRevocationRequest, DaemonChannelPairingRevocationResult, DaemonChannelTypeDescriptor, DaemonChannelUpsertRequest, DaemonWorkspaceCapability } from '@qwen-code/sdk/daemon';
+export interface ChannelEditorDialogProps {
+    open: boolean;
+    descriptor: DaemonChannelTypeDescriptor;
+    instance?: DaemonChannelInstanceSnapshot;
+    expectedRevision: string;
+    existingNames: readonly string[];
+    workspaces: readonly DaemonWorkspaceCapability[];
+    workspaceCwd: string;
+    workspaceLoading?: boolean;
+    onWorkspaceChange: (workspaceCwd: string) => void;
+    onOpenChange: (open: boolean) => void;
+    onSave: (name: string, request: DaemonChannelUpsertRequest) => Promise<unknown>;
+    onReload: () => Promise<unknown>;
+    listPairingRequests: (name: string) => Promise<DaemonChannelPairingRequestsSnapshot>;
+    approvePairingRequest: (name: string, code: string) => Promise<DaemonChannelPairingApprovalResult>;
+    listPairingApprovals: (name: string) => Promise<DaemonChannelPairingApprovalsSnapshot>;
+    revokePairingApproval: (name: string, request: DaemonChannelPairingRevocationRequest) => Promise<DaemonChannelPairingRevocationResult>;
+}
+export declare function ChannelEditorDialog({ open, descriptor, instance, expectedRevision, existingNames, workspaces, workspaceCwd, workspaceLoading, onWorkspaceChange, onOpenChange, onSave, onReload, listPairingRequests, approvePairingRequest, listPairingApprovals, revokePairingApproval, }: ChannelEditorDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/channels/ChannelPairingRequests.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonChannelPairingApprovalResult, DaemonChannelPairingApprovalsSnapshot, DaemonChannelPairingRequestsSnapshot, DaemonChannelPairingRevocationRequest, DaemonChannelPairingRevocationResult } from '@qwen-code/sdk/daemon';
+export interface ChannelPairingRequestsProps {
+    channelName: string;
+    listRequests: (name: string) => Promise<DaemonChannelPairingRequestsSnapshot>;
+    approveRequest: (name: string, code: string) => Promise<DaemonChannelPairingApprovalResult>;
+    listApprovals: (name: string) => Promise<DaemonChannelPairingApprovalsSnapshot>;
+    revokeApproval: (name: string, request: DaemonChannelPairingRevocationRequest) => Promise<DaemonChannelPairingRevocationResult>;
+    staticAllowedUsers?: readonly string[];
+}
+export declare function ChannelPairingRequests({ channelName, listRequests, approveRequest, listApprovals, revokeApproval, staticAllowedUsers, }: ChannelPairingRequestsProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/channels/ChannelsManagerPage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type Ref } from 'react';
+interface ChannelsManagerPageProps {
+    onClose: () => void;
+    initialFocusRef?: Ref<HTMLHeadingElement>;
+}
+export declare function ChannelsManagerPage({ onClose, initialFocusRef, }: ChannelsManagerPageProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/channels/channel-editor-state.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonChannelInstanceSnapshot, DaemonChannelSecretUpdate, DaemonChannelTypeDescriptor, DaemonChannelUpsertRequest } from '@qwen-code/sdk/daemon';
+export type ChannelSenderPolicy = 'pairing' | 'open' | '';
+export interface ChannelSecretDraft {
+    operation: DaemonChannelSecretUpdate['operation'];
+    value?: string;
+}
+export interface ChannelEditorDraft {
+    name: string;
+    values: Record<string, string | boolean>;
+    secrets: Record<string, ChannelSecretDraft>;
+    senderPolicy: ChannelSenderPolicy;
+    allowedGroupIds: string;
+}
+export type ChannelEditorValidationCode = 'required' | 'credential' | 'duplicate' | 'invalid' | 'invalidGroupId' | 'invalidOption' | 'number' | 'outOfRange' | 'policy';
+export type ChannelEditorValidationErrors = Record<string, ChannelEditorValidationCode>;
+export declare function hasDescriptorSenderPolicy(descriptor: DaemonChannelTypeDescriptor): boolean;
+export declare function hasDescriptorGroupPolicy(descriptor: DaemonChannelTypeDescriptor): boolean;
+export declare function createChannelEditorDraft(descriptor: DaemonChannelTypeDescriptor, instance?: DaemonChannelInstanceSnapshot): ChannelEditorDraft;
+export declare function validateChannelEditorDraft(descriptor: DaemonChannelTypeDescriptor, draft: ChannelEditorDraft, existingNames: readonly string[]): ChannelEditorValidationErrors;
+export declare function buildChannelUpsertRequest(descriptor: DaemonChannelTypeDescriptor, draft: ChannelEditorDraft, expectedRevision: string, instance?: DaemonChannelInstanceSnapshot): DaemonChannelUpsertRequest;

package/dist/types/components/channels/channel-platform.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonChannelTypeDescriptor } from '@qwen-code/sdk/daemon';
+export declare const PLATFORM_MARKS: Record<string, string>;
+export declare function isSupportedChannelType(type: unknown): type is 'dingtalk' | 'dws' | 'wecom' | 'feishu' | 'github' | 'gitlab';
+export declare function isChannelPlatformAvailable(descriptor: DaemonChannelTypeDescriptor): boolean;

package/dist/types/components/composer/AddMenu.d.ts

@@ -0,0 +1,20 @@
+import type { SkillInfo } from '../../completions/slashCompletion';
+import type { WebShellComposerTag } from '../../customization';
+import type { AtMentionWorkspaceActions } from '../../hooks/useAtMentionSources';
+export interface AddMenuProps {
+    disabled?: boolean;
+    availabilityKey: string;
+    addFileAvailable: boolean;
+    uploadAvailable: boolean;
+    onAddFiles: (files: File[], destination: 'attach' | 'upload') => void;
+    onFilePickerCancel: () => void;
+    onInsertReference: (tag: WebShellComposerTag) => void;
+    onPrependSkill: (invocation: string) => void;
+    getWorkspaceActions: () => AtMentionWorkspaceActions | undefined;
+    skills: readonly SkillInfo[];
+    onSkillsOpenChange?: (open: boolean) => void;
+    skillsLoading?: boolean;
+    skillsLoadError?: boolean;
+    skillsLoaded?: boolean;
+}
+export declare function AddMenu({ disabled, availabilityKey, addFileAvailable, uploadAvailable, onAddFiles, onFilePickerCancel, onInsertReference, onPrependSkill, getWorkspaceActions, skills, onSkillsOpenChange, skillsLoading, skillsLoadError, skillsLoaded, }: AddMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/composer/prependSkillInvocation.d.ts

@@ -0,0 +1,12 @@
+export interface PrependSkillTransaction {
+    changes: {
+        from: 0;
+        to: 0;
+        insert: string;
+    };
+    selection: {
+        anchor: number;
+    };
+    scrollIntoView: true;
+}
+export declare function computePrependSkillTransaction(currentDoc: string, invocation: string): PrependSkillTransaction | null;

package/dist/types/components/dialogs/AddWorkspaceDialog.d.ts

@@ -0,0 +1,24 @@
+export interface WorkspacePathSuggestion {
+    name: string;
+    path: string;
+}
+export interface WorkspacePathSuggestions {
+    dir: string;
+    sep: string;
+    suggestions: WorkspacePathSuggestion[];
+    truncated: boolean;
+}
+interface AddWorkspaceDialogProps {
+    onClose: () => void;
+    onAdd: (cwd: string, persist: boolean, displayName?: string) => Promise<void>;
+    displayNameEnabled?: boolean;
+    /**
+     * Directory autocomplete backend. When provided, typing an absolute path
+     * surfaces matching subdirectories in a listbox under the input.
+     */
+    onSuggest?: (prefix: string) => Promise<WorkspacePathSuggestions>;
+    onPick?: () => Promise<string | undefined>;
+    persistenceSupported?: boolean;
+}
+export declare function AddWorkspaceDialog({ onClose, onAdd, displayNameEnabled, onSuggest, onPick, persistenceSupported, }: AddWorkspaceDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialogs/ApprovalModeDialog.d.ts

@@ -0,0 +1,7 @@
+interface ApprovalModeDialogProps {
+    currentMode: string;
+    sessionWorkflowEnabled?: boolean;
+    onSelect: (modeId: string) => void;
+}
+export declare function ApprovalModeDialog({ currentMode, onSelect, }: ApprovalModeDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialogs/DaemonStatusDialog.d.ts

@@ -0,0 +1,3 @@
+export declare function DaemonStatusDialog({ onChangeTarget, }?: {
+    onChangeTarget?: (daemonOrigin: string, token?: string) => boolean | void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dialogs/DeleteSessionDialog.d.ts

@@ -0,0 +1,8 @@
+interface DeleteSessionDialogProps {
+    onDeleted: (sessionIds: string[]) => void;
+    onError: (error: unknown) => void;
+    onClose: () => void;
+    workspaceCwd?: string;
+}
+export declare function DeleteSessionDialog({ onDeleted, onError, onClose, workspaceCwd, }: DeleteSessionDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialogs/DialogShell.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from 'react';
+type DialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'auto';
+interface DialogShellProps {
+    title: string;
+    subtitle?: string;
+    size?: DialogSize;
+    allowFullscreen?: boolean;
+    dismissible?: boolean;
+    onClose: () => void;
+    children: ReactNode;
+}
+export declare const DialogShellIdContext: import("react").Context<object | null>;
+export declare function isTopDialogShellId(shellId: object | null): boolean;
+export declare function DialogShell({ title, subtitle, size, allowFullscreen, dismissible, onClose, children, }: DialogShellProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialogs/GitDialog.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export type GitDialogView = 'diff' | 'log' | 'prs' | 'commit';
+export declare function GitDialog({ workspaceCwd, gitCwd, initialView, sessionId, resolveSessionForWorkspace, onClose, }: {
+    workspaceCwd: string;
+    gitCwd?: string;
+    initialView: GitDialogView;
+    sessionId?: string;
+    resolveSessionForWorkspace?: (cwd: string, forceCreate?: boolean) => Promise<string | undefined>;
+    onClose: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dialogs/GitDiffDialog.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare function GitDiffContent({ workspaceCwd, gitCwd, onSubtitleChange, }: {
+    workspaceCwd: string;
+    gitCwd?: string;
+    onSubtitleChange?: (subtitle: string | undefined) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function GitDiffDialog({ workspaceCwd, onClose, }: {
+    workspaceCwd: string;
+    onClose: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dialogs/GitHubPrsDialog.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare function GitHubPrsContent({ workspaceCwd, onSubtitleChange, }: {
+    workspaceCwd: string;
+    onSubtitleChange?: (subtitle: string | undefined) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dialogs/GitLogDialog.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare function GitLogContent({ workspaceCwd, gitCwd, onSubtitleChange, }: {
+    workspaceCwd: string;
+    gitCwd?: string;
+    onSubtitleChange?: (subtitle: string | undefined) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function GitLogDialog({ workspaceCwd, onClose, }: {
+    workspaceCwd: string;
+    onClose: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dialogs/GoalEditDialog.d.ts

@@ -0,0 +1,9 @@
+interface GoalEditDialogProps {
+    objective: string;
+    saving: boolean;
+    error?: string | null;
+    onSave: (objective: string) => void;
+    onClose: () => void;
+}
+export declare function GoalEditDialog({ objective, saving, error, onSave, onClose, }: GoalEditDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialogs/GoalsDialog.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+interface GoalsDialogProps {
+    /** Create a canonical Goal in a brand-new session and switch to it.
+     * Return `false` when session setup failed and the error was already shown;
+     * throw to render the control failure inline. */
+    onCreateGoal: (condition: string) => boolean | void | Promise<boolean | void>;
+    /** Open the session driving a goal — its transcript IS the goal's history. */
+    onOpenSession: (sessionId: string) => void;
+    onError: (error: unknown, fallback: string) => void;
+}
+export declare function GoalsDialog({ onCreateGoal, onOpenSession, onError, }: GoalsDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialogs/HelpDialog.d.ts

@@ -0,0 +1,6 @@
+import type { CommandInfo } from '../../adapters/types';
+interface HelpDialogProps {
+    commands: readonly CommandInfo[];
+}
+export declare function HelpDialog({ commands }: HelpDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialogs/ModelDialog.d.ts

@@ -0,0 +1,28 @@
+export type ModelDialogMode = 'main' | 'fast' | 'voice' | 'vision' | 'advisor' | 'image';
+interface ModelDialogProps {
+    mode?: ModelDialogMode;
+    loading?: boolean;
+    error?: Error;
+    onSelect: (modelId: string) => void;
+    models?: ModelDialogModel[];
+    currentModelId?: string;
+    filterModel?: (model: ModelDialogModel) => boolean;
+}
+export interface ModelDialogModel {
+    id: string;
+    baseModelId?: string;
+    label?: string;
+    authType?: string;
+    contextWindow?: number;
+    modalities?: {
+        image?: boolean;
+        pdf?: boolean;
+        audio?: boolean;
+        video?: boolean;
+    };
+    baseUrl?: string;
+    envKey?: string;
+    isRuntime?: boolean;
+}
+export declare function ModelDialog({ mode, loading, error, onSelect, models, currentModelId, filterModel, }: ModelDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialogs/ModelFallbacksDialog.d.ts

@@ -0,0 +1,14 @@
+export interface FallbackModelOption {
+    /** Base model id persisted in the modelFallbacks setting. */
+    baseId: string;
+    label: string;
+}
+export interface ModelFallbacksDialogProps {
+    models: FallbackModelOption[];
+    /** Currently configured fallback base ids, in priority order. */
+    current: string[];
+    max: number;
+    onConfirm: (baseIds: string[]) => void;
+    onClose: () => void;
+}
+export declare function ModelFallbacksDialog({ models, current, max, onConfirm, onClose, }: ModelFallbacksDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dialogs/ReleaseSessionDialog.d.ts

@@ -0,0 +1,8 @@
+interface ReleaseSessionDialogProps {
+    onReleased: (sessionId: string) => void;
+    onError: (error: unknown) => void;
+    onClose: () => void;
+    workspaceCwd?: string;
+}
+export declare function ReleaseSessionDialog({ onReleased, onError, onClose, workspaceCwd, }: ReleaseSessionDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialogs/ResumeDialog.d.ts

@@ -0,0 +1,7 @@
+interface ResumeDialogProps {
+    onSelect: (sessionId: string) => void;
+    onClose: () => void;
+    workspaceCwd?: string;
+}
+export declare function ResumeDialog({ onSelect, onClose, workspaceCwd, }: ResumeDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialogs/RewindDialog.d.ts

@@ -0,0 +1,12 @@
+import type { DaemonRewindSnapshotInfo, DaemonTranscriptBlock } from '@qwen-code/sdk/daemon';
+interface RewindDialogProps {
+    blocks: readonly DaemonTranscriptBlock[];
+    loadSnapshots: () => Promise<{
+        snapshots: DaemonRewindSnapshotInfo[];
+    }>;
+    rewind: (promptId: string) => Promise<void>;
+    onError: (error: unknown) => void;
+    onClose: () => void;
+}
+export declare function RewindDialog({ blocks, loadSnapshots, rewind, onError, onClose, }: RewindDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialogs/ScheduledTasksDialog.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonWorkspaceCapability, DaemonSessionSummary } from '@qwen-code/sdk/daemon';
+interface ScheduledTasksDialogProps {
+    /** Manual "run now": execute the task's prompt in its bound session (so it
+     * lands in the same transcript as its scheduled runs), or in the current
+     * session for an unbound task. The App wiring switches to that session. */
+    onRunPrompt: (prompt: string, sessionId: string | null) => void | Promise<void>;
+    /** Switch to the chat view with the composer primed to describe a task, so
+     * the agent can create it conversationally via its cron_create tool. */
+    onCreateViaChat: () => void;
+    /** Open a task's bound session — its transcript IS the task's run history.
+     * When absent, tasks fall back to the inline fire-timestamp list. */
+    onOpenSession?: (sessionId: string) => void;
+    /** Registered workspaces on a multi-workspace daemon (from capabilities).
+     * When more than one is present the page aggregates every trusted workspace's
+     * tasks (each card tagged with its workspace) and the New-task form offers a
+     * workspace picker. Absent or a single entry → the plain primary-only view. */
+    workspaces?: DaemonWorkspaceCapability[];
+    /** Forces all task operations through this workspace's route. */
+    lockedWorkspace?: DaemonWorkspaceCapability;
+    currentSession?: DaemonSessionSummary;
+    currentSessionSchedulingAvailable?: boolean;
+    onError: (error: unknown, fallback: string) => void;
+}
+export declare function ScheduledTasksDialog({ onRunPrompt, onCreateViaChat, onOpenSession, workspaces, lockedWorkspace, currentSession, currentSessionSchedulingAvailable, onError, }: ScheduledTasksDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialogs/SessionRow.d.ts

@@ -0,0 +1,46 @@
+import { type ReactNode } from 'react';
+import { type DaemonSessionSummary } from '@qwen-code/web-shell/daemon-react-sdk';
+interface SessionRowProps {
+    session: DaemonSessionSummary;
+    /** Roving keyboard/hover highlight. */
+    active: boolean;
+    /** The user's current session — marks it with the accent bar + ✓. */
+    current: boolean;
+    /** Confirmed target for a destructive action (release), distinct from cursor. */
+    confirmed?: boolean;
+    /** Non-actionable row (e.g. the current session, or an inactive one). */
+    disabled?: boolean;
+    /** Tooltip shown when `current` (the pseudo-element ✓ can't carry text). */
+    currentLabel?: string;
+    /** Stable id so the listbox can point `aria-activedescendant` at this row. */
+    optionId?: string;
+    /**
+     * `aria-selected` value. Per WAI-ARIA this marks the chosen value, not the
+     * roving highlight (which `aria-activedescendant` conveys) — so it defaults
+     * to `current`. Multi-select (delete) passes the checked state and release
+     * passes its confirmed target instead.
+     */
+    ariaSelected?: boolean;
+    /** Leading slot, e.g. a multi-select checkbox. */
+    leading?: ReactNode;
+    /** Trailing slot in the title row, e.g. a status badge. */
+    trailing?: ReactNode;
+    /** Test-only selector for the resume dialog's session options. */
+    resumeSelector?: boolean;
+    onClick: () => void;
+    /**
+     * Pointer moved over the row (real movement — see useListboxKeyboard). This
+     * updates the roving cursor only; callers that separate cursor from confirmed
+     * target (e.g. release/rewind) still keep the destructive action behind an
+     * explicit Enter/click + button flow.
+     */
+    onActivate?: () => void;
+}
+/**
+ * A session list row shared by the resume / delete / release dialogs. Owns the
+ * common shell (roving highlight, current marker, disabled state) and the
+ * identical metadata line (relative time · client count · active prompt);
+ * per-dialog affordances go through the `leading`/`trailing` slots.
+ */
+export declare function SessionRow({ session, active, current, confirmed, disabled, currentLabel, optionId, ariaSelected, leading, trailing, resumeSelector, onClick, onActivate, }: SessionRowProps): import("react/jsx-runtime").JSX.Element;
+export {};