@codingame/monaco-vscode-api 31.0.1 → 32.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions/chatSessions.contribution.d.ts

@@ -4,15 +4,17 @@ import { Disposable, IDisposable } from "../../../../../base/common/lifecycle.js
 import { URI } from "../../../../../base/common/uri.js";
 import { IMenuService } from "../../../../../platform/actions/common/actions.service.js";
 import { IContextKeyService } from "../../../../../platform/contextkey/common/contextkey.service.js";
+import { ServicesAccessor } from "../../../../../platform/instantiation/common/instantiation.js";
 import { ILabelService } from "../../../../../platform/label/common/label.service.js";
 import { ILogService } from "../../../../../platform/log/common/log.service.js";
 import { IThemeService } from "../../../../../platform/theme/common/themeService.service.js";
 import { IExtensionService } from "../../../../services/extensions/common/extensions.service.js";
 import { IChatAgentAttachmentCapabilities } from "../../common/participants/chatAgents.js";
 import { IChatAgentService } from "../../common/participants/chatAgents.service.js";
-import { ChatSessionStatus, IChatNewSessionRequest, IChatSession, IChatSessionCommitEvent, IChatSessionContentProvider, IChatSessionCustomizationItemGroup, IChatSessionCustomizationsProvider, IChatSessionItem, IChatSessionItemController, IChatSessionItemsDelta, IChatSessionOptionsChangeEvent, IChatSessionProviderOptionGroup, IChatSessionProviderOptionItem, IChatSessionRequestHistoryItem, IChatSessionsExtensionPoint, ReadonlyChatSessionOptionsMap, ResolvedChatSessionsExtensionPoint } from "../../common/chatSessionsService.js";
+import { ChatSessionStatus, IChatNewSessionRequest, IChatSession, IChatSessionCommitEvent, IChatSessionContentProvider, IChatSessionCustomizationItemGroup, IChatSessionCustomizationsProvider, IChatSessionItem, IChatSessionItemController, IChatSessionItemsDelta, IChatSessionOptionsChangeEvent, IChatSessionProviderOptionGroup, IChatSessionProviderOptionItem, IChatSessionRequestHistoryItem, IChatSessionsExtensionPoint, IChatInputCompletionsParams, IChatInputCompletionsResult, ReadonlyChatSessionOptionsMap, ResolvedChatSessionsExtensionPoint } from "../../common/chatSessionsService.js";
 import { IChatSessionsService } from "../../common/chatSessionsService.service.js";
 import { ResponseModelState } from "../../common/chatService/chatService.js";
+import { IChatRequestVariableEntry } from "../../common/attachments/chatVariableEntries.js";
 import { Target } from "../../common/promptSyntax/promptTypes.js";
 import { IChatModel } from "../../common/model/chatModel.js";
 export declare class ChatSessionsService extends Disposable implements IChatSessionsService {
@@ -67,6 +69,7 @@ export declare class ChatSessionsService extends Disposable implements IChatSess
         chatSessionType: string;
         count: number;
     }[];
+    resolveChatSessionItem(chatSessionType: string, resource: URI, token: CancellationToken): Promise<IChatSessionItem | undefined>;
     private updateInProgressStatus;
     private registerContribution;
     private _isContributionAvailable;
@@ -97,6 +100,8 @@ export declare class ChatSessionsService extends Disposable implements IChatSess
     activateChatSessionItemProvider(chatViewType: string): Promise<void>;
     private doActivateChatSessionItemController;
     canResolveChatSession(sessionType: string): Promise<boolean>;
+    provideChatInputCompletions(sessionResource: URI, params: IChatInputCompletionsParams, token: CancellationToken): Promise<IChatInputCompletionsResult | undefined>;
+    getChatInputCompletionTriggerCharacters(sessionType: string): Promise<readonly string[] | undefined>;
     private tryActivateControllers;
     getChatSessionItems(providersToResolve: readonly string[] | undefined, token: CancellationToken): AsyncIterable<{
         readonly chatSessionType: string;
@@ -152,12 +157,19 @@ export declare enum ChatSessionPosition {
     Editor = "editor",
     Sidebar = "sidebar"
 }
+type NewChatSessionSendOptions = {
+    readonly prompt: string;
+    readonly attachedContext?: IChatRequestVariableEntry[];
+    readonly initialSessionOptions?: ReadonlyChatSessionOptionsMap;
+};
 export type NewChatSessionOpenOptions = {
     readonly type: string;
     readonly position: ChatSessionPosition;
     readonly displayName: string;
     readonly replaceEditor?: boolean;
 };
+export declare function openChatSession(accessor: ServicesAccessor, openOptions: NewChatSessionOpenOptions, chatSendOptions?: NewChatSessionSendOptions): Promise<void>;
 export declare function getResourceForNewChatSession(options: NewChatSessionOpenOptions): URI;
 export declare function getSessionStatusForModel(model: IChatModel): ChatSessionStatus | undefined;
 export declare function chatResponseStateToSessionStatus(state: ResponseModelState): ChatSessionStatus;
+export {};

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions/chatSessions.contribution.js

@@ -11,7 +11,6 @@ import { Schemas } from '../../../../../base/common/network.js';
 import { joinPath } from '../../../../../base/common/resources.js';
 import { ThemeIcon } from '../../../../../base/common/themables.js';
 import { URI } from '../../../../../base/common/uri.js';
-import { generateUuid } from '../../../../../base/common/uuid.js';
 import { localize, localize2 } from '../../../../../nls.js';
 import { MenuId, MenuItemAction, MenuRegistry, registerAction2, Action2 } from '../../../../../platform/actions/common/actions.js';
 import { IMenuService } from '../../../../../platform/actions/common/actions.service.js';
@@ -42,53 +41,54 @@ import { ChatViewId } from '../chat.js';
 import { AgentSessionProviders, getAgentSessionProviderName, getAgentSessionProvider } from '../agentSessions/agentSessions.js';
 import { isCancellationError, BugIndicatingError } from '../../../../../base/common/errors.js';
 import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.service.js';
-import { isUntitledChatSession, LocalChatSessionUri } from '../../common/model/chatUri.js';
+import { getChatSessionType, isUntitledChatSession, LocalChatSessionUri } from '../../common/model/chatUri.js';
 import { assertNever } from '../../../../../base/common/assert.js';
 import { ICommandService } from '../../../../../platform/commands/common/commands.service.js';
 import { Target } from '../../common/promptSyntax/promptTypes.js';
 import { slashReg } from '../../common/requestParser/chatRequestParser.js';
-import { IPromptsService } from '../../common/promptSyntax/service/promptsService.service.js';
 import { OffsetRange } from '../../../../../editor/common/core/ranges/offsetRange.js';
 import { ILanguageModelToolsService } from '../../common/tools/languageModelToolsService.service.js';
+import { ICustomizationHarnessService } from '../../common/customizationHarnessService.service.js';
+import { generateUuid } from '../../../../../base/common/uuid.js';
 import { observableFromEvent } from '../../../../../base/common/observableInternal/observables/observableFromEvent.js';
 import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
 
 const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "chatSessions",
     jsonSchema: {
-        description: ( localize(6257, "Contributes chat session integrations to the chat widget.")),
+        description: ( localize(6489, "Contributes chat session integrations to the chat widget.")),
         type: "array",
         items: {
             type: "object",
             additionalProperties: false,
             properties: {
                 type: {
-                    description: ( localize(6258, "Unique identifier for the type of chat session.")),
+                    description: ( localize(6490, "Unique identifier for the type of chat session.")),
                     type: "string"
                 },
                 name: {
                     description: ( localize(
-                        6259,
+                        6491,
                         "Name of the dynamically registered chat participant (eg: @agent). Must not contain whitespace."
                     )),
                     type: "string",
                     pattern: "^[\\w-]+$"
                 },
                 displayName: {
-                    description: ( localize(6260, "A longer name for this item which is used for display in menus.")),
+                    description: ( localize(6492, "A longer name for this item which is used for display in menus.")),
                     type: "string"
                 },
                 description: {
-                    description: ( localize(6261, "Description of the chat session for use in menus and tooltips.")),
+                    description: ( localize(6493, "Description of the chat session for use in menus and tooltips.")),
                     type: "string"
                 },
                 when: {
-                    description: ( localize(6262, "Condition which must be true to show this item.")),
+                    description: ( localize(6494, "Condition which must be true to show this item.")),
                     type: "string"
                 },
                 icon: {
                     description: ( localize(
-                        6263,
+                        6495,
                         "Icon identifier (codicon ID) for the chat session editor tab. For example, \"{0}\" or \"{1}\".",
                         "$(github)",
                         "$(cloud)"
@@ -99,22 +99,22 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         type: "object",
                         properties: {
                             light: {
-                                description: ( localize(6264, "Icon path when a light theme is used")),
+                                description: ( localize(6496, "Icon path when a light theme is used")),
                                 type: "string"
                             },
                             dark: {
-                                description: ( localize(6265, "Icon path when a dark theme is used")),
+                                description: ( localize(6497, "Icon path when a dark theme is used")),
                                 type: "string"
                             }
                         }
                     }]
                 },
                 order: {
-                    description: ( localize(6266, "Order in which this item should be displayed.")),
+                    description: ( localize(6498, "Order in which this item should be displayed.")),
                     type: "integer"
                 },
                 alternativeIds: {
-                    description: ( localize(6267, "Alternative identifiers for backward compatibility.")),
+                    description: ( localize(6499, "Alternative identifiers for backward compatibility.")),
                     type: "array",
                     items: {
                         type: "string"
@@ -122,95 +122,95 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 welcomeTitle: {
                     description: ( localize(
-                        6268,
+                        6500,
                         "Title text to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 welcomeMessage: {
                     description: ( localize(
-                        6269,
+                        6501,
                         "Message text (supports markdown) to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 welcomeTips: {
                     description: ( localize(
-                        6270,
+                        6502,
                         "Tips text (supports markdown and theme icons) to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 inputPlaceholder: {
                     description: ( localize(
-                        6271,
+                        6503,
                         "Placeholder text to display in the chat input box for this session type."
                     )),
                     type: "string"
                 },
                 capabilities: {
-                    description: ( localize(6272, "Optional capabilities for this chat session.")),
+                    description: ( localize(6504, "Optional capabilities for this chat session.")),
                     type: "object",
                     additionalProperties: false,
                     properties: {
                         supportsFileAttachments: {
                             description: ( localize(
-                                6273,
+                                6505,
                                 "Whether this chat session supports attaching files or file references."
                             )),
                             type: "boolean"
                         },
                         supportsToolAttachments: {
                             description: ( localize(
-                                6274,
+                                6506,
                                 "Whether this chat session supports attaching tools or tool references."
                             )),
                             type: "boolean"
                         },
                         supportsMCPAttachments: {
-                            description: ( localize(6275, "Whether this chat session supports attaching MCP resources.")),
+                            description: ( localize(6507, "Whether this chat session supports attaching MCP resources.")),
                             type: "boolean"
                         },
                         supportsImageAttachments: {
-                            description: ( localize(6276, "Whether this chat session supports attaching images.")),
+                            description: ( localize(6508, "Whether this chat session supports attaching images.")),
                             type: "boolean"
                         },
                         supportsSearchResultAttachments: {
-                            description: ( localize(6277, "Whether this chat session supports attaching search results.")),
+                            description: ( localize(6509, "Whether this chat session supports attaching search results.")),
                             type: "boolean"
                         },
                         supportsInstructionAttachments: {
-                            description: ( localize(6278, "Whether this chat session supports attaching instructions.")),
+                            description: ( localize(6510, "Whether this chat session supports attaching instructions.")),
                             type: "boolean"
                         },
                         supportsSourceControlAttachments: {
                             description: ( localize(
-                                6279,
+                                6511,
                                 "Whether this chat session supports attaching source control changes."
                             )),
                             type: "boolean"
                         },
                         supportsProblemAttachments: {
-                            description: ( localize(6280, "Whether this chat session supports attaching problems.")),
+                            description: ( localize(6512, "Whether this chat session supports attaching problems.")),
                             type: "boolean"
                         },
                         supportsSymbolAttachments: {
-                            description: ( localize(6281, "Whether this chat session supports attaching symbols.")),
+                            description: ( localize(6513, "Whether this chat session supports attaching symbols.")),
                             type: "boolean"
                         },
                         supportsPromptAttachments: {
-                            description: ( localize(6282, "Whether this chat session supports attaching prompts.")),
+                            description: ( localize(6514, "Whether this chat session supports attaching prompts.")),
                             type: "boolean"
                         },
                         supportsHandOffs: {
-                            description: ( localize(6283, "Whether this chat session supports hand-off prompts.")),
+                            description: ( localize(6515, "Whether this chat session supports hand-off prompts.")),
                             type: "boolean"
                         }
                     }
                 },
                 commands: {
                     markdownDescription: ( localize(
-                        6284,
+                        6516,
                         "Commands available for this chat session, which the user can invoke with a `/`."
                     )),
                     type: "array",
@@ -227,17 +227,17 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         properties: {
                             name: {
                                 description: ( localize(
-                                    6285,
+                                    6517,
                                     "A short name by which this command is referred to in the UI, e.g. `fix` or `explain` for commands that fix an issue or explain code. The name should be unique among the commands provided by this participant."
                                 )),
                                 type: "string"
                             },
                             description: {
-                                description: ( localize(6286, "A description of this command.")),
+                                description: ( localize(6518, "A description of this command.")),
                                 type: "string"
                             },
                             when: {
-                                description: ( localize(6287, "A condition which must be true to enable this command.")),
+                                description: ( localize(6519, "A condition which must be true to enable this command.")),
                                 type: "string"
                             }
                         }
@@ -245,7 +245,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 canDelegate: {
                     description: ( localize(
-                        6288,
+                        6520,
                         "Whether delegation is supported. Default is false. Note that enabling this is experimental and may not be respected at all times."
                     )),
                     type: "boolean",
@@ -253,14 +253,14 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 customAgentTarget: {
                     description: ( localize(
-                        6289,
+                        6521,
                         "When set, the chat session will show a filtered mode picker that prefers custom agents whose target property matches this value. Custom agents without a target property are still shown in all session types. This enables the use of standard agent/mode with contributed sessions."
                     )),
                     type: "string"
                 },
                 requiresCustomModels: {
                     description: ( localize(
-                        6290,
+                        6522,
                         "When set, the chat session will show a filtered model picker that prefers custom models. This enables the use of standard model picker with contributed sessions."
                     )),
                     type: "boolean",
@@ -268,7 +268,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 autoAttachReferences: {
                     description: ( localize(
-                        6291,
+                        6523,
                         "Whether to automatically attach instruction files to chat requests for this session type."
                     )),
                     type: "boolean",
@@ -276,7 +276,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 useRequestToPopulateBuiltInPickers: {
                     description: ( localize(
-                        6292,
+                        6524,
                         "Whether to use ChatRequestTurn2 to populate built-in pickers such as the Agent and Model pickers."
                     )),
                     type: "boolean",
@@ -440,6 +440,13 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             count
         })));
     }
+    async resolveChatSessionItem(chatSessionType, resource, token) {
+        const entry = this._itemControllers.get(chatSessionType);
+        if (!entry?.controller.resolveChatSessionItem) {
+            return undefined;
+        }
+        return entry.controller.resolveChatSessionItem(resource, token);
+    }
     async updateInProgressStatus(chatSessionType) {
         try {
             const items = [];
@@ -556,7 +563,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openSessionWithPrompt.${contribution.type}`,
-                    title: ( localize2(6293, "New {0} with Prompt", contribution.displayName)),
+                    title: ( localize2(6525, "New {0} with Prompt", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: false,
@@ -565,7 +572,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             }
             async run(accessor, chatOptions) {
                 const chatService = accessor.get(IChatService);
-                const promptsService = accessor.get(IPromptsService);
+                const customizationHarnessService = accessor.get(ICustomizationHarnessService);
                 const toolsService = accessor.get(ILanguageModelToolsService);
                 const {
                     type
@@ -580,7 +587,12 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                         "ChatSessionsContribution#sendPrompt"
                     );
                     try {
-                        const promptFile = await resolvePromptSlashCommand(chatOptions.prompt, promptsService, toolsService);
+                        const promptFile = await resolvePromptSlashCommand(
+                            chatOptions.prompt,
+                            contribution.type,
+                            customizationHarnessService,
+                            toolsService
+                        );
                         if (promptFile) {
                             attachedContext = [promptFile, ...(attachedContext ?? [])];
                         }
@@ -603,7 +615,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionEditor.${contribution.type}`,
-                    title: ( localize2(6294, "New {0} Session", contribution.displayName)),
+                    title: ( localize2(6526, "New {0} Session", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: true,
@@ -626,7 +638,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionSidebar.${contribution.type}`,
-                    title: ( localize2(6295, "New {0} Session", contribution.displayName)),
+                    title: ( localize2(6527, "New {0} Session", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: false,
@@ -823,9 +835,13 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             contribution,
             extension: undefined
         });
+        this._contributionDisposables.set(contribution.type, ( new DisposableStore()));
+        this._updateHasCanDelegateProvidersContextKey();
         this._onDidChangeAvailability.fire();
         return toDisposable(() => {
             this._contributions.delete(contribution.type);
+            this._contributionDisposables.deleteAndDispose(contribution.type);
+            this._updateHasCanDelegateProvidersContextKey();
             this._onDidChangeAvailability.fire();
         });
     }
@@ -862,6 +878,26 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         await this._extensionService.activateByEvent(`onChatSession:${sessionType}`);
         return ( this._contentProviders.has(sessionType));
     }
+    async provideChatInputCompletions(sessionResource, params, token) {
+        const sessionType = getChatSessionType(sessionResource);
+        const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
+        const provider = this._contentProviders.get(resolvedType);
+        if (!provider?.provideChatInputCompletions) {
+            return undefined;
+        }
+        return provider.provideChatInputCompletions(sessionResource, params, token);
+    }
+    async getChatInputCompletionTriggerCharacters(sessionType) {
+        const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
+        const provider = this._contentProviders.get(resolvedType);
+        if (!provider) {
+            return undefined;
+        }
+        if (!provider.provideChatInputCompletionTriggerCharacters) {
+            return [];
+        }
+        return provider.provideChatInputCompletionTriggerCharacters();
+    }
     async tryActivateControllers(providersToResolve) {
         await Promise.all(( this.getAllChatSessionContributions().map(async contrib => {
             if (providersToResolve && !providersToResolve.includes(contrib.type)) {
@@ -1022,7 +1058,8 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 return existingSessionData.session;
             }
         }
-        if (!(await raceCancellationError(this.canResolveChatSession(sessionResource.scheme), token))) {
+        const sessionType = getChatSessionType(sessionResource);
+        if (!(await raceCancellationError(this.canResolveChatSession(sessionType), token))) {
             throw Error(`Can not find provider for ${sessionResource}`);
         }
         {
@@ -1031,16 +1068,16 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 return existingSessionData.session;
             }
         }
-        const resolvedType = this._resolveToPrimaryType(sessionResource.scheme) || sessionResource.scheme;
+        const resolvedType = this._resolveToPrimaryType(sessionType) || sessionType;
         const provider = this._contentProviders.get(resolvedType);
         if (!provider) {
             throw Error(`Can not find provider for ${sessionResource}`);
         }
         let session;
         const newSessionOptionGroups = isUntitledChatSession(sessionResource) ? await this.getNewChatSessionInputState(resolvedType, sessionResource) : undefined;
-        if (isUntitledChatSession(sessionResource) && newSessionOptionGroups) {
+        if (isUntitledChatSession(sessionResource) && (newSessionOptionGroups || resolvedType.startsWith("agent-host-"))) {
             const options = ( new Map());
-            for (const group of newSessionOptionGroups) {
+            for (const group of newSessionOptionGroups ?? []) {
                 const selected = group.selected ?? group.items.find(item => item.default) ?? group.items[0];
                 if (selected) {
                     options.set(group.id, selected);
@@ -1068,16 +1105,10 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 return existingSessionData.session;
             }
         }
-        const sessionData = ( new ContributedChatSessionData(
-            session,
-            sessionResource.scheme,
-            sessionResource,
-            session.options,
-            resource => {
-                sessionData.dispose();
-                this._sessions.delete(resource);
-            }
-        ));
+        const sessionData = ( new ContributedChatSessionData(session, sessionType, sessionResource, session.options, resource => {
+            sessionData.dispose();
+            this._sessions.delete(resource);
+        }));
         this._sessions.set(sessionResource, sessionData);
         if (session.options) {
             this._onDidChangeSessionOptions.fire({
@@ -1208,7 +1239,7 @@ function registerNewSessionInPlaceAction(type, displayName) {
         constructor() {
             super({
                 id: `workbench.action.chat.openNewChatSessionInPlace.${type}`,
-                title: ( localize2(6296, "New {0} Session", displayName)),
+                title: ( localize2(6528, "New {0} Session", displayName)),
                 category: CHAT_CATEGORY,
                 f1: false,
                 precondition: ChatContextKeys.enabled
@@ -1224,7 +1255,7 @@ function registerNewSessionInPlaceAction(type, displayName) {
             }
             await openChatSession(accessor, {
                 type: type,
-                displayName: ( localize(6297, "Chat")),
+                displayName: ( localize(6529, "Chat")),
                 position: chatSessionPosition,
                 replaceEditor: true
             });
@@ -1236,7 +1267,7 @@ function registerNewSessionExternalAction(type, displayName, commandId) {
         constructor() {
             super({
                 id: `workbench.action.chat.openNewChatSessionExternal.${type}`,
-                title: ( localize2(6298, "New {0} Session", displayName)),
+                title: ( localize2(6530, "New {0} Session", displayName)),
                 category: CHAT_CATEGORY,
                 f1: false,
                 precondition: ChatContextKeys.enabled
@@ -1260,7 +1291,7 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
     const logService = accessor.get(ILogService);
     const editorGroupService = accessor.get(IEditorGroupsService);
     const editorService = accessor.get(IEditorService);
-    const promptsService = accessor.get(IPromptsService);
+    const customizationHarnessService = accessor.get(ICustomizationHarnessService);
     const toolsService = accessor.get(ILanguageModelToolsService);
     const resource = getResourceForNewChatSession(openOptions);
     try {
@@ -1282,7 +1313,7 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
                     override: ChatEditorInput.EditorID,
                     pinned: true,
                     title: {
-                        fallback: ( localize(6299, "{0}", openOptions.displayName))
+                        fallback: ( localize(6531, "{0}", openOptions.displayName))
                     }
                 };
                 if (openOptions.replaceEditor) {
@@ -1324,7 +1355,12 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
                 chatSessionService.updateSessionOptions(resource, normalizeSessionOptions(chatSendOptions.initialSessionOptions));
             }
             let attachedContext = chatSendOptions.attachedContext;
-            const promptFile = await resolvePromptSlashCommand(chatSendOptions.prompt, promptsService, toolsService);
+            const promptFile = await resolvePromptSlashCommand(
+                chatSendOptions.prompt,
+                openOptions.type,
+                customizationHarnessService,
+                toolsService
+            );
             if (promptFile) {
                 attachedContext = [promptFile, ...(attachedContext ?? [])];
             }
@@ -1349,10 +1385,10 @@ function normalizeSessionOptions(options) {
     }
     return ChatSessionOptionsMap.fromRecord(options);
 }
-async function resolvePromptSlashCommand(prompt, promptsService, toolsService) {
+async function resolvePromptSlashCommand(prompt, sessionType, customizationHarnessService, toolsService) {
     const slashMatch = prompt.match(slashReg);
     if (slashMatch) {
-        const slashCommand = await promptsService.resolvePromptSlashCommand(slashMatch[1], CancellationToken.None);
+        const slashCommand = await customizationHarnessService.resolvePromptSlashCommand(slashMatch[1], sessionType, CancellationToken.None);
         if (slashCommand) {
             const parseResult = slashCommand.parsedPromptFile;
             const refs = parseResult.body?.variableReferences.map((
@@ -1428,4 +1464,4 @@ function chatResponseStateToSessionStatus(state) {
     }
 }
 
-export { ChatSessionPosition, ChatSessionsService, chatResponseStateToSessionStatus, getResourceForNewChatSession, getSessionStatusForModel };
+export { ChatSessionPosition, ChatSessionsService, chatResponseStateToSessionStatus, getResourceForNewChatSession, getSessionStatusForModel, openChatSession };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSetup/chatSetup.js

@@ -5,7 +5,6 @@ import { localize } from '../../../../../nls.js';
 import { EnablementState } from '../../../../services/extensionManagement/common/extensionManagement.js';
 
 const defaultChat = {
-    completionsRefreshTokenCommand: product.defaultChatAgent?.completionsRefreshTokenCommand ?? "",
     chatRefreshTokenCommand: product.defaultChatAgent?.chatRefreshTokenCommand ?? "",
     providerExtensionId: product.defaultChatAgent?.providerExtensionId ?? ""
 };
@@ -31,7 +30,6 @@ var ChatSetupStrategy;
     ChatSetupStrategy[ChatSetupStrategy["SetupWithAppleProvider"] = 5] = "SetupWithAppleProvider";
 })(ChatSetupStrategy || (ChatSetupStrategy = {}));
 function refreshTokens(commandService) {
-    commandService.executeCommand(defaultChat.completionsRefreshTokenCommand);
     commandService.executeCommand(defaultChat.chatRefreshTokenCommand);
 }
 async function maybeEnableAuthExtension(extensionsWorkbenchService, logService) {
@@ -50,7 +48,7 @@ async function maybeEnableAuthExtension(extensionsWorkbenchService, logService)
         );
         try {
             await extensionsWorkbenchService.setEnablement([providerExtension], EnablementState.EnabledGlobally);
-            await extensionsWorkbenchService.updateRunningExtensions(( localize(6300, "Enabling GitHub Authentication")));
+            await extensionsWorkbenchService.updateRunningExtensions(( localize(6532, "Enabling GitHub Authentication")));
             return true;
         } catch (error) {
             logService.error(

package/vscode/src/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackService.service.d.ts

@@ -0,0 +1,26 @@
+import { Event } from "../../../../../base/common/event.js";
+import { IDisposable } from "../../../../../base/common/lifecycle.js";
+import { URI } from "../../../../../base/common/uri.js";
+import { IChatPlanReviewResult } from "../../common/chatService/chatService.js";
+import { IPlanReviewFeedbackItem } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackService";
+export declare const IPlanReviewFeedbackService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IPlanReviewFeedbackService>;
+export interface IPlanReviewFeedbackService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChangeFeedback: Event<URI>;
+    readonly onDidChangeNavigation: Event<URI>;
+    readonly onDidChangeRegistrations: Event<void>;
+    registerPlanReview(planUri: URI, onSubmit: (result: IChatPlanReviewResult) => void): IDisposable;
+    isActivePlanReview(uri: URI): boolean;
+    addFeedback(planUri: URI, line: number, column: number, text: string): string;
+    removeFeedback(planUri: URI, feedbackId: string): void;
+    updateFeedback(planUri: URI, feedbackId: string, newText: string): void;
+    getFeedback(planUri: URI): readonly IPlanReviewFeedbackItem[];
+    clearFeedback(planUri: URI): void;
+    getNextFeedback(planUri: URI, next: boolean): IPlanReviewFeedbackItem | undefined;
+    getNavigationBearing(planUri: URI): {
+        activeIdx: number;
+        totalCount: number;
+    };
+    setNavigationAnchor(planUri: URI, itemId: string | undefined): void;
+    submitAllFeedback(planUri: URI): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';
+
+const IPlanReviewFeedbackService = ( createDecorator("planReviewFeedbackService"));
+
+export { IPlanReviewFeedbackService };

package/vscode/src/vs/workbench/contrib/chat/browser/tools/chatToolRiskAssessmentService.service.d.ts

@@ -0,0 +1,17 @@
+import { CancellationToken } from "../../../../../base/common/cancellation.js";
+import { IToolData } from "../../common/tools/languageModelToolsService.js";
+import { IToolRiskAssessment } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/tools/chatToolRiskAssessmentService";
+export declare const IChatToolRiskAssessmentService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatToolRiskAssessmentService>;
+export interface IChatToolRiskAssessmentService {
+    readonly _serviceBrand: undefined;
+    /** Returns whether the feature is enabled by configuration. */
+    isEnabled(): boolean;
+    /** Synchronously read a previously cached assessment, or undefined if none. */
+    getCached(tool: IToolData, parameters: unknown): IToolRiskAssessment | undefined;
+    /**
+    * Get a cached or freshly-computed risk assessment for a tool call.
+    * Returns `undefined` when the feature is disabled, no model is available,
+    * or the assessment cannot be parsed.
+    */
+    assess(tool: IToolData, parameters: unknown, token: CancellationToken): Promise<IToolRiskAssessment | undefined>;
+}