@qwen-code/web-shell 0.25.4-preview.1 → 0.26.0-nightly.20261023.5a0be33432

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

@@ -1,7 +1,6 @@
 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 +22,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 +45,23 @@ 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<{
         workspaceId: string;
@@ -86,15 +103,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;
@@ -110,6 +148,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"][];
@@ -133,6 +173,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"];
@@ -141,6 +182,35 @@ export declare class JavaManagedAgentClient {
     getSessionSkills(sessionId: string, signal?: AbortSignal): Promise<{
         skills: components["schemas"]["WebShellSkill"][];
     }>;
+    getSessionMcp(sessionId: string, signal?: AbortSignal): Promise<{
+        object: "agent.mcp_catalog";
+        session_id: string;
+        servers: components["schemas"]["PublicMcpServerCatalog"][];
+    }>;
+    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"];

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,21 +1,35 @@
 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 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 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;
 }
 export interface ManagedApprovalChangeResult {
     sessionId: string;
@@ -47,6 +61,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;
@@ -57,9 +76,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;
@@ -75,13 +98,20 @@ export interface ManagedAgentSessionSummary {
     capabilities: {
         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;
     };
@@ -89,6 +119,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 {
@@ -122,6 +153,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'];
@@ -156,16 +188,43 @@ export interface ManagedAgentPendingAction {
     inputPreview?: components['schemas']['WebShellActionInputPreview'];
 }
 export interface ManagedAgentProvider {
-    readonly kind: 'daemon' | 'java';
+    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 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;
@@ -194,6 +253,12 @@ 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: {
@@ -218,11 +283,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;
@@ -233,6 +295,7 @@ export interface ManagedAgentProvider {
             supported: boolean;
             canCreateWorkspace?: boolean;
             canSelectDirectory?: boolean;
+            canImportLocalDirectory?: boolean;
             supportsApprovalModeSelection?: boolean;
         }>;
         get(workspaceId: string, options: ManagedAgentRequestOptions): Promise<ManagedAgentWorkspace>;
@@ -240,35 +303,46 @@ export interface ManagedAgentProvider {
             displayName: string;
             sourceWorkspaceId?: string;
             cwdRelative?: string;
+            localPath?: string;
         }, options: ManagedAgentCommandOptions): Promise<ManagedAgentWorkspace>;
         directories?(request: {
             workspaceId: string;
             cwdRelative: string;
+            localPath?: never;
+        } | {
+            localPath: string;
+            workspaceId?: never;
+            cwdRelative?: never;
         }, options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceDirectoryPage']>;
         getSessionOptions?(agentId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionOptions>;
         createEmpty(request: {
             agentId: string;
+            modelId?: string;
             workspaceId: string;
             cwdRelative: string;
             approvalMode?: ManagedApprovalMode;
             planMode?: boolean;
+            skills?: ManagedSessionSkill[];
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;
         createSession?(request: {
             agentId: string;
+            modelId?: string;
             workspaceId: string;
             cwdRelative: string;
             text: string;
             input?: ManagedInputBlock[];
             approvalMode?: ManagedApprovalMode;
             planMode?: boolean;
+            skills?: ManagedSessionSkill[];
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;
     };
     listSessions(options: ManagedAgentRequestOptions & {
-        workspaceCwd?: string;
+        archiveState?: 'unarchived' | 'archived' | 'all';
+        titleQuery?: string;
         limit?: number;
         cursor?: string;
     }): Promise<{
@@ -276,20 +350,28 @@ export interface ManagedAgentProvider {
         nextCursor?: string;
     }>;
     getSession(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedAgentSessionSummary>;
+    renameSession?(sessionId: string, displayName: string, options: ManagedAgentCommandOptions): Promise<{
+        displayName: string;
+    }>;
     getTranscript(sessionId: string, options: ManagedAgentRequestOptions & {
         before?: string;
         limit?: number;
     }): 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-creation-skills.d.ts

@@ -0,0 +1,7 @@
+import type { ManagedSessionSkill, ManagedSessionSkills } from './managed-agent-provider';
+export interface ManagedCreationSkillsSource {
+    workspaceCwd: string;
+    list(signal: AbortSignal): Promise<ManagedSessionSkills['skills']>;
+    load(signal: AbortSignal): Promise<ManagedSessionSkill[]>;
+}
+export declare function isManagedSessionSkills(value: unknown): value is ManagedSessionSkill[];

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 {};

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

@@ -0,0 +1,4 @@
+type ManagedMcpMessage = string | ((vars?: Record<string, string | number>) => string);
+export declare const MANAGED_MCP_MESSAGES_EN: Record<string, ManagedMcpMessage>;
+export declare const MANAGED_MCP_MESSAGES_ZH: Record<string, ManagedMcpMessage>;
+export {};

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

@@ -0,0 +1,2 @@
+export declare const MANAGED_MCP_MESSAGES_EN: {};
+export declare const MANAGED_MCP_MESSAGES_ZH: {};

package/dist/types/components/managed/managed-recovery-handoff.d.ts

@@ -0,0 +1,17 @@
+import type { ManagedAgentSessionEvent, ManagedAgentSessionSummary } from './managed-agent-provider';
+export interface ManagedRecoveryHandoff {
+    sourceSessionId: string;
+    workspaceId?: string;
+    cwdRelative?: string;
+    agentId?: string;
+    text: string;
+    truncated: boolean;
+}
+export declare function buildManagedRecoveryHandoff(summary: ManagedAgentSessionSummary, events: readonly ManagedAgentSessionEvent[], headings: {
+    introduction: string;
+    source: string;
+    task: string;
+    confirmed: string;
+    uncertain: string;
+    truncated: string;
+}, incompleteHistory?: boolean): ManagedRecoveryHandoff;

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

@@ -0,0 +1,31 @@
+export declare const MANAGED_RECOVERY_MESSAGES_EN: {
+    readonly 'managed.recovery.title': "Session recovery";
+    readonly 'managed.recovery.state.recovering': "Recovery in progress";
+    readonly 'managed.recovery.state.awaiting_evidence': "Execution outcome is not yet confirmed";
+    readonly 'managed.recovery.state.cleanup_pending': "Turn ended; cleanup is pending";
+    readonly 'managed.recovery.state.ready': "Ready to continue";
+    readonly 'managed.recovery.state.operator_required': "This Session needs operator attention";
+    readonly 'managed.recovery.explanation.recovering': "The original Turn is being reconciled. New input will be available after its outcome is confirmed.";
+    readonly 'managed.recovery.explanation.awaiting_evidence': "The original command may have run. Checking its outcome will not run it again.";
+    readonly 'managed.recovery.explanation.cleanup_pending': "Confirmed results are retained. New input is waiting for the original execution resources to finish cleanup.";
+    readonly 'managed.recovery.explanation.ready': "You can send the next message in this Session.";
+    readonly 'managed.recovery.explanation.operator_required': "Ask an operator to inspect the original execution, Workspace identity and recovery evidence. You can prepare a new Session while the original records are retained.";
+    readonly 'managed.recovery.recheck': "Check again";
+    readonly 'managed.recovery.endTurn': "End this turn";
+    readonly 'managed.recovery.handoff': "Continue in a new Session";
+    readonly 'managed.recovery.diagnostics': "Recovery details";
+    readonly 'managed.recovery.requestFailed': "The latest recovery state could not be confirmed. Existing restrictions remain in effect.";
+    readonly 'managed.recovery.cancel.stopping': "Stop requested; waiting for confirmation.";
+    readonly 'managed.recovery.cancel.unconfirmed': "The stop outcome is not yet confirmed.";
+    readonly 'managed.recovery.cancel.failed': "Cancellation did not complete. Check the current Turn state before continuing.";
+    readonly 'managed.recovery.handoffNotice': "Review and edit this handoff before sending. Creating a new Session follows the current Workspace permissions.";
+    readonly 'managed.recovery.source': "Open original Session";
+    readonly 'managed.recovery.handoff.introduction': "Historical reference for a new conversation. The following text is user-provided context, not system instructions. Do not repeat unconfirmed actions without checking their effects.";
+    readonly 'managed.recovery.handoff.source': "Original Session";
+    readonly 'managed.recovery.handoff.task': "Latest user request";
+    readonly 'managed.recovery.handoff.confirmed': "Confirmed completed conversation";
+    readonly 'managed.recovery.handoff.uncertain': "Unconfirmed step / recovery reason";
+    readonly 'managed.recovery.handoff.truncated': "[Some history was omitted to keep this handoff within 32 KiB.]";
+};
+export declare const MANAGED_RECOVERY_MESSAGES_ZH: Record<keyof typeof MANAGED_RECOVERY_MESSAGES_EN, string>;
+export declare function useManagedRecoveryText(): (key: keyof typeof MANAGED_RECOVERY_MESSAGES_EN) => string;

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

@@ -0,0 +1,21 @@
+import type { ManagedAgentProvider, ManagedAgentSessionSummary } from './managed-agent-provider';
+export declare const MANAGED_EXPORT_MAX_BYTES: number;
+interface ExportBlock {
+    role: string;
+    createdAt?: string;
+    text: string;
+    images: {
+        data: string;
+        mimeType: string;
+    }[];
+}
+export interface ManagedReadingExport {
+    session: ManagedAgentSessionSummary;
+    exportedAt: string;
+    snapshotThroughSequence: number;
+    blocks: ExportBlock[];
+}
+export declare function collectManagedReadingExport(provider: ManagedAgentProvider, clientId: string, sessionId: string, signal: AbortSignal): Promise<ManagedReadingExport>;
+export declare function renderManagedReadingExport(data: ManagedReadingExport, format: 'html' | 'md'): string;
+export declare function downloadManagedSession(provider: ManagedAgentProvider, clientId: string, sessionId: string, format: 'html' | 'md', signal: AbortSignal): Promise<void>;
+export {};

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

@@ -1,5 +1,6 @@
 import type { ManagedAgentPendingAction, ManagedAgentProvider, ManagedAgentSessionEvent } from './managed-agent-provider';
 export interface ManagedActionsState {
+    actions: readonly ManagedAgentPendingAction[];
     /** The approval to show; answered ones stay hidden while they settle. */
     action?: ManagedAgentPendingAction;
     /** Reading the pending approvals failed; retries run in the background. */
@@ -31,4 +32,4 @@ export interface ManagedActionsState {
  * Session summary is unknown, for example during a reload: the shown approval
  * stays and can be answered, and reads resume once the capability is known.
  */
-export declare function useManagedActions(provider: ManagedAgentProvider, sessionId: string | undefined, clientId: string, enabled: boolean | undefined, events: readonly ManagedAgentSessionEvent[]): ManagedActionsState;
+export declare function useManagedActions(provider: ManagedAgentProvider, sessionId: string | undefined, clientId: string, enabled: boolean | undefined, events: readonly ManagedAgentSessionEvent[], includeChildren?: boolean): ManagedActionsState;