@codingame/monaco-vscode-api 20.5.0 → 21.0.1

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

@@ -1,23 +1,25 @@
 
+import { Iterable } from '../../../../base/common/iterator.js';
 import { toDisposable, Disposable } from '../../../../base/common/lifecycle.js';
 import { Schemas } from '../../../../base/common/network.js';
-import { URI } from '../../../../base/common/uri.js';
-import { stringifyPromptElementJSON } from './tools/promptTsxTypes.js';
 import '../../../../base/common/observableInternal/index.js';
-import { Iterable } from '../../../../base/common/iterator.js';
+import { URI } from '../../../../base/common/uri.js';
 import { localize } from '../../../../nls.js';
+import { stringifyPromptElementJSON } from './tools/promptTsxTypes.js';
 import { ObservableSet } from '../../../../base/common/observableInternal/set.js';
 import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
 
 var ToolDataSource;
 (function (ToolDataSource) {
     ToolDataSource.Internal = { type: 'internal', label: 'Built-In' };
+    ToolDataSource.External = { type: 'external', label: 'External' };
     function toKey(source) {
         switch (source.type) {
             case 'extension': return `extension:${source.extensionId.value}`;
             case 'mcp': return `mcp:${source.collectionId}:${source.definitionId}`;
             case 'user': return `user:${( source.file.toString())}`;
             case 'internal': return 'internal';
+            case 'external': return 'external';
         }
     }
     ToolDataSource.toKey = toKey;
@@ -27,16 +29,16 @@ var ToolDataSource;
     ToolDataSource.equals = equals;
     function classify(source) {
         if (source.type === 'internal') {
-            return { ordinal: 1, label: ( localize(5425, 'Built-In')) };
+            return { ordinal: 1, label: ( localize(5552, 'Built-In')) };
         }
         else if (source.type === 'mcp') {
-            return { ordinal: 2, label: ( localize(5426, 'MCP Server: {0}', source.label)) };
+            return { ordinal: 2, label: ( localize(5553, 'MCP Server: {0}', source.label)) };
         }
         else if (source.type === 'user') {
-            return { ordinal: 0, label: ( localize(5427, 'User Defined')) };
+            return { ordinal: 0, label: ( localize(5554, 'User Defined')) };
         }
         else {
-            return { ordinal: 3, label: ( localize(5428, 'Extension: {0}', source.label)) };
+            return { ordinal: 3, label: ( localize(5555, 'Extension: {0}', source.label)) };
         }
     }
     ToolDataSource.classify = classify;
@@ -56,6 +58,11 @@ function toolResultHasBuffers(result) {
 function stringifyPromptTsxPart(part) {
     return stringifyPromptElementJSON(part.value);
 }
+var ToolInvocationPresentation;
+(function (ToolInvocationPresentation) {
+    ToolInvocationPresentation["Hidden"] = "hidden";
+    ToolInvocationPresentation["HiddenAfterComplete"] = "hiddenAfterComplete";
+})(ToolInvocationPresentation || (ToolInvocationPresentation = {}));
 class ToolSet {
     constructor(id, referenceName, icon, source, description) {
         this.id = id;
@@ -110,4 +117,4 @@ function createToolSchemaUri(toolOrId) {
     ));
 }
 
-export { ToolDataSource, ToolSet, createToolInputUri, createToolSchemaUri, isToolInvocationContext, isToolResultInputOutputDetails, isToolResultOutputDetails, stringifyPromptTsxPart, toolResultHasBuffers };
+export { ToolDataSource, ToolInvocationPresentation, ToolSet, createToolInputUri, createToolSchemaUri, isToolInvocationContext, isToolResultInputOutputDetails, isToolResultOutputDetails, stringifyPromptTsxPart, toolResultHasBuffers };

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

@@ -10,16 +10,17 @@ export interface ILanguageModelToolsService {
     onDidChangeTools: Event<void>;
     registerToolData(toolData: IToolData): IDisposable;
     registerToolImplementation(id: string, tool: IToolImpl): IDisposable;
-    flushToolChanges(): void;
+    registerTool(toolData: IToolData, tool: IToolImpl): IDisposable;
     getTools(): Iterable<Readonly<IToolData>>;
     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" | "memory", autoConfirm?: boolean): void;
+    setToolAutoConfirmation(toolId: string, scope: "workspace" | "profile" | "session" | "never"): void;
+    getToolAutoConfirmation(toolId: string): "workspace" | "profile" | "session" | "never";
     resetToolAutoConfirmation(): void;
     cancelToolCallsForRequest(requestId: string): void;
     toToolEnablementMap(toolOrToolSetNames: Set<string>): Record<string, boolean>;
-    toToolAndToolSetEnablementMap(toolOrToolSetNames: readonly string[] | undefined): IToolAndToolSetEnablementMap;
+    toToolAndToolSetEnablementMap(toolOrToolSetNames: readonly string[]): IToolAndToolSetEnablementMap;
     readonly toolSets: IObservable<Iterable<ToolSet>>;
     getToolSet(id: string): ToolSet | undefined;
     getToolSetByName(name: string): ToolSet | undefined;

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

@@ -2,6 +2,7 @@ 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 { ThemeIcon } from "../../../../base/common/themables.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";
@@ -14,24 +15,33 @@ export declare enum ChatMessageRole {
     User = 1,
     Assistant = 2
 }
-export declare enum ToolResultAudience {
+export declare enum LanguageModelPartAudience {
     Assistant = 0,
-    User = 1
+    User = 1,
+    Extension = 2
 }
 export interface IChatMessageTextPart {
     type: "text";
     value: string;
-    audience?: ToolResultAudience[];
+    audience?: LanguageModelPartAudience[];
 }
 export interface IChatMessageImagePart {
     type: "image_url";
     value: IChatImageURLPart;
 }
+export interface IChatMessageThinkingPart {
+    type: "thinking";
+    value: string | string[];
+    id?: string;
+    metadata?: {
+        readonly [key: string]: any;
+    };
+}
 export interface IChatMessageDataPart {
     type: "data";
     mimeType: string;
     data: VSBuffer;
-    audience?: ToolResultAudience[];
+    audience?: LanguageModelPartAudience[];
 }
 export interface IChatImageURLPart {
     /**
@@ -66,7 +76,7 @@ export interface IChatMessageToolResultPart {
     value: (IChatResponseTextPart | IChatResponsePromptTsxPart | IChatResponseDataPart)[];
     isError?: boolean;
 }
-export type IChatMessagePart = IChatMessageTextPart | IChatMessageToolResultPart | IChatResponseToolUsePart | IChatMessageImagePart | IChatMessageDataPart;
+export type IChatMessagePart = IChatMessageTextPart | IChatMessageToolResultPart | IChatResponseToolUsePart | IChatMessageImagePart | IChatMessageDataPart | IChatMessageThinkingPart;
 export interface IChatMessage {
     readonly name?: string | undefined;
     readonly role: ChatMessageRole;
@@ -75,7 +85,7 @@ export interface IChatMessage {
 export interface IChatResponseTextPart {
     type: "text";
     value: string;
-    audience?: ToolResultAudience[];
+    audience?: LanguageModelPartAudience[];
 }
 export interface IChatResponsePromptTsxPart {
     type: "prompt_tsx";
@@ -83,8 +93,9 @@ export interface IChatResponsePromptTsxPart {
 }
 export interface IChatResponseDataPart {
     type: "data";
-    value: IChatImageURLPart;
-    audience?: ToolResultAudience[];
+    mimeType: string;
+    data: VSBuffer;
+    audience?: LanguageModelPartAudience[];
 }
 export interface IChatResponseToolUsePart {
     type: "tool_use";
@@ -92,6 +103,14 @@ export interface IChatResponseToolUsePart {
     toolCallId: string;
     parameters: any;
 }
+export interface IChatResponseThinkingPart {
+    type: "thinking";
+    value: string | string[];
+    id?: string;
+    metadata?: {
+        readonly [key: string]: any;
+    };
+}
 export interface IChatResponsePullRequestPart {
     type: "pullRequest";
     uri: URI;
@@ -100,25 +119,22 @@ export interface IChatResponsePullRequestPart {
     author: string;
     linkTag: string;
 }
+export type IChatResponsePart = IChatResponseTextPart | IChatResponseToolUsePart | IChatResponseDataPart | IChatResponseThinkingPart;
 export type IExtendedChatResponsePart = IChatResponsePullRequestPart;
-export type IChatResponsePart = IChatResponseTextPart | IChatResponseToolUsePart | IChatResponseDataPart;
-export interface IChatResponseFragment {
-    index: number;
-    part: IChatResponsePart;
-}
 export interface ILanguageModelChatMetadata {
     readonly extension: ExtensionIdentifier;
     readonly name: string;
     readonly id: string;
     readonly vendor: string;
     readonly version: string;
-    readonly description?: string;
-    readonly cost?: string;
+    readonly tooltip?: string;
+    readonly detail?: string;
     readonly family: string;
     readonly maxInputTokens: number;
     readonly maxOutputTokens: number;
     readonly isDefault?: boolean;
     readonly isUserSelectable?: boolean;
+    readonly statusIcon?: ThemeIcon;
     readonly modelPickerCategory: {
         label: string;
         order: number;
@@ -136,14 +152,15 @@ export interface ILanguageModelChatMetadata {
 export declare namespace ILanguageModelChatMetadata {
     function suitableForAgentMode(metadata: ILanguageModelChatMetadata): boolean;
     function asQualifiedName(metadata: ILanguageModelChatMetadata): string;
+    function matchesQualifiedName(name: string, metadata: ILanguageModelChatMetadata): boolean;
 }
 export interface ILanguageModelChatResponse {
-    stream: AsyncIterable<IChatResponseFragment | IChatResponseFragment[]>;
+    stream: AsyncIterable<IChatResponsePart | IChatResponsePart[]>;
     result: Promise<any>;
 }
 export interface ILanguageModelChatProvider {
     onDidChange: Event<void>;
-    prepareLanguageModelChat(options: {
+    provideLanguageModelChatInfo(options: {
         silent: boolean;
     }, token: CancellationToken): Promise<ILanguageModelChatMetadataAndIdentifier[]>;
     sendChatRequest(modelId: string, messages: IChatMessage[], from: ExtensionIdentifier, options: {
@@ -176,7 +193,7 @@ export interface IUserFriendlyLanguageModel {
     displayName: string;
     managementCommand?: string;
 }
-export declare const languageModelExtensionPoint: import("../../../services/extensions/common/extensionsRegistry.js").IExtensionPoint<IUserFriendlyLanguageModel | IUserFriendlyLanguageModel[]>;
+export declare const languageModelChatProviderExtensionPoint: import("../../../services/extensions/common/extensionsRegistry.js").IExtensionPoint<IUserFriendlyLanguageModel | IUserFriendlyLanguageModel[]>;
 export declare class LanguageModelsService implements ILanguageModelsService {
     private readonly _extensionService;
     private readonly _logService;
@@ -191,6 +208,7 @@ export declare class LanguageModelsService implements ILanguageModelsService {
     private readonly _onLanguageModelChange;
     readonly onDidChangeLanguageModels: Event<void>;
     constructor(_extensionService: IExtensionService, _logService: ILogService, _storageService: IStorageService, _contextKeyService: IContextKeyService);
+    private _hasStoredModelForvendor;
     dispose(): void;
     updateModelPickerPreference(modelIdentifier: string, showInModelPicker: boolean): void;
     getVendors(): IUserFriendlyLanguageModel[];

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

@@ -10,7 +10,6 @@ import { IContextKeyService } from '../../../../platform/contextkey/common/conte
 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';
 import { ChatContextKeys } from './chatContextKeys.js';
@@ -21,11 +20,12 @@ 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 LanguageModelPartAudience;
+(function (LanguageModelPartAudience) {
+    LanguageModelPartAudience[LanguageModelPartAudience["Assistant"] = 0] = "Assistant";
+    LanguageModelPartAudience[LanguageModelPartAudience["User"] = 1] = "User";
+    LanguageModelPartAudience[LanguageModelPartAudience["Extension"] = 2] = "Extension";
+})(LanguageModelPartAudience || (LanguageModelPartAudience = {}));
 var ChatImageMimeType;
 (function (ChatImageMimeType) {
     ChatImageMimeType["PNG"] = "image/png";
@@ -47,48 +47,52 @@ var ILanguageModelChatMetadata;
     }
     ILanguageModelChatMetadata.suitableForAgentMode = suitableForAgentMode;
     function asQualifiedName(metadata) {
-        if (metadata.modelPickerCategory === undefined) {
-            return `${metadata.name} (${metadata.family})`;
-        }
-        return metadata.name;
+        return `${metadata.name} (${metadata.vendor})`;
     }
     ILanguageModelChatMetadata.asQualifiedName = asQualifiedName;
+    function matchesQualifiedName(name, metadata) {
+        if (metadata.vendor === 'copilot' && name === metadata.name) {
+            return true;
+        }
+        return name === asQualifiedName(metadata);
+    }
+    ILanguageModelChatMetadata.matchesQualifiedName = matchesQualifiedName;
 })(ILanguageModelChatMetadata || (ILanguageModelChatMetadata = {}));
-const languageModelType = {
+const languageModelChatProviderType = {
     type: 'object',
     properties: {
         vendor: {
             type: 'string',
-            description: ( localize(5429, "A globally unique vendor of language models."))
+            description: ( localize(5556, "A globally unique vendor of language model chat provider."))
         },
         displayName: {
             type: 'string',
-            description: ( localize(5430, "The display name of the language model vendor."))
+            description: ( localize(5557, "The display name of the language model chat provider."))
         },
         managementCommand: {
             type: 'string',
             description: ( localize(
-                5431,
-                "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."
+                5558,
+                "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."
             ))
         }
     }
 };
-const languageModelExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'languageModels',
+const languageModelChatProviderExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'languageModelChatProviders',
     jsonSchema: {
-        description: ( localize(5432, "Contribute language models of a specific vendor.")),
+        description: ( localize(5559, "Contribute language model chat providers of a specific vendor.")),
         oneOf: [
-            languageModelType,
+            languageModelChatProviderType,
             {
                 type: 'array',
-                items: languageModelType
+                items: languageModelChatProviderType
             }
         ]
     },
     activationEventsGenerator: (contribs, result) => {
         for (const contrib of contribs) {
-            result.push(`onLanguageModelChat:${contrib.vendor}`);
+            result.push(`onLanguageModelChatProvider:${contrib.vendor}`);
         }
     }
 });
@@ -109,31 +113,30 @@ let LanguageModelsService = class LanguageModelsService {
         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._store.add(languageModelChatProviderExtensionPoint.setHandler((extensions) => {
             this._vendors.clear();
             for (const extension of extensions) {
-                if (!isProposedApiEnabled(extension.description, 'chatProvider')) {
-                    extension.collector.error(( localize(5433, "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(
-                            5434,
+                            5560,
                             "The vendor '{0}' is already registered and cannot be registered twice",
                             item.vendor
                         )));
                         continue;
                     }
                     if (isFalsyOrWhitespace(item.vendor)) {
-                        extension.collector.error(( localize(5435, "The vendor field cannot be empty.")));
+                        extension.collector.error(( localize(5561, "The vendor field cannot be empty.")));
                         continue;
                     }
                     if (item.vendor.trim() !== item.vendor) {
-                        extension.collector.error(( localize(5436, "The vendor field cannot start or end with whitespace.")));
+                        extension.collector.error(( localize(5562, "The vendor field cannot start or end with whitespace.")));
                         continue;
                     }
                     this._vendors.set(item.vendor, item);
+                    if (this._hasStoredModelForvendor(item.vendor)) {
+                        this._extensionService.activateByEvent(`onLanguageModelChatProvider:${item.vendor}`);
+                    }
                 }
             }
             for (const [vendor, _] of this._providers) {
@@ -143,6 +146,11 @@ let LanguageModelsService = class LanguageModelsService {
             }
         }));
     }
+    _hasStoredModelForvendor(vendor) {
+        return ( ( Object.keys(this._modelPickerUserPreferences)).some(modelId => {
+            return modelId.startsWith(vendor);
+        }));
+    }
     dispose() {
         this._store.dispose();
         this._providers.clear();
@@ -193,6 +201,10 @@ let LanguageModelsService = class LanguageModelsService {
         if (typeof vendors === 'string') {
             vendors = [vendors];
         }
+        const all = ( vendors.map(
+            vendor => this._extensionService.activateByEvent(`onLanguageModelChatProvider:${vendor}`)
+        ));
+        await Promise.all(all);
         this._clearModelCache(vendors);
         for (const vendor of vendors) {
             const provider = this._providers.get(vendor);
@@ -201,7 +213,10 @@ let LanguageModelsService = class LanguageModelsService {
                 continue;
             }
             try {
-                const modelsAndIdentifiers = await provider.prepareLanguageModelChat({ silent }, CancellationToken.None);
+                let modelsAndIdentifiers = await provider.provideLanguageModelChatInfo({ silent }, CancellationToken.None);
+                if (!silent && ( modelsAndIdentifiers.some(m => m.metadata.isUserSelectable))) {
+                    modelsAndIdentifiers = modelsAndIdentifiers.filter(m => m.metadata.isUserSelectable || this._modelPickerUserPreferences[m.identifier] === true);
+                }
                 for (const modelAndIdentifier of modelsAndIdentifiers) {
                     if (( this._modelCache.has(modelAndIdentifier.identifier))) {
                         this._logService.warn(`[LM] Model ${modelAndIdentifier.identifier} is already registered. Skipping.`);
@@ -219,15 +234,10 @@ let LanguageModelsService = class LanguageModelsService {
     }
     async selectLanguageModels(selector, allowPromptingUser) {
         if (selector.vendor) {
-            await this._extensionService.activateByEvent(`onLanguageModelChat:${selector.vendor}}`);
             await this.resolveLanguageModels([selector.vendor], !allowPromptingUser);
         }
         else {
             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 = [];
@@ -286,4 +296,4 @@ LanguageModelsService = ( __decorate([
     ( __param(3, IContextKeyService))
 ], LanguageModelsService));
 
-export { ChatImageMimeType, ChatMessageRole, ILanguageModelChatMetadata, ImageDetailLevel, LanguageModelsService, ToolResultAudience, languageModelExtensionPoint };
+export { ChatImageMimeType, ChatMessageRole, ILanguageModelChatMetadata, ImageDetailLevel, LanguageModelPartAudience, LanguageModelsService, languageModelChatProviderExtensionPoint };

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(5437, "Other Models")), order: Number.MAX_SAFE_INTEGER };
+const DEFAULT_MODEL_PICKER_CATEGORY = { label: ( localize(5563, "Other Models")), order: Number.MAX_SAFE_INTEGER };
 
 export { DEFAULT_MODEL_PICKER_CATEGORY };

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

@@ -55,7 +55,7 @@ export interface ICustomChatMode {
      */
     readonly uri: URI;
     /**
-     * Name of the custom chat mode.
+     * Name of the custom chat mode as used in prompt files or contexts
      */
     readonly name: string;
     /**

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

@@ -0,0 +1,14 @@
+import { CancellationToken } from "../../../../../base/common/cancellation.js";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "../languageModelToolsService.js";
+export declare const ConfirmationToolId = "vscode_get_confirmation";
+export declare const ConfirmationToolData: IToolData;
+export interface IConfirmationToolParams {
+    title: string;
+    message: string;
+    confirmationType?: "basic" | "terminal";
+    terminalCommand?: string;
+}
+export declare class ConfirmationTool implements IToolImpl {
+    prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+}

package/vscode/src/vs/workbench/contrib/chat/common/tools/confirmationTool.js

@@ -0,0 +1,76 @@
+
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import { ToolDataSource, ToolInvocationPresentation } from '../languageModelToolsService.js';
+
+const ConfirmationToolId = 'vscode_get_confirmation';
+const ConfirmationToolData = {
+    id: ConfirmationToolId,
+    displayName: 'Confirmation Tool',
+    modelDescription: 'A tool that demonstrates different types of confirmations. Takes a title, message, and confirmation type (basic or terminal).',
+    source: ToolDataSource.Internal,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            title: {
+                type: 'string',
+                description: 'Title for the confirmation dialog'
+            },
+            message: {
+                type: 'string',
+                description: 'Message to show in the confirmation dialog'
+            },
+            confirmationType: {
+                type: 'string',
+                enum: ['basic', 'terminal'],
+                description: 'Type of confirmation to show - basic for simple confirmation, terminal for terminal command confirmation'
+            },
+            terminalCommand: {
+                type: 'string',
+                description: 'Terminal command to show (only used when confirmationType is "terminal")'
+            }
+        },
+        required: ['title', 'message', 'confirmationType'],
+        additionalProperties: false
+    }
+};
+class ConfirmationTool {
+    async prepareToolInvocation(context, token) {
+        const parameters = context.parameters;
+        if (!parameters.title || !parameters.message) {
+            throw ( new Error('Missing required parameters for ConfirmationTool'));
+        }
+        const confirmationType = parameters.confirmationType ?? 'basic';
+        let toolSpecificData;
+        if (confirmationType === 'terminal') {
+            toolSpecificData = {
+                kind: 'terminal',
+                commandLine: {
+                    original: parameters.terminalCommand ?? ''
+                },
+                language: 'bash'
+            };
+        }
+        else {
+            toolSpecificData = undefined;
+        }
+        return {
+            confirmationMessages: {
+                title: parameters.title,
+                message: ( new MarkdownString(parameters.message)),
+                allowAutoConfirm: false
+            },
+            toolSpecificData,
+            presentation: ToolInvocationPresentation.HiddenAfterComplete
+        };
+    }
+    async invoke(invocation, countTokens, progress, token) {
+        return {
+            content: [{
+                    kind: 'text',
+                    value: 'yes'
+                }]
+        };
+    }
+}
+
+export { ConfirmationTool, ConfirmationToolData, ConfirmationToolId };

package/vscode/src/vs/workbench/contrib/chat/common/tools/editFileTool.js

@@ -7,7 +7,7 @@ import { CellUri } from '../../../notebook/common/notebookCommon.js';
 import { INotebookService } from '../../../notebook/common/notebookService.service.js';
 import { ICodeMapperService } from '../chatCodeMapperService.service.js';
 import { IChatService } from '../chatService.service.js';
-import { ToolDataSource } from '../languageModelToolsService.js';
+import { ToolDataSource, ToolInvocationPresentation } from '../languageModelToolsService.js';
 import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
 
 const ExtensionEditToolId = 'vscode_editFile';
@@ -111,7 +111,7 @@ let EditTool = class EditTool {
     }
     async prepareToolInvocation(context, token) {
         return {
-            presentation: 'hidden'
+            presentation: ToolInvocationPresentation.Hidden
         };
     }
 };

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

@@ -2,17 +2,26 @@ 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 { ITelemetryService } from "../../../../../platform/telemetry/common/telemetry.service.js";
 import { IChatTodoListService } from "../chatTodoListService.service.js";
 export declare const TodoListToolSettingId = "chat.todoListTool.enabled";
+export declare const TodoListToolWriteOnlySettingId = "chat.todoListTool.writeOnly";
 export declare const ManageTodoListToolToolId = "manage_todo_list";
+export declare function createManageTodoListToolData(writeOnly: boolean): IToolData;
 export declare const ManageTodoListToolData: IToolData;
 export declare class ManageTodoListTool extends Disposable implements IToolImpl {
+    private readonly writeOnly;
     private readonly chatTodoListService;
     private readonly logService;
-    constructor(chatTodoListService: IChatTodoListService, logService: ILogService);
+    private readonly telemetryService;
+    constructor(writeOnly: boolean, chatTodoListService: IChatTodoListService, logService: ILogService, telemetryService: ITelemetryService);
     invoke(invocation: IToolInvocation, _countTokens: any, _progress: any, _token: CancellationToken): Promise<IToolResult>;
     prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
     private generatePastTenseMessage;
     private handleRead;
+    private handleReadOperation;
+    private handleWriteOperation;
+    private calculateStatusCounts;
     private formatTodoListAsMarkdownTaskList;
+    private calculateTodoChanges;
 }