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

package/dist/types/components/managed/generated/managed-agent-api.d.ts

@@ -412,6 +412,108 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/agent/web-shell/v1/workspaces/create": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Create an independent empty Workspace under the operator-controlled creation root and grant its authenticated creator OWNER access. Disabled deployments reject creation. The actor-scoped idempotency key freezes the normalized name and storage registration; retry the same request after an uncertain response. Completed replay checks current access and does not restore removed Workspaces or revoked grants. No host path is accepted or returned. */
+        post: operations["webShellCreateWorkspace"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-options/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Read effective approval policy options for an Agent in the authenticated tenant. Requires an actor. Does not create a Session or change an existing policy. */
+        post: operations["queryWebShellSessionOptions"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-models/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Read the allowed model catalog and current model selection of a readable Session. No credentials or provider routes are returned. */
+        post: operations["queryWebShellSessionModels"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-models/change": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Change the model of an idle Workspace Session for later Turns. The actor-scoped idempotency key replays an earlier completed change before current admission checks; expectedRevision prevents overwriting a concurrent selection. */
+        post: operations["changeWebShellSessionModel"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-approval/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Read the current policy and owner-authorized change support of a readable Workspace Session. */
+        post: operations["queryWebShellSessionApproval"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-approval/change": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Change the next-Turn policy of an idle built-in Workspace Session. Requires its recorded owner and current OPERATOR access. Changes are revision-checked and actor/session-scoped idempotent. */
+        post: operations["changeWebShellSessionApproval"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -480,6 +582,11 @@ export interface components {
             input?: components["schemas"]["InputBlock"][];
             metadata?: components["schemas"]["WebShellMetadata"];
             workspace?: components["schemas"]["WebShellWorkspaceSelection"];
+            /**
+             * @description Optional policy for Workspace-bound creation only. Omission preserves the existing default and idempotency digest. Explicit selection is validated against the resolved Agent and tool profile and frozen in the Session; Shell refuses yolo and definitions retain their compiled policy.
+             * @enum {string}
+             */
+            approvalMode?: "default" | "auto-edit" | "yolo";
         };
         WebShellSubmitRequest: {
             /** @description Trace correlation only. */
@@ -540,6 +647,20 @@ export interface components {
             lastSequence: number;
             workspace?: components["schemas"]["WebShellWorkspaceContext"];
             capabilities: components["schemas"]["WebShellSessionCapabilities"];
+            /**
+             * @description Current effective approval policy; initialApprovalMode retains the immutable creation policy.
+             * @enum {string}
+             */
+            approvalMode?: "default" | "auto-edit" | "yolo";
+            modelContext?: components["schemas"]["WebShellModelContext"];
+            modelSelection?: components["schemas"]["WebShellModelSelection"];
+            /** Format: int64 */
+            approvalRevision?: number;
+            /**
+             * @description Immutable creation-time policy, used to confirm creation replay.
+             * @enum {string}
+             */
+            initialApprovalMode?: "default" | "auto-edit" | "yolo";
         };
         WebShellSessionCapabilities: {
             /**
@@ -576,8 +697,12 @@ export interface components {
              * @default false
              */
             sessionDelete?: boolean;
-            /** @description Present only for persisted Shell Sessions, with no schema default; files and unbound Sessions omit it. True when Workspace files, Shell deployment admission and persisted default/auto-edit approval are valid. False prevents fresh sending. Disabling only the Shell flag preserves accepted cancellation and approval while Workspace files remain enabled and persisted approval remains valid; files-off or invalid approval can refuse attachment. This capability does not override authorization or recovery refusals. */
+            /** @description Present only for persisted Shell Sessions, with no schema default; files and unbound Sessions omit it. True when Workspace files, Shell deployment admission and a valid persisted approval mode are valid. False prevents fresh sending. Disabling only the Shell flag preserves accepted cancellation and approval while Workspace files remain enabled and persisted approval remains valid; files-off or invalid approval can refuse attachment. This capability does not override authorization or recovery refusals. */
             foregroundShell?: boolean;
+            /** @description The caller may request an idle Session model change using the server model catalog. Missing means unsupported; authorization and revision admission still apply. */
+            modelChange?: boolean;
+            /** @description The caller owns this built-in Workspace Session with OPERATOR access and the Harness supports approval-selection/1. Idle-state admission is checked separately. Missing means false. */
+            approvalModeChange?: boolean;
         };
         WebShellSessionPage: {
             data: components["schemas"]["WebShellSession"][];
@@ -715,6 +840,10 @@ export interface components {
                 workspaceContext: boolean;
                 /** @description Supports authorized Workspace discovery, Session creation, and saved binding read-back. This capability does not advertise execution readiness. Deployments may separately opt in to an initial Workspace Turn at creation: Read/Write/Edit under hosted-workspace-files/1, or file tools plus mandatory-approval foreground Shell under hosted-workspace-shell/1 when the Shell opt-in is enabled. The public Shell tool list does not include the child agent tool. Callers holding the OPERATOR role may submit later Turns or rename under the same opt-in while the registry row stays ACTIVE and still backs the Session's binding and the actor recorded by the Workspace create command keeps OPERATOR or above, and may cancel a running Turn (its delivery re-checks no grants). Shell fresh sending also requires foregroundShell=true. Public Shell close, archive, unarchive and delete stay unavailable, including protocol-0, while close of other profiles follows its separate capability and lifecycle admission; archive, delete and unarchive follow their separate retention capabilities after reliable Workspace close. */
                 workspaceBinding: boolean;
+                /** @description Supports creating empty Workspaces under the operator-controlled root. Missing or false means unsupported; current actor and server admission checks still apply. */
+                workspaceCreation?: boolean;
+                /** @description Supports effective Session policy options and explicit Workspace-bound creation policy. Missing or false means unsupported. */
+                approvalModeSelection?: boolean;
             };
             /** @description Same authorized explicit default as default_workspace, including when outside this page; null if absent or not creatable. A non-null default is active and has canCreateSession=true. */
             defaultWorkspace: (components["schemas"]["WebShellWorkspace"] & {
@@ -1097,6 +1226,89 @@ export interface components {
              */
             byteLength: number;
         };
+        WebShellWorkspaceCreateRequest: {
+            /** @description Trimmed display name, without control characters. The server validates the normalized name. */
+            displayName: string;
+            idempotencyKey: string;
+        };
+        WebShellSessionOptionsRequest: {
+            agentId: string;
+        };
+        WebShellSessionOptions: {
+            /** @enum {string} */
+            approvalMode: "default" | "auto-edit" | "yolo";
+            /** @description Effective modes for this Agent/profile. Stored definitions offer only their pinned mode; auto and plan are unsupported. */
+            availableApprovalModes: ("default" | "auto-edit" | "yolo")[];
+        };
+        /** @description Safe allowlisted observation for a Workspace-bound Session. Unknown counts are omitted, never estimated. */
+        WebShellModelContext: {
+            /** @description Actual model identity from the committed main-model usage resource. */
+            modelId: string;
+            /** @description Provider prompt token count for the latest successfully committed main-model request; not cumulative billing usage. */
+            inputTokens?: number;
+            /** @description Context capacity from the same resolved model configuration. Missing means unknown. */
+            contextWindowSize?: number;
+            /** @description Timestamp of the committed source observation, in Unix epoch milliseconds. */
+            observedAt: number;
+        };
+        WebShellModelSelection: {
+            modelId?: string;
+            /** Format: int64 */
+            revision: number;
+        };
+        WebShellModelOption: {
+            modelId: string;
+            label: string;
+        };
+        WebShellSessionModelsRequest: {
+            sessionId: string;
+        };
+        WebShellSessionModels: {
+            models: components["schemas"]["WebShellModelOption"][];
+            modelSelection: components["schemas"]["WebShellModelSelection"];
+            supported: boolean;
+        };
+        WebShellChangeModelRequest: {
+            sessionId: string;
+            modelId: string;
+            /** Format: int64 */
+            expectedRevision: number;
+            idempotencyKey: string;
+            requestId?: string;
+        };
+        WebShellModelChangeResult: {
+            sessionId: string;
+            modelSelection: components["schemas"]["WebShellModelSelection"];
+            replayed: boolean;
+        };
+        WebShellSessionApprovalRequest: {
+            sessionId: string;
+        };
+        WebShellSessionApproval: {
+            /** @enum {string} */
+            approvalMode: "default" | "auto-edit" | "yolo";
+            /** Format: int64 */
+            approvalRevision: number;
+            availableApprovalModes: ("default" | "auto-edit" | "yolo")[];
+            supported: boolean;
+        };
+        WebShellChangeApprovalRequest: {
+            sessionId: string;
+            /** Format: int64 */
+            expectedRevision: number;
+            idempotencyKey: string;
+            requestId?: string;
+            /** @enum {string} */
+            approvalMode: "default" | "auto-edit" | "yolo";
+        };
+        WebShellApprovalChangeResult: {
+            sessionId: string;
+            /** @enum {string} */
+            approvalMode: "default" | "auto-edit" | "yolo";
+            /** Format: int64 */
+            approvalRevision: number;
+            replayed: boolean;
+        };
     };
     responses: {
         /** @description The authenticated actor belongs to another tenant than X-Qwen-Tenant-Id or has an invalid ID (actor_scope_mismatch, which the tenant filter answers on every /v1/agents/ and WebShell route), or the resource is readable but the actor lacks this operation or the original Action responder permission. Artifact content reads may also return artifact_content_forbidden when the actor cannot read the original bytes. */
@@ -2035,4 +2247,183 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
+    webShellCreateWorkspace: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellWorkspaceCreateRequest"];
+            };
+        };
+        responses: {
+            /** @description Created Workspace or authorized same-key replay. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellWorkspace"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    queryWebShellSessionOptions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellSessionOptionsRequest"];
+            };
+        };
+        responses: {
+            /** @description Effective default and supported policies. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellSessionOptions"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    queryWebShellSessionModels: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellSessionModelsRequest"];
+            };
+        };
+        responses: {
+            /** @description Session model options. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellSessionModels"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    changeWebShellSessionModel: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellChangeModelRequest"];
+            };
+        };
+        responses: {
+            /** @description The admitted model selection, or the same original result on replay. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellModelChangeResult"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    queryWebShellSessionApproval: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellSessionApprovalRequest"];
+            };
+        };
+        responses: {
+            /** @description The current policy options. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellSessionApproval"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    changeWebShellSessionApproval: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellChangeApprovalRequest"];
+            };
+        };
+        responses: {
+            /** @description The committed approval selection, or its original receipt on replay. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellApprovalChangeResult"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
 }

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

@@ -52,6 +52,10 @@ export declare class JavaManagedAgentClient {
         canCreateSession: boolean;
         state: "active" | "draining" | "removed";
     }>;
+    createWorkspace(request: Schemas['WebShellWorkspaceCreateRequest'], signal?: AbortSignal): Promise<JavaAgentWorkspace>;
+    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']>;
     getTranscript(request: Schemas['WebShellTranscriptRequest'], signal?: AbortSignal): Promise<JavaAgentTranscript>;
     createSession(request: Schemas['WebShellCreateRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
     submitTurn(request: Schemas['WebShellSubmitRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
@@ -98,6 +102,16 @@ export declare class JavaManagedAgentClient {
     /** 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']>;
+    getSessionModels(sessionId: string, signal?: AbortSignal): Promise<{
+        models: components["schemas"]["WebShellModelOption"][];
+        modelSelection: components["schemas"]["WebShellModelSelection"];
+        supported: boolean;
+    }>;
+    changeModel(request: Schemas['WebShellChangeModelRequest'], signal?: AbortSignal): Promise<{
+        sessionId: string;
+        modelSelection: components["schemas"]["WebShellModelSelection"];
+        replayed: boolean;
+    }>;
     getToolResult(sessionId: string, itemId: string, signal?: AbortSignal): Promise<{
         result: components["schemas"]["PublicToolResult"];
         access: components["schemas"]["ArtifactAccess"];

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

@@ -2,9 +2,53 @@ import type { components } from './generated/managed-agent-api';
 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 declare function isManagedApprovalMode(value: unknown): value is ManagedApprovalMode;
+export interface ManagedSessionOptions {
+    approvalMode: ManagedApprovalMode;
+    availableApprovalModes: ManagedApprovalMode[];
+}
+export interface ManagedSessionApproval extends ManagedSessionOptions {
+    approvalRevision: number;
+    supported: boolean;
+}
+export interface ManagedApprovalChangeResult {
+    sessionId: string;
+    approvalMode: ManagedApprovalMode;
+    approvalRevision: number;
+    replayed: boolean;
+}
+export interface ManagedModelContext {
+    modelId: string;
+    inputTokens?: number;
+    contextWindowSize?: number;
+    observedAt: number;
+}
+export interface ManagedModelSelection {
+    modelId?: string;
+    revision: number;
+}
+export interface ManagedSessionModels {
+    models: {
+        modelId: string;
+        label: string;
+    }[];
+    modelSelection: ManagedModelSelection;
+    supported: boolean;
+}
+export interface ManagedModelChangeResult {
+    sessionId: string;
+    modelSelection: ManagedModelSelection;
+    replayed: boolean;
+}
 export interface ManagedAgentSessionSummary {
     sessionId: string;
     agentId?: string;
+    approvalMode?: ManagedApprovalMode;
+    initialApprovalMode?: ManagedApprovalMode;
+    approvalRevision?: number;
+    modelContext?: ManagedModelContext;
+    modelSelection?: ManagedModelSelection;
     activeTurnId?: string;
     title: string;
     workspaceCwd?: string;
@@ -29,6 +73,8 @@ export interface ManagedAgentSessionSummary {
         /** The caller may submit later Turns to this Workspace-bound Session. */
         workspaceTurns?: boolean;
         cwdChange?: boolean;
+        modelChange?: boolean;
+        approvalModeChange?: boolean;
     };
     failure?: {
         code: string;
@@ -124,6 +170,22 @@ export interface ManagedAgentProvider {
         }, options: ManagedAgentCommandOptions): Promise<ManagedCwdOperation>;
         query(sessionId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedCwdOperation>;
     };
+    readonly approvalChange?: {
+        queryOptions(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionApproval>;
+        submit(sessionId: string, request: {
+            approvalMode: ManagedApprovalMode;
+            expectedRevision: number;
+        }, options: ManagedAgentCommandOptions & {
+            requestId: string;
+        }): Promise<ManagedApprovalChangeResult>;
+    };
+    readonly modelChange?: {
+        queryOptions(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionModels>;
+        submit(sessionId: string, request: {
+            modelId: string;
+            expectedRevision: number;
+        }, options: ManagedAgentCommandOptions): Promise<ManagedModelChangeResult>;
+    };
     readonly workspaceBinding?: {
         readonly agentId: string;
         /** Host-published model-specific AgentDefinitions available for new Sessions. */
@@ -139,12 +201,19 @@ export interface ManagedAgentProvider {
             defaultWorkspace?: ManagedAgentWorkspace | null;
             nextCursor?: string;
             supported: boolean;
+            canCreateWorkspace?: boolean;
+            supportsApprovalModeSelection?: boolean;
         }>;
         get(workspaceId: string, options: ManagedAgentRequestOptions): Promise<ManagedAgentWorkspace>;
+        createWorkspace?(request: {
+            displayName: string;
+        }, options: ManagedAgentCommandOptions): Promise<ManagedAgentWorkspace>;
+        getSessionOptions?(agentId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionOptions>;
         createEmpty(request: {
             agentId: string;
             workspaceId: string;
             cwdRelative: string;
+            approvalMode?: ManagedApprovalMode;
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;
@@ -153,6 +222,7 @@ export interface ManagedAgentProvider {
             workspaceId: string;
             cwdRelative: string;
             text: string;
+            approvalMode?: ManagedApprovalMode;
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;

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

@@ -1,6 +1,6 @@
 export declare function managedRequestId(): string;
 export declare function getManagedClientId(baseUrl: string): string;
-export declare function managedSelectionFromUrl(): {
+export declare function managedSelectionFromUrl(defaultOpen?: boolean): {
     open: boolean;
     sessionId?: string;
 };

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

@@ -0,0 +1,24 @@
+import type { ManagedAgentProvider, ManagedApprovalMode, ManagedAgentSessionSummary, ManagedSessionApproval } from './managed-agent-provider';
+interface ApprovalIntent {
+    sessionId: string;
+    approvalMode: ManagedApprovalMode;
+    expectedRevision: number;
+    idempotencyKey: string;
+    requestId: string;
+}
+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;
+    optionsLoading: boolean;
+    optionsError: boolean;
+    supported: boolean;
+    blocked: boolean;
+    submit: (approvalMode: ManagedApprovalMode) => Promise<true | undefined>;
+    confirm: () => Promise<true | undefined>;
+    reloadOptions: () => void;
+    isBlocked: () => boolean;
+    key: string;
+    pending?: ApprovalIntent;
+    busy: boolean;
+    errorCode?: string;
+};
+export {};

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

@@ -0,0 +1,23 @@
+import type { ManagedAgentProvider, ManagedAgentSessionSummary, ManagedSessionModels } from './managed-agent-provider';
+interface ModelIntent {
+    sessionId: string;
+    modelId: string;
+    expectedRevision: number;
+    idempotencyKey: string;
+}
+export declare function useManagedModelChange(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined, summary: ManagedAgentSessionSummary | undefined, refreshSummary: (signal?: AbortSignal) => Promise<ManagedAgentSessionSummary | undefined>, interactive: boolean): {
+    options: ManagedSessionModels | undefined;
+    optionsLoading: boolean;
+    optionsError: boolean;
+    supported: boolean;
+    blocked: boolean;
+    submit: (modelId: string) => Promise<true | undefined>;
+    confirm: () => Promise<true | undefined>;
+    reloadOptions: () => void;
+    isBlocked: () => boolean;
+    key: string;
+    pending?: ModelIntent;
+    busy: boolean;
+    errorCode?: string;
+};
+export {};

package/dist/types/components/sidebar/WebShellSidebar.d.ts

@@ -135,6 +135,9 @@ interface WebShellSidebarProps {
     lockedWorkspace?: WebShellSidebarLockedWorkspace;
     branding?: false | WebShellSidebarBranding;
     primaryNav?: WebShellSidebarPrimaryNavOptions;
+    /** Replace daemon history with navigation owned by an external session provider. */
+    sessionContent?: ReactNode;
+    sessionHeader?: ReactNode;
     /** Whether to show the Tasks/Channels session-source switch. Defaults to true. */
     showSessionSourceSwitch?: boolean;
     /** Show Live conversations and, in rail layout, the Live entry. Defaults to false. */
@@ -162,4 +165,4 @@ interface WebShellSidebarProps {
     onLoadStandaloneSession?: (sessionId: string) => Promise<void> | void;
     onStandaloneNotice?: (message: string) => void;
 }
-export declare function WebShellSidebar({ collapsed, layout, activePage, containerWidth, onOpenHome, onCollapsedChange, onOpenSettings, onOpenAgents, onOpenPlugins, onOpenChannels, onOpenLive, onLiveVoiceSlotChange, onOpenManagedSessions, onOpenDaemonStatus, onOpenScheduledTasks, onOpenWorkflows, onOpenGoals, onOpenSessions, canOpenSessionsOverview, onOpenWorkspacesOverview, onOpenSplitView, canOpenSplitView, onNewSession, onNewStandaloneSession, onLoadSession, onOpenHostSession, onSelectCurrentSession, onSessionRenameConfirmed, onSessionsDeleted, onError, theme, onThemeChange, mobileOpen, onMobileClose, selectedWorkspaceCwd, onSelectWorkspace, onOpenGitDiff, onOpenCommit, onOpenAddWorkspace, workspaces: providedWorkspaces, lockedWorkspaceCwd, lockedWorkspace: lockedWorkspaceOptions, branding, primaryNav: primaryNavOptions, showSessionSourceSwitch, showLive, hideProjectHeader, sessionActions: sessionActionsOptions, footer, workspaceOverview, onOpenWorkspaceManagement, onNewWorktreeSession, projectFeaturesEnabled, onLoadStandaloneSession, onStandaloneNotice, }: WebShellSidebarProps): import("react/jsx-runtime").JSX.Element;
+export declare function WebShellSidebar({ collapsed, layout, activePage, containerWidth, onOpenHome, onCollapsedChange, onOpenSettings, onOpenAgents, onOpenPlugins, onOpenChannels, onOpenLive, onLiveVoiceSlotChange, onOpenManagedSessions, onOpenDaemonStatus, onOpenScheduledTasks, onOpenWorkflows, onOpenGoals, onOpenSessions, canOpenSessionsOverview, onOpenWorkspacesOverview, onOpenSplitView, canOpenSplitView, onNewSession, onNewStandaloneSession, onLoadSession, onOpenHostSession, onSelectCurrentSession, onSessionRenameConfirmed, onSessionsDeleted, onError, theme, onThemeChange, mobileOpen, onMobileClose, selectedWorkspaceCwd, onSelectWorkspace, onOpenGitDiff, onOpenCommit, onOpenAddWorkspace, workspaces: providedWorkspaces, lockedWorkspaceCwd, lockedWorkspace: lockedWorkspaceOptions, branding, primaryNav: primaryNavOptions, sessionContent, sessionHeader, showSessionSourceSwitch, showLive, hideProjectHeader, sessionActions: sessionActionsOptions, footer, workspaceOverview, onOpenWorkspaceManagement, onNewWorktreeSession, projectFeaturesEnabled, onLoadStandaloneSession, onStandaloneNotice, }: WebShellSidebarProps): import("react/jsx-runtime").JSX.Element;

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?: "success" | "default" | "destructive" | null | undefined;
+    variant?: "default" | "success" | "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;