@codingame/monaco-vscode-chat-service-override 16.1.0 → 17.0.0

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.js

@@ -1,62 +1,264 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { PROMPT_LANGUAGE_ID } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/constants';
+import { flatten, forEach } from '../utils/treeUtils.js';
+import { PromptParser } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptParser';
+import { match } from '@codingame/monaco-vscode-api/vscode/vs/base/common/glob';
+import { pick } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
 import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { PromptFilesLocator } from '../utils/promptFilesLocator.js';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ObjectCache } from '../../../../../../base/common/objectCache.js';
 import { TextModelPromptParser } from '../parsers/textModelPromptParser.js';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { PROMPT_FILE_EXTENSION } from '@codingame/monaco-vscode-51fed910-d648-5620-9b80-9232cd79d116-common/vscode/vs/platform/prompts/common/constants';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
 
 let PromptsService = class PromptsService extends Disposable {
-    constructor(initService, userDataService) {
+    constructor(labelService, modelService, initService, userDataService) {
         super();
+        this.labelService = labelService;
+        this.modelService = modelService;
         this.initService = initService;
         this.userDataService = userDataService;
         this.fileLocator = this.initService.createInstance(PromptFilesLocator);
         this.cache = this._register(( new ObjectCache((model) => {
-            const parser = initService.createInstance(TextModelPromptParser, model, []);
-            parser.start();
+            assert(model.isDisposed() === false, 'Text model must not be disposed.');
+            const parser = initService.createInstance(TextModelPromptParser, model, { seenReferences: [] }).start();
             parser.assertNotDisposed('Created prompt parser must not be disposed.');
             return parser;
         })));
     }
     getSyntaxParserFor(model) {
-        assert(!model.isDisposed(), 'Cannot create a prompt syntax parser for a disposed model.');
+        assert(model.isDisposed() === false, 'Cannot create a prompt syntax parser for a disposed model.');
         return this.cache.get(model);
     }
-    async listPromptFiles() {
+    async listPromptFiles(type) {
         const userLocations = [this.userDataService.currentProfile.promptsHome];
         const prompts = await Promise.all([
-            this.fileLocator.listFilesIn(userLocations)
-                .then(withType('user')),
-            this.fileLocator.listFiles()
-                .then(withType('local')),
+            this.fileLocator.listFilesIn(userLocations, type)
+                .then(withType('user', type)),
+            this.fileLocator.listFiles(type)
+                .then(withType('local', type)),
         ]);
         return prompts.flat();
     }
     getSourceFolders(type) {
-        assert(type === 'local' || type === 'user', `Unknown prompt type '${type}'.`);
-        const prompts = (type === 'user')
-            ? [this.userDataService.currentProfile.promptsHome]
-            : this.fileLocator.getConfigBasedSourceFolders();
-        return ( prompts.map(addType(type)));
+        assert(type === 'prompt' || type === 'instructions', `Unknown prompt type '${type}'.`);
+        const result = [];
+        for (const uri of this.fileLocator.getConfigBasedSourceFolders(type)) {
+            result.push({ uri, storage: 'local', type });
+        }
+        const userHome = this.userDataService.currentProfile.promptsHome;
+        result.push({ uri: userHome, storage: 'user', type });
+        return result;
+    }
+    asPromptSlashCommand(command) {
+        if (command.match(/^[\w_\-\.]+/)) {
+            return { command, detail: ( localize(5092, 'Prompt file: {0}', command)) };
+        }
+        return undefined;
+    }
+    async resolvePromptSlashCommand(data) {
+        if (data.promptPath) {
+            return data.promptPath;
+        }
+        const files = await this.listPromptFiles('prompt');
+        const command = data.command;
+        const result = files.find(file => getPromptCommandName(file.uri.path) === command);
+        if (result) {
+            return result;
+        }
+        const model = this.modelService.getModels().find(model => model.getLanguageId() === PROMPT_LANGUAGE_ID && getPromptCommandName(model.uri.path) === command);
+        if (model) {
+            return { uri: model.uri, storage: 'local', type: 'prompt' };
+        }
+        return undefined;
+    }
+    async findPromptSlashCommands() {
+        const promptFiles = await this.listPromptFiles('prompt');
+        return (promptFiles.map(promptPath => {
+            const command = getPromptCommandName(promptPath.uri.path);
+            return {
+                command,
+                detail: ( localize(
+                    5092,
+                    'Prompt file: {0}',
+                    this.labelService.getUriLabel(promptPath.uri, { relative: true })
+                )),
+                promptPath
+            };
+        }));
+    }
+    async findInstructionFilesFor(files) {
+        const result = [];
+        const instructionFiles = await this.listPromptFiles('instructions');
+        if (instructionFiles.length === 0) {
+            return result;
+        }
+        const instructions = await this.getAllMetadata(( instructionFiles.map(pick('uri'))));
+        for (const instruction of instructions.flatMap(flatten)) {
+            const { metadata, uri } = instruction;
+            const { applyTo } = metadata;
+            if (applyTo === undefined) {
+                continue;
+            }
+            if ((applyTo === '**') || (applyTo === '**/*')) {
+                result.push(uri);
+                continue;
+            }
+            for (const file of files) {
+                if (match(applyTo, file.fsPath)) {
+                    result.push(uri);
+                }
+            }
+        }
+        return [...( new ResourceSet(result))];
+    }
+    async getAllMetadata(promptUris) {
+        const metadata = await Promise.all(( promptUris.map(async (uri) => {
+            let parser;
+            try {
+                parser = this.initService.createInstance(PromptParser, uri, { allowNonPromptFiles: true }).start();
+                await parser.allSettled();
+                return collectMetadata(parser);
+            }
+            finally {
+                parser?.dispose();
+            }
+        })));
+        return metadata;
+    }
+    async getCombinedToolsMetadata(promptUris) {
+        if (promptUris.length === 0) {
+            return null;
+        }
+        const filesMetadata = await this.getAllMetadata(promptUris);
+        const allTools = ( filesMetadata
+            .map((fileMetadata) => {
+            const result = [];
+            let isFirst = true;
+            let isRootInAgentMode = false;
+            let hasTools = false;
+            let chatMode;
+            forEach((node) => {
+                const { metadata } = node;
+                const { mode, tools } = metadata;
+                if (isFirst === true) {
+                    isFirst = false;
+                    if ((mode === ChatMode.Agent) || (tools !== undefined)) {
+                        isRootInAgentMode = true;
+                        chatMode = ChatMode.Agent;
+                    }
+                }
+                chatMode ??= mode;
+                if (chatMode && mode) {
+                    chatMode = morePrivilegedChatMode(chatMode, mode);
+                }
+                if (isRootInAgentMode && tools !== undefined) {
+                    result.push(...tools);
+                    hasTools = true;
+                }
+                return false;
+            }, fileMetadata);
+            if (chatMode === ChatMode.Agent) {
+                return {
+                    tools: (hasTools)
+                        ? [...( new Set(result))]
+                        : undefined,
+                    mode: ChatMode.Agent,
+                };
+            }
+            return {
+                mode: chatMode,
+            };
+        }));
+        let hasAnyTools = false;
+        let resultingChatMode;
+        const result = [];
+        for (const { tools, mode } of allTools) {
+            resultingChatMode ??= mode;
+            if (resultingChatMode && mode) {
+                resultingChatMode = morePrivilegedChatMode(resultingChatMode, mode);
+            }
+            if (tools) {
+                result.push(...tools);
+                hasAnyTools = true;
+            }
+        }
+        if (resultingChatMode === ChatMode.Agent) {
+            return {
+                tools: (hasAnyTools)
+                    ? [...( new Set(result))]
+                    : undefined,
+                mode: resultingChatMode,
+            };
+        }
+        return {
+            tools: undefined,
+            mode: resultingChatMode,
+        };
     }
 };
 PromptsService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IUserDataProfileService))
+    ( __param(0, ILabelService)),
+    ( __param(1, IModelService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IUserDataProfileService))
 ], PromptsService));
-const addType = (type) => {
+const morePrivilegedChatMode = (chatMode1, chatMode2) => {
+    if (chatMode1 === chatMode2) {
+        return chatMode1;
+    }
+    if ((chatMode1 === ChatMode.Agent) || (chatMode2 === ChatMode.Agent)) {
+        return ChatMode.Agent;
+    }
+    if ((chatMode1 === ChatMode.Edit) || (chatMode2 === ChatMode.Edit)) {
+        return ChatMode.Edit;
+    }
+    throw ( new Error([
+        'Invalid logic encountered: ',
+        `at this point modes '${chatMode1}' and '${chatMode2}' are different, but`,
+        `both must have be equal to '${ChatMode.Ask}' at the same time.`,
+    ].join(' ')));
+};
+const collectMetadata = (reference) => {
+    const childMetadata = [];
+    for (const child of reference.references) {
+        if (child.errorCondition !== undefined) {
+            continue;
+        }
+        childMetadata.push(collectMetadata(child));
+    }
+    const children = (childMetadata.length > 0)
+        ? childMetadata
+        : undefined;
+    return {
+        uri: reference.uri,
+        metadata: reference.metadata,
+        children,
+    };
+};
+function getPromptCommandName(path) {
+    const name = basename(path, PROMPT_FILE_EXTENSION);
+    return name;
+}
+const addType = (storage, type) => {
     return (uri) => {
-        return { uri, type: type };
+        return { uri, storage, type };
     };
 };
-const withType = (type) => {
+const withType = (storage, type) => {
     return (uris) => {
         return ( uris
-            .map(addType(type)));
+            .map(addType(storage, type)));
     };
 };
 
-export { PromptsService };
+export { PromptsService, getPromptCommandName };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/utils/promptFilesLocator.d.ts

@@ -1,3 +1,4 @@
+import { TPromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
@@ -7,10 +8,10 @@ export declare class PromptFilesLocator {
     private readonly configService;
     private readonly workspaceService;
     constructor(fileService: IFileService, configService: IConfigurationService, workspaceService: IWorkspaceContextService);
-    listFiles(): Promise<readonly URI[]>;
-    listFilesIn(folders: readonly URI[]): Promise<readonly URI[]>;
-    getConfigBasedSourceFolders(): readonly URI[];
-    private findInstructionFiles;
+    listFiles(type: TPromptsType): Promise<readonly URI[]>;
+    listFilesIn(folders: readonly URI[], type: TPromptsType): Promise<readonly URI[]>;
+    getConfigBasedSourceFolders(type: TPromptsType): readonly URI[];
+    private findFilesInLocations;
 }
 export declare const isValidGlob: (pattern: string) => boolean;
 export declare const firstNonGlobParent: (location: URI) => URI;

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/utils/promptFilesLocator.js

@@ -6,11 +6,11 @@ import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/asser
 import { isAbsolute } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
-import { PromptsConfig } from '@codingame/monaco-vscode-a1eb43d5-da63-5f76-8ad4-acf0d6c3b749-common/vscode/vs/platform/prompts/common/config';
-import { basename, extUri, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { PromptsConfig } from '@codingame/monaco-vscode-51fed910-d648-5620-9b80-9232cd79d116-common/vscode/vs/platform/prompts/common/config';
+import { basename, dirname, extUri } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { PROMPT_FILE_EXTENSION, isPromptFile } from '@codingame/monaco-vscode-a1eb43d5-da63-5f76-8ad4-acf0d6c3b749-common/vscode/vs/platform/prompts/common/constants';
+import { PROMPT_FILE_EXTENSION, getPromptFileType } from '@codingame/monaco-vscode-51fed910-d648-5620-9b80-9232cd79d116-common/vscode/vs/platform/prompts/common/constants';
 
 let PromptFilesLocator = class PromptFilesLocator {
     constructor(fileService, configService, workspaceService) {
@@ -18,16 +18,16 @@ let PromptFilesLocator = class PromptFilesLocator {
         this.configService = configService;
         this.workspaceService = workspaceService;
     }
-    async listFiles() {
-        const configuredLocations = PromptsConfig.promptSourceFolders(this.configService);
+    async listFiles(type) {
+        const configuredLocations = PromptsConfig.promptSourceFolders(this.configService, type);
         const absoluteLocations = toAbsoluteLocations(configuredLocations, this.workspaceService);
-        return await this.listFilesIn(absoluteLocations);
+        return await this.listFilesIn(absoluteLocations, type);
     }
-    async listFilesIn(folders) {
-        return await this.findInstructionFiles(folders);
+    async listFilesIn(folders, type) {
+        return await this.findFilesInLocations(folders, type);
     }
-    getConfigBasedSourceFolders() {
-        const configuredLocations = PromptsConfig.promptSourceFolders(this.configService);
+    getConfigBasedSourceFolders(type) {
+        const configuredLocations = PromptsConfig.promptSourceFolders(this.configService, type);
         const absoluteLocations = toAbsoluteLocations(configuredLocations, this.workspaceService);
         const result = ( new ResourceSet());
         for (const absoluteLocation of absoluteLocations) {
@@ -46,23 +46,29 @@ let PromptFilesLocator = class PromptFilesLocator {
             if (isValidGlob(path) === true) {
                 continue;
             }
-            result.add(URI.file(path));
+            result.add(absoluteLocation.with({ path }));
         }
         return [...result];
     }
-    async findInstructionFiles(absoluteLocations) {
+    async findFilesInLocations(absoluteLocations, type) {
         const paths = ( new ResourceSet());
         for (const absoluteLocation of absoluteLocations) {
             assert(isAbsolute(absoluteLocation.path), `Provided location must be an absolute path, got '${absoluteLocation.path}'.`);
-            const location = (isValidGlob(basename(absoluteLocation)) || absoluteLocation.path.endsWith(PROMPT_FILE_EXTENSION))
-                ? absoluteLocation
-                : extUri.joinPath(absoluteLocation, `*${PROMPT_FILE_EXTENSION}`);
-            const promptFiles = await findAllPromptFiles(firstNonGlobParent(location), this.fileService);
-            for (const file of promptFiles) {
-                if (match(location.path, file.path)) {
+            const nonGlobParent = firstNonGlobParent(absoluteLocation);
+            if (nonGlobParent === absoluteLocation) {
+                const promptFiles = await findFilesInLocation(absoluteLocation, type, this.fileService);
+                for (const file of promptFiles) {
                     paths.add(file);
                 }
             }
+            else {
+                const promptFiles = await findFilesInLocation(nonGlobParent, type, this.fileService);
+                for (const file of promptFiles) {
+                    if (match(absoluteLocation.path, file.path)) {
+                        paths.add(file);
+                    }
+                }
+            }
         }
         return [...paths];
     }
@@ -133,22 +139,22 @@ const firstNonGlobParent = (location) => {
     }
     return firstNonGlobParent(parent);
 };
-const findAllPromptFiles = async (location, fileService) => {
+const findFilesInLocation = async (location, type, fileService) => {
     const result = [];
     try {
         const info = await fileService.resolve(location);
-        if (info.isFile && isPromptFile(info.resource)) {
+        if (info.isFile && getPromptFileType(info.resource) === type) {
             result.push(info.resource);
             return result;
         }
         if (info.isDirectory && info.children) {
             for (const child of info.children) {
-                if (child.isFile && isPromptFile(child.resource)) {
+                if (child.isFile && getPromptFileType(child.resource) === type) {
                     result.push(child.resource);
                     continue;
                 }
                 if (child.isDirectory) {
-                    const promptFiles = await findAllPromptFiles(child.resource, fileService);
+                    const promptFiles = await findFilesInLocation(child.resource, type, fileService);
                     result.push(...promptFiles);
                     continue;
                 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/utils/treeUtils.d.ts

@@ -0,0 +1,10 @@
+export type TTree<TTreenNode> = {
+    children?: readonly TTree<TTreenNode>[];
+} & TTreenNode;
+export declare const flatten: <TTreeNode>(treeRoot: TTree<TTreeNode>) => Omit<TTreeNode, "children">[];
+export declare const forEach: <TTreeNode>(callback: (node: TTreeNode) => boolean, treeRoot: TTree<TTreeNode>) => ReturnType<typeof callback>;
+export declare const map: <TTreeNode extends object, TNewTreeNode extends object>(callback: (originalNode: Readonly<TTree<TTreeNode>>, newChildren: Readonly<TNewTreeNode>[] | undefined) => TTree<TNewTreeNode>, treeRoot: TTree<TTreeNode>) => TTree<TNewTreeNode>;
+type TRestParameters<T extends (...args: any[]) => any> = T extends (first: any, ...rest: infer R) => any ? R : never;
+type TCurriedFunction<T extends (...args: any[]) => any> = ((...args: TRestParameters<T>) => ReturnType<T>);
+export declare const curry: <T, K>(callback: (arg1: T, ...args: any[]) => K, arg1: T) => TCurriedFunction<typeof callback>;
+export {};

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/utils/treeUtils.js

@@ -0,0 +1,25 @@
+
+
+const flatten = (treeRoot) => {
+    const result = [];
+    result.push(treeRoot);
+    for (const child of treeRoot.children ?? []) {
+        result.push(...flatten(child));
+    }
+    return result;
+};
+const forEach = (callback, treeRoot) => {
+    const shouldStop = callback(treeRoot);
+    if (shouldStop === true) {
+        return true;
+    }
+    for (const child of treeRoot.children ?? []) {
+        const shouldStop = forEach(callback, child);
+        if (shouldStop === true) {
+            return true;
+        }
+    }
+    return false;
+};
+
+export { flatten, forEach };

package/vscode/src/vs/workbench/contrib/chat/common/tools/languageModelToolsContribution.js

@@ -26,7 +26,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
     },
     jsonSchema: {
         description: ( localize(
-            5007,
+            5093,
             'Contributes a tool that can be invoked by a language model in a chat session, or from a standalone command. Registered tools can be used by all extensions.'
         )),
         type: 'array',
@@ -52,7 +52,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
             properties: {
                 name: {
                     description: ( localize(
-                        5008,
+                        5094,
                         "A unique name for this tool. This name must be a globally unique identifier, and is also used as a name when presenting this tool to a language model."
                     )),
                     type: 'string',
@@ -60,7 +60,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 toolReferenceName: {
                     markdownDescription: ( localize(
-                        5009,
+                        5095,
                         "If {0} is enabled for this tool, the user may use '#' with this name to invoke the tool in a query. Otherwise, the name is not required. Name must not contain whitespace.",
                         '`canBeReferencedInPrompt`'
                     )),
@@ -69,32 +69,32 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 displayName: {
                     description: ( localize(
-                        5010,
+                        5096,
                         "A human-readable name for this tool that may be used to describe it in the UI."
                     )),
                     type: 'string'
                 },
                 userDescription: {
-                    description: ( localize(5011, "A description of this tool that may be shown to the user.")),
+                    description: ( localize(5097, "A description of this tool that may be shown to the user.")),
                     type: 'string'
                 },
                 modelDescription: {
                     description: ( localize(
-                        5012,
+                        5098,
                         "A description of this tool that may be used by a language model to select it."
                     )),
                     type: 'string'
                 },
                 inputSchema: {
                     description: ( localize(
-                        5013,
+                        5099,
                         "A JSON schema for the input this tool accepts. The input must be an object at the top level. A particular language model may not support all JSON schema features. See the documentation for the language model family you are using for more information."
                     )),
                     $ref: toolsParametersSchemaSchemaId
                 },
                 canBeReferencedInPrompt: {
                     markdownDescription: ( localize(
-                        5014,
+                        5100,
                         "If true, this tool shows up as an attachment that the user can add manually to their request. Chat participants will receive the tool in {0}.",
                         '`ChatRequest#toolReferences`'
                     )),
@@ -102,7 +102,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 icon: {
                     markdownDescription: ( localize(
-                        5015,
+                        5101,
                         "An icon that represents this tool. Either a file path, an object with file paths for dark and light themes, or a theme icon reference, like `$(zap)`"
                     )),
                     anyOf: [{
@@ -112,11 +112,11 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                             type: 'object',
                             properties: {
                                 light: {
-                                    description: ( localize(5016, 'Icon path when a light theme is used')),
+                                    description: ( localize(5102, 'Icon path when a light theme is used')),
                                     type: 'string'
                                 },
                                 dark: {
-                                    description: ( localize(5017, 'Icon path when a dark theme is used')),
+                                    description: ( localize(5103, 'Icon path when a dark theme is used')),
                                     type: 'string'
                                 }
                             }
@@ -124,14 +124,14 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 when: {
                     markdownDescription: ( localize(
-                        5018,
+                        5104,
                         "Condition which must be true for this tool to be enabled. Note that a tool may still be invoked by another extension even when its `when` condition is false."
                     )),
                     type: 'string'
                 },
                 tags: {
                     description: ( localize(
-                        5019,
+                        5105,
                         "A set of tags that roughly describe the tool's capabilities. A tool user may use these to filter the set of tools to just ones that are relevant for the task at hand, or they may want to pick a tag that can be used to identify just the tools contributed by this extension."
                     )),
                     type: 'array',
@@ -147,7 +147,6 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
 function toToolKey(extensionIdentifier, toolName) {
     return `${extensionIdentifier.value}/${toolName}`;
 }
-const CopilotAgentModeTag = 'vscode_editing';
 let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionPointHandler {
     static { this.ID = 'workbench.contrib.toolsExtensionPointHandler'; }
     constructor(languageModelToolsService, logService, productService) {
@@ -171,15 +170,8 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                         logService.error(`Extension '${extension.description.identifier.value}' CANNOT register tool with name starting with "vscode_" or "copilot_"`);
                         continue;
                     }
-                    if (rawTool.tags?.includes(CopilotAgentModeTag)) {
-                        if (!isProposedApiEnabled(extension.description, 'languageModelToolsForAgent') && !isProposedApiEnabled(extension.description, 'chatParticipantPrivate')) {
-                            logService.error(`Extension '${extension.description.identifier.value}' CANNOT register tool with tag "${CopilotAgentModeTag}" without enabling 'languageModelToolsForAgent' proposal`);
-                            continue;
-                        }
-                    }
-                    if (rawTool.tags?.some(tag => tag !== CopilotAgentModeTag && (tag.startsWith('copilot_') || tag.startsWith('vscode_'))) && !isProposedApiEnabled(extension.description, 'chatParticipantPrivate')) {
+                    if (rawTool.tags?.some(tag => tag.startsWith('copilot_') || tag.startsWith('vscode_')) && !isProposedApiEnabled(extension.description, 'chatParticipantPrivate')) {
                         logService.error(`Extension '${extension.description.identifier.value}' CANNOT register tool with tags starting with "vscode_" or "copilot_"`);
-                        continue;
                     }
                     const rawIcon = rawTool.icon;
                     let icon;
@@ -200,16 +192,13 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                         isProposedApiEnabled(extension.description, 'chatParticipantPrivate');
                     const tool = {
                         ...rawTool,
-                        source: { type: 'extension', extensionId: extension.description.identifier, isExternalTool: !isBuiltinTool },
+                        source: { type: 'extension', label: extension.description.displayName ?? extension.description.name, extensionId: extension.description.identifier, isExternalTool: !isBuiltinTool },
                         inputSchema: rawTool.inputSchema,
                         id: rawTool.name,
                         icon,
                         when: rawTool.when ? ContextKeyExpr.deserialize(rawTool.when) : undefined,
-                        requiresConfirmation: !isBuiltinTool,
                         alwaysDisplayInputOutput: !isBuiltinTool,
-                        supportsToolPicker: isBuiltinTool ?
-                            false :
-                            rawTool.canBeReferencedInPrompt
+                        supportsToolPicker: rawTool.canBeReferencedInPrompt
                     };
                     const disposable = languageModelToolsService.registerToolData(tool);
                     this._registrationDisposables.set(toToolKey(extension.description.identifier, rawTool.name), disposable);
@@ -242,9 +231,9 @@ class LanguageModelToolDataRenderer extends Disposable {
             return { data: { headers: [], rows: [] }, dispose: () => { } };
         }
         const headers = [
-            ( localize(5020, "Name")),
-            ( localize(5021, "Display Name")),
-            ( localize(5022, "Description")),
+            ( localize(5106, "Name")),
+            ( localize(5107, "Display Name")),
+            ( localize(5108, "Description")),
         ];
         const rows = ( contribs.map(t => {
             return [
@@ -264,7 +253,7 @@ class LanguageModelToolDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: 'languageModelTools',
-    label: ( localize(5023, "Language Model Tools")),
+    label: ( localize(5109, "Language Model Tools")),
     access: {
         canToggle: false
     },

package/vscode/src/vs/workbench/contrib/chat/common/voiceChatService.d.ts

@@ -4,7 +4,7 @@ import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { RawContextKey } 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";
 import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
-import { IChatModel } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IChatModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel";
 import { ISpeechToTextEvent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/speech/common/speechService";
 import { ISpeechService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/speech/common/speechService.service";
 import { IVoiceChatService } from "./voiceChatService.service.js";

package/vscode/src/vs/workbench/contrib/chat/common/voiceChatService.js

@@ -7,7 +7,7 @@ import { rtrim } from '@codingame/monaco-vscode-api/vscode/vs/base/common/string
 import { RawContextKey } 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';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
-import { chatAgentLeader, chatSubcommandLeader } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { chatAgentLeader, chatSubcommandLeader } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
 import { SpeechToTextStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/speech/common/speechService';
 import { ISpeechService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/speech/common/speechService.service';
 
@@ -21,7 +21,7 @@ var PhraseTextType;
 const VoiceChatInProgress = ( new RawContextKey(
     'voiceChatInProgress',
     false,
-    { type: 'boolean', description: ( localize(5024, "A speech-to-text session is in progress for chat.")) }
+    { type: 'boolean', description: ( localize(5110, "A speech-to-text session is in progress for chat.")) }
 ));
 let VoiceChatService = class VoiceChatService extends Disposable {
     static { VoiceChatService_1 = this; }