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

package/dist/types/daemon/session/types.d.ts

@@ -0,0 +1,568 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ReactNode } from 'react';
+import type { CreateSessionRequest, DaemonCapabilities, DaemonBackgroundTurn, DaemonEvent, DaemonApprovalMode, DaemonApprovalModeResult, DaemonAvailableCommand, DaemonForkSessionResult, DaemonInputAnnotation, DaemonSessionBtwResult, DaemonSessionGenerationEvent, DaemonSessionAttachmentReference, DaemonSessionAttachmentData, DaemonMidTurnMessageResult, DaemonMidTurnMessagesResult, DaemonRemoveMidTurnMessageResult, DaemonPendingPromptsResult, DaemonRemovePendingPromptResult, DaemonSessionContextStatus, DaemonSessionSavedWorkflowDetail, DaemonSessionContextUsageStatus, DaemonSessionRecapResult, DaemonRewindResult, DaemonRewindSnapshotInfo, DaemonSession, DaemonSessionSummary, DaemonSessionSupportedCommandsStatus, DaemonSessionTaskWithWorkflowStatus, DaemonSessionTasksStatus, DaemonSessionWorkflowTaskStatus, DaemonSessionWorkflowTasksStatus, DaemonSessionStatsStatus, DaemonSessionArtifactsEnvelope, SessionSourceInput, SessionSourcesResult, SessionSourceUpsertResult, SessionSourceRemoveResult, DaemonSkillToggleMutation, DaemonShellCommandResult, DaemonTranscriptBlock, DaemonTranscriptStore, DaemonWorkspaceGitStatus, DaemonWorkspaceProvidersStatus, DaemonStandaloneCreationRecovery, DaemonStandaloneWorkingDirectory, HeartbeatResult, GoalControlRequest, GoalSnapshotV2, GoalStateResponse, PermissionResponse, PromptContentBlock, PromptResult, ReasoningSelection, SessionMetadataResult, SetModelResult } from '@qwen-code/sdk/daemon';
+export type DaemonConnectionStatus = 'idle' | 'connecting' | 'connected' | 'disconnected' | 'error';
+export interface DaemonSessionOwnerSnapshot {
+    isCurrent(): boolean;
+}
+export interface DaemonSessionOwnerGuard {
+    capture(options?: {
+        includeRecovery?: boolean;
+    }): DaemonSessionOwnerSnapshot;
+}
+export type DaemonProductSessionContext = {
+    kind: 'workspace';
+    cwd: string;
+} | {
+    kind: 'standalone';
+} | {
+    kind: 'live';
+};
+export interface DaemonStandaloneConnectionState {
+    projectlessOutputDirectory?: string;
+    workingDirectory?: DaemonStandaloneWorkingDirectory;
+    creationRecovery?: DaemonStandaloneCreationRecovery;
+    errorCode?: string;
+}
+export interface DaemonConnectionState {
+    status: DaemonConnectionStatus;
+    sessionId?: string;
+    /**
+     * Daemon-confirmed client identity bound to this session (the value sent as
+     * `X-Qwen-Client-Id`). Consumers use it to recognize their OWN
+     * originator-stamped legacy frames. Stable-id mid-turn queues are shared by
+     * the session and do not use this id as an ownership boundary.
+     */
+    clientId?: string;
+    /** Explicit product and restore context for the current or pending session. */
+    sessionContext?: DaemonProductSessionContext;
+    /** Product workspace cwd. Always absent for standalone and Live contexts. */
+    workspaceCwd?: string;
+    /** Standalone-only working-directory and outcome recovery state. */
+    standaloneSession?: DaemonStandaloneConnectionState;
+    /** Current Git branch, short detached-HEAD hash, or undefined outside Git. */
+    gitBranch?: string;
+    /**
+     * Last enriched working-tree summary for the current workspace, pushed by
+     * the daemon via `git_status_changed` (only set when the event's
+     * workspaceCwd matches this connection's workspace).
+     */
+    gitStatus?: DaemonWorkspaceGitStatus;
+    commands?: DaemonCommandInfo[];
+    skills?: string[];
+    models?: DaemonModelInfo[];
+    currentModel?: string;
+    reasoning?: DaemonReasoningControls;
+    currentMode?: string;
+    planExecutionMode?: string;
+    displayName?: string;
+    titleSource?: 'manual' | 'auto';
+    /** Latest main-conversation model usage event. */
+    tokenUsage?: DaemonTokenUsage;
+    /** Authoritative Goal v2 state for the current session. */
+    goalState?: GoalSnapshotV2;
+    backgroundTurn?: DaemonBackgroundTurn;
+    /** Stops a lagging live-state snapshot from reviving the finished execution. */
+    finishedBackgroundTurnId?: string;
+    /** Local monotonic time; orders background events against live-state requests. */
+    backgroundTurnObservedAt?: number;
+    /** Current context-window occupancy, used with contextWindow for percentages. */
+    tokenCount?: number;
+    contextWindow?: number;
+    providers?: DaemonWorkspaceProvidersStatus;
+    supportedCommands?: DaemonSessionSupportedCommandsStatus;
+    context?: DaemonSessionContextStatus;
+    capabilities?: DaemonCapabilities;
+    /** True while the current session transcript is being loaded. */
+    loadingTranscript?: boolean;
+    /** True while replaying buffered events after a reconnect. */
+    catchingUp?: boolean;
+    error?: string;
+    /** Latest HTTP error status kept for diagnostics; use missingSession for UI. */
+    errorStatus?: number;
+    /** True only when the server confirmed the current session is missing. */
+    missingSession?: boolean;
+}
+export interface DaemonReasoningControls {
+    enabled: boolean;
+    effort: ReasoningSelection;
+    efforts: Array<Exclude<ReasoningSelection, 'none' | 'default'>>;
+    /** The model default when the daemon advertises one. */
+    defaultEffort?: Exclude<ReasoningSelection, 'none' | 'default'>;
+    enableValue?: 'default';
+    canEnable?: false;
+    /** Defaults to true. False means effort is mutable but thinking is required. */
+    canDisable?: boolean;
+}
+export interface DaemonTokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    thoughtTokens?: number;
+    cachedReadTokens?: number;
+}
+export interface DaemonSessionProviderProps {
+    /** Daemon base URL. Optional when nested inside DaemonWorkspaceProvider (inherited). */
+    baseUrl?: string;
+    /** Bearer token. Optional when nested inside DaemonWorkspaceProvider (inherited). */
+    token?: string;
+    /** Legacy workspace context. Do not combine with standalone or Live context. */
+    workspaceCwd?: string;
+    /** Explicit product context. Legacy callers may continue using workspaceCwd. */
+    sessionContext?: DaemonProductSessionContext;
+    /** Session id to load. Undefined keeps the page empty until a prompt creates one. */
+    sessionId?: string;
+    /** Stable client identity to reuse for session-scoped daemon requests. */
+    clientId?: string;
+    /**
+     * Creator attribution forwarded on workspace session load/resume. The
+     * daemon applies it only when the restored session has no persisted source,
+     * so a host (e.g. the VS Code companion) reclaims its pre-attribution
+     * sessions on first open without ever overwriting existing attribution.
+     */
+    sessionSourceType?: string;
+    /** Extra create-session options, excluding workspaceCwd which is owned by the provider. */
+    createSessionRequest?: Omit<CreateSessionRequest, 'workspaceCwd'>;
+    /** Maximum queued SSE events requested from the daemon per subscription. */
+    maxQueued?: number;
+    /** Maximum normalized transcript blocks retained in memory. */
+    maxBlocks?: number;
+    /**
+     * Maximum estimated bytes of transcript blocks retained in memory.
+     * Trimming evicts oldest blocks until the estimate is back under this
+     * budget; a block-count window alone is not a memory ceiling because
+     * blocks can carry large raw tool payloads. Defaults to the transcript
+     * store's built-in budget.
+     */
+    maxRetainedBytes?: number;
+    /** Latest persisted records requested during an existing-session load. */
+    historyPageSize?: number;
+    /** Keep the full subagent transcript, or retain only bounded root summaries. */
+    subagentTranscriptMode?: 'full' | 'summary';
+    /** Hide this client's own user prompt echo when the daemon replays events. */
+    suppressOwnUserEcho?: boolean;
+    /** Attach raw daemon events to normalized transcript blocks for debugging. */
+    includeRawEvent?: boolean;
+    /**
+     * Fetch the branch during initialization and session loading. Defaults to
+     * true; disable when the UI owns Git status loading. Changing this option
+     * reconnects the session.
+     */
+    prefetchGitBranch?: boolean;
+    /**
+     * Preload sessionless Skills. Defaults to true; disable when the UI loads
+     * Skills on demand. Changing this option reconnects the session.
+     */
+    prefetchSkills?: boolean;
+    /** Connect to the daemon automatically on mount. */
+    autoConnect?: boolean;
+    /** Reconnect automatically after recoverable daemon/session failures. */
+    autoReconnect?: boolean;
+    /**
+     * Restart a live SSE event stream after each accepted prompt. A stream that
+     * is already down is always rebuilt immediately on prompt admission,
+     * regardless of this flag.
+     */
+    restartEventStreamOnPrompt?: boolean;
+    /** Initial reconnect delay in milliseconds. */
+    reconnectDelayMs?: number;
+    /** Maximum reconnect delay in milliseconds after backoff. */
+    maxReconnectDelayMs?: number;
+    /** Interval in milliseconds for client heartbeat checks. */
+    heartbeatIntervalMs?: number;
+    /** Consecutive heartbeat failures before marking the session disconnected. */
+    heartbeatFailureThreshold?: number;
+    /** Optional user-facing fallback warnings for partial session load failures. */
+    loadWarnings?: {
+        /** Warning shown when model/provider status cannot be loaded. */
+        models?: string;
+        /** Warning shown when supported command metadata cannot be loaded. */
+        commands?: string;
+        /** Warning shown when session context metadata cannot be loaded. */
+        context?: string;
+    };
+    /** React children rendered inside the daemon session contexts. */
+    children: ReactNode;
+}
+export type DaemonPromptStatus = 'idle' | 'waiting' | 'streaming';
+export type DaemonNoticeSeverity = 'info' | 'warning' | 'error';
+export type DaemonNoticeCategory = 'validation' | 'user_action' | 'connection' | 'protocol' | 'lifecycle' | 'system';
+export type DaemonNoticeOperation = 'send_prompt' | 'continue_session' | 'send_shell_command' | 'switch_model' | 'set_reasoning_effort' | 'set_approval_mode' | 'submit_permission' | 'cancel_prompt' | 'attach_session' | 'load_session' | 'resume_session' | 'create_session' | 'close_session' | 'rename_session' | 'release_session' | 'list_sessions' | 'load_context' | 'load_context_usage' | 'load_tasks' | 'load_artifacts' | 'read_attachment' | 'remove_attachment' | 'cancel_task' | 'control_workflow' | 'run_saved_workflow' | 'read_saved_workflow' | 'load_goal' | 'control_goal' | 'clear_goal' | 'load_stats' | 'rewind_snapshots' | 'rewind_session' | 'refresh_commands' | 'recap_session' | 'generate_session_content' | 'btw_session' | 'branch_session' | 'fork_session' | 'record_session' | 'stream' | 'normalize_event';
+export interface DaemonSessionNotice {
+    id: string;
+    severity: DaemonNoticeSeverity;
+    category: DaemonNoticeCategory;
+    operation?: DaemonNoticeOperation;
+    code: string;
+    message: string;
+    debugMessage?: string;
+    recoverable?: boolean;
+    sourceRetry?: () => Promise<void>;
+    createdAt: number;
+}
+type AddDaemonSessionNoticeInput = Omit<DaemonSessionNotice, 'id' | 'createdAt'> & {
+    id?: string;
+    createdAt?: number;
+};
+export type AddDaemonSessionNotice = (notice: AddDaemonSessionNoticeInput) => DaemonSessionNotice;
+export interface DaemonModelInfo {
+    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;
+    reasoningPreview?: DaemonReasoningControls;
+}
+export interface DaemonCommandInfo {
+    name: string;
+    description: string;
+    argumentHint?: string;
+    autoSubmit?: boolean;
+    source?: string;
+    altNames?: string[];
+    raw: DaemonAvailableCommand;
+}
+export interface SendPromptOptions {
+    /** Original text declared at the user submission boundary, before host preparation. */
+    submittedPrompt?: string;
+    optimisticUserMessage?: boolean;
+    images?: DaemonPromptImage[];
+    files?: DaemonPromptFile[];
+    inputAnnotations?: DaemonInputAnnotation[];
+    /**
+     * When true, the daemon strips orphaned user entries from the chat
+     * history before re-sending, and skips recording a duplicate user
+     * message in the JSONL transcript. Used by Ctrl+Y retry.
+     */
+    retry?: boolean;
+    /** Fired after local validation, immediately before dispatch to the daemon. */
+    onAdmissionStarted?: () => void;
+    /**
+     * Fired once the daemon has ACCEPTED the prompt (admission), before the turn
+     * runs to completion. Lets a caller act on "the prompt reached the session"
+     * without waiting for the whole turn — e.g. the scheduled-tasks "run now",
+     * which records the run at admission so a long/stalled turn or a closed tab
+     * can't lose the record.
+     */
+    onAdmitted?: () => void;
+}
+export interface SubmitPromptOptions extends SendPromptOptions {
+    sessionId?: string;
+    signal?: AbortSignal;
+}
+export interface PendingPromptActionOptions {
+    sessionId?: string;
+}
+export interface GetTasksActionOptions {
+    silent?: boolean;
+}
+export interface DaemonPromptImage {
+    data: string;
+    mimeType?: string;
+    mediaType?: string;
+    media_type?: string;
+}
+export interface DaemonPromptFile {
+    name: string;
+    data?: Blob;
+    text?: string;
+    mimeType?: string;
+    mediaType?: string;
+    media_type?: string;
+}
+export type DaemonTodoStatus = 'pending' | 'in_progress' | 'completed';
+export type DaemonTodoPriority = 'low' | 'medium' | 'high';
+export interface DaemonTodoItem {
+    id: string;
+    content: string;
+    status: DaemonTodoStatus;
+    priority?: DaemonTodoPriority;
+    blockedBy?: string[];
+}
+export interface DaemonTodoList {
+    blockId: string;
+    toolCallId: string;
+    title: string;
+    status: string;
+    planId?: string;
+    sourceCallId?: string;
+    items: DaemonTodoItem[];
+    raw: Extract<DaemonTranscriptBlock, {
+        kind: 'tool';
+    }>;
+}
+export interface SubmitPromptResult {
+    promptId: string;
+    removedAfterAbort?: true;
+}
+export interface DaemonActivePromptState {
+    active: boolean | undefined;
+    workspaceCwd: string | undefined;
+    sessionId: string | undefined;
+}
+export interface DaemonSessionActions {
+    /**
+     * Publish the daemon's authoritative "this session has a prompt in flight"
+     * state for the identified session, or `undefined` when it cannot be known
+     * (a daemon without `workspace_session_live_state`, or a workspace nothing
+     * polls live state for).
+     *
+     * The event stream alone cannot tell a long silent tool call apart from a
+     * finished turn, so without this the pane settles a still-running turn to
+     * `idle` after a few seconds of silence and the loading indicator drops
+     * mid-turn (#9487). While this reports `true`, silence-based settling is
+     * suppressed. A fresh `false` settles a restored prompt, and losing a known
+     * `true` settles an observed turn when its terminal event never arrives.
+     */
+    setDaemonActivePrompt(active: boolean | undefined, owner?: Pick<DaemonActivePromptState, 'workspaceCwd' | 'sessionId'>, backgroundTurn?: DaemonBackgroundTurn, requestStartedAt?: number): void;
+    sendPrompt(text: string, options?: SendPromptOptions): Promise<PromptResult>;
+    continueSession(): Promise<void>;
+    /**
+     * Non-blocking prompt submission. POSTs to the daemon and returns
+     * immediately with the `promptId`. The daemon queues the prompt in its
+     * FIFO if a turn is already running. Use this during streaming to
+     * enqueue prompts without waiting for the current turn to complete.
+     */
+    submitPrompt(text: string, options?: SubmitPromptOptions): Promise<SubmitPromptResult>;
+    cancel(): Promise<void>;
+    setModel(modelId: string): Promise<SetModelResult>;
+    setReasoningEffort(value: ReasoningSelection, opts?: {
+        persist?: boolean;
+    }): Promise<void>;
+    setApprovalMode(mode: DaemonApprovalMode, opts?: {
+        persist?: boolean;
+        planMode?: boolean;
+    }): Promise<DaemonApprovalModeResult>;
+    respondToPermission(requestId: string, response: PermissionResponse): Promise<boolean>;
+    respondToGlobalPermission(requestId: string, response: PermissionResponse): Promise<boolean>;
+    submitPermission(requestId: string, optionId?: string, answers?: Record<string, string>): Promise<boolean>;
+    heartbeat(): Promise<HeartbeatResult | undefined>;
+    listSessions(options?: {
+        pageSize?: number;
+    }): Promise<DaemonSessionSummary[]>;
+    loadSession(sessionId: string, options?: {
+        workspaceCwd?: string;
+        sessionContext?: DaemonProductSessionContext;
+    }): Promise<void>;
+    /** `memory` replay is reserved for the provider's live-journal repair. */
+    reloadSession(signal: AbortSignal, options?: {
+        replaySource?: 'configured' | 'memory';
+    }): Promise<void>;
+    resumeSession(sessionId: string, options?: {
+        workspaceCwd?: string;
+        sessionContext?: DaemonProductSessionContext;
+    }): Promise<void>;
+    /**
+     * Create a daemon session and update local session state. Callers that need
+     * transcript/event streaming must follow with `attachSession()`.
+     *
+     * `options.sessionContext` selects the exact product context. The legacy
+     * `options.workspaceCwd` form targets a registered workspace runtime only.
+     * Omit both to keep the provider's active context / legacy primary fallback.
+     * Standalone creation is not automatically retried; Live creation is not
+     * supported.
+     *
+     * `options.approvalMode` seeds the session's approval mode in the create
+     * request itself, so the daemon applies it atomically at spawn instead of
+     * requiring a follow-up `setApprovalMode` call.
+     * `options.modelServiceId` is a standalone-only atomic create override.
+     *
+     * `options.sourceType` records immutable creator attribution.
+     */
+    createSession(options?: {
+        workspaceCwd?: string;
+        sessionContext?: DaemonProductSessionContext;
+        modelServiceId?: string;
+        approvalMode?: DaemonApprovalMode;
+        sourceType?: string;
+        worktree?: {
+            slug?: string;
+        };
+        branch?: {
+            name: string;
+        };
+    }): Promise<DaemonSession>;
+    attachSession(): Promise<void>;
+    clearSession(): Promise<void>;
+    newSession(): Promise<void>;
+    releaseSession(sessionId: string): Promise<void>;
+    closeSession(): Promise<void>;
+    refreshCommands(): Promise<void>;
+    getContext(): Promise<DaemonSessionContextStatus>;
+    getContextUsage(opts?: {
+        detail?: boolean;
+        /** Reconcile composer counters after compression, without changing billing usage. */
+        syncCounters?: boolean;
+        /** Rethrow transient failures raw instead of recording a notice; for
+         * surfaces that re-collect automatically and report failures inline. */
+        silent?: boolean;
+    }): Promise<DaemonSessionContextUsageStatus>;
+    renameSession(displayName: string): Promise<SessionMetadataResult>;
+    recapSession(): Promise<DaemonSessionRecapResult>;
+    generateSessionContent(prompt: string, opts?: {
+        signal?: AbortSignal;
+    }): AsyncGenerator<DaemonSessionGenerationEvent>;
+    getRewindSnapshots(): Promise<{
+        snapshots: DaemonRewindSnapshotInfo[];
+    }>;
+    rewindSession(promptId: string, opts?: {
+        rewindFiles?: boolean;
+    }): Promise<DaemonRewindResult>;
+    btwSession(question: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<DaemonSessionBtwResult>;
+    uploadAttachment(attachment: DaemonPromptImage | DaemonPromptFile, opts?: {
+        signal?: AbortSignal;
+        sessionId?: string;
+    }): Promise<DaemonSessionAttachmentReference>;
+    readAttachment(attachmentId: string): Promise<DaemonSessionAttachmentData>;
+    /** List every attachment currently stored for the session, upload order. */
+    listAttachments(): Promise<DaemonSessionAttachmentReference[]>;
+    removeAttachment(attachmentId: string, opts?: {
+        sessionId?: string;
+    }): Promise<boolean>;
+    /**
+     * Queue a message typed while a turn is running. Calls without an id support
+     * old daemons and are best-effort; calls with a stable `messageId` may reject
+     * on an ambiguous transport failure so the caller can reconcile. `content`
+     * carries attachment blocks — pre-flight the daemon's
+     * `session_attachments` capability before attaching references.
+     */
+    enqueueMidTurnMessage(message: string, opts?: {
+        signal?: AbortSignal;
+        messageId?: string;
+        content?: PromptContentBlock[];
+        onAdmissionStarted?: () => void;
+    }): Promise<DaemonMidTurnMessageResult>;
+    removeMidTurnMessage(messageId: string, opts?: PendingPromptActionOptions): Promise<DaemonRemoveMidTurnMessageResult>;
+    /**
+     * Best-effort reconciliation snapshot (queue + delivery-state rings) from the
+     * daemon. Resolves `undefined` (never throws/raises a notice) when there
+     * is no session or the query fails — callers preserve current state.
+     * Pre-flight the
+     * `session_mid_turn_message_query` capability before relying on it: older
+     * daemons lack the route.
+     */
+    getMidTurnMessages(opts?: {
+        signal?: AbortSignal;
+    }): Promise<DaemonMidTurnMessagesResult | undefined>;
+    getPendingPrompts(opts?: PendingPromptActionOptions): Promise<DaemonPendingPromptsResult>;
+    removePendingPrompt(promptId: string, opts?: PendingPromptActionOptions): Promise<DaemonRemovePendingPromptResult>;
+    sendShellCommand(command: string): Promise<DaemonShellCommandResult>;
+    getTasks(opts?: GetTasksActionOptions): Promise<DaemonSessionTasksStatus>;
+    getWorkflowTasks(opts?: GetTasksActionOptions): Promise<DaemonSessionWorkflowTasksStatus>;
+    cancelTask(taskId: string, kind: DaemonSessionTaskWithWorkflowStatus['kind']): Promise<{
+        cancelled: boolean;
+    }>;
+    controlWorkflowTask(taskId: string, action: 'pause' | 'resume' | 'retry' | 'rerun' | 'delete-history'): Promise<{
+        changed: boolean;
+        status?: DaemonSessionWorkflowTaskStatus['status'];
+        taskId?: string;
+    }>;
+    runSavedWorkflow(name: string): Promise<{
+        started: boolean;
+        status?: DaemonSessionWorkflowTaskStatus['status'];
+        taskId?: string;
+    }>;
+    /**
+     * Read one saved workflow definition (script + parsed meta). Resolves to
+     * null when the name is unknown or Workflow controls are unavailable.
+     */
+    readSavedWorkflow(name: string): Promise<DaemonSessionSavedWorkflowDetail | null>;
+    getGoal(): Promise<GoalStateResponse>;
+    controlGoal(request: GoalControlRequest): Promise<GoalStateResponse>;
+    /**
+     * Install a Goal snapshot obtained outside the session action layer — a
+     * workspace-scoped control against the session this connection is attached
+     * to — reconciled like any other snapshot. A no-op once the connection has
+     * moved to another session.
+     */
+    applyGoalSnapshot(sessionId: string, snapshot: GoalSnapshotV2): void;
+    clearGoal(): Promise<{
+        cleared: boolean;
+        condition?: string;
+    }>;
+    getStats(): Promise<DaemonSessionStatsStatus>;
+    loadArtifacts(): Promise<DaemonSessionArtifactsEnvelope>;
+    listSources(): Promise<SessionSourcesResult>;
+    upsertSource(source: SessionSourceInput): Promise<SessionSourceUpsertResult>;
+    removeSource(sourceId: string): Promise<SessionSourceRemoveResult>;
+    branchSession(name?: string, atRecordId?: string): Promise<{
+        sessionId: string;
+        displayName: string;
+        switchStarted: boolean;
+        sourceWarnings?: string[];
+    }>;
+    forkSession(directive: string): Promise<DaemonForkSessionResult>;
+}
+export interface DaemonSessionContextValue {
+    store: DaemonTranscriptStore;
+    connection: DaemonConnectionState;
+    promptStatus: DaemonPromptStatus;
+    actions: DaemonSessionActions;
+}
+export interface DaemonWorkspaceEventSignals {
+    memoryVersion: number;
+    agentsVersion: number;
+    toolsVersion: number;
+    settingsVersion: number;
+    skillsVersion: number;
+    lastSkillMutation?: DaemonSkillToggleMutation;
+    skillMutationsByCwd?: Record<string, DaemonSkillToggleMutation[]>;
+    mcpVersion: number;
+    extensionsVersion: number;
+    artifactsVersion: number;
+    sourcesVersion?: number;
+    lastExtensionChange?: {
+        status?: 'installed' | 'enabled' | 'disabled' | 'updated' | 'uninstalled' | 'failed';
+        source?: string;
+        name?: string;
+        version?: string;
+        error?: string;
+        refreshed: number;
+        failed: number;
+    };
+    initVersion: number;
+    authVersion: number;
+}
+export interface ActivePrompt {
+    controller: AbortController;
+    promptId?: string;
+    replayedTurnEvents?: Map<string, DaemonEvent>;
+    resolve?: (result: PromptResult) => void;
+    reject?: (error: unknown) => void;
+}
+export type SettledPrompt = {
+    status: 'resolved';
+    result: PromptResult;
+} | {
+    status: 'rejected';
+    error: unknown;
+};
+export interface PendingSessionLoad {
+    id: number;
+    sessionId: string;
+    mode: 'load' | 'resume' | 'attach';
+    sessionContext?: DaemonProductSessionContext;
+    timeout?: ReturnType<typeof setTimeout>;
+    /** SDK timeout for load/resume; `0` disables its timer. */
+    requestTimeoutMs?: number;
+    resolve: () => void;
+    reject: (error: unknown) => void;
+    signal?: AbortSignal;
+    replaySource?: 'configured' | 'memory';
+}
+export {};

package/dist/types/daemon/timing.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonTranscriptStore } from '@qwen-code/sdk/daemon';
+export interface TimerRef {
+    current: ReturnType<typeof setTimeout> | undefined;
+}
+export declare function getReconnectDelayMs(attempt: number, reconnectDelayMs: number, maxReconnectDelayMs: number): number;
+export declare function withActionTimeout<T>(promise: Promise<T>, message: string, timeoutMs?: number): Promise<T>;
+export declare function delay(delayMs: number, signal: AbortSignal): Promise<void>;
+export declare function clearPassiveAssistantDoneTimer(timerRef: TimerRef): void;
+export declare function schedulePassiveAssistantDone(store: DaemonTranscriptStore, timerRef: TimerRef, reason?: string, delayMs?: number, onDone?: () => void): void;

package/dist/types/daemon/useDaemonFollowupSuggestion.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface FollowupState {
+    suggestion: string | null;
+    isVisible: boolean;
+    shownAt: number;
+}
+export interface UseDaemonFollowupSuggestionOptions {
+    enabled?: boolean;
+    onAccept?: (suggestion: string) => void;
+    onOutcome?: (params: {
+        outcome: 'accepted' | 'ignored';
+        accept_method?: 'tab' | 'enter' | 'right';
+        time_ms: number;
+        suggestion_length: number;
+    }) => void;
+}
+export interface UseDaemonFollowupSuggestionReturn {
+    /**
+     * Current follow-up suggestion display state — pass directly to
+     * `<ChatEditor followupState={...} />`. Reflects the controller's
+     * post-debounce visible state, not the raw daemon push.
+     */
+    followupState: FollowupState;
+    /**
+     * Accept the visible suggestion. Wire to
+     * `<ChatEditor onAcceptFollowup={...} />`.
+     * Calls the underlying controller's accept (which invokes the
+     * consumer-provided `onAccept` from options) AND clears the daemon
+     * store's `lastFollowupSuggestion` so the same suggestion does not
+     * re-push into the controller on the next render.
+     */
+    onAcceptFollowup: (method?: 'tab' | 'enter' | 'right', options?: {
+        skipOnAccept?: boolean;
+    }) => void;
+    /**
+     * Dismiss the visible suggestion. Wire to
+     * `<ChatEditor onDismissFollowup={...} />`.
+     * Same store-clear semantics as `onAcceptFollowup`.
+     */
+    onDismissFollowup: () => void;
+    /**
+     * Explicit invalidation hook. Adapters call this just before invoking
+     * `actions.sendPrompt(...)` so the prior turn's ghost-text disappears
+     * synchronously — no wire round-trip needed (the daemon does not
+     * emit a "suggestion cleared" event on prompt boundaries; clients
+     * self-invalidate).
+     */
+    clear: () => void;
+}
+/**
+ * Wire the daemon's server-pushed `followup_suggestion` event into the
+ * Web Shell's composer. Consumers:
+ *
+ *   1. Render `<ChatEditor followupState={...} onAcceptFollowup={...}
+ *      onDismissFollowup={...} />` with the three values returned here.
+ *      `ChatEditor` declares exactly these three props, typed from this
+ *      interface; `ChatPane` and `App` are the two in-tree hosts that call
+ *      this hook and thread them down.
+ *   2. Call `clear()` from the hook just before `actions.sendPrompt(...)`
+ *      so the prior turn's ghost-text disappears immediately.
+ *
+ * The hook subscribes to daemon follow-up sidechannels and drives a
+ * daemon-local accept/dismiss controller. The controller is the source
+ * of truth for what the input renders; the store/sidechannel is the
+ * source of truth for what the daemon last sent for this session.
+ *
+ * Wiring `onAccept` and `onOutcome` propagates straight to the
+ * daemon-local controller.
+ *
+ * Must be called within a `<DaemonSessionProvider>` — throws via
+ * `useDaemonTranscriptStore` otherwise.
+ */
+export declare function useDaemonFollowupSuggestion(opts?: UseDaemonFollowupSuggestionOptions): UseDaemonFollowupSuggestionReturn;