@qwen-code/web-shell 0.26.0 → 0.26.1-nightly.20261025.8e28d5380c

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

@@ -1,7 +1,7 @@
+import type { ManagedExtensionManifest, ManagedExtensionPin, ManagedExtensionPackageOperation, ManagedExtensionSelection } from './managed-extension-types';
 import type { components } from './generated/managed-agent-api';
 import type { ManagedArtifact } from './managed-tool-result-types';
 type Schemas = components['schemas'];
-export type JavaAgentDate = number | string;
 export type JavaAgentTurn = Schemas['WebShellTurn'];
 export interface JavaAgentEnvironment {
     environmentId?: string;
@@ -23,6 +23,7 @@ export declare function isJavaAgentResyncRequired(frame: JavaAgentEvent | JavaAg
 export type JavaAgentContentPart = Schemas['WebShellContentPart'];
 export type JavaAgentItem = Schemas['WebShellItem'];
 export type JavaAgentCommandAdmission = Schemas['WebShellAdmission'];
+export type JavaAgentTurnAdmission = Schemas['WebShellTurnAdmission'];
 export type JavaAgentTranscript = Schemas['WebShellTranscript'];
 export type JavaAgentAction = Schemas['WebShellAction'];
 export type JavaAgentActionPage = Schemas['WebShellActionPage'];
@@ -45,6 +46,22 @@ export declare class JavaManagedAgentClient {
     constructor(options: JavaManagedAgentClientOptions);
     listSessions(request: Schemas['WebShellListRequest'], signal?: AbortSignal): Promise<JavaAgentSessionPage>;
     getSession(sessionId: string, signal?: AbortSignal): Promise<JavaAgentSession>;
+    getRecovery(sessionId: string, signal?: AbortSignal): Promise<{
+        state: "recovering" | "awaiting_evidence" | "cleanup_pending" | "ready" | "operator_required";
+        reasonCode: string;
+        turnId?: string;
+        nextTurnAllowed: boolean;
+        actions: components["schemas"]["SessionRecoveryActions"];
+        nextRecheckAt?: number;
+    }>;
+    recheckRecovery(sessionId: string, turnId: string, signal?: AbortSignal): Promise<{
+        state: "recovering" | "awaiting_evidence" | "cleanup_pending" | "ready" | "operator_required";
+        reasonCode: string;
+        turnId?: string;
+        nextTurnAllowed: boolean;
+        actions: components["schemas"]["SessionRecoveryActions"];
+        nextRecheckAt?: number;
+    }>;
     renameSession(request: Schemas['WebShellRenameRequest'], signal?: AbortSignal): Promise<Schemas['WebShellRenameResult']>;
     listWorkspaces(request: Schemas['WebShellWorkspaceQueryRequest'], signal?: AbortSignal): Promise<JavaAgentWorkspacePage>;
     getWorkspace(workspaceId: string, signal?: AbortSignal): Promise<{
@@ -87,15 +104,36 @@ export declare class JavaManagedAgentClient {
     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']>;
+    lifecycleCommand(kind: 'close' | 'archive' | 'delete', request: Schemas['WebShellLifecycleRequest'], 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;
+    }>;
+    unarchiveSession(request: Schemas['WebShellLifecycleRequest'], signal?: AbortSignal): Promise<JavaAgentSession>;
+    exportSnapshot(request: Schemas['WebShellExportRequest'], signal?: AbortSignal): Promise<{
+        items: components["schemas"]["WebShellItem"][];
+        nextCursor?: string | null;
+        hasMore: boolean;
+        snapshotThroughSequence: number;
+    }>;
     getTranscript(request: Schemas['WebShellTranscriptRequest'], signal?: AbortSignal): Promise<JavaAgentTranscript>;
     createSession(request: Schemas['WebShellCreateRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
-    submitTurn(request: Schemas['WebShellSubmitRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
-    cancelTurn(request: Schemas['WebShellCancelRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
+    submitTurn(request: Schemas['WebShellSubmitRequest'], signal?: AbortSignal): Promise<JavaAgentTurnAdmission>;
+    cancelTurn(request: Schemas['WebShellCancelRequest'], signal?: AbortSignal): Promise<JavaAgentTurnAdmission>;
     queryActions(request: Schemas['WebShellActionQueryRequest'], signal?: AbortSignal): Promise<JavaAgentActionPage>;
     listTasks(request: Schemas['WebShellTaskQueryRequest'], signal?: AbortSignal): Promise<{
         data: components["schemas"]["WebShellTask"][];
         hasMore: boolean;
         nextCursor?: string | null;
+        activeChildCount?: number;
     }>;
     getTask(request: Schemas['WebShellTaskGetRequest'], signal?: AbortSignal): Promise<{
         taskId: string;
@@ -111,6 +149,8 @@ export declare class JavaManagedAgentClient {
         outputCursor?: string;
         artifactRefs: string[];
         actionCapabilities: components["schemas"]["TaskActionCapability"][];
+        stopRequested?: boolean;
+        approvalMode?: "default" | "auto-edit" | "yolo";
     }>;
     listTaskEvents(request: Schemas['WebShellTaskEventQueryRequest'], signal?: AbortSignal): Promise<{
         data: components["schemas"]["WebShellTaskEvent"][];
@@ -134,6 +174,7 @@ 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']>;
+    compressContext(request: Schemas['WebShellContextCompressionRequest'], signal?: AbortSignal): Promise<Schemas['WebShellContextCompressionOperation']>;
     getSessionModels(sessionId: string, signal?: AbortSignal): Promise<{
         models: components["schemas"]["WebShellModelOption"][];
         modelSelection: components["schemas"]["WebShellModelSelection"];
@@ -147,6 +188,76 @@ export declare class JavaManagedAgentClient {
         session_id: string;
         servers: components["schemas"]["PublicMcpServerCatalog"][];
     }>;
+    listExtensionPackages(workspaceId: string, signal?: AbortSignal): Promise<{
+        supported: boolean;
+        extensions: components["schemas"]["ManagedExtensionPackage"][];
+    }>;
+    publishExtensionPackage(workspaceId: string, extensionId: string | undefined, packageDigest: string, manifest: ManagedExtensionManifest, archive: Blob, idempotencyKey: string, signal?: AbortSignal): Promise<ManagedExtensionPackageOperation>;
+    getExtensionSettings(workspaceId: string, extensionId: string, signal?: AbortSignal): Promise<{
+        settingsRevision: number;
+        configuredKeys: string[];
+    }>;
+    saveExtensionSettings(workspaceId: string, extensionId: string, expectedRevision: number, values: Record<string, string>, idempotencyKey: string, signal?: AbortSignal): Promise<{
+        operationId: string;
+        extensionId: string;
+        kind: "publish" | "settings";
+        state: "pending" | "settled";
+        revision: number;
+        packageDigest: string | null;
+    }>;
+    queryExtensionConfiguration(sessionId: string, operationId?: string, signal?: AbortSignal): Promise<{
+        sessionId: string;
+        supported: boolean;
+        revision: number;
+        extensions: components["schemas"]["ManagedExtensionPackagePin"][];
+        requestedExtensions: components["schemas"]["ManagedExtensionPackagePin"][];
+        operation?: components["schemas"]["ManagedExtensionApplyOperation"];
+    }>;
+    applyExtensionConfiguration(sessionId: string, command: ManagedExtensionSelection, idempotencyKey: string, signal?: AbortSignal): Promise<{
+        sessionId: string;
+        supported: boolean;
+        revision: number;
+        extensions: components["schemas"]["ManagedExtensionPackagePin"][];
+        requestedExtensions: components["schemas"]["ManagedExtensionPackagePin"][];
+        operation?: components["schemas"]["ManagedExtensionApplyOperation"];
+    }>;
+    resumeExtensionConfiguration(sessionId: string, operationId: string, recoverPrevious: boolean, signal?: AbortSignal): Promise<{
+        sessionId: string;
+        supported: boolean;
+        revision: number;
+        extensions: components["schemas"]["ManagedExtensionPackagePin"][];
+        requestedExtensions: components["schemas"]["ManagedExtensionPackagePin"][];
+        operation?: components["schemas"]["ManagedExtensionApplyOperation"];
+    }>;
+    getExtensionPackage(workspaceId: string, pin: ManagedExtensionPin, signal?: AbortSignal): Promise<{
+        pin: components["schemas"]["ManagedExtensionPackagePin"];
+        manifest: components["schemas"]["ManagedExtensionPackageManifest"];
+        byteLength: number;
+    }>;
+    queryMcpManagement(request: Schemas['WebShellMcpManagementQuery'], signal?: AbortSignal): Promise<{
+        sessionId: string;
+        revision: number;
+        supported: boolean;
+        availableServers: components["schemas"]["ManagedMcpPublishedServer"][];
+        servers: components["schemas"]["ManagedMcpManagementServer"][];
+        operation?: components["schemas"]["ManagedMcpManagementOperation"];
+    }>;
+    submitMcpManagement(request: Schemas['WebShellMcpManagementSubmit'], signal?: AbortSignal): Promise<{
+        sessionId: string;
+        revision: number;
+        supported: boolean;
+        availableServers: components["schemas"]["ManagedMcpPublishedServer"][];
+        servers: components["schemas"]["ManagedMcpManagementServer"][];
+        operation?: components["schemas"]["ManagedMcpManagementOperation"];
+    }>;
+    getMcpManagementOperation(request: Schemas['WebShellMcpManagementOperationQuery'], signal?: AbortSignal): Promise<{
+        sessionId: string;
+        revision: number;
+        supported: boolean;
+        availableServers: components["schemas"]["ManagedMcpPublishedServer"][];
+        servers: components["schemas"]["ManagedMcpManagementServer"][];
+        operation?: components["schemas"]["ManagedMcpManagementOperation"];
+    }>;
     changeModel(request: Schemas['WebShellChangeModelRequest'], signal?: AbortSignal): Promise<{
         sessionId: string;
         modelSelection: components["schemas"]["WebShellModelSelection"];
@@ -181,6 +292,14 @@ export declare class JavaManagedAgentClient {
     openArtifactStream(artifact: ManagedArtifact, signal?: AbortSignal): Promise<ReadableStream<Uint8Array>>;
     private artifactContent;
     streamEvents(request: Schemas['WebShellStreamRequest'], signal?: AbortSignal, onOpen?: () => void, onAlive?: () => void): AsyncGenerator<JavaAgentEvent | JavaAgentResyncRequired>;
+    queryUserMessages(sessionId: string, signal?: AbortSignal): Promise<{
+        paused: boolean;
+        messages: components["schemas"]["UserMessage"][];
+    }>;
+    commandUserMessages(sessionId: string, command: import('./use-managed-user-messages').ManagedUserMessageCommand, idempotencyKey: string, signal?: AbortSignal): Promise<{
+        paused: boolean;
+        messages: components["schemas"]["UserMessage"][];
+    }>;
     private post;
     private request;
 }

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

@@ -1,5 +1,4 @@
-import type { JavaAgentDate, JavaAgentEvent, JavaAgentItem } from './java-managed-agent-client';
+import type { JavaAgentEvent, JavaAgentItem } from './java-managed-agent-client';
 import type { ManagedAgentSessionEvent } from './managed-agent-provider';
 export declare function projectJavaAgentEvent(event: JavaAgentEvent): ManagedAgentSessionEvent | undefined;
 export declare function projectJavaAgentItem(item: JavaAgentItem): ManagedAgentSessionEvent[];
-export declare function toTimestamp(value: JavaAgentDate | undefined): number;

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

@@ -1,16 +1,12 @@
 import { type JavaManagedAgentClientOptions } from './java-managed-agent-client';
 import type { ManagedArtifactSave } from './managed-tool-result-types';
-import type { ManagedAgentProvider } from './managed-agent-provider';
+import type { ManagedAgentProvider, ManagedModelPreset } from './managed-agent-provider';
 export interface JavaManagedAgentProviderOptions extends JavaManagedAgentClientOptions {
     agentId?: string;
-    environmentId?: string;
     /** 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;
-    }[];
+    modelPresets?: readonly ManagedModelPreset[];
     /** Acquire a streaming save target during the user gesture, then call openStream. */
     saveArtifact?: ManagedArtifactSave;
 }

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

@@ -1,25 +1,45 @@
+import type { ManagedExtensionManifest, ManagedExtensionPin, ManagedExtensionCatalog, ManagedExtensionPackageOperation, ManagedExtensionSettings, ManagedExtensionSnapshot, ManagedExtensionSelection } from './managed-extension-types';
 import type { components } from './generated/managed-agent-api';
+import type { ManagedMcpManagementCommand, ManagedMcpManagementSnapshot } from './managed-mcp-management-types';
 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 declare function isManagedSessionRunning(phase: ManagedAgentSessionPhase): boolean;
 export type ManagedAgentRuntimeState = 'unknown' | 'starting' | 'ready' | 'failed';
-export type ManagedApprovalMode = 'default' | 'auto-edit' | 'yolo';
+export interface ManagedPermissionRules {
+    readonly allow: readonly string[];
+    readonly ask: readonly string[];
+    readonly deny: readonly string[];
+}
+export type ManagedApprovalMode = 'default' | 'auto-edit' | 'auto' | 'yolo';
 export type ManagedInputBlock = components['schemas']['InputBlock'];
 export type ManagedSessionSkills = components['schemas']['WebShellSessionSkills'];
 export type ManagedSessionMcp = components['schemas']['PublicMcpCatalog'];
 export declare function isManagedApprovalMode(value: unknown): value is ManagedApprovalMode;
+export declare function isManagedInitialApprovalMode(value: unknown): value is Exclude<ManagedApprovalMode, 'auto'>;
+export declare function managedPermissionRulesEqual(left: ManagedPermissionRules | undefined, right: ManagedPermissionRules | undefined): boolean;
 export type ManagedSessionSkill = components['schemas']['SessionCreationSkill'];
+export type ManagedSessionRecovery = components['schemas']['SessionRecovery'];
+export type ManagedTurnCancelOperation = components['schemas']['WebShellCommandOperation'];
+export interface ManagedModelPreset {
+    agentId: string;
+    label: string;
+    modelId?: string;
+}
 export interface ManagedSessionOptions {
     approvalMode: ManagedApprovalMode;
     availableApprovalModes: ManagedApprovalMode[];
     planModeSupported?: boolean;
     inputAttachments?: boolean;
     skillsSupported?: boolean;
+    modelSelectionSupported?: boolean;
 }
 export interface ManagedSessionApproval extends ManagedSessionOptions {
     approvalRevision: number;
     supported: boolean;
     planMode?: boolean;
     liveSupported?: boolean;
+    permissionRulesSupported?: boolean;
+    permissionRules?: ManagedPermissionRules;
 }
 export interface ManagedApprovalChangeResult {
     sessionId: string;
@@ -27,6 +47,7 @@ export interface ManagedApprovalChangeResult {
     approvalRevision: number;
     replayed: boolean;
     planMode?: boolean;
+    permissionRules?: ManagedPermissionRules;
 }
 export interface ManagedModelContext {
     modelId: string;
@@ -51,6 +72,11 @@ export interface ManagedModelChangeResult {
     modelSelection: ManagedModelSelection;
     replayed: boolean;
 }
+export type ManagedLifecycleKind = 'close' | 'archive' | 'delete';
+export type ManagedLifecycleAction = ManagedLifecycleKind | 'unarchive' | 'close_archive';
+export type ManagedLifecycleOperation = components['schemas']['WebShellCommandOperation'];
+export type ManagedExportPage = components['schemas']['WebShellExportPage'];
+export type ManagedExportItem = components['schemas']['WebShellItem'];
 export interface ManagedAgentSessionSummary {
     sessionId: string;
     agentId?: string;
@@ -61,9 +87,13 @@ export interface ManagedAgentSessionSummary {
     planModeSupported?: boolean;
     modelContext?: ManagedModelContext;
     modelSelection?: ManagedModelSelection;
+    compactionRevision?: number;
+    contextCompressionOperationId?: string;
+    lifecycleStatus?: string;
+    lastSequence?: number;
+    lifecycleOperation?: components['schemas']['WebShellLifecycleOperation'];
     activeTurnId?: string;
     title: string;
-    workspaceCwd?: string;
     workspace?: {
         workspaceId: string;
         cwdRelative: string;
@@ -80,13 +110,19 @@ export interface ManagedAgentSessionSummary {
         canSend: boolean;
         canCancel: boolean;
         canRename?: boolean;
+        sessionClose?: boolean;
+        sessionArchive?: boolean;
+        sessionUnarchive?: boolean;
+        sessionDelete?: boolean;
         actions?: boolean;
+        childAgents?: boolean;
         tasks?: boolean;
         artifacts?: boolean;
         /** The caller may submit later Turns to this Workspace-bound Session. */
         workspaceTurns?: boolean;
         cwdChange?: boolean;
         modelChange?: boolean;
+        contextCompression?: boolean;
         approvalModeChange?: boolean;
         inputAttachments?: boolean;
     };
@@ -94,6 +130,7 @@ export interface ManagedAgentSessionSummary {
         code: string;
         message: string;
     };
+    recovery?: ManagedSessionRecovery;
 }
 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 {
@@ -127,6 +164,7 @@ export interface ManagedAgentCommandOptions extends ManagedAgentRequestOptions {
     idempotencyKey: string;
 }
 export type ManagedCwdOperation = components['schemas']['WebShellCwdOperation'];
+export type ManagedContextCompressionOperation = components['schemas']['WebShellContextCompressionOperation'];
 export type ManagedTask = components['schemas']['WebShellTask'];
 export type ManagedTaskPage = components['schemas']['WebShellTaskPage'];
 export type ManagedTaskEvent = components['schemas']['WebShellTaskEvent'];
@@ -161,19 +199,62 @@ export interface ManagedAgentPendingAction {
     inputPreview?: components['schemas']['WebShellActionInputPreview'];
 }
 export interface ManagedAgentProvider {
-    readonly kind: 'daemon' | 'java';
+    readonly userMessages?: {
+        query(sessionId: string, options: ManagedAgentRequestOptions): Promise<import('./use-managed-user-messages').ManagedUserMessageSnapshot>;
+        command(sessionId: string, command: import('./use-managed-user-messages').ManagedUserMessageCommand, options: {
+            idempotencyKey: string;
+            signal?: AbortSignal;
+        }): Promise<import('./use-managed-user-messages').ManagedUserMessageSnapshot>;
+    };
+    readonly lifecycle?: {
+        submit(kind: ManagedLifecycleKind, sessionId: string, options: ManagedAgentCommandOptions): Promise<ManagedLifecycleOperation>;
+        unarchive(sessionId: string, options: ManagedAgentCommandOptions): Promise<ManagedAgentSessionSummary>;
+        query(sessionId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedLifecycleOperation>;
+    };
+    exportSnapshot?(sessionId: string, options: ManagedAgentRequestOptions & {
+        cursor?: string;
+    }): Promise<ManagedExportPage>;
     readonly storageKey: string;
     readonly canCancel: boolean;
-    readonly acceptsWorkspaceCwd: boolean;
+    /** Present when the provider can filter the complete Session history by title. */
+    readonly titleSearch?: boolean;
+    readonly recovery?: {
+        query(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionRecovery>;
+        recheck(sessionId: string, turnId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionRecovery>;
+    };
+    queryCancelOperation(sessionId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedTurnCancelOperation>;
     readonly skills?: {
         list(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionSkills>;
     };
     readonly mcp?: {
         list(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionMcp>;
     };
+    readonly extensions?: {
+        readonly storageScope?: string;
+        list(workspaceId: string, options: ManagedAgentRequestOptions): Promise<ManagedExtensionCatalog>;
+        publish(workspaceId: string, extensionId: string | undefined, packageDigest: string, manifest: ManagedExtensionManifest, archive: Blob, options: ManagedAgentCommandOptions): Promise<ManagedExtensionPackageOperation>;
+        settings(workspaceId: string, extensionId: string, options: ManagedAgentRequestOptions): Promise<ManagedExtensionSettings>;
+        saveSettings(workspaceId: string, extensionId: string, expectedRevision: number, values: Record<string, string>, options: ManagedAgentCommandOptions): Promise<ManagedExtensionPackageOperation>;
+        query(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedExtensionSnapshot>;
+        apply(sessionId: string, selection: ManagedExtensionSelection, options: ManagedAgentCommandOptions): Promise<ManagedExtensionSnapshot>;
+        operation(sessionId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedExtensionSnapshot>;
+        resume(sessionId: string, operationId: string, recoverPrevious: boolean, options: ManagedAgentRequestOptions): Promise<ManagedExtensionSnapshot>;
+        package(workspaceId: string, pin: ManagedExtensionPin, options: ManagedAgentRequestOptions): Promise<ManagedExtensionCatalog['extensions'][number]>;
+    };
+    readonly mcpManagement?: {
+        /** Explicit tenant/actor namespace for pending commands saved in this tab. */
+        readonly storageScope?: string;
+        query(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedMcpManagementSnapshot>;
+        submit(sessionId: string, command: ManagedMcpManagementCommand, options: ManagedAgentCommandOptions & {
+            requestId: string;
+        }): Promise<ManagedMcpManagementSnapshot>;
+        operation(sessionId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedMcpManagementSnapshot>;
+    };
     /** Present when the provider can serve Hosted permission Actions. */
     readonly actions?: {
-        listPending(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedAgentPendingAction[]>;
+        listPending(sessionId: string, options: ManagedAgentRequestOptions & {
+            includeChildren?: boolean;
+        }): Promise<ManagedAgentPendingAction[]>;
         respond(action: ManagedAgentPendingAction, optionId: string, options: ManagedAgentCommandOptions): Promise<void>;
     };
     readonly toolResults?: ManagedToolResultReader;
@@ -202,12 +283,19 @@ export interface ManagedAgentProvider {
         }, options: ManagedAgentCommandOptions): Promise<ManagedCwdOperation>;
         query(sessionId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedCwdOperation>;
     };
+    readonly contextCompression?: {
+        submit(sessionId: string, request: {
+            expectedCompactionRevision: number;
+        }, options: ManagedAgentCommandOptions): Promise<ManagedContextCompressionOperation>;
+        query(sessionId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedContextCompressionOperation>;
+    };
     readonly approvalChange?: {
         queryOptions(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionApproval>;
         submit(sessionId: string, request: {
             approvalMode: ManagedApprovalMode;
             expectedRevision: number;
             planMode?: boolean;
+            permissionRules?: ManagedPermissionRules;
         }, options: ManagedAgentCommandOptions & {
             requestId: string;
         }): Promise<ManagedApprovalChangeResult>;
@@ -226,11 +314,8 @@ 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;
-            label: string;
-        }[];
+        /** Host-published models and legacy AgentDefinition presets for new Sessions. */
+        readonly modelPresets?: readonly ManagedModelPreset[];
         list(options: ManagedAgentRequestOptions & {
             cursor?: string;
             limit?: number;
@@ -263,16 +348,19 @@ export interface ManagedAgentProvider {
         getSessionOptions?(agentId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionOptions>;
         createEmpty(request: {
             agentId: string;
+            modelId?: string;
             workspaceId: string;
             cwdRelative: string;
             approvalMode?: ManagedApprovalMode;
             planMode?: boolean;
             skills?: ManagedSessionSkill[];
+            extensionPins?: ManagedExtensionPin[];
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;
         createSession?(request: {
             agentId: string;
+            modelId?: string;
             workspaceId: string;
             cwdRelative: string;
             text: string;
@@ -280,12 +368,14 @@ export interface ManagedAgentProvider {
             approvalMode?: ManagedApprovalMode;
             planMode?: boolean;
             skills?: ManagedSessionSkill[];
+            extensionPins?: ManagedExtensionPin[];
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;
     };
     listSessions(options: ManagedAgentRequestOptions & {
-        workspaceCwd?: string;
+        archiveState?: 'unarchived' | 'archived' | 'all';
+        titleQuery?: string;
         limit?: number;
         cursor?: string;
     }): Promise<{
@@ -302,14 +392,19 @@ export interface ManagedAgentProvider {
     }): Promise<ManagedAgentSessionTranscript>;
     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>;
+    }, options: ManagedAgentCommandOptions): Promise<ManagedAgentTurnAdmission & {
+        operationId: string;
+    }>;
+    cancel(sessionId: string, turnId: string, options: ManagedAgentCommandOptions): Promise<{
+        sessionId: string;
+        turnId: string;
+        operationId: string;
+    }>;
     subscribeEvents(sessionId: string, options: ManagedAgentRequestOptions & {
         lastEventId?: number;
         /**

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

@@ -0,0 +1,36 @@
+export declare const MANAGED_EXTENSION_MESSAGES_EN: {
+    readonly 'managed.extensions.title': "Managed extensions";
+    readonly 'managed.extensions.description': "Publish a fixed package, select versions, then apply to an idle session.";
+    readonly 'managed.extensions.selectSession': "Select a workspace and session to manage extensions.";
+    readonly 'managed.extensions.unsupported': "Package extensions are unavailable for this target.";
+    readonly 'managed.extensions.source': "Original Git, npm, directory or archive source";
+    readonly 'managed.extensions.ref': "Source revision (optional)";
+    readonly 'managed.extensions.target': "Target platform";
+    readonly 'managed.extensions.publish': "Publish package";
+    readonly 'managed.extensions.new': "New extension";
+    readonly 'managed.extensions.update': "Update selected extension";
+    readonly 'managed.extensions.apply': "Apply selection";
+    readonly 'managed.extensions.retry': "Retry original request";
+    readonly 'managed.extensions.continue': "Continue original operation";
+    readonly 'managed.extensions.recover': "Restore previous version";
+    readonly 'managed.extensions.settings': "Settings";
+    readonly 'managed.extensions.settingsDescription': "Enter the complete set of environment settings. Saved values are never displayed.";
+    readonly 'managed.extensions.addSetting': "Add setting";
+    readonly 'managed.extensions.key': "Environment variable";
+    readonly 'managed.extensions.value': "Value";
+    readonly 'managed.extensions.saveSettings': "Save settings revision";
+    readonly 'managed.extensions.useSettings': "Use saved settings revision";
+    readonly 'managed.extensions.settingsRevision': "Settings revision (optional)";
+    readonly 'managed.extensions.installed': "Installed";
+    readonly 'managed.extensions.pending': "Pending apply";
+    readonly 'managed.extensions.active': "Active";
+    readonly 'managed.extensions.preparing': "Preparing";
+    readonly 'managed.extensions.prepared': "Ready to apply";
+    readonly 'managed.extensions.committed': "Applying";
+    readonly 'managed.extensions.recovery_required': "Recovery blocked";
+    readonly 'managed.extensions.failed': "Failed";
+    readonly 'managed.extensions.empty': "No packages published in this workspace.";
+    readonly 'managed.extensions.failedRequest': "The request could not be confirmed. Refresh status or retry the original request.";
+    readonly 'managed.extensions.localPublisher': "A connected daemon is required to prepare an original source.";
+};
+export declare const MANAGED_EXTENSION_MESSAGES_ZH: Record<keyof typeof MANAGED_EXTENSION_MESSAGES_EN, string>;

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

@@ -0,0 +1,10 @@
+import type { components } from './generated/managed-agent-api';
+export type ManagedExtensionPin = components['schemas']['ManagedExtensionPackagePin'];
+export type ManagedExtensionManifest = components['schemas']['ManagedExtensionPackageManifest'];
+export type ManagedExtensionCatalog = components['schemas']['ManagedExtensionPackageCatalog'];
+export type ManagedExtensionPackageOperation = components['schemas']['ManagedExtensionPackageOperation'];
+export type ManagedExtensionSettings = components['schemas']['ManagedExtensionPackageSettings'];
+export type ManagedExtensionSnapshot = components['schemas']['ManagedExtensionManagementSnapshot'];
+export type ManagedExtensionSelection = components['schemas']['ManagedExtensionApplySelection'];
+export declare function isManagedExtensionPins(value: unknown): value is ManagedExtensionPin[];
+export declare function requireExtensionSnapshot(value: ManagedExtensionSnapshot, sessionId: string): ManagedExtensionSnapshot;

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

@@ -0,0 +1,80 @@
+export declare const MANAGED_LIFECYCLE_MESSAGES_EN: {
+    'managed.sessionActions': string;
+    'managed.historyFilter': string;
+    'managed.history.unarchived': string;
+    'managed.history.archived': string;
+    'managed.exportHtml': string;
+    'managed.exportMarkdown': string;
+    'managed.exportHtmlDescription': string;
+    'managed.exportMarkdownDescription': string;
+    'managed.exportFailed': string;
+    'managed.exporting': string;
+    'managed.exportNotReady': string;
+    'managed.exportTooLarge': string;
+    'managed.exportChanged': string;
+    'managed.sessionState.active': string;
+    'managed.sessionState.closing': string;
+    'managed.sessionState.closed': string;
+    'managed.sessionState.archived': string;
+    'managed.sessionState.deleting': string;
+    'managed.sessionState.deleted': string;
+    'managed.lifecycle.close': string;
+    'managed.lifecycle.close_archive': string;
+    'managed.lifecycle.archive': string;
+    'managed.lifecycle.unarchive': string;
+    'managed.lifecycle.delete': string;
+    'managed.lifecycle.submitting': string;
+    'managed.lifecycle.pending': string;
+    'managed.lifecycle.running': string;
+    'managed.lifecycle.recovery_blocked': string;
+    'managed.lifecycle.failed': string;
+    'managed.lifecycle.unconfirmed': string;
+    'managed.lifecycle.retry': string;
+    'managed.lifecycle.confirm': string;
+    'managed.lifecycle.deleteDescription': string;
+    'managed.lifecycle.closeDescription': string;
+    'managed.lifecycle.archiveIncomplete': string;
+    'managed.lifecycle.openTask': string;
+    'managed.lifecycle.stopFirst': string;
+    'managed.lifecycle.storageUnavailable': string;
+};
+export declare const MANAGED_LIFECYCLE_MESSAGES_ZH: {
+    'managed.sessionActions': string;
+    'managed.historyFilter': string;
+    'managed.history.unarchived': string;
+    'managed.history.archived': string;
+    'managed.exportHtml': string;
+    'managed.exportMarkdown': string;
+    'managed.exportHtmlDescription': string;
+    'managed.exportMarkdownDescription': string;
+    'managed.exportFailed': string;
+    'managed.exporting': string;
+    'managed.exportNotReady': string;
+    'managed.exportTooLarge': string;
+    'managed.exportChanged': string;
+    'managed.sessionState.active': string;
+    'managed.sessionState.closing': string;
+    'managed.sessionState.closed': string;
+    'managed.sessionState.archived': string;
+    'managed.sessionState.deleting': string;
+    'managed.sessionState.deleted': string;
+    'managed.lifecycle.close': string;
+    'managed.lifecycle.close_archive': string;
+    'managed.lifecycle.archive': string;
+    'managed.lifecycle.unarchive': string;
+    'managed.lifecycle.delete': string;
+    'managed.lifecycle.submitting': string;
+    'managed.lifecycle.pending': string;
+    'managed.lifecycle.running': string;
+    'managed.lifecycle.recovery_blocked': string;
+    'managed.lifecycle.failed': string;
+    'managed.lifecycle.unconfirmed': string;
+    'managed.lifecycle.retry': string;
+    'managed.lifecycle.confirm': string;
+    'managed.lifecycle.deleteDescription': string;
+    'managed.lifecycle.closeDescription': string;
+    'managed.lifecycle.archiveIncomplete': string;
+    'managed.lifecycle.openTask': string;
+    'managed.lifecycle.stopFirst': string;
+    'managed.lifecycle.storageUnavailable': string;
+};

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

@@ -0,0 +1,2 @@
+export declare const MANAGED_LIFECYCLE_MESSAGES_EN: {};
+export declare const MANAGED_LIFECYCLE_MESSAGES_ZH: {};

package/dist/types/components/managed/managed-mcp-command-storage.d.ts

@@ -0,0 +1,16 @@
+import type { ManagedMcpManagementCommand } from './managed-mcp-management-types';
+export interface ManagedMcpCommandAttempt {
+    command: ManagedMcpManagementCommand;
+    requestId: string;
+    idempotencyKey: string;
+    operationId?: string;
+}
+export type ManagedMcpCommandTarget = readonly [
+    providerKey: string,
+    actorScope: string,
+    clientId: string,
+    workspaceId: string,
+    sessionId: string
+];
+export declare function restoreManagedMcpCommand(target: ManagedMcpCommandTarget): ManagedMcpCommandAttempt | undefined;
+export declare function saveManagedMcpCommand(target: ManagedMcpCommandTarget, attempt: ManagedMcpCommandAttempt | undefined): void;

package/dist/types/components/managed/managed-mcp-management-types.d.ts

@@ -0,0 +1,8 @@
+import type { components } from './generated/managed-agent-api';
+type Schemas = components['schemas'];
+export type ManagedMcpServerPin = Schemas['ManagedMcpServerPin'];
+export type ManagedMcpManagementSnapshot = Schemas['ManagedMcpManagementSnapshot'];
+export type ManagedMcpManagementOperation = Schemas['ManagedMcpManagementOperation'];
+export type ManagedMcpManagementAction = ManagedMcpManagementOperation['action'];
+export type ManagedMcpManagementCommand = Omit<Schemas['WebShellMcpManagementSubmit'], 'sessionId' | 'requestId' | 'idempotencyKey'>;
+export {};