@codingame/monaco-vscode-chat-service-override 17.2.0 → 18.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/promptSyntax/promptToolsCodeLensProvider.js

@@ -0,0 +1,95 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { EditOperation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editOperation';
+import { isITextModel } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { showToolsPicker } from '../actions/chatToolPicker.js';
+import { ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { ALL_PROMPTS_LANGUAGE_SELECTOR } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/constants';
+import { PromptToolsMetadata } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptHeader/metadata/tools';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types.service';
+import { registerEditorFeature } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorFeatures';
+
+let PromptToolsCodeLensProvider = class PromptToolsCodeLensProvider extends Disposable {
+    constructor(promptsService, languageService, languageModelToolsService, instantiationService) {
+        super();
+        this.promptsService = promptsService;
+        this.languageService = languageService;
+        this.languageModelToolsService = languageModelToolsService;
+        this.instantiationService = instantiationService;
+        this.cmdId = `_configure/${generateUuid()}`;
+        this._register(this.languageService.codeLensProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, this));
+        this._register(CommandsRegistry.registerCommand(this.cmdId, (_accessor, ...args) => {
+            const [first, second] = args;
+            if (isITextModel(first) && second instanceof PromptToolsMetadata) {
+                this.updateTools(first, second);
+            }
+        }));
+    }
+    async provideCodeLenses(model, token) {
+        const parser = this.promptsService.getSyntaxParserFor(model);
+        const { header } = await parser
+            .start()
+            .settled();
+        if ((header === undefined) || token.isCancellationRequested) {
+            return undefined;
+        }
+        if (('tools' in header.metadataUtility) === false) {
+            return undefined;
+        }
+        const { tools } = header.metadataUtility;
+        if (tools === undefined) {
+            return undefined;
+        }
+        const codeLens = {
+            range: tools.range.collapseToStart(),
+            command: {
+                title: ( localize(5077, "Configure Tools...")),
+                id: this.cmdId,
+                arguments: [model, tools]
+            }
+        };
+        return { lenses: [codeLens] };
+    }
+    async updateTools(model, tools) {
+        const toolNames = ( new Set(tools.value));
+        const selectedToolsNow = ( new Map());
+        for (const tool of this.languageModelToolsService.getTools()) {
+            selectedToolsNow.set(tool, ( toolNames.has(tool.toolReferenceName ?? tool.displayName)));
+        }
+        for (const toolSet of this.languageModelToolsService.toolSets.get()) {
+            selectedToolsNow.set(toolSet, ( toolNames.has(toolSet.referenceName)));
+        }
+        const newSelectedAfter = await this.instantiationService.invokeFunction(showToolsPicker, ( localize(5078, "Select tools")), selectedToolsNow);
+        if (!newSelectedAfter) {
+            return;
+        }
+        const newToolNames = [];
+        for (const [item, picked] of newSelectedAfter) {
+            if (picked) {
+                if (item instanceof ToolSet) {
+                    newToolNames.push(item.referenceName);
+                }
+                else {
+                    newToolNames.push(item.toolReferenceName ?? item.displayName);
+                }
+            }
+        }
+        model.pushStackElement();
+        model.pushEditOperations(null, [EditOperation.replaceMove(tools.range, `tools: [${( newToolNames.map(s => `'${s}'`)).join(', ')}]`)], () => null);
+        model.pushStackElement();
+    }
+};
+PromptToolsCodeLensProvider = ( __decorate([
+    ( __param(0, IPromptsService)),
+    ( __param(1, ILanguageFeaturesService)),
+    ( __param(2, ILanguageModelToolsService)),
+    ( __param(3, IInstantiationService))
+], PromptToolsCodeLensProvider));
+registerEditorFeature(PromptToolsCodeLensProvider);

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

@@ -0,0 +1,24 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IUserDataProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
+export declare class UserToolSetsContributions extends Disposable implements IWorkbenchContribution {
+    private readonly _languageModelToolsService;
+    private readonly _userDataProfileService;
+    private readonly _fileService;
+    private readonly _logService;
+    static readonly ID = "chat.userToolSets";
+    constructor(extensionService: IExtensionService, lifecycleService: ILifecycleService, _languageModelToolsService: ILanguageModelToolsService, _userDataProfileService: IUserDataProfileService, _fileService: IFileService, _logService: ILogService);
+    private _initToolSets;
+}
+export declare class ConfigureToolSets extends Action2 {
+    static readonly ID = "chat.configureToolSets";
+    constructor();
+    run(accessor: ServicesAccessor): Promise<void>;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/tools/toolSetsContribution.js

@@ -0,0 +1,348 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { isFalsyOrEmpty } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { basename, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { isFalsyOrWhitespace } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { isObject, assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { CHAT_CATEGORY } from '@codingame/monaco-vscode-3a35f433-1297-5707-ab58-c261b8180e6d-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { getAllCodicons, Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { isValidBasename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/extpath';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { parse } from '@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/base/common/jsonc';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { ChatViewId } from '@codingame/monaco-vscode-7adbeffb-8051-54a9-8c9b-b62ce9e5836f-common/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+const toolEnumValues = [];
+const toolEnumDescriptions = [];
+const toolSetSchemaId = 'vscode://schemas/toolsets';
+const toolSetsSchema = {
+    id: toolSetSchemaId,
+    allowComments: true,
+    allowTrailingCommas: true,
+    defaultSnippets: [{
+            label: ( localize(5079, "Empty tool set")),
+            body: { '${1:toolSetName}': { 'tools': ['${2:someTool}', '${3:anotherTool}'], 'description': '${4:description}', 'icon': '${5:tools}' } }
+        }],
+    type: 'object',
+    description: ( localize(5080, 'User tool sets configuration')),
+    additionalProperties: {
+        type: 'object',
+        required: ['tools'],
+        additionalProperties: false,
+        properties: {
+            tools: {
+                description: ( localize(
+                    5081,
+                    "A list of tools or tool sets to include in this tool set. Cannot be empty and must reference tools the way they are referenced in prompts."
+                )),
+                type: 'array',
+                minItems: 1,
+                items: {
+                    type: 'string',
+                    enum: toolEnumValues,
+                    enumDescriptions: toolEnumDescriptions,
+                }
+            },
+            icon: {
+                description: ( localize(
+                    5082,
+                    "Icon to use for this tool set in the UI. Uses the `\\$(name)`-syntax, like `\\$(zap)`"
+                )),
+                type: 'string',
+                enum: Array.from(getAllCodicons(), icon => icon.id),
+                markdownEnumDescriptions: Array.from(getAllCodicons(), icon => `$(${icon.id})`),
+            },
+            description: {
+                description: ( localize(5083, "A short description of this tool set.")),
+                type: 'string'
+            },
+        },
+    }
+};
+const reg = ( Registry.as(Extensions.JSONContribution));
+class RawToolSetsShape {
+    static { this.suffix = '.toolsets.jsonc'; }
+    static isToolSetFileName(uri) {
+        return basename(uri).endsWith(RawToolSetsShape.suffix);
+    }
+    static from(data, logService) {
+        if (!isObject(data)) {
+            throw ( new Error(`Invalid tool set data`));
+        }
+        const map = ( new Map());
+        for (const [name, value] of Object.entries(data)) {
+            if (isFalsyOrWhitespace(name)) {
+                logService.error(`Tool set name cannot be empty`);
+            }
+            if (isFalsyOrEmpty(value.tools)) {
+                logService.error(`Tool set '${name}' cannot have an empty tools array`);
+            }
+            map.set(name, {
+                name,
+                tools: value.tools,
+                description: value.description,
+                icon: value.icon,
+            });
+        }
+        return new class extends RawToolSetsShape {
+        }(map);
+    }
+    constructor(entries) {
+        this.entries = ( Object.freeze(( new Map(entries))));
+    }
+}
+let UserToolSetsContributions = class UserToolSetsContributions extends Disposable {
+    static { this.ID = 'chat.userToolSets'; }
+    constructor(extensionService, lifecycleService, _languageModelToolsService, _userDataProfileService, _fileService, _logService) {
+        super();
+        this._languageModelToolsService = _languageModelToolsService;
+        this._userDataProfileService = _userDataProfileService;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        Promise.allSettled([
+            extensionService.whenInstalledExtensionsRegistered,
+            lifecycleService.when(LifecyclePhase.Restored)
+        ]).then(() => this._initToolSets());
+        const toolsObs = observableFromEvent(this, _languageModelToolsService.onDidChangeTools, () => Array.from(_languageModelToolsService.getTools()));
+        const store = this._store.add(( new DisposableStore()));
+        this._store.add(autorun(r => {
+            const tools = toolsObs.read(r);
+            const toolSets = this._languageModelToolsService.toolSets.read(r);
+            const data = [];
+            for (const tool of tools) {
+                if (tool.canBeReferencedInPrompt) {
+                    data.push({
+                        name: tool.toolReferenceName ?? tool.displayName,
+                        sourceLabel: ToolDataSource.classify(tool.source).label,
+                        sourceOrdinal: ToolDataSource.classify(tool.source).ordinal,
+                        description: tool.userDescription ?? tool.modelDescription
+                    });
+                }
+            }
+            for (const toolSet of toolSets) {
+                data.push({
+                    name: toolSet.referenceName,
+                    sourceLabel: ToolDataSource.classify(toolSet.source).label,
+                    sourceOrdinal: ToolDataSource.classify(toolSet.source).ordinal,
+                    description: toolSet.description
+                });
+            }
+            toolEnumValues.length = 0;
+            toolEnumDescriptions.length = 0;
+            data.sort((a, b) => {
+                if (a.sourceOrdinal !== b.sourceOrdinal) {
+                    return a.sourceOrdinal - b.sourceOrdinal;
+                }
+                if (a.sourceLabel !== b.sourceLabel) {
+                    return a.sourceLabel.localeCompare(b.sourceLabel);
+                }
+                return a.name.localeCompare(b.name);
+            });
+            for (const item of data) {
+                toolEnumValues.push(item.name);
+                toolEnumDescriptions.push(( localize(5084, "{1} ({0})\n\n{2}", item.sourceLabel, item.name, item.description)));
+            }
+            store.clear();
+            reg.registerSchema(toolSetSchemaId, toolSetsSchema, store);
+        }));
+    }
+    _initToolSets() {
+        const promptFolder = observableFromEvent(this, this._userDataProfileService.onDidChangeCurrentProfile, () => this._userDataProfileService.currentProfile.promptsHome);
+        const toolsSig = observableSignalFromEvent(this, this._languageModelToolsService.onDidChangeTools);
+        const fileEventSig = observableSignalFromEvent(this, Event.filter(this._fileService.onDidFilesChange, e => e.affects(promptFolder.get())));
+        const store = this._store.add(( new DisposableStore()));
+        const getFilesInFolder = async (folder) => {
+            try {
+                return (await this._fileService.resolve(folder)).children ?? [];
+            }
+            catch (err) {
+                return [];
+            }
+        };
+        this._store.add(autorun(async (r) => {
+            store.clear();
+            toolsSig.read(r);
+            fileEventSig.read(r);
+            const uri = promptFolder.read(r);
+            const cts = ( new CancellationTokenSource());
+            store.add(toDisposable(() => cts.dispose(true)));
+            const entries = await getFilesInFolder(uri);
+            if (cts.token.isCancellationRequested) {
+                store.clear();
+                return;
+            }
+            for (const entry of entries) {
+                if (!entry.isFile || !RawToolSetsShape.isToolSetFileName(entry.resource)) {
+                    continue;
+                }
+                store.add(this._fileService.watch(entry.resource));
+                let data;
+                try {
+                    const content = await this._fileService.readFile(entry.resource, undefined, cts.token);
+                    const rawObj = parse(( content.value.toString()));
+                    data = RawToolSetsShape.from(rawObj, this._logService);
+                }
+                catch (err) {
+                    this._logService.error(`Error reading tool set file ${( entry.resource.toString())}:`, err);
+                    continue;
+                }
+                if (cts.token.isCancellationRequested) {
+                    store.dispose();
+                    break;
+                }
+                for (const [name, value] of data.entries) {
+                    const tools = [];
+                    const toolSets = [];
+                    value.tools.forEach(name => {
+                        const tool = this._languageModelToolsService.getToolByName(name);
+                        if (tool) {
+                            tools.push(tool);
+                            return;
+                        }
+                        const toolSet = this._languageModelToolsService.getToolSetByName(name);
+                        if (toolSet) {
+                            toolSets.push(toolSet);
+                            return;
+                        }
+                    });
+                    if (tools.length === 0 && toolSets.length === 0) {
+                        continue;
+                    }
+                    const toolset = this._languageModelToolsService.createToolSet({ type: 'user', file: entry.resource, label: basename(entry.resource) }, `user/${( entry.resource.toString())}/${name}`, name, {
+                        icon: value.icon ? ThemeIcon.fromId(value.icon) : undefined,
+                        description: value.description
+                    });
+                    transaction(tx => {
+                        store.add(toolset);
+                        tools.forEach(tool => store.add(toolset.addTool(tool, tx)));
+                        toolSets.forEach(toolSet => store.add(toolset.addToolSet(toolSet, tx)));
+                    });
+                }
+            }
+        }));
+    }
+};
+UserToolSetsContributions = ( __decorate([
+    ( __param(0, IExtensionService)),
+    ( __param(1, ILifecycleService)),
+    ( __param(2, ILanguageModelToolsService)),
+    ( __param(3, IUserDataProfileService)),
+    ( __param(4, IFileService)),
+    ( __param(5, ILogService))
+], UserToolSetsContributions));
+class ConfigureToolSets extends Action2 {
+    static { this.ID = 'chat.configureToolSets'; }
+    constructor() {
+        super({
+            id: ConfigureToolSets.ID,
+            title: ( localize2(5085, 'Configure Tool Sets')),
+            category: CHAT_CATEGORY,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ChatContextKeys.Tools.toolsCount.greater(0))),
+            menu: {
+                id: MenuId.ViewTitle,
+                when: ( ContextKeyExpr.equals('view', ChatViewId)),
+                order: 11,
+                group: '2_manage'
+            },
+        });
+    }
+    async run(accessor) {
+        const toolsService = accessor.get(ILanguageModelToolsService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const editorService = accessor.get(IEditorService);
+        const userDataProfileService = accessor.get(IUserDataProfileService);
+        const fileService = accessor.get(IFileService);
+        const textFileService = accessor.get(ITextFileService);
+        const picks = [];
+        picks.push({
+            label: ( localize(5086, 'Create new tool sets file...')),
+            alwaysShow: true,
+            iconClass: ThemeIcon.asClassName(Codicon.plus)
+        });
+        for (const toolSet of toolsService.toolSets.get()) {
+            if (toolSet.source.type !== 'user') {
+                continue;
+            }
+            picks.push({
+                label: toolSet.referenceName,
+                toolset: toolSet,
+                tooltip: toolSet.description,
+                iconClass: ThemeIcon.asClassName(toolSet.icon)
+            });
+        }
+        const pick = await quickInputService.pick(picks, {
+            canPickMany: false,
+            placeHolder: ( localize(5087, 'Select a tool set to configure')),
+        });
+        if (!pick) {
+            return;
+        }
+        let resource;
+        if (!pick.toolset) {
+            const name = await quickInputService.input({
+                placeHolder: ( localize(5088, "Type tool sets file name")),
+                validateInput: async (input) => {
+                    if (!input) {
+                        return localize(5089, "Invalid file name");
+                    }
+                    if (!isValidBasename(input)) {
+                        return localize(5090, "'{0}' is not a valid file name", input);
+                    }
+                    return undefined;
+                }
+            });
+            if (isFalsyOrWhitespace(name)) {
+                return;
+            }
+            resource = joinPath(userDataProfileService.currentProfile.promptsHome, `${name}${RawToolSetsShape.suffix}`);
+            if (!(await fileService.exists(resource))) {
+                await textFileService.write(resource, [
+                    '// Place your tool sets here...',
+                    '// Example:',
+                    '// {',
+                    '// \t"toolSetName": {',
+                    '// \t\t"tools": [',
+                    '// \t\t\t"someTool",',
+                    '// \t\t\t"anotherTool"',
+                    '// \t\t],',
+                    '// \t\t"description": "description",',
+                    '// \t\t"icon": "tools"',
+                    '// \t}',
+                    '// }',
+                ].join('\n'));
+            }
+        }
+        else {
+            assertType(pick.toolset.source.type === 'user');
+            resource = pick.toolset.source.file;
+        }
+        await editorService.openEditor({ resource, options: { pinned: true } });
+    }
+}
+
+export { ConfigureToolSets, UserToolSetsContributions };

package/vscode/src/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcomeHandler.js

@@ -13,7 +13,7 @@ import { ChatViewsWelcomeExtensions } from '@codingame/monaco-vscode-c465110a-57
 const chatViewsWelcomeExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'chatViewsWelcome',
     jsonSchema: {
-        description: ( localize(4993, 'Contributes a welcome message to a chat view')),
+        description: ( localize(5092, 'Contributes a welcome message to a chat view')),
         type: 'array',
         items: {
             additionalProperties: false,
@@ -21,22 +21,22 @@ const chatViewsWelcomeExtensionPoint = ExtensionsRegistry.registerExtensionPoint
             properties: {
                 icon: {
                     type: 'string',
-                    description: ( localize(4994, 'The icon for the welcome message.')),
+                    description: ( localize(5093, 'The icon for the welcome message.')),
                 },
                 title: {
                     type: 'string',
-                    description: ( localize(4995, 'The title of the welcome message.')),
+                    description: ( localize(5094, 'The title of the welcome message.')),
                 },
                 content: {
                     type: 'string',
                     description: ( localize(
-                        4996,
+                        5095,
                         'The content of the welcome message. The first command link will be rendered as a button.'
                     )),
                 },
                 when: {
                     type: 'string',
-                    description: ( localize(4997, 'Condition when the welcome message is shown.')),
+                    description: ( localize(5096, 'Condition when the welcome message is shown.')),
                 }
             }
         },

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

@@ -1,6 +1,6 @@
 import { DeferredPromise } from "@codingame/monaco-vscode-api/vscode/vs/base/common/async";
 import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
-import { IChatTerminalToolInvocationData, IChatToolInputInvocationData, IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IChatExtensionsContent, IChatTerminalToolInvocationData, IChatToolInputInvocationData, IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
 import { IPreparedToolInvocation, IToolConfirmationMessages, IToolData, IToolProgressStep, IToolResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
 export declare class ChatToolInvocation implements IChatToolInvocation {
     readonly toolCallId: string;
@@ -21,7 +21,7 @@ export declare class ChatToolInvocation implements IChatToolInvocation {
     private _confirmationMessages;
     readonly presentation: IPreparedToolInvocation["presentation"];
     readonly toolId: string;
-    readonly toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData;
+    readonly toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent;
     readonly progress: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").ISettableObservable<{
         message?: string | IMarkdownString;
         progress: number;

package/vscode/src/vs/workbench/contrib/chat/common/chatProgressTypes/chatToolInvocation.js

@@ -2,7 +2,7 @@
 import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 
 class ChatToolInvocation {
     get isComplete() {
@@ -27,7 +27,7 @@ class ChatToolInvocation {
         this._isCompleteDeferred = ( new DeferredPromise());
         this._confirmDeferred = ( new DeferredPromise());
         this.progress = observableValue(this, { progress: 0 });
-        const defaultMessage = ( localize(5053, "Using {0}", `"${toolData.displayName}"`));
+        const defaultMessage = ( localize(5161, "Using {0}", `"${toolData.displayName}"`));
         const invocationMessage = preparedInvocation?.invocationMessage ?? defaultMessage;
         this.invocationMessage = invocationMessage;
         this.pastTenseMessage = preparedInvocation?.pastTenseMessage;

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

@@ -0,0 +1,30 @@
+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 { ReadableStreamEvents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/stream";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { FileSystemProviderCapabilities, FileType, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileReadWriteCapability, IStat } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+export declare class ChatResponseResourceFileSystemProvider extends Disposable implements IWorkbenchContribution, IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileReadStreamCapability {
+    private readonly chatService;
+    private readonly _fileService;
+    static readonly ID = "workbench.contrib.chatResponseResourceFileSystemProvider";
+    readonly onDidChangeCapabilities: Event<any>;
+    readonly onDidChangeFile: Event<any>;
+    readonly capabilities: FileSystemProviderCapabilities;
+    constructor(chatService: IChatService, _fileService: IFileService);
+    readFile(resource: URI): Promise<Uint8Array>;
+    readFileStream(resource: URI): ReadableStreamEvents<Uint8Array>;
+    stat(resource: URI): Promise<IStat>;
+    delete(): Promise<void>;
+    watch(): IDisposable;
+    mkdir(): Promise<void>;
+    readdir(): Promise<[
+        string,
+        FileType
+    ][]>;
+    rename(): Promise<void>;
+    writeFile(): Promise<void>;
+    private lookupURI;
+}