@codingame/monaco-vscode-katex-common 34.1.2 → 35.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostGenericConfigChips.js

@@ -10,6 +10,7 @@ import { StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform
 import { isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { isClaimedByDedicatedPicker, AgentHostChatInputPicker } from './agentHostChatInputPicker.js';
 import { IAgentHostSessionWorkingDirectoryResolver } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionWorkingDirectoryResolver.service';
+import { IAgentHostNewSessionFolderService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostNewSessionFolderService.service';
 import { IAgentHostUntitledProvisionalSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { toAgentHostBackendSessionUri } from './agentHostSessionUri.js';
@@ -21,7 +22,8 @@ let AgentHostGenericConfigChips = class AgentHostGenericConfigChips extends Disp
         _agentHostService,
         _provisional,
         _workingDirectoryResolver,
-        _workspaceContextService
+        _workspaceContextService,
+        _newSessionFolderService
     ) {
         super();
         this._widget = _widget;
@@ -30,6 +32,7 @@ let AgentHostGenericConfigChips = class AgentHostGenericConfigChips extends Disp
         this._provisional = _provisional;
         this._workingDirectoryResolver = _workingDirectoryResolver;
         this._workspaceContextService = _workspaceContextService;
+        this._newSessionFolderService = _newSessionFolderService;
         this._chips = this._register(( new DisposableMap()));
         this._subRef = this._register(( new MutableDisposable()));
         this._initialResolveCts = this._register(( new MutableDisposable()));
@@ -107,11 +110,11 @@ let AgentHostGenericConfigChips = class AgentHostGenericConfigChips extends Disp
     _readWorkingDirectory() {
         const state = this._subRef.value?.sub.value;
         if (state && !(state instanceof Error)) {
-            const cwd = state.summary.workingDirectory;
+            const cwd = state.workingDirectory;
             return typeof cwd === "string" ? ( URI.parse(cwd)) : cwd;
         }
         const sessionResource = this._widget.viewModel?.sessionResource;
-        return (sessionResource && this._workingDirectoryResolver.resolve(sessionResource)) ?? this._workspaceContextService.getWorkspace().folders[0]?.uri;
+        return (sessionResource && this._newSessionFolderService.getFolder(sessionResource)) ?? (sessionResource && this._workingDirectoryResolver.resolve(sessionResource)) ?? this._newSessionFolderService.getDefaultFolder() ?? this._workspaceContextService.getWorkspace().folders[0]?.uri;
     }
     _readSchemaProperties() {
         const sessionResource = this._widget.viewModel?.sessionResource;
@@ -166,6 +169,6 @@ let AgentHostGenericConfigChips = class AgentHostGenericConfigChips extends Disp
         }
     }
 };
-AgentHostGenericConfigChips = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IAgentHostService)), ( __param(3, IAgentHostUntitledProvisionalSessionService)), ( __param(4, IAgentHostSessionWorkingDirectoryResolver)), ( __param(5, IWorkspaceContextService))], AgentHostGenericConfigChips));
+AgentHostGenericConfigChips = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IAgentHostService)), ( __param(3, IAgentHostUntitledProvisionalSessionService)), ( __param(4, IAgentHostSessionWorkingDirectoryResolver)), ( __param(5, IWorkspaceContextService)), ( __param(6, IAgentHostNewSessionFolderService))], AgentHostGenericConfigChips));
 
 export { AgentHostGenericConfigChips };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionReferenceAttachment.d.ts

@@ -0,0 +1,12 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { type SimpleMessageAttachment } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import { type IChatRequestSessionReferenceVariableEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries";
+export declare const AgentHostSessionReferenceAttachmentDisplayKind = "sessionReference";
+export declare const AgentHostSessionReferenceTrajectoryAttachmentDisplayKind = "sessionReferenceTrajectory";
+export declare const AgentHostSessionReferenceAttachmentMetadataKey = "vscode.agentHost.sessionReference";
+export declare function toSessionReferenceModelRepresentation(label: string, sessionResource: URI, trajectoryPath?: string): string;
+export declare function toSessionReferenceAttachmentMeta(sessionResource: URI): NonNullable<SimpleMessageAttachment["_meta"]>;
+export declare function restoreSessionReferenceVariableEntryFromAttachment(attachment: SimpleMessageAttachment): IChatRequestSessionReferenceVariableEntry | undefined;
+export declare function isSessionReferenceTrajectoryAttachment(attachment: {
+    readonly displayKind?: string;
+}): boolean;

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSnapshotController.d.ts

@@ -0,0 +1,116 @@
+import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable, IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { type ToolCallState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IChatProgress, IChatWorkspaceEdit } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { ChatEditingSessionState, IChatEditingSession, IEditSessionDiffStats, IEditSessionEntryDiff, IModifiedFileEntry, IStreamingEdits } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService";
+import { IChatRequestDisablement, IChatResponseModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
+/**
+ * A thin {@link IChatEditingSession} for agent host sessions. The agent host
+ * has its own diff / changeset machinery and renders file edits via the
+ * dedicated {@link IChatExternalEdit} progress part — so this session only
+ * needs to support the chat-level "restore to checkpoint" UX.
+ *
+ * Concretely it implements:
+ * - {@link restoreSnapshot} (writes before/after content to disk)
+ * - {@link requestDisablement} (so disabled-request UI works after restore)
+ * - {@link getSnapshotUri} / {@link getSnapshotContents} (so checkpoint diff
+ *   viewers can resolve historical content)
+ *
+ * Everything else is a no-op / empty observable / `undefined`. In particular:
+ * - `entries` is always empty → the global accept/reject UI doesn't appear
+ * - no diff computation, no multi-diff editor, no streaming-edits APIs
+ *
+ * Undo/redo granularity is per-request: every request occupies one checkpoint
+ * regardless of how many tool calls it ran. The `stopId` parameters on
+ * {@link restoreSnapshot}, {@link getSnapshotUri}, and {@link getSnapshotContents}
+ * are accepted for interface compatibility but ignored.
+ *
+ * Hydrated by the session handler via {@link ensureRequestCheckpoint} and
+ * {@link addToolCallEdits} as turns and tool calls arrive.
+ */
+export declare class AgentHostSnapshotController extends Disposable implements IChatEditingSession {
+    readonly chatSessionResource: URI;
+    private readonly _connectionAuthority;
+    private readonly _logService;
+    private readonly _fileService;
+    readonly supportsKeepUndo = false;
+    readonly isGlobalEditingSession = false;
+    readonly state: IObservable<ChatEditingSessionState>;
+    readonly entries: IObservable<readonly IModifiedFileEntry[]>;
+    readonly requestDisablement: IObservable<IChatRequestDisablement[]>;
+    readonly canUndo: IObservable<boolean>;
+    readonly canRedo: IObservable<boolean>;
+    private readonly _onDidDispose;
+    readonly onDidDispose: Event<void>;
+    private readonly _checkpoints;
+    private readonly _currentCheckpointIndex;
+    private readonly _undoRedoSequencer;
+    constructor(chatSessionResource: URI, _connectionAuthority: string, _logService: ILogService, _fileService: IFileService);
+    /**
+     * Ensures a checkpoint exists for the given request. Called at the start
+     * of every turn (and during history hydration) so {@link requestDisablement}
+     * and {@link restoreSnapshot} can reference every request, even ones that
+     * produce no file edits.
+     *
+     * Splices away stale checkpoints past the current index (undo branch
+     * semantics) when a new request arrives after a checkpoint restore.
+     */
+    ensureRequestCheckpoint(requestId: string): void;
+    /**
+     * Folds a completed tool call's file edits into the checkpoint for the
+     * given request. Idempotent on `toolCallId`.
+     */
+    addToolCallEdits(requestId: string, tc: ToolCallState): void;
+    private _findCheckpointIndex;
+    restoreSnapshot(requestId: string, _stopId: string | undefined): Promise<void>;
+    /**
+     * Steps a single checkpoint backwards, undoing the edits of the current
+     * checkpoint. The "Undo" UI invokes this once per click.
+     */
+    undoInteraction(): Promise<void>;
+    /**
+     * Steps a single checkpoint forwards, redoing the edits of the next
+     * checkpoint.
+     *
+     * Implementing this is essential: the "Redo" action repeatedly calls this
+     * while {@link canRedo} is `true`, so a no-op implementation would spin
+     * forever and hang the window.
+     */
+    redoInteraction(): Promise<void>;
+    /**
+     * Moves the on-disk file state and the checkpoint cursor to `targetIdx`,
+     * writing each crossed checkpoint's before/after content. Must run inside
+     * the {@link _undoRedoSequencer} to avoid racing writes.
+     */
+    private _navigateToCheckpointIndex;
+    getSnapshotUri(requestId: string, uri: URI, _stopId: string | undefined): URI | undefined;
+    getSnapshotContents(requestId: string, uri: URI, _stopId: string | undefined): Promise<VSBuffer | undefined>;
+    getSnapshotModel(_requestId: string, _undoStop: string | undefined, _snapshotUri: URI): Promise<ITextModel | null>;
+    hasEditsInRequest(requestId: string, _reader?: IReader): boolean;
+    show(_previousChanges?: boolean): Promise<void>;
+    getEntry(_uri: URI): IModifiedFileEntry | undefined;
+    readEntry(_uri: URI, _reader: IReader): IModifiedFileEntry | undefined;
+    accept(..._uris: URI[]): Promise<void>;
+    reject(..._uris: URI[]): Promise<void>;
+    getEntryDiffBetweenStops(_uri: URI, _requestId: string | undefined, _stopId: string | undefined): IObservable<IEditSessionEntryDiff | undefined> | undefined;
+    getEntryDiffBetweenRequests(_uri: URI, _startRequestId: string, _stopRequestId: string): IObservable<IEditSessionEntryDiff | undefined>;
+    getDiffsForFilesInSession(): IObservable<readonly IEditSessionEntryDiff[]>;
+    getDiffsForFilesInRequest(_requestId: string): IObservable<readonly IEditSessionEntryDiff[]>;
+    getDiffForSession(): IObservable<IEditSessionDiffStats>;
+    triggerExplanationGeneration(): Promise<void>;
+    clearExplanations(): void;
+    hasExplanations(): boolean;
+    startStreamingEdits(_resource: URI, _responseModel: IChatResponseModel, _inUndoStop: string | undefined): IStreamingEdits;
+    applyWorkspaceEdit(_edit: IChatWorkspaceEdit, _responseModel: IChatResponseModel, _undoStopId: string): void;
+    startExternalEdits(_responseModel: IChatResponseModel, _operationId: number, _resources: URI[], _undoStopId: string, _contentFor?: URI[]): Promise<IChatProgress[]>;
+    stopExternalEdits(_responseModel: IChatResponseModel, _operationId: number, _contentFor?: URI[]): Promise<IChatProgress[]>;
+    stop(_clearState?: boolean): Promise<void>;
+    dispose(): void;
+    private _writeCheckpointContent;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSnapshotController.js

@@ -0,0 +1,348 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Sequencer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { toAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { FileEditKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ChatEditingSessionState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
+import { fileEditsToExternalEdits } from './stateToProgressAdapter.js';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+import { derivedOpts, derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+import { ToolCallStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
+
+let AgentHostSnapshotController = class AgentHostSnapshotController extends Disposable {
+    constructor(chatSessionResource, _connectionAuthority, _logService, _fileService) {
+        super();
+        this.chatSessionResource = chatSessionResource;
+        this._connectionAuthority = _connectionAuthority;
+        this._logService = _logService;
+        this._fileService = _fileService;
+        this.supportsKeepUndo = false;
+        this.isGlobalEditingSession = false;
+        this.state = constObservable(ChatEditingSessionState.Idle);
+        this.entries = constObservable([]);
+        this.requestDisablement = derivedOpts({
+            equalsFn: (a, b) => a.length === b.length && a.every((v, i) => v.requestId === b[i].requestId)
+        }, reader => {
+            const currentIdx = this._currentCheckpointIndex.read(reader);
+            const disabled = [];
+            for (let i = currentIdx + 1; i < this._checkpoints.length; i++) {
+                disabled.push({
+                    requestId: this._checkpoints[i].requestId
+                });
+            }
+            return disabled;
+        });
+        this.canUndo = derived(this, r => this._currentCheckpointIndex.read(r) >= 0);
+        this.canRedo = derived(
+            this,
+            r => this._currentCheckpointIndex.read(r) < this._checkpoints.length - 1
+        );
+        this._onDidDispose = this._register(( new Emitter()));
+        this.onDidDispose = this._onDidDispose.event;
+        this._checkpoints = [];
+        this._currentCheckpointIndex = observableValue(this, -1);
+        this._undoRedoSequencer = ( new Sequencer());
+    }
+    ensureRequestCheckpoint(requestId) {
+        if (( this._checkpoints.some(cp => cp.requestId === requestId))) {
+            return;
+        }
+        const currentIdx = this._currentCheckpointIndex.get();
+        if (currentIdx < this._checkpoints.length - 1) {
+            this._checkpoints.splice(currentIdx + 1);
+        }
+        this._checkpoints.push({
+            requestId,
+            edits: [],
+            seenToolCallIds: ( new Set())
+        });
+        transaction(tx => {
+            this._currentCheckpointIndex.set(this._checkpoints.length - 1, tx);
+        });
+    }
+    addToolCallEdits(requestId, tc) {
+        if (tc.status !== ToolCallStatus.Completed) {
+            return;
+        }
+        this.ensureRequestCheckpoint(requestId);
+        const cp = this._checkpoints.find(c => c.requestId === requestId);
+        if (!cp || ( cp.seenToolCallIds.has(tc.toolCallId))) {
+            return;
+        }
+        cp.seenToolCallIds.add(tc.toolCallId);
+        const fileEdits = fileEditsToExternalEdits(tc);
+        if (fileEdits.length === 0) {
+            return;
+        }
+        const authority = this._connectionAuthority;
+        for (const edit of fileEdits) {
+            const resource = toAgentHostUri(edit.resource, authority);
+            const entry = {
+                kind: edit.kind,
+                resource,
+                originalResource: edit.originalResource ? toAgentHostUri(edit.originalResource, authority) : undefined,
+                beforeContentUri: edit.beforeContentUri ? toAgentHostUri(edit.beforeContentUri, authority) : undefined,
+                afterContentUri: edit.afterContentUri ? toAgentHostUri(edit.afterContentUri, authority) : undefined,
+                undoStopId: edit.undoStopId,
+                diff: edit.diff
+            };
+            const existingIdx = cp.edits.findIndex(e => ( e.resource.toString()) === ( resource.toString()));
+            if (existingIdx < 0) {
+                cp.edits.push(entry);
+            } else {
+                cp.edits[existingIdx] = mergeFileEdit(cp.edits[existingIdx], entry);
+            }
+        }
+    }
+    _findCheckpointIndex(requestId) {
+        return this._checkpoints.findIndex(cp => cp.requestId === requestId);
+    }
+    async restoreSnapshot(requestId, _stopId) {
+        return this._undoRedoSequencer.queue(async () => {
+            const cpIdx = this._findCheckpointIndex(requestId);
+            if (cpIdx < 0) {
+                this._logService.warn(
+                    `[AgentHostSnapshotController] No checkpoint found for requestId=${requestId}`
+                );
+                return;
+            }
+            await this._navigateToCheckpointIndex(cpIdx - 1);
+        });
+    }
+    async undoInteraction() {
+        return this._undoRedoSequencer.queue(async () => {
+            const currentIdx = this._currentCheckpointIndex.get();
+            if (currentIdx < 0) {
+                return;
+            }
+            await this._navigateToCheckpointIndex(currentIdx - 1);
+        });
+    }
+    async redoInteraction() {
+        return this._undoRedoSequencer.queue(async () => {
+            const currentIdx = this._currentCheckpointIndex.get();
+            if (currentIdx >= this._checkpoints.length - 1) {
+                return;
+            }
+            await this._navigateToCheckpointIndex(currentIdx + 1);
+        });
+    }
+    async _navigateToCheckpointIndex(targetIdx) {
+        const currentIdx = this._currentCheckpointIndex.get();
+        if (targetIdx < currentIdx) {
+            for (let i = currentIdx; i > targetIdx; i--) {
+                await this._writeCheckpointContent(this._checkpoints[i], "before");
+            }
+        } else if (targetIdx > currentIdx) {
+            for (let i = currentIdx + 1; i <= targetIdx; i++) {
+                await this._writeCheckpointContent(this._checkpoints[i], "after");
+            }
+        }
+        transaction(tx => {
+            this._currentCheckpointIndex.set(targetIdx, tx);
+        });
+    }
+    getSnapshotUri(requestId, uri, _stopId) {
+        const cp = this._checkpoints.find(c => c.requestId === requestId);
+        if (!cp || !( cp.edits.some(e => ( e.resource.toString()) === ( uri.toString())))) {
+            return undefined;
+        }
+        return ( URI.from({
+            scheme: Schemas.chatEditingSnapshotScheme,
+            path: uri.path,
+            query: JSON.stringify({
+                session: ( this.chatSessionResource.toString()),
+                requestId,
+                undoStop: ""
+            })
+        }));
+    }
+    async getSnapshotContents(requestId, uri, _stopId) {
+        const cp = this._checkpoints.find(c => c.requestId === requestId);
+        if (!cp) {
+            return undefined;
+        }
+        const uriStr = ( uri.toString());
+        let edit;
+        for (let i = cp.edits.length - 1; i >= 0; i--) {
+            if (( cp.edits[i].resource.toString()) === uriStr) {
+                edit = cp.edits[i];
+                break;
+            }
+        }
+        if (!edit) {
+            return undefined;
+        }
+        try {
+            if (!edit.afterContentUri) {
+                return VSBuffer.fromByteArray([]);
+            }
+            const content = await this._fileService.readFile(edit.afterContentUri);
+            return content.value;
+        } catch (err) {
+            this._logService.warn(`[AgentHostSnapshotController] Failed to fetch snapshot content`, err);
+            return undefined;
+        }
+    }
+    async getSnapshotModel(_requestId, _undoStop, _snapshotUri) {
+        return null;
+    }
+    hasEditsInRequest(requestId, _reader) {
+        const cp = this._checkpoints.find(c => c.requestId === requestId);
+        return !!cp && cp.edits.length > 0;
+    }
+    async show(_previousChanges) {}
+    getEntry(_uri) {
+        return undefined;
+    }
+    readEntry(_uri, _reader) {
+        return undefined;
+    }
+    async accept(..._uris) {}
+    async reject(..._uris) {}
+    getEntryDiffBetweenStops(_uri, _requestId, _stopId) {
+        return undefined;
+    }
+    getEntryDiffBetweenRequests(_uri, _startRequestId, _stopRequestId) {
+        return constObservable(undefined);
+    }
+    getDiffsForFilesInSession() {
+        return constObservable([]);
+    }
+    getDiffsForFilesInRequest(_requestId) {
+        return constObservable([]);
+    }
+    getDiffForSession() {
+        return constObservable({
+            added: 0,
+            removed: 0
+        });
+    }
+    async triggerExplanationGeneration() {}
+    clearExplanations() {}
+    hasExplanations() {
+        return false;
+    }
+    startStreamingEdits(_resource, _responseModel, _inUndoStop) {
+        throw ( new Error("Not supported for agent host sessions"));
+    }
+    applyWorkspaceEdit(_edit, _responseModel, _undoStopId) {
+        throw ( new Error("Not supported for agent host sessions"));
+    }
+    async startExternalEdits(_responseModel, _operationId, _resources, _undoStopId, _contentFor) {
+        throw ( new Error("Not supported for agent host sessions"));
+    }
+    async stopExternalEdits(_responseModel, _operationId, _contentFor) {
+        throw ( new Error("Not supported for agent host sessions"));
+    }
+    async stop(_clearState) {
+        this.dispose();
+    }
+    dispose() {
+        this._onDidDispose.fire();
+        super.dispose();
+    }
+    async _writeCheckpointContent(checkpoint, direction) {
+        const ops = ( checkpoint.edits.map(async edit => {
+            try {
+                if (direction === "before") {
+                    switch (edit.kind) {
+                    case FileEditKind.Create:
+                        await this._fileService.del(edit.resource);
+                        break;
+                    case FileEditKind.Delete:
+                        if (edit.beforeContentUri) {
+                            const content = await this._fileService.readFile(edit.beforeContentUri);
+                            await this._fileService.writeFile(edit.resource, content.value);
+                        }
+                        break;
+                    case FileEditKind.Rename:
+                        if (edit.originalResource) {
+                            await this._fileService.move(edit.resource, edit.originalResource, true);
+                        }
+                        if (edit.beforeContentUri && edit.originalResource) {
+                            const content = await this._fileService.readFile(edit.beforeContentUri);
+                            await this._fileService.writeFile(edit.originalResource, content.value);
+                        }
+                        break;
+                    case FileEditKind.Edit:
+                        if (edit.beforeContentUri) {
+                            const content = await this._fileService.readFile(edit.beforeContentUri);
+                            await this._fileService.writeFile(edit.resource, content.value);
+                        }
+                        break;
+                    }
+                } else {
+                    switch (edit.kind) {
+                    case FileEditKind.Create:
+                        if (edit.afterContentUri) {
+                            const content = await this._fileService.readFile(edit.afterContentUri);
+                            await this._fileService.writeFile(edit.resource, content.value);
+                        }
+                        break;
+                    case FileEditKind.Delete:
+                        await this._fileService.del(edit.resource);
+                        break;
+                    case FileEditKind.Rename:
+                        if (edit.originalResource) {
+                            await this._fileService.move(edit.originalResource, edit.resource, true);
+                        }
+                        if (edit.afterContentUri) {
+                            const content = await this._fileService.readFile(edit.afterContentUri);
+                            await this._fileService.writeFile(edit.resource, content.value);
+                        }
+                        break;
+                    case FileEditKind.Edit:
+                        if (edit.afterContentUri) {
+                            const content = await this._fileService.readFile(edit.afterContentUri);
+                            await this._fileService.writeFile(edit.resource, content.value);
+                        }
+                        break;
+                    }
+                }
+            } catch (err) {
+                this._logService.warn(
+                    `[AgentHostSnapshotController] Failed to ${direction === "before" ? "undo" : "redo"} ${edit.kind} for ${( edit.resource.toString())}`,
+                    err
+                );
+            }
+        }));
+        await Promise.all(ops);
+    }
+};
+AgentHostSnapshotController = ( __decorate([( __param(2, ILogService)), ( __param(3, IFileService))], AgentHostSnapshotController));
+function mergeFileEdit(prev, next) {
+    const startsAbsent = prev.kind === FileEditKind.Create;
+    const endsAbsent = next.kind === FileEditKind.Delete;
+    let kind;
+    if (startsAbsent && endsAbsent) {
+        kind = FileEditKind.Edit;
+    } else if (startsAbsent) {
+        kind = FileEditKind.Create;
+    } else if (endsAbsent) {
+        kind = FileEditKind.Delete;
+    } else {
+        kind = FileEditKind.Edit;
+    }
+    return {
+        kind,
+        resource: next.resource,
+        originalResource: next.originalResource ?? prev.originalResource,
+        beforeContentUri: prev.beforeContentUri,
+        afterContentUri: next.afterContentUri,
+        undoStopId: prev.undoStopId,
+        diff: next.diff ?? prev.diff
+    };
+}
+
+export { AgentHostSnapshotController };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/media/agentHostChatInputPicker.css

@@ -99,7 +99,7 @@
 	container-type: inline-size;
 }
 
-@container (max-width: 480px) {
+@container (max-width: 400px) {
 	.agent-host-chat-input-picker-label {
 		display: none;
 	}