use vscode.lm tools

Author: complyue

.husky/pre-push

@@ -4,7 +4,7 @@ import { z } from "zod"
  * ToolGroup
  */
 
-export const toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"] as const
+export const toolGroups = ["read", "edit", "browser", "command", "vsclmt", "mcp", "modes"] as const
 
 export const toolGroupsSchema = z.enum(toolGroups)
 
@@ -25,6 +25,7 @@ export const toolNames = [
 	"list_files",
 	"list_code_definition_names",
 	"browser_action",
+	"use_vsclmt",
 	"use_mcp_tool",
 	"access_mcp_resource",
 	"ask_followup_question",

packages/types/src/tool.ts

@@ -17,6 +17,7 @@ import { listCodeDefinitionNamesTool } from "../tools/listCodeDefinitionNamesToo
 import { searchFilesTool } from "../tools/searchFilesTool"
 import { browserActionTool } from "../tools/browserActionTool"
 import { executeCommandTool } from "../tools/executeCommandTool"
+import { useVSCLMT } from "../tools/vsclmt"
 import { useMcpToolTool } from "../tools/useMcpToolTool"
 import { accessMcpResourceTool } from "../tools/accessMcpResourceTool"
 import { askFollowupQuestionTool } from "../tools/askFollowupQuestionTool"
@@ -176,6 +177,8 @@ export async function presentAssistantMessage(cline: Task) {
 						return `[${block.name} for '${block.params.path}']`
 					case "browser_action":
 						return `[${block.name} for '${block.params.action}']`
+					case "use_vsclmt":
+						return `[${block.name} for '${block.params.tool_name}']`
 					case "use_mcp_tool":
 						return `[${block.name} for '${block.params.server_name}']`
 					case "access_mcp_resource":
@@ -431,6 +434,9 @@ export async function presentAssistantMessage(cline: Task) {
 				case "execute_command":
 					await executeCommandTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag)
 					break
+				case "use_vsclmt":
+					await useVSCLMT(cline, block, askApproval, handleError, pushToolResult, removeClosingTag)
+					break
 				case "use_mcp_tool":
 					await useMcpToolTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag)
 					break

src/core/assistant-message/presentAssistantMessage.ts

@@ -3,6 +3,7 @@ export { getSystemInfoSection } from "./system-info"
 export { getObjectiveSection } from "./objective"
 export { addCustomInstructions } from "./custom-instructions"
 export { getSharedToolUseSection } from "./tool-use"
+export { getVSCLMTSection } from "./vsclmt"
 export { getMcpServersSection } from "./mcp-servers"
 export { getToolUseGuidelinesSection } from "./tool-use-guidelines"
 export { getCapabilitiesSection } from "./capabilities"

src/core/prompts/sections/index.ts

@@ -0,0 +1,51 @@
+import type { ToolInfo } from "../../../services/vsclm/VSCLMToolsService"
+
+export function getVSCLMTSection(selectedVSCLMT: ToolInfo[]): string {
+	if (!selectedVSCLMT || selectedVSCLMT.length === 0) {
+		return ""
+	}
+
+	const toolDescriptions = selectedVSCLMT
+		.map((tool) => {
+			const displayName = tool.displayName || tool.name
+			const description = tool.description || tool.userDescription || "No description available"
+
+			let toolSection = `### ${displayName}
+**Provider Extension:** ${tool.providerExtensionDisplayName} (${tool.providerExtensionId})
+**Description:** ${description}
+
+**Tool Name:** ${tool.name}`
+
+			// Add input schema information if available
+			if (tool.inputSchema && typeof tool.inputSchema === "object") {
+				try {
+					const schemaStr = JSON.stringify(tool.inputSchema, null, 2)
+					toolSection += `
+**Input Schema:**
+\`\`\`json
+${schemaStr}
+\`\`\``
+				} catch (error) {
+					// If schema can't be serialized, skip it
+					console.log(`Error serializing input schema for tool ${tool.name}:`, error)
+				}
+			}
+
+			// Add tags if available
+			if (tool.tags && tool.tags.length > 0) {
+				toolSection += `
+**Tags:** ${tool.tags.join(", ")}`
+			}
+
+			return toolSection
+		})
+		.join("\n\n")
+
+	return `## VS Code Language Model Tools
+
+The following VS Code Language Model tools are available for use. You can invoke them using the \`use_vsclmt\` tool with the appropriate tool name and arguments.
+
+${toolDescriptions}
+
+**Usage:** To use any of these tools, use the \`use_vsclmt\` tool with the \`tool_name\` parameter set to the exact tool name shown above, and provide any required arguments as a JSON string in the \`arguments\` parameter.`
+}

src/core/prompts/sections/vsclmt.ts

@@ -7,6 +7,7 @@ import { Mode, modes, defaultModeSlug, getModeBySlug, getGroupName, getModeSelec
 import { DiffStrategy } from "../../shared/tools"
 import { formatLanguage } from "../../shared/language"
 
+import { VSCLMToolsService } from "../../services/vsclm/VSCLMToolsService"
 import { McpHub } from "../../services/mcp/McpHub"
 import { CodeIndexManager } from "../../services/code-index/manager"
 
@@ -18,6 +19,7 @@ import {
 	getSystemInfoSection,
 	getObjectiveSection,
 	getSharedToolUseSection,
+	getVSCLMTSection,
 	getMcpServersSection,
 	getToolUseGuidelinesSection,
 	getCapabilitiesSection,
@@ -31,6 +33,7 @@ async function generatePrompt(
 	cwd: string,
 	supportsComputerUse: boolean,
 	mode: Mode,
+	vsclmtService?: VSCLMToolsService,
 	mcpHub?: McpHub,
 	diffStrategy?: DiffStrategy,
 	browserViewportSize?: string,
@@ -56,8 +59,9 @@ async function generatePrompt(
 	const modeConfig = getModeBySlug(mode, customModeConfigs) || modes.find((m) => m.slug === mode) || modes[0]
 	const { roleDefinition, baseInstructions } = getModeSelection(mode, promptComponent, customModeConfigs)
 
-	const [modesSection, mcpServersSection] = await Promise.all([
+	const [modesSection, vsclmtSection, mcpServersSection] = await Promise.all([
 		getModesSection(context),
+		vsclmtService ? getVSCLMTSection(vsclmtService.getSelectedTools()) : Promise.resolve(""),
 		modeConfig.groups.some((groupEntry) => getGroupName(groupEntry) === "mcp")
 			? getMcpServersSection(mcpHub, effectiveDiffStrategy, enableMcpServerCreation)
 			: Promise.resolve(""),
@@ -87,6 +91,8 @@ ${getToolDescriptionsForMode(
 
 ${getToolUseGuidelinesSection(codeIndexManager)}
 
+${vsclmtSection}
+
 ${mcpServersSection}
 
 ${getCapabilitiesSection(cwd, supportsComputerUse, mcpHub, effectiveDiffStrategy, codeIndexManager)}
@@ -108,6 +114,7 @@ export const SYSTEM_PROMPT = async (
 	context: vscode.ExtensionContext,
 	cwd: string,
 	supportsComputerUse: boolean,
+	vsclmtService?: VSCLMToolsService,
 	mcpHub?: McpHub,
 	diffStrategy?: DiffStrategy,
 	browserViewportSize?: string,
@@ -182,6 +189,7 @@ ${customInstructions}`
 		cwd,
 		supportsComputerUse,
 		currentMode.slug,
+		vsclmtService,
 		mcpHub,
 		effectiveDiffStrategy,
 		browserViewportSize,

src/core/prompts/system.ts

@@ -17,6 +17,7 @@ import { getListCodeDefinitionNamesDescription } from "./list-code-definition-na
 import { getBrowserActionDescription } from "./browser-action"
 import { getAskFollowupQuestionDescription } from "./ask-followup-question"
 import { getAttemptCompletionDescription } from "./attempt-completion"
+import { getVSCLMTDescription } from "./vsclmt"
 import { getUseMcpToolDescription } from "./use-mcp-tool"
 import { getAccessMcpResourceDescription } from "./access-mcp-resource"
 import { getSwitchModeDescription } from "./switch-mode"
@@ -26,6 +27,7 @@ import { CodeIndexManager } from "../../../services/code-index/manager"
 
 // Map of tool names to their description functions
 const toolDescriptionMap: Record<string, (args: ToolArgs) => string | undefined> = {
+	use_vsclmt: (args) => getVSCLMTDescription(args),
 	execute_command: (args) => getExecuteCommandDescription(args),
 	read_file: (args) => getReadFileDescription(args),
 	fetch_instructions: () => getFetchInstructionsDescription(),
@@ -134,6 +136,7 @@ export {
 	getBrowserActionDescription,
 	getAskFollowupQuestionDescription,
 	getAttemptCompletionDescription,
+	getVSCLMTDescription,
 	getUseMcpToolDescription,
 	getAccessMcpResourceDescription,
 	getSwitchModeDescription,

src/core/prompts/tools/index.ts

@@ -0,0 +1,27 @@
+import { ToolArgs } from "./types"
+
+export function getVSCLMTDescription(args: ToolArgs): string {
+	return `## use_vsclmt
+
+Access and invoke VS Code Language Model tools that are selected and available in the current workspace.
+
+Required parameters:
+- tool_name: The name of the VS Code LM tool to invoke
+
+Optional parameters:
+- arguments: JSON string containing the arguments for the tool
+
+The tool will:
+1. Validate that the specified VS Code LM tool is available and selected
+2. Parse and validate the provided arguments
+3. Invoke the tool using VS Code's native language model tool system
+4. Return the tool's result or any error messages
+
+Use this tool to leverage VS Code's ecosystem of language model tools for enhanced functionality.
+
+Example:
+<use_vsclmt>
+<tool_name>example-tool</tool_name>
+<arguments>{"param1": "value1", "param2": "value2"}</arguments>
+</use_vsclmt>`
+}

src/core/prompts/tools/vsclmt.ts

@@ -1615,6 +1615,7 @@ export class Task extends EventEmitter<ClineEvents> {
 	// kilocode_change end
 
 	/*private kilocode_change*/ async getSystemPrompt(): Promise<string> {
+		const vsclmtService = this.providerRef.deref()?.getVSCLMToolService()
 		const { mcpEnabled } = (await this.providerRef.deref()?.getState()) ?? {}
 		let mcpHub: McpHub | undefined
 		if (mcpEnabled ?? true) {
@@ -1666,6 +1667,7 @@ export class Task extends EventEmitter<ClineEvents> {
 				provider.context,
 				this.cwd,
 				(this.api.getModel().info.supportsComputerUse ?? false) && (browserToolEnabled ?? true),
+				vsclmtService,
 				mcpHub,
 				this.diffStrategy,
 				browserViewportSize,

src/core/task/Task.ts

@@ -0,0 +1,102 @@
+import * as vscode from "vscode"
+import { formatResponse } from "../prompts/responses"
+import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools"
+import { Task } from "../task/Task"
+
+export async function useVSCLMT(
+	cline: Task,
+	toolUse: ToolUse,
+	askApproval: AskApproval,
+	handleError: HandleError,
+	pushToolResult: PushToolResult,
+	removeClosingTag: RemoveClosingTag,
+): Promise<void> {
+	const { tool_name, arguments: toolArgs } = toolUse.params
+
+	// Handle partial tool invocation (missing parameters)
+	if (toolUse.partial) {
+		const partialMessage = JSON.stringify({
+			type: "vsclmt_tool",
+			toolName: removeClosingTag("tool_name", tool_name),
+			arguments: removeClosingTag("arguments", toolArgs),
+		})
+
+		await cline.ask("tool", partialMessage, toolUse.partial).catch(() => {})
+		return
+	}
+
+	// Non-partial: require tool_name
+	if (!tool_name) {
+		cline.recordToolError("use_vsclmt")
+		pushToolResult(await cline.sayAndCreateMissingParamError("use_vsclmt", "tool_name"))
+		return
+	}
+
+	// Get the vsclmt service from ClineProvider
+	const provider = cline.providerRef.deref()
+	const vsclmtService = provider?.getVSCLMToolService()
+
+	if (!vsclmtService) {
+		pushToolResult(formatResponse.toolError("VS Code LM tool system not available"))
+		return
+	}
+
+	// Parse arguments if provided
+	let parsedArgs: any = {}
+	if (toolArgs) {
+		try {
+			parsedArgs = JSON.parse(toolArgs)
+		} catch (error) {
+			pushToolResult(formatResponse.toolError(`Invalid JSON arguments: ${error.message}`))
+			return
+		}
+	}
+
+	try {
+		// Check if tool is selected
+		if (!vsclmtService.isToolSelected(tool_name)) {
+			pushToolResult(
+				formatResponse.toolError(
+					`Tool '${tool_name}' is not selected for use. Please select it in the Tool Selection panel.`,
+				),
+			)
+			return
+		}
+
+		// Prepare tool invocation to get any user confirmation message
+		const prepared = await vsclmtService.prepareToolInvocation(tool_name, parsedArgs)
+		if (prepared?.confirmationMessages) {
+			// Ask for approval with the tool's custom confirmation message
+			const message =
+				prepared.confirmationMessages.message instanceof vscode.MarkdownString
+					? prepared.confirmationMessages.message.value
+					: prepared.confirmationMessages.message
+
+			const confirmText = `${prepared.confirmationMessages.title}\n${message}`
+			const approved = await askApproval("tool", confirmText)
+
+			if (!approved) {
+				pushToolResult(formatResponse.toolDenied())
+				return
+			}
+		}
+
+		// Invoke the tool with any progress message from preparation
+		const result = await vsclmtService.invokeTool(tool_name, parsedArgs)
+
+		// Format the result for display
+		let resultText: string
+		if (typeof result === "string") {
+			resultText = result
+		} else if (result && typeof result === "object") {
+			resultText = JSON.stringify(result, null, 2)
+		} else {
+			resultText = String(result)
+		}
+
+		pushToolResult(`VS Code LM tool '${tool_name}' executed successfully:\n\n${resultText}`)
+	} catch (error) {
+		await handleError("VS Code LM tool invocation", error)
+		pushToolResult(formatResponse.toolError(`Failed to invoke VS Code LM tool '${tool_name}': ${error.message}`))
+	}
+}