@dudousxd/nestjs-agent 1.15.0 → 1.16.1

package/dist/index.cjs

@@ -1186,6 +1186,59 @@ var AgentService = class {
     }
     return queue.publish(threadId);
   }
+  /**
+  * `POST <base>/queue/:messageId/interrupt` — run a message that is already waiting NOW: it moves
+  * to the head of its queue marked as an interrupt, any pause is lifted, and the running turn is
+  * cancelled (its settle starts this message — the same path a `mode: 'interrupt'` send takes).
+  * With nothing running, the message starts at once.
+  *
+  * One request, and the message never leaves the queue: a client that removed it and sent it again
+  * would lose it if the second call failed, and would run it twice if another tab's drain started
+  * it in between. Answers the queue, plus `interrupting` (the run that was cancelled) or `runId`
+  * (the run this message started).
+  */
+  async interruptQueuedMessage(actor, messageId) {
+    const queue = this.requireQueue();
+    const store = queue.queueStore();
+    const threadId = await this.assertOwnsQueuedMessage(actor, messageId);
+    const gone = /* @__PURE__ */ __name(() => new import_common3.GoneException(`queued message ${messageId} already started or was removed`), "gone");
+    const marked = await store.updateQueuedMessage(messageId, {
+      interrupt: true
+    });
+    if (marked === null) {
+      throw gone();
+    }
+    if (marked.interrupt !== true) {
+      throw new import_common3.NotImplementedException("Interrupting a queued message requires a ChatQueueStore whose updateQueuedMessage stores `interrupt`; the bound store ignored it.");
+    }
+    if (!await store.moveQueuedMessage(messageId, 0)) {
+      throw gone();
+    }
+    await store.setQueuePause(threadId, null);
+    const { live } = await queue.holder(threadId, this.runner);
+    if (live !== null && live !== messageId && await store.getQueuedMessage(messageId) !== null) {
+      const state2 = await queue.publish(threadId);
+      await this.runner.cancel(live);
+      return {
+        ...state2,
+        interrupting: live
+      };
+    }
+    if (live !== null) {
+      return {
+        ...await queue.state(threadId),
+        runId: messageId
+      };
+    }
+    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
+      } : {}
+    };
+  }
   /** `DELETE <base>/threads/:id/queue` — drop every waiting message (and any pause). */
   async clearQueue(actor, threadId) {
     await this.assertOwnsThread(actor, threadId);
@@ -2828,6 +2881,14 @@ var QueueController = class {
       } : {}
     });
   }
+  /**
+  * Run a waiting message now: it moves to the head as an interrupt and the running turn is
+  * cancelled for it. Carries `interrupting` (the cancelled run), or `runId` when nothing was
+  * running and it started at once.
+  */
+  async interrupt(req, messageId) {
+    return this.agent.interruptQueuedMessage(await this.actorResolver.resolve(req), messageId);
+  }
   async remove(req, messageId) {
     return this.agent.removeQueuedMessage(await this.actorResolver.resolve(req), messageId);
   }
@@ -2878,6 +2939,17 @@ _ts_decorate12([
   ]),
   _ts_metadata12("design:returntype", Promise)
 ], QueueController.prototype, "update", null);
+_ts_decorate12([
+  (0, import_common12.Post)("queue/:messageId/interrupt"),
+  _ts_param11(0, (0, import_common12.Req)()),
+  _ts_param11(1, (0, import_common12.Param)("messageId")),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
+    typeof Request === "undefined" ? Object : Request,
+    String
+  ]),
+  _ts_metadata12("design:returntype", Promise)
+], QueueController.prototype, "interrupt", null);
 _ts_decorate12([
   (0, import_common12.Delete)("queue/:messageId"),
   _ts_param11(0, (0, import_common12.Req)()),