@dudousxd/nestjs-agent 1.16.1 → 1.17.1

package/dist/durable/index.cjs

@@ -30,10 +30,10 @@ __export(durable_exports, {
 module.exports = __toCommonJS(durable_exports);
 
 // src/durable/agent-run.workflow.ts
-var import_nestjs_agent_core3 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core2 = require("@dudousxd/nestjs-agent-core");
 var import_nestjs_durable2 = require("@dudousxd/nestjs-durable");
 var import_nestjs_durable_core2 = require("@dudousxd/nestjs-durable-core");
-var import_common3 = require("@nestjs/common");
+var import_common2 = require("@nestjs/common");
 
 // src/agent-deps.ts
 function utcDay(date = /* @__PURE__ */ new Date()) {
@@ -51,9 +51,26 @@ function childSinkWriter(writer) {
 }
 __name(childSinkWriter, "childSinkWriter");
 
-// src/queue/chat-queue.service.ts
+// src/queue/chat-queue.token.ts
+var AGENT_CHAT_QUEUE = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent:chat-queue");
+
+// src/durable/agent-run.steps.ts
 var import_nestjs_agent_core = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_durable = require("@dudousxd/nestjs-durable");
 var import_common = require("@nestjs/common");
+
+// src/durable/outside-workflow-ctx.ts
+var import_nestjs_durable_core = require("@dudousxd/nestjs-durable-core");
+function outsideWorkflowCtx(fn) {
+  return (0, import_nestjs_durable_core.runInWorkflowCtx)(void 0, fn);
+}
+__name(outsideWorkflowCtx, "outsideWorkflowCtx");
+function stepOf(ctx) {
+  return (name, fn, ...rest) => ctx.localStep(name, (...args) => outsideWorkflowCtx(() => fn(...args)), ...rest);
+}
+__name(stepOf, "stepOf");
+
+// src/durable/agent-run.steps.ts
 function _ts_decorate(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") {
@@ -80,736 +97,296 @@ function _ts_param(paramIndex, decorator) {
   };
 }
 __name(_ts_param, "_ts_param");
-var MAX_DRAIN_ATTEMPTS = 8;
-var ChatQueueService = class _ChatQueueService {
+var AgentRunSteps = class {
   static {
-    __name(this, "ChatQueueService");
+    __name(this, "AgentRunSteps");
+  }
+  factory;
+  constructor(factory) {
+    this.factory = factory;
   }
-  store;
-  sink;
-  quotaProvider;
-  options;
-  staging;
-  logger = new import_common.Logger(_ChatQueueService.name);
   /**
-  * Runs this process claimed a thread for and has not handed to a runner yet. A holder in here is
-  * alive whatever the runner says — it simply has not registered the run yet.
+  * Retryable: every side effect (persist/quota/stream markers) happens loop-side under
+  * `hooks.step`, so a durable retry only re-runs the model call and re-streams its tokens — never
+  * double-writes. NEVER call `writer.end()`/`fail()` here: the workflow owns the stream's lifecycle,
+  * across however many turns/retries it takes.
   */
-  starting = /* @__PURE__ */ new Set();
-  constructor(store, sink, quotaProvider, options, staging) {
-    this.store = store;
-    this.sink = sink;
-    this.quotaProvider = quotaProvider;
-    this.options = options;
-    this.staging = staging;
-  }
-  /** Whether the bound store can hold a queue. Without one, a busy thread is not queued. */
-  get supported() {
-    return (0, import_nestjs_agent_core.isChatQueueStore)(this.store);
+  llm(input) {
+    return outsideWorkflowCtx(() => this.runLlm(input));
   }
-  /** The bound store as a queue store, or a 501 naming what is missing. */
-  queueStore() {
-    if (!(0, import_nestjs_agent_core.isChatQueueStore)(this.store)) {
-      throw new import_common.NotImplementedException("Queueing messages requires an AgentStore that implements ChatQueueStore (enqueueMessage, listQueue, \u2026, claimActiveStream, releaseActiveStream); the bound store does not.");
+  async runLlm(input) {
+    const deps = this.factory.forAgent(input.agentName);
+    const tools = (0, import_nestjs_agent_core.withMemoryTool)({
+      tools: (0, import_nestjs_agent_core.withSkillTool)({
+        tools: (0, import_nestjs_agent_core.withAskTool)({
+          tools: await deps.registry.definitionsFor(input.actor, deps.rolesPolicy, deps.toolAllowList, {
+            ...input.threadId !== void 0 ? {
+              threadId: input.threadId
+            } : {},
+            ...input.agentName !== void 0 ? {
+              agentName: input.agentName
+            } : {}
+          }),
+          ask: deps.ask
+        }),
+        enabled: deps.skills !== void 0
+      }),
+      enabled: deps.memory?.provider.write !== void 0
+    });
+    const buffer = input.bufferOutput === true ? (0, import_nestjs_agent_core.createFrameBuffer)() : void 0;
+    let writer;
+    if (buffer !== void 0) {
+      writer = buffer.writer;
+    } else {
+      const opened = await deps.sink.open(input.sinkRunId);
+      writer = input.childSink ? childSinkWriter(opened) : opened;
     }
-    return this.store;
-  }
-  async state(threadId) {
-    const store = this.queueStore();
-    const [items, paused] = await Promise.all([
-      store.listQueue(threadId),
-      store.queuePause(threadId)
-    ]);
-    return {
-      items: items.map(import_nestjs_agent_core.queuedMessageView),
-      paused
+    const frames = (0, import_nestjs_agent_core.observeTurnFrames)(writer);
+    const turn = (0, import_nestjs_agent_core.withTurnFrames)(await (0, import_nestjs_agent_core.traceLlmTurn)(input.runId, input.step, () => deps.model.runTurn({
+      system: input.system,
+      messages: input.messages,
+      tools,
+      sink: frames.writer,
+      ...input.model !== void 0 ? {
+        model: input.model
+      } : {}
+    })), frames.summary());
+    const stamped = (0, import_nestjs_agent_core.stampToolKinds)(turn, deps);
+    return buffer === void 0 ? stamped : {
+      ...stamped,
+      bufferedFrames: buffer.frames()
     };
   }
   /**
-  * Whether `holder` is still running. A run this process is about to start is; otherwise the
-  * runner decides, and a runner that cannot tell says yes.
+  * NO DURABLE retries — a tool may not be idempotent (a bare `@Step()` carries none, unlike `llm`
+  * above). What it does retry, in place, is a CLASSIFIED-TRANSIENT error from the tool's own
+  * invocation (a DB deadlock, a lock-wait timeout — see `isTransientToolError`): the server rolled
+  * that work back, so re-invoking it is safe, and doing it here (inside this one step, never a new
+  * checkpoint) is exactly how the non-dispatched loop path handles it too. The timeout is applied
+  * HERE, handler-side, via `withToolTimeout` — never as a durable dispatch `timeoutMs`, which
+  * bounds engine liveness (retryable) rather than the tool's own business outcome — and per
+  * ATTEMPT, so a retried invocation gets its own fresh timeout window.
   */
-  async isAlive(holder, runner) {
-    if (this.starting.has(holder)) {
-      return true;
-    }
-    if (typeof runner.isRunActive !== "function") {
-      return true;
-    }
-    try {
-      return await runner.isRunActive(holder);
-    } catch {
-      return true;
-    }
+  tool(input) {
+    return outsideWorkflowCtx(() => this.runTool(input));
   }
-  /**
-  * The run holding `threadId`, or `null` when it is free — a holder the runner reports dead counts
-  * as free, and is returned as `stale` so the caller can claim over it.
-  */
-  async holder(threadId, runner) {
-    const holder = await this.queueStore().activeRunForThread(threadId);
-    if (holder === null) {
-      return {
-        live: null,
-        stale: null
-      };
+  async runTool(input) {
+    const deps = this.factory.forAgent(input.ctx.agentName);
+    if (deps.registry.spec(input.toolName)?.kind === "action" && input.toolType !== "action") {
+      throw new Error(`tool "${input.toolName}" is an action tool but was dispatched without approval: the dispatching process resolved its kind against a registry that does not have it`);
     }
-    return await this.isAlive(holder, runner) ? {
-      live: holder,
-      stale: null
-    } : {
-      live: null,
-      stale: holder
+    const sinkRunId = input.sinkRunId;
+    let opened;
+    const ui = (0, import_nestjs_agent_core.createUiCollector)(input.toolCallId, sinkRunId === void 0 ? void 0 : async (event) => {
+      opened ??= Promise.resolve(deps.sink.open(sinkRunId)).then((writer) => input.childSink === true ? childSinkWriter(writer) : writer);
+      await (await opened).write((0, import_nestjs_agent_core.encodeStreamEvent)(event));
+    });
+    const ctx = {
+      ...(0, import_nestjs_agent_core.toolCallContext)(input.ctx, input.toolCallId),
+      emitUi: ui.emit
+    };
+    const localClassify = deps.toolTransientRetry !== false ? deps.toolTransientRetry?.classify : void 0;
+    const transientRetry = input.transientRetry === false ? false : {
+      attempts: input.transientRetry.attempts,
+      backoffMs: input.transientRetry.backoffMs,
+      ...localClassify !== void 0 ? {
+        classify: localClassify
+      } : {}
     };
+    const output = await (0, import_nestjs_agent_core.traceToolExecution)(input.ctx.runId, {
+      toolCallId: input.toolCallId,
+      toolName: input.toolName,
+      toolType: input.toolType
+    }, () => (0, import_nestjs_agent_core.invokeWithTransientRetry)(() => {
+      ui.restart();
+      const invocation = deps.registry.invoke(input.toolName, input.input, ctx, deps.rolesPolicy);
+      return input.timeoutMs !== void 0 ? (0, import_nestjs_agent_core.withToolTimeout)(invocation, input.timeoutMs, input.toolName) : invocation;
+    }, transientRetry, {
+      onRetry: /* @__PURE__ */ __name((attempt, error) => {
+        (0, import_nestjs_agent_core.publishAgentToolRetry)({
+          toolName: input.toolName,
+          toolCallId: input.toolCallId,
+          attempt,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }, "onRetry")
+    }));
+    return input.collectUi === true ? (0, import_nestjs_agent_core.wrapToolStepOutput)(output, ui.components()) : output;
+  }
+};
+_ts_decorate([
+  (0, import_nestjs_durable.Step)({
+    retries: 3
+  }),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DispatchedLlmInput === "undefined" ? Object : DispatchedLlmInput
+  ]),
+  _ts_metadata("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], AgentRunSteps.prototype, "llm", null);
+_ts_decorate([
+  (0, import_nestjs_durable.Step)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DispatchedToolInput === "undefined" ? Object : DispatchedToolInput
+  ]),
+  _ts_metadata("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], AgentRunSteps.prototype, "tool", null);
+AgentRunSteps = _ts_decorate([
+  (0, import_common.Injectable)(),
+  _ts_param(0, (0, import_common.Inject)(import_nestjs_agent_core.AGENT_DEPS_FACTORY)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory
+  ])
+], AgentRunSteps);
+
+// 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;
+  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_decorate2, "_ts_decorate");
+function _ts_metadata2(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var AgentRunWorkflow = class _AgentRunWorkflow {
+  static {
+    __name(this, "AgentRunWorkflow");
+  }
+  factory;
+  store;
+  runs;
+  queue;
+  logger = new import_common2.Logger(_AgentRunWorkflow.name);
+  constructor(factory, store, runs, queue) {
+    this.factory = factory;
+    this.store = store;
+    this.runs = runs;
+    this.queue = queue;
   }
   /**
-  * Decide what follows a TOP-LEVEL run that is settling on `threadId`, and move the thread there:
-  * hand it to the next queued message (claimed and popped here, started by the caller), or pause
-  * the queue, or release the thread. Call it BEFORE the run's terminal frame, so a client reading
-  * the stream learns what comes next from the `queue` frame, and so the thread is already free
-  * when the client sees the run end.
+  * Move the thread past this settling turn — to the next queued message, started here as a
+  * fire-and-forget `ctx.startChild` under the message's own id, or to a paused/empty queue — and
+  * answer the `queue` frame to write before the turn's terminal.
   *
-  * A no-op returning `{}` on a store without a queue.
+  * Journaled: the decision (which message, claimed and popped) is one `localStep`, so a replay
+  * reads it back instead of popping a second message, and the start is the runtime's own
+  * replay-safe spawn. Gated by `ctx.patched`, so a run recorded before the queue existed replays
+  * against the history it has. A no-op for a sub-agent's run and on a store without a queue.
   */
-  async plan(args) {
-    if (!(0, import_nestjs_agent_core.isChatQueueStore)(this.store)) {
-      return {};
+  async advanceQueue(ctx, input, outcome, error) {
+    const queue = this.queue;
+    if (queue === void 0 || !queue.supported || input.sinkRunId !== void 0 || input.deliverTo !== void 0) {
+      return void 0;
     }
-    const store = this.store;
-    const { threadId, outcome } = args;
-    if (await store.activeRunForThread(threadId) !== args.runId) {
-      return {};
+    if (!await ctx.patched("agent:chat-queue")) {
+      return void 0;
     }
-    let holding = args.runId;
-    for (let attempt = 0; attempt < MAX_DRAIN_ATTEMPTS; attempt += 1) {
-      const items = await store.listQueue(threadId);
-      const head = items[0];
-      if (head === void 0) {
-        if (holding !== null) {
-          await store.releaseActiveStream(threadId, holding);
-          holding = null;
-          continue;
-        }
-        return {};
-      }
-      let pause = await store.queuePause(threadId);
-      if (pause === null) {
-        const reason = pauseReasonFor(outcome, head);
-        if (reason !== null) {
-          pause = {
-            reason,
-            ...outcome === "failed" && args.error !== void 0 ? {
-              message: args.error
-            } : {},
-            at: (/* @__PURE__ */ new Date()).toISOString()
-          };
-          await store.setQueuePause(threadId, pause);
-        }
-      }
-      if (pause === null) {
-        const blocked = await this.quotaBlock(head.actor);
-        if (blocked !== null) {
-          pause = {
-            reason: "quota_exceeded",
-            message: blocked,
-            at: (/* @__PURE__ */ new Date()).toISOString()
-          };
-          await store.setQueuePause(threadId, pause);
-        }
-      }
-      if (pause !== null) {
-        if (holding !== null) {
-          await store.releaseActiveStream(threadId, holding);
-        }
-        return {
-          frame: queueFrame(items, pause)
-        };
-      }
-      const claimed = await store.claimActiveStream(threadId, head.id, holding !== null ? {
-        replacing: holding
-      } : {});
-      if (!claimed) {
+    const plan = await stepOf(ctx)(`queue:${outcome}`, async () => {
+      try {
+        const settled = outcome === "completed" && await this.isCancelled(ctx.runId) ? "cancelled" : outcome;
+        return await queue.plan({
+          threadId: input.threadId,
+          runId: ctx.runId,
+          outcome: settled,
+          ...error !== void 0 ? {
+            error
+          } : {}
+        });
+      } catch {
         return {};
       }
-      holding = head.id;
-      if (!await store.removeQueuedMessage(head.id)) {
-        await store.releaseActiveStream(threadId, head.id);
-        holding = null;
-        continue;
-      }
-      const next = {
-        runId: head.id,
-        messageId: head.id,
-        input: await this.inputFor(head)
-      };
-      return {
-        next,
-        frame: queueFrame(items.slice(1), null, {
-          messageId: head.id,
-          runId: head.id
-        })
-      };
-    }
-    if (holding !== null) {
-      await store.releaseActiveStream(threadId, holding);
-    }
-    return {};
-  }
-  /**
-  * {@link plan}, then start what it picked with `start`. What an in-process settle (the inline
-  * runner, a durable cancel issued outside a workflow) calls; answers the frame to write.
-  */
-  async handoff(args, start) {
-    const plan = await this.plan(args);
-    if (plan.next === void 0) {
-      return plan.frame;
-    }
-    return await this.launch(args.threadId, plan.next, start) ? plan.frame : this.pausedFrame(args.threadId);
-  }
-  /**
-  * Start the head of an IDLE thread's queue — after a send queued behind a run that turned out to
-  * be gone, after a resume, after a stale holder. Does nothing while a live run holds the thread
-  * (its settle drains) or while the queue is paused. Answers the started run's id, if any.
-  */
-  async kick(threadId, runner) {
-    if (!(0, import_nestjs_agent_core.isChatQueueStore)(this.store)) {
-      return void 0;
-    }
-    const { live, stale } = await this.holder(threadId, runner);
-    if (live !== null) {
-      return void 0;
-    }
-    if (stale !== null) {
-      this.logger.warn(`thread ${threadId} was held by run ${stale}, which is no longer running`);
-    }
-    const plan = await this.plan({
-      threadId,
-      runId: stale,
-      outcome: "completed"
     });
-    if (plan.next === void 0) {
-      return void 0;
+    const next = plan.next;
+    if (next === void 0) {
+      return plan.frame;
     }
-    const started = await this.launch(threadId, plan.next, (input, runId) => runner.start(input, {
-      runId
-    }));
-    if (started && plan.frame !== void 0) {
-      await this.write(plan.next.runId, plan.frame);
+    try {
+      await ctx.startChild(_AgentRunWorkflow, next.input, next.runId);
+      return plan.frame;
+    } catch (failure) {
+      if ((0, import_nestjs_durable_core2.isWorkflowControlFlowSignal)(failure)) {
+        throw failure;
+      }
+      const reason = failure instanceof Error ? failure.message : String(failure);
+      return stepOf(ctx)("queue:restore", async () => {
+        await queue.restore(input.threadId, next, "start_failed", reason);
+        return queue.pausedFrame(input.threadId);
+      });
     }
-    return started ? plan.next.runId : void 0;
   }
   /**
-  * Start a turn the thread is already claimed for. On failure the message goes back to the head of
-  * the queue, the queue pauses (`start_failed`), and the claim is released — nothing is lost and
-  * nothing is left holding the thread.
+  * Has someone asked this run to stop? Read from the runtime's own run status, which is where
+  * `DurableAgentRunner.cancel` puts it — `cancelling` while a compensating cancel is in flight,
+  * `cancelled` once it has settled.
+  *
+  * Costs a run read at each of the loop's observation points (two per step). That is a row the
+  * control plane already has, against a turn that is otherwise making model calls, and it buys the
+  * property that matters: the answer comes from a place BOTH the canceller and every pod that might
+  * replay this run can see.
+  *
+  * Failing to ask is not a cancel. A tenant with no gateway wired, or an operator briefly
+  * unreachable, answers "no" and the run carries on — the alternative is failing healthy runs
+  * because a status read timed out. The loop journals that answer like any other, so two processes
+  * can never disagree about what was seen here.
   */
-  async launch(threadId, next, start) {
-    this.starting.add(next.runId);
+  async isCancelled(runId) {
     try {
-      await start(next.input, next.runId);
-      return true;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error(`queued message ${next.messageId} could not start: ${message}`);
-      await this.restore(threadId, next, "start_failed", message);
+      const status = (await this.runs?.getRunDetail(runId))?.run.status;
+      return status === "cancelled" || status === "cancelling";
+    } catch {
       return false;
-    } finally {
-      this.starting.delete(next.runId);
     }
   }
-  /** Put a turn that never started back at the head of its queue, paused, and free the thread. */
-  async restore(threadId, next, reason, message) {
-    const store = this.queueStore();
-    const { input } = next;
-    await store.enqueueMessage({
-      threadId,
-      actor: input.actor,
-      content: input.userText,
-      at: "head",
-      ...input.attachments !== void 0 ? {
-        attachments: input.attachments
-      } : {},
-      ...input.agentName !== void 0 ? {
-        agentName: input.agentName
-      } : {},
-      ...input.model !== void 0 ? {
-        model: input.model
-      } : {},
-      ...input.pageContext !== void 0 ? {
-        pageContext: input.pageContext
-      } : {}
-    });
-    await store.setQueuePause(threadId, {
-      reason,
-      message,
-      at: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    await store.releaseActiveStream(threadId, next.runId);
-  }
-  /** A `queue` frame with the thread's current state. */
-  async pausedFrame(threadId) {
-    return {
-      kind: "queue",
-      queue: await this.state(threadId)
-    };
-  }
   /**
-  * Tell whoever is watching the thread that its queue changed: a `queue` frame into the stream of
-  * the run holding it. Best-effort — a thread nobody is streaming has no one to tell, and the next
-  * read of the thread carries the queue anyway.
+  * Settle the delegation a DETACHED run was started for, when that run ends without an answer.
+  *
+  * The loop delivers its own success (`deliver:detached`) but cannot catch its own crash, and the
+  * runtime settles the run row without knowing anything delegated it. Left alone, the card in the
+  * calling conversation says "started" for ever — the one state a reader can neither wait on nor
+  * act on. A no-op for every other run: only a detached one carries a delivery address.
   */
-  async publish(threadId) {
-    const state = await this.state(threadId);
-    const holder = await this.queueStore().activeRunForThread(threadId);
-    if (holder !== null) {
-      await this.write(holder, {
-        kind: "queue",
-        queue: state
-      }).catch((error) => {
-        this.logger.warn(`could not publish the queue of thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
-      });
+  async settleDetachedParent(ctx, input, outcome) {
+    const delivery = input.deliverTo;
+    if (delivery === void 0) {
+      return;
     }
-    return state;
-  }
-  async write(runId, frame) {
-    const writer = await this.sink.open(runId);
-    await writer.write((0, import_nestjs_agent_core.encodeStreamEvent)(frame));
+    await stepOf(ctx)("deliver:detached:unsettled", () => (0, import_nestjs_agent_core2.settleUnsettledDelegation)({
+      store: this.store,
+      delivery,
+      agent: input.agentName ?? "default",
+      runId: ctx.runId,
+      status: outcome.status,
+      ...outcome.error !== void 0 ? {
+        error: outcome.error
+      } : {}
+    }));
   }
-  /** Why `actor` may not start a turn now (the quota message), or `null`. */
-  async quotaBlock(actor) {
-    if (this.options?.quota === void 0 || this.quotaProvider === void 0) {
-      return null;
-    }
-    try {
-      const { blocked } = await this.quotaProvider.report({
-        actor
-      });
-      if (blocked === void 0) {
-        return null;
-      }
-      return blocked.reason ?? `The ${blocked.period === "day" ? "daily" : "monthly"} quota is used up`;
-    } catch {
-      return null;
-    }
-  }
-  /**
-  * The turn a queued message starts: everything it was queued with, today's date, and its
-  * attachments' urls minted afresh — the ones stored at enqueue time may have expired while it
-  * waited. An attachment the staging store no longer resolves keeps its stored url.
-  */
-  async inputFor(message) {
-    const attachments = await this.freshAttachments(message.actor, message.attachments ?? []);
-    return {
-      threadId: message.threadId,
-      actor: message.actor,
-      userText: message.content,
-      day: utcDay(),
-      ...message.agentName !== void 0 ? {
-        agentName: message.agentName
-      } : {},
-      ...attachments.length > 0 ? {
-        attachments
-      } : {},
-      ...message.pageContext !== void 0 ? {
-        pageContext: message.pageContext
-      } : {},
-      ...message.model !== void 0 ? {
-        model: message.model
-      } : {}
-    };
-  }
-  async freshAttachments(actor, attachments) {
-    const staging = this.staging;
-    if (attachments.length === 0 || staging === void 0 || typeof staging.resolve !== "function") {
-      return attachments;
-    }
-    return Promise.all(attachments.map(async (attachment) => {
-      try {
-        return await staging.resolve({
-          mediaId: attachment.mediaId,
-          actor
-        }) ?? attachment;
-      } catch {
-        return attachment;
-      }
-    }));
-  }
-};
-ChatQueueService = _ts_decorate([
-  (0, import_common.Injectable)(),
-  _ts_param(0, (0, import_common.Inject)(import_nestjs_agent_core.AGENT_STORE)),
-  _ts_param(1, (0, import_common.Inject)(import_nestjs_agent_core.AGENT_SINK)),
-  _ts_param(2, (0, import_common.Optional)()),
-  _ts_param(2, (0, import_common.Inject)(import_nestjs_agent_core.AGENT_QUOTA_PROVIDER)),
-  _ts_param(3, (0, import_common.Optional)()),
-  _ts_param(3, (0, import_common.Inject)(import_nestjs_agent_core.AGENT_OPTIONS)),
-  _ts_param(4, (0, import_common.Optional)()),
-  _ts_param(4, (0, import_common.Inject)(import_nestjs_agent_core.AGENT_ATTACHMENT_STAGING)),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof AgentStore === "undefined" ? Object : AgentStore,
-    typeof TokenStreamSink === "undefined" ? Object : TokenStreamSink,
-    typeof QuotaProvider === "undefined" ? Object : QuotaProvider,
-    typeof Pick === "undefined" ? Object : Pick,
-    typeof AttachmentStagingStore === "undefined" ? Object : AttachmentStagingStore
-  ])
-], ChatQueueService);
-function pauseReasonFor(outcome, head) {
-  if (outcome === "failed") {
-    return "run_failed";
-  }
-  if (outcome === "cancelled" && head.interrupt !== true) {
-    return "cancelled";
-  }
-  return null;
-}
-__name(pauseReasonFor, "pauseReasonFor");
-function queueFrame(items, paused, started) {
-  return {
-    kind: "queue",
-    queue: {
-      items: items.map(import_nestjs_agent_core.queuedMessageView),
-      paused
-    },
-    ...started !== void 0 ? {
-      started
-    } : {}
-  };
-}
-__name(queueFrame, "queueFrame");
-
-// src/durable/agent-run.steps.ts
-var import_nestjs_agent_core2 = require("@dudousxd/nestjs-agent-core");
-var import_nestjs_durable = require("@dudousxd/nestjs-durable");
-var import_common2 = require("@nestjs/common");
-
-// src/durable/outside-workflow-ctx.ts
-var import_nestjs_durable_core = require("@dudousxd/nestjs-durable-core");
-function outsideWorkflowCtx(fn) {
-  return (0, import_nestjs_durable_core.runInWorkflowCtx)(void 0, fn);
-}
-__name(outsideWorkflowCtx, "outsideWorkflowCtx");
-function stepOf(ctx) {
-  return (name, fn, ...rest) => ctx.localStep(name, (...args) => outsideWorkflowCtx(() => fn(...args)), ...rest);
-}
-__name(stepOf, "stepOf");
-
-// src/durable/agent-run.steps.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;
-  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_decorate2, "_ts_decorate");
-function _ts_metadata2(metadataKey, metadataValue) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
-    return Reflect.metadata(metadataKey, metadataValue);
-  }
-}
-__name(_ts_metadata2, "_ts_metadata");
-function _ts_param2(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param2, "_ts_param");
-var AgentRunSteps = class {
-  static {
-    __name(this, "AgentRunSteps");
-  }
-  factory;
-  constructor(factory) {
-    this.factory = factory;
-  }
-  /**
-  * Retryable: every side effect (persist/quota/stream markers) happens loop-side under
-  * `hooks.step`, so a durable retry only re-runs the model call and re-streams its tokens — never
-  * double-writes. NEVER call `writer.end()`/`fail()` here: the workflow owns the stream's lifecycle,
-  * across however many turns/retries it takes.
-  */
-  llm(input) {
-    return outsideWorkflowCtx(() => this.runLlm(input));
-  }
-  async runLlm(input) {
-    const deps = this.factory.forAgent(input.agentName);
-    const tools = (0, import_nestjs_agent_core2.withMemoryTool)({
-      tools: (0, import_nestjs_agent_core2.withSkillTool)({
-        tools: (0, import_nestjs_agent_core2.withAskTool)({
-          tools: await deps.registry.definitionsFor(input.actor, deps.rolesPolicy, deps.toolAllowList, {
-            ...input.threadId !== void 0 ? {
-              threadId: input.threadId
-            } : {},
-            ...input.agentName !== void 0 ? {
-              agentName: input.agentName
-            } : {}
-          }),
-          ask: deps.ask
-        }),
-        enabled: deps.skills !== void 0
-      }),
-      enabled: deps.memory?.provider.write !== void 0
-    });
-    const buffer = input.bufferOutput === true ? (0, import_nestjs_agent_core2.createFrameBuffer)() : void 0;
-    let writer;
-    if (buffer !== void 0) {
-      writer = buffer.writer;
-    } else {
-      const opened = await deps.sink.open(input.sinkRunId);
-      writer = input.childSink ? childSinkWriter(opened) : opened;
-    }
-    const frames = (0, import_nestjs_agent_core2.observeTurnFrames)(writer);
-    const turn = (0, import_nestjs_agent_core2.withTurnFrames)(await (0, import_nestjs_agent_core2.traceLlmTurn)(input.runId, input.step, () => deps.model.runTurn({
-      system: input.system,
-      messages: input.messages,
-      tools,
-      sink: frames.writer,
-      ...input.model !== void 0 ? {
-        model: input.model
-      } : {}
-    })), frames.summary());
-    const stamped = (0, import_nestjs_agent_core2.stampToolKinds)(turn, deps);
-    return buffer === void 0 ? stamped : {
-      ...stamped,
-      bufferedFrames: buffer.frames()
-    };
-  }
-  /**
-  * NO DURABLE retries — a tool may not be idempotent (a bare `@Step()` carries none, unlike `llm`
-  * above). What it does retry, in place, is a CLASSIFIED-TRANSIENT error from the tool's own
-  * invocation (a DB deadlock, a lock-wait timeout — see `isTransientToolError`): the server rolled
-  * that work back, so re-invoking it is safe, and doing it here (inside this one step, never a new
-  * checkpoint) is exactly how the non-dispatched loop path handles it too. The timeout is applied
-  * HERE, handler-side, via `withToolTimeout` — never as a durable dispatch `timeoutMs`, which
-  * bounds engine liveness (retryable) rather than the tool's own business outcome — and per
-  * ATTEMPT, so a retried invocation gets its own fresh timeout window.
-  */
-  tool(input) {
-    return outsideWorkflowCtx(() => this.runTool(input));
-  }
-  async runTool(input) {
-    const deps = this.factory.forAgent(input.ctx.agentName);
-    if (deps.registry.spec(input.toolName)?.kind === "action" && input.toolType !== "action") {
-      throw new Error(`tool "${input.toolName}" is an action tool but was dispatched without approval: the dispatching process resolved its kind against a registry that does not have it`);
-    }
-    const sinkRunId = input.sinkRunId;
-    let opened;
-    const ui = (0, import_nestjs_agent_core2.createUiCollector)(input.toolCallId, sinkRunId === void 0 ? void 0 : async (event) => {
-      opened ??= Promise.resolve(deps.sink.open(sinkRunId)).then((writer) => input.childSink === true ? childSinkWriter(writer) : writer);
-      await (await opened).write((0, import_nestjs_agent_core2.encodeStreamEvent)(event));
-    });
-    const ctx = {
-      ...input.ctx,
-      emitUi: ui.emit
-    };
-    const localClassify = deps.toolTransientRetry !== false ? deps.toolTransientRetry?.classify : void 0;
-    const transientRetry = input.transientRetry === false ? false : {
-      attempts: input.transientRetry.attempts,
-      backoffMs: input.transientRetry.backoffMs,
-      ...localClassify !== void 0 ? {
-        classify: localClassify
-      } : {}
-    };
-    const output = await (0, import_nestjs_agent_core2.traceToolExecution)(input.ctx.runId, {
-      toolCallId: input.toolCallId,
-      toolName: input.toolName,
-      toolType: input.toolType
-    }, () => (0, import_nestjs_agent_core2.invokeWithTransientRetry)(() => {
-      ui.restart();
-      const invocation = deps.registry.invoke(input.toolName, input.input, ctx, deps.rolesPolicy);
-      return input.timeoutMs !== void 0 ? (0, import_nestjs_agent_core2.withToolTimeout)(invocation, input.timeoutMs, input.toolName) : invocation;
-    }, transientRetry, {
-      onRetry: /* @__PURE__ */ __name((attempt, error) => {
-        (0, import_nestjs_agent_core2.publishAgentToolRetry)({
-          toolName: input.toolName,
-          toolCallId: input.toolCallId,
-          attempt,
-          message: error instanceof Error ? error.message : String(error)
-        });
-      }, "onRetry")
-    }));
-    return input.collectUi === true ? (0, import_nestjs_agent_core2.wrapToolStepOutput)(output, ui.components()) : output;
-  }
-};
-_ts_decorate2([
-  (0, import_nestjs_durable.Step)({
-    retries: 3
-  }),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    typeof DispatchedLlmInput === "undefined" ? Object : DispatchedLlmInput
-  ]),
-  _ts_metadata2("design:returntype", typeof Promise === "undefined" ? Object : Promise)
-], AgentRunSteps.prototype, "llm", null);
-_ts_decorate2([
-  (0, import_nestjs_durable.Step)(),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    typeof DispatchedToolInput === "undefined" ? Object : DispatchedToolInput
-  ]),
-  _ts_metadata2("design:returntype", typeof Promise === "undefined" ? Object : Promise)
-], AgentRunSteps.prototype, "tool", null);
-AgentRunSteps = _ts_decorate2([
-  (0, import_common2.Injectable)(),
-  _ts_param2(0, (0, import_common2.Inject)(import_nestjs_agent_core2.AGENT_DEPS_FACTORY)),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory
-  ])
-], AgentRunSteps);
-
-// src/durable/agent-run.workflow.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);
-  } 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_decorate3, "_ts_decorate");
-function _ts_metadata3(metadataKey, metadataValue) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
-    return Reflect.metadata(metadataKey, metadataValue);
-  }
-}
-__name(_ts_metadata3, "_ts_metadata");
-function _ts_param3(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param3, "_ts_param");
-var AgentRunWorkflow = class _AgentRunWorkflow {
-  static {
-    __name(this, "AgentRunWorkflow");
-  }
-  factory;
-  store;
-  runs;
-  queue;
-  constructor(factory, store, runs, queue) {
-    this.factory = factory;
-    this.store = store;
-    this.runs = runs;
-    this.queue = queue;
-  }
-  /**
-  * Move the thread past this settling turn — to the next queued message, started here as a
-  * fire-and-forget `ctx.startChild` under the message's own id, or to a paused/empty queue — and
-  * answer the `queue` frame to write before the turn's terminal.
-  *
-  * Journaled: the decision (which message, claimed and popped) is one `localStep`, so a replay
-  * reads it back instead of popping a second message, and the start is the runtime's own
-  * replay-safe spawn. Gated by `ctx.patched`, so a run recorded before the queue existed replays
-  * against the history it has. A no-op for a sub-agent's run and on a store without a queue.
-  */
-  async advanceQueue(ctx, input, outcome, error) {
-    const queue = this.queue;
-    if (queue === void 0 || !queue.supported || input.sinkRunId !== void 0 || input.deliverTo !== void 0) {
-      return void 0;
-    }
-    if (!await ctx.patched("agent:chat-queue")) {
-      return void 0;
-    }
-    const plan = await stepOf(ctx)(`queue:${outcome}`, async () => {
-      try {
-        const settled = outcome === "completed" && await this.isCancelled(ctx.runId) ? "cancelled" : outcome;
-        return await queue.plan({
-          threadId: input.threadId,
-          runId: ctx.runId,
-          outcome: settled,
-          ...error !== void 0 ? {
-            error
-          } : {}
-        });
-      } catch {
-        return {};
-      }
-    });
-    const next = plan.next;
-    if (next === void 0) {
-      return plan.frame;
-    }
-    try {
-      await ctx.startChild(_AgentRunWorkflow, next.input, next.runId);
-      return plan.frame;
-    } catch (failure) {
-      if ((0, import_nestjs_durable_core2.isWorkflowControlFlowSignal)(failure)) {
-        throw failure;
-      }
-      const reason = failure instanceof Error ? failure.message : String(failure);
-      return stepOf(ctx)("queue:restore", async () => {
-        await queue.restore(input.threadId, next, "start_failed", reason);
-        return queue.pausedFrame(input.threadId);
-      });
-    }
-  }
-  /**
-  * Has someone asked this run to stop? Read from the runtime's own run status, which is where
-  * `DurableAgentRunner.cancel` puts it — `cancelling` while a compensating cancel is in flight,
-  * `cancelled` once it has settled.
-  *
-  * Costs a run read at each of the loop's observation points (two per step). That is a row the
-  * control plane already has, against a turn that is otherwise making model calls, and it buys the
-  * property that matters: the answer comes from a place BOTH the canceller and every pod that might
-  * replay this run can see.
-  *
-  * Failing to ask is not a cancel. A tenant with no gateway wired, or an operator briefly
-  * unreachable, answers "no" and the run carries on — the alternative is failing healthy runs
-  * because a status read timed out. The loop journals that answer like any other, so two processes
-  * can never disagree about what was seen here.
-  */
-  async isCancelled(runId) {
-    try {
-      const status = (await this.runs?.getRunDetail(runId))?.run.status;
-      return status === "cancelled" || status === "cancelling";
-    } catch {
-      return false;
-    }
-  }
-  /**
-  * Settle the delegation a DETACHED run was started for, when that run ends without an answer.
-  *
-  * The loop delivers its own success (`deliver:detached`) but cannot catch its own crash, and the
-  * runtime settles the run row without knowing anything delegated it. Left alone, the card in the
-  * calling conversation says "started" for ever — the one state a reader can neither wait on nor
-  * act on. A no-op for every other run: only a detached one carries a delivery address.
-  */
-  async settleDetachedParent(ctx, input, outcome) {
-    const delivery = input.deliverTo;
-    if (delivery === void 0) {
-      return;
-    }
-    await stepOf(ctx)("deliver:detached:unsettled", () => (0, import_nestjs_agent_core3.settleUnsettledDelegation)({
-      store: this.store,
-      delivery,
-      agent: input.agentName ?? "default",
-      runId: ctx.runId,
-      status: outcome.status,
-      ...outcome.error !== void 0 ? {
-        error: outcome.error
-      } : {}
-    }));
-  }
-  async run(ctx, input) {
-    const day = input.day ?? utcDay();
-    const deps = this.factory.forAgent(input.agentName);
-    const dispatchSteps = await ctx.patched("agent:dispatched-steps");
-    if (input.sinkRunId !== void 0 || input.deliverTo !== void 0) {
-      await stepOf(ctx)("activate", () => this.store.setActiveStream(input.threadId, ctx.runId));
+  async run(ctx, input) {
+    const day = input.day ?? utcDay();
+    const deps = this.factory.forAgent(input.agentName);
+    const dispatchSteps = await ctx.patched("agent:dispatched-steps");
+    if (input.sinkRunId !== void 0 || input.deliverTo !== void 0) {
+      await stepOf(ctx)("activate", () => this.store.setActiveStream(input.threadId, ctx.runId));
     }
     const sinkRunId = input.sinkRunId ?? ctx.runId;
     const chainBelow = [
@@ -834,7 +411,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
           end: /* @__PURE__ */ __name(async () => {
             const frame = await this.advanceQueue(ctx, input, "completed");
             if (frame !== void 0) {
-              await writer.write((0, import_nestjs_agent_core3.encodeStreamEvent)(frame));
+              await writer.write((0, import_nestjs_agent_core2.encodeStreamEvent)(frame));
             }
             await writer.end();
           }, "end")
@@ -866,7 +443,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       // await, so launching a batch in one tick — what `settleAll` does — fixes the block of
       // positions in call order however the tools then settle. `ctx.patched` keeps a run that
       // recorded the one-call-at-a-time shape replaying against that shape.
-      parallel: import_nestjs_agent_core3.settleAll,
+      parallel: import_nestjs_agent_core2.settleAll,
       cancelled: /* @__PURE__ */ __name(() => this.isCancelled(ctx.runId), "cancelled"),
       patched: /* @__PURE__ */ __name((id) => ctx.patched(id), "patched"),
       // Dispatched-step suspends must escape the loop's tool catch — control flow, not a tool
@@ -960,167 +537,457 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       } : {}
     };
     try {
-      const result = await (0, import_nestjs_agent_core3.runAgentLoop)({
+      const result = await (0, import_nestjs_agent_core2.runAgentLoop)({
         ...deps,
         day
       }, input, hooks);
-      await stepOf(ctx)("deactivate", () => (0, import_nestjs_agent_core3.releaseThreadRun)(this.store, input.threadId, ctx.runId));
+      await stepOf(ctx)("deactivate", () => (0, import_nestjs_agent_core2.releaseThreadRun)(this.store, input.threadId, ctx.runId));
       return result;
     } catch (error) {
       if ((0, import_nestjs_durable_core2.isWorkflowControlFlowSignal)(error)) {
         throw error;
       }
-      if (error instanceof import_nestjs_agent_core3.RunCancelledError) {
-        await stepOf(ctx)("deactivate", () => (0, import_nestjs_agent_core3.releaseThreadRun)(this.store, input.threadId, ctx.runId));
+      if (error instanceof import_nestjs_agent_core2.RunCancelledError) {
+        await stepOf(ctx)("deactivate", () => (0, import_nestjs_agent_core2.releaseThreadRun)(this.store, input.threadId, ctx.runId));
         await this.settleDetachedParent(ctx, input, {
           status: "cancelled"
         });
         throw error;
       }
-      if ((0, import_nestjs_agent_core3.isReplayIntegrityError)(error)) {
-        const failure = {
-          code: "run_failed",
-          message: error.message
-        };
-        (0, import_nestjs_agent_core3.publishAgentRunFailed)({
+      if ((0, import_nestjs_agent_core2.isReplayIntegrityError)(error)) {
+        const detail = error.message;
+        const code2 = (0, import_nestjs_agent_core2.agentFailureCode)(error);
+        this.logger.error(`agent run ${ctx.runId} failed (${code2}): ${detail}`);
+        (0, import_nestjs_agent_core2.publishAgentRunFailed)({
+          runId: ctx.runId,
+          code: code2,
+          message: detail
+        });
+        await (0, import_nestjs_agent_core2.settleDeadRun)(this.store, {
           runId: ctx.runId,
-          ...failure
+          threadId: input.threadId,
+          failure: {
+            code: code2,
+            message: detail
+          }
         });
-        await (await hooks.openSink()).fail(failure);
+        await (await hooks.openSink()).fail((0, import_nestjs_agent_core2.streamFailure)(error));
         throw error;
       }
       const message = error instanceof Error ? error.message : String(error);
-      const code = (0, import_nestjs_agent_core3.agentFailureCode)(error);
-      (0, import_nestjs_agent_core3.publishAgentRunFailed)({
+      const code = (0, import_nestjs_agent_core2.agentFailureCode)(error);
+      this.logger.error(`agent run ${ctx.runId} failed (${code}): ${message}`);
+      (0, import_nestjs_agent_core2.publishAgentRunFailed)({
         runId: ctx.runId,
         code,
         message
       });
-      await stepOf(ctx)("persist:run:fail", () => this.store.recordRunEnd?.({
-        runId: ctx.runId,
-        status: "failed",
-        errorCode: code,
-        errorMessage: message
-      }) ?? Promise.resolve());
+      await stepOf(ctx)("persist:run:fail", async () => {
+        await this.store.recordRunEnd?.({
+          runId: ctx.runId,
+          status: "failed",
+          errorCode: code,
+          errorMessage: message
+        });
+        await Promise.resolve(this.store.failUnsettledToolCalls?.(ctx.runId, import_nestjs_agent_core2.RUN_ENDED_BEFORE_TOOL_CALL)).catch(() => 0);
+      });
       const queueFrame2 = await this.advanceQueue(ctx, input, "failed", message);
-      await stepOf(ctx)("deactivate", () => (0, import_nestjs_agent_core3.releaseThreadRun)(this.store, input.threadId, ctx.runId));
+      await stepOf(ctx)("deactivate", () => (0, import_nestjs_agent_core2.releaseThreadRun)(this.store, input.threadId, ctx.runId));
       await this.settleDetachedParent(ctx, input, {
         status: "failed",
         error: message
       });
       const writer = await hooks.openSink();
       if (queueFrame2 !== void 0) {
-        await writer.write((0, import_nestjs_agent_core3.encodeStreamEvent)(queueFrame2));
+        await writer.write((0, import_nestjs_agent_core2.encodeStreamEvent)(queueFrame2));
+      }
+      await writer.fail((0, import_nestjs_agent_core2.streamFailure)(error));
+      throw error;
+    }
+  }
+};
+AgentRunWorkflow = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  (0, import_nestjs_durable2.Workflow)({
+    name: "agent.run",
+    version: "1"
+  }),
+  _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.Optional)()),
+  _ts_param2(2, (0, import_common2.Inject)(import_nestjs_durable2.RUN_GATEWAY)),
+  _ts_param2(3, (0, import_common2.Optional)()),
+  _ts_param2(3, (0, import_common2.Inject)(AGENT_CHAT_QUEUE)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
+    typeof AgentStore === "undefined" ? Object : AgentStore,
+    typeof RunGateway === "undefined" ? Object : RunGateway,
+    typeof ChatQueueService === "undefined" ? Object : ChatQueueService
+  ])
+], 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");
+var import_nestjs_agent_core4 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_durable3 = require("@dudousxd/nestjs-durable");
+var import_nestjs_durable_core3 = 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);
+  } 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_decorate3, "_ts_decorate");
+function _ts_metadata3(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__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");
+function isThreadTurn(input) {
+  return typeof input === "object" && input !== null && input.sinkRunId === void 0 && input.deliverTo === void 0;
+}
+__name(isThreadTurn, "isThreadTurn");
+var DurableAgentRunner = class _DurableAgentRunner {
+  static {
+    __name(this, "DurableAgentRunner");
+  }
+  workflows;
+  runs;
+  store;
+  sink;
+  queue;
+  logger = new import_common3.Logger(_DurableAgentRunner.name);
+  constructor(workflows, runs, store, sink, queue) {
+    this.workflows = workflows;
+    this.runs = runs;
+    this.store = store;
+    this.sink = sink;
+    this.queue = queue;
+    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, options = {}) {
+    const stamped = {
+      ...input,
+      day: input.day ?? utcDay()
+    };
+    const runId = options.runId ?? (0, import_node_crypto.randomUUID)();
+    try {
+      await this.workflows.start(AgentRunWorkflow, stamped, runId);
+    } catch (error) {
+      if (!(0, import_nestjs_durable_core3.isWorkflowControlFlowSignal)(error)) {
+        throw error;
+      }
+    }
+    return {
+      runId
+    };
+  }
+  /**
+  * From the runtime's own run row. A run it does not know yet counts as running — a queued turn is
+  * claimed before its `startChild` lands — and so does one it cannot be asked about: only a run the
+  * runtime reports settled (`completed`/`failed`/`cancelled`/`dead`) is stale.
+  */
+  async isRunActive(runId) {
+    try {
+      const status = (await this.runs.getRunDetail(runId))?.run.status;
+      return !(status === "completed" || status === "failed" || status === "cancelled" || status === "dead");
+    } catch {
+      return true;
+    }
+  }
+  async signal(runId, toolCallId2, reply) {
+    await this.workflows.signal(`tool:${runId}:${toolCallId2}`, reply);
+  }
+  /**
+  * Stop a run, and settle what the durable runtime knows nothing about.
+  *
+  * `compensate: true` is the form that gives the BODY a chance: it moves the run to `cancelling`
+  * (which is what the workflow's own cancel observation reads) and then re-drives it, so a turn
+  * running in-process unwinds at its next safe point instead of finishing. It also guarantees the
+  * outcome for the turn that CANNOT observe anything — one parked on `waitForSignal`, suspended
+  * inside a position its journal already holds — because that re-drive re-suspends and the runtime
+  * 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,
+  * 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 input = await this.inputOf(runId);
+    const threadId = threadOfRun(input);
+    await this.runs.cancel(runId, {
+      compensate: true
+    });
+    const writer = await this.sink.open(runId);
+    if (threadId !== void 0) {
+      if (this.queue?.supported === true && isThreadTurn(input)) {
+        try {
+          const frame = await this.queue.handoff({
+            threadId,
+            runId,
+            outcome: "cancelled"
+          }, (next, nextRunId) => this.start(next, {
+            runId: nextRunId
+          }));
+          if (frame !== void 0) {
+            await writer.write((0, import_nestjs_agent_core4.encodeStreamEvent)(frame));
+          }
+        } catch (error) {
+          this.logger.error(`could not advance the queue of thread ${threadId} after cancelling ${runId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
       }
-      await writer.fail({
-        code,
-        message
-      });
-      throw error;
+      await (0, import_nestjs_agent_core4.releaseThreadRun)(this.store, threadId, runId);
+    }
+    await writer.write((0, import_nestjs_agent_core4.encodeStreamEvent)({
+      kind: "cancelled"
+    }));
+    await writer.end();
+    await this.store.recordRunEnd?.({
+      runId,
+      status: "cancelled"
+    });
+  }
+  /**
+  * The input a run was started with (which thread it 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 inputOf(runId) {
+    try {
+      return (await this.runs.getRunDetail(runId))?.run.input;
+    } catch {
+      return void 0;
     }
   }
 };
-AgentRunWorkflow = _ts_decorate3([
+DurableAgentRunner = _ts_decorate3([
   (0, import_common3.Injectable)(),
-  (0, import_nestjs_durable2.Workflow)({
-    name: "agent.run",
-    version: "1"
-  }),
-  _ts_param3(0, (0, import_common3.Inject)(import_nestjs_agent_core3.AGENT_DEPS_FACTORY)),
-  _ts_param3(1, (0, import_common3.Inject)(import_nestjs_agent_core3.AGENT_STORE)),
-  _ts_param3(2, (0, import_common3.Optional)()),
-  _ts_param3(2, (0, import_common3.Inject)(import_nestjs_durable2.RUN_GATEWAY)),
-  _ts_param3(3, (0, import_common3.Optional)()),
+  _ts_param3(1, (0, import_common3.Inject)(import_nestjs_durable3.RUN_GATEWAY)),
+  _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_param3(4, (0, import_common3.Optional)()),
+  _ts_param3(4, (0, import_common3.Inject)(AGENT_CHAT_QUEUE)),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [
-    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
-    typeof AgentStore === "undefined" ? Object : AgentStore,
+    typeof import_nestjs_durable3.WorkflowService === "undefined" ? Object : import_nestjs_durable3.WorkflowService,
     typeof RunGateway === "undefined" ? Object : RunGateway,
+    typeof AgentStore === "undefined" ? Object : AgentStore,
+    typeof TokenStreamSink === "undefined" ? Object : TokenStreamSink,
     typeof ChatQueueService === "undefined" ? Object : ChatQueueService
   ])
-], AgentRunWorkflow);
-function isSignalTimeout(error) {
-  return error instanceof Error && error.name === "SignalTimeoutError";
-}
-__name(isSignalTimeout, "isSignalTimeout");
+], DurableAgentRunner);
 
-// src/durable/durable-agent-runner.ts
-var import_node_crypto = require("crypto");
+// src/durable/agent-durable.module.ts
 var import_nestjs_agent_core5 = require("@dudousxd/nestjs-agent-core");
-var import_nestjs_durable3 = require("@dudousxd/nestjs-durable");
-var import_nestjs_durable_core3 = require("@dudousxd/nestjs-durable-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);
+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);
+  } 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 buf;
   }
-  wake(buf) {
-    for (const resolve of buf.notify) {
-      resolve();
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function runnerProviders() {
+  return [
+    DurableAgentRunner,
+    {
+      provide: import_nestjs_agent_core5.AGENT_DURABLE_RUNNER,
+      useExisting: DurableAgentRunner
     }
-    buf.notify.clear();
+  ];
+}
+__name(runnerProviders, "runnerProviders");
+var AgentDurableHttpModule = class AgentDurableHttpModule2 {
+  static {
+    __name(this, "AgentDurableHttpModule");
   }
-  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")
-    };
+};
+AgentDurableHttpModule = _ts_decorate4([
+  (0, import_common4.Global)(),
+  (0, import_common4.Module)({
+    providers: [
+      AgentRunWorkflow,
+      ...runnerProviders()
+    ],
+    exports: [
+      import_nestjs_agent_core5.AGENT_DURABLE_RUNNER,
+      AgentRunWorkflow
+    ]
+  })
+], AgentDurableHttpModule);
+var AgentDurableModule = class _AgentDurableModule {
+  static {
+    __name(this, "AgentDurableModule");
   }
-  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));
+  /**
+  * `surface: 'http'` returns the reduced `AgentDurableHttpModule` wiring (no `AgentRunSteps`);
+  * everything else (omitted, `'engine'`, `'both'`) returns this module's own full wiring — the
+  * class's `@Module` providers above merge in regardless of which DynamicModule shape a caller
+  * imports (Nest merges a class's static provider list with whatever a self-referencing
+  * `DynamicModule` adds), which is exactly why the reduced case has to be a DIFFERENT module class
+  * rather than a conditional subset of this one's own decorator.
+  */
+  static forRoot(options) {
+    if (options?.surface === "http") {
+      return {
+        module: AgentDurableHttpModule,
+        global: true
+      };
     }
-  }
-  close(runId) {
-    this.runs.delete(runId);
+    return {
+      module: _AgentDurableModule,
+      global: true
+    };
   }
 };
+AgentDurableModule = _ts_decorate4([
+  (0, import_common4.Global)(),
+  (0, import_common4.Module)({
+    providers: [
+      AgentRunWorkflow,
+      AgentRunSteps,
+      ...runnerProviders()
+    ],
+    exports: [
+      import_nestjs_agent_core5.AGENT_DURABLE_RUNNER,
+      AgentRunWorkflow,
+      AgentRunSteps
+    ]
+  })
+], AgentDurableModule);
 
-// src/durable/durable-agent-runner.ts
-function _ts_decorate4(decorators, target, key, desc) {
+// src/agent.module.ts
+var import_nestjs_agent_core31 = require("@dudousxd/nestjs-agent-core");
+var import_common27 = require("@nestjs/common");
+var import_core4 = require("@nestjs/core");
+
+// src/agent-deps.factory.ts
+var import_nestjs_agent_core6 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core7 = require("@dudousxd/nestjs-agent-core");
+var import_common5 = require("@nestjs/common");
+function _ts_decorate5(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);
@@ -1133,7 +1000,7 @@ function _ts_decorate4(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate4, "_ts_decorate");
+__name(_ts_decorate5, "_ts_decorate");
 function _ts_metadata4(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
@@ -1146,168 +1013,242 @@ function _ts_param4(paramIndex, decorator) {
   };
 }
 __name(_ts_param4, "_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");
-function isThreadTurn(input) {
-  return typeof input === "object" && input !== null && input.sinkRunId === void 0 && input.deliverTo === void 0;
+function delegateToolName(args) {
+  const slug = args.target.replace(/[^a-zA-Z0-9]+/g, "_");
+  return args.detached === true ? `start_${slug}` : `ask_${slug}`;
 }
-__name(isThreadTurn, "isThreadTurn");
-var DurableAgentRunner = class _DurableAgentRunner {
+__name(delegateToolName, "delegateToolName");
+var AgentDepsFactory2 = class {
   static {
-    __name(this, "DurableAgentRunner");
+    __name(this, "AgentDepsFactory");
   }
-  workflows;
-  runs;
+  options;
+  model;
   store;
   sink;
-  queue;
-  logger = new import_common4.Logger(_DurableAgentRunner.name);
-  constructor(workflows, runs, store, sink, queue) {
-    this.workflows = workflows;
-    this.runs = runs;
+  rolesPolicy;
+  registry;
+  agents;
+  promptContributors;
+  pricingStore;
+  skills;
+  memory;
+  constructor(options, model, store, sink, rolesPolicy, registry, agents, promptContributors, pricingStore, skills, memory) {
+    this.options = options;
+    this.model = model;
     this.store = store;
     this.sink = sink;
-    this.queue = queue;
-    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.");
-    }
+    this.rolesPolicy = rolesPolicy;
+    this.registry = registry;
+    this.agents = agents;
+    this.promptContributors = promptContributors;
+    this.pricingStore = pricingStore;
+    this.skills = skills;
+    this.memory = memory;
   }
-  async start(input, options = {}) {
-    const stamped = {
-      ...input,
-      day: input.day ?? utcDay()
-    };
-    const runId = options.runId ?? (0, import_node_crypto.randomUUID)();
-    try {
-      await this.workflows.start(AgentRunWorkflow, stamped, runId);
-    } catch (error) {
-      if (!(0, import_nestjs_durable_core3.isWorkflowControlFlowSignal)(error)) {
-        throw error;
-      }
-    }
-    return {
-      runId
-    };
+  /** The turn's memory seam, shared with the read-back endpoint. Undefined → memory is not configured. */
+  memoryConfig() {
+    return this.memory;
+  }
+  /** The turn's skills seam, shared with the listing endpoint. Undefined → skills are not configured. */
+  skillsConfig() {
+    return this.skills;
   }
   /**
-  * From the runtime's own run row. A run it does not know yet counts as running — a queued turn is
-  * claimed before its `startChild` lands — and so does one it cannot be asked about: only a run the
-  * runtime reports settled (`completed`/`failed`/`cancelled`/`dead`) is stale.
+  * The agent a turn uses when the caller names none: the explicit `defaultAgent` option, else the
+  * sole registered `@Agent` when there is exactly one, else `'default'` (a bare assistant).
   */
-  async isRunActive(runId) {
-    try {
-      const status = (await this.runs.getRunDetail(runId))?.run.status;
-      return !(status === "completed" || status === "failed" || status === "cancelled" || status === "dead");
-    } catch {
-      return true;
+  defaultAgentName() {
+    if (this.options.defaultAgent !== void 0) {
+      return this.options.defaultAgent;
     }
+    const registered = this.agents.list();
+    return registered.length === 1 ? registered[0]?.name ?? "default" : "default";
   }
-  async signal(runId, toolCallId2, reply) {
-    await this.workflows.signal(`tool:${runId}:${toolCallId2}`, reply);
-  }
-  /**
-  * Stop a run, and settle what the durable runtime knows nothing about.
-  *
-  * `compensate: true` is the form that gives the BODY a chance: it moves the run to `cancelling`
-  * (which is what the workflow's own cancel observation reads) and then re-drives it, so a turn
-  * running in-process unwinds at its next safe point instead of finishing. It also guarantees the
-  * outcome for the turn that CANNOT observe anything — one parked on `waitForSignal`, suspended
-  * inside a position its journal already holds — because that re-drive re-suspends and the runtime
-  * 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,
-  * 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 input = await this.inputOf(runId);
-    const threadId = threadOfRun(input);
-    await this.runs.cancel(runId, {
-      compensate: true
-    });
-    const writer = await this.sink.open(runId);
-    if (threadId !== void 0) {
-      if (this.queue?.supported === true && isThreadTurn(input)) {
-        try {
-          const frame = await this.queue.handoff({
-            threadId,
-            runId,
-            outcome: "cancelled"
-          }, (next, nextRunId) => this.start(next, {
-            runId: nextRunId
-          }));
-          if (frame !== void 0) {
-            await writer.write((0, import_nestjs_agent_core5.encodeStreamEvent)(frame));
-          }
-        } catch (error) {
-          this.logger.error(`could not advance the queue of thread ${threadId} after cancelling ${runId}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-      }
-      await (0, import_nestjs_agent_core5.releaseThreadRun)(this.store, threadId, runId);
+  effectiveTools(definition) {
+    if (definition === void 0) {
+      return void 0;
     }
-    await writer.write((0, import_nestjs_agent_core5.encodeStreamEvent)({
-      kind: "cancelled"
-    }));
-    await writer.end();
-    await this.store.recordRunEnd?.({
-      runId,
-      status: "cancelled"
+    const delegated = (definition.delegatesTo ?? []).map((edge) => {
+      const { agent, detached } = (0, import_nestjs_agent_core6.normalizeDelegation)(edge);
+      return delegateToolName({
+        target: agent,
+        detached
+      });
     });
+    if (definition.tools === void 0 && delegated.length === 0) {
+      return void 0;
+    }
+    return [
+      ...definition.tools ?? [],
+      ...delegated
+    ];
+  }
+  forAgent(agentName) {
+    const name = agentName ?? this.defaultAgentName();
+    const definition = this.agents.get(name);
+    const toolAllowList = this.effectiveTools(definition);
+    const followUpsCount = this.followUpsCount();
+    const retrieval = this.options.retrieval;
+    const historyPolicy = this.historyPolicy(definition);
+    const ask = definition?.ask ?? this.options.ask;
+    return {
+      model: this.model,
+      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 ?? this.options.systemPrompt ?? "You are a helpful assistant.",
+      maxSteps: definition?.maxSteps ?? 8,
+      ...definition?.maxDelegationDepth !== void 0 ? {
+        maxDelegationDepth: definition.maxDelegationDepth
+      } : {},
+      ...definition?.maxAgentAppearances !== void 0 ? {
+        maxAgentAppearances: definition.maxAgentAppearances
+      } : {},
+      ...definition?.modelId !== void 0 ? {
+        modelId: definition.modelId
+      } : {},
+      ...this.pricingStore !== void 0 ? {
+        pricingStore: this.pricingStore
+      } : {},
+      ...historyPolicy !== void 0 ? {
+        historyPolicy
+      } : {},
+      inputProcessors: this.options.inputProcessors ?? [],
+      outputProcessors: this.options.outputProcessors ?? [],
+      ...definition?.outputSchema !== void 0 ? {
+        outputSchema: definition.outputSchema
+      } : {},
+      ...definition?.outputRepairAttempts !== void 0 ? {
+        outputRepairAttempts: definition.outputRepairAttempts
+      } : {},
+      ...definition?.intake !== void 0 ? {
+        intake: definition.intake
+      } : {},
+      // Most specific wins, exactly as `historyPolicy` resolves: the agent's own `@Agent({ ask })`,
+      // else the module-wide flag. Both are module config, so every process of a deployment agrees.
+      ...ask === true ? {
+        ask: true
+      } : {},
+      // Module-wide, never per-agent: a skill is a procedure, not a persona, and an agent that could
+      // opt out of one would make the catalog depend on which agent a turn happened to select — a
+      // per-turn fact the worker re-deriving the tool list cannot see.
+      ...this.skills !== void 0 ? {
+        skills: this.skills
+      } : {},
+      // Module-wide, never per-agent, for the same reason skills are: which memories a turn carries
+      // cannot depend on which persona answered it, or the worker re-deriving a dispatched turn's
+      // tool list would disagree with the loop about whether `remember` was offered.
+      ...this.memory !== void 0 ? {
+        memory: this.memory
+      } : {},
+      ...toolAllowList !== void 0 ? {
+        toolAllowList
+      } : {},
+      ...this.options.toolTimeoutMs !== void 0 ? {
+        toolTimeoutMs: this.options.toolTimeoutMs
+      } : {},
+      ...this.options.toolTransientRetry !== void 0 ? {
+        toolTransientRetry: this.options.toolTransientRetry
+      } : {},
+      ...followUpsCount !== void 0 ? {
+        followUpsCount
+      } : {},
+      ...retrieval?.mode === "inject" ? {
+        retriever: retrieval.retriever,
+        ...retrieval.topK !== void 0 ? {
+          retrievalTopK: retrieval.topK
+        } : {}
+      } : {}
+    };
   }
   /**
-  * The input a run was started with (which thread it 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.
+  * The ceiling on how much of a thread this agent's turns carry, most specific wins: the agent's
+  * own `@Agent({ history })`, else a module-wide custom `historyPolicy`, else the module-wide
+  * `history` window. Undefined → unbounded, the behaviour of a module that configures none.
   */
-  async inputOf(runId) {
-    try {
-      return (await this.runs.getRunDetail(runId))?.run.input;
-    } catch {
-      return void 0;
+  historyPolicy(definition) {
+    if (definition?.history !== void 0) {
+      return this.window(definition.history);
+    }
+    if (this.options.historyPolicy !== void 0) {
+      return this.options.historyPolicy;
+    }
+    return this.options.history === void 0 ? void 0 : this.window(this.options.history);
+  }
+  /** Build the built-in window policy from the declarative `{ maxMessages, maxTokens, summarize }`. */
+  window(config) {
+    return (0, import_nestjs_agent_core6.windowHistory)({
+      ...config.maxMessages !== void 0 ? {
+        maxMessages: config.maxMessages
+      } : {},
+      ...config.maxTokens !== void 0 ? {
+        maxTokens: config.maxTokens
+      } : {},
+      // The shared module model, not a per-agent one: an agent's `modelId` is an accounting label,
+      // and only one provider is ever bound.
+      ...config.summarize === true ? {
+        summarize: (0, import_nestjs_agent_core6.summarizeWithModel)(this.model)
+      } : {}
+    });
+  }
+  /** Normalize the `followUps` option (`true` → 3, `{ count }` → count) to a number, or undefined. */
+  followUpsCount() {
+    const followUps = this.options.followUps;
+    if (followUps === true) {
+      return 3;
+    }
+    if (typeof followUps === "object") {
+      return followUps.count;
     }
+    return void 0;
   }
 };
-DurableAgentRunner = _ts_decorate4([
-  (0, import_common4.Injectable)(),
-  _ts_param4(1, (0, import_common4.Inject)(import_nestjs_durable3.RUN_GATEWAY)),
-  _ts_param4(2, (0, import_common4.Inject)(import_nestjs_agent_core5.AGENT_STORE)),
-  _ts_param4(3, (0, import_common4.Inject)(import_nestjs_agent_core5.AGENT_SINK)),
-  _ts_param4(4, (0, import_common4.Optional)()),
+AgentDepsFactory2 = _ts_decorate5([
+  (0, import_common5.Injectable)(),
+  _ts_param4(0, (0, import_common5.Inject)(import_nestjs_agent_core7.AGENT_OPTIONS)),
+  _ts_param4(1, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_MODEL)),
+  _ts_param4(2, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_STORE)),
+  _ts_param4(3, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_SINK)),
+  _ts_param4(4, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_ROLES_POLICY)),
+  _ts_param4(5, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_TOOL_REGISTRY)),
+  _ts_param4(6, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_REGISTRY)),
+  _ts_param4(7, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_PROMPT_CONTRIBUTORS)),
+  _ts_param4(8, (0, import_common5.Optional)()),
+  _ts_param4(8, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_PRICING_STORE)),
+  _ts_param4(9, (0, import_common5.Optional)()),
+  _ts_param4(9, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_SKILLS)),
+  _ts_param4(10, (0, import_common5.Optional)()),
+  _ts_param4(10, (0, import_common5.Inject)(import_nestjs_agent_core6.AGENT_MEMORY)),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
-    typeof import_nestjs_durable3.WorkflowService === "undefined" ? Object : import_nestjs_durable3.WorkflowService,
-    typeof RunGateway === "undefined" ? Object : RunGateway,
+    typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions,
+    typeof ModelProvider === "undefined" ? Object : ModelProvider,
     typeof AgentStore === "undefined" ? Object : AgentStore,
     typeof TokenStreamSink === "undefined" ? Object : TokenStreamSink,
-    typeof ChatQueueService === "undefined" ? Object : ChatQueueService
+    typeof RolesPolicy === "undefined" ? Object : RolesPolicy,
+    typeof import_nestjs_agent_core6.ToolRegistry === "undefined" ? Object : import_nestjs_agent_core6.ToolRegistry,
+    typeof import_nestjs_agent_core6.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core6.AgentRegistry,
+    Array,
+    Object,
+    Object,
+    Object
   ])
-], DurableAgentRunner);
+], AgentDepsFactory2);
 
-// src/durable/agent-durable.module.ts
-var import_nestjs_agent_core6 = require("@dudousxd/nestjs-agent-core");
-var import_common5 = require("@nestjs/common");
-function _ts_decorate5(decorators, target, key, desc) {
+// src/agent.service.ts
+var import_nestjs_agent_core10 = require("@dudousxd/nestjs-agent-core");
+var import_common8 = require("@nestjs/common");
+
+// src/queue/chat-queue.service.ts
+var import_nestjs_agent_core8 = require("@dudousxd/nestjs-agent-core");
+var import_common6 = require("@nestjs/common");
+function _ts_decorate6(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);
@@ -1320,342 +1261,436 @@ function _ts_decorate5(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate5, "_ts_decorate");
-function runnerProviders() {
-  return [
-    DurableAgentRunner,
-    {
-      provide: import_nestjs_agent_core6.AGENT_DURABLE_RUNNER,
-      useExisting: DurableAgentRunner
-    }
-  ];
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata5(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
 }
-__name(runnerProviders, "runnerProviders");
-var AgentDurableHttpModule = class AgentDurableHttpModule2 {
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var MAX_DRAIN_ATTEMPTS = 8;
+var ChatQueueService2 = class _ChatQueueService {
   static {
-    __name(this, "AgentDurableHttpModule");
+    __name(this, "ChatQueueService");
   }
-};
-AgentDurableHttpModule = _ts_decorate5([
-  (0, import_common5.Global)(),
-  (0, import_common5.Module)({
-    providers: [
-      AgentRunWorkflow,
-      ...runnerProviders()
-    ],
-    exports: [
-      import_nestjs_agent_core6.AGENT_DURABLE_RUNNER,
-      AgentRunWorkflow
-    ]
-  })
-], AgentDurableHttpModule);
-var AgentDurableModule = class _AgentDurableModule {
-  static {
-    __name(this, "AgentDurableModule");
+  store;
+  sink;
+  quotaProvider;
+  options;
+  staging;
+  logger = new import_common6.Logger(_ChatQueueService.name);
+  /**
+  * Runs this process claimed a thread for and has not handed to a runner yet. A holder in here is
+  * alive whatever the runner says — it simply has not registered the run yet.
+  */
+  starting = /* @__PURE__ */ new Set();
+  constructor(store, sink, quotaProvider, options, staging) {
+    this.store = store;
+    this.sink = sink;
+    this.quotaProvider = quotaProvider;
+    this.options = options;
+    this.staging = staging;
+  }
+  /** Whether the bound store can hold a queue. Without one, a busy thread is not queued. */
+  get supported() {
+    return (0, import_nestjs_agent_core8.isChatQueueStore)(this.store);
+  }
+  /** The bound store as a queue store, or a 501 naming what is missing. */
+  queueStore() {
+    if (!(0, import_nestjs_agent_core8.isChatQueueStore)(this.store)) {
+      throw new import_common6.NotImplementedException("Queueing messages requires an AgentStore that implements ChatQueueStore (enqueueMessage, listQueue, \u2026, claimActiveStream, releaseActiveStream); the bound store does not.");
+    }
+    return this.store;
+  }
+  async state(threadId) {
+    const store = this.queueStore();
+    const [items, paused] = await Promise.all([
+      store.listQueue(threadId),
+      store.queuePause(threadId)
+    ]);
+    return {
+      items: items.map(import_nestjs_agent_core8.queuedMessageView),
+      paused
+    };
   }
   /**
-  * `surface: 'http'` returns the reduced `AgentDurableHttpModule` wiring (no `AgentRunSteps`);
-  * everything else (omitted, `'engine'`, `'both'`) returns this module's own full wiring — the
-  * class's `@Module` providers above merge in regardless of which DynamicModule shape a caller
-  * imports (Nest merges a class's static provider list with whatever a self-referencing
-  * `DynamicModule` adds), which is exactly why the reduced case has to be a DIFFERENT module class
-  * rather than a conditional subset of this one's own decorator.
+  * Whether `holder` is still running. A run this process is about to start is; otherwise the
+  * runner decides, and a runner that cannot tell says yes.
   */
-  static forRoot(options) {
-    if (options?.surface === "http") {
+  async isAlive(holder, runner) {
+    if (this.starting.has(holder)) {
+      return true;
+    }
+    if (typeof runner.isRunActive !== "function") {
+      return true;
+    }
+    try {
+      return await runner.isRunActive(holder);
+    } catch {
+      return true;
+    }
+  }
+  /**
+  * The run holding `threadId`, or `null` when it is free — a holder the runner reports dead counts
+  * as free, and is returned as `stale` so the caller can claim over it.
+  */
+  async holder(threadId, runner) {
+    const holder = await this.queueStore().activeRunForThread(threadId);
+    if (holder === null) {
       return {
-        module: AgentDurableHttpModule,
-        global: true
+        live: null,
+        stale: null
       };
     }
-    return {
-      module: _AgentDurableModule,
-      global: true
+    return await this.isAlive(holder, runner) ? {
+      live: holder,
+      stale: null
+    } : {
+      live: null,
+      stale: holder
     };
   }
-};
-AgentDurableModule = _ts_decorate5([
-  (0, import_common5.Global)(),
-  (0, import_common5.Module)({
-    providers: [
-      AgentRunWorkflow,
-      AgentRunSteps,
-      ...runnerProviders()
-    ],
-    exports: [
-      import_nestjs_agent_core6.AGENT_DURABLE_RUNNER,
-      AgentRunWorkflow,
-      AgentRunSteps
-    ]
-  })
-], AgentDurableModule);
-
-// src/agent.module.ts
-var import_nestjs_agent_core30 = require("@dudousxd/nestjs-agent-core");
-var import_common26 = require("@nestjs/common");
-var import_core4 = require("@nestjs/core");
-
-// src/agent-deps.factory.ts
-var import_nestjs_agent_core7 = require("@dudousxd/nestjs-agent-core");
-var import_nestjs_agent_core8 = require("@dudousxd/nestjs-agent-core");
-var import_common6 = require("@nestjs/common");
-function _ts_decorate6(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;
+  /**
+  * Decide what follows a TOP-LEVEL run that is settling on `threadId`, and move the thread there:
+  * hand it to the next queued message (claimed and popped here, started by the caller), or pause
+  * the queue, or release the thread. Call it BEFORE the run's terminal frame, so a client reading
+  * the stream learns what comes next from the `queue` frame, and so the thread is already free
+  * when the client sees the run end.
+  *
+  * A no-op returning `{}` on a store without a queue.
+  */
+  async plan(args) {
+    if (!(0, import_nestjs_agent_core8.isChatQueueStore)(this.store)) {
+      return {};
+    }
+    const store = this.store;
+    const { threadId, outcome } = args;
+    if (await store.activeRunForThread(threadId) !== args.runId) {
+      return {};
+    }
+    let holding = args.runId;
+    for (let attempt = 0; attempt < MAX_DRAIN_ATTEMPTS; attempt += 1) {
+      const items = await store.listQueue(threadId);
+      const head = items[0];
+      if (head === void 0) {
+        if (holding !== null) {
+          await store.releaseActiveStream(threadId, holding);
+          holding = null;
+          continue;
+        }
+        return {};
+      }
+      let pause = await store.queuePause(threadId);
+      if (pause === null) {
+        const reason = pauseReasonFor(outcome, head);
+        if (reason !== null) {
+          pause = {
+            reason,
+            ...outcome === "failed" && args.error !== void 0 ? {
+              message: args.error
+            } : {},
+            at: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          await store.setQueuePause(threadId, pause);
+        }
+      }
+      if (pause === null) {
+        const blocked = await this.quotaBlock(head.actor);
+        if (blocked !== null) {
+          pause = {
+            reason: "quota_exceeded",
+            message: blocked,
+            at: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          await store.setQueuePause(threadId, pause);
+        }
+      }
+      if (pause !== null) {
+        if (holding !== null) {
+          await store.releaseActiveStream(threadId, holding);
+        }
+        return {
+          frame: queueFrame(items, pause)
+        };
+      }
+      const claimed = await store.claimActiveStream(threadId, head.id, holding !== null ? {
+        replacing: holding
+      } : {});
+      if (!claimed) {
+        return {};
+      }
+      holding = head.id;
+      if (!await store.removeQueuedMessage(head.id)) {
+        await store.releaseActiveStream(threadId, head.id);
+        holding = null;
+        continue;
       }
+      const next = {
+        runId: head.id,
+        messageId: head.id,
+        input: await this.inputFor(head)
+      };
+      return {
+        next,
+        frame: queueFrame(items.slice(1), null, {
+          messageId: head.id,
+          runId: head.id
+        })
+      };
     }
-  }
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate6, "_ts_decorate");
-function _ts_metadata5(metadataKey, metadataValue) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
-    return Reflect.metadata(metadataKey, metadataValue);
-  }
-}
-__name(_ts_metadata5, "_ts_metadata");
-function _ts_param5(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param5, "_ts_param");
-function delegateToolName(args) {
-  const slug = args.target.replace(/[^a-zA-Z0-9]+/g, "_");
-  return args.detached === true ? `start_${slug}` : `ask_${slug}`;
-}
-__name(delegateToolName, "delegateToolName");
-var AgentDepsFactory2 = class {
-  static {
-    __name(this, "AgentDepsFactory");
-  }
-  options;
-  model;
-  store;
-  sink;
-  rolesPolicy;
-  registry;
-  agents;
-  promptContributors;
-  pricingStore;
-  skills;
-  memory;
-  constructor(options, model, store, sink, rolesPolicy, registry, agents, promptContributors, pricingStore, skills, memory) {
-    this.options = options;
-    this.model = model;
-    this.store = store;
-    this.sink = sink;
-    this.rolesPolicy = rolesPolicy;
-    this.registry = registry;
-    this.agents = agents;
-    this.promptContributors = promptContributors;
-    this.pricingStore = pricingStore;
-    this.skills = skills;
-    this.memory = memory;
-  }
-  /** The turn's memory seam, shared with the read-back endpoint. Undefined → memory is not configured. */
-  memoryConfig() {
-    return this.memory;
-  }
-  /** The turn's skills seam, shared with the listing endpoint. Undefined → skills are not configured. */
-  skillsConfig() {
-    return this.skills;
+    if (holding !== null) {
+      await store.releaseActiveStream(threadId, holding);
+    }
+    return {};
   }
   /**
-  * The agent a turn uses when the caller names none: the explicit `defaultAgent` option, else the
-  * sole registered `@Agent` when there is exactly one, else `'default'` (a bare assistant).
+  * {@link plan}, then start what it picked with `start`. What an in-process settle (the inline
+  * runner, a durable cancel issued outside a workflow) calls; answers the frame to write.
   */
-  defaultAgentName() {
-    if (this.options.defaultAgent !== void 0) {
-      return this.options.defaultAgent;
+  async handoff(args, start) {
+    const plan = await this.plan(args);
+    if (plan.next === void 0) {
+      return plan.frame;
     }
-    const registered = this.agents.list();
-    return registered.length === 1 ? registered[0]?.name ?? "default" : "default";
+    return await this.launch(args.threadId, plan.next, start) ? plan.frame : this.pausedFrame(args.threadId);
   }
-  effectiveTools(definition) {
-    if (definition === void 0) {
+  /**
+  * Start the head of an IDLE thread's queue — after a send queued behind a run that turned out to
+  * be gone, after a resume, after a stale holder. Does nothing while a live run holds the thread
+  * (its settle drains) or while the queue is paused. Answers the started run's id, if any.
+  */
+  async kick(threadId, runner) {
+    if (!(0, import_nestjs_agent_core8.isChatQueueStore)(this.store)) {
       return void 0;
     }
-    const delegated = (definition.delegatesTo ?? []).map((edge) => {
-      const { agent, detached } = (0, import_nestjs_agent_core7.normalizeDelegation)(edge);
-      return delegateToolName({
-        target: agent,
-        detached
-      });
+    const { live, stale } = await this.holder(threadId, runner);
+    if (live !== null) {
+      return void 0;
+    }
+    if (stale !== null) {
+      this.logger.warn(`thread ${threadId} was held by run ${stale}, which is no longer running`);
+    }
+    const plan = await this.plan({
+      threadId,
+      runId: stale,
+      outcome: "completed"
     });
-    if (definition.tools === void 0 && delegated.length === 0) {
+    if (plan.next === void 0) {
       return void 0;
     }
-    return [
-      ...definition.tools ?? [],
-      ...delegated
-    ];
+    const started = await this.launch(threadId, plan.next, (input, runId) => runner.start(input, {
+      runId
+    }));
+    if (started && plan.frame !== void 0) {
+      await this.write(plan.next.runId, plan.frame);
+    }
+    return started ? plan.next.runId : void 0;
   }
-  forAgent(agentName) {
-    const name = agentName ?? this.defaultAgentName();
-    const definition = this.agents.get(name);
-    const toolAllowList = this.effectiveTools(definition);
-    const followUpsCount = this.followUpsCount();
-    const retrieval = this.options.retrieval;
-    const historyPolicy = this.historyPolicy(definition);
-    const ask = definition?.ask ?? this.options.ask;
-    return {
-      model: this.model,
-      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 ?? this.options.systemPrompt ?? "You are a helpful assistant.",
-      maxSteps: definition?.maxSteps ?? 8,
-      ...definition?.maxDelegationDepth !== void 0 ? {
-        maxDelegationDepth: definition.maxDelegationDepth
-      } : {},
-      ...definition?.maxAgentAppearances !== void 0 ? {
-        maxAgentAppearances: definition.maxAgentAppearances
-      } : {},
-      ...definition?.modelId !== void 0 ? {
-        modelId: definition.modelId
-      } : {},
-      ...this.pricingStore !== void 0 ? {
-        pricingStore: this.pricingStore
-      } : {},
-      ...historyPolicy !== void 0 ? {
-        historyPolicy
-      } : {},
-      inputProcessors: this.options.inputProcessors ?? [],
-      outputProcessors: this.options.outputProcessors ?? [],
-      ...definition?.outputSchema !== void 0 ? {
-        outputSchema: definition.outputSchema
-      } : {},
-      ...definition?.outputRepairAttempts !== void 0 ? {
-        outputRepairAttempts: definition.outputRepairAttempts
-      } : {},
-      ...definition?.intake !== void 0 ? {
-        intake: definition.intake
-      } : {},
-      // Most specific wins, exactly as `historyPolicy` resolves: the agent's own `@Agent({ ask })`,
-      // else the module-wide flag. Both are module config, so every process of a deployment agrees.
-      ...ask === true ? {
-        ask: true
-      } : {},
-      // Module-wide, never per-agent: a skill is a procedure, not a persona, and an agent that could
-      // opt out of one would make the catalog depend on which agent a turn happened to select — a
-      // per-turn fact the worker re-deriving the tool list cannot see.
-      ...this.skills !== void 0 ? {
-        skills: this.skills
-      } : {},
-      // Module-wide, never per-agent, for the same reason skills are: which memories a turn carries
-      // cannot depend on which persona answered it, or the worker re-deriving a dispatched turn's
-      // tool list would disagree with the loop about whether `remember` was offered.
-      ...this.memory !== void 0 ? {
-        memory: this.memory
-      } : {},
-      ...toolAllowList !== void 0 ? {
-        toolAllowList
-      } : {},
-      ...this.options.toolTimeoutMs !== void 0 ? {
-        toolTimeoutMs: this.options.toolTimeoutMs
+  /**
+  * Start a turn the thread is already claimed for. On failure the message goes back to the head of
+  * the queue, the queue pauses (`start_failed`), and the claim is released — nothing is lost and
+  * nothing is left holding the thread.
+  */
+  async launch(threadId, next, start) {
+    this.starting.add(next.runId);
+    try {
+      await start(next.input, next.runId);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`queued message ${next.messageId} could not start: ${message}`);
+      await this.restore(threadId, next, "start_failed", message);
+      return false;
+    } finally {
+      this.starting.delete(next.runId);
+    }
+  }
+  /** Put a turn that never started back at the head of its queue, paused, and free the thread. */
+  async restore(threadId, next, reason, message) {
+    const store = this.queueStore();
+    const { input } = next;
+    await store.enqueueMessage({
+      threadId,
+      actor: input.actor,
+      content: input.userText,
+      at: "head",
+      ...input.attachments !== void 0 ? {
+        attachments: input.attachments
       } : {},
-      ...this.options.toolTransientRetry !== void 0 ? {
-        toolTransientRetry: this.options.toolTransientRetry
+      ...input.agentName !== void 0 ? {
+        agentName: input.agentName
       } : {},
-      ...followUpsCount !== void 0 ? {
-        followUpsCount
+      ...input.model !== void 0 ? {
+        model: input.model
       } : {},
-      ...retrieval?.mode === "inject" ? {
-        retriever: retrieval.retriever,
-        ...retrieval.topK !== void 0 ? {
-          retrievalTopK: retrieval.topK
-        } : {}
+      ...input.pageContext !== void 0 ? {
+        pageContext: input.pageContext
       } : {}
+    });
+    await store.setQueuePause(threadId, {
+      reason,
+      message,
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await store.releaseActiveStream(threadId, next.runId);
+  }
+  /** A `queue` frame with the thread's current state. */
+  async pausedFrame(threadId) {
+    return {
+      kind: "queue",
+      queue: await this.state(threadId)
     };
   }
   /**
-  * The ceiling on how much of a thread this agent's turns carry, most specific wins: the agent's
-  * own `@Agent({ history })`, else a module-wide custom `historyPolicy`, else the module-wide
-  * `history` window. Undefined → unbounded, the behaviour of a module that configures none.
+  * Tell whoever is watching the thread that its queue changed: a `queue` frame into the stream of
+  * the run holding it. Best-effort — a thread nobody is streaming has no one to tell, and the next
+  * read of the thread carries the queue anyway.
   */
-  historyPolicy(definition) {
-    if (definition?.history !== void 0) {
-      return this.window(definition.history);
+  async publish(threadId) {
+    const state = await this.state(threadId);
+    const holder = await this.queueStore().activeRunForThread(threadId);
+    if (holder !== null) {
+      await this.write(holder, {
+        kind: "queue",
+        queue: state
+      }).catch((error) => {
+        this.logger.warn(`could not publish the queue of thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
+      });
     }
-    if (this.options.historyPolicy !== void 0) {
-      return this.options.historyPolicy;
+    return state;
+  }
+  async write(runId, frame) {
+    const writer = await this.sink.open(runId);
+    await writer.write((0, import_nestjs_agent_core8.encodeStreamEvent)(frame));
+  }
+  /** Why `actor` may not start a turn now (the quota message), or `null`. */
+  async quotaBlock(actor) {
+    if (this.options?.quota === void 0 || this.quotaProvider === void 0) {
+      return null;
+    }
+    try {
+      const { blocked } = await this.quotaProvider.report({
+        actor
+      });
+      if (blocked === void 0) {
+        return null;
+      }
+      return blocked.reason ?? `The ${blocked.period === "day" ? "daily" : "monthly"} quota is used up`;
+    } catch {
+      return null;
     }
-    return this.options.history === void 0 ? void 0 : this.window(this.options.history);
   }
-  /** Build the built-in window policy from the declarative `{ maxMessages, maxTokens, summarize }`. */
-  window(config) {
-    return (0, import_nestjs_agent_core7.windowHistory)({
-      ...config.maxMessages !== void 0 ? {
-        maxMessages: config.maxMessages
+  /**
+  * The turn a queued message starts: everything it was queued with, today's date, and its
+  * attachments' urls minted afresh — the ones stored at enqueue time may have expired while it
+  * waited. An attachment the staging store no longer resolves keeps its stored url.
+  */
+  async inputFor(message) {
+    const attachments = await this.freshAttachments(message.actor, message.attachments ?? []);
+    return {
+      threadId: message.threadId,
+      actor: message.actor,
+      userText: message.content,
+      day: utcDay(),
+      ...message.agentName !== void 0 ? {
+        agentName: message.agentName
       } : {},
-      ...config.maxTokens !== void 0 ? {
-        maxTokens: config.maxTokens
+      ...attachments.length > 0 ? {
+        attachments
       } : {},
-      // The shared module model, not a per-agent one: an agent's `modelId` is an accounting label,
-      // and only one provider is ever bound.
-      ...config.summarize === true ? {
-        summarize: (0, import_nestjs_agent_core7.summarizeWithModel)(this.model)
+      ...message.pageContext !== void 0 ? {
+        pageContext: message.pageContext
+      } : {},
+      ...message.model !== void 0 ? {
+        model: message.model
       } : {}
-    });
+    };
   }
-  /** Normalize the `followUps` option (`true` → 3, `{ count }` → count) to a number, or undefined. */
-  followUpsCount() {
-    const followUps = this.options.followUps;
-    if (followUps === true) {
-      return 3;
-    }
-    if (typeof followUps === "object") {
-      return followUps.count;
+  async freshAttachments(actor, attachments) {
+    const staging = this.staging;
+    if (attachments.length === 0 || staging === void 0 || typeof staging.resolve !== "function") {
+      return attachments;
     }
-    return void 0;
+    return Promise.all(attachments.map(async (attachment) => {
+      try {
+        return await staging.resolve({
+          mediaId: attachment.mediaId,
+          actor
+        }) ?? attachment;
+      } catch {
+        return attachment;
+      }
+    }));
   }
 };
-AgentDepsFactory2 = _ts_decorate6([
+ChatQueueService2 = _ts_decorate6([
   (0, import_common6.Injectable)(),
-  _ts_param5(0, (0, import_common6.Inject)(import_nestjs_agent_core8.AGENT_OPTIONS)),
-  _ts_param5(1, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_MODEL)),
-  _ts_param5(2, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_STORE)),
-  _ts_param5(3, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_SINK)),
-  _ts_param5(4, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_ROLES_POLICY)),
-  _ts_param5(5, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_TOOL_REGISTRY)),
-  _ts_param5(6, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_REGISTRY)),
-  _ts_param5(7, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_PROMPT_CONTRIBUTORS)),
-  _ts_param5(8, (0, import_common6.Optional)()),
-  _ts_param5(8, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_PRICING_STORE)),
-  _ts_param5(9, (0, import_common6.Optional)()),
-  _ts_param5(9, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_SKILLS)),
-  _ts_param5(10, (0, import_common6.Optional)()),
-  _ts_param5(10, (0, import_common6.Inject)(import_nestjs_agent_core7.AGENT_MEMORY)),
+  _ts_param5(0, (0, import_common6.Inject)(import_nestjs_agent_core8.AGENT_STORE)),
+  _ts_param5(1, (0, import_common6.Inject)(import_nestjs_agent_core8.AGENT_SINK)),
+  _ts_param5(2, (0, import_common6.Optional)()),
+  _ts_param5(2, (0, import_common6.Inject)(import_nestjs_agent_core8.AGENT_QUOTA_PROVIDER)),
+  _ts_param5(3, (0, import_common6.Optional)()),
+  _ts_param5(3, (0, import_common6.Inject)(import_nestjs_agent_core8.AGENT_OPTIONS)),
+  _ts_param5(4, (0, import_common6.Optional)()),
+  _ts_param5(4, (0, import_common6.Inject)(import_nestjs_agent_core8.AGENT_ATTACHMENT_STAGING)),
   _ts_metadata5("design:type", Function),
   _ts_metadata5("design:paramtypes", [
-    typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions,
-    typeof ModelProvider === "undefined" ? Object : ModelProvider,
     typeof AgentStore === "undefined" ? Object : AgentStore,
     typeof TokenStreamSink === "undefined" ? Object : TokenStreamSink,
-    typeof RolesPolicy === "undefined" ? Object : RolesPolicy,
-    typeof import_nestjs_agent_core7.ToolRegistry === "undefined" ? Object : import_nestjs_agent_core7.ToolRegistry,
-    typeof import_nestjs_agent_core7.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core7.AgentRegistry,
-    Array,
-    Object,
-    Object,
-    Object
+    typeof QuotaProvider === "undefined" ? Object : QuotaProvider,
+    typeof Pick === "undefined" ? Object : Pick,
+    typeof AttachmentStagingStore === "undefined" ? Object : AttachmentStagingStore
   ])
-], AgentDepsFactory2);
+], ChatQueueService2);
+function pauseReasonFor(outcome, head) {
+  if (outcome === "failed") {
+    return "run_failed";
+  }
+  if (outcome === "cancelled" && head.interrupt !== true) {
+    return "cancelled";
+  }
+  return null;
+}
+__name(pauseReasonFor, "pauseReasonFor");
+function queueFrame(items, paused, started) {
+  return {
+    kind: "queue",
+    queue: {
+      items: items.map(import_nestjs_agent_core8.queuedMessageView),
+      paused
+    },
+    ...started !== void 0 ? {
+      started
+    } : {}
+  };
+}
+__name(queueFrame, "queueFrame");
 
-// src/agent.service.ts
+// src/run-not-active.exception.ts
 var import_nestjs_agent_core9 = require("@dudousxd/nestjs-agent-core");
 var import_common7 = require("@nestjs/common");
+var RunNotActiveException = class extends import_common7.ConflictException {
+  static {
+    __name(this, "RunNotActiveException");
+  }
+  runId;
+  code = import_nestjs_agent_core9.RUN_NOT_ACTIVE_CODE;
+  constructor(runId) {
+    super({
+      statusCode: 409,
+      code: import_nestjs_agent_core9.RUN_NOT_ACTIVE_CODE,
+      message: import_nestjs_agent_core9.RUN_NOT_ACTIVE_MESSAGE
+    }), this.runId = runId;
+  }
+};
+
+// src/agent.service.ts
 function _ts_decorate7(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") {
@@ -1712,7 +1747,7 @@ var AgentService = class {
   requireQueue() {
     const queue = this.queueing();
     if (queue === void 0) {
-      throw new import_common7.NotImplementedException("Queueing messages requires an AgentStore that implements ChatQueueStore; the bound store does not.");
+      throw new import_common8.NotImplementedException("Queueing messages requires an AgentStore that implements ChatQueueStore; the bound store does not.");
     }
     return queue;
   }
@@ -1749,12 +1784,12 @@ var AgentService = class {
       actor
     });
     if (blocked !== void 0) {
-      throw new import_common7.HttpException({
-        statusCode: import_common7.HttpStatus.TOO_MANY_REQUESTS,
+      throw new import_common8.HttpException({
+        statusCode: import_common8.HttpStatus.TOO_MANY_REQUESTS,
         code: "quota_exceeded",
         period: blocked.period,
         message: blocked.reason ?? `The ${blocked.period === "day" ? "daily" : "monthly"} quota is used up`
-      }, import_common7.HttpStatus.TOO_MANY_REQUESTS);
+      }, import_common8.HttpStatus.TOO_MANY_REQUESTS);
     }
   }
   /**
@@ -1782,17 +1817,17 @@ var AgentService = class {
   */
   async assertModelAllowed(actor, agent, model) {
     if (this.models === void 0) {
-      throw new import_common7.BadRequestException(`model "${model}" cannot be selected: no ModelCatalog is configured (AgentModule.forRoot({ models }))`);
+      throw new import_common8.BadRequestException(`model "${model}" cannot be selected: no ModelCatalog is configured (AgentModule.forRoot({ models }))`);
     }
-    const entry = (0, import_nestjs_agent_core9.findCatalogModel)(await this.models.list({
+    const entry = (0, import_nestjs_agent_core10.findCatalogModel)(await this.models.list({
       actor,
       agent
     }), model);
     if (entry === void 0) {
-      throw new import_common7.BadRequestException(`model "${model}" is not offered`);
+      throw new import_common8.BadRequestException(`model "${model}" is not offered`);
     }
     if (!entry.available) {
-      throw new import_common7.BadRequestException(`model "${model}" is not available${entry.unavailableReason ? `: ${entry.unavailableReason}` : ""}`);
+      throw new import_common8.BadRequestException(`model "${model}" is not available${entry.unavailableReason ? `: ${entry.unavailableReason}` : ""}`);
     }
     return entry.id;
   }
@@ -1808,7 +1843,7 @@ var AgentService = class {
     })).locked : void 0;
     if (locked !== void 0) {
       if (requested !== void 0 && requested !== locked.model) {
-        throw new import_common7.BadRequestException(`model "${requested}" cannot be selected: ${locked.reason ?? `this agent always uses "${locked.model}"`}`);
+        throw new import_common8.BadRequestException(`model "${requested}" cannot be selected: ${locked.reason ?? `this agent always uses "${locked.model}"`}`);
       }
       return locked.model;
     }
@@ -1852,7 +1887,7 @@ var AgentService = class {
       };
     }
     await this.requireQueue().publish(result.threadId);
-    throw new import_common7.ConflictException({
+    throw new import_common8.ConflictException({
       statusCode: 409,
       code: "run_active",
       message: `thread ${result.threadId} already has a turn running`
@@ -1870,7 +1905,7 @@ var AgentService = class {
     let threadId = params.threadId;
     if (threadId === void 0) {
       if (params.regenerate === true) {
-        throw new import_common7.BadRequestException("regenerate requires an existing threadId");
+        throw new import_common8.BadRequestException("regenerate requires an existing threadId");
       }
       const created = await this.store.createThread({
         actor: params.actor,
@@ -1912,6 +1947,11 @@ var AgentService = class {
     }
     const mode = params.mode ?? "auto";
     const { live, stale } = await queue.holder(threadId, this.runner);
+    if (stale !== null) {
+      await (0, import_nestjs_agent_core10.settleDeadRun)(this.store, {
+        runId: stale
+      });
+    }
     if (live === null && mode !== "queue") {
       const runId = crypto.randomUUID();
       if (await queue.queueStore().claimActiveStream(threadId, runId, stale !== null ? {
@@ -1924,7 +1964,7 @@ var AgentService = class {
       }
     }
     if (params.regenerate === true) {
-      throw new import_common7.ConflictException({
+      throw new import_common8.ConflictException({
         statusCode: 409,
         code: "run_active",
         message: "cannot regenerate while a turn is running on this thread"
@@ -2021,7 +2061,7 @@ var AgentService = class {
     const store = queue.queueStore();
     const threadId = await this.assertOwnsQueuedMessage(actor, messageId);
     if (patch.message !== void 0 && patch.message.trim().length === 0) {
-      throw new import_common7.BadRequestException("message must not be empty");
+      throw new import_common8.BadRequestException("message must not be empty");
     }
     const attachments = patch.attachments === void 0 || patch.attachments === null ? patch.attachments : await this.resolveAttachments(actor, patch.attachments);
     if (patch.message !== void 0 || attachments !== void 0) {
@@ -2034,15 +2074,15 @@ var AgentService = class {
         } : {}
       });
       if (updated === null) {
-        throw new import_common7.GoneException(`queued message ${messageId} already started or was removed`);
+        throw new import_common8.GoneException(`queued message ${messageId} already started or was removed`);
       }
     }
     if (patch.position !== void 0) {
       if (!Number.isInteger(patch.position) || patch.position < 0) {
-        throw new import_common7.BadRequestException("position must be a non-negative integer");
+        throw new import_common8.BadRequestException("position must be a non-negative integer");
       }
       if (!await store.moveQueuedMessage(messageId, patch.position)) {
-        throw new import_common7.GoneException(`queued message ${messageId} already started or was removed`);
+        throw new import_common8.GoneException(`queued message ${messageId} already started or was removed`);
       }
     }
     return queue.publish(threadId);
@@ -2052,7 +2092,7 @@ var AgentService = class {
     const queue = this.requireQueue();
     const threadId = await this.assertOwnsQueuedMessage(actor, messageId);
     if (!await queue.queueStore().removeQueuedMessage(messageId)) {
-      throw new import_common7.GoneException(`queued message ${messageId} already started or was removed`);
+      throw new import_common8.GoneException(`queued message ${messageId} already started or was removed`);
     }
     return queue.publish(threadId);
   }
@@ -2071,7 +2111,7 @@ var AgentService = class {
     const queue = this.requireQueue();
     const store = queue.queueStore();
     const threadId = await this.assertOwnsQueuedMessage(actor, messageId);
-    const gone = /* @__PURE__ */ __name(() => new import_common7.GoneException(`queued message ${messageId} already started or was removed`), "gone");
+    const gone = /* @__PURE__ */ __name(() => new import_common8.GoneException(`queued message ${messageId} already started or was removed`), "gone");
     const marked = await store.updateQueuedMessage(messageId, {
       interrupt: true
     });
@@ -2079,7 +2119,7 @@ var AgentService = class {
       throw gone();
     }
     if (marked.interrupt !== true) {
-      throw new import_common7.NotImplementedException("Interrupting a queued message requires a ChatQueueStore whose updateQueuedMessage stores `interrupt`; the bound store ignored it.");
+      throw new import_common8.NotImplementedException("Interrupting a queued message requires a ChatQueueStore whose updateQueuedMessage stores `interrupt`; the bound store ignored it.");
     }
     if (!await store.moveQueuedMessage(messageId, 0)) {
       throw gone();
@@ -2138,7 +2178,7 @@ var AgentService = class {
   async assertOwnsQueuedMessage(actor, messageId) {
     const message = await this.requireQueue().queueStore().getQueuedMessage(messageId);
     if (message === null) {
-      throw new import_common7.NotFoundException(`queued message ${messageId} not found`);
+      throw new import_common8.NotFoundException(`queued message ${messageId} not found`);
     }
     await this.assertOwnsThread(actor, message.threadId);
     return message.threadId;
@@ -2159,7 +2199,7 @@ var AgentService = class {
     }
     const staging = this.staging;
     if (staging === void 0 || typeof staging.resolve !== "function") {
-      throw new import_common7.NotImplementedException("Message attachments require an AGENT_ATTACHMENT_STAGING provider implementing resolve(); attachment urls are never taken from the request.");
+      throw new import_common8.NotImplementedException("Message attachments require an AGENT_ATTACHMENT_STAGING provider implementing resolve(); attachment urls are never taken from the request.");
     }
     const resolved = [];
     for (const ref of refs) {
@@ -2168,7 +2208,7 @@ var AgentService = class {
         actor
       });
       if (attachment === null) {
-        throw new import_common7.ForbiddenException(`attachment ${ref.mediaId} is not available to this actor`);
+        throw new import_common8.ForbiddenException(`attachment ${ref.mediaId} is not available to this actor`);
       }
       resolved.push(attachment);
     }
@@ -2272,8 +2312,29 @@ var AgentService = class {
   async signalToolCall(toolCallId2, reply) {
     await this.assertNotExpired(toolCallId2);
     const runId = await this.resolveRunForToolCall(toolCallId2);
+    await this.assertRunWaiting(runId);
     return this.runner.signal(runId, toolCallId2, reply);
   }
+  /**
+  * Refuse a decision addressed at a run that is over (`409 run_not_active`). The runtime would take
+  * the signal and buffer it for a run that never comes back — the person's "yes" is accepted, the
+  * card says so, and nothing runs. Settles the calls the dead run left awaiting a decision on the
+  * way out, so the card stops asking. A runner that cannot say whether a run is alive is taken at
+  * its word that it is, and so is one that fails to answer.
+  */
+  async assertRunWaiting(runId) {
+    if (typeof this.runner.isRunActive !== "function") {
+      return;
+    }
+    const active = await this.runner.isRunActive(runId).catch(() => true);
+    if (active) {
+      return;
+    }
+    await (0, import_nestjs_agent_core10.settleDeadRun)(this.store, {
+      runId
+    });
+    throw new RunNotActiveException(runId);
+  }
   async cancel(actor, runId) {
     await this.assertOwnsActiveStream(actor, runId);
     return this.runner.cancel(runId);
@@ -2317,7 +2378,7 @@ var AgentService = class {
       return;
     }
     if (this.store.updateThread === void 0) {
-      throw new import_common7.NotImplementedException("Setting a thread's defaultAgent or model requires an AgentStore that implements updateThread(); the bound store does not support it.");
+      throw new import_common8.NotImplementedException("Setting a thread's defaultAgent or model requires an AgentStore that implements updateThread(); the bound store does not support it.");
     }
     const model = patch.model === void 0 || patch.model === null ? patch.model : await this.assertModelAllowed(actor, patch.defaultAgent ?? await this.resolveAgentName(void 0, threadId), patch.model);
     await this.store.updateThread(threadId, {
@@ -2335,10 +2396,10 @@ var AgentService = class {
   validateTitle(title) {
     const trimmed = title.trim();
     if (trimmed.length === 0) {
-      throw new import_common7.BadRequestException("title must not be empty");
+      throw new import_common8.BadRequestException("title must not be empty");
     }
     if (trimmed.length > 200) {
-      throw new import_common7.BadRequestException("title must be at most 200 characters");
+      throw new import_common8.BadRequestException("title must be at most 200 characters");
     }
     return trimmed;
   }
@@ -2441,21 +2502,21 @@ var AgentService = class {
   */
   async setMessageFeedback(actor, messageId, input) {
     if (input.value !== null && input.value !== "up" && input.value !== "down") {
-      throw new import_common7.BadRequestException("value must be 'up', 'down' or null");
+      throw new import_common8.BadRequestException("value must be 'up', 'down' or null");
     }
     if (input.comment !== void 0 && typeof input.comment !== "string") {
-      throw new import_common7.BadRequestException("comment must be a string");
+      throw new import_common8.BadRequestException("comment must be a string");
     }
     const comment = input.comment?.trim();
     if (comment !== void 0 && comment.length > 2e3) {
-      throw new import_common7.BadRequestException("comment must be at most 2000 characters");
+      throw new import_common8.BadRequestException("comment must be at most 2000 characters");
     }
     if (this.store.threadOfMessage === void 0 || this.store.setMessageFeedback === void 0) {
-      throw new import_common7.NotImplementedException("Message feedback requires an AgentStore that implements threadOfMessage() and setMessageFeedback(); the bound store does not support it.");
+      throw new import_common8.NotImplementedException("Message feedback requires an AgentStore that implements threadOfMessage() and setMessageFeedback(); the bound store does not support it.");
     }
     const threadId = await this.store.threadOfMessage(messageId);
     if (threadId === null) {
-      throw new import_common7.NotFoundException(`message ${messageId} not found`);
+      throw new import_common8.NotFoundException(`message ${messageId} not found`);
     }
     await this.assertOwnsThread(actor, threadId);
     const feedback = input.value === null ? null : {
@@ -2503,7 +2564,7 @@ var AgentService = class {
     const list = this.attachmentInventory();
     const referencedMediaIds = this.store.referencedMediaIds?.bind(this.store);
     if (referencedMediaIds === void 0) {
-      throw new import_common7.NotImplementedException("Collecting attachments requires an AgentStore that implements referencedMediaIds(); the bound store cannot say which media a message still references, and guessing would delete files that are in use.");
+      throw new import_common8.NotImplementedException("Collecting attachments requires an AgentStore that implements referencedMediaIds(); the bound store cannot say which media a message still references, and guessing would delete files that are in use.");
     }
     const stagedBefore = options.olderThan.toISOString();
     const inventory = await list({
@@ -2525,7 +2586,7 @@ var AgentService = class {
   attachmentInventory() {
     const list = this.staging?.list?.bind(this.staging);
     if (list === void 0) {
-      throw new import_common7.NotImplementedException("Listing attachments requires an AGENT_ATTACHMENT_STAGING provider implementing list(); the host owns the staged bytes, so only it can enumerate them.");
+      throw new import_common8.NotImplementedException("Listing attachments requires an AGENT_ATTACHMENT_STAGING provider implementing list(); the host owns the staged bytes, so only it can enumerate them.");
     }
     return list;
   }
@@ -2536,10 +2597,10 @@ var AgentService = class {
   async assertOwnsThread(actor, threadId) {
     const owner = await this.store.ownerOfThread(threadId);
     if (owner === null) {
-      throw new import_common7.NotFoundException(`thread ${threadId} not found`);
+      throw new import_common8.NotFoundException(`thread ${threadId} not found`);
     }
     if (owner !== actor.id) {
-      throw new import_common7.ForbiddenException("thread belongs to another actor");
+      throw new import_common8.ForbiddenException("thread belongs to another actor");
     }
   }
   /**
@@ -2550,10 +2611,10 @@ var AgentService = class {
   async assertOwnsToolCall(actor, toolCallId2) {
     const owner = await this.store.ownerOfToolCall(toolCallId2);
     if (owner === null) {
-      throw new import_common7.NotFoundException(`tool call ${toolCallId2} not found`);
+      throw new import_common8.NotFoundException(`tool call ${toolCallId2} not found`);
     }
     if (owner !== actor.id) {
-      throw new import_common7.ForbiddenException("tool call belongs to another actor");
+      throw new import_common8.ForbiddenException("tool call belongs to another actor");
     }
   }
   /**
@@ -2568,12 +2629,12 @@ var AgentService = class {
     if (this.store.toolCallInput === void 0) {
       return;
     }
-    const questions = (0, import_nestjs_agent_core9.readElicitationQuestions)(await this.store.toolCallInput(toolCallId2));
+    const questions = (0, import_nestjs_agent_core10.readElicitationQuestions)(await this.store.toolCallInput(toolCallId2));
     for (const question of questions) {
       const submitted = Object.hasOwn(answers2, question.id) ? answers2[question.id] : void 0;
-      const problem = (0, import_nestjs_agent_core9.validateElicitationAnswer)(question, submitted ?? question.defaults ?? []);
+      const problem = (0, import_nestjs_agent_core10.validateElicitationAnswer)(question, submitted ?? question.defaults ?? []);
       if (problem !== null) {
-        throw new import_common7.BadRequestException(`answers["${question.id}"] ${problem}`);
+        throw new import_common8.BadRequestException(`answers["${question.id}"] ${problem}`);
       }
     }
   }
@@ -2585,21 +2646,21 @@ var AgentService = class {
   */
   async assertMayDecide(actor, toolCallId2) {
     const approval = await this.store.toolCallApproval?.(toolCallId2);
-    const approver = approval?.approver ?? import_nestjs_agent_core9.REQUESTER_APPROVER;
-    if (approver === import_nestjs_agent_core9.REQUESTER_APPROVER) {
+    const approver = approval?.approver ?? import_nestjs_agent_core10.REQUESTER_APPROVER;
+    if (approver === import_nestjs_agent_core10.REQUESTER_APPROVER) {
       return this.assertOwnsToolCall(actor, toolCallId2);
     }
     const requesterRef = await this.store.ownerOfToolCall(toolCallId2);
     if (requesterRef === null) {
-      throw new import_common7.NotFoundException(`tool call ${toolCallId2} not found`);
+      throw new import_common8.NotFoundException(`tool call ${toolCallId2} not found`);
     }
-    const allowed = await (0, import_nestjs_agent_core9.mayDecideApproval)(this.deps.forAgent().approvalPolicy, actor, {
+    const allowed = await (0, import_nestjs_agent_core10.mayDecideApproval)(this.deps.forAgent().approvalPolicy, actor, {
       toolCallId: toolCallId2,
       approver,
       requesterRef
     });
     if (!allowed) {
-      throw new import_common7.ForbiddenException(`this approval is for ${approver}`);
+      throw new import_common8.ForbiddenException(`this approval is for ${approver}`);
     }
   }
   /**
@@ -2615,7 +2676,7 @@ var AgentService = class {
     }
     const lapsed = approval.status === "expired" || approval.status === "pending_approval" && approval.expiresAt !== null && Date.parse(approval.expiresAt) <= Date.now();
     if (lapsed) {
-      throw new import_common7.GoneException(`the approval request for tool call ${toolCallId2} has expired`);
+      throw new import_common8.GoneException(`the approval request for tool call ${toolCallId2} has expired`);
     }
   }
   /**
@@ -2628,7 +2689,7 @@ var AgentService = class {
   async resolveRunForToolCall(toolCallId2) {
     const runId = await this.store.runForToolCall(toolCallId2);
     if (runId === null) {
-      throw new import_common7.NotFoundException(`tool call ${toolCallId2} has no active run to signal`);
+      throw new import_common8.NotFoundException(`tool call ${toolCallId2} has no active run to signal`);
     }
     return runId;
   }
@@ -2636,27 +2697,27 @@ var AgentService = class {
   async assertOwnsActiveStream(actor, runId) {
     const owner = await this.store.ownerOfActiveStream(runId);
     if (owner === null) {
-      throw new import_common7.NotFoundException(`no active run ${runId}`);
+      throw new import_common8.NotFoundException(`no active run ${runId}`);
     }
     if (owner !== actor.id) {
-      throw new import_common7.ForbiddenException("run belongs to another actor");
+      throw new import_common8.ForbiddenException("run belongs to another actor");
     }
   }
 };
 AgentService = _ts_decorate7([
-  (0, import_common7.Injectable)(),
-  _ts_param6(0, (0, import_common7.Inject)(import_nestjs_agent_core9.AGENT_RUNNER)),
-  _ts_param6(1, (0, import_common7.Inject)(import_nestjs_agent_core9.AGENT_STORE)),
-  _ts_param6(2, (0, import_common7.Inject)(import_nestjs_agent_core9.AGENT_DEPS_FACTORY)),
-  _ts_param6(3, (0, import_common7.Optional)()),
-  _ts_param6(3, (0, import_common7.Inject)(import_nestjs_agent_core9.AGENT_ATTACHMENT_STAGING)),
-  _ts_param6(4, (0, import_common7.Optional)()),
-  _ts_param6(4, (0, import_common7.Inject)(import_nestjs_agent_core9.AGENT_MODEL_CATALOG)),
-  _ts_param6(5, (0, import_common7.Optional)()),
-  _ts_param6(5, (0, import_common7.Inject)(import_nestjs_agent_core9.AGENT_QUOTA_PROVIDER)),
-  _ts_param6(6, (0, import_common7.Optional)()),
-  _ts_param6(6, (0, import_common7.Inject)(import_nestjs_agent_core9.AGENT_OPTIONS)),
-  _ts_param6(7, (0, import_common7.Optional)()),
+  (0, import_common8.Injectable)(),
+  _ts_param6(0, (0, import_common8.Inject)(import_nestjs_agent_core10.AGENT_RUNNER)),
+  _ts_param6(1, (0, import_common8.Inject)(import_nestjs_agent_core10.AGENT_STORE)),
+  _ts_param6(2, (0, import_common8.Inject)(import_nestjs_agent_core10.AGENT_DEPS_FACTORY)),
+  _ts_param6(3, (0, import_common8.Optional)()),
+  _ts_param6(3, (0, import_common8.Inject)(import_nestjs_agent_core10.AGENT_ATTACHMENT_STAGING)),
+  _ts_param6(4, (0, import_common8.Optional)()),
+  _ts_param6(4, (0, import_common8.Inject)(import_nestjs_agent_core10.AGENT_MODEL_CATALOG)),
+  _ts_param6(5, (0, import_common8.Optional)()),
+  _ts_param6(5, (0, import_common8.Inject)(import_nestjs_agent_core10.AGENT_QUOTA_PROVIDER)),
+  _ts_param6(6, (0, import_common8.Optional)()),
+  _ts_param6(6, (0, import_common8.Inject)(import_nestjs_agent_core10.AGENT_OPTIONS)),
+  _ts_param6(7, (0, import_common8.Optional)()),
   _ts_metadata6("design:type", Function),
   _ts_metadata6("design:paramtypes", [
     typeof AgentRunner === "undefined" ? Object : AgentRunner,
@@ -2666,12 +2727,12 @@ AgentService = _ts_decorate7([
     typeof ModelCatalog === "undefined" ? Object : ModelCatalog,
     typeof QuotaProvider === "undefined" ? Object : QuotaProvider,
     typeof Pick === "undefined" ? Object : Pick,
-    typeof ChatQueueService === "undefined" ? Object : ChatQueueService
+    typeof ChatQueueService2 === "undefined" ? Object : ChatQueueService2
   ])
 ], AgentService);
 
 // src/approval-port.adapter.ts
-var import_common8 = require("@nestjs/common");
+var import_common9 = require("@nestjs/common");
 function _ts_decorate8(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") {
@@ -2730,7 +2791,7 @@ var AgentApprovalPortAdapter = class {
   }
 };
 AgentApprovalPortAdapter = _ts_decorate8([
-  (0, import_common8.Injectable)(),
+  (0, import_common9.Injectable)(),
   _ts_metadata7("design:type", Function),
   _ts_metadata7("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService
@@ -2738,8 +2799,8 @@ AgentApprovalPortAdapter = _ts_decorate8([
 ], AgentApprovalPortAdapter);
 
 // src/controller/agents.controller.ts
-var import_nestjs_agent_core10 = require("@dudousxd/nestjs-agent-core");
-var import_common9 = require("@nestjs/common");
+var import_nestjs_agent_core11 = require("@dudousxd/nestjs-agent-core");
+var import_common10 = require("@nestjs/common");
 function _ts_decorate9(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") {
@@ -2788,25 +2849,25 @@ var AgentsController = class {
   }
 };
 _ts_decorate9([
-  (0, import_common9.Get)(),
+  (0, import_common10.Get)(),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", []),
   _ts_metadata8("design:returntype", Array)
 ], AgentsController.prototype, "list", null);
 AgentsController = _ts_decorate9([
-  (0, import_common9.Controller)("agents"),
-  _ts_param7(0, (0, import_common9.Inject)(import_nestjs_agent_core10.AGENT_REGISTRY)),
-  _ts_param7(1, (0, import_common9.Inject)(import_nestjs_agent_core10.AGENT_DEPS_FACTORY)),
+  (0, import_common10.Controller)("agents"),
+  _ts_param7(0, (0, import_common10.Inject)(import_nestjs_agent_core11.AGENT_REGISTRY)),
+  _ts_param7(1, (0, import_common10.Inject)(import_nestjs_agent_core11.AGENT_DEPS_FACTORY)),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", [
-    typeof import_nestjs_agent_core10.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core10.AgentRegistry,
+    typeof import_nestjs_agent_core11.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core11.AgentRegistry,
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory
   ])
 ], AgentsController);
 
 // src/controller/attachments.controller.ts
-var import_nestjs_agent_core11 = require("@dudousxd/nestjs-agent-core");
-var import_common10 = require("@nestjs/common");
+var import_nestjs_agent_core12 = require("@dudousxd/nestjs-agent-core");
+var import_common11 = require("@nestjs/common");
 var import_platform_express = require("@nestjs/platform-express");
 
 // src/attachment-limits.ts
@@ -2894,17 +2955,17 @@ var AttachmentsController = class {
   }
   async upload(req, file) {
     if (this.staging === void 0) {
-      throw new import_common10.NotImplementedException("Attachment upload is not configured on this server: bind AGENT_ATTACHMENT_STAGING (e.g. import AgentMediaAttachmentsModule).");
+      throw new import_common11.NotImplementedException("Attachment upload is not configured on this server: bind AGENT_ATTACHMENT_STAGING (e.g. import AgentMediaAttachmentsModule).");
     }
     if (file === void 0) {
-      throw new import_common10.BadRequestException('multipart field "file" is required');
+      throw new import_common11.BadRequestException('multipart field "file" is required');
     }
     const { allowedContentTypes, maxBytes } = attachmentLimits(this.options, this.staging);
     if (!allowedContentTypes.includes(file.mimetype)) {
-      throw new import_common10.UnsupportedMediaTypeException(`content type "${file.mimetype}" is not allowed (allowed: ${allowedContentTypes.join(", ")})`);
+      throw new import_common11.UnsupportedMediaTypeException(`content type "${file.mimetype}" is not allowed (allowed: ${allowedContentTypes.join(", ")})`);
     }
     if (file.size > maxBytes) {
-      throw new import_common10.PayloadTooLargeException(`file exceeds the ${maxBytes}-byte limit`);
+      throw new import_common11.PayloadTooLargeException(`file exceeds the ${maxBytes}-byte limit`);
     }
     const actor = await this.actorResolver.resolve(req);
     return this.staging.stage({
@@ -2917,8 +2978,8 @@ var AttachmentsController = class {
   }
 };
 _ts_decorate10([
-  (0, import_common10.Get)(),
-  _ts_param8(0, (0, import_common10.Req)()),
+  (0, import_common11.Get)(),
+  _ts_param8(0, (0, import_common11.Req)()),
   _ts_metadata9("design:type", Function),
   _ts_metadata9("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request
@@ -2926,14 +2987,14 @@ _ts_decorate10([
   _ts_metadata9("design:returntype", Promise)
 ], AttachmentsController.prototype, "list", null);
 _ts_decorate10([
-  (0, import_common10.Post)(),
-  (0, import_common10.UseInterceptors)((0, import_platform_express.FileInterceptor)("file", {
+  (0, import_common11.Post)(),
+  (0, import_common11.UseInterceptors)((0, import_platform_express.FileInterceptor)("file", {
     limits: {
       fileSize: HARD_MAX_ATTACHMENT_BYTES
     }
   })),
-  _ts_param8(0, (0, import_common10.Req)()),
-  _ts_param8(1, (0, import_common10.UploadedFile)()),
+  _ts_param8(0, (0, import_common11.Req)()),
+  _ts_param8(1, (0, import_common11.UploadedFile)()),
   _ts_metadata9("design:type", Function),
   _ts_metadata9("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -2942,11 +3003,11 @@ _ts_decorate10([
   _ts_metadata9("design:returntype", Promise)
 ], AttachmentsController.prototype, "upload", null);
 AttachmentsController = _ts_decorate10([
-  (0, import_common10.Controller)("attachments"),
-  _ts_param8(0, (0, import_common10.Inject)(import_nestjs_agent_core11.AGENT_OPTIONS)),
-  _ts_param8(1, (0, import_common10.Inject)(import_nestjs_agent_core11.AGENT_ACTOR_RESOLVER)),
-  _ts_param8(3, (0, import_common10.Optional)()),
-  _ts_param8(3, (0, import_common10.Inject)(import_nestjs_agent_core11.AGENT_ATTACHMENT_STAGING)),
+  (0, import_common11.Controller)("attachments"),
+  _ts_param8(0, (0, import_common11.Inject)(import_nestjs_agent_core12.AGENT_OPTIONS)),
+  _ts_param8(1, (0, import_common11.Inject)(import_nestjs_agent_core12.AGENT_ACTOR_RESOLVER)),
+  _ts_param8(3, (0, import_common11.Optional)()),
+  _ts_param8(3, (0, import_common11.Inject)(import_nestjs_agent_core12.AGENT_ATTACHMENT_STAGING)),
   _ts_metadata9("design:type", Function),
   _ts_metadata9("design:paramtypes", [
     typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions,
@@ -2957,8 +3018,8 @@ AttachmentsController = _ts_decorate10([
 ], AttachmentsController);
 
 // src/controller/chat.controller.ts
-var import_nestjs_agent_core12 = require("@dudousxd/nestjs-agent-core");
-var import_common11 = require("@nestjs/common");
+var import_nestjs_agent_core13 = require("@dudousxd/nestjs-agent-core");
+var import_common12 = require("@nestjs/common");
 function _ts_decorate11(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") {
@@ -2995,7 +3056,7 @@ function sendMode(body) {
   if (body.mode === "auto" || body.mode === "queue" || body.mode === "interrupt") {
     return body.mode;
   }
-  throw new import_common11.BadRequestException("mode must be 'auto', 'queue' or 'interrupt'");
+  throw new import_common12.BadRequestException("mode must be 'auto', 'queue' or 'interrupt'");
 }
 __name(sendMode, "sendMode");
 function attachmentRefs(claimed) {
@@ -3003,21 +3064,21 @@ function attachmentRefs(claimed) {
     return [];
   }
   if (!Array.isArray(claimed)) {
-    throw new import_common11.BadRequestException("attachments must be an array of { mediaId }");
+    throw new import_common12.BadRequestException("attachments must be an array of { mediaId }");
   }
   if (claimed.length > MAX_ATTACHMENTS_PER_MESSAGE) {
-    throw new import_common11.BadRequestException(`a message may carry at most ${MAX_ATTACHMENTS_PER_MESSAGE} attachments`);
+    throw new import_common12.BadRequestException(`a message may carry at most ${MAX_ATTACHMENTS_PER_MESSAGE} attachments`);
   }
   return claimed.map((entry) => {
     if (typeof entry !== "object" || entry === null || !("mediaId" in entry)) {
-      throw new import_common11.BadRequestException("each attachment must be an object with a mediaId");
+      throw new import_common12.BadRequestException("each attachment must be an object with a mediaId");
     }
     if (Object.keys(entry).some((key) => key !== "mediaId")) {
-      throw new import_common11.BadRequestException("attachments are { mediaId } refs \u2014 send nothing but the id");
+      throw new import_common12.BadRequestException("attachments are { mediaId } refs \u2014 send nothing but the id");
     }
     const { mediaId } = entry;
     if (typeof mediaId !== "string" || mediaId.length === 0) {
-      throw new import_common11.BadRequestException("each attachment must carry a non-empty string mediaId");
+      throw new import_common12.BadRequestException("each attachment must carry a non-empty string mediaId");
     }
     return {
       mediaId
@@ -3150,13 +3211,10 @@ data: ${line}
       }
       res.write("event: done\ndata: {}\n\n");
     } catch (error) {
-      const payload = error instanceof import_nestjs_agent_core12.AgentStreamError ? {
+      const payload = error instanceof import_nestjs_agent_core13.AgentStreamError ? {
         code: error.code,
         message: error.message
-      } : {
-        code: "run_failed",
-        message: error instanceof Error ? error.message : "stream error"
-      };
+      } : (0, import_nestjs_agent_core13.streamFailure)(error);
       res.write(`event: error
 data: ${JSON.stringify(payload)}
 
@@ -3166,10 +3224,10 @@ data: ${JSON.stringify(payload)}
   }
 };
 _ts_decorate11([
-  (0, import_common11.Post)("chat"),
-  _ts_param9(0, (0, import_common11.Req)()),
-  _ts_param9(1, (0, import_common11.Res)()),
-  _ts_param9(2, (0, import_common11.Body)()),
+  (0, import_common12.Post)("chat"),
+  _ts_param9(0, (0, import_common12.Req)()),
+  _ts_param9(1, (0, import_common12.Res)()),
+  _ts_param9(2, (0, import_common12.Body)()),
   _ts_metadata10("design:type", Function),
   _ts_metadata10("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3179,11 +3237,11 @@ _ts_decorate11([
   _ts_metadata10("design:returntype", Promise)
 ], ChatController.prototype, "chat", null);
 _ts_decorate11([
-  (0, import_common11.Get)("chat/:runId/stream"),
-  _ts_param9(0, (0, import_common11.Req)()),
-  _ts_param9(1, (0, import_common11.Param)("runId")),
-  _ts_param9(2, (0, import_common11.Res)()),
-  _ts_param9(3, (0, import_common11.Query)("after")),
+  (0, import_common12.Get)("chat/:runId/stream"),
+  _ts_param9(0, (0, import_common12.Req)()),
+  _ts_param9(1, (0, import_common12.Param)("runId")),
+  _ts_param9(2, (0, import_common12.Res)()),
+  _ts_param9(3, (0, import_common12.Query)("after")),
   _ts_metadata10("design:type", Function),
   _ts_metadata10("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3194,9 +3252,9 @@ _ts_decorate11([
   _ts_metadata10("design:returntype", Promise)
 ], ChatController.prototype, "stream", null);
 _ts_decorate11([
-  (0, import_common11.Post)("chat/:runId/cancel"),
-  _ts_param9(0, (0, import_common11.Req)()),
-  _ts_param9(1, (0, import_common11.Param)("runId")),
+  (0, import_common12.Post)("chat/:runId/cancel"),
+  _ts_param9(0, (0, import_common12.Req)()),
+  _ts_param9(1, (0, import_common12.Param)("runId")),
   _ts_metadata10("design:type", Function),
   _ts_metadata10("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3205,8 +3263,8 @@ _ts_decorate11([
   _ts_metadata10("design:returntype", Promise)
 ], ChatController.prototype, "cancel", null);
 ChatController = _ts_decorate11([
-  (0, import_common11.Controller)(),
-  _ts_param9(1, (0, import_common11.Inject)(import_nestjs_agent_core12.AGENT_ACTOR_RESOLVER)),
+  (0, import_common12.Controller)(),
+  _ts_param9(1, (0, import_common12.Inject)(import_nestjs_agent_core13.AGENT_ACTOR_RESOLVER)),
   _ts_metadata10("design:type", Function),
   _ts_metadata10("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
@@ -3224,8 +3282,8 @@ function parseCursor(raw) {
 __name(parseCursor, "parseCursor");
 
 // src/controller/config.controller.ts
-var import_nestjs_agent_core13 = require("@dudousxd/nestjs-agent-core");
-var import_common12 = require("@nestjs/common");
+var import_nestjs_agent_core14 = require("@dudousxd/nestjs-agent-core");
+var import_common13 = require("@nestjs/common");
 
 // src/resolver/anonymous-actor-resolver.ts
 var import_node_crypto2 = require("crypto");
@@ -3372,8 +3430,8 @@ var ConfigController = class {
   }
 };
 _ts_decorate12([
-  (0, import_common12.Get)(),
-  _ts_param10(0, (0, import_common12.Req)()),
+  (0, import_common13.Get)(),
+  _ts_param10(0, (0, import_common13.Req)()),
   _ts_metadata11("design:type", Function),
   _ts_metadata11("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request
@@ -3381,13 +3439,13 @@ _ts_decorate12([
   _ts_metadata11("design:returntype", Promise)
 ], ConfigController.prototype, "config", null);
 ConfigController = _ts_decorate12([
-  (0, import_common12.Controller)("config"),
-  _ts_param10(0, (0, import_common12.Inject)(import_nestjs_agent_core13.AGENT_OPTIONS)),
-  _ts_param10(1, (0, import_common12.Inject)(import_nestjs_agent_core13.AGENT_ACTOR_RESOLVER)),
-  _ts_param10(2, (0, import_common12.Optional)()),
-  _ts_param10(2, (0, import_common12.Inject)(import_nestjs_agent_core13.AGENT_ATTACHMENT_STAGING)),
-  _ts_param10(3, (0, import_common12.Optional)()),
-  _ts_param10(3, (0, import_common12.Inject)(import_nestjs_agent_core13.AGENT_MODEL_CATALOG)),
+  (0, import_common13.Controller)("config"),
+  _ts_param10(0, (0, import_common13.Inject)(import_nestjs_agent_core14.AGENT_OPTIONS)),
+  _ts_param10(1, (0, import_common13.Inject)(import_nestjs_agent_core14.AGENT_ACTOR_RESOLVER)),
+  _ts_param10(2, (0, import_common13.Optional)()),
+  _ts_param10(2, (0, import_common13.Inject)(import_nestjs_agent_core14.AGENT_ATTACHMENT_STAGING)),
+  _ts_param10(3, (0, import_common13.Optional)()),
+  _ts_param10(3, (0, import_common13.Inject)(import_nestjs_agent_core14.AGENT_MODEL_CATALOG)),
   _ts_metadata11("design:type", Function),
   _ts_metadata11("design:paramtypes", [
     typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions,
@@ -3398,8 +3456,8 @@ ConfigController = _ts_decorate12([
 ], ConfigController);
 
 // src/controller/memories.controller.ts
-var import_nestjs_agent_core14 = require("@dudousxd/nestjs-agent-core");
-var import_common13 = require("@nestjs/common");
+var import_nestjs_agent_core15 = require("@dudousxd/nestjs-agent-core");
+var import_common14 = require("@nestjs/common");
 function _ts_decorate13(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") {
@@ -3459,20 +3517,20 @@ var MemoriesController = class {
   */
   async forget(req, id) {
     if (this.memory === void 0) {
-      throw new import_common13.NotFoundException("No memory is configured in this deployment.");
+      throw new import_common14.NotFoundException("No memory is configured in this deployment.");
     }
     const actor = await this.actorResolver.resolve(req);
     const digest = await this.unbounded("", actor);
     const entry = digest.entries.find((candidate) => candidate.id === id);
     if (entry === void 0) {
-      throw new import_common13.NotFoundException(`No memory with id "${id}".`);
+      throw new import_common14.NotFoundException(`No memory with id "${id}".`);
     }
-    const verdict = (0, import_nestjs_agent_core14.memoryForgetVerdict)({
+    const verdict = (0, import_nestjs_agent_core15.memoryForgetVerdict)({
       record: entry,
       actor
     });
     if (!verdict.allowed) {
-      throw new import_common13.ForbiddenException(verdict.reason);
+      throw new import_common14.ForbiddenException(verdict.reason);
     }
     return {
       forgotten: await this.memory.provider.forget({
@@ -3486,7 +3544,7 @@ var MemoriesController = class {
   }
   async unbounded(threadId, actor) {
     const config = this.memory;
-    return await (0, import_nestjs_agent_core14.offerMemories)({
+    return await (0, import_nestjs_agent_core15.offerMemories)({
       config: {
         ...config,
         maxMemories: Number.POSITIVE_INFINITY
@@ -3499,9 +3557,9 @@ var MemoriesController = class {
   }
 };
 _ts_decorate13([
-  (0, import_common13.Get)(),
-  _ts_param11(0, (0, import_common13.Req)()),
-  _ts_param11(1, (0, import_common13.Query)("threadId")),
+  (0, import_common14.Get)(),
+  _ts_param11(0, (0, import_common14.Req)()),
+  _ts_param11(1, (0, import_common14.Query)("threadId")),
   _ts_metadata12("design:type", Function),
   _ts_metadata12("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3510,9 +3568,9 @@ _ts_decorate13([
   _ts_metadata12("design:returntype", Promise)
 ], MemoriesController.prototype, "list", null);
 _ts_decorate13([
-  (0, import_common13.Delete)(":id"),
-  _ts_param11(0, (0, import_common13.Req)()),
-  _ts_param11(1, (0, import_common13.Param)("id")),
+  (0, import_common14.Delete)(":id"),
+  _ts_param11(0, (0, import_common14.Req)()),
+  _ts_param11(1, (0, import_common14.Param)("id")),
   _ts_metadata12("design:type", Function),
   _ts_metadata12("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3521,10 +3579,10 @@ _ts_decorate13([
   _ts_metadata12("design:returntype", Promise)
 ], MemoriesController.prototype, "forget", null);
 MemoriesController = _ts_decorate13([
-  (0, import_common13.Controller)("memories"),
-  _ts_param11(0, (0, import_common13.Inject)(import_nestjs_agent_core14.AGENT_ACTOR_RESOLVER)),
-  _ts_param11(1, (0, import_common13.Optional)()),
-  _ts_param11(1, (0, import_common13.Inject)(import_nestjs_agent_core14.AGENT_MEMORY)),
+  (0, import_common14.Controller)("memories"),
+  _ts_param11(0, (0, import_common14.Inject)(import_nestjs_agent_core15.AGENT_ACTOR_RESOLVER)),
+  _ts_param11(1, (0, import_common14.Optional)()),
+  _ts_param11(1, (0, import_common14.Inject)(import_nestjs_agent_core15.AGENT_MEMORY)),
   _ts_metadata12("design:type", Function),
   _ts_metadata12("design:paramtypes", [
     typeof ActorResolver === "undefined" ? Object : ActorResolver,
@@ -3533,8 +3591,8 @@ MemoriesController = _ts_decorate13([
 ], MemoriesController);
 
 // src/controller/messages.controller.ts
-var import_nestjs_agent_core15 = require("@dudousxd/nestjs-agent-core");
-var import_common14 = require("@nestjs/common");
+var import_nestjs_agent_core16 = require("@dudousxd/nestjs-agent-core");
+var import_common15 = require("@nestjs/common");
 function _ts_decorate14(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") {
@@ -3589,11 +3647,11 @@ var MessagesController = class {
   }
 };
 _ts_decorate14([
-  (0, import_common14.Post)(":id/feedback"),
-  (0, import_common14.HttpCode)(200),
-  _ts_param12(0, (0, import_common14.Req)()),
-  _ts_param12(1, (0, import_common14.Param)("id")),
-  _ts_param12(2, (0, import_common14.Body)()),
+  (0, import_common15.Post)(":id/feedback"),
+  (0, import_common15.HttpCode)(200),
+  _ts_param12(0, (0, import_common15.Req)()),
+  _ts_param12(1, (0, import_common15.Param)("id")),
+  _ts_param12(2, (0, import_common15.Body)()),
   _ts_metadata13("design:type", Function),
   _ts_metadata13("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3603,8 +3661,8 @@ _ts_decorate14([
   _ts_metadata13("design:returntype", Promise)
 ], MessagesController.prototype, "feedback", null);
 MessagesController = _ts_decorate14([
-  (0, import_common14.Controller)("messages"),
-  _ts_param12(1, (0, import_common14.Inject)(import_nestjs_agent_core15.AGENT_ACTOR_RESOLVER)),
+  (0, import_common15.Controller)("messages"),
+  _ts_param12(1, (0, import_common15.Inject)(import_nestjs_agent_core16.AGENT_ACTOR_RESOLVER)),
   _ts_metadata13("design:type", Function),
   _ts_metadata13("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
@@ -3613,8 +3671,8 @@ MessagesController = _ts_decorate14([
 ], MessagesController);
 
 // src/controller/models.controller.ts
-var import_nestjs_agent_core16 = require("@dudousxd/nestjs-agent-core");
-var import_common15 = require("@nestjs/common");
+var import_nestjs_agent_core17 = require("@dudousxd/nestjs-agent-core");
+var import_common16 = require("@nestjs/common");
 function _ts_decorate15(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") {
@@ -3661,9 +3719,9 @@ var ModelsController = class {
   }
 };
 _ts_decorate15([
-  (0, import_common15.Get)(),
-  _ts_param13(0, (0, import_common15.Req)()),
-  _ts_param13(1, (0, import_common15.Query)("agent")),
+  (0, import_common16.Get)(),
+  _ts_param13(0, (0, import_common16.Req)()),
+  _ts_param13(1, (0, import_common16.Query)("agent")),
   _ts_metadata14("design:type", Function),
   _ts_metadata14("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3672,8 +3730,8 @@ _ts_decorate15([
   _ts_metadata14("design:returntype", Promise)
 ], ModelsController.prototype, "list", null);
 ModelsController = _ts_decorate15([
-  (0, import_common15.Controller)("models"),
-  _ts_param13(1, (0, import_common15.Inject)(import_nestjs_agent_core16.AGENT_ACTOR_RESOLVER)),
+  (0, import_common16.Controller)("models"),
+  _ts_param13(1, (0, import_common16.Inject)(import_nestjs_agent_core17.AGENT_ACTOR_RESOLVER)),
   _ts_metadata14("design:type", Function),
   _ts_metadata14("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
@@ -3682,8 +3740,8 @@ ModelsController = _ts_decorate15([
 ], ModelsController);
 
 // src/controller/queue.controller.ts
-var import_nestjs_agent_core17 = require("@dudousxd/nestjs-agent-core");
-var import_common16 = require("@nestjs/common");
+var import_nestjs_agent_core18 = require("@dudousxd/nestjs-agent-core");
+var import_common17 = 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") {
@@ -3733,10 +3791,10 @@ var QueueController = class {
   async update(req, messageId, body) {
     const actor = await this.actorResolver.resolve(req);
     if (body.message !== void 0 && typeof body.message !== "string") {
-      throw new import_common16.BadRequestException("message must be a string");
+      throw new import_common17.BadRequestException("message must be a string");
     }
     if (body.position !== void 0 && typeof body.position !== "number") {
-      throw new import_common16.BadRequestException("position must be a number");
+      throw new import_common17.BadRequestException("position must be a number");
     }
     const attachments = body.attachments === void 0 ? void 0 : body.attachments === null ? null : attachmentRefs(body.attachments);
     return this.agent.updateQueuedMessage(actor, messageId, {
@@ -3764,9 +3822,9 @@ var QueueController = class {
   }
 };
 _ts_decorate16([
-  (0, import_common16.Get)("threads/:id/queue"),
-  _ts_param14(0, (0, import_common16.Req)()),
-  _ts_param14(1, (0, import_common16.Param)("id")),
+  (0, import_common17.Get)("threads/:id/queue"),
+  _ts_param14(0, (0, import_common17.Req)()),
+  _ts_param14(1, (0, import_common17.Param)("id")),
   _ts_metadata15("design:type", Function),
   _ts_metadata15("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3775,9 +3833,9 @@ _ts_decorate16([
   _ts_metadata15("design:returntype", Promise)
 ], QueueController.prototype, "list", null);
 _ts_decorate16([
-  (0, import_common16.Delete)("threads/:id/queue"),
-  _ts_param14(0, (0, import_common16.Req)()),
-  _ts_param14(1, (0, import_common16.Param)("id")),
+  (0, import_common17.Delete)("threads/:id/queue"),
+  _ts_param14(0, (0, import_common17.Req)()),
+  _ts_param14(1, (0, import_common17.Param)("id")),
   _ts_metadata15("design:type", Function),
   _ts_metadata15("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3786,9 +3844,9 @@ _ts_decorate16([
   _ts_metadata15("design:returntype", Promise)
 ], QueueController.prototype, "clear", null);
 _ts_decorate16([
-  (0, import_common16.Post)("threads/:id/queue/resume"),
-  _ts_param14(0, (0, import_common16.Req)()),
-  _ts_param14(1, (0, import_common16.Param)("id")),
+  (0, import_common17.Post)("threads/:id/queue/resume"),
+  _ts_param14(0, (0, import_common17.Req)()),
+  _ts_param14(1, (0, import_common17.Param)("id")),
   _ts_metadata15("design:type", Function),
   _ts_metadata15("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3797,10 +3855,10 @@ _ts_decorate16([
   _ts_metadata15("design:returntype", Promise)
 ], QueueController.prototype, "resume", null);
 _ts_decorate16([
-  (0, import_common16.Patch)("queue/:messageId"),
-  _ts_param14(0, (0, import_common16.Req)()),
-  _ts_param14(1, (0, import_common16.Param)("messageId")),
-  _ts_param14(2, (0, import_common16.Body)()),
+  (0, import_common17.Patch)("queue/:messageId"),
+  _ts_param14(0, (0, import_common17.Req)()),
+  _ts_param14(1, (0, import_common17.Param)("messageId")),
+  _ts_param14(2, (0, import_common17.Body)()),
   _ts_metadata15("design:type", Function),
   _ts_metadata15("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3810,9 +3868,9 @@ _ts_decorate16([
   _ts_metadata15("design:returntype", Promise)
 ], QueueController.prototype, "update", null);
 _ts_decorate16([
-  (0, import_common16.Post)("queue/:messageId/interrupt"),
-  _ts_param14(0, (0, import_common16.Req)()),
-  _ts_param14(1, (0, import_common16.Param)("messageId")),
+  (0, import_common17.Post)("queue/:messageId/interrupt"),
+  _ts_param14(0, (0, import_common17.Req)()),
+  _ts_param14(1, (0, import_common17.Param)("messageId")),
   _ts_metadata15("design:type", Function),
   _ts_metadata15("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3821,9 +3879,9 @@ _ts_decorate16([
   _ts_metadata15("design:returntype", Promise)
 ], QueueController.prototype, "interrupt", null);
 _ts_decorate16([
-  (0, import_common16.Delete)("queue/:messageId"),
-  _ts_param14(0, (0, import_common16.Req)()),
-  _ts_param14(1, (0, import_common16.Param)("messageId")),
+  (0, import_common17.Delete)("queue/:messageId"),
+  _ts_param14(0, (0, import_common17.Req)()),
+  _ts_param14(1, (0, import_common17.Param)("messageId")),
   _ts_metadata15("design:type", Function),
   _ts_metadata15("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3832,8 +3890,8 @@ _ts_decorate16([
   _ts_metadata15("design:returntype", Promise)
 ], QueueController.prototype, "remove", null);
 QueueController = _ts_decorate16([
-  (0, import_common16.Controller)(),
-  _ts_param14(1, (0, import_common16.Inject)(import_nestjs_agent_core17.AGENT_ACTOR_RESOLVER)),
+  (0, import_common17.Controller)(),
+  _ts_param14(1, (0, import_common17.Inject)(import_nestjs_agent_core18.AGENT_ACTOR_RESOLVER)),
   _ts_metadata15("design:type", Function),
   _ts_metadata15("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
@@ -3842,8 +3900,8 @@ QueueController = _ts_decorate16([
 ], QueueController);
 
 // src/controller/quota.controller.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");
 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") {
@@ -3890,8 +3948,8 @@ var QuotaController = class {
   }
 };
 _ts_decorate17([
-  (0, import_common17.Get)(),
-  _ts_param15(0, (0, import_common17.Req)()),
+  (0, import_common18.Get)(),
+  _ts_param15(0, (0, import_common18.Req)()),
   _ts_metadata16("design:type", Function),
   _ts_metadata16("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request
@@ -3899,8 +3957,8 @@ _ts_decorate17([
   _ts_metadata16("design:returntype", Promise)
 ], QuotaController.prototype, "report", null);
 QuotaController = _ts_decorate17([
-  (0, import_common17.Controller)("quota"),
-  _ts_param15(1, (0, import_common17.Inject)(import_nestjs_agent_core18.AGENT_ACTOR_RESOLVER)),
+  (0, import_common18.Controller)("quota"),
+  _ts_param15(1, (0, import_common18.Inject)(import_nestjs_agent_core19.AGENT_ACTOR_RESOLVER)),
   _ts_metadata16("design:type", Function),
   _ts_metadata16("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
@@ -3909,8 +3967,8 @@ QuotaController = _ts_decorate17([
 ], QuotaController);
 
 // src/controller/skills.controller.ts
-var import_nestjs_agent_core19 = require("@dudousxd/nestjs-agent-core");
-var import_common18 = require("@nestjs/common");
+var import_nestjs_agent_core20 = require("@dudousxd/nestjs-agent-core");
+var import_common19 = require("@nestjs/common");
 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") {
@@ -3952,7 +4010,7 @@ var SkillsController = class {
       return [];
     }
     const actor = await this.actorResolver.resolve(req);
-    const offer = await (0, import_nestjs_agent_core19.offerSkills)(this.skills, {
+    const offer = await (0, import_nestjs_agent_core20.offerSkills)(this.skills, {
       actor,
       threadId: threadId ?? ""
     });
@@ -3960,9 +4018,9 @@ var SkillsController = class {
   }
 };
 _ts_decorate18([
-  (0, import_common18.Get)(),
-  _ts_param16(0, (0, import_common18.Req)()),
-  _ts_param16(1, (0, import_common18.Query)("threadId")),
+  (0, import_common19.Get)(),
+  _ts_param16(0, (0, import_common19.Req)()),
+  _ts_param16(1, (0, import_common19.Query)("threadId")),
   _ts_metadata17("design:type", Function),
   _ts_metadata17("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -3971,10 +4029,10 @@ _ts_decorate18([
   _ts_metadata17("design:returntype", Promise)
 ], SkillsController.prototype, "list", null);
 SkillsController = _ts_decorate18([
-  (0, import_common18.Controller)("skills"),
-  _ts_param16(0, (0, import_common18.Inject)(import_nestjs_agent_core19.AGENT_ACTOR_RESOLVER)),
-  _ts_param16(1, (0, import_common18.Optional)()),
-  _ts_param16(1, (0, import_common18.Inject)(import_nestjs_agent_core19.AGENT_SKILLS)),
+  (0, import_common19.Controller)("skills"),
+  _ts_param16(0, (0, import_common19.Inject)(import_nestjs_agent_core20.AGENT_ACTOR_RESOLVER)),
+  _ts_param16(1, (0, import_common19.Optional)()),
+  _ts_param16(1, (0, import_common19.Inject)(import_nestjs_agent_core20.AGENT_SKILLS)),
   _ts_metadata17("design:type", Function),
   _ts_metadata17("design:paramtypes", [
     typeof ActorResolver === "undefined" ? Object : ActorResolver,
@@ -3983,8 +4041,8 @@ SkillsController = _ts_decorate18([
 ], SkillsController);
 
 // src/controller/threads.controller.ts
-var import_nestjs_agent_core20 = require("@dudousxd/nestjs-agent-core");
-var import_common19 = require("@nestjs/common");
+var import_nestjs_agent_core21 = require("@dudousxd/nestjs-agent-core");
+var import_common20 = require("@nestjs/common");
 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") {
@@ -4078,8 +4136,8 @@ var ThreadsController = class {
   }
 };
 _ts_decorate19([
-  (0, import_common19.Get)(),
-  _ts_param17(0, (0, import_common19.Req)()),
+  (0, import_common20.Get)(),
+  _ts_param17(0, (0, import_common20.Req)()),
   _ts_metadata18("design:type", Function),
   _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request
@@ -4087,9 +4145,9 @@ _ts_decorate19([
   _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "list", null);
 _ts_decorate19([
-  (0, import_common19.Get)(":id"),
-  _ts_param17(0, (0, import_common19.Req)()),
-  _ts_param17(1, (0, import_common19.Param)("id")),
+  (0, import_common20.Get)(":id"),
+  _ts_param17(0, (0, import_common20.Req)()),
+  _ts_param17(1, (0, import_common20.Param)("id")),
   _ts_metadata18("design:type", Function),
   _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -4098,9 +4156,9 @@ _ts_decorate19([
   _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "detail", null);
 _ts_decorate19([
-  (0, import_common19.Delete)(":id"),
-  _ts_param17(0, (0, import_common19.Req)()),
-  _ts_param17(1, (0, import_common19.Param)("id")),
+  (0, import_common20.Delete)(":id"),
+  _ts_param17(0, (0, import_common20.Req)()),
+  _ts_param17(1, (0, import_common20.Param)("id")),
   _ts_metadata18("design:type", Function),
   _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -4109,10 +4167,10 @@ _ts_decorate19([
   _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "remove", null);
 _ts_decorate19([
-  (0, import_common19.Post)(":id/fork-from/:messageId"),
-  _ts_param17(0, (0, import_common19.Req)()),
-  _ts_param17(1, (0, import_common19.Param)("id")),
-  _ts_param17(2, (0, import_common19.Param)("messageId")),
+  (0, import_common20.Post)(":id/fork-from/:messageId"),
+  _ts_param17(0, (0, import_common20.Req)()),
+  _ts_param17(1, (0, import_common20.Param)("id")),
+  _ts_param17(2, (0, import_common20.Param)("messageId")),
   _ts_metadata18("design:type", Function),
   _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -4122,10 +4180,10 @@ _ts_decorate19([
   _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "fork", null);
 _ts_decorate19([
-  (0, import_common19.Patch)(":id"),
-  _ts_param17(0, (0, import_common19.Req)()),
-  _ts_param17(1, (0, import_common19.Param)("id")),
-  _ts_param17(2, (0, import_common19.Body)()),
+  (0, import_common20.Patch)(":id"),
+  _ts_param17(0, (0, import_common20.Req)()),
+  _ts_param17(1, (0, import_common20.Param)("id")),
+  _ts_param17(2, (0, import_common20.Body)()),
   _ts_metadata18("design:type", Function),
   _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -4135,9 +4193,9 @@ _ts_decorate19([
   _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "update", null);
 _ts_decorate19([
-  (0, import_common19.Post)(":id/promote"),
-  _ts_param17(0, (0, import_common19.Req)()),
-  _ts_param17(1, (0, import_common19.Param)("id")),
+  (0, import_common20.Post)(":id/promote"),
+  _ts_param17(0, (0, import_common20.Req)()),
+  _ts_param17(1, (0, import_common20.Param)("id")),
   _ts_metadata18("design:type", Function),
   _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -4146,10 +4204,10 @@ _ts_decorate19([
   _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "promote", null);
 _ts_decorate19([
-  (0, import_common19.Delete)(":id/from/:messageId"),
-  _ts_param17(0, (0, import_common19.Req)()),
-  _ts_param17(1, (0, import_common19.Param)("id")),
-  _ts_param17(2, (0, import_common19.Param)("messageId")),
+  (0, import_common20.Delete)(":id/from/:messageId"),
+  _ts_param17(0, (0, import_common20.Req)()),
+  _ts_param17(1, (0, import_common20.Param)("id")),
+  _ts_param17(2, (0, import_common20.Param)("messageId")),
   _ts_metadata18("design:type", Function),
   _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -4159,8 +4217,8 @@ _ts_decorate19([
   _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "truncateFrom", null);
 ThreadsController = _ts_decorate19([
-  (0, import_common19.Controller)("threads"),
-  _ts_param17(1, (0, import_common19.Inject)(import_nestjs_agent_core20.AGENT_ACTOR_RESOLVER)),
+  (0, import_common20.Controller)("threads"),
+  _ts_param17(1, (0, import_common20.Inject)(import_nestjs_agent_core21.AGENT_ACTOR_RESOLVER)),
   _ts_metadata18("design:type", Function),
   _ts_metadata18("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
@@ -4169,8 +4227,8 @@ ThreadsController = _ts_decorate19([
 ], ThreadsController);
 
 // src/controller/tool-call.controller.ts
-var import_nestjs_agent_core21 = require("@dudousxd/nestjs-agent-core");
-var import_common20 = require("@nestjs/common");
+var import_nestjs_agent_core22 = require("@dudousxd/nestjs-agent-core");
+var import_common21 = 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") {
@@ -4205,7 +4263,7 @@ var MAX_VIA_LENGTH = 64;
 var DEFAULT_VIA = "web";
 function toolCallId(claimed) {
   if (typeof claimed !== "string" || claimed.length === 0) {
-    throw new import_common20.BadRequestException("toolCallId must be a non-empty string");
+    throw new import_common21.BadRequestException("toolCallId must be a non-empty string");
   }
   return claimed;
 }
@@ -4215,10 +4273,10 @@ function rejectReason(claimed) {
     return void 0;
   }
   if (typeof claimed !== "string") {
-    throw new import_common20.BadRequestException("reason must be a string");
+    throw new import_common21.BadRequestException("reason must be a string");
   }
   if (claimed.length > MAX_REJECT_REASON_LENGTH) {
-    throw new import_common20.BadRequestException(`reason must be at most ${MAX_REJECT_REASON_LENGTH} characters`);
+    throw new import_common21.BadRequestException(`reason must be at most ${MAX_REJECT_REASON_LENGTH} characters`);
   }
   return claimed;
 }
@@ -4228,7 +4286,7 @@ function remember(claimed) {
     return false;
   }
   if (typeof claimed !== "boolean") {
-    throw new import_common20.BadRequestException("remember must be a boolean");
+    throw new import_common21.BadRequestException("remember must be a boolean");
   }
   return claimed;
 }
@@ -4238,7 +4296,7 @@ function via(claimed) {
     return DEFAULT_VIA;
   }
   if (typeof claimed !== "string" || claimed.length === 0 || claimed.length > MAX_VIA_LENGTH) {
-    throw new import_common20.BadRequestException(`via must be a string of 1-${MAX_VIA_LENGTH} characters`);
+    throw new import_common21.BadRequestException(`via must be a string of 1-${MAX_VIA_LENGTH} characters`);
   }
   return claimed;
 }
@@ -4248,26 +4306,26 @@ function answers(claimed) {
     return void 0;
   }
   if (typeof claimed !== "object" || claimed === null || Array.isArray(claimed)) {
-    throw new import_common20.BadRequestException("answers must be an object of questionId \u2192 chosen values");
+    throw new import_common21.BadRequestException("answers must be an object of questionId \u2192 chosen values");
   }
   const entries = Object.entries(claimed);
   if (entries.length > MAX_ANSWERED_QUESTIONS) {
-    throw new import_common20.BadRequestException(`answers may cover at most ${MAX_ANSWERED_QUESTIONS} questions`);
+    throw new import_common21.BadRequestException(`answers may cover at most ${MAX_ANSWERED_QUESTIONS} questions`);
   }
   const validated = /* @__PURE__ */ Object.create(null);
   for (const [questionId, values] of entries) {
     if (!Array.isArray(values)) {
-      throw new import_common20.BadRequestException(`answers["${questionId}"] must be an array of chosen values`);
+      throw new import_common21.BadRequestException(`answers["${questionId}"] must be an array of chosen values`);
     }
     if (values.length > MAX_VALUES_PER_QUESTION) {
-      throw new import_common20.BadRequestException(`answers["${questionId}"] may carry at most ${MAX_VALUES_PER_QUESTION} values`);
+      throw new import_common21.BadRequestException(`answers["${questionId}"] may carry at most ${MAX_VALUES_PER_QUESTION} values`);
     }
     for (const value of values) {
       if (typeof value !== "string") {
-        throw new import_common20.BadRequestException(`answers["${questionId}"] must contain only strings`);
+        throw new import_common21.BadRequestException(`answers["${questionId}"] must contain only strings`);
       }
       if (value.length > MAX_ANSWER_VALUE_LENGTH) {
-        throw new import_common20.BadRequestException(`answers["${questionId}"] values must be at most ${MAX_ANSWER_VALUE_LENGTH} characters`);
+        throw new import_common21.BadRequestException(`answers["${questionId}"] values must be at most ${MAX_ANSWER_VALUE_LENGTH} characters`);
       }
     }
     validated[questionId] = values;
@@ -4330,9 +4388,9 @@ var ToolCallController = class {
   }
 };
 _ts_decorate20([
-  (0, import_common20.Post)("approve"),
-  _ts_param18(0, (0, import_common20.Req)()),
-  _ts_param18(1, (0, import_common20.Body)()),
+  (0, import_common21.Post)("approve"),
+  _ts_param18(0, (0, import_common21.Req)()),
+  _ts_param18(1, (0, import_common21.Body)()),
   _ts_metadata19("design:type", Function),
   _ts_metadata19("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -4341,9 +4399,9 @@ _ts_decorate20([
   _ts_metadata19("design:returntype", Promise)
 ], ToolCallController.prototype, "approve", null);
 _ts_decorate20([
-  (0, import_common20.Post)("reject"),
-  _ts_param18(0, (0, import_common20.Req)()),
-  _ts_param18(1, (0, import_common20.Body)()),
+  (0, import_common21.Post)("reject"),
+  _ts_param18(0, (0, import_common21.Req)()),
+  _ts_param18(1, (0, import_common21.Body)()),
   _ts_metadata19("design:type", Function),
   _ts_metadata19("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -4352,9 +4410,9 @@ _ts_decorate20([
   _ts_metadata19("design:returntype", Promise)
 ], ToolCallController.prototype, "reject", null);
 _ts_decorate20([
-  (0, import_common20.Post)("answer"),
-  _ts_param18(0, (0, import_common20.Req)()),
-  _ts_param18(1, (0, import_common20.Body)()),
+  (0, import_common21.Post)("answer"),
+  _ts_param18(0, (0, import_common21.Req)()),
+  _ts_param18(1, (0, import_common21.Body)()),
   _ts_metadata19("design:type", Function),
   _ts_metadata19("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -4363,9 +4421,9 @@ _ts_decorate20([
   _ts_metadata19("design:returntype", Promise)
 ], ToolCallController.prototype, "answer", null);
 _ts_decorate20([
-  (0, import_common20.Post)("skip"),
-  _ts_param18(0, (0, import_common20.Req)()),
-  _ts_param18(1, (0, import_common20.Body)()),
+  (0, import_common21.Post)("skip"),
+  _ts_param18(0, (0, import_common21.Req)()),
+  _ts_param18(1, (0, import_common21.Body)()),
   _ts_metadata19("design:type", Function),
   _ts_metadata19("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -4374,8 +4432,8 @@ _ts_decorate20([
   _ts_metadata19("design:returntype", Promise)
 ], ToolCallController.prototype, "skip", null);
 ToolCallController = _ts_decorate20([
-  (0, import_common20.Controller)("tool-call"),
-  _ts_param18(1, (0, import_common20.Inject)(import_nestjs_agent_core21.AGENT_ACTOR_RESOLVER)),
+  (0, import_common21.Controller)("tool-call"),
+  _ts_param18(1, (0, import_common21.Inject)(import_nestjs_agent_core22.AGENT_ACTOR_RESOLVER)),
   _ts_metadata19("design:type", Function),
   _ts_metadata19("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
@@ -4384,8 +4442,8 @@ ToolCallController = _ts_decorate20([
 ], ToolCallController);
 
 // src/controller/tools.controller.ts
-var import_nestjs_agent_core22 = require("@dudousxd/nestjs-agent-core");
-var import_common21 = require("@nestjs/common");
+var import_nestjs_agent_core23 = require("@dudousxd/nestjs-agent-core");
+var import_common22 = require("@nestjs/common");
 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") {
@@ -4425,11 +4483,11 @@ var ToolsController = class {
     this.agents = agents;
   }
   async list(req, agent) {
-    if (agent !== void 0 && agent !== import_nestjs_agent_core22.ALL_AGENTS && this.agents.get(agent) === void 0) {
-      throw new import_common21.NotFoundException(`No agent named "${agent}"`);
+    if (agent !== void 0 && agent !== import_nestjs_agent_core23.ALL_AGENTS && this.agents.get(agent) === void 0) {
+      throw new import_common22.NotFoundException(`No agent named "${agent}"`);
     }
     const actor = await this.actorResolver.resolve(req);
-    const names = agent === import_nestjs_agent_core22.ALL_AGENTS ? [
+    const names = agent === import_nestjs_agent_core23.ALL_AGENTS ? [
       void 0,
       ...this.agents.list().map((definition) => definition.name)
     ] : [
@@ -4456,9 +4514,9 @@ var ToolsController = class {
   }
 };
 _ts_decorate21([
-  (0, import_common21.Get)(),
-  _ts_param19(0, (0, import_common21.Req)()),
-  _ts_param19(1, (0, import_common21.Query)("agent")),
+  (0, import_common22.Get)(),
+  _ts_param19(0, (0, import_common22.Req)()),
+  _ts_param19(1, (0, import_common22.Query)("agent")),
   _ts_metadata20("design:type", Function),
   _ts_metadata20("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
@@ -4467,21 +4525,21 @@ _ts_decorate21([
   _ts_metadata20("design:returntype", Promise)
 ], ToolsController.prototype, "list", null);
 ToolsController = _ts_decorate21([
-  (0, import_common21.Controller)("tools"),
-  _ts_param19(0, (0, import_common21.Inject)(import_nestjs_agent_core22.AGENT_ACTOR_RESOLVER)),
-  _ts_param19(1, (0, import_common21.Inject)(import_nestjs_agent_core22.AGENT_DEPS_FACTORY)),
-  _ts_param19(2, (0, import_common21.Inject)(import_nestjs_agent_core22.AGENT_REGISTRY)),
+  (0, import_common22.Controller)("tools"),
+  _ts_param19(0, (0, import_common22.Inject)(import_nestjs_agent_core23.AGENT_ACTOR_RESOLVER)),
+  _ts_param19(1, (0, import_common22.Inject)(import_nestjs_agent_core23.AGENT_DEPS_FACTORY)),
+  _ts_param19(2, (0, import_common22.Inject)(import_nestjs_agent_core23.AGENT_REGISTRY)),
   _ts_metadata20("design:type", Function),
   _ts_metadata20("design:paramtypes", [
     typeof ActorResolver === "undefined" ? Object : ActorResolver,
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
-    typeof import_nestjs_agent_core22.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core22.AgentRegistry
+    typeof import_nestjs_agent_core23.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core23.AgentRegistry
   ])
 ], ToolsController);
 
 // src/discovery/agent-discovery.service.ts
-var import_nestjs_agent_core23 = require("@dudousxd/nestjs-agent-core");
-var import_common22 = require("@nestjs/common");
+var import_nestjs_agent_core24 = require("@dudousxd/nestjs-agent-core");
+var import_common23 = require("@nestjs/common");
 var import_core = require("@nestjs/core");
 
 // src/decorator/agent.decorator.ts
@@ -4532,7 +4590,7 @@ var AgentDiscoveryService = class _AgentDiscoveryService {
   scanner;
   registry;
   contributors;
-  logger = new import_common22.Logger(_AgentDiscoveryService.name);
+  logger = new import_common23.Logger(_AgentDiscoveryService.name);
   constructor(discovery, scanner, registry, contributors) {
     this.discovery = discovery;
     this.scanner = scanner;
@@ -4651,21 +4709,21 @@ var AgentDiscoveryService = class _AgentDiscoveryService {
   }
 };
 AgentDiscoveryService = _ts_decorate22([
-  (0, import_common22.Injectable)(),
-  _ts_param20(2, (0, import_common22.Inject)(import_nestjs_agent_core23.AGENT_REGISTRY)),
-  _ts_param20(3, (0, import_common22.Inject)(import_nestjs_agent_core23.AGENT_PROMPT_CONTRIBUTORS)),
+  (0, import_common23.Injectable)(),
+  _ts_param20(2, (0, import_common23.Inject)(import_nestjs_agent_core24.AGENT_REGISTRY)),
+  _ts_param20(3, (0, import_common23.Inject)(import_nestjs_agent_core24.AGENT_PROMPT_CONTRIBUTORS)),
   _ts_metadata21("design:type", Function),
   _ts_metadata21("design:paramtypes", [
     typeof import_core.DiscoveryService === "undefined" ? Object : import_core.DiscoveryService,
     typeof import_core.MetadataScanner === "undefined" ? Object : import_core.MetadataScanner,
-    typeof import_nestjs_agent_core23.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core23.AgentRegistry,
+    typeof import_nestjs_agent_core24.AgentRegistry === "undefined" ? Object : import_nestjs_agent_core24.AgentRegistry,
     Array
   ])
 ], AgentDiscoveryService);
 
 // src/discovery/ai-tool-discovery.service.ts
-var import_nestjs_agent_core24 = require("@dudousxd/nestjs-agent-core");
-var import_common23 = require("@nestjs/common");
+var import_nestjs_agent_core25 = require("@dudousxd/nestjs-agent-core");
+var import_common24 = require("@nestjs/common");
 var import_core2 = require("@nestjs/core");
 var import_zod = require("zod");
 
@@ -4719,7 +4777,7 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
   registry;
   agents;
   options;
-  logger = new import_common23.Logger(_AiToolDiscoveryService.name);
+  logger = new import_common24.Logger(_AiToolDiscoveryService.name);
   constructor(discovery, registry, agents, options) {
     this.discovery = discovery;
     this.registry = registry;
@@ -4804,7 +4862,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_core24.normalizeDelegation)(edge);
+        const { agent: target, detached } = (0, import_nestjs_agent_core25.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.`);
@@ -4855,10 +4913,10 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
   }
 };
 AiToolDiscoveryService = _ts_decorate23([
-  (0, import_common23.Injectable)(),
-  _ts_param21(1, (0, import_common23.Inject)(import_nestjs_agent_core24.AGENT_TOOL_REGISTRY)),
-  _ts_param21(2, (0, import_common23.Inject)(import_nestjs_agent_core24.AGENT_REGISTRY)),
-  _ts_param21(3, (0, import_common23.Inject)(import_nestjs_agent_core24.AGENT_OPTIONS)),
+  (0, import_common24.Injectable)(),
+  _ts_param21(1, (0, import_common24.Inject)(import_nestjs_agent_core25.AGENT_TOOL_REGISTRY)),
+  _ts_param21(2, (0, import_common24.Inject)(import_nestjs_agent_core25.AGENT_REGISTRY)),
+  _ts_param21(3, (0, import_common24.Inject)(import_nestjs_agent_core25.AGENT_OPTIONS)),
   _ts_metadata22("design:type", Function),
   _ts_metadata22("design:paramtypes", [
     typeof import_core2.DiscoveryService === "undefined" ? Object : import_core2.DiscoveryService,
@@ -4869,20 +4927,20 @@ AiToolDiscoveryService = _ts_decorate23([
 ], AiToolDiscoveryService);
 
 // src/discovery/skill-discovery.service.ts
-var import_nestjs_agent_core26 = require("@dudousxd/nestjs-agent-core");
-var import_common24 = require("@nestjs/common");
+var import_nestjs_agent_core27 = require("@dudousxd/nestjs-agent-core");
+var import_common25 = 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_core25 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core26 = 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_core25.GLOBAL_SCOPE;
+  return options.scope ?? import_nestjs_agent_core26.GLOBAL_SCOPE;
 }
 __name(skillScope, "skillScope");
 
@@ -4919,7 +4977,7 @@ var SkillDiscoveryService = class _SkillDiscoveryService {
   }
   discovery;
   declared;
-  logger = new import_common24.Logger(_SkillDiscoveryService.name);
+  logger = new import_common25.Logger(_SkillDiscoveryService.name);
   constructor(discovery, declared) {
     this.discovery = discovery;
     this.declared = declared;
@@ -4957,8 +5015,8 @@ var SkillDiscoveryService = class _SkillDiscoveryService {
   }
 };
 SkillDiscoveryService = _ts_decorate24([
-  (0, import_common24.Injectable)(),
-  _ts_param22(1, (0, import_common24.Inject)(import_nestjs_agent_core26.AGENT_SKILL_SOURCES)),
+  (0, import_common25.Injectable)(),
+  _ts_param22(1, (0, import_common25.Inject)(import_nestjs_agent_core27.AGENT_SKILL_SOURCES)),
   _ts_metadata23("design:type", Function),
   _ts_metadata23("design:paramtypes", [
     typeof import_core3.DiscoveryService === "undefined" ? Object : import_core3.DiscoveryService,
@@ -4967,7 +5025,7 @@ SkillDiscoveryService = _ts_decorate24([
 ], SkillDiscoveryService);
 
 // src/ledger-quota-provider.ts
-var import_nestjs_agent_core27 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core28 = require("@dudousxd/nestjs-agent-core");
 var LedgerQuotaProvider = class {
   static {
     __name(this, "LedgerQuotaProvider");
@@ -4987,12 +5045,12 @@ var LedgerQuotaProvider = class {
       await this.dayWindow(actorRef, now)
     ];
     if (this.store.usageBetween !== void 0) {
-      const range = (0, import_nestjs_agent_core27.quotaPeriodRange)("month", now);
+      const range = (0, import_nestjs_agent_core28.quotaPeriodRange)("month", now);
       const used = await this.store.usageBetween(actorRef, range.fromDay, range.toDay);
       windows.push(this.window("month", used.usedTokens, used.costUsd, range.resetsAt));
     }
-    const blocked = (0, import_nestjs_agent_core27.exhaustedWindow)(windows);
-    const warning = (0, import_nestjs_agent_core27.quotaWarning)(windows);
+    const blocked = (0, import_nestjs_agent_core28.exhaustedWindow)(windows);
+    const warning = (0, import_nestjs_agent_core28.quotaWarning)(windows);
     return {
       windows,
       ...blocked !== void 0 ? {
@@ -5004,7 +5062,7 @@ var LedgerQuotaProvider = class {
     };
   }
   async dayWindow(actorRef, now) {
-    const range = (0, import_nestjs_agent_core27.quotaPeriodRange)("day", now);
+    const range = (0, import_nestjs_agent_core28.quotaPeriodRange)("day", now);
     const { usedTokens, costUsd } = await this.store.quotaToday(actorRef, range.fromDay);
     return this.window("day", usedTokens, costUsd, range.resetsAt);
   }
@@ -5029,8 +5087,8 @@ var LedgerQuotaProvider = class {
 };
 
 // src/runner/inline-agent-runner.ts
-var import_nestjs_agent_core28 = require("@dudousxd/nestjs-agent-core");
-var import_common25 = require("@nestjs/common");
+var import_nestjs_agent_core29 = require("@dudousxd/nestjs-agent-core");
+var import_common26 = require("@nestjs/common");
 function _ts_decorate25(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") {
@@ -5064,7 +5122,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
   factory;
   store;
   queue;
-  logger = new import_common25.Logger(_InlineAgentRunner.name);
+  logger = new import_common26.Logger(_InlineAgentRunner.name);
   pending = /* @__PURE__ */ new Map();
   /**
   * Runs someone has asked to stop. In-process, like `pending`, and for the same reason: this runner
@@ -5084,7 +5142,15 @@ var InlineAgentRunner = class _InlineAgentRunner {
   * that was running it is gone (a restart), and a thread it still holds is a stale claim.
   */
   async isRunActive(runId) {
-    return this.live.has(runId);
+    if (this.live.has(runId)) {
+      return true;
+    }
+    for (const key of this.pending.keys()) {
+      if (key.startsWith(`${runId}:`)) {
+        return true;
+      }
+    }
+    return false;
   }
   async start(input, options = {}) {
     const runId = options.runId ?? crypto.randomUUID();
@@ -5105,18 +5171,18 @@ var InlineAgentRunner = class _InlineAgentRunner {
       ],
       input
     });
-    void (0, import_nestjs_agent_core28.runAgentLoop)({
+    void (0, import_nestjs_agent_core29.runAgentLoop)({
       ...deps,
       day
-    }, input, hooks).then(() => (0, import_nestjs_agent_core28.releaseThreadRun)(this.store, input.threadId, runId)).catch(async (error) => {
-      if (error instanceof import_nestjs_agent_core28.RunCancelledError) {
+    }, input, hooks).then(() => (0, import_nestjs_agent_core29.releaseThreadRun)(this.store, input.threadId, runId)).catch(async (error) => {
+      if (error instanceof import_nestjs_agent_core29.RunCancelledError) {
         await this.settleCancelled(runId, input, deps);
         return;
       }
       const message = error instanceof Error ? error.message : String(error);
-      const code = (0, import_nestjs_agent_core28.agentFailureCode)(error);
+      const code = (0, import_nestjs_agent_core29.agentFailureCode)(error);
       this.logger.error(`agent run ${runId} failed (${code}): ${message}`);
-      (0, import_nestjs_agent_core28.publishAgentRunFailed)({
+      (0, import_nestjs_agent_core29.publishAgentRunFailed)({
         runId,
         code,
         message
@@ -5127,13 +5193,11 @@ var InlineAgentRunner = class _InlineAgentRunner {
         errorCode: code,
         errorMessage: message
       });
+      await Promise.resolve(this.store.failUnsettledToolCalls?.(runId, import_nestjs_agent_core29.RUN_ENDED_BEFORE_TOOL_CALL)).catch(() => 0);
       const writer = await deps.sink.open(runId);
       await this.settleQueue(writer, input, runId, "failed", message);
-      await (0, import_nestjs_agent_core28.releaseThreadRun)(this.store, input.threadId, runId);
-      await writer.fail({
-        code,
-        message
-      });
+      await (0, import_nestjs_agent_core29.releaseThreadRun)(this.store, input.threadId, runId);
+      await writer.fail((0, import_nestjs_agent_core29.streamFailure)(error));
     }).finally(() => {
       this.cancelled.delete(runId);
       this.live.delete(runId);
@@ -5169,7 +5233,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_core28.RunCancelledError());
+        waiter.reject(new import_nestjs_agent_core29.RunCancelledError());
       }
     }
     await Promise.resolve();
@@ -5184,8 +5248,8 @@ var InlineAgentRunner = class _InlineAgentRunner {
     this.logger.log(`agent run ${runId} cancelled`);
     const writer = await deps.sink.open(runId);
     await this.settleQueue(writer, input, runId, "cancelled");
-    await (0, import_nestjs_agent_core28.releaseThreadRun)(this.store, input.threadId, runId);
-    await writer.write((0, import_nestjs_agent_core28.encodeStreamEvent)({
+    await (0, import_nestjs_agent_core29.releaseThreadRun)(this.store, input.threadId, runId);
+    await writer.write((0, import_nestjs_agent_core29.encodeStreamEvent)({
       kind: "cancelled"
     }));
     await writer.end();
@@ -5220,7 +5284,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
         runId: nextRunId
       }));
       if (frame !== void 0) {
-        await writer.write((0, import_nestjs_agent_core28.encodeStreamEvent)(frame));
+        await writer.write((0, import_nestjs_agent_core29.encodeStreamEvent)(frame));
       }
     } catch (failure) {
       this.logger.error(`could not advance the queue of thread ${input.threadId} after run ${runId}: ${failure instanceof Error ? failure.message : String(failure)}`);
@@ -5291,7 +5355,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
       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_core28.settleAll,
+      parallel: import_nestjs_agent_core29.settleAll,
       cancelled: /* @__PURE__ */ __name(async () => this.cancelled.has(runId), "cancelled"),
       runAgent: /* @__PURE__ */ __name((agentName, task) => this.runNested({
         agentName,
@@ -5342,7 +5406,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
       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_core28.settleAll,
+      parallel: import_nestjs_agent_core29.settleAll,
       cancelled: /* @__PURE__ */ __name(async () => this.cancelled.has(runId), "cancelled"),
       runAgent: /* @__PURE__ */ __name((childName, childTask) => this.runNested({
         agentName: childName,
@@ -5375,7 +5439,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
         }
       }), "startAgent")
     };
-    void (0, import_nestjs_agent_core28.runAgentLoop)({
+    void (0, import_nestjs_agent_core29.runAgentLoop)({
       ...deps,
       day
     }, {
@@ -5389,13 +5453,13 @@ var InlineAgentRunner = class _InlineAgentRunner {
       parentRunId,
       deliverTo
     }, hooks).catch(async (error) => {
-      const cancelled = error instanceof import_nestjs_agent_core28.RunCancelledError;
+      const cancelled = error instanceof import_nestjs_agent_core29.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_core28.publishAgentRunFailed)({
+        (0, import_nestjs_agent_core29.publishAgentRunFailed)({
           runId,
-          code: (0, import_nestjs_agent_core28.agentFailureCode)(error),
+          code: (0, import_nestjs_agent_core29.agentFailureCode)(error),
           message
         });
       }
@@ -5403,11 +5467,12 @@ var InlineAgentRunner = class _InlineAgentRunner {
         runId,
         status: cancelled ? "cancelled" : "failed",
         ...cancelled ? {} : {
-          errorCode: (0, import_nestjs_agent_core28.agentFailureCode)(error),
+          errorCode: (0, import_nestjs_agent_core29.agentFailureCode)(error),
           errorMessage: message
         }
       });
-      await (0, import_nestjs_agent_core28.settleUnsettledDelegation)({
+      await Promise.resolve(this.store.failUnsettledToolCalls?.(runId, import_nestjs_agent_core29.RUN_ENDED_BEFORE_TOOL_CALL)).catch(() => 0);
+      await (0, import_nestjs_agent_core29.settleUnsettledDelegation)({
         store: this.store,
         delivery: deliverTo,
         agent: agentName,
@@ -5446,7 +5511,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
       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_core28.settleAll,
+      parallel: import_nestjs_agent_core29.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"),
@@ -5481,7 +5546,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
       }), "startAgent")
     };
     try {
-      return await (0, import_nestjs_agent_core28.runAgentLoop)({
+      return await (0, import_nestjs_agent_core29.runAgentLoop)({
         ...deps,
         day
       }, {
@@ -5501,15 +5566,15 @@ var InlineAgentRunner = class _InlineAgentRunner {
   }
 };
 InlineAgentRunner = _ts_decorate25([
-  (0, import_common25.Injectable)(),
-  _ts_param23(0, (0, import_common25.Inject)(import_nestjs_agent_core28.AGENT_DEPS_FACTORY)),
-  _ts_param23(1, (0, import_common25.Inject)(import_nestjs_agent_core28.AGENT_STORE)),
-  _ts_param23(2, (0, import_common25.Optional)()),
+  (0, import_common26.Injectable)(),
+  _ts_param23(0, (0, import_common26.Inject)(import_nestjs_agent_core29.AGENT_DEPS_FACTORY)),
+  _ts_param23(1, (0, import_common26.Inject)(import_nestjs_agent_core29.AGENT_STORE)),
+  _ts_param23(2, (0, import_common26.Optional)()),
   _ts_metadata24("design:type", Function),
   _ts_metadata24("design:paramtypes", [
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
     typeof AgentStore === "undefined" ? Object : AgentStore,
-    typeof ChatQueueService === "undefined" ? Object : ChatQueueService
+    typeof ChatQueueService2 === "undefined" ? Object : ChatQueueService2
   ])
 ], InlineAgentRunner);
 function isThreadTurn2(input) {
@@ -5518,7 +5583,7 @@ function isThreadTurn2(input) {
 __name(isThreadTurn2, "isThreadTurn");
 
 // src/skills-config.ts
-var import_nestjs_agent_core29 = require("@dudousxd/nestjs-agent-core");
+var import_nestjs_agent_core30 = require("@dudousxd/nestjs-agent-core");
 function declaredSkillProvider(declared) {
   return {
     list: /* @__PURE__ */ __name(({ scopes }) => declared.filter((skill) => scopes.includes(skill.scope)).map(({ name, description, scope }) => ({
@@ -5544,7 +5609,7 @@ function resolveSkillsConfig(options, declared) {
     declaredSkillProvider(declared)
   ];
   return {
-    provider: providers.length === 1 ? providers[0] : (0, import_nestjs_agent_core29.compositeSkillProvider)(providers),
+    provider: providers.length === 1 ? providers[0] : (0, import_nestjs_agent_core30.compositeSkillProvider)(providers),
     ...options.scopes !== void 0 ? {
       scopes: options.scopes
     } : {},
@@ -5571,11 +5636,11 @@ function _ts_decorate26(decorators, target, key, desc) {
 }
 __name(_ts_decorate26, "_ts_decorate");
 var DEFAULT_PATH = "agent";
-var logger = new import_common26.Logger("AgentModule");
+var logger = new import_common27.Logger("AgentModule");
 function externalStoreWrapper(modules) {
   for (const module2 of modules.values()) {
     if (module2.metatype === AgentModule) continue;
-    const wrapper = module2.providers.get(import_nestjs_agent_core30.AGENT_STORE);
+    const wrapper = module2.providers.get(import_nestjs_agent_core31.AGENT_STORE);
     if (wrapper !== void 0) return wrapper;
   }
   return void 0;
@@ -5606,7 +5671,7 @@ function resolveStore(options, modules) {
   const external = externalStoreWrapper(modules);
   if (external !== void 0) return forwardingStore(external);
   logger.warn("No `store` configured and no store module imported \u2014 using the in-memory store. Threads are lost on restart and not shared between processes: not for production. Pass `store`, or import a store module (e.g. MikroOrmAgentStoreModule.forFeature()).");
-  return new import_nestjs_agent_core30.InMemoryAgentStore();
+  return new import_nestjs_agent_core31.InMemoryAgentStore();
 }
 __name(resolveStore, "resolveStore");
 function isQuotaProvider(quota) {
@@ -5622,99 +5687,99 @@ __name(resolveCatalog, "resolveCatalog");
 function sharedProviders(durable) {
   const providers = [
     {
-      provide: import_nestjs_agent_core30.AGENT_TOOL_REGISTRY,
-      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core30.ToolRegistry(), "useFactory")
+      provide: import_nestjs_agent_core31.AGENT_TOOL_REGISTRY,
+      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core31.ToolRegistry(), "useFactory")
     },
     // Starts empty; AgentDiscoveryService populates it from `@Agent`-decorated providers at boot.
     {
-      provide: import_nestjs_agent_core30.AGENT_REGISTRY,
-      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core30.AgentRegistry(), "useFactory")
+      provide: import_nestjs_agent_core31.AGENT_REGISTRY,
+      useFactory: /* @__PURE__ */ __name(() => new import_nestjs_agent_core31.AgentRegistry(), "useFactory")
     },
     // A shared, mutable list AgentDiscoveryService fills with `@SystemPromptContributor()` methods.
     {
-      provide: import_nestjs_agent_core30.AGENT_PROMPT_CONTRIBUTORS,
+      provide: import_nestjs_agent_core31.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_core30.AGENT_SKILL_SOURCES,
+      provide: import_nestjs_agent_core31.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_core30.AGENT_SKILLS,
+      provide: import_nestjs_agent_core31.AGENT_SKILLS,
       useFactory: /* @__PURE__ */ __name((options, declared) => resolveSkillsConfig(options.skills, declared), "useFactory"),
       inject: [
-        import_nestjs_agent_core30.AGENT_OPTIONS,
-        import_nestjs_agent_core30.AGENT_SKILL_SOURCES
+        import_nestjs_agent_core31.AGENT_OPTIONS,
+        import_nestjs_agent_core31.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_core30.AGENT_MEMORY,
+      provide: import_nestjs_agent_core31.AGENT_MEMORY,
       useFactory: /* @__PURE__ */ __name((options) => options.memory, "useFactory"),
       inject: [
-        import_nestjs_agent_core30.AGENT_OPTIONS
+        import_nestjs_agent_core31.AGENT_OPTIONS
       ]
     },
     {
-      provide: import_nestjs_agent_core30.AGENT_SINK,
+      provide: import_nestjs_agent_core31.AGENT_SINK,
       useFactory: /* @__PURE__ */ __name((options) => options.sink ?? new InProcessTokenStreamSink(), "useFactory"),
       inject: [
-        import_nestjs_agent_core30.AGENT_OPTIONS
+        import_nestjs_agent_core31.AGENT_OPTIONS
       ]
     },
     {
-      provide: import_nestjs_agent_core30.AGENT_ROLES_POLICY,
-      useFactory: /* @__PURE__ */ __name((options) => options.rolesPolicy ?? new import_nestjs_agent_core30.DefaultRolesPolicy(options.defaultRoles), "useFactory"),
+      provide: import_nestjs_agent_core31.AGENT_ROLES_POLICY,
+      useFactory: /* @__PURE__ */ __name((options) => options.rolesPolicy ?? new import_nestjs_agent_core31.DefaultRolesPolicy(options.defaultRoles), "useFactory"),
       inject: [
-        import_nestjs_agent_core30.AGENT_OPTIONS
+        import_nestjs_agent_core31.AGENT_OPTIONS
       ]
     },
     {
-      provide: import_nestjs_agent_core30.AGENT_ACTOR_RESOLVER,
+      provide: import_nestjs_agent_core31.AGENT_ACTOR_RESOLVER,
       useFactory: /* @__PURE__ */ __name((options) => {
         if (options.actorResolver !== void 0) return options.actorResolver;
         logger.warn("No `actorResolver` configured \u2014 the agent endpoints are PUBLIC: every browser gets its own anonymous identity (an HttpOnly cookie). Set `actorResolver: requestUserActorResolver()` (or your own) to require login.");
         return new AnonymousActorResolver();
       }, "useFactory"),
       inject: [
-        import_nestjs_agent_core30.AGENT_OPTIONS
+        import_nestjs_agent_core31.AGENT_OPTIONS
       ]
     },
     {
-      provide: import_nestjs_agent_core30.AGENT_MODEL,
+      provide: import_nestjs_agent_core31.AGENT_MODEL,
       useFactory: /* @__PURE__ */ __name((o) => o.model, "useFactory"),
       inject: [
-        import_nestjs_agent_core30.AGENT_OPTIONS
+        import_nestjs_agent_core31.AGENT_OPTIONS
       ]
     },
     {
       // `quota` is either a provider of the host's own or ceilings for the built-in ledger one;
       // omitted, the ledger provider still reports usage, with no ceiling to block on.
-      provide: import_nestjs_agent_core30.AGENT_QUOTA_PROVIDER,
+      provide: import_nestjs_agent_core31.AGENT_QUOTA_PROVIDER,
       useFactory: /* @__PURE__ */ __name((o, store) => isQuotaProvider(o.quota) ? o.quota : new LedgerQuotaProvider(store, o.quota?.limits, o.quota?.warnAt !== void 0 ? {
         warnAt: o.quota.warnAt
       } : {}), "useFactory"),
       inject: [
-        import_nestjs_agent_core30.AGENT_OPTIONS,
-        import_nestjs_agent_core30.AGENT_STORE
+        import_nestjs_agent_core31.AGENT_OPTIONS,
+        import_nestjs_agent_core31.AGENT_STORE
       ]
     },
     {
-      provide: import_nestjs_agent_core30.AGENT_MODEL_CATALOG,
+      provide: import_nestjs_agent_core31.AGENT_MODEL_CATALOG,
       useFactory: /* @__PURE__ */ __name((o) => resolveCatalog(o), "useFactory"),
       inject: [
-        import_nestjs_agent_core30.AGENT_OPTIONS
+        import_nestjs_agent_core31.AGENT_OPTIONS
       ]
     },
     AgentDepsFactory2,
     {
-      provide: import_nestjs_agent_core30.AGENT_DEPS_FACTORY,
+      provide: import_nestjs_agent_core31.AGENT_DEPS_FACTORY,
       useExisting: AgentDepsFactory2
     },
     // Populates the registry + contributors (onModuleInit) BEFORE AiToolDiscoveryService synthesizes
@@ -5724,28 +5789,32 @@ function sharedProviders(durable) {
     SkillDiscoveryService,
     // The thread message queue — every surface, since both runners and the durable workflow settle
     // into it, and the chat routes enqueue into it.
-    ChatQueueService,
+    ChatQueueService2,
+    {
+      provide: AGENT_CHAT_QUEUE,
+      useExisting: ChatQueueService2
+    },
     InlineAgentRunner,
     AgentService,
     // Bound ALWAYS (durable or inline) — the console's cross-thread approvals inbox routes decisions
     // through AgentService.signalToolCall, which reaches whichever AGENT_RUNNER is bound above.
     AgentApprovalPortAdapter,
     {
-      provide: import_nestjs_agent_core30.AGENT_APPROVAL_PORT,
+      provide: import_nestjs_agent_core31.AGENT_APPROVAL_PORT,
       useExisting: AgentApprovalPortAdapter
     }
   ];
   providers.push({
-    provide: import_nestjs_agent_core30.AGENT_STORE,
+    provide: import_nestjs_agent_core31.AGENT_STORE,
     useFactory: /* @__PURE__ */ __name((o, modules) => resolveStore(o, modules), "useFactory"),
     inject: [
-      import_nestjs_agent_core30.AGENT_OPTIONS,
+      import_nestjs_agent_core31.AGENT_OPTIONS,
       import_core4.ModulesContainer
     ]
   });
   if (durable) {
     providers.push({
-      provide: import_nestjs_agent_core30.AGENT_RUNNER,
+      provide: import_nestjs_agent_core31.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.");
@@ -5754,14 +5823,14 @@ function sharedProviders(durable) {
       }, "useFactory"),
       inject: [
         {
-          token: import_nestjs_agent_core30.AGENT_DURABLE_RUNNER,
+          token: import_nestjs_agent_core31.AGENT_DURABLE_RUNNER,
           optional: true
         }
       ]
     });
   } else {
     providers.push({
-      provide: import_nestjs_agent_core30.AGENT_RUNNER,
+      provide: import_nestjs_agent_core31.AGENT_RUNNER,
       useExisting: InlineAgentRunner
     });
   }
@@ -5770,25 +5839,26 @@ function sharedProviders(durable) {
 __name(sharedProviders, "sharedProviders");
 function exportsFor() {
   return [
-    import_nestjs_agent_core30.AGENT_OPTIONS,
-    import_nestjs_agent_core30.AGENT_TOOL_REGISTRY,
-    import_nestjs_agent_core30.AGENT_REGISTRY,
-    import_nestjs_agent_core30.AGENT_SINK,
-    import_nestjs_agent_core30.AGENT_ROLES_POLICY,
-    import_nestjs_agent_core30.AGENT_ACTOR_RESOLVER,
-    import_nestjs_agent_core30.AGENT_MODEL,
-    import_nestjs_agent_core30.AGENT_STORE,
-    import_nestjs_agent_core30.AGENT_MODEL_CATALOG,
-    import_nestjs_agent_core30.AGENT_QUOTA_PROVIDER,
-    import_nestjs_agent_core30.AGENT_PROMPT_CONTRIBUTORS,
-    import_nestjs_agent_core30.AGENT_SKILLS,
-    import_nestjs_agent_core30.AGENT_MEMORY,
-    import_nestjs_agent_core30.AGENT_DEPS_FACTORY,
+    import_nestjs_agent_core31.AGENT_OPTIONS,
+    import_nestjs_agent_core31.AGENT_TOOL_REGISTRY,
+    import_nestjs_agent_core31.AGENT_REGISTRY,
+    import_nestjs_agent_core31.AGENT_SINK,
+    import_nestjs_agent_core31.AGENT_ROLES_POLICY,
+    import_nestjs_agent_core31.AGENT_ACTOR_RESOLVER,
+    import_nestjs_agent_core31.AGENT_MODEL,
+    import_nestjs_agent_core31.AGENT_STORE,
+    import_nestjs_agent_core31.AGENT_MODEL_CATALOG,
+    import_nestjs_agent_core31.AGENT_QUOTA_PROVIDER,
+    import_nestjs_agent_core31.AGENT_PROMPT_CONTRIBUTORS,
+    import_nestjs_agent_core31.AGENT_SKILLS,
+    import_nestjs_agent_core31.AGENT_MEMORY,
+    import_nestjs_agent_core31.AGENT_DEPS_FACTORY,
     AgentDepsFactory2,
     AgentService,
-    ChatQueueService,
+    ChatQueueService2,
+    AGENT_CHAT_QUEUE,
     InlineAgentRunner,
-    import_nestjs_agent_core30.AGENT_APPROVAL_PORT
+    import_nestjs_agent_core31.AGENT_APPROVAL_PORT
   ];
 }
 __name(exportsFor, "exportsFor");
@@ -5852,7 +5922,7 @@ var AgentModule = class _AgentModule {
       controllers: controllersForSurface(options.surface),
       providers: [
         {
-          provide: import_nestjs_agent_core30.AGENT_OPTIONS,
+          provide: import_nestjs_agent_core31.AGENT_OPTIONS,
           useValue: options
         },
         ...sharedProviders(options.durable ?? false),
@@ -5875,7 +5945,7 @@ var AgentModule = class _AgentModule {
       controllers: controllersForSurface(options.surface),
       providers: [
         {
-          provide: import_nestjs_agent_core30.AGENT_OPTIONS,
+          provide: import_nestjs_agent_core31.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
@@ -5897,8 +5967,8 @@ var AgentModule = class _AgentModule {
   }
 };
 AgentModule = _ts_decorate26([
-  (0, import_common26.Global)(),
-  (0, import_common26.Module)({})
+  (0, import_common27.Global)(),
+  (0, import_common27.Module)({})
 ], AgentModule);
 
 // src/durable/agent-durable.ts