@qwen-code/web-shell 0.26.3 → 0.26.4-nightly.20261029.70be140e14

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

@@ -57,7 +57,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** @description Without a cursor, a Session that has a Snapshot returns all of its Items, the events up to the Snapshot other than turn.accepted, item.output_text.delta, item.reasoning.delta, item.tool_call.updated and item.tool_result.updated, which the Items already hold, and every event after it. Otherwise, and for an olderCursor, limit bounds the page of events. */
+        /** @description Default view: Without a cursor, a Session that has a Snapshot returns all of its Items, the events up to the Snapshot other than turn.accepted, item.output_text.delta, item.reasoning.delta, item.tool_call.updated and item.tool_result.updated, which the Items already hold, and every event after it. Otherwise, and for an olderCursor, limit bounds the page of events. Explicit view=messages instead returns at most100 current ma_message Items using tenant/Session keyset pagination, independent of published snapshots. Bodies are live per page. coveredSequence and lastSequence are the projection sequence included by this read, so the client resumes SSE there and does not skip an unprojected tail. Only bounded lifecycle events for the selected Turns accompany the Items. An older cursor pins direction, scope, sequence membership and projection generation;409 message_projection_changed requires reloading history. */
         post: operations["webShellTranscript"];
         delete?: never;
         options?: never;
@@ -804,7 +804,7 @@ export interface paths {
         put?: never;
         /**
          * Read one immutable public Session snapshot page for reading exports
-         * @description Requires current Session read authorization on every page. Reuses the public item snapshot cursor, whose subsequent pages retain the original snapshot version and watermark. No private journal, Runtime or storage credentials are returned. The client waits for a snapshot covering its captured Session watermark before using its first page.
+         * @description Default view: Requires current Session read authorization on every page. Reuses the public item snapshot cursor, whose subsequent pages retain the original snapshot version and watermark. No private journal, Runtime or storage credentials are returned. The client waits for a snapshot covering its captured Session watermark before using its first page. Explicit view=messages instead reads live message-table pages forward. The first read captures a finite membership bound; later body/status changes are allowed and no persistent snapshot is created or selected. snapshotThroughSequence then names that membership bound, not frozen content. If the initial message projection lags committed events,503 message_projection_pending asks the caller to retry instead of returning incomplete history. Projection-generation changes invalidate the cursor.
          */
         post: operations["webShellExportSession"];
         delete?: never;
@@ -1057,6 +1057,94 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/agent/web-shell/v1/workspaces/worktrees/options": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Options a main Session worktree */
+        post: operations["webShellSessionWorktreeOptions"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspaces/worktrees/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Query a main Session worktree */
+        post: operations["webShellSessionWorktreeQuery"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspaces/worktrees/inspect": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Inspect a main Session worktree */
+        post: operations["webShellSessionWorktreeInspect"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspaces/worktrees/cleanup": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Cleanup a main Session worktree */
+        post: operations["webShellSessionWorktreeCleanup"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/transcript/items/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Read recent published Session items and page toward older items
+         * @description Default view: Requires current Session read authorization on every page. The first page returns at most limit Items from the newest published snapshot, in chronological order. nextCursor pages toward older Items in that same signed, retained snapshot. snapshotThroughSequence identifies its coverage, which may lag the current Session head; an empty page with zero coverage does not certify an empty Session because no published snapshot may be available. This page does not contain live tail events or current approval/task state; use the existing transcript, event and state APIs for those. A newer snapshot does not change an existing cursor. Forward export cursors cannot be used here and backward cursors cannot be used for exports. No journal replay, writer acquisition or local cache is involved. Explicit view=messages instead reads current message-table Items backward without any published snapshot, using the same scoped keyset and projection-generation rules as messages-view transcript reads. snapshotThroughSequence then names the initial sequence membership bound; bodies can change between pages. This mode does not return lifecycle events or claim fixed snapshot content.
+         */
+        post: operations["webShellRecentTranscriptItems"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -1154,6 +1242,11 @@ export interface components {
             cursor?: string | null;
             /** @default 100 */
             limit?: number | null;
+            /**
+             * @description Select direct live message-table pages. Omit to retain the existing snapshot/event view. Message view accepts limit1..100; cursors bind scope, direction, membership range and projection generation, not frozen bodies.
+             * @enum {string|null}
+             */
+            view?: "messages" | null;
         };
         WebShellStreamRequest: {
             /** Format: uuid */
@@ -1188,6 +1281,10 @@ export interface components {
             skills?: components["schemas"]["SessionCreationSkill"][];
             /** @description Optional immutable initial extension selection. Omission keeps the legacy configuration path; an explicit empty array starts the unified configuration format. Included in creation idempotency and applied before the first model request. Requires session-extension-packages/1 and an extension-capable original Runtime. */
             extensionPins?: components["schemas"]["ManagedExtensionPackagePin"][];
+            /** @description Opt into a main Session worktree on supported LOCAL storage. Omission uses the current directory; an empty object freezes HEAD at first admission. Requires an explicit Workspace. Preparation is durable and gates Runtime execution; replay preserves the original commit, directory and branch. */
+            worktree?: {
+                baseRef?: string;
+            };
         };
         WebShellSubmitRequest: {
             /** @description Trace correlation only. */
@@ -1290,6 +1387,7 @@ export interface components {
             /** @description Current unsettled lifecycle operation, queried in batch under Session read authorization. A failed close/delete may leave the Session closing/deleting; only explicit retry starts a new operation. Settled Sessions omit this projection. */
             lifecycleOperation?: components["schemas"]["WebShellLifecycleOperation"];
             recovery?: components["schemas"]["SessionRecovery"];
+            worktree?: components["schemas"]["WebShellSessionWorktree"] | null;
         };
         WebShellSessionCapabilities: {
             /**
@@ -2096,18 +2194,22 @@ export interface components {
             skills: components["schemas"]["WebShellSkill"][];
         };
         WebShellWorkspaceFileQueryRequest: {
-            workspaceId: string;
-            cwdRelative: string;
+            workspaceId?: string;
+            cwdRelative?: string;
             directory: string;
             query?: string;
             expectedScopeRevision?: string;
-        };
+            /** Format: uuid */
+            sessionId?: string;
+        } & (unknown | unknown);
         WebShellWorkspaceFileReadRequest: {
-            workspaceId: string;
-            cwdRelative: string;
+            workspaceId?: string;
+            cwdRelative?: string;
             path: string;
             expectedScopeRevision: string;
-        };
+            /** Format: uuid */
+            sessionId?: string;
+        } & (unknown | unknown);
         WebShellWorkspaceFileEntry: {
             path: string;
             name: string;
@@ -2308,7 +2410,10 @@ export interface components {
             items: components["schemas"]["WebShellItem"][];
             nextCursor?: string | null;
             hasMore: boolean;
-            /** Format: int64 */
+            /**
+             * Format: int64
+             * @description In explicit messages view, this is the fixed sequence membership upper bound; row bodies are live, not frozen snapshot content.
+             */
             snapshotThroughSequence: number;
         };
         WebShellExportRequest: {
@@ -2317,6 +2422,11 @@ export interface components {
             cursor?: string | null;
             /** @default 100 */
             limit?: number | null;
+            /**
+             * @description Select direct live message-table pages. Omit to retain the existing snapshot/event view. Message view accepts limit1..100; cursors bind scope, direction, membership range and projection generation, not frozen bodies.
+             * @enum {string|null}
+             */
+            view?: "messages" | null;
         };
         /** @description Durable Turn input or cancellation admission. The operation identifies the saved command and remains stable across idempotent retries. */
         WebShellTurnAdmission: {
@@ -2522,6 +2632,52 @@ export interface components {
             /** Format: uuid */
             uploadId: string;
         };
+        WebShellSessionWorktree: {
+            id: string;
+            sessionId: string;
+            workspaceId: string;
+            branch: string;
+            baseCommit: string;
+            cwdRelative: string;
+            operationId: string;
+            /** @enum {string} */
+            state: "preparing" | "ready" | "failed" | "blocked" | "removing" | "removed";
+            revision: number;
+            errorCode?: string | null;
+        };
+        WebShellSessionWorktreeOptions: {
+            supported: boolean;
+            reason?: string | null;
+            baseCommit?: string | null;
+            /** @description Source checkout branch independent of base ref; HEAD when detached, null when unavailable. */
+            currentBranch?: string | null;
+            branches: string[];
+        };
+        WebShellSessionWorktreePage: {
+            data: components["schemas"]["WebShellSessionWorktree"][];
+        };
+        WebShellSessionWorktreeInspection: {
+            worktree: components["schemas"]["WebShellSessionWorktree"];
+            canCleanup: boolean;
+            cleanupBlocker?: string | null;
+        };
+        WebShellSessionWorktreeOptionsRequest: {
+            workspaceId: string;
+            cwdRelative: string;
+            baseRef?: string;
+        };
+        WebShellSessionWorktreeQueryRequest: {
+            workspaceId: string;
+        };
+        WebShellSessionWorktreeInspectRequest: {
+            workspaceId: string;
+            worktreeId: string;
+        };
+        WebShellSessionWorktreeCleanupRequest: {
+            workspaceId: string;
+            worktreeId: string;
+            idempotencyKey: string;
+        };
     };
     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. */
@@ -2736,7 +2892,17 @@ export interface operations {
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
+            /** @description Message projection is not ready for a complete stream handoff; retry the read. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
         };
     };
     webShellStreamEvents: {
@@ -4218,7 +4384,7 @@ export interface operations {
             };
         };
         responses: {
-            /** @description Immutable public item snapshot page. */
+            /** @description Chronological Item page: published snapshot by default, or live messages when explicitly selected. */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -4233,6 +4399,15 @@ export interface operations {
             404: components["responses"]["NotFound"];
             409: components["responses"]["CursorExpired"];
             413: components["responses"]["PayloadTooLarge"];
+            /** @description Message projection has not caught up; retry the export. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
         };
     };
     webShellQueryUserMessages: {
@@ -4643,11 +4818,13 @@ export interface operations {
     webShellWorkspaceFilesUpload: {
         parameters: {
             query: {
-                workspaceId: string;
-                cwdRelative: string;
+                workspaceId?: string;
+                cwdRelative?: string;
                 path: string;
                 expectedScopeRevision: string;
                 uploadId: string;
+                /** @description Exactly one locator: Session ID, or Workspace ID plus cwdRelative. */
+                sessionId?: string;
             };
             header?: never;
             path?: never;
@@ -4724,4 +4901,159 @@ export interface operations {
             503: components["responses"]["Unavailable"];
         };
     };
+    webShellSessionWorktreeOptions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellSessionWorktreeOptionsRequest"];
+            };
+        };
+        responses: {
+            /** @description Session worktree result. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellSessionWorktreeOptions"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    webShellSessionWorktreeQuery: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellSessionWorktreeQueryRequest"];
+            };
+        };
+        responses: {
+            /** @description Session worktree result. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellSessionWorktreePage"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    webShellSessionWorktreeInspect: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellSessionWorktreeInspectRequest"];
+            };
+        };
+        responses: {
+            /** @description Session worktree result. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellSessionWorktreeInspection"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    webShellSessionWorktreeCleanup: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellSessionWorktreeCleanupRequest"];
+            };
+        };
+        responses: {
+            /** @description Session worktree result. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellSessionWorktree"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    webShellRecentTranscriptItems: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellExportRequest"];
+            };
+        };
+        responses: {
+            /** @description Bounded recent published Item page. Items are chronological within each page. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellExportPage"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["CursorExpired"];
+            413: components["responses"]["PayloadTooLarge"];
+            /** @description Message projection is not ready for a complete stream handoff; retry the read. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
+        };
+    };
 }

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

@@ -1,5 +1,6 @@
 import type { ManagedExtensionManifest, ManagedExtensionPin, ManagedExtensionPackageOperation, ManagedExtensionSelection } from './managed-extension-types';
 import type { components } from './generated/managed-agent-api';
+import type { ManagedWorkspaceFileQueryRequest, ManagedWorkspaceFileReadRequest, ManagedWorkspaceFileUploadRequest } from './managed-agent-provider';
 import type { ManagedArtifact } from './managed-tool-result-types';
 type Schemas = components['schemas'];
 export type JavaAgentTurn = Schemas['WebShellTurn'];
@@ -98,15 +99,9 @@ export declare class JavaManagedAgentClient {
         replayed: boolean;
     }>;
     createWorkspace(request: Schemas['WebShellWorkspaceCreateRequest'], signal?: AbortSignal): Promise<JavaAgentWorkspace>;
-    queryWorkspaceFiles(request: Schemas['WebShellWorkspaceFileQueryRequest'], signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFilePage']>;
-    readWorkspaceFile(request: Schemas['WebShellWorkspaceFileReadRequest'], signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFileSnapshot']>;
-    uploadWorkspaceFile(request: {
-        workspaceId: string;
-        cwdRelative: string;
-        path: string;
-        expectedScopeRevision: string;
-        uploadId: string;
-    }, data: Blob, signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFileUploadResult']>;
+    queryWorkspaceFiles(request: ManagedWorkspaceFileQueryRequest, signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFilePage']>;
+    readWorkspaceFile(request: ManagedWorkspaceFileReadRequest, signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFileSnapshot']>;
+    uploadWorkspaceFile(request: ManagedWorkspaceFileUploadRequest, data: Blob, signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFileUploadResult']>;
     queryWorkspaceFileUpload(uploadId: string, signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFileUploadStatus']>;
     workspaceDirectories(request: Schemas['WebShellWorkspaceDirectoryQueryRequest'], signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceDirectoryPage']>;
     getSessionApproval(sessionId: string, signal?: AbortSignal): Promise<Schemas['WebShellSessionApproval']>;
@@ -133,7 +128,12 @@ export declare class JavaManagedAgentClient {
         snapshotThroughSequence: number;
     }>;
     getTranscript(request: Schemas['WebShellTranscriptRequest'], signal?: AbortSignal): Promise<JavaAgentTranscript>;
+    getRecentTranscriptItems(request: Schemas['WebShellExportRequest'], signal?: AbortSignal): Promise<Schemas['WebShellExportPage']>;
     createSession(request: Schemas['WebShellCreateRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
+    worktreeOptions(request: Schemas['WebShellSessionWorktreeOptionsRequest'], signal?: AbortSignal): Promise<Schemas['WebShellSessionWorktreeOptions']>;
+    listSessionWorktrees(workspaceId: string, signal?: AbortSignal): Promise<Schemas['WebShellSessionWorktreePage']>;
+    inspectSessionWorktree(workspaceId: string, worktreeId: string, signal?: AbortSignal): Promise<Schemas['WebShellSessionWorktreeInspection']>;
+    cleanupSessionWorktree(request: Schemas['WebShellSessionWorktreeCleanupRequest'], signal?: AbortSignal): Promise<Schemas['WebShellSessionWorktree']>;
     submitTurn(request: Schemas['WebShellSubmitRequest'], signal?: AbortSignal): Promise<JavaAgentTurnAdmission>;
     cancelTurn(request: Schemas['WebShellCancelRequest'], signal?: AbortSignal): Promise<JavaAgentTurnAdmission>;
     queryActions(request: Schemas['WebShellActionQueryRequest'], signal?: AbortSignal): Promise<JavaAgentActionPage>;

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

@@ -14,6 +14,22 @@ 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 type ManagedWorkspaceFileLocator = {
+    sessionId: string;
+    workspaceId?: never;
+    cwdRelative?: never;
+} | {
+    sessionId?: never;
+    workspaceId: string;
+    cwdRelative: string;
+};
+export type ManagedWorkspaceFileQueryRequest = ManagedWorkspaceFileLocator & Omit<components['schemas']['WebShellWorkspaceFileQueryRequest'], 'sessionId' | 'workspaceId' | 'cwdRelative'>;
+export type ManagedWorkspaceFileReadRequest = ManagedWorkspaceFileLocator & Omit<components['schemas']['WebShellWorkspaceFileReadRequest'], 'sessionId' | 'workspaceId' | 'cwdRelative'>;
+export type ManagedWorkspaceFileUploadRequest = ManagedWorkspaceFileLocator & {
+    path: string;
+    expectedScopeRevision: string;
+    uploadId: string;
+};
 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;
@@ -77,9 +93,12 @@ export type ManagedLifecycleAction = ManagedLifecycleKind | 'unarchive' | 'close
 export type ManagedLifecycleOperation = components['schemas']['WebShellCommandOperation'];
 export type ManagedExportPage = components['schemas']['WebShellExportPage'];
 export type ManagedExportItem = components['schemas']['WebShellItem'];
+export type ManagedSessionWorktree = components['schemas']['WebShellSessionWorktree'];
+export type ManagedSessionWorktreeOptions = components['schemas']['WebShellSessionWorktreeOptions'];
 export interface ManagedAgentSessionSummary {
     sessionId: string;
     agentId?: string;
+    worktree?: ManagedSessionWorktree | null;
     approvalMode?: ManagedApprovalMode;
     initialApprovalMode?: ManagedApprovalMode;
     approvalRevision?: number;
@@ -140,7 +159,7 @@ export interface ManagedAgentSessionEvent {
     turnId: string;
     data?: unknown;
     /**
-     * Projected from a durable snapshot item rather than a raw event. The
+     * Projected from a materialized Item rather than a raw event. The
      * server can retract its items (reconciliation), after which these
      * projections must not survive a resync.
      */
@@ -150,6 +169,7 @@ export interface ManagedAgentSessionTranscript {
     events: ManagedAgentSessionEvent[];
     olderCursor?: string;
     lastEventId: number;
+    history?: 'items';
 }
 export interface ManagedAgentTurnAdmission {
     sessionId: string;
@@ -212,6 +232,7 @@ export interface ManagedAgentProvider {
     exportSnapshot?(sessionId: string, options: ManagedAgentRequestOptions & {
         cursor?: string;
     }): Promise<ManagedExportPage>;
+    readonly exportConsistency?: 'live';
     readonly storageKey: string;
     readonly canCancel: boolean;
     /** Present when the provider can filter the complete Session history by title. */
@@ -299,15 +320,9 @@ export interface ManagedAgentProvider {
         }, options: ManagedAgentCommandOptions): Promise<ManagedModelChangeResult>;
     };
     readonly workspaceFiles?: {
-        query(request: components['schemas']['WebShellWorkspaceFileQueryRequest'], options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFilePage']>;
-        read(request: components['schemas']['WebShellWorkspaceFileReadRequest'], options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFileSnapshot']>;
-        upload?(request: {
-            workspaceId: string;
-            cwdRelative: string;
-            path: string;
-            expectedScopeRevision: string;
-            uploadId: string;
-        }, data: Blob, options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFileUploadResult']>;
+        query(request: ManagedWorkspaceFileQueryRequest, options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFilePage']>;
+        read(request: ManagedWorkspaceFileReadRequest, options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFileSnapshot']>;
+        upload?(request: ManagedWorkspaceFileUploadRequest, data: Blob, options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFileUploadResult']>;
         queryUpload?(uploadId: string, options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFileUploadStatus']>;
     };
     readonly workspaceBinding?: {
@@ -354,6 +369,9 @@ export interface ManagedAgentProvider {
             planMode?: boolean;
             skills?: ManagedSessionSkill[];
             extensionPins?: ManagedExtensionPin[];
+            worktree?: {
+                baseRef?: string;
+            };
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;
@@ -368,10 +386,25 @@ export interface ManagedAgentProvider {
             planMode?: boolean;
             skills?: ManagedSessionSkill[];
             extensionPins?: ManagedExtensionPin[];
+            worktree?: {
+                baseRef?: string;
+            };
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;
     };
+    readonly sessionWorktrees?: {
+        options(request: {
+            workspaceId: string;
+            cwdRelative: string;
+            baseRef?: string;
+        }, options: ManagedAgentRequestOptions): Promise<ManagedSessionWorktreeOptions>;
+        list(workspaceId: string, options: ManagedAgentRequestOptions): Promise<{
+            data: ManagedSessionWorktree[];
+        }>;
+        inspect(workspaceId: string, worktreeId: string, options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellSessionWorktreeInspection']>;
+        cleanup(workspaceId: string, worktreeId: string, options: ManagedAgentCommandOptions): Promise<ManagedSessionWorktree>;
+    };
     listSessions(options: ManagedAgentRequestOptions & {
         archiveState?: 'unarchived' | 'archived' | 'all';
         titleQuery?: string;

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

@@ -13,6 +13,7 @@ export interface ManagedReadingExport {
     session: ManagedAgentSessionSummary;
     exportedAt: string;
     snapshotThroughSequence: number;
+    consistency?: 'live';
     blocks: ExportBlock[];
 }
 export declare function collectManagedReadingExport(provider: ManagedAgentProvider, clientId: string, sessionId: string, signal: AbortSignal): Promise<ManagedReadingExport>;

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

@@ -1,5 +1,5 @@
 import type { Message } from '../../adapters/types';
 import type { ManagedAgentSessionEvent } from './managed-agent-provider';
-export declare function mergeManagedEvents(current: readonly ManagedAgentSessionEvent[], incoming: readonly ManagedAgentSessionEvent[]): ManagedAgentSessionEvent[];
+export declare function mergeManagedEvents(current: readonly ManagedAgentSessionEvent[], incoming: readonly ManagedAgentSessionEvent[], itemPages?: boolean): ManagedAgentSessionEvent[];
 export declare function managedEventsToMessages(events: readonly ManagedAgentSessionEvent[], truncatedLabel: string): Message[];
 export declare function createManagedMessageProjector(): (events: readonly ManagedAgentSessionEvent[], truncatedLabel: string) => Message[];