@borgee/agents-host 0.2.44 → 0.2.56

package/dist/plugin-sdk.js

@@ -3224,7 +3224,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open2() {
+          ws.once("open", function open() {
             duplex._final(callback);
           });
           return;
@@ -3245,7 +3245,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open2() {
+          ws.once("open", function open() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -3706,123 +3706,8 @@ var require_websocket_server = __commonJS({
   }
 });
 
-// ../sdk/plugin-ts/dist/cursor-store.js
-import { randomUUID } from "node:crypto";
-import { mkdir, open, readFile, rename, unlink } from "node:fs/promises";
-import { dirname } from "node:path";
-var MemoryCursorStore = class {
-  cursors = /* @__PURE__ */ new Map();
-  async read(agentId) {
-    return this.cursors.get(agentId) ?? -1;
-  }
-  async write(agentId, cursor) {
-    this.cursors.set(agentId, cursor);
-  }
-};
-var nodeCursorFileOps = {
-  mkdir: (path) => mkdir(path, { recursive: true }),
-  open: (path, flags, mode) => open(path, flags, mode),
-  rename,
-  unlink
-};
-var FileCursorStore = class {
-  resolvePathFn;
-  fs;
-  platform;
-  constructor(options) {
-    this.resolvePathFn = options.resolvePath;
-    this.fs = options.fs ?? nodeCursorFileOps;
-    this.platform = options.platform ?? process.platform;
-  }
-  async read(agentId) {
-    const filePath = this.resolvePathFn(agentId);
-    let raw;
-    try {
-      raw = await readFile(filePath, "utf8");
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return -1;
-      }
-      throw error;
-    }
-    const parsed = JSON.parse(raw);
-    if (!Number.isSafeInteger(parsed.cursor) || parsed.cursor < 0) {
-      throw new Error(`invalid cursor file: ${filePath}`);
-    }
-    return parsed.cursor;
-  }
-  async write(agentId, cursor) {
-    if (!Number.isSafeInteger(cursor) || cursor < 0) {
-      throw new Error(`invalid cursor: ${cursor}`);
-    }
-    const filePath = this.resolvePathFn(agentId);
-    const parentPath = dirname(filePath);
-    await this.fs.mkdir(parentPath);
-    const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
-    let temporaryHandle;
-    try {
-      temporaryHandle = await this.fs.open(temporaryPath, "wx", 384);
-      await temporaryHandle.writeFile(JSON.stringify({ cursor, updatedAt: Date.now() }), {
-        encoding: "utf8"
-      });
-      await temporaryHandle.sync();
-      await temporaryHandle.close();
-      temporaryHandle = void 0;
-      await this.fs.rename(temporaryPath, filePath);
-      await this.syncDirectory(parentPath);
-    } catch (error) {
-      if (temporaryHandle) {
-        try {
-          await temporaryHandle.close();
-        } catch {
-        }
-      }
-      try {
-        await this.fs.unlink(temporaryPath);
-      } catch {
-      }
-      throw error;
-    }
-  }
-  shouldIgnoreDirectorySyncError(error) {
-    const code = error.code;
-    return this.platform === "win32" && (code === "EPERM" || code === "EINVAL");
-  }
-  async syncDirectory(path) {
-    let directoryHandle;
-    try {
-      try {
-        directoryHandle = await this.fs.open(path, "r");
-      } catch (error) {
-        if (!this.shouldIgnoreDirectorySyncError(error)) {
-          throw error;
-        }
-        return;
-      }
-      try {
-        await directoryHandle.sync();
-      } catch (error) {
-        if (!this.shouldIgnoreDirectorySyncError(error)) {
-          throw error;
-        }
-      }
-    } catch (error) {
-      if (directoryHandle) {
-        try {
-          await directoryHandle.close();
-        } catch {
-        }
-      }
-      throw error;
-    }
-    if (directoryHandle) {
-      await directoryHandle.close();
-    }
-  }
-};
-
 // ../sdk/plugin-ts/dist/bpp/bpp-transport.js
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID } from "node:crypto";
 
 // ../../node_modules/.pnpm/ws@8.21.1/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -3869,32 +3754,33 @@ var CONFIG_ACK_REASONS = /* @__PURE__ */ new Set([
   "unknown"
 ]);
 var WS_CLOSE_AUTH_FAILED = 4004;
+var RESUME_REPLAY_MODE = "latest_n";
+var RESUME_SINCE_CURSOR = 0;
+var RESUME_LATEST_N = 200;
 var RESULT_STATUS_OK = "ok";
+var STOP_TURN_ACTION = "stop_turn";
+var STOP_TURN_CHANNEL_ID_INVALID = "stop_turn_channel_id_invalid";
+var SERVER_REQUEST_FAILED = "server_request_failed";
 var BppTransport = class {
   performTimeoutMs;
   heartbeatIntervalMs;
   reconnectBaseMs;
   reconnectMaxMs;
   autoReconnect;
-  resumeAckTimeoutMs;
   configApplyTimeoutMs;
   ctx;
   handlers;
   serverRequestHandler;
+  stopTurnHandler;
   ws;
   pending = /* @__PURE__ */ new Map();
-  legacyAckSockets = /* @__PURE__ */ new WeakSet();
-  legacyReconnectSockets = /* @__PURE__ */ new WeakSet();
   closed = false;
-  // ONLINE = resume acknowledged and replay drained. Outbound semantic actions gate on this,
-  // not on a raw open socket, so a send issued during reconnect never races ahead of session.resume.
+  // ONLINE = this socket's handshake has been written and its identity is known.
+  // Outbound semantic actions gate on this rather than on a raw open socket, so a
+  // send issued during a reconnect never races ahead of the handshake.
   online = false;
   terminal = false;
-  resumeWaiter;
-  replayRemaining = 0;
-  replayHighWater = -1;
-  lastConsumedCursor = -1;
-  cursorFailed = false;
+  inboundFailed = false;
   inboundChain = Promise.resolve();
   configChain = Promise.resolve();
   configAcks = /* @__PURE__ */ new Map();
@@ -3903,7 +3789,8 @@ var BppTransport = class {
   reconnectAttempt = 0;
   heartbeatTimer;
   reconnectTimer;
-  // connect 后经 get_me 解析到的 agentId (opts 未给时)。用于 cursor 键 + 上行帧。
+  // The agent id resolved by get_me when the caller supplied none; stamped on
+  // every outbound frame that names an agent.
   agentId = "";
   constructor(options = {}) {
     this.performTimeoutMs = options.performTimeoutMs ?? 3e4;
@@ -3911,15 +3798,11 @@ var BppTransport = class {
     this.reconnectBaseMs = options.reconnectBaseMs ?? 500;
     this.reconnectMaxMs = options.reconnectMaxMs ?? 3e4;
     this.autoReconnect = options.autoReconnect ?? true;
-    this.resumeAckTimeoutMs = options.resumeAckTimeoutMs ?? 5e3;
     this.configApplyTimeoutMs = options.configApplyTimeoutMs ?? 5e3;
   }
   get logger() {
     return this.ctx?.logger;
   }
-  get cursorStore() {
-    return this.ctx?.cursorStore;
-  }
   currentAgentId() {
     return this.agentId || this.ctx?.agentId || "";
   }
@@ -3929,6 +3812,9 @@ var BppTransport = class {
   setServerRequestHandler(handler) {
     this.serverRequestHandler = handler;
   }
+  setStopTurnHandler(handler) {
+    this.stopTurnHandler = handler;
+  }
   getResolvedAgentId() {
     return this.currentAgentId();
   }
@@ -3948,8 +3834,6 @@ var BppTransport = class {
     this.online = false;
     this.stopHeartbeat();
     this.rejectReconnectWaiters(new BorgeeError("transport not connected", "bpp.not_connected"));
-    if (this.resumeWaiter)
-      this.rejectResumeWaiter(this.resumeWaiter.ws, new BorgeeError("transport closed", "bpp.transport_closed"));
     this.rejectAllPending(new BorgeeError("transport closed", "bpp.transport_closed"));
     const ws = this.ws;
     this.ws = void 0;
@@ -3974,17 +3858,21 @@ var BppTransport = class {
       this.sendTyping(action);
       return void 0;
     }
+    if (action.op === "report_activity") {
+      this.sendActivity(action);
+      return void 0;
+    }
     const deadline = Date.now() + this.performTimeoutMs;
     if (this.closed || this.terminal) {
       throw new BorgeeError("transport not connected", "bpp.not_connected");
     }
-    if (opts?.preResume) {
+    if (opts?.handshake) {
       if (!this.isOpen())
         throw new BorgeeError("transport not connected", "bpp.not_connected");
     } else if (!this.online) {
       await this.waitUntilOnline(action.op, deadline);
     }
-    const nonce = randomUUID2();
+    const nonce = randomUUID();
     const frame = {
       type: "semantic_action",
       agent_id: this.currentAgentId(),
@@ -4004,7 +3892,7 @@ var BppTransport = class {
   }
   // ---- socket 生命周期 ----
   // Transition the given socket to ONLINE. Bails if the socket is stale (a reconnect replaced it),
-  // so a late replay-completion from a prior socket cannot flip online across a reconnect.
+  // so a handshake completing on a prior socket cannot flip online across a reconnect.
   goOnline(source) {
     if (!source || source !== this.ws)
       return;
@@ -4015,7 +3903,7 @@ var BppTransport = class {
   isOpen() {
     return this.ws !== void 0 && this.ws.readyState === import_websocket.default.OPEN;
   }
-  openSocket(mode = "canonical") {
+  openSocket() {
     const ctx = this.ctx;
     if (!ctx)
       throw new BorgeeError("connect() called without context", "bpp.no_context");
@@ -4043,7 +3931,7 @@ var BppTransport = class {
             settled = true;
             reject(error);
           }
-        }, mode);
+        });
       });
       ws.on("message", (data) => {
         this.onMessage(rawToString(data), ws);
@@ -4056,11 +3944,7 @@ var BppTransport = class {
         }
       });
       ws.on("close", (code, reason) => {
-        const legacyReconnect = this.legacyReconnectSockets.has(ws);
-        if (legacyReconnect)
-          this.legacyReconnectSockets.delete(ws);
         connectionAbort.abort();
-        this.rejectResumeWaiter(ws, new BorgeeError("ws closed before resume acknowledgement", "bpp.resume_incomplete"));
         const wasCurrent = this.ws === ws;
         if (wasCurrent) {
           this.online = false;
@@ -4077,11 +3961,11 @@ var BppTransport = class {
         if (wasCurrent) {
           this.rejectAllPending(authFailed ? new BorgeeError("authentication failed: invalid or revoked API key", "bpp.auth_failed") : new BorgeeError("connection lost", "bpp.connection_lost"));
         }
-        if (!settled && !legacyReconnect) {
+        if (!settled) {
           settled = true;
-          reject(authFailed ? new BorgeeError("authentication failed: invalid or revoked API key", "bpp.auth_failed") : new BorgeeError(opened ? "ws closed before resume acknowledgement" : "ws closed before open", opened ? "bpp.resume_incomplete" : "bpp.connect_failed"));
+          reject(authFailed ? new BorgeeError("authentication failed: invalid or revoked API key", "bpp.auth_failed") : new BorgeeError(opened ? "ws closed before the handshake was written" : "ws closed before open", opened ? "bpp.handshake_incomplete" : "bpp.connect_failed"));
         }
-        if (authFailed || legacyReconnect || !wasCurrent) {
+        if (authFailed || !wasCurrent) {
           if (authFailed && wasCurrent) {
             this.rejectReconnectWaiters(new BorgeeError("authentication failed: invalid or revoked API key", "bpp.auth_failed"));
           }
@@ -4095,7 +3979,7 @@ var BppTransport = class {
       });
     });
   }
-  async onOpen(ws, resolve, reject, mode) {
+  async onOpen(ws, resolve, reject) {
     const ctx = this.ctx;
     if (!ctx)
       return;
@@ -4109,154 +3993,33 @@ var BppTransport = class {
     this.sendTo(ws, connectFrame);
     try {
       if (!this.currentAgentId()) {
-        const identity = await this.perform({ op: "get_me" }, { preResume: true });
+        const identity = await this.perform({ op: "get_me" }, { handshake: true });
         const resolved = identity && typeof identity === "object" ? identity.id : "";
         if (!resolved)
           throw new BorgeeError("authenticated agent identity could not be resolved", "bpp.identity_unresolved");
         this.agentId = resolved;
       }
-      const cursor = await this.cursorStore?.read(this.currentAgentId()) ?? -1;
-      this.lastConsumedCursor = Math.max(this.lastConsumedCursor, cursor);
-      if (mode === "legacy") {
-        this.sendLegacyReconnect(ws, Math.max(cursor, 0), resolve);
-        return;
-      }
-      this.sendResumeRequest(ws, Math.max(cursor, 0), resolve, reject);
+      this.sendResumeRequest(ws);
+      this.startHeartbeat();
+      this.goOnline(ws);
+      resolve();
     } catch (error) {
-      const failure = error instanceof BorgeeError ? error : new BorgeeError(`cursor read failed: ${String(error)}`, "bpp.cursor_store_read_failed");
+      const failure = error instanceof BorgeeError ? error : new BorgeeError(`agent identity handshake failed: ${String(error)}`, "bpp.identity_unresolved");
       reject(failure);
       this.failTerminal(failure, ws);
     }
   }
-  sendResumeRequest(ws, sinceCursor, resolve, reject) {
-    const ctx = this.ctx;
-    if (!ctx || ws !== this.ws)
-      return;
-    const replayMode = ctx.replayMode ?? "latest_n";
+  // The resume is written for one reader: a server that still holds durable
+  // frames behind a pre-ack barrier releases it when this frame arrives. Its
+  // answer is not read, so the request asks for nothing.
+  sendResumeRequest(ws) {
     const frame = {
       type: "session.resume",
-      replay_mode: replayMode,
-      since_cursor: sinceCursor,
-      ...replayMode === "latest_n" ? { latest_n: ctx.replayLatestN ?? 200 } : {}
-    };
-    this.handlers?.onStateChange({ status: "resuming" });
-    const priorWaiter = this.resumeWaiter;
-    if (priorWaiter?.ws === ws) {
-      clearTimeout(priorWaiter.timer);
-    }
-    const timeoutMs = ctx.resumeAckTimeoutMs ?? this.resumeAckTimeoutMs;
-    let waiter;
-    const timer = setTimeout(() => {
-      if (this.resumeWaiter !== waiter || this.ws !== ws)
-        return;
-      this.resumeWaiter = void 0;
-      if (this.retryWithLegacyReconnect(ws, resolve, reject))
-        return;
-      const error = new BorgeeError("session.resume_ack timed out", "bpp.resume_ack_timeout");
-      reject(error);
-      this.failTerminal(error, ws);
-    }, timeoutMs);
-    waiter = { ws, resolve, reject, timer };
-    this.resumeWaiter = waiter;
-    this.send(frame);
-  }
-  sendLegacyReconnect(ws, sinceCursor, resolve) {
-    const ctx = this.ctx;
-    if (!ctx || ws !== this.ws || ws.readyState !== import_websocket.default.OPEN)
-      return;
-    this.legacyAckSockets.add(ws);
-    const now = Date.now();
-    const frame = {
-      type: "reconnect_handshake",
-      plugin_id: ctx.pluginId ?? "",
-      agent_id: this.currentAgentId(),
-      last_known_cursor: sinceCursor,
-      disconnect_at: now,
-      reconnect_at: now
+      replay_mode: RESUME_REPLAY_MODE,
+      since_cursor: RESUME_SINCE_CURSOR,
+      latest_n: RESUME_LATEST_N
     };
-    this.replayRemaining = 0;
-    this.replayHighWater = Math.max(this.replayHighWater, sinceCursor);
     this.sendTo(ws, frame);
-    resolve();
-    this.startHeartbeat();
-    this.goOnline(ws);
-  }
-  retryWithLegacyReconnect(ws, resolve, reject) {
-    if (ws !== this.ws || ws.readyState !== import_websocket.default.OPEN)
-      return false;
-    this.legacyReconnectSockets.add(ws);
-    try {
-      ws.close();
-    } catch {
-      this.legacyReconnectSockets.delete(ws);
-      return false;
-    }
-    void this.openSocket("legacy").then(resolve).catch(reject);
-    return true;
-  }
-  finishReplayIfReady(source) {
-    if (this.replayRemaining !== 0)
-      return Promise.resolve();
-    const highWater = this.replayHighWater;
-    if (highWater <= this.lastConsumedCursor) {
-      this.goOnline(source);
-      return Promise.resolve();
-    }
-    return this.persistCursor(highWater).then(() => {
-      this.goOnline(source);
-    });
-  }
-  handleResumeAck(frame, source) {
-    const waiter = this.resumeWaiter;
-    const compatibilityAck = source === this.ws && this.legacyAckSockets.has(source) && (!waiter || waiter.ws !== source);
-    if (!compatibilityAck && (!waiter || waiter.ws !== source || source !== this.ws))
-      return;
-    if (waiter?.ws === source)
-      clearTimeout(waiter.timer);
-    if (!Number.isSafeInteger(frame.count) || frame.count < 0 || frame.count > 500 || !Number.isSafeInteger(frame.high_water) || frame.high_water < 0) {
-      if (waiter?.ws === source)
-        this.resumeWaiter = void 0;
-      if (compatibilityAck)
-        this.legacyAckSockets.delete(source);
-      const error = new BorgeeError("invalid session.resume_ack bounds", "bpp.resume_ack_invalid");
-      if (waiter?.ws === source)
-        waiter.reject(error);
-      this.failTerminal(error, source);
-      return;
-    }
-    if (frame.reset) {
-      if (waiter?.ws === source)
-        this.resumeWaiter = void 0;
-      void this.resetCursor(frame.high_water).then(() => {
-        if (compatibilityAck)
-          this.legacyAckSockets.delete(source);
-        this.replayRemaining = 0;
-        this.replayHighWater = frame.high_water;
-        waiter?.resolve();
-        this.startHeartbeat();
-        this.inboundChain = this.inboundChain.then(() => this.finishReplayIfReady(source)).catch((error) => {
-          this.failTerminal(this.cursorFailure(error), source);
-        });
-      }).catch((error) => {
-        const failure = this.cursorFailure(error);
-        waiter?.reject(failure);
-        this.failTerminal(failure, source);
-      });
-      return;
-    }
-    if (waiter?.ws === source)
-      this.resumeWaiter = void 0;
-    if (compatibilityAck)
-      this.legacyAckSockets.delete(source);
-    this.replayRemaining = frame.count;
-    this.replayHighWater = frame.high_water;
-    waiter?.resolve();
-    this.startHeartbeat();
-    if (frame.count === 0) {
-      this.inboundChain = this.inboundChain.then(() => this.finishReplayIfReady(source)).catch((error) => {
-        this.failTerminal(this.cursorFailure(error), source);
-      });
-    }
   }
   scheduleReconnect() {
     if (this.closed || this.terminal || !this.autoReconnect)
@@ -4312,13 +4075,7 @@ var BppTransport = class {
         void this.handleServerRequest(env);
         break;
       case "inbound_message":
-        this.handleInbound(env, source);
-        break;
-      case "session.resume_ack":
-        this.handleResumeAck(env, source);
-        break;
-      case "session.summary":
-        this.handleSummary(env, source);
+        this.handleInbound(env);
         break;
       case "semantic_action_result":
         this.handleActionResult(env);
@@ -4329,6 +4086,7 @@ var BppTransport = class {
       case "agent_config_update":
         this.handleConfigUpdate(env, source);
         break;
+      case "session.resume_ack":
       case "pong":
       case "ping":
       case "agent_toggle":
@@ -4337,40 +4095,14 @@ var BppTransport = class {
         break;
     }
   }
-  handleInbound(frame, source) {
-    this.inboundChain = this.inboundChain.then(async () => {
-      if (this.cursorFailed)
+  handleInbound(frame) {
+    this.inboundChain = this.inboundChain.then(() => {
+      if (this.inboundFailed)
         return;
-      if (!Number.isSafeInteger(frame.cursor) || frame.cursor <= this.lastConsumedCursor) {
-        throw new BorgeeError(`non-monotonic inbound cursor ${frame.cursor}`, "bpp.cursor_non_monotonic");
-      }
-      const event = mapInbound(frame);
-      this.handlers?.onInbound(event);
-      await this.persistCursor(frame.cursor);
-      if (this.replayRemaining > 0) {
-        this.replayRemaining -= 1;
-        await this.finishReplayIfReady(source);
-      }
-    }).catch((error) => {
-      this.cursorFailed = true;
-      this.failTerminal(this.cursorFailure(error), this.ws);
-    });
-  }
-  handleSummary(frame, source) {
-    this.inboundChain = this.inboundChain.then(async () => {
-      if (this.cursorFailed)
-        return;
-      if (!Number.isSafeInteger(frame.cursor) || frame.cursor < this.lastConsumedCursor)
-        throw new BorgeeError(`non-monotonic summary cursor ${frame.cursor}`, "bpp.cursor_non_monotonic");
-      this.handlers?.onReplaySummary({ cursor: frame.cursor, missedCount: frame.missed_count, sinceCursor: frame.since_cursor, throughCursor: frame.through_cursor, summary: frame.summary });
-      await this.persistCursor(frame.cursor);
-      if (this.replayRemaining > 0) {
-        this.replayRemaining -= 1;
-        await this.finishReplayIfReady(source);
-      }
+      this.handlers?.onInbound(mapInbound(frame));
     }).catch((error) => {
-      this.cursorFailed = true;
-      this.failTerminal(this.cursorFailure(error), this.ws);
+      this.inboundFailed = true;
+      this.failTerminal(this.inboundFailure(error), this.ws);
     });
   }
   handleActionResult(frame) {
@@ -4380,7 +4112,7 @@ var BppTransport = class {
     this.pending.delete(frame.nonce);
     clearTimeout(p.timer);
     if (frame.status === RESULT_STATUS_OK) {
-      const result = decodeActionResult(p.op, frame.payload, frame.cursor);
+      const result = decodeActionResult(p.op, frame.payload);
       if (p.op === "get_me" && result && typeof result === "object") {
         const id = result.id;
         if (id)
@@ -4509,6 +4241,10 @@ var BppTransport = class {
       return;
     const data = env.data ?? {};
     const action = typeof data.action === "string" ? data.action : "";
+    if (action === STOP_TURN_ACTION) {
+      await this.answerStopTurn(id, data);
+      return;
+    }
     if (!this.serverRequestHandler) {
       this.send({ type: "response", id, error: "no_server_request_handler" });
       return;
@@ -4520,6 +4256,40 @@ var BppTransport = class {
       this.send({ type: "response", id, error: err instanceof Error ? err.message : String(err) });
     }
   }
+  // Precedence: the specific handler wins, an onServerRequest callback gets
+  // stop_turn only while no specific one is registered, and with neither the
+  // SDK answers the request itself. That order is what lets a plugin that
+  // already switches on the action name inside one callback keep working
+  // unchanged, and lets it move onto onStopTurn one action at a time.
+  async answerStopTurn(id, data) {
+    const channelId = data.channel_id;
+    if (typeof channelId !== "string" || channelId === "") {
+      this.send({ type: "response", id, error: STOP_TURN_CHANNEL_ID_INVALID });
+      return;
+    }
+    const specific = this.stopTurnHandler;
+    const generic = this.serverRequestHandler;
+    try {
+      const answer = specific ? await specific(channelId) : generic ? await generic(STOP_TURN_ACTION, data) : { aborted: false };
+      this.send({ type: "response", id, data: this.asStopTurnResult(answer) });
+    } catch (err) {
+      this.logger?.warn("bpp.stop_turn_handler_failed", err);
+      this.send({ type: "response", id, error: SERVER_REQUEST_FAILED });
+    }
+  }
+  // The rail's answer is one boolean and nothing else, so that is what goes on
+  // the wire whatever the handler returned. A callback switching on action names
+  // answers actions it does not implement with something else entirely — and
+  // "the callback does not implement stopping" is one of the things false
+  // already covers, so it is reported as such rather than as a broken agent.
+  asStopTurnResult(answer) {
+    const aborted = answer?.aborted;
+    if (typeof aborted !== "boolean") {
+      this.logger?.warn("bpp.stop_turn_answer_unusable", answer);
+      return { aborted: false };
+    }
+    return { aborted };
+  }
   // ---- task 生命周期上行 ----
   sendTaskStarted(action) {
     const frame = {
@@ -4544,6 +4314,59 @@ var BppTransport = class {
     };
     this.send(frame);
   }
+  // sendActivity flattens the four-shape union onto one frame. The union is
+  // how a producer says which shape it is reporting; the wire puts the
+  // discriminator beside its payload with no wrapper object, matching both the
+  // protocol this relays and inbound_message's own `kind`.
+  //
+  // The frame names no agent: identity is stamped by the server from the
+  // authenticated connection, so nothing here can report as another agent.
+  sendActivity(action) {
+    const frame = {
+      type: "agent_activity",
+      channel_id: action.channelId,
+      sequence: action.sequence,
+      shape: action.activity.shape,
+      activity_id: "",
+      label: "",
+      description: "",
+      kind: "",
+      status: "",
+      detail: "",
+      parent_id: "",
+      subagent: false,
+      reason: "",
+      stream: "",
+      text: "",
+      turn_state: ""
+    };
+    switch (action.activity.shape) {
+      case "activity":
+        frame.activity_id = action.activity.id;
+        frame.label = action.activity.label ?? "";
+        frame.description = action.activity.description ?? "";
+        frame.kind = action.activity.kind ?? "";
+        frame.status = action.activity.status ?? "";
+        frame.detail = action.activity.detail ?? "";
+        frame.parent_id = action.activity.parentId ?? "";
+        frame.subagent = action.activity.subagent ?? false;
+        frame.reason = action.activity.reason ?? "";
+        if (action.activity.paths)
+          frame.paths = action.activity.paths;
+        break;
+      case "plan":
+        frame.plan = action.activity.entries.map((entry) => ({ label: entry.label, status: entry.status }));
+        break;
+      case "output":
+        frame.stream = action.activity.stream;
+        frame.text = action.activity.text;
+        break;
+      case "turn":
+        frame.turn_state = action.activity.state;
+        break;
+    }
+    this.send(frame);
+  }
   sendTyping(action) {
     this.send({ type: "typing", channel_id: action.channelId });
   }
@@ -4566,28 +4389,10 @@ var BppTransport = class {
       this.logger?.warn("bpp.send_failed", err);
     }
   }
-  async persistCursor(cursor) {
-    if (cursor <= this.lastConsumedCursor)
-      return;
-    await this.cursorStore?.write(this.currentAgentId(), cursor);
-    this.lastConsumedCursor = cursor;
-  }
-  async resetCursor(cursor) {
-    await this.cursorStore?.write(this.currentAgentId(), cursor);
-    this.lastConsumedCursor = cursor;
-  }
-  cursorFailure(error) {
+  inboundFailure(error) {
     if (error instanceof BorgeeError)
       return error;
-    return new BorgeeError(`cursor persistence failed: ${String(error)}`, "bpp.cursor_store_write_failed");
-  }
-  rejectResumeWaiter(ws, error) {
-    const waiter = this.resumeWaiter;
-    if (!waiter || waiter.ws !== ws)
-      return;
-    clearTimeout(waiter.timer);
-    this.resumeWaiter = void 0;
-    waiter.reject(error);
+    return new BorgeeError(`inbound dispatch failed: ${String(error)}`, "bpp.inbound_dispatch_failed");
   }
   failTerminal(error, ws) {
     if (this.terminal)
@@ -4595,8 +4400,6 @@ var BppTransport = class {
     this.terminal = true;
     this.online = false;
     this.handlers?.onStateChange({ status: "error", reason: "unknown", code: error.code });
-    if (ws)
-      this.rejectResumeWaiter(ws, error);
     this.rejectReconnectWaiters(error);
     this.rejectAllPending(error);
     try {
@@ -4739,11 +4542,11 @@ function encodeActionPayload(action) {
       return {};
   }
 }
-function decodeActionResult(op, payloadJSON, frameCursor) {
+function decodeActionResult(op, payloadJSON) {
   const p = safeParseJSON(payloadJSON);
   switch (op) {
     case "send_message":
-      return { messageId: String(p.message_id ?? ""), cursor: frameCursor };
+      return { messageId: String(p.message_id ?? "") };
     case "create_dm":
       return { channelId: String(p.channel_id ?? "") };
     case "get_me":
@@ -4856,7 +4659,6 @@ function mapInbound(frame) {
   const kind = frame.kind;
   const base = {
     kind,
-    cursor: frame.cursor,
     channelId: frame.channel_id,
     channelType: frame.channel_type,
     authorName: frame.author_name,
@@ -4931,6 +4733,102 @@ function rawToString(data) {
   return String(data);
 }
 
+// ../sdk/plugin-ts/dist/activity-reporter.js
+var DEFAULT_THROTTLE_MS = 150;
+var OUTPUT_TAIL_CHARS = 2e3;
+var defaultScheduler = (callback, delayMs) => {
+  const timer = setTimeout(callback, delayMs);
+  timer.unref?.();
+  return () => clearTimeout(timer);
+};
+function outputTail(text) {
+  if (text.length <= OUTPUT_TAIL_CHARS) {
+    return text;
+  }
+  const tail = text.slice(text.length - OUTPUT_TAIL_CHARS);
+  return /^[\uDC00-\uDFFF]/.test(tail) ? tail.slice(1) : tail;
+}
+function throttleKey(activity) {
+  switch (activity.shape) {
+    case "activity":
+      return `activity:${activity.id}`;
+    case "plan":
+      return "plan";
+    case "output":
+      return `output:${activity.stream}`;
+  }
+}
+var TurnActivityReporter = class {
+  options;
+  windows = /* @__PURE__ */ new Map();
+  throttleMs;
+  scheduler;
+  ended = false;
+  constructor(options) {
+    this.options = options;
+    this.throttleMs = options.throttleMs ?? DEFAULT_THROTTLE_MS;
+    this.scheduler = options.scheduler ?? defaultScheduler;
+  }
+  start() {
+    this.report({ shape: "turn", state: "started" });
+  }
+  progress(activity) {
+    if (this.ended) {
+      return;
+    }
+    this.offer(activity.shape === "output" ? { ...activity, text: outputTail(activity.text) } : activity);
+  }
+  /**
+   * Ends the turn. What the windows still hold goes first, so the last thing a
+   * reader sees of a turn is that turn's own last word rather than whatever
+   * happened to fall outside a window.
+   */
+  end() {
+    if (this.ended) {
+      return;
+    }
+    this.ended = true;
+    this.drain();
+    this.report({ shape: "turn", state: "ended" });
+  }
+  offer(activity) {
+    const key = throttleKey(activity);
+    const open = this.windows.get(key);
+    if (open) {
+      open.latest = activity;
+      return;
+    }
+    this.report(activity);
+    this.openWindow(key);
+  }
+  openWindow(key) {
+    const window = { latest: null, cancel: null };
+    window.cancel = this.scheduler(() => {
+      this.windows.delete(key);
+      if (window.latest) {
+        this.offer(window.latest);
+      }
+    }, this.throttleMs);
+    this.windows.set(key, window);
+  }
+  drain() {
+    const held = [...this.windows.values()];
+    this.windows.clear();
+    for (const window of held) {
+      window.cancel?.();
+      if (window.latest) {
+        this.report(window.latest);
+      }
+    }
+  }
+  report(activity) {
+    if (this.options.canReport && !this.options.canReport()) {
+      return;
+    }
+    this.options.deliver({ channelId: this.options.channelId, activity });
+  }
+};
+
 // ../sdk/plugin-ts/dist/client.js
 var noopLogger = {
   debug() {
@@ -4946,21 +4844,19 @@ var Client = class {
   opts;
   t;
   logger;
-  cursorStore;
   _agentId;
+  activitySequence = 0;
   _state = { status: "connecting" };
   listeners = {
     message: /* @__PURE__ */ new Set(),
     configUpdate: /* @__PURE__ */ new Set(),
     permissionDenied: /* @__PURE__ */ new Set(),
-    connectionState: /* @__PURE__ */ new Set(),
-    replaySummary: /* @__PURE__ */ new Set()
+    connectionState: /* @__PURE__ */ new Set()
   };
   constructor(opts, transport) {
     this.opts = opts;
     this.t = transport;
     this.logger = opts.logger ?? noopLogger;
-    this.cursorStore = opts.cursorStore ?? new MemoryCursorStore();
     this._agentId = opts.agentId ?? "";
   }
   get agentId() {
@@ -5060,6 +4956,31 @@ var Client = class {
       reason: input.reason
     }).catch((err) => this.logger.warn("reportTaskFinished failed", err));
   }
+  reportActivity(input) {
+    void this.t.perform({
+      op: "report_activity",
+      channelId: input.channelId,
+      sequence: this.nextActivitySequence(),
+      activity: input.activity
+    }).catch((err) => this.logger.warn("reportActivity failed", err));
+  }
+  reportTurnActivity(input) {
+    return new TurnActivityReporter({
+      ...input,
+      deliver: (report) => this.reportActivity(report)
+    });
+  }
+  /**
+   * The counter every activity report carries. It belongs to the connection
+   * rather than to a producer: both readers use it only to drop anything not
+   * newer, so two producers on one agent numbering independently would silently
+   * erase each other, and the failure would present as a missing report rather
+   * than as a wrong one. Nothing outside this client can supply or observe it.
+   */
+  nextActivitySequence() {
+    this.activitySequence += 1;
+    return this.activitySequence;
+  }
   // ─── Task CRUD (BPP semantic actions) ───────────────────
   // Semantic actions rather than REST: the blueprint's protocol red line
   // (plugin-protocol.md 1.3) is that a plugin does not reach past the semantic
@@ -5143,6 +5064,9 @@ var Client = class {
   onServerRequest(handler) {
     this.t.setServerRequestHandler?.(handler);
   }
+  onStopTurn(handler) {
+    this.t.setStopTurnHandler?.(handler);
+  }
   emit(event, payload) {
     for (const h of this.listeners[event])
       h(payload);
@@ -5153,7 +5077,6 @@ var Client = class {
       onConfigUpdate: (u) => this.emit("configUpdate", u),
       applyConfigUpdate: this.opts.configUpdateHandler,
       onPermissionDenied: (d) => this.emit("permissionDenied", d),
-      onReplaySummary: (summary) => this.emit("replaySummary", summary),
       onStateChange: (s) => {
         this._state = s;
         this.emit("connectionState", s);
@@ -5166,12 +5089,8 @@ var Client = class {
       apiKey: this.opts.apiKey,
       agentId: this._agentId,
       pluginId: this.opts.pluginId,
-      cursorStore: this.cursorStore,
       logger: this.logger,
-      resumeAckTimeoutMs: this.opts.resumeAckTimeoutMs,
-      configApplyTimeoutMs: this.opts.configApplyTimeoutMs,
-      replayMode: this.opts.replayMode,
-      replayLatestN: this.opts.replayLatestN
+      configApplyTimeoutMs: this.opts.configApplyTimeoutMs
     };
   }
 };
@@ -5180,8 +5099,6 @@ function createBorgeePlugin(opts) {
 }
 export {
   BorgeeError,
-  FileCursorStore,
-  MemoryCursorStore,
   PermissionDeniedError,
   createBorgeePlugin
 };