@codingame/monaco-vscode-api 8.0.4 → 9.0.0

package/vscode/src/vs/workbench/api/common/extHostChatAgents2.js

@@ -3,15 +3,15 @@ import { raceCancellation } from '../../../base/common/async.js';
 import { toErrorMessage } from '../../../base/common/errorMessage.js';
 import { Emitter } from '../../../base/common/event.js';
 import { Iterable } from '../../../base/common/iterator.js';
-import { Disposable, DisposableMap, DisposableStore } from '../../../base/common/lifecycle.js';
+import { Disposable, DisposableMap, toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
 import { revive } from '../../../base/common/marshalling.js';
 import { StopWatch } from '../../../base/common/stopwatch.js';
 import { assertType } from '../../../base/common/types.js';
 import { URI } from '../../../base/common/uri.js';
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 import { MainContext } from './extHost.protocol.js';
-import { Selection, Range, ChatAgentRequest, ChatAgentResult, ChatFollowup, ChatAgentUserActionEvent, ChatAgentCompletionItem, ChatLocation, ChatAgentValueReference, ChatResponsePart, MarkdownString, ChatResponseMarkdownPart as ChatResponseMarkdownPart$1, ChatResponseMarkdownWithVulnerabilitiesPart as ChatResponseMarkdownWithVulnerabilitiesPart$1, ChatResponseFilesPart, ChatResponseAnchorPart, ChatResponseCommandButtonPart, ChatTask, ChatResponseProgressPart, ChatResponseWarningPart as ChatResponseWarningPart$1, ChatResponseReferencePart, ChatResponseCodeCitationPart, ChatResponseTextEditPart, ChatResponseDetectedParticipantPart, ChatResponseConfirmationPart, ChatTaskResult } from './extHostTypeConverters.js';
-import { ChatRequestEditorData, ChatRequestNotebookData, LanguageModelError, ChatRequestTurn, ChatResponseTurn, ChatResultFeedbackKind, ChatResponseMarkdownPart, ChatResponseMarkdownWithVulnerabilitiesPart, ChatResponseWarningPart, ChatResponseTextEditPart as ChatResponseTextEditPart$1, ChatResponseDetectedParticipantPart as ChatResponseDetectedParticipantPart$1, ChatResponseConfirmationPart as ChatResponseConfirmationPart$1, ChatResponseCodeCitationPart as ChatResponseCodeCitationPart$1, ChatResponseReferencePart as ChatResponseReferencePart$1, ThemeIcon, ChatResponseFileTreePart, ChatResponseAnchorPart as ChatResponseAnchorPart$1, ChatResponseCommandButtonPart as ChatResponseCommandButtonPart$1, ChatResponseProgressPart2, MarkdownString as MarkdownString$1 } from './extHostTypes.js';
+import { ChatAgentRequest, ChatLocation, Selection, Range, ChatAgentResult, ChatFollowup, ChatAgentUserActionEvent, ChatAgentCompletionItem, ChatResponseMarkdownPart as ChatResponseMarkdownPart$1, ChatResponseMarkdownWithVulnerabilitiesPart as ChatResponseMarkdownWithVulnerabilitiesPart$1, ChatResponseFilesPart, ChatResponseAnchorPart, ChatResponseCommandButtonPart, ChatTask, ChatResponseProgressPart, ChatResponseWarningPart as ChatResponseWarningPart$1, ChatResponseReferencePart, ChatResponseCodeCitationPart, ChatResponseTextEditPart, ChatResponseDetectedParticipantPart, ChatResponseConfirmationPart, ChatResponsePart, ChatLanguageModelToolReference, MarkdownString, ChatTaskResult, ChatPromptReference } from './extHostTypeConverters.js';
+import { ChatRequestEditorData, LanguageModelError, ChatResponseTurn, ChatResponseMarkdownPart, ChatResponseMarkdownWithVulnerabilitiesPart, ChatResponseWarningPart, ChatResponseTextEditPart as ChatResponseTextEditPart$1, ChatResponseDetectedParticipantPart as ChatResponseDetectedParticipantPart$1, ChatResponseConfirmationPart as ChatResponseConfirmationPart$1, ChatResponseCodeCitationPart as ChatResponseCodeCitationPart$1, ChatResponseMovePart, ChatResponseReferencePart as ChatResponseReferencePart$1, ChatRequestNotebookData, ChatRequestTurn, ChatResultFeedbackKind, ChatResponseFileTreePart, ChatResponseAnchorPart as ChatResponseAnchorPart$1, ChatResponseCommandButtonPart as ChatResponseCommandButtonPart$1, ChatResponseProgressPart2, ThemeIcon, MarkdownString as MarkdownString$1 } from './extHostTypes.js';
 import { ChatAgentLocation } from '../../contrib/chat/common/chatAgents.js';
 import { ChatAgentVoteDirection } from '../../contrib/chat/common/chatService.js';
 import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
@@ -46,7 +46,7 @@ class ChatAgentResponseStream {
                 }
             }
             const _report = (progress, task) => {
-                if (typeof this._firstProgress === 'undefined' && 'content' in progress) {
+                if (typeof this._firstProgress === 'undefined' && (progress.kind === 'markdownContent' || progress.kind === 'markdownVuln')) {
                     this._firstProgress = this._stopWatch.elapsed();
                 }
                 if (task) {
@@ -66,7 +66,7 @@ class ChatAgentResponseStream {
                         }
                     };
                     Promise.all([progressReporterPromise, task?.(progressReporter)]).then(([handle, res]) => {
-                        if (handle !== undefined && res !== undefined) {
+                        if (handle !== undefined) {
                             this._proxy.$handleProgressChunk(this._request.requestId, ChatTaskResult.from(res), handle);
                         }
                     });
@@ -134,10 +134,10 @@ class ChatAgentResponseStream {
                 },
                 reference2(value, iconPath, options) {
                     throwIfDone(this.reference);
-                    if ('variableName' in value) {
+                    if (typeof value === 'object' && 'variableName' in value) {
                         checkProposedApiEnabled(that._extension, 'chatParticipantAdditions');
                     }
-                    if ('variableName' in value && !value.value) {
+                    if (typeof value === 'object' && 'variableName' in value && !value.value) {
                         const matchingVarData = that._request.variables.variables.find(v => v.name === value.variableName);
                         if (matchingVarData) {
                             let references;
@@ -201,7 +201,8 @@ class ChatAgentResponseStream {
                         part instanceof ChatResponseDetectedParticipantPart$1 ||
                         part instanceof ChatResponseWarningPart ||
                         part instanceof ChatResponseConfirmationPart$1 ||
-                        part instanceof ChatResponseCodeCitationPart$1) {
+                        part instanceof ChatResponseCodeCitationPart$1 ||
+                        part instanceof ChatResponseMovePart) {
                         checkProposedApiEnabled(that._extension, 'chatParticipantAdditions');
                     }
                     if (part instanceof ChatResponseReferencePart$1) {
@@ -220,12 +221,14 @@ class ChatAgentResponseStream {
 }
 class ExtHostChatAgents2 extends Disposable {
     static { this._idPool = 0; }
+    static { this._participantDetectionProviderIdPool = 0; }
     constructor(mainContext, _logService, _commands, _documents) {
         super();
         this._logService = _logService;
         this._commands = _commands;
         this._documents = _documents;
         this._agents = ( new Map());
+        this._participantDetectionProviders = ( new Map());
         this._sessionDisposables = this._register(( new DisposableMap()));
         this._completionDisposables = this._register(( new DisposableMap()));
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadChatAgents2));
@@ -247,6 +250,38 @@ class ExtHostChatAgents2 extends Disposable {
         this._proxy.$registerAgent(handle, extension.identifier, id, { isSticky: true }, dynamicProps);
         return agent.apiAgent;
     }
+    registerChatParticipantDetectionProvider(provider) {
+        const handle = ExtHostChatAgents2._participantDetectionProviderIdPool++;
+        this._participantDetectionProviders.set(handle, provider);
+        this._proxy.$registerChatParticipantDetectionProvider(handle);
+        return toDisposable(() => {
+            this._participantDetectionProviders.delete(handle);
+            this._proxy.$unregisterChatParticipantDetectionProvider(handle);
+        });
+    }
+    async $detectChatParticipant(handle, requestDto, context, options, token) {
+        const { request, location, history } = await this._createRequest(requestDto, context);
+        const provider = this._participantDetectionProviders.get(handle);
+        if (!provider) {
+            return undefined;
+        }
+        return provider.provideParticipantDetection(ChatAgentRequest.to(request, location), { history }, { participants: options.participants, location: ChatLocation.to(options.location) }, token);
+    }
+    async _createRequest(requestDto, context) {
+        const request = revive(requestDto);
+        const convertedHistory = await this.prepareHistoryTurns(request.agentId, context);
+        let location;
+        if (request.locationData?.type === ChatAgentLocation.Editor) {
+            const document = this._documents.getDocument(request.locationData.document);
+            location = new ChatRequestEditorData(document, Selection.to(request.locationData.selection), Range.to(request.locationData.wholeRange));
+        }
+        else if (request.locationData?.type === ChatAgentLocation.Notebook) {
+            const cell = this._documents.getDocument(request.locationData.sessionInputUri);
+            location = new ChatRequestNotebookData(cell);
+        }
+        else ;
+        return { request, location, history: convertedHistory };
+    }
     async $invokeAgent(handle, requestDto, context, token) {
         const agent = this._agents.get(handle);
         if (!agent) {
@@ -254,33 +289,22 @@ class ExtHostChatAgents2 extends Disposable {
                 `[CHAT](${handle}) CANNOT invoke agent because the agent is not registered`
             ));
         }
-        const request = revive(requestDto);
-        let sessionDisposables = this._sessionDisposables.get(request.sessionId);
-        if (!sessionDisposables) {
-            sessionDisposables = ( new DisposableStore());
-            this._sessionDisposables.set(request.sessionId, sessionDisposables);
-        }
-        const stream = ( new ChatAgentResponseStream(
-            agent.extension,
-            request,
-            this._proxy,
-            this._commands.converter,
-            sessionDisposables
-        ));
+        let stream;
         try {
-            const convertedHistory = await this.prepareHistoryTurns(request.agentId, context);
-            let location2;
-            if (request.locationData?.type === ChatAgentLocation.Editor) {
-                const document = this._documents.getDocument(request.locationData.document);
-                location2 = new ChatRequestEditorData(document, Selection.to(request.locationData.selection), Range.to(request.locationData.wholeRange));
-            }
-            else if (request.locationData?.type === ChatAgentLocation.Notebook) {
-                const cell = this._documents.getDocument(request.locationData.sessionInputUri);
-                location2 = new ChatRequestNotebookData(cell);
-            }
-            else if (request.locationData?.type === ChatAgentLocation.Terminal) {
+            const { request, location, history } = await this._createRequest(requestDto, context);
+            let sessionDisposables = this._sessionDisposables.get(request.sessionId);
+            if (!sessionDisposables) {
+                sessionDisposables = ( new DisposableStore());
+                this._sessionDisposables.set(request.sessionId, sessionDisposables);
             }
-            const task = agent.invoke(ChatAgentRequest.to(request, location2), { history: convertedHistory }, stream.apiObject, token);
+            stream = ( new ChatAgentResponseStream(
+                agent.extension,
+                request,
+                this._proxy,
+                this._commands.converter,
+                sessionDisposables
+            ));
+            const task = agent.invoke(ChatAgentRequest.to(request, location), { history }, stream.apiObject, token);
             return await raceCancellation(Promise.resolve(task).then((result) => {
                 if (result?.metadata) {
                     try {
@@ -289,7 +313,7 @@ class ExtHostChatAgents2 extends Disposable {
                     catch (err) {
                         const msg = `result.metadata MUST be JSON.stringify-able. Got error: ${err.message}`;
                         this._logService.error(`[${agent.extension.identifier.value}] [@${agent.id}] ${msg}`, agent.extension);
-                        return { errorDetails: { message: msg }, timings: stream.timings };
+                        return { errorDetails: { message: msg }, timings: stream?.timings, nextQuestion: result.nextQuestion };
                     }
                 }
                 let errorDetails;
@@ -302,7 +326,7 @@ class ExtHostChatAgents2 extends Disposable {
                 if (errorDetails?.responseIsRedacted) {
                     checkProposedApiEnabled(agent.extension, 'chatParticipantPrivate');
                 }
-                return { errorDetails, timings: stream.timings, metadata: result?.metadata };
+                return { errorDetails, timings: stream?.timings, metadata: result?.metadata, nextQuestion: result?.nextQuestion };
             }), token);
         }
         catch (e) {
@@ -313,7 +337,7 @@ class ExtHostChatAgents2 extends Disposable {
             return { errorDetails: { message: toErrorMessage(e), responseIsIncomplete: true } };
         }
         finally {
-            stream.close();
+            stream?.close();
         }
     }
     async prepareHistoryTurns(agentId, context) {
@@ -325,8 +349,13 @@ class ExtHostChatAgents2 extends Disposable {
                 { ...ehResult, metadata: undefined };
             const varsWithoutTools = ( h.request.variables.variables
                 .filter(v => !v.isTool)
-                .map(ChatAgentValueReference.to));
-            res.push(new ChatRequestTurn(h.request.message, h.request.command, varsWithoutTools, h.request.agentId));
+                .map(ChatPromptReference.to));
+            const toolReferences = ( h.request.variables.variables
+                .filter(v => v.isTool)
+                .map(ChatLanguageModelToolReference.to));
+            const turn = new ChatRequestTurn(h.request.message, h.request.command, varsWithoutTools, h.request.agentId);
+            turn.toolReferences = toolReferences;
+            res.push(turn);
             const parts = coalesce(( h.response.map(r => ChatResponsePart.toContent(r, this._commands.converter))));
             res.push(new ChatResponseTurn(parts, result, h.request.agentId, h.request.command));
         }
@@ -353,14 +382,14 @@ class ExtHostChatAgents2 extends Disposable {
         })
             .map(f => ChatFollowup.from(f, request)));
     }
-    $acceptFeedback(handle, result, vote, reportIssue) {
+    $acceptFeedback(handle, result, voteAction) {
         const agent = this._agents.get(handle);
         if (!agent) {
             return;
         }
         const ehResult = ChatAgentResult.to(result);
         let kind;
-        switch (vote) {
+        switch (voteAction.direction) {
             case ChatAgentVoteDirection.Down:
                 kind = ChatResultFeedbackKind.Unhelpful;
                 break;
@@ -368,9 +397,12 @@ class ExtHostChatAgents2 extends Disposable {
                 kind = ChatResultFeedbackKind.Helpful;
                 break;
         }
-        agent.acceptFeedback(reportIssue ?
-            ( Object.freeze({ result: ehResult, kind, reportIssue })) :
-            ( Object.freeze({ result: ehResult, kind })));
+        const feedback = {
+            result: ehResult,
+            kind,
+            unhelpfulReason: isProposedApiEnabled(agent.extension, 'chatParticipantAdditions') ? voteAction.reason : undefined,
+        };
+        agent.acceptFeedback(( Object.freeze(feedback)));
     }
     $acceptAction(handle, result, event) {
         const agent = this._agents.get(handle);
@@ -410,6 +442,14 @@ class ExtHostChatAgents2 extends Disposable {
         }
         return await agent.provideWelcomeMessage(ChatLocation.to(location), token);
     }
+    async $provideChatTitle(handle, context, token) {
+        const agent = this._agents.get(handle);
+        if (!agent) {
+            return;
+        }
+        const history = await this.prepareHistoryTurns(agent.id, { history: context });
+        return await agent.provideTitle({ history }, token);
+    }
     async $provideSampleQuestions(handle, location, token) {
         const agent = this._agents.get(handle);
         if (!agent) {
@@ -470,6 +510,12 @@ class ExtHostChatAgent {
             }
         }));
     }
+    async provideTitle(context, token) {
+        if (!this._titleProvider) {
+            return;
+        }
+        return (await this._titleProvider.provideChatTitle(context, token)) ?? undefined;
+    }
     async provideSampleQuestions(location, token) {
         if (!this._welcomeMessageProvider || !this._welcomeMessageProvider.provideSampleQuestions) {
             return [];
@@ -539,15 +585,6 @@ class ExtHostChatAgent {
                 that._followupProvider = v;
                 updateMetadataSoon();
             },
-            get isDefault() {
-                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
-                return that._isDefault;
-            },
-            set isDefault(v) {
-                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
-                that._isDefault = v;
-                updateMetadataSoon();
-            },
             get helpTextPrefix() {
                 checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 return that._helpTextPrefix;
@@ -622,6 +659,15 @@ class ExtHostChatAgent {
                 checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 return that._welcomeMessageProvider;
             },
+            set titleProvider(v) {
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
+                that._titleProvider = v;
+                updateMetadataSoon();
+            },
+            get titleProvider() {
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
+                return that._titleProvider;
+            },
             onDidPerformAction: !isProposedApiEnabled(this.extension, 'chatParticipantAdditions')
                 ? undefined
                 : this._onDidPerformAction.event,

package/vscode/src/vs/workbench/api/common/extHostComments.js

@@ -460,7 +460,7 @@ function createExtHostComments(mainContext, commands, documents) {
         }
         get activeCommentThread() {
             checkProposedApiEnabled(this._extension, 'activeComment');
-            return this._activeThread;
+            return this._activeThread?.value;
         }
         constructor(_extension, _handle, _id, _label) {
             this._extension = _extension;

package/vscode/src/vs/workbench/api/common/extHostDiagnostics.js

@@ -105,7 +105,7 @@ class DiagnosticCollection {
                     marker.push({
                         severity: MarkerSeverity.Info,
                         message: ( localize(
-                            4582,
+                            4884,
                             "Not showing {0} further errors and warnings.",
                             diagnostics.length - this._maxDiagnosticsPerFile
                         )),

package/vscode/src/vs/workbench/api/common/extHostExtensionService.js

@@ -316,7 +316,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         });
     }
     _loadExtensionContext(extensionDescription, extensionInternalStore) {
-        const lanuageModelAccessInformation = this._extHostLanguageModels.createLanguageModelAccessInformation(extensionDescription);
+        const languageModelAccessInformation = this._extHostLanguageModels.createLanguageModelAccessInformation(extensionDescription);
         const globalState = extensionInternalStore.add(( new ExtensionGlobalMemento(extensionDescription, this._storage)));
         const workspaceState = extensionInternalStore.add(( new ExtensionMemento(extensionDescription.identifier.value, false, this._storage)));
         const secrets = extensionInternalStore.add(( new ExtensionSecrets(extensionDescription, this._secretState)));
@@ -341,7 +341,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
                 workspaceState,
                 secrets,
                 subscriptions: [],
-                get languageModelAccessInformation() { return lanuageModelAccessInformation; },
+                get languageModelAccessInformation() { return languageModelAccessInformation; },
                 get extensionUri() { return extensionDescription.extensionLocation; },
                 get extensionPath() { return extensionDescription.extensionLocation.fsPath; },
                 asAbsolutePath(relativePath) { return join(extensionDescription.extensionLocation.fsPath, relativePath); },
@@ -536,12 +536,12 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
     async _doHandleExtensionTests() {
         const { extensionDevelopmentLocationURI, extensionTestsLocationURI } = this._initData.environment;
         if (!extensionDevelopmentLocationURI || !extensionTestsLocationURI) {
-            throw ( new Error(localize(442, "Cannot load test runner.")));
+            throw ( new Error(localize(447, "Cannot load test runner.")));
         }
         const testRunner = await this._loadCommonJSModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false)));
         if (!testRunner || typeof testRunner.run !== 'function') {
             throw ( new Error(localize(
-                443,
+                448,
                 "Path {0} does not point to a valid extension test runner.",
                 ( extensionTestsLocationURI.toString())
             )));

package/vscode/src/vs/workbench/api/common/extHostLanguageFeatures.js

@@ -519,7 +519,7 @@ class DocumentPasteEditProvider {
              (edits.map((edit, i) => ({
                 _cacheId: [cacheId, i],
                 title: edit.title ?? ( localize(
-                    4583,
+                    4885,
                     "Paste using '{0}' extension",
                     this._extension.displayName || this._extension.name
                 )),
@@ -1776,7 +1776,7 @@ class DocumentDropEditAdapter {
              (editsArray.map((edit, i) => ({
                 _cacheId: [cacheId, i],
                 title: edit.title ?? ( localize(
-                    4584,
+                    4886,
                     "Drop using '{0}' extension",
                     this._extension.displayName || this._extension.name
                 )),
@@ -1923,13 +1923,13 @@ class ExtHostLanguageFeatures {
         return result;
     }
     $provideCodeLenses(handle, resource, token) {
-        return this._withAdapter(handle, CodeLensAdapter, adapter => adapter.provideCodeLenses(URI.revive(resource), token), undefined, token);
+        return this._withAdapter(handle, CodeLensAdapter, adapter => adapter.provideCodeLenses(URI.revive(resource), token), undefined, token, resource.scheme === 'output');
     }
     $resolveCodeLens(handle, symbol, token) {
-        return this._withAdapter(handle, CodeLensAdapter, adapter => adapter.resolveCodeLens(symbol, token), undefined, undefined);
+        return this._withAdapter(handle, CodeLensAdapter, adapter => adapter.resolveCodeLens(symbol, token), undefined, undefined, true);
     }
     $releaseCodeLenses(handle, cacheId) {
-        this._withAdapter(handle, CodeLensAdapter, adapter => Promise.resolve(adapter.releaseCodeLenses(cacheId)), undefined, undefined);
+        this._withAdapter(handle, CodeLensAdapter, adapter => Promise.resolve(adapter.releaseCodeLenses(cacheId)), undefined, undefined, true);
     }
     registerDefinitionProvider(extension, selector, provider) {
         const handle = this._addNewAdapter(( (new DefinitionAdapter(this._documents, provider))), extension);

package/vscode/src/vs/workbench/api/common/extHostLanguageModelTools.js

@@ -1,39 +1,81 @@
+import { raceCancellation } from '../../../base/common/async.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { CancellationError } from '../../../base/common/errors.js';
 import { toDisposable } from '../../../base/common/lifecycle.js';
 import { revive } from '../../../base/common/marshalling.js';
+import { generateUuid } from '../../../base/common/uuid.js';
 import { MainContext } from './extHost.protocol.js';
-import { LanguageModelToolDescription } from './extHostTypeConverters.js';
+import { LanguageModelToolResult, LanguageModelToolDescription } from './extHostTypeConverters.js';
 class ExtHostLanguageModelTools {
     constructor(mainContext) {
         this._registeredTools = ( new Map());
+        this._tokenCountFuncs = ( new Map());
         this._allTools = ( new Map());
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadLanguageModelTools));
         this._proxy.$getTools().then(tools => {
             for (const tool of tools) {
-                this._allTools.set(tool.name, revive(tool));
+                this._allTools.set(tool.id, revive(tool));
             }
         });
     }
-    async invokeTool(name, parameters, token) {
-        return await this._proxy.$invokeTool(name, parameters, token);
+    async $countTokensForInvocation(callId, input, token) {
+        const fn = this._tokenCountFuncs.get(callId);
+        if (!fn) {
+            throw ( new Error(`Tool invocation call ${callId} not found`));
+        }
+        return await fn(input, token);
     }
-    async $acceptToolDelta(delta) {
-        if (delta.added) {
-            this._allTools.set(delta.added.name, delta.added);
+    async invokeTool(toolId, options, token) {
+        const callId = generateUuid();
+        if (options.tokenOptions) {
+            this._tokenCountFuncs.set(callId, options.tokenOptions.countTokens);
+        }
+        try {
+            const result = await this._proxy.$invokeTool({
+                toolId,
+                callId,
+                parameters: options.parameters,
+                tokenBudget: options.tokenOptions?.tokenBudget,
+            }, token);
+            return LanguageModelToolResult.to(result);
         }
-        if (delta.removed) {
-            this._allTools.delete(delta.removed);
+        finally {
+            this._tokenCountFuncs.delete(callId);
+        }
+    }
+    $onDidChangeTools(tools) {
+        this._allTools.clear();
+        for (const tool of tools) {
+            this._allTools.set(tool.id, tool);
         }
     }
     get tools() {
         return ( Array.from(( this._allTools.values()))
             .map(tool => LanguageModelToolDescription.to(tool)));
     }
-    async $invokeTool(name, parameters, token) {
-        const item = this._registeredTools.get(name);
+    async $invokeTool(dto, token) {
+        const item = this._registeredTools.get(dto.toolId);
         if (!item) {
-            throw ( new Error(`Unknown tool ${name}`));
+            throw ( new Error(`Unknown tool ${dto.toolId}`));
+        }
+        const options = { parameters: dto.parameters };
+        if (dto.tokenBudget !== undefined) {
+            options.tokenOptions = {
+                tokenBudget: dto.tokenBudget,
+                countTokens: this._tokenCountFuncs.get(dto.callId) || ((value, token = CancellationToken.None) => this._proxy.$countTokensForInvocation(dto.callId, value, token))
+            };
+        }
+        const extensionResult = await raceCancellation(Promise.resolve(item.tool.invoke(options, token)), token);
+        if (!extensionResult) {
+            throw ( new CancellationError());
+        }
+        for (const key of ( Object.keys(extensionResult))) {
+            const value = extensionResult[key];
+            if (value instanceof Promise) {
+                throw ( new Error(`Tool result for '${key}' cannot be a Promise`));
+            }
         }
-        return await item.tool.invoke(parameters, token);
+        return LanguageModelToolResult.from(extensionResult);
     }
     registerTool(extension, name, tool) {
         this._registeredTools.set(name, { extension, tool });

package/vscode/src/vs/workbench/api/common/extHostLanguageModels.js

@@ -15,7 +15,7 @@ import { MainContext } from './extHost.protocol.js';
 import { IExtHostAuthentication } from './extHostAuthentication.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { LanguageModelChatMessage } from './extHostTypeConverters.js';
-import { LanguageModelError, LanguageModelChatMessageRole, LanguageModelFunctionResultPart, LanguageModelTextPart, LanguageModelFunctionUsePart } from './extHostTypes.js';
+import { LanguageModelError, LanguageModelChatMessageRole, LanguageModelToolResultPart, LanguageModelTextPart, LanguageModelToolCallPart } from './extHostTypes.js';
 import { INTERNAL_AUTH_PROVIDER_PREFIX } from '../../services/authentication/common/authentication.js';
 import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 var ExtHostLanguageModels_1;
@@ -78,7 +78,7 @@ class LanguageModelResponse {
             out = new LanguageModelTextPart(fragment.part.value);
         }
         else {
-            out = new LanguageModelFunctionUsePart(fragment.part.name, fragment.part.parameters);
+            out = new LanguageModelToolCallPart(fragment.part.name, fragment.part.toolCallId, fragment.part.parameters);
         }
         res.stream.emitOne(out);
     }
@@ -157,8 +157,8 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
                 return;
             }
             let part;
-            if (fragment.part instanceof LanguageModelFunctionUsePart) {
-                part = { type: 'function_use', name: fragment.part.name, parameters: fragment.part.parameters };
+            if (fragment.part instanceof LanguageModelToolCallPart) {
+                part = { type: 'tool_use', name: fragment.part.name, parameters: fragment.part.parameters, toolCallId: fragment.part.toolCallId };
             }
             else if (fragment.part instanceof LanguageModelTextPart) {
                 part = { type: 'text', value: fragment.part.value };
@@ -291,7 +291,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
             if (message.role === LanguageModelChatMessageRole.System) {
                 checkProposedApiEnabled(extension, 'languageModelSystem');
             }
-            if (message.content2 instanceof LanguageModelFunctionResultPart) {
+            if (( (message.content2.some(part => part instanceof LanguageModelToolResultPart)))) {
                 checkProposedApiEnabled(extension, 'lmTools');
             }
             internalMessages.push(LanguageModelChatMessage.from(message));
@@ -329,7 +329,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
         }
         try {
             const detail = justification
-                ? ( localize(577, "Justification: {1}", to.displayName, justification))
+                ? ( localize(955, "Justification: {1}", to.displayName, justification))
                 : undefined;
             await this._extHostAuthentication.getSession(from, providerId, [], { forceNewSession: { detail } });
             this.$updateModelAccesslist([{ from: from.identifier, to: to.identifier, enabled: true }]);

package/vscode/src/vs/workbench/api/common/extHostLogService.js

@@ -6,7 +6,7 @@ import { IExtHostInitDataService } from './extHostInitDataService.js';
 let ExtHostLogService = class ExtHostLogService extends LogService {
     constructor(isWorker, loggerService, initData) {
         const id = initData.remote.isRemote ? 'remoteexthost' : isWorker ? 'workerexthost' : 'exthost';
-        const name = initData.remote.isRemote ? ( localize(578, "Extension Host (Remote)")) : isWorker ? ( localize(579, "Extension Host (Worker)")) : ( localize(580, "Extension Host"));
+        const name = initData.remote.isRemote ? ( localize(956, "Extension Host (Remote)")) : isWorker ? ( localize(957, "Extension Host (Worker)")) : ( localize(958, "Extension Host"));
         super(loggerService.createLogger(id, { name }));
     }
 };

package/vscode/src/vs/workbench/api/common/extHostNotebook.js

@@ -153,34 +153,34 @@ class ExtHostNotebookController {
         const document = this._documents.get(URI.revive(canonicalUri));
         return assertIsDefined(document?.apiNotebook);
     }
-    async showNotebookDocument(notebookOrUri, options) {
-        if (URI.isUri(notebookOrUri)) {
-            notebookOrUri = await this.openNotebookDocument(notebookOrUri);
-        }
+    async showNotebookDocument(notebook, options) {
         let resolvedOptions;
         if (typeof options === 'object') {
             resolvedOptions = {
                 position: ViewColumn.from(options.viewColumn),
                 preserveFocus: options.preserveFocus,
                 selections: options.selections && ( options.selections.map(NotebookRange.from)),
-                pinned: typeof options.preview === 'boolean' ? !options.preview : undefined
+                pinned: typeof options.preview === 'boolean' ? !options.preview : undefined,
+                label: options?.label
             };
         }
         else {
             resolvedOptions = {
-                preserveFocus: false
+                preserveFocus: false,
+                pinned: true
             };
         }
-        const editorId = await this._notebookEditorsProxy.$tryShowNotebookDocument(notebookOrUri.uri, notebookOrUri.notebookType, resolvedOptions);
+        const viewType = options?.asRepl ? 'repl' : notebook.notebookType;
+        const editorId = await this._notebookEditorsProxy.$tryShowNotebookDocument(notebook.uri, viewType, resolvedOptions);
         const editor = editorId && this._editors.get(editorId)?.apiEditor;
         if (editor) {
             return editor;
         }
         if (editorId) {
-            throw ( new Error(`Could NOT open editor for "${( notebookOrUri.uri.toString())}" because another editor opened in the meantime.`));
+            throw ( new Error(`Could NOT open editor for "${( notebook.uri.toString())}" because another editor opened in the meantime.`));
         }
         else {
-            throw ( new Error(`Could NOT open editor for "${( notebookOrUri.uri.toString())}".`));
+            throw ( new Error(`Could NOT open editor for "${( notebook.uri.toString())}".`));
         }
     }
     async $provideNotebookCellStatusBarItems(handle, uri, index, token) {
@@ -254,7 +254,7 @@ class ExtHostNotebookController {
             throw ( new Error('Document version mismatch'));
         }
         if (!this._extHostFileSystem.value.isWritableFileSystem(uri.scheme)) {
-            throw new FileOperationError(localize(4585, "Unable to modify read-only file '{0}'", this._resourceForError(uri)), FileOperationResult.FILE_PERMISSION_DENIED);
+            throw new FileOperationError(localize(4887, "Unable to modify read-only file '{0}'", this._resourceForError(uri)), FileOperationResult.FILE_PERMISSION_DENIED);
         }
         const data = {
             metadata: filter(document.apiNotebook.metadata, key => !(serializer.options?.transientDocumentMetadata ?? {})[key]),
@@ -426,7 +426,7 @@ class ExtHostNotebookController {
         if (typeof options?.mtime === 'number' && typeof options.etag === 'string' && options.etag !== ETAG_DISABLED &&
             typeof stat.mtime === 'number' && typeof stat.size === 'number' &&
             options.mtime < stat.mtime && options.etag !== etag({ mtime: options.mtime , size: stat.size })) {
-            throw new FileOperationError(localize(4586, "File Modified Since"), FileOperationResult.FILE_MODIFIED_SINCE, options);
+            throw new FileOperationError(localize(4888, "File Modified Since"), FileOperationResult.FILE_MODIFIED_SINCE, options);
         }
         return;
     }