@dudousxd/nestjs-agent 0.13.0 → 1.0.1

package/README.md

@@ -101,6 +101,40 @@ nobody is streaming (including one that has already finished). In-process caller
 authorized elsewhere use `AgentService.subscribe(runId)`; anything reachable from a request must go
 through `AgentService.subscribeAs(actor, runId)`.
 
+### A durable turn's model call and tools run in a worker
+
+Under `durable: true` the turn's model call and each of its tool executions are **dispatched steps**
+(`AgentRunSteps.llm` / `AgentRunSteps.tool`), which is what `ctx.step` means in
+[`@dudousxd/nestjs-durable`](https://davidecarvalho.github.io/aviary/docs/durable): they are routed
+to whichever worker serves those groups, not run in the pod that took the request. There is no
+option to place them anywhere else.
+
+So a `@AiTool` handler is in the same position as any `@Step` handler: it has no caller's execution
+context to inherit. A handler that reaches for a request-scoped ORM EntityManager, an
+AsyncLocalStorage tenant or a CLS transaction must establish that itself — under MikroORM, that is
+`@CreateRequestContext()` (or `@EnsureRequestContext()`) on the handler:
+
+```ts
+@AiTool({ name: 'closeWorkOrder', kind: 'action', description: '…', input: z.object({ id: z.string() }) })
+export class CloseWorkOrderTool implements ToolHandler<{ id: string }> {
+  constructor(private readonly em: EntityManager) {}
+
+  @CreateRequestContext()
+  async execute(input: { id: string }) {
+    /* … */
+  }
+}
+```
+
+A handler that skips it fails inside the worker, and an `action` tool is where that costs most: the
+call is recorded `failed`, the error is handed to the model, the turn completes — and a human's
+approval has been spent on an action that never ran.
+
+Multi-pod fleets also need a cross-process `TokenStreamSink` (e.g.
+`@dudousxd/nestjs-agent/sink-redis`), since the worker writing tokens is generally not the pod
+holding the reader's SSE connection. The default in-process sink logs a warning at boot under
+`durable: true` for exactly this reason.
+
 ### Deploying split API/worker pods
 
 By default `AgentModule`/`AgentDurableModule` wire everything: every controller, the `agent.run`

package/dist/{agent-deps.factory-y2hvoQ6U.d.cts → agent-deps.factory-OjrLyAZo.d.cts}

@@ -140,7 +140,7 @@ interface AgentSkillsOptions {
     /**
      * Which scope tokens an actor draws from, most specific first — the precedence order. Omit → the
      * actor's own (`actor:<id>`), their tenant's (`tenant:<ref>`, when they have one), and `global`.
-     * Supply one to add an axis this library has no key for: a sector, a squadron, a shift.
+     * Supply one to add an axis this library has no key for: a sector, a region, a shift.
      */
     scopes?: ScopeResolver;
     /**
@@ -219,31 +219,20 @@ interface AgentModuleOptions {
     /**
      * Run each turn as a durable workflow instead of in-process. Requires importing
      * `AgentDurableModule` from `@dudousxd/nestjs-agent/durable` and a configured `DurableModule`.
-     */
-    durable?: boolean;
-    /**
-     * Dispatch the turn's model call and tool executions as routed durable steps
-     * (`AgentRunSteps.llm` / `AgentRunSteps.tool`) instead of in-process `ctx.localStep`s. OMITTED
-     * keeps them in-process; `true` without `durable: true` throws at module build.
-     *
-     * WHAT IT BUYS: the run is not pinned to one pod for the two long parts of a turn, so a fleet can
-     * scale the model call and tool execution separately from the workflow itself.
      *
-     * WHY IT IS NOT A DEFAULT. It relocates the HOST's own code. A tool handler no longer runs inside
-     * the turn's workflow body but inside whichever worker serves the routed group, and the `llm`
-     * step re-runs the host's tool-visibility callbacks there to rebuild its tool list. A handler
-     * that resolves anything per invocation from its caller's execution context — a request-scoped
-     * ORM EntityManager, an AsyncLocalStorage tenant, a CLS transaction — finds nothing in that
-     * worker, and the library has no way to know which handlers do that. Turn this on once the tools
-     * this deployment registers establish whatever context they need themselves.
+     * The turn's model call and its tool executions are dispatched steps
+     * (`AgentRunSteps.llm` / `AgentRunSteps.tool`), so a `@AiTool` handler runs in whichever worker
+     * serves the routed group rather than in the pod that took the request. A handler that resolves
+     * anything per invocation from its caller's execution context — a request-scoped ORM
+     * EntityManager, an AsyncLocalStorage tenant, a CLS transaction — must establish that context
+     * itself (`@CreateRequestContext`/`@EnsureRequestContext` under MikroORM), exactly as a `@Step`
+     * handler does.
      *
-     * The cross-process-sink requirement is a property of `durable: true` itself, not of this flag:
-     * the turn already runs on whichever worker takes `agent.run`, which may not be the pod holding
-     * the SSE connection — multi-pod fleets MUST wire a cross-process token sink (e.g. a Redis
-     * pub/sub `TokenStreamSink`) either way. STATIC top-level flag (like `durable`/
-     * `attachments.upload`): it decides how the workflow dispatches at module build time.
+     * Multi-pod fleets MUST also wire a cross-process token sink (e.g. a Redis pub/sub
+     * `TokenStreamSink`): the turn runs on whichever worker takes `agent.run`, which may not be the
+     * pod holding the SSE connection.
      */
-    dispatchedSteps?: boolean;
+    durable?: boolean;
     /**
      * Static functional tools (`{ spec, handler }`, e.g. from `createExecuteSqlTool`) to register at
      * boot. For tools that need DI-resolved dependencies, use `provideAgentTool(factory, inject)` in a
@@ -390,14 +379,6 @@ interface AgentModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
      * the runner. Requires importing `AgentDurableModule` and a configured `DurableModule`.
      */
     durable?: boolean;
-    /**
-     * Dispatch the turn's model call and tool executions as routed durable steps. Omitted keeps the
-     * turn's steps in-process localSteps. Same static-wiring reasoning as `durable` above — it lives
-     * here (not in the async factory result) because it decides how `AgentRunWorkflow` builds its
-     * hooks at module build time. `true` without `durable: true` throws at module build. See
-     * `AgentModuleOptions.dispatchedSteps` for the full contract.
-     */
-    dispatchedSteps?: boolean;
     /**
      * Set when `AGENT_STORE` is bound by a globally-imported store module (e.g.
      * `MikroOrmAgentStoreModule.forFeature()`) instead of returned as `store` from `useFactory`.

package/dist/{agent-deps.factory-y2hvoQ6U.d.ts → agent-deps.factory-OjrLyAZo.d.ts}

@@ -140,7 +140,7 @@ interface AgentSkillsOptions {
     /**
      * Which scope tokens an actor draws from, most specific first — the precedence order. Omit → the
      * actor's own (`actor:<id>`), their tenant's (`tenant:<ref>`, when they have one), and `global`.
-     * Supply one to add an axis this library has no key for: a sector, a squadron, a shift.
+     * Supply one to add an axis this library has no key for: a sector, a region, a shift.
      */
     scopes?: ScopeResolver;
     /**
@@ -219,31 +219,20 @@ interface AgentModuleOptions {
     /**
      * Run each turn as a durable workflow instead of in-process. Requires importing
      * `AgentDurableModule` from `@dudousxd/nestjs-agent/durable` and a configured `DurableModule`.
-     */
-    durable?: boolean;
-    /**
-     * Dispatch the turn's model call and tool executions as routed durable steps
-     * (`AgentRunSteps.llm` / `AgentRunSteps.tool`) instead of in-process `ctx.localStep`s. OMITTED
-     * keeps them in-process; `true` without `durable: true` throws at module build.
-     *
-     * WHAT IT BUYS: the run is not pinned to one pod for the two long parts of a turn, so a fleet can
-     * scale the model call and tool execution separately from the workflow itself.
      *
-     * WHY IT IS NOT A DEFAULT. It relocates the HOST's own code. A tool handler no longer runs inside
-     * the turn's workflow body but inside whichever worker serves the routed group, and the `llm`
-     * step re-runs the host's tool-visibility callbacks there to rebuild its tool list. A handler
-     * that resolves anything per invocation from its caller's execution context — a request-scoped
-     * ORM EntityManager, an AsyncLocalStorage tenant, a CLS transaction — finds nothing in that
-     * worker, and the library has no way to know which handlers do that. Turn this on once the tools
-     * this deployment registers establish whatever context they need themselves.
+     * The turn's model call and its tool executions are dispatched steps
+     * (`AgentRunSteps.llm` / `AgentRunSteps.tool`), so a `@AiTool` handler runs in whichever worker
+     * serves the routed group rather than in the pod that took the request. A handler that resolves
+     * anything per invocation from its caller's execution context — a request-scoped ORM
+     * EntityManager, an AsyncLocalStorage tenant, a CLS transaction — must establish that context
+     * itself (`@CreateRequestContext`/`@EnsureRequestContext` under MikroORM), exactly as a `@Step`
+     * handler does.
      *
-     * The cross-process-sink requirement is a property of `durable: true` itself, not of this flag:
-     * the turn already runs on whichever worker takes `agent.run`, which may not be the pod holding
-     * the SSE connection — multi-pod fleets MUST wire a cross-process token sink (e.g. a Redis
-     * pub/sub `TokenStreamSink`) either way. STATIC top-level flag (like `durable`/
-     * `attachments.upload`): it decides how the workflow dispatches at module build time.
+     * Multi-pod fleets MUST also wire a cross-process token sink (e.g. a Redis pub/sub
+     * `TokenStreamSink`): the turn runs on whichever worker takes `agent.run`, which may not be the
+     * pod holding the SSE connection.
      */
-    dispatchedSteps?: boolean;
+    durable?: boolean;
     /**
      * Static functional tools (`{ spec, handler }`, e.g. from `createExecuteSqlTool`) to register at
      * boot. For tools that need DI-resolved dependencies, use `provideAgentTool(factory, inject)` in a
@@ -390,14 +379,6 @@ interface AgentModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
      * the runner. Requires importing `AgentDurableModule` and a configured `DurableModule`.
      */
     durable?: boolean;
-    /**
-     * Dispatch the turn's model call and tool executions as routed durable steps. Omitted keeps the
-     * turn's steps in-process localSteps. Same static-wiring reasoning as `durable` above — it lives
-     * here (not in the async factory result) because it decides how `AgentRunWorkflow` builds its
-     * hooks at module build time. `true` without `durable: true` throws at module build. See
-     * `AgentModuleOptions.dispatchedSteps` for the full contract.
-     */
-    dispatchedSteps?: boolean;
     /**
      * Set when `AGENT_STORE` is bound by a globally-imported store module (e.g.
      * `MikroOrmAgentStoreModule.forFeature()`) instead of returned as `store` from `useFactory`.

package/dist/durable/index.cjs

@@ -21,7 +21,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/durable/index.ts
 var durable_exports = {};
 __export(durable_exports, {
-  AGENT_DISPATCHED_STEPS: () => AGENT_DISPATCHED_STEPS,
   AgentDurableModule: () => AgentDurableModule,
   AgentRunSteps: () => AgentRunSteps,
   AgentRunWorkflow: () => AgentRunWorkflow,
@@ -190,9 +189,6 @@ AgentRunSteps = _ts_decorate([
   ])
 ], AgentRunSteps);
 
-// src/durable/dispatched-steps.token.ts
-var AGENT_DISPATCHED_STEPS = Symbol.for("@dudousxd/nestjs-agent:dispatched-steps");
-
 // src/durable/agent-run.workflow.ts
 function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -217,12 +213,10 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
   }
   factory;
   store;
-  dispatchedSteps;
   runs;
-  constructor(factory, store, dispatchedSteps, runs) {
+  constructor(factory, store, runs) {
     this.factory = factory;
     this.store = store;
-    this.dispatchedSteps = dispatchedSteps;
     this.runs = runs;
   }
   /**
@@ -275,7 +269,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
   async run(ctx, input) {
     const day = input.day ?? utcDay();
     const deps = this.factory.forAgent(input.agentName);
-    const dispatchSteps = this.dispatchedSteps && await ctx.patched("agent:dispatched-steps");
+    const dispatchSteps = await ctx.patched("agent:dispatched-steps");
     if (input.sinkRunId !== void 0 || input.deliverTo !== void 0) {
       await ctx.localStep("activate", () => this.store.setActiveStream(input.threadId, ctx.runId));
     }
@@ -365,10 +359,11 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
           runId: childRunId
         };
       }, "startAgent"),
-      // Routes the two long steps through AgentRunSteps as engine-dispatched `ctx.step`s instead of
-      // `ctx.localStep`s, so a turn isn't pinned to this workflow worker for the model call or a tool
-      // execution. `sinkRunId`/`childSink` are sink routing this workflow already resolved above —
-      // core's dispatchLlm signature stays sink-topology-agnostic, so we add them here, not in core.
+      // The two long steps as engine-dispatched `ctx.step`s, so a turn isn't pinned to this
+      // workflow worker for the model call or a tool execution. `sinkRunId`/`childSink` are sink
+      // routing this workflow already resolved above — core's dispatchLlm signature stays
+      // sink-topology-agnostic, so we add them here, not in core. Omitted only for a run whose
+      // journal predates dispatch (`dispatchSteps` above), which leaves the loop on `hooks.step`.
       ...dispatchSteps ? {
         dispatchLlm: /* @__PURE__ */ __name((index, envelope) => ctx.step(AgentRunSteps.prototype.llm, {
           ...envelope,
@@ -454,24 +449,92 @@ AgentRunWorkflow = _ts_decorate2([
   }),
   _ts_param2(0, (0, import_common2.Inject)(import_nestjs_agent_core2.AGENT_DEPS_FACTORY)),
   _ts_param2(1, (0, import_common2.Inject)(import_nestjs_agent_core2.AGENT_STORE)),
-  _ts_param2(2, (0, import_common2.Inject)(AGENT_DISPATCHED_STEPS)),
-  _ts_param2(3, (0, import_common2.Optional)()),
-  _ts_param2(3, (0, import_common2.Inject)(import_nestjs_durable2.RUN_GATEWAY)),
+  _ts_param2(2, (0, import_common2.Optional)()),
+  _ts_param2(2, (0, import_common2.Inject)(import_nestjs_durable2.RUN_GATEWAY)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
     typeof AgentStore === "undefined" ? Object : AgentStore,
-    Boolean,
     typeof RunGateway === "undefined" ? Object : RunGateway
   ])
 ], AgentRunWorkflow);
 
 // src/durable/durable-agent-runner.ts
 var import_node_crypto = require("crypto");
-var import_nestjs_agent_core3 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core4 = require("@dudousxd/nestjs-agent-core");
 var import_nestjs_durable3 = require("@dudousxd/nestjs-durable");
 var import_nestjs_durable_core2 = require("@dudousxd/nestjs-durable-core");
 var import_common3 = require("@nestjs/common");
+
+// src/in-process-sink.ts
+var import_nestjs_agent_core3 = require("@dudousxd/nestjs-agent-core");
+var InProcessTokenStreamSink = class {
+  static {
+    __name(this, "InProcessTokenStreamSink");
+  }
+  runs = /* @__PURE__ */ new Map();
+  buffer(runId) {
+    let buf = this.runs.get(runId);
+    if (buf === void 0) {
+      buf = {
+        chunks: [],
+        ended: false,
+        notify: /* @__PURE__ */ new Set()
+      };
+      this.runs.set(runId, buf);
+    }
+    return buf;
+  }
+  wake(buf) {
+    for (const resolve of buf.notify) {
+      resolve();
+    }
+    buf.notify.clear();
+  }
+  open(runId) {
+    const buf = this.buffer(runId);
+    return {
+      write: /* @__PURE__ */ __name((chunk) => {
+        buf.chunks.push(chunk);
+        this.wake(buf);
+      }, "write"),
+      end: /* @__PURE__ */ __name(() => {
+        buf.ended = true;
+        this.wake(buf);
+      }, "end"),
+      fail: /* @__PURE__ */ __name((error) => {
+        buf.failure = error;
+        buf.ended = true;
+        this.wake(buf);
+      }, "fail")
+    };
+  }
+  async *subscribe(runId) {
+    const buf = this.buffer(runId);
+    let index = 0;
+    while (true) {
+      while (index < buf.chunks.length) {
+        const chunk = buf.chunks[index];
+        index += 1;
+        if (chunk !== void 0) {
+          yield chunk;
+        }
+      }
+      if (buf.ended) {
+        if (buf.failure !== void 0) {
+          throw new import_nestjs_agent_core3.AgentStreamError(buf.failure);
+        }
+        return;
+      }
+      await new Promise((resolve) => buf.notify.add(resolve));
+    }
+  }
+  close(runId) {
+    this.runs.delete(runId);
+  }
+};
+
+// src/durable/durable-agent-runner.ts
 function _ts_decorate3(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);
@@ -489,6 +552,13 @@ function _ts_param3(paramIndex, decorator) {
   };
 }
 __name(_ts_param3, "_ts_param");
+function threadOfRun(input) {
+  if (typeof input !== "object" || input === null || !("threadId" in input)) {
+    return void 0;
+  }
+  return typeof input.threadId === "string" ? input.threadId : void 0;
+}
+__name(threadOfRun, "threadOfRun");
 var DurableAgentRunner = class _DurableAgentRunner {
   static {
     __name(this, "DurableAgentRunner");
@@ -503,6 +573,9 @@ var DurableAgentRunner = class _DurableAgentRunner {
     this.runs = runs;
     this.store = store;
     this.sink = sink;
+    if (this.sink instanceof InProcessTokenStreamSink) {
+      this.logger.warn("durable: true with the default InProcessTokenStreamSink, which only buffers tokens in this process. The worker that runs the turn \u2014 and the one that serves its dispatched `llm` step \u2014 cannot stream into this buffer. Wire a cross-process TokenStreamSink (e.g. a Redis pub/sub sink) via AgentModule.forRoot({ sink }) before running multi-pod.");
+    }
   }
   async start(input) {
     const stamped = {
@@ -535,19 +608,30 @@ var DurableAgentRunner = class _DurableAgentRunner {
   * settles the run `cancelled` regardless. The cascade to child runs comes with it.
   *
   * Neither of those settles the agent's own state, so this does: the run row gets its own terminal,
-  * and the subscriber gets a `cancelled` frame followed by a normal end. Both are keyed by runId
-  * alone, which is why they belong here rather than in the body — the body is the only place that
-  * knows which THREAD was streaming, so releasing that stays there (see `AgentRunWorkflow`).
+  * the thread stops reporting a live stream, and the subscriber gets a `cancelled` frame followed
+  * by a normal end.
+  *
+  * The thread is released HERE rather than left to the body, because a cancelled turn is usually
+  * suspended — parked on a human, or on one of the dispatched steps a turn spends most of its life
+  * in — and a suspended body never reaches its own catch: the runtime settles the run from outside
+  * it. The body still releases the thread on the paths where it does unwind (see
+  * `AgentRunWorkflow`); both write the same `null`, and whichever gets there first is right. The
+  * thread id comes off the run's own recorded input, so this holds for a sub-agent's subthread too
+  * — read best-effort, because a gateway that cannot name the thread must not stop the cancel.
   *
   * A tool already executing is not interrupted, here or anywhere: see `haltIfCancelled` in core.
   */
   async cancel(runId) {
     this.logger.log(`cancelling agent run ${runId}`);
+    const threadId = await this.threadOf(runId);
     await this.runs.cancel(runId, {
       compensate: true
     });
+    if (threadId !== void 0) {
+      await this.store.setActiveStream(threadId, null);
+    }
     const writer = await this.sink.open(runId);
-    await writer.write((0, import_nestjs_agent_core3.encodeStreamEvent)({
+    await writer.write((0, import_nestjs_agent_core4.encodeStreamEvent)({
       kind: "cancelled"
     }));
     await writer.end();
@@ -556,12 +640,29 @@ var DurableAgentRunner = class _DurableAgentRunner {
       status: "cancelled"
     });
   }
+  /**
+  * Which thread a run was streaming, or `undefined` where the gateway cannot say.
+  *
+  * A read failure answers `undefined` instead of propagating, the same posture `AgentRunWorkflow`
+  * takes for its own cancel observation: failing to ask is not an answer worth failing a cancel
+  * over. This id is only needed to clear the thread's active stream, and a stream still marked live
+  * is a far smaller fault than the one a throw here would cause — a run nobody ever told to stop,
+  * with a subscriber holding a stream that never settles, from the one call whose entire job is to
+  * make a run stop.
+  */
+  async threadOf(runId) {
+    try {
+      return threadOfRun((await this.runs.getRunDetail(runId))?.run.input);
+    } catch {
+      return void 0;
+    }
+  }
 };
 DurableAgentRunner = _ts_decorate3([
   (0, import_common3.Injectable)(),
   _ts_param3(1, (0, import_common3.Inject)(import_nestjs_durable3.RUN_GATEWAY)),
-  _ts_param3(2, (0, import_common3.Inject)(import_nestjs_agent_core3.AGENT_STORE)),
-  _ts_param3(3, (0, import_common3.Inject)(import_nestjs_agent_core3.AGENT_SINK)),
+  _ts_param3(2, (0, import_common3.Inject)(import_nestjs_agent_core4.AGENT_STORE)),
+  _ts_param3(3, (0, import_common3.Inject)(import_nestjs_agent_core4.AGENT_SINK)),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [
     typeof import_nestjs_durable3.WorkflowService === "undefined" ? Object : import_nestjs_durable3.WorkflowService,
@@ -574,76 +675,6 @@ DurableAgentRunner = _ts_decorate3([
 // src/durable/agent-durable.module.ts
 var import_nestjs_agent_core5 = require("@dudousxd/nestjs-agent-core");
 var import_common4 = require("@nestjs/common");
-
-// src/in-process-sink.ts
-var import_nestjs_agent_core4 = require("@dudousxd/nestjs-agent-core");
-var InProcessTokenStreamSink = class {
-  static {
-    __name(this, "InProcessTokenStreamSink");
-  }
-  runs = /* @__PURE__ */ new Map();
-  buffer(runId) {
-    let buf = this.runs.get(runId);
-    if (buf === void 0) {
-      buf = {
-        chunks: [],
-        ended: false,
-        notify: /* @__PURE__ */ new Set()
-      };
-      this.runs.set(runId, buf);
-    }
-    return buf;
-  }
-  wake(buf) {
-    for (const resolve of buf.notify) {
-      resolve();
-    }
-    buf.notify.clear();
-  }
-  open(runId) {
-    const buf = this.buffer(runId);
-    return {
-      write: /* @__PURE__ */ __name((chunk) => {
-        buf.chunks.push(chunk);
-        this.wake(buf);
-      }, "write"),
-      end: /* @__PURE__ */ __name(() => {
-        buf.ended = true;
-        this.wake(buf);
-      }, "end"),
-      fail: /* @__PURE__ */ __name((error) => {
-        buf.failure = error;
-        buf.ended = true;
-        this.wake(buf);
-      }, "fail")
-    };
-  }
-  async *subscribe(runId) {
-    const buf = this.buffer(runId);
-    let index = 0;
-    while (true) {
-      while (index < buf.chunks.length) {
-        const chunk = buf.chunks[index];
-        index += 1;
-        if (chunk !== void 0) {
-          yield chunk;
-        }
-      }
-      if (buf.ended) {
-        if (buf.failure !== void 0) {
-          throw new import_nestjs_agent_core4.AgentStreamError(buf.failure);
-        }
-        return;
-      }
-      await new Promise((resolve) => buf.notify.add(resolve));
-    }
-  }
-  close(runId) {
-    this.runs.delete(runId);
-  }
-};
-
-// src/durable/agent-durable.module.ts
 function _ts_decorate4(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);
@@ -651,27 +682,12 @@ function _ts_decorate4(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate4, "_ts_decorate");
-var logger = new import_common4.Logger("AgentDurableModule");
 function runnerProviders() {
   return [
     DurableAgentRunner,
     {
       provide: import_nestjs_agent_core5.AGENT_DURABLE_RUNNER,
       useExisting: DurableAgentRunner
-    },
-    {
-      provide: AGENT_DISPATCHED_STEPS,
-      useFactory: /* @__PURE__ */ __name((options, sink) => {
-        const enabled = options.durable === true && options.dispatchedSteps === true;
-        if (enabled && sink instanceof InProcessTokenStreamSink) {
-          logger.warn("dispatchedSteps: true with the default InProcessTokenStreamSink, which only buffers tokens in-process. A dispatched `llm` step served by a different worker cannot stream into this buffer. Wire a cross-process TokenStreamSink (e.g. a Redis pub/sub sink) via AgentModule.forRoot({ sink }) before running multi-pod, or drop dispatchedSteps to keep the turn in-process localSteps.");
-        }
-        return enabled;
-      }, "useFactory"),
-      inject: [
-        import_nestjs_agent_core5.AGENT_OPTIONS,
-        import_nestjs_agent_core5.AGENT_SINK
-      ]
     }
   ];
 }
@@ -690,8 +706,7 @@ AgentDurableHttpModule = _ts_decorate4([
     ],
     exports: [
       import_nestjs_agent_core5.AGENT_DURABLE_RUNNER,
-      AgentRunWorkflow,
-      AGENT_DISPATCHED_STEPS
+      AgentRunWorkflow
     ]
   })
 ], AgentDurableHttpModule);
@@ -731,8 +746,7 @@ AgentDurableModule = _ts_decorate4([
     exports: [
       import_nestjs_agent_core5.AGENT_DURABLE_RUNNER,
       AgentRunWorkflow,
-      AgentRunSteps,
-      AGENT_DISPATCHED_STEPS
+      AgentRunSteps
     ]
   })
 ], AgentDurableModule);
@@ -3590,18 +3604,11 @@ function routerFor(path) {
   ]);
 }
 __name(routerFor, "routerFor");
-function assertDispatchedStepsRequiresDurable(dispatchedSteps, durable) {
-  if (dispatchedSteps && !durable) {
-    throw new Error("AgentModule dispatchedSteps: true requires durable: true \u2014 dispatched steps are routed durable steps (AgentRunSteps.llm/tool) with no in-process equivalent.");
-  }
-}
-__name(assertDispatchedStepsRequiresDurable, "assertDispatchedStepsRequiresDurable");
 var AgentModule = class _AgentModule {
   static {
     __name(this, "AgentModule");
   }
   static forRoot(options) {
-    assertDispatchedStepsRequiresDurable(options.dispatchedSteps ?? false, options.durable ?? false);
     const path = options.path ?? DEFAULT_PATH;
     const includeStore = options.store !== void 0;
     applyGuards(options.guards);
@@ -3625,7 +3632,6 @@ var AgentModule = class _AgentModule {
     };
   }
   static forRootAsync(options) {
-    assertDispatchedStepsRequiresDurable(options.dispatchedSteps ?? false, options.durable ?? false);
     const path = options.path ?? DEFAULT_PATH;
     const includeStore = options.externalStore !== true;
     applyGuards(options.guards);
@@ -3641,20 +3647,16 @@ var AgentModule = class _AgentModule {
       providers: [
         {
           provide: import_nestjs_agent_core23.AGENT_OPTIONS,
-          // Stamp the STATIC wiring flags onto the factory result: `durable`/`dispatchedSteps`/
-          // `surface` are authoritative on the async config object (they decided the actual wiring
-          // above), and `AgentDurableModule` derives the effective dispatched-steps value from
-          // AGENT_OPTIONS — without this stamp, an async host would get in-process localSteps
-          // despite durable: true. `surface` isn't read back by anything today (AgentDurableModule
-          // takes its own mirror option — see its doc for why), but it's stamped here too so the
-          // EFFECTIVE value is always observable off AGENT_OPTIONS, sync or async alike.
+          // 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
+          // anything today (AgentDurableModule takes its own mirror option — see its doc for why),
+          // but it's stamped here too so the EFFECTIVE value is always observable off
+          // AGENT_OPTIONS, sync or async alike.
           useFactory: /* @__PURE__ */ __name(async (...args) => ({
             ...await options.useFactory(...args),
             durable: options.durable ?? false,
-            surface: options.surface ?? "both",
-            ...options.dispatchedSteps !== void 0 ? {
-              dispatchedSteps: options.dispatchedSteps
-            } : {}
+            surface: options.surface ?? "both"
           }), "useFactory"),
           inject: options.inject ?? []
         },
@@ -3685,7 +3687,6 @@ function agentDurable(options) {
 __name(agentDurable, "agentDurable");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AGENT_DISPATCHED_STEPS,
   AgentDurableModule,
   AgentRunSteps,
   AgentRunWorkflow,