@silkweave/nestjs 2.4.0 → 2.5.0

package/README.md

@@ -1,16 +1,30 @@
 # @silkweave/nestjs
 
-NestJS adapter for [Silkweave](https://github.com/silkweave/silkweave). Expose your **existing NestJS controllers** as MCP (Model Context Protocol) tools by adding a single `@Mcp()` decorator to a route handler. The tool's name, description, and input schema are **reflected** from the route, the `@Param`/`@Query`/`@Body` decorators, and any `@nestjs/swagger` / `class-validator` metadata the method already carries - nothing is re-declared. On a tool call the validated input is split back into the method's positional arguments and the handler is invoked directly, with `@UseGuards()` guards applied first.
+NestJS adapter for [Silkweave](https://github.com/silkweave/silkweave). Expose your **existing NestJS controllers** as MCP (Model Context Protocol) tools by adding a single `@Mcp()` decorator to a route handler - or as **end-to-end-typed tRPC procedures** with the sibling `@Trpc()` decorator. The name, description, and input schema are **reflected** from the route, the `@Param`/`@Query`/`@Body` decorators, and any `@nestjs/swagger` / `class-validator` metadata the method already carries - nothing is re-declared. On a call the validated input is split back into the method's positional arguments and the handler is invoked directly, with `@UseGuards()` guards applied first.
 
-It is **additive**: controllers keep serving HTTP exactly as before, and removing `@Mcp()` fully reverts a method.
+It is **additive**: controllers keep serving HTTP exactly as before, and removing the decorator fully reverts a method. The same method can carry both `@Mcp()` (for agents) and `@Trpc()` (for your frontend) alongside `@UseGuards()`.
 
 ## Install
 
 ```bash
 pnpm add @silkweave/core @silkweave/nestjs @nestjs/common @nestjs/core @nestjs/platform-express reflect-metadata
+
+# then add only the adapter packages you use (each is an optional peer):
+pnpm add @silkweave/mcp        # if you use mcp()
+pnpm add @silkweave/trpc       # if you use trpc()
+pnpm add @silkweave/typegen    # if you use typegen()
+```
+
+The adapters live behind **subpath exports** and their stacks are **optional peer dependencies**, so an MCP-only app never pulls in `@trpc/server`, and a tRPC-only app never pulls in the MCP SDK / OAuth stack. The decorators and module come from the root; each adapter from its subpath:
+
+```ts
+import { Mcp, Trpc, SilkweaveModule } from '@silkweave/nestjs'
+import { mcp } from '@silkweave/nestjs/mcp'
+import { trpc } from '@silkweave/nestjs/trpc'
+import { typegen } from '@silkweave/nestjs/typegen'
 ```
 
-`@nestjs/swagger` and `class-validator` are **optional** peers - install whichever your DTOs already use; the reflector reads both and falls back to TypeScript `design:type` when neither is present.
+`@nestjs/swagger` and `class-validator` are **optional** peers too - install whichever your DTOs already use; the reflector reads both and falls back to TypeScript `design:type` when neither is present.
 
 > NestJS needs decorator-aware transforms with `emitDecoratorMetadata`. Use `@swc-node/register` (`node --import @swc-node/register/esm-register src/main.ts`) or the `nest start` CLI; plain `tsx` does not emit decorator metadata.
 
@@ -70,7 +84,8 @@ export class UsersController {
 ```ts
 // app.module.ts
 import { Module } from '@nestjs/common'
-import { mcp, SilkweaveModule } from '@silkweave/nestjs'
+import { SilkweaveModule } from '@silkweave/nestjs'
+import { mcp } from '@silkweave/nestjs/mcp'
 import { AdminGuard } from './admin.guard.js'
 import { UsersController } from './users.controller.js'
 
@@ -183,9 +198,127 @@ Mounts the MCP Streamable HTTP transport directly at `basePath`, with sideload (
 | `sideloadResources` | `boolean` | `true` | Mount `{basePath}/resource/:id` |
 | `resourceDir` | `string` | `'resources'` | Directory the sideload route reads from |
 
+## tRPC
+
+`@Trpc()` is the tRPC sibling of `@Mcp()`. It exposes a controller route as a tRPC procedure, reflecting its key, input, and kind from exactly the same sources `@Mcp` uses - so a single method can serve REST, MCP, and tRPC at once. Two things differ because tRPC consumers need them: **precise output types** in the generated router, and **subscriptions** for `async *` routes.
+
+```ts
+import { Mcp, Trpc } from '@silkweave/nestjs'
+import { ApiOkResponse, ApiOperation } from '@nestjs/swagger'
+
+class ListUsersResponse {
+  @ApiProperty({ type: [UserDto] }) users!: UserDto[]
+}
+
+@Controller('users')
+export class UsersController {
+  @Get('list-by-space')
+  @ApiOperation({ summary: 'List the users in a space' })
+  @ApiOkResponse({ type: ListUsersResponse })   // ← drives the generated output type
+  @UseGuards(AuthGuard)                          // ← reads the real Express request (cookies/headers)
+  @Trpc()                                        // → query  `usersListBySpace`
+  @Mcp()                                         // → MCP tool `UsersListBySpace`
+  listBySpace(@Query() q: ListBySpaceQuery, @Req() req: AppRequest) {
+    return this.users.listForSpace(req.user, q.spaceId)
+  }
+}
+```
+
+### `@Trpc(options?)` (method decorator)
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `name` | `string` | `${ControllerBase}.${MethodName}` | Procedure-name override (before camelCasing) |
+| `description` | `string` | `@ApiOperation` summary/description, else generated | Procedure description |
+| `input` | `Record<string, z.ZodType>` | - | Zod raw-shape override merged over reflected fields (same as `@Mcp({ input })`) |
+| `output` | `z.ZodType \| DtoClass \| Record<string, z.ZodType>` | reflected from `@ApiOkResponse` | Explicit output schema driving the generated output type (wins over reflection) |
+| `chunk` | `z.ZodType \| DtoClass` | `unknown` | Element type for a subscription's `async *` stream |
+| `kind` | `'query' \| 'mutation' \| 'subscription'` | inferred | `@Get` ⇒ query, others ⇒ mutation, `async *` ⇒ subscription |
+| `pipes` | `'apply' \| 'skip'` | `'apply'` | Whether to run parameter-bound pipes when re-binding |
+
+### Naming & kind
+
+Procedure keys are `camelCase(`${ControllerBase}.${MethodName}`)` - `UsersController.listBySpace` → `usersListBySpace` - matching the dotted-name → camelCase convention of the core tRPC adapter. Pin any exception with `@Trpc({ name })`. `kind` is inferred from the HTTP verb (`@Get` ⇒ `query`, otherwise `mutation`) or the method body (`async *` ⇒ `subscription`); override with `@Trpc({ kind })`.
+
+### Output types (the precise part)
+
+tRPC carries output types end-to-end, so the generated `AppRouter` needs them. In preference order:
+
+1. **`@ApiOkResponse({ type: Dto })`** (or any 2xx `@ApiResponse`) - the response DTO is flattened like an input DTO into the procedure's output type.
+2. **`@Trpc({ output })`** - an explicit Zod schema, DTO class, or raw shape. Wins over reflection. Use it when the return shape can't be reflected losslessly (e.g. **nested** DTOs and `Dto[]` arrays degrade to `unknown`/`unknown[]` - reflection is one level deep). For a precise nested shape, hand `@Trpc({ output })` a Zod schema.
+
+### Subscriptions (`async *` ⇒ SSE)
+
+An `async *` method is registered as a tRPC **subscription** served over SSE. It needs no HTTP verb - a verb-less `@Trpc({ kind: 'subscription', chunk })` exposes it over tRPC **without** creating a public REST route (see [tRPC/MCP without REST](#trpcmcp-without-a-public-rest-route)). Guards run before the first chunk.
+
+```ts
+@Trpc({ kind: 'subscription', chunk: BoardTick })   // → subscription `usersWatch`
+async *watch(@Query() q: WatchQuery, @Req() req: AppRequest): AsyncGenerator<BoardTick> {
+  for await (const tick of this.board.stream(req.user, q)) { yield tick }
+}
+```
+
+### `trpc(options?)` adapter
+
+Mounts a single tRPC HTTP handler (httpBatch for queries/mutations, SSE for subscriptions) on Nest's HTTP adapter at `basePath`, built from every `@Trpc` route.
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `basePath` | `string` | `'/trpc'` | URL prefix the handler mounts on |
+| `cors` | `CorsOptions \| boolean` | `true` | CORS. For cookie auth pass `{ origin: '<spa-origin>', credentials: true }` |
+| `auth` | `AuthConfig` | - | Optional transport-edge bearer validation. Usually omitted - `@Trpc` routes authenticate via their own `@UseGuards()` |
+
+**Guards + cookie auth, no separate config.** 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 an `AuthGuard` reading an HttpOnly session cookie works with no auth config - the client just sends `credentials: 'include'` / `withCredentials`. A denying guard surfaces to the client as a `TRPCError` whose `data.httpStatus` is the guard's HTTP status (e.g. `401`/`403`), so a `splitLink`/`errorLink` can react.
+
+Reach the authenticated principal + silkweave context from a handler with `@Req() req` (read `req.user`, set by the guard - works identically over REST, tRPC, and MCP).
+
+### `typegen(options?)` adapter
+
+On bootstrap, writes a `.ts` file containing the tRPC `AppRouter` type covering every `@Trpc` procedure - the exact `TRPCBuiltRouter` contract `createTRPCClient<AppRouter>()` and `inferRouterInputs`/`inferRouterOutputs` consume. It only sees `@Trpc` actions (MCP tools are gated out), so the emitted router matches what `trpc()` serves.
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `path` | `string` | - | Output file path (resolved against `process.cwd()`; parent dirs created) |
+| `format` | `'trpc-router' \| 'interfaces' \| 'all'` | `'trpc-router'` | `'trpc-router'` emits `AppRouter`; `'interfaces'` emits `{Name}Input`/`{Name}Output`; `'all'` both |
+
+```ts
+// app.module.ts
+import { SilkweaveModule } from '@silkweave/nestjs'
+import { mcp } from '@silkweave/nestjs/mcp'
+import { trpc } from '@silkweave/nestjs/trpc'
+import { typegen } from '@silkweave/nestjs/typegen'
+
+SilkweaveModule.forRoot({
+  silkweave: { name: 'my-app', description: 'My App', version: '1.0.0' },
+  adapters: [
+    mcp({ basePath: '/mcp', auth: mcpAuth }),         // @Mcp methods → MCP tools (bearer/OAuth)
+    trpc({ basePath: '/trpc' }),                      // @Trpc methods → tRPC procedures (cookie/guard auth)
+    typegen({ path: '../app/src/types/appRouter.ts' })// @Trpc procedures → AppRouter type
+  ]
+})
+```
+
+```ts
+// client - the emitted AppRouter is the only import you need
+import { createTRPCClient, httpBatchLink, httpSubscriptionLink, splitLink } from '@trpc/client'
+import type { AppRouter } from './types/appRouter.js'
+
+export const trpc = createTRPCClient<AppRouter>({
+  links: [splitLink({
+    condition: (op) => op.type === 'subscription',
+    true: httpSubscriptionLink({ url: '/trpc' }),               // SSE, withCredentials for cookies
+    false: httpBatchLink({ url: '/trpc', fetch: (u, o) => fetch(u, { ...o, credentials: 'include' }) })
+  })]
+})
+```
+
+### tRPC/MCP without a public REST route
+
+A `@Get`/`@Post` is inherently a public REST route. To expose a method over **tRPC and/or MCP only**, omit the HTTP-verb decorator: Nest never maps it as REST, and `@Trpc({ kind })` (or `@Mcp()`) still picks it up. This is how subscriptions (which are verb-less `async *` methods) and any internal-only procedure stay off the public REST surface.
+
 ## Guards & DI
 
-Native NestJS `@UseGuards()` on `@Mcp` methods run before the handler is invoked. Guards receive an `ExecutionContext` with the request in `switchToHttp().getRequest()`, and the `Reflector` is wired up so guards can read custom metadata.
+Native NestJS `@UseGuards()` on `@Mcp`/`@Trpc` methods run before the handler is invoked. Guards receive an `ExecutionContext` with the request in `switchToHttp().getRequest()`, and the `Reflector` is wired up so guards can read custom metadata.
 
 **Headers over MCP.** The inbound tool-call request is surfaced as a stand-in `{ headers, url, params, query }` object built from the MCP SDK's `extra.requestInfo`, so a header-based guard - e.g. one reading `getRequest().headers['x-api-key']` - works unchanged. `ExecutionContext.getType()` is `'http'` whenever a request is available (and `'rpc'` for transports with none, e.g. MCP stdio). Caveats:
 
@@ -217,7 +350,7 @@ Because the handler is invoked directly (not through Nest's HTTP request pipelin
 
 ## Notes
 
-- **Opt-in.** Only methods carrying `@Mcp()` are exposed - controllers are never auto-published.
+- **Opt-in.** Only methods carrying `@Mcp()`/`@Trpc()` are exposed - controllers are never auto-published.
 - **Express only by default.** `@nestjs/platform-fastify` requires `@fastify/express` registered upfront.
 - **`reflect-metadata`** must be imported once at the top of your entry file.
 

package/build/index-C1W-O7EX.d.mts

@@ -0,0 +1,46 @@
+import { SilkweaveContext } from "@silkweave/core";
+
+//#region ../auth/build/index.d.mts
+//#endregion
+//#region src/provider/types.d.ts
+interface AuthInfo {
+  token: string;
+  clientId?: string;
+  scopes?: string[];
+  expiresAt?: number;
+  [key: string]: unknown;
+}
+interface OAuthRequest {
+  method: string;
+  url: URL;
+  headers: Record<string, string | undefined>;
+  body?: Record<string, string>;
+}
+interface OAuthResponse {
+  status: number;
+  headers: Record<string, string>;
+  body?: string | Record<string, unknown>;
+}
+interface OAuthProvider {
+  authorize(req: OAuthRequest): Promise<OAuthResponse>;
+  callback(req: OAuthRequest): Promise<OAuthResponse>;
+  token(req: OAuthRequest): Promise<OAuthResponse>;
+  register(req: OAuthRequest): Promise<OAuthResponse>;
+  metadata(): OAuthResponse;
+  verifyToken(token: string): Promise<AuthInfo | undefined>;
+} //#endregion
+//#region src/types.d.ts
+type VerifyToken = (token: string, context: SilkweaveContext) => Promise<AuthInfo | undefined>;
+interface AuthConfig {
+  verifyToken: VerifyToken;
+  required?: boolean;
+  resourceUrl?: string;
+  authorizationServers?: string[];
+  requiredScopes?: string[];
+  provider?: OAuthProvider;
+  callbackPath?: string;
+} //#endregion
+//#region src/provider/store.d.ts
+//#endregion
+export { AuthConfig as t };
+//# sourceMappingURL=index-C1W-O7EX.d.mts.map

package/build/index-C1W-O7EX.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-C1W-O7EX.d.mts","names":["SilkweaveContext","AuthError","Error","code","statusCode","constructor","message","invalidToken","insufficientScope","extractBearerToken","header","buildWWWAuthenticate","error","description","resourceMetadataUrl","ProtectedResourceMetadata","resource","authorization_servers","scopes_supported","bearer_methods_supported","generateProtectedResourceMetadata","resourceUrl","authorizationServers","AuthInfo","token","clientId","scopes","expiresAt","key","OAuthRequest","URL","Record","method","url","headers","body","OAuthResponse","status","OAuthProvider","Promise","authorize","req","callback","register","metadata","verifyToken","VerifyToken","context","AuthConfig","required","requiredScopes","provider","callbackPath","AuthCodeData","redirectUri","codeChallenge","codeChallengeMethod","upstreamAccessToken","upstreamIdToken","email","sub","PendingAuthData","scope","clientState","ClientRegistration","clientSecret","redirectUris","clientName","createdAt","RefreshTokenData","OAuthStore","saveAuthCode","data","getAuthCode","deleteAuthCode","savePendingAuth","state","getPendingAuth","deletePendingAuth","savePkceVerifier","verifier","getPkceVerifier","deletePkceVerifier","saveClient","getClient","saveRefreshToken","getRefreshToken","deleteRefreshToken","GoogleOAuthOptions","signingKey","tokenTtl","store","google","options","OAuthProxyConfig","authorizeUrl","tokenUrl","userinfoUrl","createOAuthProxy","config","matchRedirectUri","uri","patterns","createJsonStore","path","createMemoryStore","RedisClient","get","set","value","ex","del","RedisStoreOptions","client","prefix","createRedisStore","ValidateResult","auth","error_description","validateToken","authorizationHeader"],"sources":["../../auth/build/index.d.mts"],"mappings":";;;;;UAyBUuB,QAAAA;EACRC,KAAAA;EACAC,QAAAA;EACAC,MAAAA;EACAC,SAAAA;EAAAA,CACCC,GAAAA;AAAAA;AAAAA,UAEOC,YAAAA;EACRG,MAAAA;EACAC,GAAAA,EAAKH,GAAAA;EACLI,OAAAA,EAASH,MAAAA;EACTI,IAAAA,GAAOJ,MAAAA;AAAAA;AAAAA,UAECK,aAAAA;EACRC,MAAAA;EACAH,OAAAA,EAASH,MAAAA;EACTI,IAAAA,YAAgBJ,MAAAA;AAAAA;AAAAA,UAERO,aAAAA;EACRE,SAAAA,CAAUC,GAAAA,EAAKZ,YAAAA,GAAeU,OAAAA,CAAQH,aAAAA;EACtCM,QAAAA,CAASD,GAAAA,EAAKZ,YAAAA,GAAeU,OAAAA,CAAQH,aAAAA;EACrCZ,KAAAA,CAAMiB,GAAAA,EAAKZ,YAAAA,GAAeU,OAAAA,CAAQH,aAAAA;EAClCO,QAAAA,CAASF,GAAAA,EAAKZ,YAAAA,GAAeU,OAAAA,CAAQH,aAAAA;EACrCQ,QAAAA,IAAYR,aAAAA;EACZS,WAAAA,CAAYrB,KAAAA,WAAgBe,OAAAA,CAAQhB,QAAAA;AAAAA;AAAAA;AAAAA,KAIjCuB,WAAAA,IAAetB,KAAAA,UAAeuB,OAAAA,EAAS/C,gBAAAA,KAAqBuC,OAAAA,CAAQhB,QAAAA;AAAAA,UAC/DyB,UAAAA;EACRH,WAAAA,EAAaC,WAAAA;EACbG,QAAAA;EACA5B,WAAAA;EACAC,oBAAAA;EACA4B,cAAAA;EACAC,QAAAA,GAAWb,aAAAA;EACXc,YAAAA;AAAAA;AAAAA"}

package/build/index.d.mts

@@ -1,197 +1,14 @@
+import { _ as reflectDtoFields, a as OpenApiDocument, c as openApiFields, d as classValidatorToField, f as designTypeToField, g as openapiSchemaToField, h as normalizeEnum, i as SilkweaveModuleOptions, l as FieldDesc, m as mergeField, n as NestSilkweaveAdapter, o as OpenApiLookup, p as fieldToZod, r as SILKWEAVE_MODULE_OPTIONS, s as buildOpenApiLookup, t as NestAdapterRegisterContext, u as apiPropertyToField, v as swaggerParamToField, y as typeTokenToBase } from "./types-ByWkPWx2.mjs";
 import { CanActivate, DynamicModule, MiddlewareConsumer, NestModule, Type } from "@nestjs/common";
 import { ApplicationConfig, DiscoveryService, HttpAdapterHost, MetadataScanner, ModuleRef, Reflector } from "@nestjs/core";
-import { Action, SilkweaveContext, SilkweaveOptions } from "@silkweave/core";
+import { Action } from "@silkweave/core";
 import { z } from "zod/v4";
-import { AuthConfig } from "@silkweave/auth";
-import { CorsOptions } from "cors";
 
-//#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';
-  /** 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. Currently `mcp()`. */
-  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
-//#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
 //#region src/lib/metadata.d.ts
 /** Reflect-metadata key carrying `@Mcp` options on a controller method. */
 declare const MCP_METADATA = "__silkweave_mcp__";
+/** Reflect-metadata key carrying `@Trpc` options on a controller method. */
+declare const TRPC_METADATA = "__silkweave_trpc__";
 /**
  * Options for the `@Mcp()` method decorator. Every field is optional - an empty
  * `@Mcp()` exposes the decorated controller route as an MCP tool with its name,
@@ -233,6 +50,63 @@ interface McpMetadata {
    */
   result?: 'json' | 'smart';
 }
+/** tRPC procedure kind for a `@Trpc`-decorated route. */
+type TrpcKind = 'query' | 'mutation' | 'subscription';
+/**
+ * Options for the `@Trpc()` method decorator - the tRPC sibling of `@Mcp`. An
+ * empty `@Trpc()` exposes the decorated controller route as a tRPC procedure
+ * with its key, input schema, and kind reflected from the route + parameter
+ * decorators + swagger/class-validator metadata (identically to `@Mcp`).
+ *
+ * Unlike MCP, tRPC carries precise *output* types into the generated router, so
+ * `@Trpc` adds an `output`/`chunk` hatch and a `kind` override on top of the
+ * shared reflection. The two decorators compose on the same method.
+ */
+interface TrpcMetadata {
+  /**
+   * Procedure-name override (before camelCasing). When unset it is derived from
+   * the controller class + method name (e.g. `UsersController.listBySpace` →
+   * `Users.listBySpace`, camelCased by the router to `usersListBySpace`).
+   */
+  name?: string;
+  /**
+   * Procedure description override. When unset it falls back to the method's
+   * `@ApiOperation({ summary | description })`, then a generated default.
+   */
+  description?: string;
+  /**
+   * Zod raw-shape override merged over the reflected input fields (override wins
+   * per field). Same escape hatch as `@Mcp({ input })`.
+   */
+  input?: Record<string, z.ZodType>;
+  /**
+   * Explicit output schema driving the generated procedure's output type - a Zod
+   * type, a DTO class (reflected like `@ApiOkResponse`), or a raw shape (wrapped
+   * in `z.object`). Wins over `@ApiOkResponse` reflection. The biggest reason to
+   * set this is when the return shape can't be reflected losslessly from a DTO.
+   */
+  output?: z.ZodType | Type | Record<string, z.ZodType>;
+  /**
+   * Chunk schema for an async-generator route exposed as a tRPC **subscription**.
+   * A Zod type or a DTO class. Drives the emitted
+   * `TRPCSubscriptionProcedure<{ output }>` type. When unset the chunk type falls
+   * back to `unknown`.
+   */
+  chunk?: z.ZodType | Type;
+  /**
+   * Procedure kind. When unset it is inferred: an `async *` route ⇒
+   * `'subscription'`, a `@Get` route ⇒ `'query'`, anything else ⇒ `'mutation'`.
+   * Set this to expose a verb-less route (no `@Get`/`@Post`) as a query or
+   * subscription - `@Trpc({ kind })` works without an HTTP-verb decorator, so the
+   * route is served over tRPC (and/or MCP) without becoming a public REST route.
+   */
+  kind?: TrpcKind;
+  /**
+   * Whether to apply the method's parameter-bound pipes when re-binding the call.
+   * Default `'apply'`. Same semantics as `@Mcp({ pipes })`.
+   */
+  pipes?: 'apply' | 'skip';
+}
 //#endregion
 //#region src/decorator/mcp.d.ts
 /**
@@ -270,7 +144,48 @@ interface McpMetadata {
  */
 declare function Mcp(options?: McpMetadata): MethodDecorator;
 //#endregion
+//#region src/decorator/trpc.d.ts
+/**
+ * Method decorator that exposes a NestJS controller route as a **tRPC
+ * procedure** - the sibling of `@Mcp`. Like `@Mcp` it is additive and reflects
+ * the procedure's input from the method's own metadata (route + `@Param`/
+ * `@Query`/`@Body` + swagger/class-validator), so a single method can carry both
+ * `@Trpc()` and `@Mcp()` and `@UseGuards()`.
+ *
+ * Two things differ from MCP because tRPC consumers need them:
+ * - **kind** - inferred from the route (`@Get` ⇒ query, others ⇒ mutation) or an
+ *   `async *` body (⇒ subscription); override with `@Trpc({ kind })`.
+ * - **output** - the generated `AppRouter` carries precise output types. Drive
+ *   them with `@ApiOkResponse({ type: Dto })` reflection or `@Trpc({ output })`.
+ *
+ * `@Trpc()` works **without** an HTTP-verb decorator: with no `@Get`/`@Post` the
+ * route is never mapped as REST, so `@Trpc({ kind })` exposes it over tRPC (and
+ * `@Mcp` over MCP) while keeping it off the public REST surface.
+ *
+ * @example
+ * ```ts
+ * @Controller('users')
+ * export class UsersController {
+ *   @Get('list-by-space')
+ *   @ApiOperation({ summary: 'List users in a space' })
+ *   @ApiOkResponse({ type: ListUsersResponse })   // drives the output type
+ *   @UseGuards(AuthGuard)
+ *   @Trpc()                                        // → procedure `usersListBySpace` (query)
+ *   @Mcp()                                         // → MCP tool `UsersListBySpace`
+ *   listBySpace(@Query() q: ListBySpaceQuery, @Req() req: AppRequest) {
+ *     return this.service.list(req.user, q.spaceId)
+ *   }
+ * }
+ * ```
+ */
+declare function Trpc(options?: TrpcMetadata): MethodDecorator;
+//#endregion
 //#region src/lib/controllerDiscovery.d.ts
+interface DiscoverOptions {
+  openapi?: OpenApiDocument;
+  globalGuards?: Type<CanActivate>[];
+  defaultResult?: 'json' | 'smart';
+}
 declare class ControllerDiscovery {
   private readonly discovery;
   private readonly scanner;
@@ -279,17 +194,24 @@ declare class ControllerDiscovery {
   private readonly appConfig;
   constructor(discovery: DiscoveryService, scanner: MetadataScanner, reflector: Reflector, moduleRef: ModuleRef, appConfig: ApplicationConfig);
   /**
-   * Walk every Nest provider/controller, find methods annotated with `@Mcp`,
-   * and build a core `Action` per method whose input schema is reflected from
-   * the route + parameter decorators (+ optional OpenAPI document) and whose
-   * `run` re-binds the validated input back into the method's positional
-   * arguments (with `@UseGuards` guards - and any opted-in `globalGuards` -
-   * applied first).
+   * Walk every Nest provider/controller, find methods annotated with `@Mcp`
+   * and/or `@Trpc`, and build a core `Action` per decorator present on each
+   * method. The input schema is reflected from the route + parameter decorators
+   * (+ optional OpenAPI document) and the `run` re-binds the validated input back
+   * into the method's positional arguments (with `@UseGuards` guards applied
+   * first). A method carrying both decorators yields two actions - one gated to
+   * the `mcp` adapter, one to the `trpc`/`typegen` adapters - sharing the same
+   * reflected input, bindings, and guards.
    */
-  discover(openapi?: OpenApiDocument, globalGuards?: Type<CanActivate>[], defaultResult?: 'json' | 'smart'): Action[];
-  private toAction;
-  /** Build the merged Zod input shape and the per-argument re-bind plan. */
-  private buildInput;
+  discover(options?: DiscoverOptions): Action[];
+  /** Compute the per-method reflection shared by the `mcp` and `trpc` builders. */
+  private reflect;
+  /** Build a guard-application closure shared by both run shapes. */
+  private guardRunner;
+  /** Synthesize the MCP-targeted action (unchanged behavior from v2.4). */
+  private mcpAction;
+  /** Synthesize the tRPC-targeted action (kind/output/subscription + httpStatus errors). */
+  private trpcAction;
 }
 //#endregion
 //#region src/lib/guards.d.ts
@@ -385,11 +307,12 @@ declare function specialBinding(paramtype: number, data: string | undefined): Bi
 /**
  * Root module for `@silkweave/nestjs`.
  *
- * Discovers every `@Mcp`-decorated **controller method** via `DiscoveryService`,
- * reflects each into a Silkweave action (input schema from the route + parameter
- * decorators + optional OpenAPI document; invocation by re-binding the validated
- * input back into the method), and registers the configured adapter(s) - `mcp()` -
- * directly on Nest's HTTP adapter inside `configure()`.
+ * Discovers every `@Mcp`/`@Trpc`-decorated **controller method** via
+ * `DiscoveryService`, reflects each into a Silkweave action (input schema from
+ * the route + parameter decorators + optional OpenAPI document; invocation by
+ * re-binding the validated input back into the method), and registers the
+ * configured adapter(s) - `mcp()`, `trpc()`, `typegen()` - directly on Nest's
+ * HTTP adapter inside `configure()`.
  *
  * Because `configure()` runs during `registerModules` - before Nest's
  * `registerRouter()` step - Silkweave's routes always sit ahead of every
@@ -419,5 +342,5 @@ declare class SilkweaveModule implements NestModule {
   configure(_consumer: MiddlewareConsumer): void;
 }
 //#endregion
-export { Binding, ControllerDiscovery, FieldDesc, MCP_METADATA, Mcp, McpAdapterOptions, McpMetadata, NestAdapterRegisterContext, NestSilkweaveAdapter, OpenApiDocument, OpenApiLookup, SILKWEAVE_MODULE_OPTIONS, SilkweaveModule, SilkweaveModuleOptions, apiPropertyToField, buildOpenApiLookup, classValidatorToField, collectGlobalGuards, collectGuards, designTypeToField, fieldToZod, invokeRebound, mcp, mergeField, normalizeEnum, openApiFields, openapiSchemaToField, reflectDtoFields, runGuards, specialBinding, swaggerParamToField, typeTokenToBase };
+export { Binding, ControllerDiscovery, DiscoverOptions, FieldDesc, MCP_METADATA, Mcp, McpMetadata, NestAdapterRegisterContext, NestSilkweaveAdapter, OpenApiDocument, OpenApiLookup, SILKWEAVE_MODULE_OPTIONS, SilkweaveModule, SilkweaveModuleOptions, TRPC_METADATA, Trpc, TrpcKind, TrpcMetadata, apiPropertyToField, buildOpenApiLookup, classValidatorToField, collectGlobalGuards, collectGuards, designTypeToField, fieldToZod, invokeRebound, mergeField, normalizeEnum, openApiFields, openapiSchemaToField, reflectDtoFields, runGuards, specialBinding, swaggerParamToField, typeTokenToBase };
 //# sourceMappingURL=index.d.mts.map

package/build/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/lib/reflect/schema.ts","../src/lib/reflect/openapi.ts","../src/lib/types.ts","../src/adapter/mcp.ts","../src/lib/metadata.ts","../src/decorator/mcp.ts","../src/lib/controllerDiscovery.ts","../src/lib/guards.ts","../src/lib/rebind.ts","../src/lib/silkweave.module.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/lib/metadata.ts","../src/decorator/mcp.ts","../src/decorator/trpc.ts","../src/lib/controllerDiscovery.ts","../src/lib/guards.ts","../src/lib/rebind.ts","../src/lib/silkweave.module.ts"],"mappings":"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"}