@namzu/sdk 3.0.0 → 3.2.0

package/src/connector/mcp/__tests__/prompts-and-lifecycle.test.ts

@@ -0,0 +1,286 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { JSON_RPC_METHOD_NOT_FOUND } from '../../../constants/mcp/index.js'
+import type {
+	MCPJsonRpcMessage,
+	MCPPromptDefinition,
+	MCPPromptMessage,
+	MCPTransport,
+} from '../../../types/connector/index.js'
+import { MCPClient } from '../client.js'
+import { MCPServer } from '../server.js'
+import type { MCPServerPromptProvider, MCPServerToolProvider } from '../server.js'
+
+/**
+ * The half of MCP that is not tools.
+ *
+ * `MCPPromptDefinition` and `MCPPromptArgument` were declared when the types
+ * were written; no client method ever asked for a prompt and no server branch
+ * ever served one. `MCPLifecycleEvent` and `MCPEventListener` were declared
+ * beside them and nothing ever emitted one, so a host could learn that a
+ * server had died only by noticing calls had started failing.
+ */
+
+function fakeTransport(): {
+	transport: MCPTransport
+	sent: MCPJsonRpcMessage[]
+	deliver: (m: MCPJsonRpcMessage) => void
+} {
+	const sent: MCPJsonRpcMessage[] = []
+	let onMessage: ((m: MCPJsonRpcMessage) => void) | undefined
+	const transport: MCPTransport = {
+		connect: async () => undefined,
+		close: async () => undefined,
+		send: async (m: MCPJsonRpcMessage) => {
+			sent.push(m)
+		},
+		onMessage: (h: (m: MCPJsonRpcMessage) => void) => {
+			onMessage = h
+		},
+		onClose: () => undefined,
+		onError: () => undefined,
+	} as unknown as MCPTransport
+	return { transport, sent, deliver: (m) => onMessage?.(m) }
+}
+
+const toolProvider: MCPServerToolProvider = {
+	listTools: () => [],
+	callTool: async () => ({ content: [{ type: 'text', text: 'ok' }] }),
+}
+
+function promptProvider(over: Partial<MCPServerPromptProvider> = {}): MCPServerPromptProvider {
+	const prompts: MCPPromptDefinition[] = [
+		{
+			name: 'summarize',
+			description: 'Summarize a file',
+			arguments: [
+				{ name: 'path', required: true },
+				{ name: 'style', required: false },
+			],
+		},
+	]
+	const messages: MCPPromptMessage[] = [
+		{ role: 'user', content: { type: 'text', text: 'summarize it' } },
+	]
+	return {
+		listPrompts: () => prompts,
+		getPrompt: async () => ({ description: 'Summarize a file', messages }),
+		...over,
+	}
+}
+
+async function ask(
+	t: ReturnType<typeof fakeTransport>,
+	method: string,
+	params: Record<string, unknown> = {},
+) {
+	t.deliver({ jsonrpc: '2.0', id: 1, method, params } as MCPJsonRpcMessage)
+	await new Promise((r) => setTimeout(r, 0))
+	return t.sent.at(-1) as MCPJsonRpcMessage & {
+		result?: unknown
+		error?: { code: number; message: string }
+	}
+}
+
+describe('a server serves the prompts it publishes', () => {
+	it('lists them', async () => {
+		const t = fakeTransport()
+		const server = new MCPServer({ name: 'srv' }, toolProvider, undefined, promptProvider())
+		await server.start(t.transport)
+
+		const reply = await ask(t, 'prompts/list')
+
+		expect((reply.result as { prompts: MCPPromptDefinition[] }).prompts[0]?.name).toBe('summarize')
+	})
+
+	it('returns the messages the server composed', async () => {
+		const t = fakeTransport()
+		const server = new MCPServer({ name: 'srv' }, toolProvider, undefined, promptProvider())
+		await server.start(t.transport)
+
+		const reply = await ask(t, 'prompts/get', {
+			name: 'summarize',
+			arguments: { path: 'a.ts' },
+		})
+
+		expect((reply.result as { messages: MCPPromptMessage[] }).messages[0]?.content).toEqual({
+			type: 'text',
+			text: 'summarize it',
+		})
+	})
+
+	it('advertises the capability only when something is behind it', async () => {
+		const withPrompts = fakeTransport()
+		const without = fakeTransport()
+		const a = new MCPServer({ name: 'a' }, toolProvider, undefined, promptProvider())
+		const b = new MCPServer({ name: 'b' }, toolProvider)
+		await a.start(withPrompts.transport)
+		await b.start(without.transport)
+
+		const withCap = await ask(withPrompts, 'initialize')
+		const withoutCap = await ask(without, 'initialize')
+
+		// A capability advertised without a provider is a promise the next
+		// call breaks.
+		expect(
+			(withCap.result as { capabilities: Record<string, unknown> }).capabilities.prompts,
+		).toBeDefined()
+		expect(
+			(withoutCap.result as { capabilities: Record<string, unknown> }).capabilities.prompts,
+		).toBeUndefined()
+	})
+
+	it('refuses a required argument the caller omitted', async () => {
+		const t = fakeTransport()
+		const server = new MCPServer({ name: 'srv' }, toolProvider, undefined, promptProvider())
+		await server.start(t.transport)
+
+		const reply = await ask(t, 'prompts/get', { name: 'summarize', arguments: {} })
+
+		// Checked from the declaration, so every provider does not have to
+		// re-implement it or forget to.
+		expect(reply.error?.message).toContain('path')
+	})
+
+	it('accepts an optional argument being absent', async () => {
+		const t = fakeTransport()
+		const server = new MCPServer({ name: 'srv' }, toolProvider, undefined, promptProvider())
+		await server.start(t.transport)
+
+		const reply = await ask(t, 'prompts/get', {
+			name: 'summarize',
+			arguments: { path: 'a.ts' },
+		})
+
+		expect(reply.error).toBeUndefined()
+	})
+
+	it('refuses a prompt it does not publish', async () => {
+		const t = fakeTransport()
+		const server = new MCPServer({ name: 'srv' }, toolProvider, undefined, promptProvider())
+		await server.start(t.transport)
+
+		const reply = await ask(t, 'prompts/get', { name: 'nonexistent' })
+
+		expect(reply.error?.message).toContain('nonexistent')
+	})
+})
+
+describe('"none" and "not here" are different answers', () => {
+	it('says method-not-found for prompts when there is no provider', async () => {
+		const t = fakeTransport()
+		const server = new MCPServer({ name: 'srv' }, toolProvider)
+		await server.start(t.transport)
+
+		const reply = await ask(t, 'prompts/list')
+
+		expect(reply.error?.code).toBe(JSON_RPC_METHOD_NOT_FOUND)
+	})
+
+	it('says method-not-found for resources when there is no provider', async () => {
+		const t = fakeTransport()
+		const server = new MCPServer({ name: 'srv' }, toolProvider)
+		await server.start(t.transport)
+
+		const reply = await ask(t, 'resources/list')
+
+		// This used to answer `{ resources: [] }` for a capability
+		// `initialize` never advertised — telling a client "none" where the
+		// truth is "not here". The two send a client in opposite directions.
+		expect(reply.error?.code).toBe(JSON_RPC_METHOD_NOT_FOUND)
+	})
+
+	it('uses the protocol code for an unknown method, not a generic failure', async () => {
+		const t = fakeTransport()
+		const server = new MCPServer({ name: 'srv' }, toolProvider)
+		await server.start(t.transport)
+
+		const reply = await ask(t, 'completely/unknown')
+
+		expect(reply.error?.code).toBe(JSON_RPC_METHOD_NOT_FOUND)
+	})
+
+	it('still reports a provider failure as an internal error', async () => {
+		const t = fakeTransport()
+		const server = new MCPServer(
+			{ name: 'srv' },
+			toolProvider,
+			undefined,
+			promptProvider({
+				listPrompts: () => {
+					throw new Error('provider exploded')
+				},
+			}),
+		)
+		await server.start(t.transport)
+
+		const reply = await ask(t, 'prompts/list')
+
+		// A broken provider is not the same as an unimplemented method, and
+		// collapsing the two would tell a client to stop asking for something
+		// that works tomorrow.
+		expect(reply.error?.code).toBe(-32603)
+	})
+})
+
+describe('a client says out loud what it already knew', () => {
+	function failingClient() {
+		// `connect` failing is the simplest path that actually emits. A
+		// never-connected client's `disconnect` returns early and emits
+		// nothing — an easy way to write a test that proves nothing, which is
+		// what the first version of these did.
+		return new MCPClient({
+			serverName: 'srv',
+			transport: { type: 'stdio', command: 'definitely-not-a-real-binary-xyz', args: [] },
+		})
+	}
+
+	/**
+	 * Covered here: the transport-error emitter. `connect`'s own catch emits
+	 * the same event and is NOT pinned — a spawn failure surfaces through the
+	 * transport first, so the catch is the second line of defence rather than
+	 * the path this reaches. Reaching it needs a connection that opens and
+	 * then fails negotiation, which this fake cannot stage; said rather than
+	 * left for a mutation run to discover.
+	 */
+	it('reports a failure to whoever is listening', async () => {
+		const client = failingClient()
+		const seen: string[] = []
+		client.onLifecycle((e) => seen.push(e.type))
+
+		await client.connect().catch(() => undefined)
+
+		expect(seen).toContain('mcp_client_error')
+	})
+
+	it('stops reporting once the listener unsubscribes', async () => {
+		const client = failingClient()
+		const seen = vi.fn()
+
+		const off = client.onLifecycle(seen)
+		off()
+		await client.connect().catch(() => undefined)
+
+		// `onNotification` returns nothing, so a listener registered there
+		// cannot be removed and keeps a disposed host object alive for as
+		// long as the client. This is that bug not repeated.
+		expect(seen).not.toHaveBeenCalled()
+	})
+
+	it('leaves other listeners working when one throws', async () => {
+		const client = failingClient()
+		const survivor = vi.fn()
+		client.onLifecycle(() => {
+			throw new Error('observer bug')
+		})
+		client.onLifecycle(survivor)
+
+		await client.connect().catch(() => undefined)
+
+		// These fire from inside transport callbacks and from `connect`'s
+		// failure path, so an escaping exception would surface as a connection
+		// error — blaming the server for a bug in the host's own observer, and
+		// silencing every listener registered after the broken one.
+		expect(survivor).toHaveBeenCalled()
+	})
+})

package/src/connector/mcp/client.ts

@@ -3,8 +3,12 @@ import type {
 	MCPClientState,
 	MCPConnectionStatus,
 	MCPContentBlock,
+	MCPEventListener,
 	MCPInitializeResult,
 	MCPJsonRpcMessage,
+	MCPLifecycleEvent,
+	MCPPromptDefinition,
+	MCPPromptMessage,
 	MCPResource,
 	MCPResourceTemplate,
 	MCPServerCapabilities,
@@ -52,6 +56,7 @@ export class MCPClient {
 	private nextRequestId = 1
 	private notificationHandlers: Array<(method: string, params?: Record<string, unknown>) => void> =
 		[]
+	private lifecycleListeners: MCPEventListener[] = []
 	private log: Logger
 	private readonly config: MCPClientConfig
 
@@ -74,12 +79,14 @@ export class MCPClient {
 			this.transport.onClose(() => {
 				this.status = 'disconnected'
 				this.log.info('MCP transport closed')
+				this.emitLifecycle({ type: 'mcp_client_disconnected', clientId: this.id })
 				this.rejectAllPending(`MCP transport to "${this.config.serverName}" closed`)
 			})
 			this.transport.onError((err) => {
 				this.status = 'error'
 				this.error = err.message
 				this.log.error('MCP transport error', { error: err.message })
+				this.emitLifecycle({ type: 'mcp_client_error', clientId: this.id, error: err.message })
 				this.rejectAllPending(`MCP transport to "${this.config.serverName}" failed: ${err.message}`)
 			})
 
@@ -116,6 +123,11 @@ export class MCPClient {
 
 			this.status = 'connected'
 			this.connectedAt = Date.now()
+			this.emitLifecycle({
+				type: 'mcp_client_connected',
+				clientId: this.id,
+				serverName: this.config.serverName,
+			})
 			this.log.info(`Connected to MCP server: ${result.serverInfo.name}`)
 
 			return result
@@ -123,6 +135,7 @@ export class MCPClient {
 			this.status = 'error'
 			this.error = toErrorMessage(err)
 			this.log.error('MCP connection failed', { error: this.error })
+			this.emitLifecycle({ type: 'mcp_client_error', clientId: this.id, error: this.error })
 			throw err
 		}
 	}
@@ -136,6 +149,7 @@ export class MCPClient {
 		this.status = 'disconnected'
 		this.connectedAt = undefined
 		this.log.info('MCP client disconnected')
+		this.emitLifecycle({ type: 'mcp_client_disconnected', clientId: this.id })
 	}
 
 	isConnected(): boolean {
@@ -181,6 +195,48 @@ export class MCPClient {
 		return result.contents
 	}
 
+	/**
+	 * The prompts a server publishes.
+	 *
+	 * A prompt is the server's own wording for a task it knows how to set
+	 * up — the half of MCP that is not tools. `MCPPromptDefinition` and
+	 * `MCPPromptArgument` were declared when the types were written and no
+	 * method ever asked for one, so a server offering prompts had them
+	 * silently ignored.
+	 *
+	 * Paged through the same reader as every other list, which is the point
+	 * of it being generic: a server that pages its prompts does not get
+	 * silently truncated to page one the way the tool list once was.
+	 */
+	async listPrompts(): Promise<MCPPromptDefinition[]> {
+		this.requireConnected()
+		return await this.listAllPages('prompts/list', 'prompts')
+	}
+
+	/**
+	 * Fetch one prompt, with its arguments filled in.
+	 *
+	 * Returns the messages the SERVER composed. They are data to be shown to
+	 * a model, never instructions to this client: a prompt arriving from a
+	 * remote server is exactly the untrusted-content case, and treating its
+	 * text as direction would let a server steer the agent by publishing a
+	 * prompt nobody asked to run.
+	 */
+	async getPrompt(
+		name: string,
+		args?: Record<string, string>,
+	): Promise<{ description?: string; messages: MCPPromptMessage[] }> {
+		this.requireConnected()
+		const result = (await this.request('prompts/get', {
+			name,
+			arguments: args ?? {},
+		})) as { description?: string; messages?: MCPPromptMessage[] }
+		return {
+			...(result.description !== undefined ? { description: result.description } : {}),
+			messages: result.messages ?? [],
+		}
+	}
+
 	async listResourceTemplates(): Promise<MCPResourceTemplate[]> {
 		this.requireConnected()
 		return await this.listAllPages('resources/templates/list', 'resourceTemplates')
@@ -231,6 +287,45 @@ export class MCPClient {
 		this.notificationHandlers.push(handler)
 	}
 
+	/**
+	 * Watch this client come up, go down, or fail.
+	 *
+	 * `MCPLifecycleEvent` and `MCPEventListener` were declared with the rest
+	 * of the MCP types and nothing ever emitted one, so a host could observe
+	 * a server dying only by noticing that calls had started failing. The
+	 * four transitions below already existed and already mutated `status`;
+	 * this adds no state, it just says out loud what the client already
+	 * knew.
+	 *
+	 * Returns an unsubscribe. `onNotification` above does not, which is the
+	 * bug this avoids repeating: a listener that cannot be removed keeps a
+	 * disposed host object alive for as long as the client lives.
+	 */
+	onLifecycle(listener: MCPEventListener): () => void {
+		this.lifecycleListeners.push(listener)
+		return () => {
+			const index = this.lifecycleListeners.indexOf(listener)
+			if (index >= 0) this.lifecycleListeners.splice(index, 1)
+		}
+	}
+
+	/**
+	 * A listener that throws must not take the transport down with it.
+	 *
+	 * These fire from inside transport callbacks and from the failure path
+	 * of `connect`, so an exception here would surface as a connection
+	 * error — blaming the server for a bug in the host's own observer.
+	 */
+	private emitLifecycle(event: MCPLifecycleEvent): void {
+		for (const listener of this.lifecycleListeners) {
+			try {
+				listener(event)
+			} catch (err) {
+				this.log.warn('MCP lifecycle listener threw', { error: toErrorMessage(err) })
+			}
+		}
+	}
+
 	private createTransport(config: MCPTransportUnion): MCPTransport {
 		switch (config.type) {
 			case 'stdio':

package/src/connector/mcp/discovery.ts

@@ -38,7 +38,18 @@ export class MCPToolDiscovery {
 	private clients: MCPClient[]
 	private log: Logger
 	private options: MCPToolDiscoveryOptions
-	/** Last admitted tool set per client, for drift detection. */
+	/**
+	 * Last admitted tool set per SERVER, for drift detection.
+	 *
+	 * Keyed by server name rather than client id, and the difference is the
+	 * whole point. A client id is minted per connection, so on the path a
+	 * real MCP server actually takes — a plugin enabling, connecting, and
+	 * being disabled again — every discovery was the first one that id had
+	 * ever seen, and drift could not fire however many times the server
+	 * changed underneath. The threat is a server that advertises something
+	 * benign when a host approves it and something else afterwards, which is
+	 * a property of the SERVER across connections.
+	 */
 	private lastSeen = new Map<string, MCPToolDefinition[]>()
 
 	constructor(clients: MCPClient[], options: MCPToolDiscoveryOptions = {}) {
@@ -53,7 +64,11 @@ export class MCPToolDiscovery {
 
 	removeClient(clientId: string): void {
 		this.clients = this.clients.filter((c) => c.id !== clientId)
-		this.lastSeen.delete(clientId)
+		// The remembered tool set is deliberately NOT forgotten. Dropping it on
+		// disconnect is what made the rug pull invisible: disable, swap the
+		// server's tools, enable again, and the next discovery had nothing to
+		// compare against. What is remembered is a name and a list of tool
+		// shapes, so keeping it costs almost nothing.
 	}
 
 	async discoverAll(): Promise<MCPDiscoveredTool[]> {
@@ -119,8 +134,8 @@ export class MCPToolDiscovery {
 	}
 
 	private detectDrift(clientId: string, serverName: string, admitted: MCPToolDefinition[]): void {
-		const previous = this.lastSeen.get(clientId)
-		this.lastSeen.set(clientId, admitted)
+		const previous = this.lastSeen.get(serverName)
+		this.lastSeen.set(serverName, admitted)
 		if (!previous) return
 
 		const drift = diffTools(previous, admitted)

package/src/connector/mcp/index.ts

@@ -17,8 +17,12 @@ export { MCPToolDiscovery } from './discovery.js'
 
 export { MCPConnectorBridge } from '../../bridge/mcp/connector/adapter.js'
 
-export { MCPServer } from './server.js'
-export type { MCPServerToolProvider, MCPServerResourceProvider } from './server.js'
+export { MCPServer, MCPMethodNotFound } from './server.js'
+export type {
+	MCPServerToolProvider,
+	MCPServerResourceProvider,
+	MCPServerPromptProvider,
+} from './server.js'
 
 export type { MCPToolDiscoveryOptions } from './discovery.js'
 export { applyToolPolicy, diffTools, hasDrift, toolsHash } from './policy.js'

package/src/connector/mcp/server.ts

@@ -1,3 +1,4 @@
+import { JSON_RPC_METHOD_NOT_FOUND } from '../../constants/mcp/index.js'
 import type {
 	MCPContentBlock,
 	MCPJsonRpcMessage,
@@ -9,11 +10,27 @@ import type {
 	MCPToolResult,
 	MCPTransport,
 } from '../../types/connector/index.js'
+import type { MCPPromptDefinition, MCPPromptMessage } from '../../types/connector/index.js'
 import type { MCPServerId } from '../../types/ids/index.js'
 import { toErrorMessage } from '../../utils/error.js'
 import { generateMCPServerId } from '../../utils/id.js'
 import { type Logger, getRootLogger } from '../../utils/logger.js'
 
+/**
+ * A method this server does not implement.
+ *
+ * Carried as its own error so the dispatcher can answer with the protocol's
+ * own code instead of a generic internal error. `-32603` tells a client the
+ * server broke; `-32601` tells it the server does not do this — and only the
+ * second lets a client stop asking rather than retry.
+ */
+export class MCPMethodNotFound extends Error {
+	constructor(readonly method: string) {
+		super(`Method not found: ${method}`)
+		this.name = 'MCPMethodNotFound'
+	}
+}
+
 export interface MCPServerToolProvider {
 	listTools(): MCPToolDefinition[]
 	callTool(name: string, args?: Record<string, unknown>): Promise<MCPToolResult>
@@ -24,11 +41,27 @@ export interface MCPServerResourceProvider {
 	readResource(uri: string): Promise<MCPContentBlock[]>
 }
 
+/**
+ * Prompts this server publishes.
+ *
+ * Injected as an interface like the other two, so the server owns dispatch
+ * and the host owns content. `MCPPromptDefinition` existed in the types
+ * from the start with no way to serve one.
+ */
+export interface MCPServerPromptProvider {
+	listPrompts(): MCPPromptDefinition[]
+	getPrompt(
+		name: string,
+		args?: Record<string, string>,
+	): Promise<{ description?: string; messages: MCPPromptMessage[] }>
+}
+
 export class MCPServer {
 	readonly id: MCPServerId
 	private config: MCPServerConfig
 	private toolProvider: MCPServerToolProvider
 	private resourceProvider?: MCPServerResourceProvider
+	private promptProvider?: MCPServerPromptProvider
 	private transport: MCPTransport | null = null
 	private running = false
 	private connectedClients = 0
@@ -39,11 +72,13 @@ export class MCPServer {
 		config: MCPServerConfig,
 		toolProvider: MCPServerToolProvider,
 		resourceProvider?: MCPServerResourceProvider,
+		promptProvider?: MCPServerPromptProvider,
 	) {
 		this.id = config.id ?? generateMCPServerId()
 		this.config = config
 		this.toolProvider = toolProvider
 		this.resourceProvider = resourceProvider
+		this.promptProvider = promptProvider
 		this.log = getRootLogger().child({ component: 'MCPServer', serverId: this.id })
 	}
 
@@ -100,7 +135,8 @@ export class MCPServer {
 			const result = await this.dispatch(message.method, message.params ?? {})
 			await this.respond(message.id, result)
 		} catch (err) {
-			await this.respondError(message.id, -32603, toErrorMessage(err))
+			const code = err instanceof MCPMethodNotFound ? JSON_RPC_METHOD_NOT_FOUND : -32603
+			await this.respondError(message.id, code, toErrorMessage(err))
 		}
 	}
 
@@ -116,10 +152,14 @@ export class MCPServer {
 				return this.handleResourcesList()
 			case 'resources/read':
 				return this.handleResourcesRead(params)
+			case 'prompts/list':
+				return this.handlePromptsList()
+			case 'prompts/get':
+				return this.handlePromptsGet(params)
 			case 'ping':
 				return {}
 			default:
-				throw new Error(`Unknown method: ${method}`)
+				throw new MCPMethodNotFound(method)
 		}
 	}
 
@@ -138,6 +178,13 @@ export class MCPServer {
 			capabilities.resources = { subscribe: false, listChanged: false }
 		}
 
+		// Declared only when there is something behind it, matching resources
+		// above. A capability advertised without a provider is a promise the
+		// next call breaks.
+		if (this.promptProvider) {
+			capabilities.prompts = { listChanged: false }
+		}
+
 		return {
 			protocolVersion: '2024-11-05',
 			capabilities,
@@ -166,13 +213,64 @@ export class MCPServer {
 		return this.toolProvider.callTool(name, args)
 	}
 
+	/**
+	 * An empty list is what a server with NO resources returns. A server
+	 * that cannot serve resources at all has to say so differently.
+	 *
+	 * This used to answer `{ resources: [] }` when no provider was
+	 * configured, for a capability `initialize` never advertised — so a
+	 * client that asked anyway was told, in the protocol's own vocabulary,
+	 * that the answer is "none" rather than "not here". The two send a
+	 * client in opposite directions: one stops asking, the other looks for
+	 * the resource somewhere else.
+	 */
 	private handleResourcesList(): { resources: MCPResource[] } {
 		if (!this.resourceProvider) {
-			return { resources: [] }
+			throw new MCPMethodNotFound('resources/list')
 		}
 		return { resources: this.resourceProvider.listResources() }
 	}
 
+	private handlePromptsList(): { prompts: MCPPromptDefinition[] } {
+		if (!this.promptProvider) {
+			throw new MCPMethodNotFound('prompts/list')
+		}
+		return { prompts: this.promptProvider.listPrompts() }
+	}
+
+	private async handlePromptsGet(
+		params: Record<string, unknown>,
+	): Promise<{ description?: string; messages: MCPPromptMessage[] }> {
+		if (!this.promptProvider) {
+			throw new MCPMethodNotFound('prompts/get')
+		}
+		const name = params.name as string
+		if (!name) {
+			throw new Error('prompts/get requires a "name"')
+		}
+		const args = (params.arguments as Record<string, string> | undefined) ?? {}
+
+		// Required arguments are checked HERE rather than left to the
+		// provider. A prompt declares them, so a missing one is answerable
+		// from the declaration alone, and every provider would otherwise
+		// re-implement the same check or forget to.
+		const declared = this.promptProvider.listPrompts().find((p) => p.name === name)
+		if (!declared) {
+			throw new Error(`Unknown prompt: ${name}`)
+		}
+		const missing = (declared.arguments ?? [])
+			.filter((a) => a.required === true)
+			.map((a) => a.name)
+			.filter((n) => args[n] === undefined)
+		if (missing.length > 0) {
+			throw new Error(
+				`prompts/get "${name}" is missing required argument(s): ${missing.join(', ')}`,
+			)
+		}
+
+		return this.promptProvider.getPrompt(name, args)
+	}
+
 	private async handleResourcesRead(
 		params: Record<string, unknown>,
 	): Promise<{ contents: MCPContentBlock[] }> {