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

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

@@ -0,0 +1,35 @@
+export interface ChartSeries {
+    /** Legend label. */
+    label: string;
+    /** Data points, oldest→newest; shares the x-axis with the other series. */
+    values: number[];
+    /** CSS color for the line + swatch, e.g. `'var(--primary)'`. Applied as an
+     *  SVG `stroke`/`fill` presentation attribute (not an inline style). */
+    color: string;
+}
+interface SvgLineChartProps {
+    series: ChartSeries[];
+    /** Epoch-ms timestamp per data point, aligned with `values`; drives the
+     *  hover tooltip's time line. */
+    timestamps?: number[];
+    /** Format a y value for the peak label, per-series current value, and hover. */
+    format?: (value: number) => string;
+    /** Format a bucket timestamp for the hover tooltip header. */
+    formatTime?: (t: number) => string;
+    /** Start the y-axis at 0 (default) so magnitudes read honestly, vs. auto-min
+     *  which exaggerates small wiggles. */
+    zeroBased?: boolean;
+    /** Accessible description of what the chart shows. */
+    ariaLabel?: string;
+    /** Localized prefix for the peak-value label (default `'peak'`). */
+    peakLabel?: string;
+}
+/**
+ * Dependency-free inline-SVG line chart for the Daemon Status dashboard. Draws
+ * one or more equal-length series on a shared, zero-based y-axis, with a hover
+ * cursor that reads out each series' value and the bucket time at that point.
+ * Kept deliberately small rather than pulling a charting lib into the
+ * self-contained, CSP-strict `serve --web` bundle.
+ */
+export declare function SvgLineChart({ series, timestamps, format, formatTime, zeroBased, ariaLabel, peakLabel, }: SvgLineChartProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,8 @@
+import { type WebShellTheme } from '../../themeContext';
+interface ThemeDialogProps {
+    currentTheme: WebShellTheme;
+    onSelect: (theme: WebShellTheme) => void;
+    onClose: () => void;
+}
+export declare function ThemeDialog({ currentTheme, onSelect, onClose, }: ThemeDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+interface HeatmapDay {
+    tokens: number;
+    /** cachedTokens / inputTokens for that day, 0..1. */
+    cacheReadRate: number;
+}
+interface TokenHeatmapProps {
+    /** Per-day cells keyed by local `YYYY-MM-DD`. */
+    heatmap: Record<string, HeatmapDay>;
+    /** Trailing days the daemon aggregated (drives the rendered window). */
+    days: number;
+}
+export declare function TokenHeatmap({ heatmap, days }: TokenHeatmapProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Daemon Status "统计 / Usage" tab: a Today/7D/30D period toggle over the
+ * selected range's totals + breakdown, a ~12-month token heatmap, and — below
+ * it — per-model token share, skill-call counts, and daily token/session
+ * charts for the range. Mounts only when the tab is active, so the aggregate
+ * loads on demand; the daemon caches it per range.
+ */
+export declare function UsageDashboardTab(): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+import styles from './DialogPrimitives.module.css';
+export declare function dp(...names: Array<keyof typeof styles | false | null | undefined>): string;

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

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Pure cron-schedule helpers for the Scheduled Tasks page — building a cron
+ * expression from the form's builder inputs, and turning a cron expression /
+ * last-fired timestamp into a localized label. Kept free of React and of the
+ * SDK task type so they can be unit-tested in isolation.
+ */
+export type Frequency = 'daily' | 'weekdays' | 'weekly' | 'hourly' | 'minutes' | 'custom';
+export interface BuilderState {
+    frequency: Frequency;
+    time: string;
+    weekday: number;
+    minuteInterval: number;
+    customCron: string;
+}
+/** Minimal `t()` shape — a key plus optional interpolation vars. */
+export type TranslateFn = (key: string, vars?: Record<string, string | number>) => string;
+export declare function parseHhmm(time: string): {
+    hh: number;
+    mm: number;
+} | null;
+/** Build a 5-field cron from the builder inputs. Returns null when the inputs
+ * for the chosen frequency are invalid (the caller surfaces a form error). */
+export declare function buildCron(state: BuilderState): string | null;
+/** Human-readable schedule label, localized. Covers the shapes the builder
+ * emits (the common cases in the reference design); anything else — including
+ * ranges/lists a power user hand-writes — falls back to the raw expression so
+ * the label is never wrong, only sometimes terse. */
+export declare function describeCron(cron: string, t: TranslateFn): string;
+/** The default builder state for a new task, and the fallback for fields a
+ * reversed cron doesn't drive. Single source of truth — the dialog imports this
+ * rather than keeping its own copy, so the create form and the cron-reversal
+ * can't drift apart. */
+export declare const DEFAULT_BUILDER: BuilderState;
+/**
+ * Best-effort inverse of {@link buildCron}: maps a cron expression back onto
+ * the builder so the edit form can prefill its pickers. Recognizes ONLY the
+ * shapes buildCron can round-trip losslessly (mirroring {@link describeCron});
+ * anything else — ranges, lists, a hand-written expression — falls back to the
+ * `custom` frequency with the raw cron, so editing a task can never silently
+ * rewrite a schedule it couldn't represent in the structured pickers.
+ */
+export declare function parseCronToBuilder(cron: string): BuilderState;
+/**
+ * Compact, localized countdown from a millisecond remainder: `"3h 12m"`,
+ * `"5m 20s"`, `"45s"`, or the "due now" label once elapsed. Shows the two
+ * most-significant units, dropping a zero secondary (`"3h"` not `"3h 0m"`), so
+ * the pill stays short. Unit words come from `t` (`scheduledTasks.dur.*`).
+ */
+export declare function formatCountdown(msRemaining: number, t: TranslateFn): string;
+/** "Last run: …" label, or "never run" for a task that has not genuinely
+ * fired. A fresh task is stamped with `lastFiredAt = floor(createdAt)` so the
+ * scheduler can't fire it during its creation minute — that stamp is NOT a
+ * real run, so anything at or before the creation minute reads as "never". */
+export declare function describeLastRun(task: {
+    createdAt: number;
+    lastFiredAt: number | null;
+}, t: TranslateFn): string;

package/dist/types/components/extensions/ExtensionsManagerPage.d.ts

@@ -0,0 +1,9 @@
+import { type Ref } from 'react';
+import type { EmbeddedManagerPage } from '../plugins/manager-page';
+interface ExtensionsManagerPageProps {
+    onClose: () => void;
+    initialFocusRef?: Ref<HTMLHeadingElement>;
+    embedded?: EmbeddedManagerPage;
+}
+export declare function ExtensionsManagerPage({ onClose, initialFocusRef, embedded, }: ExtensionsManagerPageProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,3 @@
+import type { DaemonExtensionEntry } from '@qwen-code/sdk/daemon';
+export declare function preserveSelectedExtensionName(name: string | null, extensions: readonly DaemonExtensionEntry[]): string | null;
+export declare function filterExtensions(extensions: readonly DaemonExtensionEntry[], query: string): DaemonExtensionEntry[];

package/dist/types/components/local-control-api.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface LanCandidate {
+    interfaceName: string;
+    address: string;
+}
+export interface LocalControlStatus {
+    active: boolean;
+    url?: string;
+    /**
+     * Set when the daemon withheld the pairing URL from this response because
+     * the request carried no credentials (#9106); the URL is printed to the
+     * daemon terminal instead.
+     */
+    urlRedacted?: boolean;
+    qrText?: string;
+    interfaceName?: string;
+    address?: string;
+    sleepInhibited?: boolean;
+    encrypted?: boolean;
+    interfaces?: LanCandidate[];
+}
+export declare class LocalControlRequestError extends Error {
+    readonly payload?: LocalControlStatus | undefined;
+    constructor(message: string, payload?: LocalControlStatus | undefined);
+}
+export declare function requestLocalControl(baseUrl: string, token: string | undefined, method: 'GET' | 'POST', path: string, body?: object): Promise<LocalControlStatus>;

package/dist/types/components/mcp/McpManagerPage.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+import type { SerializedMcpStatusMessage } from '../messages/McpStatusMessage';
+import type { EmbeddedManagerPage } from '../plugins/manager-page';
+interface McpManagerPageProps {
+    message?: SerializedMcpStatusMessage;
+    onClose: () => void;
+    embedded?: EmbeddedManagerPage;
+    workspaceCwd?: string;
+    workspaceControl?: ReactNode;
+}
+export declare function McpManagerPage({ message, onClose, embedded, workspaceCwd, workspaceControl, }: McpManagerPageProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,18 @@
+import type { PermissionRequest } from '../../adapters/types';
+interface AskUserQuestionProps {
+    request: PermissionRequest;
+    onConfirm: (id: string, selectedOption: string, answers?: Record<string, string>) => Promise<boolean>;
+    onError: (error: unknown, fallback: string) => void;
+    variant?: 'inline' | 'floating';
+    customInputLabel?: string;
+    /**
+     * Whether this question should pull keyboard focus to its first option when it
+     * becomes the topmost one. Defaults to true. Split-view panes pass false so an
+     * question in one pane doesn't steal focus from the pane the user is in; like
+     * ToolApproval, keyboard handling is focus-scoped, so it stays operable once
+     * the user tabs/clicks into it.
+     */
+    keyboardActive?: boolean;
+}
+export declare function AskUserQuestion({ request, onConfirm, onError, variant, keyboardActive, customInputLabel, }: AskUserQuestionProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,40 @@
+import { type WebShellAssistantTurnFooterRenderInfo, type WebShellSource } from '../../customization';
+import type { DaemonSessionGenerationEvent } from '@qwen-code/sdk/daemon';
+interface AssistantMessageProps {
+    content: string;
+    isStreaming?: boolean;
+    timestamp?: number;
+    onBranchSession?: () => void | Promise<void>;
+    showFooterActions?: boolean;
+    showBranchAction?: boolean;
+    isLocateFlashing?: boolean;
+    customFooterInfo?: WebShellAssistantTurnFooterRenderInfo;
+    turnSources?: readonly WebShellSource[];
+    onSourceOpen?: (source: WebShellSource) => void;
+}
+export declare const AssistantMessage: import("react").NamedExoticComponent<AssistantMessageProps>;
+interface ThinkingMessageProps {
+    content: string;
+    isStreaming?: boolean;
+    timestamp?: number;
+    isLocateFlashing?: boolean;
+    generateContent?: SessionContentGenerator;
+}
+export type SessionContentGenerator = (prompt: string, opts?: {
+    signal?: AbortSignal;
+}) => AsyncGenerator<DaemonSessionGenerationEvent>;
+export declare const ThinkingMessage: import("react").NamedExoticComponent<ThinkingMessageProps>;
+interface ThinkingTranslateButtonProps {
+    content: string;
+    generateContent?: SessionContentGenerator;
+    className?: string;
+    mode?: 'translate' | 'explain-shell';
+}
+export declare function ThinkingTranslateButton({ content, generateContent, className, mode, }: ThinkingTranslateButtonProps): import("react/jsx-runtime").JSX.Element;
+export declare function getThinkingSummaryKey({ isStreaming, durationMs, }: {
+    isStreaming?: boolean;
+    durationMs?: number;
+}): 'thinking.running' | 'thinking.done' | 'thinking.doneBriefly';
+export declare function formatThinkingDuration(ms: number): string;
+export declare function ThinkingDoneIcon(): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+interface AuthMessageProps {
+    onMessage: (text: string, type?: 'status' | 'error') => void;
+    onClose: () => void;
+}
+export declare function AuthMessage({ onMessage, onClose }: AuthMessageProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+interface BtwMessageProps {
+    question: string;
+    answer: string;
+    isPending: boolean;
+}
+export declare const BtwMessage: import("react").NamedExoticComponent<BtwMessageProps>;
+export {};

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

@@ -0,0 +1,9 @@
+import type { DaemonSessionContextUsageStatus } from '@qwen-code/web-shell/daemon-react-sdk';
+export declare function serializeContextUsageMessage(status: DaemonSessionContextUsageStatus): string;
+export declare function parseContextUsageMessage(content: string): DaemonSessionContextUsageStatus | null;
+export declare function ContextUsageMessage({ status, onShowDetail, compact, }: {
+    status: DaemonSessionContextUsageStatus;
+    /** Run /context detail, exactly like typing it. */
+    onShowDetail?: () => void;
+    compact?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,31 @@
+import { type CSSProperties, type ReactNode } from 'react';
+export interface EnhancedTableCell {
+    key: string;
+    content: ReactNode;
+    text: string;
+    rawText?: string;
+    isHeader: boolean;
+    textAlign?: CSSProperties['textAlign'];
+}
+export interface EnhancedTableRow {
+    key: string;
+    cells: EnhancedTableCell[];
+}
+export interface EnhancedTableData {
+    headers: EnhancedTableCell[];
+    rows: EnhancedTableRow[];
+    columnCount: number;
+}
+export declare const MAX_ENHANCED_TABLE_ROWS = 500;
+export declare const MAX_ENHANCED_TABLE_COLUMNS = 50;
+interface EnhancedMarkdownTableProps {
+    children?: ReactNode;
+    fallback?: ReactNode;
+    toolbarExtra?: ReactNode;
+}
+export declare function EnhancedMarkdownTable({ children, fallback, toolbarExtra, }: EnhancedMarkdownTableProps): import("react/jsx-runtime").JSX.Element;
+export declare function EnhancedTable({ table, toolbarExtra, }: {
+    table: EnhancedTableData;
+    toolbarExtra?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+import { type ComponentProps } from 'react';
+import type { Components, ExtraProps } from 'react-markdown';
+import type { WebShellFootnoteIconResolver, WebShellFootnotePreviewMount } from '../../customization';
+export declare function FootnoteSup({ node, children, linkComponent, iconResolver, mountPreview, ...props }: ComponentProps<'sup'> & ExtraProps & {
+    linkComponent?: Components['a'];
+    iconResolver?: WebShellFootnoteIconResolver;
+    mountPreview?: WebShellFootnotePreviewMount;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function FootnoteSection({ node, children, sectionComponent, ...props }: ComponentProps<'section'> & ExtraProps & {
+    sectionComponent?: Components['section'];
+}): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,9 @@
+import type { Components } from 'react-markdown';
+import type { WebShellFootnotePreviewMount } from '../../customization';
+import type { FootnotePreview } from './rehype-footnote-cards';
+export declare function FootnotePreviewContent({ notes, index, mount, linkComponent, }: {
+    notes: FootnotePreview[];
+    index: number;
+    mount?: WebShellFootnotePreviewMount;
+    linkComponent?: Components['a'];
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,5 @@
+export declare function GoalApprovalContent({ objective, content, id, }: {
+    objective: string;
+    content: string;
+    id: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,15 @@
+export type GoalStatusKind = 'set' | 'achieved' | 'cleared' | 'failed' | 'aborted' | 'blocked' | 'usage_limited' | 'paused' | 'checking';
+export interface SerializedGoalStatusMessage {
+    kind: GoalStatusKind;
+    condition: string;
+    iterations?: number;
+    durationMs?: number;
+    setAt?: number;
+    lastReason?: string;
+}
+declare const serializeGoalStatusMessage: (data: SerializedGoalStatusMessage) => string;
+declare function parseGoalStatusMessage(content: unknown): SerializedGoalStatusMessage | null;
+export { serializeGoalStatusMessage, parseGoalStatusMessage };
+export declare function GoalStatusMessage({ status, }: {
+    status: SerializedGoalStatusMessage;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+/**
+ * Plain-text renderer that turns explicit http(s) URLs into anchors. Mirrors
+ * MarkdownLink's safety (`isSafeHref`) and desktop-shell routing
+ * (`useExternalLinkOpener`); text without URLs passes through untouched.
+ */
+export declare const LinkifiedText: import("react").NamedExoticComponent<{
+    text: string;
+}>;

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

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

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

@@ -0,0 +1,38 @@
+import { type MarkdownTableMode, type MarkdownContentSource } from '../../customization';
+interface MarkdownProps {
+    content: string;
+    source?: MarkdownContentSource;
+    /**
+     * True while the message is still streaming in. Used to defer expensive,
+     * per-chunk rendering (Mermaid diagrams and Shiki syntax highlighting) until
+     * the content settles, avoiding flicker and wasted re-tokenization.
+     */
+    isStreaming?: boolean;
+    tableMode?: MarkdownTableMode;
+}
+export interface ResolvedFenceLanguage {
+    /** What the user typed, in its original case, shown in the code-block header. */
+    label: string;
+    /** Canonical language id (aliases resolved); also used to detect mermaid. */
+    lang: string;
+    /** A supported Shiki language id, or 'text' when unsupported (no highlight). */
+    resolvedLang: string;
+}
+export declare function resolveFenceLanguage(rawLang: string | undefined): ResolvedFenceLanguage;
+export declare function isSafeHref(url: string | undefined): boolean;
+export declare function isSafeImageSrc(url: string | undefined, documentMode?: boolean): boolean;
+/**
+ * react-markdown sanitizes every href through `defaultUrlTransform`, which
+ * allows only `http(s)`, `irc(s)`, `mailto` and `xmpp` and rewrites everything
+ * else to `''`. Without this, `qwen-session://<id>` never reaches
+ * {@link MarkdownLink} with its scheme intact, the interception below is dead
+ * code, and the link renders as an inert anchor.
+ *
+ * Letting the scheme through is safe: `MarkdownLink` never puts it in the DOM.
+ * It renders `href="#"` and dispatches the id as an event, so nothing navigates
+ * to a `qwen-session:` URL — and an unknown scheme is inert in a browser anyway.
+ * Every other href keeps the default sanitizer.
+ */
+export declare function markdownUrlTransform(url: string, documentMode?: boolean): string;
+export declare const Markdown: import("react").NamedExoticComponent<MarkdownProps>;
+export {};

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

@@ -0,0 +1,65 @@
+import { type CSSProperties, type ReactElement, type ReactNode } from 'react';
+import { ChartRendererRegistry, type JsonPrimitive, type JsonValue } from '@datafe-open/markdown-chart';
+import { type CreateEChartsRendererOptions } from '@datafe-open/markdown-chart-echarts';
+import type { Components } from 'react-markdown';
+import type { CodeBlockRenderer, WebShellMarkdownChartCustomization } from '../../customization';
+import type { WebShellTheme } from '../../themeContext';
+export declare const ECHARTS_FULLDATA_LANGUAGE = "echarts-fulldata";
+export type DatasetCell = JsonPrimitive;
+export interface EchartsFullDataOption {
+    readonly [key: string]: JsonValue | undefined;
+}
+export interface EchartsInstance {
+    setOption(option: EchartsFullDataOption, opts?: {
+        readonly notMerge?: boolean;
+    }): void;
+    resize(): void;
+    dispose(): void;
+}
+export interface EchartsRuntime {
+    init(element: HTMLElement, theme?: string): EchartsInstance;
+}
+export type EchartsRuntimeLoader = () => EchartsRuntime | Promise<EchartsRuntime>;
+export interface EchartsFullDataResolvedDataset {
+    readonly dimensions: string[];
+    readonly source: DatasetCell[][];
+}
+export interface EchartsFullDataRefMeta {
+    readonly dimensions: string[];
+    readonly format: 'csv' | 'json';
+}
+export type EchartsFullDataRefResolver = (ref: string, meta: EchartsFullDataRefMeta) => EchartsFullDataResolvedDataset | Promise<EchartsFullDataResolvedDataset>;
+export interface EchartsFullDataBlockProps {
+    readonly option?: EchartsFullDataOption;
+    readonly parseError?: string;
+    readonly isStreaming?: boolean;
+    readonly theme: WebShellTheme;
+    readonly loadEcharts?: EchartsRuntimeLoader;
+}
+export interface EchartsFullDataRendererOptions {
+    readonly loadEcharts?: EchartsRuntimeLoader;
+    readonly resolveDataRef?: EchartsFullDataRefResolver;
+}
+export declare function createMarkdownChartRegistry(options?: CreateEChartsRendererOptions): ChartRendererRegistry;
+export declare const DEFAULT_WEB_SHELL_MARKDOWN_CHART: WebShellMarkdownChartCustomization;
+export declare function createWebShellMarkdownChartPre(registry: ChartRendererRegistry, options?: {
+    readonly chartClassName?: string;
+    readonly chartStyle?: CSSProperties;
+}): NonNullable<Components['pre']>;
+export declare function WebShellMarkdownChartProvider({ customization, source, streaming, theme, children, }: {
+    readonly customization: WebShellMarkdownChartCustomization;
+    readonly source: string;
+    readonly streaming: boolean;
+    readonly theme: WebShellTheme;
+    readonly children: ReactNode;
+}): ReactElement;
+/**
+ * @deprecated Configure `markdown.chart.registry` with
+ * `createMarkdownChartRegistry` instead.
+ */
+export declare function createEchartsFullDataRenderer(options?: EchartsFullDataRendererOptions): CodeBlockRenderer;
+/**
+ * @deprecated Configure `markdown.chart.registry` and emit a Markdown chart
+ * fence instead.
+ */
+export declare function EchartsFullDataBlock({ option, parseError, isStreaming, theme, loadEcharts, }: EchartsFullDataBlockProps): ReactElement;

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

@@ -0,0 +1,21 @@
+import { AppBridge } from '@modelcontextprotocol/ext-apps/app-bridge';
+type SandboxResource = Parameters<AppBridge['sendSandboxResourceReady']>[0];
+type AppToolResult = Parameters<AppBridge['sendToolResult']>[0];
+export interface McpAppDisplay {
+    type: 'mcp_app';
+    serverName: string;
+    resourceUri: string;
+    html: string;
+    toolResult: AppToolResult;
+    toolArguments: Record<string, unknown>;
+    fallbackText: string;
+    csp?: SandboxResource['csp'];
+    permissions?: SandboxResource['permissions'];
+}
+export declare function getMcpAppDisplay(value: unknown): McpAppDisplay | undefined;
+export declare function resolveMcpAppSandboxUrl(daemonBaseUrl: string, hostUrl: string): string | undefined;
+export declare function applySandboxCspQuery(sandboxUrl: string, cspJson: string): string;
+export declare function McpApp({ display }: {
+    display: McpAppDisplay;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,22 @@
+import type { DaemonWorkspaceActions, DaemonWorkspaceMcpToolsStatus, DaemonWorkspaceMcpResourcesStatus } from '@qwen-code/web-shell/daemon-react-sdk';
+type DaemonWorkspaceMcpStatus = Awaited<ReturnType<DaemonWorkspaceActions['loadMcpStatus']>>;
+interface SerializedMcpStatusMessage {
+    status: DaemonWorkspaceMcpStatus;
+    toolsByServer: Record<string, DaemonWorkspaceMcpToolsStatus>;
+    /**
+     * Per-server MCP resources, preloaded alongside tools so the dialog can
+     * browse them offline. Keyed by server name. Optional because messages
+     * serialized by older clients omit it — consumers must read defensively
+     * (`?? {}`), and the optional type forces that at compile time.
+     */
+    resourcesByServer?: Record<string, DaemonWorkspaceMcpResourcesStatus>;
+    showDescriptions: boolean;
+    showSchema: boolean;
+    showTips: boolean;
+}
+declare const serializeMcpStatusMessage: (data: SerializedMcpStatusMessage) => string;
+declare function parseMcpStatusMessage(content: string): SerializedMcpStatusMessage | null;
+export { serializeMcpStatusMessage, parseMcpStatusMessage, type SerializedMcpStatusMessage, };
+export declare function McpStatusMessage({ message, }: {
+    message: SerializedMcpStatusMessage;
+}): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,9 @@
+import { type DaemonContextFileScope } from '@qwen-code/web-shell/daemon-react-sdk';
+interface MemoryMessageProps {
+    refreshSignal?: number;
+    addSignal?: number;
+    addScope?: DaemonContextFileScope;
+    onMessage?: (message: string, type?: 'status' | 'error') => void;
+}
+export declare function MemoryMessage({ refreshSignal, addSignal, addScope, onMessage, }: MemoryMessageProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,23 @@
+import type { DaemonModelConfiguration, DaemonModelConfigurationUpdateResult } from '@qwen-code/sdk/daemon';
+import type { DaemonWorkspaceProviderStatus } from '@qwen-code/web-shell/daemon-react-sdk';
+export interface ModelDeleteTarget {
+    key?: string;
+    authType: string;
+    modelId: string;
+    baseUrl?: string;
+}
+export interface ModelManagementProps {
+    providers: DaemonWorkspaceProviderStatus[];
+    configurations?: DaemonModelConfiguration[];
+    onUpdateContextWindow?: (key: string, size: number | null) => Promise<DaemonModelConfigurationUpdateResult>;
+    /** Effective current model id (ACP or base form), for the "current" badge. */
+    currentModelId: string | undefined;
+    loading: boolean;
+    error: Error | undefined;
+    /** True while a select/delete request is in flight. */
+    busy: boolean;
+    onSelectModel: (modelId: string) => void;
+    onDeleteModel: (target: ModelDeleteTarget) => void;
+    onAddModel: () => void;
+}
+export declare function ModelManagementSection({ providers, configurations, onUpdateContextWindow, currentModelId, loading, error, busy, onSelectModel, onDeleteModel, onAddModel, }: ModelManagementProps): import("react/jsx-runtime").JSX.Element;