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

package/index.js

@@ -82,6 +82,26 @@ import { ChatEditingExplanationModelManager } from './vscode/src/vs/workbench/co
 import { ChatToolOutputStateCache } from './vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/chatToolOutputStateCache.js';
 import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service';
 import { TerminalSandboxService } from './vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.js';
+import { IAgentFeedbackService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/agentFeedback/browser/agentFeedbackService.service';
+import { AgentFeedbackService } from './vscode/src/vs/sessions/contrib/agentFeedback/browser/agentFeedbackService.js';
+import { ISessionsConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionsConfigurationService.service';
+import { SessionsConfigurationService } from './vscode/src/vs/sessions/contrib/chat/browser/sessionsConfigurationService.js';
+import { IAICustomizationWorkspaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService.service';
+import { SessionsAICustomizationWorkspaceService } from './vscode/src/vs/sessions/contrib/chat/browser/aiCustomizationWorkspaceService.js';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/sessionsManagementService.service';
+import { SessionsManagementService } from './vscode/src/vs/sessions/contrib/sessions/browser/sessionsManagementService.js';
+import { IAgentPluginService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service';
+import { AgentPluginService } from './vscode/src/vs/workbench/contrib/chat/common/plugins/agentPluginServiceImpl.js';
+import { PluginMarketplaceService } from './vscode/src/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.js';
+import { IPluginMarketplaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service';
+import { IAgentPluginRepositoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service';
+import { AgentPluginRepositoryService } from './vscode/src/vs/workbench/contrib/chat/browser/agentPluginRepositoryService.js';
+import { IPluginInstallService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginInstallService.service';
+import { PluginInstallService } from './vscode/src/vs/workbench/contrib/chat/browser/pluginInstallService.js';
+import { IChatAttachmentWidgetRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatAttachmentWidgetRegistry.service';
+import { ChatAttachmentWidgetRegistry } from './vscode/src/vs/workbench/contrib/chat/browser/attachments/chatAttachmentWidgetRegistry.js';
+import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
+import { ChatDebugServiceImpl } from './vscode/src/vs/workbench/contrib/chat/common/chatDebugServiceImpl.js';
 import './vscode/src/vs/workbench/contrib/chat/browser/chat.contribution.js';
 import './vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/terminal.chatAgentTools.contribution.js';
 import './vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminal.chat.contribution.js';
@@ -132,7 +152,17 @@ function getServiceOverride() {
         [IChatTipService.toString()]: new SyncDescriptor(ChatTipService, [], true),
         [IChatEditingExplanationModelManager.toString()]: new SyncDescriptor(ChatEditingExplanationModelManager, [], true),
         [IChatToolOutputStateCache.toString()]: new SyncDescriptor(ChatToolOutputStateCache, [], true),
-        [ITerminalSandboxService.toString()]: new SyncDescriptor(TerminalSandboxService, [], true)
+        [ITerminalSandboxService.toString()]: new SyncDescriptor(TerminalSandboxService, [], true),
+        [IAgentFeedbackService.toString()]: new SyncDescriptor(AgentFeedbackService, [], true),
+        [ISessionsConfigurationService.toString()]: new SyncDescriptor(SessionsConfigurationService, [], true),
+        [IAICustomizationWorkspaceService.toString()]: new SyncDescriptor(SessionsAICustomizationWorkspaceService, [], true),
+        [ISessionsManagementService.toString()]: new SyncDescriptor(SessionsManagementService, [], true),
+        [IAgentPluginService.toString()]: new SyncDescriptor(AgentPluginService, [], true),
+        [IPluginMarketplaceService.toString()]: new SyncDescriptor(PluginMarketplaceService, [], true),
+        [IAgentPluginRepositoryService.toString()]: new SyncDescriptor(AgentPluginRepositoryService, [], true),
+        [IPluginInstallService.toString()]: new SyncDescriptor(PluginInstallService, [], true),
+        [IChatAttachmentWidgetRegistry.toString()]: new SyncDescriptor(ChatAttachmentWidgetRegistry, [], true),
+        [IChatDebugService.toString()]: new SyncDescriptor(ChatDebugServiceImpl, [], true)
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-chat-service-override",
-  "version": "26.2.2",
+  "version": "27.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - chat service-override",
   "keywords": [],
@@ -15,10 +15,10 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "26.2.2",
-    "@codingame/monaco-vscode-katex-common": "26.2.2",
-    "@codingame/monaco-vscode-xterm-addons-common": "26.2.2",
-    "@codingame/monaco-vscode-xterm-common": "26.2.2"
+    "@codingame/monaco-vscode-api": "27.0.0",
+    "@codingame/monaco-vscode-katex-common": "27.0.0",
+    "@codingame/monaco-vscode-xterm-addons-common": "27.0.0",
+    "@codingame/monaco-vscode-xterm-common": "27.0.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/platform/browserElements/common/browserElements.d.ts

@@ -1,8 +1,23 @@
 import { IRectangle } from "@codingame/monaco-vscode-api/vscode/vs/platform/window/common/window";
+export interface IElementAncestor {
+    readonly tagName: string;
+    readonly id?: string;
+    readonly classNames?: string[];
+}
 export interface IElementData {
     readonly outerHTML: string;
     readonly computedStyle: string;
     readonly bounds: IRectangle;
+    readonly ancestors?: IElementAncestor[];
+    readonly attributes?: Record<string, string>;
+    readonly computedStyles?: Record<string, string>;
+    readonly dimensions?: {
+        readonly top: number;
+        readonly left: number;
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly innerText?: string;
 }
 /**
  * Locator for identifying a browser target/webview.

package/vscode/src/vs/sessions/contrib/agentFeedback/browser/agentFeedbackService.d.ts

@@ -0,0 +1,53 @@
+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 { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service";
+import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IAgentFeedbackService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/agentFeedback/browser/agentFeedbackService.service";
+export interface IAgentFeedback {
+    readonly id: string;
+    readonly text: string;
+    readonly resourceUri: URI;
+    readonly range: IRange;
+    readonly sessionResource: URI;
+}
+export interface IAgentFeedbackChangeEvent {
+    readonly sessionResource: URI;
+    readonly feedbackItems: readonly IAgentFeedback[];
+}
+export interface IAgentFeedbackNavigationBearing {
+    readonly activeIdx: number;
+    readonly totalCount: number;
+}
+export declare class AgentFeedbackService extends Disposable implements IAgentFeedbackService {
+    private readonly _chatEditingService;
+    private readonly _agentSessionsService;
+    private readonly _editorService;
+    private readonly _chatWidgetService;
+    private readonly _commandService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChangeFeedback;
+    readonly onDidChangeFeedback: Event<IAgentFeedbackChangeEvent>;
+    private readonly _onDidChangeNavigation;
+    readonly onDidChangeNavigation: Event<URI>;
+    /** sessionResource → feedback items */
+    private readonly _feedbackBySession;
+    private readonly _sessionUpdatedOrder;
+    private _sessionUpdatedSequence;
+    private readonly _navigationAnchorBySession;
+    constructor(_chatEditingService: IChatEditingService, _agentSessionsService: IAgentSessionsService, _editorService: IEditorService, _chatWidgetService: IChatWidgetService, _commandService: ICommandService);
+    addFeedback(sessionResource: URI, resourceUri: URI, range: IRange, text: string): IAgentFeedback;
+    removeFeedback(sessionResource: URI, feedbackId: string): void;
+    getFeedback(sessionResource: URI): readonly IAgentFeedback[];
+    getMostRecentSessionForResource(resourceUri: URI): URI | undefined;
+    private _sessionContainsResource;
+    revealFeedback(sessionResource: URI, feedbackId: string): Promise<void>;
+    getNextFeedback(sessionResource: URI, next: boolean): IAgentFeedback | undefined;
+    getNavigationBearing(sessionResource: URI): IAgentFeedbackNavigationBearing;
+    clearFeedback(sessionResource: URI): void;
+    addFeedbackAndSubmit(sessionResource: URI, resourceUri: URI, range: IRange, text: string): Promise<void>;
+}

package/vscode/src/vs/sessions/contrib/agentFeedback/browser/agentFeedbackService.js

@@ -0,0 +1,219 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { editingEntriesContainResource, agentSessionContainsResource } from '../../../../workbench/contrib/chat/browser/sessionResourceMatching.js';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+
+let AgentFeedbackService = class AgentFeedbackService extends Disposable {
+    constructor(
+        _chatEditingService,
+        _agentSessionsService,
+        _editorService,
+        _chatWidgetService,
+        _commandService
+    ) {
+        super();
+        this._chatEditingService = _chatEditingService;
+        this._agentSessionsService = _agentSessionsService;
+        this._editorService = _editorService;
+        this._chatWidgetService = _chatWidgetService;
+        this._commandService = _commandService;
+        this._onDidChangeFeedback = this._store.add(( new Emitter()));
+        this.onDidChangeFeedback = this._onDidChangeFeedback.event;
+        this._onDidChangeNavigation = this._store.add(( new Emitter()));
+        this.onDidChangeNavigation = this._onDidChangeNavigation.event;
+        this._feedbackBySession = ( new Map());
+        this._sessionUpdatedOrder = ( new Map());
+        this._sessionUpdatedSequence = 0;
+        this._navigationAnchorBySession = ( new Map());
+    }
+    addFeedback(sessionResource, resourceUri, range, text) {
+        const key = ( sessionResource.toString());
+        let feedbackItems = this._feedbackBySession.get(key);
+        if (!feedbackItems) {
+            feedbackItems = [];
+            this._feedbackBySession.set(key, feedbackItems);
+        }
+        const feedback = {
+            id: generateUuid(),
+            text,
+            resourceUri,
+            range,
+            sessionResource
+        };
+        const resourceStr = ( resourceUri.toString());
+        const hasExistingForFile = ( feedbackItems.some(f => ( f.resourceUri.toString()) === resourceStr));
+        if (!hasExistingForFile) {
+            feedbackItems.push(feedback);
+        } else {
+            let insertIdx = feedbackItems.length;
+            for (let i = 0; i < feedbackItems.length; i++) {
+                if (( feedbackItems[i].resourceUri.toString()) === resourceStr && feedbackItems[i].range.startLineNumber > range.startLineNumber) {
+                    insertIdx = i;
+                    break;
+                }
+                if (( feedbackItems[i].resourceUri.toString()) === resourceStr) {
+                    insertIdx = i + 1;
+                }
+            }
+            feedbackItems.splice(insertIdx, 0, feedback);
+        }
+        this._sessionUpdatedOrder.set(key, ++this._sessionUpdatedSequence);
+        this._onDidChangeNavigation.fire(sessionResource);
+        this._onDidChangeFeedback.fire({
+            sessionResource,
+            feedbackItems
+        });
+        return feedback;
+    }
+    removeFeedback(sessionResource, feedbackId) {
+        const key = ( sessionResource.toString());
+        const feedbackItems = this._feedbackBySession.get(key);
+        if (!feedbackItems) {
+            return;
+        }
+        const idx = feedbackItems.findIndex(f => f.id === feedbackId);
+        if (idx >= 0) {
+            feedbackItems.splice(idx, 1);
+            if (this._navigationAnchorBySession.get(key) === feedbackId) {
+                this._navigationAnchorBySession.delete(key);
+                this._onDidChangeNavigation.fire(sessionResource);
+            }
+            if (feedbackItems.length > 0) {
+                this._sessionUpdatedOrder.set(key, ++this._sessionUpdatedSequence);
+            } else {
+                this._sessionUpdatedOrder.delete(key);
+            }
+            this._onDidChangeFeedback.fire({
+                sessionResource,
+                feedbackItems
+            });
+        }
+    }
+    getFeedback(sessionResource) {
+        return this._feedbackBySession.get(( sessionResource.toString())) ?? [];
+    }
+    getMostRecentSessionForResource(resourceUri) {
+        let bestSession;
+        let bestSequence = -1;
+        for (const [, feedbackItems] of this._feedbackBySession) {
+            if (!feedbackItems.length) {
+                continue;
+            }
+            const candidate = feedbackItems[0].sessionResource;
+            if (!this._sessionContainsResource(candidate, resourceUri, feedbackItems)) {
+                continue;
+            }
+            const sequence = this._sessionUpdatedOrder.get(( candidate.toString())) ?? 0;
+            if (sequence > bestSequence) {
+                bestSession = candidate;
+                bestSequence = sequence;
+            }
+        }
+        return bestSession;
+    }
+    _sessionContainsResource(sessionResource, resourceUri, feedbackItems) {
+        if (( feedbackItems.some(item => isEqual(item.resourceUri, resourceUri)))) {
+            return true;
+        }
+        for (const editingSession of this._chatEditingService.editingSessionsObs.get()) {
+            if (!isEqual(editingSession.chatSessionResource, sessionResource)) {
+                continue;
+            }
+            if (editingEntriesContainResource(editingSession.entries.get(), resourceUri)) {
+                return true;
+            }
+        }
+        for (const session of this._agentSessionsService.model.sessions) {
+            if (!isEqual(session.resource, sessionResource)) {
+                continue;
+            }
+            if (agentSessionContainsResource(session, resourceUri)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async revealFeedback(sessionResource, feedbackId) {
+        const key = ( sessionResource.toString());
+        const feedbackItems = this._feedbackBySession.get(key);
+        const feedback = feedbackItems?.find(f => f.id === feedbackId);
+        if (!feedback) {
+            return;
+        }
+        await this._editorService.openEditor({
+            resource: feedback.resourceUri,
+            options: {
+                preserveFocus: false,
+                revealIfVisible: true
+            }
+        });
+        setTimeout(() => {
+            this._navigationAnchorBySession.set(key, feedbackId);
+            this._onDidChangeNavigation.fire(sessionResource);
+        }, 50);
+    }
+    getNextFeedback(sessionResource, next) {
+        const key = ( sessionResource.toString());
+        const feedbackItems = this._feedbackBySession.get(key);
+        if (!feedbackItems?.length) {
+            this._navigationAnchorBySession.delete(key);
+            return undefined;
+        }
+        const anchorId = this._navigationAnchorBySession.get(key);
+        let anchorIndex = anchorId ? feedbackItems.findIndex(item => item.id === anchorId) : -1;
+        if (anchorIndex < 0 && !next) {
+            anchorIndex = 0;
+        }
+        const nextIndex = next ? (anchorIndex + 1) % feedbackItems.length : (anchorIndex - 1 + feedbackItems.length) % feedbackItems.length;
+        const feedback = feedbackItems[nextIndex];
+        this._navigationAnchorBySession.set(key, feedback.id);
+        this._onDidChangeNavigation.fire(sessionResource);
+        return feedback;
+    }
+    getNavigationBearing(sessionResource) {
+        const key = ( sessionResource.toString());
+        const feedbackItems = this._feedbackBySession.get(key) ?? [];
+        const anchorId = this._navigationAnchorBySession.get(key);
+        const activeIdx = anchorId ? feedbackItems.findIndex(item => item.id === anchorId) : -1;
+        return {
+            activeIdx,
+            totalCount: feedbackItems.length
+        };
+    }
+    clearFeedback(sessionResource) {
+        const key = ( sessionResource.toString());
+        this._feedbackBySession.delete(key);
+        this._sessionUpdatedOrder.delete(key);
+        this._navigationAnchorBySession.delete(key);
+        this._onDidChangeNavigation.fire(sessionResource);
+        this._onDidChangeFeedback.fire({
+            sessionResource,
+            feedbackItems: []
+        });
+    }
+    async addFeedbackAndSubmit(sessionResource, resourceUri, range, text) {
+        this.addFeedback(sessionResource, resourceUri, range, text);
+        const widget = this._chatWidgetService.getWidgetBySessionResource(sessionResource);
+        if (widget) {
+            const attachmentId = "agentFeedback:" + ( sessionResource.toString());
+            const hasAttachment = () => ( widget.attachmentModel.attachments.some(a => a.id === attachmentId));
+            if (!hasAttachment()) {
+                await Event.toPromise(Event.filter(widget.attachmentModel.onDidChange, () => hasAttachment()));
+            }
+        } else {
+            await ( new Promise(resolve => setTimeout(resolve, 100)));
+        }
+        await this._commandService.executeCommand("agentFeedbackEditor.action.submit");
+    }
+};
+AgentFeedbackService = ( __decorate([( __param(0, IChatEditingService)), ( __param(1, IAgentSessionsService)), ( __param(2, IEditorService)), ( __param(3, IChatWidgetService)), ( __param(4, ICommandService))], AgentFeedbackService));
+
+export { AgentFeedbackService };

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

@@ -0,0 +1,39 @@
+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 { AICustomizationManagementSection, IStorageSourceFilter } from "../../../../workbench/contrib/chat/common/aiCustomizationWorkspaceService.js";
+import { IAICustomizationWorkspaceService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService.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 { 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";
+/**
+ * Agent Sessions override of IAICustomizationWorkspaceService.
+ * Delegates to ISessionsManagementService to provide the active session's
+ * worktree/repository as the project root, and supports worktree commit.
+ */
+export declare class SessionsAICustomizationWorkspaceService implements IAICustomizationWorkspaceService {
+    private readonly sessionsService;
+    private readonly instantiationService;
+    readonly _serviceBrand: undefined;
+    readonly activeProjectRoot: IObservable<URI | undefined>;
+    /**
+     * CLI-accessible user directories for customization file filtering and creation.
+     */
+    private readonly _cliUserRoots;
+    /**
+     * Pre-built filter for types that should only show CLI-accessible user roots.
+     */
+    private readonly _cliUserFilter;
+    constructor(sessionsService: ISessionsManagementService, instantiationService: IInstantiationService, pathService: IPathService);
+    getActiveProjectRoot(): URI | undefined;
+    readonly managementSections: readonly AICustomizationManagementSection[];
+    private static readonly _hooksFilter;
+    private static readonly _allUserRootsFilter;
+    getStorageSourceFilter(type: PromptsType): IStorageSourceFilter;
+    /**
+     * Returns the CLI-accessible user directories (~/.copilot, ~/.claude, ~/.agents).
+     */
+    readonly isSessionsWindow = true;
+    commitFiles(projectRoot: URI, fileUris: URI[]): Promise<void>;
+    generateCustomization(type: PromptsType): Promise<void>;
+}

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

@@ -0,0 +1,83 @@
+
+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 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { AICustomizationManagementSection } from '../../../../workbench/contrib/chat/common/aiCustomizationWorkspaceService.js';
+import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+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 { 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, pathService) {
+        this.sessionsService = sessionsService;
+        this.instantiationService = instantiationService;
+        this.managementSections = [
+            AICustomizationManagementSection.Agents,
+            AICustomizationManagementSection.Skills,
+            AICustomizationManagementSection.Instructions,
+            AICustomizationManagementSection.Prompts,
+            AICustomizationManagementSection.Hooks
+        ];
+        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],
+            includedUserFileRoots: this._cliUserRoots
+        };
+        this.activeProjectRoot = derived(reader => {
+            const session = this.sessionsService.activeSession.read(reader);
+            return session?.worktree ?? session?.repository;
+        });
+    }
+    getActiveProjectRoot() {
+        const session = this.sessionsService.getActiveSession();
+        return session?.worktree ?? session?.repository;
+    }
+    static {
+        this._hooksFilter = {
+            sources: [PromptsStorage.local]
+        };
+    }
+    static {
+        this._allUserRootsFilter = {
+            sources: [PromptsStorage.local, PromptsStorage.user]
+        };
+    }
+    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) {
+            await this.sessionsService.commitWorktreeFiles(session, fileUris);
+        }
+    }
+    async generateCustomization(type) {
+        const creator = this.instantiationService.createInstance(CustomizationCreatorService);
+        await creator.createWithAI(type);
+    }
+};
+SessionsAICustomizationWorkspaceService = SessionsAICustomizationWorkspaceService_1 = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, IInstantiationService)), ( __param(2, IPathService))], 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;
+}