@qwen-code/web-shell 0.25.1-preview.2 → 0.25.2-preview.0

package/dist/types/components/managed/java-managed-agent-client.d.ts

@@ -57,9 +57,47 @@ export declare class JavaManagedAgentClient {
     submitTurn(request: Schemas['WebShellSubmitRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
     cancelTurn(request: Schemas['WebShellCancelRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
     queryActions(request: Schemas['WebShellActionQueryRequest'], signal?: AbortSignal): Promise<JavaAgentActionPage>;
+    listTasks(request: Schemas['WebShellTaskQueryRequest'], signal?: AbortSignal): Promise<{
+        data: components["schemas"]["WebShellTask"][];
+        hasMore: boolean;
+        nextCursor?: string | null;
+    }>;
+    getTask(request: Schemas['WebShellTaskGetRequest'], signal?: AbortSignal): Promise<{
+        taskId: string;
+        sessionId: string;
+        kind: components["schemas"]["TaskKind"];
+        state: components["schemas"]["TaskState"];
+        definitionRevision?: number;
+        runtimeState?: components["schemas"]["TaskRuntimeState"];
+        createdAt: number;
+        startedAt?: number;
+        settledAt?: number;
+        outputCursor?: string;
+        artifactRefs: string[];
+        actionCapabilities: components["schemas"]["TaskActionCapability"][];
+    }>;
+    listTaskEvents(request: Schemas['WebShellTaskEventQueryRequest'], signal?: AbortSignal): Promise<{
+        data: components["schemas"]["WebShellTaskEvent"][];
+        hasMore: boolean;
+        nextCursor: string;
+    }>;
+    cancelTask(request: Schemas['WebShellTaskCancelRequest'], signal?: AbortSignal): Promise<{
+        operationId: string;
+        sessionId: string;
+        type: "create_session" | "submit_input" | "cancel" | "action_response" | "close" | "archive" | "delete" | "task_cancel";
+        taskId?: string;
+        status: "pending" | "running" | "completed" | "failed" | "cancelled" | "recovery_blocked";
+        admissionStage: "java_durable" | "harness_confirmed";
+        deliveryState: "pending" | "leased" | "confirmed" | "blocked";
+        receiptId?: string;
+        actionResolution?: components["schemas"]["WebShellActionResolution"];
+        failureCode?: string;
+        replayed: boolean;
+    }>;
     respondAction(request: Schemas['WebShellActionRespondRequest'], signal?: AbortSignal): Promise<Schemas['WebShellCommandOperation']>;
     /** Reads an operation's latest durable status; polling is not a replay. */
     queryOperation(request: Schemas['WebShellOperationRequest'], signal?: AbortSignal): Promise<Schemas['WebShellOperation']>;
+    changeCwd(request: Schemas['WebShellChangeCwdRequest'], signal?: AbortSignal): Promise<Schemas['WebShellCwdOperation']>;
     getToolResult(sessionId: string, itemId: string, signal?: AbortSignal): Promise<{
         result: components["schemas"]["PublicToolResult"];
         access: components["schemas"]["ArtifactAccess"];
@@ -80,7 +118,7 @@ export declare class JavaManagedAgentClient {
     readArtifactRange(artifact: ManagedArtifact, offset: number, length: number, signal?: AbortSignal): Promise<Uint8Array>;
     openArtifactStream(artifact: ManagedArtifact, signal?: AbortSignal): Promise<ReadableStream<Uint8Array>>;
     private artifactContent;
-    streamEvents(request: Schemas['WebShellStreamRequest'], signal?: AbortSignal, onOpen?: () => void): AsyncGenerator<JavaAgentEvent | JavaAgentResyncRequired>;
+    streamEvents(request: Schemas['WebShellStreamRequest'], signal?: AbortSignal, onOpen?: () => void, onAlive?: () => void): AsyncGenerator<JavaAgentEvent | JavaAgentResyncRequired>;
     private post;
     private request;
 }

package/dist/types/components/managed/java-managed-agent-provider.d.ts

@@ -7,6 +7,10 @@ export interface JavaManagedAgentProviderOptions extends JavaManagedAgentClientO
     /** Include tenant and actor identity; replace this scope/provider when either changes. Token refresh alone can use getHeaders. */
     productScope?: string;
     enableWorkspaceBinding?: boolean;
+    modelPresets?: readonly {
+        agentId: string;
+        label: string;
+    }[];
     /** Acquire a streaming save target during the user gesture, then call openStream. */
     saveArtifact?: ManagedArtifactSave;
 }

package/dist/types/components/managed/managed-agent-provider.d.ts

@@ -4,12 +4,15 @@ export type ManagedAgentSessionPhase = 'created' | 'admitted' | 'runtime_startin
 export type ManagedAgentRuntimeState = 'unknown' | 'starting' | 'ready' | 'failed';
 export interface ManagedAgentSessionSummary {
     sessionId: string;
+    agentId?: string;
     activeTurnId?: string;
     title: string;
     workspaceCwd?: string;
     workspace?: {
         workspaceId: string;
         cwdRelative: string;
+        contextRevision?: number;
+        state?: 'ready' | 'changing' | 'recovery_blocked';
     };
     createdAt: number;
     admittedAt: number;
@@ -21,16 +24,18 @@ export interface ManagedAgentSessionSummary {
         canSend: boolean;
         canCancel: boolean;
         actions?: boolean;
+        tasks?: boolean;
         artifacts?: boolean;
         /** The caller may submit later Turns to this Workspace-bound Session. */
         workspaceTurns?: boolean;
+        cwdChange?: boolean;
     };
     failure?: {
         code: string;
         message: string;
     };
 }
-export type ManagedAgentSessionEventType = 'accepted' | 'runtime_starting' | 'runtime_ready' | 'runtime_failed' | 'runtime_released' | 'agent_started' | 'assistant_thought' | 'assistant_delta' | 'tool_requested' | 'tool_started' | 'tool_completed' | 'tool_result_updated' | 'completed' | 'failed' | 'cancelling' | 'cancelled' | 'action_updated' | 'stream_gap';
+export type ManagedAgentSessionEventType = 'accepted' | 'runtime_starting' | 'runtime_ready' | 'runtime_failed' | 'runtime_released' | 'agent_started' | 'assistant_thought' | 'assistant_delta' | 'tool_requested' | 'tool_started' | 'tool_completed' | 'tool_result_updated' | 'completed' | 'failed' | 'cancelling' | 'cancelled' | 'action_updated' | 'context_changed' | 'stream_gap';
 export interface ManagedAgentSessionEvent {
     id: number;
     at: number;
@@ -61,6 +66,14 @@ export interface ManagedAgentRequestOptions {
 export interface ManagedAgentCommandOptions extends ManagedAgentRequestOptions {
     idempotencyKey: string;
 }
+export type ManagedCwdOperation = components['schemas']['WebShellCwdOperation'];
+export type ManagedTask = components['schemas']['WebShellTask'];
+export type ManagedTaskPage = components['schemas']['WebShellTaskPage'];
+export type ManagedTaskEvent = components['schemas']['WebShellTaskEvent'];
+export type ManagedTaskEventPage = components['schemas']['WebShellTaskEventPage'];
+export type ManagedTaskCancelOperation = components['schemas']['WebShellCommandOperation'] & {
+    type: 'task_cancel';
+};
 /** A Hosted tool approval waiting for the Session owner's answer. */
 export interface ManagedAgentPendingAction {
     actionId: string;
@@ -89,8 +102,35 @@ export interface ManagedAgentProvider {
         respond(action: ManagedAgentPendingAction, optionId: string, options: ManagedAgentCommandOptions): Promise<void>;
     };
     readonly toolResults?: ManagedToolResultReader;
+    readonly tasks?: {
+        list(sessionId: string, options: ManagedAgentRequestOptions & {
+            cursor?: string;
+            limit?: number;
+        }): Promise<ManagedTaskPage>;
+        get(sessionId: string, taskId: string, options: ManagedAgentRequestOptions): Promise<ManagedTask>;
+        listEvents(sessionId: string, taskId: string, options: ManagedAgentRequestOptions & {
+            after?: string;
+            limit?: number;
+        }): Promise<ManagedTaskEventPage>;
+        readonly cancel?: {
+            submit(sessionId: string, taskId: string, options: ManagedAgentCommandOptions): Promise<ManagedTaskCancelOperation>;
+            query(sessionId: string, taskId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedTaskCancelOperation>;
+        };
+    };
+    readonly cwdChange?: {
+        submit(sessionId: string, request: {
+            cwdRelative: string;
+            expectedContextRevision: number;
+        }, options: ManagedAgentCommandOptions): Promise<ManagedCwdOperation>;
+        query(sessionId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedCwdOperation>;
+    };
     readonly workspaceBinding?: {
         readonly agentId: string;
+        /** Host-published model-specific AgentDefinitions available for new Sessions. */
+        readonly modelPresets?: readonly {
+            agentId: string;
+            label: string;
+        }[];
         list(options: ManagedAgentRequestOptions & {
             cursor?: string;
             limit?: number;
@@ -108,6 +148,14 @@ export interface ManagedAgentProvider {
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;
+        createSession?(request: {
+            agentId: string;
+            workspaceId: string;
+            cwdRelative: string;
+            text: string;
+        }, options: ManagedAgentCommandOptions): Promise<{
+            sessionId: string;
+        }>;
     };
     listSessions(options: ManagedAgentRequestOptions & {
         workspaceCwd?: string;
@@ -139,6 +187,12 @@ export interface ManagedAgentProvider {
          * depend on stream activity.
          */
         onEstablished?(): void;
+        /**
+         * Called for each complete heartbeat or comment frame the stream
+         * delivers. Heartbeats never decode into events, so on an idle
+         * Session this is the only sign of life an established stream gives.
+         */
+        onAlive?(): void;
     }): AsyncIterable<ManagedAgentSessionEvent>;
 }
 export interface ManagedAgentWorkspace {

package/dist/types/components/managed/managed-development-options.d.ts

@@ -0,0 +1,7 @@
+import type { JavaManagedAgentProviderOptions } from './java-managed-agent-provider';
+/** Local Vite configuration; the production host supplies these provider options directly. */
+export declare function managedDevelopmentOptions(params: URLSearchParams, env: {
+    VITE_MANAGED_AGENT_ACTOR_ID?: string;
+    VITE_MANAGED_AGENT_MODEL_PRESETS?: string;
+    VITE_MANAGED_AGENT_WORKSPACE_BINDING?: string;
+}): Pick<JavaManagedAgentProviderOptions, 'productScope' | 'getHeaders' | 'enableWorkspaceBinding' | 'modelPresets'>;

package/dist/types/components/managed/managed-request-error.d.ts

@@ -12,3 +12,9 @@
  * are worth another attempt.
  */
 export declare function isNonRetryableClientError(error: unknown): boolean;
+/**
+ * A 401/403. This client re-derives its credentials on every request, so an
+ * expired short-lived token gets a fresh answer on the very next attempt
+ * once the host refreshes — never a terminal condition.
+ */
+export declare function isAuthFailure(error: unknown): boolean;

package/dist/types/components/managed/managed-task-messages.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+type ManagedTaskMessage = string | ((vars?: Record<string, string | number>) => string);
+export declare const MANAGED_TASK_MESSAGES_EN: Record<string, ManagedTaskMessage>;
+export declare const MANAGED_TASK_MESSAGES_ZH: Record<string, ManagedTaskMessage>;
+export {};

package/dist/types/components/managed/managed-task-messages.transcript-stub.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const MANAGED_TASK_MESSAGES_EN: {};
+export declare const MANAGED_TASK_MESSAGES_ZH: {};

package/dist/types/components/managed/managed-task.test-fixtures.d.ts

@@ -0,0 +1,4 @@
+import type { ManagedTask, ManagedTaskCancelOperation, ManagedTaskEvent } from './managed-agent-provider';
+export declare const task: ManagedTask;
+export declare const taskOperation: ManagedTaskCancelOperation;
+export declare function taskEvent(cursor: string, type?: string): ManagedTaskEvent;

package/dist/types/components/managed/use-managed-cwd-change.d.ts

@@ -0,0 +1,21 @@
+import type { ManagedAgentProvider, ManagedAgentSessionSummary } from './managed-agent-provider';
+interface CwdIntent {
+    sessionId: string;
+    workspaceId: string;
+    cwdRelative: string;
+    expectedContextRevision: number;
+    idempotencyKey: string;
+    operationId?: string;
+}
+export declare function useManagedCwdChange(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined, summary: ManagedAgentSessionSummary | undefined, refreshSummary: (signal?: AbortSignal) => Promise<ManagedAgentSessionSummary | undefined>): {
+    blocked: boolean;
+    submit: (cwdRelative: string, expectedContextRevision: number) => Promise<true | undefined>;
+    confirm: () => Promise<void>;
+    isBlocked: () => boolean;
+    key: string;
+    pending?: CwdIntent;
+    busy: boolean;
+    errorCode?: string;
+    target?: string;
+};
+export {};

package/dist/types/components/managed/use-managed-session.d.ts

@@ -1,12 +1,26 @@
 import type { ManagedAgentProvider, ManagedAgentSessionEvent, ManagedAgentSessionSummary } from './managed-agent-provider';
+type SignalLeg = 'session' | 'transcript' | 'stream';
+interface SignalEntry {
+    readonly message: string;
+    readonly final: boolean;
+    readonly seq: number;
+    readonly leg: SignalLeg;
+    readonly stall?: boolean;
+}
+export declare function failureRetryDelayMs(failures: number): number;
 export declare function useManagedSession(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined): {
+    stoppedReason: string | undefined;
+    stoppedLeg: SignalLeg | undefined;
+    error: string | undefined;
     loadingOlder: boolean;
     loadOlder: () => Promise<void>;
     reload: () => void;
+    refreshSummary: (signal?: AbortSignal) => Promise<ManagedAgentSessionSummary | undefined>;
     sessionId?: string;
     summary?: ManagedAgentSessionSummary;
     events: ManagedAgentSessionEvent[];
     olderCursor?: string;
     loading: boolean;
-    error?: string;
+    signals?: Partial<Record<SignalLeg, SignalEntry>>;
 };
+export {};

package/dist/types/components/managed/use-managed-task-cancel.d.ts

@@ -0,0 +1,12 @@
+import type { ManagedAgentProvider, ManagedTask } from './managed-agent-provider';
+export interface ManagedTaskCancelState {
+    status: 'submitting' | 'stopping' | 'unconfirmed' | 'failed';
+    busy: boolean;
+    code?: string;
+}
+export declare function useManagedTaskCancel(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined, snapshots: readonly ManagedTask[], refreshTasks: () => void, applySnapshot: (task: ManagedTask) => void): {
+    states: Record<string, ManagedTaskCancelState>;
+    pendingTaskIds: string[];
+    submit(task: ManagedTask): Promise<void>;
+    resume(taskId: string): Promise<void>;
+};

package/dist/types/components/managed/use-managed-tasks.d.ts

@@ -0,0 +1,49 @@
+import type { ManagedAgentProvider, ManagedTask } from './managed-agent-provider';
+export declare function isManagedTaskTerminal(task: ManagedTask): boolean;
+export declare function useManagedTasks(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined, open: boolean): {
+    page: {
+        data: import("./generated/managed-agent-api").components["schemas"]["WebShellTask"][];
+        hasMore: boolean;
+        nextCursor?: string | null;
+    };
+    task: {
+        taskId: string;
+        sessionId: string;
+        kind: import("./generated/managed-agent-api").components["schemas"]["TaskKind"];
+        state: import("./generated/managed-agent-api").components["schemas"]["TaskState"];
+        definitionRevision?: number;
+        runtimeState?: import("./generated/managed-agent-api").components["schemas"]["TaskRuntimeState"];
+        createdAt: number;
+        startedAt?: number;
+        settledAt?: number;
+        outputCursor?: string;
+        artifactRefs: string[];
+        actionCapabilities: import("./generated/managed-agent-api").components["schemas"]["TaskActionCapability"][];
+    } | undefined;
+    selectedId: string | undefined;
+    events: {
+        schemaVersion: number;
+        projectionVersion: number;
+        taskId: string;
+        sessionId: string;
+        type: import("./generated/managed-agent-api").components["schemas"]["TaskEventType"];
+        cursor: string;
+        createdAt: number;
+        state?: import("./generated/managed-agent-api").components["schemas"]["TaskState"];
+        runtimeState?: import("./generated/managed-agent-api").components["schemas"]["TaskRuntimeState"];
+        text?: string;
+        truncated?: boolean;
+        artifactId?: string;
+    }[];
+    moreEvents: boolean;
+    historyGap: boolean;
+    loading: boolean;
+    error: unknown;
+    hasPrevious: boolean;
+    refresh: () => void;
+    apply: (task: ManagedTask) => void;
+    select: (taskId?: string) => void;
+    next: () => void;
+    previous: () => void;
+    loadMoreEvents: () => void;
+};

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

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

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

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+export interface SelectionCopyMenuProps {
+    children: ReactNode;
+    className: string;
+    content: string;
+    enabled: boolean;
+}
+export declare function SelectionCopyMenu({ children, className, content, enabled, }: SelectionCopyMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/messages/SelectionCopyMenu.transcript-stub.d.ts

@@ -0,0 +1,2 @@
+import type { SelectionCopyMenuProps } from './SelectionCopyMenu';
+export declare function SelectionCopyMenu({ children, className, }: SelectionCopyMenuProps): import("react/jsx-runtime").JSX.Element;

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

@@ -5,6 +5,7 @@ interface ToolApprovalProps {
     onConfirm: (id: string, selectedOption: string) => void | Promise<void>;
     variant?: 'inline' | 'floating';
     disabled?: boolean;
+    showBrowserNotifications?: 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/
@@ -32,5 +33,5 @@ export declare function parseTitle(title?: string): {
     toolName: string;
     description: string;
 };
-export declare function ToolApproval({ request, onConfirm, variant, disabled, keyboardActive, extraDescriptionId, planTodos, planExecutionMode, generateContent, }: ToolApprovalProps): import("react/jsx-runtime").JSX.Element;
+export declare function ToolApproval({ request, onConfirm, variant, disabled, showBrowserNotifications, keyboardActive, extraDescriptionId, planTodos, planExecutionMode, generateContent, }: ToolApprovalProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,5 +1,6 @@
-import type { ACPToolCall } from '../../adapters/types';
-export { isActiveToolStatus } from '../../adapters/toolClassification';
+import type { ACPToolCall } from '../../adapters/types.js';
+export { isAskUserQuestionToolName } from '../../constants/toolNames.js';
+export { isActiveToolStatus } from '../../adapters/toolClassification.js';
 /**
  * Internal-tool-name → display-name lookup. This is a standalone copy of
  * core's `ToolDisplayNames` (mapped to wire names, as the CLI's shared
@@ -19,7 +20,6 @@ export declare function formatToolDisplayName(toolName: string): string;
  * English {@link formatToolDisplayName}. Pass the `t` from `useI18n()`.
  */
 export declare function localizeToolDisplayName(toolName: string, t: (key: string, vars?: Record<string, string | number>) => string): string;
-export declare function isAskUserQuestionToolName(toolName: string): boolean;
 export declare function isAdvisorToolName(toolName: string): boolean;
 export declare function isCompletedAskUserQuestion(tool: ACPToolCall): boolean;
 export declare function getQuestionAnswerResult(tool: ACPToolCall): {

package/dist/types/components/panels/EnvironmentPanel.d.ts

@@ -44,5 +44,10 @@ export type EnvironmentAgentTask = DaemonSessionAgentTaskStatus & {
     color?: string;
     lineageState?: 'complete' | 'orphaned' | 'cycle';
 };
+/**
+ * Statuses this panel renders with a spinner. The header's activity dot keys
+ * off the same set, so the dot cannot promise a row the panel shows settled.
+ */
+export declare function isTaskInProgress(status: DaemonSessionTaskWithWorkflowStatus['status']): boolean;
 export declare function EnvironmentPanel({ sources, onOpenSource, retrySourceRegistration, floating, hidden, workspaceCwd, gitWorkspaceCwd, gitCwd, gitSessionId, branch, gitStatus, tasks, agentTasks, attachments, attachmentsLoading, attachmentsError, onRetryAttachments, artifacts, artifactsLoading, items, onOpenGitDiff, onOpenGitCommit, onOpenGitWorktrees, onOpenGitLog, onOpenAgent, onOpenAgentWorkflow, onOpenTask, onReadImage, onImagePreview, onAttachmentPreview, onAttachmentPreviewError, onOpenArtifact, onDismiss, }: EnvironmentPanelProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/ui/alert.d.ts

@@ -1,7 +1,7 @@
 import type * as React from 'react';
 import { type VariantProps } from 'class-variance-authority';
 declare const alertVariants: (props?: ({
-    variant?: "default" | "destructive" | "success" | null | undefined;
+    variant?: "success" | "default" | "destructive" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 declare function Alert({ className, variant, ...props }: React.ComponentProps<'div'> & VariantProps<typeof alertVariants>): import("react/jsx-runtime").JSX.Element;
 declare function AlertTitle({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ui/resizable.d.ts

@@ -0,0 +1,5 @@
+import * as ResizablePrimitive from 'react-resizable-panels';
+declare const ResizablePanelGroup: import("react").ForwardRefExoticComponent<Omit<ResizablePrimitive.GroupProps, "elementRef"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ResizablePanel: import("react").ForwardRefExoticComponent<Omit<ResizablePrimitive.PanelProps, "elementRef"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ResizableHandle: import("react").ForwardRefExoticComponent<Omit<ResizablePrimitive.SeparatorProps, "elementRef"> & import("react").RefAttributes<HTMLDivElement>>;
+export { ResizableHandle, ResizablePanel, ResizablePanelGroup };

package/dist/types/constants/toolNames.d.ts

@@ -7,3 +7,4 @@
 export declare const AGENT_TOOL_NAME = "agent";
 /** Whether a tool name identifies the Agent (sub-agent) tool. */
 export declare function isAgentTool(toolName: string | undefined): boolean;
+export declare function isAskUserQuestionToolName(toolName: string): boolean;

package/dist/types/customization.d.ts

@@ -136,7 +136,7 @@ export interface WebShellChatHeaderOptions {
     /** Built-in header actions to show. Token and context usage are opt-in. */
     items?: readonly WebShellChatHeaderItem[];
 }
-export type WebShellRightPanelItem = 'review' | 'sideTask' | 'terminal' | 'webPreview' | 'trajectory';
+export type WebShellRightPanelItem = 'files' | 'review' | 'sideTask' | 'terminal' | 'webPreview' | 'trajectory';
 export interface WebShellRightPanelOptions {
     /** Empty-state actions to show. Defaults to review and sideTask. */
     items?: readonly WebShellRightPanelItem[];

package/dist/types/daemon/session/turn-notification-context.d.ts

@@ -15,10 +15,11 @@ export interface TurnNotificationContent {
     sessionTitle?: string;
     promptText?: string;
     responseText?: string;
+    attention?: 'approval' | 'question';
 }
 export interface TurnNotification extends TurnNotificationContent {
     key: string;
-    outcome: 'completed' | 'failed' | 'ended' | 'cancelled';
+    outcome: 'completed' | 'failed' | 'ended' | 'cancelled' | 'approval' | 'question';
 }
 export interface TurnNotificationObserver {
     retain(scope: string): () => void;

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

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { ReactNode } from 'react';
-import type { CreateSessionRequest, DaemonBranchSessionRequest, 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, DaemonSessionArtifactInput, DaemonSessionArtifactMutationResult, 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';
+import type { CreateSessionRequest, DaemonBranchSessionRequest, DaemonCapabilities, DaemonBackgroundTurn, DaemonEvent, DaemonApprovalMode, DaemonApprovalModeResult, DaemonAvailableCommand, DaemonForkSessionResult, DaemonInputAnnotation, DaemonSessionBtwResult, DaemonSessionGenerationEvent, DaemonSessionAttachmentReference, DaemonSessionAttachmentData, DaemonMidTurnMessageResult, DaemonMidTurnMessagesResult, DaemonRemoveMidTurnMessageResult, DaemonSendMidTurnMessagesNowResult, DaemonPendingPromptsResult, DaemonRemovePendingPromptResult, DaemonSessionContextStatus, DaemonSessionSavedWorkflowDetail, DaemonSessionContextUsageStatus, DaemonSessionRecapResult, DaemonRewindResult, DaemonRewindSnapshotInfo, DaemonSession, DaemonSessionSummary, DaemonSessionSupportedCommandsStatus, DaemonSessionTaskWithWorkflowStatus, DaemonSessionTasksStatus, DaemonSessionWorkflowTaskStatus, DaemonSessionWorkflowTasksStatus, DaemonSessionStatsStatus, DaemonSessionArtifactsEnvelope, DaemonSessionArtifactInput, DaemonSessionArtifactMutationResult, 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;
@@ -489,6 +489,14 @@ export interface DaemonSessionActions {
         onAdmissionStarted?: () => void;
     }): Promise<DaemonMidTurnMessageResult>;
     removeMidTurnMessage(messageId: string, opts?: PendingPromptActionOptions): Promise<DaemonRemoveMidTurnMessageResult>;
+    /**
+     * Ask the daemon to deliver the queued mid-turn messages now, cutting short
+     * a model response that a foreground turn is streaming, unless it has
+     * started a tool call.
+     * Pre-flight the daemon's `session_mid_turn_send_now` capability: older
+     * daemons lack the route.
+     */
+    sendMidTurnMessagesNow(opts?: PendingPromptActionOptions): Promise<DaemonSendMidTurnMessagesNowResult>;
     /**
      * Best-effort reconciliation snapshot (queue + delivery-state rings) from the
      * daemon. Resolves `undefined` (never throws/raises a notice) when there

package/dist/types/hooks/useComposerCore.d.ts

@@ -98,6 +98,7 @@ export interface UseComposerCoreOptions {
     atWorkspaceCwd?: string;
     composerScopeKey?: string;
     disableLegacyHistoryFallback?: boolean;
+    shellModeEnabled?: boolean;
     attachmentsEnabled?: boolean;
     workspaceFeaturesEnabled?: boolean;
     composerTagIcons?: WebShellComposerTagIconMap;
@@ -124,6 +125,8 @@ export interface UseComposerCoreOptions {
     /** CodeMirror theme extension for the editor view. Each variant provides its own. */
     editorTheme: Parameters<typeof EditorView.theme>[0];
 }
+export declare function getComposerDraftStorageKey(sessionId: string | undefined, workspaceCwd: string | undefined): string | undefined;
+export declare function clearComposerDraftIfMatches(storageKey: string | undefined, text: string): void;
 export interface SearchState {
     searchMode: boolean;
     searchQuery: string;

package/dist/types/hooks/useQueuedPrompts.d.ts

@@ -70,6 +70,8 @@ export interface UseQueuedPromptsResult {
     enqueuePrompt: (text: string, images?: PromptImage[], files?: PromptFile[], onComplete?: () => void, inputAnnotations?: DaemonInputAnnotation[], onAdmitted?: () => void, submittedPrompt?: string) => boolean;
     removeQueuedPrompt: (id: number) => void;
     insertQueuedPrompt: (id: number) => Promise<void>;
+    /** Ask the daemon to deliver the queued mid-turn messages now. */
+    sendQueuedPromptNow: (id: number) => Promise<void>;
     editQueuedPrompt: (id: number) => Promise<void>;
     editLastQueuedPrompt: () => boolean;
     clearQueuedPrompts: () => boolean;

package/dist/types/trajectory/project-trajectory-lifecycle.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type DaemonEvent, type ExecutionLifecycleEntry, type ToolLifecycleEntry } from '@qwen-code/sdk/daemon';
+import type { Trajectory } from './types';
+import type { TrajectoryLiveSnapshot } from './trajectory-live-store';
+export type TrajectoryLifecycleEntry = ExecutionLifecycleEntry | ToolLifecycleEntry;
+export interface TrajectoryLifecycleProjection {
+    byRowKey: ReadonlyMap<string, TrajectoryLifecycleEntry>;
+    byExecution: ReadonlyMap<string, TrajectoryLifecycleEntry>;
+    outsideWindow: readonly TrajectoryLifecycleEntry[];
+    status: TrajectoryLiveSnapshot['status'];
+    incomplete: boolean;
+    truncated: boolean;
+}
+export declare function projectHistoricalLifecycle(events: readonly DaemonEvent[]): {
+    requests: import("@qwen-code/sdk/daemon").ExecutionLifecycleState;
+    tools: import("@qwen-code/sdk/daemon").ToolLifecycleState;
+    truncated: boolean;
+    incomplete: boolean;
+};
+export declare function projectTrajectoryLifecycle(history: ReturnType<typeof projectHistoricalLifecycle>, trajectory: Trajectory | undefined, identity: {
+    sessionId: string;
+    scope?: string;
+} | undefined, live: TrajectoryLiveSnapshot): TrajectoryLifecycleProjection;

package/dist/types/trajectory/trajectory-live-context.d.ts

@@ -0,0 +1,3 @@
+import type { TrajectoryLiveSnapshot, TrajectoryLiveStore } from './trajectory-live-store.js';
+export declare const TrajectoryLiveContext: import("react").Context<TrajectoryLiveStore | null>;
+export declare function useTrajectoryLiveSnapshot(): TrajectoryLiveSnapshot;

package/dist/types/trajectory/trajectory-live-store.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type DaemonEvent, type ExecutionLifecycleState, type ToolLifecycleState } from '@qwen-code/sdk/daemon';
+export interface TrajectoryLiveSnapshot {
+    readonly sessionId?: string;
+    readonly scope?: string;
+    readonly epoch?: string;
+    readonly lastEventId?: number;
+    readonly status: 'catching-up' | 'live' | 'stale' | 'unavailable';
+    readonly reason?: string;
+    readonly requests: ExecutionLifecycleState;
+    readonly tools: ToolLifecycleState;
+    readonly incomplete: boolean;
+    readonly truncated: boolean;
+}
+export interface TrajectoryLiveInput {
+    sessionId: string;
+    scope: string;
+    epoch?: string;
+    lastEventId?: number;
+    events: readonly DaemonEvent[];
+    incomplete: boolean;
+}
+export interface TrajectoryLiveStore {
+    getSnapshot(): TrajectoryLiveSnapshot;
+    subscribe(listener: () => void): () => void;
+    begin(owner: object, input: TrajectoryLiveInput): void;
+    reconnect(owner: object, liveOnly?: boolean): void;
+    ingest(owner: object, event: DaemonEvent, epoch?: string): void;
+    invalidate(owner: object, reason: string): void;
+    clear(): void;
+}
+export declare function createTrajectoryLiveStore(): TrajectoryLiveStore;

package/dist/types/trajectory/transcriptPageLoader.d.ts

@@ -15,6 +15,10 @@ export interface TrajectoryTranscriptClient {
         cursor?: string;
     }): Promise<TrajectoryPageResult>;
 }
+export declare function trajectoryLoaderIdentity(loader: TrajectoryPageLoader | undefined): {
+    sessionId: string;
+    scope?: string;
+} | undefined;
 /**
  * A page loader for one session, stable per (client, session).
  *
@@ -30,4 +34,4 @@ export interface TrajectoryTranscriptClient {
  * `summary` projection, which rewrites the event stream the timing frames sit
  * in.
  */
-export declare function createTrajectoryPageLoader(client: TrajectoryTranscriptClient, sessionId: string): TrajectoryPageLoader;
+export declare function createTrajectoryPageLoader(client: TrajectoryTranscriptClient, sessionId: string, scope?: string): TrajectoryPageLoader;

package/dist/types/trajectory/useTrajectoryWindow.d.ts

@@ -5,6 +5,7 @@
  */
 import type { DaemonEvent } from '@qwen-code/sdk/daemon';
 import type { Trajectory } from './types';
+import { type TrajectoryLifecycleProjection } from './project-trajectory-lifecycle';
 /**
  * Records asked for per read. The daemon caps a page at 500 records and at
  * 4 MB, whichever binds first, so a session whose tools wrote a lot comes back
@@ -65,6 +66,7 @@ export type TrajectoryWindowFailure = {
 export declare const TRAJECTORY_BOOKMARK_LIMIT = 64;
 export declare const TRAJECTORY_CURSOR_BUDGET: number;
 export interface TrajectoryWindow {
+    lifecycle: TrajectoryLifecycleProjection;
     trajectory: Trajectory | undefined;
     status: 'idle' | 'loading' | 'ready' | 'error';
     error?: TrajectoryWindowFailure;

package/dist/types/utils/askUserPermission.d.ts

@@ -3,7 +3,7 @@
  * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { PermissionRequest } from '../adapters/types';
+import type { PermissionRequest } from '../adapters/types.js';
 /**
  * True when a pending permission is an AskUserQuestion prompt (it carries a
  * `questions` array, and either no tool name or the AskUserQuestion tool name)