feat(mcp): expose server resources via list/read tools

MCP bridged only tools; servers also publish resources (files, records,
docs). Both transports now speak resources/list + resources/read, the
manager aggregates them across servers, and two read-only tools —
list_mcp_resources / read_mcp_resource — let the agent enumerate and pull
them in. /mcp lists them too. (Prompts-as-commands is the remaining MCP
surface, deferred as a focused follow-up.)

Author: halfaipg

src/agent/agent.ts

@@ -515,6 +515,9 @@ export function createAgent(opts: CreateAgentOptions = {}): AgentBundle {
 			},
 		},
 	});
+	// Back the list_mcp_resources / read_mcp_resource tools. Assigned now
+	// (after the manager exists); resources populate once connectMcp runs.
+	toolContext.mcp = mcp;
 	const connectMcp = async (): Promise<readonly McpServerStatus[]> => {
 		await mcp.connectAll({ cwd });
 		const mcpTools = mcp.tools();

src/commands/builtins/mcp.ts

@@ -47,6 +47,11 @@ export const mcp: Command = {
 			ctx.emit("Tools:");
 			for (const t of tools) ctx.emit(`  ${t.name}`);
 		}
+		const resources = ctx.bundle.mcp.resources();
+		if (resources.length > 0) {
+			ctx.emit("Resources (read via read_mcp_resource):");
+			for (const r of resources) ctx.emit(`  ${r.server} :: ${r.descriptor.uri}`);
+		}
 		return { handled: true };
 	},
 };

src/mcp/__test__/mock-server.mjs

@@ -23,7 +23,7 @@ rl.on("line", (line) => {
 			id: msg.id,
 			result: {
 				protocolVersion: "2025-06-18",
-				capabilities: { tools: {} },
+				capabilities: { tools: {}, resources: {} },
 				serverInfo: { name: "mock", version: "0" },
 			},
 		});
@@ -63,6 +63,23 @@ rl.on("line", (line) => {
 		}
 		return;
 	}
+	if (msg.method === "resources/list") {
+		send({
+			jsonrpc: "2.0",
+			id: msg.id,
+			result: { resources: [{ uri: "mock://greeting", name: "greeting", mimeType: "text/plain" }] },
+		});
+		return;
+	}
+	if (msg.method === "resources/read") {
+		const uri = msg.params?.uri;
+		send({
+			jsonrpc: "2.0",
+			id: msg.id,
+			result: { contents: [{ uri, mimeType: "text/plain", text: "hello from mock" }] },
+		});
+		return;
+	}
 	// Unknown method → error response.
 	if (typeof msg.id === "number") {
 		send({ jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: `unknown method: ${msg.method}` } });

src/mcp/client.ts

@@ -1,4 +1,4 @@
-import type { McpCallToolResult, McpToolDescriptor } from "./protocol.js";
+import type { McpCallToolResult, McpReadResourceResult, McpResourceDescriptor, McpToolDescriptor } from "./protocol.js";
 
 /** What every MCP client speaks to, regardless of transport (stdio | http). */
 export const CLIENT_INFO = { name: "codebase-cli", version: "1" } as const;
@@ -19,6 +19,10 @@ export interface McpClient {
 	listTools(): Promise<McpToolDescriptor[]>;
 	/** Invoke a tool by name with arguments. */
 	callTool(name: string, args: unknown): Promise<McpCallToolResult>;
+	/** List the server's resources. Returns [] when the server has no resources capability. */
+	listResources(): Promise<McpResourceDescriptor[]>;
+	/** Read one resource by URI. */
+	readResource(uri: string): Promise<McpReadResourceResult>;
 	/** Tear down the transport and reject any in-flight requests. */
 	close(): void;
 }

src/mcp/http-client.ts

@@ -5,6 +5,8 @@ import {
 	type JsonRpcResponse,
 	MCP_PROTOCOL_VERSION,
 	type McpCallToolResult,
+	type McpReadResourceResult,
+	type McpResourceDescriptor,
 	type McpToolDescriptor,
 	parseRpcLine,
 } from "./protocol.js";
@@ -67,6 +69,21 @@ export class HttpMcpClient implements McpClient {
 		return (res.result as McpCallToolResult) ?? {};
 	}
 
+	async listResources(): Promise<McpResourceDescriptor[]> {
+		try {
+			const res = await this.request("resources/list", {});
+			const result = res.result as { resources?: McpResourceDescriptor[] } | undefined;
+			return Array.isArray(result?.resources) ? result.resources : [];
+		} catch {
+			return [];
+		}
+	}
+
+	async readResource(uri: string): Promise<McpReadResourceResult> {
+		const res = await this.request("resources/read", { uri });
+		return (res.result as McpReadResourceResult) ?? {};
+	}
+
 	close(): void {
 		if (this.closed) return;
 		this.closed = true;

src/mcp/manager.test.ts

@@ -80,6 +80,19 @@ describe("McpManager (against the mock server)", () => {
 		expect(manager.status()).toEqual([]);
 	});
 
+	it("aggregates resources and reads one by server + uri", async () => {
+		writeConfig({ demo: { command: process.execPath, args: [MOCK] } });
+		manager = new McpManager();
+		await manager.connectAll({ home, cwd });
+
+		const resources = manager.resources();
+		expect(resources).toHaveLength(1);
+		expect(resources[0]).toMatchObject({ server: "demo", descriptor: { uri: "mock://greeting", name: "greeting" } });
+
+		const read = await manager.readResource("demo", "mock://greeting");
+		expect(read.contents?.[0]).toMatchObject({ text: "hello from mock" });
+	});
+
 	it("connects a remote (url) server over HTTP and bridges its tools", async () => {
 		const server = await startHttpMock();
 		try {

src/mcp/manager.ts

@@ -5,6 +5,7 @@ import { HttpMcpClient } from "./http-client.js";
 import type { AuthorizeDeps } from "./oauth/flow.js";
 import { McpOAuthProvider } from "./oauth/provider.js";
 import { McpOAuthStore } from "./oauth/store.js";
+import type { McpReadResourceResult, McpResourceDescriptor } from "./protocol.js";
 import { StdioMcpClient } from "./stdio-client.js";
 import { mcpToAgentTool } from "./to-agent-tool.js";
 
@@ -15,6 +16,12 @@ export interface McpServerStatus {
 	error?: string;
 }
 
+/** A resource plus the server that exposes it. */
+export interface McpResourceRef {
+	server: string;
+	descriptor: McpResourceDescriptor;
+}
+
 export interface McpManagerOptions {
 	/** Persisted OAuth sessions for remote servers. Defaults to ~/.codebase/mcp-credentials.json. */
 	oauthStore?: McpOAuthStore;
@@ -34,8 +41,10 @@ export interface McpManagerOptions {
  */
 export class McpManager {
 	private readonly clients: McpClient[] = [];
+	private readonly clientsByName = new Map<string, McpClient>();
 	private readonly statuses: McpServerStatus[] = [];
 	private readonly toolList: AgentTool<any>[] = [];
+	private readonly resourceList: McpResourceRef[] = [];
 	private readonly oauthStore: McpOAuthStore;
 	private readonly authDeps: AuthorizeDeps;
 
@@ -59,9 +68,14 @@ export class McpManager {
 					await client.connect();
 					const descriptors = await client.listTools();
 					this.clients.push(client);
+					this.clientsByName.set(name, client);
 					for (const desc of descriptors) {
 						this.toolList.push(mcpToAgentTool(name, client, desc));
 					}
+					// Resources are best-effort — a server without the capability
+					// returns [], and a failure here never blocks its tools.
+					const resources = await client.listResources().catch(() => []);
+					for (const r of resources) this.resourceList.push({ server: name, descriptor: r });
 					this.statuses.push({ name, connected: true, toolCount: descriptors.length });
 				} catch (err) {
 					client.close();
@@ -86,6 +100,18 @@ export class McpManager {
 		return this.statuses;
 	}
 
+	/** Every resource discovered across connected servers. */
+	resources(): readonly McpResourceRef[] {
+		return this.resourceList;
+	}
+
+	/** Read a resource by server name + URI. Throws if the server isn't connected. */
+	async readResource(server: string, uri: string): Promise<McpReadResourceResult> {
+		const client = this.clientsByName.get(server);
+		if (!client) throw new Error(`MCP server "${server}" is not connected`);
+		return client.readResource(uri);
+	}
+
 	/** Terminate every server connection. Idempotent. */
 	dispose(): void {
 		for (const client of this.clients) client.close();

src/mcp/protocol.ts

@@ -54,6 +54,27 @@ export interface McpCallToolResult {
 	[key: string]: unknown;
 }
 
+/** A resource as described by a server's resources/list response. */
+export interface McpResourceDescriptor {
+	uri: string;
+	name?: string;
+	description?: string;
+	mimeType?: string;
+}
+
+/** One content chunk of a resources/read result — text or base64 blob. */
+export interface McpResourceContent {
+	uri?: string;
+	mimeType?: string;
+	text?: string;
+	blob?: string;
+}
+
+export interface McpReadResourceResult {
+	contents?: McpResourceContent[];
+	[key: string]: unknown;
+}
+
 /** Parse one line of stdio output into a JSON-RPC message, or null if unparseable. */
 export function parseRpcLine(line: string): JsonRpcResponse | JsonRpcNotification | null {
 	const trimmed = line.trim();

src/mcp/stdio-client.ts

@@ -6,6 +6,8 @@ import {
 	type JsonRpcResponse,
 	MCP_PROTOCOL_VERSION,
 	type McpCallToolResult,
+	type McpReadResourceResult,
+	type McpResourceDescriptor,
 	type McpToolDescriptor,
 	parseRpcLine,
 } from "./protocol.js";
@@ -89,6 +91,23 @@ export class StdioMcpClient implements McpClient {
 		return (res.result as McpCallToolResult) ?? {};
 	}
 
+	/** List resources; [] when the server lacks a resources capability. */
+	async listResources(): Promise<McpResourceDescriptor[]> {
+		try {
+			const res = await this.request("resources/list", {});
+			const result = res.result as { resources?: McpResourceDescriptor[] } | undefined;
+			return Array.isArray(result?.resources) ? result.resources : [];
+		} catch {
+			return [];
+		}
+	}
+
+	/** Read one resource by URI. */
+	async readResource(uri: string): Promise<McpReadResourceResult> {
+		const res = await this.request("resources/read", { uri });
+		return (res.result as McpReadResourceResult) ?? {};
+	}
+
 	/** Terminate the subprocess and reject any in-flight requests. */
 	close(): void {
 		if (this.closed) return;

src/permissions/store.ts

@@ -122,6 +122,9 @@ const ALWAYS_ALLOWED: ReadonlySet<string> = new Set([
 	// present_copy only surfaces a click-to-copy box in the UI — no fs,
 	// shell, or network. Prompting for it would be pure friction.
 	"present_copy",
+	// MCP resource reads are read-only fetches from already-trusted servers.
+	"list_mcp_resources",
+	"read_mcp_resource",
 ]);
 
 export interface PermissionStoreOptions {