@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/chat/browser/runScriptCustomTaskWidget.d.ts

@@ -0,0 +1,48 @@
+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 { TaskStorageTarget } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionsTasksService";
+export declare const WORKTREE_CREATED_RUN_ON: "worktreeCreated";
+export interface IRunScriptCustomTaskWidgetState {
+    readonly label?: string;
+    readonly labelDisabledReason?: string;
+    readonly command?: string;
+    readonly commandDisabledReason?: string;
+    readonly target?: TaskStorageTarget;
+    readonly targetDisabledReason?: string;
+    readonly runOn?: typeof WORKTREE_CREATED_RUN_ON;
+    readonly mode?: "add" | "add-existing" | "configure";
+}
+export interface IRunScriptCustomTaskWidgetResult {
+    readonly label?: string;
+    readonly command: string;
+    readonly target: TaskStorageTarget;
+    readonly runOn?: typeof WORKTREE_CREATED_RUN_ON;
+}
+export declare class RunScriptCustomTaskWidget extends Disposable {
+    readonly domNode: HTMLElement;
+    private readonly _labelInput;
+    private readonly _commandInput;
+    private readonly _runOnCheckbox;
+    private readonly _storageOptions;
+    private readonly _submitButton;
+    private readonly _cancelButton;
+    private readonly _labelLocked;
+    private readonly _commandLocked;
+    private readonly _targetLocked;
+    private readonly _isExistingTask;
+    private readonly _isAddExistingTask;
+    private readonly _initialLabel;
+    private readonly _initialCommand;
+    private readonly _initialRunOn;
+    private readonly _initialTarget;
+    private _selectedTarget;
+    private readonly _onDidSubmit;
+    readonly onDidSubmit: Event<IRunScriptCustomTaskWidgetResult>;
+    private readonly _onDidCancel;
+    readonly onDidCancel: Event<void>;
+    constructor(state: IRunScriptCustomTaskWidgetState);
+    focus(): void;
+    private _submit;
+    private _updateButtonState;
+    private _getSubmitLabel;
+}

package/vscode/src/vs/sessions/contrib/chat/browser/runScriptCustomTaskWidget.js

@@ -0,0 +1,215 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import * as runScriptAction from './media/runScriptAction.css';
+import { $, append, addDisposableListener, EventType } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { InputBox } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/inputbox/inputBox';
+import { Radio } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/radio/radio';
+import { Checkbox } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/toggle/toggle';
+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 { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { defaultInputBoxStyles, defaultCheckboxStyles, defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+
+registerCss(runScriptAction, 1);
+const WORKTREE_CREATED_RUN_ON = "worktreeCreated";
+class RunScriptCustomTaskWidget extends Disposable {
+    constructor(state) {
+        super();
+        this._onDidSubmit = this._register(( new Emitter()));
+        this.onDidSubmit = this._onDidSubmit.event;
+        this._onDidCancel = this._register(( new Emitter()));
+        this.onDidCancel = this._onDidCancel.event;
+        this._labelLocked = !!state.labelDisabledReason;
+        this._commandLocked = !!state.commandDisabledReason;
+        this._targetLocked = !!state.targetDisabledReason && state.target !== undefined;
+        this._isExistingTask = state.mode === "configure";
+        this._isAddExistingTask = state.mode === "add-existing";
+        this._selectedTarget = state.target ?? (state.targetDisabledReason ? "user" : "workspace");
+        this._initialLabel = state.label ?? "";
+        this._initialCommand = state.command ?? "";
+        this._initialRunOn = state.runOn === WORKTREE_CREATED_RUN_ON;
+        this._initialTarget = this._selectedTarget;
+        this.domNode = $(".run-script-action-widget");
+        const labelSection = append(this.domNode, $(".run-script-action-section"));
+        append(
+            labelSection,
+            $("label.run-script-action-label", undefined, ( localize(3802, "Name")))
+        );
+        const labelInputContainer = append(labelSection, $(".run-script-action-input"));
+        this._labelInput = this._register(( new InputBox(labelInputContainer, undefined, {
+            placeholder: ( localize(3803, "Enter a name for this task (optional)")),
+            tooltip: state.labelDisabledReason,
+            ariaLabel: ( localize(3804, "Task name")),
+            inputBoxStyles: defaultInputBoxStyles
+        })));
+        this._labelInput.value = state.label ?? "";
+        if (state.labelDisabledReason) {
+            this._labelInput.disable();
+        }
+        const commandSection = append(this.domNode, $(".run-script-action-section"));
+        append(
+            commandSection,
+            $("label.run-script-action-label", undefined, ( localize(3805, "Command")))
+        );
+        const commandInputContainer = append(commandSection, $(".run-script-action-input"));
+        this._commandInput = this._register(( new InputBox(commandInputContainer, undefined, {
+            placeholder: ( localize(3806, "Enter command (for example, npm run dev)")),
+            tooltip: state.commandDisabledReason,
+            ariaLabel: ( localize(3807, "Task command")),
+            inputBoxStyles: defaultInputBoxStyles
+        })));
+        this._commandInput.value = state.command ?? "";
+        if (state.commandDisabledReason) {
+            this._commandInput.disable();
+        }
+        const runOnSection = append(this.domNode, $(".run-script-action-section"));
+        append(
+            runOnSection,
+            $("div.run-script-action-label", undefined, ( localize(3808, "Run Options")))
+        );
+        const runOnRow = append(runOnSection, $(".run-script-action-option-row"));
+        this._runOnCheckbox = this._register(( new Checkbox(( localize(3809, "Run When Worktree Is Created")), state.runOn === WORKTREE_CREATED_RUN_ON, defaultCheckboxStyles)));
+        runOnRow.appendChild(this._runOnCheckbox.domNode);
+        const runOnText = append(
+            runOnRow,
+            $("span.run-script-action-option-text", undefined, ( localize(3810, "Automatically run this task when the session worktree is created")))
+        );
+        this._register(addDisposableListener(
+            runOnText,
+            EventType.CLICK,
+            () => this._runOnCheckbox.checked = !this._runOnCheckbox.checked
+        ));
+        const storageSection = append(this.domNode, $(".run-script-action-section"));
+        append(
+            storageSection,
+            $("div.run-script-action-label", undefined, ( localize(3811, "Save In")))
+        );
+        const storageDisabledReason = state.targetDisabledReason;
+        if (storageDisabledReason) {
+            append(
+                storageSection,
+                $("div.run-script-action-hint", undefined, storageDisabledReason)
+            );
+        }
+        const workspaceTargetDisabled = !!storageDisabledReason;
+        this._storageOptions = this._register(( new Radio({
+            items: [{
+                text: ( localize(3812, "Workspace")),
+                tooltip: storageDisabledReason ?? ( localize(3813, "Save this task in the current workspace")),
+                isActive: this._selectedTarget === "workspace",
+                disabled: workspaceTargetDisabled
+            }, {
+                text: ( localize(3814, "User")),
+                tooltip: this._targetLocked ? storageDisabledReason : ( localize(
+                    3815,
+                    "Save this task in your user tasks and make it available in all sessions"
+                )),
+                isActive: this._selectedTarget === "user",
+                disabled: this._targetLocked
+            }]
+        })));
+        this._storageOptions.domNode.setAttribute("aria-label", ( localize(3816, "Task storage target")));
+        this._storageOptions.domNode.classList.toggle("run-script-action-radio-disabled", this._targetLocked);
+        this._storageOptions.setEnabled(!this._targetLocked);
+        storageSection.appendChild(this._storageOptions.domNode);
+        const buttonRow = append(this.domNode, $(".run-script-action-buttons"));
+        this._cancelButton = this._register(( new Button(buttonRow, {
+            ...defaultButtonStyles,
+            secondary: true
+        })));
+        this._cancelButton.label = ( localize(3817, "Cancel"));
+        this._submitButton = this._register(( new Button(buttonRow, defaultButtonStyles)));
+        this._submitButton.label = this._getSubmitLabel();
+        this._register(this._labelInput.onDidChange(() => this._updateButtonState()));
+        this._register(this._commandInput.onDidChange(() => this._updateButtonState()));
+        this._register(this._storageOptions.onDidSelect(index => {
+            this._selectedTarget = index === 0 ? "workspace" : "user";
+            this._updateButtonState();
+        }));
+        this._register(this._runOnCheckbox.onChange(() => this._updateButtonState()));
+        this._register(this._submitButton.onDidClick(() => this._submit()));
+        this._register(this._cancelButton.onDidClick(() => this._onDidCancel.fire()));
+        this._register(
+            addDisposableListener(this._labelInput.inputElement, EventType.KEY_DOWN, event => {
+                const keyboardEvent = ( new StandardKeyboardEvent(event));
+                if (keyboardEvent.equals(KeyCode.Enter)) {
+                    keyboardEvent.preventDefault();
+                    keyboardEvent.stopPropagation();
+                    this._submit();
+                }
+            })
+        );
+        this._register(
+            addDisposableListener(this._commandInput.inputElement, EventType.KEY_DOWN, event => {
+                const keyboardEvent = ( new StandardKeyboardEvent(event));
+                if (keyboardEvent.equals(KeyCode.Enter)) {
+                    keyboardEvent.preventDefault();
+                    keyboardEvent.stopPropagation();
+                    this._submit();
+                }
+            })
+        );
+        this._register(addDisposableListener(this.domNode, EventType.KEY_DOWN, event => {
+            const keyboardEvent = ( new StandardKeyboardEvent(event));
+            if (keyboardEvent.equals(KeyCode.Escape)) {
+                keyboardEvent.preventDefault();
+                keyboardEvent.stopPropagation();
+                this._onDidCancel.fire();
+            }
+        }));
+        this._updateButtonState();
+    }
+    focus() {
+        if (!this._labelLocked) {
+            this._labelInput.focus();
+            return;
+        }
+        if (this._commandLocked) {
+            this._runOnCheckbox.focus();
+            return;
+        }
+        this._commandInput.focus();
+    }
+    _submit() {
+        const label = this._labelInput.value.trim();
+        const command = this._commandInput.value.trim();
+        if (!command) {
+            return;
+        }
+        this._onDidSubmit.fire({
+            label: label.length > 0 ? label : undefined,
+            command,
+            target: this._selectedTarget,
+            runOn: this._runOnCheckbox.checked ? WORKTREE_CREATED_RUN_ON : undefined
+        });
+    }
+    _updateButtonState() {
+        this._submitButton.enabled = this._commandInput.value.trim().length > 0;
+        this._submitButton.label = this._getSubmitLabel();
+    }
+    _getSubmitLabel() {
+        if (this._isAddExistingTask) {
+            return localize(3818, "Add to Agents Window");
+        }
+        if (!this._isExistingTask) {
+            return localize(3819, "Add Task");
+        }
+        const targetChanged = this._selectedTarget !== this._initialTarget;
+        const labelChanged = this._labelInput.value !== this._initialLabel;
+        const commandChanged = this._commandInput.value !== this._initialCommand;
+        const runOnChanged = this._runOnCheckbox.checked !== this._initialRunOn;
+        const otherChanged = labelChanged || commandChanged || runOnChanged;
+        if (targetChanged && otherChanged) {
+            return localize(3820, "Move and Update Task");
+        }
+        if (targetChanged) {
+            return localize(3821, "Move Task");
+        }
+        return localize(3822, "Update Task");
+    }
+}
+
+export { RunScriptCustomTaskWidget, WORKTREE_CREATED_RUN_ON };

package/vscode/src/vs/sessions/contrib/chat/browser/sessionTurnChanges.d.ts

@@ -0,0 +1,27 @@
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { AbstractChatResponseFileChangesService, IChatResponseFileChangesOpenContext, IChatResponseFileChangesStats } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatResponseFileChangesService";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IAgentWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ISessionChangesService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService";
+import { IChangesViewService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changesViewService.service";
+/** Opens response changes in the canonical Agents Changes editor. */
+export declare class SessionsChatResponseFileChangesService extends AbstractChatResponseFileChangesService {
+    private readonly _editorService;
+    private readonly _sessionsManagementService;
+    private readonly _sessionsService;
+    private readonly _sessionChangesService;
+    private readonly _layoutService;
+    private readonly _changesViewService;
+    constructor(_editorService: IEditorService, _sessionsManagementService: ISessionsManagementService, _sessionsService: ISessionsService, _sessionChangesService: ISessionChangesService, _layoutService: IAgentWorkbenchLayoutService, _changesViewService: IChangesViewService);
+    getChangeStatsForRequest(sessionResource: URI, requestId: string, context: IChatResponseFileChangesOpenContext): IObservable<IChatResponseFileChangesStats> | undefined;
+    openChangesForRequest(chatResource: URI, requestId: string | undefined, context: IChatResponseFileChangesOpenContext): void;
+    private _openStandaloneChanges;
+    private _isMostRecentChat;
+    private _getSessionFileChanges;
+    private _toSessionFileChanges;
+    private _openTransientLastTurnChanges;
+    private _openSessionTurnChanges;
+}

package/vscode/src/vs/sessions/contrib/chat/browser/sessionTurnChanges.js

@@ -0,0 +1,237 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual, extUriBiasedIgnorePathCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AbstractChatResponseFileChangesService, AUTHORITATIVE_EMPTY_CHAT_RESPONSE_FILE_CHANGES } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatResponseFileChangesService';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { isAgentHostProviderId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { TURN_CHANGES_CHANGESET_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService';
+import { IChangesViewService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changesViewService.service';
+import { derivedObservableWithCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+import { ISessionChangesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/sessionChangesService.service';
+
+function changeStatsEqual(a, b) {
+    return a.files === b.files && a.insertions === b.insertions && a.deletions === b.deletions;
+}
+let SessionsChatResponseFileChangesService = class SessionsChatResponseFileChangesService extends AbstractChatResponseFileChangesService {
+    constructor(
+        _editorService,
+        _sessionsManagementService,
+        _sessionsService,
+        _sessionChangesService,
+        _layoutService,
+        _changesViewService
+    ) {
+        super();
+        this._editorService = _editorService;
+        this._sessionsManagementService = _sessionsManagementService;
+        this._sessionsService = _sessionsService;
+        this._sessionChangesService = _sessionChangesService;
+        this._layoutService = _layoutService;
+        this._changesViewService = _changesViewService;
+    }
+    getChangeStatsForRequest(sessionResource, requestId, context) {
+        if (!context.isLastTurn) {
+            return undefined;
+        }
+        const owner = this._sessionsManagementService.getSessionForChatResource(sessionResource);
+        if (!owner || !isEqual(
+            this._changesViewService.activeSessionResourceObs.get(),
+            owner.session.resource
+        )) {
+            return undefined;
+        }
+        const requestChanges = this.getChangesForRequest(sessionResource, requestId);
+        return derivedObservableWithCache(this, (reader, lastValue) => {
+            const requestDiffs = requestChanges?.read(reader) ?? [];
+            const readRequestStats = () => {
+                let insertions = 0, deletions = 0;
+                for (const change of requestDiffs) {
+                    insertions += change.added;
+                    deletions += change.removed;
+                }
+                return {
+                    files: requestDiffs.length,
+                    insertions,
+                    deletions
+                };
+            };
+            let stats;
+            if (requestDiffs === AUTHORITATIVE_EMPTY_CHAT_RESPONSE_FILE_CHANGES) {
+                stats = readRequestStats();
+            } else if (!isEqual(
+                this._changesViewService.activeSessionResourceObs.read(reader),
+                owner.session.resource
+            ) || !this._isMostRecentChat(owner.session, owner.chat, reader)) {
+                stats = readRequestStats();
+            } else {
+                const changeset = this._changesViewService.activeSessionChangesetsObs.read(reader)?.find(
+                    candidate => candidate.id === TURN_CHANGES_CHANGESET_ID && candidate.isEnabled.read(reader)
+                );
+                if (!changeset) {
+                    stats = readRequestStats();
+                } else if (changeset.isLoadingChanges.read(reader)) {
+                    return lastValue ?? readRequestStats();
+                } else {
+                    const changes = changeset.changes.read(reader);
+                    let insertions = 0, deletions = 0;
+                    for (const change of changes) {
+                        insertions += change.insertions;
+                        deletions += change.deletions;
+                    }
+                    stats = {
+                        files: changes.length,
+                        insertions,
+                        deletions
+                    };
+                }
+            }
+            return lastValue && changeStatsEqual(lastValue, stats) ? lastValue : stats;
+        });
+    }
+    openChangesForRequest(chatResource, requestId, context) {
+        const owner = this._sessionsManagementService.getSessionForChatResource(chatResource);
+        if (!owner) {
+            this._openStandaloneChanges(chatResource, requestId);
+            return;
+        }
+        if (context.isLastTurn) {
+            if (requestId === undefined) {
+                if (isAgentHostProviderId(owner.session.providerId)) {
+                    void this._openSessionTurnChanges(owner.session);
+                } else {
+                    const changes = owner.chat.lastTurnChanges;
+                    if (changes) {
+                        this._openTransientLastTurnChanges(owner.session, ( owner.chat.resource.toString()), changes);
+                    }
+                }
+                return;
+            }
+            if (this._isMostRecentChat(owner.session, owner.chat)) {
+                void this._openSessionTurnChanges(owner.session);
+                return;
+            }
+            const changes = this._getSessionFileChanges(owner.session, chatResource, requestId);
+            if (changes) {
+                this._openTransientLastTurnChanges(owner.session, requestId, changes);
+            }
+            return;
+        }
+        if (requestId === undefined) {
+            return;
+        }
+        const changes = this.getChangesForRequest(chatResource, requestId);
+        if (!changes) {
+            this._openStandaloneChanges(chatResource, requestId);
+            return;
+        }
+        void this._openSessionTurnChanges(owner.session, {
+            id: `${TURN_CHANGES_CHANGESET_ID}:${requestId}`,
+            label: ( localize(3896, "Turn Changes")),
+            description: ( localize(3897, "Changes from the selected chat turn.")),
+            changes: this._toSessionFileChanges(owner.session, changes)
+        });
+    }
+    _openStandaloneChanges(chatResource, requestId) {
+        if (requestId === undefined) {
+            return;
+        }
+        const diffs = this.getChangesForRequest(chatResource, requestId)?.get();
+        if (!diffs?.length) {
+            return;
+        }
+        const source = ( URI.parse(`multi-diff-editor:${( Date.now().toString())}-${( Math.random().toString(36)).slice(2)}`));
+        this._editorService.openEditor({
+            multiDiffSource: source,
+            label: ( localize(3898, "Turn File Changes")),
+            resources: diffs.map(diff => ({
+                original: {
+                    resource: diff.originalURI
+                },
+                modified: {
+                    resource: diff.modifiedURI
+                }
+            }))
+        });
+    }
+    _isMostRecentChat(session, chat, reader) {
+        const mostRecentChat = session.chats.read(reader).reduce(
+            (latest, candidate) => !latest || candidate.updatedAt.read(reader).getTime() > latest.updatedAt.read(reader).getTime() ? candidate : latest,
+            undefined
+        );
+        return isEqual(
+            mostRecentChat?.resource ?? session.mainChat.read(reader).resource,
+            chat.resource
+        );
+    }
+    _getSessionFileChanges(session, chatResource, requestId) {
+        const changes = this.getChangesForRequest(chatResource, requestId);
+        return changes ? this._toSessionFileChanges(session, changes) : undefined;
+    }
+    _toSessionFileChanges(session, changes) {
+        return derived(reader => {
+            const workspace = session.workspace?.read(reader);
+            const workspaceFolders = workspace?.folders.flatMap(folder => [folder.root, folder.workingDirectory]) ?? [];
+            return changes.read(reader).filter(diff => ( workspaceFolders.some(folder => extUriBiasedIgnorePathCase.isEqualOrParent(folder.with({
+                path: diff.modifiedURI.path
+            }), folder)))).map(diff => ({
+                uri: diff.modifiedURI,
+                originalUri: isEqual(diff.originalURI, diff.modifiedURI) ? undefined : diff.originalURI,
+                modifiedUri: diff.isDeleted ? undefined : diff.modifiedSnapshotURI ?? diff.modifiedURI,
+                insertions: diff.added,
+                deletions: diff.removed
+            }));
+        });
+    }
+    _openTransientLastTurnChanges(session, id, changes) {
+        void this._openSessionTurnChanges(session, {
+            id: `${TURN_CHANGES_CHANGESET_ID}:${id}`,
+            label: ( localize(3899, "Turn Changes")),
+            description: ( localize(3900, "Changes from the viewed chat's last turn.")),
+            changes
+        });
+    }
+    async _openSessionTurnChanges(session, transientTurn) {
+        if (!isEqual(this._sessionsService.activeSession.get()?.resource, session.resource)) {
+            this._sessionsService.showSession(session.resource, {
+                preserveFocus: true
+            });
+        }
+        this._layoutService.revealEditorPartExplicitly();
+        const changesetSelection = transientTurn ? {
+            kind: "transient",
+            changeset: {
+                id: transientTurn.id,
+                label: transientTurn.label,
+                description: transientTurn.description,
+                isEnabled: constObservable(true),
+                isDefault: constObservable(false),
+                isLoadingChanges: constObservable(false),
+                changes: transientTurn.changes,
+                operations: constObservable([]),
+                originalCheckpointRef: constObservable(undefined),
+                modifiedCheckpointRef: constObservable(undefined),
+                async invokeOperation(operationId) {
+                    throw ( new Error(`Historical turn changes do not support operation '${operationId}'`));
+                }
+            }
+        } : {
+            kind: "id",
+            id: TURN_CHANGES_CHANGESET_ID
+        };
+        await this._sessionChangesService.openChangesEditor(session.resource, {
+            changesetSelection
+        });
+    }
+};
+SessionsChatResponseFileChangesService = ( __decorate([( __param(0, IEditorService)), ( __param(1, ISessionsManagementService)), ( __param(2, ISessionsService)), ( __param(3, ISessionChangesService)), ( __param(4, IAgentWorkbenchLayoutService)), ( __param(5, IChangesViewService))], SessionsChatResponseFileChangesService));
+
+export { SessionsChatResponseFileChangesService };

package/vscode/src/vs/sessions/contrib/chat/browser/sessionsChatAccessibilityHelp.d.ts

@@ -0,0 +1,10 @@
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions";
+import { AccessibleViewType, AccessibleContentProvider } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView";
+import { IAccessibleViewImplementation } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleViewRegistry";
+export declare class SessionsChatAccessibilityHelp implements IAccessibleViewImplementation {
+    readonly priority = 120;
+    readonly name = "sessionsChat";
+    readonly type = AccessibleViewType.Help;
+    readonly when: import("@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey").ContextKeyExpression | undefined;
+    getProvider(accessor: ServicesAccessor): AccessibleContentProvider;
+}