@dudousxd/nestjs-agent 0.10.1 → 0.11.0

package/dist/index.d.cts

@@ -177,6 +177,17 @@ interface AiToolOptions {
     input: StandardSchemaV1;
     /** Roles allowed to invoke. Omit to inherit the module's default roles. */
     roles?: string[];
+    /**
+     * Whether this tool exists in this deployment. `false` — or a predicate returning `false`, which
+     * is re-evaluated every turn — drops it before the role filter, so the model is never shown it.
+     * Omit → enabled.
+     *
+     * Use this for availability that is knowable without DI (a constant, `process.env`, a closure
+     * over something the app already holds). When the answer lives in an injected service, implement
+     * `isEnabled()` on the class instead: this object is built while the decorator is evaluated, at
+     * import time, and can't reach the container.
+     */
+    enabled?: boolean | (() => boolean | Promise<boolean>);
     /**
      * Authz ability checked by an ability-aware RolesPolicy (e.g. `AgentAuthzModule`'s
      * `AuthzRolesPolicy` → `gate.forUser(actor).allows(ability)`). Ignored by the default
@@ -194,6 +205,18 @@ interface AiToolOptions {
  *   async execute(input, ctx) { return { tempC: 21 }; }
  * }
  * ```
+ *
+ * A tool the deployment can turn off — the flag read through DI, so `.env` and a config service
+ * both work:
+ *
+ * ```ts
+ * @AiTool({ name: 'searchDocs', kind: 'read', description: '...', input: schema })
+ * class SearchDocsTool implements ToolHandler<Input> {
+ *   constructor(private readonly config: ConfigService) {}
+ *   isEnabled() { return this.config.get('DOCS_SEARCH_ENABLED') === 'true'; }
+ *   async execute(input, ctx) { ... }
+ * }
+ * ```
  */
 declare function AiTool(options: AiToolOptions): ClassDecorator;
 declare function readAiToolMetadata(target: object): AiToolOptions | undefined;

package/dist/index.d.ts

@@ -177,6 +177,17 @@ interface AiToolOptions {
     input: StandardSchemaV1;
     /** Roles allowed to invoke. Omit to inherit the module's default roles. */
     roles?: string[];
+    /**
+     * Whether this tool exists in this deployment. `false` — or a predicate returning `false`, which
+     * is re-evaluated every turn — drops it before the role filter, so the model is never shown it.
+     * Omit → enabled.
+     *
+     * Use this for availability that is knowable without DI (a constant, `process.env`, a closure
+     * over something the app already holds). When the answer lives in an injected service, implement
+     * `isEnabled()` on the class instead: this object is built while the decorator is evaluated, at
+     * import time, and can't reach the container.
+     */
+    enabled?: boolean | (() => boolean | Promise<boolean>);
     /**
      * Authz ability checked by an ability-aware RolesPolicy (e.g. `AgentAuthzModule`'s
      * `AuthzRolesPolicy` → `gate.forUser(actor).allows(ability)`). Ignored by the default
@@ -194,6 +205,18 @@ interface AiToolOptions {
  *   async execute(input, ctx) { return { tempC: 21 }; }
  * }
  * ```
+ *
+ * A tool the deployment can turn off — the flag read through DI, so `.env` and a config service
+ * both work:
+ *
+ * ```ts
+ * @AiTool({ name: 'searchDocs', kind: 'read', description: '...', input: schema })
+ * class SearchDocsTool implements ToolHandler<Input> {
+ *   constructor(private readonly config: ConfigService) {}
+ *   isEnabled() { return this.config.get('DOCS_SEARCH_ENABLED') === 'true'; }
+ *   async execute(input, ctx) { ... }
+ * }
+ * ```
  */
 declare function AiTool(options: AiToolOptions): ClassDecorator;
 declare function readAiToolMetadata(target: object): AiToolOptions | undefined;

package/dist/index.js

@@ -1450,9 +1450,21 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
         } : {},
         ...meta.ability !== void 0 ? {
           ability: meta.ability
+        } : {},
+        ...meta.enabled !== void 0 ? {
+          enabled: meta.enabled
         } : {}
       }, {
-        execute: /* @__PURE__ */ __name((input, ctx) => instance.execute(input, ctx), "execute")
+        execute: /* @__PURE__ */ __name((input, ctx) => instance.execute(input, ctx), "execute"),
+        // Forwarded, not copied: the registry holds this wrapper rather than the provider, so an
+        // `isEnabled()`/`canUse()` left behind here would be a gate that silently never applies.
+        // Called through `instance` so each keeps its `this` (and its injected deps).
+        ...typeof handler.isEnabled === "function" ? {
+          isEnabled: /* @__PURE__ */ __name(() => instance.isEnabled(), "isEnabled")
+        } : {},
+        ...typeof handler.canUse === "function" ? {
+          canUse: /* @__PURE__ */ __name((actor) => instance.canUse(actor), "canUse")
+        } : {}
       });
       count += 1;
     }