@abide/abide 0.57.1 → 0.100.0

package/src/lib/mcp/createMcpServer.ts

@@ -1,56 +0,0 @@
-import { NO_STORE } from '../shared/CACHE_CONTROL_VALUES.ts'
-import { TEXT_PLAIN } from '../shared/TEXT_PLAIN.ts'
-import { dispatchMcpRequest } from './dispatchMcpRequest.ts'
-import type { McpServer } from './types/McpServer.ts'
-import type { McpServerOptions } from './types/McpServerOptions.ts'
-
-const DEFAULT_NAME = 'abide-app'
-const DEFAULT_VERSION = '0.0.0'
-
-/*
-Constructs an MCP server bound to the project's rpc registry. Returns an
-object whose `handle(request)` is the function the bun route at
-/__abide/mcp invokes. Framework-internal — the abide:mcp virtual
-default-constructs it; there is no user-authored server module. Server
-name/version default from package.json.
-
-Tools are derived from every rpc with `clients.mcp: true` (auto-on for
-read-only rpcs that carry a schema; mutating rpcs opt in explicitly)
-and from every socket with `clients.mcp: true` (a `<base>-tail` read tool
-plus a `<base>-publish` tool when clientPublish is set). The HTTP method
-feeds each rpc tool's annotations. Auth inherits from the inbound request
-— bearer / cookie headers flow into the synthesized Request that hits
-each rpc handler. An optional `authorize` hook in opts can short-circuit
-the request before any tool dispatches.
-*/
-// @documentation mcp
-export function createMcpServer(opts: McpServerOptions = {}): McpServer {
-    const serverInfo = {
-        name: opts.name ?? DEFAULT_NAME,
-        version: opts.version ?? DEFAULT_VERSION,
-    }
-    return {
-        async handle(request: Request): Promise<Response> {
-            if (request.method !== 'POST') {
-                return new Response('Method Not Allowed', {
-                    status: 405,
-                    headers: {
-                        Allow: 'POST',
-                        'Content-Type': TEXT_PLAIN,
-                        'Cache-Control': NO_STORE,
-                    },
-                })
-            }
-            const envelope = await dispatchMcpRequest(request, opts, serverInfo)
-            /* A notification yields no envelope — JSON-RPC forbids replying, so
-               ack the receipt with an empty 202 instead of a response body. */
-            if (envelope === undefined) {
-                return new Response(undefined, {
-                    status: 202,
-                    headers: { 'Cache-Control': NO_STORE },
-                })
-            }
-            return Response.json(envelope, { headers: { 'Cache-Control': NO_STORE } })
-        },
-    }
-}

package/src/lib/mcp/dispatchMcpRequest.ts

@@ -1,159 +0,0 @@
-import { ensureRegistriesLoaded } from '../server/runtime/registryManifests.ts'
-import { messageFromError } from '../shared/messageFromError.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'
-
-const PROTOCOL_VERSION = '2025-06-18'
-
-function jsonRpcError(
-    id: string | number | null,
-    code: number,
-    message: string,
-    data?: unknown,
-): JsonRpcResponse {
-    return { jsonrpc: '2.0', id, error: { code, message, ...(data === undefined ? {} : { data }) } }
-}
-
-function jsonRpcOk(id: string | number | null, result: unknown): JsonRpcResponse {
-    return { jsonrpc: '2.0', id, result }
-}
-
-/*
-Interpolates the caller's arguments into the prompt body and wraps the
-result in the MCP prompts/get wire shape — a markdown prompt is a single
-user message whose text is the rendered template. (The in-process agent
-loop reaches the same prompts via mcpSurface().getPrompt, which returns
-plain messages rather than this wire shape.)
-*/
-function getPrompt(
-    name: string,
-    args: Record<string, unknown> | undefined,
-): Record<string, unknown> {
-    const { description, messages } = renderPrompt(name, args)
-    return {
-        ...(description ? { description } : {}),
-        messages: messages.map((message) => ({
-            role: message.role,
-            content: { type: 'text', text: message.text },
-        })),
-    }
-}
-
-/*
-Parses a single JSON-RPC envelope and dispatches by method. Errors
-become JSON-RPC error responses (the HTTP layer always returns 200 with
-an envelope for JSON-RPC over HTTP; transport errors are different). The
-tool/prompt derivation and tool dispatch live in mcpSurface — the same
-projection the in-process agent loop builds on.
-*/
-export async function dispatchMcpRequest(
-    request: Request,
-    opts: McpServerOptions,
-    serverInfo: { name: string; version: string },
-): Promise<JsonRpcResponse | undefined> {
-    let envelope: JsonRpcRequest
-    try {
-        envelope = (await request.clone().json()) as JsonRpcRequest
-    } catch {
-        return jsonRpcError(null, -32700, 'Parse error')
-    }
-    /* A notification has no `id` field at all (absent — `id: 0`/`id: null` are
-       valid ids). JSON-RPC 2.0 forbids replying to a notification, so dispatch it
-       for its side effect and return undefined to signal "no reply". */
-    const isNotification = !('id' in envelope)
-    const id = envelope.id ?? null
-    if (envelope.jsonrpc !== '2.0' || typeof envelope.method !== 'string') {
-        return isNotification ? undefined : jsonRpcError(id, -32600, 'Invalid Request')
-    }
-
-    // Run the method for its side effect, then drop the reply for a notification.
-    const response = await dispatchMethod(envelope, id, request, opts, serverInfo)
-    return isNotification ? undefined : response
-}
-
-/* Resolves a parsed, validated request to its JSON-RPC response. The caller
-   discards this for notifications; non-notifications get it verbatim. */
-async function dispatchMethod(
-    envelope: JsonRpcRequest,
-    id: string | number | null,
-    request: Request,
-    opts: McpServerOptions,
-    serverInfo: { name: string; version: string },
-): Promise<JsonRpcResponse> {
-    if (opts.authorize) {
-        try {
-            await opts.authorize(request)
-        } catch (error) {
-            const message = messageFromError(error)
-            return jsonRpcError(id, -32001, message)
-        }
-    }
-
-    try {
-        await ensureRegistriesLoaded()
-        switch (envelope.method) {
-            case 'initialize':
-                return jsonRpcOk(id, {
-                    protocolVersion: PROTOCOL_VERSION,
-                    capabilities: {
-                        tools: { listChanged: false },
-                        prompts: { listChanged: false },
-                        resources: { listChanged: false },
-                    },
-                    serverInfo,
-                })
-            case 'ping':
-                return jsonRpcOk(id, {})
-            case 'tools/list':
-                return jsonRpcOk(id, { tools: mcpTools.list() })
-            case 'tools/call': {
-                const params = envelope.params as
-                    | { name?: string; arguments?: Record<string, unknown> }
-                    | undefined
-                if (!params?.name) {
-                    return jsonRpcError(id, -32602, 'Missing tool name')
-                }
-                return jsonRpcOk(id, await mcpTools.call(params.name, params.arguments, request))
-            }
-            case 'resources/list': {
-                const resourceServer = mcpResourceServerSlot.server
-                return jsonRpcOk(id, {
-                    resources: resourceServer ? await resourceServer.list() : [],
-                })
-            }
-            case 'resources/read': {
-                const params = envelope.params as { uri?: string } | undefined
-                if (!params?.uri) {
-                    return jsonRpcError(id, -32602, 'Missing resource uri')
-                }
-                const resourceServer = mcpResourceServerSlot.server
-                const contents = resourceServer ? await resourceServer.read(params.uri) : undefined
-                if (!contents) {
-                    return jsonRpcError(id, -32602, `unknown resource: ${params.uri}`)
-                }
-                return jsonRpcOk(id, { contents: [contents] })
-            }
-            case 'prompts/list':
-                return jsonRpcOk(id, { prompts: buildPrompts() })
-            case 'prompts/get': {
-                const params = envelope.params as
-                    | { name?: string; arguments?: Record<string, unknown> }
-                    | undefined
-                if (!params?.name) {
-                    return jsonRpcError(id, -32602, 'Missing prompt name')
-                }
-                return jsonRpcOk(id, getPrompt(params.name, params.arguments))
-            }
-            default:
-                return jsonRpcError(id, -32601, `Method not found: ${envelope.method}`)
-        }
-    } catch (error) {
-        const message = messageFromError(error)
-        return jsonRpcError(id, -32603, message)
-    }
-}

package/src/lib/mcp/mcpResourceServerSlot.ts

@@ -1,13 +0,0 @@
-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 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.
-*/
-export const mcpResourceServerSlot: { server: McpResourceServer | undefined } = {
-    server: undefined,
-}

package/src/lib/mcp/mcpSurface.ts

@@ -1,57 +0,0 @@
-import { abideLog } from '../shared/abideLog.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. 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.
-*/
-
-/* 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')
-
-/*
-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
-the model acts with the caller's identity. Used by `agent()`.
-*/
-export function mcpSurface(request: Request): McpSurface {
-    // Built on first read and memoized: an engine that advertises tools but never
-    // reads prompts (or reaches tools over HTTP, reading neither) skips the unused build.
-    let tools: ToolDescriptor[] | undefined
-    let prompts: PromptDescriptor[] | undefined
-    return {
-        get tools() {
-            tools ??= mcpTools.list()
-            return tools
-        },
-        get prompts() {
-            prompts ??= buildPrompts()
-            return prompts
-        },
-        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 = mcpResourceServerSlot.server
-            return server ? server.list() : []
-        },
-        async readResource(uri) {
-            const server = mcpResourceServerSlot.server
-            return server ? server.read(uri) : undefined
-        },
-    }
-}

package/src/lib/mcp/mcpTools.ts

@@ -1,196 +0,0 @@
-import { dispatchRpcInProcess } from '../server/rpc/dispatchRpcInProcess.ts'
-import {
-    resolveInputJsonSchema,
-    resolveOutputJsonSchema,
-} from '../server/rpc/resolveRpcJsonSchema.ts'
-import { rpcRegistry } from '../server/rpc/rpcRegistry.ts'
-import type { RpcRegistryEntry } from '../server/rpc/types/RpcRegistryEntry.ts'
-import { socketOperations } from '../server/sockets/socketOperations.ts'
-import { socketRegistry } from '../server/sockets/socketRegistry.ts'
-import type { SocketOperation } from '../server/sockets/types/SocketOperation.ts'
-import type { SocketRegistryEntry } from '../server/sockets/types/SocketRegistryEntry.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 { toolResultFromResponse } from './toolResultFromResponse.ts'
-import type { ToolDescriptor } from './types/ToolDescriptor.ts'
-import type { ToolResult } from './types/ToolResult.ts'
-
-/*
-One MCP-exposed tool, resolved from the live registries: an rpc, or one of a
-socket's operations. The ref carries the tool's identity (name) plus the
-registry entry it projects from; the descriptor and the dispatch below are two
-renderings of the same ref, so tools/list and tools/call can't disagree on
-which tools exist or what they're called.
-*/
-type McpToolRef =
-    | { kind: 'rpc'; name: string; entry: RpcRegistryEntry }
-    | { kind: 'socket'; name: string; entry: SocketRegistryEntry; operation: SocketOperation }
-
-/*
-Enumerates the MCP tool namespace — the single decision of which tools exist.
-RPCs with clients.mcp=true become one tool named after the export's URL
-(folder segments joined with `-`; reads auto-expose while mutating rpcs
-require an explicit clients.mcp — see resolveClientFlags). Sockets with
-clients.mcp=true contribute a `<base>-tail` read tool and, when clientPublish
-is set, a `<base>-publish` tool (existence + naming live in socketOperations).
-RPCs enumerate first, so on a name collision the rpc tool wins.
-*/
-function mcpToolRefs(): McpToolRef[] {
-    const refs: McpToolRef[] = []
-    for (const entry of rpcRegistry.values()) {
-        if (!entry.remote.clients.mcp) {
-            continue
-        }
-        refs.push({ kind: 'rpc', name: commandNameForUrl(entry.remote.url), entry })
-    }
-    for (const entry of socketRegistry.values()) {
-        if (!entry.clients.mcp) {
-            continue
-        }
-        for (const operation of socketOperations(entry)) {
-            refs.push({ kind: 'socket', name: operation.name, entry, operation })
-        }
-    }
-    return refs
-}
-
-/*
-The advertised face of one tool. An rpc tool's 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; the HTTP method feeds the annotations
-(readOnlyHint / destructiveHint / idempotentHint) so a model can tell a read
-from a write.
-*/
-function describeTool(ref: McpToolRef): ToolDescriptor {
-    if (ref.kind === 'rpc') {
-        // The declared inputSchema VALIDATOR overrides the build-projected input-type schema
-        // (ADR-0030 input side); with neither the tool advertises the opaque fallback, as before.
-        const inputSchema = resolveInputJsonSchema(ref.entry) ?? jsonSchemaForSchema(undefined)
-        const tool: ToolDescriptor = {
-            name: ref.name,
-            description:
-                (inputSchema.description as string | undefined) ??
-                `${ref.entry.remote.method} ${ref.entry.remote.url}`,
-            inputSchema,
-            annotations: annotationsForMethod(ref.entry.remote.method),
-        }
-        // The declared outputSchema VALIDATOR overrides the build-projected return-type schema
-        // (ADR-0030 D2); with neither the tool advertises no outputSchema, exactly as before.
-        const outputSchema = resolveOutputJsonSchema(ref.entry)
-        if (outputSchema) {
-            tool.outputSchema = outputSchema
-        }
-        return tool
-    }
-    const payloadSchema = jsonSchemaForSchema(ref.entry.schema)
-    if (ref.operation.kind === 'tail') {
-        return {
-            name: ref.name,
-            description: `Read recent messages from the "${ref.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 },
-        }
-    }
-    return {
-        name: ref.name,
-        description: `Publish a message to the "${ref.operation.socketName}" socket`,
-        inputSchema: payloadSchema,
-        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
-    }
-}
-
-function textResult(text: string, isError = false): ToolResult {
-    return { content: [{ type: 'text', text }], ...(isError ? { isError: true } : {}) }
-}
-
-/*
-Dispatches an rpc tool by synthesizing a Request (with forwarded auth headers
-from `inbound`) and piping 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.
-*/
-async function callRpcTool(
-    entry: RpcRegistryEntry,
-    args: Record<string, unknown> | undefined,
-    inbound: Request,
-): Promise<ToolResult> {
-    const response = await dispatchRpcInProcess({
-        remote: entry.remote,
-        args,
-        baseUrl: `${new URL(inbound.url).origin}/`,
-        headers: forwardHeaders(inbound.headers),
-    })
-    return toolResultFromResponse(response)
-}
-
-/*
-Dispatches a socket tool. tail returns the retained tail (request/response
-can't hold a live subscription); publish validates against the socket schema
-and fans out.
-*/
-function callSocketTool(
-    entry: SocketRegistryEntry,
-    operation: SocketOperation,
-    args: Record<string, unknown> | undefined,
-): Promise<ToolResult> | ToolResult {
-    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')
-}
-
-/*
-The MCP tool surface: what tools/list advertises and what tools/call runs.
-Both faces render from mcpToolRefs — the tool namespace is decided once, so
-everything advertised is callable and everything callable is advertised.
-list() is the only face that builds descriptors (schema projection is
-per-call work dispatch never pays). Read at call time (not cached) so rpcs
-constructed after boot show up, matching the other registry projections.
-*/
-export const mcpTools = {
-    list(): ToolDescriptor[] {
-        return mcpToolRefs().map(describeTool)
-    },
-    async call(
-        toolName: string,
-        args: Record<string, unknown> | undefined,
-        inbound: Request,
-    ): Promise<ToolResult> {
-        for (const ref of mcpToolRefs()) {
-            if (ref.name !== toolName) {
-                continue
-            }
-            return ref.kind === 'rpc'
-                ? callRpcTool(ref.entry, args, inbound)
-                : callSocketTool(ref.entry, ref.operation, args)
-        }
-        throw new Error(`unknown tool: ${toolName}`)
-    },
-}

package/src/lib/mcp/renderPrompt.ts

@@ -1,25 +0,0 @@
-import { promptRegistry } from '../server/prompts/promptRegistry.ts'
-import type { PromptMessage } from './types/PromptMessage.ts'
-
-/*
-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>) },
-        ],
-    }
-}

package/src/lib/mcp/toolResultFromResponse.ts

@@ -1,100 +0,0 @@
-import { decodeResponse } from '../shared/decodeResponse.ts'
-import { isStreamingResponse } from '../shared/isStreamingResponse.ts'
-import { messageFromError } from '../shared/messageFromError.ts'
-import { responseErrorText } from '../shared/responseErrorText.ts'
-import { streamResponse } from '../shared/streamResponse.ts'
-
-/* MCP `tools/call` is request/response, not a streaming transport, so a genuinely live
-   stream must be bounded: return what arrived within these limits (with a truncation note)
-   rather than buffering forever and never answering. */
-const MAX_STREAM_FRAMES = 1000
-const STREAM_TOOL_TIMEOUT_MS = 30_000
-
-// Frames a value as MCP text content — strings verbatim, everything else as JSON.
-// An undefined body (204 / empty) becomes '' — `JSON.stringify(undefined)` is the
-// value `undefined`, not a string, which would make an invalid text content block.
-function asText(value: unknown): string {
-    if (value === undefined) {
-        return ''
-    }
-    return typeof value === 'string' ? value : JSON.stringify(value)
-}
-
-/*
-Turns an RPC Response into an MCP `tools/call` result. Always
-carries a `text` content block for backward compatibility; adds
-`structuredContent` (an object, per the MCP spec) so models that
-understand structured output get the typed value instead of a stringified
-blob.
-
-  - non-2xx        → { content:[text], isError:true }
-  - sse/jsonl body → drained frame-by-frame; structuredContent = { frames }.
-                     A mid-stream error surfaces as isError with the
-                     frames collected so far.
-  - object body    → structuredContent = the object.
-  - array/primitive → text only (structuredContent must be an object).
-*/
-export async function toolResultFromResponse(response: Response): Promise<Record<string, unknown>> {
-    if (!response.ok) {
-        return {
-            content: [{ type: 'text', text: await responseErrorText(response) }],
-            isError: true,
-        }
-    }
-
-    if (isStreamingResponse(response)) {
-        const frames: unknown[] = []
-        // Set when WE stop the stream (cap/timeout), so the iterator's resulting end/throw
-        // reads as truncation, not a stream error.
-        let truncated: string | undefined
-        const timer = setTimeout(() => {
-            truncated = `stream truncated after ${STREAM_TOOL_TIMEOUT_MS}ms — MCP tools/call is request/response, not a live stream`
-            void response.body?.cancel()
-        }, STREAM_TOOL_TIMEOUT_MS)
-        try {
-            for await (const frame of streamResponse(response)) {
-                frames.push(frame)
-                if (frames.length >= MAX_STREAM_FRAMES) {
-                    truncated = `stream truncated at ${MAX_STREAM_FRAMES} frames`
-                    void response.body?.cancel()
-                    break
-                }
-            }
-        } catch (error) {
-            /* A real mid-stream error (we didn't cancel) surfaces as isError; a throw caused
-               by our own cancel falls through to the truncated result below. */
-            if (truncated === undefined) {
-                clearTimeout(timer)
-                return {
-                    content: [
-                        { type: 'text', text: frames.map(asText).join('\n') },
-                        { type: 'text', text: `stream error: ${messageFromError(error)}` },
-                    ],
-                    structuredContent: { frames },
-                    isError: true,
-                }
-            }
-        } finally {
-            clearTimeout(timer)
-        }
-        const content: { type: 'text'; text: string }[] = [
-            { type: 'text', text: frames.map(asText).join('\n') },
-        ]
-        if (truncated !== undefined) {
-            content.push({ type: 'text', text: truncated })
-        }
-        return {
-            content,
-            structuredContent: truncated === undefined ? { frames } : { frames, truncated },
-        }
-    }
-
-    const body = await decodeResponse(response)
-    const result: Record<string, unknown> = {
-        content: [{ type: 'text', text: asText(body) }],
-    }
-    if (body !== null && typeof body === 'object' && !Array.isArray(body)) {
-        result.structuredContent = body
-    }
-    return result
-}

package/src/lib/mcp/types/JsonRpcRequest.ts

@@ -1,12 +0,0 @@
-/*
-JSON-RPC 2.0 request frame as MCP delivers it over Streamable HTTP. The
-`id` is absent for notifications; they are dispatched for their side effect
-and acknowledged with a 202 (JSON-RPC forbids replying with an envelope).
-`method` is a string like "tools/list" or "resources/read".
-*/
-export type JsonRpcRequest = {
-    jsonrpc: '2.0'
-    id?: string | number
-    method: string
-    params?: Record<string, unknown>
-}

package/src/lib/mcp/types/JsonRpcResponse.ts

@@ -1,20 +0,0 @@
-/*
-JSON-RPC 2.0 response frame. Exactly one of `result` / `error` is set
-per request. The `id` echoes the inbound request id (null when the
-request id was malformed and the error is being returned).
-*/
-export type JsonRpcResponse =
-    | {
-          jsonrpc: '2.0'
-          id: string | number | null
-          result: unknown
-      }
-    | {
-          jsonrpc: '2.0'
-          id: string | number | null
-          error: {
-              code: number
-              message: string
-              data?: unknown
-          }
-      }

package/src/lib/mcp/types/McpResourceContents.ts

@@ -1,10 +0,0 @@
-/*
-One entry in an MCP resources/read result. Text-typed resources carry `text`;
-everything else carries base64 `blob` — exactly one is present.
-*/
-export type McpResourceContents = {
-    uri: string
-    mimeType: string
-    text?: string
-    blob?: string
-}

package/src/lib/mcp/types/McpResourceDescriptor.ts

@@ -1,6 +0,0 @@
-/* One entry in an MCP resources/list result — a file under src/mcp/resources. */
-export type McpResourceDescriptor = {
-    uri: string
-    name: string
-    mimeType: string
-}

package/src/lib/mcp/types/McpResourceServer.ts

@@ -1,12 +0,0 @@
-import type { McpResourceContents } from './McpResourceContents.ts'
-import type { McpResourceDescriptor } from './McpResourceDescriptor.ts'
-
-/*
-Serves the project's src/mcp/resources files to the MCP dispatcher. `list`
-backs resources/list; `read` backs resources/read and resolves to undefined
-for an unknown uri.
-*/
-export type McpResourceServer = {
-    list(): Promise<McpResourceDescriptor[]>
-    read(uri: string): Promise<McpResourceContents | undefined>
-}