@jini-ai/mcp 0.3.3 → 0.4.0

package/dist/server/resource-protocol.js

@@ -9,9 +9,9 @@
  * `ReadResourceRequestSchema` handlers, exactly as `tool-protocol.js` is
  * wired to `ListToolsRequestSchema`/`CallToolRequestSchema`.
  */
-import { sanitizeUntrustedText } from '@jini-ai/cli';
+import { sanitizeUntrustedText } from '@jini-ai/core/text';
 /** Projects a resource list into the `Resource[]` shape `resources/list` returns. */
-export function resourcesToList(resources) {
+export function resourcesToList({ resources }) {
     return resources.map((resource) => ({
         uri: resource.uri,
         name: resource.name,
@@ -20,7 +20,7 @@ export function resourcesToList(resources) {
     }));
 }
 /** 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) {
+export function buildResourceIndex({ resources }) {
     const index = new Map();
     for (const resource of resources) {
         if (index.has(resource.uri)) {
@@ -41,18 +41,18 @@ export function buildResourceIndex(resources) {
  * 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) {
+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);
+        result = await resource.read({ ctx: ctx });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        throw new Error(sanitizeUntrustedText(message));
+        throw new Error(sanitizeUntrustedText({ text: message }));
     }
     const mimeType = result.mimeType ?? resource.mimeType;
     return {

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

@@ -13,7 +13,7 @@
  * 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
+ * `archived provenance ledger`'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).
  *
@@ -37,8 +37,8 @@ export const activeContextResource = {
     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', daemonCallOptions(ctx));
+    read: async ({ ctx }) => {
+        const data = await getDaemonJson({ baseUrl: ctx.baseUrl, route: '/api/active' }, daemonCallOptions({ ctx }));
         return { text: JSON.stringify(data, null, 2) };
     },
 };

package/dist/server/sdk-transport.d.ts

@@ -0,0 +1,11 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { McpTransportLike } from './ports.js';
+/** Internal boundary adapter; SDK callbacks keep their native signature behind the port. */
+export declare function adaptSdkTransport({ transport: sdk }: {
+    transport: Transport;
+}): McpTransportLike;
+/** Resolves adapters to the underlying SDK transport; host ports stay structurally usable. */
+export declare function resolveSdkTransport({ transport }: {
+    transport: McpTransportLike;
+}): Transport;
+//# sourceMappingURL=sdk-transport.d.ts.map

package/dist/server/sdk-transport.js

@@ -0,0 +1,31 @@
+const sdkTransports = new WeakMap();
+/** Internal boundary adapter; SDK callbacks keep their native signature behind the port. */
+export function adaptSdkTransport({ transport: sdk }) {
+    const transport = {
+        get onmessage() {
+            const handler = sdk.onmessage;
+            return handler ? ({ message }) => handler(message) : undefined;
+        },
+        set onmessage(handler) {
+            if (handler)
+                sdk.onmessage = (message) => handler({ message });
+            else
+                delete sdk.onmessage;
+        },
+        get onclose() { return sdk.onclose; },
+        set onclose(handler) {
+            if (handler)
+                sdk.onclose = handler;
+            else
+                delete sdk.onclose;
+        },
+        close: (_required) => sdk.close(),
+    };
+    sdkTransports.set(transport, sdk);
+    return transport;
+}
+/** Resolves adapters to the underlying SDK transport; host ports stay structurally usable. */
+export function resolveSdkTransport({ transport }) {
+    return (sdkTransports.get(transport) ?? transport);
+}
+//# sourceMappingURL=sdk-transport.js.map

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

@@ -36,7 +36,9 @@ export interface McpToolContext {
  * @complexity O(1).
  * @overallScore 100/100
  */
-export declare function daemonCallOptions(ctx: McpToolContext): {
+export declare function daemonCallOptions({ ctx }: {
+    ctx: McpToolContext;
+}): {
     fetchImpl: typeof fetch;
     headers?: Record<string, string>;
     signal?: AbortSignal;
@@ -54,7 +56,10 @@ export interface McpToolDef<Args extends Record<string, unknown> = Record<string
     readonly description: string;
     readonly inputSchema: Tool['inputSchema'];
     readonly annotations?: Tool['annotations'];
-    readonly handler: (args: Args, ctx: McpToolContext) => Promise<unknown> | unknown;
+    readonly handler: (requiredArgs: {
+        args: Args;
+        ctx: McpToolContext;
+    }) => Promise<unknown> | unknown;
 }
 /**
  * Wraps a successful tool result as an MCP `CallToolResult`.
@@ -69,15 +74,26 @@ export interface McpToolDef<Args extends Record<string, unknown> = Record<string
  * @complexity O(n) in the number of content-array entries, only when `payload` already looks like an
  * envelope; O(1) otherwise.
  */
-export declare function okResult(payload: unknown): CallToolResult;
+export declare function okResult({ payload }: {
+    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;
+export declare function errorResult({ message }: {
+    message: string;
+}): CallToolResult;
+/** Returns a validated non-empty string, or throws the existing caller-facing error. */
+export declare function requireString({ value, name }: {
+    value: unknown;
+    name: string;
+}): string;
 /** Projects a tool list into the `Tool[]` shape `tools/list` returns. */
-export declare function toolsToList(tools: readonly McpToolDef[]): Tool[];
+export declare function toolsToList({ tools }: {
+    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>;
+export declare function buildToolIndex({ tools }: {
+    tools: readonly McpToolDef[];
+}): Map<string, McpToolDef>;
 /**
  * `tools/call` dispatch: looks up `name` in `tools`, validates `rawArgs` against the tool's
  * declared `inputSchema`, runs its handler, and converts the outcome to a `CallToolResult` — an
@@ -90,5 +106,11 @@ export declare function buildToolIndex(tools: readonly McpToolDef[]): Map<string
  * result: either can end up echoing caller- or daemon-supplied text, and it is cheaper to sanitize
  * unconditionally than to prove which call site needs it.
  */
-export declare function handleToolCall(name: string, rawArgs: Record<string, unknown> | undefined, tools: ReadonlyMap<string, McpToolDef>, ctx: McpToolContext): Promise<CallToolResult>;
+export declare function handleToolCall({ name, tools, ctx }: {
+    name: string;
+    tools: ReadonlyMap<string, McpToolDef>;
+    ctx: McpToolContext;
+}, { rawArgs }?: {
+    rawArgs?: Record<string, unknown> | undefined;
+}): Promise<CallToolResult>;
 //# sourceMappingURL=tool-protocol.d.ts.map

package/dist/server/tool-protocol.js

@@ -6,7 +6,7 @@
  * 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
+ * `({ 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`.
@@ -22,7 +22,7 @@
  * `delegated-tool-bridge.ts` already keeps an image block in its returned `ToolExecutionResult.output`
  * (it is model-safe per that package's `tool-result-surfaces.ts`), but this module still turned it
  * back into text on the way out. It is also how a **human-confirmation token reached model-visible
- * text** in a separate, traced incident (`ADR-053` Decision 5): a `resource` block carrying the token
+ * text** in a separate, traced incident ( Decision 5): a `resource` block carrying the token
  * fell to the same stringify path because an earlier version of this fix only recognized `text` and
  * `image`, and `resource` was not yet in that hand-rolled allowlist.
  *
@@ -41,9 +41,10 @@
  * allowlist" into "remember to bump the SDK", not into an unconditional guarantee. It also does not
  * (and cannot) judge intent: a handler that puts a secret inside an otherwise well-formed `text` block
  * will still have it pass through as designed — withholding a value from the model is the handler's
- * responsibility (`ADR-053` Decision 4), not this generic wrapper's.
+ * responsibility ( Decision 4), not this generic wrapper's.
+ * See docs/decisions/DR-002-protocol-resource-boundary.md.
  */
-import { sanitizeUntrustedText } from '@jini-ai/cli';
+import { sanitizeUntrustedText } from '@jini-ai/core/text';
 import { CfWorkerJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/cfworker';
 import { ContentBlockSchema } from '@modelcontextprotocol/sdk/types.js';
 /**
@@ -60,7 +61,7 @@ import { ContentBlockSchema } from '@modelcontextprotocol/sdk/types.js';
  * @complexity O(1).
  * @overallScore 100/100
  */
-export function daemonCallOptions(ctx) {
+export function daemonCallOptions({ ctx }) {
     return {
         fetchImpl: ctx.fetchImpl,
         ...(ctx.authHeaders !== undefined ? { headers: { ...ctx.authHeaders } } : {}),
@@ -112,7 +113,7 @@ function isMcpContentEnvelope(payload) {
  * @complexity O(n) in the number of content-array entries, only when `payload` already looks like an
  * envelope; O(1) otherwise.
  */
-export function okResult(payload) {
+export function okResult({ payload }) {
     if (isMcpContentEnvelope(payload)) {
         return { content: payload.content };
     }
@@ -123,17 +124,18 @@ export function okResult(payload) {
     return { content: [{ type: 'text', text }] };
 }
 /** Wraps a tool failure as an MCP `isError` result. */
-export function errorResult(message) {
+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) {
+/** Returns a validated non-empty string, or throws the existing caller-facing error. */
+export function requireString({ value, name }) {
     if (typeof value !== 'string' || value.length === 0) {
         throw new Error(`${name} is required (string).`);
     }
+    return value;
 }
 /** Projects a tool list into the `Tool[]` shape `tools/list` returns. */
-export function toolsToList(tools) {
+export function toolsToList({ tools }) {
     return tools.map((tool) => ({
         name: tool.name,
         description: tool.description,
@@ -142,7 +144,7 @@ export function toolsToList(tools) {
     }));
 }
 /** 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) {
+export function buildToolIndex({ tools }) {
     const index = new Map();
     for (const tool of tools) {
         if (index.has(tool.name)) {
@@ -187,10 +189,10 @@ function validatorForTool(tool) {
  * result: either can end up echoing caller- or daemon-supplied text, and it is cheaper to sanitize
  * unconditionally than to prove which call site needs it.
  */
-export async function handleToolCall(name, rawArgs, tools, ctx) {
+export async function handleToolCall({ name, tools, ctx }, { rawArgs } = {}) {
     const tool = tools.get(name);
     if (tool === undefined) {
-        return errorResult(`unknown tool: ${name}`);
+        return errorResult({ message: `unknown tool: ${name}` });
     }
     const args = rawArgs ?? {};
     // Validation gets its own error boundary, separate from the handler's below. The
@@ -205,21 +207,21 @@ export async function handleToolCall(name, rawArgs, tools, ctx) {
     try {
         const validation = validatorForTool(tool)(args);
         if (!validation.valid) {
-            return errorResult(sanitizeUntrustedText(`invalid arguments for ${name}: ${validation.errorMessage}`));
+            return errorResult({ message: sanitizeUntrustedText({ text: `invalid arguments for ${name}: ${validation.errorMessage}` }) });
         }
         validatedArgs = validation.data;
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        return errorResult(sanitizeUntrustedText(`invalid arguments for ${name}: ${message}`));
+        return errorResult({ message: sanitizeUntrustedText({ text: `invalid arguments for ${name}: ${message}` }) });
     }
     try {
-        const result = await tool.handler(validatedArgs, ctx);
-        return okResult(result);
+        const result = await tool.handler({ args: validatedArgs, ctx: ctx });
+        return okResult({ payload: result });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        return errorResult(sanitizeUntrustedText(message));
+        return errorResult({ message: sanitizeUntrustedText({ text: message }) });
     }
 }
 //# sourceMappingURL=tool-protocol.js.map

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

@@ -9,7 +9,7 @@
  * 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).
+ * `archived provenance ledger`'s 2026-07-21 addition for the full design-decision note).
  *
  * `tools` capability is always advertised (`capabilities: {tools: {}}`).
  * `resources` capability (`ListResourcesRequestSchema`/
@@ -18,61 +18,72 @@
  * 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
+ * `archived provenance ledger`'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 { McpTransportLike } from './ports.js';
+export type { McpTransportLike } from './ports.js';
 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`.
- */
+/** Object-shaped server port. The default adapter translates it to the SDK interface. */
 export interface McpServerLike {
-    setRequestHandler(schema: typeof ListToolsRequestSchema, handler: () => Promise<ListToolsResult>): void;
-    setRequestHandler(schema: typeof CallToolRequestSchema, handler: (request: {
-        params: {
-            name: string;
-            arguments?: Record<string, unknown>;
-        };
-    }, extra?: {
-        signal?: AbortSignal;
-    }) => 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>;
+    setRequestHandler(args: {
+        schema: typeof ListToolsRequestSchema;
+        handler: () => Promise<ListToolsResult>;
+    }): void;
+    setRequestHandler(args: {
+        schema: typeof CallToolRequestSchema;
+        handler: (requiredArgs: {
+            request: {
+                params: {
+                    name: string;
+                    arguments?: Record<string, unknown>;
+                };
+            };
+        }, optionalArgs?: {
+            extra?: {
+                signal?: AbortSignal;
+            };
+        }) => Promise<CallToolResult>;
+    }): void;
+    setRequestHandler(args: {
+        schema: typeof ListResourcesRequestSchema;
+        handler: () => Promise<ListResourcesResult>;
+    }): void;
+    setRequestHandler(args: {
+        schema: typeof ReadResourceRequestSchema;
+        handler: (requiredArgs: {
+            request: {
+                params: {
+                    uri: string;
+                };
+            };
+        }) => Promise<ReadResourceResult>;
+    }): void;
+    connect(args: {
+        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. */
+/** Required identity, tool surface, and daemon URL resolver. */
+export interface McpToolServerRequiredArgs {
+    /** Identity 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. */
+    /** Duplicate tool names throw at construction. */
     readonly tools: readonly McpToolDef[];
+    /** Resolves once when the returned handle runs. */
+    readonly resolveBaseUrl: () => Promise<string> | string;
+}
+export interface McpToolServerOptions {
     /** 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}. */
@@ -90,9 +101,15 @@ export interface McpToolServerOptions {
     /** 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;
+    readonly createServer?: (args: {
+        info: Implementation;
+        options: ServerOptions;
+    }) => McpServerLike;
     /** Test/embedding seam: builds the underlying transport. Defaults to the real `StdioServerTransport`. */
-    readonly createTransport?: (stdin?: Readable, stdout?: Writable) => McpTransportLike;
+    readonly createTransport?: (requiredArgs: Record<string, never>, optionalArgs?: {
+        stdin?: Readable;
+        stdout?: Writable;
+    }) => McpTransportLike;
 }
 export interface McpToolServerHandle {
     /**
@@ -100,14 +117,14 @@ export interface McpToolServerHandle {
      * open until the client disconnects (stdin EOF) or the idle-exit window elapses. Resolves once
      * the transport has closed.
      */
-    run(): Promise<void>;
+    run(required: Record<string, never>): Promise<void>;
 }
 /**
- * Builds a stdio MCP server hosting `options.tools` (and, optionally, `options.resources`).
+ * Builds a stdio MCP server hosting `requiredArgs.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;
+export declare function createMcpToolServer(requiredArgs: McpToolServerRequiredArgs, options?: McpToolServerOptions): McpToolServerHandle;
 //# sourceMappingURL=tool-server.d.ts.map

package/dist/server/tool-server.js

@@ -1,3 +1,4 @@
+import { adaptSdkTransport, resolveSdkTransport } from './sdk-transport.js';
 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';
@@ -6,28 +7,33 @@ import { buildResourceIndex, handleResourceRead, resourcesToList } from './resou
 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);
+// SDK objects remain behind these adapters; hosts implement the object-shaped ports above.
+function defaultCreateServer({ info, options }) {
+    const server = new Server(info, options);
+    return {
+        setRequestHandler: (({ schema, handler }) => server.setRequestHandler(schema, (request, extra) => handler({ request }, { extra }))),
+        connect: ({ transport }) => server.connect(resolveSdkTransport({ transport })),
+    };
 }
-function defaultCreateTransport(stdin, stdout) {
-    return new StdioServerTransport(stdin, stdout);
+function defaultCreateTransport(_requiredArgs, { stdin, stdout } = {}) {
+    return adaptSdkTransport({ transport: new StdioServerTransport(stdin, stdout) });
 }
 /**
- * Builds a stdio MCP server hosting `options.tools` (and, optionally, `options.resources`).
+ * Builds a stdio MCP server hosting `requiredArgs.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);
+export function createMcpToolServer(requiredArgs, options = {}) {
+    const toolIndex = buildToolIndex({ tools: requiredArgs.tools });
     const resources = options.resources ?? [];
-    const resourceIndex = buildResourceIndex(resources);
+    const resourceIndex = buildResourceIndex({ resources });
     const createServer = options.createServer ?? defaultCreateServer;
     const createTransport = options.createTransport ?? defaultCreateTransport;
     return {
-        async run() {
-            const resolvedBaseUrl = await options.resolveBaseUrl();
+        async run(_required) {
+            const resolvedBaseUrl = await requiredArgs.resolveBaseUrl();
             const ctx = {
                 baseUrl: String(resolvedBaseUrl).replace(/\/$/, ''),
                 fetchImpl: options.fetchImpl ?? fetch,
@@ -38,30 +44,48 @@ export function createMcpToolServer(options) {
                 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 } : {}),
+            const withActivity = (handler) => (...args) => idleExit.trackRequest({ fn: () => handler(...args) });
+            const server = createServer({
+                info: { name: requiredArgs.name, version: requiredArgs.version },
+                options: {
+                    capabilities: { tools: {}, ...(resources.length > 0 ? { resources: {} } : {}) },
+                    ...(options.instructions !== undefined ? { instructions: options.instructions } : {}),
+                },
+            });
+            server.setRequestHandler({
+                schema: ListToolsRequestSchema,
+                handler: withActivity(async () => ({ tools: toolsToList({ tools: requiredArgs.tools }) })),
+            });
+            server.setRequestHandler({
+                schema: CallToolRequestSchema,
+                handler: withActivity(async ({ request }, { extra } = {}) => handleToolCall({ name: request.params.name, tools: toolIndex, ctx: extra?.signal !== undefined ? { ...ctx, signal: extra.signal } : ctx }, { rawArgs: request.params.arguments })),
             });
-            server.setRequestHandler(ListToolsRequestSchema, withActivity(async () => ({ tools: toolsToList(options.tools) })));
-            server.setRequestHandler(CallToolRequestSchema, withActivity(async (request, extra) => handleToolCall(request.params.name, request.params.arguments, toolIndex, extra?.signal !== undefined ? { ...ctx, signal: extra.signal } : 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)));
+                server.setRequestHandler({
+                    schema: ListResourcesRequestSchema,
+                    handler: withActivity(async () => ({ resources: resourcesToList({ resources }) })),
+                });
+                server.setRequestHandler({
+                    schema: ReadResourceRequestSchema,
+                    handler: withActivity(async ({ request }) => handleResourceRead({ uri: request.params.uri, resources: resourceIndex, ctx })),
+                });
             }
-            const transport = createTransport(options.stdin, options.stdout);
+            const transport = createTransport({}, {
+                ...(options.stdin === undefined ? {} : { stdin: options.stdin }),
+                ...(options.stdout === undefined ? {} : { stdout: options.stdout }),
+            });
             try {
                 closeTransportForIdle = () => {
-                    void transport.close().catch(() => { });
+                    void transport.close({}).catch(() => { });
                 };
-                await server.connect(transport);
+                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);
+                transport.onmessage = ({ message }) => {
+                    idleExit.noteActivity({});
+                    sdkOnMessage?.({ message });
                 };
                 const stdin = options.stdin ?? process.stdin;
                 await new Promise((resolve) => {
@@ -71,7 +95,7 @@ export function createMcpToolServer(options) {
                         if (finished)
                             return;
                         finished = true;
-                        idleExit.dispose();
+                        idleExit.dispose({});
                         resolve();
                     };
                     transport.onclose = () => {
@@ -79,7 +103,7 @@ export function createMcpToolServer(options) {
                         done();
                     };
                     const closeTransportForStdin = () => {
-                        void transport.close().catch(() => done());
+                        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.
@@ -88,7 +112,7 @@ export function createMcpToolServer(options) {
                 });
             }
             finally {
-                idleExit.dispose();
+                idleExit.dispose({});
                 closeTransportForIdle = null;
             }
         },

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

@@ -39,12 +39,12 @@ export const searchComponentsTool = {
         additionalProperties: false,
     },
     annotations: { ...READ_ANNOTATIONS, title: 'Search the interactive-UI component catalog' },
-    handler: async (args, ctx) => {
-        requireString(args.query, 'query');
-        const params = new URLSearchParams({ q: args.query });
+    handler: async ({ args, ctx }) => {
+        const query = requireString({ value: args.query, name: 'query' });
+        const params = new URLSearchParams({ q: query });
         if (typeof args.limit === 'number')
             params.set('limit', String(args.limit));
-        const data = await getDaemonJson(ctx.baseUrl, `/api/components/search?${params.toString()}`, daemonCallOptions(ctx));
+        const data = await getDaemonJson({ baseUrl: ctx.baseUrl, route: `/api/components/search?${params.toString()}` }, daemonCallOptions({ ctx }));
         return data.hits;
     },
 };
@@ -61,9 +61,9 @@ export const describeComponentTool = {
         additionalProperties: false,
     },
     annotations: { ...READ_ANNOTATIONS, title: 'Describe an interactive-UI component' },
-    handler: async (args, ctx) => {
-        requireString(args.id, 'id');
-        return getDaemonJson(ctx.baseUrl, `/api/components/${encodeURIComponent(args.id)}`, daemonCallOptions(ctx));
+    handler: async ({ args, ctx }) => {
+        const id = requireString({ value: args.id, name: 'id' });
+        return getDaemonJson({ baseUrl: ctx.baseUrl, route: `/api/components/${encodeURIComponent(id)}` }, daemonCallOptions({ ctx }));
     },
 };
 /** Both component-catalog discovery tools, ready to pass as `createMcpToolServer`'s `tools` option. */