@borgee/agents-host 0.2.74 → 0.2.94

package/dist/plugin-sdk.js

@@ -3722,8 +3722,8 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 // ../sdk/plugin-ts/dist/errors.js
 var BorgeeError = class extends Error {
   code;
-  constructor(message, code) {
-    super(message);
+  constructor(message, code, options) {
+    super(message, options);
     this.name = "BorgeeError";
     this.code = code;
   }
@@ -3743,6 +3743,95 @@ var PermissionDeniedError = class extends BorgeeError {
   }
 };
 
+// ../sdk/plugin-ts/dist/channel-contracts.js
+var isZoneId = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{1,128}$/.test(value);
+var validateChannelPlacement = (parentId) => {
+  if (parentId !== null && (!isZoneId(parentId) || parentId === "null")) {
+    throw new BorgeeError("parentId is required: pass null for Default or a Zone ID", "channel.placement_invalid");
+  }
+};
+var rejectChannelPlacementUpdate = (input) => {
+  for (const field of ["parentId", "parent_id", "channelType", "channel_type", "kind"]) {
+    if (Object.hasOwn(input, field)) {
+      throw new BorgeeError(`${field} cannot be changed after channel creation`, "channel.field_immutable");
+    }
+  }
+};
+var validateListZonesInput = (input) => {
+  if (!isZoneId(input.guildId)) {
+    throw new BorgeeError("guildId must be a nonempty opaque ID", "zone.input_invalid");
+  }
+  if (input.limit !== void 0 && (!Number.isInteger(input.limit) || input.limit < 1 || input.limit > 50)) {
+    throw new BorgeeError("limit must be an integer between 1 and 50", "zone.input_invalid");
+  }
+  if (input.after !== void 0 && !isZoneId(input.after)) {
+    throw new BorgeeError("after must be a nonempty opaque Zone ID", "zone.input_invalid");
+  }
+};
+
+// ../sdk/plugin-ts/dist/bpp/channel-results.js
+var invalidResult = (field) => new BorgeeError(`Invalid channel result: ${field}`, "bpp.invalid_result");
+var record = (value, field) => {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw invalidResult(field);
+  return value;
+};
+var requiredString = (value, field) => {
+  if (typeof value !== "string")
+    throw invalidResult(field);
+  return value;
+};
+var decodeChannel = (value) => {
+  const channel = record(value, "channel");
+  if (!isZoneId(channel.id))
+    throw invalidResult("id");
+  if (channel.parent_id !== null && !isZoneId(channel.parent_id))
+    throw invalidResult("parent_id");
+  return {
+    id: channel.id,
+    name: requiredString(channel.name, "name"),
+    kind: requiredString(channel.kind, "kind"),
+    parentId: channel.parent_id
+  };
+};
+var decodeChannels = (value) => {
+  if (!Array.isArray(value))
+    throw invalidResult("channels");
+  return value.map(decodeChannel);
+};
+var decodeZone = (value) => {
+  const zone = record(value, "zone");
+  if (!isZoneId(zone.id))
+    throw invalidResult("zone.id");
+  const name = requiredString(zone.name, "zone.name");
+  if (new RegExp("^\\p{White_Space}|\\p{White_Space}$", "u").test(name) || [...name].length < 1 || [...name].length > 100 || /[\p{Cc}\p{Cs}]/u.test(name)) {
+    throw invalidResult("zone.name");
+  }
+  return { id: zone.id, name };
+};
+var decodeZonePage = (value, input) => {
+  const page = record(value, "Zone page");
+  if (!Array.isArray(page.zones))
+    throw invalidResult("zones");
+  const limit = input?.limit ?? 20;
+  if (page.zones.length > limit)
+    throw invalidResult("zones exceed the requested limit");
+  const zones = page.zones.map(decodeZone);
+  let previous = input?.after;
+  for (const zone of zones) {
+    if (previous !== void 0 && zone.id <= previous)
+      throw invalidResult("Zone IDs must follow the cursor in ascending order");
+    previous = zone.id;
+  }
+  const nextAfter = page.next_after;
+  if (nextAfter !== null) {
+    if (!isZoneId(nextAfter) || zones.length !== limit || nextAfter !== zones.at(-1)?.id) {
+      throw invalidResult("next_after must be null or the final ID of a full page");
+    }
+  }
+  return { zones, nextAfter };
+};
+
 // ../sdk/plugin-ts/dist/bpp/bpp-transport.js
 var PROTOCOL_VERSION = "bpp-1";
 var CONFIG_ACK_REASONS = /* @__PURE__ */ new Set([
@@ -3757,6 +3846,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 +3868,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 +3903,9 @@ var BppTransport = class {
   setStopTurnHandler(handler) {
     this.stopTurnHandler = handler;
   }
+  setStopBackgroundRunHandler(handler) {
+    this.stopBackgroundRunHandler = handler;
+  }
   getResolvedAgentId() {
     return this.currentAgentId();
   }
@@ -3881,7 +3976,7 @@ var BppTransport = class {
       }
     }
   }
-  // ---- perform (上行) ----
+  // ---- Outbound operations ----
   async perform(action, opts) {
     if (action.op === "report_task_started") {
       this.sendTaskStarted(action);
@@ -3923,11 +4018,17 @@ var BppTransport = class {
         this.pending.delete(nonce);
         reject(new BorgeeError(`semantic_action ${action.op} timed out`, "bpp.action_timeout"));
       }, remaining);
-      this.pending.set(nonce, { op: action.op, resolve, reject, timer });
+      this.pending.set(nonce, {
+        op: action.op,
+        ...action.op === "list_zones" ? { zoneInput: { guildId: action.guildId, limit: action.limit, after: action.after } } : {},
+        resolve,
+        reject,
+        timer
+      });
       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 +4198,7 @@ var BppTransport = class {
       this.heartbeatTimer = void 0;
     }
   }
-  // ---- 下行分发 ----
+  // ---- Inbound dispatch ----
   onMessage(raw, source) {
     if (source !== this.ws)
       return;
@@ -4153,7 +4254,13 @@ var BppTransport = class {
     this.pending.delete(frame.nonce);
     clearTimeout(p.timer);
     if (frame.status === RESULT_STATUS_OK) {
-      const result = decodeActionResult(p.op, frame.payload);
+      let result;
+      try {
+        result = decodeActionResult(p.op, frame.payload, p.zoneInput);
+      } catch (error) {
+        p.reject(error);
+        return;
+      }
       if (p.op === "get_me" && result && typeof result === "object") {
         const id = result.id;
         if (id)
@@ -4286,6 +4393,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 +4447,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 +4526,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":
@@ -4396,6 +4544,9 @@ var BppTransport = class {
         frame.detail = action.activity.detail ?? "";
         frame.parent_id = action.activity.parentId ?? "";
         frame.subagent = action.activity.subagent ?? false;
+        frame.background = action.activity.background;
+        frame.background_state = action.activity.backgroundState;
+        frame.follow_up_control = action.activity.followUpControl;
         frame.reason = action.activity.reason ?? "";
         if (action.activity.paths)
           frame.paths = action.activity.paths;
@@ -4413,13 +4564,24 @@ 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.parent_id = action.activity.parentId ?? "";
+        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 +4681,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 };
@@ -4545,15 +4708,21 @@ function encodeActionPayload(action) {
     case "list_users":
     case "list_channels":
       return {};
+    case "list_zones":
+      validateListZonesInput(action);
+      return { guild_id: action.guildId, limit: action.limit, after: action.after };
     case "create_channel":
+      validateChannelPlacement(action.parentId);
       return {
         guild_id: action.guildId,
         name: action.name,
+        parent_id: action.parentId,
         topic: action.topic,
         visibility: action.visibility,
         member_ids: action.memberIds
       };
     case "update_channel":
+      rejectChannelPlacementUpdate(action);
       return {
         channel_id: action.channelId,
         name: action.name,
@@ -4597,7 +4766,20 @@ function encodeActionPayload(action) {
       return {};
   }
 }
-function decodeActionResult(op, payloadJSON) {
+function decodeActionResult(op, payloadJSON, zoneInput) {
+  if (op === "list_zones" || op === "list_channels" || op === "create_channel" || op === "update_channel") {
+    let value;
+    try {
+      value = JSON.parse(payloadJSON);
+    } catch (cause) {
+      throw new BorgeeError("Invalid JSON in channel result", "bpp.invalid_result", { cause });
+    }
+    if (op === "list_zones")
+      return decodeZonePage(value, zoneInput);
+    if (op === "list_channels")
+      return decodeChannels(value);
+    return decodeChannel(value);
+  }
   const p = safeParseJSON(payloadJSON);
   switch (op) {
     case "send_message":
@@ -4614,7 +4796,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) => ({
@@ -4637,21 +4819,6 @@ function decodeActionResult(op, payloadJSON) {
         kind: u.kind === "agent" ? "agent" : "user"
       }));
     }
-    case "list_channels": {
-      const arr = Array.isArray(p) ? p : [];
-      return arr.map((c) => ({
-        id: String(c.id ?? ""),
-        name: String(c.name ?? ""),
-        kind: String(c.kind ?? "")
-      }));
-    }
-    case "create_channel":
-    case "update_channel":
-      return {
-        id: String(p.id ?? ""),
-        name: String(p.name ?? ""),
-        kind: String(p.kind ?? "")
-      };
     case "set_topic":
     case "delete_channel":
       return void 0;
@@ -4954,7 +5121,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) {
@@ -4991,16 +5159,19 @@ var Client = class {
     return await this.t.perform({ op: "list_channels" });
   }
   async createChannel(input) {
+    validateChannelPlacement(input.parentId);
     return await this.t.perform({
       op: "create_channel",
       guildId: input.guildId,
       name: input.name,
+      parentId: input.parentId,
       topic: input.topic,
       visibility: input.visibility,
       memberIds: input.memberIds
     });
   }
   async updateChannel(input) {
+    rejectChannelPlacementUpdate(input);
     return await this.t.perform({
       op: "update_channel",
       channelId: input.channelId,
@@ -5009,6 +5180,10 @@ var Client = class {
       archived: input.archived
     });
   }
+  async listZones(input) {
+    validateListZonesInput(input);
+    return await this.t.perform({ op: "list_zones", ...input });
+  }
   async setTopic(input) {
     await this.t.perform({ op: "set_topic", channelId: input.channelId, topic: input.topic });
   }
@@ -5141,6 +5316,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 +5355,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
 };