@silkweave/nestjs 2.4.0 → 2.5.0

package/build/mcp.d.mts

@@ -0,0 +1,35 @@
+import { n as NestSilkweaveAdapter } from "./types-ByWkPWx2.mjs";
+import { t as AuthConfig } from "./index-C1W-O7EX.mjs";
+import { CorsOptions } from "cors";
+
+//#region src/adapter/mcp.d.ts
+interface McpAdapterOptions {
+  /** URL prefix the MCP namespace lives under - the transport itself is at this exact path. Default `'/mcp'`. */
+  basePath?: string;
+  /** Optional bearer-token / OAuth 2.1 config. */
+  auth?: AuthConfig;
+  /** CORS configuration. `false` to disable, `true`/omitted for permissive defaults, or a `CorsOptions` object. */
+  cors?: CorsOptions | boolean;
+  /** Mount the sideload resource route at `${basePath}/resource/:id`. Default `true`. */
+  sideloadResources?: boolean;
+  /** Directory the sideload route reads from. Default `'resources'`. */
+  resourceDir?: string;
+}
+/**
+ * MCP adapter for `@silkweave/nestjs`. Registers the MCP Streamable HTTP
+ * transport, sideload, well-known and OAuth routes individually on Nest's
+ * HTTP adapter at the configured `basePath` (default `/mcp`):
+ *
+ * - `POST/GET/DELETE ${basePath}` - Streamable HTTP transport
+ * - `GET ${basePath}/resource/:id` - sideload (`sideloadResources` opt-out)
+ * - `GET ${basePath}/.well-known/oauth-protected-resource` - RFC 9728 metadata (when `auth.resourceUrl`/`auth.authorizationServers` set)
+ * - `GET ${basePath}/authorize`, `POST ${basePath}/token`, `POST ${basePath}/register`, `GET ${basePath}${callbackPath}` (when `auth.provider` set)
+ *
+ * Each route is a real Nest-level route - they show up in
+ * `RoutesResolver`'s log and there is no sub-app or middleware-slot
+ * indirection.
+ */
+declare function mcp(options?: McpAdapterOptions): NestSilkweaveAdapter;
+//#endregion
+export { McpAdapterOptions, mcp };
+//# sourceMappingURL=mcp.d.mts.map

package/build/mcp.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.mts","names":[],"sources":["../src/adapter/mcp.ts"],"mappings":";;;;;UAaiB,iBAAA;;EAEf,QAAA;EAFgC;EAIhC,IAAA,GAAO,UAAA;EAEW;EAAlB,IAAA,GAAO,WAAA;EAFP;EAIA,iBAAA;EAFA;EAIA,WAAA;AAAA;;;;AA6BF;;;;;;;;;;;iBAAgB,GAAA,CAAI,OAAA,GAAS,iBAAA,GAAyB,oBAAA"}

package/build/mcp.mjs

@@ -0,0 +1,61 @@
+import { authMiddleware, mcpCors, mcpTransport, oauthRoutes, protectedResourceMetadata, sideloadResource } from "@silkweave/mcp";
+import express from "express";
+//#region src/adapter/mcp.ts
+function compose(...handlers) {
+	return (req, res, next) => {
+		let i = 0;
+		const dispatch = () => {
+			const h = handlers[i++];
+			if (!h) return next();
+			h(req, res, (err) => err ? next(err) : dispatch());
+		};
+		dispatch();
+	};
+}
+/**
+* MCP adapter for `@silkweave/nestjs`. Registers the MCP Streamable HTTP
+* transport, sideload, well-known and OAuth routes individually on Nest's
+* HTTP adapter at the configured `basePath` (default `/mcp`):
+*
+* - `POST/GET/DELETE ${basePath}` - Streamable HTTP transport
+* - `GET ${basePath}/resource/:id` - sideload (`sideloadResources` opt-out)
+* - `GET ${basePath}/.well-known/oauth-protected-resource` - RFC 9728 metadata (when `auth.resourceUrl`/`auth.authorizationServers` set)
+* - `GET ${basePath}/authorize`, `POST ${basePath}/token`, `POST ${basePath}/register`, `GET ${basePath}${callbackPath}` (when `auth.provider` set)
+*
+* Each route is a real Nest-level route - they show up in
+* `RoutesResolver`'s log and there is no sub-app or middleware-slot
+* indirection.
+*/
+function mcp(options = {}) {
+	return {
+		name: "mcp",
+		register({ httpAdapter, silkweaveOptions, baseContext, actions }) {
+			const basePath = (options.basePath ?? "/mcp").replace(/\/$/, "");
+			if (!basePath) throw new Error("@silkweave/nestjs mcp(): basePath cannot be empty or \"/\" - pick a path like \"/mcp\".");
+			const adapter = httpAdapter;
+			const corsHandler = mcpCors(options.cors ?? true);
+			const auth = options.auth;
+			const guard = auth ? authMiddleware(auth, baseContext) : null;
+			const prefix = (...handlers) => handlers.filter((h) => Boolean(h));
+			if (auth?.authorizationServers?.length && auth.resourceUrl) adapter.get(`${basePath}/.well-known/oauth-protected-resource`, ...prefix(corsHandler, protectedResourceMetadata(auth)));
+			if (auth?.provider) {
+				const oauth = oauthRoutes(auth);
+				adapter.get(`${basePath}/.well-known/oauth-authorization-server`, ...prefix(corsHandler, oauth.wellKnownAuthServer));
+				adapter.get(`${basePath}/authorize`, ...prefix(corsHandler, oauth.authorize));
+				adapter.get(`${basePath}${oauth.callbackPath}`, ...prefix(corsHandler, oauth.callback));
+				adapter.post(`${basePath}/token`, ...prefix(corsHandler, ...oauth.token));
+				adapter.post(`${basePath}/register`, ...prefix(corsHandler, ...oauth.register));
+			}
+			const protect = guard ? (h) => compose(guard, h) : (h) => h;
+			if (options.sideloadResources !== false) adapter.get(`${basePath}/resource/:id`, ...prefix(corsHandler, protect(sideloadResource({ resourceDir: options.resourceDir }))));
+			const transport = mcpTransport(silkweaveOptions, baseContext, actions);
+			adapter.post(basePath, ...prefix(corsHandler, express.json(), protect(transport.post)));
+			adapter.get(basePath, ...prefix(corsHandler, protect(transport.stream)));
+			adapter.delete(basePath, ...prefix(corsHandler, protect(transport.stream)));
+		}
+	};
+}
+//#endregion
+export { mcp };
+
+//# sourceMappingURL=mcp.mjs.map

package/build/mcp.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.mjs","names":[],"sources":["../src/adapter/mcp.ts"],"sourcesContent":["import { AuthConfig } from '@silkweave/auth'\nimport {\n  authMiddleware,\n  mcpCors,\n  mcpTransport,\n  oauthRoutes,\n  protectedResourceMetadata,\n  sideloadResource\n} from '@silkweave/mcp'\nimport { type CorsOptions } from 'cors'\nimport express, { type RequestHandler } from 'express'\nimport type { NestAdapterRegisterContext, NestSilkweaveAdapter } from '../lib/types.js'\n\nexport interface McpAdapterOptions {\n  /** URL prefix the MCP namespace lives under - the transport itself is at this exact path. Default `'/mcp'`. */\n  basePath?: string\n  /** Optional bearer-token / OAuth 2.1 config. */\n  auth?: AuthConfig\n  /** CORS configuration. `false` to disable, `true`/omitted for permissive defaults, or a `CorsOptions` object. */\n  cors?: CorsOptions | boolean\n  /** Mount the sideload resource route at `${basePath}/resource/:id`. Default `true`. */\n  sideloadResources?: boolean\n  /** Directory the sideload route reads from. Default `'resources'`. */\n  resourceDir?: string\n}\n\nfunction compose(...handlers: RequestHandler[]): RequestHandler {\n  return (req, res, next) => {\n    let i = 0\n    const dispatch: () => void = () => {\n      const h = handlers[i++]\n      if (!h) { return next() }\n      h(req, res, (err) => err ? next(err) : dispatch())\n    }\n    dispatch()\n  }\n}\n\n/**\n * MCP adapter for `@silkweave/nestjs`. Registers the MCP Streamable HTTP\n * transport, sideload, well-known and OAuth routes individually on Nest's\n * HTTP adapter at the configured `basePath` (default `/mcp`):\n *\n * - `POST/GET/DELETE ${basePath}` - Streamable HTTP transport\n * - `GET ${basePath}/resource/:id` - sideload (`sideloadResources` opt-out)\n * - `GET ${basePath}/.well-known/oauth-protected-resource` - RFC 9728 metadata (when `auth.resourceUrl`/`auth.authorizationServers` set)\n * - `GET ${basePath}/authorize`, `POST ${basePath}/token`, `POST ${basePath}/register`, `GET ${basePath}${callbackPath}` (when `auth.provider` set)\n *\n * Each route is a real Nest-level route - they show up in\n * `RoutesResolver`'s log and there is no sub-app or middleware-slot\n * indirection.\n */\nexport function mcp(options: McpAdapterOptions = {}): NestSilkweaveAdapter {\n  return {\n    name: 'mcp',\n    register({ httpAdapter, silkweaveOptions, baseContext, actions }: NestAdapterRegisterContext): void {\n      const basePath = (options.basePath ?? '/mcp').replace(/\\/$/, '')\n      if (!basePath) { throw new Error('@silkweave/nestjs mcp(): basePath cannot be empty or \"/\" - pick a path like \"/mcp\".') }\n\n      const adapter = httpAdapter as unknown as {\n        get: (path: string, ...h: RequestHandler[]) => unknown\n        post: (path: string, ...h: RequestHandler[]) => unknown\n        delete: (path: string, ...h: RequestHandler[]) => unknown\n      }\n\n      const corsHandler = mcpCors(options.cors ?? true)\n      const auth = options.auth\n      const guard = auth ? authMiddleware(auth, baseContext) : null\n      const prefix = (...handlers: (RequestHandler | null)[]): RequestHandler[] =>\n        handlers.filter((h): h is RequestHandler => Boolean(h))\n\n      // Public auth-discovery / OAuth routes - registered first so they're\n      // never inadvertently guarded by the auth middleware.\n      if (auth?.authorizationServers?.length && auth.resourceUrl) {\n        adapter.get(\n          `${basePath}/.well-known/oauth-protected-resource`,\n          ...prefix(corsHandler, protectedResourceMetadata(auth))\n        )\n      }\n      if (auth?.provider) {\n        const oauth = oauthRoutes(auth)\n        adapter.get(`${basePath}/.well-known/oauth-authorization-server`, ...prefix(corsHandler, oauth.wellKnownAuthServer))\n        adapter.get(`${basePath}/authorize`, ...prefix(corsHandler, oauth.authorize))\n        adapter.get(`${basePath}${oauth.callbackPath}`, ...prefix(corsHandler, oauth.callback))\n        adapter.post(`${basePath}/token`, ...prefix(corsHandler, ...oauth.token))\n        adapter.post(`${basePath}/register`, ...prefix(corsHandler, ...oauth.register))\n      }\n\n      // Protected routes - wrapped with auth middleware (when configured).\n      const protect = guard ? (h: RequestHandler) => compose(guard, h) : (h: RequestHandler) => h\n\n      if (options.sideloadResources !== false) {\n        adapter.get(`${basePath}/resource/:id`, ...prefix(corsHandler, protect(sideloadResource({ resourceDir: options.resourceDir }))))\n      }\n\n      const transport = mcpTransport(silkweaveOptions, baseContext, actions)\n      adapter.post(basePath, ...prefix(corsHandler, express.json(), protect(transport.post)))\n      adapter.get(basePath, ...prefix(corsHandler, protect(transport.stream)))\n      adapter.delete(basePath, ...prefix(corsHandler, protect(transport.stream)))\n    }\n  }\n}\n"],"mappings":";;;AA0BA,SAAS,QAAQ,GAAG,UAA4C;AAC9D,SAAQ,KAAK,KAAK,SAAS;EACzB,IAAI,IAAI;EACR,MAAM,iBAA6B;GACjC,MAAM,IAAI,SAAS;AACnB,OAAI,CAAC,EAAK,QAAO,MAAM;AACvB,KAAE,KAAK,MAAM,QAAQ,MAAM,KAAK,IAAI,GAAG,UAAU,CAAC;;AAEpD,YAAU;;;;;;;;;;;;;;;;;AAkBd,SAAgB,IAAI,UAA6B,EAAE,EAAwB;AACzE,QAAO;EACL,MAAM;EACN,SAAS,EAAE,aAAa,kBAAkB,aAAa,WAA6C;GAClG,MAAM,YAAY,QAAQ,YAAY,QAAQ,QAAQ,OAAO,GAAG;AAChE,OAAI,CAAC,SAAY,OAAM,IAAI,MAAM,0FAAsF;GAEvH,MAAM,UAAU;GAMhB,MAAM,cAAc,QAAQ,QAAQ,QAAQ,KAAK;GACjD,MAAM,OAAO,QAAQ;GACrB,MAAM,QAAQ,OAAO,eAAe,MAAM,YAAY,GAAG;GACzD,MAAM,UAAU,GAAG,aACjB,SAAS,QAAQ,MAA2B,QAAQ,EAAE,CAAC;AAIzD,OAAI,MAAM,sBAAsB,UAAU,KAAK,YAC7C,SAAQ,IACN,GAAG,SAAS,wCACZ,GAAG,OAAO,aAAa,0BAA0B,KAAK,CAAC,CACxD;AAEH,OAAI,MAAM,UAAU;IAClB,MAAM,QAAQ,YAAY,KAAK;AAC/B,YAAQ,IAAI,GAAG,SAAS,0CAA0C,GAAG,OAAO,aAAa,MAAM,oBAAoB,CAAC;AACpH,YAAQ,IAAI,GAAG,SAAS,aAAa,GAAG,OAAO,aAAa,MAAM,UAAU,CAAC;AAC7E,YAAQ,IAAI,GAAG,WAAW,MAAM,gBAAgB,GAAG,OAAO,aAAa,MAAM,SAAS,CAAC;AACvF,YAAQ,KAAK,GAAG,SAAS,SAAS,GAAG,OAAO,aAAa,GAAG,MAAM,MAAM,CAAC;AACzE,YAAQ,KAAK,GAAG,SAAS,YAAY,GAAG,OAAO,aAAa,GAAG,MAAM,SAAS,CAAC;;GAIjF,MAAM,UAAU,SAAS,MAAsB,QAAQ,OAAO,EAAE,IAAI,MAAsB;AAE1F,OAAI,QAAQ,sBAAsB,MAChC,SAAQ,IAAI,GAAG,SAAS,gBAAgB,GAAG,OAAO,aAAa,QAAQ,iBAAiB,EAAE,aAAa,QAAQ,aAAa,CAAC,CAAC,CAAC,CAAC;GAGlI,MAAM,YAAY,aAAa,kBAAkB,aAAa,QAAQ;AACtE,WAAQ,KAAK,UAAU,GAAG,OAAO,aAAa,QAAQ,MAAM,EAAE,QAAQ,UAAU,KAAK,CAAC,CAAC;AACvF,WAAQ,IAAI,UAAU,GAAG,OAAO,aAAa,QAAQ,UAAU,OAAO,CAAC,CAAC;AACxE,WAAQ,OAAO,UAAU,GAAG,OAAO,aAAa,QAAQ,UAAU,OAAO,CAAC,CAAC;;EAE9E"}

package/build/trpc.d.mts

@@ -0,0 +1,39 @@
+import { n as NestSilkweaveAdapter } from "./types-ByWkPWx2.mjs";
+import { t as AuthConfig } from "./index-C1W-O7EX.mjs";
+import { CorsOptions } from "cors";
+
+//#region src/adapter/trpc.d.ts
+interface TrpcAdapterOptions {
+  /** URL prefix the tRPC handler mounts on. Default `'/trpc'`. */
+  basePath?: string;
+  /**
+   * CORS configuration. `false` to disable, `true`/omitted for permissive
+   * defaults, or a `CorsOptions` object. For cookie-based auth set
+   * `{ origin: '<spa-origin>', credentials: true }` so the browser sends the
+   * session cookie (`credentials: 'include'` / `withCredentials`).
+   */
+  cors?: CorsOptions | boolean;
+  /**
+   * Optional bearer-token / OAuth 2.1 config. Usually omitted - `@Trpc` routes
+   * authenticate with their own `@UseGuards()` reading the real Express request
+   * (cookies/headers), so no separate auth config is needed. Provide this only
+   * to additionally validate an `Authorization` bearer at the transport edge.
+   */
+  auth?: AuthConfig;
+}
+/**
+ * tRPC adapter for `@silkweave/nestjs`. Mounts a single tRPC HTTP handler (httpBatch
+ * for queries/mutations, SSE for subscriptions) on Nest's HTTP adapter at the
+ * configured `basePath` (default `/trpc`), built from every `@Trpc`-decorated
+ * controller method.
+ *
+ * Each procedure runs the method's `@UseGuards()` first, with the guard receiving
+ * a real `ExecutionContext` whose `switchToHttp().getRequest()` is the **actual
+ * Express request** (cookies/headers/`req.user`) - so cookie-session auth works
+ * with no separate auth config. A denying guard surfaces to the client as a
+ * `TRPCError` whose `data.httpStatus` is the guard's HTTP status (401/403).
+ */
+declare function trpc(options?: TrpcAdapterOptions): NestSilkweaveAdapter;
+//#endregion
+export { TrpcAdapterOptions, trpc };
+//# sourceMappingURL=trpc.d.mts.map

package/build/trpc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trpc.d.mts","names":[],"sources":["../src/adapter/trpc.ts"],"mappings":";;;;;UAQiB,kBAAA;;EAEf,QAAA;EAFiC;;;;;;EASjC,IAAA,GAAO,WAAA;EAOA;;;AAqBT;;;EArBE,IAAA,GAAO,UAAA;AAAA;;;;;;;;;;;;;iBAqBO,IAAA,CAAK,OAAA,GAAS,kBAAA,GAA0B,oBAAA"}

package/build/trpc.mjs

@@ -0,0 +1,59 @@
+import { buildRouter, createActionLogger, resolveAuth } from "@silkweave/trpc";
+import { createExpressMiddleware } from "@trpc/server/adapters/express";
+import { TRPCError } from "@trpc/server";
+import cors from "cors";
+//#region src/adapter/trpc.ts
+function resolveCors(config) {
+	if (config === false) return null;
+	return cors({
+		origin: "*",
+		...config === true || config === void 0 ? {} : config
+	});
+}
+/**
+* tRPC adapter for `@silkweave/nestjs`. Mounts a single tRPC HTTP handler (httpBatch
+* for queries/mutations, SSE for subscriptions) on Nest's HTTP adapter at the
+* configured `basePath` (default `/trpc`), built from every `@Trpc`-decorated
+* controller method.
+*
+* Each procedure runs the method's `@UseGuards()` first, with the guard receiving
+* a real `ExecutionContext` whose `switchToHttp().getRequest()` is the **actual
+* Express request** (cookies/headers/`req.user`) - so cookie-session auth works
+* with no separate auth config. A denying guard surfaces to the client as a
+* `TRPCError` whose `data.httpStatus` is the guard's HTTP status (401/403).
+*/
+function trpc(options = {}) {
+	return {
+		name: "trpc",
+		register({ httpAdapter, baseContext, actions }) {
+			const basePath = (options.basePath ?? "/trpc").replace(/\/$/, "");
+			if (!basePath) throw new Error("@silkweave/nestjs trpc(): basePath cannot be empty or \"/\" - pick a path like \"/trpc\".");
+			const router = buildRouter(actions);
+			const logger = createActionLogger();
+			const middleware = createExpressMiddleware({
+				router,
+				createContext: async ({ req, res }) => {
+					const resolved = await resolveAuth(options.auth, req.headers.authorization, baseContext.fork({ request: req }));
+					if (resolved.kind === "error") throw new TRPCError({
+						code: "UNAUTHORIZED",
+						message: resolved.error.body.error_description
+					});
+					return { silkweaveContext: baseContext.fork({
+						logger,
+						request: req,
+						response: res,
+						...resolved.authInfo ? { auth: resolved.authInfo } : {}
+					}) };
+				}
+			});
+			const adapter = httpAdapter;
+			const corsHandler = resolveCors(options.cors ?? true);
+			const handlers = corsHandler ? [corsHandler, middleware] : [middleware];
+			adapter.use(basePath, ...handlers);
+		}
+	};
+}
+//#endregion
+export { trpc };
+
+//# sourceMappingURL=trpc.mjs.map

package/build/trpc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trpc.mjs","names":[],"sources":["../src/adapter/trpc.ts"],"sourcesContent":["import { AuthConfig } from '@silkweave/auth'\nimport { buildRouter, createActionLogger, resolveAuth, type TrpcHandlerContext } from '@silkweave/trpc'\nimport { createExpressMiddleware } from '@trpc/server/adapters/express'\nimport { TRPCError } from '@trpc/server'\nimport cors, { type CorsOptions } from 'cors'\nimport type { Request, RequestHandler, Response } from 'express'\nimport type { NestAdapterRegisterContext, NestSilkweaveAdapter } from '../lib/types.js'\n\nexport interface TrpcAdapterOptions {\n  /** URL prefix the tRPC handler mounts on. Default `'/trpc'`. */\n  basePath?: string\n  /**\n   * CORS configuration. `false` to disable, `true`/omitted for permissive\n   * defaults, or a `CorsOptions` object. For cookie-based auth set\n   * `{ origin: '<spa-origin>', credentials: true }` so the browser sends the\n   * session cookie (`credentials: 'include'` / `withCredentials`).\n   */\n  cors?: CorsOptions | boolean\n  /**\n   * Optional bearer-token / OAuth 2.1 config. Usually omitted - `@Trpc` routes\n   * authenticate with their own `@UseGuards()` reading the real Express request\n   * (cookies/headers), so no separate auth config is needed. Provide this only\n   * to additionally validate an `Authorization` bearer at the transport edge.\n   */\n  auth?: AuthConfig\n}\n\nfunction resolveCors(config: CorsOptions | boolean | undefined): RequestHandler | null {\n  if (config === false) { return null }\n  const userConfig = config === true || config === undefined ? {} : config\n  return cors({ origin: '*', ...userConfig }) as RequestHandler\n}\n\n/**\n * tRPC adapter for `@silkweave/nestjs`. Mounts a single tRPC HTTP handler (httpBatch\n * for queries/mutations, SSE for subscriptions) on Nest's HTTP adapter at the\n * configured `basePath` (default `/trpc`), built from every `@Trpc`-decorated\n * controller method.\n *\n * Each procedure runs the method's `@UseGuards()` first, with the guard receiving\n * a real `ExecutionContext` whose `switchToHttp().getRequest()` is the **actual\n * Express request** (cookies/headers/`req.user`) - so cookie-session auth works\n * with no separate auth config. A denying guard surfaces to the client as a\n * `TRPCError` whose `data.httpStatus` is the guard's HTTP status (401/403).\n */\nexport function trpc(options: TrpcAdapterOptions = {}): NestSilkweaveAdapter {\n  return {\n    name: 'trpc',\n    register({ httpAdapter, baseContext, actions }: NestAdapterRegisterContext): void {\n      const basePath = (options.basePath ?? '/trpc').replace(/\\/$/, '')\n      if (!basePath) { throw new Error('@silkweave/nestjs trpc(): basePath cannot be empty or \"/\" - pick a path like \"/trpc\".') }\n\n      const router = buildRouter(actions)\n      const logger = createActionLogger()\n\n      const middleware = createExpressMiddleware({\n        router,\n        createContext: async ({ req, res }: { req: Request; res: Response }): Promise<TrpcHandlerContext> => {\n          const resolved = await resolveAuth(options.auth, req.headers.authorization, baseContext.fork({ request: req }))\n          if (resolved.kind === 'error') {\n            throw new TRPCError({ code: 'UNAUTHORIZED', message: resolved.error.body.error_description })\n          }\n          return {\n            silkweaveContext: baseContext.fork({\n              logger,\n              request: req,\n              response: res,\n              ...(resolved.authInfo ? { auth: resolved.authInfo } : {})\n            })\n          }\n        }\n      }) as unknown as RequestHandler\n\n      const adapter = httpAdapter as unknown as { use: (path: string, ...handlers: RequestHandler[]) => unknown }\n      const corsHandler = resolveCors(options.cors ?? true)\n      const handlers = corsHandler ? [corsHandler, middleware] : [middleware]\n      adapter.use(basePath, ...handlers)\n    }\n  }\n}\n"],"mappings":";;;;;AA2BA,SAAS,YAAY,QAAkE;AACrF,KAAI,WAAW,MAAS,QAAO;AAE/B,QAAO,KAAK;EAAE,QAAQ;EAAK,GADR,WAAW,QAAQ,WAAW,KAAA,IAAY,EAAE,GAAG;EACxB,CAAC;;;;;;;;;;;;;;AAe7C,SAAgB,KAAK,UAA8B,EAAE,EAAwB;AAC3E,QAAO;EACL,MAAM;EACN,SAAS,EAAE,aAAa,aAAa,WAA6C;GAChF,MAAM,YAAY,QAAQ,YAAY,SAAS,QAAQ,OAAO,GAAG;AACjE,OAAI,CAAC,SAAY,OAAM,IAAI,MAAM,4FAAwF;GAEzH,MAAM,SAAS,YAAY,QAAQ;GACnC,MAAM,SAAS,oBAAoB;GAEnC,MAAM,aAAa,wBAAwB;IACzC;IACA,eAAe,OAAO,EAAE,KAAK,UAAwE;KACnG,MAAM,WAAW,MAAM,YAAY,QAAQ,MAAM,IAAI,QAAQ,eAAe,YAAY,KAAK,EAAE,SAAS,KAAK,CAAC,CAAC;AAC/G,SAAI,SAAS,SAAS,QACpB,OAAM,IAAI,UAAU;MAAE,MAAM;MAAgB,SAAS,SAAS,MAAM,KAAK;MAAmB,CAAC;AAE/F,YAAO,EACL,kBAAkB,YAAY,KAAK;MACjC;MACA,SAAS;MACT,UAAU;MACV,GAAI,SAAS,WAAW,EAAE,MAAM,SAAS,UAAU,GAAG,EAAE;MACzD,CAAC,EACH;;IAEJ,CAAC;GAEF,MAAM,UAAU;GAChB,MAAM,cAAc,YAAY,QAAQ,QAAQ,KAAK;GACrD,MAAM,WAAW,cAAc,CAAC,aAAa,WAAW,GAAG,CAAC,WAAW;AACvE,WAAQ,IAAI,UAAU,GAAG,SAAS;;EAErC"}

package/build/typegen.d.mts

@@ -0,0 +1,32 @@
+import { n as NestSilkweaveAdapter } from "./types-ByWkPWx2.mjs";
+import { TypegenFormat } from "@silkweave/typegen";
+
+//#region src/adapter/typegen.d.ts
+interface TypegenAdapterOptions {
+  /** Output file path for the generated `.d.ts`/`.ts` file. Resolved against `process.cwd()`. Parent dirs are created. */
+  path: string;
+  /**
+   * What to emit. Defaults to `'trpc-router'` - an `AppRouter` type alias
+   * (`TRPCBuiltRouter`) for `createTRPCClient<AppRouter>()`, with one
+   * `TRPCQueryProcedure`/`TRPCMutationProcedure`/`TRPCSubscriptionProcedure` per
+   * `@Trpc` route keyed by camelCase name, carrying precise input/output types.
+   * Use `'interfaces'` for `{Name}Input`/`{Name}Output` interfaces, or `'all'` for both.
+   */
+  format?: TypegenFormat;
+}
+/**
+ * Type-generation adapter for `@silkweave/nestjs`. On module bootstrap it writes
+ * a `.ts` file containing the tRPC `AppRouter` type covering every `@Trpc`
+ * procedure - the exact `TRPCBuiltRouter` contract `createTRPCClient<AppRouter>()`
+ * + `inferRouterInputs`/`inferRouterOutputs` consume. It only sees `@Trpc`
+ * actions (MCP tools are gated out), so the emitted router matches what the
+ * `trpc()` adapter serves at runtime.
+ *
+ * `@silkweave/typegen` (which pulls in the TypeScript compiler API) is imported
+ * lazily inside `register()`, so MCP-only apps that never use this adapter don't
+ * load it.
+ */
+declare function typegen(options: TypegenAdapterOptions): NestSilkweaveAdapter;
+//#endregion
+export { TypegenAdapterOptions, typegen };
+//# sourceMappingURL=typegen.d.mts.map

package/build/typegen.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typegen.d.mts","names":[],"sources":["../src/adapter/typegen.ts"],"mappings":";;;;UAKiB,qBAAA;;EAEf,IAAA;EAFoC;;;;;;;EAUpC,MAAA,GAAS,aAAA;AAAA;;;;;;;;;;;;;iBAeK,OAAA,CAAQ,OAAA,EAAS,qBAAA,GAAwB,oBAAA"}

package/build/typegen.mjs

@@ -0,0 +1,36 @@
+import { dirname, resolve } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+//#region src/adapter/typegen.ts
+/**
+* Type-generation adapter for `@silkweave/nestjs`. On module bootstrap it writes
+* a `.ts` file containing the tRPC `AppRouter` type covering every `@Trpc`
+* procedure - the exact `TRPCBuiltRouter` contract `createTRPCClient<AppRouter>()`
+* + `inferRouterInputs`/`inferRouterOutputs` consume. It only sees `@Trpc`
+* actions (MCP tools are gated out), so the emitted router matches what the
+* `trpc()` adapter serves at runtime.
+*
+* `@silkweave/typegen` (which pulls in the TypeScript compiler API) is imported
+* lazily inside `register()`, so MCP-only apps that never use this adapter don't
+* load it.
+*/
+function typegen(options) {
+	return {
+		name: "typegen",
+		register({ actions }) {
+			const target = resolve(options.path);
+			(async () => {
+				const { renderTypegen } = await import("@silkweave/typegen");
+				const output = renderTypegen(actions, options.format ?? "trpc-router");
+				await mkdir(dirname(target), { recursive: true });
+				await writeFile(target, output, "utf-8");
+				console.info(`@silkweave/nestjs typegen: wrote ${actions.length} tRPC procedure types to ${target}`);
+			})().catch((error) => {
+				console.error(`@silkweave/nestjs typegen: failed to write ${target}:`, error);
+			});
+		}
+	};
+}
+//#endregion
+export { typegen };
+
+//# sourceMappingURL=typegen.mjs.map

package/build/typegen.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"typegen.mjs","names":[],"sources":["../src/adapter/typegen.ts"],"sourcesContent":["import { mkdir, writeFile } from 'node:fs/promises'\nimport { dirname, resolve } from 'node:path'\nimport type { TypegenFormat } from '@silkweave/typegen'\nimport type { NestAdapterRegisterContext, NestSilkweaveAdapter } from '../lib/types.js'\n\nexport interface TypegenAdapterOptions {\n  /** Output file path for the generated `.d.ts`/`.ts` file. Resolved against `process.cwd()`. Parent dirs are created. */\n  path: string\n  /**\n   * What to emit. Defaults to `'trpc-router'` - an `AppRouter` type alias\n   * (`TRPCBuiltRouter`) for `createTRPCClient<AppRouter>()`, with one\n   * `TRPCQueryProcedure`/`TRPCMutationProcedure`/`TRPCSubscriptionProcedure` per\n   * `@Trpc` route keyed by camelCase name, carrying precise input/output types.\n   * Use `'interfaces'` for `{Name}Input`/`{Name}Output` interfaces, or `'all'` for both.\n   */\n  format?: TypegenFormat\n}\n\n/**\n * Type-generation adapter for `@silkweave/nestjs`. On module bootstrap it writes\n * a `.ts` file containing the tRPC `AppRouter` type covering every `@Trpc`\n * procedure - the exact `TRPCBuiltRouter` contract `createTRPCClient<AppRouter>()`\n * + `inferRouterInputs`/`inferRouterOutputs` consume. It only sees `@Trpc`\n * actions (MCP tools are gated out), so the emitted router matches what the\n * `trpc()` adapter serves at runtime.\n *\n * `@silkweave/typegen` (which pulls in the TypeScript compiler API) is imported\n * lazily inside `register()`, so MCP-only apps that never use this adapter don't\n * load it.\n */\nexport function typegen(options: TypegenAdapterOptions): NestSilkweaveAdapter {\n  return {\n    name: 'typegen',\n    register({ actions }: NestAdapterRegisterContext): void {\n      const target = resolve(options.path)\n      void (async () => {\n        const { renderTypegen } = await import('@silkweave/typegen')\n        const output = renderTypegen(actions, options.format ?? 'trpc-router')\n        await mkdir(dirname(target), { recursive: true })\n        await writeFile(target, output, 'utf-8')\n        console.info(`@silkweave/nestjs typegen: wrote ${actions.length} tRPC procedure types to ${target}`)\n      })().catch((error: unknown) => {\n        console.error(`@silkweave/nestjs typegen: failed to write ${target}:`, error)\n      })\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AA8BA,SAAgB,QAAQ,SAAsD;AAC5E,QAAO;EACL,MAAM;EACN,SAAS,EAAE,WAA6C;GACtD,MAAM,SAAS,QAAQ,QAAQ,KAAK;AACpC,IAAM,YAAY;IAChB,MAAM,EAAE,kBAAkB,MAAM,OAAO;IACvC,MAAM,SAAS,cAAc,SAAS,QAAQ,UAAU,cAAc;AACtE,UAAM,MAAM,QAAQ,OAAO,EAAE,EAAE,WAAW,MAAM,CAAC;AACjD,UAAM,UAAU,QAAQ,QAAQ,QAAQ;AACxC,YAAQ,KAAK,oCAAoC,QAAQ,OAAO,2BAA2B,SAAS;OAClG,CAAC,OAAO,UAAmB;AAC7B,YAAQ,MAAM,8CAA8C,OAAO,IAAI,MAAM;KAC7E;;EAEL"}

package/build/types-ByWkPWx2.d.mts

@@ -0,0 +1,162 @@
+import { CanActivate, Type } from "@nestjs/common";
+import { HttpAdapterHost } from "@nestjs/core";
+import { Action, SilkweaveContext, SilkweaveOptions } from "@silkweave/core";
+import { z } from "zod/v4";
+
+//#region src/lib/reflect/schema.d.ts
+/**
+ * A transport-neutral description of a single input field. Every metadata
+ * source (swagger decorators, class-validator, an OpenAPI document, TypeScript
+ * `design:type`) is mapped to this shape, the shapes are merged by precedence,
+ * and the result is converted to Zod once. Keeping a single intermediate keeps
+ * the per-source mappers small and the Zod construction in one place.
+ */
+interface FieldDesc {
+  type?: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'unknown';
+  required?: boolean;
+  description?: string;
+  enum?: (string | number)[];
+  items?: FieldDesc;
+  min?: number;
+  max?: number;
+  minLength?: number;
+  maxLength?: number;
+  format?: string;
+  default?: unknown;
+}
+/** Merge `over` onto `base` - defined keys of `over` win. */
+declare function mergeField(base: FieldDesc, over: FieldDesc): FieldDesc;
+/** Convert a merged {@link FieldDesc} to a Zod schema. */
+declare function fieldToZod(d: FieldDesc): z.ZodType;
+/** Normalise a TS-enum object or an array literal to a flat value list. */
+declare function normalizeEnum(value: unknown): (string | number)[] | undefined;
+/** Map a swagger/`design:type` type token (constructor, `[Type]`, or string) to a base type. */
+declare function typeTokenToBase(type: unknown): FieldDesc['type'] | undefined;
+/** From the constructor TypeScript emits via `emitDecoratorMetadata`. */
+declare function designTypeToField(ctor: unknown): FieldDesc;
+/** From an `@ApiParam`/`@ApiQuery` entry stored under `swagger/apiParameters`. */
+declare function swaggerParamToField(p: Record<string, any>): FieldDesc;
+/** From an `@ApiProperty` options object stored under `swagger/apiModelProperties`. */
+declare function apiPropertyToField(o: Record<string, any>): FieldDesc;
+/** From an array of `class-validator` validation-metadata entries for one property. */
+declare function classValidatorToField(metas: Array<{
+  type?: string;
+  name?: string;
+  constraints?: unknown[];
+}>): FieldDesc;
+/** From an OpenAPI Schema Object (used by both the doc and `@ApiParam({ schema })`). */
+declare function openapiSchemaToField(schema: Record<string, any>): FieldDesc;
+/**
+ * Reflect a whole-DTO class (`@Body() dto: CreateDto`) into per-property
+ * {@link FieldDesc}s. Property names are the union of `@ApiProperty` and
+ * `class-validator` decorated fields; each field merges `design:type` (base),
+ * then `class-validator` constraints, then `@ApiProperty` (highest). Properties
+ * default to required unless a source marks them optional.
+ */
+declare function reflectDtoFields(dtoType: any): Record<string, FieldDesc>;
+//#endregion
+//#region src/lib/reflect/openapi.d.ts
+/**
+ * A minimal view of an OpenAPI document - the subset we read. Matches the shape
+ * `SwaggerModule.createDocument()` returns, but typed loosely so callers can
+ * pass any compatible object without a hard `@nestjs/swagger` dependency.
+ */
+interface OpenApiDocument {
+  paths?: Record<string, Record<string, any>>;
+  components?: {
+    schemas?: Record<string, any>;
+  };
+}
+interface OpenApiLookup {
+  doc: OpenApiDocument;
+  /** `${METHOD} ${path}` → operation object. */
+  operations: Map<string, any>;
+}
+/** Index a document's operations by `${METHOD} ${path}` for fast matching. */
+declare function buildOpenApiLookup(doc: OpenApiDocument): OpenApiLookup;
+/**
+ * Resolve the per-field descriptors for a route from an ingested OpenAPI
+ * document. Merges `parameters` (path/query/header) and the JSON request-body
+ * schema's properties into a single field map. Returns `{}` when the operation
+ * isn't found - callers fall back to decorator reflection.
+ */
+declare function openApiFields(lookup: OpenApiLookup, method: string, openapiPath: string): Record<string, FieldDesc>;
+//#endregion
+//#region src/lib/types.d.ts
+/**
+ * Context passed to a Nest Silkweave adapter when `SilkweaveModule` wires it
+ * up. Adapters register their routes directly on `httpAdapter` (no
+ * placeholder middleware, no `silkweave()` builder), so they only fire
+ * `register()` once and own the rest of their lifecycle implicitly through
+ * Nest.
+ */
+interface NestAdapterRegisterContext {
+  /** Nest's underlying HTTP adapter (Express or Fastify). */
+  httpAdapter: NonNullable<HttpAdapterHost['httpAdapter']>;
+  /** Identity the adapter surfaces to clients (e.g. MCP server name). */
+  silkweaveOptions: SilkweaveOptions;
+  /** Per-adapter context - already forked with `{ adapter: adapter.name, ...userContext }`. */
+  baseContext: SilkweaveContext;
+  /** Actions filtered to those enabled on this adapter. */
+  actions: Action[];
+}
+/**
+ * A Silkweave Nest adapter. Each transport (REST, tRPC, MCP) implements this
+ * shape. `register()` is called from `SilkweaveModule.configure()` - which
+ * runs *before* Nest's controller routes are mapped - so adapter routes
+ * always sit ahead of any catch-all controllers in the framework's request
+ * pipeline.
+ */
+interface NestSilkweaveAdapter {
+  /** Adapter discriminator - set on the silkweave context as `ctx.get('adapter')`. */
+  readonly name: 'mcp' | 'trpc' | 'typegen';
+  /** URL prefix the adapter mounts on (e.g. `'/mcp'`). Surfaced for introspection. */
+  readonly basePath?: string;
+  /**
+   * When `true`, the adapter receives every discovered action regardless of
+   * each action's `isEnabled` gate. Reserved for non-runtime adapters that need
+   * the entire action surface.
+   */
+  readonly allActions?: boolean;
+  /** Register this adapter's routes on Nest's HTTP server. */
+  register(ctx: NestAdapterRegisterContext): void;
+}
+interface SilkweaveModuleOptions {
+  /** Identity for the silkweave instance - surfaced to MCP clients, OpenAPI, etc. */
+  silkweave: SilkweaveOptions;
+  /** Adapters to mount - any of `mcp()`, `trpc()`, `typegen()`. */
+  adapters: NestSilkweaveAdapter[];
+  /** Initial context keys merged into every adapter's `baseContext`. */
+  context?: Record<string, unknown>;
+  /**
+   * Optional OpenAPI document (e.g. from `SwaggerModule.createDocument(app, cfg)`)
+   * used as an authoritative source when reflecting `@Mcp` tool input schemas.
+   * Matched to each method by HTTP verb + path; falls back to decorator
+   * reflection when an operation or field isn't present.
+   */
+  openapi?: OpenApiDocument;
+  /**
+   * Opt-in allow-list of app-global guard classes (registered via
+   * `app.useGlobalGuards()` or `{ provide: APP_GUARD, useClass }`) to run on
+   * every MCP tool call, before each method/class `@UseGuards`. Listed by
+   * class - a blanket "run all globals" is deliberately not offered, since
+   * unrelated globals (e.g. a `ThrottlerGuard` that needs a writable response)
+   * would misbehave over MCP. Empty/omitted ⇒ no global guards run.
+   *
+   * Note: over MCP the request stand-in is headers-only (`params`/`query` are
+   * empty), so per-session or IP-derived guard logic won't apply; header-based
+   * authentication still works.
+   */
+  globalGuards?: Type<CanActivate>[];
+  /**
+   * Default MCP result format for every `@Mcp` tool - `'json'` (compact JSON,
+   * `jsonToolResult`) or `'smart'` (inline small / embedded-resource large,
+   * `smartToolResult`). Defaults to `'smart'`. A per-method `@Mcp({ result })`
+   * overrides this, and a client's per-call `_meta.disposition` overrides both.
+   */
+  defaultResult?: 'json' | 'smart';
+}
+declare const SILKWEAVE_MODULE_OPTIONS = "__silkweave_module_options__";
+//#endregion
+export { reflectDtoFields as _, OpenApiDocument as a, openApiFields as c, classValidatorToField as d, designTypeToField as f, openapiSchemaToField as g, normalizeEnum as h, SilkweaveModuleOptions as i, FieldDesc as l, mergeField as m, NestSilkweaveAdapter as n, OpenApiLookup as o, fieldToZod as p, SILKWEAVE_MODULE_OPTIONS as r, buildOpenApiLookup as s, NestAdapterRegisterContext as t, apiPropertyToField as u, swaggerParamToField as v, typeTokenToBase as y };
+//# sourceMappingURL=types-ByWkPWx2.d.mts.map

package/build/types-ByWkPWx2.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-ByWkPWx2.d.mts","names":[],"sources":["../src/lib/reflect/schema.ts","../src/lib/reflect/openapi.ts","../src/lib/types.ts"],"mappings":";;;;;;;;;;;AAeA;;UAAiB,SAAA;EACf,IAAA;EACA,QAAA;EACA,WAAA;EACA,IAAA;EACA,KAAA,GAAQ,SAAA;EACR,GAAA;EACA,GAAA;EACA,SAAA;EACA,SAAA;EACA,MAAA;EACA,OAAA;AAAA;;iBAac,UAAA,CAAW,IAAA,EAAM,SAAA,EAAW,IAAA,EAAM,SAAA,GAAY,SAAA;;iBA2C9C,UAAA,CAAW,CAAA,EAAG,SAAA,GAAY,CAAA,CAAE,OAAA;;iBAc5B,aAAA,CAAc,KAAA;;iBAWd,eAAA,CAAgB,IAAA,YAAgB,SAAA;;iBAkBhC,iBAAA,CAAkB,IAAA,YAAgB,SAAA;;iBAQlC,mBAAA,CAAoB,CAAA,EAAG,MAAA,gBAAsB,SAAA;;iBAgB7C,kBAAA,CAAmB,CAAA,EAAG,MAAA,gBAAsB,SAAA;;iBA4D5C,qBAAA,CAAsB,KAAA,EAAO,KAAA;EAAQ,IAAA;EAAe,IAAA;EAAe,WAAA;AAAA,KAA6B,SAAA;;iBAOhG,oBAAA,CAAqB,MAAA,EAAQ,MAAA,gBAAsB,SAAA;;;;;;;AAxHnE;iBAoJgB,gBAAA,CAAiB,OAAA,QAAe,MAAA,SAAe,SAAA;;;;;;;;UC5O9C,eAAA;EACf,KAAA,GAAQ,MAAA,SAAe,MAAA;EACvB,UAAA;IAAe,OAAA,GAAU,MAAA;EAAA;AAAA;AAAA,UAGV,aAAA;EACf,GAAA,EAAK,eAAA;EDML;ECJA,UAAA,EAAY,GAAA;AAAA;;iBAIE,kBAAA,CAAmB,GAAA,EAAK,eAAA,GAAkB,aAAA;;;;;;ADmB1D;iBCqBgB,aAAA,CAAc,MAAA,EAAQ,aAAA,EAAe,MAAA,UAAgB,WAAA,WAAsB,MAAA,SAAe,SAAA;;;;;AD7C1G;;;;;UEHiB,0BAAA;EFMf;EEJA,WAAA,EAAa,WAAA,CAAY,eAAA;EFMzB;EEJA,gBAAA,EAAkB,gBAAA;EFKlB;EEHA,WAAA,EAAa,gBAAA;EFKb;EEHA,OAAA,EAAS,MAAA;AAAA;;;;AFmBX;;;;UETiB,oBAAA;EFS6C;EAAA,SEPnD,IAAA;EFO4D;EAAA,SEL5D,QAAA;EFKgB;;;;;EAAA,SEChB,UAAA;EF0CK;EExCd,QAAA,CAAS,GAAA,EAAK,0BAAA;AAAA;AAAA,UAGC,sBAAA;EFqCa;EEnC5B,SAAA,EAAW,gBAAA;EFmC6B;EEjCxC,QAAA,EAAU,oBAAA;EFiCuC;EE/BjD,OAAA,GAAU,MAAA;EF6CI;;;;;AAWhB;EEjDE,OAAA,GAAU,eAAA;;;;AFmEZ;;;;;AAQA;;;;EE9DE,YAAA,GAAe,IAAA,CAAK,WAAA;EF8Dc;;;;AAgBpC;;EEvEE,aAAA;AAAA;AAAA,cAGW,wBAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silkweave/nestjs",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Silkweave NestJS Adapter",
   "license": "MIT",
   "homepage": "https://www.silkweave.dev",
@@ -23,18 +23,50 @@
       "@silkweave/source": "./src/index.ts",
       "types": "./build/index.d.mts",
       "default": "./build/index.mjs"
+    },
+    "./mcp": {
+      "@silkweave/source": "./src/mcp.ts",
+      "types": "./build/mcp.d.mts",
+      "default": "./build/mcp.mjs"
+    },
+    "./trpc": {
+      "@silkweave/source": "./src/trpc.ts",
+      "types": "./build/trpc.d.mts",
+      "default": "./build/trpc.mjs"
+    },
+    "./typegen": {
+      "@silkweave/source": "./src/typegen.ts",
+      "types": "./build/typegen.d.mts",
+      "default": "./build/typegen.mjs"
     }
   },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0 || ^11.0.0",
     "@nestjs/core": "^10.0.0 || ^11.0.0",
     "@nestjs/swagger": "^7.0.0 || ^8.0.0 || ^11.0.0",
-    "class-validator": "^0.14.0 || ^0.15.0"
+    "rxjs": "^7.0.0",
+    "@trpc/server": "^11.7.1",
+    "class-validator": "^0.14.0 || ^0.15.0",
+    "@silkweave/mcp": "^2.5.0",
+    "@silkweave/typegen": "^2.5.0",
+    "@silkweave/trpc": "^2.5.0"
   },
   "peerDependenciesMeta": {
     "@nestjs/swagger": {
       "optional": true
     },
+    "@silkweave/mcp": {
+      "optional": true
+    },
+    "@silkweave/trpc": {
+      "optional": true
+    },
+    "@silkweave/typegen": {
+      "optional": true
+    },
+    "@trpc/server": {
+      "optional": true
+    },
     "class-validator": {
       "optional": true
     }
@@ -43,9 +75,7 @@
     "cors": "^2.8.6",
     "express": "^5.2.1",
     "zod": "^3.25.0",
-    "@silkweave/auth": "2.4.0",
-    "@silkweave/core": "2.4.0",
-    "@silkweave/mcp": "2.4.0"
+    "@silkweave/core": "2.5.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
@@ -53,6 +83,7 @@
     "@nestjs/core": "^11.0.0",
     "@nestjs/swagger": "^11.0.0",
     "@stylistic/eslint-plugin": "^5.10.0",
+    "@trpc/server": "^11.7.1",
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.6",
     "@types/node": "^22.0.0",
@@ -63,7 +94,11 @@
     "tsdown": "^0.21.8",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.56.1"
+    "typescript-eslint": "^8.56.1",
+    "@silkweave/auth": "2.5.0",
+    "@silkweave/mcp": "2.5.0",
+    "@silkweave/typegen": "2.5.0",
+    "@silkweave/trpc": "2.5.0"
   },
   "scripts": {
     "clean": "rimraf build",