velocious 1.0.692 → 1.0.694

package/build/src/mcp/dispatcher.d.ts

@@ -0,0 +1,133 @@
+export type McpToolResult = {
+    /**
+     * - Tool result content blocks.
+     */
+    content: Array<{
+        text: string;
+        type: "text";
+    }>;
+    /**
+     * - Whether the tool call failed.
+     */
+    isError: boolean;
+};
+export type FrontendModelRequestEntry = {
+    /**
+     * - Built-in command type.
+     */
+    commandType?: string;
+    /**
+     * - Custom command path.
+     */
+    customPath?: string;
+    /**
+     * - Backend model name.
+     */
+    model: string;
+    /**
+     * - Command payload.
+     */
+    payload: Record<string, unknown>;
+    /**
+     * - Remote request context.
+     */
+    requestContext?: Record<string, string | number | boolean> | undefined;
+    /**
+     * - Request correlation id.
+     */
+    requestId: string;
+};
+export type ApiManifest = Record<string, unknown> & {
+    formatVersion?: number;
+    resources?: Record<string, unknown>;
+};
+export type ManifestCommandEntry = {
+    /**
+     * - Declared typed command arguments.
+     */
+    args?: Array<{
+        name: string;
+        type: string;
+    }>;
+    /**
+     * - Whether the entry is a synthesized built-in command.
+     */
+    isBuiltIn?: boolean;
+    /**
+     * - Command method name.
+     */
+    methodName: string;
+    /**
+     * - Manifest command path (member paths carry `<id>`).
+     */
+    path?: string;
+    /**
+     * - Declared JSDoc return type.
+     */
+    returnType?: string | null;
+    /**
+     * - Command scope.
+     */
+    scope: "collection" | "member";
+};
+export type ManifestResourceEntry = {
+    /**
+     * - Scope-keyed custom command entries.
+     */
+    commands?: Record<string, ManifestCommandEntry[]>;
+    /**
+     * - Scope-keyed built-in command maps.
+     */
+    builtInCommands?: Record<string, Record<string, string>>;
+    /**
+     * - Backend model name.
+     */
+    modelName: string;
+    /**
+     * - Primary key attribute name(s).
+     */
+    primaryKey?: string | string[];
+};
+/**
+ * Lists the MCP tools exposed by a configuration's frontend-model API manifest.
+ * @param {object} args - Arguments.
+ * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+ * @returns {Promise<Record<string, unknown>[]>} - MCP `tools/list` tool definitions.
+ */
+export declare function listMcpTools({ configuration }: {
+    configuration: import("../configuration.js").default;
+}): Promise<Record<string, unknown>[]>;
+/**
+ * Executes one MCP `tools/call` against the frontend-model dispatcher.
+ * The tool call is translated into the exact shared frontend-model request entry
+ * (`commandType`/`customPath`, `model`, `payload`, `requestContext`) and runs
+ * through `FrontendModelController.frontendApi()` in-process, so tenant and
+ * ability resolution stay inside the owning dispatcher — MCP never bypasses them.
+ * @param {object} args - Arguments.
+ * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+ * @param {Record<string, string | number | boolean> | undefined} [args.requestContext] - Remote request context forwarded to the app's ability/tenant resolvers.
+ * @param {Record<string, unknown>} args.toolArguments - Tool arguments from the MCP client.
+ * @param {string} args.toolName - MCP tool name.
+ * @returns {Promise<McpToolResult>} - MCP tool call result.
+ */
+export declare function callMcpTool({ configuration, requestContext, toolArguments, toolName }: {
+    configuration: import("../configuration.js").default;
+    requestContext?: Record<string, string | number | boolean> | undefined;
+    toolArguments: Record<string, unknown>;
+    toolName: string;
+}): Promise<McpToolResult>;
+/**
+ * Builds the synthetic HTTP request lines for one MCP dispatch. The request-context
+ * `authorization` key is forwarded as the request's `Authorization` header so apps
+ * whose ability resolver authenticates from headers (Bearer service tokens or
+ * personal access tokens) authenticate MCP tool calls exactly like HTTP calls.
+ * Carriage returns and line feeds are stripped so a context value can never inject
+ * extra request lines.
+ * @param {object} args - Arguments.
+ * @param {Record<string, string | number | boolean> | undefined} args.requestContext - Remote request context.
+ * @returns {string} - Raw HTTP request head.
+ */
+export declare function buildSyntheticRequestLines({ requestContext }: {
+    requestContext: Record<string, string | number | boolean> | undefined;
+}): string;
+//# sourceMappingURL=dispatcher.d.ts.map

package/build/src/mcp/dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../../../src/mcp/dispatcher.js"],"names":[],"mappings":"AAGG,YAAkB,aAAa,GAC/B;;;;IAAgD,OAAO,EAA5C,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAC9C;;;;IAAoB,OAAO,EAAhB,OAAO,CACpB;CAAA,CAAA;AAGE,YAAkB,yBAAyB,GAC3C;;;;IAAoB,WAAW,AAA/B,CACA,EADW,MAAM,CACjB;;;;IAAoB,UAAU,AAA9B,CACA,EADW,MAAM,CACjB;;;;IAAmB,KAAK,EAAb,MAAM,CACjB;;;;IAAoC,OAAO,EAAhC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAClC;;;;IAAmE,cAAc,AAAjF,CACA,EADW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,SAAS,CAChE;;;;IAAmB,SAAS,EAAjB,MAAM,CACnB;CAAA,CAAA;AAGE,YAAmG,WAAW,GAApG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAC,CAAa;AAI9G,YAAkB,oBAAoB,GACtC;;;;IAAiD,IAAI,AAArD,CACA,EADW,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAC9C;;;;IAAqB,SAAS,AAA9B,CACA,EADW,OAAO,CAClB;;;;IAAmB,UAAU,EAAlB,MAAM,CACjB;;;;IAAoB,IAAI,AAAxB,CACA,EADW,MAAM,CACjB;;;;IAA2B,UAAU,AAArC,CACA,EADW,MAAM,GAAG,IAAI,CACxB;;;;IAAoC,KAAK,EAA9B,YAAY,GAAG,QAAQ,CACpC;CAAA,CAAA;AAGE,YAAkB,qBAAqB,GACvC;;;;IAAoD,QAAQ,AAA5D,CACA,EADW,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CACjD;;;;IAAoD,eAAe,AAAnE,CACA,EADW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CACjD;;;;IAAmB,SAAS,EAAjB,MAAM,CACjB;;;;IAA+B,UAAU,AAAzC,CACF,EADa,MAAM,GAAG,MAAM,EAAE,CAC9B;CAAA,CAAA;AAUD;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,EAAC,aAAa,EAAC,EAH/C;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;CAE+C,GAFrC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAM9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAAC,EAAC,aAAa,EAAE,cAAc,EAAE,aAAa,EAAE,QAAQ,EAAC,EANvF;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAAqE,cAAc,AAAnF,CACA,EADQ,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,SAAS,CAC7D;IAAsC,aAAa,EAA3C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAC/B;IAAqB,QAAQ,EAArB,MAAM,CACd;CAEuF,GAF7E,OAAO,CAAC,aAAa,CAAC,CA+BlC;AAuED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,EAAC,cAAc,EAAC,EAHxD;IAAoE,cAAc,EAA1E,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,SAAS,CAC7D;CAEwD,GAF9C,MAAM,CAkBlB"}

package/build/src/mcp/dispatcher.js

@@ -0,0 +1,232 @@
+// @ts-check
+/**
+ * @typedef {object} McpToolResult
+ * @property {Array<{text: string, type: "text"}>} content - Tool result content blocks.
+ * @property {boolean} isError - Whether the tool call failed.
+ */
+/**
+ * @typedef {object} FrontendModelRequestEntry
+ * @property {string} [commandType] - Built-in command type.
+ * @property {string} [customPath] - Custom command path.
+ * @property {string} model - Backend model name.
+ * @property {Record<string, unknown>} payload - Command payload.
+ * @property {Record<string, string | number | boolean> | undefined} [requestContext] - Remote request context.
+ * @property {string} requestId - Request correlation id.
+ */
+/**
+ * @typedef {Record<string, unknown> & {formatVersion?: number, resources?: Record<string, unknown>}} ApiManifest
+ */
+/**
+ * @typedef {object} ManifestCommandEntry
+ * @property {Array<{name: string, type: string}>} [args] - Declared typed command arguments.
+ * @property {boolean} [isBuiltIn] - Whether the entry is a synthesized built-in command.
+ * @property {string} methodName - Command method name.
+ * @property {string} [path] - Manifest command path (member paths carry `<id>`).
+ * @property {string | null} [returnType] - Declared JSDoc return type.
+ * @property {"collection" | "member"} scope - Command scope.
+ */
+/**
+ * @typedef {object} ManifestResourceEntry
+ * @property {Record<string, ManifestCommandEntry[]>} [commands] - Scope-keyed custom command entries.
+ * @property {Record<string, Record<string, string>>} [builtInCommands] - Scope-keyed built-in command maps.
+ * @property {string} modelName - Backend model name.
+ * @property {string | string[]} [primaryKey] - Primary key attribute name(s).
+ */
+import FrontendModelController from "../frontend-model-controller.js";
+import Request from "../http-server/client/request.js";
+import Response from "../http-server/client/response.js";
+import { deserializeFrontendModelTransportValue, serializeFrontendModelTransportValue } from "../frontend-models/transport-serialization.js";
+import { generateMcpTools, metaToolName, parseMcpToolName } from "./manifest-tools.js";
+const MCP_REQUEST_PATH = "/frontend-models";
+/**
+ * Lists the MCP tools exposed by a configuration's frontend-model API manifest.
+ * @param {object} args - Arguments.
+ * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+ * @returns {Promise<Record<string, unknown>[]>} - MCP `tools/list` tool definitions.
+ */
+export async function listMcpTools({ configuration }) {
+    const manifest = /** @type {ApiManifest} */ (await configuration.getApiManifest());
+    return generateMcpTools(manifest);
+}
+/**
+ * Executes one MCP `tools/call` against the frontend-model dispatcher.
+ * The tool call is translated into the exact shared frontend-model request entry
+ * (`commandType`/`customPath`, `model`, `payload`, `requestContext`) and runs
+ * through `FrontendModelController.frontendApi()` in-process, so tenant and
+ * ability resolution stay inside the owning dispatcher — MCP never bypasses them.
+ * @param {object} args - Arguments.
+ * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+ * @param {Record<string, string | number | boolean> | undefined} [args.requestContext] - Remote request context forwarded to the app's ability/tenant resolvers.
+ * @param {Record<string, unknown>} args.toolArguments - Tool arguments from the MCP client.
+ * @param {string} args.toolName - MCP tool name.
+ * @returns {Promise<McpToolResult>} - MCP tool call result.
+ */
+export async function callMcpTool({ configuration, requestContext, toolArguments, toolName }) {
+    const manifest = /** @type {ApiManifest} */ (await configuration.getApiManifest());
+    if (toolName === metaToolName()) {
+        return textResult({ value: manifest });
+    }
+    const identity = parseMcpToolName({ manifest, toolName });
+    if (!identity)
+        return errorResult(`Unknown MCP tool '${toolName}'.`);
+    const manifestResources = /** @type {Record<string, unknown>} */ (manifest.resources || {});
+    const resource = /** @type {ManifestResourceEntry} */ (manifestResources[identity.modelKey]);
+    const commandEntry = findManifestCommandEntry({ commandName: identity.commandName, resource, scope: identity.scope });
+    if (!commandEntry)
+        return errorResult(`Manifest command entry missing for tool '${toolName}'.`);
+    const requestEntry = buildFrontendModelRequestEntry({ commandEntry, model: String(resource.modelName), requestContext, toolArguments });
+    const responsePayload = await runFrontendApiRequest({ configuration, requestEntry });
+    const responseEntry = Array.isArray(responsePayload?.responses) ? responsePayload.responses[0] : undefined;
+    const commandResponse = responseEntry?.response;
+    if (!commandResponse)
+        return errorResult("Frontend-model dispatcher returned no response.");
+    if (commandResponse.status === "error") {
+        return errorResult(commandResponse.errorMessage || "Frontend-model command failed.", commandResponse);
+    }
+    return textResult({ value: commandResponse });
+}
+/**
+ * Finds the manifest command entry matching a parsed tool identity.
+ * @param {object} args - Arguments.
+ * @param {string} args.commandName - Command method name.
+ * @param {ManifestResourceEntry} args.resource - Manifest resource entry.
+ * @param {"collection" | "member"} args.scope - Command scope.
+ * @returns {ManifestCommandEntry | undefined} - Manifest command entry.
+ */
+function findManifestCommandEntry({ commandName, resource, scope }) {
+    if (resource.builtInCommands?.[scope]?.[commandName]) {
+        return { isBuiltIn: true, methodName: commandName, scope };
+    }
+    const scopeCommands = resource.commands?.[scope];
+    if (!Array.isArray(scopeCommands))
+        return undefined;
+    return scopeCommands.find((entry) => entry.methodName === commandName);
+}
+/**
+ * Builds the shared frontend-model request entry for one tool call.
+ * @param {object} args - Arguments.
+ * @param {ManifestCommandEntry} args.commandEntry - Manifest command entry.
+ * @param {string} args.model - Backend model name.
+ * @param {Record<string, string | number | boolean> | undefined} args.requestContext - Remote request context.
+ * @param {Record<string, unknown>} args.toolArguments - Tool arguments.
+ * @returns {FrontendModelRequestEntry} - frontendApi request entry.
+ */
+function buildFrontendModelRequestEntry({ commandEntry, model, requestContext, toolArguments }) {
+    const isBuiltInCommand = ["attach", "attachmentList", "create", "destroy", "download", "find", "index", "update", "url"].includes(commandEntry.methodName);
+    if (isBuiltInCommand) {
+        return {
+            commandType: commandEntry.methodName,
+            model,
+            payload: toolArguments,
+            requestId: "mcp-1",
+            requestContext
+        };
+    }
+    return {
+        customPath: resolveCustomCommandPath({ commandEntry, toolArguments }),
+        model,
+        payload: toolArguments,
+        requestId: "mcp-1",
+        requestContext
+    };
+}
+/**
+ * Substitutes the `<id>` placeholder of a manifest command path with the tool's
+ * primary key argument, matching the member route the dispatcher resolves.
+ * @param {object} args - Arguments.
+ * @param {ManifestCommandEntry} args.commandEntry - Manifest command entry (carries `path` and `scope`).
+ * @param {Record<string, unknown>} args.toolArguments - Tool arguments.
+ * @returns {string} - Custom command path.
+ */
+function resolveCustomCommandPath({ commandEntry, toolArguments }) {
+    const path = String(commandEntry.path || "");
+    if (!path.includes("<id>"))
+        return path;
+    const idValue = toolArguments.id ?? toolArguments.recordId;
+    return path.replace("<id>", encodeURIComponent(String(idValue ?? "")));
+}
+/**
+ * Builds the synthetic HTTP request lines for one MCP dispatch. The request-context
+ * `authorization` key is forwarded as the request's `Authorization` header so apps
+ * whose ability resolver authenticates from headers (Bearer service tokens or
+ * personal access tokens) authenticate MCP tool calls exactly like HTTP calls.
+ * Carriage returns and line feeds are stripped so a context value can never inject
+ * extra request lines.
+ * @param {object} args - Arguments.
+ * @param {Record<string, string | number | boolean> | undefined} args.requestContext - Remote request context.
+ * @returns {string} - Raw HTTP request head.
+ */
+export function buildSyntheticRequestLines({ requestContext }) {
+    const lines = [
+        `POST ${MCP_REQUEST_PATH} HTTP/1.1`,
+        "Host: velocious-mcp",
+        "Content-Length: 0",
+    ];
+    if (requestContext && typeof requestContext.authorization === "string") {
+        const authorization = requestContext.authorization.replace(/[\r\n]/g, "").trim();
+        if (authorization.length > 0)
+            lines.push(`Authorization: ${authorization}`);
+    }
+    lines.push("", "");
+    return lines.join("\r\n");
+}
+/**
+ * Runs one frontend-model request entry through the controller in-process,
+ * mirroring the synthetic-request pattern used by the controller specs.
+ * @param {object} args - Arguments.
+ * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+ * @param {FrontendModelRequestEntry} args.requestEntry - frontendApi request entry.
+ * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - Parsed frontendApi response payload.
+ */
+async function runFrontendApiRequest({ configuration, requestEntry }) {
+    const client = /** @type {import("../http-server/client/index.js").default} */ ({ remoteAddress: "127.0.0.1" });
+    const request = new Request({ client, configuration });
+    const donePromise = new Promise((resolve) => request.requestParser.events.on("done", resolve));
+    request.feed(Buffer.from(buildSyntheticRequestLines({ requestContext: requestEntry.requestContext }), "utf8"));
+    await donePromise;
+    const response = new Response({ configuration });
+    const controller = new FrontendModelController({
+        action: "frontendApi",
+        configuration,
+        controller: "frontend-models",
+        params: { requests: [requestEntry] },
+        request,
+        response,
+        viewPath: `${configuration.getDirectory()}/src/routes/frontend-models`
+    });
+    await controller.frontendApi();
+    const body = response.getBody();
+    const responseText = body === null || body === undefined
+        ? ""
+        : (typeof body === "string" ? body : Buffer.from(body).toString("utf8"));
+    const responseJson = responseText.length > 0 ? JSON.parse(responseText) : {};
+    return /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (deserializeFrontendModelTransportValue(responseJson));
+}
+/**
+ * Wraps a value as an MCP text content result.
+ * @param {object} args - Arguments.
+ * @param {unknown} args.value - Value to serialize as JSON text.
+ * @returns {McpToolResult} - MCP tool result.
+ */
+function textResult({ value }) {
+    const serialized = serializeFrontendModelTransportValue(value);
+    return {
+        content: [{ text: JSON.stringify(serialized, null, 2), type: "text" }],
+        isError: false
+    };
+}
+/**
+ * Builds an MCP error result, optionally including the dispatcher's error
+ * payload (validation summaries stay faithful — nothing is swallowed).
+ * @param {string} message - Error message.
+ * @param {Record<string, unknown>} [payload] - Full dispatcher error payload.
+ * @returns {McpToolResult} - MCP tool result.
+ */
+function errorResult(message, payload) {
+    const detail = payload ? `\n${JSON.stringify(payload, null, 2)}` : "";
+    return {
+        content: [{ text: `${message}${detail}`, type: "text" }],
+        isError: true
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dispatcher.js","sourceRoot":"","sources":["../../../src/mcp/dispatcher.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * @typedef {object} McpToolResult\n * @property {Array<{text: string, type: \"text\"}>} content - Tool result content blocks.\n * @property {boolean} isError - Whether the tool call failed.\n */\n\n/**\n * @typedef {object} FrontendModelRequestEntry\n * @property {string} [commandType] - Built-in command type.\n * @property {string} [customPath] - Custom command path.\n * @property {string} model - Backend model name.\n * @property {Record<string, unknown>} payload - Command payload.\n * @property {Record<string, string | number | boolean> | undefined} [requestContext] - Remote request context.\n * @property {string} requestId - Request correlation id.\n */\n\n/**\n * @typedef {Record<string, unknown> & {formatVersion?: number, resources?: Record<string, unknown>}} ApiManifest\n */\n\n/**\n * @typedef {object} ManifestCommandEntry\n * @property {Array<{name: string, type: string}>} [args] - Declared typed command arguments.\n * @property {boolean} [isBuiltIn] - Whether the entry is a synthesized built-in command.\n * @property {string} methodName - Command method name.\n * @property {string} [path] - Manifest command path (member paths carry `<id>`).\n * @property {string | null} [returnType] - Declared JSDoc return type.\n * @property {\"collection\" | \"member\"} scope - Command scope.\n */\n\n/**\n * @typedef {object} ManifestResourceEntry\n * @property {Record<string, ManifestCommandEntry[]>} [commands] - Scope-keyed custom command entries.\n * @property {Record<string, Record<string, string>>} [builtInCommands] - Scope-keyed built-in command maps.\n * @property {string} modelName - Backend model name.\n * @property {string | string[]} [primaryKey] - Primary key attribute name(s).\n */\n\nimport FrontendModelController from \"../frontend-model-controller.js\"\nimport Request from \"../http-server/client/request.js\"\nimport Response from \"../http-server/client/response.js\"\nimport {deserializeFrontendModelTransportValue, serializeFrontendModelTransportValue} from \"../frontend-models/transport-serialization.js\"\nimport {generateMcpTools, metaToolName, parseMcpToolName} from \"./manifest-tools.js\"\n\nconst MCP_REQUEST_PATH = \"/frontend-models\"\n\n/**\n * Lists the MCP tools exposed by a configuration's frontend-model API manifest.\n * @param {object} args - Arguments.\n * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n * @returns {Promise<Record<string, unknown>[]>} - MCP `tools/list` tool definitions.\n */\nexport async function listMcpTools({configuration}) {\n  const manifest = /** @type {ApiManifest} */ (await configuration.getApiManifest())\n\n  return generateMcpTools(manifest)\n}\n\n/**\n * Executes one MCP `tools/call` against the frontend-model dispatcher.\n * The tool call is translated into the exact shared frontend-model request entry\n * (`commandType`/`customPath`, `model`, `payload`, `requestContext`) and runs\n * through `FrontendModelController.frontendApi()` in-process, so tenant and\n * ability resolution stay inside the owning dispatcher — MCP never bypasses them.\n * @param {object} args - Arguments.\n * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n * @param {Record<string, string | number | boolean> | undefined} [args.requestContext] - Remote request context forwarded to the app's ability/tenant resolvers.\n * @param {Record<string, unknown>} args.toolArguments - Tool arguments from the MCP client.\n * @param {string} args.toolName - MCP tool name.\n * @returns {Promise<McpToolResult>} - MCP tool call result.\n */\nexport async function callMcpTool({configuration, requestContext, toolArguments, toolName}) {\n  const manifest = /** @type {ApiManifest} */ (await configuration.getApiManifest())\n\n  if (toolName === metaToolName()) {\n    return textResult({value: manifest})\n  }\n\n  const identity = parseMcpToolName({manifest, toolName})\n\n  if (!identity) return errorResult(`Unknown MCP tool '${toolName}'.`)\n\n  const manifestResources = /** @type {Record<string, unknown>} */ (manifest.resources || {})\n  const resource = /** @type {ManifestResourceEntry} */ (manifestResources[identity.modelKey])\n  const commandEntry = findManifestCommandEntry({commandName: identity.commandName, resource, scope: identity.scope})\n\n  if (!commandEntry) return errorResult(`Manifest command entry missing for tool '${toolName}'.`)\n\n  const requestEntry = buildFrontendModelRequestEntry({commandEntry, model: String(resource.modelName), requestContext, toolArguments})\n  const responsePayload = await runFrontendApiRequest({configuration, requestEntry})\n  const responseEntry = Array.isArray(responsePayload?.responses) ? responsePayload.responses[0] : undefined\n  const commandResponse = responseEntry?.response\n\n  if (!commandResponse) return errorResult(\"Frontend-model dispatcher returned no response.\")\n\n  if (commandResponse.status === \"error\") {\n    return errorResult(commandResponse.errorMessage || \"Frontend-model command failed.\", commandResponse)\n  }\n\n  return textResult({value: commandResponse})\n}\n\n/**\n * Finds the manifest command entry matching a parsed tool identity.\n * @param {object} args - Arguments.\n * @param {string} args.commandName - Command method name.\n * @param {ManifestResourceEntry} args.resource - Manifest resource entry.\n * @param {\"collection\" | \"member\"} args.scope - Command scope.\n * @returns {ManifestCommandEntry | undefined} - Manifest command entry.\n */\nfunction findManifestCommandEntry({commandName, resource, scope}) {\n  if (resource.builtInCommands?.[scope]?.[commandName]) {\n    return {isBuiltIn: true, methodName: commandName, scope}\n  }\n\n  const scopeCommands = resource.commands?.[scope]\n\n  if (!Array.isArray(scopeCommands)) return undefined\n\n  return scopeCommands.find((entry) => entry.methodName === commandName)\n}\n\n/**\n * Builds the shared frontend-model request entry for one tool call.\n * @param {object} args - Arguments.\n * @param {ManifestCommandEntry} args.commandEntry - Manifest command entry.\n * @param {string} args.model - Backend model name.\n * @param {Record<string, string | number | boolean> | undefined} args.requestContext - Remote request context.\n * @param {Record<string, unknown>} args.toolArguments - Tool arguments.\n * @returns {FrontendModelRequestEntry} - frontendApi request entry.\n */\nfunction buildFrontendModelRequestEntry({commandEntry, model, requestContext, toolArguments}) {\n  const isBuiltInCommand = [\"attach\", \"attachmentList\", \"create\", \"destroy\", \"download\", \"find\", \"index\", \"update\", \"url\"].includes(commandEntry.methodName)\n\n  if (isBuiltInCommand) {\n    return {\n      commandType: commandEntry.methodName,\n      model,\n      payload: toolArguments,\n      requestId: \"mcp-1\",\n      requestContext\n    }\n  }\n\n  return {\n    customPath: resolveCustomCommandPath({commandEntry, toolArguments}),\n    model,\n    payload: toolArguments,\n    requestId: \"mcp-1\",\n    requestContext\n  }\n}\n\n/**\n * Substitutes the `<id>` placeholder of a manifest command path with the tool's\n * primary key argument, matching the member route the dispatcher resolves.\n * @param {object} args - Arguments.\n * @param {ManifestCommandEntry} args.commandEntry - Manifest command entry (carries `path` and `scope`).\n * @param {Record<string, unknown>} args.toolArguments - Tool arguments.\n * @returns {string} - Custom command path.\n */\nfunction resolveCustomCommandPath({commandEntry, toolArguments}) {\n  const path = String(commandEntry.path || \"\")\n\n  if (!path.includes(\"<id>\")) return path\n\n  const idValue = toolArguments.id ?? toolArguments.recordId\n\n  return path.replace(\"<id>\", encodeURIComponent(String(idValue ?? \"\")))\n}\n\n/**\n * Builds the synthetic HTTP request lines for one MCP dispatch. The request-context\n * `authorization` key is forwarded as the request's `Authorization` header so apps\n * whose ability resolver authenticates from headers (Bearer service tokens or\n * personal access tokens) authenticate MCP tool calls exactly like HTTP calls.\n * Carriage returns and line feeds are stripped so a context value can never inject\n * extra request lines.\n * @param {object} args - Arguments.\n * @param {Record<string, string | number | boolean> | undefined} args.requestContext - Remote request context.\n * @returns {string} - Raw HTTP request head.\n */\nexport function buildSyntheticRequestLines({requestContext}) {\n  const lines = [\n    `POST ${MCP_REQUEST_PATH} HTTP/1.1`,\n    \"Host: velocious-mcp\",\n    \"Content-Length: 0\",\n  ]\n\n  if (requestContext && typeof requestContext.authorization === \"string\") {\n    const authorization = requestContext.authorization.replace(/[\\r\\n]/g, \"\").trim()\n\n    if (authorization.length > 0) lines.push(`Authorization: ${authorization}`)\n  }\n\n  lines.push(\"\", \"\")\n\n  return lines.join(\"\\r\\n\")\n}\n\n/**\n * Runs one frontend-model request entry through the controller in-process,\n * mirroring the synthetic-request pattern used by the controller specs.\n * @param {object} args - Arguments.\n * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n * @param {FrontendModelRequestEntry} args.requestEntry - frontendApi request entry.\n * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - Parsed frontendApi response payload.\n */\nasync function runFrontendApiRequest({configuration, requestEntry}) {\n  const client = /** @type {import(\"../http-server/client/index.js\").default} */ ({remoteAddress: \"127.0.0.1\"})\n  const request = new Request({client, configuration})\n  const donePromise = new Promise((resolve) => request.requestParser.events.on(\"done\", resolve))\n\n  request.feed(Buffer.from(buildSyntheticRequestLines({requestContext: requestEntry.requestContext}), \"utf8\"))\n\n  await donePromise\n\n  const response = new Response({configuration})\n  const controller = new FrontendModelController({\n    action: \"frontendApi\",\n    configuration,\n    controller: \"frontend-models\",\n    params: {requests: [requestEntry]},\n    request,\n    response,\n    viewPath: `${configuration.getDirectory()}/src/routes/frontend-models`\n  })\n\n  await controller.frontendApi()\n\n  const body = response.getBody()\n  const responseText = body === null || body === undefined\n    ? \"\"\n    : (typeof body === \"string\" ? body : Buffer.from(body).toString(\"utf8\"))\n  const responseJson = responseText.length > 0 ? JSON.parse(responseText) : {}\n\n  return /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (deserializeFrontendModelTransportValue(responseJson))\n}\n\n/**\n * Wraps a value as an MCP text content result.\n * @param {object} args - Arguments.\n * @param {unknown} args.value - Value to serialize as JSON text.\n * @returns {McpToolResult} - MCP tool result.\n */\nfunction textResult({value}) {\n  const serialized = serializeFrontendModelTransportValue(value)\n\n  return {\n    content: [{text: JSON.stringify(serialized, null, 2), type: \"text\"}],\n    isError: false\n  }\n}\n\n/**\n * Builds an MCP error result, optionally including the dispatcher's error\n * payload (validation summaries stay faithful — nothing is swallowed).\n * @param {string} message - Error message.\n * @param {Record<string, unknown>} [payload] - Full dispatcher error payload.\n * @returns {McpToolResult} - MCP tool result.\n */\nfunction errorResult(message, payload) {\n  const detail = payload ? `\\n${JSON.stringify(payload, null, 2)}` : \"\"\n\n  return {\n    content: [{text: `${message}${detail}`, type: \"text\"}],\n    isError: true\n  }\n}\n"]}

package/build/src/mcp/json-rpc-server.d.ts

@@ -0,0 +1,47 @@
+export type JsonRpcMessage = Record<string, unknown> & {
+    error?: {
+        code: number;
+        message: string;
+    };
+    id?: number | string | null;
+    jsonrpc: string;
+    method?: string;
+    params?: Record<string, unknown>;
+    result?: Record<string, unknown>;
+};
+/**
+ * Handles one JSON-RPC message of the MCP protocol (initialize / tools/list /
+ * tools/call / ping) against a Velocious configuration. Returns null for
+ * notifications (no response expected).
+ * @param {object} args - Arguments.
+ * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+ * @param {JsonRpcMessage} args.request - Parsed JSON-RPC request.
+ * @param {Record<string, string | number | boolean> | undefined} [args.requestContext] - Remote request context forwarded to every tool call.
+ * @returns {Promise<JsonRpcMessage | null>} - JSON-RPC response, or null for notifications.
+ */
+export declare function handleMcpRequest({ configuration, request, requestContext }: {
+    configuration: import("../configuration.js").default;
+    request: JsonRpcMessage;
+    requestContext?: Record<string, string | number | boolean> | undefined;
+}): Promise<JsonRpcMessage | null>;
+/**
+ * Starts a line-delimited JSON-RPC MCP server over stdio (the primary MCP
+ * transport for local tool servers). Each input line is one JSON-RPC message;
+ * each response is written as one JSON line.
+ * @param {object} args - Arguments.
+ * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+ * @param {import("node:stream").Readable} [args.input] - Input stream (defaults to stdin).
+ * @param {import("node:stream").Writable} [args.output] - Output stream (defaults to stdout).
+ * @param {Record<string, string | number | boolean> | undefined} [args.requestContext] - Remote request context forwarded to every tool call.
+ * @returns {{close: () => void, done: Promise<void>}} - Server handle; `done` resolves when the input stream closes.
+ */
+export declare function startMcpStdioServer({ configuration, input, output, requestContext }: {
+    configuration: import("../configuration.js").default;
+    input?: import("node:stream").Readable;
+    output?: import("node:stream").Writable;
+    requestContext?: Record<string, string | number | boolean> | undefined;
+}): {
+    close: () => void;
+    done: Promise<void>;
+};
+//# sourceMappingURL=json-rpc-server.d.ts.map

package/build/src/mcp/json-rpc-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-rpc-server.d.ts","sourceRoot":"","sources":["../../../src/mcp/json-rpc-server.js"],"names":[],"mappings":"AAGG,YAAkN,cAAc,GAAtN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAC,KAAK,CAAC,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAC,CAAgB;AAQnO;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CAAC,EAAC,aAAa,EAAE,OAAO,EAAE,cAAc,EAAC,EAL5E;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAA6B,OAAO,EAA5B,cAAc,CACtB;IAAqE,cAAc,AAAnF,CACA,EADQ,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,SAAS,CAC7D;CAE4E,GAFlE,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAsC1C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,EAAC,aAAa,EAAE,KAAqB,EAAE,MAAuB,EAAE,cAAc,EAAC,EANhH;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAA8C,KAAK,AAAnD,CACA,EADQ,OAAO,aAAa,EAAE,QAAQ,CACtC;IAA8C,MAAM,AAApD,CACA,EADQ,OAAO,aAAa,EAAE,QAAQ,CACtC;IAAqE,cAAc,AAAnF,CACA,EADQ,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,SAAS,CAC7D;CAEgH,GAFtG;IAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CAAC,CA6EpD"}

package/build/src/mcp/json-rpc-server.js

@@ -0,0 +1,142 @@
+// @ts-check
+/**
+ * @typedef {Record<string, unknown> & {error?: {code: number, message: string}, id?: number | string | null, jsonrpc: string, method?: string, params?: Record<string, unknown>, result?: Record<string, unknown>}} JsonRpcMessage
+ */
+import readline from "node:readline";
+import { callMcpTool, listMcpTools } from "./dispatcher.js";
+const MCP_PROTOCOL_VERSION = "2025-03-26";
+/**
+ * Handles one JSON-RPC message of the MCP protocol (initialize / tools/list /
+ * tools/call / ping) against a Velocious configuration. Returns null for
+ * notifications (no response expected).
+ * @param {object} args - Arguments.
+ * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+ * @param {JsonRpcMessage} args.request - Parsed JSON-RPC request.
+ * @param {Record<string, string | number | boolean> | undefined} [args.requestContext] - Remote request context forwarded to every tool call.
+ * @returns {Promise<JsonRpcMessage | null>} - JSON-RPC response, or null for notifications.
+ */
+export async function handleMcpRequest({ configuration, request, requestContext }) {
+    if (!request || typeof request !== "object" || request.jsonrpc !== "2.0" || typeof request.method !== "string") {
+        return jsonRpcError(null, -32600, "Invalid Request");
+    }
+    const id = request.id;
+    if (request.method.startsWith("notifications/"))
+        return null;
+    if (request.method === "initialize") {
+        return jsonRpcResult(id, {
+            capabilities: { tools: { listChanged: false } },
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            serverInfo: { name: "velocious-mcp", title: "Velocious frontend-model MCP server", version: "1.0.0" }
+        });
+    }
+    if (request.method === "ping")
+        return jsonRpcResult(id, {});
+    if (request.method === "tools/list") {
+        return jsonRpcResult(id, { tools: await listMcpTools({ configuration }) });
+    }
+    if (request.method === "tools/call") {
+        const params = request.params || {};
+        if (typeof params.name !== "string")
+            return jsonRpcError(id, -32602, "Expected tools/call params.name");
+        const toolArguments = params.arguments && typeof params.arguments === "object" && !Array.isArray(params.arguments)
+            ? /** @type {Record<string, unknown>} */ (params.arguments)
+            : {};
+        return jsonRpcResult(id, await callMcpTool({ configuration, requestContext, toolArguments, toolName: params.name }));
+    }
+    return jsonRpcError(id, -32601, `Method not found: ${request.method}`);
+}
+/**
+ * Starts a line-delimited JSON-RPC MCP server over stdio (the primary MCP
+ * transport for local tool servers). Each input line is one JSON-RPC message;
+ * each response is written as one JSON line.
+ * @param {object} args - Arguments.
+ * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+ * @param {import("node:stream").Readable} [args.input] - Input stream (defaults to stdin).
+ * @param {import("node:stream").Writable} [args.output] - Output stream (defaults to stdout).
+ * @param {Record<string, string | number | boolean> | undefined} [args.requestContext] - Remote request context forwarded to every tool call.
+ * @returns {{close: () => void, done: Promise<void>}} - Server handle; `done` resolves when the input stream closes.
+ */
+export function startMcpStdioServer({ configuration, input = process.stdin, output = process.stdout, requestContext }) {
+    let closed = false;
+    let doneResolved = false;
+    /** @type {((value: void) => void) | undefined} */
+    let resolveDone;
+    const done = new Promise((resolve) => { resolveDone = resolve; });
+    /**
+     * Writes one JSON-RPC message as a line.
+     * @param {JsonRpcMessage | null} message - Message to write.
+     * @returns {void} - No return value.
+     */
+    const writeMessage = (message) => {
+        // Responses for in-flight requests are still written after the input
+        // stream closed; only after `done` resolved are writes suppressed.
+        if (message === null || doneResolved)
+            return;
+        output.write(`${JSON.stringify(message)}\n`);
+    };
+    const readlineInterface = readline.createInterface({ input });
+    let pendingRequests = 0;
+    const finishIfClosed = () => {
+        if (closed && pendingRequests === 0 && resolveDone && !doneResolved) {
+            doneResolved = true;
+            resolveDone(undefined);
+        }
+    };
+    readlineInterface.on("line", (/** @type {string} */ line) => {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            return;
+        /** @type {JsonRpcMessage} */
+        let request;
+        try {
+            request = JSON.parse(trimmed);
+        }
+        catch {
+            writeMessage(jsonRpcError(null, -32700, "Parse error"));
+            return;
+        }
+        pendingRequests++;
+        handleMcpRequest({ configuration, request, requestContext }).then((response) => {
+            writeMessage(response);
+        }).catch((error) => {
+            writeMessage(jsonRpcError(request.id ?? null, -32603, `Internal error: ${error instanceof Error ? error.message : String(error)}`));
+        }).finally(() => {
+            pendingRequests--;
+            finishIfClosed();
+        });
+    });
+    readlineInterface.on("close", () => {
+        closed = true;
+        finishIfClosed();
+    });
+    return {
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            readlineInterface.close();
+            finishIfClosed();
+        },
+        done
+    };
+}
+/**
+ * Builds a JSON-RPC success response.
+ * @param {number | string | null | undefined} id - Request id.
+ * @param {Record<string, unknown>} result - Result payload.
+ * @returns {JsonRpcMessage} - JSON-RPC response.
+ */
+function jsonRpcResult(id, result) {
+    return { id, jsonrpc: "2.0", result };
+}
+/**
+ * Builds a JSON-RPC error response.
+ * @param {number | string | null | undefined} id - Request id.
+ * @param {number} code - JSON-RPC error code.
+ * @param {string} message - Error message.
+ * @returns {JsonRpcMessage} - JSON-RPC response.
+ */
+function jsonRpcError(id, code, message) {
+    return { error: { code, message }, id, jsonrpc: "2.0" };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json-rpc-server.js","sourceRoot":"","sources":["../../../src/mcp/json-rpc-server.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * @typedef {Record<string, unknown> & {error?: {code: number, message: string}, id?: number | string | null, jsonrpc: string, method?: string, params?: Record<string, unknown>, result?: Record<string, unknown>}} JsonRpcMessage\n */\n\nimport readline from \"node:readline\"\nimport {callMcpTool, listMcpTools} from \"./dispatcher.js\"\n\nconst MCP_PROTOCOL_VERSION = \"2025-03-26\"\n\n/**\n * Handles one JSON-RPC message of the MCP protocol (initialize / tools/list /\n * tools/call / ping) against a Velocious configuration. Returns null for\n * notifications (no response expected).\n * @param {object} args - Arguments.\n * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n * @param {JsonRpcMessage} args.request - Parsed JSON-RPC request.\n * @param {Record<string, string | number | boolean> | undefined} [args.requestContext] - Remote request context forwarded to every tool call.\n * @returns {Promise<JsonRpcMessage | null>} - JSON-RPC response, or null for notifications.\n */\nexport async function handleMcpRequest({configuration, request, requestContext}) {\n  if (!request || typeof request !== \"object\" || request.jsonrpc !== \"2.0\" || typeof request.method !== \"string\") {\n    return jsonRpcError(null, -32600, \"Invalid Request\")\n  }\n\n  const id = request.id\n\n  if (request.method.startsWith(\"notifications/\")) return null\n\n  if (request.method === \"initialize\") {\n    return jsonRpcResult(id, {\n      capabilities: {tools: {listChanged: false}},\n      protocolVersion: MCP_PROTOCOL_VERSION,\n      serverInfo: {name: \"velocious-mcp\", title: \"Velocious frontend-model MCP server\", version: \"1.0.0\"}\n    })\n  }\n\n  if (request.method === \"ping\") return jsonRpcResult(id, {})\n\n  if (request.method === \"tools/list\") {\n    return jsonRpcResult(id, {tools: await listMcpTools({configuration})})\n  }\n\n  if (request.method === \"tools/call\") {\n    const params = request.params || {}\n\n    if (typeof params.name !== \"string\") return jsonRpcError(id, -32602, \"Expected tools/call params.name\")\n\n    const toolArguments = params.arguments && typeof params.arguments === \"object\" && !Array.isArray(params.arguments)\n      ? /** @type {Record<string, unknown>} */ (params.arguments)\n      : {}\n\n    return jsonRpcResult(id, await callMcpTool({configuration, requestContext, toolArguments, toolName: params.name}))\n  }\n\n  return jsonRpcError(id, -32601, `Method not found: ${request.method}`)\n}\n\n/**\n * Starts a line-delimited JSON-RPC MCP server over stdio (the primary MCP\n * transport for local tool servers). Each input line is one JSON-RPC message;\n * each response is written as one JSON line.\n * @param {object} args - Arguments.\n * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n * @param {import(\"node:stream\").Readable} [args.input] - Input stream (defaults to stdin).\n * @param {import(\"node:stream\").Writable} [args.output] - Output stream (defaults to stdout).\n * @param {Record<string, string | number | boolean> | undefined} [args.requestContext] - Remote request context forwarded to every tool call.\n * @returns {{close: () => void, done: Promise<void>}} - Server handle; `done` resolves when the input stream closes.\n */\nexport function startMcpStdioServer({configuration, input = process.stdin, output = process.stdout, requestContext}) {\n  let closed = false\n  let doneResolved = false\n  /** @type {((value: void) => void) | undefined} */\n  let resolveDone\n\n  const done = new Promise((resolve) => { resolveDone = resolve })\n\n  /**\n   * Writes one JSON-RPC message as a line.\n   * @param {JsonRpcMessage | null} message - Message to write.\n   * @returns {void} - No return value.\n   */\n  const writeMessage = (message) => {\n    // Responses for in-flight requests are still written after the input\n    // stream closed; only after `done` resolved are writes suppressed.\n    if (message === null || doneResolved) return\n\n    output.write(`${JSON.stringify(message)}\\n`)\n  }\n\n  const readlineInterface = readline.createInterface({input})\n\n  let pendingRequests = 0\n\n  const finishIfClosed = () => {\n    if (closed && pendingRequests === 0 && resolveDone && !doneResolved) {\n      doneResolved = true\n      resolveDone(undefined)\n    }\n  }\n\n  readlineInterface.on(\"line\", (/** @type {string} */ line) => {\n    const trimmed = line.trim()\n\n    if (trimmed.length === 0) return\n\n    /** @type {JsonRpcMessage} */\n    let request\n\n    try {\n      request = JSON.parse(trimmed)\n    } catch {\n      writeMessage(jsonRpcError(null, -32700, \"Parse error\"))\n\n      return\n    }\n\n    pendingRequests++\n\n    handleMcpRequest({configuration, request, requestContext}).then((response) => {\n      writeMessage(response)\n    }).catch((error) => {\n      writeMessage(jsonRpcError(request.id ?? null, -32603, `Internal error: ${error instanceof Error ? error.message : String(error)}`))\n    }).finally(() => {\n      pendingRequests--\n      finishIfClosed()\n    })\n  })\n\n  readlineInterface.on(\"close\", () => {\n    closed = true\n    finishIfClosed()\n  })\n\n  return {\n    close() {\n      if (closed) return\n\n      closed = true\n      readlineInterface.close()\n      finishIfClosed()\n    },\n    done\n  }\n}\n\n/**\n * Builds a JSON-RPC success response.\n * @param {number | string | null | undefined} id - Request id.\n * @param {Record<string, unknown>} result - Result payload.\n * @returns {JsonRpcMessage} - JSON-RPC response.\n */\nfunction jsonRpcResult(id, result) {\n  return {id, jsonrpc: \"2.0\", result}\n}\n\n/**\n * Builds a JSON-RPC error response.\n * @param {number | string | null | undefined} id - Request id.\n * @param {number} code - JSON-RPC error code.\n * @param {string} message - Error message.\n * @returns {JsonRpcMessage} - JSON-RPC response.\n */\nfunction jsonRpcError(id, code, message) {\n  return {error: {code, message}, id, jsonrpc: \"2.0\"}\n}\n"]}