@codingame/monaco-vscode-chat-service-override 10.1.4 → 11.0.0

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

@@ -23,9 +23,9 @@ import { IWorkbenchAssignmentService } from 'vscode/vscode/vs/workbench/services
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
 import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
-import { normalizeSerializableChatData, ChatModel, updateRanges, toChatHistoryContent, ChatRequestModel } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
-import { ChatRequestAgentPart, ChatRequestAgentSubcommandPart, chatSubcommandLeader, chatAgentLeader, ChatRequestSlashCommandPart, getPromptText } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
-import { ChatRequestParser } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
+import { normalizeSerializableChatData, ChatModel, updateRanges, toChatHistoryContent, ChatRequestModel } from '@codingame/monaco-vscode-chat-extensions-interactive-notebook-quickaccess-search-terminal-common/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { ChatRequestAgentPart, ChatRequestAgentSubcommandPart, chatSubcommandLeader, chatAgentLeader, ChatRequestSlashCommandPart, getPromptText } from '@codingame/monaco-vscode-chat-extensions-interactive-notebook-quickaccess-search-terminal-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { ChatRequestParser } from '@codingame/monaco-vscode-chat-extensions-notebook-common/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
 import { ChatServiceTelemetry } from './chatServiceTelemetry.js';
 import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service';
 import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables.service';
@@ -233,7 +233,7 @@ let ChatService = class ChatService extends Disposable {
             .filter(session => session.requests.length > 0)
             .filter(session => !( (this._sessionModels.has(session.sessionId))));
         const persistedSessionItems = ( (persistedSessions
-            .filter(session => !session.isImported)
+            .filter(session => !session.isImported && session.initialLocation !== ChatAgentLocation.EditingSession)
             .map(session => {
             const title = session.customTitle ?? ChatModel.getDefaultTitle(session.requests);
             return {
@@ -244,9 +244,9 @@ let ChatService = class ChatService extends Disposable {
             };
         })));
         const liveSessionItems = ( (Array.from(( (this._sessionModels.values())))
-            .filter(session => !session.isImported)
+            .filter(session => !session.isImported && session.initialLocation !== ChatAgentLocation.EditingSession)
             .map(session => {
-            const title = session.title || ( localize(3154, "New Chat"));
+            const title = session.title || ( localize(2698, "New Chat"));
             return {
                 sessionId: session.sessionId,
                 title,
@@ -344,6 +344,7 @@ let ChatService = class ChatService extends Disposable {
             ...options,
             locationData: request.locationData,
             attachedContext: request.attachedContext,
+            workingSet: request.workingSet,
         };
         await this._sendRequestAsync(model, model.sessionId, request.message, attempt, enableCommandDetection, defaultAgent, location, resendOptions).responseCompletePromise;
     }
@@ -400,7 +401,7 @@ let ChatService = class ChatService extends Disposable {
         const agentPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart);
         const agentSlashCommandPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestAgentSubcommandPart);
         const commandPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestSlashCommandPart);
-        const requests = [...model.getRequests()];
+        const requests = [...model.getRequests(false)];
         let gotProgress = false;
         const requestType = commandPart ? 'slashCommand' : 'string';
         const responseCreated = ( (new DeferredPromise()));
@@ -457,18 +458,32 @@ let ChatService = class ChatService extends Disposable {
                 if (agentPart || (defaultAgent && !commandPart)) {
                     const prepareChatAgentRequest = async (agent, command, enableCommandDetection, chatRequest, isParticipantDetected) => {
                         const initVariableData = { variables: [] };
-                        request = chatRequest ?? model.addRequest(parsedRequest, initVariableData, attempt, agent, command, options?.confirmation, options?.locationData, options?.attachedContext);
-                        const variableData = await this.chatVariablesService.resolveVariables(parsedRequest, request.attachedContext, model, progressCallback, token);
-                        model.updateRequest(request, variableData);
-                        const promptTextResult = getPromptText(request.message);
-                        const updatedVariableData = updateRanges(variableData, promptTextResult.diff);
+                        request = chatRequest ?? model.addRequest(parsedRequest, initVariableData, attempt, agent, command, options?.confirmation, options?.locationData, options?.attachedContext, options?.workingSet);
+                        let variableData;
+                        let message;
+                        if (chatRequest) {
+                            variableData = chatRequest.variableData;
+                            message = getPromptText(request.message).message;
+                        }
+                        else {
+                            variableData = await this.chatVariablesService.resolveVariables(parsedRequest, request.attachedContext, model, progressCallback, token);
+                            for (const variable of variableData.variables) {
+                                if (request.workingSet && variable.isFile && URI.isUri(variable.value)) {
+                                    request.workingSet.push(variable.value);
+                                }
+                            }
+                            model.updateRequest(request, variableData);
+                            const promptTextResult = getPromptText(request.message);
+                            variableData = updateRanges(variableData, promptTextResult.diff);
+                            message = promptTextResult.message;
+                        }
                         return {
                             sessionId,
                             requestId: request.id,
                             agentId: agent.id,
-                            message: promptTextResult.message,
+                            message,
                             command: command?.name,
-                            variables: updatedVariableData,
+                            variables: variableData,
                             enableCommandDetection,
                             isParticipantDetected,
                             attempt,
@@ -502,13 +517,13 @@ let ChatService = class ChatService extends Disposable {
                     const agentResult = await this.chatAgentService.invokeAgent(agent.id, requestProps, progressCallback, history, token);
                     rawResult = agentResult;
                     agentOrCommandFollowups = this.chatAgentService.getFollowups(agent.id, requestProps, agentResult, history, followupsCancelToken);
-                    chatTitlePromise = model.getRequests().length === 1 && !model.customTitle ? this.chatAgentService.getChatTitle(defaultAgent.id, this.getHistoryEntriesFromModel(model.getRequests(), model.sessionId, location, agent.id), CancellationToken.None) : undefined;
+                    chatTitlePromise = model.getRequests(false).length === 1 && !model.customTitle ? this.chatAgentService.getChatTitle(defaultAgent.id, this.getHistoryEntriesFromModel(model.getRequests(false), model.sessionId, location, agent.id), CancellationToken.None) : undefined;
                 }
                 else if (commandPart && this.chatSlashCommandService.hasCommand(commandPart.slashCommand.command)) {
                     request = model.addRequest(parsedRequest, { variables: [] }, attempt);
                     completeResponseCreated();
                     const history = [];
-                    for (const request of model.getRequests()) {
+                    for (const request of model.getRequests(false)) {
                         if (!request.response) {
                             continue;
                         }
@@ -531,7 +546,7 @@ let ChatService = class ChatService extends Disposable {
                 else {
                     if (!rawResult) {
                         this.trace('sendRequest', `Provider returned no response for session ${model.sessionId}`);
-                        rawResult = { errorDetails: { message: ( localize(3155, "Provider returned null response")) } };
+                        rawResult = { errorDetails: { message: ( localize(2699, "Provider returned null response")) } };
                     }
                     const result = rawResult.errorDetails?.responseIsFiltered ? 'filtered' :
                         rawResult.errorDetails && gotProgress ? 'errorWithOutput' :
@@ -675,7 +690,7 @@ let ChatService = class ChatService extends Disposable {
         const parsedRequest = typeof message === 'string' ?
             this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, message) :
             message;
-        const request = model.addRequest(parsedRequest, variableData || { variables: [] }, attempt ?? 0);
+        const request = model.addRequest(parsedRequest, variableData || { variables: [] }, attempt ?? 0, undefined, undefined, undefined, undefined, undefined, undefined, true);
         if (typeof response.message === 'string') {
             model.acceptResponseProgress(request, { content: ( (new MarkdownString(response.message))), kind: 'markdownContent' });
         }

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

@@ -3,7 +3,7 @@ import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
 import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
-import { CHAT_PROVIDER_ID } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
+import { CHAT_PROVIDER_ID } from '@codingame/monaco-vscode-chat-extensions-interactive-notebook-quickaccess-search-terminal-common/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
 
 let ChatWidgetHistoryService = class ChatWidgetHistoryService {
     constructor(storageService) {

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

@@ -0,0 +1,21 @@
+import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+
+class LanguageModelIgnoredFilesService {
+    constructor() {
+        this._providers = ( new Set());
+    }
+    async fileIsIgnored(uri, token) {
+        const provider = ( this._providers.values()).next().value;
+        return provider ?
+            provider.isFileIgnored(uri, token) :
+            false;
+    }
+    registerIgnoredFileProvider(provider) {
+        this._providers.add(provider);
+        return toDisposable(() => {
+            this._providers.delete(provider);
+        });
+    }
+}
+
+export { LanguageModelIgnoredFilesService };

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

@@ -120,8 +120,8 @@ LanguageModelStatsService = LanguageModelStatsService_1 = ( (__decorate([
 ], LanguageModelStatsService)));
 ( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'languageModels',
-    label: ( localize(3164, "Language Models")),
-    description: ( localize(3165, "Language models usage statistics of this extension.")),
+    label: ( localize(2712, "Language Models")),
+    description: ( localize(2713, "Language models usage statistics of this extension.")),
     access: {
         canToggle: false
     },

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

@@ -17,14 +17,14 @@ const languageModelType = {
     properties: {
         vendor: {
             type: 'string',
-            description: ( localize(3156, "A globally unique vendor of language models."))
+            description: ( localize(2700, "A globally unique vendor of language models."))
         }
     }
 };
 const languageModelExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'languageModels',
     jsonSchema: {
-        description: ( localize(3157, "Contribute language models of a specific vendor.")),
+        description: ( localize(2701, "Contribute language models of a specific vendor.")),
         oneOf: [
             languageModelType,
             {
@@ -54,24 +54,24 @@ let LanguageModelsService = class LanguageModelsService {
             this._vendors.clear();
             for (const extension of extensions) {
                 if (!isProposedApiEnabled(extension.description, 'chatProvider')) {
-                    extension.collector.error(( localize(3158, "This contribution point requires the 'chatProvider' proposal.")));
+                    extension.collector.error(( localize(2702, "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(
-                            3159,
+                            2703,
                             "The vendor '{0}' is already registered and cannot be registered twice",
                             item.vendor
                         )));
                         continue;
                     }
                     if (isFalsyOrWhitespace(item.vendor)) {
-                        extension.collector.error(( localize(3160, "The vendor field cannot be empty.")));
+                        extension.collector.error(( localize(2704, "The vendor field cannot be empty.")));
                         continue;
                     }
                     if (item.vendor.trim() !== item.vendor) {
-                        extension.collector.error(( localize(3161, "The vendor field cannot start or end with whitespace.")));
+                        extension.collector.error(( localize(2705, "The vendor field cannot start or end with whitespace.")));
                         continue;
                     }
                     this._vendors.add(item.vendor);

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

@@ -7,68 +7,95 @@ import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/cont
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { ILanguageModelToolsService } from 'vscode/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
 import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+import { toolsParametersSchemaSchemaId } from './languageModelToolsParametersSchema.js';
 
 const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'languageModelTools',
     activationEventsGenerator: (contributions, result) => {
         for (const contrib of contributions) {
-            result.push(`onLanguageModelTool:${contrib.id}`);
+            result.push(`onLanguageModelTool:${contrib.name}`);
         }
     },
     jsonSchema: {
-        description: ( localize(7251, 'Contributes a tool that can be invoked by a language model.')),
+        description: ( localize(
+            7480,
+            'Contributes a tool that can be invoked by a language model in a chat session, or from a standalone command. Registered tools can be used by all extensions.'
+        )),
         type: 'array',
         items: {
             additionalProperties: false,
             type: 'object',
-            defaultSnippets: [{ body: { name: '', description: '' } }],
-            required: ['id', 'modelDescription'],
+            defaultSnippets: [{
+                    body: {
+                        name: '${1}',
+                        modelDescription: '${2}',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                '${3:name}': {
+                                    type: 'string',
+                                    description: '${4:description}'
+                                }
+                            }
+                        },
+                    }
+                }],
+            required: ['name', 'displayName', 'modelDescription'],
             properties: {
-                id: {
-                    description: ( localize(7252, "A unique id for this tool.")),
+                name: {
+                    description: ( localize(
+                        7481,
+                        "A unique name for this tool. This name must be a globally unique identifier, and is also used as a name when presenting this tool to a language model."
+                    )),
                     type: 'string',
                     pattern: '^[\\w-]+$'
                 },
-                name: {
-                    description: ( localize(
-                        7253,
+                toolReferenceName: {
+                    markdownDescription: ( localize(
+                        7482,
                         "If {0} is enabled for this tool, the user may use '#' with this name to invoke the tool in a query. Otherwise, the name is not required. Name must not contain whitespace.",
-                        '`canBeInvokedManually`'
+                        '`canBeReferencedInPrompt`'
                     )),
                     type: 'string',
                     pattern: '^[\\w-]+$'
                 },
                 displayName: {
                     description: ( localize(
-                        7254,
+                        7483,
                         "A human-readable name for this tool that may be used to describe it in the UI."
                     )),
                     type: 'string'
                 },
                 userDescription: {
-                    description: ( localize(7255, "A description of this tool that may be shown to the user.")),
+                    description: ( localize(7484, "A description of this tool that may be shown to the user.")),
                     type: 'string'
                 },
                 modelDescription: {
-                    description: ( localize(7256, "A description of this tool that may be passed to a language model.")),
+                    description: ( localize(
+                        7485,
+                        "A description of this tool that may be used by a language model to select it."
+                    )),
                     type: 'string'
                 },
-                parametersSchema: {
-                    description: ( localize(7257, "A JSON schema for the parameters this tool accepts.")),
-                    type: 'object',
-                    $ref: 'http://json-schema.org/draft-07/schema#'
-                },
-                canBeInvokedManually: {
+                inputSchema: {
                     description: ( localize(
-                        7258,
-                        "Whether this tool can be invoked manually by the user through the chat UX."
+                        7486,
+                        "A JSON schema for the input this tool accepts. The input must be an object at the top level. A particular language model may not support all JSON schema features. See the documentation for the language model family you are using for more information."
+                    )),
+                    $ref: toolsParametersSchemaSchemaId,
+                },
+                canBeReferencedInPrompt: {
+                    markdownDescription: ( localize(
+                        7487,
+                        "If true, this tool shows up as an attachment that the user can add manually to their request. Chat participants will receive the tool in {0}.",
+                        '`ChatRequest#toolReferences`'
                     )),
                     type: 'boolean'
                 },
                 icon: {
-                    description: ( localize(
-                        7259,
-                        "An icon that represents this tool. Either a file path, an object with file paths for dark and light themes, or a theme icon reference, like `\\$(zap)`"
+                    markdownDescription: ( localize(
+                        7488,
+                        "An icon that represents this tool. Either a file path, an object with file paths for dark and light themes, or a theme icon reference, like `$(zap)`"
                     )),
                     anyOf: [{
                             type: 'string'
@@ -77,11 +104,11 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                             type: 'object',
                             properties: {
                                 light: {
-                                    description: ( localize(7260, 'Icon path when a light theme is used')),
+                                    description: ( localize(7489, 'Icon path when a light theme is used')),
                                     type: 'string'
                                 },
                                 dark: {
-                                    description: ( localize(7261, 'Icon path when a dark theme is used')),
+                                    description: ( localize(7490, 'Icon path when a dark theme is used')),
                                     type: 'string'
                                 }
                             }
@@ -89,27 +116,20 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 when: {
                     markdownDescription: ( localize(
-                        7262,
+                        7491,
                         "Condition which must be true for this tool to be enabled. Note that a tool may still be invoked by another extension even when its `when` condition is false."
                     )),
                     type: 'string'
                 },
-                supportedContentTypes: {
-                    markdownDescription: ( localize(
-                        7263,
-                        "The list of content types that this tool can return. It's required that tools support `text/plain`, and that is assumed even if not specified here. Another example could be the contentType exported by the `@vscode/prompt-tsx` library."
+                tags: {
+                    description: ( localize(
+                        7492,
+                        "A set of tags that roughly describe the tool's capabilities. A tool user may use these to filter the set of tools to just ones that are relevant for the task at hand, or they may want to pick a tag that can be used to identify just the tools contributed by this extension."
                     )),
                     type: 'array',
                     items: {
                         type: 'string'
                     }
-                },
-                requiresConfirmation: {
-                    description: ( localize(
-                        7264,
-                        "Whether this tool requires user confirmation before being executed."
-                    )),
-                    type: 'boolean'
                 }
             }
         }
@@ -125,16 +145,16 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
         languageModelToolsExtensionPoint.setHandler((extensions, delta) => {
             for (const extension of delta.added) {
                 for (const rawTool of extension.value) {
-                    if (!rawTool.id || !rawTool.modelDescription) {
-                        logService.error(`Extension '${extension.description.identifier.value}' CANNOT register tool without name and modelDescription: ${JSON.stringify(rawTool)}`);
+                    if (!rawTool.name || !rawTool.modelDescription || !rawTool.displayName) {
+                        logService.error(`Extension '${extension.description.identifier.value}' CANNOT register tool without name, modelDescription, and displayName: ${JSON.stringify(rawTool)}`);
                         continue;
                     }
-                    if (!rawTool.id.match(/^[\w-]+$/)) {
-                        logService.error(`Extension '${extension.description.identifier.value}' CANNOT register tool with invalid id: ${rawTool.id}. The id must match /^[\\w-]+$/.`);
+                    if (!rawTool.name.match(/^[\w-]+$/)) {
+                        logService.error(`Extension '${extension.description.identifier.value}' CANNOT register tool with invalid id: ${rawTool.name}. The id must match /^[\\w-]+$/.`);
                         continue;
                     }
-                    if (rawTool.canBeInvokedManually && !rawTool.name) {
-                        logService.error(`Extension '${extension.description.identifier.value}' CANNOT register tool with 'canBeInvokedManually' set without a name: ${JSON.stringify(rawTool)}`);
+                    if (rawTool.canBeReferencedInPrompt && !rawTool.toolReferenceName) {
+                        logService.error(`Extension '${extension.description.identifier.value}' CANNOT register tool with 'canBeReferencedInPrompt' set without a 'toolReferenceName': ${JSON.stringify(rawTool)}`);
                         continue;
                     }
                     const rawIcon = rawTool.icon;
@@ -153,17 +173,18 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                     }
                     const tool = {
                         ...rawTool,
+                        inputSchema: rawTool.inputSchema ?? rawTool.parametersSchema,
+                        id: rawTool.name,
                         icon,
                         when: rawTool.when ? ContextKeyExpr.deserialize(rawTool.when) : undefined,
-                        supportedContentTypes: rawTool.supportedContentTypes ? rawTool.supportedContentTypes : [],
                     };
                     const disposable = languageModelToolsService.registerToolData(tool);
-                    this._registrationDisposables.set(toToolKey(extension.description.identifier, rawTool.id), disposable);
+                    this._registrationDisposables.set(toToolKey(extension.description.identifier, rawTool.name), disposable);
                 }
             }
             for (const extension of delta.removed) {
                 for (const tool of extension.value) {
-                    this._registrationDisposables.deleteAndDispose(toToolKey(extension.description.identifier, tool.id));
+                    this._registrationDisposables.deleteAndDispose(toToolKey(extension.description.identifier, tool.name));
                 }
             }
         });