@codingame/monaco-vscode-chat-service-override 37.0.0 → 37.2.0

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

@@ -0,0 +1,90 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ToolDataSource, ToolInvocationPresentation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { IChatArtifactsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatArtifactsService.service';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+
+const SetArtifactRulesToolId = "setArtifactRules";
+const artifactGroupConfigSchema = {
+    type: "object",
+    properties: {
+        groupName: {
+            type: "string",
+            description: "Display name for the artifact group."
+        },
+        onlyShowGroup: {
+            type: "boolean",
+            description: "When true, show only the group header instead of individual items."
+        }
+    },
+    required: ["groupName"]
+};
+const inputSchema = {
+    type: "object",
+    properties: {
+        byMimeType: {
+            type: "object",
+            description: "Rules for extracting artifacts from tool results by MIME type. Maps MIME type patterns (e.g. 'image/*') to group configuration.",
+            additionalProperties: artifactGroupConfigSchema
+        },
+        byFilePath: {
+            type: "object",
+            description: "Rules for extracting artifacts from written files by file path glob pattern. Maps glob patterns (e.g. '**/*plan*.md') to group configuration.",
+            additionalProperties: artifactGroupConfigSchema
+        },
+        byMemoryFilePath: {
+            type: "object",
+            description: "Rules for extracting artifacts from memory tool writes by memory file path glob pattern. Maps glob patterns to group configuration.",
+            additionalProperties: artifactGroupConfigSchema
+        }
+    }
+};
+const SetArtifactRulesToolData = {
+    id: SetArtifactRulesToolId,
+    toolReferenceName: "artifactRules",
+    legacyToolReferenceFullNames: [],
+    displayName: ( localize(10896, "Set Artifact Rules")),
+    modelDescription: "Override the artifact extraction rules for this session. Rules control which tool results, files, and memory writes are automatically surfaced as artifacts.\n\nProvide rules as MIME type patterns, file path globs, or memory file path globs, each mapped to a group configuration with a groupName and optional onlyShowGroup flag.\n\nExamples:\n- byMimeType: { \"image/*\": { \"groupName\": \"Screenshots\", \"onlyShowGroup\": true } }\n- byFilePath: { \"**/*plan*.md\": { \"groupName\": \"Plans\" } }\n- byMemoryFilePath: { \"**/*plan*.md\": { \"groupName\": \"Plans\" } }\n\nThis fully replaces any settings-based rules for the duration of this session.",
+    canBeReferencedInPrompt: true,
+    source: ToolDataSource.Internal,
+    inputSchema
+};
+let SetArtifactRulesTool = class SetArtifactRulesTool {
+    constructor(_chatArtifactsService) {
+        this._chatArtifactsService = _chatArtifactsService;
+    }
+    async prepareToolInvocation(_context, _token) {
+        return {
+            pastTenseMessage: ( new MarkdownString(( localize(10897, "Updated artifact rules")))),
+            presentation: ToolInvocationPresentation.Hidden
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, _token) {
+        const args = invocation.parameters;
+        const chatSessionResource = invocation.context?.sessionResource;
+        if (!chatSessionResource) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "Error: No session resource available"
+                }]
+            };
+        }
+        const rules = {
+            byMimeType: args.byMimeType,
+            byFilePath: args.byFilePath,
+            byMemoryFilePath: args.byMemoryFilePath
+        };
+        this._chatArtifactsService.getArtifacts(chatSessionResource).setRuleOverrides(rules);
+        return {
+            content: [{
+                kind: "text",
+                value: ( localize(10898, "Updated artifact rules"))
+            }]
+        };
+    }
+};
+SetArtifactRulesTool = ( __decorate([( __param(0, IChatArtifactsService))], SetArtifactRulesTool));
+
+export { SetArtifactRulesTool, SetArtifactRulesToolData, SetArtifactRulesToolId };

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

@@ -0,0 +1,16 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IToolData, IToolImpl, IToolInvocation, IToolResult, IToolInvocationPreparationContext, IPreparedToolInvocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import { IChatArtifactsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatArtifactsService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+export declare const SetArtifactsToolId = "setArtifacts";
+export declare const SetArtifactsToolData: IToolData;
+export declare class SetArtifactsTool implements IToolImpl {
+    private readonly _chatArtifactsService;
+    private readonly _fileService;
+    private readonly _chatService;
+    constructor(_chatArtifactsService: IChatArtifactsService, _fileService: IFileService, _chatService: IChatService);
+    prepareToolInvocation(_context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: never, _progress: never, _token: CancellationToken): Promise<IToolResult>;
+    private _resolveSubagentName;
+}

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

@@ -0,0 +1,130 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ToolDataSource, ToolInvocationPresentation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { IChatArtifactsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatArtifactsService.service';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+
+const SetArtifactsToolId = "setArtifacts";
+const inputSchema = {
+    type: "object",
+    properties: {
+        artifacts: {
+            type: "array",
+            description: "The complete list of artifacts for this session. Overwrites any existing artifacts.",
+            items: {
+                type: "object",
+                properties: {
+                    label: {
+                        type: "string",
+                        description: "Display label for the artifact."
+                    },
+                    uri: {
+                        type: "string",
+                        description: "Fully qualified URI of the artifact (e.g. https://localhost:3000 or file:///path/to/file). Must include the scheme."
+                    },
+                    type: {
+                        type: "string",
+                        enum: ["devServer", "screenshot", "plan"],
+                        description: "The type of artifact."
+                    }
+                },
+                required: ["label"]
+            }
+        }
+    },
+    required: ["artifacts"]
+};
+const SetArtifactsToolData = {
+    id: SetArtifactsToolId,
+    toolReferenceName: "artifacts",
+    legacyToolReferenceFullNames: ["Set Session Artifacts"],
+    displayName: ( localize(10899, "Set Session Artifacts")),
+    modelDescription: "Set the list of artifacts for the current session. Each artifact has a label and either a uri or a toolCallId+dataPartIndex reference, plus an optional type (devServer, screenshot, plan). This overwrites the entire artifact list. URIs must be fully qualified with a scheme (e.g. https://localhost:3000, file:///tmp/plan.md). To reference a screenshot or image from a previous tool result, use toolCallId and dataPartIndex instead of uri.\n\nWhen to use this tool:\n- When creating or updating a plan saved to session memory — set a plan artifact so the user can view it in the artifact panel\n- When taking screenshots or producing visual output — set a screenshot artifact to surface the image\n- When starting a dev server — set a devServer artifact with the URL so the user can access it\n- When producing important documents, drafts, or temporary markdown files — set an artifact to make them easily accessible\n- After verification steps that produce visual results — update artifacts with screenshots showing the outcome\n\nWorkflow:\n- Prefer artifacts over printing long content inline in chat. Save content to a file or memory, then set an artifact pointing to it.\n- When updating plans or documents, update both the underlying file AND the artifact list.\n- Keep artifact labels concise and descriptive.",
+    canBeReferencedInPrompt: true,
+    source: ToolDataSource.Internal,
+    inputSchema
+};
+let SetArtifactsTool = class SetArtifactsTool {
+    constructor(_chatArtifactsService, _fileService, _chatService) {
+        this._chatArtifactsService = _chatArtifactsService;
+        this._fileService = _fileService;
+        this._chatService = _chatService;
+    }
+    async prepareToolInvocation(_context, _token) {
+        return {
+            pastTenseMessage: ( new MarkdownString(( localize(10900, "Updated session artifacts")))),
+            presentation: ToolInvocationPresentation.Hidden
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, _token) {
+        const args = invocation.parameters;
+        const chatSessionResource = invocation.context?.sessionResource;
+        if (!chatSessionResource) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "Error: No session resource available"
+                }]
+            };
+        }
+        const artifacts = [];
+        for (const a of args.artifacts ?? []) {
+            let uri = a.uri;
+            if (!uri) {
+                uri = "";
+            }
+            if (uri) {
+                const parsed = ( URI.parse(uri));
+                if (parsed.scheme !== "http" && parsed.scheme !== "https") {
+                    if (!(await this._fileService.exists(parsed))) {
+                        throw ( new Error(( localize(10901, "Artifact URI does not exist: {0}", uri))));
+                    }
+                }
+            }
+            artifacts.push({
+                label: a.label,
+                uri,
+                type: a.type
+            });
+        }
+        const chatArtifacts = this._chatArtifactsService.getArtifacts(chatSessionResource);
+        const subAgentInvocationId = invocation.subAgentInvocationId;
+        if (subAgentInvocationId) {
+            const agentName = this._resolveSubagentName(chatSessionResource, subAgentInvocationId);
+            chatArtifacts.setSubagentArtifacts(subAgentInvocationId, agentName, artifacts);
+        } else {
+            chatArtifacts.setAgentArtifacts(artifacts);
+        }
+        return {
+            content: [{
+                kind: "text",
+                value: ( localize(10902, "Set {0} artifact(s)", artifacts.length))
+            }]
+        };
+    }
+    _resolveSubagentName(sessionResource, subAgentInvocationId) {
+        const model = this._chatService.getSession(sessionResource);
+        if (!model) {
+            return undefined;
+        }
+        for (const request of model.getRequests()) {
+            const response = request.response;
+            if (!response) {
+                continue;
+            }
+            for (const part of response.response.value) {
+                if ((part.kind === "toolInvocation" || part.kind === "toolInvocationSerialized") && part.toolCallId === subAgentInvocationId && part.toolSpecificData?.kind === "subagent") {
+                    return part.toolSpecificData.agentName;
+                }
+            }
+        }
+        return undefined;
+    }
+};
+SetArtifactsTool = ( __decorate([( __param(0, IChatArtifactsService)), ( __param(1, IFileService)), ( __param(2, IChatService))], SetArtifactsTool));
+
+export { SetArtifactsTool, SetArtifactsToolData, SetArtifactsToolId };

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

@@ -0,0 +1,12 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress, CountTokensCallback } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+export declare const TaskCompleteToolId = "task_complete";
+/**
+ * Message sent to the agent when the session goes idle without task completion.
+ */
+export declare const AUTOPILOT_CONTINUATION_MESSAGE: string;
+export declare const TaskCompleteToolData: IToolData;
+export declare class TaskCompleteTool 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/builtinTools/taskCompleteTool.js

@@ -0,0 +1,53 @@
+
+import { ToolDataSource, ToolInvocationPresentation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+
+const TaskCompleteToolId = 'task_complete';
+const TaskCompleteToolData = {
+    id: TaskCompleteToolId,
+    displayName: 'Task Complete',
+    modelDescription: 'Signal that the user\'s task is fully done. You MUST call this tool when your work is complete — ' +
+        'whether you made code changes, answered a question, or completed any other kind of task. ' +
+        'Provide a brief summary of what was accomplished. ' +
+        'Do not restate the summary in your message text — it is shown to the user directly.\n\n' +
+        'IMPORTANT: Before calling this tool, you MUST output a brief text message summarizing what was done. ' +
+        'The task is not complete until both your summary message AND this tool call are present.\n\n' +
+        'When to call:\n' +
+        '- After answering the user\'s question or completing a conversational request\n' +
+        '- After you have completed ALL requested changes\n' +
+        '- After verifying results: tests pass, terminal commands succeeded, tool calls returned expected output\n\n' +
+        'When NOT to call:\n' +
+        '- If a terminal command failed or produced unexpected output\n' +
+        '- If an MCP or external tool call returned an error\n' +
+        '- If you encountered errors you have not resolved\n' +
+        '- If there are remaining steps to complete\n' +
+        '- If you have not verified your changes work',
+    source: ToolDataSource.Internal,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            summary: {
+                type: 'string',
+                description: 'Brief summary of what was accomplished. Omit for trivial interactions.',
+            },
+        },
+    },
+};
+class TaskCompleteTool {
+    async prepareToolInvocation(_context, _token) {
+        return {
+            presentation: ToolInvocationPresentation.Hidden,
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, _token) {
+        const params = invocation.parameters;
+        const summary = params?.summary ?? 'All done!';
+        return {
+            content: [{
+                    kind: 'text',
+                    value: summary,
+                }],
+        };
+    }
+}
+
+export { TaskCompleteTool, TaskCompleteToolData, TaskCompleteToolId };

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

@@ -0,0 +1,5 @@
+import { IToolResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+/**
+ * Creates a tool result with a single text content part.
+ */
+export declare function createToolSimpleTextResult(value: string): IToolResult;

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

@@ -0,0 +1,12 @@
+
+
+function createToolSimpleTextResult(value) {
+    return {
+        content: [{
+                kind: 'text',
+                value
+            }]
+    };
+}
+
+export { createToolSimpleTextResult };

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

@@ -0,0 +1,10 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+export declare class BuiltinToolsContribution extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "chat.builtinTools";
+    constructor(toolsService: ILanguageModelToolsService, instantiationService: IInstantiationService, configurationService: IConfigurationService);
+}
+export { InternalFetchWebPageToolId } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/toolIds";

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

@@ -0,0 +1,91 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { AskQuestionsTool, AskQuestionsToolData } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/askQuestionsTool';
+import { ConfirmationTool, ConfirmationToolData, ConfirmationToolWithOptionsData, ModifiedFilesConfirmationTool, ModifiedFilesConfirmationToolData } from './confirmationTool.js';
+import { EditTool, EditToolData } from './editFileTool.js';
+import { createManageTodoListToolData, ManageTodoListTool } from './manageTodoListTool.js';
+import { ReviewPlanTool, ReviewPlanToolData } from './reviewPlanTool.js';
+import { RunSubagentTool } from './runSubagentTool.js';
+import { SetArtifactsTool, SetArtifactsToolData } from './setArtifactsTool.js';
+import { SetArtifactRulesTool, SetArtifactRulesToolData } from './setArtifactRulesTool.js';
+import { TaskCompleteTool, TaskCompleteToolData } from './taskCompleteTool.js';
+
+let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable {
+    static {
+        this.ID = "chat.builtinTools";
+    }
+    constructor(toolsService, instantiationService, configurationService) {
+        super();
+        const editTool = instantiationService.createInstance(EditTool);
+        this._register(toolsService.registerTool(EditToolData, editTool));
+        const askQuestionsTool = this._register(instantiationService.createInstance(AskQuestionsTool));
+        this._register(toolsService.registerTool(AskQuestionsToolData, askQuestionsTool));
+        this._register(toolsService.vscodeToolSet.addTool(AskQuestionsToolData));
+        const reviewPlanTool = this._register(instantiationService.createInstance(ReviewPlanTool));
+        this._register(toolsService.registerTool(ReviewPlanToolData, reviewPlanTool));
+        const todoToolData = createManageTodoListToolData();
+        const manageTodoListTool = this._register(instantiationService.createInstance(ManageTodoListTool));
+        this._register(toolsService.registerTool(todoToolData, manageTodoListTool));
+        const confirmationTool = instantiationService.createInstance(ConfirmationTool);
+        this._register(toolsService.registerTool(ConfirmationToolData, confirmationTool));
+        this._register(
+            toolsService.registerTool(ConfirmationToolWithOptionsData, confirmationTool)
+        );
+        const modifiedFilesConfirmationTool = instantiationService.createInstance(ModifiedFilesConfirmationTool);
+        this._register(
+            toolsService.registerTool(ModifiedFilesConfirmationToolData, modifiedFilesConfirmationTool)
+        );
+        const taskCompleteTool = instantiationService.createInstance(TaskCompleteTool);
+        this._register(toolsService.registerTool(TaskCompleteToolData, taskCompleteTool));
+        const setArtifactsTool = instantiationService.createInstance(SetArtifactsTool);
+        const setArtifactRulesTool = instantiationService.createInstance(SetArtifactRulesTool);
+        const setArtifactsRegistration = this._register(( new MutableDisposable()));
+        const setArtifactRulesRegistration = this._register(( new MutableDisposable()));
+        const updateArtifactsRegistration = () => {
+            if (configurationService.getValue(ChatConfiguration.ArtifactsEnabled)) {
+                if (!setArtifactsRegistration.value) {
+                    setArtifactsRegistration.value = toolsService.registerTool(SetArtifactsToolData, setArtifactsTool);
+                }
+                if (!setArtifactRulesRegistration.value) {
+                    setArtifactRulesRegistration.value = toolsService.registerTool(SetArtifactRulesToolData, setArtifactRulesTool);
+                }
+            } else {
+                setArtifactsRegistration.clear();
+                setArtifactRulesRegistration.clear();
+            }
+        };
+        updateArtifactsRegistration();
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.ArtifactsEnabled)) {
+                updateArtifactsRegistration();
+            }
+        }));
+        const runSubagentTool = this._register(instantiationService.createInstance(RunSubagentTool));
+        let runSubagentRegistration;
+        let toolSetRegistration;
+        const registerRunSubagentTool = () => {
+            runSubagentRegistration?.dispose();
+            toolSetRegistration?.dispose();
+            toolsService.flushToolUpdates();
+            const runSubagentToolData = runSubagentTool.getToolData();
+            runSubagentRegistration = toolsService.registerTool(runSubagentToolData, runSubagentTool);
+            toolSetRegistration = toolsService.agentToolSet.addTool(runSubagentToolData);
+        };
+        registerRunSubagentTool();
+        this._register(runSubagentTool.onDidUpdateToolData(registerRunSubagentTool));
+        this._register({
+            dispose: () => {
+                runSubagentRegistration?.dispose();
+                toolSetRegistration?.dispose();
+            }
+        });
+    }
+};
+BuiltinToolsContribution = ( __decorate([( __param(0, ILanguageModelToolsService)), ( __param(1, IInstantiationService)), ( __param(2, IConfigurationService))], BuiltinToolsContribution));
+
+export { BuiltinToolsContribution };

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

@@ -0,0 +1,38 @@
+import { IJSONSchema } from "@codingame/monaco-vscode-api/vscode/vs/base/common/jsonSchema";
+import { ExtensionIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+export interface IRawToolContribution {
+    name: string;
+    displayName: string;
+    modelDescription: string;
+    toolReferenceName?: string;
+    legacyToolReferenceFullNames?: string[];
+    icon?: string | {
+        light: string;
+        dark: string;
+    };
+    when?: string;
+    tags?: string[];
+    userDescription?: string;
+    inputSchema?: IJSONSchema;
+    canBeReferencedInPrompt?: boolean;
+}
+export interface IRawToolSetContribution {
+    name: string;
+    /**
+     * @deprecated
+     */
+    referenceName?: string;
+    legacyFullNames?: string[];
+    description: string;
+    icon?: string;
+    tools: string[];
+}
+export declare function toToolSetKey(extensionIdentifier: ExtensionIdentifier, toolName: string): string;
+export declare class LanguageModelToolsExtensionPointHandler implements IWorkbenchContribution {
+    static readonly ID = "workbench.contrib.toolsExtensionPointHandler";
+    private _registrationDisposables;
+    constructor(productService: IProductService, languageModelToolsService: ILanguageModelToolsService);
+}