@qwen-code/web-shell 0.25.3-preview.0 → 0.25.3

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

@@ -51,8 +51,36 @@ export declare class JavaManagedAgentClient {
         displayName: string;
         canCreateSession: boolean;
         state: "active" | "draining" | "removed";
+        defaultCwdRelative?: string;
+        canSelectDirectory?: boolean;
+    }>;
+    listRuntimeNodes(signal?: AbortSignal): Promise<{
+        supported: boolean;
+        data: components["schemas"]["WebShellRuntimeNode"][];
+    }>;
+    checkWorkspaceDirectory(request: Schemas['WebShellWorkspaceDirectoryRequest'], signal?: AbortSignal): Promise<{
+        nodeId: string;
+        canonicalPath: string;
+        platform: "linux" | "darwin";
+    }>;
+    registerWorkspace(request: Schemas['WebShellWorkspaceRegisterRequest'], signal?: AbortSignal): Promise<{
+        operationId: string;
+        type: "workspace_create";
+        status: "pending" | "running" | "completed" | "failed" | "cancelled" | "recovery_blocked";
+        workspaceId?: string | null;
+        failureCode?: string | null;
+        replayed: boolean;
+    }>;
+    getWorkspaceOperation(operationId: string, signal?: AbortSignal): Promise<{
+        operationId: string;
+        type: "workspace_create";
+        status: "pending" | "running" | "completed" | "failed" | "cancelled" | "recovery_blocked";
+        workspaceId?: string | null;
+        failureCode?: string | null;
+        replayed: boolean;
     }>;
     createWorkspace(request: Schemas['WebShellWorkspaceCreateRequest'], signal?: AbortSignal): Promise<JavaAgentWorkspace>;
+    workspaceDirectories(request: Schemas['WebShellWorkspaceDirectoryQueryRequest'], signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceDirectoryPage']>;
     getSessionApproval(sessionId: string, signal?: AbortSignal): Promise<Schemas['WebShellSessionApproval']>;
     changeApproval(request: Schemas['WebShellChangeApprovalRequest'], signal?: AbortSignal): Promise<Schemas['WebShellApprovalChangeResult']>;
     getSessionOptions(agentId: string, signal?: AbortSignal): Promise<Schemas['WebShellSessionOptions']>;
@@ -69,6 +97,7 @@ export declare class JavaManagedAgentClient {
     getTask(request: Schemas['WebShellTaskGetRequest'], signal?: AbortSignal): Promise<{
         taskId: string;
         sessionId: string;
+        childSessionId?: string;
         kind: components["schemas"]["TaskKind"];
         state: components["schemas"]["TaskState"];
         definitionRevision?: number;
@@ -107,6 +136,9 @@ export declare class JavaManagedAgentClient {
         modelSelection: components["schemas"]["WebShellModelSelection"];
         supported: boolean;
     }>;
+    getSessionSkills(sessionId: string, signal?: AbortSignal): Promise<{
+        skills: components["schemas"]["WebShellSkill"][];
+    }>;
     changeModel(request: Schemas['WebShellChangeModelRequest'], signal?: AbortSignal): Promise<{
         sessionId: string;
         modelSelection: components["schemas"]["WebShellModelSelection"];

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

@@ -3,20 +3,26 @@ import type { ManagedToolResultReader } from './managed-tool-result-types';
 export type ManagedAgentSessionPhase = 'created' | 'admitted' | 'runtime_starting' | 'agent_running' | 'waiting_runtime' | 'tool_running' | 'cancelling' | 'completed' | 'failed' | 'cancelled';
 export type ManagedAgentRuntimeState = 'unknown' | 'starting' | 'ready' | 'failed';
 export type ManagedApprovalMode = 'default' | 'auto-edit' | 'yolo';
+export type ManagedInputBlock = components['schemas']['InputBlock'];
+export type ManagedSessionSkills = components['schemas']['WebShellSessionSkills'];
 export declare function isManagedApprovalMode(value: unknown): value is ManagedApprovalMode;
 export interface ManagedSessionOptions {
     approvalMode: ManagedApprovalMode;
     availableApprovalModes: ManagedApprovalMode[];
+    planModeSupported?: boolean;
+    inputAttachments?: boolean;
 }
 export interface ManagedSessionApproval extends ManagedSessionOptions {
     approvalRevision: number;
     supported: boolean;
+    planMode?: boolean;
 }
 export interface ManagedApprovalChangeResult {
     sessionId: string;
     approvalMode: ManagedApprovalMode;
     approvalRevision: number;
     replayed: boolean;
+    planMode?: boolean;
 }
 export interface ManagedModelContext {
     modelId: string;
@@ -47,6 +53,8 @@ export interface ManagedAgentSessionSummary {
     approvalMode?: ManagedApprovalMode;
     initialApprovalMode?: ManagedApprovalMode;
     approvalRevision?: number;
+    planMode?: boolean;
+    planModeSupported?: boolean;
     modelContext?: ManagedModelContext;
     modelSelection?: ManagedModelSelection;
     activeTurnId?: string;
@@ -75,6 +83,7 @@ export interface ManagedAgentSessionSummary {
         cwdChange?: boolean;
         modelChange?: boolean;
         approvalModeChange?: boolean;
+        inputAttachments?: boolean;
     };
     failure?: {
         code: string;
@@ -120,6 +129,15 @@ export type ManagedTaskEventPage = components['schemas']['WebShellTaskEventPage'
 export type ManagedTaskCancelOperation = components['schemas']['WebShellCommandOperation'] & {
     type: 'task_cancel';
 };
+export type ManagedRuntimeNode = components['schemas']['WebShellRuntimeNode'];
+export type ManagedWorkspaceDirectory = components['schemas']['WebShellWorkspaceDirectory'];
+export type ManagedWorkspaceCreateOperation = components['schemas']['WebShellWorkspaceCreateOperation'];
+export interface ManagedWorkspaceRegistration {
+    listNodes(options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellRuntimeNodePage']>;
+    checkDirectory(request: components['schemas']['WebShellWorkspaceDirectoryRequest'], options: ManagedAgentRequestOptions): Promise<ManagedWorkspaceDirectory>;
+    create(request: Omit<components['schemas']['WebShellWorkspaceRegisterRequest'], 'idempotencyKey' | 'requestId'>, options: ManagedAgentCommandOptions): Promise<ManagedWorkspaceCreateOperation>;
+    query(operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedWorkspaceCreateOperation>;
+}
 /** A Hosted tool approval waiting for the Session owner's answer. */
 export interface ManagedAgentPendingAction {
     actionId: string;
@@ -142,6 +160,9 @@ export interface ManagedAgentProvider {
     readonly storageKey: string;
     readonly canCancel: boolean;
     readonly acceptsWorkspaceCwd: boolean;
+    readonly skills?: {
+        list(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionSkills>;
+    };
     /** Present when the provider can serve Hosted permission Actions. */
     readonly actions?: {
         listPending(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedAgentPendingAction[]>;
@@ -175,6 +196,7 @@ export interface ManagedAgentProvider {
         submit(sessionId: string, request: {
             approvalMode: ManagedApprovalMode;
             expectedRevision: number;
+            planMode?: boolean;
         }, options: ManagedAgentCommandOptions & {
             requestId: string;
         }): Promise<ManagedApprovalChangeResult>;
@@ -188,6 +210,7 @@ export interface ManagedAgentProvider {
     };
     readonly workspaceBinding?: {
         readonly agentId: string;
+        readonly registration?: ManagedWorkspaceRegistration;
         /** Host-published model-specific AgentDefinitions available for new Sessions. */
         readonly modelPresets?: readonly {
             agentId: string;
@@ -202,18 +225,26 @@ export interface ManagedAgentProvider {
             nextCursor?: string;
             supported: boolean;
             canCreateWorkspace?: boolean;
+            canSelectDirectory?: boolean;
             supportsApprovalModeSelection?: boolean;
         }>;
         get(workspaceId: string, options: ManagedAgentRequestOptions): Promise<ManagedAgentWorkspace>;
         createWorkspace?(request: {
             displayName: string;
+            sourceWorkspaceId?: string;
+            cwdRelative?: string;
         }, options: ManagedAgentCommandOptions): Promise<ManagedAgentWorkspace>;
+        directories?(request: {
+            workspaceId: string;
+            cwdRelative: string;
+        }, options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceDirectoryPage']>;
         getSessionOptions?(agentId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionOptions>;
         createEmpty(request: {
             agentId: string;
             workspaceId: string;
             cwdRelative: string;
             approvalMode?: ManagedApprovalMode;
+            planMode?: boolean;
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;
@@ -222,7 +253,9 @@ export interface ManagedAgentProvider {
             workspaceId: string;
             cwdRelative: string;
             text: string;
+            input?: ManagedInputBlock[];
             approvalMode?: ManagedApprovalMode;
+            planMode?: boolean;
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;
@@ -243,9 +276,11 @@ export interface ManagedAgentProvider {
     createSession(request: {
         text: string;
         workspaceCwd?: string;
+        input?: ManagedInputBlock[];
     }, options: ManagedAgentCommandOptions): Promise<ManagedAgentTurnAdmission>;
     submitPrompt(sessionId: string, request: {
         text: string;
+        input?: ManagedInputBlock[];
     }, options: ManagedAgentCommandOptions): Promise<ManagedAgentTurnAdmission>;
     cancel(sessionId: string, turnId: string, options: ManagedAgentCommandOptions): Promise<void>;
     subscribeEvents(sessionId: string, options: ManagedAgentRequestOptions & {
@@ -270,4 +305,6 @@ export interface ManagedAgentWorkspace {
     displayName: string;
     state: string;
     canCreateSession: boolean;
+    defaultCwdRelative?: string;
+    canSelectDirectory?: boolean;
 }

package/dist/types/components/managed/managed-input.d.ts

@@ -0,0 +1,7 @@
+import type { PromptFile, PromptImage } from '../../adapters/promptTypes';
+import type { ManagedInputBlock } from './managed-agent-provider';
+import type { EditorHandle } from '../../hooks/useComposerCore';
+export declare function isManagedInput(value: unknown): value is ManagedInputBlock[];
+export declare function encodeManagedInput(text: string, images?: readonly PromptImage[], files?: readonly PromptFile[]): Promise<ManagedInputBlock[]>;
+export declare function managedInputText(input: readonly ManagedInputBlock[]): string;
+export declare function restoreManagedAttachments(editor: EditorHandle | null, input?: readonly ManagedInputBlock[]): void;

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

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const WORKSPACE_REGISTRATION_MESSAGES_EN: Record<string, string>;
+export declare const WORKSPACE_REGISTRATION_MESSAGES_ZH: Record<string, string>;

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

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

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

@@ -5,6 +5,7 @@ interface ApprovalIntent {
     expectedRevision: number;
     idempotencyKey: string;
     requestId: string;
+    planMode?: boolean;
 }
 export declare function useManagedApprovalChange(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined, summary: ManagedAgentSessionSummary | undefined, refreshSummary: (signal?: AbortSignal) => Promise<ManagedAgentSessionSummary | undefined>, interactive: boolean): {
     options: ManagedSessionApproval | undefined;
@@ -12,7 +13,7 @@ export declare function useManagedApprovalChange(provider: ManagedAgentProvider,
     optionsError: boolean;
     supported: boolean;
     blocked: boolean;
-    submit: (approvalMode: ManagedApprovalMode) => Promise<true | undefined>;
+    submit: (approvalMode: ManagedApprovalMode, planMode?: boolean) => Promise<true | undefined>;
     confirm: () => Promise<true | undefined>;
     reloadOptions: () => void;
     isBlocked: () => boolean;

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

@@ -0,0 +1,12 @@
+import type { ManagedAgentProvider } from './managed-agent-provider';
+export declare function useManagedSkills(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined): {
+    supported: boolean;
+    skills: {
+        name: string;
+        description: string;
+    }[];
+    loading: boolean;
+    loaded: boolean;
+    error: boolean;
+    onOpenChange: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+};

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

@@ -9,6 +9,7 @@ export declare function useManagedTasks(provider: ManagedAgentProvider, clientId
     task: {
         taskId: string;
         sessionId: string;
+        childSessionId?: string;
         kind: import("./generated/managed-agent-api").components["schemas"]["TaskKind"];
         state: import("./generated/managed-agent-api").components["schemas"]["TaskState"];
         definitionRevision?: number;

package/dist/types/customization.d.ts

@@ -1,3 +1,4 @@
+import type { WebShellApprovalMode } from './utils/planMode';
 import type { ArtifactFilter } from './components/artifacts/TurnOutputs';
 import { type CSSProperties, type ComponentType, type ReactNode } from 'react';
 import type { Components, Options } from 'react-markdown';
@@ -512,6 +513,7 @@ export type FooterRenderer = ComponentType<WebShellFooterRenderInfo>;
  */
 export type LoadingPhrasesResolver = (language: string) => readonly string[] | undefined | null;
 export interface WebShellCustomization {
+    allowedApprovalModes?: readonly WebShellApprovalMode[];
     filterArtifact?: ArtifactFilter;
     artifact?: WebShellArtifactCustomization;
     /** Host-specific label for the Ask User Question free-text choice. */

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

@@ -0,0 +1,2 @@
+import { type WebShellApprovalMode } from '../utils/planMode';
+export declare function useApprovalModes(cwd: string | undefined, allowedApprovalModes: readonly WebShellApprovalMode[] | undefined): readonly WebShellApprovalMode[];

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

@@ -10,8 +10,4 @@ export declare function useInputHistory(storageKey?: string, fallbackStorageKey?
     getReverseMatches: (query: string) => string[];
     getLastEntry: (filter?: (entry: string) => boolean) => string | null;
     resetSearch: () => void;
-    nav: {
-        canUp: boolean;
-        canDown: boolean;
-    };
 };

package/dist/types/index.d.ts

@@ -6,12 +6,13 @@ import { type WebShellBrowserNotificationsOptions } from './browser-turn-notific
 export { WebShellTranscript } from './components/WebShellTranscript';
 export type { WebShellTranscriptProps } from './components/WebShellTranscript';
 export * from './daemon-react-sdk';
+export type { WebShellApprovalMode } from './utils/planMode';
 export type { WebShellBrowserNotificationsOptions } from './browser-turn-notifications';
 export { JavaManagedAgentClient, JavaManagedAgentHttpError, type JavaAgentCommandAdmission, type JavaAgentEnvironment, type JavaAgentEvent, type JavaAgentSession, type JavaAgentTranscript, type JavaAgentTurn, type JavaManagedAgentClientOptions, } from './components/managed/java-managed-agent-client';
 export { createJavaManagedAgentProvider, type JavaManagedAgentProviderOptions, } from './components/managed/java-managed-agent-provider';
 export { ManagedAgentWebShell, type ManagedAgentWebShellProps, } from './ManagedAgentWebShell';
 export type { ManagedArtifact, ManagedArtifactPage, ManagedArtifactResponse, ManagedArtifactSave, ManagedToolResult, ManagedToolResultReader, ManagedToolResultResponse, } from './components/managed/managed-tool-result-types';
-export { type ManagedAgentCommandOptions, type ManagedAgentPendingAction, type ManagedAgentProvider, type ManagedAgentRequestOptions, type ManagedAgentRuntimeState, type ManagedAgentSessionEvent, type ManagedAgentSessionEventType, type ManagedAgentSessionPhase, type ManagedAgentSessionSummary, type ManagedAgentSessionTranscript, type ManagedAgentTurnAdmission, } from './components/managed/managed-agent-provider';
+export { type ManagedAgentCommandOptions, type ManagedAgentPendingAction, type ManagedAgentProvider, type ManagedAgentRequestOptions, type ManagedAgentRuntimeState, type ManagedAgentSessionEvent, type ManagedAgentSessionEventType, type ManagedAgentSessionPhase, type ManagedAgentSessionSummary, type ManagedAgentSessionTranscript, type ManagedAgentTurnAdmission, type ManagedRuntimeNode, type ManagedWorkspaceDirectory, type ManagedWorkspaceCreateOperation, type ManagedWorkspaceRegistration, } from './components/managed/managed-agent-provider';
 export interface WebShellWithProvidersProps extends WebShellProps {
     /**
      * Opt in to URL routing. Explicit initial session target props override the

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

@@ -1,4 +1,8 @@
-export declare const EXECUTION_APPROVAL_MODES: ("default" | "auto-edit" | "yolo" | "auto")[];
+import { DAEMON_APPROVAL_MODES } from '@qwen-code/web-shell/daemon-react-sdk';
+export type WebShellApprovalMode = Exclude<(typeof DAEMON_APPROVAL_MODES)[number], 'plan'>;
+export declare const EXECUTION_APPROVAL_MODES: ("auto" | "default" | "auto-edit" | "yolo")[];
+export declare function resolveApprovalModes(value: unknown): readonly WebShellApprovalMode[];
+export declare function nextApprovalMode(available: readonly WebShellApprovalMode[], current: string): WebShellApprovalMode | undefined;
 export declare function parsePlanCommand(args: string, enabled: boolean): {
     enabled: boolean;
     prompt?: string;

package/dist/types/voice/voice-workspace-target.d.ts

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { DaemonCapabilities, DaemonClient, DaemonSettingUpdateResult, DaemonWorkspaceCapability, DaemonWorkspaceSettingsStatus, DaemonWorkspaceVoiceStatus } from '@qwen-code/sdk/daemon';
+export declare const QUALIFIED_CORE_FEATURE = "workspace_qualified_rest_core";
+export declare const WORKSPACE_SETTINGS_FEATURE = "workspace_settings";
 interface VoiceTargetBase {
     cwd?: string;
     workspaceKey: string;