@neutrome/open-ai-router 0.1.14 → 0.1.16

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@neutrome/open-ai-router",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "hono": "^4.12.18",
     "@neutrome/lil-engine": "0.1.5"
   },

package/src/app/factory.ts

@@ -15,6 +15,7 @@ import {
 } from "../router/index.ts";
 import type { RequestContext } from "../auth/types.ts";
 import type { RouterConfig } from "../router/config.ts";
+import type { RemoteMcpClientFactory } from "../router/mcp.ts";
 
 export type RouterAppAuth = {
   authenticate(request: Request, env: Record<string, unknown>): Promise<object | null>;
@@ -38,6 +39,7 @@ export type RouterAppOptions = {
   requestIdFactory?: ExecutionRuntimeOptions["requestIdFactory"];
   executionIdFactory?: ExecutionRuntimeOptions["executionIdFactory"];
   upstreamTimeoutMs?: number;
+  remoteMcpClientFactory?: RemoteMcpClientFactory;
 };
 
 export function createRouterApp(options: RouterAppOptions) {
@@ -137,6 +139,7 @@ export function createRouterApp(options: RouterAppOptions) {
         ...(options.transforms ? { transforms: options.transforms } : {}),
         observe,
         ...(options.upstreamTimeoutMs !== undefined ? { upstreamTimeoutMs: options.upstreamTimeoutMs } : {}),
+        ...(options.remoteMcpClientFactory ? { remoteMcpClientFactory: options.remoteMcpClientFactory } : {}),
         ...(forceStreaming ? { forceStreaming: true } : {}),
       });
       if (!isEventStreamResponse(response) || !response.body) {

package/src/app/handlers.ts

@@ -132,6 +132,9 @@ function createExecutionHandlerOptions(
   if (options.upstreamTimeoutMs !== undefined) {
     handlerOptions.upstreamTimeoutMs = options.upstreamTimeoutMs;
   }
+  if (options.remoteMcpClientFactory) {
+    handlerOptions.remoteMcpClientFactory = options.remoteMcpClientFactory;
+  }
 
   return handlerOptions;
 }

package/src/index.ts

@@ -43,11 +43,24 @@ export type {
   ProviderApiStyle as ProviderStyle,
   ProviderRuntime,
   ProviderTargetConfig,
+  RemoteMcpServerConfig,
+  RemoteMcpToolConfig,
   ResolvedTarget,
   RouterConfig,
   RouterExecutionOptions,
   RouterRuntime,
 } from "./router/index.ts";
+export type {
+  RemoteMcpClientFactory,
+  RemoteMcpToolCallClient,
+  RemoteMcpToolSet,
+} from "./router/index.ts";
+export {
+  createRemoteMcpToolSet,
+  createStreamableHttpMcpClient,
+  stringifyMcpToolResult,
+  wireToolName,
+} from "./router/index.ts";
 
 export type {
   AuthDriver,

package/src/router/config.ts

@@ -17,11 +17,13 @@ export type ExecutorRouteConfig =
       executor: string;
       alias?: string;
       transforms?: string[];
+      mcps?: string[];
     }
   | {
       provider: string;
       model: string;
       transforms?: string[];
+      mcps?: string[];
     };
 
 export type ExecutorNamespaceConfig = {
@@ -29,9 +31,23 @@ export type ExecutorNamespaceConfig = {
   models: Record<string, ExecutorRouteConfig>;
 };
 
+export type RemoteMcpToolConfig = {
+  name: string;
+  description?: string;
+  inputSchema: Record<string, unknown>;
+};
+
+export type RemoteMcpServerConfig = {
+  type: "mcp_streamable_http";
+  url: string;
+  headers?: Record<string, string>;
+  tools: RemoteMcpToolConfig[];
+};
+
 export type RouterConfig = {
   trace?: boolean;
   auth?: AuthConfig;
   providers: Record<string, ProviderTargetConfig>;
   executors: Record<string, ExecutorNamespaceConfig>;
+  mcps?: Record<string, RemoteMcpServerConfig>;
 };

package/src/router/execute.test.ts

@@ -2,6 +2,7 @@ import { appendAssistantMessage } from "@neutrome/lil-engine";
 import { describe, expect, it, vi } from "vitest";
 import type { RequestContext } from "../auth/types.ts";
 import { handleChatCompletions } from "./execute.ts";
+import type { RemoteMcpClientFactory } from "./mcp.ts";
 import { createRouterRuntime } from "./runtime.ts";
 
 const encoder = new TextEncoder();
@@ -93,6 +94,138 @@ describe("router execution", () => {
     });
   });
 
+  it("injects and executes attached remote mcp tools", async () => {
+    const capturedBodies: Record<string, unknown>[] = [];
+    const close = vi.fn(async () => {});
+    const callTool = vi.fn(async (name: string, args: Record<string, unknown>) => {
+      expect(name).toBe("lookup");
+      expect(args).toEqual({ id: "42" });
+      return { content: [{ type: "text", text: "customer is active" }] };
+    });
+    const remoteMcpClientFactory: RemoteMcpClientFactory = vi.fn(async () => ({
+      callTool,
+      close,
+    }));
+
+    const runtime = createRouterRuntime({
+      config: {
+        providers: {
+          openrouter: {
+            api_base_url: "https://openrouter.ai/api/v1",
+            style: "chat-completions",
+            exports: ["*"],
+          },
+        },
+        mcps: {
+          crm: {
+            type: "mcp_streamable_http",
+            url: "https://mcp.example.test/mcp",
+            headers: { authorization: "Bearer static" },
+            tools: [{
+              name: "lookup",
+              description: "Look up a customer",
+              inputSchema: {
+                type: "object",
+                properties: { id: { type: "string" } },
+                required: ["id"],
+              },
+            }],
+          },
+        },
+        executors: {
+          default: {
+            exports: ["*"],
+            models: {
+              "gpt-4o": {
+                provider: "openrouter",
+                model: "gpt-4o",
+                mcps: ["crm"],
+              },
+            },
+          },
+        },
+      },
+      fetchImpl: vi.fn(async (_input, init) => {
+        const body = JSON.parse(decoder.decode(new Uint8Array(init?.body as ArrayBuffer)));
+        capturedBodies.push(body);
+        if (capturedBodies.length === 1) {
+          expect(body.tools).toEqual([{
+            type: "function",
+            function: {
+              name: "crm__lookup",
+              description: "Look up a customer",
+              parameters: {
+                type: "object",
+                properties: { id: { type: "string" } },
+                required: ["id"],
+              },
+            },
+          }]);
+          return new Response(
+            JSON.stringify({
+              id: "resp_1",
+              model: "gpt-4o",
+              choices: [{
+                index: 0,
+                message: {
+                  role: "assistant",
+                  tool_calls: [{
+                    id: "call_1",
+                    type: "function",
+                    function: { name: "crm__lookup", arguments: "{\"id\":\"42\"}" },
+                  }],
+                },
+                finish_reason: "tool_calls",
+              }],
+            }),
+            { headers: { "content-type": "application/json; charset=utf-8" } },
+          );
+        }
+        expect(body.messages).toContainEqual({
+          role: "tool",
+          tool_call_id: "call_1",
+          content: "customer is active",
+        });
+        return new Response(
+          JSON.stringify({
+            id: "resp_2",
+            model: "gpt-4o",
+            choices: [{
+              index: 0,
+              message: { role: "assistant", content: "done" },
+              finish_reason: "stop",
+            }],
+          }),
+          { headers: { "content-type": "application/json; charset=utf-8" } },
+        );
+      }),
+    });
+
+    const ctx: RequestContext = {
+      request: new Request("http://local/v1/chat/completions", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          model: "gpt-4o",
+          messages: [{ role: "user", content: "check customer 42" }],
+        }),
+      }),
+      incomingAuth: new Map(),
+      env: {},
+    };
+
+    const response = await handleChatCompletions({ runtime, ctx, remoteMcpClientFactory });
+
+    expect(response.status).toBe(200);
+    expect(remoteMcpClientFactory).toHaveBeenCalledOnce();
+    expect(callTool).toHaveBeenCalledOnce();
+    expect(close).toHaveBeenCalledOnce();
+    expect(capturedBodies).toHaveLength(2);
+    expect(await response.json()).toMatchObject({
+      choices: [{ message: { content: "done" } }],
+    });
+  });
+
   it("routes responses-style providers through provider transport", async () => {
     let capturedUrl = "";
     let capturedBody: Record<string, unknown> | null = null;

package/src/router/execute.ts

@@ -14,7 +14,9 @@ import {
   setStreaming,
   type Program,
   type ProviderStyle,
+  withTools,
   usageObject,
+  type ExecutionTarget,
 } from "@neutrome/lil-engine";
 import {
   createExecutionRuntime,
@@ -30,6 +32,10 @@ import { cloneForwardHeaders, isSse } from "../util/headers.ts";
 import { eventDataLines, splitSseEvents } from "../util/sse.ts";
 import { renderProgramAsLil } from "../observer.ts";
 import { resolveInvocationTarget, type ResolvedTarget } from "./resolve.ts";
+import {
+  createRemoteMcpToolSet,
+  type RemoteMcpClientFactory,
+} from "./mcp.ts";
 import type { ProviderRuntime, RouterRuntime } from "./runtime.ts";
 
 const encoder = new TextEncoder();
@@ -43,6 +49,7 @@ export type RouterExecutionOptions = Pick<
   executors?: Readonly<Record<string, Executor>>;
   transforms?: Readonly<Record<string, ProgramTransform>>;
   upstreamTimeoutMs?: number;
+  remoteMcpClientFactory?: RemoteMcpClientFactory;
 };
 
 export type HandleChatCompletionsOptions = RouterExecutionOptions & {
@@ -168,32 +175,39 @@ export async function handleChatCompletions(
       executionId: incomingExecutionId,
     });
     const resolved = resolveRequestTarget(options.runtime, request);
-    const execution = createRouterExecutionRuntime(
-      options.runtime,
-      options.ctx,
-      options,
-    );
+    const remoteMcp = prepareRemoteMcpExecution(options.runtime, resolved, options);
+    const execution = createRouterExecutionRuntime(options.runtime, options.ctx, remoteMcp.options);
 
     const startTime = Date.now();
     if (isStreaming(request)) {
-      const chunks = execution.stream(request, { target: resolved.target });
-      return await streamExecutionResponse(
-        "chat-completions",
-        chunks,
+      try {
+        const chunks = execution.stream(request, { target: remoteMcp.target });
+        return await streamExecutionResponse(
+          "chat-completions",
+          chunks,
+          resolved,
+          startTime,
+          remoteMcp.close,
+        );
+      } catch (error) {
+        await remoteMcp.close();
+        throw error;
+      }
+    }
+
+    try {
+      const response = await execution.execute(request, {
+        target: remoteMcp.target,
+      });
+      const userTime = Date.now() - startTime;
+      return jsonExecutionResponse(
+        emitChatCompletionsResponse(response),
         resolved,
-        startTime,
+        userTime,
       );
+    } finally {
+      await remoteMcp.close();
     }
-
-    const response = await execution.execute(request, {
-      target: resolved.target,
-    });
-    const userTime = Date.now() - startTime;
-    return jsonExecutionResponse(
-      emitChatCompletionsResponse(response),
-      resolved,
-      userTime,
-    );
   } catch (error) {
     return errorResponse(error);
   }
@@ -240,32 +254,39 @@ async function handleProviderStyle(
       executionId: incomingExecutionId,
     });
     const resolved = resolveRequestTarget(options.runtime, request);
-    const execution = createRouterExecutionRuntime(
-      options.runtime,
-      options.ctx,
-      options,
-    );
+    const remoteMcp = prepareRemoteMcpExecution(options.runtime, resolved, options);
+    const execution = createRouterExecutionRuntime(options.runtime, options.ctx, remoteMcp.options);
 
     const startTime = Date.now();
     if (isStreaming(request)) {
-      const chunks = execution.stream(request, { target: resolved.target });
-      return await streamExecutionResponse(
-        style,
-        chunks,
+      try {
+        const chunks = execution.stream(request, { target: remoteMcp.target });
+        return await streamExecutionResponse(
+          style,
+          chunks,
+          resolved,
+          startTime,
+          remoteMcp.close,
+        );
+      } catch (error) {
+        await remoteMcp.close();
+        throw error;
+      }
+    }
+
+    try {
+      const response = await execution.execute(request, {
+        target: remoteMcp.target,
+      });
+      const userTime = Date.now() - startTime;
+      return jsonExecutionResponse(
+        emitProviderResponse(style, response),
         resolved,
-        startTime,
+        userTime,
       );
+    } finally {
+      await remoteMcp.close();
     }
-
-    const response = await execution.execute(request, {
-      target: resolved.target,
-    });
-    const userTime = Date.now() - startTime;
-    return jsonExecutionResponse(
-      emitProviderResponse(style, response),
-      resolved,
-      userTime,
-    );
   } catch (error) {
     return errorResponse(error);
   }
@@ -451,6 +472,7 @@ async function streamExecutionResponse(
   chunks: AsyncIterable<Program>,
   resolved: ResolvedTarget,
   startTime: number,
+  cleanup?: () => Promise<void>,
 ): Promise<Response> {
   const iterator = chunks[Symbol.asyncIterator]();
 
@@ -481,8 +503,10 @@ async function streamExecutionResponse(
         if (responseStyle === "chat-completions") {
           controller.enqueue(encoder.encode("data: [DONE]\n\n"));
         }
+        await cleanup?.();
         controller.close();
       } catch (error) {
+        await cleanup?.();
         controller.enqueue(
           encoder.encode(
             `event: error\ndata: ${JSON.stringify({ message: error instanceof Error ? error.message : String(error) })}\n\n`,
@@ -492,6 +516,7 @@ async function streamExecutionResponse(
       }
     },
     async cancel() {
+      await cleanup?.();
       await iterator.return?.();
     },
   });
@@ -505,6 +530,46 @@ async function streamExecutionResponse(
   });
 }
 
+function prepareRemoteMcpExecution(
+  runtime: RouterRuntime,
+  resolved: ResolvedTarget,
+  options: RouterExecutionOptions,
+): {
+  target: ExecutionTarget;
+  options: RouterExecutionOptions;
+  close: () => Promise<void>;
+} {
+  if (resolved.mcps.length === 0) {
+    return { target: resolved.target, options, close: async () => {} };
+  }
+
+  const remoteMcp = createRemoteMcpToolSet(
+    runtime,
+    resolved.mcps,
+    options.remoteMcpClientFactory,
+  );
+  if (remoteMcp.tools.length === 0) {
+    return { target: resolved.target, options, close: remoteMcp.close };
+  }
+
+  const executorName = `__remote_mcp_${crypto.randomUUID()}`;
+  return {
+    target: {
+      kind: "executor",
+      executor: executorName,
+      alias: resolved.requestedModel,
+    },
+    options: {
+      ...options,
+      executors: {
+        ...(options.executors ?? {}),
+        [executorName]: withTools(remoteMcp.tools, resolved.target),
+      },
+    },
+    close: remoteMcp.close,
+  };
+}
+
 function jsonExecutionResponse(
   body: Uint8Array,
   resolved: ResolvedTarget,

package/src/router/index.ts

@@ -11,12 +11,20 @@ export {
   ProviderHttpError,
 } from "./execute.ts";
 export { listConfiguredModels, resolveInvocationTarget, resolveInvocationTargets } from "./resolve.ts";
+export {
+  createRemoteMcpToolSet,
+  createStreamableHttpMcpClient,
+  stringifyMcpToolResult,
+  wireToolName,
+} from "./mcp.ts";
 export type {
   AuthConfig,
   ExecutorNamespaceConfig,
   ExecutorRouteConfig,
   ProviderApiStyle,
   ProviderTargetConfig,
+  RemoteMcpServerConfig,
+  RemoteMcpToolConfig,
   RouterConfig,
 } from "./config.ts";
 export type {
@@ -24,6 +32,7 @@ export type {
   ExecutorRouteRuntime,
   ExecutorRuntime,
   ProviderRuntime,
+  RemoteMcpServerRuntime,
   RouterRuntime,
 } from "./runtime.ts";
 export type {
@@ -33,4 +42,9 @@ export type {
   HandleResponsesOptions,
   RouterExecutionOptions,
 } from "./execute.ts";
+export type {
+  RemoteMcpClientFactory,
+  RemoteMcpToolCallClient,
+  RemoteMcpToolSet,
+} from "./mcp.ts";
 export type { ResolvedTarget } from "./resolve.ts";

package/src/router/mcp.ts

@@ -0,0 +1,158 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { ExecutionContext, Tool } from "@neutrome/lil-engine";
+import type { RemoteMcpServerRuntime, RouterRuntime } from "./runtime.ts";
+
+export type RemoteMcpToolCallClient = {
+  callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+  close(): Promise<void>;
+};
+
+export type RemoteMcpClientFactory = (
+  server: RemoteMcpServerRuntime,
+  signal: AbortSignal,
+) => Promise<RemoteMcpToolCallClient>;
+
+export type RemoteMcpToolSet = {
+  tools: Tool[];
+  close(): Promise<void>;
+};
+
+export function createRemoteMcpToolSet(
+  runtime: RouterRuntime,
+  serverNames: readonly string[],
+  factory?: RemoteMcpClientFactory,
+): RemoteMcpToolSet {
+  const pool = new RemoteMcpSessionPool(
+    factory ?? ((server, signal) => createStreamableHttpMcpClient(server, signal, runtime.fetchImpl)),
+  );
+  const tools: Tool[] = [];
+  const usedNames = new Map<string, number>();
+
+  for (const serverName of unique(serverNames)) {
+    const server = runtime.mcps.get(serverName);
+    if (!server) continue;
+
+    for (const snapshot of server.tools) {
+      const baseName = wireToolName(server.name, snapshot.name);
+      const count = usedNames.get(baseName) ?? 0;
+      usedNames.set(baseName, count + 1);
+      const name = count === 0 ? baseName : `${baseName}_${count + 1}`;
+
+      tools.push({
+        name,
+        description: snapshot.description || `Remote MCP tool ${server.name}/${snapshot.name}`,
+        schema: normalizeSchema(snapshot.inputSchema),
+        async execute(args: Record<string, unknown>, ctx: ExecutionContext) {
+          const client = await pool.get(server, ctx.signal);
+          const result = await client.callTool(snapshot.name, args);
+          return stringifyMcpToolResult(result);
+        },
+      });
+    }
+  }
+
+  return { tools, close: () => pool.closeAll() };
+}
+
+export async function createStreamableHttpMcpClient(
+  server: RemoteMcpServerRuntime,
+  signal?: AbortSignal,
+  fetchImpl?: typeof fetch,
+): Promise<RemoteMcpToolCallClient> {
+  const client = new Client({ name: "open-ai-router", version: "0.1.0" });
+  const transport = new StreamableHTTPClientTransport(new URL(server.url), {
+    requestInit: { headers: server.headers ?? {} },
+    ...(fetchImpl ? { fetch: fetchImpl } : {}),
+  });
+  signal?.addEventListener("abort", () => void client.close(), { once: true });
+  await client.connect(transport as Transport);
+  return {
+    callTool(name, args) {
+      return client.callTool({ name, arguments: args });
+    },
+    close() {
+      return client.close();
+    },
+  };
+}
+
+export function wireToolName(serverName: string, toolName: string): string {
+  return `${safeToolNamePart(serverName)}__${safeToolNamePart(toolName)}`;
+}
+
+export function stringifyMcpToolResult(result: unknown): string {
+  if (!isRecord(result)) return JSON.stringify(result);
+  if ("toolResult" in result) return JSON.stringify(result.toolResult);
+
+  const chunks: string[] = [];
+  const content = result.content;
+  if (Array.isArray(content)) {
+    for (const item of content) chunks.push(stringifyContent(item));
+  }
+  if (isRecord(result.structuredContent)) {
+    chunks.push(JSON.stringify(result.structuredContent));
+  }
+  const body = chunks.filter(Boolean).join("\n");
+  if (result.isError === true) {
+    return body ? `MCP tool returned an error:\n${body}` : "MCP tool returned an error.";
+  }
+  return body || JSON.stringify(result);
+}
+
+class RemoteMcpSessionPool {
+  readonly #factory: RemoteMcpClientFactory;
+  readonly #clients = new Map<string, Promise<RemoteMcpToolCallClient>>();
+
+  constructor(factory: RemoteMcpClientFactory) {
+    this.#factory = factory;
+  }
+
+  get(server: RemoteMcpServerRuntime, signal: AbortSignal) {
+    let client = this.#clients.get(server.name);
+    if (!client) {
+      client = this.#factory(server, signal);
+      this.#clients.set(server.name, client);
+    }
+    return client;
+  }
+
+  async closeAll(): Promise<void> {
+    const clients = await Promise.allSettled(this.#clients.values());
+    this.#clients.clear();
+    await Promise.allSettled(
+      clients.flatMap((result) =>
+        result.status === "fulfilled" ? [result.value.close()] : [],
+      ),
+    );
+  }
+}
+
+function stringifyContent(item: unknown): string {
+  if (!isRecord(item)) return JSON.stringify(item);
+  if (item.type === "text" && typeof item.text === "string") return item.text;
+  if (item.type === "resource" && isRecord(item.resource)) {
+    if (typeof item.resource.text === "string") return item.resource.text;
+    return JSON.stringify(item.resource);
+  }
+  return JSON.stringify(item);
+}
+
+function normalizeSchema(value: unknown): Record<string, unknown> {
+  if (!isRecord(value)) return { type: "object" };
+  return { ...value, type: "object" };
+}
+
+function safeToolNamePart(value: string): string {
+  const cleaned = value.trim().replace(/[^A-Za-z0-9_-]+/g, "_");
+  return cleaned.replace(/^_+|_+$/g, "") || "tool";
+}
+
+function unique(values: readonly string[]): string[] {
+  return [...new Set(values)];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}

package/src/router/resolve.ts

@@ -8,6 +8,7 @@ export type ResolvedTarget = {
   suffixes: ModelSuffixSpec[];
   namespace: string;
   source: "provider" | "executor";
+  mcps: readonly string[];
 };
 
 export function resolveInvocationTarget(
@@ -43,6 +44,7 @@ export function resolveInvocationTargets(
         namespace,
         source: route.target.kind,
         suffixes: parsed.suffixes,
+        mcps: route.mcps,
         target: withSuffixTransforms(route.target, parsed.suffixes),
       });
     }
@@ -90,6 +92,7 @@ function resolveQualified(
       namespace,
       source: route.target.kind,
       suffixes,
+      mcps: route.mcps,
       target: withSuffixTransforms(route.target, suffixes),
     }];
   }
@@ -103,6 +106,7 @@ function resolveQualified(
       namespace,
       source: "provider",
       suffixes,
+      mcps: [],
       target: {
         kind: "provider",
         provider: namespace,

package/src/router/runtime.ts

@@ -6,6 +6,7 @@ import type {
   ExecutorNamespaceConfig,
   ExecutorRouteConfig,
   ProviderTargetConfig,
+  RemoteMcpServerConfig,
   RouterConfig,
 } from "./config.ts";
 
@@ -22,6 +23,7 @@ export type ExecutorRouteRuntime = {
   requestedAlias: string;
   target: ExecutionTarget;
   transforms: readonly string[];
+  mcps: readonly string[];
 };
 
 export type ExecutorRuntime = {
@@ -36,11 +38,16 @@ export type RouterRuntime = {
   providerOrder: readonly string[];
   executors: ReadonlyMap<string, ExecutorRuntime>;
   executorOrder: readonly string[];
+  mcps: ReadonlyMap<string, RemoteMcpServerRuntime>;
   authChain: readonly AuthDriver[];
   knownSuffixes: ReadonlySet<string>;
   fetchImpl: typeof fetch;
 };
 
+export type RemoteMcpServerRuntime = RemoteMcpServerConfig & {
+  name: string;
+};
+
 export type CreateRouterOptions = {
   config: RouterConfig;
   fetchImpl?: typeof fetch;
@@ -51,6 +58,7 @@ export type CreateRouterOptions = {
 export function createRouterRuntime(options: CreateRouterOptions): RouterRuntime {
   const providers = new Map<string, ProviderRuntime>();
   const executors = new Map<string, ExecutorRuntime>();
+  const mcps = new Map<string, RemoteMcpServerRuntime>();
   const providerOrder: string[] = [];
   const executorOrder: string[] = [];
 
@@ -63,6 +71,9 @@ export function createRouterRuntime(options: CreateRouterOptions): RouterRuntime
     executorOrder.push(name);
     executors.set(name, buildExecutorRuntime(name, config));
   }
+  for (const [name, config] of Object.entries(options.config.mcps ?? {})) {
+    mcps.set(name, { name, ...config });
+  }
 
   return {
     config: options.config,
@@ -70,6 +81,7 @@ export function createRouterRuntime(options: CreateRouterOptions): RouterRuntime
     providerOrder,
     executors,
     executorOrder,
+    mcps,
     authChain: options.authDrivers ?? buildAuthChain(options.config.auth),
     knownSuffixes: new Set(options.knownSuffixes ?? ["slwin", "kvtools"]),
     fetchImpl: options.fetchImpl ?? globalThis.fetch.bind(globalThis),
@@ -105,6 +117,7 @@ function buildExecutorRoute(alias: string, route: ExecutorRouteConfig): Executor
     return {
       requestedAlias: alias,
       transforms: route.transforms ?? [],
+      mcps: route.mcps ?? [],
       target: {
         kind: "provider",
         provider: route.provider,
@@ -115,9 +128,10 @@ function buildExecutorRoute(alias: string, route: ExecutorRouteConfig): Executor
   }
 
   return {
-    requestedAlias: alias,
-    transforms: route.transforms ?? [],
-    target: {
+      requestedAlias: alias,
+      transforms: route.transforms ?? [],
+      mcps: route.mcps ?? [],
+      target: {
       kind: "executor",
       executor: route.executor,
       alias: route.alias ?? alias,