@jini-ai/mcp 0.1.0

package/dist/server/daemon-client.js

@@ -0,0 +1,176 @@
+/**
+ * @module @jini-ai/mcp/server/daemon-client
+ *
+ * Bounded-I/O JSON GET/POST against a trusted daemon base URL — the transport
+ * primitive every proxy tool `createMcpToolServer` hosts is built on
+ * (`../client/client.js`'s `createMcpIdleExitController` is the other half of
+ * the mechanism; this module is the network half).
+ *
+ * Deliberately NOT `@jini-ai/cli`'s `getJsonFromDaemon`/`postJsonToDaemon`
+ * (`packages/cli/src/http.ts`): those map a failure onto `process.exit`,
+ * which is the right contract for a one-shot CLI invocation but wrong here —
+ * a stdio MCP server is a long-lived process serving many tool calls, and one
+ * failed call must return an MCP `{isError:true}` result and keep serving the
+ * next call, not terminate the process. This module ports the same
+ * bounded-read / timeout / redaction posture `http.ts` established
+ * (CR-004/SEC-RB-009 — see `ADS-memory/reports/code-review/CR-remaining-backend-audit-2026-07-21.md`,
+ * `ADS-memory/reports/security/SEC-remaining-backend-audit-2026-07-21.md`) as
+ * a throw-based primitive instead: a failed request throws a plain,
+ * already-redacted `Error` whose message a tool handler's caller
+ * (`handleToolCall` in `./tool-protocol.js`) turns into that MCP error result.
+ *
+ * No SSRF hardening here (unlike `../core/oauth.ts`'s `safeOAuthFetch`): the
+ * target is a caller-resolved, typically-loopback daemon the user already
+ * trusts enough to run — not an attacker- or server-metadata-controlled
+ * remote URL the way a configured external MCP server's OAuth endpoints are.
+ * This mirrors `@jini-ai/cli/http.ts`'s own posture for the identical "fetch my
+ * own daemon" concern (no `assertSafePublicUrl` there either).
+ */
+import { sanitizeUntrustedText } from '@jini-ai/cli';
+/** Request deadline. Generous enough for a slow tool call, short enough that a stalled daemon doesn't hang a stdio server turn forever. */
+const DEFAULT_TIMEOUT_MS = 15_000;
+/** Cap on a daemon response body. Comfortably larger than any real status/run envelope, small enough to bound worst-case memory from a hostile/broken daemon. */
+const DEFAULT_MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
+/** Thrown internally when a response exceeds its byte cap; always translated to a plain `Error` before it crosses this module's public functions. */
+export class DaemonResponseTooLargeError extends Error {
+    limitBytes;
+    constructor(limitBytes) {
+        super(`daemon response exceeded the ${limitBytes}-byte limit`);
+        this.limitBytes = limitBytes;
+        this.name = 'DaemonResponseTooLargeError';
+    }
+}
+function parseJsonLoose(text) {
+    if (text.length === 0)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Read `resp`'s body as JSON without ever buffering past `maxBytes`. Prefers streaming via
+ * `resp.body`'s reader (what a real `fetch()` `Response` provides), rejecting mid-stream once the
+ * cap is exceeded rather than buffering a huge response whole first; falls back to `resp.text()`
+ * (still byte-checked before parsing) for response-like test doubles that expose no reader. A body
+ * that isn't valid JSON resolves to `{}` rather than throwing — a malformed daemon response should
+ * surface as a normal non-2xx/shape mismatch to the caller, not an opaque parse exception.
+ */
+async function readJsonWithLimit(resp, maxBytes) {
+    const contentLength = resp.headers?.get?.('content-length');
+    if (contentLength !== null && contentLength !== undefined) {
+        const declared = Number(contentLength);
+        if (Number.isFinite(declared) && declared > maxBytes)
+            throw new DaemonResponseTooLargeError(maxBytes);
+    }
+    const body = resp.body;
+    if (body != null && typeof body.getReader === 'function') {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let text = '';
+        let total = 0;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value !== undefined) {
+                    total += value.byteLength;
+                    if (total > maxBytes)
+                        throw new DaemonResponseTooLargeError(maxBytes);
+                    text += decoder.decode(value, { stream: true });
+                }
+            }
+            text += decoder.decode();
+        }
+        finally {
+            reader.releaseLock();
+        }
+        return parseJsonLoose(text);
+    }
+    const text = await resp.text();
+    if (Buffer.byteLength(text, 'utf8') > maxBytes)
+        throw new DaemonResponseTooLargeError(maxBytes);
+    return parseJsonLoose(text);
+}
+/** Formats a `fetch()` rejection (network-unreachable) into a message safe to surface as an MCP tool error. */
+function formatConnectionFailure(err, baseUrl) {
+    const cause = err !== null && typeof err === 'object' ? err.cause : null;
+    const code = cause !== null && typeof cause === 'object' && typeof cause.code === 'string'
+        ? cause.code
+        : null;
+    if (code === 'ECONNREFUSED' || code === 'ENOTFOUND') {
+        return `cannot reach the daemon at ${baseUrl}. Is it running?`;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return sanitizeUntrustedText(message);
+}
+/** Formats a non-2xx daemon response into a message safe to surface as an MCP tool error. */
+function formatDaemonHttpError(status, url, data) {
+    const envelope = data;
+    const code = typeof envelope.error?.code === 'string' ? envelope.error.code : undefined;
+    const rawMessage = typeof envelope.error?.message === 'string' ? envelope.error.message : undefined;
+    const detail = rawMessage !== undefined ? sanitizeUntrustedText(rawMessage) : `HTTP ${status}`;
+    return code !== undefined ? `daemon ${status} on ${url}: ${code}: ${detail}` : `daemon ${status} on ${url}: ${detail}`;
+}
+/**
+ * Shared transport core behind {@link getDaemonJson} and {@link postDaemonJson}: fetch
+ * `<baseUrl><route>` with a bounded timeout and response-size cap, and turn a network failure or a
+ * non-2xx daemon response into a thrown, already-redacted `Error` — this function either resolves
+ * with the parsed body or throws. Never calls `process.exit`.
+ */
+async function requestDaemonJson(baseUrl, route, init, options = {}) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxResponseBytes = options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+    const url = `${baseUrl}${route}`;
+    const timeoutController = new AbortController();
+    const timeoutHandle = setTimeout(() => {
+        timeoutController.abort(new Error(`request to ${route} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    // A stdio server turn shouldn't be kept alive purely by this timer.
+    timeoutHandle.unref?.();
+    const signal = options.signal !== undefined ? AbortSignal.any([options.signal, timeoutController.signal]) : timeoutController.signal;
+    try {
+        let resp;
+        try {
+            resp = await fetchImpl(url, {
+                method: init.method,
+                headers: init.method === 'POST' ? { 'content-type': 'application/json', ...options.headers } : { ...options.headers },
+                ...(init.method === 'POST' ? { body: JSON.stringify(init.body ?? {}) } : {}),
+                signal,
+            });
+        }
+        catch (err) {
+            throw new Error(formatConnectionFailure(err, baseUrl));
+        }
+        let data;
+        try {
+            data = await readJsonWithLimit(resp, maxResponseBytes);
+        }
+        catch (err) {
+            if (err instanceof DaemonResponseTooLargeError) {
+                throw new Error(`response from ${url} exceeded the ${err.limitBytes}-byte limit`);
+            }
+            throw err;
+        }
+        if (!resp.ok) {
+            throw new Error(formatDaemonHttpError(resp.status, url, data));
+        }
+        return data;
+    }
+    finally {
+        clearTimeout(timeoutHandle);
+    }
+}
+/** `GET <baseUrl><route>` and return the parsed JSON response, throwing on network failure or a non-2xx status. */
+export async function getDaemonJson(baseUrl, route, options) {
+    return requestDaemonJson(baseUrl, route, { method: 'GET' }, options);
+}
+/** `POST body` (JSON-serialized) to `<baseUrl><route>` and return the parsed JSON response, throwing on network failure or a non-2xx status. */
+export async function postDaemonJson(baseUrl, route, body, options) {
+    return requestDaemonJson(baseUrl, route, { method: 'POST', body }, options);
+}
+//# sourceMappingURL=daemon-client.js.map

package/dist/server/daemon-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-client.js","sourceRoot":"","sources":["../../src/server/daemon-client.ts"],"names":[],"mappings":"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"}

package/dist/server/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module @jini-ai/mcp/server
+ * Sub-barrel for the MCP tool-hosting mechanism: the pure tool protocol
+ * layer (`tool-protocol.ts`), the pure resource protocol layer
+ * (`resource-protocol.ts`), the daemon transport (`daemon-client.ts`), the
+ * `Server`/`StdioServerTransport` wiring (`tool-server.ts`), the concrete
+ * kernel-run tool defs (`tools/run-tools.ts`), the concrete kernel
+ * resource defs (`resources/active-resource.ts`), and the delegated-tool
+ * execution def (`tools/delegated-tool.ts`).
+ */
+export * from './tool-protocol.js';
+export * from './resource-protocol.js';
+export * from './daemon-client.js';
+export * from './tool-server.js';
+export * from './tools/run-tools.js';
+export * from './tools/delegated-tool.js';
+export * from './resources/active-resource.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC"}

package/dist/server/index.js

@@ -0,0 +1,18 @@
+/**
+ * @module @jini-ai/mcp/server
+ * Sub-barrel for the MCP tool-hosting mechanism: the pure tool protocol
+ * layer (`tool-protocol.ts`), the pure resource protocol layer
+ * (`resource-protocol.ts`), the daemon transport (`daemon-client.ts`), the
+ * `Server`/`StdioServerTransport` wiring (`tool-server.ts`), the concrete
+ * kernel-run tool defs (`tools/run-tools.ts`), the concrete kernel
+ * resource defs (`resources/active-resource.ts`), and the delegated-tool
+ * execution def (`tools/delegated-tool.ts`).
+ */
+export * from './tool-protocol.js';
+export * from './resource-protocol.js';
+export * from './daemon-client.js';
+export * from './tool-server.js';
+export * from './tools/run-tools.js';
+export * from './tools/delegated-tool.js';
+export * from './resources/active-resource.js';
+//# sourceMappingURL=index.js.map

package/dist/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC"}

package/dist/server/resource-protocol.d.ts

@@ -0,0 +1,38 @@
+import type { ReadResourceResult, Resource } from '@modelcontextprotocol/sdk/types.js';
+import type { McpToolContext } from './tool-protocol.js';
+/** What one resource's `read` returns before this module wraps it into the MCP wire shape. */
+export interface McpResourceReadResult {
+    readonly text: string;
+    /** Overrides the resource def's own `mimeType` for this particular read. Rarely needed — most resources have a fixed content type. */
+    readonly mimeType?: string;
+}
+/**
+ * One read-only MCP resource a `createMcpToolServer` caller registers. `uri` must be unique within
+ * a given resource list (`buildResourceIndex` throws otherwise, mirroring `buildToolIndex`'s
+ * duplicate-name guard). Unlike a tool, a resource takes no caller-supplied arguments — it is
+ * addressed purely by its static `uri`.
+ */
+export interface McpResourceDef {
+    readonly uri: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly mimeType?: string;
+    readonly read: (ctx: McpToolContext) => Promise<McpResourceReadResult> | McpResourceReadResult;
+}
+/** Projects a resource list into the `Resource[]` shape `resources/list` returns. */
+export declare function resourcesToList(resources: readonly McpResourceDef[]): Resource[];
+/** Builds a uri -> def lookup, throwing if two resources in `resources` share a uri (a caller-configuration bug, surfaced eagerly at server-construction time rather than letting the second registration shadow the first). */
+export declare function buildResourceIndex(resources: readonly McpResourceDef[]): Map<string, McpResourceDef>;
+/**
+ * `resources/read` dispatch: looks up `uri` in `resources` and runs its `read`. Unlike
+ * {@link import('./tool-protocol.js').handleToolCall}, a failure here *throws* rather than
+ * returning an `{isError:true}` result — MCP resources have no such protocol-level "soft failure"
+ * content shape; an unknown uri or a read failure is meant to surface as a JSON-RPC error response,
+ * matching both the MCP spec's `resources/read` contract and the OD origin's own
+ * `ReadResourceRequestSchema` handler (which likewise just threw a plain `Error` on an unrecognized
+ * uri). The thrown message is passed through {@link sanitizeUntrustedText} unconditionally before
+ * it leaves this function, the same conservative posture `handleToolCall` uses — a `read`
+ * implementation may re-throw text that traces back to an untrusted daemon response.
+ */
+export declare function handleResourceRead(uri: string, resources: ReadonlyMap<string, McpResourceDef>, ctx: McpToolContext): Promise<ReadResourceResult>;
+//# sourceMappingURL=resource-protocol.d.ts.map

package/dist/server/resource-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-protocol.d.ts","sourceRoot":"","sources":["../../src/server/resource-protocol.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AACvF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,8FAA8F;AAC9F,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sIAAsI;IACtI,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,qBAAqB,CAAC,GAAG,qBAAqB,CAAC;CAChG;AAED,qFAAqF;AACrF,wBAAgB,eAAe,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,GAAG,QAAQ,EAAE,CAOhF;AAED,gOAAgO;AAChO,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CASpG;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,EAC9C,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,kBAAkB,CAAC,CAsB7B"}

package/dist/server/resource-protocol.js

@@ -0,0 +1,68 @@
+/**
+ * @module @jini-ai/mcp/server/resource-protocol
+ *
+ * The pure, SDK-connection-free half of the MCP *resource* surface —
+ * mirrors `./tool-protocol.js` for `resources/list` and `resources/read`.
+ * A resource is read-only, addressed by a static `uri` with no arguments,
+ * and returns text content; `./tool-server.js` is the thin layer that wires
+ * this to a real `Server`'s `ListResourcesRequestSchema`/
+ * `ReadResourceRequestSchema` handlers, exactly as `tool-protocol.js` is
+ * wired to `ListToolsRequestSchema`/`CallToolRequestSchema`.
+ */
+import { sanitizeUntrustedText } from '@jini-ai/cli';
+/** Projects a resource list into the `Resource[]` shape `resources/list` returns. */
+export function resourcesToList(resources) {
+    return resources.map((resource) => ({
+        uri: resource.uri,
+        name: resource.name,
+        ...(resource.description !== undefined ? { description: resource.description } : {}),
+        ...(resource.mimeType !== undefined ? { mimeType: resource.mimeType } : {}),
+    }));
+}
+/** Builds a uri -> def lookup, throwing if two resources in `resources` share a uri (a caller-configuration bug, surfaced eagerly at server-construction time rather than letting the second registration shadow the first). */
+export function buildResourceIndex(resources) {
+    const index = new Map();
+    for (const resource of resources) {
+        if (index.has(resource.uri)) {
+            throw new Error(`createMcpToolServer: duplicate resource uri "${resource.uri}"`);
+        }
+        index.set(resource.uri, resource);
+    }
+    return index;
+}
+/**
+ * `resources/read` dispatch: looks up `uri` in `resources` and runs its `read`. Unlike
+ * {@link import('./tool-protocol.js').handleToolCall}, a failure here *throws* rather than
+ * returning an `{isError:true}` result — MCP resources have no such protocol-level "soft failure"
+ * content shape; an unknown uri or a read failure is meant to surface as a JSON-RPC error response,
+ * matching both the MCP spec's `resources/read` contract and the OD origin's own
+ * `ReadResourceRequestSchema` handler (which likewise just threw a plain `Error` on an unrecognized
+ * uri). The thrown message is passed through {@link sanitizeUntrustedText} unconditionally before
+ * it leaves this function, the same conservative posture `handleToolCall` uses — a `read`
+ * implementation may re-throw text that traces back to an untrusted daemon response.
+ */
+export async function handleResourceRead(uri, resources, ctx) {
+    const resource = resources.get(uri);
+    if (resource === undefined) {
+        throw new Error(`unsupported resource URI: ${uri}`);
+    }
+    let result;
+    try {
+        result = await resource.read(ctx);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(sanitizeUntrustedText(message));
+    }
+    const mimeType = result.mimeType ?? resource.mimeType;
+    return {
+        contents: [
+            {
+                uri,
+                text: result.text,
+                ...(mimeType !== undefined ? { mimeType } : {}),
+            },
+        ],
+    };
+}
+//# sourceMappingURL=resource-protocol.js.map

package/dist/server/resource-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-protocol.js","sourceRoot":"","sources":["../../src/server/resource-protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAyBrD,qFAAqF;AACrF,MAAM,UAAU,eAAe,CAAC,SAAoC;IAClE,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAClC,GAAG,EAAE,QAAQ,CAAC,GAAG;QACjB,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,GAAG,CAAC,QAAQ,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACpF,GAAG,CAAC,QAAQ,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC5E,CAAC,CAAC,CAAC;AACN,CAAC;AAED,gOAAgO;AAChO,MAAM,UAAU,kBAAkB,CAAC,SAAoC;IACrE,MAAM,KAAK,GAAG,IAAI,GAAG,EAA0B,CAAC;IAChD,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,IAAI,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,gDAAgD,QAAQ,CAAC,GAAG,GAAG,CAAC,CAAC;QACnF,CAAC;QACD,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,GAAW,EACX,SAA8C,EAC9C,GAAmB;IAEnB,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,6BAA6B,GAAG,EAAE,CAAC,CAAC;IACtD,CAAC;IACD,IAAI,MAA6B,CAAC;IAClC,IAAI,CAAC;QACH,MAAM,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACpC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACjE,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAC;IAClD,CAAC;IACD,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,QAAQ,CAAC,QAAQ,CAAC;IACtD,OAAO;QACL,QAAQ,EAAE;YACR;gBACE,GAAG;gBACH,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aAChD;SACF;KACF,CAAC;AACJ,CAAC"}

package/dist/server/resources/active-resource.d.ts

@@ -0,0 +1,12 @@
+import type { McpResourceDef } from '../resource-protocol.js';
+/**
+ * `jini://active` -> `GET /api/active`. Returns the raw daemon payload as formatted JSON text,
+ * unchanged — unlike `getActiveContextTool`, this does not add a conversational hint when
+ * `active:false`; a resource is meant to be raw structured data a client attaches to context, not
+ * a model-facing tool result, matching the OD origin's own `od://focus/active` handler (which also
+ * returned the raw `/api/active` body with no special-casing).
+ */
+export declare const activeContextResource: McpResourceDef;
+/** The full set of kernel resource defs this package ships, ready to pass as `createMcpToolServer`'s `resources` option. */
+export declare const KERNEL_RESOURCES: readonly McpResourceDef[];
+//# sourceMappingURL=active-resource.d.ts.map

package/dist/server/resources/active-resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-resource.d.ts","sourceRoot":"","sources":["../../../src/server/resources/active-resource.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAO9D;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAUnC,CAAC;AAEF,4HAA4H;AAC5H,eAAO,MAAM,gBAAgB,EAAE,SAAS,cAAc,EAA4B,CAAC"}

package/dist/server/resources/active-resource.js

@@ -0,0 +1,46 @@
+/**
+ * @module @jini-ai/mcp/server/resources/active-resource
+ *
+ * The one MCP *resource* this package ships: a read-only pointer to
+ * `GET /api/active` (`packages/http/src/active-context.ts`'s `getActiveRoute`)
+ * — the same underlying data `../tools/run-tools.js`'s `getActiveContextTool`
+ * already proxies as a *tool*. This is not redundant: OD's origin
+ * (`apps/daemon/src/mcp.ts`) exposed the identical `/api/active` payload
+ * both ways — as the `get_active_context` tool (already ported, see
+ * `../tools/run-tools.js`) AND as the `od://focus/active` resource (its
+ * `ListResourcesRequestSchema`/`ReadResourceRequestSchema` handlers) —
+ * because tools and resources serve different MCP client affordances: a
+ * tool is invoked by the model mid-conversation, while a resource can be
+ * listed and attached to context by the user/client without any tool call.
+ * This module is that second affordance for the same primitive. See
+ * `source-map.md`'s 2026-07-21 addition for why the rest of OD's resource
+ * surface (`od://skills/...`, `od://design-systems/...`) was NOT ported the
+ * same way (both require a Skill/DesignSystem noun this kernel doesn't have).
+ *
+ * Security posture matches every other tool/resource in this package: no
+ * separate authorization mechanism here — whatever `@jini-ai/http`'s
+ * same-origin guard / bearer-auth middleware already enforces on
+ * `GET /api/active` is the only gate a read of this resource passes
+ * through.
+ */
+import { getDaemonJson } from '../daemon-client.js';
+/**
+ * `jini://active` -> `GET /api/active`. Returns the raw daemon payload as formatted JSON text,
+ * unchanged — unlike `getActiveContextTool`, this does not add a conversational hint when
+ * `active:false`; a resource is meant to be raw structured data a client attaches to context, not
+ * a model-facing tool result, matching the OD origin's own `od://focus/active` handler (which also
+ * returned the raw `/api/active` body with no special-casing).
+ */
+export const activeContextResource = {
+    uri: 'jini://active',
+    name: 'Active context',
+    description: 'The resource (resourceRef) plus optional detail the caller last recorded as its current focus via POST /api/active — the same generic, product-neutral pointer the get_active_context tool proxies, exposed here as an attachable MCP resource instead of a tool call.',
+    mimeType: 'application/json',
+    read: async (ctx) => {
+        const data = await getDaemonJson(ctx.baseUrl, '/api/active', { fetchImpl: ctx.fetchImpl });
+        return { text: JSON.stringify(data, null, 2) };
+    },
+};
+/** The full set of kernel resource defs this package ships, ready to pass as `createMcpToolServer`'s `resources` option. */
+export const KERNEL_RESOURCES = [activeContextResource];
+//# sourceMappingURL=active-resource.js.map

package/dist/server/resources/active-resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-resource.js","sourceRoot":"","sources":["../../../src/server/resources/active-resource.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAQpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAmB;IACnD,GAAG,EAAE,eAAe;IACpB,IAAI,EAAE,gBAAgB;IACtB,WAAW,EACT,wQAAwQ;IAC1Q,QAAQ,EAAE,kBAAkB;IAC5B,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;QAClB,MAAM,IAAI,GAAG,MAAM,aAAa,CAAuB,GAAG,CAAC,OAAO,EAAE,aAAa,EAAE,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC;QACjH,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;IACjD,CAAC;CACF,CAAC;AAEF,4HAA4H;AAC5H,MAAM,CAAC,MAAM,gBAAgB,GAA8B,CAAC,qBAAqB,CAAC,CAAC"}

package/dist/server/tool-protocol.d.ts

@@ -0,0 +1,45 @@
+import type { CallToolResult, Tool } from '@modelcontextprotocol/sdk/types.js';
+/** What every tool handler receives alongside its parsed arguments. */
+export interface McpToolContext {
+    /** The resolved daemon HTTP base URL (no trailing slash), fixed for the lifetime of one server run. */
+    readonly baseUrl: string;
+    /** Defaults to the global `fetch`; threaded through so a host can inject its own (e.g. for tests). */
+    readonly fetchImpl: typeof fetch;
+}
+/**
+ * One MCP tool a `createMcpToolServer` caller registers. `name` must be unique within a given
+ * tool list (`buildToolIndex` throws otherwise — a caller bug, not something to silently drop).
+ * `handler` returns a JSON-serializable payload on success or throws an `Error` (or any value —
+ * non-`Error` throws are stringified) on failure; both are converted to the matching MCP
+ * `CallToolResult` shape by {@link handleToolCall}, so individual tools never construct MCP
+ * protocol objects themselves.
+ */
+export interface McpToolDef<Args extends Record<string, unknown> = Record<string, unknown>> {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Tool['inputSchema'];
+    readonly annotations?: Tool['annotations'];
+    readonly handler: (args: Args, ctx: McpToolContext) => Promise<unknown> | unknown;
+}
+/** Wraps a successful tool result as MCP `text` content, JSON-stringifying anything that isn't already a string. */
+export declare function okResult(payload: unknown): CallToolResult;
+/** Wraps a tool failure as an MCP `isError` result. */
+export declare function errorResult(message: string): CallToolResult;
+/** Throws a caller-facing validation error unless `value` is a non-empty string. Mirrors the OD origin's `requireString` — a convenience for tool authors, not part of the MCP protocol itself. */
+export declare function requireString(value: unknown, name: string): asserts value is string;
+/** Projects a tool list into the `Tool[]` shape `tools/list` returns. */
+export declare function toolsToList(tools: readonly McpToolDef[]): Tool[];
+/** Builds a name -> def lookup, throwing if two tools in `tools` share a name (a caller-configuration bug, surfaced eagerly at server-construction time rather than silently letting the second registration shadow the first). */
+export declare function buildToolIndex(tools: readonly McpToolDef[]): Map<string, McpToolDef>;
+/**
+ * `tools/call` dispatch: looks up `name` in `tools`, runs its handler against `rawArgs`, and
+ * converts the outcome to a `CallToolResult` — an unknown tool name or a thrown error both
+ * produce an `{isError:true}` result rather than rejecting, matching MCP's convention that tool
+ * failures are protocol-level results, not JSON-RPC errors. A thrown error's message is passed
+ * through {@link sanitizeUntrustedText} before it reaches the result: `handler` may re-throw text
+ * that ultimately traces back to the daemon (untrusted network peer), and a caller-thrown
+ * validation error is cheap to sanitize unconditionally rather than trying to prove which case
+ * applies at each call site.
+ */
+export declare function handleToolCall(name: string, rawArgs: Record<string, unknown> | undefined, tools: ReadonlyMap<string, McpToolDef>, ctx: McpToolContext): Promise<CallToolResult>;
+//# sourceMappingURL=tool-protocol.d.ts.map

package/dist/server/tool-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-protocol.d.ts","sourceRoot":"","sources":["../../src/server/tool-protocol.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAE/E,uEAAuE;AACvE,MAAM,WAAW,cAAc;IAC7B,uGAAuG;IACvG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,sGAAsG;IACtG,QAAQ,CAAC,SAAS,EAAE,OAAO,KAAK,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACxF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CACnF;AAED,oHAAoH;AACpH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,cAAc,CAGzD;AAED,uDAAuD;AACvD,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAE3D;AAED,mMAAmM;AACnM,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAInF;AAED,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI,EAAE,CAOhE;AAED,mOAAmO;AACnO,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CASpF;AAED;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC5C,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,EACtC,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,cAAc,CAAC,CAYzB"}

package/dist/server/tool-protocol.js

@@ -0,0 +1,74 @@
+/**
+ * @module @jini-ai/mcp/server/tool-protocol
+ *
+ * The pure, SDK-connection-free half of the MCP tool-hosting mechanism: the
+ * `McpToolDef` contract a caller registers tools against, `tools/list`
+ * projection, and `tools/call` dispatch (look up a tool by name, run its
+ * handler, wrap the result). None of this touches `@modelcontextprotocol/sdk`'s
+ * `Server`/transport classes or the network — a tool `handler` is just
+ * `(args, ctx) => value | Promise<value>` that either returns a
+ * JSON-serializable payload (wrapped as a successful MCP result) or throws
+ * (wrapped as an `{isError:true}` MCP result). `./tool-server.js` is the thin
+ * layer that wires this to a real `Server` + `StdioServerTransport`.
+ */
+import { sanitizeUntrustedText } from '@jini-ai/cli';
+/** Wraps a successful tool result as MCP `text` content, JSON-stringifying anything that isn't already a string. */
+export function okResult(payload) {
+    const text = typeof payload === 'string' ? payload : JSON.stringify(payload, null, 2);
+    return { content: [{ type: 'text', text }] };
+}
+/** Wraps a tool failure as an MCP `isError` result. */
+export function errorResult(message) {
+    return { isError: true, content: [{ type: 'text', text: message }] };
+}
+/** Throws a caller-facing validation error unless `value` is a non-empty string. Mirrors the OD origin's `requireString` — a convenience for tool authors, not part of the MCP protocol itself. */
+export function requireString(value, name) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`${name} is required (string).`);
+    }
+}
+/** Projects a tool list into the `Tool[]` shape `tools/list` returns. */
+export function toolsToList(tools) {
+    return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        ...(tool.annotations !== undefined ? { annotations: tool.annotations } : {}),
+    }));
+}
+/** Builds a name -> def lookup, throwing if two tools in `tools` share a name (a caller-configuration bug, surfaced eagerly at server-construction time rather than silently letting the second registration shadow the first). */
+export function buildToolIndex(tools) {
+    const index = new Map();
+    for (const tool of tools) {
+        if (index.has(tool.name)) {
+            throw new Error(`createMcpToolServer: duplicate tool name "${tool.name}"`);
+        }
+        index.set(tool.name, tool);
+    }
+    return index;
+}
+/**
+ * `tools/call` dispatch: looks up `name` in `tools`, runs its handler against `rawArgs`, and
+ * converts the outcome to a `CallToolResult` — an unknown tool name or a thrown error both
+ * produce an `{isError:true}` result rather than rejecting, matching MCP's convention that tool
+ * failures are protocol-level results, not JSON-RPC errors. A thrown error's message is passed
+ * through {@link sanitizeUntrustedText} before it reaches the result: `handler` may re-throw text
+ * that ultimately traces back to the daemon (untrusted network peer), and a caller-thrown
+ * validation error is cheap to sanitize unconditionally rather than trying to prove which case
+ * applies at each call site.
+ */
+export async function handleToolCall(name, rawArgs, tools, ctx) {
+    const tool = tools.get(name);
+    if (tool === undefined) {
+        return errorResult(`unknown tool: ${name}`);
+    }
+    try {
+        const result = await tool.handler(rawArgs ?? {}, ctx);
+        return okResult(result);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return errorResult(sanitizeUntrustedText(message));
+    }
+}
+//# sourceMappingURL=tool-protocol.js.map

package/dist/server/tool-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-protocol.js","sourceRoot":"","sources":["../../src/server/tool-protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AA2BrD,oHAAoH;AACpH,MAAM,UAAU,QAAQ,CAAC,OAAgB;IACvC,MAAM,IAAI,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IACtF,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;AAC/C,CAAC;AAED,uDAAuD;AACvD,MAAM,UAAU,WAAW,CAAC,OAAe;IACzC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;AACvE,CAAC;AAED,mMAAmM;AACnM,MAAM,UAAU,aAAa,CAAC,KAAc,EAAE,IAAY;IACxD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACpD,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,wBAAwB,CAAC,CAAC;IACnD,CAAC;AACH,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,WAAW,CAAC,KAA4B;IACtD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAC1B,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,GAAG,CAAC,IAAI,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC7E,CAAC,CAAC,CAAC;AACN,CAAC;AAED,mOAAmO;AACnO,MAAM,UAAU,cAAc,CAAC,KAA4B;IACzD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAsB,CAAC;IAC5C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,6CAA6C,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;QAC7E,CAAC;QACD,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC7B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,IAAY,EACZ,OAA4C,EAC5C,KAAsC,EACtC,GAAmB;IAEnB,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC7B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,OAAO,WAAW,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC;IAC9C,CAAC;IACD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,EAAE,GAAG,CAAC,CAAC;QACtD,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACjE,OAAO,WAAW,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAC;IACrD,CAAC;AACH,CAAC"}