@silkweave/nestjs 1.12.0 → 2.2.0

package/build/index.d.mts

@@ -1,13 +1,89 @@
-import { CanActivate, DynamicModule, INestApplication, MiddlewareConsumer, NestModule, Type } from "@nestjs/common";
+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 { z } from "zod/v4";
 import { AuthConfig } from "@silkweave/auth";
-import { Action as Action$1, ActionKind, HttpMethod, SilkweaveContext, SilkweaveOptions } from "@silkweave/core";
-import z$1 from "zod/v4";
-import { InferTrpcRouter } from "@silkweave/trpc";
-import { TypegenFormat } from "@silkweave/typegen";
-import { DiscoveryService, HttpAdapterHost, MetadataScanner, ModuleRef, Reflector } from "@nestjs/core";
 import { CorsOptions } from "cors";
-import { OpenAPIObject } from "@nestjs/swagger";
 
+//#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
@@ -24,7 +100,7 @@ interface NestAdapterRegisterContext {
   /** Per-adapter context - already forked with `{ adapter: adapter.name, ...userContext }`. */
   baseContext: SilkweaveContext;
   /** Actions filtered to those enabled on this adapter. */
-  actions: Action$1[];
+  actions: Action[];
 }
 /**
  * A Silkweave Nest adapter. Each transport (REST, tRPC, MCP) implements this
@@ -35,18 +111,13 @@ interface NestAdapterRegisterContext {
  */
 interface NestSilkweaveAdapter {
   /** Adapter discriminator - set on the silkweave context as `ctx.get('adapter')`. */
-  readonly name: 'rest' | 'trpc' | 'mcp' | 'typegen';
-  /**
-   * URL prefix the adapter mounts on (e.g. `'/api'`). Surfaced for introspection
-   * tooling such as `addSilkweaveActions()` (OpenAPI/Swagger), which reads it to
-   * keep generated docs aligned with the live routes.
-   */
+  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 `transports` allowlist / `isEnabled` gate. Used by
-   * non-runtime adapters like `typegen()` that emit types for the entire
-   * action surface.
+   * 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. */
@@ -55,10 +126,30 @@ interface NestSilkweaveAdapter {
 interface SilkweaveModuleOptions {
   /** Identity for the silkweave instance - surfaced to MCP clients, OpenAPI, etc. */
   silkweave: SilkweaveOptions;
-  /** Adapters to mount. Examples: `rest()`, `trpc()`, `mcp()`. */
+  /** 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>[];
 }
 declare const SILKWEAVE_MODULE_OPTIONS = "__silkweave_module_options__";
 //#endregion
@@ -91,221 +182,120 @@ interface McpAdapterOptions {
  */
 declare function mcp(options?: McpAdapterOptions): NestSilkweaveAdapter;
 //#endregion
-//#region src/adapter/rest.d.ts
-interface RestAdapterOptions {
-  /** URL prefix joined to each action's path. e.g. `'/api'` → `POST /api/users/list`. Default: `'/api'`. */
-  basePath?: string;
-  /** Optional bearer-token auth applied to every REST action. */
-  auth?: AuthConfig;
-}
-/**
- * REST adapter for `@silkweave/nestjs`. Registers each discovered `@Action`
- * as an individual route on Nest's HTTP adapter:
- *
- * - HTTP verb comes from `method`, else `GET` for `kind: 'query'`, else `POST`.
- * - Path comes from `path` (joined to `basePath`, may contain `:param`
- *   placeholders), else `${basePath}/${actionName-with-slashes}`.
- * - Input is merged from the request body, the `queryParams` query-string
- *   fields, and any `:param` path placeholders (see `resolveActionInput`).
- *
- * Routes show up in Nest's `RoutesResolver` logger. They are registered
- * directly on the HTTP adapter (not as Nest controllers), so `@nestjs/swagger`'s
- * controller scanner does not see them - use `addSilkweaveActions()` to add them
- * to the OpenAPI document. Works on `@nestjs/platform-express` out of the box.
- * For `@nestjs/platform-fastify`, register `@fastify/express` first.
- */
-declare function rest(options?: RestAdapterOptions): NestSilkweaveAdapter;
-//#endregion
-//#region src/adapter/trpc.d.ts
-interface TrpcAdapterOptions {
-  /** URL prefix at which the tRPC handler is mounted. Default `'/trpc'`. */
-  basePath?: string;
-  /** Optional bearer-token auth applied to every tRPC procedure. */
-  auth?: AuthConfig;
-}
+//#region src/lib/metadata.d.ts
+/** Reflect-metadata key carrying `@Mcp` options on a controller method. */
+declare const MCP_METADATA = "__silkweave_mcp__";
 /**
- * tRPC adapter for `@silkweave/nestjs`. Builds a tRPC router from discovered
- * `@Action` methods and mounts the resulting express middleware at
- * `basePath` on Nest's HTTP adapter.
- *
- * Action names with dots (e.g. `users.list` from `@Actions('users')`) collapse
- * to camelCase procedure keys (`usersList`).
- *
- * Works on `@nestjs/platform-express`. On `@nestjs/platform-fastify`, register
- * `@fastify/express` first so Nest can serve Express-style middleware.
+ * 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,
+ * description, and input schema fully reflected from the method's route
+ * (`@Get`/`@Post`/...), parameter decorators (`@Param`/`@Query`/`@Body`), and
+ * any `@nestjs/swagger` (`@ApiOperation`/`@ApiParam`/`@ApiProperty`) or
+ * `class-validator` metadata it carries.
  */
-declare function trpc(options?: TrpcAdapterOptions): NestSilkweaveAdapter;
-//#endregion
-//#region src/adapter/typegen.d.ts
-interface TypegenAdapterOptions {
-  /** Output file path for the generated `.d.ts` file. Resolved against `process.cwd()`. Parent directories are created automatically. */
-  path: string;
+interface McpMetadata {
   /**
-   * What to emit (default `'all'`):
-   * - `'interfaces'` - `{Name}Input` / `{Name}Output` interfaces per action
-   * - `'trpc-router'` - `AppRouter` type alias for `createTRPCClient<AppRouter>()`
-   * - `'all'` - both
+   * MCP tool name override. When unset it is derived from the controller class
+   * and method name (e.g. `ChannelsController.findOne` → `ChannelsFindOne`).
    */
-  format?: TypegenFormat;
+  name?: string;
   /**
-   * Whether to write the file at all. Default: `process.env.NODE_ENV !== 'production'`.
-   * Server processes generally shouldn't write to disk in production deploys -
-   * leave it on the default unless you know you want otherwise.
+   * Tool description override. When unset it falls back to the method's
+   * `@ApiOperation({ summary | description })`, then a generated default.
    */
-  enabled?: boolean;
-}
-/**
- * Typegen adapter for `@silkweave/nestjs`. Discovers every `@Action`-decorated
- * method (regardless of `transports` filtering) and writes a single `.d.ts`
- * file with REST input/output interfaces and/or a tRPC `AppRouter` type alias.
- *
- * Designed for the monorepo pattern where the server (this app) is the source
- * of truth for types and consumer apps import from `path` - e.g.
- * `path: '../app/src/types/silkweave.ts'`.
- */
-declare function typegen(options: TypegenAdapterOptions): NestSilkweaveAdapter;
-//#endregion
-//#region src/lib/metadata.d.ts
-declare const ACTION_METADATA = "__silkweave_action__";
-declare const ACTIONS_METADATA = "__silkweave_actions__";
-type Transport = 'rest' | 'trpc' | 'mcp';
-interface ActionMetadata<I extends object = object, O extends object = object, C = unknown> {
-  /** Action name. Defaults to the kebab-cased method name. */
-  name?: string;
-  /** Human-readable description. Becomes the MCP tool description and REST OpenAPI summary. */
-  description: string;
-  /** Zod object schema for the action's input. */
-  input: z$1.ZodType<I> & {
-    shape: Record<string, z$1.ZodTypeAny>;
-  };
-  /** Optional Zod object schema for the action's output (used by tRPC type inference). */
-  output?: z$1.ZodType<O> & {
-    shape: Record<string, z$1.ZodTypeAny>;
-  };
+  description?: string;
   /**
-   * Zod schema for individual chunks yielded by a streaming (async-generator)
-   * action method. Required when the decorated method is an `async function*`.
-   * Mirrors `Action.chunk` in @silkweave/core; typegen/trpc use it to expose
-   * the action as a tRPC subscription.
+   * Zod raw-shape override merged over the reflected input fields (override
+   * wins per field). The escape hatch for shapes reflection can't express
+   * losslessly - discriminated unions, custom validators, `@Transform`, etc.
    */
-  chunk?: z$1.ZodType<C>;
-  /** `'query'` (GET in REST, `.query()` in tRPC) or `'mutation'` (POST in REST, `.mutation()` in tRPC). Default: `'mutation'`. */
-  kind?: ActionKind;
-  /** HTTP verb for the REST route. Defaults to `POST` (or `GET` when `kind` is `'query'`). Overrides the `kind`-derived default. */
-  method?: HttpMethod;
-  /** REST route path, optionally with `:param` placeholders (e.g. `'spaces/:spaceId/users'`). Each placeholder must be a key of `input`. Defaults to the action name with dots as slashes. */
-  path?: string;
-  /** Input fields read from the URL query string instead of the request body (e.g. `['offset', 'limit']`). Each must be a key of `input`. */
-  queryParams?: (keyof I)[];
-  /** Allowlist of transports that should expose this action. Default: all registered transports. */
-  transports?: Transport[];
-  /** Dynamic enable check (in addition to `transports`). AND-combined with the transports filter. */
-  isEnabled?: (context: SilkweaveContext) => boolean;
-  /** Custom MCP `CallToolResult` formatter. See `@silkweave/mcp`'s `smartToolResult`. */
-  toolResult?: Action$1<I, O>['toolResult'];
-  /** CLI positional-argument keys (unused for HTTP-only adapters, kept for parity with `createAction`). */
-  args?: (keyof I)[];
-  /** Custom MCP tool name override. If unset, derived from action name as PascalCase. */
-  mcpToolName?: string;
-}
-interface ActionsClassMetadata {
-  /** Prefix joined to the method-level action name with a dot. e.g. `Actions('users')` + method `list` → `users.list`. */
-  prefix?: string;
-  /** Class-level transports allowlist. Method-level `transports` overrides; otherwise inherits this. */
-  transports?: Transport[];
-}
-interface ResultToolResult<O extends object = object> {
-  toolResult?: Action$1<object, O>['toolResult'];
+  input?: Record<string, z.ZodType>;
+  /**
+   * Whether to apply the controller method's parameter-bound pipes
+   * (`@Param('id', ParseIntPipe)`) when re-binding the call. Default `'apply'`.
+   * Global/`ValidationPipe`, interceptors, and exception filters never run -
+   * the method is invoked directly, not through Nest's HTTP request pipeline.
+   */
+  pipes?: 'apply' | 'skip';
 }
-type AnyActionMetadata = ActionMetadata<object, object> & ResultToolResult<object>;
-declare const ACTION_RESPONSE_KEY = "__silkweave_response__";
 //#endregion
-//#region src/decorator/action.d.ts
+//#region src/decorator/mcp.d.ts
 /**
- * Method decorator that registers a Silkweave action.
+ * Method decorator that exposes an existing NestJS controller route as an MCP
+ * tool. It is **additive** - the route keeps serving HTTP exactly as before;
+ * `@Mcp()` just opts the method into MCP discovery.
  *
- * The decorated method becomes an Action and is exposed via every adapter
- * configured on `SilkweaveModule` (REST/tRPC/MCP), unless `transports` is
- * provided to restrict it.
+ * The tool's name, description, and input schema are reflected from the
+ * method's own metadata:
+ * - **fields** from the parameter decorators (`@Param`/`@Query`/`@Body`) - a
+ *   `@Param('id')` becomes an `id` field; a whole-DTO `@Body() dto: CreateDto`
+ *   is flattened to its properties,
+ * - **types/constraints/descriptions** from `@nestjs/swagger`
+ *   (`@ApiParam`/`@ApiQuery`/`@ApiProperty`/`@ApiOperation`) and, when present,
+ *   `class-validator` decorators on the DTOs,
+ * - optionally refined by an OpenAPI document passed to `SilkweaveModule`.
  *
- * The method receives `(input, context)` where `input` is the parsed Zod input
- * and `context` is the `SilkweaveContext` (with `logger`, `request`, optional
- * `auth`). The class instance is a normal Nest provider, so other services can
- * be injected via the constructor.
+ * On a tool call the input is split back into the method's positional arguments
+ * and the method is invoked directly (with `@UseGuards` guards applied first).
  *
  * @example
  * ```ts
- * @Injectable()
- * @Actions('users')
- * export class UserActions {
- *   constructor(private db: DbService) {}
- *
- *   @Action({
- *     description: 'List users',
- *     input: z.object({ limit: z.number().optional() }),
- *     kind: 'query'
- *   })
- *   list(input: { limit?: number }, ctx: SilkweaveContext) {
- *     return this.db.listUsers(input.limit)
+ * @Controller('sessions/:sessionId/channels')
+ * export class ChannelsController {
+ *   @Get(':channelId')
+ *   @ApiOperation({ summary: 'Get a specific channel by ID' })
+ *   @ApiParam({ name: 'sessionId', description: 'Session ID' })
+ *   @ApiParam({ name: 'channelId', description: 'Channel ID' })
+ *   @Mcp()
+ *   findOne(@Param('sessionId') sessionId: string, @Param('channelId') channelId: string) {
+ *     return this.service.get(sessionId, channelId)
  *   }
  * }
  * ```
  */
-declare function Action<I extends object = object, O extends object = object, C = unknown>(options: ActionMetadata<I, O, C>): MethodDecorator;
-//#endregion
-//#region src/decorator/actions.d.ts
-/**
- * Class decorator that groups a provider's `@Action` methods under a common
- * prefix. The prefix is joined to each method's action name with a dot
- * (e.g. `@Actions('users')` + method `list` → action name `users.list`).
- *
- * The class itself remains a normal Nest provider - add `@Injectable()`
- * separately so it can be resolved by the DI container.
- *
- * Accepts either a prefix string (shorthand) or a full options object:
- * ```ts
- * @Actions('users')
- * @Actions({ prefix: 'users', transports: ['rest', 'trpc'] })
- * ```
- */
-declare function Actions(prefixOrOptions?: string | ActionsClassMetadata): ClassDecorator;
+declare function Mcp(options?: McpMetadata): MethodDecorator;
 //#endregion
-//#region src/lib/discovery.d.ts
-declare class ActionDiscovery {
+//#region src/lib/controllerDiscovery.d.ts
+declare class ControllerDiscovery {
   private readonly discovery;
   private readonly scanner;
   private readonly reflector;
   private readonly moduleRef;
-  constructor(discovery: DiscoveryService, scanner: MetadataScanner, reflector: Reflector, moduleRef: ModuleRef);
+  private readonly appConfig;
+  constructor(discovery: DiscoveryService, scanner: MetadataScanner, reflector: Reflector, moduleRef: ModuleRef, appConfig: ApplicationConfig);
   /**
-   * Walk every Nest provider, find methods annotated with `@Action`, and build
-   * a list of core `Action` objects ready to feed into `silkweave().actions()`.
-   *
-   * Action invocation is wrapped to (a) run `@UseGuards` guards declared on the
-   * method or its class against the incoming request (read from
-   * `ctx.get('request')`, populated by REST/tRPC and by MCP-over-HTTP from the
-   * SDK's `extra.requestInfo`) and (b) bind `this` to the resolved Nest provider
-   * so DI-injected dependencies remain available.
+   * 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).
    */
-  discover(): Action$1[];
+  discover(openapi?: OpenApiDocument, globalGuards?: Type<CanActivate>[]): Action[];
   private toAction;
+  /** Build the merged Zod input shape and the per-argument re-bind plan. */
+  private buildInput;
 }
 //#endregion
-//#region src/lib/filter.d.ts
+//#region src/lib/guards.d.ts
+type GuardRef = Type<CanActivate> | CanActivate;
 /**
- * Compile a `transports` allowlist + optional user `isEnabled` into a single
- * `(ctx) => boolean` callback compatible with `Action.isEnabled`.
+ * Collect the app's global guards that match an opt-in allow-list of classes.
+ *
+ * Reads both registration styles Nest exposes via `ApplicationConfig`:
+ * `useGlobalGuards(new X())` instances (`getGlobalGuards()`) and
+ * `{ provide: APP_GUARD, useClass }` DI guards (`getGlobalRequestGuards()`,
+ * which yields `InstanceWrapper`s - we read `.instance` off each).
  *
- * - If `transports` is omitted, the action runs on every adapter.
- * - If `transports` is set, the action is gated on `ctx.get<string>('adapter')`
- *   matching one of the listed transports. Each adapter in `@silkweave/nestjs`
- *   forks its context with `{ adapter: 'rest' | 'trpc' | 'mcp' }`.
- * - If both `transports` and `userIsEnabled` are set, they are AND-combined.
+ * The allow-list is intentionally explicit-by-class: a blanket "run every
+ * global" would also fire unrelated globals (e.g. a `ThrottlerGuard` that
+ * assumes a writable response) on every tool call. An empty allow-list runs
+ * no globals, preserving the prior behavior.
+ *
+ * Call this at tool-call time, not at discovery time: `APP_GUARD` instances
+ * aren't populated until `app.init()` finishes.
  */
-declare function buildIsEnabled(transports: Transport[] | undefined, userIsEnabled: ((ctx: SilkweaveContext) => boolean) | undefined): ((ctx: SilkweaveContext) => boolean) | undefined;
-//#endregion
-//#region src/lib/guards.d.ts
-type GuardRef = Type<CanActivate> | CanActivate;
+declare function collectGlobalGuards(appConfig: ApplicationConfig, allowList: Type<CanActivate>[]): CanActivate[];
 /**
  * Read `@UseGuards(...)` metadata for both the method and its class and merge
  * the two lists. Method-level guards run AFTER class-level guards (matching
@@ -327,33 +317,69 @@ declare function collectGuards(reflector: Reflector, classRef: Type<unknown>, ha
  */
 declare function runGuards(guards: GuardRef[], moduleRef: ModuleRef, reflector: Reflector, classRef: Type<unknown>, handler: (...args: unknown[]) => unknown, request: unknown, response: unknown, contextType?: 'http' | 'rpc'): Promise<void>;
 //#endregion
-//#region src/lib/openapi.d.ts
-interface ActionPathsOptions {
-  /** URL prefix the `rest()` adapter mounts on. Default `'/api'`. */
-  basePath?: string;
-  /** OpenAPI tag the actions are grouped under. Default `'Actions'`. */
-  tag?: string;
+//#region src/lib/rebind.d.ts
+/**
+ * Instruction for reconstructing one positional handler argument from the flat
+ * MCP tool input. Built at discovery time, consumed by {@link invokeRebound}.
+ */
+type Binding = {
+  kind: 'value';
+  field: string;
+  source: 'path' | 'query' | 'body';
+  metatype?: unknown;
+  pipes?: unknown[];
+} | {
+  kind: 'object';
+  source: 'query' | 'body';
+  fields: string[];
+  metatype?: unknown;
+  pipes?: unknown[];
+} | {
+  kind: 'params';
+  fields: string[];
+} | {
+  kind: 'request';
+} | {
+  kind: 'response';
+} | {
+  kind: 'headers';
+  data?: string;
+} | {
+  kind: 'ip';
+} | {
+  kind: 'host';
+  data?: string;
+} | {
+  kind: 'missing';
+};
+interface RequestLike {
+  headers?: Record<string, unknown>;
+  ip?: unknown;
+  hosts?: Record<string, unknown>;
 }
 /**
- * Build an OpenAPI `paths` fragment for a set of Silkweave actions, mirroring
- * exactly how the `rest()` adapter routes them: the same HTTP verb (`method` ??
- * `kind`), the same `path`/`name`-derived route, and the same path/query/body
- * field split (`pathParamNames` + `queryParams`). Schemas are inlined from the
- * Zod input/output via `z.toJSONSchema`; no shared components are emitted.
+ * Reconstruct the controller method's positional arguments from the validated
+ * tool `input` (and the request stand-in for `@Req`/`@Headers`/...), then call
+ * it. `applyParamPipes` controls whether parameter-bound pipes run.
  */
-declare function buildActionPaths(actions: Action$1[], options?: ActionPathsOptions): Record<string, Record<string, unknown>>;
+declare function invokeRebound(method: (...args: any[]) => any, instance: object, input: Record<string, unknown>, bindings: Binding[], request: RequestLike | undefined, applyParamPipes: boolean): Promise<unknown>;
+/** Map a non-input parameter slot (`@Req`/`@Headers`/`@Ip`/...) to its runtime binding. */
+declare function specialBinding(paramtype: number, data: string | undefined): Binding | null;
 //#endregion
 //#region src/lib/silkweave.module.d.ts
 /**
  * Root module for `@silkweave/nestjs`.
  *
- * Discovers every `@Action`-decorated method via `DiscoveryService` and
- * registers the configured adapters (`rest()`, `trpc()`, `mcp()`) 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 controller in the Express stack. There is
- * no slot middleware, no race with Nest's 404 catch-all, and every route
- * shows up in Nest's `RoutesResolver` logger.
+ * 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()`.
+ *
+ * Because `configure()` runs during `registerModules` - before Nest's
+ * `registerRouter()` step - Silkweave's routes always sit ahead of every
+ * controller in the Express stack. The controllers keep serving HTTP exactly as
+ * before; `@Mcp` is purely additive.
  *
  * @example
  * ```ts
@@ -361,13 +387,10 @@ declare function buildActionPaths(actions: Action$1[], options?: ActionPathsOpti
  *   imports: [
  *     SilkweaveModule.forRoot({
  *       silkweave: { name: 'app', description: 'My App', version: '1.0.0' },
- *       adapters: [
- *         rest({ basePath: '/api' }),
- *         trpc({ basePath: '/trpc' }),
- *         mcp({ basePath: '/mcp' })
- *       ]
+ *       adapters: [mcp({ basePath: '/mcp' })]
  *     })
- *   ]
+ *   ],
+ *   controllers: [ChannelsController]
  * })
  * export class AppModule {}
  * ```
@@ -376,50 +399,10 @@ declare class SilkweaveModule implements NestModule {
   private readonly options;
   private readonly discovery;
   private readonly httpAdapterHost;
-  constructor(options: SilkweaveModuleOptions, discovery: ActionDiscovery, httpAdapterHost: HttpAdapterHost);
+  constructor(options: SilkweaveModuleOptions, discovery: ControllerDiscovery, httpAdapterHost: HttpAdapterHost);
   static forRoot(options: SilkweaveModuleOptions): DynamicModule;
   configure(_consumer: MiddlewareConsumer): void;
 }
 //#endregion
-//#region src/lib/swagger.d.ts
-interface SilkweaveSwaggerOptions {
-  /**
-   * URL prefix the `rest()` adapter mounts on. Defaults to the configured
-   * `rest()` adapter's `basePath`, falling back to `'/api'`.
-   */
-  basePath?: string;
-  /** OpenAPI tag the actions are grouped under. Default `'Actions'`. */
-  tag?: string;
-  /**
-   * Include actions that are *not* enabled on the REST transport (gated out via
-   * `transports` / `isEnabled`). Default `false` - the document mirrors the
-   * routes the `rest()` adapter actually registers.
-   */
-  includeDisabled?: boolean;
-}
-/**
- * Merge every REST-exposed Silkweave `@Action` into a NestJS Swagger
- * `OpenAPIObject`.
- *
- * `@nestjs/swagger` builds its document by scanning **controllers**, but
- * Silkweave registers action routes directly on the HTTP adapter (so they sit
- * ahead of controllers in the request pipeline) - which means the scanner never
- * sees them. This helper closes that gap: it discovers the actions through the
- * same `ActionDiscovery` provider the `rest()` adapter uses, builds OpenAPI
- * paths with the same routing logic (`buildActionPaths`), and merges them into
- * the document. The result stays in sync with the live routes without any
- * dynamic controllers.
- *
- * Call it between `SwaggerModule.createDocument()` and `SwaggerModule.setup()`:
- *
- * @example
- * ```ts
- * const document = SwaggerModule.createDocument(app, config)
- * addSilkweaveActions(app, document)
- * SwaggerModule.setup('api/docs', app, document)
- * ```
- */
-declare function addSilkweaveActions(app: INestApplication, document: OpenAPIObject, options?: SilkweaveSwaggerOptions): OpenAPIObject;
-//#endregion
-export { ACTIONS_METADATA, ACTION_METADATA, ACTION_RESPONSE_KEY, Action, ActionDiscovery, ActionMetadata, ActionPathsOptions, Actions, type ActionsClassMetadata, AnyActionMetadata, type InferTrpcRouter, McpAdapterOptions, NestAdapterRegisterContext, NestSilkweaveAdapter, RestAdapterOptions, ResultToolResult, SILKWEAVE_MODULE_OPTIONS, SilkweaveModule, SilkweaveModuleOptions, SilkweaveSwaggerOptions, type Transport, TrpcAdapterOptions, TypegenAdapterOptions, addSilkweaveActions, buildActionPaths, buildIsEnabled, collectGuards, mcp, rest, runGuards, trpc, typegen };
+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 };
 //# sourceMappingURL=index.d.mts.map