@abide/abide 0.45.0 → 0.47.0

package/src/abideLsp.ts

@@ -1,4 +1,3 @@
-import { fileURLToPath, pathToFileURL } from 'node:url'
 import ts from 'typescript'
 import { ABIDE_SEMANTIC_TOKENS_LEGEND } from './lib/ui/compile/ABIDE_SEMANTIC_TOKENS_LEGEND.ts'
 import type {
@@ -77,7 +76,7 @@ export async function abideLsp({ cwd }: { cwd: string }): Promise<void> {
             jsonrpc: '2.0',
             method: 'textDocument/publishDiagnostics',
             params: {
-                uri: pathToFileURL(path).href,
+                uri: Bun.pathToFileURL(path).href,
                 diagnostics: serviceFor(path)
                     .diagnostics(path)
                     .map((diagnostic) => toLspDiagnostic(text, diagnostic)),
@@ -109,7 +108,7 @@ export async function abideLsp({ cwd }: { cwd: string }): Promise<void> {
             case 'textDocument/didOpen': {
                 const { uri, text } = message.params.textDocument
                 if (isAbide(uri)) {
-                    const path = fileURLToPath(uri)
+                    const path = Bun.fileURLToPath(uri)
                     documentText.set(path, text)
                     serviceFor(path).update(path, text)
                     publish(path)
@@ -119,7 +118,7 @@ export async function abideLsp({ cwd }: { cwd: string }): Promise<void> {
             case 'textDocument/didChange': {
                 const { uri } = message.params.textDocument
                 if (isAbide(uri)) {
-                    const path = fileURLToPath(uri)
+                    const path = Bun.fileURLToPath(uri)
                     const text = message.params.contentChanges.at(-1)?.text ?? ''
                     documentText.set(path, text)
                     serviceFor(path).update(path, text)
@@ -130,7 +129,7 @@ export async function abideLsp({ cwd }: { cwd: string }): Promise<void> {
             case 'textDocument/didSave': {
                 const { uri } = message.params.textDocument
                 if (isAbide(uri)) {
-                    publish(fileURLToPath(uri))
+                    publish(Bun.fileURLToPath(uri))
                 }
                 return
             }
@@ -138,10 +137,10 @@ export async function abideLsp({ cwd }: { cwd: string }): Promise<void> {
                 /* A request: always answer (null when there's nothing to show) so
                    the editor isn't left waiting. */
                 const { uri } = message.params.textDocument
-                const text = isAbide(uri) ? (documentText.get(fileURLToPath(uri)) ?? '') : ''
+                const text = isAbide(uri) ? (documentText.get(Bun.fileURLToPath(uri)) ?? '') : ''
                 const info = isAbide(uri)
-                    ? serviceFor(fileURLToPath(uri)).quickInfo(
-                          fileURLToPath(uri),
+                    ? serviceFor(Bun.fileURLToPath(uri)).quickInfo(
+                          Bun.fileURLToPath(uri),
                           positionToOffset(text, message.params.position),
                       )
                     : undefined
@@ -156,9 +155,9 @@ export async function abideLsp({ cwd }: { cwd: string }): Promise<void> {
                 const { uri } = message.params.textDocument
                 const data = isAbide(uri)
                     ? componentSemanticTokens(
-                          serviceFor(fileURLToPath(uri)),
-                          fileURLToPath(uri),
-                          documentText.get(fileURLToPath(uri)) ?? '',
+                          serviceFor(Bun.fileURLToPath(uri)),
+                          Bun.fileURLToPath(uri),
+                          documentText.get(Bun.fileURLToPath(uri)) ?? '',
                       )
                     : []
                 send({ jsonrpc: '2.0', id: message.id, result: { data } })
@@ -167,7 +166,7 @@ export async function abideLsp({ cwd }: { cwd: string }): Promise<void> {
             case 'textDocument/didClose': {
                 const { uri } = message.params.textDocument
                 if (isAbide(uri)) {
-                    const path = fileURLToPath(uri)
+                    const path = Bun.fileURLToPath(uri)
                     serviceFor(path).close(path)
                     documentText.delete(path)
                     send({

package/src/abideResolverPlugin.ts

@@ -381,11 +381,16 @@ export function abideResolverPlugin({
                 so page imports resolve identically on both sides.
                 */
                 if (target === 'client') {
-                    /* A durable rpc (`outbox: true`) gets the third arg so its client proxy
-                       parks unreachable calls onto the outbox. */
-                    const durableArg = prepared.durable ? ', { outbox: true }' : ''
+                    /* Build-time flags on the client proxy stub: `outbox: true` parks
+                       unreachable calls; `streaming: true` (handler returns jsonl()/sse())
+                       makes the bare call return the Subscribable directly. */
+                    const flags = [
+                        prepared.durable ? 'outbox: true' : undefined,
+                        prepared.streaming ? 'streaming: true' : undefined,
+                    ].filter(Boolean)
+                    const optsArg = flags.length > 0 ? `, { ${flags.join(', ')} }` : ''
                     const contents = `import { remoteProxy as __abideRemoteProxy__ } from '${importName}/ui/remoteProxy';
-export const ${prepared.exportName} = __abideRemoteProxy__(${JSON.stringify(prepared.method)}, ${JSON.stringify(url)}${durableArg});
+export const ${prepared.exportName} = __abideRemoteProxy__(${JSON.stringify(prepared.method)}, ${JSON.stringify(url)}${optsArg});
 `
                     return { contents, loader: 'ts' }
                 }

package/src/lib/bundle/disconnected.abide

@@ -1,4 +1,7 @@
 <script>
+import { state } from '@abide/abide/ui/state'
+import { effect } from '@abide/abide/ui/effect'
+
 /*
   Default bundle connect screen (abide-ui). The launcher serves this (logo baked in
   at build time, app title injected at runtime) instead of a blank window; override

package/src/lib/cli/printCommandHelp.ts

@@ -0,0 +1,43 @@
+import type { CliManifest } from './types/CliManifest.ts'
+
+/*
+Per-command help (`<cmd> --help`): the command's method/url, its description, and
+the flags derived from its JSON Schema. Output goes to stdout; the caller exits
+zero after printing. Top-level help (the command listing) lives in
+`printTopLevelHelp`.
+*/
+export function printCommandHelp(programName: string, name: string, manifest: CliManifest): void {
+    const entry = manifest[name]
+    if (!entry) {
+        console.log(`unknown command: ${name}`)
+        return
+    }
+    console.log(`usage: ${programName} ${name} [--flags]\n`)
+    console.log(`  ${entry.method} ${entry.url}\n`)
+    const schema = entry.jsonSchema
+    const commandDescription = schema?.description as string | undefined
+    if (commandDescription) {
+        console.log(`${commandDescription}\n`)
+    }
+    const properties =
+        (schema?.properties as
+            | Record<string, { type?: string; description?: string }>
+            | undefined) ?? {}
+    const required = new Set((schema?.required as string[] | undefined) ?? [])
+    if (Object.keys(properties).length === 0) {
+        console.log('flags: (none)')
+    } else {
+        console.log('flags:')
+        for (const [key, value] of Object.entries(properties)) {
+            const tag =
+                value.type === 'boolean'
+                    ? `--${key} / --no-${key}`
+                    : `--${key} <${value.type ?? 'value'}>`
+            const requiredTag = required.has(key) ? ' (required)' : ''
+            const description = value.description ? ` — ${value.description}` : ''
+            console.log(`  ${tag.padEnd(28)}${requiredTag}${description}`)
+        }
+    }
+    console.log('\n  --json <object>          full args bag as JSON (overrides flags)')
+    console.log('  (stdin)                  pipe a JSON object as the args bag')
+}

package/src/lib/cli/printSessionHelp.ts

@@ -1,4 +1,5 @@
-import { printCommandHelp, printTopLevelHelp } from './printHelp.ts'
+import { printCommandHelp } from './printCommandHelp.ts'
+import { printTopLevelHelp } from './printTopLevelHelp.ts'
 import type { CliManifest } from './types/CliManifest.ts'
 
 /*

package/src/lib/cli/{printHelp.ts → printTopLevelHelp.ts}

@@ -26,10 +26,9 @@ function flagSignature(jsonSchema: CliManifestEntry['jsonSchema']): string {
 }
 
 /*
-Top-level help (no subcommand) lists every available command with a
-one-line summary. Per-command help (`<cmd> --help`) prints the flags
-derived from the command's JSON Schema. Output goes to stdout in both
-cases; the caller exits zero after printing.
+Top-level help (no subcommand) lists every available command with a one-line
+summary. Per-command help lives in `printCommandHelp`. Output goes to stdout;
+the caller exits zero after printing.
 */
 export function printTopLevelHelp(
     programName: string,
@@ -81,39 +80,3 @@ export function printTopLevelHelp(
         printTrimmed(footer)
     }
 }
-
-export function printCommandHelp(programName: string, name: string, manifest: CliManifest): void {
-    const entry = manifest[name]
-    if (!entry) {
-        console.log(`unknown command: ${name}`)
-        return
-    }
-    console.log(`usage: ${programName} ${name} [--flags]\n`)
-    console.log(`  ${entry.method} ${entry.url}\n`)
-    const schema = entry.jsonSchema
-    const commandDescription = schema?.description as string | undefined
-    if (commandDescription) {
-        console.log(`${commandDescription}\n`)
-    }
-    const properties =
-        (schema?.properties as
-            | Record<string, { type?: string; description?: string }>
-            | undefined) ?? {}
-    const required = new Set((schema?.required as string[] | undefined) ?? [])
-    if (Object.keys(properties).length === 0) {
-        console.log('flags: (none)')
-    } else {
-        console.log('flags:')
-        for (const [key, value] of Object.entries(properties)) {
-            const tag =
-                value.type === 'boolean'
-                    ? `--${key} / --no-${key}`
-                    : `--${key} <${value.type ?? 'value'}>`
-            const requiredTag = required.has(key) ? ' (required)' : ''
-            const description = value.description ? ` — ${value.description}` : ''
-            console.log(`  ${tag.padEnd(28)}${requiredTag}${description}`)
-        }
-    }
-    console.log('\n  --json <object>          full args bag as JSON (overrides flags)')
-    console.log('  (stdin)                  pipe a JSON object as the args bag')
-}

package/src/lib/cli/runCli.ts

@@ -4,7 +4,8 @@ import { messageFromError } from '../shared/messageFromError.ts'
 import { connectToServer } from './connectToServer.ts'
 import { dispatchCommand } from './dispatchCommand.ts'
 import { loadEnvFromBinaryDir } from './loadEnvFromBinaryDir.ts'
-import { printCommandHelp, printTopLevelHelp } from './printHelp.ts'
+import { printCommandHelp } from './printCommandHelp.ts'
+import { printTopLevelHelp } from './printTopLevelHelp.ts'
 import { printTrimmed } from './printTrimmed.ts'
 import { resolveCliTarget } from './resolveCliTarget.ts'
 import { runSession } from './runSession.ts'

package/src/lib/mcp/buildPrompts.ts

@@ -0,0 +1,25 @@
+import { promptRegistry } from '../server/prompts/promptRegistry.ts'
+import type { PromptDescriptor } from './types/PromptDescriptor.ts'
+
+/*
+MCP prompts derived from src/mcp/prompts. Arguments come from the JSON
+Schema the resolver built from each prompt's frontmatter `arguments` list
+(top-level properties + required flags); the model fills them in and the
+framework interpolates them into the body on getPrompt.
+*/
+export function buildPrompts(): PromptDescriptor[] {
+    return Array.from(promptRegistry.values()).map((entry) => {
+        const jsonSchema = entry.jsonSchema ?? {}
+        const properties = (jsonSchema.properties ?? {}) as Record<string, { description?: string }>
+        const required = new Set((jsonSchema.required as string[] | undefined) ?? [])
+        return {
+            name: entry.prompt.name,
+            ...(entry.prompt.description ? { description: entry.prompt.description } : {}),
+            arguments: Object.entries(properties).map(([argName, prop]) => ({
+                name: argName,
+                ...(prop?.description ? { description: prop.description } : {}),
+                required: required.has(argName),
+            })),
+        }
+    })
+}

package/src/lib/mcp/dispatchMcpRequest.ts

@@ -1,7 +1,9 @@
 import { ensureRegistriesLoaded } from '../server/runtime/registryManifests.ts'
 import { messageFromError } from '../shared/messageFromError.ts'
-import { getMcpResourceServer } from './mcpResourceServerSlot.ts'
-import { buildPrompts, buildTools, callTool, renderPrompt } from './mcpSurface.ts'
+import { buildPrompts } from './buildPrompts.ts'
+import { mcpResourceServerSlot } from './mcpResourceServerSlot.ts'
+import { mcpTools } from './mcpTools.ts'
+import { renderPrompt } from './renderPrompt.ts'
 import type { JsonRpcRequest } from './types/JsonRpcRequest.ts'
 import type { JsonRpcResponse } from './types/JsonRpcResponse.ts'
 import type { McpServerOptions } from './types/McpServerOptions.ts'
@@ -108,7 +110,7 @@ async function dispatchMethod(
             case 'ping':
                 return jsonRpcOk(id, {})
             case 'tools/list':
-                return jsonRpcOk(id, { tools: buildTools() })
+                return jsonRpcOk(id, { tools: mcpTools.list() })
             case 'tools/call': {
                 const params = envelope.params as
                     | { name?: string; arguments?: Record<string, unknown> }
@@ -116,10 +118,10 @@ async function dispatchMethod(
                 if (!params?.name) {
                     return jsonRpcError(id, -32602, 'Missing tool name')
                 }
-                return jsonRpcOk(id, await callTool(params.name, params.arguments, request))
+                return jsonRpcOk(id, await mcpTools.call(params.name, params.arguments, request))
             }
             case 'resources/list': {
-                const resourceServer = getMcpResourceServer()
+                const resourceServer = mcpResourceServerSlot.server
                 return jsonRpcOk(id, {
                     resources: resourceServer ? await resourceServer.list() : [],
                 })
@@ -129,7 +131,7 @@ async function dispatchMethod(
                 if (!params?.uri) {
                     return jsonRpcError(id, -32602, 'Missing resource uri')
                 }
-                const resourceServer = getMcpResourceServer()
+                const resourceServer = mcpResourceServerSlot.server
                 const contents = resourceServer ? await resourceServer.read(params.uri) : undefined
                 if (!contents) {
                     return jsonRpcError(id, -32602, `unknown resource: ${params.uri}`)

package/src/lib/mcp/mcpResourceServerSlot.ts

@@ -3,16 +3,11 @@ import type { McpResourceServer } from './types/McpResourceServer.ts'
 /*
 Process-wide slot for the MCP resource server. createServer assigns it at
 boot; dispatchMcpRequest reads it on resources/list + resources/read. Mirrors
-the registryManifests slot — the default MCP server is constructed in the
-abide:mcp virtual with no args, so the resource server (which needs the
+the other `*Slot` seams (e.g. logTapSlot) — a single object named after the
+file with a mutable field — because the default MCP server is constructed in
+the abide:mcp virtual with no args, so the resource server (which needs the
 project's resourcesDir + embedded map) is injected out of band.
 */
-let resourceServer: McpResourceServer | undefined
-
-export function setMcpResourceServer(value: McpResourceServer): void {
-    resourceServer = value
-}
-
-export function getMcpResourceServer(): McpResourceServer | undefined {
-    return resourceServer
+export const mcpResourceServerSlot: { server: McpResourceServer | undefined } = {
+    server: undefined,
 }

package/src/lib/mcp/mcpSurface.ts

@@ -1,267 +1,28 @@
-import { promptRegistry } from '../server/prompts/promptRegistry.ts'
-import { dispatchRpcInProcess } from '../server/rpc/dispatchRpcInProcess.ts'
-import { findRpcByCommandName } from '../server/rpc/findRpcByCommandName.ts'
-import { rpcRegistry } from '../server/rpc/rpcRegistry.ts'
-import { socketOperations } from '../server/sockets/socketOperations.ts'
-import { socketRegistry } from '../server/sockets/socketRegistry.ts'
 import { abideLog } from '../shared/abideLog.ts'
-import { commandNameForUrl } from '../shared/commandNameForUrl.ts'
-import { forwardHeaders } from '../shared/forwardHeaders.ts'
-import { jsonSchemaForSchema } from '../shared/jsonSchemaForSchema.ts'
-import { messageFromError } from '../shared/messageFromError.ts'
-import { annotationsForMethod } from './annotationsForMethod.ts'
-import { getMcpResourceServer } from './mcpResourceServerSlot.ts'
-import { toolResultFromResponse } from './toolResultFromResponse.ts'
-import type { McpResourceContents } from './types/McpResourceContents.ts'
-import type { McpResourceDescriptor } from './types/McpResourceDescriptor.ts'
+import { buildPrompts } from './buildPrompts.ts'
+import { mcpResourceServerSlot } from './mcpResourceServerSlot.ts'
+import { mcpTools } from './mcpTools.ts'
+import { renderPrompt } from './renderPrompt.ts'
+import type { McpSurface } from './types/McpSurface.ts'
+import type { PromptDescriptor } from './types/PromptDescriptor.ts'
+import type { ToolDescriptor } from './types/ToolDescriptor.ts'
 
 /*
 The app's MCP surface, projected for in-process consumers. This is the single
 source of truth dispatchMcpRequest (the JSON-RPC-over-HTTP transport) and the
 in-app agent loop (abide/server/agent) both build on — the same tool/prompt/
 resource derivation, so a model reaching the app over HTTP and a model driven
-in-process can't drift on what's exposed.
+in-process can't drift on what's exposed. The individual derivations live in
+sibling modules (mcpTools / buildPrompts / renderPrompt).
 
 Internal: there is no package export. The public entry is `agent()`, which
 calls `mcpSurface(request)` to hand an engine the gated tool set.
 */
 
-export type ToolDescriptor = {
-    name: string
-    description: string
-    inputSchema: Record<string, unknown>
-    outputSchema?: Record<string, unknown>
-    annotations?: Record<string, boolean>
-}
-
-export type PromptDescriptor = {
-    name: string
-    description?: string
-    arguments: Array<{ name: string; description?: string; required: boolean }>
-}
-
-// The MCP tools/call result shape (a text content block plus optional structuredContent).
-export type ToolResult = Record<string, unknown>
-
-// A prompt rendered to plain messages — the user turn(s) that seed a conversation.
-export type PromptMessage = { role: 'user'; text: string }
-
-export type McpSurface = {
-    tools: ToolDescriptor[]
-    call(name: string, args: Record<string, unknown> | undefined): Promise<ToolResult>
-    prompts: PromptDescriptor[]
-    getPrompt(name: string, args?: Record<string, unknown>): PromptMessage[]
-    listResources(): Promise<McpResourceDescriptor[]>
-    readResource(uri: string): Promise<McpResourceContents | undefined>
-}
-
-/*
-Builds the array of MCP tool descriptors.
-
-RPCs: every rpc with clients.mcp=true becomes one tool named after the
-export's URL (folder segments joined with `-`). The HTTP method feeds the
-tool's annotations (readOnlyHint / destructiveHint / idempotentHint) so
-a model can tell a read from a write; reads auto-expose while mutating
-rpcs require an explicit clients.mcp (see resolveClientFlags). When the
-rpc declares an `outputSchema` it's advertised as the tool outputSchema.
-
-Sockets: every socket with clients.mcp=true contributes a `<base>-tail`
-read tool (recent buffered messages) and, when clientPublish is set, a
-`<base>-publish` tool.
-*/
-export function buildTools(): ToolDescriptor[] {
-    const tools: ToolDescriptor[] = []
-    for (const entry of rpcRegistry.values()) {
-        if (!entry.clients.mcp) {
-            continue
-        }
-        /*
-        Tool description favours the schema's top-level description (the
-        vendor's JSON Schema conversion carries `.describe(...)` through),
-        falling back to `method url` so the tool is still labelled when
-        the schema has none.
-        */
-        const inputSchema = jsonSchemaForSchema(entry.inputSchema)
-        const tool: ToolDescriptor = {
-            name: commandNameForUrl(entry.remote.url),
-            description:
-                (inputSchema.description as string | undefined) ??
-                `${entry.remote.method} ${entry.remote.url}`,
-            inputSchema,
-            annotations: annotationsForMethod(entry.remote.method),
-        }
-        if (entry.outputSchema) {
-            tool.outputSchema = jsonSchemaForSchema(entry.outputSchema)
-        }
-        tools.push(tool)
-    }
-    for (const entry of socketRegistry.values()) {
-        if (!entry.clients.mcp) {
-            continue
-        }
-        const payloadSchema = jsonSchemaForSchema(entry.schema)
-        for (const operation of socketOperations(entry)) {
-            if (operation.kind === 'tail') {
-                tools.push({
-                    name: operation.name,
-                    description: `Read recent messages from the "${operation.socketName}" socket`,
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            count: { type: 'number', description: 'max recent messages to return' },
-                        },
-                    },
-                    outputSchema: {
-                        type: 'object',
-                        properties: { frames: { type: 'array', items: payloadSchema } },
-                    },
-                    annotations: { readOnlyHint: true, destructiveHint: false },
-                })
-                continue
-            }
-            tools.push({
-                name: operation.name,
-                description: `Publish a message to the "${operation.socketName}" socket`,
-                inputSchema: payloadSchema,
-                annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
-            })
-        }
-    }
-    return tools
-}
-
-/*
-MCP prompts derived from src/mcp/prompts. Arguments come from the JSON
-Schema the resolver built from each prompt's frontmatter `arguments` list
-(top-level properties + required flags); the model fills them in and the
-framework interpolates them into the body on getPrompt.
-*/
-export function buildPrompts(): PromptDescriptor[] {
-    return Array.from(promptRegistry.values()).map((entry) => {
-        const jsonSchema = entry.jsonSchema ?? {}
-        const properties = (jsonSchema.properties ?? {}) as Record<string, { description?: string }>
-        const required = new Set((jsonSchema.required as string[] | undefined) ?? [])
-        return {
-            name: entry.prompt.name,
-            ...(entry.prompt.description ? { description: entry.prompt.description } : {}),
-            arguments: Object.entries(properties).map(([argName, prop]) => ({
-                name: argName,
-                ...(prop?.description ? { description: prop.description } : {}),
-                required: required.has(argName),
-            })),
-        }
-    })
-}
-
 /* MCP tool-dispatch spans, opt-in via DEBUG=abide:mcp — a model's tool call,
    wrapping the underlying rpc dispatch in the same trace. */
 const mcpLog = abideLog.channel('abide:mcp')
 
-function textResult(text: string, isError = false): ToolResult {
-    return { content: [{ type: 'text', text }], ...(isError ? { isError: true } : {}) }
-}
-
-/*
-Dispatches the socket tail / publish tools by matching the tool name
-against each mcp-exposed socket's operations (socketOperations is the same
-projection tools/list advertised, so the publish op only exists when the
-socket allows it). tail returns the retained tail (request/response
-can't hold a live subscription); publish validates against the socket
-schema and fans out. Returns undefined when the name isn't a known socket
-tool so callTool can fall through to "unknown tool".
-*/
-function callSocketTool(
-    toolName: string,
-    args: Record<string, unknown> | undefined,
-): ToolResult | undefined {
-    for (const entry of socketRegistry.values()) {
-        if (!entry.clients.mcp) {
-            continue
-        }
-        const operation = socketOperations(entry).find((op) => op.name === toolName)
-        if (!operation) {
-            continue
-        }
-        if (operation.kind === 'tail') {
-            const count = typeof args?.count === 'number' ? args.count : undefined
-            const frames = entry.snapshotTail(count)
-            return {
-                content: [{ type: 'text', text: frames.map((f) => JSON.stringify(f)).join('\n') }],
-                structuredContent: { frames },
-            }
-        }
-        try {
-            // publish() validates the payload against the socket schema and throws on failure.
-            entry.socket.publish(args)
-        } catch (error) {
-            return textResult(messageFromError(error), true)
-        }
-        return textResult('ok')
-    }
-    return undefined
-}
-
-/*
-Tool dispatch. RPC tools synthesize a Request (with forwarded auth
-headers from `inbound`) and pipe it through rpc.fetch inside the request
-scope — the same seam the HTTP router crosses, so validation, the handler,
-and the request-scoped helpers (per-call cache(), cookies(), request())
-behave identically. A handler throw is caught by the scope and framed as
-an isError tool result (via the 500 response) rather than escaping. The
-response (buffered or streaming) is framed by toolResultFromResponse.
-Socket tools (`<base>-tail` / `<base>-publish`) fall through to the socket
-dispatcher.
-*/
-export async function callTool(
-    toolName: string,
-    args: Record<string, unknown> | undefined,
-    inbound: Request,
-): Promise<ToolResult> {
-    const entry = findRpcByCommandName(toolName)
-    if (entry) {
-        /* A rpc owns this name. If it isn't mcp-exposed it's still unavailable —
-           don't fall through to a socket op that happens to share the name. */
-        if (!entry.clients.mcp) {
-            throw new Error(`unknown tool: ${toolName}`)
-        }
-        const response = await dispatchRpcInProcess({
-            remote: entry.remote,
-            args,
-            baseUrl: `${new URL(inbound.url).origin}/`,
-            headers: forwardHeaders(inbound.headers),
-        })
-        return toolResultFromResponse(response)
-    }
-    const socketResult = callSocketTool(toolName, args)
-    if (socketResult) {
-        return socketResult
-    }
-    throw new Error(`unknown tool: ${toolName}`)
-}
-
-/*
-Renders a prompt: looks it up, interpolates the caller's args, and returns its
-optional description plus the message(s) that seed a conversation. A markdown
-prompt is a single user turn whose text is the interpolated template. Throws on
-an unknown prompt name. The one place prompt rendering lives — dispatchMcpRequest
-wraps this in the prompts/get wire shape, the agent loop reads the messages plain.
-*/
-export function renderPrompt(
-    name: string,
-    args?: Record<string, unknown>,
-): { description?: string; messages: PromptMessage[] } {
-    const entry = promptRegistry.get(name)
-    if (!entry) {
-        throw new Error(`unknown prompt: ${name}`)
-    }
-    return {
-        ...(entry.prompt.description ? { description: entry.prompt.description } : {}),
-        messages: [
-            { role: 'user', text: entry.prompt.render((args ?? {}) as Record<string, string>) },
-        ],
-    }
-}
-
 /*
 Projects the app's MCP surface for an in-process consumer bound to `request`
 — tool calls forward that request's auth headers into the rpc handler, so
@@ -274,22 +35,22 @@ export function mcpSurface(request: Request): McpSurface {
     let prompts: PromptDescriptor[] | undefined
     return {
         get tools() {
-            tools ??= buildTools()
+            tools ??= mcpTools.list()
             return tools
         },
         get prompts() {
             prompts ??= buildPrompts()
             return prompts
         },
-        call: (name, args) => mcpLog.trace(`mcp ${name}`, () => callTool(name, args, request)),
+        call: (name, args) => mcpLog.trace(`mcp ${name}`, () => mcpTools.call(name, args, request)),
         /* The conversation-seeding messages, without the wire-shape wrapping. */
         getPrompt: (name, args) => renderPrompt(name, args).messages,
         async listResources() {
-            const server = getMcpResourceServer()
+            const server = mcpResourceServerSlot.server
             return server ? server.list() : []
         },
         async readResource(uri) {
-            const server = getMcpResourceServer()
+            const server = mcpResourceServerSlot.server
             return server ? server.read(uri) : undefined
         },
     }