@silkweave/nestjs 1.11.0 → 2.0.0

package/build/index.d.mts

@@ -1,12 +1,89 @@
 import { CanActivate, DynamicModule, MiddlewareConsumer, NestModule, Type } from "@nestjs/common";
-import { AuthConfig } from "@silkweave/auth";
-import { Action as Action$1, ActionKind, 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 { Action, SilkweaveContext, SilkweaveOptions } 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
@@ -23,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
@@ -34,12 +111,13 @@ interface NestAdapterRegisterContext {
  */
 interface NestSilkweaveAdapter {
   /** Adapter discriminator - set on the silkweave context as `ctx.get('adapter')`. */
-  readonly name: 'rest' | 'trpc' | 'mcp' | 'typegen';
+  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. */
@@ -48,10 +126,17 @@ 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;
 }
 declare const SILKWEAVE_MODULE_OPTIONS = "__silkweave_module_options__";
 //#endregion
@@ -84,208 +169,99 @@ 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:
- *
- * - `kind: 'query'` → `GET ${basePath}/${actionName-with-slashes}` (input from query string)
- * - `kind: 'mutation'` → `POST ${basePath}/${actionName-with-slashes}` (input from JSON body)
- *
- * Routes show up in Nest's `RoutesResolver` logger and are eligible for
- * `@nestjs/swagger` scanning. 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;
-  /** 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;
+declare function Mcp(options?: McpMetadata): 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;
-//#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);
   /**
-   * 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 applied first).
    */
-  discover(): Action$1[];
+  discover(openapi?: OpenApiDocument): 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
-/**
- * Compile a `transports` allowlist + optional user `isEnabled` into a single
- * `(ctx) => boolean` callback compatible with `Action.isEnabled`.
- *
- * - 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.
- */
-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;
 /**
@@ -309,17 +285,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/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>;
+}
+/**
+ * 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 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
@@ -327,13 +355,10 @@ declare function runGuards(guards: GuardRef[], moduleRef: ModuleRef, reflector:
  *   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 {}
  * ```
@@ -342,10 +367,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
-export { ACTIONS_METADATA, ACTION_METADATA, ACTION_RESPONSE_KEY, Action, ActionDiscovery, ActionMetadata, Actions, type ActionsClassMetadata, AnyActionMetadata, type InferTrpcRouter, McpAdapterOptions, NestAdapterRegisterContext, NestSilkweaveAdapter, RestAdapterOptions, ResultToolResult, SILKWEAVE_MODULE_OPTIONS, SilkweaveModule, SilkweaveModuleOptions, type Transport, TrpcAdapterOptions, TypegenAdapterOptions, 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, collectGuards, designTypeToField, fieldToZod, invokeRebound, mcp, 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/types.ts","../src/adapter/mcp.ts","../src/adapter/rest.ts","../src/adapter/trpc.ts","../src/adapter/typegen.ts","../src/lib/metadata.ts","../src/decorator/action.ts","../src/decorator/actions.ts","../src/lib/discovery.ts","../src/lib/filter.ts","../src/lib/guards.ts","../src/lib/silkweave.module.ts"],"mappings":"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"}
+{"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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"}