@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,43 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IInstantiationService, ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IChatAgentCommand, IChatAgentData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
+import { IParsedChatRequest } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParserTypes";
+import { IChatMarkdownContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatMarkdownAnchorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatMarkdownAnchorService.service";
+export declare function agentToMarkdown(agent: IChatAgentData, sessionResource: URI, isClickable: boolean, accessor: ServicesAccessor): string;
+export declare function agentSlashCommandToMarkdown(agent: IChatAgentData, command: IChatAgentCommand, sessionResource: URI): string;
+export interface IDecorationWidgetArgs {
+    title?: string;
+}
+export declare class ChatMarkdownDecorationsRenderer {
+    private readonly keybindingService;
+    private readonly logService;
+    private readonly chatAgentService;
+    private readonly instantiationService;
+    private readonly hoverService;
+    private readonly chatService;
+    private readonly chatWidgetService;
+    private readonly commandService;
+    private readonly labelService;
+    private readonly toolsService;
+    private readonly chatMarkdownAnchorService;
+    constructor(keybindingService: IKeybindingService, logService: ILogService, chatAgentService: IChatAgentService, instantiationService: IInstantiationService, hoverService: IHoverService, chatService: IChatService, chatWidgetService: IChatWidgetService, commandService: ICommandService, labelService: ILabelService, toolsService: ILanguageModelToolsService, chatMarkdownAnchorService: IChatMarkdownAnchorService);
+    convertParsedRequestToMarkdown(sessionResource: URI, parsedRequest: IParsedChatRequest): string;
+    private genericDecorationToMarkdown;
+    walkTreeAndAnnotateReferenceLinks(content: IChatMarkdownContent, element: HTMLElement): IDisposable;
+    private renderAgentWidget;
+    private renderSlashCommandWidget;
+    private renderFileWidget;
+    private renderResourceWidget;
+    private injectKeybindingHint;
+}

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

@@ -0,0 +1,249 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { asCssVariable } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import { contentRefUrl } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/annotations';
+import { getFullyQualifiedId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { IChatAgentNameService, IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { chatSlashCommandForeground, chatSlashCommandBackground } from '../common/chatColors.js';
+import { chatSubcommandLeader, ChatRequestTextPart, ChatRequestAgentPart, ChatRequestDynamicVariablePart, ChatRequestSlashCommandPart, ChatRequestAgentSubcommandPart, ChatRequestSlashPromptPart, ChatRequestToolPart, chatAgentLeader } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatAgentHover, getChatAgentHoverOptions } from './chatAgentHover.js';
+import { IChatMarkdownAnchorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatMarkdownAnchorService.service';
+import { InlineAnchorWidget } from './chatInlineAnchorWidget.js';
+import * as chatInlineAnchorWidget from './media/chatInlineAnchorWidget.css';
+
+registerCss(chatInlineAnchorWidget);
+const decorationRefUrl = `http://_vscodedecoration_`;
+const agentRefUrl = `http://_chatagent_`;
+const agentSlashRefUrl = `http://_chatslash_`;
+function agentToMarkdown(agent, sessionResource, isClickable, accessor) {
+    const chatAgentNameService = accessor.get(IChatAgentNameService);
+    const chatAgentService = accessor.get(IChatAgentService);
+    const isAllowed = chatAgentNameService.getAgentNameRestriction(agent);
+    let name = `${isAllowed ? agent.name : getFullyQualifiedId(agent)}`;
+    const isDupe = isAllowed && chatAgentService.agentHasDupeName(agent.id);
+    if (isDupe) {
+        name += ` (${agent.publisherDisplayName})`;
+    }
+    const args = { agentId: agent.id, sessionResource, name, isClickable };
+    return `[${agent.name}](${agentRefUrl}?${encodeURIComponent(JSON.stringify(args))})`;
+}
+function agentSlashCommandToMarkdown(agent, command, sessionResource) {
+    const text = `${chatSubcommandLeader}${command.name}`;
+    const args = { agentId: agent.id, command: command.name, sessionResource };
+    return `[${text}](${agentSlashRefUrl}?${encodeURIComponent(JSON.stringify(args))})`;
+}
+let ChatMarkdownDecorationsRenderer = class ChatMarkdownDecorationsRenderer {
+    constructor(keybindingService, logService, chatAgentService, instantiationService, hoverService, chatService, chatWidgetService, commandService, labelService, toolsService, chatMarkdownAnchorService) {
+        this.keybindingService = keybindingService;
+        this.logService = logService;
+        this.chatAgentService = chatAgentService;
+        this.instantiationService = instantiationService;
+        this.hoverService = hoverService;
+        this.chatService = chatService;
+        this.chatWidgetService = chatWidgetService;
+        this.commandService = commandService;
+        this.labelService = labelService;
+        this.toolsService = toolsService;
+        this.chatMarkdownAnchorService = chatMarkdownAnchorService;
+    }
+    convertParsedRequestToMarkdown(sessionResource, parsedRequest) {
+        let result = '';
+        for (const part of parsedRequest.parts) {
+            if (part instanceof ChatRequestTextPart) {
+                result += part.text;
+            }
+            else if (part instanceof ChatRequestAgentPart) {
+                result += this.instantiationService.invokeFunction(accessor => agentToMarkdown(part.agent, sessionResource, false, accessor));
+            }
+            else {
+                result += this.genericDecorationToMarkdown(part);
+            }
+        }
+        return result;
+    }
+    genericDecorationToMarkdown(part) {
+        const uri = part instanceof ChatRequestDynamicVariablePart && part.data instanceof URI ?
+            part.data :
+            undefined;
+        const title = uri ? this.labelService.getUriLabel(uri, { relative: true }) :
+            part instanceof ChatRequestSlashCommandPart ? part.slashCommand.detail :
+                part instanceof ChatRequestAgentSubcommandPart ? part.command.description :
+                    part instanceof ChatRequestSlashPromptPart ? part.name :
+                        part instanceof ChatRequestToolPart ? (this.toolsService.getTool(part.toolId)?.userDescription) :
+                            '';
+        const args = { title };
+        const text = part.text;
+        return `[${text}](${decorationRefUrl}?${encodeURIComponent(JSON.stringify(args))})`;
+    }
+    walkTreeAndAnnotateReferenceLinks(content, element) {
+        const store = ( new DisposableStore());
+        element.querySelectorAll('a').forEach(a => {
+            const href = a.getAttribute('data-href');
+            if (href) {
+                if (href.startsWith(agentRefUrl)) {
+                    let args;
+                    try {
+                        args = JSON.parse(decodeURIComponent(href.slice(agentRefUrl.length + 1)));
+                    }
+                    catch (e) {
+                        this.logService.error('Invalid chat widget render data JSON', toErrorMessage(e));
+                    }
+                    if (args) {
+                        a.replaceWith(this.renderAgentWidget(args, store));
+                    }
+                }
+                else if (href.startsWith(agentSlashRefUrl)) {
+                    let args;
+                    try {
+                        args = JSON.parse(decodeURIComponent(href.slice(agentRefUrl.length + 1)));
+                    }
+                    catch (e) {
+                        this.logService.error('Invalid chat slash command render data JSON', toErrorMessage(e));
+                    }
+                    if (args) {
+                        a.replaceWith(this.renderSlashCommandWidget(a.textContent, args, store));
+                    }
+                }
+                else if (href.startsWith(decorationRefUrl)) {
+                    let args;
+                    try {
+                        args = JSON.parse(decodeURIComponent(href.slice(decorationRefUrl.length + 1)));
+                    }
+                    catch (e) { }
+                    a.replaceWith(this.renderResourceWidget(a.textContent, args, store));
+                }
+                else if (href.startsWith(contentRefUrl)) {
+                    this.renderFileWidget(content, href, a, store);
+                }
+                else if (href.startsWith('command:')) {
+                    this.injectKeybindingHint(a, href, this.keybindingService);
+                }
+            }
+        });
+        return store;
+    }
+    renderAgentWidget(args, store) {
+        const nameWithLeader = `${chatAgentLeader}${args.name}`;
+        let container;
+        if (args.isClickable) {
+            container = $('span.chat-agent-widget');
+            const button = store.add(( new Button(container, {
+                buttonBackground: asCssVariable(chatSlashCommandBackground),
+                buttonForeground: asCssVariable(chatSlashCommandForeground),
+                buttonHoverBackground: undefined
+            })));
+            button.label = nameWithLeader;
+            store.add(button.onDidClick(() => {
+                const agent = this.chatAgentService.getAgent(args.agentId);
+                const widget = this.chatWidgetService.getWidgetBySessionResource(args.sessionResource) || this.chatWidgetService.lastFocusedWidget;
+                if (!widget || !agent) {
+                    return;
+                }
+                this.chatService.sendRequest(widget.viewModel.sessionResource, agent.metadata.sampleRequest ?? '', {
+                    location: widget.location,
+                    agentId: agent.id,
+                    userSelectedModelId: widget.input.currentLanguageModel,
+                    modeInfo: widget.input.currentModeInfo
+                });
+            }));
+        }
+        else {
+            container = this.renderResourceWidget(nameWithLeader, undefined, store);
+        }
+        const agent = this.chatAgentService.getAgent(args.agentId);
+        const hover = ( new Lazy(() => store.add(this.instantiationService.createInstance(ChatAgentHover))));
+        store.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('element'), container, () => {
+            hover.value.setAgent(args.agentId);
+            return hover.value.domNode;
+        }, agent && getChatAgentHoverOptions(() => agent, this.commandService)));
+        return container;
+    }
+    renderSlashCommandWidget(name, args, store) {
+        const container = $('span.chat-agent-widget.chat-command-widget');
+        const agent = this.chatAgentService.getAgent(args.agentId);
+        const button = store.add(( new Button(container, {
+            buttonBackground: asCssVariable(chatSlashCommandBackground),
+            buttonForeground: asCssVariable(chatSlashCommandForeground),
+            buttonHoverBackground: undefined
+        })));
+        button.label = name;
+        store.add(button.onDidClick(() => {
+            const widget = this.chatWidgetService.getWidgetBySessionResource(args.sessionResource) || this.chatWidgetService.lastFocusedWidget;
+            if (!widget || !agent) {
+                return;
+            }
+            const command = agent.slashCommands.find(c => c.name === args.command);
+            this.chatService.sendRequest(widget.viewModel.sessionResource, command?.sampleRequest ?? '', {
+                location: widget.location,
+                agentId: agent.id,
+                slashCommand: args.command,
+                userSelectedModelId: widget.input.currentLanguageModel,
+                modeInfo: widget.input.currentModeInfo
+            });
+        }));
+        return container;
+    }
+    renderFileWidget(content, href, a, store) {
+        const fullUri = ( URI.parse(href));
+        const data = content.inlineReferences?.[fullUri.path.slice(1)];
+        if (!data) {
+            this.logService.error('Invalid chat widget render data JSON');
+            return;
+        }
+        const inlineAnchor = store.add(this.instantiationService.createInstance(InlineAnchorWidget, a, data));
+        store.add(this.chatMarkdownAnchorService.register(inlineAnchor));
+    }
+    renderResourceWidget(name, args, store) {
+        const container = $('span.chat-resource-widget');
+        const alias = $('span', undefined, name);
+        if (args?.title) {
+            store.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('element'), container, args.title));
+        }
+        container.appendChild(alias);
+        return container;
+    }
+    injectKeybindingHint(a, href, keybindingService) {
+        const command = href.match(/command:([^\)]+)/)?.[1];
+        if (command) {
+            const kb = keybindingService.lookupKeybinding(command);
+            if (kb) {
+                const keybinding = kb.getLabel();
+                if (keybinding) {
+                    a.textContent = `${a.textContent} (${keybinding})`;
+                }
+            }
+        }
+    }
+};
+ChatMarkdownDecorationsRenderer = ( __decorate([
+    ( __param(0, IKeybindingService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IChatAgentService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IHoverService)),
+    ( __param(5, IChatService)),
+    ( __param(6, IChatWidgetService)),
+    ( __param(7, ICommandService)),
+    ( __param(8, ILabelService)),
+    ( __param(9, ILanguageModelToolsService)),
+    ( __param(10, IChatMarkdownAnchorService))
+], ChatMarkdownDecorationsRenderer));
+
+export { ChatMarkdownDecorationsRenderer, agentSlashCommandToMarkdown, agentToMarkdown };

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

@@ -0,0 +1,50 @@
+import { Color } from "@codingame/monaco-vscode-api/vscode/vs/base/common/color";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IBracketPairColorizationOptions } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IViewDescriptorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service";
+export interface IChatConfiguration {
+    editor: {
+        readonly fontSize: number;
+        readonly fontFamily: string;
+        readonly lineHeight: number;
+        readonly fontWeight: string;
+        readonly wordWrap: "off" | "on";
+    };
+}
+export interface IChatEditorConfiguration {
+    readonly foreground: Color | undefined;
+    readonly inputEditor: IChatInputEditorOptions;
+    readonly resultEditor: IChatResultEditorOptions;
+}
+export interface IChatInputEditorOptions {
+    readonly backgroundColor: Color | undefined;
+    readonly accessibilitySupport: string;
+}
+export interface IChatResultEditorOptions {
+    readonly fontSize: number;
+    readonly fontFamily: string | undefined;
+    readonly lineHeight: number;
+    readonly fontWeight: string;
+    readonly backgroundColor: Color | undefined;
+    readonly bracketPairColorization: IBracketPairColorizationOptions;
+    readonly fontLigatures: boolean | string | undefined;
+    readonly wordWrap: "off" | "on";
+}
+export declare class ChatEditorOptions extends Disposable {
+    private readonly foreground;
+    private readonly inputEditorBackgroundColor;
+    private readonly resultEditorBackgroundColor;
+    private readonly configurationService;
+    private readonly themeService;
+    private readonly viewDescriptorService;
+    private static readonly lineHeightEm;
+    private readonly _onDidChange;
+    readonly onDidChange: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private _config;
+    get configuration(): IChatEditorConfiguration;
+    private static readonly relevantSettingIds;
+    constructor(viewId: string | undefined, foreground: string, inputEditorBackgroundColor: string, resultEditorBackgroundColor: string, configurationService: IConfigurationService, themeService: IThemeService, viewDescriptorService: IViewDescriptorService);
+    private update;
+}

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

@@ -0,0 +1,84 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
+
+var ChatEditorOptions_1;
+let ChatEditorOptions = class ChatEditorOptions extends Disposable {
+    static { ChatEditorOptions_1 = this; }
+    static { this.lineHeightEm = 1.4; }
+    get configuration() {
+        return this._config;
+    }
+    static { this.relevantSettingIds = [
+        'chat.editor.lineHeight',
+        'chat.editor.fontSize',
+        'chat.editor.fontFamily',
+        'chat.editor.fontWeight',
+        'chat.editor.wordWrap',
+        'editor.cursorBlinking',
+        'editor.fontLigatures',
+        'editor.accessibilitySupport',
+        'editor.bracketPairColorization.enabled',
+        'editor.bracketPairColorization.independentColorPoolPerBracketType',
+    ]; }
+    constructor(viewId, foreground, inputEditorBackgroundColor, resultEditorBackgroundColor, configurationService, themeService, viewDescriptorService) {
+        super();
+        this.foreground = foreground;
+        this.inputEditorBackgroundColor = inputEditorBackgroundColor;
+        this.resultEditorBackgroundColor = resultEditorBackgroundColor;
+        this.configurationService = configurationService;
+        this.themeService = themeService;
+        this.viewDescriptorService = viewDescriptorService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._register(this.themeService.onDidColorThemeChange(e => this.update()));
+        this._register(this.viewDescriptorService.onDidChangeLocation(e => {
+            if (( e.views.some(v => v.id === viewId))) {
+                this.update();
+            }
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (( ChatEditorOptions_1.relevantSettingIds.some(id => e.affectsConfiguration(id)))) {
+                this.update();
+            }
+        }));
+        this.update();
+    }
+    update() {
+        const editorConfig = this.configurationService.getValue('editor');
+        const chatEditorConfig = this.configurationService.getValue('chat')?.editor;
+        const accessibilitySupport = this.configurationService.getValue('editor.accessibilitySupport');
+        this._config = {
+            foreground: this.themeService.getColorTheme().getColor(this.foreground),
+            inputEditor: {
+                backgroundColor: this.themeService.getColorTheme().getColor(this.inputEditorBackgroundColor),
+                accessibilitySupport,
+            },
+            resultEditor: {
+                backgroundColor: this.themeService.getColorTheme().getColor(this.resultEditorBackgroundColor),
+                fontSize: chatEditorConfig.fontSize,
+                fontFamily: chatEditorConfig.fontFamily === 'default' ? editorConfig.fontFamily : chatEditorConfig.fontFamily,
+                fontWeight: chatEditorConfig.fontWeight,
+                lineHeight: chatEditorConfig.lineHeight ? chatEditorConfig.lineHeight : ChatEditorOptions_1.lineHeightEm * chatEditorConfig.fontSize,
+                bracketPairColorization: {
+                    enabled: this.configurationService.getValue('editor.bracketPairColorization.enabled'),
+                    independentColorPoolPerBracketType: this.configurationService.getValue('editor.bracketPairColorization.independentColorPoolPerBracketType'),
+                },
+                wordWrap: chatEditorConfig.wordWrap,
+                fontLigatures: editorConfig.fontLigatures,
+            }
+        };
+        this._onDidChange.fire();
+    }
+};
+ChatEditorOptions = ChatEditorOptions_1 = ( __decorate([
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, IViewDescriptorService))
+], ChatEditorOptions));
+
+export { ChatEditorOptions };

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

@@ -0,0 +1,32 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { UserSelectedTools } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { IChatMode } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes";
+import { IToolAndToolSetEnablementMap } 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";
+export declare enum ToolsScope {
+    Global = 0,
+    Session = 1,
+    Agent = 2,
+    Agent_ReadOnly = 3
+}
+export declare class ChatSelectedTools extends Disposable {
+    private readonly _mode;
+    private readonly _toolsService;
+    private readonly _instantiationService;
+    private readonly _globalState;
+    private readonly _sessionStates;
+    constructor(_mode: IObservable<IChatMode>, _toolsService: ILanguageModelToolsService, _storageService: IStorageService, _instantiationService: IInstantiationService);
+    /**
+     * All tools and tool sets with their enabled state.
+     */
+    readonly entriesMap: IObservable<IToolAndToolSetEnablementMap>;
+    readonly userSelectedTools: IObservable<UserSelectedTools>;
+    get entriesScope(): ToolsScope;
+    get currentMode(): IChatMode;
+    resetSessionEnablementState(): void;
+    set(enablementMap: IToolAndToolSetEnablementMap, sessionOnly: boolean): void;
+    private updateCustomModeTools;
+}

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

@@ -0,0 +1,174 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { observableMemento } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/observableMemento';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+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 { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { PromptFileRewriter } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/promptSyntax/promptFileRewriter';
+import { ObservableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/map';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+var ToolEnablementStates;
+(function (ToolEnablementStates) {
+    function fromMap(map) {
+        const toolSets = ( new Map()), tools = ( new Map());
+        for (const [entry, enabled] of map.entries()) {
+            if (entry instanceof ToolSet) {
+                toolSets.set(entry.id, enabled);
+            }
+            else {
+                tools.set(entry.id, enabled);
+            }
+        }
+        return { toolSets, tools };
+    }
+    ToolEnablementStates.fromMap = fromMap;
+    function isStoredDataV1(data) {
+        return isObject(data) && data.version === undefined
+            && (data.disabledTools === undefined || Array.isArray(data.disabledTools))
+            && (data.disabledToolSets === undefined || Array.isArray(data.disabledToolSets));
+    }
+    function isStoredDataV2(data) {
+        return isObject(data) && data.version === 2 && Array.isArray(data.toolSetEntries) && Array.isArray(data.toolEntries);
+    }
+    function fromStorage(storage) {
+        try {
+            const parsed = JSON.parse(storage);
+            if (isStoredDataV2(parsed)) {
+                return { toolSets: ( new Map(parsed.toolSetEntries)), tools: ( new Map(parsed.toolEntries)) };
+            }
+            else if (isStoredDataV1(parsed)) {
+                const toolSetEntries = parsed.disabledToolSets?.map(id => [id, false]);
+                const toolEntries = parsed.disabledTools?.map(id => [id, false]);
+                return { toolSets: ( new Map(toolSetEntries)), tools: ( new Map(toolEntries)) };
+            }
+        }
+        catch {
+        }
+        return { toolSets: ( new Map()), tools: ( new Map()) };
+    }
+    ToolEnablementStates.fromStorage = fromStorage;
+    function toStorage(state) {
+        const storageData = {
+            version: 2,
+            toolSetEntries: Array.from(state.toolSets.entries()),
+            toolEntries: Array.from(state.tools.entries())
+        };
+        return JSON.stringify(storageData);
+    }
+    ToolEnablementStates.toStorage = toStorage;
+})(ToolEnablementStates || (ToolEnablementStates = {}));
+var ToolsScope;
+(function (ToolsScope) {
+    ToolsScope[ToolsScope["Global"] = 0] = "Global";
+    ToolsScope[ToolsScope["Session"] = 1] = "Session";
+    ToolsScope[ToolsScope["Agent"] = 2] = "Agent";
+    ToolsScope[ToolsScope["Agent_ReadOnly"] = 3] = "Agent_ReadOnly";
+})(ToolsScope || (ToolsScope = {}));
+let ChatSelectedTools = class ChatSelectedTools extends Disposable {
+    constructor(_mode, _toolsService, _storageService, _instantiationService) {
+        super();
+        this._mode = _mode;
+        this._toolsService = _toolsService;
+        this._instantiationService = _instantiationService;
+        this._sessionStates = ( new ObservableMap());
+        this.entriesMap = derived(r => {
+            const map = ( new Map());
+            const currentMode = this._mode.read(r);
+            let currentMap = this._sessionStates.observable.read(r).get(currentMode.id);
+            if (!currentMap && currentMode.kind === ChatModeKind.Agent) {
+                const modeTools = currentMode.customTools?.read(r);
+                if (modeTools) {
+                    const target = currentMode.target?.read(r);
+                    currentMap = ToolEnablementStates.fromMap(this._toolsService.toToolAndToolSetEnablementMap(modeTools, target));
+                }
+            }
+            if (!currentMap) {
+                currentMap = this._globalState.read(r);
+            }
+            for (const tool of this._toolsService.toolsObservable.read(r)) {
+                if (tool.canBeReferencedInPrompt) {
+                    map.set(tool, currentMap.tools.get(tool.id) !== false);
+                }
+            }
+            for (const toolSet of this._toolsService.toolSets.read(r)) {
+                const toolSetEnabled = currentMap.toolSets.get(toolSet.id) !== false;
+                map.set(toolSet, toolSetEnabled);
+                for (const tool of toolSet.getTools(r)) {
+                    map.set(tool, toolSetEnabled || currentMap.tools.get(tool.id) === true);
+                }
+            }
+            return map;
+        });
+        this.userSelectedTools = derived(r => {
+            const result = {};
+            const map = this.entriesMap.read(r);
+            for (const [item, enabled] of map) {
+                if (!(item instanceof ToolSet)) {
+                    result[item.id] = enabled;
+                }
+            }
+            return result;
+        });
+        const globalStateMemento = observableMemento({
+            key: 'chat/selectedTools',
+            defaultValue: { toolSets: ( new Map()), tools: ( new Map()) },
+            fromStorage: ToolEnablementStates.fromStorage,
+            toStorage: ToolEnablementStates.toStorage
+        });
+        this._globalState = this._store.add(globalStateMemento(StorageScope.PROFILE, StorageTarget.MACHINE, _storageService));
+    }
+    get entriesScope() {
+        const mode = this._mode.get();
+        if (( this._sessionStates.has(mode.id))) {
+            return ToolsScope.Session;
+        }
+        if (mode.kind === ChatModeKind.Agent && mode.customTools?.get() && mode.uri) {
+            return mode.source?.storage !== PromptsStorage.extension ? ToolsScope.Agent : ToolsScope.Agent_ReadOnly;
+        }
+        return ToolsScope.Global;
+    }
+    get currentMode() {
+        return this._mode.get();
+    }
+    resetSessionEnablementState() {
+        const mode = this._mode.get();
+        this._sessionStates.delete(mode.id);
+    }
+    set(enablementMap, sessionOnly) {
+        const mode = this._mode.get();
+        if (sessionOnly || ( this._sessionStates.has(mode.id))) {
+            this._sessionStates.set(mode.id, ToolEnablementStates.fromMap(enablementMap));
+            return;
+        }
+        if (mode.kind === ChatModeKind.Agent && mode.customTools?.get() && mode.uri) {
+            if (mode.source?.storage !== PromptsStorage.extension) {
+                this.updateCustomModeTools(mode.uri.get(), enablementMap);
+                return;
+            }
+            else {
+                this._sessionStates.set(mode.id, ToolEnablementStates.fromMap(enablementMap));
+                return;
+            }
+        }
+        this._globalState.set(ToolEnablementStates.fromMap(enablementMap), undefined);
+    }
+    async updateCustomModeTools(uri, enablementMap) {
+        await this._instantiationService.createInstance(PromptFileRewriter).openAndRewriteTools(uri, enablementMap, CancellationToken.None);
+    }
+};
+ChatSelectedTools = ( __decorate([
+    ( __param(1, ILanguageModelToolsService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IInstantiationService))
+], ChatSelectedTools));
+
+export { ChatSelectedTools, ToolsScope };