@codingame/monaco-vscode-api 22.1.8 → 23.0.0

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

@@ -1,5 +1,7 @@
 
 import { Schemas } from '../../../../base/common/network.js';
+import { IChatSessionsService } from './chatSessionsService.service.js';
+import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 
 var ChatConfiguration;
 (function (ChatConfiguration) {
@@ -13,11 +15,12 @@ var ChatConfiguration;
     ChatConfiguration["CheckpointsEnabled"] = "chat.checkpoints.enabled";
     ChatConfiguration["AgentSessionsViewLocation"] = "chat.agentSessionsViewLocation";
     ChatConfiguration["ThinkingStyle"] = "chat.agent.thinkingStyle";
-    ChatConfiguration["TodoList"] = "chat.agent.todoList";
+    ChatConfiguration["TodosShowWidget"] = "chat.tools.todos.showWidget";
     ChatConfiguration["UseCloudButtonV2"] = "chat.useCloudButtonV2";
     ChatConfiguration["ShowAgentSessionsViewDescription"] = "chat.showAgentSessionsViewDescription";
     ChatConfiguration["EmptyStateHistoryEnabled"] = "chat.emptyState.history.enabled";
     ChatConfiguration["NotifyWindowOnResponseReceived"] = "chat.notifyWindowOnResponseReceived";
+    ChatConfiguration["SubagentToolCustomAgents"] = "chat.customAgentInSubagent.enabled";
 })(ChatConfiguration || (ChatConfiguration = {}));
 var ChatModeKind;
 (function (ChatModeKind) {
@@ -39,9 +42,7 @@ var ThinkingDisplayMode;
 (function (ThinkingDisplayMode) {
     ThinkingDisplayMode["Collapsed"] = "collapsed";
     ThinkingDisplayMode["CollapsedPreview"] = "collapsedPreview";
-    ThinkingDisplayMode["Expanded"] = "expanded";
-    ThinkingDisplayMode["None"] = "none";
-    ThinkingDisplayMode["CollapsedPerItem"] = "collapsedPerItem";
+    ThinkingDisplayMode["FixedScrolling"] = "fixedScrolling";
 })(ThinkingDisplayMode || (ThinkingDisplayMode = {}));
 var ChatAgentLocation;
 (function (ChatAgentLocation) {
@@ -62,9 +63,32 @@ var ChatAgentLocation;
     }
     ChatAgentLocation.fromRaw = fromRaw;
 })(ChatAgentLocation || (ChatAgentLocation = {}));
-const ChatUnsupportedFileSchemes = ( new Set(
-    [Schemas.vscodeChatEditor, Schemas.walkThrough, Schemas.vscodeChatSession, 'ccreq']
-));
-const VIEWLET_ID = 'workbench.view.chat.sessions';
+const chatAlwaysUnsupportedFileSchemes = ( new Set([
+    Schemas.vscodeChatEditor,
+    Schemas.walkThrough,
+    Schemas.vscodeLocalChatSession,
+    Schemas.vscodeSettings,
+    Schemas.webviewPanel,
+    Schemas.vscodeUserData,
+    Schemas.extension,
+    'ccreq',
+    'openai-codex',
+]));
+function isSupportedChatFileScheme(accessor, scheme) {
+    const chatService = accessor.get(IChatSessionsService);
+    if (( chatAlwaysUnsupportedFileSchemes.has(scheme))) {
+        return false;
+    }
+    if (chatService.getContentProviderSchemes().includes(scheme)) {
+        return false;
+    }
+    return true;
+}
+const AGENT_SESSIONS_VIEWLET_ID = 'workbench.view.chat.sessions';
+const MANAGE_CHAT_COMMAND_ID = 'workbench.action.chat.manage';
+const ChatEditorTitleMaxLength = 30;
+const CHAT_TERMINAL_OUTPUT_MAX_PREVIEW_LINES = 1000;
+const CONTEXT_MODELS_EDITOR = ( new RawContextKey('inModelsEditor', false));
+const CONTEXT_MODELS_SEARCH_FOCUS = ( new RawContextKey('inModelsSearch', false));
 
-export { ChatAgentLocation, ChatConfiguration, ChatModeKind, ChatUnsupportedFileSchemes, ThinkingDisplayMode, VIEWLET_ID, validateChatMode };
+export { AGENT_SESSIONS_VIEWLET_ID, CHAT_TERMINAL_OUTPUT_MAX_PREVIEW_LINES, CONTEXT_MODELS_EDITOR, CONTEXT_MODELS_SEARCH_FOCUS, ChatAgentLocation, ChatConfiguration, ChatEditorTitleMaxLength, ChatModeKind, MANAGE_CHAT_COMMAND_ID, ThinkingDisplayMode, isSupportedChatFileScheme, validateChatMode };

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

@@ -0,0 +1,49 @@
+import { IQuickInputButton, IQuickTreeItem } from "../../../../platform/quickinput/common/quickInput.js";
+import { ConfirmedReason } from "./chatService.js";
+import { ToolDataSource } from "./languageModelToolsService.js";
+export interface ILanguageModelToolConfirmationActions {
+    /** Label for the action */
+    label: string;
+    /** Action detail (e.g. tooltip) */
+    detail?: string;
+    /** Show a separator before this action */
+    divider?: boolean;
+    /** Selects this action. Resolves true if the action should be confirmed after selection */
+    select(): Promise<boolean>;
+}
+export interface ILanguageModelToolConfirmationRef {
+    toolId: string;
+    source: ToolDataSource;
+    parameters: unknown;
+}
+export interface ILanguageModelToolConfirmationActionProducer {
+    getPreConfirmAction(ref: ILanguageModelToolConfirmationRef): ConfirmedReason | undefined;
+    getPostConfirmAction(ref: ILanguageModelToolConfirmationRef): ConfirmedReason | undefined;
+    /** Gets the selectable actions to take to memorize confirmation changes */
+    getPreConfirmActions(ref: ILanguageModelToolConfirmationRef): ILanguageModelToolConfirmationActions[];
+    getPostConfirmActions(ref: ILanguageModelToolConfirmationRef): ILanguageModelToolConfirmationActions[];
+}
+export interface ILanguageModelToolConfirmationContributionQuickTreeItem extends IQuickTreeItem {
+    onDidTriggerItemButton?(button: IQuickInputButton): void;
+    onDidChangeChecked?(checked: boolean): void;
+}
+/**
+ * Type that can be registered to provide more specific confirmation
+ * actions for a specific tool.
+ */
+export type ILanguageModelToolConfirmationContribution = Partial<ILanguageModelToolConfirmationActionProducer> & {
+    /**
+     * Gets items to be shown in the `manageConfirmationPreferences` quick tree.
+     * These are added under the tool's category.
+     */
+    getManageActions?(): ILanguageModelToolConfirmationContributionQuickTreeItem[];
+    /**
+     * Defaults to true. If false, the "Always Allow" options will not be shown
+     * and _only_ your custom manage actions will be shown.
+     */
+    canUseDefaultApprovals?: boolean;
+    /**
+     * Reset all confirmation settings for this tool.
+     */
+    reset?(): void;
+};

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

@@ -0,0 +1,31 @@
+import { IDisposable } from "../../../../base/common/lifecycle.js";
+import { ILanguageModelToolConfirmationActionProducer, ILanguageModelToolConfirmationContribution } from "./languageModelToolsConfirmationService.js";
+import { IToolData } from "./languageModelToolsService.js";
+/**
+* Handles language model tool confirmation.
+*
+* - By default, all tools can have their confirmation preferences saved within
+*   a session, workspace, or globally.
+* - Tools with ToolDataSource from an extension or MCP can have that entire
+*   source's preference saved within a session, workspace, or globally.
+* - Contributable confirmations may also be registered for specific behaviors.
+*
+* Note: this interface MUST NOT depend in the ILanguageModelToolsService.
+* The ILanguageModelToolsService depends on this service instead in order to
+* call getPreConfirmAction/getPostConfirmAction.
+*/
+export interface ILanguageModelToolsConfirmationService extends ILanguageModelToolConfirmationActionProducer {
+    readonly _serviceBrand: undefined;
+    /** Opens an IQuickTree to let the user manage their preferences.  */
+    manageConfirmationPreferences(tools: Readonly<IToolData>[], options?: {
+        defaultScope?: "workspace" | "profile" | "session";
+    }): void;
+    /**
+    * Registers a contribution that provides more specific confirmation logic
+    * for a tool, in addition to the default confirmation handling.
+    */
+    registerConfirmationContribution(toolName: string, contribution: ILanguageModelToolConfirmationContribution): IDisposable;
+    /** Resets all tool and server confirmation preferences */
+    resetToolAutoConfirmation(): void;
+}
+export declare const ILanguageModelToolsConfirmationService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ILanguageModelToolsConfirmationService>;

package/vscode/src/vs/workbench/contrib/chat/common/languageModelToolsConfirmationService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const ILanguageModelToolsConfirmationService = ( createDecorator('ILanguageModelToolsConfirmationService'));
+
+export { ILanguageModelToolsConfirmationService };

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

@@ -11,6 +11,7 @@ import { Location } from "../../../../editor/common/languages.js";
 import { ContextKeyExpression } from "../../../../platform/contextkey/common/contextkey.js";
 import { ExtensionIdentifier } from "../../../../platform/extensions/common/extensions.js";
 import { IProgress } from "../../../../platform/progress/common/progress.js";
+import { UserSelectedTools } from "@codingame/monaco-vscode-aac7027b-326c-513a-95a9-e4eedd151b38-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
 import { IChatExtensionsContent, IChatTodoListContent, IChatToolInputInvocationData, type IChatTerminalToolInvocationData } from "./chatService.js";
 import { LanguageModelPartAudience } from "./languageModels.js";
 export interface IToolData {
@@ -34,6 +35,10 @@ export interface IToolData {
      */
     runsInWorkspace?: boolean;
     alwaysDisplayInputOutput?: boolean;
+    /** True if this tool might ask for pre-approval */
+    canRequestPreApproval?: boolean;
+    /** True if this tool might ask for post-approval */
+    canRequestPostApproval?: boolean;
 }
 export interface IToolProgressStep {
     readonly message: string | IMarkdownString | undefined;
@@ -88,6 +93,7 @@ export interface IToolInvocation {
     fromSubAgent?: boolean;
     toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent;
     modelId?: string;
+    userSelectedTools?: UserSelectedTools;
 }
 export interface IToolInvocationContext {
     sessionId: string;
@@ -139,7 +145,10 @@ export interface IToolResult {
     toolResultDetails?: Array<URI | Location> | IToolResultInputOutputDetails | IToolResultOutputDetails;
     toolResultError?: string;
     toolMetadata?: unknown;
+    /** Whether to ask the user to confirm these tool results. Overrides {@link IToolConfirmationMessages.confirmResults}. */
+    confirmResults?: boolean;
 }
+export declare function toolContentToA11yString(part: IToolResult["content"]): string;
 export declare function toolResultHasBuffers(result: IToolResult): boolean;
 export interface IToolResultPromptTsxPart {
     kind: "promptTsx";
@@ -160,11 +169,15 @@ export interface IToolResultDataPart {
     audience?: LanguageModelPartAudience[];
 }
 export interface IToolConfirmationMessages {
-    title: string | IMarkdownString;
-    message: string | IMarkdownString;
+    /** Title for the confirmation. If set, the user will be asked to confirm execution of the tool */
+    title?: string | IMarkdownString;
+    /** MUST be set if `title` is also set */
+    message?: string | IMarkdownString;
     disclaimer?: string | IMarkdownString;
     allowAutoConfirm?: boolean;
     terminalCustomActions?: ToolConfirmationAction[];
+    /** If true, confirmation will be requested after the tool executes and before results are sent to the model */
+    confirmResults?: boolean;
 }
 export interface IToolConfirmationAction {
     label: string;
@@ -208,5 +221,15 @@ export declare class ToolSet {
     getTools(r?: IReader): Iterable<IToolData>;
 }
 export type CountTokensCallback = (input: string, token: CancellationToken) => Promise<number>;
-export declare function createToolInputUri(toolOrId: IToolData | string): URI;
+export declare function createToolInputUri(toolCallId: string): URI;
 export declare function createToolSchemaUri(toolOrId: IToolData | string): URI;
+export declare namespace GithubCopilotToolReference {
+    const shell = "shell";
+    const edit = "edit";
+    const search = "search";
+    const customAgent = "custom-agent";
+}
+export declare namespace VSCodeToolReference {
+    const runCommands = "runCommands";
+    const runSubagent = "runSubagent";
+}

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

@@ -5,6 +5,7 @@ import { Schemas } from '../../../../base/common/network.js';
 import '../../../../base/common/observableInternal/index.js';
 import { URI } from '../../../../base/common/uri.js';
 import { localize } from '../../../../nls.js';
+import { ByteSize } from '../../../../platform/files/common/files.js';
 import { stringifyPromptElementJSON } from './tools/promptTsxTypes.js';
 import { ObservableSet } from '../../../../base/common/observableInternal/set.js';
 import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
@@ -29,16 +30,16 @@ var ToolDataSource;
     ToolDataSource.equals = equals;
     function classify(source) {
         if (source.type === 'internal') {
-            return { ordinal: 1, label: ( localize(5608, 'Built-In')) };
+            return { ordinal: 1, label: ( localize(5812, 'Built-In')) };
         }
         else if (source.type === 'mcp') {
-            return { ordinal: 2, label: ( localize(5609, 'MCP Server: {0}', source.label)) };
+            return { ordinal: 2, label: source.label };
         }
         else if (source.type === 'user') {
-            return { ordinal: 0, label: ( localize(5610, 'User Defined')) };
+            return { ordinal: 0, label: ( localize(5813, 'User Defined')) };
         }
         else {
-            return { ordinal: 3, label: ( localize(5611, 'Extension: {0}', source.label)) };
+            return { ordinal: 3, label: source.label };
         }
     }
     ToolDataSource.classify = classify;
@@ -52,6 +53,23 @@ function isToolResultInputOutputDetails(obj) {
 function isToolResultOutputDetails(obj) {
     return typeof obj === 'object' && typeof obj?.output === 'object' && typeof obj?.output?.mimeType === 'string' && obj?.output?.type === 'data';
 }
+function toolContentToA11yString(part) {
+    return ( part.map(p => {
+        switch (p.kind) {
+            case 'promptTsx':
+                return stringifyPromptTsxPart(p);
+            case 'text':
+                return p.value;
+            case 'data':
+                return localize(
+                    5814,
+                    "{0} of {1} binary data",
+                    ByteSize.formatSize(p.value.data.byteLength),
+                    p.value.mimeType || 'unknown'
+                );
+        }
+    })).join(', ');
+}
 function toolResultHasBuffers(result) {
     return ( result.content.some(part => part.kind === 'data'));
 }
@@ -102,11 +120,10 @@ class ToolSet {
         return Iterable.concat(this._tools.observable.read(r), ...( Iterable.map(this._toolSets.observable.read(r), toolSet => toolSet.getTools(r))));
     }
 }
-function createToolInputUri(toolOrId) {
-    if (typeof toolOrId !== 'string') {
-        toolOrId = toolOrId.id;
-    }
-    return ( URI.from({ scheme: Schemas.inMemory, path: `/lm/tool/${toolOrId}/tool_input.json` }));
+function createToolInputUri(toolCallId) {
+    return ( URI.from(
+        { scheme: Schemas.inMemory, path: `/lm/tool/${toolCallId}/tool_input.json` }
+    ));
 }
 function createToolSchemaUri(toolOrId) {
     if (typeof toolOrId !== 'string') {
@@ -116,5 +133,17 @@ function createToolSchemaUri(toolOrId) {
         { scheme: Schemas.vscode, authority: 'schemas', path: `/lm/tool/${toolOrId}` }
     ));
 }
+var GithubCopilotToolReference;
+(function (GithubCopilotToolReference) {
+    GithubCopilotToolReference.shell = 'shell';
+    GithubCopilotToolReference.edit = 'edit';
+    GithubCopilotToolReference.search = 'search';
+    GithubCopilotToolReference.customAgent = 'custom-agent';
+})(GithubCopilotToolReference || (GithubCopilotToolReference = {}));
+var VSCodeToolReference;
+(function (VSCodeToolReference) {
+    VSCodeToolReference.runCommands = 'runCommands';
+    VSCodeToolReference.runSubagent = 'runSubagent';
+})(VSCodeToolReference || (VSCodeToolReference = {}));
 
-export { ToolDataSource, ToolInvocationPresentation, ToolSet, createToolInputUri, createToolSchemaUri, isToolInvocationContext, isToolResultInputOutputDetails, isToolResultOutputDetails, stringifyPromptTsxPart, toolResultHasBuffers };
+export { GithubCopilotToolReference, ToolDataSource, ToolInvocationPresentation, ToolSet, VSCodeToolReference, createToolInputUri, createToolSchemaUri, isToolInvocationContext, isToolResultInputOutputDetails, isToolResultOutputDetails, stringifyPromptTsxPart, toolContentToA11yString, toolResultHasBuffers };

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

@@ -3,13 +3,17 @@ import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { IObservable } from "../../../../base/common/observable.js";
 import { ThemeIcon } from "../../../../base/common/themables.js";
-import { IVariableReference } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModes";
+import { IVariableReference } from "@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatModes";
 import { ChatRequestToolReferenceEntry } from "./chatVariableEntries.js";
 import { IToolData, IToolImpl, IToolInvocation, CountTokensCallback, IToolResult, ToolSet, ToolDataSource, IToolAndToolSetEnablementMap } from "./languageModelToolsService.js";
 export declare const ILanguageModelToolsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ILanguageModelToolsService>;
 export interface ILanguageModelToolsService {
     _serviceBrand: undefined;
-    onDidChangeTools: Event<void>;
+    readonly onDidChangeTools: Event<void>;
+    readonly onDidPrepareToolCallBecomeUnresponsive: Event<{
+        readonly sessionId: string;
+        readonly toolData: IToolData;
+    }>;
     registerToolData(toolData: IToolData): IDisposable;
     registerToolImplementation(id: string, tool: IToolImpl): IDisposable;
     registerTool(toolData: IToolData, tool: IToolImpl): IDisposable;
@@ -17,10 +21,9 @@ export interface ILanguageModelToolsService {
     getTool(id: string): IToolData | undefined;
     getToolByName(name: string, includeDisabled?: boolean): IToolData | undefined;
     invokeTool(invocation: IToolInvocation, countTokens: CountTokensCallback, token: CancellationToken): Promise<IToolResult>;
-    setToolAutoConfirmation(toolId: string, scope: "workspace" | "profile" | "session" | "never"): void;
-    getToolAutoConfirmation(toolId: string): "workspace" | "profile" | "session" | "never";
-    resetToolAutoConfirmation(): void;
     cancelToolCallsForRequest(requestId: string): void;
+    /** Flush any pending tool updates to the extension hosts. */
+    flushToolUpdates(): void;
     readonly toolSets: IObservable<Iterable<ToolSet>>;
     getToolSet(id: string): ToolSet | undefined;
     getToolSetByName(name: string): ToolSet | undefined;
@@ -32,7 +35,8 @@ export interface ILanguageModelToolsService {
     getToolByQualifiedName(qualifiedName: string): IToolData | ToolSet | undefined;
     getQualifiedToolName(tool: IToolData, toolSet?: ToolSet): string;
     getDeprecatedQualifiedToolNames(): Map<string, string>;
-    toToolAndToolSetEnablementMap(qualifiedToolOrToolSetNames: readonly string[]): IToolAndToolSetEnablementMap;
+    mapGithubToolName(githubToolName: string): string;
+    toToolAndToolSetEnablementMap(qualifiedToolOrToolSetNames: readonly string[], target: string | undefined): IToolAndToolSetEnablementMap;
     toQualifiedToolNames(map: IToolAndToolSetEnablementMap): string[];
     toToolReferences(variableReferences: readonly IVariableReference[]): ChatRequestToolReferenceEntry[];
 }

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

@@ -1,9 +1,11 @@
 import { VSBuffer } from "../../../../base/common/buffer.js";
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
+import { TypeFromJsonSchema } from "../../../../base/common/jsonSchema.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { ThemeIcon } from "../../../../base/common/themables.js";
 import { URI } from "../../../../base/common/uri.js";
+import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.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";
@@ -161,7 +163,7 @@ export interface ILanguageModelChatResponse {
     result: Promise<any>;
 }
 export interface ILanguageModelChatProvider {
-    onDidChange: Event<void>;
+    readonly onDidChange: Event<void>;
     provideLanguageModelChatInfo(options: {
         silent: boolean;
     }, token: CancellationToken): Promise<ILanguageModelChatMetadataAndIdentifier[]>;
@@ -190,16 +192,48 @@ export interface ILanguageModelChatMetadataAndIdentifier {
     metadata: ILanguageModelChatMetadata;
     identifier: string;
 }
-export interface IUserFriendlyLanguageModel {
-    vendor: string;
-    displayName: string;
-    managementCommand?: string;
-}
-export declare const languageModelChatProviderExtensionPoint: import("../../../services/extensions/common/extensionsRegistry.js").IExtensionPoint<IUserFriendlyLanguageModel | IUserFriendlyLanguageModel[]>;
+declare const languageModelChatProviderType: {
+    readonly type: "object";
+    readonly required: [
+        "vendor",
+        "displayName"
+    ];
+    readonly properties: {
+        readonly vendor: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly displayName: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly managementCommand: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly when: {
+            readonly type: "string";
+            readonly description: string;
+        };
+    };
+};
+export type IUserFriendlyLanguageModel = TypeFromJsonSchema<typeof languageModelChatProviderType>;
+export declare const languageModelChatProviderExtensionPoint: import("../../../services/extensions/common/extensionsRegistry.js").IExtensionPoint<{
+    readonly vendor: string;
+    readonly displayName: string;
+    readonly managementCommand: string | undefined;
+    readonly when: string | undefined;
+} | {
+    readonly vendor: string;
+    readonly displayName: string;
+    readonly managementCommand: string | undefined;
+    readonly when: string | undefined;
+}[]>;
 export declare class LanguageModelsService implements ILanguageModelsService {
     private readonly _extensionService;
     private readonly _logService;
     private readonly _storageService;
+    private readonly _configurationService;
     private readonly _chatEntitlementService;
     readonly _serviceBrand: undefined;
     private readonly _store;
@@ -209,9 +243,10 @@ export declare class LanguageModelsService implements ILanguageModelsService {
     private readonly _resolveLMSequencer;
     private _modelPickerUserPreferences;
     private readonly _hasUserSelectableModels;
+    private readonly _contextKeyService;
     private readonly _onLanguageModelChange;
-    readonly onDidChangeLanguageModels: Event<void>;
-    constructor(_extensionService: IExtensionService, _logService: ILogService, _storageService: IStorageService, _contextKeyService: IContextKeyService, _chatEntitlementService: IChatEntitlementService);
+    readonly onDidChangeLanguageModels: Event<string>;
+    constructor(_extensionService: IExtensionService, _logService: ILogService, _storageService: IStorageService, _contextKeyService: IContextKeyService, _configurationService: IConfigurationService, _chatEntitlementService: IChatEntitlementService);
     private _hasStoredModelForVendor;
     dispose(): void;
     updateModelPickerPreference(modelIdentifier: string, showInModelPicker: boolean): void;
@@ -227,3 +262,4 @@ export declare class LanguageModelsService implements ILanguageModelsService {
     }, token: CancellationToken): Promise<ILanguageModelChatResponse>;
     computeTokenLength(modelId: string, message: string | IChatMessage, token: CancellationToken): Promise<number>;
 }
+export {};

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

@@ -7,6 +7,8 @@ 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 { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
 import { ILogService } from '../../../../platform/log/common/log.service.js';
 import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
@@ -63,28 +65,36 @@ var ILanguageModelChatMetadata;
 })(ILanguageModelChatMetadata || (ILanguageModelChatMetadata = {}));
 const languageModelChatProviderType = {
     type: 'object',
+    required: ['vendor', 'displayName'],
     properties: {
         vendor: {
             type: 'string',
-            description: ( localize(5612, "A globally unique vendor of language model chat provider."))
+            description: ( localize(5815, "A globally unique vendor of language model chat provider."))
         },
         displayName: {
             type: 'string',
-            description: ( localize(5613, "The display name of the language model chat provider."))
+            description: ( localize(5816, "The display name of the language model chat provider."))
         },
         managementCommand: {
             type: 'string',
             description: ( localize(
-                5614,
+                5817,
                 "A command to manage the language model chat provider, 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."
             ))
+        },
+        when: {
+            type: 'string',
+            description: ( localize(
+                5818,
+                "Condition which must be true to show this language model chat provider in the Manage Models list."
+            ))
         }
     }
 };
 const languageModelChatProviderExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'languageModelChatProviders',
     jsonSchema: {
-        description: ( localize(5615, "Contribute language model chat providers of a specific vendor.")),
+        description: ( localize(5819, "Contribute language model chat providers of a specific vendor.")),
         oneOf: [
             languageModelChatProviderType,
             {
@@ -100,10 +110,11 @@ const languageModelChatProviderExtensionPoint = ExtensionsRegistry.registerExten
     }
 });
 let LanguageModelsService = class LanguageModelsService {
-    constructor(_extensionService, _logService, _storageService, _contextKeyService, _chatEntitlementService) {
+    constructor(_extensionService, _logService, _storageService, _contextKeyService, _configurationService, _chatEntitlementService) {
         this._extensionService = _extensionService;
         this._logService = _logService;
         this._storageService = _storageService;
+        this._configurationService = _configurationService;
         this._chatEntitlementService = _chatEntitlementService;
         this._store = ( new DisposableStore());
         this._providers = ( new Map());
@@ -114,15 +125,13 @@ let LanguageModelsService = class LanguageModelsService {
         this._onLanguageModelChange = this._store.add(( new Emitter()));
         this.onDidChangeLanguageModels = this._onLanguageModelChange.event;
         this._hasUserSelectableModels = ChatContextKeys.languageModelsAreUserSelectable.bindTo(_contextKeyService);
+        this._contextKeyService = _contextKeyService;
         this._modelPickerUserPreferences = this._storageService.getObject('chatModelPickerPreferences', StorageScope.PROFILE, this._modelPickerUserPreferences);
         const entitlementChangeHandler = () => {
             if ((this._chatEntitlementService.entitlement === ChatEntitlement.Business || this._chatEntitlementService.entitlement === ChatEntitlement.Enterprise) && !this._chatEntitlementService.isInternal) {
                 this._modelPickerUserPreferences = {};
                 this._storageService.store('chatModelPickerPreferences', this._modelPickerUserPreferences, StorageScope.PROFILE, StorageTarget.USER);
             }
-            else if (this._chatEntitlementService.entitlement === ChatEntitlement.Unknown) {
-                this._modelPickerUserPreferences = {};
-            }
         };
         entitlementChangeHandler();
         this._store.add(this._chatEntitlementService.onDidChangeEntitlement(entitlementChangeHandler));
@@ -135,18 +144,18 @@ let LanguageModelsService = class LanguageModelsService {
                 for (const item of Iterable.wrap(extension.value)) {
                     if (( this._vendors.has(item.vendor))) {
                         extension.collector.error(( localize(
-                            5616,
+                            5820,
                             "The vendor '{0}' is already registered and cannot be registered twice",
                             item.vendor
                         )));
                         continue;
                     }
                     if (isFalsyOrWhitespace(item.vendor)) {
-                        extension.collector.error(( localize(5617, "The vendor field cannot be empty.")));
+                        extension.collector.error(( localize(5821, "The vendor field cannot be empty.")));
                         continue;
                     }
                     if (item.vendor.trim() !== item.vendor) {
-                        extension.collector.error(( localize(5618, "The vendor field cannot start or end with whitespace.")));
+                        extension.collector.error(( localize(5822, "The vendor field cannot start or end with whitespace.")));
                         continue;
                     }
                     this._vendors.set(item.vendor, item);
@@ -185,17 +194,26 @@ let LanguageModelsService = class LanguageModelsService {
         else if (model.isUserSelectable !== showInModelPicker) {
             this._storageService.store('chatModelPickerPreferences', this._modelPickerUserPreferences, StorageScope.PROFILE, StorageTarget.USER);
         }
-        this._onLanguageModelChange.fire();
+        this._onLanguageModelChange.fire(model.vendor);
         this._logService.trace(`[LM] Updated model picker preference for ${modelIdentifier} to ${showInModelPicker}`);
     }
     getVendors() {
-        return Array.from(( this._vendors.values()));
+        return Array.from(( this._vendors.values())).filter(vendor => {
+            if (!vendor.when) {
+                return true;
+            }
+            const whenClause = ContextKeyExpr.deserialize(vendor.when);
+            return whenClause ? this._contextKeyService.contextMatchesRules(whenClause) : false;
+        });
     }
     getLanguageModelIds() {
         return Array.from(( this._modelCache.keys()));
     }
     lookupLanguageModel(modelIdentifier) {
         const model = this._modelCache.get(modelIdentifier);
+        if (model && this._configurationService.getValue('chat.experimentalShowAllModels')) {
+            return { ...model, isUserSelectable: true };
+        }
         if (model && this._modelPickerUserPreferences[modelIdentifier] !== undefined) {
             return { ...model, isUserSelectable: this._modelPickerUserPreferences[modelIdentifier] };
         }
@@ -234,7 +252,7 @@ let LanguageModelsService = class LanguageModelsService {
             catch (error) {
                 this._logService.error(`[LM] Error resolving language models for vendor ${vendor}:`, error);
             }
-            this._onLanguageModelChange.fire();
+            this._onLanguageModelChange.fire(vendor);
         });
     }
     async selectLanguageModels(selector, allowPromptingUser) {
@@ -266,7 +284,9 @@ let LanguageModelsService = class LanguageModelsService {
             throw ( new Error(`Chat model provider for vendor ${vendor} is already registered.`));
         }
         this._providers.set(vendor, provider);
-        this._resolveLanguageModels(vendor, true);
+        if (this._hasStoredModelForVendor(vendor)) {
+            this._resolveLanguageModels(vendor, true);
+        }
         const modelChangeListener = provider.onDidChange(async () => {
             await this._resolveLanguageModels(vendor, true);
         });
@@ -301,7 +321,8 @@ LanguageModelsService = ( __decorate([
     ( __param(1, ILogService)),
     ( __param(2, IStorageService)),
     ( __param(3, IContextKeyService)),
-    ( __param(4, IChatEntitlementService))
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IChatEntitlementService))
 ], LanguageModelsService));
 
 export { ChatImageMimeType, ChatMessageRole, ILanguageModelChatMetadata, ImageDetailLevel, LanguageModelPartAudience, LanguageModelsService, languageModelChatProviderExtensionPoint };

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

@@ -6,7 +6,7 @@ import { IUserFriendlyLanguageModel, ILanguageModelChatMetadata, ILanguageModelC
 export declare const ILanguageModelsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ILanguageModelsService>;
 export interface ILanguageModelsService {
     readonly _serviceBrand: undefined;
-    onDidChangeLanguageModels: Event<void>;
+    readonly onDidChangeLanguageModels: Event<string>;
     updateModelPickerPreference(modelIdentifier: string, showInModelPicker: boolean): void;
     getLanguageModelIds(): string[];
     getVendors(): IUserFriendlyLanguageModel[];

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

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