@dudousxd/nestjs-agent 1.15.0 → 1.16.1

package/dist/index.d.cts

@@ -158,6 +158,21 @@ declare class AgentService {
     }): Promise<ChatQueueState>;
     /** `DELETE <base>/queue/:messageId` — drop a waiting message. Answers the thread's queue. */
     removeQueuedMessage(actor: Actor, messageId: string): Promise<ChatQueueState>;
+    /**
+     * `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).
+     */
+    interruptQueuedMessage(actor: Actor, messageId: string): Promise<ChatQueueState & {
+        runId?: string;
+        interrupting?: string;
+    }>;
     /** `DELETE <base>/threads/:id/queue` — drop every waiting message (and any pause). */
     clearQueue(actor: Actor, threadId: string): Promise<ChatQueueState>;
     /**
@@ -1051,6 +1066,15 @@ declare class QueueController {
         runId?: string;
     }>;
     update(req: Request, messageId: string, body: UpdateQueuedMessageBody): Promise<ChatQueueState>;
+    /**
+     * 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.
+     */
+    interrupt(req: Request, messageId: string): Promise<ChatQueueState & {
+        runId?: string;
+        interrupting?: string;
+    }>;
     remove(req: Request, messageId: string): Promise<ChatQueueState>;
 }
 

package/dist/index.d.ts

@@ -158,6 +158,21 @@ declare class AgentService {
     }): Promise<ChatQueueState>;
     /** `DELETE <base>/queue/:messageId` — drop a waiting message. Answers the thread's queue. */
     removeQueuedMessage(actor: Actor, messageId: string): Promise<ChatQueueState>;
+    /**
+     * `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).
+     */
+    interruptQueuedMessage(actor: Actor, messageId: string): Promise<ChatQueueState & {
+        runId?: string;
+        interrupting?: string;
+    }>;
     /** `DELETE <base>/threads/:id/queue` — drop every waiting message (and any pause). */
     clearQueue(actor: Actor, threadId: string): Promise<ChatQueueState>;
     /**
@@ -1051,6 +1066,15 @@ declare class QueueController {
         runId?: string;
     }>;
     update(req: Request, messageId: string, body: UpdateQueuedMessageBody): Promise<ChatQueueState>;
+    /**
+     * 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.
+     */
+    interrupt(req: Request, messageId: string): Promise<ChatQueueState & {
+        runId?: string;
+        interrupting?: string;
+    }>;
     remove(req: Request, messageId: string): Promise<ChatQueueState>;
 }
 

package/dist/index.js

@@ -1112,6 +1112,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 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 NotImplementedException2("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);
@@ -2754,6 +2807,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);
   }
@@ -2804,6 +2865,17 @@ _ts_decorate12([
   ]),
   _ts_metadata12("design:returntype", Promise)
 ], QueueController.prototype, "update", null);
+_ts_decorate12([
+  Post4("queue/:messageId/interrupt"),
+  _ts_param11(0, Req7()),
+  _ts_param11(1, Param4("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([
   Delete2("queue/:messageId"),
   _ts_param11(0, Req7()),