@dudousxd/nestjs-agent 1.13.0 → 1.15.0

package/dist/durable/index.js

@@ -2,10 +2,10 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/durable/agent-run.workflow.ts
-import { AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY2, AGENT_STORE, RunCancelledError, agentFailureCode, isReplayIntegrityError, publishAgentRunFailed, runAgentLoop, settleAll, settleUnsettledDelegation } from "@dudousxd/nestjs-agent-core";
+import { AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY2, AGENT_STORE as AGENT_STORE2, RunCancelledError, agentFailureCode, encodeStreamEvent as encodeStreamEvent3, isReplayIntegrityError, publishAgentRunFailed, releaseThreadRun, runAgentLoop, settleAll, settleUnsettledDelegation } from "@dudousxd/nestjs-agent-core";
 import { RUN_GATEWAY, Workflow } from "@dudousxd/nestjs-durable";
 import { isWorkflowControlFlowSignal } from "@dudousxd/nestjs-durable-core";
-import { Inject as Inject2, Injectable as Injectable2, Optional } from "@nestjs/common";
+import { Inject as Inject3, Injectable as Injectable3, Optional as Optional2 } from "@nestjs/common";
 
 // src/agent-deps.ts
 function utcDay(date = /* @__PURE__ */ new Date()) {
@@ -23,10 +23,9 @@ function childSinkWriter(writer) {
 }
 __name(childSinkWriter, "childSinkWriter");
 
-// src/durable/agent-run.steps.ts
-import { AGENT_DEPS_FACTORY, createFrameBuffer, createUiCollector, encodeStreamEvent, invokeWithTransientRetry, observeTurnFrames, publishAgentToolRetry, stampToolKinds, traceLlmTurn, traceToolExecution, withAskTool, withMemoryTool, withSkillTool, withToolTimeout, withTurnFrames, wrapToolStepOutput } from "@dudousxd/nestjs-agent-core";
-import { Step } from "@dudousxd/nestjs-durable";
-import { Inject, Injectable } from "@nestjs/common";
+// src/queue/chat-queue.service.ts
+import { AGENT_ATTACHMENT_STAGING, AGENT_OPTIONS, AGENT_QUOTA_PROVIDER, AGENT_SINK, AGENT_STORE, encodeStreamEvent, isChatQueueStore, queuedMessageView } from "@dudousxd/nestjs-agent-core";
+import { Inject, Injectable, Logger, NotImplementedException, Optional } from "@nestjs/common";
 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") {
@@ -53,6 +52,434 @@ function _ts_param(paramIndex, decorator) {
   };
 }
 __name(_ts_param, "_ts_param");
+var MAX_DRAIN_ATTEMPTS = 8;
+var ChatQueueService = class _ChatQueueService {
+  static {
+    __name(this, "ChatQueueService");
+  }
+  store;
+  sink;
+  quotaProvider;
+  options;
+  staging;
+  logger = new 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 isChatQueueStore(this.store);
+  }
+  /** The bound store as a queue store, or a 501 naming what is missing. */
+  queueStore() {
+    if (!isChatQueueStore(this.store)) {
+      throw new 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(queuedMessageView),
+      paused
+    };
+  }
+  /**
+  * 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.
+  */
+  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 {
+        live: null,
+        stale: null
+      };
+    }
+    return await this.isAlive(holder, runner) ? {
+      live: holder,
+      stale: null
+    } : {
+      live: null,
+      stale: holder
+    };
+  }
+  /**
+  * 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 (!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
+        })
+      };
+    }
+    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 (!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 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;
+  }
+  /**
+  * 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
+      } : {},
+      ...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.
+  */
+  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)}`);
+      });
+    }
+    return state;
+  }
+  async write(runId, frame) {
+    const writer = await this.sink.open(runId);
+    await writer.write(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;
+    }
+  }
+  /**
+  * 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([
+  Injectable(),
+  _ts_param(0, Inject(AGENT_STORE)),
+  _ts_param(1, Inject(AGENT_SINK)),
+  _ts_param(2, Optional()),
+  _ts_param(2, Inject(AGENT_QUOTA_PROVIDER)),
+  _ts_param(3, Optional()),
+  _ts_param(3, Inject(AGENT_OPTIONS)),
+  _ts_param(4, Optional()),
+  _ts_param(4, Inject(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(queuedMessageView),
+      paused
+    },
+    ...started !== void 0 ? {
+      started
+    } : {}
+  };
+}
+__name(queueFrame, "queueFrame");
+
+// src/durable/agent-run.steps.ts
+import { AGENT_DEPS_FACTORY, createFrameBuffer, createUiCollector, encodeStreamEvent as encodeStreamEvent2, invokeWithTransientRetry, observeTurnFrames, publishAgentToolRetry, stampToolKinds, traceLlmTurn, traceToolExecution, withAskTool, withMemoryTool, withSkillTool, withToolTimeout, withTurnFrames, wrapToolStepOutput } from "@dudousxd/nestjs-agent-core";
+import { Step } from "@dudousxd/nestjs-durable";
+import { Inject as Inject2, Injectable as Injectable2 } from "@nestjs/common";
+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");
@@ -129,7 +556,7 @@ var AgentRunSteps = class {
     let opened;
     const ui = 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(encodeStreamEvent(event));
+      await (await opened).write(encodeStreamEvent2(event));
     });
     const ctx = {
       ...input.ctx,
@@ -164,35 +591,35 @@ var AgentRunSteps = class {
     return input.collectUi === true ? wrapToolStepOutput(output, ui.components()) : output;
   }
 };
-_ts_decorate([
+_ts_decorate2([
   Step({
     retries: 3
   }),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
     typeof DispatchedLlmInput === "undefined" ? Object : DispatchedLlmInput
   ]),
-  _ts_metadata("design:returntype", Promise)
+  _ts_metadata2("design:returntype", Promise)
 ], AgentRunSteps.prototype, "llm", null);
-_ts_decorate([
+_ts_decorate2([
   Step(),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
     typeof DispatchedToolInput === "undefined" ? Object : DispatchedToolInput
   ]),
-  _ts_metadata("design:returntype", Promise)
+  _ts_metadata2("design:returntype", Promise)
 ], AgentRunSteps.prototype, "tool", null);
-AgentRunSteps = _ts_decorate([
-  Injectable(),
-  _ts_param(0, Inject(AGENT_DEPS_FACTORY)),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
+AgentRunSteps = _ts_decorate2([
+  Injectable2(),
+  _ts_param2(0, Inject2(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_decorate2(decorators, target, key, desc) {
+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);
@@ -205,19 +632,19 @@ function _ts_decorate2(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate2, "_ts_decorate");
-function _ts_metadata2(metadataKey, metadataValue) {
+__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_metadata2, "_ts_metadata");
-function _ts_param2(paramIndex, decorator) {
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param2, "_ts_param");
+__name(_ts_param3, "_ts_param");
 var AgentRunWorkflow = class _AgentRunWorkflow {
   static {
     __name(this, "AgentRunWorkflow");
@@ -225,10 +652,63 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
   factory;
   store;
   runs;
-  constructor(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 ctx.localStep(`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 (isWorkflowControlFlowSignal(failure)) {
+        throw failure;
+      }
+      const reason = failure instanceof Error ? failure.message : String(failure);
+      return ctx.localStep("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
@@ -294,7 +774,25 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
     const hooks = {
       runId: ctx.runId,
       // A child forwards into the top-level sink but must not end/fail it (the top-level run owns it).
-      openSink: /* @__PURE__ */ __name(async () => input.sinkRunId !== void 0 ? childSinkWriter(await deps.sink.open(sinkRunId)) : deps.sink.open(ctx.runId), "openSink"),
+      // A thread's own turn hands the thread to its queue just before the loop ends the stream, so
+      // the reader learns what runs next from the `queue` frame, before the end.
+      openSink: /* @__PURE__ */ __name(async () => {
+        if (input.sinkRunId !== void 0) {
+          return childSinkWriter(await deps.sink.open(sinkRunId));
+        }
+        const writer = await deps.sink.open(ctx.runId);
+        return {
+          write: /* @__PURE__ */ __name((chunk) => writer.write(chunk), "write"),
+          fail: /* @__PURE__ */ __name((failure) => writer.fail(failure), "fail"),
+          end: /* @__PURE__ */ __name(async () => {
+            const frame = await this.advanceQueue(ctx, input, "completed");
+            if (frame !== void 0) {
+              await writer.write(encodeStreamEvent3(frame));
+            }
+            await writer.end();
+          }, "end")
+        };
+      }, "openSink"),
       // A policy's time to live becomes the signal wait's own timeout: the runtime journals the
       // deadline on the first call (a position of its own, reached only for a call the journal says
       // has a ttl) and wakes the run when it passes. The lapse comes back as a Decision rather than a
@@ -417,14 +915,14 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
         ...deps,
         day
       }, input, hooks);
-      await ctx.localStep("deactivate", () => this.store.setActiveStream(input.threadId, null));
+      await ctx.localStep("deactivate", () => releaseThreadRun(this.store, input.threadId, ctx.runId));
       return result;
     } catch (error) {
       if (isWorkflowControlFlowSignal(error)) {
         throw error;
       }
       if (error instanceof RunCancelledError) {
-        await ctx.localStep("deactivate", () => this.store.setActiveStream(input.threadId, null));
+        await ctx.localStep("deactivate", () => releaseThreadRun(this.store, input.threadId, ctx.runId));
         await this.settleDetachedParent(ctx, input, {
           status: "cancelled"
         });
@@ -455,12 +953,16 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
         errorCode: code,
         errorMessage: message
       }) ?? Promise.resolve());
-      await ctx.localStep("deactivate", () => this.store.setActiveStream(input.threadId, null));
+      const queueFrame2 = await this.advanceQueue(ctx, input, "failed", message);
+      await ctx.localStep("deactivate", () => 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(encodeStreamEvent3(queueFrame2));
+      }
       await writer.fail({
         code,
         message
@@ -469,21 +971,23 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
     }
   }
 };
-AgentRunWorkflow = _ts_decorate2([
-  Injectable2(),
+AgentRunWorkflow = _ts_decorate3([
+  Injectable3(),
   Workflow({
     name: "agent.run",
     version: "1"
   }),
-  _ts_param2(0, Inject2(AGENT_DEPS_FACTORY2)),
-  _ts_param2(1, Inject2(AGENT_STORE)),
-  _ts_param2(2, Optional()),
-  _ts_param2(2, Inject2(RUN_GATEWAY)),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _ts_param3(0, Inject3(AGENT_DEPS_FACTORY2)),
+  _ts_param3(1, Inject3(AGENT_STORE2)),
+  _ts_param3(2, Optional2()),
+  _ts_param3(2, Inject3(RUN_GATEWAY)),
+  _ts_param3(3, Optional2()),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
     typeof AgentStore === "undefined" ? Object : AgentStore,
-    typeof RunGateway === "undefined" ? Object : RunGateway
+    typeof RunGateway === "undefined" ? Object : RunGateway,
+    typeof ChatQueueService === "undefined" ? Object : ChatQueueService
   ])
 ], AgentRunWorkflow);
 function isSignalTimeout(error) {
@@ -493,10 +997,10 @@ __name(isSignalTimeout, "isSignalTimeout");
 
 // src/durable/durable-agent-runner.ts
 import { randomUUID } from "crypto";
-import { AGENT_SINK, AGENT_STORE as AGENT_STORE2, encodeStreamEvent as encodeStreamEvent2 } from "@dudousxd/nestjs-agent-core";
+import { AGENT_SINK as AGENT_SINK2, AGENT_STORE as AGENT_STORE3, encodeStreamEvent as encodeStreamEvent4, releaseThreadRun as releaseThreadRun2 } from "@dudousxd/nestjs-agent-core";
 import { RUN_GATEWAY as RUN_GATEWAY2, WorkflowService } from "@dudousxd/nestjs-durable";
 import { isWorkflowControlFlowSignal as isWorkflowControlFlowSignal2 } from "@dudousxd/nestjs-durable-core";
-import { Inject as Inject3, Injectable as Injectable3, Logger } from "@nestjs/common";
+import { Inject as Inject4, Injectable as Injectable4, Logger as Logger2, Optional as Optional3 } from "@nestjs/common";
 
 // src/in-process-sink.ts
 import { AgentStreamError } from "@dudousxd/nestjs-agent-core";
@@ -567,7 +1071,7 @@ var InProcessTokenStreamSink = class {
 };
 
 // src/durable/durable-agent-runner.ts
-function _ts_decorate3(decorators, target, key, desc) {
+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);
@@ -580,19 +1084,19 @@ function _ts_decorate3(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate3, "_ts_decorate");
-function _ts_metadata3(metadataKey, metadataValue) {
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(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) {
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param3, "_ts_param");
+__name(_ts_param4, "_ts_param");
 function threadOfRun(input) {
   if (typeof input !== "object" || input === null || !("threadId" in input)) {
     return void 0;
@@ -600,6 +1104,10 @@ function threadOfRun(input) {
   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");
@@ -608,22 +1116,24 @@ var DurableAgentRunner = class _DurableAgentRunner {
   runs;
   store;
   sink;
-  logger = new Logger(_DurableAgentRunner.name);
-  constructor(workflows, runs, store, sink) {
+  queue;
+  logger = new Logger2(_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) {
+  async start(input, options = {}) {
     const stamped = {
       ...input,
       day: input.day ?? utcDay()
     };
-    const runId = randomUUID();
+    const runId = options.runId ?? randomUUID();
     try {
       await this.workflows.start(AgentRunWorkflow, stamped, runId);
     } catch (error) {
@@ -635,6 +1145,19 @@ var DurableAgentRunner = class _DurableAgentRunner {
       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);
   }
@@ -664,15 +1187,32 @@ var DurableAgentRunner = class _DurableAgentRunner {
   */
   async cancel(runId) {
     this.logger.log(`cancelling agent run ${runId}`);
-    const threadId = await this.threadOf(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) {
-      await this.store.setActiveStream(threadId, null);
+      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(encodeStreamEvent4(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 releaseThreadRun2(this.store, threadId, runId);
     }
-    const writer = await this.sink.open(runId);
-    await writer.write(encodeStreamEvent2({
+    await writer.write(encodeStreamEvent4({
       kind: "cancelled"
     }));
     await writer.end();
@@ -682,7 +1222,7 @@ var DurableAgentRunner = class _DurableAgentRunner {
     });
   }
   /**
-  * Which thread a run was streaming, or `undefined` where the gateway cannot say.
+  * 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
@@ -691,32 +1231,34 @@ var DurableAgentRunner = class _DurableAgentRunner {
   * with a subscriber holding a stream that never settles, from the one call whose entire job is to
   * make a run stop.
   */
-  async threadOf(runId) {
+  async inputOf(runId) {
     try {
-      return threadOfRun((await this.runs.getRunDetail(runId))?.run.input);
+      return (await this.runs.getRunDetail(runId))?.run.input;
     } catch {
       return void 0;
     }
   }
 };
-DurableAgentRunner = _ts_decorate3([
-  Injectable3(),
-  _ts_param3(1, Inject3(RUN_GATEWAY2)),
-  _ts_param3(2, Inject3(AGENT_STORE2)),
-  _ts_param3(3, Inject3(AGENT_SINK)),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+DurableAgentRunner = _ts_decorate4([
+  Injectable4(),
+  _ts_param4(1, Inject4(RUN_GATEWAY2)),
+  _ts_param4(2, Inject4(AGENT_STORE3)),
+  _ts_param4(3, Inject4(AGENT_SINK2)),
+  _ts_param4(4, Optional3()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     typeof WorkflowService === "undefined" ? Object : WorkflowService,
     typeof RunGateway === "undefined" ? Object : RunGateway,
     typeof AgentStore === "undefined" ? Object : AgentStore,
-    typeof TokenStreamSink === "undefined" ? Object : TokenStreamSink
+    typeof TokenStreamSink === "undefined" ? Object : TokenStreamSink,
+    typeof ChatQueueService === "undefined" ? Object : ChatQueueService
   ])
 ], DurableAgentRunner);
 
 // src/durable/agent-durable.module.ts
 import { AGENT_DURABLE_RUNNER } from "@dudousxd/nestjs-agent-core";
 import { Global, Module } from "@nestjs/common";
-function _ts_decorate4(decorators, target, key, desc) {
+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);
@@ -729,7 +1271,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 runnerProviders() {
   return [
     DurableAgentRunner,
@@ -745,7 +1287,7 @@ var AgentDurableHttpModule = class AgentDurableHttpModule2 {
     __name(this, "AgentDurableHttpModule");
   }
 };
-AgentDurableHttpModule = _ts_decorate4([
+AgentDurableHttpModule = _ts_decorate5([
   Global(),
   Module({
     providers: [
@@ -783,7 +1325,7 @@ var AgentDurableModule = class _AgentDurableModule {
     };
   }
 };
-AgentDurableModule = _ts_decorate4([
+AgentDurableModule = _ts_decorate5([
   Global(),
   Module({
     providers: [
@@ -800,15 +1342,15 @@ AgentDurableModule = _ts_decorate4([
 ], AgentDurableModule);
 
 // src/agent.module.ts
-import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER12, AGENT_APPROVAL_PORT, AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY7, AGENT_DURABLE_RUNNER as AGENT_DURABLE_RUNNER2, AGENT_MEMORY as AGENT_MEMORY3, AGENT_MODEL as AGENT_MODEL2, AGENT_MODEL_CATALOG as AGENT_MODEL_CATALOG3, AGENT_OPTIONS as AGENT_OPTIONS6, AGENT_PROMPT_CONTRIBUTORS as AGENT_PROMPT_CONTRIBUTORS3, AGENT_QUOTA_PROVIDER as AGENT_QUOTA_PROVIDER2, AGENT_REGISTRY as AGENT_REGISTRY6, AGENT_ROLES_POLICY as AGENT_ROLES_POLICY2, AGENT_RUNNER as AGENT_RUNNER2, AGENT_SINK as AGENT_SINK3, AGENT_SKILLS as AGENT_SKILLS3, AGENT_SKILL_SOURCES as AGENT_SKILL_SOURCES2, AGENT_STORE as AGENT_STORE6, AGENT_TOOL_REGISTRY as AGENT_TOOL_REGISTRY3, AgentRegistry as AgentRegistry6, DefaultRolesPolicy, InMemoryAgentStore, ToolRegistry as ToolRegistry3 } from "@dudousxd/nestjs-agent-core";
-import { Global as Global2, Logger as Logger6, Module as Module2 } from "@nestjs/common";
+import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER13, AGENT_APPROVAL_PORT, AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY7, AGENT_DURABLE_RUNNER as AGENT_DURABLE_RUNNER2, AGENT_MEMORY as AGENT_MEMORY3, AGENT_MODEL as AGENT_MODEL2, AGENT_MODEL_CATALOG as AGENT_MODEL_CATALOG3, AGENT_OPTIONS as AGENT_OPTIONS7, AGENT_PROMPT_CONTRIBUTORS as AGENT_PROMPT_CONTRIBUTORS3, AGENT_QUOTA_PROVIDER as AGENT_QUOTA_PROVIDER3, AGENT_REGISTRY as AGENT_REGISTRY6, AGENT_ROLES_POLICY as AGENT_ROLES_POLICY2, AGENT_RUNNER as AGENT_RUNNER2, AGENT_SINK as AGENT_SINK4, AGENT_SKILLS as AGENT_SKILLS3, AGENT_SKILL_SOURCES as AGENT_SKILL_SOURCES2, AGENT_STORE as AGENT_STORE7, AGENT_TOOL_REGISTRY as AGENT_TOOL_REGISTRY3, AgentRegistry as AgentRegistry6, DefaultRolesPolicy, InMemoryAgentStore, ToolRegistry as ToolRegistry3 } from "@dudousxd/nestjs-agent-core";
+import { Global as Global2, Logger as Logger7, Module as Module2 } from "@nestjs/common";
 import { DiscoveryModule, ModulesContainer, RouterModule } from "@nestjs/core";
 
 // src/agent-deps.factory.ts
-import { AGENT_MEMORY, AGENT_MODEL, AGENT_PRICING_STORE, AGENT_PROMPT_CONTRIBUTORS, AGENT_REGISTRY, AGENT_ROLES_POLICY, AGENT_SINK as AGENT_SINK2, AGENT_SKILLS, AGENT_STORE as AGENT_STORE3, AGENT_TOOL_REGISTRY, AgentRegistry as AgentRegistry2, ToolRegistry as ToolRegistry2, normalizeDelegation, summarizeWithModel, windowHistory } from "@dudousxd/nestjs-agent-core";
-import { AGENT_OPTIONS } from "@dudousxd/nestjs-agent-core";
-import { Inject as Inject4, Injectable as Injectable4, Optional as Optional2 } from "@nestjs/common";
-function _ts_decorate5(decorators, target, key, desc) {
+import { AGENT_MEMORY, AGENT_MODEL, AGENT_PRICING_STORE, AGENT_PROMPT_CONTRIBUTORS, AGENT_REGISTRY, AGENT_ROLES_POLICY, AGENT_SINK as AGENT_SINK3, AGENT_SKILLS, AGENT_STORE as AGENT_STORE4, AGENT_TOOL_REGISTRY, AgentRegistry as AgentRegistry2, ToolRegistry as ToolRegistry2, normalizeDelegation, summarizeWithModel, windowHistory } from "@dudousxd/nestjs-agent-core";
+import { AGENT_OPTIONS as AGENT_OPTIONS2 } from "@dudousxd/nestjs-agent-core";
+import { Inject as Inject5, Injectable as Injectable5, Optional as Optional4 } from "@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);
@@ -821,19 +1363,19 @@ function _ts_decorate5(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate5, "_ts_decorate");
-function _ts_metadata4(metadataKey, metadataValue) {
+__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_metadata4, "_ts_metadata");
-function _ts_param4(paramIndex, decorator) {
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param4, "_ts_param");
+__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}`;
@@ -1030,24 +1572,24 @@ var AgentDepsFactory2 = class {
     return void 0;
   }
 };
-AgentDepsFactory2 = _ts_decorate5([
-  Injectable4(),
-  _ts_param4(0, Inject4(AGENT_OPTIONS)),
-  _ts_param4(1, Inject4(AGENT_MODEL)),
-  _ts_param4(2, Inject4(AGENT_STORE3)),
-  _ts_param4(3, Inject4(AGENT_SINK2)),
-  _ts_param4(4, Inject4(AGENT_ROLES_POLICY)),
-  _ts_param4(5, Inject4(AGENT_TOOL_REGISTRY)),
-  _ts_param4(6, Inject4(AGENT_REGISTRY)),
-  _ts_param4(7, Inject4(AGENT_PROMPT_CONTRIBUTORS)),
-  _ts_param4(8, Optional2()),
-  _ts_param4(8, Inject4(AGENT_PRICING_STORE)),
-  _ts_param4(9, Optional2()),
-  _ts_param4(9, Inject4(AGENT_SKILLS)),
-  _ts_param4(10, Optional2()),
-  _ts_param4(10, Inject4(AGENT_MEMORY)),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
+AgentDepsFactory2 = _ts_decorate6([
+  Injectable5(),
+  _ts_param5(0, Inject5(AGENT_OPTIONS2)),
+  _ts_param5(1, Inject5(AGENT_MODEL)),
+  _ts_param5(2, Inject5(AGENT_STORE4)),
+  _ts_param5(3, Inject5(AGENT_SINK3)),
+  _ts_param5(4, Inject5(AGENT_ROLES_POLICY)),
+  _ts_param5(5, Inject5(AGENT_TOOL_REGISTRY)),
+  _ts_param5(6, Inject5(AGENT_REGISTRY)),
+  _ts_param5(7, Inject5(AGENT_PROMPT_CONTRIBUTORS)),
+  _ts_param5(8, Optional4()),
+  _ts_param5(8, Inject5(AGENT_PRICING_STORE)),
+  _ts_param5(9, Optional4()),
+  _ts_param5(9, Inject5(AGENT_SKILLS)),
+  _ts_param5(10, Optional4()),
+  _ts_param5(10, Inject5(AGENT_MEMORY)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
     typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions,
     typeof ModelProvider === "undefined" ? Object : ModelProvider,
     typeof AgentStore === "undefined" ? Object : AgentStore,
@@ -1063,9 +1605,9 @@ AgentDepsFactory2 = _ts_decorate5([
 ], AgentDepsFactory2);
 
 // src/agent.service.ts
-import { AGENT_ATTACHMENT_STAGING, AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY3, AGENT_MODEL_CATALOG, AGENT_OPTIONS as AGENT_OPTIONS2, AGENT_QUOTA_PROVIDER, AGENT_RUNNER, AGENT_STORE as AGENT_STORE4, REQUESTER_APPROVER, findCatalogModel, mayDecideApproval, readElicitationQuestions, validateElicitationAnswer } from "@dudousxd/nestjs-agent-core";
-import { BadRequestException, ForbiddenException, GoneException, HttpException, HttpStatus, Inject as Inject5, Injectable as Injectable5, NotFoundException, NotImplementedException, Optional as Optional3 } from "@nestjs/common";
-function _ts_decorate6(decorators, target, key, desc) {
+import { AGENT_ATTACHMENT_STAGING as AGENT_ATTACHMENT_STAGING2, AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY3, AGENT_MODEL_CATALOG, AGENT_OPTIONS as AGENT_OPTIONS3, AGENT_QUOTA_PROVIDER as AGENT_QUOTA_PROVIDER2, AGENT_RUNNER, AGENT_STORE as AGENT_STORE5, REQUESTER_APPROVER, findCatalogModel, mayDecideApproval, readElicitationQuestions, validateElicitationAnswer } from "@dudousxd/nestjs-agent-core";
+import { BadRequestException, ConflictException, ForbiddenException, GoneException, HttpException, HttpStatus, Inject as Inject6, Injectable as Injectable6, NotFoundException, NotImplementedException as NotImplementedException2, Optional as Optional5 } from "@nestjs/common";
+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") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -1078,19 +1620,19 @@ function _ts_decorate6(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate6, "_ts_decorate");
-function _ts_metadata5(metadataKey, metadataValue) {
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata6(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) {
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param5, "_ts_param");
+__name(_ts_param6, "_ts_param");
 var AgentService = class {
   static {
     __name(this, "AgentService");
@@ -1102,7 +1644,8 @@ var AgentService = class {
   models;
   quotaProvider;
   options;
-  constructor(runner, store, deps, staging, models, quotaProvider, options) {
+  queue;
+  constructor(runner, store, deps, staging, models, quotaProvider, options, queue) {
     this.runner = runner;
     this.store = store;
     this.deps = deps;
@@ -1110,6 +1653,19 @@ var AgentService = class {
     this.models = models;
     this.quotaProvider = quotaProvider;
     this.options = options;
+    this.queue = queue;
+  }
+  /** The queue service when the bound store can hold a queue, else `undefined`. */
+  queueing() {
+    return this.queue?.supported === true ? this.queue : void 0;
+  }
+  /** The queue service, or a 501 naming what is missing. */
+  requireQueue() {
+    const queue = this.queueing();
+    if (queue === void 0) {
+      throw new NotImplementedException2("Queueing messages requires an AgentStore that implements ChatQueueStore; the bound store does not.");
+    }
+    return queue;
   }
   /**
   * The actor's budget across windows (`GET <base>/quota`) — the bound {@link QuotaProvider}'s
@@ -1220,7 +1776,44 @@ var AgentService = class {
     }
     return (await this.store.getThread(threadId))?.model ?? null;
   }
+  /**
+  * Start a turn — for in-process callers that need a run id back. A send that would have to wait
+  * (its thread already has a turn running) is refused with `409` instead; {@link send} is the form
+  * that queues it.
+  */
   async chat(params) {
+    const result = await this.send({
+      ...params,
+      mode: "auto"
+    });
+    if (result.queued !== true) {
+      return result;
+    }
+    if (result.runId !== void 0) {
+      return {
+        runId: result.runId,
+        threadId: result.threadId
+      };
+    }
+    const store = this.requireQueue().queueStore();
+    if (!await store.removeQueuedMessage(result.messageId)) {
+      return {
+        runId: result.messageId,
+        threadId: result.threadId
+      };
+    }
+    await this.requireQueue().publish(result.threadId);
+    throw new ConflictException({
+      statusCode: 409,
+      code: "run_active",
+      message: `thread ${result.threadId} already has a turn running`
+    });
+  }
+  /**
+  * Send a message: start a turn, or — when its thread already has one running — queue the message
+  * to run after it (see {@link ChatSendMode}). What `POST <base>/chat` calls.
+  */
+  async send(params) {
     await this.assertWithinQuota(params.actor);
     const agentName = await this.resolveAgentName(params.agentName, params.threadId);
     const model = await this.resolveModel(params.actor, agentName, params.model, params.threadId);
@@ -1237,7 +1830,7 @@ var AgentService = class {
         } : {}
       });
       threadId = created.id;
-    } else if (params.regenerate === true) {
+    } else {
       await this.assertOwnsThread(params.actor, threadId);
     }
     const input = {
@@ -1259,13 +1852,195 @@ var AgentService = class {
         model
       } : {}
     };
-    const { runId } = await this.runner.start(input);
-    await this.store.setActiveStream(threadId, runId);
+    const queue = this.queueing();
+    if (queue === void 0) {
+      const { runId } = await this.runner.start(input);
+      await this.store.setActiveStream(threadId, runId);
+      return {
+        runId,
+        threadId
+      };
+    }
+    const mode = params.mode ?? "auto";
+    const { live, stale } = await queue.holder(threadId, this.runner);
+    if (live === null && mode !== "queue") {
+      const runId = crypto.randomUUID();
+      if (await queue.queueStore().claimActiveStream(threadId, runId, stale !== null ? {
+        replacing: stale
+      } : {})) {
+        return {
+          runId: await this.startClaimed(input, runId),
+          threadId
+        };
+      }
+    }
+    if (params.regenerate === true) {
+      throw new ConflictException({
+        statusCode: 409,
+        code: "run_active",
+        message: "cannot regenerate while a turn is running on this thread"
+      });
+    }
+    return this.enqueue(queue, input, mode, live);
+  }
+  /**
+  * Start a turn the thread is already claimed for, under the claimed id. A runner that minted an
+  * id of its own anyway gets the thread re-pointed at it; one that fails to start frees the thread.
+  */
+  async startClaimed(input, runId) {
+    const store = this.requireQueue().queueStore();
+    let started;
+    try {
+      started = (await this.runner.start(input, {
+        runId
+      })).runId;
+    } catch (error) {
+      await store.releaseActiveStream(input.threadId, runId);
+      throw error;
+    }
+    if (started !== runId) {
+      await store.claimActiveStream(input.threadId, started, {
+        replacing: runId
+      });
+    }
+    return started;
+  }
+  /** Put a send in its thread's queue, then drain it if the thread turned out to be free. */
+  async enqueue(queue, input, mode, live) {
+    const store = queue.queueStore();
+    const threadId = input.threadId;
+    const interrupting = mode === "interrupt" && live !== null ? live : void 0;
+    const queued = await store.enqueueMessage({
+      threadId,
+      actor: input.actor,
+      content: input.userText,
+      ...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
+      } : {},
+      ...interrupting !== void 0 ? {
+        interrupt: true,
+        at: "head"
+      } : {}
+    });
+    let runId;
+    if (interrupting !== void 0) {
+      await store.setQueuePause(threadId, null);
+      await queue.publish(threadId);
+      await this.runner.cancel(interrupting);
+    } else {
+      runId = await queue.kick(threadId, this.runner);
+      if (runId === void 0) {
+        await queue.publish(threadId);
+      }
+    }
+    const state = await queue.state(threadId);
+    const position = state.items.findIndex((item) => item.id === queued.id);
     return {
-      runId,
-      threadId
+      threadId,
+      queued: true,
+      messageId: queued.id,
+      position: position === -1 ? 0 : position,
+      queue: state,
+      ...runId !== void 0 && runId === queued.id ? {
+        runId
+      } : {},
+      ...interrupting !== void 0 ? {
+        interrupting
+      } : {}
+    };
+  }
+  /** `GET <base>/threads/:id/queue` — the thread's waiting messages and whether it drains. */
+  async getQueue(actor, threadId) {
+    await this.assertOwnsThread(actor, threadId);
+    return this.requireQueue().state(threadId);
+  }
+  /**
+  * `PATCH <base>/queue/:messageId` — change a waiting message's text and/or attachments, and/or move
+  * it to `position` in the queue. Answers the thread's queue.
+  */
+  async updateQueuedMessage(actor, messageId, patch) {
+    const queue = this.requireQueue();
+    const store = queue.queueStore();
+    const threadId = await this.assertOwnsQueuedMessage(actor, messageId);
+    if (patch.message !== void 0 && patch.message.trim().length === 0) {
+      throw new 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) {
+      const updated = await store.updateQueuedMessage(messageId, {
+        ...patch.message !== void 0 ? {
+          content: patch.message
+        } : {},
+        ...attachments !== void 0 ? {
+          attachments
+        } : {}
+      });
+      if (updated === null) {
+        throw new GoneException(`queued message ${messageId} already started or was removed`);
+      }
+    }
+    if (patch.position !== void 0) {
+      if (!Number.isInteger(patch.position) || patch.position < 0) {
+        throw new BadRequestException("position must be a non-negative integer");
+      }
+      if (!await store.moveQueuedMessage(messageId, patch.position)) {
+        throw new GoneException(`queued message ${messageId} already started or was removed`);
+      }
+    }
+    return queue.publish(threadId);
+  }
+  /** `DELETE <base>/queue/:messageId` — drop a waiting message. Answers the thread's queue. */
+  async removeQueuedMessage(actor, messageId) {
+    const queue = this.requireQueue();
+    const threadId = await this.assertOwnsQueuedMessage(actor, messageId);
+    if (!await queue.queueStore().removeQueuedMessage(messageId)) {
+      throw new GoneException(`queued message ${messageId} already started or was removed`);
+    }
+    return queue.publish(threadId);
+  }
+  /** `DELETE <base>/threads/:id/queue` — drop every waiting message (and any pause). */
+  async clearQueue(actor, threadId) {
+    await this.assertOwnsThread(actor, threadId);
+    const queue = this.requireQueue();
+    await queue.queueStore().clearQueue(threadId);
+    await queue.queueStore().setQueuePause(threadId, null);
+    return queue.publish(threadId);
+  }
+  /**
+  * `POST <base>/threads/:id/queue/resume` — lift a pause and start the head when nothing is
+  * running. Answers the queue, and the run the head started under, if it did.
+  */
+  async resumeQueue(actor, threadId) {
+    await this.assertOwnsThread(actor, threadId);
+    const queue = this.requireQueue();
+    await queue.queueStore().setQueuePause(threadId, null);
+    const runId = await queue.kick(threadId, this.runner);
+    const state = runId === void 0 ? await queue.publish(threadId) : await queue.state(threadId);
+    return {
+      ...state,
+      ...runId !== void 0 ? {
+        runId
+      } : {}
     };
   }
+  /** The thread a queued message waits on, once the caller is shown to own it. */
+  async assertOwnsQueuedMessage(actor, messageId) {
+    const message = await this.requireQueue().queueStore().getQueuedMessage(messageId);
+    if (message === null) {
+      throw new NotFoundException(`queued message ${messageId} not found`);
+    }
+    await this.assertOwnsThread(actor, message.threadId);
+    return message.threadId;
+  }
   /**
   * Rebuild this turn's attachments from the staging store, keyed by the ids the caller claimed.
   * The model provider fetches {@link MessageAttachment.url} verbatim, so that url is only ever
@@ -1282,7 +2057,7 @@ var AgentService = class {
     }
     const staging = this.staging;
     if (staging === void 0 || typeof staging.resolve !== "function") {
-      throw new NotImplementedException("Message attachments require an AGENT_ATTACHMENT_STAGING provider implementing resolve(); attachment urls are never taken from the request.");
+      throw new NotImplementedException2("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) {
@@ -1440,7 +2215,7 @@ var AgentService = class {
       return;
     }
     if (this.store.updateThread === void 0) {
-      throw new NotImplementedException("Setting a thread's defaultAgent or model requires an AgentStore that implements updateThread(); the bound store does not support it.");
+      throw new NotImplementedException2("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, {
@@ -1505,9 +2280,13 @@ var AgentService = class {
   }
   async toDetailView(thread, actor) {
     const summary = await this.toSummaryView(thread);
+    const queue = this.queueing();
     return {
       ...summary,
-      messages: await this.freshAttachmentUrls(thread.messages, actor)
+      messages: await this.freshAttachmentUrls(thread.messages, actor),
+      ...queue !== void 0 ? {
+        queue: await queue.state(thread.id)
+      } : {}
     };
   }
   /**
@@ -1570,7 +2349,7 @@ var AgentService = class {
       throw new BadRequestException("comment must be at most 2000 characters");
     }
     if (this.store.threadOfMessage === void 0 || this.store.setMessageFeedback === void 0) {
-      throw new NotImplementedException("Message feedback requires an AgentStore that implements threadOfMessage() and setMessageFeedback(); the bound store does not support it.");
+      throw new NotImplementedException2("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) {
@@ -1622,7 +2401,7 @@ var AgentService = class {
     const list = this.attachmentInventory();
     const referencedMediaIds = this.store.referencedMediaIds?.bind(this.store);
     if (referencedMediaIds === void 0) {
-      throw new 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 NotImplementedException2("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({
@@ -1644,7 +2423,7 @@ var AgentService = class {
   attachmentInventory() {
     const list = this.staging?.list?.bind(this.staging);
     if (list === void 0) {
-      throw new 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 NotImplementedException2("Listing attachments requires an AGENT_ATTACHMENT_STAGING provider implementing list(); the host owns the staged bytes, so only it can enumerate them.");
     }
     return list;
   }
@@ -1762,34 +2541,36 @@ var AgentService = class {
     }
   }
 };
-AgentService = _ts_decorate6([
-  Injectable5(),
-  _ts_param5(0, Inject5(AGENT_RUNNER)),
-  _ts_param5(1, Inject5(AGENT_STORE4)),
-  _ts_param5(2, Inject5(AGENT_DEPS_FACTORY3)),
-  _ts_param5(3, Optional3()),
-  _ts_param5(3, Inject5(AGENT_ATTACHMENT_STAGING)),
-  _ts_param5(4, Optional3()),
-  _ts_param5(4, Inject5(AGENT_MODEL_CATALOG)),
-  _ts_param5(5, Optional3()),
-  _ts_param5(5, Inject5(AGENT_QUOTA_PROVIDER)),
-  _ts_param5(6, Optional3()),
-  _ts_param5(6, Inject5(AGENT_OPTIONS2)),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+AgentService = _ts_decorate7([
+  Injectable6(),
+  _ts_param6(0, Inject6(AGENT_RUNNER)),
+  _ts_param6(1, Inject6(AGENT_STORE5)),
+  _ts_param6(2, Inject6(AGENT_DEPS_FACTORY3)),
+  _ts_param6(3, Optional5()),
+  _ts_param6(3, Inject6(AGENT_ATTACHMENT_STAGING2)),
+  _ts_param6(4, Optional5()),
+  _ts_param6(4, Inject6(AGENT_MODEL_CATALOG)),
+  _ts_param6(5, Optional5()),
+  _ts_param6(5, Inject6(AGENT_QUOTA_PROVIDER2)),
+  _ts_param6(6, Optional5()),
+  _ts_param6(6, Inject6(AGENT_OPTIONS3)),
+  _ts_param6(7, Optional5()),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
     typeof AgentRunner === "undefined" ? Object : AgentRunner,
     typeof AgentStore === "undefined" ? Object : AgentStore,
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
     typeof AttachmentStagingStore === "undefined" ? Object : AttachmentStagingStore,
     typeof ModelCatalog === "undefined" ? Object : ModelCatalog,
     typeof QuotaProvider === "undefined" ? Object : QuotaProvider,
-    typeof Pick === "undefined" ? Object : Pick
+    typeof Pick === "undefined" ? Object : Pick,
+    typeof ChatQueueService === "undefined" ? Object : ChatQueueService
   ])
 ], AgentService);
 
 // src/approval-port.adapter.ts
-import { Injectable as Injectable6 } from "@nestjs/common";
-function _ts_decorate7(decorators, target, key, desc) {
+import { Injectable as Injectable7 } from "@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") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -1802,13 +2583,13 @@ function _ts_decorate7(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate7, "_ts_decorate");
-function _ts_metadata6(metadataKey, metadataValue) {
+__name(_ts_decorate8, "_ts_decorate");
+function _ts_metadata7(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata6, "_ts_metadata");
+__name(_ts_metadata7, "_ts_metadata");
 var AgentApprovalPortAdapter = class {
   static {
     __name(this, "AgentApprovalPortAdapter");
@@ -1846,18 +2627,18 @@ var AgentApprovalPortAdapter = class {
     });
   }
 };
-AgentApprovalPortAdapter = _ts_decorate7([
-  Injectable6(),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [
+AgentApprovalPortAdapter = _ts_decorate8([
+  Injectable7(),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService
   ])
 ], AgentApprovalPortAdapter);
 
 // src/controller/agents.controller.ts
 import { AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY4, AGENT_REGISTRY as AGENT_REGISTRY2, AgentRegistry as AgentRegistry3 } from "@dudousxd/nestjs-agent-core";
-import { Controller, Get, Inject as Inject6 } from "@nestjs/common";
-function _ts_decorate8(decorators, target, key, desc) {
+import { Controller, Get, Inject as Inject7 } from "@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") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -1870,19 +2651,19 @@ function _ts_decorate8(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate8, "_ts_decorate");
-function _ts_metadata7(metadataKey, metadataValue) {
+__name(_ts_decorate9, "_ts_decorate");
+function _ts_metadata8(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata7, "_ts_metadata");
-function _ts_param6(paramIndex, decorator) {
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param7(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param6, "_ts_param");
+__name(_ts_param7, "_ts_param");
 var AgentsController = class {
   static {
     __name(this, "AgentsController");
@@ -1904,26 +2685,26 @@ var AgentsController = class {
     }));
   }
 };
-_ts_decorate8([
+_ts_decorate9([
   Get(),
-  _ts_metadata7("design:type", Function),
-  _ts_metadata7("design:paramtypes", []),
-  _ts_metadata7("design:returntype", Array)
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", []),
+  _ts_metadata8("design:returntype", Array)
 ], AgentsController.prototype, "list", null);
-AgentsController = _ts_decorate8([
+AgentsController = _ts_decorate9([
   Controller("agents"),
-  _ts_param6(0, Inject6(AGENT_REGISTRY2)),
-  _ts_param6(1, Inject6(AGENT_DEPS_FACTORY4)),
-  _ts_metadata7("design:type", Function),
-  _ts_metadata7("design:paramtypes", [
+  _ts_param7(0, Inject7(AGENT_REGISTRY2)),
+  _ts_param7(1, Inject7(AGENT_DEPS_FACTORY4)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
     typeof AgentRegistry3 === "undefined" ? Object : AgentRegistry3,
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory
   ])
 ], AgentsController);
 
 // src/controller/attachments.controller.ts
-import { AGENT_ACTOR_RESOLVER, AGENT_ATTACHMENT_STAGING as AGENT_ATTACHMENT_STAGING2, AGENT_OPTIONS as AGENT_OPTIONS3 } from "@dudousxd/nestjs-agent-core";
-import { BadRequestException as BadRequestException2, Controller as Controller2, Get as Get2, Inject as Inject7, NotImplementedException as NotImplementedException2, Optional as Optional4, PayloadTooLargeException, Post, Req, UnsupportedMediaTypeException, UploadedFile, UseInterceptors } from "@nestjs/common";
+import { AGENT_ACTOR_RESOLVER, AGENT_ATTACHMENT_STAGING as AGENT_ATTACHMENT_STAGING3, AGENT_OPTIONS as AGENT_OPTIONS4 } from "@dudousxd/nestjs-agent-core";
+import { BadRequestException as BadRequestException2, Controller as Controller2, Get as Get2, Inject as Inject8, NotImplementedException as NotImplementedException3, Optional as Optional6, PayloadTooLargeException, Post, Req, UnsupportedMediaTypeException, UploadedFile, UseInterceptors } from "@nestjs/common";
 import { FileInterceptor } from "@nestjs/platform-express";
 
 // src/attachment-limits.ts
@@ -1952,7 +2733,7 @@ function attachmentLimits(options, staging) {
 __name(attachmentLimits, "attachmentLimits");
 
 // src/controller/attachments.controller.ts
-function _ts_decorate9(decorators, target, key, desc) {
+function _ts_decorate10(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);
@@ -1965,19 +2746,19 @@ function _ts_decorate9(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate9, "_ts_decorate");
-function _ts_metadata8(metadataKey, metadataValue) {
+__name(_ts_decorate10, "_ts_decorate");
+function _ts_metadata9(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata8, "_ts_metadata");
-function _ts_param7(paramIndex, decorator) {
+__name(_ts_metadata9, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param7, "_ts_param");
+__name(_ts_param8, "_ts_param");
 var HARD_MAX_ATTACHMENT_BYTES = 32 * 1024 * 1024;
 var ATTACHMENT_PAGE_SIZE = 50;
 var AttachmentsController = class {
@@ -2011,7 +2792,7 @@ var AttachmentsController = class {
   }
   async upload(req, file) {
     if (this.staging === void 0) {
-      throw new NotImplementedException2("Attachment upload is not configured on this server: bind AGENT_ATTACHMENT_STAGING (e.g. import AgentMediaAttachmentsModule).");
+      throw new NotImplementedException3("Attachment upload is not configured on this server: bind AGENT_ATTACHMENT_STAGING (e.g. import AgentMediaAttachmentsModule).");
     }
     if (file === void 0) {
       throw new BadRequestException2('multipart field "file" is required');
@@ -2033,39 +2814,39 @@ var AttachmentsController = class {
     });
   }
 };
-_ts_decorate9([
+_ts_decorate10([
   Get2(),
-  _ts_param7(0, Req()),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
+  _ts_param8(0, Req()),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request
   ]),
-  _ts_metadata8("design:returntype", Promise)
+  _ts_metadata9("design:returntype", Promise)
 ], AttachmentsController.prototype, "list", null);
-_ts_decorate9([
+_ts_decorate10([
   Post(),
   UseInterceptors(FileInterceptor("file", {
     limits: {
       fileSize: HARD_MAX_ATTACHMENT_BYTES
     }
   })),
-  _ts_param7(0, Req()),
-  _ts_param7(1, UploadedFile()),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
+  _ts_param8(0, Req()),
+  _ts_param8(1, UploadedFile()),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     Object
   ]),
-  _ts_metadata8("design:returntype", Promise)
+  _ts_metadata9("design:returntype", Promise)
 ], AttachmentsController.prototype, "upload", null);
-AttachmentsController = _ts_decorate9([
+AttachmentsController = _ts_decorate10([
   Controller2("attachments"),
-  _ts_param7(0, Inject7(AGENT_OPTIONS3)),
-  _ts_param7(1, Inject7(AGENT_ACTOR_RESOLVER)),
-  _ts_param7(3, Optional4()),
-  _ts_param7(3, Inject7(AGENT_ATTACHMENT_STAGING2)),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
+  _ts_param8(0, Inject8(AGENT_OPTIONS4)),
+  _ts_param8(1, Inject8(AGENT_ACTOR_RESOLVER)),
+  _ts_param8(3, Optional6()),
+  _ts_param8(3, Inject8(AGENT_ATTACHMENT_STAGING3)),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
     typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions,
     typeof ActorResolver === "undefined" ? Object : ActorResolver,
     typeof AgentService === "undefined" ? Object : AgentService,
@@ -2075,8 +2856,8 @@ AttachmentsController = _ts_decorate9([
 
 // src/controller/chat.controller.ts
 import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER2, AgentStreamError as AgentStreamError2 } from "@dudousxd/nestjs-agent-core";
-import { BadRequestException as BadRequestException3, Body, Controller as Controller3, Get as Get3, Inject as Inject8, Param, Post as Post2, Query, Req as Req2, Res } from "@nestjs/common";
-function _ts_decorate10(decorators, target, key, desc) {
+import { BadRequestException as BadRequestException3, Body, Controller as Controller3, Get as Get3, Inject as Inject9, Param, Post as Post2, Query, Req as Req2, Res } from "@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") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -2089,19 +2870,32 @@ function _ts_decorate10(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate10, "_ts_decorate");
-function _ts_metadata9(metadataKey, metadataValue) {
+__name(_ts_decorate11, "_ts_decorate");
+function _ts_metadata10(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata9, "_ts_metadata");
-function _ts_param8(paramIndex, decorator) {
+__name(_ts_metadata10, "_ts_metadata");
+function _ts_param9(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param8, "_ts_param");
+__name(_ts_param9, "_ts_param");
+function sendMode(body) {
+  if (body.interrupt === true) {
+    return "interrupt";
+  }
+  if (body.mode === void 0 || body.mode === null) {
+    return "auto";
+  }
+  if (body.mode === "auto" || body.mode === "queue" || body.mode === "interrupt") {
+    return body.mode;
+  }
+  throw new BadRequestException3("mode must be 'auto', 'queue' or 'interrupt'");
+}
+__name(sendMode, "sendMode");
 function attachmentRefs(claimed) {
   if (claimed === void 0) {
     return [];
@@ -2139,10 +2933,17 @@ var ChatController = class {
     this.agent = agent;
     this.actorResolver = actorResolver;
   }
+  /**
+  * Start a turn and stream it — or, when the thread already has one running, queue the message and
+  * answer `202 { queued: true, messageId, position, queue, … }` (JSON, no stream): it runs when the
+  * turn ahead of it settles, and the stream of the run holding the thread announces it with a
+  * `queue` frame.
+  */
   async chat(req, res, body) {
     const actor = await this.actorResolver.resolve(req);
     const attachments = attachmentRefs(body.attachments);
-    const { runId, threadId } = await this.agent.chat({
+    const mode = sendMode(body);
+    const result = await this.agent.send({
       actor,
       message: body.message,
       ...body.threadId !== void 0 ? {
@@ -2165,8 +2966,14 @@ var ChatController = class {
       } : {},
       ...typeof body.model === "string" && body.model.length > 0 ? {
         model: body.model
-      } : {}
+      } : {},
+      mode
     });
+    if (result.queued === true) {
+      res.status(202).json(result);
+      return;
+    }
+    const { runId, threadId } = result;
     await this.pipe(res, runId, this.agent.subscribe(runId), threadId);
   }
   /**
@@ -2256,50 +3063,50 @@ data: ${JSON.stringify(payload)}
     res.end();
   }
 };
-_ts_decorate10([
+_ts_decorate11([
   Post2("chat"),
-  _ts_param8(0, Req2()),
-  _ts_param8(1, Res()),
-  _ts_param8(2, Body()),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  _ts_param9(0, Req2()),
+  _ts_param9(1, Res()),
+  _ts_param9(2, Body()),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     typeof Response === "undefined" ? Object : Response,
     typeof ChatBody === "undefined" ? Object : ChatBody
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata10("design:returntype", Promise)
 ], ChatController.prototype, "chat", null);
-_ts_decorate10([
+_ts_decorate11([
   Get3("chat/:runId/stream"),
-  _ts_param8(0, Req2()),
-  _ts_param8(1, Param("runId")),
-  _ts_param8(2, Res()),
-  _ts_param8(3, Query("after")),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  _ts_param9(0, Req2()),
+  _ts_param9(1, Param("runId")),
+  _ts_param9(2, Res()),
+  _ts_param9(3, Query("after")),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String,
     typeof Response === "undefined" ? Object : Response,
     String
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata10("design:returntype", Promise)
 ], ChatController.prototype, "stream", null);
-_ts_decorate10([
+_ts_decorate11([
   Post2("chat/:runId/cancel"),
-  _ts_param8(0, Req2()),
-  _ts_param8(1, Param("runId")),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  _ts_param9(0, Req2()),
+  _ts_param9(1, Param("runId")),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata10("design:returntype", Promise)
 ], ChatController.prototype, "cancel", null);
-ChatController = _ts_decorate10([
+ChatController = _ts_decorate11([
   Controller3(),
-  _ts_param8(1, Inject8(AGENT_ACTOR_RESOLVER2)),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  _ts_param9(1, Inject9(AGENT_ACTOR_RESOLVER2)),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
     typeof ActorResolver === "undefined" ? Object : ActorResolver
   ])
@@ -2315,8 +3122,8 @@ function parseCursor(raw) {
 __name(parseCursor, "parseCursor");
 
 // src/controller/config.controller.ts
-import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER3, AGENT_ATTACHMENT_STAGING as AGENT_ATTACHMENT_STAGING3, AGENT_MODEL_CATALOG as AGENT_MODEL_CATALOG2, AGENT_OPTIONS as AGENT_OPTIONS4 } from "@dudousxd/nestjs-agent-core";
-import { Controller as Controller4, Get as Get4, Inject as Inject9, Optional as Optional5, Req as Req3 } from "@nestjs/common";
+import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER3, AGENT_ATTACHMENT_STAGING as AGENT_ATTACHMENT_STAGING4, AGENT_MODEL_CATALOG as AGENT_MODEL_CATALOG2, AGENT_OPTIONS as AGENT_OPTIONS5 } from "@dudousxd/nestjs-agent-core";
+import { Controller as Controller4, Get as Get4, Inject as Inject10, Optional as Optional7, Req as Req3 } from "@nestjs/common";
 
 // src/resolver/anonymous-actor-resolver.ts
 import { createHash, randomBytes } from "crypto";
@@ -2406,7 +3213,7 @@ var AnonymousActorResolver = class {
 };
 
 // src/controller/config.controller.ts
-function _ts_decorate11(decorators, target, key, desc) {
+function _ts_decorate12(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);
@@ -2419,19 +3226,19 @@ function _ts_decorate11(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate11, "_ts_decorate");
-function _ts_metadata10(metadataKey, metadataValue) {
+__name(_ts_decorate12, "_ts_decorate");
+function _ts_metadata11(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata10, "_ts_metadata");
-function _ts_param9(paramIndex, decorator) {
+__name(_ts_metadata11, "_ts_metadata");
+function _ts_param10(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param9, "_ts_param");
+__name(_ts_param10, "_ts_param");
 var ConfigController = class {
   static {
     __name(this, "ConfigController");
@@ -2462,25 +3269,25 @@ var ConfigController = class {
     };
   }
 };
-_ts_decorate11([
+_ts_decorate12([
   Get4(),
-  _ts_param9(0, Req3()),
-  _ts_metadata10("design:type", Function),
-  _ts_metadata10("design:paramtypes", [
+  _ts_param10(0, Req3()),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request
   ]),
-  _ts_metadata10("design:returntype", Promise)
+  _ts_metadata11("design:returntype", Promise)
 ], ConfigController.prototype, "config", null);
-ConfigController = _ts_decorate11([
+ConfigController = _ts_decorate12([
   Controller4("config"),
-  _ts_param9(0, Inject9(AGENT_OPTIONS4)),
-  _ts_param9(1, Inject9(AGENT_ACTOR_RESOLVER3)),
-  _ts_param9(2, Optional5()),
-  _ts_param9(2, Inject9(AGENT_ATTACHMENT_STAGING3)),
-  _ts_param9(3, Optional5()),
-  _ts_param9(3, Inject9(AGENT_MODEL_CATALOG2)),
-  _ts_metadata10("design:type", Function),
-  _ts_metadata10("design:paramtypes", [
+  _ts_param10(0, Inject10(AGENT_OPTIONS5)),
+  _ts_param10(1, Inject10(AGENT_ACTOR_RESOLVER3)),
+  _ts_param10(2, Optional7()),
+  _ts_param10(2, Inject10(AGENT_ATTACHMENT_STAGING4)),
+  _ts_param10(3, Optional7()),
+  _ts_param10(3, Inject10(AGENT_MODEL_CATALOG2)),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
     typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions,
     typeof ActorResolver === "undefined" ? Object : ActorResolver,
     Object,
@@ -2490,8 +3297,8 @@ ConfigController = _ts_decorate11([
 
 // src/controller/memories.controller.ts
 import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER4, AGENT_MEMORY as AGENT_MEMORY2, memoryForgetVerdict, offerMemories } from "@dudousxd/nestjs-agent-core";
-import { Controller as Controller5, Delete, ForbiddenException as ForbiddenException2, Get as Get5, Inject as Inject10, NotFoundException as NotFoundException2, Optional as Optional6, Param as Param2, Query as Query2, Req as Req4 } from "@nestjs/common";
-function _ts_decorate12(decorators, target, key, desc) {
+import { Controller as Controller5, Delete, ForbiddenException as ForbiddenException2, Get as Get5, Inject as Inject11, NotFoundException as NotFoundException2, Optional as Optional8, Param as Param2, Query as Query2, Req as Req4 } from "@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") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -2504,19 +3311,19 @@ function _ts_decorate12(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate12, "_ts_decorate");
-function _ts_metadata11(metadataKey, metadataValue) {
+__name(_ts_decorate13, "_ts_decorate");
+function _ts_metadata12(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata11, "_ts_metadata");
-function _ts_param10(paramIndex, decorator) {
+__name(_ts_metadata12, "_ts_metadata");
+function _ts_param11(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param10, "_ts_param");
+__name(_ts_param11, "_ts_param");
 var MemoriesController = class {
   static {
     __name(this, "MemoriesController");
@@ -2589,35 +3396,35 @@ var MemoriesController = class {
     });
   }
 };
-_ts_decorate12([
+_ts_decorate13([
   Get5(),
-  _ts_param10(0, Req4()),
-  _ts_param10(1, Query2("threadId")),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+  _ts_param11(0, Req4()),
+  _ts_param11(1, Query2("threadId")),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String
   ]),
-  _ts_metadata11("design:returntype", Promise)
+  _ts_metadata12("design:returntype", Promise)
 ], MemoriesController.prototype, "list", null);
-_ts_decorate12([
+_ts_decorate13([
   Delete(":id"),
-  _ts_param10(0, Req4()),
-  _ts_param10(1, Param2("id")),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+  _ts_param11(0, Req4()),
+  _ts_param11(1, Param2("id")),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String
   ]),
-  _ts_metadata11("design:returntype", Promise)
+  _ts_metadata12("design:returntype", Promise)
 ], MemoriesController.prototype, "forget", null);
-MemoriesController = _ts_decorate12([
+MemoriesController = _ts_decorate13([
   Controller5("memories"),
-  _ts_param10(0, Inject10(AGENT_ACTOR_RESOLVER4)),
-  _ts_param10(1, Optional6()),
-  _ts_param10(1, Inject10(AGENT_MEMORY2)),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+  _ts_param11(0, Inject11(AGENT_ACTOR_RESOLVER4)),
+  _ts_param11(1, Optional8()),
+  _ts_param11(1, Inject11(AGENT_MEMORY2)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof ActorResolver === "undefined" ? Object : ActorResolver,
     Object
   ])
@@ -2625,8 +3432,8 @@ MemoriesController = _ts_decorate12([
 
 // src/controller/messages.controller.ts
 import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER5 } from "@dudousxd/nestjs-agent-core";
-import { Body as Body2, Controller as Controller6, HttpCode, Inject as Inject11, Param as Param3, Post as Post3, Req as Req5 } from "@nestjs/common";
-function _ts_decorate13(decorators, target, key, desc) {
+import { Body as Body2, Controller as Controller6, HttpCode, Inject as Inject12, Param as Param3, Post as Post3, Req as Req5 } from "@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") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -2639,19 +3446,19 @@ function _ts_decorate13(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate13, "_ts_decorate");
-function _ts_metadata12(metadataKey, metadataValue) {
+__name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata13(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata12, "_ts_metadata");
-function _ts_param11(paramIndex, decorator) {
+__name(_ts_metadata13, "_ts_metadata");
+function _ts_param12(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param11, "_ts_param");
+__name(_ts_param12, "_ts_param");
 var MessagesController = class {
   static {
     __name(this, "MessagesController");
@@ -2679,25 +3486,25 @@ var MessagesController = class {
     };
   }
 };
-_ts_decorate13([
+_ts_decorate14([
   Post3(":id/feedback"),
   HttpCode(200),
-  _ts_param11(0, Req5()),
-  _ts_param11(1, Param3("id")),
-  _ts_param11(2, Body2()),
-  _ts_metadata12("design:type", Function),
-  _ts_metadata12("design:paramtypes", [
+  _ts_param12(0, Req5()),
+  _ts_param12(1, Param3("id")),
+  _ts_param12(2, Body2()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String,
     typeof FeedbackBody === "undefined" ? Object : FeedbackBody
   ]),
-  _ts_metadata12("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], MessagesController.prototype, "feedback", null);
-MessagesController = _ts_decorate13([
+MessagesController = _ts_decorate14([
   Controller6("messages"),
-  _ts_param11(1, Inject11(AGENT_ACTOR_RESOLVER5)),
-  _ts_metadata12("design:type", Function),
-  _ts_metadata12("design:paramtypes", [
+  _ts_param12(1, Inject12(AGENT_ACTOR_RESOLVER5)),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
     typeof ActorResolver === "undefined" ? Object : ActorResolver
   ])
@@ -2705,8 +3512,8 @@ MessagesController = _ts_decorate13([
 
 // src/controller/models.controller.ts
 import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER6 } from "@dudousxd/nestjs-agent-core";
-import { Controller as Controller7, Get as Get6, Inject as Inject12, Query as Query3, Req as Req6 } from "@nestjs/common";
-function _ts_decorate14(decorators, target, key, desc) {
+import { Controller as Controller7, Get as Get6, Inject as Inject13, Query as Query3, Req as Req6 } from "@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") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -2719,19 +3526,19 @@ function _ts_decorate14(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate14, "_ts_decorate");
-function _ts_metadata13(metadataKey, metadataValue) {
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_metadata14(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata13, "_ts_metadata");
-function _ts_param12(paramIndex, decorator) {
+__name(_ts_metadata14, "_ts_metadata");
+function _ts_param13(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param12, "_ts_param");
+__name(_ts_param13, "_ts_param");
 var ModelsController = class {
   static {
     __name(this, "ModelsController");
@@ -2751,31 +3558,31 @@ var ModelsController = class {
     return this.agent.listModels(actor, agent);
   }
 };
-_ts_decorate14([
+_ts_decorate15([
   Get6(),
-  _ts_param12(0, Req6()),
-  _ts_param12(1, Query3("agent")),
-  _ts_metadata13("design:type", Function),
-  _ts_metadata13("design:paramtypes", [
+  _ts_param13(0, Req6()),
+  _ts_param13(1, Query3("agent")),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String
   ]),
-  _ts_metadata13("design:returntype", Promise)
+  _ts_metadata14("design:returntype", Promise)
 ], ModelsController.prototype, "list", null);
-ModelsController = _ts_decorate14([
+ModelsController = _ts_decorate15([
   Controller7("models"),
-  _ts_param12(1, Inject12(AGENT_ACTOR_RESOLVER6)),
-  _ts_metadata13("design:type", Function),
-  _ts_metadata13("design:paramtypes", [
+  _ts_param13(1, Inject13(AGENT_ACTOR_RESOLVER6)),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
     typeof ActorResolver === "undefined" ? Object : ActorResolver
   ])
 ], ModelsController);
 
-// src/controller/quota.controller.ts
+// src/controller/queue.controller.ts
 import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER7 } from "@dudousxd/nestjs-agent-core";
-import { Controller as Controller8, Get as Get7, Inject as Inject13, Req as Req7 } from "@nestjs/common";
-function _ts_decorate15(decorators, target, key, desc) {
+import { BadRequestException as BadRequestException4, Body as Body3, Controller as Controller8, Delete as Delete2, Get as Get7, Inject as Inject14, Param as Param4, Patch, Post as Post4, Req as Req7 } from "@nestjs/common";
+function _ts_decorate16(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -2788,19 +3595,160 @@ function _ts_decorate15(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate15, "_ts_decorate");
-function _ts_metadata14(metadataKey, metadataValue) {
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata15(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata14, "_ts_metadata");
-function _ts_param13(paramIndex, decorator) {
+__name(_ts_metadata15, "_ts_metadata");
+function _ts_param14(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param13, "_ts_param");
+__name(_ts_param14, "_ts_param");
+var QueueController = class {
+  static {
+    __name(this, "QueueController");
+  }
+  agent;
+  actorResolver;
+  constructor(agent, actorResolver) {
+    this.agent = agent;
+    this.actorResolver = actorResolver;
+  }
+  async list(req, id) {
+    return this.agent.getQueue(await this.actorResolver.resolve(req), id);
+  }
+  async clear(req, id) {
+    return this.agent.clearQueue(await this.actorResolver.resolve(req), id);
+  }
+  /** Lift a pause; the head starts when nothing is running. Carries `runId` when it started. */
+  async resume(req, id) {
+    return this.agent.resumeQueue(await this.actorResolver.resolve(req), id);
+  }
+  async update(req, messageId, body) {
+    const actor = await this.actorResolver.resolve(req);
+    if (body.message !== void 0 && typeof body.message !== "string") {
+      throw new BadRequestException4("message must be a string");
+    }
+    if (body.position !== void 0 && typeof body.position !== "number") {
+      throw new BadRequestException4("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, {
+      ...body.message !== void 0 ? {
+        message: body.message
+      } : {},
+      ...attachments !== void 0 ? {
+        attachments
+      } : {},
+      ...body.position !== void 0 ? {
+        position: body.position
+      } : {}
+    });
+  }
+  async remove(req, messageId) {
+    return this.agent.removeQueuedMessage(await this.actorResolver.resolve(req), messageId);
+  }
+};
+_ts_decorate16([
+  Get7("threads/:id/queue"),
+  _ts_param14(0, Req7()),
+  _ts_param14(1, Param4("id")),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata15("design:returntype", Promise)
+], QueueController.prototype, "list", null);
+_ts_decorate16([
+  Delete2("threads/:id/queue"),
+  _ts_param14(0, Req7()),
+  _ts_param14(1, Param4("id")),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata15("design:returntype", Promise)
+], QueueController.prototype, "clear", null);
+_ts_decorate16([
+  Post4("threads/:id/queue/resume"),
+  _ts_param14(0, Req7()),
+  _ts_param14(1, Param4("id")),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata15("design:returntype", Promise)
+], QueueController.prototype, "resume", null);
+_ts_decorate16([
+  Patch("queue/:messageId"),
+  _ts_param14(0, Req7()),
+  _ts_param14(1, Param4("messageId")),
+  _ts_param14(2, Body3()),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String,
+    typeof UpdateQueuedMessageBody === "undefined" ? Object : UpdateQueuedMessageBody
+  ]),
+  _ts_metadata15("design:returntype", Promise)
+], QueueController.prototype, "update", null);
+_ts_decorate16([
+  Delete2("queue/:messageId"),
+  _ts_param14(0, Req7()),
+  _ts_param14(1, Param4("messageId")),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata15("design:returntype", Promise)
+], QueueController.prototype, "remove", null);
+QueueController = _ts_decorate16([
+  Controller8(),
+  _ts_param14(1, Inject14(AGENT_ACTOR_RESOLVER7)),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof AgentService === "undefined" ? Object : AgentService,
+    typeof ActorResolver === "undefined" ? Object : ActorResolver
+  ])
+], QueueController);
+
+// src/controller/quota.controller.ts
+import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER8 } from "@dudousxd/nestjs-agent-core";
+import { Controller as Controller9, Get as Get8, Inject as Inject15, Req as Req8 } from "@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") {
+    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_decorate17, "_ts_decorate");
+function _ts_metadata16(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata16, "_ts_metadata");
+function _ts_param15(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param15, "_ts_param");
 var QuotaController = class {
   static {
     __name(this, "QuotaController");
@@ -2820,29 +3768,29 @@ var QuotaController = class {
     return this.agent.quotaReport(actor);
   }
 };
-_ts_decorate15([
-  Get7(),
-  _ts_param13(0, Req7()),
-  _ts_metadata14("design:type", Function),
-  _ts_metadata14("design:paramtypes", [
+_ts_decorate17([
+  Get8(),
+  _ts_param15(0, Req8()),
+  _ts_metadata16("design:type", Function),
+  _ts_metadata16("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request
   ]),
-  _ts_metadata14("design:returntype", Promise)
+  _ts_metadata16("design:returntype", Promise)
 ], QuotaController.prototype, "report", null);
-QuotaController = _ts_decorate15([
-  Controller8("quota"),
-  _ts_param13(1, Inject13(AGENT_ACTOR_RESOLVER7)),
-  _ts_metadata14("design:type", Function),
-  _ts_metadata14("design:paramtypes", [
+QuotaController = _ts_decorate17([
+  Controller9("quota"),
+  _ts_param15(1, Inject15(AGENT_ACTOR_RESOLVER8)),
+  _ts_metadata16("design:type", Function),
+  _ts_metadata16("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
     typeof ActorResolver === "undefined" ? Object : ActorResolver
   ])
 ], QuotaController);
 
 // src/controller/skills.controller.ts
-import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER8, AGENT_SKILLS as AGENT_SKILLS2, offerSkills } from "@dudousxd/nestjs-agent-core";
-import { Controller as Controller9, Get as Get8, Inject as Inject14, Optional as Optional7, Query as Query4, Req as Req8 } from "@nestjs/common";
-function _ts_decorate16(decorators, target, key, desc) {
+import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER9, AGENT_SKILLS as AGENT_SKILLS2, offerSkills } from "@dudousxd/nestjs-agent-core";
+import { Controller as Controller10, Get as Get9, Inject as Inject16, Optional as Optional9, Query as Query4, Req as Req9 } from "@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") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -2855,19 +3803,19 @@ function _ts_decorate16(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate16, "_ts_decorate");
-function _ts_metadata15(metadataKey, metadataValue) {
+__name(_ts_decorate18, "_ts_decorate");
+function _ts_metadata17(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata15, "_ts_metadata");
-function _ts_param14(paramIndex, decorator) {
+__name(_ts_metadata17, "_ts_metadata");
+function _ts_param16(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param14, "_ts_param");
+__name(_ts_param16, "_ts_param");
 var SkillsController = class {
   static {
     __name(this, "SkillsController");
@@ -2890,33 +3838,33 @@ var SkillsController = class {
     return offer.entries;
   }
 };
-_ts_decorate16([
-  Get8(),
-  _ts_param14(0, Req8()),
-  _ts_param14(1, Query4("threadId")),
-  _ts_metadata15("design:type", Function),
-  _ts_metadata15("design:paramtypes", [
+_ts_decorate18([
+  Get9(),
+  _ts_param16(0, Req9()),
+  _ts_param16(1, Query4("threadId")),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String
   ]),
-  _ts_metadata15("design:returntype", Promise)
+  _ts_metadata17("design:returntype", Promise)
 ], SkillsController.prototype, "list", null);
-SkillsController = _ts_decorate16([
-  Controller9("skills"),
-  _ts_param14(0, Inject14(AGENT_ACTOR_RESOLVER8)),
-  _ts_param14(1, Optional7()),
-  _ts_param14(1, Inject14(AGENT_SKILLS2)),
-  _ts_metadata15("design:type", Function),
-  _ts_metadata15("design:paramtypes", [
+SkillsController = _ts_decorate18([
+  Controller10("skills"),
+  _ts_param16(0, Inject16(AGENT_ACTOR_RESOLVER9)),
+  _ts_param16(1, Optional9()),
+  _ts_param16(1, Inject16(AGENT_SKILLS2)),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [
     typeof ActorResolver === "undefined" ? Object : ActorResolver,
     Object
   ])
 ], SkillsController);
 
 // src/controller/threads.controller.ts
-import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER9 } from "@dudousxd/nestjs-agent-core";
-import { Body as Body3, Controller as Controller10, Delete as Delete2, Get as Get9, Inject as Inject15, Param as Param4, Patch, Post as Post4, Req as Req9 } from "@nestjs/common";
-function _ts_decorate17(decorators, target, key, desc) {
+import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER10 } from "@dudousxd/nestjs-agent-core";
+import { Body as Body4, Controller as Controller11, Delete as Delete3, Get as Get10, Inject as Inject17, Param as Param5, Patch as Patch2, Post as Post5, Req as Req10 } from "@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") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -2929,19 +3877,19 @@ function _ts_decorate17(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate17, "_ts_decorate");
-function _ts_metadata16(metadataKey, metadataValue) {
+__name(_ts_decorate19, "_ts_decorate");
+function _ts_metadata18(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata16, "_ts_metadata");
-function _ts_param15(paramIndex, decorator) {
+__name(_ts_metadata18, "_ts_metadata");
+function _ts_param17(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param15, "_ts_param");
+__name(_ts_param17, "_ts_param");
 var ThreadsController = class {
   static {
     __name(this, "ThreadsController");
@@ -3008,101 +3956,101 @@ var ThreadsController = class {
     };
   }
 };
-_ts_decorate17([
-  Get9(),
-  _ts_param15(0, Req9()),
-  _ts_metadata16("design:type", Function),
-  _ts_metadata16("design:paramtypes", [
+_ts_decorate19([
+  Get10(),
+  _ts_param17(0, Req10()),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request
   ]),
-  _ts_metadata16("design:returntype", Promise)
+  _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "list", null);
-_ts_decorate17([
-  Get9(":id"),
-  _ts_param15(0, Req9()),
-  _ts_param15(1, Param4("id")),
-  _ts_metadata16("design:type", Function),
-  _ts_metadata16("design:paramtypes", [
+_ts_decorate19([
+  Get10(":id"),
+  _ts_param17(0, Req10()),
+  _ts_param17(1, Param5("id")),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String
   ]),
-  _ts_metadata16("design:returntype", Promise)
+  _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "detail", null);
-_ts_decorate17([
-  Delete2(":id"),
-  _ts_param15(0, Req9()),
-  _ts_param15(1, Param4("id")),
-  _ts_metadata16("design:type", Function),
-  _ts_metadata16("design:paramtypes", [
+_ts_decorate19([
+  Delete3(":id"),
+  _ts_param17(0, Req10()),
+  _ts_param17(1, Param5("id")),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String
   ]),
-  _ts_metadata16("design:returntype", Promise)
+  _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "remove", null);
-_ts_decorate17([
-  Post4(":id/fork-from/:messageId"),
-  _ts_param15(0, Req9()),
-  _ts_param15(1, Param4("id")),
-  _ts_param15(2, Param4("messageId")),
-  _ts_metadata16("design:type", Function),
-  _ts_metadata16("design:paramtypes", [
+_ts_decorate19([
+  Post5(":id/fork-from/:messageId"),
+  _ts_param17(0, Req10()),
+  _ts_param17(1, Param5("id")),
+  _ts_param17(2, Param5("messageId")),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String,
     String
   ]),
-  _ts_metadata16("design:returntype", Promise)
+  _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "fork", null);
-_ts_decorate17([
-  Patch(":id"),
-  _ts_param15(0, Req9()),
-  _ts_param15(1, Param4("id")),
-  _ts_param15(2, Body3()),
-  _ts_metadata16("design:type", Function),
-  _ts_metadata16("design:paramtypes", [
+_ts_decorate19([
+  Patch2(":id"),
+  _ts_param17(0, Req10()),
+  _ts_param17(1, Param5("id")),
+  _ts_param17(2, Body4()),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String,
     typeof UpdateThreadBody === "undefined" ? Object : UpdateThreadBody
   ]),
-  _ts_metadata16("design:returntype", Promise)
+  _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "update", null);
-_ts_decorate17([
-  Post4(":id/promote"),
-  _ts_param15(0, Req9()),
-  _ts_param15(1, Param4("id")),
-  _ts_metadata16("design:type", Function),
-  _ts_metadata16("design:paramtypes", [
+_ts_decorate19([
+  Post5(":id/promote"),
+  _ts_param17(0, Req10()),
+  _ts_param17(1, Param5("id")),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String
   ]),
-  _ts_metadata16("design:returntype", Promise)
+  _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "promote", null);
-_ts_decorate17([
-  Delete2(":id/from/:messageId"),
-  _ts_param15(0, Req9()),
-  _ts_param15(1, Param4("id")),
-  _ts_param15(2, Param4("messageId")),
-  _ts_metadata16("design:type", Function),
-  _ts_metadata16("design:paramtypes", [
+_ts_decorate19([
+  Delete3(":id/from/:messageId"),
+  _ts_param17(0, Req10()),
+  _ts_param17(1, Param5("id")),
+  _ts_param17(2, Param5("messageId")),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String,
     String
   ]),
-  _ts_metadata16("design:returntype", Promise)
+  _ts_metadata18("design:returntype", Promise)
 ], ThreadsController.prototype, "truncateFrom", null);
-ThreadsController = _ts_decorate17([
-  Controller10("threads"),
-  _ts_param15(1, Inject15(AGENT_ACTOR_RESOLVER9)),
-  _ts_metadata16("design:type", Function),
-  _ts_metadata16("design:paramtypes", [
+ThreadsController = _ts_decorate19([
+  Controller11("threads"),
+  _ts_param17(1, Inject17(AGENT_ACTOR_RESOLVER10)),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
     typeof ActorResolver === "undefined" ? Object : ActorResolver
   ])
 ], ThreadsController);
 
 // src/controller/tool-call.controller.ts
-import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER10 } from "@dudousxd/nestjs-agent-core";
-import { BadRequestException as BadRequestException4, Body as Body4, Controller as Controller11, Inject as Inject16, Post as Post5, Req as Req10 } from "@nestjs/common";
-function _ts_decorate18(decorators, target, key, desc) {
+import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER11 } from "@dudousxd/nestjs-agent-core";
+import { BadRequestException as BadRequestException5, Body as Body5, Controller as Controller12, Inject as Inject18, Post as Post6, Req as Req11 } from "@nestjs/common";
+function _ts_decorate20(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -3115,19 +4063,19 @@ function _ts_decorate18(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate18, "_ts_decorate");
-function _ts_metadata17(metadataKey, metadataValue) {
+__name(_ts_decorate20, "_ts_decorate");
+function _ts_metadata19(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata17, "_ts_metadata");
-function _ts_param16(paramIndex, decorator) {
+__name(_ts_metadata19, "_ts_metadata");
+function _ts_param18(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param16, "_ts_param");
+__name(_ts_param18, "_ts_param");
 var MAX_ANSWERED_QUESTIONS = 100;
 var MAX_VALUES_PER_QUESTION = 100;
 var MAX_ANSWER_VALUE_LENGTH = 4096;
@@ -3136,7 +4084,7 @@ var MAX_VIA_LENGTH = 64;
 var DEFAULT_VIA = "web";
 function toolCallId(claimed) {
   if (typeof claimed !== "string" || claimed.length === 0) {
-    throw new BadRequestException4("toolCallId must be a non-empty string");
+    throw new BadRequestException5("toolCallId must be a non-empty string");
   }
   return claimed;
 }
@@ -3146,10 +4094,10 @@ function rejectReason(claimed) {
     return void 0;
   }
   if (typeof claimed !== "string") {
-    throw new BadRequestException4("reason must be a string");
+    throw new BadRequestException5("reason must be a string");
   }
   if (claimed.length > MAX_REJECT_REASON_LENGTH) {
-    throw new BadRequestException4(`reason must be at most ${MAX_REJECT_REASON_LENGTH} characters`);
+    throw new BadRequestException5(`reason must be at most ${MAX_REJECT_REASON_LENGTH} characters`);
   }
   return claimed;
 }
@@ -3159,7 +4107,7 @@ function remember(claimed) {
     return false;
   }
   if (typeof claimed !== "boolean") {
-    throw new BadRequestException4("remember must be a boolean");
+    throw new BadRequestException5("remember must be a boolean");
   }
   return claimed;
 }
@@ -3169,7 +4117,7 @@ function via(claimed) {
     return DEFAULT_VIA;
   }
   if (typeof claimed !== "string" || claimed.length === 0 || claimed.length > MAX_VIA_LENGTH) {
-    throw new BadRequestException4(`via must be a string of 1-${MAX_VIA_LENGTH} characters`);
+    throw new BadRequestException5(`via must be a string of 1-${MAX_VIA_LENGTH} characters`);
   }
   return claimed;
 }
@@ -3179,26 +4127,26 @@ function answers(claimed) {
     return void 0;
   }
   if (typeof claimed !== "object" || claimed === null || Array.isArray(claimed)) {
-    throw new BadRequestException4("answers must be an object of questionId \u2192 chosen values");
+    throw new BadRequestException5("answers must be an object of questionId \u2192 chosen values");
   }
   const entries = Object.entries(claimed);
   if (entries.length > MAX_ANSWERED_QUESTIONS) {
-    throw new BadRequestException4(`answers may cover at most ${MAX_ANSWERED_QUESTIONS} questions`);
+    throw new BadRequestException5(`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 BadRequestException4(`answers["${questionId}"] must be an array of chosen values`);
+      throw new BadRequestException5(`answers["${questionId}"] must be an array of chosen values`);
     }
     if (values.length > MAX_VALUES_PER_QUESTION) {
-      throw new BadRequestException4(`answers["${questionId}"] may carry at most ${MAX_VALUES_PER_QUESTION} values`);
+      throw new BadRequestException5(`answers["${questionId}"] may carry at most ${MAX_VALUES_PER_QUESTION} values`);
     }
     for (const value of values) {
       if (typeof value !== "string") {
-        throw new BadRequestException4(`answers["${questionId}"] must contain only strings`);
+        throw new BadRequestException5(`answers["${questionId}"] must contain only strings`);
       }
       if (value.length > MAX_ANSWER_VALUE_LENGTH) {
-        throw new BadRequestException4(`answers["${questionId}"] values must be at most ${MAX_ANSWER_VALUE_LENGTH} characters`);
+        throw new BadRequestException5(`answers["${questionId}"] values must be at most ${MAX_ANSWER_VALUE_LENGTH} characters`);
       }
     }
     validated[questionId] = values;
@@ -3260,64 +4208,64 @@ var ToolCallController = class {
     };
   }
 };
-_ts_decorate18([
-  Post5("approve"),
-  _ts_param16(0, Req10()),
-  _ts_param16(1, Body4()),
-  _ts_metadata17("design:type", Function),
-  _ts_metadata17("design:paramtypes", [
+_ts_decorate20([
+  Post6("approve"),
+  _ts_param18(0, Req11()),
+  _ts_param18(1, Body5()),
+  _ts_metadata19("design:type", Function),
+  _ts_metadata19("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     typeof ApproveBody === "undefined" ? Object : ApproveBody
   ]),
-  _ts_metadata17("design:returntype", Promise)
+  _ts_metadata19("design:returntype", Promise)
 ], ToolCallController.prototype, "approve", null);
-_ts_decorate18([
-  Post5("reject"),
-  _ts_param16(0, Req10()),
-  _ts_param16(1, Body4()),
-  _ts_metadata17("design:type", Function),
-  _ts_metadata17("design:paramtypes", [
+_ts_decorate20([
+  Post6("reject"),
+  _ts_param18(0, Req11()),
+  _ts_param18(1, Body5()),
+  _ts_metadata19("design:type", Function),
+  _ts_metadata19("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     typeof RejectBody === "undefined" ? Object : RejectBody
   ]),
-  _ts_metadata17("design:returntype", Promise)
+  _ts_metadata19("design:returntype", Promise)
 ], ToolCallController.prototype, "reject", null);
-_ts_decorate18([
-  Post5("answer"),
-  _ts_param16(0, Req10()),
-  _ts_param16(1, Body4()),
-  _ts_metadata17("design:type", Function),
-  _ts_metadata17("design:paramtypes", [
+_ts_decorate20([
+  Post6("answer"),
+  _ts_param18(0, Req11()),
+  _ts_param18(1, Body5()),
+  _ts_metadata19("design:type", Function),
+  _ts_metadata19("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     typeof AnswerBody === "undefined" ? Object : AnswerBody
   ]),
-  _ts_metadata17("design:returntype", Promise)
+  _ts_metadata19("design:returntype", Promise)
 ], ToolCallController.prototype, "answer", null);
-_ts_decorate18([
-  Post5("skip"),
-  _ts_param16(0, Req10()),
-  _ts_param16(1, Body4()),
-  _ts_metadata17("design:type", Function),
-  _ts_metadata17("design:paramtypes", [
+_ts_decorate20([
+  Post6("skip"),
+  _ts_param18(0, Req11()),
+  _ts_param18(1, Body5()),
+  _ts_metadata19("design:type", Function),
+  _ts_metadata19("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     Object
   ]),
-  _ts_metadata17("design:returntype", Promise)
+  _ts_metadata19("design:returntype", Promise)
 ], ToolCallController.prototype, "skip", null);
-ToolCallController = _ts_decorate18([
-  Controller11("tool-call"),
-  _ts_param16(1, Inject16(AGENT_ACTOR_RESOLVER10)),
-  _ts_metadata17("design:type", Function),
-  _ts_metadata17("design:paramtypes", [
+ToolCallController = _ts_decorate20([
+  Controller12("tool-call"),
+  _ts_param18(1, Inject18(AGENT_ACTOR_RESOLVER11)),
+  _ts_metadata19("design:type", Function),
+  _ts_metadata19("design:paramtypes", [
     typeof AgentService === "undefined" ? Object : AgentService,
     typeof ActorResolver === "undefined" ? Object : ActorResolver
   ])
 ], ToolCallController);
 
 // src/controller/tools.controller.ts
-import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER11, AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY5, AGENT_REGISTRY as AGENT_REGISTRY3, AgentRegistry as AgentRegistry4 } from "@dudousxd/nestjs-agent-core";
-import { Controller as Controller12, Get as Get10, Inject as Inject17, NotFoundException as NotFoundException3, Query as Query5, Req as Req11 } from "@nestjs/common";
-function _ts_decorate19(decorators, target, key, desc) {
+import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER12, AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY5, AGENT_REGISTRY as AGENT_REGISTRY3, ALL_AGENTS, AgentRegistry as AgentRegistry4 } from "@dudousxd/nestjs-agent-core";
+import { Controller as Controller13, Get as Get11, Inject as Inject19, NotFoundException as NotFoundException3, Query as Query5, Req as Req12 } from "@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") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -3330,19 +4278,19 @@ function _ts_decorate19(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate19, "_ts_decorate");
-function _ts_metadata18(metadataKey, metadataValue) {
+__name(_ts_decorate21, "_ts_decorate");
+function _ts_metadata20(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata18, "_ts_metadata");
-function _ts_param17(paramIndex, decorator) {
+__name(_ts_metadata20, "_ts_metadata");
+function _ts_param19(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param17, "_ts_param");
+__name(_ts_param19, "_ts_param");
 var ToolsController = class {
   static {
     __name(this, "ToolsController");
@@ -3356,39 +4304,54 @@ var ToolsController = class {
     this.agents = agents;
   }
   async list(req, agent) {
-    if (agent !== void 0 && this.agents.get(agent) === void 0) {
+    if (agent !== void 0 && agent !== ALL_AGENTS && this.agents.get(agent) === void 0) {
       throw new NotFoundException3(`No agent named "${agent}"`);
     }
     const actor = await this.actorResolver.resolve(req);
-    const deps = this.depsFactory.forAgent(agent);
-    const specs = await deps.registry.visibleSpecs(actor, deps.rolesPolicy, deps.toolAllowList);
-    return specs.map((spec) => ({
-      name: spec.name,
-      kind: spec.kind,
-      ...spec.presentation !== void 0 ? {
-        presentation: spec.presentation
-      } : {}
-    }));
+    const names = agent === ALL_AGENTS ? [
+      void 0,
+      ...this.agents.list().map((definition) => definition.name)
+    ] : [
+      agent
+    ];
+    const entries = /* @__PURE__ */ new Map();
+    for (const name of names) {
+      const deps = this.depsFactory.forAgent(name);
+      const specs = await deps.registry.visibleSpecs(actor, deps.rolesPolicy, deps.toolAllowList);
+      for (const spec of specs) {
+        if (entries.has(spec.name)) continue;
+        entries.set(spec.name, {
+          name: spec.name,
+          kind: spec.kind,
+          ...spec.presentation !== void 0 ? {
+            presentation: spec.presentation
+          } : {}
+        });
+      }
+    }
+    return [
+      ...entries.values()
+    ];
   }
 };
-_ts_decorate19([
-  Get10(),
-  _ts_param17(0, Req11()),
-  _ts_param17(1, Query5("agent")),
-  _ts_metadata18("design:type", Function),
-  _ts_metadata18("design:paramtypes", [
+_ts_decorate21([
+  Get11(),
+  _ts_param19(0, Req12()),
+  _ts_param19(1, Query5("agent")),
+  _ts_metadata20("design:type", Function),
+  _ts_metadata20("design:paramtypes", [
     typeof Request === "undefined" ? Object : Request,
     String
   ]),
-  _ts_metadata18("design:returntype", Promise)
+  _ts_metadata20("design:returntype", Promise)
 ], ToolsController.prototype, "list", null);
-ToolsController = _ts_decorate19([
-  Controller12("tools"),
-  _ts_param17(0, Inject17(AGENT_ACTOR_RESOLVER11)),
-  _ts_param17(1, Inject17(AGENT_DEPS_FACTORY5)),
-  _ts_param17(2, Inject17(AGENT_REGISTRY3)),
-  _ts_metadata18("design:type", Function),
-  _ts_metadata18("design:paramtypes", [
+ToolsController = _ts_decorate21([
+  Controller13("tools"),
+  _ts_param19(0, Inject19(AGENT_ACTOR_RESOLVER12)),
+  _ts_param19(1, Inject19(AGENT_DEPS_FACTORY5)),
+  _ts_param19(2, Inject19(AGENT_REGISTRY3)),
+  _ts_metadata20("design:type", Function),
+  _ts_metadata20("design:paramtypes", [
     typeof ActorResolver === "undefined" ? Object : ActorResolver,
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
     typeof AgentRegistry4 === "undefined" ? Object : AgentRegistry4
@@ -3397,7 +4360,7 @@ ToolsController = _ts_decorate19([
 
 // src/discovery/agent-discovery.service.ts
 import { AGENT_PROMPT_CONTRIBUTORS as AGENT_PROMPT_CONTRIBUTORS2, AGENT_REGISTRY as AGENT_REGISTRY4, AgentRegistry as AgentRegistry5 } from "@dudousxd/nestjs-agent-core";
-import { Inject as Inject18, Injectable as Injectable7, Logger as Logger2 } from "@nestjs/common";
+import { Inject as Inject20, Injectable as Injectable8, Logger as Logger3 } from "@nestjs/common";
 import { DiscoveryService, MetadataScanner } from "@nestjs/core";
 
 // src/decorator/agent.decorator.ts
@@ -3414,7 +4377,7 @@ var SYSTEM_PROMPT_METADATA = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent:
 var SYSTEM_PROMPT_CONTRIBUTOR_METADATA = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent:system-prompt-contributor");
 
 // src/discovery/agent-discovery.service.ts
-function _ts_decorate20(decorators, target, key, desc) {
+function _ts_decorate22(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);
@@ -3427,19 +4390,19 @@ function _ts_decorate20(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate20, "_ts_decorate");
-function _ts_metadata19(metadataKey, metadataValue) {
+__name(_ts_decorate22, "_ts_decorate");
+function _ts_metadata21(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata19, "_ts_metadata");
-function _ts_param18(paramIndex, decorator) {
+__name(_ts_metadata21, "_ts_metadata");
+function _ts_param20(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param18, "_ts_param");
+__name(_ts_param20, "_ts_param");
 var AgentDiscoveryService = class _AgentDiscoveryService {
   static {
     __name(this, "AgentDiscoveryService");
@@ -3448,7 +4411,7 @@ var AgentDiscoveryService = class _AgentDiscoveryService {
   scanner;
   registry;
   contributors;
-  logger = new Logger2(_AgentDiscoveryService.name);
+  logger = new Logger3(_AgentDiscoveryService.name);
   constructor(discovery, scanner, registry, contributors) {
     this.discovery = discovery;
     this.scanner = scanner;
@@ -3566,12 +4529,12 @@ var AgentDiscoveryService = class _AgentDiscoveryService {
     return (ctx) => candidate.call(instance, ctx);
   }
 };
-AgentDiscoveryService = _ts_decorate20([
-  Injectable7(),
-  _ts_param18(2, Inject18(AGENT_REGISTRY4)),
-  _ts_param18(3, Inject18(AGENT_PROMPT_CONTRIBUTORS2)),
-  _ts_metadata19("design:type", Function),
-  _ts_metadata19("design:paramtypes", [
+AgentDiscoveryService = _ts_decorate22([
+  Injectable8(),
+  _ts_param20(2, Inject20(AGENT_REGISTRY4)),
+  _ts_param20(3, Inject20(AGENT_PROMPT_CONTRIBUTORS2)),
+  _ts_metadata21("design:type", Function),
+  _ts_metadata21("design:paramtypes", [
     typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
     typeof MetadataScanner === "undefined" ? Object : MetadataScanner,
     typeof AgentRegistry5 === "undefined" ? Object : AgentRegistry5,
@@ -3580,8 +4543,8 @@ AgentDiscoveryService = _ts_decorate20([
 ], AgentDiscoveryService);
 
 // src/discovery/ai-tool-discovery.service.ts
-import { AGENT_OPTIONS as AGENT_OPTIONS5, AGENT_REGISTRY as AGENT_REGISTRY5, AGENT_TOOL_REGISTRY as AGENT_TOOL_REGISTRY2, normalizeDelegation as normalizeDelegation2 } from "@dudousxd/nestjs-agent-core";
-import { Inject as Inject19, Injectable as Injectable8, Logger as Logger3 } from "@nestjs/common";
+import { AGENT_OPTIONS as AGENT_OPTIONS6, AGENT_REGISTRY as AGENT_REGISTRY5, AGENT_TOOL_REGISTRY as AGENT_TOOL_REGISTRY2, normalizeDelegation as normalizeDelegation2 } from "@dudousxd/nestjs-agent-core";
+import { Inject as Inject21, Injectable as Injectable9, Logger as Logger4 } from "@nestjs/common";
 import { DiscoveryService as DiscoveryService2 } from "@nestjs/core";
 import { z } from "zod";
 
@@ -3601,7 +4564,7 @@ function isBrandedFunctionalTool(value) {
 __name(isBrandedFunctionalTool, "isBrandedFunctionalTool");
 
 // src/discovery/ai-tool-discovery.service.ts
-function _ts_decorate21(decorators, target, key, desc) {
+function _ts_decorate23(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);
@@ -3614,19 +4577,19 @@ function _ts_decorate21(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate21, "_ts_decorate");
-function _ts_metadata20(metadataKey, metadataValue) {
+__name(_ts_decorate23, "_ts_decorate");
+function _ts_metadata22(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata20, "_ts_metadata");
-function _ts_param19(paramIndex, decorator) {
+__name(_ts_metadata22, "_ts_metadata");
+function _ts_param21(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param19, "_ts_param");
+__name(_ts_param21, "_ts_param");
 var AiToolDiscoveryService = class _AiToolDiscoveryService {
   static {
     __name(this, "AiToolDiscoveryService");
@@ -3635,7 +4598,7 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
   registry;
   agents;
   options;
-  logger = new Logger3(_AiToolDiscoveryService.name);
+  logger = new Logger4(_AiToolDiscoveryService.name);
   constructor(discovery, registry, agents, options) {
     this.discovery = discovery;
     this.registry = registry;
@@ -3770,13 +4733,13 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
     return true;
   }
 };
-AiToolDiscoveryService = _ts_decorate21([
-  Injectable8(),
-  _ts_param19(1, Inject19(AGENT_TOOL_REGISTRY2)),
-  _ts_param19(2, Inject19(AGENT_REGISTRY5)),
-  _ts_param19(3, Inject19(AGENT_OPTIONS5)),
-  _ts_metadata20("design:type", Function),
-  _ts_metadata20("design:paramtypes", [
+AiToolDiscoveryService = _ts_decorate23([
+  Injectable9(),
+  _ts_param21(1, Inject21(AGENT_TOOL_REGISTRY2)),
+  _ts_param21(2, Inject21(AGENT_REGISTRY5)),
+  _ts_param21(3, Inject21(AGENT_OPTIONS6)),
+  _ts_metadata22("design:type", Function),
+  _ts_metadata22("design:paramtypes", [
     typeof DiscoveryService2 === "undefined" ? Object : DiscoveryService2,
     typeof ToolRegistry === "undefined" ? Object : ToolRegistry,
     typeof AgentRegistry === "undefined" ? Object : AgentRegistry,
@@ -3786,7 +4749,7 @@ AiToolDiscoveryService = _ts_decorate21([
 
 // src/discovery/skill-discovery.service.ts
 import { AGENT_SKILL_SOURCES } from "@dudousxd/nestjs-agent-core";
-import { Inject as Inject20, Injectable as Injectable9, Logger as Logger4 } from "@nestjs/common";
+import { Inject as Inject22, Injectable as Injectable10, Logger as Logger5 } from "@nestjs/common";
 import { DiscoveryService as DiscoveryService3 } from "@nestjs/core";
 
 // src/decorator/skill.decorator.ts
@@ -3803,7 +4766,7 @@ function skillScope(options) {
 __name(skillScope, "skillScope");
 
 // src/discovery/skill-discovery.service.ts
-function _ts_decorate22(decorators, target, key, desc) {
+function _ts_decorate24(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);
@@ -3816,26 +4779,26 @@ function _ts_decorate22(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate22, "_ts_decorate");
-function _ts_metadata21(metadataKey, metadataValue) {
+__name(_ts_decorate24, "_ts_decorate");
+function _ts_metadata23(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata21, "_ts_metadata");
-function _ts_param20(paramIndex, decorator) {
+__name(_ts_metadata23, "_ts_metadata");
+function _ts_param22(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param20, "_ts_param");
+__name(_ts_param22, "_ts_param");
 var SkillDiscoveryService = class _SkillDiscoveryService {
   static {
     __name(this, "SkillDiscoveryService");
   }
   discovery;
   declared;
-  logger = new Logger4(_SkillDiscoveryService.name);
+  logger = new Logger5(_SkillDiscoveryService.name);
   constructor(discovery, declared) {
     this.discovery = discovery;
     this.declared = declared;
@@ -3872,11 +4835,11 @@ var SkillDiscoveryService = class _SkillDiscoveryService {
     return flat === void 0 ? void 0 : () => flat;
   }
 };
-SkillDiscoveryService = _ts_decorate22([
-  Injectable9(),
-  _ts_param20(1, Inject20(AGENT_SKILL_SOURCES)),
-  _ts_metadata21("design:type", Function),
-  _ts_metadata21("design:paramtypes", [
+SkillDiscoveryService = _ts_decorate24([
+  Injectable10(),
+  _ts_param22(1, Inject22(AGENT_SKILL_SOURCES)),
+  _ts_metadata23("design:type", Function),
+  _ts_metadata23("design:paramtypes", [
     typeof DiscoveryService3 === "undefined" ? Object : DiscoveryService3,
     Array
   ])
@@ -3945,9 +4908,9 @@ var LedgerQuotaProvider = class {
 };
 
 // src/runner/inline-agent-runner.ts
-import { AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY6, AGENT_STORE as AGENT_STORE5, RunCancelledError as RunCancelledError2, agentFailureCode as agentFailureCode2, encodeStreamEvent as encodeStreamEvent3, publishAgentRunFailed as publishAgentRunFailed2, runAgentLoop as runAgentLoop2, settleAll as settleAll2, settleUnsettledDelegation as settleUnsettledDelegation2 } from "@dudousxd/nestjs-agent-core";
-import { Inject as Inject21, Injectable as Injectable10, Logger as Logger5 } from "@nestjs/common";
-function _ts_decorate23(decorators, target, key, desc) {
+import { AGENT_DEPS_FACTORY as AGENT_DEPS_FACTORY6, AGENT_STORE as AGENT_STORE6, RunCancelledError as RunCancelledError2, agentFailureCode as agentFailureCode2, encodeStreamEvent as encodeStreamEvent5, publishAgentRunFailed as publishAgentRunFailed2, releaseThreadRun as releaseThreadRun3, runAgentLoop as runAgentLoop2, settleAll as settleAll2, settleUnsettledDelegation as settleUnsettledDelegation2 } from "@dudousxd/nestjs-agent-core";
+import { Inject as Inject23, Injectable as Injectable11, Logger as Logger6, Optional as Optional10 } from "@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") {
     r = Reflect.decorate(decorators, target, key, desc);
@@ -3960,26 +4923,27 @@ function _ts_decorate23(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate23, "_ts_decorate");
-function _ts_metadata22(metadataKey, metadataValue) {
+__name(_ts_decorate25, "_ts_decorate");
+function _ts_metadata24(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata22, "_ts_metadata");
-function _ts_param21(paramIndex, decorator) {
+__name(_ts_metadata24, "_ts_metadata");
+function _ts_param23(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param21, "_ts_param");
+__name(_ts_param23, "_ts_param");
 var InlineAgentRunner = class _InlineAgentRunner {
   static {
     __name(this, "InlineAgentRunner");
   }
   factory;
   store;
-  logger = new Logger5(_InlineAgentRunner.name);
+  queue;
+  logger = new Logger6(_InlineAgentRunner.name);
   pending = /* @__PURE__ */ new Map();
   /**
   * Runs someone has asked to stop. In-process, like `pending`, and for the same reason: this runner
@@ -3987,14 +4951,25 @@ var InlineAgentRunner = class _InlineAgentRunner {
   * running it. A cancelled id is dropped once the run settles, so the set tracks live runs only.
   */
   cancelled = /* @__PURE__ */ new Set();
-  constructor(factory, store) {
+  /** Top-level runs this process is running now — what {@link isRunActive} answers from. */
+  live = /* @__PURE__ */ new Set();
+  constructor(factory, store, queue) {
     this.factory = factory;
     this.store = store;
+    this.queue = queue;
   }
-  async start(input) {
-    const runId = crypto.randomUUID();
+  /**
+  * In-process, so exact: a run this process is not running is not running anywhere — the process
+  * 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);
+  }
+  async start(input, options = {}) {
+    const runId = options.runId ?? crypto.randomUUID();
     const day = input.day ?? utcDay();
     const deps = this.factory.forAgent(input.agentName);
+    this.live.add(runId);
     const hooks = this.topLevelHooks({
       runId,
       deps,
@@ -4006,14 +4981,15 @@ var InlineAgentRunner = class _InlineAgentRunner {
         ...input.agentName !== void 0 ? [
           input.agentName
         ] : []
-      ]
+      ],
+      input
     });
     void runAgentLoop2({
       ...deps,
       day
-    }, input, hooks).then(() => this.store.setActiveStream(input.threadId, null)).catch(async (error) => {
+    }, input, hooks).then(() => releaseThreadRun3(this.store, input.threadId, runId)).catch(async (error) => {
       if (error instanceof RunCancelledError2) {
-        await this.settleCancelled(runId, input.threadId, deps);
+        await this.settleCancelled(runId, input, deps);
         return;
       }
       const message = error instanceof Error ? error.message : String(error);
@@ -4030,13 +5006,17 @@ var InlineAgentRunner = class _InlineAgentRunner {
         errorCode: code,
         errorMessage: message
       });
-      await this.store.setActiveStream(input.threadId, null);
       const writer = await deps.sink.open(runId);
+      await this.settleQueue(writer, input, runId, "failed", message);
+      await releaseThreadRun3(this.store, input.threadId, runId);
       await writer.fail({
         code,
         message
       });
-    }).finally(() => this.cancelled.delete(runId));
+    }).finally(() => {
+      this.cancelled.delete(runId);
+      this.live.delete(runId);
+    });
     return {
       runId
     };
@@ -4079,11 +5059,12 @@ var InlineAgentRunner = class _InlineAgentRunner {
   * the stream ENDED after a `cancelled` frame rather than failed, so a client that retries failed
   * streams does not retry this one.
   */
-  async settleCancelled(runId, threadId, deps) {
+  async settleCancelled(runId, input, deps) {
     this.logger.log(`agent run ${runId} cancelled`);
-    await this.store.setActiveStream(threadId, null);
     const writer = await deps.sink.open(runId);
-    await writer.write(encodeStreamEvent3({
+    await this.settleQueue(writer, input, runId, "cancelled");
+    await releaseThreadRun3(this.store, input.threadId, runId);
+    await writer.write(encodeStreamEvent5({
       kind: "cancelled"
     }));
     await writer.end();
@@ -4093,6 +5074,38 @@ var InlineAgentRunner = class _InlineAgentRunner {
     });
   }
   /**
+  * Move the thread past a settling TOP-LEVEL run — to the next queued message, which starts here,
+  * or to a paused/empty queue — and write the resulting `queue` frame into this run's stream. A
+  * no-op without a queue-capable store, and for a run that is not a thread's own turn.
+  *
+  * Never throws: the run is settling either way, and a queue that could not be advanced is picked
+  * up by the next send or resume on the thread.
+  */
+  async settleQueue(writer, input, runId, outcome, error) {
+    const queue = this.queue;
+    if (queue === void 0 || !queue.supported || !isThreadTurn2(input)) {
+      return;
+    }
+    const settled = outcome === "completed" && this.cancelled.has(runId) ? "cancelled" : outcome;
+    try {
+      const frame = await queue.handoff({
+        threadId: input.threadId,
+        runId,
+        outcome: settled,
+        ...error !== void 0 ? {
+          error
+        } : {}
+      }, (next, nextRunId) => this.start(next, {
+        runId: nextRunId
+      }));
+      if (frame !== void 0) {
+        await writer.write(encodeStreamEvent5(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)}`);
+    }
+  }
+  /**
   * Park a run on a human, keyed by run + tool call. One map for approvals and for question-set
   * answers alike: both wait on the same key, and `signal` cannot tell (or need to tell) which
   * shape it is delivering — the loop asked for one and only ever gets what the caller sent. A
@@ -4137,10 +5150,23 @@ var InlineAgentRunner = class _InlineAgentRunner {
     });
   }
   topLevelHooks(args) {
-    const { runId, deps, actor, day, threadId, chainBelow } = args;
+    const { runId, deps, actor, day, threadId, chainBelow, input } = args;
     return {
       runId,
-      openSink: /* @__PURE__ */ __name(() => deps.sink.open(runId), "openSink"),
+      // The loop ends the stream when the turn completes. Just before, the thread passes to the next
+      // queued message (or is released), and the reader is told which — so by the time a client
+      // sees the run end, the thread is already free or already running what it queued.
+      openSink: /* @__PURE__ */ __name(async () => {
+        const writer = await deps.sink.open(runId);
+        return this.queue === void 0 ? writer : {
+          write: /* @__PURE__ */ __name((chunk) => writer.write(chunk), "write"),
+          fail: /* @__PURE__ */ __name((error) => writer.fail(error), "fail"),
+          end: /* @__PURE__ */ __name(async () => {
+            await this.settleQueue(writer, input, runId, "completed");
+            await writer.end();
+          }, "end")
+        };
+      }, "openSink"),
       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"),
@@ -4353,16 +5379,22 @@ var InlineAgentRunner = class _InlineAgentRunner {
     }
   }
 };
-InlineAgentRunner = _ts_decorate23([
-  Injectable10(),
-  _ts_param21(0, Inject21(AGENT_DEPS_FACTORY6)),
-  _ts_param21(1, Inject21(AGENT_STORE5)),
-  _ts_metadata22("design:type", Function),
-  _ts_metadata22("design:paramtypes", [
+InlineAgentRunner = _ts_decorate25([
+  Injectable11(),
+  _ts_param23(0, Inject23(AGENT_DEPS_FACTORY6)),
+  _ts_param23(1, Inject23(AGENT_STORE6)),
+  _ts_param23(2, Optional10()),
+  _ts_metadata24("design:type", Function),
+  _ts_metadata24("design:paramtypes", [
     typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
-    typeof AgentStore === "undefined" ? Object : AgentStore
+    typeof AgentStore === "undefined" ? Object : AgentStore,
+    typeof ChatQueueService === "undefined" ? Object : ChatQueueService
   ])
 ], InlineAgentRunner);
+function isThreadTurn2(input) {
+  return input.sinkRunId === void 0 && input.deliverTo === void 0;
+}
+__name(isThreadTurn2, "isThreadTurn");
 
 // src/skills-config.ts
 import { compositeSkillProvider } from "@dudousxd/nestjs-agent-core";
@@ -4403,7 +5435,7 @@ function resolveSkillsConfig(options, declared) {
 __name(resolveSkillsConfig, "resolveSkillsConfig");
 
 // src/agent.module.ts
-function _ts_decorate24(decorators, target, key, desc) {
+function _ts_decorate26(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);
@@ -4416,13 +5448,13 @@ function _ts_decorate24(decorators, target, key, desc) {
   }
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate24, "_ts_decorate");
+__name(_ts_decorate26, "_ts_decorate");
 var DEFAULT_PATH = "agent";
-var logger = new Logger6("AgentModule");
+var logger = new Logger7("AgentModule");
 function externalStoreWrapper(modules) {
   for (const module of modules.values()) {
     if (module.metatype === AgentModule) continue;
-    const wrapper = module.providers.get(AGENT_STORE6);
+    const wrapper = module.providers.get(AGENT_STORE7);
     if (wrapper !== void 0) return wrapper;
   }
   return void 0;
@@ -4495,7 +5527,7 @@ function sharedProviders(durable) {
       provide: AGENT_SKILLS3,
       useFactory: /* @__PURE__ */ __name((options, declared) => resolveSkillsConfig(options.skills, declared), "useFactory"),
       inject: [
-        AGENT_OPTIONS6,
+        AGENT_OPTIONS7,
         AGENT_SKILL_SOURCES2
       ]
     },
@@ -4505,58 +5537,58 @@ function sharedProviders(durable) {
       provide: AGENT_MEMORY3,
       useFactory: /* @__PURE__ */ __name((options) => options.memory, "useFactory"),
       inject: [
-        AGENT_OPTIONS6
+        AGENT_OPTIONS7
       ]
     },
     {
-      provide: AGENT_SINK3,
+      provide: AGENT_SINK4,
       useFactory: /* @__PURE__ */ __name((options) => options.sink ?? new InProcessTokenStreamSink(), "useFactory"),
       inject: [
-        AGENT_OPTIONS6
+        AGENT_OPTIONS7
       ]
     },
     {
       provide: AGENT_ROLES_POLICY2,
       useFactory: /* @__PURE__ */ __name((options) => options.rolesPolicy ?? new DefaultRolesPolicy(options.defaultRoles), "useFactory"),
       inject: [
-        AGENT_OPTIONS6
+        AGENT_OPTIONS7
       ]
     },
     {
-      provide: AGENT_ACTOR_RESOLVER12,
+      provide: AGENT_ACTOR_RESOLVER13,
       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: [
-        AGENT_OPTIONS6
+        AGENT_OPTIONS7
       ]
     },
     {
       provide: AGENT_MODEL2,
       useFactory: /* @__PURE__ */ __name((o) => o.model, "useFactory"),
       inject: [
-        AGENT_OPTIONS6
+        AGENT_OPTIONS7
       ]
     },
     {
       // `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: AGENT_QUOTA_PROVIDER2,
+      provide: AGENT_QUOTA_PROVIDER3,
       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: [
-        AGENT_OPTIONS6,
-        AGENT_STORE6
+        AGENT_OPTIONS7,
+        AGENT_STORE7
       ]
     },
     {
       provide: AGENT_MODEL_CATALOG3,
       useFactory: /* @__PURE__ */ __name((o) => resolveCatalog(o), "useFactory"),
       inject: [
-        AGENT_OPTIONS6
+        AGENT_OPTIONS7
       ]
     },
     AgentDepsFactory2,
@@ -4569,6 +5601,9 @@ function sharedProviders(durable) {
     AgentDiscoveryService,
     AiToolDiscoveryService,
     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,
     InlineAgentRunner,
     AgentService,
     // Bound ALWAYS (durable or inline) — the console's cross-thread approvals inbox routes decisions
@@ -4580,10 +5615,10 @@ function sharedProviders(durable) {
     }
   ];
   providers.push({
-    provide: AGENT_STORE6,
+    provide: AGENT_STORE7,
     useFactory: /* @__PURE__ */ __name((o, modules) => resolveStore(o, modules), "useFactory"),
     inject: [
-      AGENT_OPTIONS6,
+      AGENT_OPTIONS7,
       ModulesContainer
     ]
   });
@@ -4614,22 +5649,23 @@ function sharedProviders(durable) {
 __name(sharedProviders, "sharedProviders");
 function exportsFor() {
   return [
-    AGENT_OPTIONS6,
+    AGENT_OPTIONS7,
     AGENT_TOOL_REGISTRY3,
     AGENT_REGISTRY6,
-    AGENT_SINK3,
+    AGENT_SINK4,
     AGENT_ROLES_POLICY2,
-    AGENT_ACTOR_RESOLVER12,
+    AGENT_ACTOR_RESOLVER13,
     AGENT_MODEL2,
-    AGENT_STORE6,
+    AGENT_STORE7,
     AGENT_MODEL_CATALOG3,
-    AGENT_QUOTA_PROVIDER2,
+    AGENT_QUOTA_PROVIDER3,
     AGENT_PROMPT_CONTRIBUTORS3,
     AGENT_SKILLS3,
     AGENT_MEMORY3,
     AGENT_DEPS_FACTORY7,
     AgentDepsFactory2,
     AgentService,
+    ChatQueueService,
     InlineAgentRunner,
     AGENT_APPROVAL_PORT
   ];
@@ -4637,6 +5673,7 @@ function exportsFor() {
 __name(exportsFor, "exportsFor");
 var BASE_CONTROLLERS = [
   ChatController,
+  QueueController,
   ThreadsController,
   ToolCallController,
   QuotaController,
@@ -4694,7 +5731,7 @@ var AgentModule = class _AgentModule {
       controllers: controllersForSurface(options.surface),
       providers: [
         {
-          provide: AGENT_OPTIONS6,
+          provide: AGENT_OPTIONS7,
           useValue: options
         },
         ...sharedProviders(options.durable ?? false),
@@ -4717,7 +5754,7 @@ var AgentModule = class _AgentModule {
       controllers: controllersForSurface(options.surface),
       providers: [
         {
-          provide: AGENT_OPTIONS6,
+          provide: AGENT_OPTIONS7,
           // 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
@@ -4738,7 +5775,7 @@ var AgentModule = class _AgentModule {
     };
   }
 };
-AgentModule = _ts_decorate24([
+AgentModule = _ts_decorate26([
   Global2(),
   Module2({})
 ], AgentModule);