@codingame/monaco-vscode-chat-service-override 22.1.9 → 23.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatManagement/chatModelsViewModel.js

@@ -0,0 +1,349 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { distinct, coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { or, matchesPrefix, matchesWords, matchesContiguousSubString, matchesCamelCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/filters';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { EditorModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorModel';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+
+var ChatModelsViewModel_1;
+const MODEL_ENTRY_TEMPLATE_ID = 'model.entry.template';
+const VENDOR_ENTRY_TEMPLATE_ID = 'vendor.entry.template';
+const wordFilter = or(matchesPrefix, matchesWords, matchesContiguousSubString);
+const CAPABILITY_REGEX = /@capability:\s*([^\s]+)/gi;
+const VISIBLE_REGEX = /@visible:\s*(true|false)/i;
+const SEARCH_SUGGESTIONS = {
+    FILTER_TYPES: [
+        '@provider:',
+        '@capability:',
+        '@visible:'
+    ],
+    CAPABILITIES: [
+        '@capability:tools',
+        '@capability:vision',
+        '@capability:agent'
+    ],
+    VISIBILITY: [
+        '@visible:true',
+        '@visible:false'
+    ]
+};
+function isVendorEntry(entry) {
+    return entry.type === 'vendor';
+}
+let ChatModelsViewModel = ChatModelsViewModel_1 = class ChatModelsViewModel extends EditorModel {
+    constructor(languageModelsService, chatEntitlementService) {
+        super();
+        this.languageModelsService = languageModelsService;
+        this.chatEntitlementService = chatEntitlementService;
+        this._onDidChangeModelEntries = this._register(( new Emitter()));
+        this.onDidChangeModelEntries = this._onDidChangeModelEntries.event;
+        this.collapsedVendors = ( new Set());
+        this.modelEntries = [];
+        this._register(this.chatEntitlementService.onDidChangeEntitlement(async () => {
+            await this.resolve();
+            this._onDidChangeModelEntries.fire();
+        }));
+    }
+    fetch(searchValue) {
+        let modelEntries = this.modelEntries;
+        const capabilityMatchesMap = ( new Map());
+        const visibleMatches = VISIBLE_REGEX.exec(searchValue);
+        if (visibleMatches && visibleMatches[1]) {
+            const visible = visibleMatches[1].toLowerCase() === 'true';
+            modelEntries = this.filterByVisible(modelEntries, visible);
+            searchValue = searchValue.replace(VISIBLE_REGEX, '');
+        }
+        const providerNames = [];
+        let match;
+        const providerRegexGlobal = /@provider:\s*((".+?")|([^\s]+))/gi;
+        while ((match = providerRegexGlobal.exec(searchValue)) !== null) {
+            const providerName = match[2] ? match[2].substring(1, match[2].length - 1) : match[3];
+            providerNames.push(providerName);
+        }
+        if (providerNames.length > 0) {
+            modelEntries = this.filterByProviders(modelEntries, providerNames);
+            searchValue = searchValue.replace(/@provider:\s*((".+?")|([^\s]+))/gi, '').replace(/@vendor:\s*((".+?")|([^\s]+))/gi, '');
+        }
+        const capabilityNames = [];
+        let capabilityMatch;
+        while ((capabilityMatch = CAPABILITY_REGEX.exec(searchValue)) !== null) {
+            capabilityNames.push(capabilityMatch[1].toLowerCase());
+        }
+        if (capabilityNames.length > 0) {
+            const filteredEntries = this.filterByCapabilities(modelEntries, capabilityNames);
+            modelEntries = [];
+            for (const { entry, matchedCapabilities } of filteredEntries) {
+                modelEntries.push(entry);
+                capabilityMatchesMap.set(ChatModelsViewModel_1.getId(entry), matchedCapabilities);
+            }
+            searchValue = searchValue.replace(/@capability:\s*([^\s]+)/gi, '');
+        }
+        searchValue = searchValue.trim();
+        if (!searchValue) {
+            return this.toEntries(modelEntries, capabilityMatchesMap);
+        }
+        return this.filterByText(modelEntries, searchValue, capabilityMatchesMap);
+    }
+    filterByProviders(modelEntries, providers) {
+        const lowerProviders = ( providers.map(p => p.toLowerCase().trim()));
+        return modelEntries.filter(m => ( lowerProviders.some(provider => m.vendor.toLowerCase() === provider ||
+            m.vendorDisplayName.toLowerCase() === provider)));
+    }
+    filterByVisible(modelEntries, visible) {
+        return modelEntries.filter(m => (m.metadata.isUserSelectable ?? false) === visible);
+    }
+    filterByCapabilities(modelEntries, capabilities) {
+        const result = [];
+        for (const m of modelEntries) {
+            if (!m.metadata.capabilities) {
+                continue;
+            }
+            const allMatchedCapabilities = [];
+            let matchesAll = true;
+            for (const capability of capabilities) {
+                const matchedForThisCapability = this.getMatchingCapabilities(m, capability);
+                if (matchedForThisCapability.length === 0) {
+                    matchesAll = false;
+                    break;
+                }
+                allMatchedCapabilities.push(...matchedForThisCapability);
+            }
+            if (matchesAll) {
+                result.push({ entry: m, matchedCapabilities: distinct(allMatchedCapabilities) });
+            }
+        }
+        return result;
+    }
+    getMatchingCapabilities(modelEntry, capability) {
+        const matchedCapabilities = [];
+        if (!modelEntry.metadata.capabilities) {
+            return matchedCapabilities;
+        }
+        switch (capability) {
+            case 'tools':
+            case 'toolcalling':
+                if (modelEntry.metadata.capabilities.toolCalling === true) {
+                    matchedCapabilities.push('toolCalling');
+                }
+                break;
+            case 'vision':
+                if (modelEntry.metadata.capabilities.vision === true) {
+                    matchedCapabilities.push('vision');
+                }
+                break;
+            case 'agent':
+            case 'agentmode':
+                if (modelEntry.metadata.capabilities.agentMode === true) {
+                    matchedCapabilities.push('agentMode');
+                }
+                break;
+            default:
+                if (modelEntry.metadata.capabilities.editTools) {
+                    for (const tool of modelEntry.metadata.capabilities.editTools) {
+                        if (tool.toLowerCase().includes(capability)) {
+                            matchedCapabilities.push(tool);
+                        }
+                    }
+                }
+                break;
+        }
+        return matchedCapabilities;
+    }
+    filterByText(modelEntries, searchValue, capabilityMatchesMap) {
+        const quoteAtFirstChar = searchValue.charAt(0) === '"';
+        const quoteAtLastChar = searchValue.charAt(searchValue.length - 1) === '"';
+        const completeMatch = quoteAtFirstChar && quoteAtLastChar;
+        if (quoteAtFirstChar) {
+            searchValue = searchValue.substring(1);
+        }
+        if (quoteAtLastChar) {
+            searchValue = searchValue.substring(0, searchValue.length - 1);
+        }
+        searchValue = searchValue.trim();
+        const result = [];
+        const words = searchValue.split(' ');
+        for (const modelEntry of modelEntries) {
+            const modelMatches = ( new ModelItemMatches(modelEntry, searchValue, words, completeMatch));
+            if (modelMatches.modelNameMatches
+                || modelMatches.providerMatches
+                || modelMatches.capabilityMatches) {
+                const modelId = ChatModelsViewModel_1.getId(modelEntry);
+                result.push({
+                    type: 'model',
+                    id: modelId,
+                    templateId: MODEL_ENTRY_TEMPLATE_ID,
+                    modelEntry,
+                    modelNameMatches: modelMatches.modelNameMatches || undefined,
+                    providerMatches: modelMatches.providerMatches || undefined,
+                    capabilityMatches: capabilityMatchesMap.get(modelId),
+                });
+            }
+        }
+        return result;
+    }
+    getVendors() {
+        return [...this.languageModelsService.getVendors()].sort((a, b) => {
+            if (a.vendor === 'copilot') {
+                return -1;
+            }
+            if (b.vendor === 'copilot') {
+                return 1;
+            }
+            return a.displayName.localeCompare(b.displayName);
+        });
+    }
+    async resolve() {
+        this.modelEntries = [];
+        for (const vendor of this.getVendors()) {
+            const modelIdentifiers = await this.languageModelsService.selectLanguageModels({ vendor: vendor.vendor }, vendor.vendor === 'copilot');
+            const models = coalesce(( modelIdentifiers.map(identifier => {
+                const metadata = this.languageModelsService.lookupLanguageModel(identifier);
+                if (!metadata) {
+                    return undefined;
+                }
+                if (vendor.vendor === 'copilot' && metadata.id === 'auto') {
+                    return undefined;
+                }
+                return {
+                    vendor: vendor.vendor,
+                    vendorDisplayName: vendor.displayName,
+                    identifier,
+                    metadata
+                };
+            })));
+            this.modelEntries.push(...models.sort((a, b) => a.metadata.name.localeCompare(b.metadata.name)));
+        }
+        this.modelEntries = distinct(this.modelEntries, modelEntry => ChatModelsViewModel_1.getId(modelEntry));
+        return super.resolve();
+    }
+    static getId(modelEntry) {
+        return modelEntry.identifier + modelEntry.vendor + (modelEntry.metadata.version || '');
+    }
+    toggleVendorCollapsed(vendorId) {
+        if (( this.collapsedVendors.has(vendorId))) {
+            this.collapsedVendors.delete(vendorId);
+        }
+        else {
+            this.collapsedVendors.add(vendorId);
+        }
+        this._onDidChangeModelEntries.fire();
+    }
+    getConfiguredVendors() {
+        return this.toEntries(this.modelEntries, ( new Map()), true);
+    }
+    toEntries(modelEntries, capabilityMatchesMap, excludeModels) {
+        const result = [];
+        const vendorMap = ( new Map());
+        for (const modelEntry of modelEntries) {
+            const models = vendorMap.get(modelEntry.vendor) || [];
+            models.push(modelEntry);
+            vendorMap.set(modelEntry.vendor, models);
+        }
+        const showVendorHeaders = vendorMap.size > 1;
+        for (const [vendor, models] of vendorMap) {
+            const firstModel = models[0];
+            const isCollapsed = ( this.collapsedVendors.has(vendor));
+            const vendorInfo = this.languageModelsService.getVendors().find(v => v.vendor === vendor);
+            if (showVendorHeaders) {
+                result.push({
+                    type: 'vendor',
+                    id: `vendor-${vendor}`,
+                    vendorEntry: {
+                        vendor: firstModel.vendor,
+                        vendorDisplayName: firstModel.vendorDisplayName,
+                        managementCommand: vendorInfo?.managementCommand
+                    },
+                    templateId: VENDOR_ENTRY_TEMPLATE_ID,
+                    collapsed: isCollapsed
+                });
+            }
+            if (!excludeModels && (!isCollapsed || !showVendorHeaders)) {
+                for (const modelEntry of models) {
+                    const modelId = ChatModelsViewModel_1.getId(modelEntry);
+                    result.push({
+                        type: 'model',
+                        id: modelId,
+                        modelEntry,
+                        templateId: MODEL_ENTRY_TEMPLATE_ID,
+                        capabilityMatches: capabilityMatchesMap.get(modelId),
+                    });
+                }
+            }
+        }
+        return result;
+    }
+};
+ChatModelsViewModel = ChatModelsViewModel_1 = ( __decorate([
+    ( __param(0, ILanguageModelsService)),
+    ( __param(1, IChatEntitlementService))
+], ChatModelsViewModel));
+class ModelItemMatches {
+    constructor(modelEntry, searchValue, words, completeMatch) {
+        this.modelNameMatches = null;
+        this.providerMatches = null;
+        this.capabilityMatches = null;
+        if (!completeMatch) {
+            this.modelNameMatches = modelEntry.metadata.name ?
+                this.matches(searchValue, modelEntry.metadata.name, (word, wordToMatchAgainst) => matchesWords(word, wordToMatchAgainst, true), words) :
+                null;
+            if (!this.modelNameMatches) {
+                this.modelNameMatches = this.matches(searchValue, modelEntry.identifier, or(matchesWords, matchesCamelCase), words);
+            }
+            this.providerMatches = this.matches(searchValue, modelEntry.vendorDisplayName, (word, wordToMatchAgainst) => matchesWords(word, wordToMatchAgainst, true), words);
+            if (modelEntry.metadata.capabilities) {
+                const capabilityStrings = [];
+                if (modelEntry.metadata.capabilities.toolCalling) {
+                    capabilityStrings.push('tools', 'toolCalling');
+                }
+                if (modelEntry.metadata.capabilities.vision) {
+                    capabilityStrings.push('vision');
+                }
+                if (modelEntry.metadata.capabilities.agentMode) {
+                    capabilityStrings.push('agent', 'agentMode');
+                }
+                if (modelEntry.metadata.capabilities.editTools) {
+                    capabilityStrings.push(...modelEntry.metadata.capabilities.editTools);
+                }
+                const capabilityString = capabilityStrings.join(' ');
+                if (capabilityString) {
+                    this.capabilityMatches = this.matches(searchValue, capabilityString, or(matchesWords, matchesCamelCase), words);
+                }
+            }
+        }
+    }
+    matches(searchValue, wordToMatchAgainst, wordMatchesFilter, words) {
+        let matches = searchValue ? wordFilter(searchValue, wordToMatchAgainst) : null;
+        if (!matches) {
+            matches = this.matchesWords(words, wordToMatchAgainst, wordMatchesFilter);
+        }
+        if (matches) {
+            matches = this.filterAndSort(matches);
+        }
+        return matches;
+    }
+    matchesWords(words, wordToMatchAgainst, wordMatchesFilter) {
+        let matches = [];
+        for (const word of words) {
+            const wordMatches = wordMatchesFilter(word, wordToMatchAgainst);
+            if (wordMatches) {
+                matches = [...(matches || []), ...wordMatches];
+            }
+            else {
+                matches = null;
+                break;
+            }
+        }
+        return matches;
+    }
+    filterAndSort(matches) {
+        return distinct(matches, (a => a.start + '.' + a.end))
+            .filter(match => !( matches.some(
+            m => !(m.start === match.start && m.end === match.end) && (m.start <= match.start && m.end >= match.end)
+        )))
+            .sort((a, b) => a.start - b.start);
+    }
+}
+
+export { ChatModelsViewModel, MODEL_ENTRY_TEMPLATE_ID, SEARCH_SUGGESTIONS, VENDOR_ENTRY_TEMPLATE_ID, isVendorEntry };

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

@@ -0,0 +1,43 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { MarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IModelEntry } from "./chatModelsViewModel.js";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IEditorProgressService } from "@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+export declare function getModelHoverContent(model: IModelEntry): MarkdownString;
+export declare class ChatModelsWidget extends Disposable {
+    private readonly languageModelsService;
+    private readonly instantiationService;
+    private readonly extensionService;
+    private readonly contextMenuService;
+    private readonly chatEntitlementService;
+    private readonly editorProgressService;
+    private readonly commandService;
+    private static NUM_INSTANCES;
+    readonly element: HTMLElement;
+    private searchWidget;
+    private searchActionsContainer;
+    private table;
+    private tableContainer;
+    private addButtonContainer;
+    private addButton;
+    private dropdownActions;
+    private viewModel;
+    private delayedFiltering;
+    private readonly searchFocusContextKey;
+    constructor(languageModelsService: ILanguageModelsService, instantiationService: IInstantiationService, extensionService: IExtensionService, contextMenuService: IContextMenuService, chatEntitlementService: IChatEntitlementService, editorProgressService: IEditorProgressService, commandService: ICommandService, contextKeyService: IContextKeyService);
+    private create;
+    private filterModels;
+    private refreshTable;
+    private enableProvider;
+    layout(height: number, width: number): void;
+    focusSearch(): void;
+    search(filter: string): void;
+    clearSearch(): void;
+    refresh(): Promise<void>;
+}