@codingame/monaco-vscode-chat-cloud-service-override 0.0.0-stage → 38.1.1

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/cloudSandboxSessionConfig.d.ts

@@ -0,0 +1,4 @@
+import { ResolveSessionConfigResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+/** Cloud draft vocabulary until the provisioned host supplies its authoritative schema. */
+export declare function createCloudSandboxSessionConfig(configurationService: IConfigurationService): ResolveSessionConfigResult;

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/cloudSandboxSessionConfig.js

@@ -0,0 +1,39 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { isAutoApprovePolicyRestricted } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/agentHostConfigPolicy';
+import { ChatConfiguration, ChatDefaultPermissionLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+
+function createCloudSandboxSessionConfig(configurationService) {
+    const restricted = isAutoApprovePolicyRestricted(configurationService);
+    const modes = ["interactive", "plan", "autopilot"];
+    const approvals = restricted ? ["manual"] : ["manual", "assisted", "allow-all"];
+    const defaults = configurationService.getValue(ChatConfiguration.DefaultConfiguration);
+    const approval = defaults?.approvals === ChatDefaultPermissionLevel.AllowAll ? "allow-all" : defaults?.approvals;
+    return {
+        schema: {
+            type: "object",
+            properties: {
+                mode: {
+                    type: "string",
+                    title: ( localize(5049, "Agent Mode")),
+                    enum: modes,
+                    enumLabels: [( localize(5050, "Interactive")), ( localize(5051, "Plan")), ( localize(5052, "Autopilot"))],
+                    enumDescriptions: [( localize(5053, "Works with you and asks for input when needed.")), ( localize(5054, "Plans the task before making changes.")), ( localize(5055, "Continues working until the task is done."))],
+                    default: "interactive"
+                },
+                approvalMode: {
+                    type: "string",
+                    title: ( localize(5056, "Approvals")),
+                    enum: approvals,
+                    default: restricted ? "manual" : "assisted"
+                }
+            }
+        },
+        values: {
+            mode: defaults?.mode && modes.includes(defaults.mode) ? defaults.mode : "interactive",
+            approvalMode: approval && approvals.includes(approval) ? approval : restricted ? "manual" : "assisted"
+        }
+    };
+}
+
+export { createCloudSandboxSessionConfig };

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessions.contribution.d.ts

@@ -0,0 +1 @@
+

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessions.contribution.js

@@ -0,0 +1,59 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { CopilotChatSessionsProvider } from './copilotChatSessionsProvider.js';
+import './copilotChatSessionsActions.js';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { isCloudSandboxEnabled, CloudSandboxEnabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost';
+import { RemoteAgentHostsEnabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+
+let DefaultSessionsProviderContribution = class DefaultSessionsProviderContribution extends Disposable {
+    static {
+        this.ID = "sessions.defaultSessionsProvider";
+    }
+    constructor(
+        instantiationService,
+        sessionsProvidersService,
+        configurationService,
+        chatEntitlementService
+    ) {
+        super();
+        const provider = this._register(
+            instantiationService.createInstance(CopilotChatSessionsProvider, "default")
+        );
+        this._register(sessionsProvidersService.registerProvider(provider));
+        if (isWeb) {
+            const sandboxRegistration = this._register(( new MutableDisposable()));
+            const updateSandboxRegistration = () => {
+                if (!isCloudSandboxEnabled(configurationService) || chatEntitlementService.sentiment.hidden) {
+                    sandboxRegistration.clear();
+                } else if (!sandboxRegistration.value) {
+                    const store = ( new DisposableStore());
+                    sandboxRegistration.value = store;
+                    const sandboxProvider = store.add(
+                        instantiationService.createInstance(CopilotChatSessionsProvider, "sandbox")
+                    );
+                    store.add(sessionsProvidersService.registerProvider(sandboxProvider));
+                }
+            };
+            this._register(configurationService.onDidChangeConfiguration(event => {
+                if (event.affectsConfiguration(CloudSandboxEnabledSettingId) || event.affectsConfiguration(RemoteAgentHostsEnabledSettingId)) {
+                    updateSandboxRegistration();
+                }
+            }));
+            this._register(chatEntitlementService.onDidChangeSentiment(updateSandboxRegistration));
+            updateSandboxRegistration();
+        }
+    }
+};
+DefaultSessionsProviderContribution = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ISessionsProvidersService)), ( __param(2, IConfigurationService)), ( __param(3, IChatEntitlementService))], DefaultSessionsProviderContribution));
+registerWorkbenchContribution2(
+    DefaultSessionsProviderContribution.ID,
+    DefaultSessionsProviderContribution,
+    WorkbenchPhase.AfterRestored
+);

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessionsActions.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessionsActions.js

@@ -0,0 +1,83 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { SessionProviderIdContext, IsNewChatSessionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { COPILOT_PROVIDER_ID } from './copilotChatSessionsProvider.js';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { ISessionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionContext.service';
+import { CLOUD_SANDBOX_CREATION_PROVIDER_ID } from '../../remoteAgentHost/browser/cloudSandboxAgentHostContribution.js';
+import { AgentHostModePicker } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/agentHost/browser/agentHostModePicker';
+import { AgentHostPermissionPickerDelegate } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/agentHost/browser/agentHostPermissionPickerDelegate';
+import { PickerActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/agentHost/browser/agentHostSessionConfigPicker';
+import { MobilePermissionPicker } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/copilotChatSessions/browser/mobilePermissionPicker';
+import { MobileAgentHostModePicker } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/agentHost/browser/mobile/mobileAgentHostModePicker';
+import { isPhoneLayout } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/mobile/mobileLayout';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+
+const IsActiveCopilotChatSessionProvider = ( ContextKeyExpr.equals(SessionProviderIdContext.key, COPILOT_PROVIDER_ID));
+const IsNewCloudSession = ( ContextKeyExpr.and(IsNewChatSessionContext, ChatContextKeys.enabled, ( ContextKeyExpr.or(IsActiveCopilotChatSessionProvider, ( SessionProviderIdContext.isEqualTo(CLOUD_SANDBOX_CREATION_PROVIDER_ID))))));
+for (const [id, title, order] of [["sessions.sandbox.modePicker", ( localize2(5057, "Agent Mode")), 0], ["sessions.sandbox.approvalPicker", ( localize2(5058, "Approvals")), 1]]) {
+    registerAction2(class extends Action2 {
+        constructor() {
+            super({
+                id,
+                title,
+                menu: [{
+                    id: Menus.NewSessionControl,
+                    group: "navigation",
+                    order,
+                    when: IsNewCloudSession
+                }]
+            });
+        }
+        run() {}
+    });
+}
+let CopilotPickerActionViewItemContribution = class CopilotPickerActionViewItemContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.copilotPickerActionViewItems";
+    }
+    constructor(actionViewItemService, layoutService) {
+        super();
+        this._register(actionViewItemService.register(
+            Menus.NewSessionControl,
+            "sessions.sandbox.modePicker",
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                return ( new PickerActionViewItem(scopedInstantiationService.createInstance(
+                    isPhoneLayout(layoutService) ? MobileAgentHostModePicker : AgentHostModePicker,
+                    session
+                )));
+            }
+        ));
+        this._register(actionViewItemService.register(
+            Menus.NewSessionControl,
+            "sessions.sandbox.approvalPicker",
+            (_action, _options, scopedInstantiationService) => {
+                const {
+                    session
+                } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+                const delegate = scopedInstantiationService.createInstance(AgentHostPermissionPickerDelegate, session);
+                return ( new PickerActionViewItem(
+                    scopedInstantiationService.createInstance(MobilePermissionPicker, delegate),
+                    delegate,
+                    true
+                ));
+            }
+        ));
+    }
+};
+CopilotPickerActionViewItemContribution = ( __decorate([( __param(0, IActionViewItemService)), ( __param(1, IWorkbenchLayoutService))], CopilotPickerActionViewItemContribution));
+registerWorkbenchContribution2(
+    CopilotPickerActionViewItemContribution.ID,
+    CopilotPickerActionViewItemContribution,
+    WorkbenchPhase.AfterRestored
+);

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessionsChangesets.d.ts

@@ -0,0 +1,87 @@
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IChatSessionFileChange2 } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChat, ISessionChangeset, ISessionChangesetOperation, ISessionChangesetOperationTarget, ISessionFileChange, ISessionWorkspace } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+type IChangesetChat = Pick<IChat, "changes" | "checkpoints" | "isArchived">;
+interface IChangesetResolver {
+    resolve(firstCheckpointRef: string, lastCheckpointRef: string): Promise<IChatSessionFileChange2[] | undefined>;
+}
+export declare function createChangesets(workspaceObs: IObservable<ISessionWorkspace | undefined>, chatsObs: IObservable<readonly IChangesetChat[]>, instantiationService: IInstantiationService): IObservable<readonly ISessionChangeset[]>;
+/**
+ * Common base for {@link ISessionChangeset} implementations.
+ *
+ * Changesets operate at the session level and derive everything they need
+ * from the session's chats list (checkpoints, archived state, last-turn
+ * end time). Subclasses that need session-level metadata not carried on
+ * `IChat` (e.g. workspace / git repository info) take those as additional
+ * constructor parameters.
+ */
+declare abstract class AbstractChangeset implements ISessionChangeset {
+    protected readonly _chats: IObservable<readonly IChangesetChat[]>;
+    abstract readonly id: string;
+    abstract readonly label: string;
+    abstract readonly description?: string;
+    abstract readonly isEnabled: IObservable<boolean>;
+    abstract readonly isDefault: IObservable<boolean>;
+    abstract readonly isLoadingChanges: IObservable<boolean>;
+    abstract readonly changes: IObservable<readonly ISessionFileChange[]>;
+    abstract readonly originalCheckpointRef: IObservable<string | undefined>;
+    abstract readonly modifiedCheckpointRef: IObservable<string | undefined>;
+    readonly operations: IObservable<readonly ISessionChangesetOperation[]>;
+    constructor(_chats: IObservable<readonly IChangesetChat[]>);
+    invokeOperation(_operationId: string, _target?: ISessionChangesetOperationTarget): Promise<void>;
+}
+/**
+ * Diff between a branch and its base (e.g. `main...feature`). Used for
+ * PR-style review and "what changed on this branch" views. Expected to be
+ * semi-static — refresh on new commits to either ref.
+ */
+export declare class BranchChangesChangeset extends AbstractChangeset {
+    static readonly ID = "branch";
+    readonly id = "branch";
+    readonly label: string;
+    readonly description: string | undefined;
+    readonly category: string;
+    readonly isEnabled: IObservable<boolean>;
+    readonly isDefault: IObservable<boolean>;
+    readonly isLoadingChanges: IObservable<boolean>;
+    readonly changes: IObservable<readonly ISessionFileChange[]>;
+    readonly originalCheckpointRef: IObservable<string | undefined>;
+    readonly modifiedCheckpointRef: IObservable<string | undefined>;
+    constructor(workspaceObs: IObservable<ISessionWorkspace | undefined>, chatsObs: IObservable<readonly IChangesetChat[]>);
+}
+/**
+ * Aggregate of every file the session has touched.
+ */
+export declare class AllChangesChangeset extends AbstractChangeset {
+    static readonly ID = "allChanges";
+    readonly id = "allChanges";
+    readonly label: string;
+    readonly description: string;
+    readonly category: string;
+    readonly isEnabled: IObservable<boolean>;
+    readonly isDefault: IObservable<boolean>;
+    readonly isLoadingChanges: IObservable<boolean>;
+    readonly changes: IObservable<readonly ISessionFileChange[]>;
+    readonly originalCheckpointRef: IObservable<string | undefined>;
+    readonly modifiedCheckpointRef: IObservable<string | undefined>;
+    constructor(chatsObs: IObservable<readonly IChangesetChat[]>, changesetResolver: IChangesetResolver);
+}
+/**
+ * Files touched by the most recent agent turn.
+ */
+export declare class LastTurnChangesChangeset extends AbstractChangeset {
+    static readonly ID = "lastTurnChanges";
+    readonly id = "lastTurnChanges";
+    readonly label: string;
+    readonly description: string;
+    readonly category: string;
+    readonly isEnabled: IObservable<boolean>;
+    readonly isDefault: IObservable<boolean>;
+    readonly isLoadingChanges: IObservable<boolean>;
+    readonly changes: IObservable<readonly ISessionFileChange[]>;
+    readonly originalCheckpointRef: IObservable<string | undefined>;
+    readonly modifiedCheckpointRef: IObservable<string | undefined>;
+    constructor(chatsObs: IObservable<readonly IChangesetChat[]>, changesetResolver: IChangesetResolver);
+}
+export {};

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessionsChangesets.js

@@ -0,0 +1,176 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { gitHubInfoEqual, BRANCH_CHANGES_CHANGESET_ID, sessionFileChangesEqual } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { IGitHubService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/githubService.service';
+import { toPRContentUri } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/common/utils';
+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 { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/promise';
+
+let GitHubRepositoryChangesetResolver = class GitHubRepositoryChangesetResolver {
+    constructor(workspace, _gitHubService) {
+        this._gitHubService = _gitHubService;
+        this._gitHubInfoObs = derivedOpts({
+            equalsFn: gitHubInfoEqual
+        }, reader => {
+            const gitRepository = workspace.read(reader)?.folders[0].gitRepository;
+            return gitRepository?.gitHubInfo.read(reader);
+        });
+    }
+    async resolve(firstCheckpointRef, lastCheckpointRef) {
+        const gitHubInfo = this._gitHubInfoObs.get();
+        if (!gitHubInfo || !gitHubInfo.pullRequest?.number) {
+            return undefined;
+        }
+        const params = {
+            owner: gitHubInfo.owner,
+            repo: gitHubInfo.repo,
+            prNumber: gitHubInfo.pullRequest.number
+        };
+        const changes = await this._gitHubService.getChangedFiles(params.owner, params.repo, firstCheckpointRef, lastCheckpointRef);
+        return changes.map(change => {
+            const uri = toPRContentUri(change.filename, {
+                ...params,
+                commitSha: lastCheckpointRef,
+                status: change.status,
+                isBase: false
+            });
+            const originalUri = change.status !== "added" ? toPRContentUri(change.previous_filename || change.filename, {
+                ...params,
+                commitSha: firstCheckpointRef,
+                previousFileName: change.previous_filename,
+                status: change.status,
+                isBase: true
+            }) : undefined;
+            const modifiedUri = change.status !== "removed" ? uri : undefined;
+            return {
+                uri,
+                originalUri,
+                modifiedUri,
+                insertions: change.additions,
+                deletions: change.deletions
+            };
+        });
+    }
+};
+GitHubRepositoryChangesetResolver = ( __decorate([( __param(1, IGitHubService))], GitHubRepositoryChangesetResolver));
+function createChangesets(workspaceObs, chatsObs, instantiationService) {
+    const changesetResolver = instantiationService.createInstance(GitHubRepositoryChangesetResolver, workspaceObs);
+    return constObservable([( new BranchChangesChangeset(workspaceObs, chatsObs)), ( new AllChangesChangeset(chatsObs, changesetResolver)), ( new LastTurnChangesChangeset(chatsObs, changesetResolver))]);
+}
+class AbstractChangeset {
+    constructor(_chats) {
+        this._chats = _chats;
+        this.operations = constObservable([]);
+    }
+    async invokeOperation(_operationId, _target) {}
+}
+class BranchChangesChangeset extends AbstractChangeset {
+    static {
+        this.ID = BRANCH_CHANGES_CHANGESET_ID;
+    }
+    constructor(workspaceObs, chatsObs) {
+        super(chatsObs);
+        this.id = BranchChangesChangeset.ID;
+        this.label = ( localize(5059, "Branch Changes"));
+        this.category = ( localize(5060, "Changes"));
+        this.isLoadingChanges = constObservable(false);
+        this.modifiedCheckpointRef = constObservable(undefined);
+        const gitRepository = workspaceObs.get()?.folders[0].gitRepository;
+        const branchName = gitRepository?.branchName;
+        const baseBranchName = gitRepository?.baseBranchName;
+        this.description = branchName && baseBranchName ? `${branchName} → ${baseBranchName}` : branchName;
+        this.originalCheckpointRef = derived(reader => {
+            return chatsObs.read(reader)[0]?.checkpoints.read(reader)?.firstCheckpointRef;
+        });
+        const isArchivedObs = derived(reader => chatsObs.read(reader)[0]?.isArchived.read(reader) === true);
+        this.isDefault = derived(reader => !isArchivedObs.read(reader));
+        this.isEnabled = derived(reader => !isArchivedObs.read(reader));
+        this.changes = derived(reader => {
+            return chatsObs.read(reader)[0]?.changes.read(reader) ?? [];
+        });
+    }
+}
+class AllChangesChangeset extends AbstractChangeset {
+    static {
+        this.ID = "allChanges";
+    }
+    constructor(chatsObs, changesetResolver) {
+        super(chatsObs);
+        this.id = AllChangesChangeset.ID;
+        this.label = ( localize(5061, "All Changes"));
+        this.description = ( localize(5062, "Show all changes made in this session"));
+        this.category = ( localize(5063, "Checkpoints"));
+        this.originalCheckpointRef = derived(reader => {
+            return chatsObs.read(reader)[0]?.checkpoints.read(reader)?.firstCheckpointRef;
+        });
+        this.modifiedCheckpointRef = derived(reader => {
+            return chatsObs.read(reader)[0]?.checkpoints.read(reader)?.lastCheckpointRef;
+        });
+        const changesPromiseObs = derived(reader => {
+            const originalCheckpointRef = this.originalCheckpointRef.read(reader);
+            const modifiedCheckpointRef = this.modifiedCheckpointRef.read(reader);
+            if (!originalCheckpointRef || !modifiedCheckpointRef) {
+                return constObservable([]);
+            }
+            const diffPromise = changesetResolver.resolve(originalCheckpointRef, modifiedCheckpointRef);
+            return ( new ObservablePromise(diffPromise)).resolvedValue;
+        });
+        this.isLoadingChanges = derived(reader => {
+            return changesPromiseObs.read(reader).read(reader) === undefined;
+        });
+        this.changes = derivedOpts({
+            equalsFn: sessionFileChangesEqual
+        }, reader => {
+            return changesPromiseObs.read(reader).read(reader) ?? [];
+        });
+        this.isDefault = derived(reader => chatsObs.read(reader)[0]?.isArchived.read(reader) === true);
+        this.isEnabled = derived(
+            reader => this.originalCheckpointRef.read(reader) !== undefined && this.modifiedCheckpointRef.read(reader) !== undefined
+        );
+    }
+}
+class LastTurnChangesChangeset extends AbstractChangeset {
+    static {
+        this.ID = "lastTurnChanges";
+    }
+    constructor(chatsObs, changesetResolver) {
+        super(chatsObs);
+        this.id = LastTurnChangesChangeset.ID;
+        this.label = ( localize(5064, "Last Turn Changes"));
+        this.description = ( localize(5065, "Show only changes made in the last turn"));
+        this.category = ( localize(5063, "Checkpoints"));
+        this.isDefault = constObservable(false);
+        this.modifiedCheckpointRef = derived(reader => {
+            return chatsObs.read(reader)[0]?.checkpoints.read(reader)?.lastCheckpointRef;
+        });
+        this.originalCheckpointRef = derived(reader => {
+            const modifiedCheckpointRef = this.modifiedCheckpointRef.read(reader);
+            return modifiedCheckpointRef ? `${modifiedCheckpointRef}^` : undefined;
+        });
+        const changesPromiseObs = derived(reader => {
+            const originalCheckpointRef = this.originalCheckpointRef.read(reader);
+            const modifiedCheckpointRef = this.modifiedCheckpointRef.read(reader);
+            if (!originalCheckpointRef || !modifiedCheckpointRef) {
+                return constObservable([]);
+            }
+            const diffPromise = changesetResolver.resolve(originalCheckpointRef, modifiedCheckpointRef);
+            return ( new ObservablePromise(diffPromise)).resolvedValue;
+        });
+        this.isLoadingChanges = derived(reader => {
+            return changesPromiseObs.read(reader).read(reader) === undefined;
+        });
+        this.changes = derivedOpts({
+            equalsFn: sessionFileChangesEqual
+        }, reader => {
+            return changesPromiseObs.read(reader).read(reader) ?? [];
+        });
+        this.isEnabled = derived(
+            reader => this.originalCheckpointRef.read(reader) !== undefined && this.modifiedCheckpointRef.read(reader) !== undefined
+        );
+    }
+}
+
+export { AllChangesChangeset, BranchChangesChangeset, LastTurnChangesChangeset, createChangesets };