@borgee/agents-host 0.2.73 → 0.2.84

package/dist/plugin-sdk.js

@@ -3757,6 +3757,8 @@ var WS_CLOSE_AUTH_FAILED = 4004;
 var RESULT_STATUS_OK = "ok";
 var STOP_TURN_ACTION = "stop_turn";
 var STOP_TURN_CHANNEL_ID_INVALID = "stop_turn_channel_id_invalid";
+var STOP_BACKGROUND_RUN_ACTION = "stop_background_run";
+var STOP_BACKGROUND_RUN_TARGET_INVALID = "stop_background_run_target_invalid";
 var SERVER_REQUEST_FAILED = "server_request_failed";
 var BppTransport = class {
   performTimeoutMs;
@@ -3777,6 +3779,7 @@ var BppTransport = class {
   // send issued during a reconnect never races ahead of the handshake.
   online = false;
   terminal = false;
+  stopBackgroundRunHandler;
   inboundChain = Promise.resolve();
   configChain = Promise.resolve();
   configAcks = /* @__PURE__ */ new Map();
@@ -3811,6 +3814,9 @@ var BppTransport = class {
   setStopTurnHandler(handler) {
     this.stopTurnHandler = handler;
   }
+  setStopBackgroundRunHandler(handler) {
+    this.stopBackgroundRunHandler = handler;
+  }
   getResolvedAgentId() {
     return this.currentAgentId();
   }
@@ -3881,7 +3887,7 @@ var BppTransport = class {
       }
     }
   }
-  // ---- perform (上行) ----
+  // ---- Outbound operations ----
   async perform(action, opts) {
     if (action.op === "report_task_started") {
       this.sendTaskStarted(action);
@@ -3927,7 +3933,7 @@ var BppTransport = class {
       this.send(frame);
     });
   }
-  // ---- socket 生命周期 ----
+  // ---- Socket lifecycle ----
   // Transition the given socket to ONLINE. Bails if the socket is stale (a reconnect replaced it),
   // so a handshake completing on a prior socket cannot flip online across a reconnect.
   goOnline(source) {
@@ -4097,7 +4103,7 @@ var BppTransport = class {
       this.heartbeatTimer = void 0;
     }
   }
-  // ---- 下行分发 ----
+  // ---- Inbound dispatch ----
   onMessage(raw, source) {
     if (source !== this.ws)
       return;
@@ -4286,6 +4292,10 @@ var BppTransport = class {
       await this.answerStopTurn(id, data);
       return;
     }
+    if (action === STOP_BACKGROUND_RUN_ACTION) {
+      await this.answerStopBackgroundRun(id, data);
+      return;
+    }
     if (!this.serverRequestHandler) {
       this.send({ type: "response", id, error: "no_server_request_handler" });
       return;
@@ -4336,7 +4346,38 @@ var BppTransport = class {
     }
     return { aborted };
   }
-  // ---- task 生命周期上行 ----
+  async answerStopBackgroundRun(id, data) {
+    const channelId = data.channel_id;
+    const runId = data.run_id;
+    if (typeof channelId !== "string" || channelId === "" || typeof runId !== "string" || runId === "") {
+      this.send({ type: "response", id, error: STOP_BACKGROUND_RUN_TARGET_INVALID });
+      return;
+    }
+    try {
+      const answer = this.stopBackgroundRunHandler ? await this.stopBackgroundRunHandler(channelId, runId) : {
+        outcome: "unsupported",
+        reason: "Targeted background-run cancellation is not registered"
+      };
+      this.send({ type: "response", id, data: this.asStopBackgroundRunResult(answer) });
+    } catch (err) {
+      this.logger?.warn("bpp.stop_background_run_handler_failed", err);
+      this.send({ type: "response", id, error: SERVER_REQUEST_FAILED });
+    }
+  }
+  asStopBackgroundRunResult(answer) {
+    const candidate = answer;
+    if (!candidate || !["stopped", "not_found", "unsupported"].includes(candidate.outcome)) {
+      return {
+        outcome: "unsupported",
+        reason: "Targeted background-run cancellation returned an unusable answer"
+      };
+    }
+    return {
+      outcome: candidate.outcome,
+      ...typeof candidate.reason === "string" && candidate.reason !== "" ? { reason: candidate.reason } : {}
+    };
+  }
+  // ---- Task lifecycle output ----
   sendTaskStarted(action) {
     const frame = {
       type: "task_started",
@@ -4384,7 +4425,13 @@ var BppTransport = class {
       reason: "",
       stream: "",
       text: "",
-      turn_state: ""
+      turn_state: "",
+      run_id: "",
+      run_state: "",
+      started_at: 0,
+      finished_at: 0,
+      stop_supported: false,
+      stop_unsupported_reason: ""
     };
     switch (action.activity.shape) {
       case "activity":
@@ -4413,13 +4460,23 @@ var BppTransport = class {
       case "turn":
         frame.turn_state = action.activity.state;
         break;
+      case "background_run":
+        frame.run_id = action.activity.runId;
+        frame.label = action.activity.label;
+        frame.run_state = action.activity.state;
+        frame.started_at = action.activity.startedAt;
+        frame.finished_at = action.activity.finishedAt ?? 0;
+        frame.reason = action.activity.reason ?? "";
+        frame.stop_supported = action.activity.stopSupported;
+        frame.stop_unsupported_reason = action.activity.stopUnsupportedReason ?? "";
+        break;
     }
     this.send(frame);
   }
   sendTyping(action) {
     this.send({ type: "typing", channel_id: action.channelId });
   }
-  // ---- 低层发送 ----
+  // ---- Low-level output ----
   send(frame) {
     if (!this.isOpen())
       return;
@@ -4519,7 +4576,8 @@ function encodeActionPayload(action) {
       return {
         channel_id: action.channelId,
         content: action.body,
-        reply_to_id: action.replyToId
+        reply_to_id: action.replyToId,
+        content_type: action.contentType
       };
     case "edit_message":
       return { message_id: action.messageId, content: action.body };
@@ -4614,7 +4672,7 @@ function decodeActionResult(op, payloadJSON) {
     case "delete_message":
     case "react":
       return void 0;
-    // 客户端方法返回 void
+    // These client methods return void.
     case "read_channel_history": {
       const arr = Array.isArray(p) ? p : [];
       return arr.map((m) => ({
@@ -4954,7 +5012,8 @@ var Client = class {
       op: "send_message",
       channelId: input.channelId,
       body: input.body,
-      replyToId: input.replyToId
+      replyToId: input.replyToId,
+      contentType: input.contentType
     });
   }
   async editMessage(input) {
@@ -5141,6 +5200,9 @@ var Client = class {
   onStopTurn(handler) {
     this.t.setStopTurnHandler?.(handler);
   }
+  onStopBackgroundRun(handler) {
+    this.t.setStopBackgroundRunHandler?.(handler);
+  }
   emit(event, payload) {
     for (const h of this.listeners[event]) {
       try {
@@ -5177,8 +5239,116 @@ var Client = class {
 function createBorgeePlugin(opts) {
   return new Client(opts, new BppTransport());
 }
+
+// ../sdk/plugin-ts/dist/draft-message.js
+var THROTTLE_MS = 250;
+var DraftMessageController = class {
+  client;
+  channelId;
+  replyToId;
+  messageId = null;
+  currentBody = "";
+  pendingBody = null;
+  timer = null;
+  sealed = false;
+  writeChain = Promise.resolve();
+  constructor(client, channelId, replyToId) {
+    this.client = client;
+    this.channelId = channelId;
+    this.replyToId = replyToId;
+  }
+  /**
+   * Offer the whole body as it currently reads — not a delta. Nothing is written
+   * for up to {@link THROTTLE_MS}, and only the last body offered in that window
+   * is; blank text is ignored, which is why a producer that has not yet emitted
+   * anything visible never creates an empty message.
+   */
+  update(text) {
+    if (this.sealed || !text.trim())
+      return;
+    this.pendingBody = text;
+    if (this.timer)
+      return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.flushPending().catch(() => {
+      });
+    }, THROTTLE_MS);
+  }
+  /**
+   * Seal the draft at `finalText` and resolve once that text is on the wire.
+   * Empty final text means the draft said nothing worth keeping, so the message
+   * is deleted rather than left showing a body the producer has disowned.
+   */
+  async finalize(finalText) {
+    this.sealed = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (finalText.trim()) {
+      this.pendingBody = finalText;
+      await this.flushPending();
+      this.messageId = null;
+      return;
+    }
+    await this.enqueue(async () => {
+      if (!this.messageId)
+        return;
+      await this.client.deleteMessage({ messageId: this.messageId });
+      this.messageId = null;
+    });
+  }
+  /** Seal the draft and remove whatever it published. */
+  async discard() {
+    this.sealed = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.pendingBody = null;
+    await this.enqueue(async () => {
+      if (!this.messageId)
+        return;
+      await this.client.deleteMessage({ messageId: this.messageId });
+      this.messageId = null;
+    });
+  }
+  /** Whether a message has actually been published yet. */
+  get hasMessage() {
+    return this.messageId !== null;
+  }
+  async flushPending() {
+    await this.enqueue(async () => {
+      const body = this.pendingBody;
+      if (!body || body === this.currentBody)
+        return;
+      if (this.messageId) {
+        await this.client.editMessage({ messageId: this.messageId, body });
+      } else {
+        const posted = await this.client.sendMessage({
+          channelId: this.channelId,
+          body,
+          replyToId: this.replyToId
+        });
+        this.messageId = posted.messageId;
+      }
+      this.currentBody = body;
+    });
+  }
+  /**
+   * Run `op` after every write queued before it. The same callback handles both
+   * settlements deliberately: a rejected write must not wedge the chain, and a
+   * producer that keeps typing after one failed edit still gets its next one.
+   */
+  enqueue(op) {
+    this.writeChain = this.writeChain.then(op, op);
+    return this.writeChain;
+  }
+};
 export {
   BorgeeError,
+  DraftMessageController,
   PermissionDeniedError,
   createBorgeePlugin
 };