@jini-ai/mcp 0.1.0

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

@@ -0,0 +1,105 @@
+/**
+ * @module @jini-ai/mcp/server/tool-server
+ *
+ * `createMcpToolServer` — the generic stdio MCP server hosting mechanism.
+ * Ported from the *mechanism* of OD's `apps/daemon/src/mcp.ts` `runMcpStdio`
+ * (idle-exit lifecycle, `Server` + `StdioServerTransport` wiring, holding the
+ * process open until stdin closes) with the OD-specific parts — the
+ * hardcoded 18-tool `TOOL_DEFS`, the `od://` resource scheme, the
+ * project/skill/plugin `instructions` prose — replaced by a caller-supplied,
+ * bounded, explicit `tools: readonly McpToolDef[]` list. A caller is the
+ * *first* user of this mechanism, not the only one it will ever support (see
+ * `source-map.md`'s 2026-07-21 addition for the full design-decision note).
+ *
+ * `tools` capability is always advertised (`capabilities: {tools: {}}`).
+ * `resources` capability (`ListResourcesRequestSchema`/
+ * `ReadResourceRequestSchema`, mirroring the tools wiring one section down)
+ * is advertised only when the caller supplies at least one entry in the
+ * optional `resources` option — a 2026-07-21 addition once this package
+ * shipped its first genuinely portable resource (`../resources/
+ * active-resource.js`'s `jini://active`, see that file's module doc and
+ * `source-map.md`'s 2026-07-21 addition for why the *rest* of OD's resource
+ * surface — `od://skills/...`, `od://design-systems/...` — still has no
+ * kernel equivalent and stays unported). A caller passing no `resources`
+ * gets the exact same `capabilities: {tools: {}}`-only server this module
+ * always produced.
+ */
+import type { Readable, Writable } from 'node:stream';
+import type { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult, Implementation, ListResourcesResult, ListToolsResult, ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import { type McpResourceDef } from './resource-protocol.js';
+import { type McpToolDef } from './tool-protocol.js';
+/**
+ * The minimal surface this module needs from an MCP `Server` instance. A real
+ * `@modelcontextprotocol/sdk` `Server` satisfies this structurally (its own `setRequestHandler`
+ * is more general — one generic method covering every request schema — and TS accepts the
+ * narrowing); a test can substitute a lightweight fake without spinning up a real transport.
+ * Method-shorthand syntax (not arrow-typed properties) is deliberate: it keeps parameter checking
+ * bivariant, so a handler typed against a *specific* request shape (as the two internal handlers
+ * below are) is still assignable here even under `strict`.
+ */
+export interface McpServerLike {
+    setRequestHandler(schema: typeof ListToolsRequestSchema, handler: () => Promise<ListToolsResult>): void;
+    setRequestHandler(schema: typeof CallToolRequestSchema, handler: (request: {
+        params: {
+            name: string;
+            arguments?: Record<string, unknown>;
+        };
+    }) => Promise<CallToolResult>): void;
+    setRequestHandler(schema: typeof ListResourcesRequestSchema, handler: () => Promise<ListResourcesResult>): void;
+    setRequestHandler(schema: typeof ReadResourceRequestSchema, handler: (request: {
+        params: {
+            uri: string;
+        };
+    }) => Promise<ReadResourceResult>): void;
+    connect(transport: McpTransportLike): Promise<void>;
+}
+/** The minimal surface this module needs from an MCP transport. A real `StdioServerTransport` satisfies this structurally. */
+export interface McpTransportLike {
+    onmessage?: ((message: unknown) => void) | undefined;
+    onclose?: (() => void) | undefined;
+    close(): Promise<void>;
+}
+export interface McpToolServerOptions {
+    /** Advertised to the MCP client during initialization. */
+    readonly name: string;
+    readonly version: string;
+    /** The bounded, explicit tool list this server hosts. Duplicate names throw at construction time. */
+    readonly tools: readonly McpToolDef[];
+    /** The bounded, explicit read-only resource list this server hosts. Duplicate uris throw at construction time. Omit (or pass an empty array) for a tools-only server — `capabilities.resources` is only advertised when this is non-empty. */
+    readonly resources?: readonly McpResourceDef[];
+    /** Resolves the daemon HTTP base URL once, at the start of {@link McpToolServerHandle.run}. May be sync or async (e.g. wraps `@jini-ai/cli`'s `resolveDaemonUrl`). */
+    readonly resolveBaseUrl: () => Promise<string> | string;
+    /** Free-text guidance surfaced to the MCP client alongside the tool list. Optional — omit for a caller with nothing to add beyond each tool's own `description`. */
+    readonly instructions?: string;
+    /** Idle-exit window in ms. Defaults to {@link DEFAULT_IDLE_MS}. */
+    readonly idleMs?: number;
+    /** Defaults to the global `fetch`; threaded into every tool call's {@link McpToolContext}. */
+    readonly fetchImpl?: typeof fetch;
+    /** Defaults to `process.stdin`; inject for tests (or an alternate stdio pair). */
+    readonly stdin?: Readable;
+    /** Defaults to `process.stdout`; inject for tests. */
+    readonly stdout?: Writable;
+    /** Test/embedding seam: builds the underlying `Server`. Defaults to the real `@modelcontextprotocol/sdk` `Server`. */
+    readonly createServer?: (info: Implementation, options: ServerOptions) => McpServerLike;
+    /** Test/embedding seam: builds the underlying transport. Defaults to the real `StdioServerTransport`. */
+    readonly createTransport?: (stdin?: Readable, stdout?: Writable) => McpTransportLike;
+}
+export interface McpToolServerHandle {
+    /**
+     * Resolves the daemon base URL, connects the MCP server to its transport, and holds the process
+     * open until the client disconnects (stdin EOF) or the idle-exit window elapses. Resolves once
+     * the transport has closed.
+     */
+    run(): Promise<void>;
+}
+/**
+ * Builds a stdio MCP server hosting `options.tools` (and, optionally, `options.resources`).
+ * Construction is synchronous and cheap (validates tool-name uniqueness via
+ * {@link buildToolIndex} and resource-uri uniqueness via {@link buildResourceIndex}); all I/O —
+ * resolving the daemon URL, connecting the transport, serving requests — happens in the returned
+ * handle's `run()`.
+ */
+export declare function createMcpToolServer(options: McpToolServerOptions): McpToolServerHandle;
+//# sourceMappingURL=tool-server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-server.d.ts","sourceRoot":"","sources":["../../src/server/tool-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAE/E,OAAO,EACL,qBAAqB,EACrB,0BAA0B,EAC1B,sBAAsB,EACtB,yBAAyB,EAC1B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EACV,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EACnB,MAAM,oCAAoC,CAAC;AAE5C,OAAO,EAA2D,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACtH,OAAO,EAAoE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAKvH;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,iBAAiB,CAAC,MAAM,EAAE,OAAO,sBAAsB,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;IACxG,iBAAiB,CACf,MAAM,EAAE,OAAO,qBAAqB,EACpC,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;SAAE,CAAA;KAAE,KAAK,OAAO,CAAC,cAAc,CAAC,GAC/G,IAAI,CAAC;IACR,iBAAiB,CAAC,MAAM,EAAE,OAAO,0BAA0B,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAAC;IAChH,iBAAiB,CACf,MAAM,EAAE,OAAO,yBAAyB,EACxC,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,KAAK,OAAO,CAAC,kBAAkB,CAAC,GAC7E,IAAI,CAAC;IACR,OAAO,CAAC,SAAS,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrD;AAED,8HAA8H;AAC9H,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IACrD,OAAO,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IACnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,qGAAqG;IACrG,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;IACtC,8OAA8O;IAC9O,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC/C,sKAAsK;IACtK,QAAQ,CAAC,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;IACxD,oKAAoK;IACpK,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,8FAA8F;IAC9F,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IAClC,kFAAkF;IAClF,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC;IAC1B,sDAAsD;IACtD,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC;IAC3B,sHAAsH;IACtH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,aAAa,KAAK,aAAa,CAAC;IACxF,yGAAyG;IACzG,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,QAAQ,KAAK,gBAAgB,CAAC;CACtF;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACtB;AAUD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,mBAAmB,CAmGtF"}

package/dist/server/tool-server.js

@@ -0,0 +1,96 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { createMcpIdleExitController } from '../client/client.js';
+import { buildResourceIndex, handleResourceRead, resourcesToList } from './resource-protocol.js';
+import { buildToolIndex, handleToolCall, toolsToList } from './tool-protocol.js';
+/** Auto-exit an idle server after this long with no tool activity — same ceiling the OD origin used for its own stdio MCP server. */
+const DEFAULT_IDLE_MS = 30 * 60 * 1000;
+function defaultCreateServer(info, options) {
+    return new Server(info, options);
+}
+function defaultCreateTransport(stdin, stdout) {
+    return new StdioServerTransport(stdin, stdout);
+}
+/**
+ * Builds a stdio MCP server hosting `options.tools` (and, optionally, `options.resources`).
+ * Construction is synchronous and cheap (validates tool-name uniqueness via
+ * {@link buildToolIndex} and resource-uri uniqueness via {@link buildResourceIndex}); all I/O —
+ * resolving the daemon URL, connecting the transport, serving requests — happens in the returned
+ * handle's `run()`.
+ */
+export function createMcpToolServer(options) {
+    const toolIndex = buildToolIndex(options.tools);
+    const resources = options.resources ?? [];
+    const resourceIndex = buildResourceIndex(resources);
+    const createServer = options.createServer ?? defaultCreateServer;
+    const createTransport = options.createTransport ?? defaultCreateTransport;
+    return {
+        async run() {
+            const resolvedBaseUrl = await options.resolveBaseUrl();
+            const ctx = {
+                baseUrl: String(resolvedBaseUrl).replace(/\/$/, ''),
+                fetchImpl: options.fetchImpl ?? fetch,
+            };
+            let closeTransportForIdle = null;
+            const idleExit = createMcpIdleExitController({
+                idleMs: options.idleMs ?? DEFAULT_IDLE_MS,
+                onIdle: () => closeTransportForIdle?.(),
+            });
+            const withActivity = (handler) => (...args) => idleExit.trackRequest(() => handler(...args));
+            const server = createServer({ name: options.name, version: options.version }, {
+                capabilities: { tools: {}, ...(resources.length > 0 ? { resources: {} } : {}) },
+                ...(options.instructions !== undefined ? { instructions: options.instructions } : {}),
+            });
+            server.setRequestHandler(ListToolsRequestSchema, withActivity(async () => ({ tools: toolsToList(options.tools) })));
+            server.setRequestHandler(CallToolRequestSchema, withActivity(async (request) => handleToolCall(request.params.name, request.params.arguments, toolIndex, ctx)));
+            if (resources.length > 0) {
+                server.setRequestHandler(ListResourcesRequestSchema, withActivity(async () => ({ resources: resourcesToList(resources) })));
+                server.setRequestHandler(ReadResourceRequestSchema, withActivity(async (request) => handleResourceRead(request.params.uri, resourceIndex, ctx)));
+            }
+            const transport = createTransport(options.stdin, options.stdout);
+            try {
+                closeTransportForIdle = () => {
+                    void transport.close().catch(() => { });
+                };
+                await server.connect(transport);
+                // `connect()` sets `transport.onmessage` to its own protocol-dispatch handler; wrap it so
+                // every inbound message also counts as activity for the idle-exit timer, without losing
+                // the SDK's own routing.
+                const sdkOnMessage = transport.onmessage;
+                transport.onmessage = (message) => {
+                    idleExit.noteActivity();
+                    sdkOnMessage?.(message);
+                };
+                const stdin = options.stdin ?? process.stdin;
+                await new Promise((resolve) => {
+                    const sdkOnClose = transport.onclose;
+                    let finished = false;
+                    const done = () => {
+                        if (finished)
+                            return;
+                        finished = true;
+                        idleExit.dispose();
+                        resolve();
+                    };
+                    transport.onclose = () => {
+                        sdkOnClose?.();
+                        done();
+                    };
+                    const closeTransportForStdin = () => {
+                        void transport.close().catch(() => done());
+                    };
+                    // Hold the process open until the client disconnects (stdin EOF) — `connect()` only
+                    // starts the transport, it doesn't wait for the stream to close.
+                    stdin.once('end', closeTransportForStdin);
+                    stdin.once('close', closeTransportForStdin);
+                });
+            }
+            finally {
+                idleExit.dispose();
+                closeTransportForIdle = null;
+            }
+        },
+    };
+}
+//# sourceMappingURL=tool-server.js.map

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

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

package/dist/server/tools/delegated-tool.d.ts

@@ -0,0 +1,15 @@
+import { type McpToolDef } from '../tool-protocol.js';
+export interface CreateExecuteDelegatedToolToolOptions {
+    /** The one run this MCP server process — and therefore this tool instance — is scoped to. */
+    readonly runId: string;
+    /** Generates each call's `toolUseId`. @default node:crypto randomUUID */
+    readonly generateToolUseId?: () => string;
+}
+/**
+ * Builds the `execute_delegated_tool` tool def for one specific `runId`. A fresh MCP server
+ * process (one per spawned `claude` run, see `../../bin/serve.js`) calls this once at startup;
+ * every `tools/call` for the returned def's `name` during that process's lifetime executes
+ * against the same run.
+ */
+export declare function createExecuteDelegatedToolTool(options: CreateExecuteDelegatedToolToolOptions): McpToolDef;
+//# sourceMappingURL=delegated-tool.d.ts.map

package/dist/server/tools/delegated-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegated-tool.d.ts","sourceRoot":"","sources":["../../../src/server/tools/delegated-tool.ts"],"names":[],"mappings":"AA4BA,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAOrE,MAAM,WAAW,qCAAqC;IACpD,6FAA6F;IAC7F,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,MAAM,CAAC;CAC3C;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,qCAAqC,GAAG,UAAU,CAuDzG"}

package/dist/server/tools/delegated-tool.js

@@ -0,0 +1,90 @@
+/**
+ * @module @jini-ai/mcp/server/tools/delegated-tool
+ *
+ * `execute_delegated_tool` — the MCP-callback half of gap 3's continuation transport (see
+ * `packages/daemon/source-map.md`'s "run/chat orchestration gap 3, part 1" addition and this
+ * package's own dated section in `source-map.md` for the rest of the spike). The swarm-consensus
+ * Final Recommendation asked for exactly this: "inject the already-shipped MCP host into one
+ * MCP-capable CLI's launch config, prove a tool round-trip through the existing
+ * `delegated-tool-bridge.ts`." Where `../tools/run-tools.js`'s tools proxy generic
+ * run-lifecycle HTTP endpoints, this tool proxies the new `POST /api/delegated-tool-calls`
+ * daemon route (`packages/http/src/delegated-tools.ts`), which is the one and only thing that
+ * calls into `createDelegatedToolBridge` (`packages/daemon/src/delegated-tool-bridge.ts`) — the
+ * same `ToolExecutor` deny-by-default gate every other tool-execution path in this codebase
+ * already uses. No parallel authorization mechanism is introduced anywhere on this path.
+ *
+ * Unlike every other tool this package ships (`run-tools.ts`'s five tools, plain static
+ * objects), this one is a **factory**. The MCP server subprocess a `claude` run spawns via
+ * `.mcp.json` (see `../../bin/serve.js`) is scoped to exactly one `runId` for its entire
+ * lifetime — the daemon injected that run id into the subprocess's own environment at spawn
+ * time, before the model ever said a word. `runId` is therefore closed over at construction
+ * time, not accepted as a per-call tool argument: a model has no legitimate way to pick, or
+ * need to know, which run it is currently inside, and letting it supply one would open a
+ * confused-deputy path (one run's MCP subprocess executing a tool call "as" a different run).
+ * `toolUseId` is likewise generated per call (`randomUUID` by default), not model-supplied — a
+ * model has no legitimate reason to choose its own correlation id either.
+ */
+import { randomUUID } from 'node:crypto';
+import { postDaemonJson } from '../daemon-client.js';
+import { requireString } from '../tool-protocol.js';
+/**
+ * Builds the `execute_delegated_tool` tool def for one specific `runId`. A fresh MCP server
+ * process (one per spawned `claude` run, see `../../bin/serve.js`) calls this once at startup;
+ * every `tools/call` for the returned def's `name` during that process's lifetime executes
+ * against the same run.
+ */
+export function createExecuteDelegatedToolTool(options) {
+    const { runId } = options;
+    const generateToolUseId = options.generateToolUseId ?? randomUUID;
+    return {
+        name: 'execute_delegated_tool',
+        description: 'Execute a Jini-registered tool (never an agent-vendor-specific tool name) against the current run, routed through the daemon\'s ToolExecutor deny-by-default gate — the same authorization/confirmation/audit path every other tool-execution mechanism in this host uses. Returns {result}, a ToolExecutionResult: {status, output?, truncated?, error?} where status is one of completed|denied|confirmation-denied|timed-out|cancelled|failed.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                toolId: {
+                    type: 'string',
+                    description: 'Jini registry tool id to invoke. Required.',
+                },
+                input: {
+                    // `type` is load-bearing, not decoration. Declared without one, an MCP client has no
+                    // signal that this property carries structured data, and at least one real client
+                    // (Claude Code, observed 2026-07-26) then delivers the model's object as a raw JSON
+                    // *string* — which every Jini tool rejects, because a tool's input is a record or
+                    // absent (`@jini-ai/daemon`'s `toCapabilityInput` refuses a string by name rather than
+                    // coercing it). The effect was that only no-input tools were callable at all.
+                    //
+                    // Object-only is narrower than "arbitrary JSON" and deliberately so: it is exactly
+                    // what every registered tool accepts today, it matches MCP's own convention that tool
+                    // arguments are objects, and widening it later (a union type, say) is additive.
+                    type: 'object',
+                    additionalProperties: true,
+                    description: 'JSON object of input fields for the tool. Optional; omit for a tool that takes no input. Must be an object, not a JSON-encoded string.',
+                },
+            },
+            required: ['toolId'],
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+            title: 'Execute a Jini-registered tool',
+        },
+        handler: async (args, ctx) => {
+            requireString(args.toolId, 'toolId');
+            const body = {
+                runId,
+                toolUseId: generateToolUseId(),
+                toolId: args.toolId,
+                input: args.input,
+            };
+            const data = await postDaemonJson(ctx.baseUrl, '/api/delegated-tool-calls', body, {
+                fetchImpl: ctx.fetchImpl,
+            });
+            return data.result;
+        },
+    };
+}
+//# sourceMappingURL=delegated-tool.js.map

package/dist/server/tools/delegated-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegated-tool.js","sourceRoot":"","sources":["../../../src/server/tools/delegated-tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAmB,MAAM,qBAAqB,CAAC;AAcrE;;;;;GAKG;AACH,MAAM,UAAU,8BAA8B,CAAC,OAA8C;IAC3F,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC;IAC1B,MAAM,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,IAAI,UAAU,CAAC;IAElE,OAAO;QACL,IAAI,EAAE,wBAAwB;QAC9B,WAAW,EACT,mbAAmb;QACrb,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,MAAM,EAAE;oBACN,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,4CAA4C;iBAC1D;gBACD,KAAK,EAAE;oBACL,qFAAqF;oBACrF,kFAAkF;oBAClF,oFAAoF;oBACpF,kFAAkF;oBAClF,uFAAuF;oBACvF,8EAA8E;oBAC9E,EAAE;oBACF,mFAAmF;oBACnF,sFAAsF;oBACtF,gFAAgF;oBAChF,IAAI,EAAE,QAAQ;oBACd,oBAAoB,EAAE,IAAI;oBAC1B,WAAW,EAAE,wIAAwI;iBACtJ;aACF;YACD,QAAQ,EAAE,CAAC,QAAQ,CAAC;YACpB,oBAAoB,EAAE,KAAK;SAC5B;QACD,WAAW,EAAE;YACX,YAAY,EAAE,KAAK;YACnB,cAAc,EAAE,KAAK;YACrB,eAAe,EAAE,KAAK;YACtB,aAAa,EAAE,KAAK;YACpB,KAAK,EAAE,gCAAgC;SACxC;QACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;YAC3B,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YACrC,MAAM,IAAI,GAA4B;gBACpC,KAAK;gBACL,SAAS,EAAE,iBAAiB,EAAE;gBAC9B,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,KAAK,EAAE,IAAI,CAAC,KAAK;aAClB,CAAC;YACF,MAAM,IAAI,GAAG,MAAM,cAAc,CAA+B,GAAG,CAAC,OAAO,EAAE,2BAA2B,EAAE,IAAI,EAAE;gBAC9G,SAAS,EAAE,GAAG,CAAC,SAAS;aACzB,CAAC,CAAC;YACH,OAAO,IAAI,CAAC,MAAM,CAAC;QACrB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/server/tools/run-tools.d.ts

@@ -0,0 +1,14 @@
+import { type McpToolDef } from '../tool-protocol.js';
+/** `start_run` -> `POST /api/runs` (`packages/http/src/runs.ts`'s `runStartRoute`). */
+export declare const startRunTool: McpToolDef;
+/** `get_run` -> `GET /api/runs/:runId` (`packages/http/src/runs.ts`'s `runStatusRoute`). */
+export declare const getRunTool: McpToolDef;
+/** `cancel_run` -> `POST /api/runs/:runId/cancel` (`packages/http/src/runs.ts`'s `runCancelRoute`). */
+export declare const cancelRunTool: McpToolDef;
+/** `get_active_context` -> `GET /api/active` (`packages/http/src/active-context.ts`'s `getActiveRoute`). */
+export declare const getActiveContextTool: McpToolDef;
+/** `list_agents` -> `GET /api/agents` (`packages/http/src/agents.ts`'s `agentListRoute`). */
+export declare const listAgentsTool: McpToolDef;
+/** The full set of kernel-run tool defs this package ships, ready to pass as `createMcpToolServer`'s `tools` option. */
+export declare const RUN_TOOLS: readonly McpToolDef[];
+//# sourceMappingURL=run-tools.d.ts.map

package/dist/server/tools/run-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-tools.d.ts","sourceRoot":"","sources":["../../../src/server/tools/run-tools.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAmBrE,uFAAuF;AACvF,eAAO,MAAM,YAAY,EAAE,UAiC1B,CAAC;AAEF,4FAA4F;AAC5F,eAAO,MAAM,UAAU,EAAE,UAgBxB,CAAC;AAEF,uGAAuG;AACvG,eAAO,MAAM,aAAa,EAAE,UAoB3B,CAAC;AAOF,4GAA4G;AAC5G,eAAO,MAAM,oBAAoB,EAAE,UAgBlC,CAAC;AAEF,6FAA6F;AAC7F,eAAO,MAAM,cAAc,EAAE,UAM5B,CAAC;AAEF,wHAAwH;AACxH,eAAO,MAAM,SAAS,EAAE,SAAS,UAAU,EAM1C,CAAC"}

package/dist/server/tools/run-tools.js

@@ -0,0 +1,142 @@
+/**
+ * @module @jini-ai/mcp/server/tools/run-tools
+ *
+ * The first real, concrete `McpToolDef`s hosted by `createMcpToolServer`
+ * (`../tool-server.js`) — a proxy over `@jini-ai/http`'s already-gated `Run`
+ * transport (`packages/http/src/runs.ts`) plus the generic active-resource
+ * channel (`packages/http/src/active-context.ts`) and the agent-def listing
+ * (`packages/http/src/agents.ts`). Each tool's `handler` does nothing but
+ * validate its own arguments and proxy a single HTTP call via
+ * `../daemon-client.js` — no separate authorization mechanism, no caching,
+ * no state: whatever `@jini-ai/http`'s same-origin guard / bearer-auth
+ * middleware already enforces on the target route is the only gate a call
+ * here passes through (see `source-map.md`'s 2026-07-21 addition for the
+ * full origin-mapping and what was deliberately not ported).
+ */
+import { getDaemonJson, postDaemonJson } from '../daemon-client.js';
+import { requireString } from '../tool-protocol.js';
+const READ_ANNOTATIONS = {
+    readOnlyHint: true,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+const WRITE_ANNOTATIONS = {
+    readOnlyHint: false,
+    idempotentHint: false,
+    destructiveHint: false,
+    openWorldHint: false,
+};
+function optionalNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/** `start_run` -> `POST /api/runs` (`packages/http/src/runs.ts`'s `runStartRoute`). */
+export const startRunTool = {
+    name: 'start_run',
+    description: 'Start a new run against a caller-supplied contextRef (an opaque identity the run belongs to — this kernel has no project/conversation noun, just that one caller-chosen string). Returns {run, started} immediately; poll get_run(run.id) for completion.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            contextRef: {
+                type: 'string',
+                description: 'Opaque caller-supplied identity the run belongs to. Required.',
+            },
+            agentId: {
+                type: 'string',
+                description: 'Which registered agent should drive this run. Optional; the host may default this.',
+            },
+            idempotencyKey: {
+                type: 'string',
+                description: 'Starting twice with the same key returns the original run instead of starting a second one. Optional.',
+            },
+        },
+        required: ['contextRef'],
+        additionalProperties: false,
+    },
+    annotations: { ...WRITE_ANNOTATIONS, title: 'Start a run' },
+    handler: async (args, ctx) => {
+        requireString(args.contextRef, 'contextRef');
+        const body = { contextRef: args.contextRef };
+        const agentId = optionalNonEmptyString(args.agentId);
+        if (agentId !== undefined)
+            body.agentId = agentId;
+        const idempotencyKey = optionalNonEmptyString(args.idempotencyKey);
+        if (idempotencyKey !== undefined)
+            body.idempotencyKey = idempotencyKey;
+        return postDaemonJson(ctx.baseUrl, '/api/runs', body, { fetchImpl: ctx.fetchImpl });
+    },
+};
+/** `get_run` -> `GET /api/runs/:runId` (`packages/http/src/runs.ts`'s `runStatusRoute`). */
+export const getRunTool = {
+    name: 'get_run',
+    description: 'Poll a run started by start_run. Returns {run} with the run\'s current state (queued|running|succeeded|failed|canceled, per @jini-ai/protocol\'s RunState).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            runId: { type: 'string', description: 'Run id returned by start_run.' },
+        },
+        required: ['runId'],
+        additionalProperties: false,
+    },
+    annotations: { ...READ_ANNOTATIONS, title: 'Check a run' },
+    handler: async (args, ctx) => {
+        requireString(args.runId, 'runId');
+        return getDaemonJson(ctx.baseUrl, `/api/runs/${encodeURIComponent(args.runId)}`, { fetchImpl: ctx.fetchImpl });
+    },
+};
+/** `cancel_run` -> `POST /api/runs/:runId/cancel` (`packages/http/src/runs.ts`'s `runCancelRoute`). */
+export const cancelRunTool = {
+    name: 'cancel_run',
+    description: 'Request cancellation of an in-flight run started by start_run. A no-op on an already-terminal run.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            runId: { type: 'string', description: 'Run id returned by start_run.' },
+            reason: { type: 'string', description: 'Optional human-readable cancellation reason.' },
+        },
+        required: ['runId'],
+        additionalProperties: false,
+    },
+    annotations: { ...WRITE_ANNOTATIONS, title: 'Cancel a run' },
+    handler: async (args, ctx) => {
+        requireString(args.runId, 'runId');
+        const body = {};
+        const reason = optionalNonEmptyString(args.reason);
+        if (reason !== undefined)
+            body.reason = reason;
+        return postDaemonJson(ctx.baseUrl, `/api/runs/${encodeURIComponent(args.runId)}/cancel`, body, { fetchImpl: ctx.fetchImpl });
+    },
+};
+/** `get_active_context` -> `GET /api/active` (`packages/http/src/active-context.ts`'s `getActiveRoute`). */
+export const getActiveContextTool = {
+    name: 'get_active_context',
+    description: 'The resource (resourceRef) plus optional detail the caller last recorded as its current focus via POST /api/active — a generic, product-neutral pointer (this kernel has no "project" or "file" noun; a host maps resourceRef to whatever domain object it manages). Returns {active:false} once the pointer has aged past its TTL (5 minutes, see ACTIVE_CONTEXT_TTL_MS in packages/http/src/active-context.ts) or was never set.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    annotations: { ...READ_ANNOTATIONS, title: 'What is the caller focused on?' },
+    handler: async (_args, ctx) => {
+        const data = await getDaemonJson(ctx.baseUrl, '/api/active', { fetchImpl: ctx.fetchImpl });
+        if (data.active !== true) {
+            return {
+                active: false,
+                hint: 'No active resource is currently recorded, or the recorded one aged out (5-minute TTL). Pass an explicit resource reference to other tools instead of relying on this fallback.',
+            };
+        }
+        return data;
+    },
+};
+/** `list_agents` -> `GET /api/agents` (`packages/http/src/agents.ts`'s `agentListRoute`). */
+export const listAgentsTool = {
+    name: 'list_agents',
+    description: 'List every agent def registered with this host\'s @jini-ai/agent-runtime — {id, name} pairs suitable for start_run\'s optional agentId argument. Static registration data only: this does not probe which agent binaries are actually installed on the host machine.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    annotations: { ...READ_ANNOTATIONS, title: 'List registered agents' },
+    handler: async (_args, ctx) => getDaemonJson(ctx.baseUrl, '/api/agents', { fetchImpl: ctx.fetchImpl }),
+};
+/** The full set of kernel-run tool defs this package ships, ready to pass as `createMcpToolServer`'s `tools` option. */
+export const RUN_TOOLS = [
+    startRunTool,
+    getRunTool,
+    cancelRunTool,
+    getActiveContextTool,
+    listAgentsTool,
+];
+//# sourceMappingURL=run-tools.js.map

package/dist/server/tools/run-tools.js.map

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

package/dist/server/tools/tool-catalog-tools.d.ts

@@ -0,0 +1,8 @@
+import { type McpToolDef } from '../tool-protocol.js';
+/** `search_tools` -> `GET /api/tools/search` (`packages/http/src/tool-catalog.ts`'s `toolCatalogSearchRoute`). */
+export declare const searchToolsTool: McpToolDef;
+/** `describe_tool` -> `GET /api/tools/:id` (`packages/http/src/tool-catalog.ts`'s `toolCatalogDescribeRoute`). */
+export declare const describeToolTool: McpToolDef;
+/** Both tool-catalog discovery tools, ready to pass as `createMcpToolServer`'s `tools` option. */
+export declare const TOOL_CATALOG_TOOLS: readonly McpToolDef[];
+//# sourceMappingURL=tool-catalog-tools.d.ts.map

package/dist/server/tools/tool-catalog-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-catalog-tools.d.ts","sourceRoot":"","sources":["../../../src/server/tools/tool-catalog-tools.ts"],"names":[],"mappings":"AAcA,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAiBrE,kHAAkH;AAClH,eAAO,MAAM,eAAe,EAAE,UAuB7B,CAAC;AAEF,kHAAkH;AAClH,eAAO,MAAM,gBAAgB,EAAE,UAiB9B,CAAC;AAEF,kGAAkG;AAClG,eAAO,MAAM,kBAAkB,EAAE,SAAS,UAAU,EAAwC,CAAC"}

package/dist/server/tools/tool-catalog-tools.js

@@ -0,0 +1,66 @@
+/**
+ * @module @jini-ai/mcp/server/tools/tool-catalog-tools
+ *
+ * `search_tools` / `describe_tool` — the discovery half of `ai-control-plane.md` §29 /
+ * `PROP-tool-catalog-discovery-2026-07-26.md` §6.1, proxying `@jini-ai/http`'s
+ * `GET /api/tools/search` / `GET /api/tools/:id` exactly as `run-tools.ts`'s tools proxy
+ * `runs.ts` — no separate authorization mechanism, no caching, no state.
+ *
+ * v0 scope: no principal scoping, no versioning, no schema narrowing. Execution is unchanged —
+ * a caller still runs a discovered id through `execute_delegated_tool`
+ * (`../tools/delegated-tool.js`), which is the only thing that ever reaches `ToolExecutor`.
+ * Finding a tool id here grants nothing (`PROP` §6.3).
+ */
+import { getDaemonJson } from '../daemon-client.js';
+import { requireString } from '../tool-protocol.js';
+const READ_ANNOTATIONS = {
+    readOnlyHint: true,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+/** `search_tools` -> `GET /api/tools/search` (`packages/http/src/tool-catalog.ts`'s `toolCatalogSearchRoute`). */
+export const searchToolsTool = {
+    name: 'search_tools',
+    description: 'Search the durable tool catalog by keyword. Returns ranked {id, description, source, score} candidates only — no input schemas, so this stays cheap to call broadly. Call describe_tool on the 1-3 candidates that look right before calling execute_delegated_tool.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Keywords to search for, e.g. "navigate page" or "fill form". Required.' },
+            limit: { type: 'number', description: 'Max hits to return (1-25). Optional, defaults to 10.' },
+        },
+        required: ['query'],
+        additionalProperties: false,
+    },
+    annotations: { ...READ_ANNOTATIONS, title: 'Search the tool catalog' },
+    handler: async (args, ctx) => {
+        requireString(args.query, 'query');
+        const params = new URLSearchParams({ q: args.query });
+        if (typeof args.limit === 'number')
+            params.set('limit', String(args.limit));
+        const data = await getDaemonJson(ctx.baseUrl, `/api/tools/search?${params.toString()}`, {
+            fetchImpl: ctx.fetchImpl,
+        });
+        return data.hits;
+    },
+};
+/** `describe_tool` -> `GET /api/tools/:id` (`packages/http/src/tool-catalog.ts`'s `toolCatalogDescribeRoute`). */
+export const describeToolTool = {
+    name: 'describe_tool',
+    description: 'Get the full descriptor for one tool id found via search_tools — description and input schema. Paid for only on the candidates that survive search, per the tool catalog\'s staged-discovery design.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Tool id returned by search_tools. Required.' },
+        },
+        required: ['id'],
+        additionalProperties: false,
+    },
+    annotations: { ...READ_ANNOTATIONS, title: 'Describe a tool' },
+    handler: async (args, ctx) => {
+        requireString(args.id, 'id');
+        return getDaemonJson(ctx.baseUrl, `/api/tools/${encodeURIComponent(args.id)}`, { fetchImpl: ctx.fetchImpl });
+    },
+};
+/** Both tool-catalog discovery tools, ready to pass as `createMcpToolServer`'s `tools` option. */
+export const TOOL_CATALOG_TOOLS = [searchToolsTool, describeToolTool];
+//# sourceMappingURL=tool-catalog-tools.js.map

package/dist/server/tools/tool-catalog-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-catalog-tools.js","sourceRoot":"","sources":["../../../src/server/tools/tool-catalog-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAmB,MAAM,qBAAqB,CAAC;AAErE,MAAM,gBAAgB,GAAG;IACvB,YAAY,EAAE,IAAI;IAClB,cAAc,EAAE,IAAI;IACpB,aAAa,EAAE,KAAK;CACZ,CAAC;AAWX,kHAAkH;AAClH,MAAM,CAAC,MAAM,eAAe,GAAe;IACzC,IAAI,EAAE,cAAc;IACpB,WAAW,EACT,sQAAsQ;IACxQ,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,wEAAwE,EAAE;YAChH,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,sDAAsD,EAAE;SAC/F;QACD,QAAQ,EAAE,CAAC,OAAO,CAAC;QACnB,oBAAoB,EAAE,KAAK;KAC5B;IACD,WAAW,EAAE,EAAE,GAAG,gBAAgB,EAAE,KAAK,EAAE,yBAAyB,EAAE;IACtE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;QAC3B,aAAa,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACnC,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QACtD,IAAI,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ;YAAE,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5E,MAAM,IAAI,GAAG,MAAM,aAAa,CAA4B,GAAG,CAAC,OAAO,EAAE,qBAAqB,MAAM,CAAC,QAAQ,EAAE,EAAE,EAAE;YACjH,SAAS,EAAE,GAAG,CAAC,SAAS;SACzB,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;CACF,CAAC;AAEF,kHAAkH;AAClH,MAAM,CAAC,MAAM,gBAAgB,GAAe;IAC1C,IAAI,EAAE,eAAe;IACrB,WAAW,EACT,sMAAsM;IACxM,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,6CAA6C,EAAE;SACnF;QACD,QAAQ,EAAE,CAAC,IAAI,CAAC;QAChB,oBAAoB,EAAE,KAAK;KAC5B;IACD,WAAW,EAAE,EAAE,GAAG,gBAAgB,EAAE,KAAK,EAAE,iBAAiB,EAAE;IAC9D,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;QAC3B,aAAa,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QAC7B,OAAO,aAAa,CAAC,GAAG,CAAC,OAAO,EAAE,cAAc,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC;IAC/G,CAAC;CACF,CAAC;AAEF,kGAAkG;AAClG,MAAM,CAAC,MAAM,kBAAkB,GAA0B,CAAC,eAAe,EAAE,gBAAgB,CAAC,CAAC"}