@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -38,54 +38,62 @@ import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/
 
 const toolEnumValues = [];
 const toolEnumDescriptions = [];
-const toolSetSchemaId = 'vscode://schemas/toolsets';
+const toolSetSchemaId = "vscode://schemas/toolsets";
 const toolSetsSchema = {
     id: toolSetSchemaId,
     allowComments: true,
     allowTrailingCommas: true,
     defaultSnippets: [{
-            label: ( localize(5584, "Empty tool set")),
-            body: { '${1:toolSetName}': { 'tools': ['${2:someTool}', '${3:anotherTool}'], 'description': '${4:description}', 'icon': '${5:tools}' } }
-        }],
-    type: 'object',
-    description: ( localize(5585, 'User tool sets configuration')),
+        label: ( localize(5803, "Empty tool set")),
+        body: {
+            "${1:toolSetName}": {
+                "tools": ["${2:someTool}", "${3:anotherTool}"],
+                "description": "${4:description}",
+                "icon": "${5:tools}"
+            }
+        }
+    }],
+    type: "object",
+    description: ( localize(5804, "User tool sets configuration")),
     additionalProperties: {
-        type: 'object',
-        required: ['tools'],
+        type: "object",
+        required: ["tools"],
         additionalProperties: false,
         properties: {
             tools: {
                 description: ( localize(
-                    5586,
+                    5805,
                     "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',
+                type: "array",
                 minItems: 1,
                 items: {
-                    type: 'string',
+                    type: "string",
                     enum: toolEnumValues,
-                    enumDescriptions: toolEnumDescriptions,
+                    enumDescriptions: toolEnumDescriptions
                 }
             },
             icon: {
                 description: ( localize(
-                    5587,
-                    'Icon to use for this tool set in the UI. Uses the "\\$(name)"-syntax, like "\\$(zap)"'
+                    5806,
+                    "Icon to use for this tool set in the UI. Uses the \"\\$(name)\"-syntax, like \"\\$(zap)\""
                 )),
-                type: 'string',
+                type: "string",
                 enum: Array.from(getAllCodicons(), icon => icon.id),
-                markdownEnumDescriptions: Array.from(getAllCodicons(), icon => `$(${icon.id})`),
+                markdownEnumDescriptions: Array.from(getAllCodicons(), icon => `$(${icon.id})`)
             },
             description: {
-                description: ( localize(5588, "A short description of this tool set.")),
-                type: 'string'
-            },
-        },
+                description: ( localize(5807, "A short description of this tool set.")),
+                type: "string"
+            }
+        }
     }
 };
 const reg = ( Registry.as(Extensions.JSONContribution));
 class RawToolSetsShape {
-    static { this.suffix = '.toolsets.jsonc'; }
+    static {
+        this.suffix = ".toolsets.jsonc";
+    }
     static isToolSetFileName(uri) {
         return basename(uri).endsWith(RawToolSetsShape.suffix);
     }
@@ -105,19 +113,27 @@ class RawToolSetsShape {
                 name,
                 tools: value.tools,
                 description: value.description,
-                icon: value.icon,
+                icon: value.icon
             });
         }
-        return new class extends RawToolSetsShape {
-        }(map);
+        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) {
+    static {
+        this.ID = "chat.userToolSets";
+    }
+    constructor(
+        extensionService,
+        lifecycleService,
+        _languageModelToolsService,
+        _userDataProfileService,
+        _fileService,
+        _logService
+    ) {
         super();
         this._languageModelToolsService = _languageModelToolsService;
         this._userDataProfileService = _userDataProfileService;
@@ -127,7 +143,11 @@ let UserToolSetsContributions = class UserToolSetsContributions extends Disposab
             extensionService.whenInstalledExtensionsRegistered,
             lifecycleService.when(LifecyclePhase.Restored)
         ]).then(() => this._initToolSets());
-        const toolsObs = observableFromEvent(this, _languageModelToolsService.onDidChangeTools, () => Array.from(_languageModelToolsService.getTools()));
+        const toolsObs = observableFromEvent(
+            this,
+            _languageModelToolsService.onDidChangeTools,
+            () => Array.from(_languageModelToolsService.getAllToolsIncludingDisabled())
+        );
         const store = this._store.add(( new DisposableStore()));
         this._store.add(autorun(r => {
             const tools = toolsObs.read(r);
@@ -164,26 +184,32 @@ let UserToolSetsContributions = class UserToolSetsContributions extends Disposab
             });
             for (const item of data) {
                 toolEnumValues.push(item.name);
-                toolEnumDescriptions.push(( localize(5589, "{1} ({0})\n\n{2}", item.sourceLabel, item.name, item.description)));
+                toolEnumDescriptions.push(( localize(5808, "{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 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 fileEventSig = observableSignalFromEvent(
+            this,
+            Event.filter(this._fileService.onDidFilesChange, e => e.affects(promptFolder.get()))
+        );
         const store = this._store.add(( new DisposableStore()));
-        const getFilesInFolder = async (folder) => {
+        const getFilesInFolder = async folder => {
             try {
                 return (await this._fileService.resolve(folder)).children ?? [];
-            }
-            catch (err) {
+            } catch (err) {
                 return [];
             }
         };
-        this._store.add(autorun(async (r) => {
+        this._store.add(autorun(async r => {
             store.clear();
             toolsSig.read(r);
             fileEventSig.read(r);
@@ -204,8 +230,7 @@ let UserToolSetsContributions = class UserToolSetsContributions extends Disposab
                     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) {
+                } catch (err) {
                     this._logService.error(`Error reading tool set file ${( entry.resource.toString())}:`, err);
                     continue;
                 }
@@ -230,7 +255,11 @@ let UserToolSetsContributions = class UserToolSetsContributions extends Disposab
                     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, {
+                    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
                     });
@@ -244,30 +273,25 @@ let UserToolSetsContributions = class UserToolSetsContributions extends Disposab
         }));
     }
 };
-UserToolSetsContributions = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, ILifecycleService)),
-    ( __param(2, ILanguageModelToolsService)),
-    ( __param(3, IUserDataProfileService)),
-    ( __param(4, IFileService)),
-    ( __param(5, ILogService))
-], UserToolSetsContributions));
+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'; }
+    static {
+        this.ID = "chat.configureToolSets";
+    }
     constructor() {
         super({
             id: ConfigureToolSets.ID,
-            title: ( localize2(5590, 'Configure Tool Sets...')),
-            shortTitle: ( localize(5591, "Tool Sets")),
+            title: ( localize2(5809, "Configure Tool Sets...")),
+            shortTitle: ( localize(5810, "Tool Sets")),
             category: CHAT_CATEGORY,
             f1: true,
             precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ChatContextKeys.Tools.toolsCount.greater(0))),
             menu: {
                 id: CHAT_CONFIG_MENU_ID,
-                when: ( ContextKeyExpr.equals('view', ChatViewId)),
+                when: ( ContextKeyExpr.equals("view", ChatViewId)),
                 order: 11,
-                group: '2_level'
-            },
+                group: "2_level"
+            }
         });
     }
     async run(accessor) {
@@ -279,12 +303,12 @@ class ConfigureToolSets extends Action2 {
         const textFileService = accessor.get(ITextFileService);
         const picks = [];
         picks.push({
-            label: ( localize(5592, 'Create new tool sets file...')),
+            label: ( localize(5811, "Create new tool sets file...")),
             alwaysShow: true,
             iconClass: ThemeIcon.asClassName(Codicon.plus)
         });
         for (const toolSet of toolsService.toolSets.get()) {
-            if (toolSet.source.type !== 'user') {
+            if (toolSet.source.type !== "user") {
                 continue;
             }
             picks.push({
@@ -296,7 +320,7 @@ class ConfigureToolSets extends Action2 {
         }
         const pick = await quickInputService.pick(picks, {
             canPickMany: false,
-            placeHolder: ( localize(5593, 'Select a tool set to configure')),
+            placeHolder: ( localize(5812, "Select a tool set to configure"))
         });
         if (!pick) {
             return;
@@ -304,13 +328,13 @@ class ConfigureToolSets extends Action2 {
         let resource;
         if (!pick.toolset) {
             const name = await quickInputService.input({
-                placeHolder: ( localize(5594, "Type tool sets file name")),
-                validateInput: async (input) => {
+                placeHolder: ( localize(5813, "Type tool sets file name")),
+                validateInput: async input => {
                     if (!input) {
-                        return localize(5595, "Invalid file name");
+                        return localize(5814, "Invalid file name");
                     }
                     if (!isValidBasename(input)) {
-                        return localize(5596, "'{0}' is not a valid file name", input);
+                        return localize(5815, "'{0}' is not a valid file name", input);
                     }
                     return undefined;
                 }
@@ -318,29 +342,36 @@ class ConfigureToolSets extends Action2 {
             if (isFalsyOrWhitespace(name)) {
                 return;
             }
-            resource = joinPath(userDataProfileService.currentProfile.promptsHome, `${name}${RawToolSetsShape.suffix}`);
+            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'));
+                    "// 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');
+        } else {
+            assertType(pick.toolset.source.type === "user");
             resource = pick.toolset.source.file;
         }
-        await editorService.openEditor({ resource, options: { pinned: true } });
+        await editorService.openEditor({
+            resource,
+            options: {
+                pinned: true
+            }
+        });
     }
 }
 

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

@@ -11,57 +11,63 @@ import { ExtensionsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workb
 import { ChatViewsWelcomeExtensions } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcome';
 
 const chatViewsWelcomeJsonSchema = {
-    type: 'object',
+    type: "object",
     additionalProperties: false,
-    required: ['icon', 'title', 'contents', 'when'],
+    required: ["icon", "title", "contents", "when"],
     properties: {
         icon: {
-            type: 'string',
-            description: ( localize(5602, 'The icon for the welcome message.')),
+            type: "string",
+            description: ( localize(5821, "The icon for the welcome message."))
         },
         title: {
-            type: 'string',
-            description: ( localize(5603, 'The title of the welcome message.')),
+            type: "string",
+            description: ( localize(5822, "The title of the welcome message."))
         },
         content: {
-            type: 'string',
+            type: "string",
             description: ( localize(
-                5604,
-                'The content of the welcome message. The first command link will be rendered as a button.'
-            )),
+                5823,
+                "The content of the welcome message. The first command link will be rendered as a button."
+            ))
         },
         when: {
-            type: 'string',
-            description: ( localize(5605, 'Condition when the welcome message is shown.')),
+            type: "string",
+            description: ( localize(5824, "Condition when the welcome message is shown."))
         }
     }
 };
 const chatViewsWelcomeExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'chatViewsWelcome',
+    extensionPoint: "chatViewsWelcome",
     jsonSchema: {
-        description: ( localize(5606, 'Contributes a welcome message to a chat view')),
-        type: 'array',
-        items: chatViewsWelcomeJsonSchema,
-    },
+        description: ( localize(5825, "Contributes a welcome message to a chat view")),
+        type: "array",
+        items: chatViewsWelcomeJsonSchema
+    }
 });
 let ChatViewsWelcomeHandler = class ChatViewsWelcomeHandler {
-    static { this.ID = 'workbench.contrib.chatViewsWelcomeHandler'; }
+    static {
+        this.ID = "workbench.contrib.chatViewsWelcomeHandler";
+    }
     constructor(logService) {
         this.logService = logService;
         chatViewsWelcomeExtensionPoint.setHandler((extensions, delta) => {
             for (const extension of delta.added) {
                 for (const providerDescriptor of extension.value) {
-                    checkProposedApiEnabled(extension.description, 'chatParticipantPrivate');
+                    checkProposedApiEnabled(extension.description, "chatParticipantPrivate");
                     const when = ContextKeyExpr.deserialize(providerDescriptor.when);
                     if (!when) {
-                        this.logService.error(`Could not deserialize 'when' clause for chatViewsWelcome contribution: ${providerDescriptor.when}`);
+                        this.logService.error(
+                            `Could not deserialize 'when' clause for chatViewsWelcome contribution: ${providerDescriptor.when}`
+                        );
                         continue;
                     }
                     const descriptor = {
                         ...providerDescriptor,
                         when,
                         icon: ThemeIcon.fromString(providerDescriptor.icon),
-                        content: ( new MarkdownString(providerDescriptor.content, { isTrusted: true })),
+                        content: ( new MarkdownString(providerDescriptor.content, {
+                            isTrusted: true
+                        }))
                     };
                     ( Registry.as(ChatViewsWelcomeExtensions.ChatViewsWelcomeRegistry)).register(descriptor);
                 }
@@ -69,8 +75,6 @@ let ChatViewsWelcomeHandler = class ChatViewsWelcomeHandler {
         });
     }
 };
-ChatViewsWelcomeHandler = ( __decorate([
-    ( __param(0, ILogService))
-], ChatViewsWelcomeHandler));
+ChatViewsWelcomeHandler = ( __decorate([( __param(0, ILogService))], ChatViewsWelcomeHandler));
 
 export { ChatViewsWelcomeHandler };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatMarkdownAnchorService.js

@@ -16,18 +16,22 @@ class ChatMarkdownAnchorService extends Disposable {
     }
     register(widget) {
         if (( this._widgets.some(other => other === widget))) {
-            throw ( new Error('Cannot register the same widget multiple times'));
+            throw ( new Error("Cannot register the same widget multiple times"));
         }
         this._widgets.push(widget);
         const element = widget.getHTMLElement();
         if (isActiveElement(element)) {
             this.setLastFocusedList(widget);
         }
-        return combinedDisposable(addDisposableListener(element, 'focus', () => this.setLastFocusedList(widget)), toDisposable(() => this._widgets.splice(this._widgets.indexOf(widget), 1)), addDisposableListener(element, 'blur', () => {
-            if (this._lastFocusedWidget === widget) {
-                this.setLastFocusedList(undefined);
-            }
-        }));
+        return combinedDisposable(
+            addDisposableListener(element, "focus", () => this.setLastFocusedList(widget)),
+            toDisposable(() => this._widgets.splice(this._widgets.indexOf(widget), 1)),
+            addDisposableListener(element, "blur", () => {
+                if (this._lastFocusedWidget === widget) {
+                    this.setLastFocusedList(undefined);
+                }
+            })
+        );
     }
 }
 

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/chatToolOutputStateCache.d.ts

@@ -0,0 +1,16 @@
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IChatToolOutputStateCache } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/chatToolOutputStateCache.service";
+export interface IOutputState {
+    webviewOrigin: string;
+    height: number;
+    webviewState?: string;
+}
+export declare class ChatToolOutputStateCache implements IChatToolOutputStateCache {
+    readonly _serviceBrand: undefined;
+    private readonly _cache;
+    constructor(storageService: IStorageService);
+    get(toolCallId: string): IOutputState | undefined;
+    set(toolCallId: string, state: IOutputState): void;
+    private _serialize;
+    private _deserialize;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/chatToolOutputStateCache.js

@@ -0,0 +1,57 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { LRUCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { StorageScope, WillSaveStateReason, 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 '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+const CACHE_STORAGE_KEY = "chat/toolOutputStateCache";
+const CACHE_LIMIT = 100;
+let ChatToolOutputStateCache = class ChatToolOutputStateCache {
+    constructor(storageService) {
+        this._cache = ( new LRUCache(CACHE_LIMIT, 0.75));
+        const raw = storageService.get(CACHE_STORAGE_KEY, StorageScope.WORKSPACE, "{}");
+        this._deserialize(raw);
+        const onWillSaveStateBecauseOfShutdown = Event.filter(
+            storageService.onWillSaveState,
+            e => e.reason === WillSaveStateReason.SHUTDOWN
+        );
+        Event.once(onWillSaveStateBecauseOfShutdown)(() => {
+            storageService.store(
+                CACHE_STORAGE_KEY,
+                this._serialize(),
+                StorageScope.WORKSPACE,
+                StorageTarget.MACHINE
+            );
+        });
+    }
+    get(toolCallId) {
+        return this._cache.get(toolCallId);
+    }
+    set(toolCallId, state) {
+        this._cache.set(toolCallId, state);
+    }
+    _serialize() {
+        const data = Object.create(null);
+        for (const [key, value] of this._cache) {
+            data[key] = value;
+        }
+        return JSON.stringify(data);
+    }
+    _deserialize(raw) {
+        try {
+            const data = JSON.parse(raw);
+            for (const key in data) {
+                const state = data[key];
+                if (typeof state.webviewOrigin === "string" && typeof state.height === "number") {
+                    this._cache.set(key, state);
+                }
+            }
+        } catch {}
+    }
+};
+ChatToolOutputStateCache = ( __decorate([( __param(0, IStorageService))], ChatToolOutputStateCache));
+
+export { ChatToolOutputStateCache };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatLayoutService.js

@@ -10,16 +10,14 @@ const FONT_SIZE = 13;
 let ChatLayoutService = class ChatLayoutService extends Disposable {
     constructor(configurationService) {
         super();
-        const chatFontFamily = observableConfigValue('chat.fontFamily', 'default', configurationService);
+        const chatFontFamily = observableConfigValue("chat.fontFamily", "default", configurationService);
         this.fontFamily = derived(reader => {
             const fontFamily = chatFontFamily.read(reader);
-            return fontFamily === 'default' ? null : fontFamily;
+            return fontFamily === "default" ? null : fontFamily;
         });
-        this.fontSize = observableConfigValue('chat.fontSize', FONT_SIZE, configurationService);
+        this.fontSize = observableConfigValue("chat.fontSize", FONT_SIZE, configurationService);
     }
 };
-ChatLayoutService = ( __decorate([
-    ( __param(0, IConfigurationService))
-], ChatLayoutService));
+ChatLayoutService = ( __decorate([( __param(0, IConfigurationService))], ChatLayoutService));
 
 export { ChatLayoutService };