@dudousxd/nestjs-agent 1.1.2 → 1.3.0

package/dist/durable/index.cjs

@@ -304,7 +304,21 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       runId: ctx.runId,
       // A child forwards into the top-level sink but must not end/fail it (the top-level run owns it).
       openSink: /* @__PURE__ */ __name(async () => input.sinkRunId !== void 0 ? childSinkWriter(await deps.sink.open(sinkRunId)) : deps.sink.open(ctx.runId), "openSink"),
-      awaitApproval: /* @__PURE__ */ __name((call) => ctx.waitForSignal(`tool:${ctx.runId}:${call.id}`), "awaitApproval"),
+      // A policy's time to live becomes the signal wait's own timeout: the runtime journals the
+      // deadline on the first call (a position of its own, reached only for a call the journal says
+      // has a ttl) and wakes the run when it passes. The lapse comes back as a Decision rather than a
+      // throw, so the loop settles the call `expired` on its ordinary rejection checkpoint.
+      awaitApproval: /* @__PURE__ */ __name((call, _toolCtx, opts) => opts?.timeoutMs === void 0 ? ctx.waitForSignal(`tool:${ctx.runId}:${call.id}`) : ctx.waitForSignal(`tool:${ctx.runId}:${call.id}`, {
+        timeoutMs: opts.timeoutMs
+      }).catch((error) => {
+        if (isSignalTimeout(error)) {
+          return {
+            approved: false,
+            expired: true
+          };
+        }
+        throw error;
+      }), "awaitApproval"),
       // The same wait, on the same signal key, carrying a typed answer instead of a yes/no — so a
       // question set and an approval reach a parked run through one path, and the HTTP surface that
       // settles either one is the same `POST /agent/tool-call/*` family.
@@ -478,6 +492,10 @@ AgentRunWorkflow = _ts_decorate2([
     typeof RunGateway === "undefined" ? Object : RunGateway
   ])
 ], AgentRunWorkflow);
+function isSignalTimeout(error) {
+  return error instanceof Error && error.name === "SignalTimeoutError";
+}
+__name(isSignalTimeout, "isSignalTimeout");
 
 // src/durable/durable-agent-runner.ts
 var import_node_crypto = require("crypto");
@@ -788,8 +806,8 @@ AgentDurableModule = _ts_decorate4([
 ], AgentDurableModule);
 
 // src/agent.module.ts
-var import_nestjs_agent_core23 = require("@dudousxd/nestjs-agent-core");
-var import_common20 = require("@nestjs/common");
+var import_nestjs_agent_core24 = require("@dudousxd/nestjs-agent-core");
+var import_common21 = require("@nestjs/common");
 var import_core4 = require("@nestjs/core");
 
 // src/agent-deps.factory.ts
@@ -908,6 +926,9 @@ var AgentDepsFactory2 = class {
       store: this.store,
       sink: this.sink,
       rolesPolicy: this.rolesPolicy,
+      ...this.options.approvalPolicy !== void 0 ? {
+        approvalPolicy: this.options.approvalPolicy
+      } : {},
       registry: this.registry,
       promptContributors: this.promptContributors,
       systemPrompt: definition?.systemPrompt ?? "You are a helpful assistant.",
@@ -1191,18 +1212,35 @@ var AgentService = class {
     await this.assertOwnsActiveStream(actor, runId);
     return this.subscribe(runId);
   }
-  async approve(actor, toolCallId2) {
-    await this.assertOwnsToolCall(actor, toolCallId2);
+  /**
+  * Approve a parked action call as `actor`. Who may is the call's recorded approver's business
+  * (see {@link assertMayDecide}); `remember` approves later calls of the same tool in the same
+  * thread, and `via` names the surface the decision came through (`'web'`, `'slack'`, …) — both
+  * persisted with the call.
+  */
+  async approve(actor, toolCallId2, opts = {}) {
+    await this.assertMayDecide(actor, toolCallId2);
     return this.signalToolCall(toolCallId2, {
-      approved: true
+      approved: true,
+      executedByRef: actor.id,
+      ...opts.remember === true ? {
+        remember: true
+      } : {},
+      ...opts.via !== void 0 ? {
+        decidedVia: opts.via
+      } : {}
     });
   }
-  async reject(actor, toolCallId2, reason) {
-    await this.assertOwnsToolCall(actor, toolCallId2);
+  async reject(actor, toolCallId2, reason, opts = {}) {
+    await this.assertMayDecide(actor, toolCallId2);
     return this.signalToolCall(toolCallId2, {
       approved: false,
+      executedByRef: actor.id,
       ...reason !== void 0 ? {
         reason
+      } : {},
+      ...opts.via !== void 0 ? {
+        decidedVia: opts.via
       } : {}
     });
   }
@@ -1243,6 +1281,7 @@ var AgentService = class {
   * not the thread's own actor).
   */
   async signalToolCall(toolCallId2, reply) {
+    await this.assertNotExpired(toolCallId2);
     const runId = await this.resolveRunForToolCall(toolCallId2);
     return this.runner.signal(runId, toolCallId2, reply);
   }
@@ -1481,6 +1520,47 @@ var AgentService = class {
     }
   }
   /**
+  * Authorization seam for approve/reject. The call's recorded approver decides who may settle it:
+  * the requester (the default, and every call recorded before approvers existed) is the thread's
+  * own actor — the ownership check this always was; any other approver goes through the policy's
+  * `canDecide`, which by default asks whether the actor holds that role.
+  */
+  async assertMayDecide(actor, toolCallId2) {
+    const approval = await this.store.toolCallApproval?.(toolCallId2);
+    const approver = approval?.approver ?? import_nestjs_agent_core8.REQUESTER_APPROVER;
+    if (approver === import_nestjs_agent_core8.REQUESTER_APPROVER) {
+      return this.assertOwnsToolCall(actor, toolCallId2);
+    }
+    const requesterRef = await this.store.ownerOfToolCall(toolCallId2);
+    if (requesterRef === null) {
+      throw new import_common6.NotFoundException(`tool call ${toolCallId2} not found`);
+    }
+    const allowed = await (0, import_nestjs_agent_core8.mayDecideApproval)(this.deps.forAgent().approvalPolicy, actor, {
+      toolCallId: toolCallId2,
+      approver,
+      requesterRef
+    });
+    if (!allowed) {
+      throw new import_common6.ForbiddenException(`this approval is for ${approver}`);
+    }
+  }
+  /**
+  * Refuse a decision on a request that has already lapsed — recorded `expired`, or past its
+  * `expiresAt` with the run's own timer about to fire. Signalling it anyway would race the timeout:
+  * a durable runtime buffers a signal nobody is waiting on, and a late approval must not be what a
+  * later replay of the run reads back.
+  */
+  async assertNotExpired(toolCallId2) {
+    const approval = await this.store.toolCallApproval?.(toolCallId2);
+    if (approval === null || approval === void 0) {
+      return;
+    }
+    const lapsed = approval.status === "expired" || approval.status === "pending_approval" && approval.expiresAt !== null && Date.parse(approval.expiresAt) <= Date.now();
+    if (lapsed) {
+      throw new import_common6.GoneException(`the approval request for tool call ${toolCallId2} has expired`);
+    }
+  }
+  /**
   * Resolve the run awaiting `toolCallId`. Derived server-side from the tool call alone — the client
   * never knows or supplies a runId, and that run is the sub-agent's own child run when the pending
   * call belongs to a delegated agent. The store answers from the CALL'S OWN `runId` where it has
@@ -1558,6 +1638,12 @@ var AgentApprovalPortAdapter = class {
       approved: true,
       ...opts?.executedByRef !== void 0 ? {
         executedByRef: opts.executedByRef
+      } : {},
+      ...opts?.remember === true ? {
+        remember: true
+      } : {},
+      ...opts?.decidedVia !== void 0 ? {
+        decidedVia: opts.decidedVia
       } : {}
     });
   }
@@ -1569,6 +1655,9 @@ var AgentApprovalPortAdapter = class {
       } : {},
       ...opts?.reason !== void 0 ? {
         reason: opts.reason
+      } : {},
+      ...opts?.decidedVia !== void 0 ? {
+        decidedVia: opts.decidedVia
       } : {}
     });
   }
@@ -2488,6 +2577,8 @@ var MAX_ANSWERED_QUESTIONS = 100;
 var MAX_VALUES_PER_QUESTION = 100;
 var MAX_ANSWER_VALUE_LENGTH = 4096;
 var MAX_REJECT_REASON_LENGTH = 4096;
+var MAX_VIA_LENGTH = 64;
+var DEFAULT_VIA = "web";
 function toolCallId(claimed) {
   if (typeof claimed !== "string" || claimed.length === 0) {
     throw new import_common15.BadRequestException("toolCallId must be a non-empty string");
@@ -2508,6 +2599,26 @@ function rejectReason(claimed) {
   return claimed;
 }
 __name(rejectReason, "rejectReason");
+function remember(claimed) {
+  if (claimed === void 0) {
+    return false;
+  }
+  if (typeof claimed !== "boolean") {
+    throw new import_common15.BadRequestException("remember must be a boolean");
+  }
+  return claimed;
+}
+__name(remember, "remember");
+function via(claimed) {
+  if (claimed === void 0) {
+    return DEFAULT_VIA;
+  }
+  if (typeof claimed !== "string" || claimed.length === 0 || claimed.length > MAX_VIA_LENGTH) {
+    throw new import_common15.BadRequestException(`via must be a string of 1-${MAX_VIA_LENGTH} characters`);
+  }
+  return claimed;
+}
+__name(via, "via");
 function answers(claimed) {
   if (claimed === void 0) {
     return void 0;
@@ -2552,14 +2663,19 @@ var ToolCallController = class {
   }
   async approve(req, body) {
     const actor = await this.actorResolver.resolve(req);
-    await this.agent.approve(actor, toolCallId(body.toolCallId));
+    await this.agent.approve(actor, toolCallId(body.toolCallId), {
+      remember: remember(body.remember),
+      via: via(body.via)
+    });
     return {
       ok: true
     };
   }
   async reject(req, body) {
     const actor = await this.actorResolver.resolve(req);
-    await this.agent.reject(actor, toolCallId(body.toolCallId), rejectReason(body.reason));
+    await this.agent.reject(actor, toolCallId(body.toolCallId), rejectReason(body.reason), {
+      via: via(body.via)
+    });
     return {
       ok: true
     };
@@ -2625,7 +2741,7 @@ _ts_decorate15([
   _ts_metadata14("design:type", Function),
   _ts_metadata14("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
-    typeof ApproveBody === "undefined" ? Object : ApproveBody
+    Object
   ]),
   _ts_metadata14("design:returntype", Promise)
 ], ToolCallController.prototype, "skip", null);
@@ -2639,9 +2755,90 @@ ToolCallController = _ts_decorate15([
   ])
 ], ToolCallController);
 
-// src/discovery/agent-discovery.service.ts
+// src/controller/tools.controller.ts
 var import_nestjs_agent_core17 = require("@dudousxd/nestjs-agent-core");
 var import_common16 = require("@nestjs/common");
+function _ts_decorate16(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata15(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata15, "_ts_metadata");
+function _ts_param14(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param14, "_ts_param");
+var ToolsController = class {
+  static {
+    __name(this, "ToolsController");
+  }
+  actorResolver;
+  depsFactory;
+  agents;
+  constructor(actorResolver, depsFactory, agents) {
+    this.actorResolver = actorResolver;
+    this.depsFactory = depsFactory;
+    this.agents = agents;
+  }
+  async list(req, agent) {
+    if (agent !== void 0 && this.agents.get(agent) === void 0) {
+      throw new import_common16.NotFoundException(`No agent named "${agent}"`);
+    }
+    const actor = await this.actorResolver.resolve(req);
+    const deps = this.depsFactory.forAgent(agent);
+    const specs = await deps.registry.visibleSpecs(actor, deps.rolesPolicy, deps.toolAllowList);
+    return specs.map((spec) => ({
+      name: spec.name,
+      kind: spec.kind,
+      ...spec.presentation !== void 0 ? {
+        presentation: spec.presentation
+      } : {}
+    }));
+  }
+};
+_ts_decorate16([
+  (0, import_common16.Get)(),
+  _ts_param14(0, (0, import_common16.Req)()),
+  _ts_param14(1, (0, import_common16.Query)("agent")),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata15("design:returntype", Promise)
+], ToolsController.prototype, "list", null);
+ToolsController = _ts_decorate16([
+  (0, import_common16.Controller)("tools"),
+  _ts_param14(0, (0, import_common16.Inject)(import_nestjs_agent_core17.AGENT_ACTOR_RESOLVER)),
+  _ts_param14(1, (0, import_common16.Inject)(import_nestjs_agent_core17.AGENT_DEPS_FACTORY)),
+  _ts_param14(2, (0, import_common16.Inject)(import_nestjs_agent_core17.AGENT_REGISTRY)),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof ActorResolver === "undefined" ? Object : ActorResolver,
+    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
+    typeof import_nestjs_agent_core17.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core17.AgentRegistry
+  ])
+], ToolsController);
+
+// src/discovery/agent-discovery.service.ts
+var import_nestjs_agent_core18 = require("@dudousxd/nestjs-agent-core");
+var import_common17 = require("@nestjs/common");
 var import_core = require("@nestjs/core");
 
 // src/decorator/agent.decorator.ts
@@ -2658,7 +2855,7 @@ var SYSTEM_PROMPT_METADATA = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent:
 var SYSTEM_PROMPT_CONTRIBUTOR_METADATA = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent:system-prompt-contributor");
 
 // src/discovery/agent-discovery.service.ts
-function _ts_decorate16(decorators, target, key, desc) {
+function _ts_decorate17(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -2671,19 +2868,19 @@ function _ts_decorate16(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate16, "_ts_decorate");
-function _ts_metadata15(metadataKey, metadataValue) {
+__name(_ts_decorate17, "_ts_decorate");
+function _ts_metadata16(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata15, "_ts_metadata");
-function _ts_param14(paramIndex, decorator) {
+__name(_ts_metadata16, "_ts_metadata");
+function _ts_param15(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param14, "_ts_param");
+__name(_ts_param15, "_ts_param");
 var AgentDiscoveryService = class _AgentDiscoveryService {
   static {
     __name(this, "AgentDiscoveryService");
@@ -2692,7 +2889,7 @@ var AgentDiscoveryService = class _AgentDiscoveryService {
   scanner;
   registry;
   contributors;
-  logger = new import_common16.Logger(_AgentDiscoveryService.name);
+  logger = new import_common17.Logger(_AgentDiscoveryService.name);
   constructor(discovery, scanner, registry, contributors) {
     this.discovery = discovery;
     this.scanner = scanner;
@@ -2810,22 +3007,22 @@ var AgentDiscoveryService = class _AgentDiscoveryService {
     return (ctx) => candidate.call(instance, ctx);
   }
 };
-AgentDiscoveryService = _ts_decorate16([
-  (0, import_common16.Injectable)(),
-  _ts_param14(2, (0, import_common16.Inject)(import_nestjs_agent_core17.AGENT_REGISTRY)),
-  _ts_param14(3, (0, import_common16.Inject)(import_nestjs_agent_core17.AGENT_PROMPT_CONTRIBUTORS)),
-  _ts_metadata15("design:type", Function),
-  _ts_metadata15("design:paramtypes", [
+AgentDiscoveryService = _ts_decorate17([
+  (0, import_common17.Injectable)(),
+  _ts_param15(2, (0, import_common17.Inject)(import_nestjs_agent_core18.AGENT_REGISTRY)),
+  _ts_param15(3, (0, import_common17.Inject)(import_nestjs_agent_core18.AGENT_PROMPT_CONTRIBUTORS)),
+  _ts_metadata16("design:type", Function),
+  _ts_metadata16("design:paramtypes", [
     typeof import_core.DiscoveryService === "undefined" ? Object : import_core.DiscoveryService,
     typeof import_core.MetadataScanner === "undefined" ? Object : import_core.MetadataScanner,
-    typeof import_nestjs_agent_core17.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core17.AgentRegistry,
+    typeof import_nestjs_agent_core18.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core18.AgentRegistry,
     Array
   ])
 ], AgentDiscoveryService);
 
 // src/discovery/ai-tool-discovery.service.ts
-var import_nestjs_agent_core18 = require("@dudousxd/nestjs-agent-core");
-var import_common17 = require("@nestjs/common");
+var import_nestjs_agent_core19 = require("@dudousxd/nestjs-agent-core");
+var import_common18 = require("@nestjs/common");
 var import_core2 = require("@nestjs/core");
 var import_zod = require("zod");
 
@@ -2845,7 +3042,7 @@ function isBrandedFunctionalTool(value) {
 __name(isBrandedFunctionalTool, "isBrandedFunctionalTool");
 
 // src/discovery/ai-tool-discovery.service.ts
-function _ts_decorate17(decorators, target, key, desc) {
+function _ts_decorate18(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -2858,19 +3055,19 @@ function _ts_decorate17(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate17, "_ts_decorate");
-function _ts_metadata16(metadataKey, metadataValue) {
+__name(_ts_decorate18, "_ts_decorate");
+function _ts_metadata17(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata16, "_ts_metadata");
-function _ts_param15(paramIndex, decorator) {
+__name(_ts_metadata17, "_ts_metadata");
+function _ts_param16(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param15, "_ts_param");
+__name(_ts_param16, "_ts_param");
 var AiToolDiscoveryService = class _AiToolDiscoveryService {
   static {
     __name(this, "AiToolDiscoveryService");
@@ -2879,7 +3076,7 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
   registry;
   agents;
   options;
-  logger = new import_common17.Logger(_AiToolDiscoveryService.name);
+  logger = new import_common18.Logger(_AiToolDiscoveryService.name);
   constructor(discovery, registry, agents, options) {
     this.discovery = discovery;
     this.registry = registry;
@@ -2924,6 +3121,9 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
         } : {},
         ...meta.enabled !== void 0 ? {
           enabled: meta.enabled
+        } : {},
+        ...meta.presentation !== void 0 ? {
+          presentation: meta.presentation
         } : {}
       }, {
         execute: /* @__PURE__ */ __name((input, ctx) => instance.execute(input, ctx), "execute"),
@@ -2947,7 +3147,7 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
     let delegates = 0;
     for (const definition of this.agents.list()) {
       for (const edge of definition.delegatesTo ?? []) {
-        const { agent: target, detached } = (0, import_nestjs_agent_core18.normalizeDelegation)(edge);
+        const { agent: target, detached } = (0, import_nestjs_agent_core19.normalizeDelegation)(edge);
         const targetDefinition = this.agents.get(target);
         if (targetDefinition === void 0) {
           throw new Error(`Agent "${definition.name}" hands off to "${target}", which is not a registered @Agent. Declare it as an @Agent provider or fix the reference.`);
@@ -2997,13 +3197,13 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
     return true;
   }
 };
-AiToolDiscoveryService = _ts_decorate17([
-  (0, import_common17.Injectable)(),
-  _ts_param15(1, (0, import_common17.Inject)(import_nestjs_agent_core18.AGENT_TOOL_REGISTRY)),
-  _ts_param15(2, (0, import_common17.Inject)(import_nestjs_agent_core18.AGENT_REGISTRY)),
-  _ts_param15(3, (0, import_common17.Inject)(import_nestjs_agent_core18.AGENT_OPTIONS)),
-  _ts_metadata16("design:type", Function),
-  _ts_metadata16("design:paramtypes", [
+AiToolDiscoveryService = _ts_decorate18([
+  (0, import_common18.Injectable)(),
+  _ts_param16(1, (0, import_common18.Inject)(import_nestjs_agent_core19.AGENT_TOOL_REGISTRY)),
+  _ts_param16(2, (0, import_common18.Inject)(import_nestjs_agent_core19.AGENT_REGISTRY)),
+  _ts_param16(3, (0, import_common18.Inject)(import_nestjs_agent_core19.AGENT_OPTIONS)),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [
     typeof import_core2.DiscoveryService === "undefined" ? Object : import_core2.DiscoveryService,
     typeof ToolRegistry === "undefined" ? Object : ToolRegistry,
     typeof AgentRegistry === "undefined" ? Object : AgentRegistry,
@@ -3012,25 +3212,25 @@ AiToolDiscoveryService = _ts_decorate17([
 ], AiToolDiscoveryService);
 
 // src/discovery/skill-discovery.service.ts
-var import_nestjs_agent_core20 = require("@dudousxd/nestjs-agent-core");
-var import_common18 = require("@nestjs/common");
+var import_nestjs_agent_core21 = require("@dudousxd/nestjs-agent-core");
+var import_common19 = require("@nestjs/common");
 var import_core3 = require("@nestjs/core");
 
 // src/decorator/skill.decorator.ts
 var import_reflect_metadata4 = require("reflect-metadata");
-var import_nestjs_agent_core19 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core20 = require("@dudousxd/nestjs-agent-core");
 var SKILL_METADATA = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent:skill-metadata");
 function readSkillMetadata(target) {
   return Reflect.getMetadata(SKILL_METADATA, target);
 }
 __name(readSkillMetadata, "readSkillMetadata");
 function skillScope(options) {
-  return options.scope ?? import_nestjs_agent_core19.GLOBAL_SCOPE;
+  return options.scope ?? import_nestjs_agent_core20.GLOBAL_SCOPE;
 }
 __name(skillScope, "skillScope");
 
 // src/discovery/skill-discovery.service.ts
-function _ts_decorate18(decorators, target, key, desc) {
+function _ts_decorate19(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -3043,26 +3243,26 @@ function _ts_decorate18(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate18, "_ts_decorate");
-function _ts_metadata17(metadataKey, metadataValue) {
+__name(_ts_decorate19, "_ts_decorate");
+function _ts_metadata18(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata17, "_ts_metadata");
-function _ts_param16(paramIndex, decorator) {
+__name(_ts_metadata18, "_ts_metadata");
+function _ts_param17(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param16, "_ts_param");
+__name(_ts_param17, "_ts_param");
 var SkillDiscoveryService = class _SkillDiscoveryService {
   static {
     __name(this, "SkillDiscoveryService");
   }
   discovery;
   declared;
-  logger = new import_common18.Logger(_SkillDiscoveryService.name);
+  logger = new import_common19.Logger(_SkillDiscoveryService.name);
   constructor(discovery, declared) {
     this.discovery = discovery;
     this.declared = declared;
@@ -3099,11 +3299,11 @@ var SkillDiscoveryService = class _SkillDiscoveryService {
     return flat === void 0 ? void 0 : () => flat;
   }
 };
-SkillDiscoveryService = _ts_decorate18([
-  (0, import_common18.Injectable)(),
-  _ts_param16(1, (0, import_common18.Inject)(import_nestjs_agent_core20.AGENT_SKILL_SOURCES)),
-  _ts_metadata17("design:type", Function),
-  _ts_metadata17("design:paramtypes", [
+SkillDiscoveryService = _ts_decorate19([
+  (0, import_common19.Injectable)(),
+  _ts_param17(1, (0, import_common19.Inject)(import_nestjs_agent_core21.AGENT_SKILL_SOURCES)),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
     typeof import_core3.DiscoveryService === "undefined" ? Object : import_core3.DiscoveryService,
     Array
   ])
@@ -3133,9 +3333,9 @@ var LedgerQuotaStore = class {
 };
 
 // src/runner/inline-agent-runner.ts
-var import_nestjs_agent_core21 = require("@dudousxd/nestjs-agent-core");
-var import_common19 = require("@nestjs/common");
-function _ts_decorate19(decorators, target, key, desc) {
+var import_nestjs_agent_core22 = require("@dudousxd/nestjs-agent-core");
+var import_common20 = require("@nestjs/common");
+function _ts_decorate20(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -3148,26 +3348,26 @@ function _ts_decorate19(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate19, "_ts_decorate");
-function _ts_metadata18(metadataKey, metadataValue) {
+__name(_ts_decorate20, "_ts_decorate");
+function _ts_metadata19(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata18, "_ts_metadata");
-function _ts_param17(paramIndex, decorator) {
+__name(_ts_metadata19, "_ts_metadata");
+function _ts_param18(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param17, "_ts_param");
+__name(_ts_param18, "_ts_param");
 var InlineAgentRunner = class _InlineAgentRunner {
   static {
     __name(this, "InlineAgentRunner");
   }
   factory;
   store;
-  logger = new import_common19.Logger(_InlineAgentRunner.name);
+  logger = new import_common20.Logger(_InlineAgentRunner.name);
   pending = /* @__PURE__ */ new Map();
   /**
   * Runs someone has asked to stop. In-process, like `pending`, and for the same reason: this runner
@@ -3196,18 +3396,18 @@ var InlineAgentRunner = class _InlineAgentRunner {
         ] : []
       ]
     });
-    void (0, import_nestjs_agent_core21.runAgentLoop)({
+    void (0, import_nestjs_agent_core22.runAgentLoop)({
       ...deps,
       day
     }, input, hooks).then(() => this.store.setActiveStream(input.threadId, null)).catch(async (error) => {
-      if (error instanceof import_nestjs_agent_core21.RunCancelledError) {
+      if (error instanceof import_nestjs_agent_core22.RunCancelledError) {
         await this.settleCancelled(runId, input.threadId, deps);
         return;
       }
       const message = error instanceof Error ? error.message : String(error);
-      const code = (0, import_nestjs_agent_core21.agentFailureCode)(error);
+      const code = (0, import_nestjs_agent_core22.agentFailureCode)(error);
       this.logger.error(`agent run ${runId} failed (${code}): ${message}`);
-      (0, import_nestjs_agent_core21.publishAgentRunFailed)({
+      (0, import_nestjs_agent_core22.publishAgentRunFailed)({
         runId,
         code,
         message
@@ -3256,7 +3456,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
     for (const [key, waiter] of this.pending) {
       if (key.startsWith(`${runId}:`)) {
         this.pending.delete(key);
-        waiter.reject(new import_nestjs_agent_core21.RunCancelledError());
+        waiter.reject(new import_nestjs_agent_core22.RunCancelledError());
       }
     }
     await Promise.resolve();
@@ -3271,7 +3471,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
     this.logger.log(`agent run ${runId} cancelled`);
     await this.store.setActiveStream(threadId, null);
     const writer = await deps.sink.open(runId);
-    await writer.write((0, import_nestjs_agent_core21.encodeStreamEvent)({
+    await writer.write((0, import_nestjs_agent_core22.encodeStreamEvent)({
       kind: "cancelled"
     }));
     await writer.end();
@@ -3286,6 +3486,36 @@ var InlineAgentRunner = class _InlineAgentRunner {
   * shape it is delivering — the loop asked for one and only ever gets what the caller sent. A
   * cancel settles the wait too, by rejecting it.
   */
+  /**
+  * {@link park} for an approval, bounded by the policy's time to live when it has one: the timer
+  * settles the wait as `expired` — the same Decision the durable runner builds from its signal
+  * timeout — and a decision that arrives first disarms it.
+  */
+  parkApproval(runId, toolCallId2, timeoutMs) {
+    const waiting = this.park(runId, toolCallId2);
+    if (timeoutMs === void 0) {
+      return waiting;
+    }
+    const key = `${runId}:${toolCallId2}`;
+    let timer;
+    const lapse = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        const entry = this.pending.get(key);
+        if (entry !== void 0) {
+          this.pending.delete(key);
+          resolve({
+            approved: false,
+            expired: true
+          });
+        }
+      }, timeoutMs);
+      timer.unref?.();
+    });
+    return Promise.race([
+      waiting,
+      lapse
+    ]).finally(() => clearTimeout(timer));
+  }
   park(runId, toolCallId2) {
     return new Promise((resolve, reject) => {
       this.pending.set(`${runId}:${toolCallId2}`, {
@@ -3299,10 +3529,10 @@ var InlineAgentRunner = class _InlineAgentRunner {
     return {
       runId,
       openSink: /* @__PURE__ */ __name(() => deps.sink.open(runId), "openSink"),
-      awaitApproval: /* @__PURE__ */ __name((call) => this.park(runId, call.id), "awaitApproval"),
+      awaitApproval: /* @__PURE__ */ __name((call, _ctx, opts) => this.parkApproval(runId, call.id, opts?.timeoutMs), "awaitApproval"),
       awaitAnswers: /* @__PURE__ */ __name((request) => this.park(runId, request.id), "awaitAnswers"),
       step: /* @__PURE__ */ __name((_name, fn) => fn(), "step"),
-      parallel: import_nestjs_agent_core21.settleAll,
+      parallel: import_nestjs_agent_core22.settleAll,
       cancelled: /* @__PURE__ */ __name(async () => this.cancelled.has(runId), "cancelled"),
       runAgent: /* @__PURE__ */ __name((agentName, task) => this.runNested({
         agentName,
@@ -3350,10 +3580,10 @@ var InlineAgentRunner = class _InlineAgentRunner {
     const hooks = {
       runId,
       openSink: /* @__PURE__ */ __name(() => deps.sink.open(runId), "openSink"),
-      awaitApproval: /* @__PURE__ */ __name((call) => this.park(runId, call.id), "awaitApproval"),
+      awaitApproval: /* @__PURE__ */ __name((call, _ctx, opts) => this.parkApproval(runId, call.id, opts?.timeoutMs), "awaitApproval"),
       awaitAnswers: /* @__PURE__ */ __name((request) => this.park(runId, request.id), "awaitAnswers"),
       step: /* @__PURE__ */ __name((_name, fn) => fn(), "step"),
-      parallel: import_nestjs_agent_core21.settleAll,
+      parallel: import_nestjs_agent_core22.settleAll,
       cancelled: /* @__PURE__ */ __name(async () => this.cancelled.has(runId), "cancelled"),
       runAgent: /* @__PURE__ */ __name((childName, childTask) => this.runNested({
         agentName: childName,
@@ -3386,7 +3616,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
         }
       }), "startAgent")
     };
-    void (0, import_nestjs_agent_core21.runAgentLoop)({
+    void (0, import_nestjs_agent_core22.runAgentLoop)({
       ...deps,
       day
     }, {
@@ -3400,13 +3630,13 @@ var InlineAgentRunner = class _InlineAgentRunner {
       parentRunId,
       deliverTo
     }, hooks).catch(async (error) => {
-      const cancelled = error instanceof import_nestjs_agent_core21.RunCancelledError;
+      const cancelled = error instanceof import_nestjs_agent_core22.RunCancelledError;
       const message = error instanceof Error ? error.message : String(error);
       if (!cancelled) {
         this.logger.error(`detached agent run ${runId} failed: ${message}`);
-        (0, import_nestjs_agent_core21.publishAgentRunFailed)({
+        (0, import_nestjs_agent_core22.publishAgentRunFailed)({
           runId,
-          code: (0, import_nestjs_agent_core21.agentFailureCode)(error),
+          code: (0, import_nestjs_agent_core22.agentFailureCode)(error),
           message
         });
       }
@@ -3414,11 +3644,11 @@ var InlineAgentRunner = class _InlineAgentRunner {
         runId,
         status: cancelled ? "cancelled" : "failed",
         ...cancelled ? {} : {
-          errorCode: (0, import_nestjs_agent_core21.agentFailureCode)(error),
+          errorCode: (0, import_nestjs_agent_core22.agentFailureCode)(error),
           errorMessage: message
         }
       });
-      await (0, import_nestjs_agent_core21.settleUnsettledDelegation)({
+      await (0, import_nestjs_agent_core22.settleUnsettledDelegation)({
         store: this.store,
         delivery: deliverTo,
         agent: agentName,
@@ -3454,10 +3684,10 @@ var InlineAgentRunner = class _InlineAgentRunner {
       runId,
       // Forward into the top-level stream; the top-level run owns end/fail on that shared sink.
       openSink: /* @__PURE__ */ __name(async () => childSinkWriter(await deps.sink.open(sinkRunId)), "openSink"),
-      awaitApproval: /* @__PURE__ */ __name((call) => this.park(runId, call.id), "awaitApproval"),
+      awaitApproval: /* @__PURE__ */ __name((call, _ctx, opts) => this.parkApproval(runId, call.id, opts?.timeoutMs), "awaitApproval"),
       awaitAnswers: /* @__PURE__ */ __name((request) => this.park(runId, request.id), "awaitAnswers"),
       step: /* @__PURE__ */ __name((_name, fn) => fn(), "step"),
-      parallel: import_nestjs_agent_core21.settleAll,
+      parallel: import_nestjs_agent_core22.settleAll,
       // A child stops when it is cancelled OR when the run a human is actually watching is: the
       // canceller names the top-level run, which is the only id that ever left the server.
       cancelled: /* @__PURE__ */ __name(async () => this.cancelled.has(runId) || this.cancelled.has(sinkRunId), "cancelled"),
@@ -3492,7 +3722,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
       }), "startAgent")
     };
     try {
-      return await (0, import_nestjs_agent_core21.runAgentLoop)({
+      return await (0, import_nestjs_agent_core22.runAgentLoop)({
         ...deps,
         day
       }, {
@@ -3511,19 +3741,19 @@ var InlineAgentRunner = class _InlineAgentRunner {
     }
   }
 };
-InlineAgentRunner = _ts_decorate19([
-  (0, import_common19.Injectable)(),
-  _ts_param17(0, (0, import_common19.Inject)(import_nestjs_agent_core21.AGENT_DEPS_FACTORY)),
-  _ts_param17(1, (0, import_common19.Inject)(import_nestjs_agent_core21.AGENT_STORE)),
-  _ts_metadata18("design:type", Function),
-  _ts_metadata18("design:paramtypes", [
+InlineAgentRunner = _ts_decorate20([
+  (0, import_common20.Injectable)(),
+  _ts_param18(0, (0, import_common20.Inject)(import_nestjs_agent_core22.AGENT_DEPS_FACTORY)),
+  _ts_param18(1, (0, import_common20.Inject)(import_nestjs_agent_core22.AGENT_STORE)),
+  _ts_metadata19("design:type", Function),
+  _ts_metadata19("design:paramtypes", [
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
     typeof AgentStore === "undefined" ? Object : AgentStore
   ])
 ], InlineAgentRunner);
 
 // src/skills-config.ts
-var import_nestjs_agent_core22 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core23 = require("@dudousxd/nestjs-agent-core");
 function declaredSkillProvider(declared) {
   return {
     list: /* @__PURE__ */ __name(({ scopes }) => declared.filter((skill) => scopes.includes(skill.scope)).map(({ name, description, scope }) => ({
@@ -3549,7 +3779,7 @@ function resolveSkillsConfig(options, declared) {
     declaredSkillProvider(declared)
   ];
   return {
-    provider: providers.length === 1 ? providers[0] : (0, import_nestjs_agent_core22.compositeSkillProvider)(providers),
+    provider: providers.length === 1 ? providers[0] : (0, import_nestjs_agent_core23.compositeSkillProvider)(providers),
     ...options.scopes !== void 0 ? {
       scopes: options.scopes
     } : {},
@@ -3561,7 +3791,7 @@ function resolveSkillsConfig(options, declared) {
 __name(resolveSkillsConfig, "resolveSkillsConfig");
 
 // src/agent.module.ts
-function _ts_decorate20(decorators, target, key, desc) {
+function _ts_decorate21(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -3574,92 +3804,92 @@ function _ts_decorate20(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate20, "_ts_decorate");
+__name(_ts_decorate21, "_ts_decorate");
 var DEFAULT_PATH = "agent";
 function sharedProviders(durable, includeStore) {
   const providers = [
     {
-      provide: import_nestjs_agent_core23.AGENT_TOOL_REGISTRY,
-      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core23.ToolRegistry(), "useFactory")
+      provide: import_nestjs_agent_core24.AGENT_TOOL_REGISTRY,
+      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core24.ToolRegistry(), "useFactory")
     },
     // Starts empty; AgentDiscoveryService populates it from `@Agent`-decorated providers at boot.
     {
-      provide: import_nestjs_agent_core23.AGENT_REGISTRY,
-      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core23.AgentRegistry(), "useFactory")
+      provide: import_nestjs_agent_core24.AGENT_REGISTRY,
+      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core24.AgentRegistry(), "useFactory")
     },
     // A shared, mutable list AgentDiscoveryService fills with `@SystemPromptContributor()` methods.
     {
-      provide: import_nestjs_agent_core23.AGENT_PROMPT_CONTRIBUTORS,
+      provide: import_nestjs_agent_core24.AGENT_PROMPT_CONTRIBUTORS,
       useFactory: /* @__PURE__ */ __name(() => [], "useFactory")
     },
     // Likewise for `@Skill`-decorated providers — filled by SkillDiscoveryService at onModuleInit,
     // read lazily by the AGENT_SKILLS provider below (which DI builds before discovery has run).
     {
-      provide: import_nestjs_agent_core23.AGENT_SKILL_SOURCES,
+      provide: import_nestjs_agent_core24.AGENT_SKILL_SOURCES,
       useFactory: /* @__PURE__ */ __name(() => [], "useFactory")
     },
     {
       // One resolution, shared by the loop's deps and the listing endpoint: a second one would
       // drift, and a user would be offered a skill the agent cannot reach. `undefined` when the
       // host configured none — which is what keeps the turn's checkpoint sequence unchanged.
-      provide: import_nestjs_agent_core23.AGENT_SKILLS,
+      provide: import_nestjs_agent_core24.AGENT_SKILLS,
       useFactory: /* @__PURE__ */ __name((options, declared) => resolveSkillsConfig(options.skills, declared), "useFactory"),
       inject: [
-        import_nestjs_agent_core23.AGENT_OPTIONS,
-        import_nestjs_agent_core23.AGENT_SKILL_SOURCES
+        import_nestjs_agent_core24.AGENT_OPTIONS,
+        import_nestjs_agent_core24.AGENT_SKILL_SOURCES
       ]
     },
     {
       // One resolution, shared by the loop's deps and the read-back endpoint: a person has to be
       // shown what the model was shown, and two resolutions would eventually disagree about that.
-      provide: import_nestjs_agent_core23.AGENT_MEMORY,
+      provide: import_nestjs_agent_core24.AGENT_MEMORY,
       useFactory: /* @__PURE__ */ __name((options) => options.memory, "useFactory"),
       inject: [
-        import_nestjs_agent_core23.AGENT_OPTIONS
+        import_nestjs_agent_core24.AGENT_OPTIONS
       ]
     },
     {
-      provide: import_nestjs_agent_core23.AGENT_SINK,
+      provide: import_nestjs_agent_core24.AGENT_SINK,
       useFactory: /* @__PURE__ */ __name((options) => options.sink ?? new InProcessTokenStreamSink(), "useFactory"),
       inject: [
-        import_nestjs_agent_core23.AGENT_OPTIONS
+        import_nestjs_agent_core24.AGENT_OPTIONS
       ]
     },
     {
-      provide: import_nestjs_agent_core23.AGENT_ROLES_POLICY,
-      useFactory: /* @__PURE__ */ __name((options) => options.rolesPolicy ?? new import_nestjs_agent_core23.DefaultRolesPolicy(options.defaultRoles), "useFactory"),
+      provide: import_nestjs_agent_core24.AGENT_ROLES_POLICY,
+      useFactory: /* @__PURE__ */ __name((options) => options.rolesPolicy ?? new import_nestjs_agent_core24.DefaultRolesPolicy(options.defaultRoles), "useFactory"),
       inject: [
-        import_nestjs_agent_core23.AGENT_OPTIONS
+        import_nestjs_agent_core24.AGENT_OPTIONS
       ]
     },
     {
-      provide: import_nestjs_agent_core23.AGENT_ACTOR_RESOLVER,
+      provide: import_nestjs_agent_core24.AGENT_ACTOR_RESOLVER,
       useFactory: /* @__PURE__ */ __name((options) => options.actorResolver, "useFactory"),
       inject: [
-        import_nestjs_agent_core23.AGENT_OPTIONS
+        import_nestjs_agent_core24.AGENT_OPTIONS
       ]
     },
     {
-      provide: import_nestjs_agent_core23.AGENT_MODEL,
+      provide: import_nestjs_agent_core24.AGENT_MODEL,
       useFactory: /* @__PURE__ */ __name((o) => o.model, "useFactory"),
       inject: [
-        import_nestjs_agent_core23.AGENT_OPTIONS
+        import_nestjs_agent_core24.AGENT_OPTIONS
       ]
     },
     {
       // An explicit `quota` wins; otherwise `quotaLimitTokens` binds the built-in ledger-backed
       // store; otherwise quotas are off (undefined). The ledger store reads the same usage rows
       // the loop already writes, so enforcement needs no extra shared state across replicas.
-      provide: import_nestjs_agent_core23.AGENT_QUOTA_STORE,
+      provide: import_nestjs_agent_core24.AGENT_QUOTA_STORE,
       useFactory: /* @__PURE__ */ __name((o, store) => o.quota ?? (o.quotaLimitTokens !== void 0 ? new LedgerQuotaStore(store, o.quotaLimitTokens) : void 0), "useFactory"),
       inject: [
-        import_nestjs_agent_core23.AGENT_OPTIONS,
-        import_nestjs_agent_core23.AGENT_STORE
+        import_nestjs_agent_core24.AGENT_OPTIONS,
+        import_nestjs_agent_core24.AGENT_STORE
       ]
     },
     AgentDepsFactory2,
     {
-      provide: import_nestjs_agent_core23.AGENT_DEPS_FACTORY,
+      provide: import_nestjs_agent_core24.AGENT_DEPS_FACTORY,
       useExisting: AgentDepsFactory2
     },
     // Populates the registry + contributors (onModuleInit) BEFORE AiToolDiscoveryService synthesizes
@@ -3673,22 +3903,22 @@ function sharedProviders(durable, includeStore) {
     // through AgentService.signalToolCall, which reaches whichever AGENT_RUNNER is bound above.
     AgentApprovalPortAdapter,
     {
-      provide: import_nestjs_agent_core23.AGENT_APPROVAL_PORT,
+      provide: import_nestjs_agent_core24.AGENT_APPROVAL_PORT,
       useExisting: AgentApprovalPortAdapter
     }
   ];
   if (includeStore) {
     providers.push({
-      provide: import_nestjs_agent_core23.AGENT_STORE,
+      provide: import_nestjs_agent_core24.AGENT_STORE,
       useFactory: /* @__PURE__ */ __name((o) => o.store, "useFactory"),
       inject: [
-        import_nestjs_agent_core23.AGENT_OPTIONS
+        import_nestjs_agent_core24.AGENT_OPTIONS
       ]
     });
   }
   if (durable) {
     providers.push({
-      provide: import_nestjs_agent_core23.AGENT_RUNNER,
+      provide: import_nestjs_agent_core24.AGENT_RUNNER,
       useFactory: /* @__PURE__ */ __name((durableRunner) => {
         if (durableRunner === void 0) {
           throw new Error("AgentModule.forRoot({ durable: true }) requires importing AgentDurableModule from '@dudousxd/nestjs-agent/durable' (alongside a configured DurableModule). It was not found.");
@@ -3697,14 +3927,14 @@ function sharedProviders(durable, includeStore) {
       }, "useFactory"),
       inject: [
         {
-          token: import_nestjs_agent_core23.AGENT_DURABLE_RUNNER,
+          token: import_nestjs_agent_core24.AGENT_DURABLE_RUNNER,
           optional: true
         }
       ]
     });
   } else {
     providers.push({
-      provide: import_nestjs_agent_core23.AGENT_RUNNER,
+      provide: import_nestjs_agent_core24.AGENT_RUNNER,
       useExisting: InlineAgentRunner
     });
   }
@@ -3713,25 +3943,25 @@ function sharedProviders(durable, includeStore) {
 __name(sharedProviders, "sharedProviders");
 function exportsFor(includeStore) {
   return [
-    import_nestjs_agent_core23.AGENT_OPTIONS,
-    import_nestjs_agent_core23.AGENT_TOOL_REGISTRY,
-    import_nestjs_agent_core23.AGENT_REGISTRY,
-    import_nestjs_agent_core23.AGENT_SINK,
-    import_nestjs_agent_core23.AGENT_ROLES_POLICY,
-    import_nestjs_agent_core23.AGENT_ACTOR_RESOLVER,
-    import_nestjs_agent_core23.AGENT_MODEL,
+    import_nestjs_agent_core24.AGENT_OPTIONS,
+    import_nestjs_agent_core24.AGENT_TOOL_REGISTRY,
+    import_nestjs_agent_core24.AGENT_REGISTRY,
+    import_nestjs_agent_core24.AGENT_SINK,
+    import_nestjs_agent_core24.AGENT_ROLES_POLICY,
+    import_nestjs_agent_core24.AGENT_ACTOR_RESOLVER,
+    import_nestjs_agent_core24.AGENT_MODEL,
     ...includeStore ? [
-      import_nestjs_agent_core23.AGENT_STORE
+      import_nestjs_agent_core24.AGENT_STORE
     ] : [],
-    import_nestjs_agent_core23.AGENT_QUOTA_STORE,
-    import_nestjs_agent_core23.AGENT_PROMPT_CONTRIBUTORS,
-    import_nestjs_agent_core23.AGENT_SKILLS,
-    import_nestjs_agent_core23.AGENT_MEMORY,
-    import_nestjs_agent_core23.AGENT_DEPS_FACTORY,
+    import_nestjs_agent_core24.AGENT_QUOTA_STORE,
+    import_nestjs_agent_core24.AGENT_PROMPT_CONTRIBUTORS,
+    import_nestjs_agent_core24.AGENT_SKILLS,
+    import_nestjs_agent_core24.AGENT_MEMORY,
+    import_nestjs_agent_core24.AGENT_DEPS_FACTORY,
     AgentDepsFactory2,
     AgentService,
     InlineAgentRunner,
-    import_nestjs_agent_core23.AGENT_APPROVAL_PORT
+    import_nestjs_agent_core24.AGENT_APPROVAL_PORT
   ];
 }
 __name(exportsFor, "exportsFor");
@@ -3742,7 +3972,8 @@ var BASE_CONTROLLERS = [
   QuotaController,
   AgentsController,
   SkillsController,
-  MemoriesController
+  MemoriesController,
+  ToolsController
 ];
 var GUARDABLE_CONTROLLERS = [
   ...BASE_CONTROLLERS,
@@ -3800,7 +4031,7 @@ var AgentModule = class _AgentModule {
       controllers: controllersForSurface(options.surface, options.attachments?.upload === true),
       providers: [
         {
-          provide: import_nestjs_agent_core23.AGENT_OPTIONS,
+          provide: import_nestjs_agent_core24.AGENT_OPTIONS,
           useValue: options
         },
         ...sharedProviders(options.durable ?? false, includeStore),
@@ -3824,7 +4055,7 @@ var AgentModule = class _AgentModule {
       controllers: controllersForSurface(options.surface, options.attachmentsUpload === true),
       providers: [
         {
-          provide: import_nestjs_agent_core23.AGENT_OPTIONS,
+          provide: import_nestjs_agent_core24.AGENT_OPTIONS,
           // Stamp the STATIC wiring flags onto the factory result: `durable`/`surface` are
           // authoritative on the async config object (they decided the actual wiring above), and
           // the durable module reads `durable` back off AGENT_OPTIONS. `surface` isn't read back by
@@ -3845,9 +4076,9 @@ var AgentModule = class _AgentModule {
     };
   }
 };
-AgentModule = _ts_decorate20([
-  (0, import_common20.Global)(),
-  (0, import_common20.Module)({})
+AgentModule = _ts_decorate21([
+  (0, import_common21.Global)(),
+  (0, import_common21.Module)({})
 ], AgentModule);
 
 // src/durable/agent-durable.ts