@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

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

@@ -0,0 +1,251 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { joinPath, relativePath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { AICustomizationManagementSection, applyStorageSourceFilter } from '../../../../workbench/contrib/chat/common/aiCustomizationWorkspaceService.js';
+import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/sessionsManagementService.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { CustomizationCreatorService } from '../../../../workbench/contrib/chat/browser/aiCustomization/customizationCreatorService.js';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+var SessionsAICustomizationWorkspaceService_1;
+let SessionsAICustomizationWorkspaceService = class SessionsAICustomizationWorkspaceService {
+    static {
+        SessionsAICustomizationWorkspaceService_1 = this;
+    }
+    constructor(
+        sessionsService,
+        instantiationService,
+        promptsService,
+        pathService,
+        commandService,
+        logService,
+        fileService,
+        notificationService
+    ) {
+        this.sessionsService = sessionsService;
+        this.instantiationService = instantiationService;
+        this.promptsService = promptsService;
+        this.commandService = commandService;
+        this.logService = logService;
+        this.fileService = fileService;
+        this.notificationService = notificationService;
+        this.managementSections = [
+            AICustomizationManagementSection.Agents,
+            AICustomizationManagementSection.Skills,
+            AICustomizationManagementSection.Instructions,
+            AICustomizationManagementSection.Prompts,
+            AICustomizationManagementSection.Hooks,
+            AICustomizationManagementSection.McpServers,
+            AICustomizationManagementSection.Plugins
+        ];
+        this.isSessionsWindow = true;
+        const userHome = pathService.userHome({
+            preferLocal: true
+        });
+        this._cliUserRoots = [
+            joinPath(userHome, ".copilot"),
+            joinPath(userHome, ".claude"),
+            joinPath(userHome, ".agents")
+        ];
+        this._cliUserFilter = {
+            sources: [PromptsStorage.local, PromptsStorage.user, PromptsStorage.plugin],
+            includedUserFileRoots: this._cliUserRoots
+        };
+        this._overrideRoot = observableValue(this, undefined);
+        this.activeProjectRoot = derived(reader => {
+            const override = this._overrideRoot.read(reader);
+            if (override) {
+                return override;
+            }
+            const session = this.sessionsService.activeSession.read(reader);
+            return session?.worktree ?? session?.repository;
+        });
+        this.hasOverrideProjectRoot = derived(reader => {
+            return this._overrideRoot.read(reader) !== undefined;
+        });
+    }
+    getActiveProjectRoot() {
+        const override = this._overrideRoot.get();
+        if (override) {
+            return override;
+        }
+        const session = this.sessionsService.getActiveSession();
+        return session?.worktree ?? session?.repository;
+    }
+    setOverrideProjectRoot(root) {
+        this._overrideRoot.set(root, undefined);
+    }
+    clearOverrideProjectRoot() {
+        this._overrideRoot.set(undefined, undefined);
+    }
+    static {
+        this._hooksFilter = {
+            sources: [PromptsStorage.local, PromptsStorage.plugin]
+        };
+    }
+    static {
+        this._allUserRootsFilter = {
+            sources: [PromptsStorage.local, PromptsStorage.user, PromptsStorage.plugin]
+        };
+    }
+    getStorageSourceFilter(type) {
+        if (type === PromptsType.hook) {
+            return SessionsAICustomizationWorkspaceService_1._hooksFilter;
+        }
+        if (type === PromptsType.prompt) {
+            return SessionsAICustomizationWorkspaceService_1._allUserRootsFilter;
+        }
+        return this._cliUserFilter;
+    }
+    async commitFiles(_projectRoot, fileUris) {
+        const session = this.sessionsService.getActiveSession();
+        if (!session?.repository) {
+            return;
+        }
+        for (const fileUri of fileUris) {
+            await this.commitFileToRepos(fileUri, session.repository, session.worktree);
+        }
+    }
+    async deleteFiles(_projectRoot, fileUris) {
+        const session = this.sessionsService.getActiveSession();
+        if (!session?.repository) {
+            return;
+        }
+        for (const fileUri of fileUris) {
+            await this.commitDeletionToRepos(fileUri, session.repository, session.worktree);
+        }
+    }
+    getRelativePath(fileUri, repositoryUri, worktreeUri) {
+        if (worktreeUri) {
+            const rel = relativePath(worktreeUri, fileUri);
+            if (rel) {
+                return rel;
+            }
+        }
+        return relativePath(repositoryUri, fileUri);
+    }
+    async commitFileToRepos(fileUri, repositoryUri, worktreeUri) {
+        const relPath = this.getRelativePath(fileUri, repositoryUri, worktreeUri);
+        if (!relPath) {
+            return;
+        }
+        const repoFileUri = URI.joinPath(repositoryUri, relPath);
+        try {
+            if (( repoFileUri.toString()) !== ( fileUri.toString())) {
+                const content = await this.fileService.readFile(fileUri);
+                await this.fileService.writeFile(repoFileUri, content.value);
+            }
+            await this.commandService.executeCommand("github.copilot.cli.sessions.commitToRepository", {
+                repositoryUri,
+                fileUri: repoFileUri
+            });
+        } catch (error) {
+            this.logService.error(
+                "[SessionsAICustomizationWorkspaceService] Failed to commit to repository:",
+                error
+            );
+            if (worktreeUri) {
+                this.notificationService.notify({
+                    severity: Severity.Warning,
+                    message: ( localize(
+                        2517,
+                        "Your customization was saved to this session's worktree, but we couldn't apply it to the default branch. You may need to apply it manually."
+                    ))
+                });
+            }
+        }
+        if (worktreeUri) {
+            const worktreeFileUri = URI.joinPath(worktreeUri, relPath);
+            try {
+                if (( worktreeFileUri.toString()) !== ( fileUri.toString())) {
+                    const content = await this.fileService.readFile(fileUri);
+                    await this.fileService.writeFile(worktreeFileUri, content.value);
+                }
+                await this.commandService.executeCommand("github.copilot.cli.sessions.commitToWorktree", {
+                    worktreeUri,
+                    fileUri: worktreeFileUri
+                });
+            } catch (error) {
+                this.logService.error(
+                    "[SessionsAICustomizationWorkspaceService] Failed to commit to worktree:",
+                    error
+                );
+            }
+        }
+    }
+    async commitDeletionToRepos(fileUri, repositoryUri, worktreeUri) {
+        const relPath = this.getRelativePath(fileUri, repositoryUri, worktreeUri);
+        if (!relPath) {
+            return;
+        }
+        const repoFileUri = URI.joinPath(repositoryUri, relPath);
+        try {
+            if (await this.fileService.exists(repoFileUri)) {
+                await this.fileService.del(repoFileUri, {
+                    useTrash: true,
+                    recursive: true
+                });
+            }
+            await this.commandService.executeCommand("github.copilot.cli.sessions.commitToRepository", {
+                repositoryUri,
+                fileUri: repoFileUri
+            });
+        } catch (error) {
+            this.logService.error(
+                "[SessionsAICustomizationWorkspaceService] Failed to commit deletion to repository:",
+                error
+            );
+            if (worktreeUri) {
+                this.notificationService.notify({
+                    severity: Severity.Warning,
+                    message: ( localize(
+                        2518,
+                        "Your customization was removed from this session's worktree, but we couldn't apply the change to the default branch. You may need to remove it manually."
+                    ))
+                });
+            }
+        }
+        if (worktreeUri) {
+            const worktreeFileUri = URI.joinPath(worktreeUri, relPath);
+            try {
+                await this.commandService.executeCommand("github.copilot.cli.sessions.commitToWorktree", {
+                    worktreeUri,
+                    fileUri: worktreeFileUri
+                });
+            } catch (error) {
+                this.logService.error(
+                    "[SessionsAICustomizationWorkspaceService] Failed to commit deletion to worktree:",
+                    error
+                );
+            }
+        }
+    }
+    async generateCustomization(type) {
+        const creator = this.instantiationService.createInstance(CustomizationCreatorService);
+        await creator.createWithAI(type);
+    }
+    async getFilteredPromptSlashCommands(token) {
+        const allCommands = await this.promptsService.getPromptSlashCommands(token);
+        return allCommands.filter(cmd => {
+            const filter = this.getStorageSourceFilter(cmd.promptPath.type);
+            return applyStorageSourceFilter([cmd.promptPath], filter).length > 0;
+        });
+    }
+};
+SessionsAICustomizationWorkspaceService = SessionsAICustomizationWorkspaceService_1 = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, IInstantiationService)), ( __param(2, IPromptsService)), ( __param(3, IPathService)), ( __param(4, ICommandService)), ( __param(5, ILogService)), ( __param(6, IFileService)), ( __param(7, INotificationService))], SessionsAICustomizationWorkspaceService));
+
+export { SessionsAICustomizationWorkspaceService };

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

@@ -0,0 +1,123 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IChatSessionProviderOptionGroup, IChatSessionProviderOptionItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IsolationMode } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionTargetPicker";
+import { AgentSessionProviders } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IChatRequestVariableEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries";
+export type NewSessionChangeType = "repoUri" | "isolationMode" | "branch" | "options" | "disabled";
+/**
+ * Represents a resolved option group with its current selected value.
+ */
+export interface ISessionOptionGroup {
+    readonly group: IChatSessionProviderOptionGroup;
+    readonly value: IChatSessionProviderOptionItem | undefined;
+}
+/**
+ * A new session represents a session being configured before the first
+ * request is sent. It holds the user's selections (repoUri, isolationMode)
+ * and fires a single event when any property changes.
+ */
+export interface INewSession extends IDisposable {
+    readonly resource: URI;
+    readonly target: AgentSessionProviders;
+    readonly repoUri: URI | undefined;
+    readonly isolationMode: IsolationMode;
+    readonly branch: string | undefined;
+    readonly modelId: string | undefined;
+    readonly query: string | undefined;
+    readonly attachedContext: IChatRequestVariableEntry[] | undefined;
+    readonly selectedOptions: ReadonlyMap<string, IChatSessionProviderOptionItem>;
+    readonly disabled: boolean;
+    readonly onDidChange: Event<NewSessionChangeType>;
+    setRepoUri(uri: URI): void;
+    setIsolationMode(mode: IsolationMode): void;
+    setBranch(branch: string | undefined): void;
+    setModelId(modelId: string | undefined): void;
+    setQuery(query: string): void;
+    setAttachedContext(context: IChatRequestVariableEntry[] | undefined): void;
+    setOption(optionId: string, value: IChatSessionProviderOptionItem | string): void;
+}
+/**
+ * Local new session for Background agent sessions.
+ * Fires `onDidChange` for both `repoUri` and `isolationMode` changes.
+ * Notifies the extension service with session options for each property change.
+ */
+export declare class LocalNewSession extends Disposable implements INewSession {
+    readonly resource: URI;
+    private readonly chatSessionsService;
+    private readonly logService;
+    private _repoUri;
+    private _isolationMode;
+    private _branch;
+    private _modelId;
+    private _query;
+    private _attachedContext;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<NewSessionChangeType>;
+    readonly target = AgentSessionProviders.Background;
+    readonly selectedOptions: Map<string, IChatSessionProviderOptionItem>;
+    get repoUri(): URI | undefined;
+    get isolationMode(): IsolationMode;
+    get branch(): string | undefined;
+    get modelId(): string | undefined;
+    get query(): string | undefined;
+    get attachedContext(): IChatRequestVariableEntry[] | undefined;
+    get disabled(): boolean;
+    constructor(resource: URI, defaultRepoUri: URI | undefined, chatSessionsService: IChatSessionsService, logService: ILogService);
+    setRepoUri(uri: URI): void;
+    setIsolationMode(mode: IsolationMode): void;
+    setBranch(branch: string | undefined): void;
+    setModelId(modelId: string | undefined): void;
+    setQuery(query: string): void;
+    setAttachedContext(context: IChatRequestVariableEntry[] | undefined): void;
+    setOption(optionId: string, value: IChatSessionProviderOptionItem | string): void;
+}
+/**
+ * Remote new session for Cloud agent sessions.
+ * Manages extension-driven option groups (models, etc.) and their values.
+ * Fires events for option group changes.
+ */
+export declare class RemoteNewSession extends Disposable implements INewSession {
+    readonly resource: URI;
+    readonly target: AgentSessionProviders;
+    private readonly chatSessionsService;
+    private readonly contextKeyService;
+    private readonly logService;
+    private _repoUri;
+    private _modelId;
+    private _query;
+    private _attachedContext;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<NewSessionChangeType>;
+    private readonly _onDidChangeOptionGroups;
+    readonly onDidChangeOptionGroups: Event<void>;
+    readonly selectedOptions: Map<string, IChatSessionProviderOptionItem>;
+    get repoUri(): URI | undefined;
+    get isolationMode(): IsolationMode;
+    get branch(): string | undefined;
+    get modelId(): string | undefined;
+    get query(): string | undefined;
+    get attachedContext(): IChatRequestVariableEntry[] | undefined;
+    get disabled(): boolean;
+    private readonly _whenClauseKeys;
+    constructor(resource: URI, target: AgentSessionProviders, chatSessionsService: IChatSessionsService, contextKeyService: IContextKeyService, logService: ILogService);
+    setRepoUri(uri: URI): void;
+    setIsolationMode(_mode: IsolationMode): void;
+    setBranch(_branch: string | undefined): void;
+    setModelId(modelId: string | undefined): void;
+    setQuery(query: string): void;
+    setAttachedContext(context: IChatRequestVariableEntry[] | undefined): void;
+    setOption(optionId: string, value: IChatSessionProviderOptionItem | string): void;
+    getModelOptionGroup(): ISessionOptionGroup | undefined;
+    getOtherOptionGroups(): ISessionOptionGroup[];
+    getOptionValue(groupId: string): IChatSessionProviderOptionItem | undefined;
+    setOptionValue(groupId: string, value: IChatSessionProviderOptionItem): void;
+    private _getOptionGroups;
+    private _isOptionGroupVisible;
+    private _updateWhenClauseKeys;
+    private _getValueForGroup;
+}

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

@@ -0,0 +1,278 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+
+const REPOSITORY_OPTION_ID = "repository";
+const BRANCH_OPTION_ID = "branch";
+const ISOLATION_OPTION_ID = "isolation";
+let LocalNewSession = class LocalNewSession extends Disposable {
+    get repoUri() {
+        return this._repoUri;
+    }
+    get isolationMode() {
+        return this._isolationMode;
+    }
+    get branch() {
+        return this._branch;
+    }
+    get modelId() {
+        return this._modelId;
+    }
+    get query() {
+        return this._query;
+    }
+    get attachedContext() {
+        return this._attachedContext;
+    }
+    get disabled() {
+        if (!this._repoUri) {
+            return true;
+        }
+        if (this._isolationMode === "worktree" && !this._branch) {
+            return true;
+        }
+        return false;
+    }
+    constructor(resource, defaultRepoUri, chatSessionsService, logService) {
+        super();
+        this.resource = resource;
+        this.chatSessionsService = chatSessionsService;
+        this.logService = logService;
+        this._isolationMode = "worktree";
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.target = AgentSessionProviders.Background;
+        this.selectedOptions = ( new Map());
+        if (defaultRepoUri) {
+            this._repoUri = defaultRepoUri;
+            this.setOption(REPOSITORY_OPTION_ID, defaultRepoUri.fsPath);
+        }
+    }
+    setRepoUri(uri) {
+        this._repoUri = uri;
+        this._isolationMode = "workspace";
+        this._branch = undefined;
+        this._onDidChange.fire("repoUri");
+        this._onDidChange.fire("disabled");
+        this.setOption(REPOSITORY_OPTION_ID, uri.fsPath);
+    }
+    setIsolationMode(mode) {
+        if (this._isolationMode !== mode) {
+            this._isolationMode = mode;
+            this._onDidChange.fire("isolationMode");
+            this._onDidChange.fire("disabled");
+            this.setOption(ISOLATION_OPTION_ID, mode);
+        }
+    }
+    setBranch(branch) {
+        if (this._branch !== branch) {
+            this._branch = branch;
+            this._onDidChange.fire("branch");
+            this._onDidChange.fire("disabled");
+            this.setOption(BRANCH_OPTION_ID, branch ?? "");
+        }
+    }
+    setModelId(modelId) {
+        this._modelId = modelId;
+    }
+    setQuery(query) {
+        this._query = query;
+    }
+    setAttachedContext(context) {
+        this._attachedContext = context;
+    }
+    setOption(optionId, value) {
+        if (typeof value === "string") {
+            this.selectedOptions.set(optionId, {
+                id: value,
+                name: value
+            });
+        } else {
+            this.selectedOptions.set(optionId, value);
+        }
+        this.chatSessionsService.notifySessionOptionsChange(this.resource, [{
+            optionId,
+            value
+        }]).catch(
+            err => this.logService.error(`Failed to notify session option ${optionId} change:`, err)
+        );
+    }
+};
+LocalNewSession = ( __decorate([( __param(2, IChatSessionsService)), ( __param(3, ILogService))], LocalNewSession));
+let RemoteNewSession = class RemoteNewSession extends Disposable {
+    get repoUri() {
+        return this._repoUri;
+    }
+    get isolationMode() {
+        return "worktree";
+    }
+    get branch() {
+        return undefined;
+    }
+    get modelId() {
+        return this._modelId;
+    }
+    get query() {
+        return this._query;
+    }
+    get attachedContext() {
+        return this._attachedContext;
+    }
+    get disabled() {
+        return !this._repoUri && !( this.selectedOptions.has("repositories"));
+    }
+    constructor(resource, target, chatSessionsService, contextKeyService, logService) {
+        super();
+        this.resource = resource;
+        this.target = target;
+        this.chatSessionsService = chatSessionsService;
+        this.contextKeyService = contextKeyService;
+        this.logService = logService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._onDidChangeOptionGroups = this._register(( new Emitter()));
+        this.onDidChangeOptionGroups = this._onDidChangeOptionGroups.event;
+        this.selectedOptions = ( new Map());
+        this._whenClauseKeys = ( new Set());
+        this._updateWhenClauseKeys();
+        this._register(this.chatSessionsService.onDidChangeOptionGroups(() => {
+            this._updateWhenClauseKeys();
+            this._onDidChangeOptionGroups.fire();
+            this._onDidChange.fire("options");
+        }));
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            if (this._whenClauseKeys.size > 0 && e.affectsSome(this._whenClauseKeys)) {
+                this._onDidChangeOptionGroups.fire();
+            }
+        }));
+    }
+    setRepoUri(uri) {
+        this._repoUri = uri;
+        this._onDidChange.fire("repoUri");
+        this._onDidChange.fire("disabled");
+        const id = uri.path.substring(1);
+        this.setOption("repositories", {
+            id,
+            name: id
+        });
+    }
+    setIsolationMode(_mode) {}
+    setBranch(_branch) {}
+    setModelId(modelId) {
+        this._modelId = modelId;
+    }
+    setQuery(query) {
+        this._query = query;
+    }
+    setAttachedContext(context) {
+        this._attachedContext = context;
+    }
+    setOption(optionId, value) {
+        if (typeof value !== "string") {
+            this.selectedOptions.set(optionId, value);
+        }
+        this._onDidChange.fire("options");
+        this._onDidChange.fire("disabled");
+        this.chatSessionsService.notifySessionOptionsChange(this.resource, [{
+            optionId,
+            value
+        }]).catch(
+            err => this.logService.error(`Failed to notify extension of ${optionId} change:`, err)
+        );
+    }
+    getModelOptionGroup() {
+        const groups = this._getOptionGroups();
+        if (!groups) {
+            return undefined;
+        }
+        const group = groups.find(g => isModelOptionGroup(g));
+        if (!group) {
+            return undefined;
+        }
+        return {
+            group,
+            value: this._getValueForGroup(group)
+        };
+    }
+    getOtherOptionGroups() {
+        const groups = this._getOptionGroups();
+        if (!groups) {
+            return [];
+        }
+        return ( groups.filter(
+            g => !isModelOptionGroup(g) && !isRepositoriesOptionGroup(g) && this._isOptionGroupVisible(g)
+        ).map(g => ({
+            group: g,
+            value: this._getValueForGroup(g)
+        })));
+    }
+    getOptionValue(groupId) {
+        return this.selectedOptions.get(groupId);
+    }
+    setOptionValue(groupId, value) {
+        this.setOption(groupId, value);
+    }
+    _getOptionGroups() {
+        return this.chatSessionsService.getOptionGroupsForSessionType(this.target);
+    }
+    _isOptionGroupVisible(group) {
+        if (!group.when) {
+            return true;
+        }
+        const expr = ContextKeyExpr.deserialize(group.when);
+        return !expr || this.contextKeyService.contextMatchesRules(expr);
+    }
+    _updateWhenClauseKeys() {
+        this._whenClauseKeys.clear();
+        const groups = this._getOptionGroups();
+        if (!groups) {
+            return;
+        }
+        for (const group of groups) {
+            if (group.when) {
+                const expr = ContextKeyExpr.deserialize(group.when);
+                if (expr) {
+                    for (const key of ( expr.keys())) {
+                        this._whenClauseKeys.add(key);
+                    }
+                }
+            }
+        }
+    }
+    _getValueForGroup(group) {
+        const selected = this.selectedOptions.get(group.id);
+        if (selected) {
+            return selected;
+        }
+        const sessionOption = this.chatSessionsService.getSessionOption(this.resource, group.id);
+        if (sessionOption && typeof sessionOption !== "string") {
+            return sessionOption;
+        }
+        if (typeof sessionOption === "string") {
+            const item = group.items.find(i => i.id === sessionOption.trim());
+            if (item) {
+                return item;
+            }
+        }
+        return group.items.find(i => i.default === true) ?? group.items[0];
+    }
+};
+RemoteNewSession = ( __decorate([( __param(2, IChatSessionsService)), ( __param(3, IContextKeyService)), ( __param(4, ILogService))], RemoteNewSession));
+function isModelOptionGroup(group) {
+    if (group.id === "models") {
+        return true;
+    }
+    const nameLower = group.name.toLowerCase();
+    return nameLower === "model" || nameLower === "models";
+}
+function isRepositoriesOptionGroup(group) {
+    return group.id === "repositories";
+}
+
+export { LocalNewSession, RemoteNewSession };