@codingame/monaco-vscode-api 19.1.4 → 20.0.0

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

@@ -2,9 +2,11 @@ import { VSBuffer } from "../../../../base/common/buffer.js";
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
+import { URI } from "../../../../base/common/uri.js";
 import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
 import { ExtensionIdentifier } from "../../../../platform/extensions/common/extensions.js";
 import { ILogService } from "../../../../platform/log/common/log.service.js";
+import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
 import { IExtensionService } from "../../../services/extensions/common/extensions.service.js";
 import { ILanguageModelsService } from "./languageModels.service.js";
 export declare enum ChatMessageRole {
@@ -12,9 +14,14 @@ export declare enum ChatMessageRole {
     User = 1,
     Assistant = 2
 }
+export declare enum ToolResultAudience {
+    Assistant = 0,
+    User = 1
+}
 export interface IChatMessageTextPart {
     type: "text";
     value: string;
+    audience?: ToolResultAudience[];
 }
 export interface IChatMessageImagePart {
     type: "image_url";
@@ -24,6 +31,7 @@ export interface IChatMessageDataPart {
     type: "data";
     mimeType: string;
     data: VSBuffer;
+    audience?: ToolResultAudience[];
 }
 export interface IChatImageURLPart {
     mimeType: ChatImageMimeType;
@@ -55,6 +63,7 @@ export interface IChatMessage {
 export interface IChatResponseTextPart {
     type: "text";
     value: string;
+    audience?: ToolResultAudience[];
 }
 export interface IChatResponsePromptTsxPart {
     type: "prompt_tsx";
@@ -63,6 +72,7 @@ export interface IChatResponsePromptTsxPart {
 export interface IChatResponseDataPart {
     type: "data";
     value: IChatImageURLPart;
+    audience?: ToolResultAudience[];
 }
 export interface IChatResponseToolUsePart {
     type: "tool_use";
@@ -70,6 +80,15 @@ export interface IChatResponseToolUsePart {
     toolCallId: string;
     parameters: any;
 }
+export interface IChatResponsePullRequestPart {
+    type: "pullRequest";
+    uri: URI;
+    title: string;
+    description: string;
+    author: string;
+    linkTag: string;
+}
+export type IExtendedChatResponsePart = IChatResponsePullRequestPart;
 export type IChatResponsePart = IChatResponseTextPart | IChatResponseToolUsePart | IChatResponseDataPart;
 export interface IChatResponseFragment {
     index: number;
@@ -86,7 +105,6 @@ export interface ILanguageModelChatMetadata {
     readonly family: string;
     readonly maxInputTokens: number;
     readonly maxOutputTokens: number;
-    readonly targetExtensions?: string[];
     readonly isDefault?: boolean;
     readonly isUserSelectable?: boolean;
     readonly modelPickerCategory: {
@@ -111,6 +129,16 @@ export interface ILanguageModelChatResponse {
     stream: AsyncIterable<IChatResponseFragment | IChatResponseFragment[]>;
     result: Promise<any>;
 }
+export interface ILanguageModelChatProvider {
+    onDidChange: Event<void>;
+    prepareLanguageModelChat(options: {
+        silent: boolean;
+    }, token: CancellationToken): Promise<ILanguageModelChatMetadataAndIdentifier[]>;
+    sendChatRequest(modelId: string, messages: IChatMessage[], from: ExtensionIdentifier, options: {
+        [name: string]: any;
+    }, token: CancellationToken): Promise<ILanguageModelChatResponse>;
+    provideTokenCount(modelId: string, message: string | IChatMessage, token: CancellationToken): Promise<number>;
+}
 export interface ILanguageModelChat {
     metadata: ILanguageModelChatMetadata;
     sendChatRequest(messages: IChatMessage[], from: ExtensionIdentifier, options: {
@@ -131,35 +159,37 @@ export interface ILanguageModelChatMetadataAndIdentifier {
     metadata: ILanguageModelChatMetadata;
     identifier: string;
 }
-export interface ILanguageModelsChangeEvent {
-    added?: ILanguageModelChatMetadataAndIdentifier[];
-    removed?: string[];
-}
-interface IUserFriendlyLanguageModel {
+export interface IUserFriendlyLanguageModel {
     vendor: string;
+    displayName: string;
+    managementCommand?: string;
 }
 export declare const languageModelExtensionPoint: import("../../../services/extensions/common/extensionsRegistry.js").IExtensionPoint<IUserFriendlyLanguageModel | IUserFriendlyLanguageModel[]>;
 export declare class LanguageModelsService implements ILanguageModelsService {
     private readonly _extensionService;
     private readonly _logService;
-    private readonly _contextKeyService;
+    private readonly _storageService;
     readonly _serviceBrand: undefined;
     private readonly _store;
     private readonly _providers;
+    private readonly _modelCache;
     private readonly _vendors;
-    private readonly _onDidChangeProviders;
-    readonly onDidChangeLanguageModels: Event<ILanguageModelsChangeEvent>;
+    private readonly _modelPickerUserPreferences;
     private readonly _hasUserSelectableModels;
-    constructor(_extensionService: IExtensionService, _logService: ILogService, _contextKeyService: IContextKeyService);
+    private readonly _onLanguageModelChange;
+    readonly onDidChangeLanguageModels: Event<void>;
+    constructor(_extensionService: IExtensionService, _logService: ILogService, _storageService: IStorageService, _contextKeyService: IContextKeyService);
     dispose(): void;
+    updateModelPickerPreference(modelIdentifier: string, showInModelPicker: boolean): void;
+    getVendors(): IUserFriendlyLanguageModel[];
     getLanguageModelIds(): string[];
-    lookupLanguageModel(identifier: string): ILanguageModelChatMetadata | undefined;
-    selectLanguageModels(selector: ILanguageModelChatSelector): Promise<string[]>;
-    registerLanguageModelChat(identifier: string, provider: ILanguageModelChat): IDisposable;
-    private updateUserSelectableModelsContext;
-    sendChatRequest(identifier: string, from: ExtensionIdentifier, messages: IChatMessage[], options: {
+    lookupLanguageModel(modelIdentifier: string): ILanguageModelChatMetadata | undefined;
+    private _clearModelCache;
+    resolveLanguageModels(vendors: string | string[], silent: boolean): Promise<void>;
+    selectLanguageModels(selector: ILanguageModelChatSelector, allowPromptingUser?: boolean): Promise<string[]>;
+    registerLanguageModelProvider(vendor: string, provider: ILanguageModelChatProvider): IDisposable;
+    sendChatRequest(modelId: string, from: ExtensionIdentifier, messages: IChatMessage[], options: {
         [name: string]: any;
     }, token: CancellationToken): Promise<ILanguageModelChatResponse>;
-    computeTokenLength(identifier: string, message: string | IChatMessage, token: CancellationToken): Promise<number>;
+    computeTokenLength(modelId: string, message: string | IChatMessage, token: CancellationToken): Promise<number>;
 }
-export {};

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

@@ -1,13 +1,15 @@
 
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { Iterable } from '../../../../base/common/iterator.js';
 import { DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
 import { isFalsyOrWhitespace } from '../../../../base/common/strings.js';
 import { localize } from '../../../../nls.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
-import { ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
 import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
 import { isProposedApiEnabled } from '../../../services/extensions/common/extensions.js';
 import { IExtensionService } from '../../../services/extensions/common/extensions.service.js';
 import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
@@ -19,6 +21,11 @@ var ChatMessageRole;
     ChatMessageRole[ChatMessageRole["User"] = 1] = "User";
     ChatMessageRole[ChatMessageRole["Assistant"] = 2] = "Assistant";
 })(ChatMessageRole || (ChatMessageRole = {}));
+var ToolResultAudience;
+(function (ToolResultAudience) {
+    ToolResultAudience[ToolResultAudience["Assistant"] = 0] = "Assistant";
+    ToolResultAudience[ToolResultAudience["User"] = 1] = "User";
+})(ToolResultAudience || (ToolResultAudience = {}));
 var ChatImageMimeType;
 (function (ChatImageMimeType) {
     ChatImageMimeType["PNG"] = "image/png";
@@ -52,14 +59,25 @@ const languageModelType = {
     properties: {
         vendor: {
             type: 'string',
-            description: ( localize(5311, "A globally unique vendor of language models."))
+            description: ( localize(5426, "A globally unique vendor of language models."))
+        },
+        displayName: {
+            type: 'string',
+            description: ( localize(5427, "The display name of the language model vendor."))
+        },
+        managementCommand: {
+            type: 'string',
+            description: ( localize(
+                5428,
+                "A command to manage the language model vendor, e.g. 'Manage Copilot models'. This is used in the chat model picker. If not provided, a gear icon is not rendered during vendor selection."
+            ))
         }
     }
 };
 const languageModelExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'languageModels',
     jsonSchema: {
-        description: ( localize(5312, "Contribute language models of a specific vendor.")),
+        description: ( localize(5429, "Contribute language models of a specific vendor.")),
         oneOf: [
             languageModelType,
             {
@@ -75,133 +93,197 @@ const languageModelExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     }
 });
 let LanguageModelsService = class LanguageModelsService {
-    constructor(_extensionService, _logService, _contextKeyService) {
+    constructor(_extensionService, _logService, _storageService, _contextKeyService) {
         this._extensionService = _extensionService;
         this._logService = _logService;
-        this._contextKeyService = _contextKeyService;
+        this._storageService = _storageService;
         this._store = ( new DisposableStore());
         this._providers = ( new Map());
-        this._vendors = ( new Set());
-        this._onDidChangeProviders = this._store.add(( new Emitter()));
-        this.onDidChangeLanguageModels = this._onDidChangeProviders.event;
-        this._hasUserSelectableModels = ChatContextKeys.languageModelsAreUserSelectable.bindTo(this._contextKeyService);
+        this._modelCache = ( new Map());
+        this._vendors = ( new Map());
+        this._modelPickerUserPreferences = {};
+        this._onLanguageModelChange = this._store.add(( new Emitter()));
+        this.onDidChangeLanguageModels = this._onLanguageModelChange.event;
+        this._hasUserSelectableModels = ChatContextKeys.languageModelsAreUserSelectable.bindTo(_contextKeyService);
+        this._modelPickerUserPreferences = this._storageService.getObject('chatModelPickerPreferences', StorageScope.PROFILE, this._modelPickerUserPreferences);
+        this._store.add(this.onDidChangeLanguageModels(() => {
+            this._hasUserSelectableModels.set(this._modelCache.size > 0 && ( Array.from(( this._modelCache.values())).some(model => model.isUserSelectable)));
+        }));
         this._store.add(languageModelExtensionPoint.setHandler((extensions) => {
             this._vendors.clear();
             for (const extension of extensions) {
                 if (!isProposedApiEnabled(extension.description, 'chatProvider')) {
-                    extension.collector.error(( localize(5313, "This contribution point requires the 'chatProvider' proposal.")));
+                    extension.collector.error(( localize(5430, "This contribution point requires the 'chatProvider' proposal.")));
                     continue;
                 }
                 for (const item of Iterable.wrap(extension.value)) {
                     if (( this._vendors.has(item.vendor))) {
                         extension.collector.error(( localize(
-                            5314,
+                            5431,
                             "The vendor '{0}' is already registered and cannot be registered twice",
                             item.vendor
                         )));
                         continue;
                     }
                     if (isFalsyOrWhitespace(item.vendor)) {
-                        extension.collector.error(( localize(5315, "The vendor field cannot be empty.")));
+                        extension.collector.error(( localize(5432, "The vendor field cannot be empty.")));
                         continue;
                     }
                     if (item.vendor.trim() !== item.vendor) {
-                        extension.collector.error(( localize(5316, "The vendor field cannot start or end with whitespace.")));
+                        extension.collector.error(( localize(5433, "The vendor field cannot start or end with whitespace.")));
                         continue;
                     }
-                    this._vendors.add(item.vendor);
+                    this._vendors.set(item.vendor, item);
                 }
             }
-            const removed = [];
-            for (const [identifier, value] of this._providers) {
-                if (!( this._vendors.has(value.metadata.vendor))) {
-                    this._providers.delete(identifier);
-                    removed.push(identifier);
+            for (const [vendor, _] of this._providers) {
+                if (!( this._vendors.has(vendor))) {
+                    this._providers.delete(vendor);
                 }
             }
-            if (removed.length > 0) {
-                this._onDidChangeProviders.fire({ removed });
-            }
         }));
     }
     dispose() {
         this._store.dispose();
         this._providers.clear();
     }
+    updateModelPickerPreference(modelIdentifier, showInModelPicker) {
+        const model = this._modelCache.get(modelIdentifier);
+        if (!model) {
+            this._logService.warn(`[LM] Cannot update model picker preference for unknown model ${modelIdentifier}`);
+            return;
+        }
+        this._modelPickerUserPreferences[modelIdentifier] = showInModelPicker;
+        if (showInModelPicker === model.isUserSelectable) {
+            delete this._modelPickerUserPreferences[modelIdentifier];
+            this._storageService.store('chatModelPickerPreferences', this._modelPickerUserPreferences, StorageScope.PROFILE, StorageTarget.USER);
+        }
+        else if (model.isUserSelectable !== showInModelPicker) {
+            this._storageService.store('chatModelPickerPreferences', this._modelPickerUserPreferences, StorageScope.PROFILE, StorageTarget.USER);
+        }
+        this._onLanguageModelChange.fire();
+        this._logService.trace(`[LM] Updated model picker preference for ${modelIdentifier} to ${showInModelPicker}`);
+    }
+    getVendors() {
+        return Array.from(( this._vendors.values()));
+    }
     getLanguageModelIds() {
-        return Array.from(( this._providers.keys()));
+        return Array.from(( this._modelCache.keys()));
+    }
+    lookupLanguageModel(modelIdentifier) {
+        const model = this._modelCache.get(modelIdentifier);
+        if (model && this._modelPickerUserPreferences[modelIdentifier] !== undefined) {
+            return { ...model, isUserSelectable: this._modelPickerUserPreferences[modelIdentifier] };
+        }
+        return model;
     }
-    lookupLanguageModel(identifier) {
-        return this._providers.get(identifier)?.metadata;
+    _clearModelCache(vendors) {
+        if (typeof vendors === 'string') {
+            vendors = [vendors];
+        }
+        for (const vendor of vendors) {
+            for (const [id, model] of this._modelCache.entries()) {
+                if (model.vendor === vendor) {
+                    this._modelCache.delete(id);
+                }
+            }
+        }
     }
-    async selectLanguageModels(selector) {
+    async resolveLanguageModels(vendors, silent) {
+        if (typeof vendors === 'string') {
+            vendors = [vendors];
+        }
+        this._clearModelCache(vendors);
+        for (const vendor of vendors) {
+            const provider = this._providers.get(vendor);
+            if (!provider) {
+                this._logService.warn(`[LM] No provider registered for vendor ${vendor}`);
+                continue;
+            }
+            try {
+                const modelsAndIdentifiers = await provider.prepareLanguageModelChat({ silent }, CancellationToken.None);
+                for (const modelAndIdentifier of modelsAndIdentifiers) {
+                    if (( this._modelCache.has(modelAndIdentifier.identifier))) {
+                        this._logService.warn(`[LM] Model ${modelAndIdentifier.identifier} is already registered. Skipping.`);
+                        continue;
+                    }
+                    this._modelCache.set(modelAndIdentifier.identifier, modelAndIdentifier.metadata);
+                }
+                this._logService.trace(`[LM] Resolved language models for vendor ${vendor}`, modelsAndIdentifiers);
+            }
+            catch (error) {
+                this._logService.error(`[LM] Error resolving language models for vendor ${vendor}:`, error);
+            }
+        }
+        this._onLanguageModelChange.fire();
+    }
+    async selectLanguageModels(selector, allowPromptingUser) {
         if (selector.vendor) {
             await this._extensionService.activateByEvent(`onLanguageModelChat:${selector.vendor}}`);
+            await this.resolveLanguageModels([selector.vendor], !allowPromptingUser);
         }
         else {
-            const all = ( Array.from(this._vendors).map(
+            const allVendors = Array.from(( this._vendors.keys()));
+            const all = ( allVendors.map(
                 vendor => this._extensionService.activateByEvent(`onLanguageModelChat:${vendor}`)
             ));
             await Promise.all(all);
+            await this.resolveLanguageModels(allVendors, !allowPromptingUser);
         }
         const result = [];
-        for (const [identifier, model] of this._providers) {
-            if ((selector.vendor === undefined || model.metadata.vendor === selector.vendor)
-                && (selector.family === undefined || model.metadata.family === selector.family)
-                && (selector.version === undefined || model.metadata.version === selector.version)
-                && (selector.id === undefined || model.metadata.id === selector.id)
-                && (!model.metadata.targetExtensions || ( model.metadata.targetExtensions.some(candidate => ExtensionIdentifier.equals(candidate, selector.extension))))) {
-                result.push(identifier);
+        for (const [internalModelIdentifier, model] of this._modelCache) {
+            if ((selector.vendor === undefined || model.vendor === selector.vendor)
+                && (selector.family === undefined || model.family === selector.family)
+                && (selector.version === undefined || model.version === selector.version)
+                && (selector.id === undefined || model.id === selector.id)) {
+                result.push(internalModelIdentifier);
             }
         }
         this._logService.trace('[LM] selected language models', selector, result);
         return result;
     }
-    registerLanguageModelChat(identifier, provider) {
-        this._logService.trace('[LM] registering language model chat', identifier, provider.metadata);
-        if (!( this._vendors.has(provider.metadata.vendor))) {
-            throw ( new Error(`Chat response provider uses UNKNOWN vendor ${provider.metadata.vendor}.`));
+    registerLanguageModelProvider(vendor, provider) {
+        this._logService.trace('[LM] registering language model provider', vendor, provider);
+        if (!( this._vendors.has(vendor))) {
+            throw ( new Error(`Chat model provider uses UNKNOWN vendor ${vendor}.`));
         }
-        if (( this._providers.has(identifier))) {
-            throw ( new Error(
-                `Chat response provider with identifier ${identifier} is already registered.`
-            ));
+        if (( this._providers.has(vendor))) {
+            throw ( new Error(`Chat model provider for vendor ${vendor} is already registered.`));
         }
-        this._providers.set(identifier, provider);
-        this._onDidChangeProviders.fire({ added: [{ identifier, metadata: provider.metadata }] });
-        this.updateUserSelectableModelsContext();
+        this._providers.set(vendor, provider);
+        this.resolveLanguageModels(vendor, true).then(() => {
+            this._onLanguageModelChange.fire();
+        });
         return toDisposable(() => {
-            this.updateUserSelectableModelsContext();
-            if (this._providers.delete(identifier)) {
-                this._onDidChangeProviders.fire({ removed: [identifier] });
-                this._logService.trace('[LM] UNregistered language model chat', identifier, provider.metadata);
-            }
+            this._logService.trace('[LM] UNregistered language model provider', vendor);
+            this._clearModelCache(vendor);
+            this._providers.delete(vendor);
         });
     }
-    updateUserSelectableModelsContext() {
-        const hasUserSelectableModels = ( Array.from(( this._providers.values())).some(p => p.metadata.isUserSelectable && !p.metadata.isDefault));
-        const hasDefaultModel = ( Array.from(( this._providers.values())).some(p => p.metadata.isDefault));
-        this._hasUserSelectableModels.set(hasUserSelectableModels && hasDefaultModel);
-    }
-    async sendChatRequest(identifier, from, messages, options, token) {
-        const provider = this._providers.get(identifier);
+    async sendChatRequest(modelId, from, messages, options, token) {
+        const provider = this._providers.get(this._modelCache.get(modelId)?.vendor || '');
         if (!provider) {
-            throw ( new Error(`Chat response provider with identifier ${identifier} is not registered.`));
+            throw ( new Error(`Chat provider for model ${modelId} is not registered.`));
         }
-        return provider.sendChatRequest(messages, from, options, token);
+        return provider.sendChatRequest(modelId, messages, from, options, token);
     }
-    computeTokenLength(identifier, message, token) {
-        const provider = this._providers.get(identifier);
+    computeTokenLength(modelId, message, token) {
+        const model = this._modelCache.get(modelId);
+        if (!model) {
+            throw ( new Error(`Chat model ${modelId} could not be found.`));
+        }
+        const provider = this._providers.get(model.vendor);
         if (!provider) {
-            throw ( new Error(`Chat response provider with identifier ${identifier} is not registered.`));
+            throw ( new Error(`Chat provider for model ${modelId} is not registered.`));
         }
-        return provider.provideTokenCount(message, token);
+        return provider.provideTokenCount(modelId, message, token);
     }
 };
 LanguageModelsService = ( __decorate([
     ( __param(0, IExtensionService)),
     ( __param(1, ILogService)),
-    ( __param(2, IContextKeyService))
+    ( __param(2, IStorageService)),
+    ( __param(3, IContextKeyService))
 ], LanguageModelsService));
 
-export { ChatImageMimeType, ChatMessageRole, ILanguageModelChatMetadata, ImageDetailLevel, LanguageModelsService, languageModelExtensionPoint };
+export { ChatImageMimeType, ChatMessageRole, ILanguageModelChatMetadata, ImageDetailLevel, LanguageModelsService, ToolResultAudience, languageModelExtensionPoint };

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

@@ -2,17 +2,19 @@ import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { ExtensionIdentifier } from "../../../../platform/extensions/common/extensions.js";
-import { ILanguageModelsChangeEvent, ILanguageModelChatMetadata, ILanguageModelChatSelector, ILanguageModelChat, IChatMessage, ILanguageModelChatResponse } from "./languageModels.js";
+import { IUserFriendlyLanguageModel, ILanguageModelChatMetadata, ILanguageModelChatSelector, ILanguageModelChatProvider, IChatMessage, ILanguageModelChatResponse } from "./languageModels.js";
 export declare const ILanguageModelsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ILanguageModelsService>;
 export interface ILanguageModelsService {
     readonly _serviceBrand: undefined;
-    onDidChangeLanguageModels: Event<ILanguageModelsChangeEvent>;
+    onDidChangeLanguageModels: Event<void>;
+    updateModelPickerPreference(modelIdentifier: string, showInModelPicker: boolean): void;
     getLanguageModelIds(): string[];
-    lookupLanguageModel(identifier: string): ILanguageModelChatMetadata | undefined;
-    selectLanguageModels(selector: ILanguageModelChatSelector): Promise<string[]>;
-    registerLanguageModelChat(identifier: string, provider: ILanguageModelChat): IDisposable;
-    sendChatRequest(identifier: string, from: ExtensionIdentifier, messages: IChatMessage[], options: {
+    getVendors(): IUserFriendlyLanguageModel[];
+    lookupLanguageModel(modelId: string): ILanguageModelChatMetadata | undefined;
+    selectLanguageModels(selector: ILanguageModelChatSelector, allowPromptingUser?: boolean): Promise<string[]>;
+    registerLanguageModelProvider(vendor: string, provider: ILanguageModelChatProvider): IDisposable;
+    sendChatRequest(modelId: string, from: ExtensionIdentifier, messages: IChatMessage[], options: {
         [name: string]: any;
     }, token: CancellationToken): Promise<ILanguageModelChatResponse>;
-    computeTokenLength(identifier: string, message: string | IChatMessage, token: CancellationToken): Promise<number>;
+    computeTokenLength(modelId: string, message: string | IChatMessage, token: CancellationToken): Promise<number>;
 }

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

@@ -0,0 +1,4 @@
+export declare const DEFAULT_MODEL_PICKER_CATEGORY: {
+    label: string;
+    order: number;
+};

package/vscode/src/vs/workbench/contrib/chat/common/modelPicker/modelPickerWidget.js

@@ -0,0 +1,6 @@
+
+import { localize } from '../../../../../nls.js';
+
+const DEFAULT_MODEL_PICKER_CATEGORY = { label: ( localize(5434, "Other Models")), order: Number.MAX_SAFE_INTEGER };
+
+export { DEFAULT_MODEL_PICKER_CATEGORY };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/types.d.ts

@@ -3,7 +3,7 @@ import { Event } from "../../../../../../base/common/event.js";
 import { ResolveError } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/promptFileReferenceErrors";
 import { IDisposable } from "../../../../../../base/common/lifecycle.js";
 import { VSBufferReadableStream } from "../../../../../../base/common/buffer.js";
-import { PromptsType } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { PromptsType } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
 import { CancellationToken } from "../../../../../../base/common/cancellation.js";
 import { IPromptContentsProviderOptions } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/promptContentsProviderBase";
 export interface IPromptContentsProvider extends IDisposable {

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

@@ -2,7 +2,7 @@ import { ChatModeKind } from "../../constants.js";
 import { URI } from "../../../../../../base/common/uri.js";
 import { TMetadata } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptHeader/headerBase";
 import { TextModelPromptParser } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/promptSyntax/parsers/textModelPromptParser";
-import { PromptsType } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { PromptsType } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
 import { ITopError } from "../parsers/types.js";
 export type TPromptsStorage = "local" | "user";
 export interface IPromptPath {

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

@@ -3,7 +3,7 @@ import { Event } from "../../../../../../base/common/event.js";
 import { IDisposable } from "../../../../../../base/common/lifecycle.js";
 import { URI } from "../../../../../../base/common/uri.js";
 import { ITextModel } from "../../../../../../editor/common/model.js";
-import { PromptsType } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { PromptsType } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
 import { TSharedPrompt, IPromptPath, IChatPromptSlashCommand, IPromptParserResult, ICustomChatMode } from "./promptsService.js";
 export declare const IPromptsService: import("../../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IPromptsService>;
 export interface IPromptsService extends IDisposable {

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

@@ -0,0 +1,17 @@
+import { CancellationToken } from "../../../../../base/common/cancellation.js";
+import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { IToolData, IToolImpl, IToolInvocation, IToolResult, IToolInvocationPreparationContext, IPreparedToolInvocation } from "../languageModelToolsService.js";
+import { ILogService } from "../../../../../platform/log/common/log.service.js";
+import { IChatTodoListService } from "../chatTodoListService.service.js";
+export declare const TodoListToolSettingId = "chat.todoListTool.enabled";
+export declare const ManageTodoListToolToolId = "manage_todo_list";
+export declare const ManageTodoListToolData: IToolData;
+export declare class ManageTodoListTool extends Disposable implements IToolImpl {
+    private readonly chatTodoListService;
+    private readonly logService;
+    constructor(chatTodoListService: IChatTodoListService, logService: ILogService);
+    invoke(invocation: IToolInvocation, _countTokens: any, _progress: any, _token: CancellationToken): Promise<IToolResult>;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    private handleRead;
+    private formatTodoListAsMarkdownTaskList;
+}