feat: add access_mcp_resource as native tool and update MCP server instructions

- Refactored accessMcpResourceTool to extend BaseTool class
- Added native tool definition for access_mcp_resource
- Updated MCP servers section to provide different instructions based on protocol
  - XML mode: mentions use_mcp_tool wrapper
  - Native mode: explains mcp_{server}_{tool} naming pattern
- Registered access_mcp_resource in native tools list

Author: daniel-lxs

src/core/assistant-message/NativeToolCallParser.ts

@@ -256,9 +256,9 @@ export class NativeToolCallParser {
 
 	/**
 	 * Finalize a streaming tool call.
-	 * Parses the complete JSON and returns the final ToolUse.
+	 * Parses the complete JSON and returns the final ToolUse or McpToolUse.
 	 */
-	public static finalizeStreamingToolCall(id: string): ToolUse | null {
+	public static finalizeStreamingToolCall(id: string): ToolUse | McpToolUse | null {
 		const toolCall = this.streamingToolCalls.get(id)
 		if (!toolCall) {
 			console.warn(`[NativeToolCallParser] Attempting to finalize unknown tool call: ${id}`)

src/core/prompts/sections/mcp-servers.ts

@@ -53,6 +53,11 @@ export async function getMcpServersSection(
 					.join("\n\n")}`
 			: "(No MCP servers currently connected)"
 
+	// Different instructions based on protocol
+	const toolAccessInstructions = includeToolDescriptions
+		? `When a server is connected, you can use the server's tools via the \`use_mcp_tool\` tool, and access the server's resources via the \`access_mcp_resource\` tool.`
+		: `When a server is connected, each server's tools are available as native tools with the naming pattern \`mcp_{server_name}_{tool_name}\`. For example, a tool named 'get_forecast' from a server named 'weather' would be available as \`mcp_weather_get_forecast\`. You can also access server resources using the \`access_mcp_resource\` tool.`
+
 	const baseSection = `MCP SERVERS
 
 The Model Context Protocol (MCP) enables communication between the system and MCP servers that provide additional tools and resources to extend your capabilities. MCP servers can be one of two types:
@@ -62,7 +67,7 @@ The Model Context Protocol (MCP) enables communication between the system and MC
 
 # Connected MCP Servers
 
-When a server is connected, you can use the server's tools via the \`use_mcp_tool\` tool, and access the server's resources via the \`access_mcp_resource\` tool.
+${toolAccessInstructions}
 
 ${connectedServers}`
 

src/core/prompts/tools/native-tools/access_mcp_resource.ts

@@ -0,0 +1,41 @@
+import type OpenAI from "openai"
+
+const ACCESS_MCP_RESOURCE_DESCRIPTION = `Request to access a resource provided by a connected MCP server. Resources represent data sources that can be used as context, such as files, API responses, or system information.
+
+Parameters:
+- server_name: (required) The name of the MCP server providing the resource
+- uri: (required) The URI identifying the specific resource to access
+
+Example: Accessing a weather resource
+{ "server_name": "weather-server", "uri": "weather://san-francisco/current" }
+
+Example: Accessing a file resource from an MCP server
+{ "server_name": "filesystem-server", "uri": "file:///path/to/data.json" }`
+
+const SERVER_NAME_PARAMETER_DESCRIPTION = `The name of the MCP server providing the resource`
+
+const URI_PARAMETER_DESCRIPTION = `The URI identifying the specific resource to access`
+
+export default {
+	type: "function",
+	function: {
+		name: "access_mcp_resource",
+		description: ACCESS_MCP_RESOURCE_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				server_name: {
+					type: "string",
+					description: SERVER_NAME_PARAMETER_DESCRIPTION,
+				},
+				uri: {
+					type: "string",
+					description: URI_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["server_name", "uri"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

src/core/prompts/tools/native-tools/index.ts

@@ -1,4 +1,5 @@
 import type OpenAI from "openai"
+import accessMcpResource from "./access_mcp_resource"
 import askFollowupQuestion from "./ask_followup_question"
 import attemptCompletion from "./attempt_completion"
 import browserAction from "./browser_action"
@@ -29,6 +30,7 @@ export { convertOpenAIToolToAnthropic, convertOpenAIToolsToAnthropic } from "./c
  */
 export function getNativeTools(partialReadsEnabled: boolean = true): OpenAI.Chat.ChatCompletionTool[] {
 	return [
+		accessMcpResource,
 		apply_diff_single_file,
 		askFollowupQuestion,
 		attemptCompletion,

src/core/tools/accessMcpResourceTool.ts

@@ -1,45 +1,44 @@
 import { ClineAskUseMcpServer } from "../../shared/ExtensionMessage"
-import { ToolUse, RemoveClosingTag, AskApproval, HandleError, PushToolResult } from "../../shared/tools"
+import type { ToolUse } from "../../shared/tools"
 import { Task } from "../task/Task"
 import { formatResponse } from "../prompts/responses"
+import { BaseTool, ToolCallbacks } from "./BaseTool"
 
-export async function accessMcpResourceTool(
-	cline: Task,
-	block: ToolUse,
-	askApproval: AskApproval,
-	handleError: HandleError,
-	pushToolResult: PushToolResult,
-	removeClosingTag: RemoveClosingTag,
-) {
-	const server_name: string | undefined = block.params.server_name
-	const uri: string | undefined = block.params.uri
-
-	try {
-		if (block.partial) {
-			const partialMessage = JSON.stringify({
-				type: "access_mcp_resource",
-				serverName: removeClosingTag("server_name", server_name),
-				uri: removeClosingTag("uri", uri),
-			} satisfies ClineAskUseMcpServer)
+interface AccessMcpResourceParams {
+	server_name: string
+	uri: string
+}
+
+export class AccessMcpResourceTool extends BaseTool<"access_mcp_resource"> {
+	readonly name = "access_mcp_resource" as const
+
+	parseLegacy(params: Partial<Record<string, string>>): AccessMcpResourceParams {
+		return {
+			server_name: params.server_name || "",
+			uri: params.uri || "",
+		}
+	}
 
-			await cline.ask("use_mcp_server", partialMessage, block.partial).catch(() => {})
-			return
-		} else {
+	async execute(params: AccessMcpResourceParams, task: Task, callbacks: ToolCallbacks): Promise<void> {
+		const { askApproval, handleError, pushToolResult, toolProtocol } = callbacks
+		const { server_name, uri } = params
+
+		try {
 			if (!server_name) {
-				cline.consecutiveMistakeCount++
-				cline.recordToolError("access_mcp_resource")
-				pushToolResult(await cline.sayAndCreateMissingParamError("access_mcp_resource", "server_name"))
+				task.consecutiveMistakeCount++
+				task.recordToolError("access_mcp_resource")
+				pushToolResult(await task.sayAndCreateMissingParamError("access_mcp_resource", "server_name"))
 				return
 			}
 
 			if (!uri) {
-				cline.consecutiveMistakeCount++
-				cline.recordToolError("access_mcp_resource")
-				pushToolResult(await cline.sayAndCreateMissingParamError("access_mcp_resource", "uri"))
+				task.consecutiveMistakeCount++
+				task.recordToolError("access_mcp_resource")
+				pushToolResult(await task.sayAndCreateMissingParamError("access_mcp_resource", "uri"))
 				return
 			}
 
-			cline.consecutiveMistakeCount = 0
+			task.consecutiveMistakeCount = 0
 
 			const completeMessage = JSON.stringify({
 				type: "access_mcp_resource",
@@ -50,12 +49,13 @@ export async function accessMcpResourceTool(
 			const didApprove = await askApproval("use_mcp_server", completeMessage)
 
 			if (!didApprove) {
+				pushToolResult(formatResponse.toolDenied(toolProtocol))
 				return
 			}
 
 			// Now execute the tool
-			await cline.say("mcp_server_request_started")
-			const resourceResult = await cline.providerRef.deref()?.getMcpHub()?.readResource(server_name, uri)
+			await task.say("mcp_server_request_started")
+			const resourceResult = await task.providerRef.deref()?.getMcpHub()?.readResource(server_name, uri)
 
 			const resourceResultPretty =
 				resourceResult?.contents
@@ -81,13 +81,25 @@ export async function accessMcpResourceTool(
 				}
 			})
 
-			await cline.say("mcp_server_response", resourceResultPretty, images)
+			await task.say("mcp_server_response", resourceResultPretty, images)
 			pushToolResult(formatResponse.toolResult(resourceResultPretty, images))
-
-			return
+		} catch (error) {
+			await handleError("accessing MCP resource", error instanceof Error ? error : new Error(String(error)))
 		}
-	} catch (error) {
-		await handleError("accessing MCP resource", error)
-		return
+	}
+
+	override async handlePartial(task: Task, block: ToolUse<"access_mcp_resource">): Promise<void> {
+		const server_name = this.removeClosingTag("server_name", block.params.server_name, true)
+		const uri = this.removeClosingTag("uri", block.params.uri, true)
+
+		const partialMessage = JSON.stringify({
+			type: "access_mcp_resource",
+			serverName: server_name,
+			uri: uri,
+		} satisfies ClineAskUseMcpServer)
+
+		await task.ask("use_mcp_server", partialMessage, block.partial).catch(() => {})
 	}
 }
+
+export const accessMcpResourceTool = new AccessMcpResourceTool()