trpc-to-mcp 1.3.2 → 2.0.0

package/README.md

@@ -1,257 +1,217 @@
-## Introduction
+# trpc-to-mcp
 
-You can skip this part if you know exactly why you're turning your tRPC endpoints into MCP tools.
+Turn the tRPC procedures you choose into MCP tools.
 
-<details>
-<summary>How to think of MCPs</summary>
-
-At its core, the Model Context Protocol (MCP) gives language models a context to interact with external systems by exposing well-defined tools. This isn't about wrapping API endpoints- it's about enabling AI to perform tasks with clarity and purpose.
+- Works with tRPC v11 and `@modelcontextprotocol/server` v2, the MCP TypeScript SDK
+- [Serve tools over stdio or HTTP](#serve-your-tools)
+- [Use the tRPC context and middlewares on every tool call](#context)
+- [Transform outputs into text, images, or other MCP content](#transform-outputs)
+- [Return structured content from procedures with an output schema](#structured-output)
+- [Mount on Next.js and other frameworks with mcp-handler](#mcp-handler)
 
-This library was created to convert only the tRPC procedures you explicitly choose into MCP tools. By doing so, it ensures that only the functionalities intended for controlled AI interaction are exposed, rather than indiscriminately converting all endpoints.
+<details>
+<summary>Why only the procedures you choose?</summary>
 
-Remember, for an endpoint to be effectively transformed into an MCP tool, it should be meticulously documented with clear descriptions, meaningful names, and well-defined inputs/outputs. This careful design is crucial because MCP tools are more than mere API endpoints - they form the operational contexts that enable language models to function reliably.
+An MCP tool is something a language model decides to call on its own, so expose only the procedures you want a model to use. A model picks a tool based on its name, description, and input schema. Give each exposed procedure a clear name, a description of what it does and when to use it, and a `.describe()` on each input field.
 
 </details>
 
-## tRPC to MCP
-
-- Support for tRPC v11
-- [Transform your JSON outputs into human-language with custom helpers](#transform-output)
-- [Turn your tRPC router into MCP tools](#to-mcp-tools)
-- [Turn your tRPC router into MCP server](#to-mcp-server)
-- [Turn your tRPC router into @vercel/mcp-adapter handler](#to-vercel-mcp-adapter)
-
-## Usage
-
-1. Install trpc-to-mcp
+## Install
 
 ```bash
-npm install trpc-to-mcp
-
-pnpm add trpc-to-mcp
+pnpm add trpc-to-mcp @modelcontextprotocol/server
+```
 
-bun add trpc-to-mcp
+`@trpc/server` 11 and `@modelcontextprotocol/server` 2 are peer dependencies. Node.js 20 or later is required.
 
-yarn add trpc-to-mcp
-```
+## Usage
 
-2. Add `McpMeta` to your tRPC instance
+1. Add `McpMeta` to your tRPC instance.
 
 ```typescript
 import { initTRPC } from "@trpc/server";
 import { type McpMeta } from "trpc-to-mcp";
 
-const t = initTRPC.meta<McpMeta>().create();
+const t = initTRPC.context<Context>().meta<McpMeta>().create();
 ```
 
-3. Enable `mcp` support for a procedure
+2. Enable `mcp` on the procedures you want as tools.
 
 ```typescript
+import { z } from "zod";
+
 export const appRouter = t.router({
   hello: t.procedure
     .meta({
       mcp: {
         enabled: true,
-        description: "Say hello to a name",
-        // You can leave it empty, it'll be converted to "hello"
-        // If you have subrouters, then subrouter_procedure_name
+        description: "Say hello to someone",
+        // Optional. Defaults to the procedure path with dots replaced by
+        // underscores, e.g. "hello" or "user_byId".
         name: "say_hello",
       },
     })
-    .input(
-      z.object({
-        name: z.string(),
-      }),
-    )
-    .query(({ input }) => {
-      return { greeting: `Hello ${input.name}` };
-    }),
+    .input(z.object({ name: z.string().describe("Who to greet") }))
+    .query(({ input }) => `Hello ${input.name}`),
 });
 ```
 
-## Transform Outputs
+Inputs must be object schemas from a validator that implements [Standard JSON Schema](https://standardschema.dev), such as zod 4.2 or later, ArkType, or Valibot with `toStandardJsonSchema()`. Chained `.input()` calls are merged into one tool input schema. Subscriptions can't be tools.
 
-If you need a human-language outputs for LLMs to have a better context, you can use `transformMcpProcedure`
+tRPC validates input on every call, so your zod transforms and refinements run as usual. Errors thrown by a procedure, including `TRPCError`, come back to the client as a tool result with `isError: true`.
 
-You simply wrap your procedure with the helper function, and provide a transformer callback function that turns your procedure output into `ContentBlock[]` array compatible with MCP content output.
+`meta.mcp` also takes `title` and `annotations`. Queries get `readOnlyHint: true` unless you set it yourself.
 
-```typescript
-import { initTRPC } from "@trpc/server";
-import { z } from "zod";
+## Serve your tools
 
-import { transformMcpProcedure, type McpMeta } from "../src";
+`createMcpServer` returns an `McpServer` with your tools registered. You can register more tools, prompts, and resources on it.
 
-const t = initTRPC.meta<McpMeta>().create();
+Over stdio:
 
-export const appRouter = t.router({
-  procedure: transformMcpProcedure(
-    t.procedure
-      .meta({
-        mcp: {
-          enabled: true,
-          description: "Send a message",
-          name: "send_message",
-        },
-      })
-      .input(
-        z.object({
-          message: z.string(),
-        }),
-      )
-      .query(({ input }) => {
-        return {
-          payload: {
-            from: "trpc",
-            message: input.message,
-            array: [{ a: 1 }, { b: 2 }],
-          },
-        };
-      }),
-    (output) => {
-      return [
-        ...output.payload.array.map((item) => {
-          const [name, value] = Object.entries(item);
-          return {
-            type: "text" as const,
-            text: `${name} is ${value} letter of alphabet`,
-          };
-        }),
-        {
-          type: "image",
-          data: "...",
-          mimeType: "",
-        },
-        {
-          type: "audio", // or even "resource" | "resource_link"
-          data: "...",
-          mimeType: "",
-        },
-      ];
-    },
-  ),
-});
-```
+```typescript
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { createMcpServer } from "trpc-to-mcp";
 
-## To MCP tools
+serveStdio(() =>
+  createMcpServer({ name: "my-app", version: "1.0.0" }, appRouter, { db }),
+);
+```
 
-4. You can turn a router into tools
+Over HTTP, with the SDK's `createMcpHandler` on any runtime with web-standard `Request` and `Response`:
 
 ```typescript
-import { appRouter } from "@/server/trpc/root.ts";
-import { extractToolsFromProcedures } from "trpc-to-mcp";
+import { createMcpHandler } from "@modelcontextprotocol/server";
+import { createMcpServer } from "trpc-to-mcp";
 
-const tools = extractToolsFromProcedures(appRouter);
+const handler = createMcpHandler(() =>
+  createMcpServer({ name: "my-app", version: "1.0.0" }, appRouter, { db }),
+);
 
-/*
+export default { fetch: handler.fetch };
+```
 
-[
-  {
-    name: "Tool name",
-    description: "Description of the tool",
-    pathInRouter: [...],
-    inputSchema: JSONSchema // this if full JSON schema from your zod schema
-  },
-  ...
-]
+To add tools to an `McpServer` you created yourself, call `registerTrpcTools(server, appRouter, ctx)`.
 
-*/
+## Context
+
+The third argument is the tRPC context. Pass a value, or a function that creates the context on each tool call. The function receives the MCP request context, so it can read the HTTP request and the auth info from your auth middleware.
+
+```typescript
+createMcpServer({ name: "my-app", version: "1.0.0" }, appRouter, (ctx) => ({
+  db,
+  headers: ctx.http?.req?.headers,
+  auth: ctx.http?.authInfo,
+}));
 ```
 
-## To MCP server
+Tool calls run through your tRPC middlewares, so auth checks in a `protectedProcedure` apply to MCP clients too.
 
-5. You can turn a router into an MCP server
+## Transform outputs
+
+By default a tool returns the procedure output as JSON text. To return something easier for a model to read, wrap the procedure with `transformMcpProcedure` and return MCP content blocks. The `output` argument is typed from the procedure.
 
 ```typescript
-import { appRouter } from "@/server/trpc/root.ts";
-import { createMcpServer } from "trpc-to-mcp";
+import { transformMcpProcedure } from "trpc-to-mcp";
 
-const ctx = {
-  session: {
-    // ...
-  },
-};
+export const appRouter = t.router({
+  weather: transformMcpProcedure(
+    t.procedure
+      .meta({
+        mcp: { enabled: true, description: "Current weather in a city" },
+      })
+      .input(z.object({ city: z.string() }))
+      .query(({ input }) => getWeather(input.city)),
+    (output) => [
+      { type: "text", text: `${output.city}: ${output.temperature}°C` },
+      { type: "image", data: output.radarPng, mimeType: "image/png" },
+    ],
+  ),
+});
+```
 
-// Returns high-level McpServer instance
-const mcpServer = createMcpServer(
-  implementation, // Pass your Implementation instance
-  appRouter,
-  ctx, // Pass your tRPC context
-);
+The content types are `text`, `image`, `audio`, `resource`, and `resource_link`. The procedure still returns its normal output to tRPC clients.
+
+## Structured output
+
+If a procedure has an `.output()` validator that describes an object, the tool advertises it as an `outputSchema` and returns the output as `structuredContent` next to the text content.
+
+```typescript
+t.procedure
+  .meta({ mcp: { enabled: true, description: "Look up a user" } })
+  .input(z.object({ id: z.string() }))
+  .output(z.object({ id: z.string(), name: z.string() }))
+  .query(({ input }) => db.user.find(input.id));
 ```
 
-## To Vercel MCP adapter
+## mcp-handler
 
-6. You can turn a router into `@vercel/mcp-adapter` handler
+[mcp-handler](https://github.com/vercel/mcp-handler) turns an MCP server into a `(Request) => Promise<Response>` handler for Next.js, Nuxt, SvelteKit, Hono, and other frameworks. Install `mcp-handler` 2, then:
 
 ```typescript
-// app/api/[transport]/route.ts
+// app/api/mcp/route.ts
 import { trpcToMcpHandler } from "trpc-to-mcp/adapters/vercel-mcp-adapter";
 
-const handler = trpcToHandler(appRouter, ctx, {
-  // @vercel/mcp-adapter config options
-  config: {
-    basePath: "/api",
-    // Disable in production
-    verboseLogs: true,
-    maxDuration: 60,
+const handler = trpcToMcpHandler(appRouter, createContext, {
+  // mcp-handler options
+  serverOptions: {
+    serverInfo: { name: "my-app", version: "1.0.0" },
+    verboseLogs: process.env.NODE_ENV === "development",
   },
-  // @vercel/mcp-adapter server options
-  serverOptions: { ... },
-  callback: (server) => {
-    // You can modify the McpServer instance
-  }
+  // Register extra tools, prompts, or resources
+  callback: (server) => {},
 });
 
-export { handler as DELETE, handler as GET, handler as POST };
+export { handler as GET, handler as POST };
 ```
 
+mcp-handler serves requests without sessions, so there is no Redis setup and no `basePath`. Mount the handler at any route.
+
 ## Use with better-auth
 
-7. You can use it with better-auth
+The [`@better-auth/mcp`](https://www.better-auth.com/docs/plugins/mcp) plugin makes your better-auth app an OAuth authorization server for MCP clients. Put your handler behind `requireMcpAuth`, and read the user ID from the access token claims.
 
 ```typescript
-// app/api/[transport]/route.ts
-
-import { withMcpAuth } from "better-auth/plugins";
-import { trpcToMcpHandler } from "trpc-to-mcp/adapters/vercel-mcp-adapter";
+// app/api/mcp/route.ts
+import { requireMcpAuth } from "@better-auth/mcp";
+import { createMcpHandler } from "@modelcontextprotocol/server";
+import { createMcpServer } from "trpc-to-mcp";
 
-// Define a function to retrieve user session from database
-async function getSession(mcpSession: McpSession): Promise<Session | null> {
-  // You can use mcpSession.userId to fetch session
-  // await db.query.session.findFirst({
-  //    where: (table, { eq }) => eq(table.userId, mcpSession.userId)
-  // })
-}
-
-const handler = withMcpAuth(auth, async (request, mcpSession) => {
-  // Retrieve the session from database via userId inside mcpSession
-  const session = await getSession(mcpSession);
-
-  const handler = trpcToMcpHandler(
-    appRouter,
-    // Pass your tRPC context here
-    {
-      db,
-      headers: request.headers,
-      session: session?.session,
-      user: session?.user,
-    },
-    {
-      config: {
-        basePath: "/api",
-        // Disable in production
-        verboseLogs: true,
-        maxDuration: 60,
-      },
-    },
+export const POST = requireMcpAuth(auth, (request, claims) => {
+  const handler = createMcpHandler(
+    () =>
+      createMcpServer({ name: "my-app", version: "1.0.0" }, appRouter, {
+        db,
+        userId: claims.sub,
+      }),
+    // @better-auth/mcp recommends serving only the 2026-07-28 protocol.
+    { legacy: "reject" },
   );
 
-  return await handler(request);
+  return handler.fetch(request);
 });
+```
+
+## List tools without a server
 
-export { handler as DELETE, handler as GET, handler as POST };
+`extractToolsFromProcedures` returns the tool definitions, including JSON input schemas, without creating a server.
+
+```typescript
+import { extractToolsFromProcedures } from "trpc-to-mcp";
+
+const tools = extractToolsFromProcedures(appRouter);
+// [{ name: "say_hello", description: "...", path: "hello", type: "query", inputSchema: {...} }]
 ```
 
+## Upgrading from 1.x
+
+- Replace `@modelcontextprotocol/sdk` with `@modelcontextprotocol/server` 2, and upgrade `mcp-handler` to 2 if you use the adapter.
+- In `trpcToMcpHandler`, remove `config`. Move `verboseLogs` into `serverOptions`, and mount the handler at the route you want.
+- Use zod 4.2 or later, or another validator with Standard JSON Schema support.
+- Replace `setRequestHandler(server.server, tools, caller)` with `registerTrpcTools(server, appRouter, ctx)`.
+- `McpTool.pathInRouter` is now `McpTool.path`, a dotted string.
+
+See [CHANGELOG.md](./CHANGELOG.md) for the full list.
+
 ## Result
 
 Now you can chill and add MCP to your VC-backed startup so your investors won't worry, and profit

package/dist/adapters/vercel-mcp-adapter.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_tools = require("../tools.cjs");
+let mcp_handler = require("mcp-handler");
+//#region src/adapters/vercel-mcp-adapter.ts
+/**
+* Creates an `mcp-handler` request handler, a `(Request) => Promise<Response>`
+* you can mount as a Next.js route or in any Fetch-compatible framework.
+* Use `callback` to register extra tools, prompts, or resources.
+*/
+function trpcToMcpHandler(router, ctx, options = {}) {
+	return (0, mcp_handler.createMcpHandler)(async (server) => {
+		require_tools.registerTrpcTools(server, router, ctx);
+		await options.callback?.(server);
+	}, options.serverOptions);
+}
+//#endregion
+exports.trpcToMcpHandler = trpcToMcpHandler;
+
+//# sourceMappingURL=vercel-mcp-adapter.cjs.map

package/dist/adapters/vercel-mcp-adapter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel-mcp-adapter.cjs","names":["createMcpHandler"],"sources":["../../src/adapters/vercel-mcp-adapter.ts"],"sourcesContent":["import type { McpServer } from \"@modelcontextprotocol/server\";\nimport type { AnyTRPCRouter } from \"@trpc/server\";\nimport { createMcpHandler, type McpHandlerOptions } from \"mcp-handler\";\n\nimport { registerTrpcTools } from \"../tools\";\nimport type { MaybePromise, McpContext } from \"../types\";\n\nexport type { McpHandlerOptions };\n\n/**\n * Creates an `mcp-handler` request handler, a `(Request) => Promise<Response>`\n * you can mount as a Next.js route or in any Fetch-compatible framework.\n * Use `callback` to register extra tools, prompts, or resources.\n */\nexport function trpcToMcpHandler<TRouter extends AnyTRPCRouter>(\n  router: TRouter,\n  ctx: McpContext<TRouter>,\n  options: {\n    serverOptions?: McpHandlerOptions;\n    callback?: (server: McpServer) => MaybePromise<void>;\n  } = {},\n) {\n  return createMcpHandler(async (server) => {\n    registerTrpcTools(server, router, ctx);\n    await options.callback?.(server);\n  }, options.serverOptions);\n}\n"],"mappings":";;;;;;;;;AAcA,SAAgB,iBACd,QACA,KACA,UAGI,CAAC,GACL;CACA,QAAA,GAAOA,YAAAA,iBAAAA,CAAiB,OAAO,WAAW;EACxC,cAAA,kBAAkB,QAAQ,QAAQ,GAAG;EACrC,MAAM,QAAQ,WAAW,MAAM;CACjC,GAAG,QAAQ,aAAa;AAC1B"}

package/dist/adapters/vercel-mcp-adapter.d.cts

@@ -0,0 +1,17 @@
+import { MaybePromise, McpContext } from "../types.cjs";
+import { McpServer } from "@modelcontextprotocol/server";
+import { AnyTRPCRouter } from "@trpc/server";
+import { McpHandlerOptions } from "mcp-handler";
+//#region src/adapters/vercel-mcp-adapter.d.ts
+/**
+ * Creates an `mcp-handler` request handler, a `(Request) => Promise<Response>`
+ * you can mount as a Next.js route or in any Fetch-compatible framework.
+ * Use `callback` to register extra tools, prompts, or resources.
+ */
+export declare function trpcToMcpHandler<TRouter extends AnyTRPCRouter>(router: TRouter, ctx: McpContext<TRouter>, options?: {
+  serverOptions?: McpHandlerOptions;
+  callback?: (server: McpServer) => MaybePromise<void>;
+}): (request: Request) => Promise<Response>;
+//#endregion
+export type { McpHandlerOptions };
+//# sourceMappingURL=vercel-mcp-adapter.d.cts.map

package/dist/adapters/vercel-mcp-adapter.d.mts

@@ -1,14 +1,17 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
-import { AnyRootTypes, RouterRecord, Router, MaybePromise } from '@trpc/server/unstable-core-do-not-import';
-import { createMcpHandler } from 'mcp-handler';
-
-type VercelMcpHandler = ReturnType<typeof createMcpHandler>;
-type McpServerOptions = Parameters<typeof createMcpHandler>[1];
-type McpHandlerConfig = Parameters<typeof createMcpHandler>[2];
-declare function trpcToMcpHandler<TRoot extends AnyRootTypes, TRecord extends RouterRecord>(appRouter: Router<TRoot, TRecord>, ctx: TRoot["ctx"] | (() => MaybePromise<TRoot["ctx"]>), handlerOptions: {
-    config: McpHandlerConfig;
-    serverOptions?: McpServerOptions;
-    callback?: (server: McpServer) => unknown;
+import { MaybePromise, McpContext } from "../types.mjs";
+import { McpServer } from "@modelcontextprotocol/server";
+import { AnyTRPCRouter } from "@trpc/server";
+import { McpHandlerOptions } from "mcp-handler";
+//#region src/adapters/vercel-mcp-adapter.d.ts
+/**
+ * Creates an `mcp-handler` request handler, a `(Request) => Promise<Response>`
+ * you can mount as a Next.js route or in any Fetch-compatible framework.
+ * Use `callback` to register extra tools, prompts, or resources.
+ */
+export declare function trpcToMcpHandler<TRouter extends AnyTRPCRouter>(router: TRouter, ctx: McpContext<TRouter>, options?: {
+  serverOptions?: McpHandlerOptions;
+  callback?: (server: McpServer) => MaybePromise<void>;
 }): (request: Request) => Promise<Response>;
-
-export { type McpHandlerConfig, type McpServerOptions, type VercelMcpHandler, trpcToMcpHandler };
+//#endregion
+export type { McpHandlerOptions };
+//# sourceMappingURL=vercel-mcp-adapter.d.mts.map

package/dist/adapters/vercel-mcp-adapter.mjs

@@ -1,30 +1,18 @@
-import { setRequestHandler } from '../chunk-7GYUHEUD.mjs';
-import { extractToolsFromProcedures } from '../chunk-ULLXW6IN.mjs';
-import { createMcpHandler } from 'mcp-handler';
-
-function trpcToMcpHandler(appRouter, ctx, handlerOptions) {
-  const { serverOptions, config, callback } = handlerOptions;
-  const tools = extractToolsFromProcedures(appRouter);
-  const trpcCaller = appRouter.createCaller(ctx);
-  const handler = createMcpHandler(
-    (server) => {
-      setRequestHandler(server.server, tools, trpcCaller);
-      if (typeof callback === "function") {
-        callback(server);
-      }
-    },
-    {
-      // Leave it empty because we list tools manually
-      capabilities: {
-        tools: {}
-      },
-      ...serverOptions
-    },
-    config
-  );
-  return handler;
+import { registerTrpcTools } from "../tools.mjs";
+import { createMcpHandler } from "mcp-handler";
+//#region src/adapters/vercel-mcp-adapter.ts
+/**
+* Creates an `mcp-handler` request handler, a `(Request) => Promise<Response>`
+* you can mount as a Next.js route or in any Fetch-compatible framework.
+* Use `callback` to register extra tools, prompts, or resources.
+*/
+function trpcToMcpHandler(router, ctx, options = {}) {
+	return createMcpHandler(async (server) => {
+		registerTrpcTools(server, router, ctx);
+		await options.callback?.(server);
+	}, options.serverOptions);
 }
-
+//#endregion
 export { trpcToMcpHandler };
-//# sourceMappingURL=vercel-mcp-adapter.mjs.map
+
 //# sourceMappingURL=vercel-mcp-adapter.mjs.map

package/dist/adapters/vercel-mcp-adapter.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/adapters/vercel-mcp-adapter.ts"],"names":[],"mappings":";;;;AAgBO,SAAS,gBAAA,CAId,SAAA,EACA,GAAA,EACA,cAAA,EAKA;AACA,EAAA,MAAM,EAAE,aAAA,EAAe,MAAA,EAAQ,QAAA,EAAS,GAAI,cAAA;AAE5C,EAAA,MAAM,KAAA,GAAQ,2BAA2B,SAAS,CAAA;AAClD,EAAA,MAAM,UAAA,GAAa,SAAA,CAAU,YAAA,CAAa,GAAG,CAAA;AAE7C,EAAA,MAAM,OAAA,GAAU,gBAAA;AAAA,IACd,CAAC,MAAA,KAAW;AACV,MAAA,iBAAA,CAAkB,MAAA,CAAO,MAAA,EAAQ,KAAA,EAAO,UAAU,CAAA;AAElD,MAAA,IAAI,OAAO,aAAa,UAAA,EAAY;AAClC,QAAA,QAAA,CAAS,MAAM,CAAA;AAAA,MACjB;AAAA,IACF,CAAA;AAAA,IACA;AAAA;AAAA,MAEE,YAAA,EAAc;AAAA,QACZ,OAAO;AAAC,OACV;AAAA,MACA,GAAG;AAAA,KACL;AAAA,IACA;AAAA,GACF;AAEA,EAAA,OAAO,OAAA;AACT","file":"vercel-mcp-adapter.mjs","sourcesContent":["import type { McpServer } from \"@modelcontextprotocol/sdk/server/mcp\";\nimport type {\n  AnyRootTypes,\n  MaybePromise,\n  Router,\n  RouterRecord,\n} from \"@trpc/server/unstable-core-do-not-import\";\nimport { createMcpHandler } from \"mcp-handler\";\n\nimport { setRequestHandler } from \"../server\";\nimport { extractToolsFromProcedures } from \"../tools\";\n\nexport type VercelMcpHandler = ReturnType<typeof createMcpHandler>;\nexport type McpServerOptions = Parameters<typeof createMcpHandler>[1];\nexport type McpHandlerConfig = Parameters<typeof createMcpHandler>[2];\n\nexport function trpcToMcpHandler<\n  TRoot extends AnyRootTypes,\n  TRecord extends RouterRecord,\n>(\n  appRouter: Router<TRoot, TRecord>,\n  ctx: TRoot[\"ctx\"] | (() => MaybePromise<TRoot[\"ctx\"]>),\n  handlerOptions: {\n    config: McpHandlerConfig;\n    serverOptions?: McpServerOptions;\n    callback?: (server: McpServer) => unknown;\n  },\n) {\n  const { serverOptions, config, callback } = handlerOptions;\n\n  const tools = extractToolsFromProcedures(appRouter);\n  const trpcCaller = appRouter.createCaller(ctx);\n\n  const handler = createMcpHandler(\n    (server) => {\n      setRequestHandler(server.server, tools, trpcCaller);\n\n      if (typeof callback === \"function\") {\n        callback(server);\n      }\n    },\n    {\n      // Leave it empty because we list tools manually\n      capabilities: {\n        tools: {},\n      },\n      ...serverOptions,\n    },\n    config,\n  );\n\n  return handler;\n}\n"]}
+{"version":3,"file":"vercel-mcp-adapter.mjs","names":[],"sources":["../../src/adapters/vercel-mcp-adapter.ts"],"sourcesContent":["import type { McpServer } from \"@modelcontextprotocol/server\";\nimport type { AnyTRPCRouter } from \"@trpc/server\";\nimport { createMcpHandler, type McpHandlerOptions } from \"mcp-handler\";\n\nimport { registerTrpcTools } from \"../tools\";\nimport type { MaybePromise, McpContext } from \"../types\";\n\nexport type { McpHandlerOptions };\n\n/**\n * Creates an `mcp-handler` request handler, a `(Request) => Promise<Response>`\n * you can mount as a Next.js route or in any Fetch-compatible framework.\n * Use `callback` to register extra tools, prompts, or resources.\n */\nexport function trpcToMcpHandler<TRouter extends AnyTRPCRouter>(\n  router: TRouter,\n  ctx: McpContext<TRouter>,\n  options: {\n    serverOptions?: McpHandlerOptions;\n    callback?: (server: McpServer) => MaybePromise<void>;\n  } = {},\n) {\n  return createMcpHandler(async (server) => {\n    registerTrpcTools(server, router, ctx);\n    await options.callback?.(server);\n  }, options.serverOptions);\n}\n"],"mappings":";;;;;;;;AAcA,SAAgB,iBACd,QACA,KACA,UAGI,CAAC,GACL;CACA,OAAO,iBAAiB,OAAO,WAAW;EACxC,kBAAkB,QAAQ,QAAQ,GAAG;EACrC,MAAM,QAAQ,WAAW,MAAM;CACjC,GAAG,QAAQ,aAAa;AAC1B"}

package/dist/helpers.cjs

@@ -0,0 +1,20 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/helpers.ts
+const transforms = /* @__PURE__ */ new WeakMap();
+/**
+* Wraps a procedure so its MCP tool returns `transform(output)` as content
+* instead of the JSON-serialized output. The procedure itself is unchanged.
+*/
+function transformMcpProcedure(procedure, transform) {
+	transforms.set(procedure, transform);
+	return procedure;
+}
+/** @internal Used by `extractToolsFromProcedures`. */
+function getMcpTransform(procedure) {
+	return transforms.get(procedure);
+}
+//#endregion
+exports.getMcpTransform = getMcpTransform;
+exports.transformMcpProcedure = transformMcpProcedure;
+
+//# sourceMappingURL=helpers.cjs.map

package/dist/helpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.cjs","names":[],"sources":["../src/helpers.ts"],"sourcesContent":["import type { ContentBlock } from \"@modelcontextprotocol/server\";\nimport type { AnyTRPCProcedure, inferProcedureOutput } from \"@trpc/server\";\n\nimport type { MaybePromise, McpToolTransform } from \"./types\";\n\n// Keyed by procedure instead of stored in meta: procedures built from the same\n// base procedure share one `meta.mcp` object, so writing to it would leak the\n// transform into sibling procedures.\nconst transforms = new WeakMap<AnyTRPCProcedure, McpToolTransform>();\n\n/**\n * Wraps a procedure so its MCP tool returns `transform(output)` as content\n * instead of the JSON-serialized output. The procedure itself is unchanged.\n */\nexport function transformMcpProcedure<TProcedure extends AnyTRPCProcedure>(\n  procedure: TProcedure,\n  transform: (\n    output: inferProcedureOutput<TProcedure>,\n  ) => MaybePromise<ContentBlock[]>,\n): TProcedure {\n  // The map only hands this transform the output of `procedure`.\n  transforms.set(procedure, transform as McpToolTransform);\n  return procedure;\n}\n\n/** @internal Used by `extractToolsFromProcedures`. */\nexport function getMcpTransform(procedure: AnyTRPCProcedure) {\n  return transforms.get(procedure);\n}\n"],"mappings":";;AAQA,MAAM,6BAAa,IAAI,QAA4C;;;;;AAMnE,SAAgB,sBACd,WACA,WAGY;CAEZ,WAAW,IAAI,WAAW,SAA6B;CACvD,OAAO;AACT;;AAGA,SAAgB,gBAAgB,WAA6B;CAC3D,OAAO,WAAW,IAAI,SAAS;AACjC"}

package/dist/helpers.d.cts

@@ -0,0 +1,13 @@
+import { MaybePromise, McpToolTransform } from "./types.cjs";
+import { ContentBlock } from "@modelcontextprotocol/server";
+import { AnyTRPCProcedure, inferProcedureOutput } from "@trpc/server";
+//#region src/helpers.d.ts
+/**
+ * Wraps a procedure so its MCP tool returns `transform(output)` as content
+ * instead of the JSON-serialized output. The procedure itself is unchanged.
+ */
+export declare function transformMcpProcedure<TProcedure extends AnyTRPCProcedure>(procedure: TProcedure, transform: (output: inferProcedureOutput<TProcedure>) => MaybePromise<ContentBlock[]>): TProcedure;
+/** @internal Used by `extractToolsFromProcedures`. */
+export declare function getMcpTransform(procedure: AnyTRPCProcedure): McpToolTransform | undefined;
+//#endregion
+//# sourceMappingURL=helpers.d.cts.map

package/dist/helpers.d.mts

@@ -1,6 +1,13 @@
-import { ContentBlock } from '@modelcontextprotocol/sdk/types';
-import { AnyProcedure, inferProcedureOutput, MaybePromise } from '@trpc/server/unstable-core-do-not-import';
-
-declare function transformMcpProcedure<TProcedure extends AnyProcedure>(procedure: TProcedure, callback: (output: inferProcedureOutput<TProcedure>) => MaybePromise<ContentBlock[]>): TProcedure;
-
-export { transformMcpProcedure };
+import { MaybePromise, McpToolTransform } from "./types.mjs";
+import { ContentBlock } from "@modelcontextprotocol/server";
+import { AnyTRPCProcedure, inferProcedureOutput } from "@trpc/server";
+//#region src/helpers.d.ts
+/**
+ * Wraps a procedure so its MCP tool returns `transform(output)` as content
+ * instead of the JSON-serialized output. The procedure itself is unchanged.
+ */
+export declare function transformMcpProcedure<TProcedure extends AnyTRPCProcedure>(procedure: TProcedure, transform: (output: inferProcedureOutput<TProcedure>) => MaybePromise<ContentBlock[]>): TProcedure;
+/** @internal Used by `extractToolsFromProcedures`. */
+export declare function getMcpTransform(procedure: AnyTRPCProcedure): McpToolTransform | undefined;
+//#endregion
+//# sourceMappingURL=helpers.d.mts.map

package/dist/helpers.mjs

@@ -1,3 +1,18 @@
-export { transformMcpProcedure } from './chunk-FIQIIJAT.mjs';
-//# sourceMappingURL=helpers.mjs.map
+//#region src/helpers.ts
+const transforms = /* @__PURE__ */ new WeakMap();
+/**
+* Wraps a procedure so its MCP tool returns `transform(output)` as content
+* instead of the JSON-serialized output. The procedure itself is unchanged.
+*/
+function transformMcpProcedure(procedure, transform) {
+	transforms.set(procedure, transform);
+	return procedure;
+}
+/** @internal Used by `extractToolsFromProcedures`. */
+function getMcpTransform(procedure) {
+	return transforms.get(procedure);
+}
+//#endregion
+export { getMcpTransform, transformMcpProcedure };
+
 //# sourceMappingURL=helpers.mjs.map

package/dist/helpers.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"helpers.mjs"}
+{"version":3,"file":"helpers.mjs","names":[],"sources":["../src/helpers.ts"],"sourcesContent":["import type { ContentBlock } from \"@modelcontextprotocol/server\";\nimport type { AnyTRPCProcedure, inferProcedureOutput } from \"@trpc/server\";\n\nimport type { MaybePromise, McpToolTransform } from \"./types\";\n\n// Keyed by procedure instead of stored in meta: procedures built from the same\n// base procedure share one `meta.mcp` object, so writing to it would leak the\n// transform into sibling procedures.\nconst transforms = new WeakMap<AnyTRPCProcedure, McpToolTransform>();\n\n/**\n * Wraps a procedure so its MCP tool returns `transform(output)` as content\n * instead of the JSON-serialized output. The procedure itself is unchanged.\n */\nexport function transformMcpProcedure<TProcedure extends AnyTRPCProcedure>(\n  procedure: TProcedure,\n  transform: (\n    output: inferProcedureOutput<TProcedure>,\n  ) => MaybePromise<ContentBlock[]>,\n): TProcedure {\n  // The map only hands this transform the output of `procedure`.\n  transforms.set(procedure, transform as McpToolTransform);\n  return procedure;\n}\n\n/** @internal Used by `extractToolsFromProcedures`. */\nexport function getMcpTransform(procedure: AnyTRPCProcedure) {\n  return transforms.get(procedure);\n}\n"],"mappings":";AAQA,MAAM,6BAAa,IAAI,QAA4C;;;;;AAMnE,SAAgB,sBACd,WACA,WAGY;CAEZ,WAAW,IAAI,WAAW,SAA6B;CACvD,OAAO;AACT;;AAGA,SAAgB,gBAAgB,WAA6B;CAC3D,OAAO,WAAW,IAAI,SAAS;AACjC"}

package/dist/index.cjs

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_helpers = require("./helpers.cjs");
+const require_tools = require("./tools.cjs");
+const require_server = require("./server.cjs");
+require("./types.cjs");
+exports.createMcpServer = require_server.createMcpServer;
+exports.extractToolsFromProcedures = require_tools.extractToolsFromProcedures;
+exports.registerTrpcTools = require_tools.registerTrpcTools;
+exports.transformMcpProcedure = require_helpers.transformMcpProcedure;