@dhfpub/clawpool 0.1.0

package/dist/index.js

@@ -0,0 +1,2654 @@
+// index.ts
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+
+// src/channel.ts
+import {
+  applyAccountNameToChannelSection as applyAccountNameToChannelSection2,
+  chunkTextForOutbound,
+  DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID3,
+  deleteAccountFromConfigSection,
+  formatPairingApproveHint,
+  normalizeAccountId as normalizeAccountId3,
+  setAccountEnabledInConfigSection,
+  waitUntilAbort
+} from "openclaw/plugin-sdk";
+
+// src/actions.ts
+import {
+  jsonResult,
+  readStringParam
+} from "openclaw/plugin-sdk";
+
+// src/accounts.ts
+import {
+  DEFAULT_ACCOUNT_ID,
+  normalizeAccountId,
+  normalizeOptionalAccountId
+} from "openclaw/plugin-sdk/account-id";
+function rawAibotConfig(cfg) {
+  return cfg.channels?.clawpool ?? {};
+}
+function listConfiguredAccountIds(cfg) {
+  const accounts = rawAibotConfig(cfg).accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return [];
+  }
+  return Object.keys(accounts).filter(Boolean);
+}
+function listAibotAccountIds(cfg) {
+  const ids = listConfiguredAccountIds(cfg);
+  if (ids.length === 0) {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  return ids.toSorted((a, b) => a.localeCompare(b));
+}
+function resolveDefaultAibotAccountId(cfg) {
+  const aibotCfg = rawAibotConfig(cfg);
+  const preferred = normalizeOptionalAccountId(aibotCfg.defaultAccount);
+  if (preferred && listAibotAccountIds(cfg).some((accountId) => normalizeAccountId(accountId) === preferred)) {
+    return preferred;
+  }
+  const ids = listAibotAccountIds(cfg);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function resolveAccountRawConfig(cfg, accountId) {
+  const aibotCfg = rawAibotConfig(cfg);
+  const { accounts: _ignoredAccounts, defaultAccount: _ignoredDefault, ...base } = aibotCfg;
+  const account = aibotCfg.accounts?.[accountId] ?? {};
+  return {
+    ...base,
+    ...account
+  };
+}
+function normalizeNonEmpty(value) {
+  const s = String(value ?? "").trim();
+  return s;
+}
+function normalizeAgentId(value) {
+  return normalizeNonEmpty(value);
+}
+function appendAgentIdToWsUrl(rawWsUrl, agentId) {
+  if (!rawWsUrl) {
+    return "";
+  }
+  const direct = rawWsUrl.replaceAll("{agent_id}", encodeURIComponent(agentId));
+  if (!agentId) {
+    return direct;
+  }
+  try {
+    const parsed = new URL(direct);
+    if (!parsed.searchParams.get("agent_id")) {
+      parsed.searchParams.set("agent_id", agentId);
+    }
+    return parsed.toString();
+  } catch {
+    if (direct.includes("agent_id=")) {
+      return direct;
+    }
+    return direct.includes("?") ? `${direct}&agent_id=${encodeURIComponent(agentId)}` : `${direct}?agent_id=${encodeURIComponent(agentId)}`;
+  }
+}
+function resolveWsUrl(merged, agentId) {
+  const envWs = normalizeNonEmpty(process.env.CLAWPOOL_WS_URL);
+  const cfgWs = normalizeNonEmpty(merged.wsUrl);
+  const ws = cfgWs || envWs;
+  if (ws) {
+    return appendAgentIdToWsUrl(ws, agentId);
+  }
+  if (!agentId) {
+    return "";
+  }
+  return `ws://127.0.0.1:27189/v1/agent-api/ws?agent_id=${encodeURIComponent(agentId)}`;
+}
+function redactAibotWsUrl(wsUrl) {
+  if (!wsUrl) {
+    return "";
+  }
+  try {
+    const parsed = new URL(wsUrl);
+    if (parsed.searchParams.has("agent_id")) {
+      parsed.searchParams.set("agent_id", "***");
+    }
+    return parsed.toString();
+  } catch {
+    return wsUrl.replace(/(agent_id=)[^&]+/g, "$1***");
+  }
+}
+function resolveAibotAccount(params) {
+  const accountId = normalizeAccountId(params.accountId);
+  const merged = resolveAccountRawConfig(params.cfg, accountId);
+  const baseEnabled = rawAibotConfig(params.cfg).enabled !== false;
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  const agentId = normalizeAgentId(merged.agentId || process.env.CLAWPOOL_AGENT_ID);
+  const apiKey = normalizeNonEmpty(merged.apiKey || process.env.CLAWPOOL_API_KEY);
+  const wsUrl = resolveWsUrl(merged, agentId);
+  const configured = Boolean(wsUrl && agentId && apiKey);
+  return {
+    accountId,
+    name: normalizeNonEmpty(merged.name) || void 0,
+    enabled,
+    configured,
+    wsUrl,
+    agentId,
+    apiKey,
+    config: merged
+  };
+}
+function normalizeAibotSessionTarget(raw) {
+  const trimmed = String(raw ?? "").trim();
+  if (!trimmed) {
+    return "";
+  }
+  return trimmed.replace(/^clawpool:/i, "").replace(/^session:/i, "").trim();
+}
+
+// src/client.ts
+import { randomUUID } from "node:crypto";
+var DEFAULT_RECONNECT_BASE_MS = 2e3;
+var DEFAULT_RECONNECT_MAX_MS = 3e4;
+var DEFAULT_RECONNECT_STABLE_MS = 3e4;
+var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+var DEFAULT_HEARTBEAT_SEC = 30;
+function clampInt(value, fallback, min, max) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) {
+    return fallback;
+  }
+  return Math.max(min, Math.min(max, Math.floor(n)));
+}
+function buildFastRetryDelays(baseDelayMs) {
+  const first = Math.max(100, Math.min(300, Math.floor(baseDelayMs / 4)));
+  const second = Math.max(first, Math.min(1e3, Math.floor(baseDelayMs / 2)));
+  return [first, second];
+}
+function randomIntInclusive(min, max) {
+  const boundedMin = Math.floor(min);
+  const boundedMax = Math.floor(max);
+  if (boundedMax <= boundedMin) {
+    return boundedMin;
+  }
+  return boundedMin + Math.floor(Math.random() * (boundedMax - boundedMin + 1));
+}
+function normalizeCloseReason(value) {
+  const reason = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (!reason) {
+    return void 0;
+  }
+  return reason.slice(0, 160);
+}
+function redactWsUrlForLog(wsUrl) {
+  if (!wsUrl) {
+    return "";
+  }
+  try {
+    const parsed = new URL(wsUrl);
+    if (parsed.searchParams.has("agent_id")) {
+      parsed.searchParams.set("agent_id", "***");
+    }
+    return parsed.toString();
+  } catch {
+    return wsUrl.replace(/(agent_id=)[^&]+/g, "$1***");
+  }
+}
+function parseHeartbeatSec(payload) {
+  return clampInt(payload.heartbeat_sec, DEFAULT_HEARTBEAT_SEC, 5, 300);
+}
+async function sleepWithAbort(ms, abortSignal) {
+  if (ms <= 0 || abortSignal.aborted) {
+    return;
+  }
+  await new Promise((resolve) => {
+    let settled = false;
+    let timer = null;
+    function finish() {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+      abortSignal.removeEventListener("abort", onAbort);
+      resolve();
+    }
+    function onAbort() {
+      finish();
+    }
+    timer = setTimeout(finish, ms);
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function resolveReconnectPolicy(account) {
+  const baseDelayMs = clampInt(account.config.reconnectMs, DEFAULT_RECONNECT_BASE_MS, 100, 6e4);
+  const fallbackMaxMs = Math.max(DEFAULT_RECONNECT_MAX_MS, baseDelayMs * 8);
+  const maxDelayMs = clampInt(account.config.reconnectMaxMs, fallbackMaxMs, baseDelayMs, 3e5);
+  const stableConnectionMs = clampInt(
+    account.config.reconnectStableMs,
+    DEFAULT_RECONNECT_STABLE_MS,
+    1e3,
+    6e5
+  );
+  const connectTimeoutMs = clampInt(
+    account.config.connectTimeoutMs,
+    DEFAULT_CONNECT_TIMEOUT_MS,
+    1e3,
+    6e4
+  );
+  const fastRetryDelaysMs = buildFastRetryDelays(baseDelayMs);
+  return {
+    baseDelayMs,
+    maxDelayMs,
+    stableConnectionMs,
+    fastRetryDelaysMs,
+    authPenaltyAttemptFloor: fastRetryDelaysMs.length + 4,
+    connectTimeoutMs
+  };
+}
+var AuthRejectedError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(`clawpool auth failed: code=${code}, msg=${message}`);
+    this.name = "AuthRejectedError";
+    this.code = code;
+  }
+};
+function parseCode(payload) {
+  const n = Number(payload.code ?? 0);
+  if (Number.isFinite(n)) {
+    return n;
+  }
+  return 0;
+}
+function parseMessage(payload) {
+  const s = String(payload.msg ?? "").trim();
+  return s || "unknown error";
+}
+function parseKickedReason(payload) {
+  const reason = String(payload.reason ?? payload.msg ?? "").trim();
+  return reason || "unknown";
+}
+async function wsDataToText(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data).toString("utf8");
+  }
+  if (ArrayBuffer.isView(data)) {
+    return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
+  }
+  if (data && typeof data.text === "function") {
+    return data.text();
+  }
+  return String(data ?? "");
+}
+var AibotWsClient = class {
+  account;
+  callbacks;
+  reconnectPolicy;
+  ws = null;
+  running = false;
+  seq = Date.now();
+  loopPromise = null;
+  pending = /* @__PURE__ */ new Map();
+  pendingStreamHighSurrogate = /* @__PURE__ */ new Map();
+  reconnectPenaltyAttemptFloor = 0;
+  connectionSerial = 0;
+  keepaliveTimer = null;
+  keepaliveInFlight = false;
+  lastConnectionError = "";
+  lastConnectionErrorLogAt = 0;
+  suppressedConnectionErrors = 0;
+  lastReconnectLogAt = 0;
+  suppressedReconnectLogs = 0;
+  status = {
+    running: false,
+    connected: false,
+    authed: false,
+    lastError: null,
+    lastConnectAt: null,
+    lastDisconnectAt: null
+  };
+  constructor(account, callbacks = {}) {
+    this.account = account;
+    this.callbacks = callbacks;
+    this.reconnectPolicy = resolveReconnectPolicy(account);
+  }
+  logInfo(message) {
+    this.callbacks.logger?.info?.(`[clawpool] [${this.account.accountId}] ${message}`);
+  }
+  logWarn(message) {
+    this.callbacks.logger?.warn?.(`[clawpool] [${this.account.accountId}] ${message}`);
+  }
+  logError(message) {
+    this.callbacks.logger?.error?.(`[clawpool] [${this.account.accountId}] ${message}`);
+  }
+  logConnectionError(message) {
+    const now = Date.now();
+    const sameAsLast = this.lastConnectionError === message;
+    const shouldLog = !sameAsLast || now - this.lastConnectionErrorLogAt >= 3e4 || this.suppressedConnectionErrors >= 10;
+    if (!shouldLog) {
+      this.suppressedConnectionErrors += 1;
+      return;
+    }
+    const repeats = this.suppressedConnectionErrors;
+    this.lastConnectionError = message;
+    this.lastConnectionErrorLogAt = now;
+    this.suppressedConnectionErrors = 0;
+    if (repeats > 0) {
+      this.logWarn(`connection error: ${message} (suppressed=${repeats})`);
+      return;
+    }
+    this.logWarn(`connection error: ${message}`);
+  }
+  logReconnectPlan(params) {
+    const now = Date.now();
+    const important = params.attempt <= 3 || params.authRejected || params.penaltyFloor > 0 || params.stable || params.attempt % 10 === 0;
+    const shouldLog = important || now - this.lastReconnectLogAt >= 3e4;
+    if (!shouldLog) {
+      this.suppressedReconnectLogs += 1;
+      return;
+    }
+    const suppressed = this.suppressedReconnectLogs;
+    this.suppressedReconnectLogs = 0;
+    this.lastReconnectLogAt = now;
+    this.logInfo(
+      `reconnect scheduled in ${params.delayMs}ms attempt=${params.attempt} stable=${params.stable} authRejected=${params.authRejected} penaltyFloor=${params.penaltyFloor} suppressed=${suppressed}`
+    );
+  }
+  getStatus() {
+    return { ...this.status };
+  }
+  async start(abortSignal) {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    this.updateStatus({ running: true, lastError: null });
+    this.logInfo(
+      `client start ws=${redactWsUrlForLog(this.account.wsUrl)} reconnectBaseMs=${this.reconnectPolicy.baseDelayMs} reconnectMaxMs=${this.reconnectPolicy.maxDelayMs} reconnectStableMs=${this.reconnectPolicy.stableConnectionMs} connectTimeoutMs=${this.reconnectPolicy.connectTimeoutMs}`
+    );
+    this.loopPromise = this.runLoop(abortSignal);
+    void this.loopPromise.catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.updateStatus({
+        running: false,
+        connected: false,
+        authed: false,
+        lastError: msg,
+        lastDisconnectAt: Date.now()
+      });
+      this.logError(`run loop crashed: ${msg}`);
+    });
+  }
+  stop() {
+    this.running = false;
+    this.stopKeepalive();
+    this.rejectAllPending(new Error("clawpool client stopped"));
+    this.safeCloseWs("client_stopped");
+    this.updateStatus({
+      running: false,
+      connected: false,
+      authed: false,
+      lastDisconnectAt: Date.now()
+    });
+  }
+  async waitUntilStopped() {
+    await this.loopPromise;
+  }
+  async sendText(sessionId, text, opts = {}) {
+    this.ensureReady();
+    const payload = {
+      session_id: sessionId,
+      client_msg_id: opts.clientMsgId || `clawpool_${randomUUID()}`,
+      msg_type: 1,
+      content: text
+    };
+    if (opts.quotedMessageId) {
+      payload.quoted_message_id = opts.quotedMessageId;
+    }
+    if (opts.extra && Object.keys(opts.extra).length > 0) {
+      payload.extra = opts.extra;
+    }
+    const packet = await this.request("send_msg", payload, {
+      expected: ["send_ack", "send_nack", "error"],
+      timeoutMs: opts.timeoutMs ?? 2e4
+    });
+    if (packet.cmd !== "send_ack") {
+      throw this.packetError(packet);
+    }
+    return packet.payload;
+  }
+  async sendMedia(sessionId, mediaUrl, caption = "", opts = {}) {
+    this.ensureReady();
+    const payload = {
+      session_id: sessionId,
+      client_msg_id: opts.clientMsgId || `clawpool_${randomUUID()}`,
+      msg_type: opts.msgType ?? 2,
+      content: caption || "[media]",
+      media_url: mediaUrl
+    };
+    if (opts.quotedMessageId) {
+      payload.quoted_message_id = opts.quotedMessageId;
+    }
+    if (opts.extra && Object.keys(opts.extra).length > 0) {
+      payload.extra = opts.extra;
+    }
+    const packet = await this.request("send_msg", payload, {
+      expected: ["send_ack", "send_nack", "error"],
+      timeoutMs: opts.timeoutMs ?? 3e4
+    });
+    if (packet.cmd !== "send_ack") {
+      throw this.packetError(packet);
+    }
+    return packet.payload;
+  }
+  async bindSessionRoute(channel2, accountId, routeSessionKey, sessionId, opts = {}) {
+    this.ensureReady();
+    const normalizedChannel = String(channel2 ?? "").trim().toLowerCase();
+    const normalizedAccountID = String(accountId ?? "").trim();
+    const normalizedRouteSessionKey = String(routeSessionKey ?? "").trim();
+    const normalizedSessionID = String(sessionId ?? "").trim();
+    if (!normalizedChannel || !normalizedAccountID || !normalizedRouteSessionKey || !normalizedSessionID) {
+      throw new Error("clawpool session_route_bind requires channel/account_id/route_session_key/session_id");
+    }
+    this.logInfo(
+      `session_route_bind request channel=${normalizedChannel} accountId=${normalizedAccountID} routeSessionKey=${normalizedRouteSessionKey} sessionId=${normalizedSessionID}`
+    );
+    const packet = await this.request(
+      "session_route_bind",
+      {
+        channel: normalizedChannel,
+        account_id: normalizedAccountID,
+        route_session_key: normalizedRouteSessionKey,
+        session_id: normalizedSessionID
+      },
+      {
+        expected: ["send_ack", "send_nack", "error"],
+        timeoutMs: opts.timeoutMs ?? 1e4
+      }
+    );
+    if (packet.cmd !== "send_ack") {
+      this.logWarn(
+        `session_route_bind nack channel=${normalizedChannel} accountId=${normalizedAccountID} routeSessionKey=${normalizedRouteSessionKey} sessionId=${normalizedSessionID}`
+      );
+      throw this.packetError(packet);
+    }
+    this.logInfo(
+      `session_route_bind ack channel=${normalizedChannel} accountId=${normalizedAccountID} routeSessionKey=${normalizedRouteSessionKey} sessionId=${normalizedSessionID}`
+    );
+    return packet.payload;
+  }
+  async resolveSessionRoute(channel2, accountId, routeSessionKey, opts = {}) {
+    this.ensureReady();
+    const normalizedChannel = String(channel2 ?? "").trim().toLowerCase();
+    const normalizedAccountID = String(accountId ?? "").trim();
+    const normalizedRouteSessionKey = String(routeSessionKey ?? "").trim();
+    if (!normalizedChannel || !normalizedAccountID || !normalizedRouteSessionKey) {
+      throw new Error("clawpool session_route_resolve requires channel/account_id/route_session_key");
+    }
+    this.logInfo(
+      `session_route_resolve request channel=${normalizedChannel} accountId=${normalizedAccountID} routeSessionKey=${normalizedRouteSessionKey}`
+    );
+    const packet = await this.request(
+      "session_route_resolve",
+      {
+        channel: normalizedChannel,
+        account_id: normalizedAccountID,
+        route_session_key: normalizedRouteSessionKey
+      },
+      {
+        expected: ["send_ack", "send_nack", "error"],
+        timeoutMs: opts.timeoutMs ?? 1e4
+      }
+    );
+    if (packet.cmd !== "send_ack") {
+      this.logWarn(
+        `session_route_resolve nack channel=${normalizedChannel} accountId=${normalizedAccountID} routeSessionKey=${normalizedRouteSessionKey}`
+      );
+      throw this.packetError(packet);
+    }
+    const payload = packet.payload;
+    const normalizedSessionID = String(payload.session_id ?? "").trim();
+    if (!normalizedSessionID) {
+      throw new Error("clawpool session_route_resolve ack missing session_id");
+    }
+    this.logInfo(
+      `session_route_resolve ack channel=${normalizedChannel} accountId=${normalizedAccountID} routeSessionKey=${normalizedRouteSessionKey} sessionId=${normalizedSessionID}`
+    );
+    return {
+      ...payload,
+      channel: String(payload.channel ?? normalizedChannel),
+      account_id: String(payload.account_id ?? normalizedAccountID),
+      route_session_key: String(payload.route_session_key ?? normalizedRouteSessionKey),
+      session_id: normalizedSessionID
+    };
+  }
+  async sendStreamChunk(sessionId, deltaContent, opts) {
+    this.ensureReady();
+    const normalizedDeltaContent = this.normalizeStreamDeltaContent(
+      opts.clientMsgId,
+      deltaContent,
+      opts.isFinish === true
+    );
+    if (!normalizedDeltaContent && !opts.isFinish) {
+      return;
+    }
+    const payload = {
+      session_id: sessionId,
+      client_msg_id: opts.clientMsgId,
+      delta_content: normalizedDeltaContent,
+      is_finish: opts.isFinish ?? false
+    };
+    if (opts.quotedMessageId) {
+      payload.quoted_message_id = opts.quotedMessageId;
+    }
+    if (opts.isFinish) {
+      const packet = await this.request("client_stream_chunk", payload, {
+        expected: ["send_ack", "send_nack", "error"],
+        timeoutMs: opts.timeoutMs ?? 2e4
+      });
+      if (packet.cmd !== "send_ack") {
+        throw this.packetError(packet);
+      }
+      return packet.payload;
+    }
+    this.sendPacket("client_stream_chunk", payload);
+  }
+  async deleteMessage(sessionId, msgId, opts = {}) {
+    this.ensureReady();
+    const normalizedSessionId = String(sessionId ?? "").trim();
+    if (!normalizedSessionId) {
+      throw new Error("clawpool delete_msg requires session_id");
+    }
+    const normalizedMsgId = String(msgId ?? "").trim();
+    if (!/^\d+$/.test(normalizedMsgId)) {
+      throw new Error("clawpool delete_msg requires numeric msg_id");
+    }
+    const packet = await this.request(
+      "delete_msg",
+      {
+        session_id: normalizedSessionId,
+        msg_id: normalizedMsgId
+      },
+      {
+        expected: ["send_ack", "send_nack", "error"],
+        timeoutMs: opts.timeoutMs ?? 2e4
+      }
+    );
+    if (packet.cmd !== "send_ack") {
+      throw this.packetError(packet);
+    }
+    return packet.payload;
+  }
+  ackEvent(eventId, payload = {}) {
+    this.ensureReady();
+    const normalizedEventId = String(eventId ?? "").trim();
+    if (!normalizedEventId) {
+      throw new Error("clawpool event_ack requires event_id");
+    }
+    const ackPayload = {
+      event_id: normalizedEventId,
+      received_at: Math.floor(payload.receivedAt ?? Date.now())
+    };
+    const sessionId = String(payload.sessionId ?? "").trim();
+    if (sessionId) {
+      ackPayload.session_id = sessionId;
+    }
+    const msgId = String(payload.msgId ?? "").trim();
+    if (/^\d+$/.test(msgId)) {
+      ackPayload.msg_id = msgId;
+    }
+    this.sendPacket("event_ack", ackPayload);
+  }
+  setSessionComposing(sessionId, active, opts = {}) {
+    this.ensureReady();
+    const normalizedSessionId = String(sessionId ?? "").trim();
+    if (!normalizedSessionId) {
+      throw new Error("clawpool session_activity_set requires session_id");
+    }
+    const payload = {
+      session_id: normalizedSessionId,
+      kind: "composing",
+      active
+    };
+    const refEventId = String(opts.refEventId ?? "").trim();
+    if (refEventId) {
+      payload.ref_event_id = refEventId;
+    }
+    const refMsgId = String(opts.refMsgId ?? "").trim();
+    if (/^\d+$/.test(refMsgId)) {
+      payload.ref_msg_id = refMsgId;
+    }
+    this.sendPacket("session_activity_set", payload);
+  }
+  async runLoop(abortSignal) {
+    let attempt = 0;
+    while (this.running && !abortSignal.aborted) {
+      let uptimeMs = 0;
+      let authRejected = false;
+      let shouldReconnect = true;
+      const cycle = attempt + 1;
+      try {
+        const outcome = await this.connectOnce(abortSignal, cycle);
+        uptimeMs = outcome.uptimeMs;
+        shouldReconnect = !outcome.aborted;
+        if (!outcome.aborted) {
+          const codeText = outcome.closeCode != null ? String(outcome.closeCode) : "-";
+          const reasonText = outcome.closeReason ? ` reason=${outcome.closeReason}` : "";
+          this.logWarn(
+            `websocket closed cause=${outcome.cause} code=${codeText}${reasonText} uptimeMs=${uptimeMs}`
+          );
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        authRejected = err instanceof AuthRejectedError;
+        this.updateStatus({
+          connected: false,
+          authed: false,
+          lastError: msg,
+          lastDisconnectAt: Date.now()
+        });
+        this.logConnectionError(msg);
+      }
+      if (!this.running || abortSignal.aborted || !shouldReconnect) {
+        break;
+      }
+      const stable = uptimeMs >= this.reconnectPolicy.stableConnectionMs;
+      if (stable) {
+        attempt = 0;
+      }
+      attempt += 1;
+      if (authRejected) {
+        attempt = Math.max(attempt, this.reconnectPolicy.authPenaltyAttemptFloor);
+      }
+      const penaltyFloor = this.consumeReconnectPenaltyAttemptFloor();
+      if (penaltyFloor > 0) {
+        attempt = Math.max(attempt, penaltyFloor);
+      }
+      const delay = this.resolveReconnectDelayMs(attempt);
+      this.logReconnectPlan({
+        delayMs: delay,
+        attempt,
+        stable,
+        authRejected,
+        penaltyFloor
+      });
+      await sleepWithAbort(delay, abortSignal);
+    }
+    this.stop();
+  }
+  async connectOnce(abortSignal, cycle) {
+    const connSerial = this.nextConnectionSerial();
+    this.logInfo(`websocket connect begin conn=${connSerial} cycle=${cycle}`);
+    const ws = await this.openWebSocket(this.account.wsUrl, abortSignal);
+    this.ws = ws;
+    const connectedAt = Date.now();
+    this.updateStatus({
+      connected: true,
+      authed: false,
+      lastError: null,
+      lastConnectAt: connectedAt
+    });
+    this.logInfo(`websocket connected conn=${connSerial}`);
+    const onMessage = (event) => {
+      void this.handleMessageEvent(event.data);
+    };
+    const onClose = () => {
+      this.stopKeepalive();
+      this.updateStatus({
+        connected: false,
+        authed: false,
+        lastDisconnectAt: Date.now()
+      });
+      this.rejectAllPending(new Error("clawpool websocket closed"));
+      if (this.ws === ws && ws.readyState !== WebSocket.OPEN) {
+        this.ws = null;
+      }
+    };
+    const onError = () => {
+      this.stopKeepalive();
+      this.updateStatus({
+        connected: false,
+        authed: false,
+        lastDisconnectAt: Date.now()
+      });
+      this.rejectAllPending(new Error("clawpool websocket error"));
+    };
+    ws.addEventListener("message", onMessage);
+    ws.addEventListener("close", onClose);
+    ws.addEventListener("error", onError);
+    try {
+      const auth = await this.authenticate(connSerial);
+      this.startKeepalive(ws, connSerial, auth.heartbeatSec);
+      const outcome = await this.waitForCloseOrAbort(ws, abortSignal);
+      return {
+        ...outcome,
+        uptimeMs: Math.max(0, Date.now() - connectedAt)
+      };
+    } catch (err) {
+      this.safeCloseSpecificWs(ws, "connect_once_error");
+      throw err;
+    } finally {
+      ws.removeEventListener("message", onMessage);
+      ws.removeEventListener("close", onClose);
+      ws.removeEventListener("error", onError);
+      this.stopKeepalive();
+      this.safeCloseSpecificWs(ws, "connect_once_finally");
+      this.logInfo(`websocket connect end conn=${connSerial}`);
+    }
+  }
+  async openWebSocket(url, abortSignal) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(url);
+      let done = false;
+      const timeoutMs = this.reconnectPolicy.connectTimeoutMs;
+      let timer = null;
+      const closeWs = () => {
+        try {
+          ws.close();
+        } catch {
+        }
+      };
+      const onOpen = () => {
+        finish(() => resolve(ws));
+      };
+      const onError = () => {
+        finish(() => reject(new Error("clawpool websocket connect failed")));
+      };
+      const onAbort = () => {
+        finish(() => {
+          closeWs();
+          reject(new Error("aborted"));
+        });
+      };
+      const finish = (fn) => {
+        if (done) {
+          return;
+        }
+        done = true;
+        if (timer) {
+          clearTimeout(timer);
+        }
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onError);
+        abortSignal.removeEventListener("abort", onAbort);
+        fn();
+      };
+      timer = setTimeout(() => {
+        finish(() => {
+          closeWs();
+          reject(new Error("clawpool websocket connect timeout"));
+        });
+      }, timeoutMs);
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onError);
+      abortSignal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  async waitForCloseOrAbort(ws, abortSignal) {
+    return new Promise((resolve) => {
+      let settled = false;
+      const closeWs = () => {
+        this.safeCloseSpecificWs(ws);
+      };
+      function finish(result) {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        ws.removeEventListener("close", onClose);
+        ws.removeEventListener("error", onError);
+        abortSignal.removeEventListener("abort", onAbort);
+        resolve(result);
+      }
+      function onClose(event) {
+        const close = event;
+        const code = Number(close.code);
+        finish({
+          cause: "close",
+          aborted: false,
+          closeCode: Number.isFinite(code) ? code : void 0,
+          closeReason: normalizeCloseReason(close.reason)
+        });
+      }
+      function onError() {
+        finish({
+          cause: "error",
+          aborted: false
+        });
+      }
+      function onAbort() {
+        closeWs();
+        finish({
+          cause: "abort",
+          aborted: true
+        });
+      }
+      ws.addEventListener("close", onClose);
+      ws.addEventListener("error", onError);
+      abortSignal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  async authenticate(connSerial) {
+    this.logInfo(`auth begin conn=${connSerial}`);
+    const packet = await this.request(
+      "auth",
+      {
+        agent_id: this.account.agentId,
+        api_key: this.account.apiKey,
+        client: "openclaw-clawpool"
+      },
+      {
+        expected: ["auth_ack"],
+        timeoutMs: 1e4,
+        requireAuthed: false
+      }
+    );
+    const payload = packet.payload ?? {};
+    const code = parseCode(payload);
+    if (code !== 0) {
+      throw new AuthRejectedError(code, parseMessage(payload));
+    }
+    const heartbeatSec = parseHeartbeatSec(payload);
+    const protocol = String(payload.protocol ?? "").trim() || void 0;
+    this.updateStatus({ authed: true, lastError: null });
+    this.logInfo(
+      `auth success conn=${connSerial} heartbeatSec=${heartbeatSec} protocol=${protocol ?? "-"}`
+    );
+    return {
+      heartbeatSec,
+      protocol
+    };
+  }
+  async handleMessageEvent(data) {
+    const text = await wsDataToText(data);
+    if (!text) {
+      return;
+    }
+    let packet;
+    try {
+      packet = JSON.parse(text);
+    } catch {
+      this.logWarn("ignored non-json message");
+      return;
+    }
+    const cmd = String(packet.cmd ?? "").trim();
+    const seq = Number(packet.seq ?? 0);
+    if (cmd === "ping") {
+      this.sendPacket("pong", { ts: Date.now() }, seq > 0 ? seq : void 0, false);
+      return;
+    }
+    if (cmd === "event_msg") {
+      this.callbacks.onEventMsg?.(packet.payload);
+      return;
+    }
+    if (cmd === "event_react") {
+      this.callbacks.onEventReact?.(packet.payload);
+      return;
+    }
+    if (cmd === "event_revoke") {
+      this.callbacks.onEventRevoke?.(packet.payload);
+      return;
+    }
+    if (cmd === "kicked") {
+      const payload = packet.payload ?? {};
+      const reason = parseKickedReason(payload);
+      if (reason === "replaced_by_new_connection") {
+        this.reconnectPenaltyAttemptFloor = Math.max(
+          this.reconnectPenaltyAttemptFloor,
+          this.reconnectPolicy.fastRetryDelaysMs.length + 5
+        );
+        this.logWarn(
+          `apply reconnect penalty for kicked replacement penaltyFloor=${this.reconnectPenaltyAttemptFloor}`
+        );
+      }
+      this.logWarn(`connection kicked by server reason=${reason}`);
+      this.safeCloseWs("kicked_by_server");
+      return;
+    }
+    const pending = this.pending.get(seq);
+    if (pending && pending.expected.has(cmd)) {
+      this.pending.delete(seq);
+      clearTimeout(pending.timer);
+      pending.resolve(packet);
+      return;
+    }
+  }
+  ensureReady(requireAuthed = true) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("clawpool websocket is not open");
+    }
+    if (requireAuthed && !this.status.authed) {
+      throw new Error("clawpool websocket is not authed");
+    }
+  }
+  nextSeq() {
+    this.seq += 1;
+    return this.seq;
+  }
+  sendPacket(cmd, payload, seq, requireAuthed = true) {
+    this.ensureReady(requireAuthed);
+    const outSeq = seq ?? this.nextSeq();
+    const packet = {
+      cmd,
+      seq: outSeq,
+      payload
+    };
+    this.ws?.send(JSON.stringify(packet));
+    return outSeq;
+  }
+  async request(cmd, payload, opts) {
+    this.ensureReady(opts.requireAuthed ?? true);
+    const seq = this.nextSeq();
+    const expected = new Set(opts.expected);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(seq);
+        reject(new Error(`${cmd} timeout`));
+      }, opts.timeoutMs);
+      this.pending.set(seq, {
+        expected,
+        resolve,
+        reject,
+        timer
+      });
+      try {
+        const packet = {
+          cmd,
+          seq,
+          payload
+        };
+        this.ws?.send(JSON.stringify(packet));
+      } catch (err) {
+        this.pending.delete(seq);
+        clearTimeout(timer);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  rejectAllPending(err) {
+    const pendingCount = this.pending.size;
+    if (pendingCount > 0) {
+      this.logWarn(`reject pending requests count=${pendingCount} reason=${err.message}`);
+    }
+    for (const [seq, pending] of this.pending.entries()) {
+      this.pending.delete(seq);
+      clearTimeout(pending.timer);
+      pending.reject(err);
+    }
+  }
+  packetError(packet) {
+    const payload = packet.payload;
+    const code = Number(payload.code ?? 0);
+    const msg = String(payload.msg ?? packet.cmd ?? "unknown error");
+    return new Error(`clawpool ${packet.cmd}: code=${code} msg=${msg}`);
+  }
+  normalizeStreamDeltaContent(clientMsgId, deltaContent, isFinish) {
+    const carry = this.pendingStreamHighSurrogate.get(clientMsgId) ?? "";
+    this.pendingStreamHighSurrogate.delete(clientMsgId);
+    let normalized = `${carry}${String(deltaContent ?? "")}`;
+    if (!normalized) {
+      return "";
+    }
+    if (isFinish && !deltaContent && carry) {
+      this.logWarn(`dropping dangling high surrogate at stream finish clientMsgId=${clientMsgId}`);
+      return "";
+    }
+    if (!isFinish && this.endsWithHighSurrogate(normalized)) {
+      this.pendingStreamHighSurrogate.set(clientMsgId, normalized.slice(-1));
+      normalized = normalized.slice(0, -1);
+    } else if (isFinish && this.endsWithHighSurrogate(normalized)) {
+      this.logWarn(`dropping dangling high surrogate at stream finish clientMsgId=${clientMsgId}`);
+      normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+  }
+  endsWithHighSurrogate(value) {
+    if (!value) {
+      return false;
+    }
+    const code = value.charCodeAt(value.length - 1);
+    return code >= 55296 && code <= 56319;
+  }
+  nextConnectionSerial() {
+    this.connectionSerial += 1;
+    return this.connectionSerial;
+  }
+  resolveKeepalivePolicy(heartbeatSec) {
+    const defaultIntervalMs = Math.max(5e3, Math.min(2e4, Math.floor(heartbeatSec * 1e3 / 2)));
+    const intervalMs = clampInt(
+      this.account.config.keepalivePingMs,
+      defaultIntervalMs,
+      2e3,
+      6e4
+    );
+    const defaultTimeoutMs = Math.max(3e3, Math.min(15e3, Math.floor(intervalMs * 0.8)));
+    const timeoutMs = clampInt(
+      this.account.config.keepaliveTimeoutMs,
+      defaultTimeoutMs,
+      1e3,
+      6e4
+    );
+    return {
+      intervalMs,
+      timeoutMs
+    };
+  }
+  startKeepalive(ws, connSerial, heartbeatSec) {
+    this.stopKeepalive();
+    const policy = this.resolveKeepalivePolicy(heartbeatSec);
+    this.logInfo(
+      `keepalive start conn=${connSerial} intervalMs=${policy.intervalMs} timeoutMs=${policy.timeoutMs} serverHeartbeatSec=${heartbeatSec}`
+    );
+    this.keepaliveTimer = setInterval(() => {
+      void this.runKeepaliveProbe(ws, connSerial, policy.timeoutMs);
+    }, policy.intervalMs);
+  }
+  stopKeepalive() {
+    if (this.keepaliveTimer) {
+      clearInterval(this.keepaliveTimer);
+      this.keepaliveTimer = null;
+    }
+    this.keepaliveInFlight = false;
+  }
+  async runKeepaliveProbe(ws, connSerial, timeoutMs) {
+    if (!this.running || this.ws !== ws || ws.readyState !== WebSocket.OPEN || !this.status.authed) {
+      return;
+    }
+    if (this.keepaliveInFlight) {
+      this.logWarn(`keepalive overlap detected conn=${connSerial}, force reconnect`);
+      this.safeCloseSpecificWs(ws, "keepalive_overlap");
+      return;
+    }
+    this.keepaliveInFlight = true;
+    const startedAt = Date.now();
+    try {
+      await this.request(
+        "ping",
+        {
+          ts: startedAt,
+          source: "clawpool_keepalive"
+        },
+        {
+          expected: ["pong"],
+          timeoutMs
+        }
+      );
+      const latencyMs = Math.max(0, Date.now() - startedAt);
+      if (latencyMs >= 2e3) {
+        this.logWarn(`keepalive high latency conn=${connSerial} latencyMs=${latencyMs}`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.logWarn(`keepalive failed conn=${connSerial} err=${msg}, force reconnect`);
+      if (this.ws === ws) {
+        this.safeCloseSpecificWs(ws, "keepalive_probe_failed");
+      }
+    } finally {
+      this.keepaliveInFlight = false;
+    }
+  }
+  resolveReconnectDelayMs(attempt) {
+    if (attempt <= 0) {
+      return 0;
+    }
+    const fastRetryDelays = this.reconnectPolicy.fastRetryDelaysMs;
+    if (attempt <= fastRetryDelays.length) {
+      return fastRetryDelays[attempt - 1] ?? this.reconnectPolicy.baseDelayMs;
+    }
+    const exponent = attempt - fastRetryDelays.length - 1;
+    const uncapped = this.reconnectPolicy.baseDelayMs * 2 ** exponent;
+    const capped = Math.min(this.reconnectPolicy.maxDelayMs, Math.floor(uncapped));
+    const jitterFloor = Math.max(100, Math.floor(capped * 0.5));
+    return randomIntInclusive(jitterFloor, capped);
+  }
+  consumeReconnectPenaltyAttemptFloor() {
+    const floor = this.reconnectPenaltyAttemptFloor;
+    this.reconnectPenaltyAttemptFloor = 0;
+    return floor;
+  }
+  safeCloseSpecificWs(ws, reason = "") {
+    try {
+      ws.close();
+    } catch {
+    }
+    if (this.ws === ws) {
+      this.ws = null;
+    }
+  }
+  safeCloseWs(reason = "") {
+    if (!this.ws) {
+      return;
+    }
+    this.safeCloseSpecificWs(this.ws, reason);
+  }
+  updateStatus(patch) {
+    this.status = {
+      ...this.status,
+      ...patch
+    };
+    this.callbacks.onStatus?.(this.getStatus());
+  }
+};
+var activeClients = /* @__PURE__ */ new Map();
+function setActiveAibotClient(accountId, client) {
+  if (!accountId) {
+    return;
+  }
+  if (!client) {
+    activeClients.delete(accountId);
+    return;
+  }
+  activeClients.set(accountId, client);
+}
+function clearActiveAibotClient(accountId, client) {
+  if (!accountId) {
+    return;
+  }
+  if (activeClients.get(accountId) !== client) {
+    return;
+  }
+  activeClients.delete(accountId);
+}
+function getActiveAibotClient(accountId) {
+  if (!accountId) {
+    return null;
+  }
+  return activeClients.get(accountId) ?? null;
+}
+function requireActiveAibotClient(accountId) {
+  const client = getActiveAibotClient(accountId);
+  if (!client) {
+    throw new Error(
+      `clawpool account "${accountId}" is not connected; start the gateway channel runtime first`
+    );
+  }
+  return client;
+}
+
+// src/actions.ts
+var SUPPORTED_AIBOT_MESSAGE_ACTIONS = /* @__PURE__ */ new Set(["unsend", "delete"]);
+function toSnakeCaseKey(key) {
+  return key.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function readStringishParam(params, key) {
+  const value = readStringParam(params, key);
+  if (value) {
+    return value;
+  }
+  const snakeKey = toSnakeCaseKey(key);
+  const raw = (Object.hasOwn(params, key) ? params[key] : void 0) ?? (snakeKey !== key && Object.hasOwn(params, snakeKey) ? params[snakeKey] : void 0);
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return String(raw);
+  }
+  return void 0;
+}
+function resolveDeleteSessionId(params) {
+  const direct = readStringParam(params.params, "sessionId") ?? readStringParam(params.params, "to") ?? params.currentChannelId;
+  return normalizeAibotSessionTarget(direct ?? "");
+}
+var aibotMessageActions = {
+  listActions: ({ cfg }) => {
+    const hasConfiguredAccount = listAibotAccountIds(cfg).map((accountId) => resolveAibotAccount({ cfg, accountId })).some((account) => account.enabled && account.configured);
+    if (!hasConfiguredAccount) {
+      return [];
+    }
+    return ["unsend"];
+  },
+  supportsAction: ({ action }) => SUPPORTED_AIBOT_MESSAGE_ACTIONS.has(action),
+  handleAction: async ({ action, params, cfg, accountId, toolContext }) => {
+    if (!SUPPORTED_AIBOT_MESSAGE_ACTIONS.has(action)) {
+      throw new Error(`Clawpool action ${action} is not supported`);
+    }
+    const account = resolveAibotAccount({ cfg, accountId });
+    const client = requireActiveAibotClient(account.accountId);
+    const messageId = readStringishParam(params, "messageId") ?? readStringishParam(params, "msgId");
+    if (!messageId) {
+      throw new Error("Clawpool unsend requires messageId.");
+    }
+    const sessionId = resolveDeleteSessionId({
+      params,
+      currentChannelId: toolContext?.currentChannelId
+    });
+    if (!sessionId) {
+      throw new Error(
+        "Clawpool unsend requires sessionId or to, or must be used inside an active Clawpool conversation."
+      );
+    }
+    const ack = await client.deleteMessage(sessionId, messageId);
+    return jsonResult({
+      ok: true,
+      deleted: true,
+      unsent: action === "unsend",
+      messageId: String(ack.msg_id ?? messageId),
+      sessionId: String(ack.session_id ?? sessionId)
+    });
+  }
+};
+
+// src/monitor.ts
+import {
+  createReplyPrefixOptions,
+  resolveOutboundMediaUrls,
+  sendMediaWithLeadingCaption
+} from "openclaw/plugin-sdk";
+
+// src/reply-text-guard.ts
+var NETWORK_ERROR_MESSAGE = "\u4E0A\u6E38\u670D\u52A1\u7F51\u7EDC\u5F02\u5E38\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+var TIMEOUT_MESSAGE = "\u4E0A\u6E38\u670D\u52A1\u54CD\u5E94\u8D85\u65F6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+var CONTEXT_OVERFLOW_MESSAGE = "\u5F53\u524D\u4F1A\u8BDD\u4E0A\u4E0B\u6587\u8FC7\u957F\uFF0C\u8BF7\u65B0\u5F00\u4F1A\u8BDD\u540E\u91CD\u8BD5\u3002";
+var GENERIC_STOP_MESSAGE = "\u4E0A\u6E38\u670D\u52A1\u5F02\u5E38\u4E2D\u65AD\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+function guardInternalReplyText(rawText) {
+  const normalized = String(rawText ?? "").trim();
+  if (!normalized) {
+    return null;
+  }
+  if (/^Unhandled stop reason:\s*network_error$/i.test(normalized)) {
+    return {
+      code: "upstream_network_error",
+      rawText: normalized,
+      userText: NETWORK_ERROR_MESSAGE
+    };
+  }
+  if (/^LLM request timed out\.?$/i.test(normalized)) {
+    return {
+      code: "upstream_timeout",
+      rawText: normalized,
+      userText: TIMEOUT_MESSAGE
+    };
+  }
+  if (normalized.startsWith("Context overflow: prompt too large for the model.")) {
+    return {
+      code: "upstream_context_overflow",
+      rawText: normalized,
+      userText: CONTEXT_OVERFLOW_MESSAGE
+    };
+  }
+  if (/^Unhandled stop reason:\s*[a-z0-9_]+$/i.test(normalized)) {
+    return {
+      code: "upstream_stop_reason",
+      rawText: normalized,
+      userText: GENERIC_STOP_MESSAGE
+    };
+  }
+  return null;
+}
+
+// src/upstream-retry.ts
+var DEFAULT_UPSTREAM_RETRY_MAX_ATTEMPTS = 3;
+var DEFAULT_UPSTREAM_RETRY_BASE_DELAY_MS = 300;
+var DEFAULT_UPSTREAM_RETRY_MAX_DELAY_MS = 2e3;
+function clampInt2(value, fallback, min, max) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) {
+    return fallback;
+  }
+  return Math.max(min, Math.min(max, Math.floor(n)));
+}
+function resolveUpstreamRetryPolicy(account) {
+  const maxAttempts = clampInt2(
+    account.config.upstreamRetryMaxAttempts,
+    DEFAULT_UPSTREAM_RETRY_MAX_ATTEMPTS,
+    1,
+    5
+  );
+  const baseDelayMs = clampInt2(
+    account.config.upstreamRetryBaseDelayMs,
+    DEFAULT_UPSTREAM_RETRY_BASE_DELAY_MS,
+    0,
+    1e4
+  );
+  const maxDelayMs = clampInt2(
+    account.config.upstreamRetryMaxDelayMs,
+    DEFAULT_UPSTREAM_RETRY_MAX_DELAY_MS,
+    baseDelayMs,
+    3e4
+  );
+  return {
+    maxAttempts,
+    baseDelayMs,
+    maxDelayMs
+  };
+}
+function isRetryableGuardedReply(guarded) {
+  if (!guarded) {
+    return false;
+  }
+  return guarded.code === "upstream_network_error" || guarded.code === "upstream_timeout";
+}
+function resolveUpstreamRetryDelayMs(policy, attempt) {
+  if (attempt <= 0) {
+    return 0;
+  }
+  const exponent = Math.max(0, attempt - 1);
+  const delay = policy.baseDelayMs * 2 ** exponent;
+  return Math.min(policy.maxDelayMs, Math.floor(delay));
+}
+
+// src/runtime.ts
+var runtime = null;
+function setAibotRuntime(next) {
+  runtime = next;
+}
+function getAibotRuntime() {
+  if (!runtime) {
+    throw new Error("Aibot runtime not initialized");
+  }
+  return runtime;
+}
+
+// src/quoted-reply-body.ts
+function buildBodyWithQuotedReplyId(rawBody, quotedMessageId) {
+  if (!quotedMessageId) {
+    return rawBody;
+  }
+  return `[quoted_message_id=${quotedMessageId}]
+${rawBody}`;
+}
+
+// src/monitor.ts
+var activeMonitorClients = /* @__PURE__ */ new Map();
+function registerActiveMonitor(accountId, client) {
+  if (!accountId) {
+    return null;
+  }
+  const previous = activeMonitorClients.get(accountId) ?? null;
+  activeMonitorClients.set(accountId, client);
+  return previous === client ? null : previous;
+}
+function isActiveMonitor(accountId, client) {
+  if (!accountId) {
+    return false;
+  }
+  return activeMonitorClients.get(accountId) === client;
+}
+function clearActiveMonitor(accountId, client) {
+  if (!accountId) {
+    return;
+  }
+  if (activeMonitorClients.get(accountId) !== client) {
+    return;
+  }
+  activeMonitorClients.delete(accountId);
+}
+function toStringId(value) {
+  const text = String(value ?? "").trim();
+  return text;
+}
+function toTimestampMs(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) {
+    return void 0;
+  }
+  if (n < 1e12) {
+    return Math.floor(n * 1e3);
+  }
+  return Math.floor(n);
+}
+function normalizeNumericMessageId(value) {
+  const raw = toStringId(value);
+  if (!raw) {
+    return void 0;
+  }
+  return /^\d+$/.test(raw) ? raw : void 0;
+}
+function resolveStreamChunkChars(account) {
+  return Math.max(1, account.config.streamChunkChars ?? 48);
+}
+function resolveStreamChunkDelayMs(account) {
+  return Math.max(0, Math.floor(account.config.streamChunkDelayMs ?? 0));
+}
+function resolveStreamFinishDelayMs(account) {
+  return resolveStreamChunkDelayMs(account);
+}
+function sleep(ms) {
+  if (ms <= 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function endsWithHighSurrogate(value) {
+  if (!value) {
+    return false;
+  }
+  const code = value.charCodeAt(value.length - 1);
+  return code >= 55296 && code <= 56319;
+}
+function startsWithLowSurrogate(value) {
+  if (!value) {
+    return false;
+  }
+  const code = value.charCodeAt(0);
+  return code >= 56320 && code <= 57343;
+}
+function splitTextByLengthPreserveContent(text, maxChars) {
+  const source = String(text ?? "");
+  if (!source) {
+    return [];
+  }
+  const limit = Math.max(1, Math.floor(maxChars));
+  const chunks = [];
+  let cursor = 0;
+  while (cursor < source.length) {
+    let end = Math.min(source.length, cursor + limit);
+    if (end < source.length) {
+      const tail = source.slice(cursor, end);
+      const head = source.slice(end, end + 1);
+      if (endsWithHighSurrogate(tail) && startsWithLowSurrogate(head)) {
+        end++;
+      }
+    }
+    const chunk = source.slice(cursor, end);
+    if (!chunk) {
+      break;
+    }
+    chunks.push(chunk);
+    cursor = end;
+  }
+  return chunks;
+}
+function buildEventLogContext(params) {
+  const parts = [
+    `eventId=${params.eventId || "-"}`,
+    `sessionId=${params.sessionId}`,
+    `messageSid=${params.messageSid}`
+  ];
+  if (params.clientMsgId) {
+    parts.push(`clientMsgId=${params.clientMsgId}`);
+  }
+  if (params.outboundCounter !== void 0) {
+    parts.push(`outboundCounter=${params.outboundCounter}`);
+  }
+  return parts.join(" ");
+}
+async function deliverAibotStreamBlock(params) {
+  const chunks = splitTextByLengthPreserveContent(params.text, resolveStreamChunkChars(params.account));
+  const chunkDelayMs = resolveStreamChunkDelayMs(params.account);
+  let didSend = false;
+  const context = buildEventLogContext({
+    eventId: params.eventId,
+    sessionId: params.sessionId,
+    messageSid: params.messageSid,
+    clientMsgId: params.clientMsgId
+  });
+  params.runtime.log(
+    `[clawpool:${params.account.accountId}] stream block split into ${chunks.length} chunk(s) ${context} textLen=${params.text.length} chunkDelayMs=${chunkDelayMs}`
+  );
+  for (let index = 0; index < chunks.length; index++) {
+    const chunk = chunks[index];
+    const normalized = String(chunk ?? "");
+    if (!normalized) {
+      continue;
+    }
+    params.runtime.log(
+      `[clawpool:${params.account.accountId}] stream chunk send ${context} chunkIndex=${index + 1}/${chunks.length} deltaLen=${normalized.length}`
+    );
+    await params.client.sendStreamChunk(params.sessionId, normalized, {
+      clientMsgId: params.clientMsgId,
+      quotedMessageId: params.quotedMessageId,
+      isFinish: false
+    });
+    didSend = true;
+    params.statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+    if (chunkDelayMs > 0 && index < chunks.length - 1) {
+      await sleep(chunkDelayMs);
+    }
+  }
+  return didSend;
+}
+async function deliverAibotMessage(params) {
+  const { payload, client, account, sessionId, quotedMessageId, runtime: runtime2, statusSink, stableClientMsgId } = params;
+  const core = getAibotRuntime();
+  const tableMode = params.tableMode ?? "code";
+  const text = core.channel.text.convertMarkdownTables(payload.text ?? "", tableMode);
+  const mediaSent = await sendMediaWithLeadingCaption({
+    mediaUrls: resolveOutboundMediaUrls(payload),
+    caption: text,
+    send: async ({ mediaUrl, caption }) => {
+      await client.sendMedia(sessionId, mediaUrl, caption ?? "", {
+        quotedMessageId,
+        clientMsgId: stableClientMsgId ? `${stableClientMsgId}_media` : void 0
+      });
+      statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+    },
+    onError: (error) => {
+      runtime2.error(`clawpool media send failed: ${String(error)}`);
+      statusSink?.({ lastError: String(error) });
+    }
+  });
+  if (mediaSent) {
+    return true;
+  }
+  if (!text) {
+    return false;
+  }
+  const maxChunkChars = Math.max(1, account.config.maxChunkChars ?? 1200);
+  const chunks = splitTextByLengthPreserveContent(text, maxChunkChars);
+  let chunkIndex = 0;
+  for (const chunk of chunks) {
+    chunkIndex++;
+    const normalized = String(chunk ?? "");
+    if (!normalized) {
+      continue;
+    }
+    await client.sendText(sessionId, normalized, {
+      quotedMessageId,
+      clientMsgId: stableClientMsgId ? `${stableClientMsgId}_chunk${chunkIndex}` : void 0
+    });
+    statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+  }
+  return true;
+}
+async function bindSessionRouteMapping(params) {
+  const routeSessionKey = String(params.routeSessionKey ?? "").trim();
+  const sessionId = String(params.sessionId ?? "").trim();
+  if (!routeSessionKey || !sessionId) {
+    return;
+  }
+  try {
+    params.runtime.log(
+      `[clawpool:${params.account.accountId}] session route bind begin routeSessionKey=${routeSessionKey} sessionId=${sessionId}`
+    );
+    await params.client.bindSessionRoute(
+      "clawpool",
+      params.account.accountId,
+      routeSessionKey,
+      sessionId
+    );
+    params.runtime.log(
+      `[clawpool:${params.account.accountId}] session route bind success routeSessionKey=${routeSessionKey} sessionId=${sessionId}`
+    );
+  } catch (err) {
+    const reason = `clawpool session route bind failed routeSessionKey=${routeSessionKey} sessionId=${sessionId}: ${String(err)}`;
+    params.runtime.error(`[clawpool:${params.account.accountId}] ${reason}`);
+    params.statusSink?.({ lastError: reason });
+  }
+}
+async function processEvent(params) {
+  const { event, account, config, runtime: runtime2, client, statusSink } = params;
+  const core = getAibotRuntime();
+  const sessionId = toStringId(event.session_id);
+  const messageSid = toStringId(event.msg_id);
+  const rawBody = String(event.content ?? "").trim();
+  if (!sessionId || !messageSid || !rawBody) {
+    const reason = `invalid event_msg payload: session_id=${sessionId || "<empty>"} msg_id=${messageSid || "<empty>"}`;
+    runtime2.error(`[clawpool:${account.accountId}] ${reason}`);
+    statusSink?.({ lastError: reason });
+    return;
+  }
+  const eventId = toStringId(event.event_id);
+  const quotedMessageId = normalizeNumericMessageId(event.quoted_message_id);
+  const bodyForAgent = buildBodyWithQuotedReplyId(rawBody, quotedMessageId);
+  const senderId = toStringId(event.sender_id);
+  const isGroup = Number(event.session_type ?? 0) === 2 || String(event.event_type ?? "").startsWith("group_");
+  const chatType = isGroup ? "group" : "direct";
+  const createdAt = toTimestampMs(event.created_at);
+  const baseLogContext = buildEventLogContext({
+    eventId,
+    sessionId,
+    messageSid
+  });
+  runtime2.log(
+    `[clawpool:${account.accountId}] inbound event ${baseLogContext} chatType=${chatType} bodyLen=${rawBody.length} quotedMessageId=${quotedMessageId || "-"}`
+  );
+  const route = core.channel.routing.resolveAgentRoute({
+    cfg: config,
+    channel: "clawpool",
+    accountId: account.accountId,
+    peer: {
+      kind: isGroup ? "group" : "direct",
+      id: sessionId
+    }
+  });
+  const storePath = core.channel.session.resolveStorePath(config.session?.store, {
+    agentId: route.agentId
+  });
+  const previousTimestamp = core.channel.session.readSessionUpdatedAt({
+    storePath,
+    sessionKey: route.sessionKey
+  });
+  const fromLabel = isGroup ? `group:${sessionId}/${senderId || "unknown"}` : `user:${senderId || "unknown"}`;
+  const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(config);
+  const body = core.channel.reply.formatAgentEnvelope({
+    channel: "Clawpool",
+    from: fromLabel,
+    timestamp: createdAt,
+    previousTimestamp,
+    envelope: envelopeOptions,
+    body: bodyForAgent
+  });
+  const from = isGroup ? `clawpool:group:${sessionId}:${senderId || "unknown"}` : `clawpool:${senderId || "unknown"}`;
+  const to = `clawpool:${sessionId}`;
+  const ctxPayload = core.channel.reply.finalizeInboundContext({
+    Body: body,
+    BodyForAgent: bodyForAgent,
+    RawBody: rawBody,
+    CommandBody: rawBody,
+    // Clawpool inbound text is end-user chat content; do not parse it as OpenClaw slash/bang commands.
+    BodyForCommands: "",
+    From: from,
+    To: to,
+    SessionKey: route.sessionKey,
+    AccountId: route.accountId,
+    ChatType: chatType,
+    ConversationLabel: fromLabel,
+    SenderName: senderId || void 0,
+    SenderId: senderId || void 0,
+    CommandAuthorized: false,
+    Provider: "clawpool",
+    Surface: "clawpool",
+    MessageSid: messageSid,
+    // This field carries the inbound quoted message id from end user (event.quoted_message_id).
+    // It is not the outbound reply anchor used when plugin sends replies back to Aibot.
+    ReplyToMessageSid: quotedMessageId,
+    OriginatingChannel: "clawpool",
+    OriginatingTo: to
+  });
+  const routeSessionKey = ctxPayload.SessionKey ?? route.sessionKey;
+  await core.channel.session.recordInboundSession({
+    storePath,
+    sessionKey: routeSessionKey,
+    ctx: ctxPayload,
+    onRecordError: (err) => runtime2.error(`clawpool session meta update failed: ${String(err)}`)
+  });
+  await bindSessionRouteMapping({
+    client,
+    account,
+    runtime: runtime2,
+    sessionId,
+    routeSessionKey,
+    statusSink: statusSink ? (patch) => statusSink({ lastError: patch.lastError }) : void 0
+  });
+  if (eventId) {
+    try {
+      client.ackEvent(eventId, {
+        sessionId,
+        msgId: messageSid,
+        receivedAt: Date.now()
+      });
+    } catch (err) {
+      runtime2.error(`[clawpool:${account.accountId}] event ack failed eventId=${eventId}: ${String(err)}`);
+      statusSink?.({ lastError: String(err) });
+    }
+  }
+  const outboundQuotedMessageId = normalizeNumericMessageId(event.msg_id);
+  const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+    cfg: config,
+    agentId: route.agentId,
+    channel: "clawpool",
+    accountId: account.accountId
+  });
+  const tableMode = core.channel.text.resolveMarkdownTableMode({
+    cfg: config,
+    channel: "clawpool",
+    accountId: account.accountId
+  });
+  const streamClientMsgId = `reply_${messageSid}_stream`;
+  const retryPolicy = resolveUpstreamRetryPolicy(account);
+  let composingSet = false;
+  const setComposing = (active) => {
+    try {
+      client.setSessionComposing(sessionId, active, {
+        refEventId: eventId || void 0,
+        refMsgId: outboundQuotedMessageId
+      });
+      composingSet = active;
+      statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+    } catch (err) {
+      runtime2.error(
+        `[clawpool:${account.accountId}] session activity update failed eventId=${eventId || "-"} sessionId=${sessionId} active=${active}: ${String(err)}`
+      );
+      statusSink?.({ lastError: String(err) });
+    }
+  };
+  setComposing(true);
+  try {
+    for (let attempt = 1; attempt <= retryPolicy.maxAttempts; attempt++) {
+      let hasSentBlock = false;
+      let outboundCounter = 0;
+      let attemptHasOutbound = false;
+      let retryGuardedText = null;
+      const attemptLabel = `${attempt}/${retryPolicy.maxAttempts}`;
+      const finishStreamIfNeeded = async () => {
+        if (!hasSentBlock) {
+          return;
+        }
+        hasSentBlock = false;
+        try {
+          const finishContext = buildEventLogContext({
+            eventId,
+            sessionId,
+            messageSid,
+            clientMsgId: streamClientMsgId
+          });
+          const finishDelayMs = resolveStreamFinishDelayMs(account);
+          if (finishDelayMs > 0) {
+            runtime2.log(
+              `[clawpool:${account.accountId}] stream finish delay ${finishContext} delayMs=${finishDelayMs}`
+            );
+            await sleep(finishDelayMs);
+          }
+          runtime2.log(
+            `[clawpool:${account.accountId}] stream finish ${finishContext}`
+          );
+          await client.sendStreamChunk(sessionId, "", {
+            clientMsgId: streamClientMsgId,
+            quotedMessageId: outboundQuotedMessageId,
+            isFinish: true
+          });
+          attemptHasOutbound = true;
+          statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+        } catch (err) {
+          runtime2.error(`[clawpool:${account.accountId}] stream finish failed: ${String(err)}`);
+          statusSink?.({ lastError: String(err) });
+        }
+      };
+      const dispatchResult = await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: ctxPayload,
+        cfg: config,
+        dispatcherOptions: {
+          ...prefixOptions,
+          deliver: async (payload, info) => {
+            outboundCounter++;
+            const outPayload = payload;
+            const guardedText = guardInternalReplyText(String(outPayload.text ?? ""));
+            const normalizedPayload = guardedText ? { ...outPayload, text: guardedText.userText } : outPayload;
+            const hasMedia = Boolean(normalizedPayload.mediaUrl) || (normalizedPayload.mediaUrls?.length ?? 0) > 0;
+            const text = core.channel.text.convertMarkdownTables(normalizedPayload.text ?? "", tableMode);
+            const streamedTextAlreadyVisible = hasSentBlock;
+            const deliverContext = buildEventLogContext({
+              eventId,
+              sessionId,
+              messageSid,
+              clientMsgId: info.kind === "block" ? streamClientMsgId : `reply_${messageSid}_${outboundCounter}`,
+              outboundCounter
+            });
+            runtime2.log(
+              `[clawpool:${account.accountId}] deliver ${deliverContext} kind=${info.kind} textLen=${text.length} hasMedia=${hasMedia} streamedBefore=${streamedTextAlreadyVisible}`
+            );
+            if (guardedText) {
+              runtime2.error(
+                `[clawpool:${account.accountId}] rewrite internal reply text ${deliverContext} code=${guardedText.code} raw=${JSON.stringify(guardedText.rawText)}`
+              );
+            }
+            if (guardedText && retryGuardedText == null && isRetryableGuardedReply(guardedText) && !attemptHasOutbound && !hasSentBlock) {
+              retryGuardedText = guardedText;
+              runtime2.log(
+                `[clawpool:${account.accountId}] defer guarded upstream reply for retry ${deliverContext} attempt=${attemptLabel} code=${guardedText.code}`
+              );
+              return;
+            }
+            if (retryGuardedText && !attemptHasOutbound && !hasSentBlock) {
+              runtime2.log(
+                `[clawpool:${account.accountId}] skip outbound while retry pending ${deliverContext} attempt=${attemptLabel} code=${retryGuardedText.code}`
+              );
+              return;
+            }
+            if (info.kind === "block" && !guardedText && !hasMedia && text) {
+              const didSendBlock = await deliverAibotStreamBlock({
+                text,
+                client,
+                account,
+                sessionId,
+                eventId,
+                messageSid,
+                quotedMessageId: outboundQuotedMessageId,
+                clientMsgId: streamClientMsgId,
+                runtime: runtime2,
+                statusSink
+              });
+              hasSentBlock = hasSentBlock || didSendBlock;
+              attemptHasOutbound = attemptHasOutbound || didSendBlock;
+              return;
+            }
+            await finishStreamIfNeeded();
+            if (info.kind === "final" && streamedTextAlreadyVisible && !hasMedia && text) {
+              runtime2.log(
+                `[clawpool:${account.accountId}] skip final text after streamed block ${deliverContext} textLen=${text.length}`
+              );
+              return;
+            }
+            const stableClientMsgId = `reply_${messageSid}_${outboundCounter}`;
+            runtime2.log(
+              `[clawpool:${account.accountId}] deliver message ${buildEventLogContext({
+                eventId,
+                sessionId,
+                messageSid,
+                clientMsgId: stableClientMsgId,
+                outboundCounter
+              })} textLen=${text.length} hasMedia=${hasMedia}`
+            );
+            const didSendMessage = await deliverAibotMessage({
+              payload: normalizedPayload,
+              client,
+              account,
+              sessionId,
+              quotedMessageId: outboundQuotedMessageId,
+              runtime: runtime2,
+              statusSink,
+              stableClientMsgId,
+              tableMode
+            });
+            attemptHasOutbound = attemptHasOutbound || didSendMessage;
+          },
+          onError: (err, info) => {
+            runtime2.error(`[clawpool:${account.accountId}] ${info.kind} reply failed: ${String(err)}`);
+            statusSink?.({ lastError: String(err) });
+          }
+        },
+        replyOptions: {
+          onModelSelected
+        }
+      });
+      runtime2.log(
+        `[clawpool:${account.accountId}] dispatch complete ${baseLogContext} attempt=${attemptLabel} queuedFinal=${dispatchResult.queuedFinal} counts=${JSON.stringify(dispatchResult.counts)}`
+      );
+      await finishStreamIfNeeded();
+      if (retryGuardedText && !attemptHasOutbound) {
+        if (attempt < retryPolicy.maxAttempts) {
+          const delayMs = resolveUpstreamRetryDelayMs(retryPolicy, attempt);
+          runtime2.error(
+            `[clawpool:${account.accountId}] upstream guarded reply retry ${baseLogContext} code=${retryGuardedText.code} attempt=${attemptLabel} next=${attempt + 1}/${retryPolicy.maxAttempts} delayMs=${delayMs}`
+          );
+          if (delayMs > 0) {
+            await sleep(delayMs);
+          }
+          continue;
+        }
+        outboundCounter++;
+        const stableClientMsgId = `reply_${messageSid}_${outboundCounter}`;
+        runtime2.error(
+          `[clawpool:${account.accountId}] upstream guarded reply retry exhausted ${baseLogContext} code=${retryGuardedText.code} attempts=${retryPolicy.maxAttempts}`
+        );
+        const didSendMessage = await deliverAibotMessage({
+          payload: {
+            text: retryGuardedText.userText
+          },
+          client,
+          account,
+          sessionId,
+          quotedMessageId: outboundQuotedMessageId,
+          runtime: runtime2,
+          statusSink,
+          stableClientMsgId,
+          tableMode
+        });
+        attemptHasOutbound = attemptHasOutbound || didSendMessage;
+      }
+      break;
+    }
+  } finally {
+    if (composingSet) {
+      setComposing(false);
+    }
+  }
+}
+async function monitorAibotProvider(options) {
+  const { account, config, runtime: runtime2, abortSignal, statusSink } = options;
+  let client;
+  const guardedStatusSink = (patch) => {
+    if (!isActiveMonitor(account.accountId, client)) {
+      return;
+    }
+    statusSink?.(patch);
+  };
+  client = new AibotWsClient(account, {
+    logger: {
+      info: (message) => runtime2.log(message),
+      warn: (message) => runtime2.log(`[warn] ${message}`),
+      error: (message) => runtime2.error(message),
+      debug: (message) => runtime2.log(message)
+    },
+    onStatus: (status) => {
+      guardedStatusSink({
+        running: status.running,
+        connected: status.connected,
+        lastError: status.lastError,
+        lastConnectAt: status.lastConnectAt ?? void 0,
+        lastDisconnectAt: status.lastDisconnectAt ?? void 0
+      });
+    },
+    onEventMsg: (event) => {
+      if (!isActiveMonitor(account.accountId, client)) {
+        return;
+      }
+      guardedStatusSink({ lastInboundAt: Date.now() });
+      void processEvent({
+        event,
+        account,
+        config,
+        runtime: runtime2,
+        client,
+        statusSink: guardedStatusSink
+      }).catch((err) => {
+        if (!isActiveMonitor(account.accountId, client)) {
+          return;
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        runtime2.error(`[clawpool:${account.accountId}] process event failed: ${msg}`);
+        guardedStatusSink({ lastError: msg });
+      });
+    }
+  });
+  const previousClient = registerActiveMonitor(account.accountId, client);
+  if (previousClient) {
+    runtime2.log(`[clawpool:${account.accountId}] stopping superseded clawpool monitor before restart`);
+    previousClient.stop();
+  }
+  setActiveAibotClient(account.accountId, client);
+  try {
+    await client.start(abortSignal);
+  } catch (err) {
+    clearActiveAibotClient(account.accountId, client);
+    clearActiveMonitor(account.accountId, client);
+    throw err;
+  }
+  void client.waitUntilStopped().catch((err) => {
+    if (!isActiveMonitor(account.accountId, client)) {
+      return;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    runtime2.error(`[clawpool:${account.accountId}] background run loop failed: ${msg}`);
+    guardedStatusSink({ lastError: msg });
+  }).finally(() => {
+    clearActiveAibotClient(account.accountId, client);
+    clearActiveMonitor(account.accountId, client);
+  });
+  return {
+    stop: () => {
+      clearActiveAibotClient(account.accountId, client);
+      clearActiveMonitor(account.accountId, client);
+      client.stop();
+    }
+  };
+}
+
+// src/onboarding.ts
+import { normalizeAccountId as normalizeAccountId2 } from "openclaw/plugin-sdk";
+
+// src/setup-config.ts
+import {
+  applyAccountNameToChannelSection,
+  DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID2,
+  migrateBaseNameToDefaultAccount
+} from "openclaw/plugin-sdk";
+function resolveSetupValues(input) {
+  const apiKey = String(input.token ?? input.appToken ?? "").trim();
+  const wsUrl = String(input.httpUrl ?? input.webhookUrl ?? input.url ?? "").trim();
+  const agentId = String(input.userId ?? "").trim();
+  return {
+    apiKey: apiKey || void 0,
+    wsUrl: wsUrl || void 0,
+    agentId: agentId || void 0
+  };
+}
+function applySetupAccountConfig(params) {
+  const { cfg, accountId, name, values } = params;
+  const namedConfig = applyAccountNameToChannelSection({
+    cfg,
+    channelKey: "clawpool",
+    accountId,
+    name
+  });
+  const next = accountId !== DEFAULT_ACCOUNT_ID2 ? migrateBaseNameToDefaultAccount({
+    cfg: namedConfig,
+    channelKey: "clawpool"
+  }) : namedConfig;
+  if (accountId === DEFAULT_ACCOUNT_ID2) {
+    return {
+      ...next,
+      channels: {
+        ...next.channels,
+        clawpool: {
+          ...next.channels?.clawpool,
+          enabled: true,
+          ...values.apiKey ? { apiKey: values.apiKey } : {},
+          ...values.wsUrl ? { wsUrl: values.wsUrl } : {},
+          ...values.agentId ? { agentId: values.agentId } : {}
+        }
+      }
+    };
+  }
+  return {
+    ...next,
+    channels: {
+      ...next.channels,
+      clawpool: {
+        ...next.channels?.clawpool,
+        enabled: true,
+        accounts: {
+          ...next.channels?.clawpool?.accounts ?? {},
+          [accountId]: {
+            ...next.channels?.clawpool?.accounts?.[accountId],
+            enabled: true,
+            ...values.apiKey ? { apiKey: values.apiKey } : {},
+            ...values.wsUrl ? { wsUrl: values.wsUrl } : {},
+            ...values.agentId ? { agentId: values.agentId } : {}
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/onboarding.ts
+var channel = "clawpool";
+function formatAccountLabel(accountId) {
+  return accountId === "default" ? "default (primary)" : accountId;
+}
+function normalizeOptionalAccountId2(raw) {
+  const value = String(raw ?? "").trim();
+  if (!value) {
+    return void 0;
+  }
+  return normalizeAccountId2(value);
+}
+function resolveSuggestedWsUrl(agentId) {
+  const cleaned = String(agentId ?? "").trim();
+  if (!cleaned) {
+    return "ws://127.0.0.1:27189/v1/agent-api/ws?agent_id=9992";
+  }
+  return `ws://127.0.0.1:27189/v1/agent-api/ws?agent_id=${encodeURIComponent(cleaned)}`;
+}
+async function resolveAccountIdForConfigure(params) {
+  const accountOverride = normalizeOptionalAccountId2(params.accountOverride);
+  if (accountOverride) {
+    return accountOverride;
+  }
+  const defaultAccountId = resolveDefaultAibotAccountId(params.cfg);
+  const accountIds = listAibotAccountIds(params.cfg).filter(Boolean);
+  if (!params.shouldPromptAccountIds || accountIds.length <= 1) {
+    return defaultAccountId;
+  }
+  const selected = await params.prompter.select({
+    message: "Select Clawpool account",
+    options: accountIds.map((accountId) => ({
+      value: accountId,
+      label: formatAccountLabel(accountId)
+    })),
+    initialValue: defaultAccountId
+  });
+  return normalizeAccountId2(selected);
+}
+async function promptSetupGuide(prompter) {
+  await prompter.note(
+    [
+      "Clawpool requires three values:",
+      "1) wsUrl (Aibot Agent API ws endpoint)",
+      "2) agentId",
+      "3) apiKey",
+      "Example wsUrl: ws://127.0.0.1:27189/v1/agent-api/ws?agent_id=9992",
+      "Env fallback: CLAWPOOL_WS_URL / CLAWPOOL_AGENT_ID / CLAWPOOL_API_KEY"
+    ].join("\n"),
+    "Clawpool setup"
+  );
+}
+var clawpoolOnboardingAdapter = {
+  channel,
+  getStatus: async ({ cfg }) => {
+    const configured = listAibotAccountIds(cfg).some(
+      (accountId) => resolveAibotAccount({ cfg, accountId }).configured
+    );
+    return {
+      channel,
+      configured,
+      statusLines: [`Clawpool: ${configured ? "configured" : "needs wsUrl/agentId/apiKey"}`],
+      selectionHint: configured ? "configured" : "needs setup",
+      quickstartScore: configured ? 2 : 1
+    };
+  },
+  configure: async ({ cfg, prompter, accountOverrides, shouldPromptAccountIds }) => {
+    const accountId = await resolveAccountIdForConfigure({
+      cfg,
+      prompter,
+      accountOverride: accountOverrides[channel],
+      shouldPromptAccountIds
+    });
+    const current = resolveAibotAccount({ cfg, accountId });
+    const accountConfigured = current.configured;
+    if (accountConfigured) {
+      const keep = await prompter.confirm({
+        message: `Clawpool account "${formatAccountLabel(accountId)}" is already configured. Keep current settings?`,
+        initialValue: true
+      });
+      if (keep) {
+        return { cfg, accountId };
+      }
+    } else {
+      await promptSetupGuide(prompter);
+    }
+    const initialAgentId = String(current.config.agentId ?? process.env.CLAWPOOL_AGENT_ID ?? "").trim();
+    const initialWsUrl = String(current.config.wsUrl ?? process.env.CLAWPOOL_WS_URL ?? "").trim();
+    const wsUrl = String(
+      await prompter.text({
+        message: "Clawpool wsUrl",
+        initialValue: initialWsUrl || resolveSuggestedWsUrl(initialAgentId),
+        placeholder: "ws://127.0.0.1:27189/v1/agent-api/ws?agent_id=9992",
+        validate: (value) => {
+          const resolved = String(value ?? "").trim();
+          if (!resolved) {
+            return "Required";
+          }
+          if (!/^wss?:\/\//i.test(resolved)) {
+            return "Must start with ws:// or wss://";
+          }
+          return void 0;
+        }
+      })
+    ).trim();
+    const agentId = String(
+      await prompter.text({
+        message: "Clawpool agentId",
+        initialValue: initialAgentId || current.agentId,
+        validate: (value) => String(value ?? "").trim() ? void 0 : "Required"
+      })
+    ).trim();
+    const apiKey = String(
+      await prompter.text({
+        message: "Clawpool apiKey",
+        initialValue: String(current.config.apiKey ?? process.env.CLAWPOOL_API_KEY ?? "").trim(),
+        validate: (value) => String(value ?? "").trim() ? void 0 : "Required"
+      })
+    ).trim();
+    const next = applySetupAccountConfig({
+      cfg,
+      accountId,
+      values: {
+        wsUrl,
+        agentId,
+        apiKey
+      }
+    });
+    return {
+      cfg: next,
+      accountId
+    };
+  },
+  disable: (cfg) => ({
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      clawpool: {
+        ...cfg.channels?.clawpool,
+        enabled: false
+      }
+    }
+  })
+};
+
+// src/target-resolver.ts
+var aibotSessionIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isAibotSessionID(value) {
+  const normalized = String(value ?? "").trim();
+  if (!normalized) {
+    return false;
+  }
+  return aibotSessionIDPattern.test(normalized);
+}
+function normalizeAibotSessionTarget2(raw) {
+  const trimmed = String(raw ?? "").trim();
+  if (!trimmed) {
+    return "";
+  }
+  return trimmed.replace(/^clawpool:/i, "").replace(/^session:/i, "").trim();
+}
+function buildRouteSessionKeyCandidates(rawTarget, normalizedTarget) {
+  if (rawTarget === normalizedTarget) {
+    return [rawTarget];
+  }
+  return [rawTarget, normalizedTarget].filter((candidate) => candidate.length > 0);
+}
+async function resolveAibotOutboundTarget(params) {
+  const rawTarget = String(params.to ?? "").trim();
+  if (!rawTarget) {
+    throw new Error("clawpool outbound target must be non-empty");
+  }
+  const normalizedTarget = normalizeAibotSessionTarget2(rawTarget);
+  if (!normalizedTarget) {
+    throw new Error("clawpool outbound target must contain session_id or route_session_key");
+  }
+  if (isAibotSessionID(normalizedTarget)) {
+    return {
+      sessionId: normalizedTarget,
+      rawTarget,
+      normalizedTarget,
+      resolveSource: "direct"
+    };
+  }
+  if (/^\d+$/.test(normalizedTarget)) {
+    throw new Error(
+      `clawpool outbound target "${rawTarget}" is numeric; expected session_id(UUID) or route.sessionKey`
+    );
+  }
+  const routeSessionKeyCandidates = buildRouteSessionKeyCandidates(rawTarget, normalizedTarget);
+  let lastResolveError = null;
+  for (const routeSessionKey of routeSessionKeyCandidates) {
+    try {
+      const ack = await params.client.resolveSessionRoute("clawpool", params.accountId, routeSessionKey);
+      const sessionId = String(ack.session_id ?? "").trim();
+      if (!isAibotSessionID(sessionId)) {
+        throw new Error(
+          `session_route_resolve returned invalid session_id for route_session_key="${routeSessionKey}"`
+        );
+      }
+      return {
+        sessionId,
+        rawTarget,
+        normalizedTarget,
+        resolveSource: "sessionRouteMap"
+      };
+    } catch (err) {
+      lastResolveError = err instanceof Error ? err : new Error(String(err));
+    }
+  }
+  if (lastResolveError) {
+    throw new Error(
+      `clawpool outbound target resolve failed target="${rawTarget}" accountId=${params.accountId}: ${lastResolveError.message}`
+    );
+  }
+  throw new Error(`clawpool outbound target resolve failed target="${rawTarget}" accountId=${params.accountId}`);
+}
+
+// src/channel.ts
+var meta = {
+  id: "clawpool",
+  label: "Clawpool",
+  selectionLabel: "Clawpool",
+  blurb: "Bridge OpenClaw to Clawpool over the Aibot Agent API WebSocket.",
+  aliases: ["cp", "clowpool"],
+  order: 90
+};
+function normalizeQuotedMessageId(rawInput) {
+  const raw = String(rawInput ?? "").trim();
+  if (!raw) {
+    return void 0;
+  }
+  if (/^\d+$/.test(raw)) {
+    return raw;
+  }
+  const parsed = raw.split(":").at(-1)?.trim() ?? "";
+  if (/^\d+$/.test(parsed)) {
+    return parsed;
+  }
+  return void 0;
+}
+function logAibotOutboundAdapter(message) {
+  console.info(`[clawpool:outbound] ${message}`);
+}
+function asAibotChannelConfig(cfg) {
+  return cfg.channels?.clawpool ?? {};
+}
+function buildAccountSnapshot(params) {
+  const { account, runtime: runtime2 } = params;
+  return {
+    accountId: account.accountId,
+    name: account.name,
+    enabled: account.enabled,
+    configured: account.configured,
+    running: runtime2?.running ?? false,
+    connected: runtime2?.connected ?? false,
+    lastError: runtime2?.lastError ?? null,
+    lastStartAt: runtime2?.lastStartAt ?? null,
+    lastStopAt: runtime2?.lastStopAt ?? null,
+    lastInboundAt: runtime2?.lastInboundAt ?? null,
+    lastOutboundAt: runtime2?.lastOutboundAt ?? null,
+    dmPolicy: account.config.dmPolicy ?? "open",
+    tokenSource: account.apiKey ? "config" : "none"
+  };
+}
+var AibotConfigSchema = {
+  type: "object",
+  additionalProperties: true,
+  properties: {}
+};
+var aibotPlugin = {
+  id: "clawpool",
+  meta,
+  onboarding: clawpoolOnboardingAdapter,
+  capabilities: {
+    chatTypes: ["direct", "group"],
+    media: true,
+    reactions: true,
+    unsend: true,
+    threads: false,
+    polls: false,
+    nativeCommands: false,
+    blockStreaming: true
+  },
+  actions: aibotMessageActions,
+  reload: {
+    configPrefixes: ["channels.clawpool"]
+  },
+  configSchema: {
+    schema: AibotConfigSchema
+  },
+  config: {
+    listAccountIds: (cfg) => listAibotAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveAibotAccount({ cfg, accountId }),
+    defaultAccountId: (cfg) => resolveDefaultAibotAccountId(cfg),
+    setAccountEnabled: ({ cfg, accountId, enabled }) => setAccountEnabledInConfigSection({
+      cfg,
+      sectionKey: "clawpool",
+      accountId,
+      enabled,
+      allowTopLevel: true
+    }),
+    deleteAccount: ({ cfg, accountId }) => deleteAccountFromConfigSection({
+      cfg,
+      sectionKey: "clawpool",
+      accountId,
+      clearBaseFields: [
+        "name",
+        "wsUrl",
+        "agentId",
+        "apiKey",
+        "reconnectMs",
+        "reconnectMaxMs",
+        "reconnectStableMs",
+        "connectTimeoutMs",
+        "keepalivePingMs",
+        "keepaliveTimeoutMs",
+        "upstreamRetryMaxAttempts",
+        "upstreamRetryBaseDelayMs",
+        "upstreamRetryMaxDelayMs",
+        "maxChunkChars",
+        "dmPolicy",
+        "allowFrom",
+        "defaultTo"
+      ]
+    }),
+    isConfigured: (account) => account.configured,
+    describeAccount: (account, cfg) => {
+      const root = asAibotChannelConfig(cfg);
+      return {
+        accountId: account.accountId,
+        name: account.name,
+        enabled: account.enabled,
+        configured: account.configured,
+        running: false,
+        connected: false,
+        lastError: account.configured ? null : "missing wsUrl/agentId/apiKey (or CLAWPOOL_WS_URL/CLAWPOOL_AGENT_ID/CLAWPOOL_API_KEY)",
+        dmPolicy: account.config.dmPolicy ?? "open",
+        tokenSource: account.apiKey ? "config" : "none",
+        mode: "block_streaming",
+        baseUrl: redactAibotWsUrl(account.wsUrl),
+        allowFrom: account.config.allowFrom?.map((entry) => String(entry).trim()).filter(Boolean) ?? [],
+        nameSource: root.accounts?.[account.accountId]?.name ? "account" : "base"
+      };
+    },
+    resolveAllowFrom: ({ cfg, accountId }) => resolveAibotAccount({ cfg, accountId }).config.allowFrom?.map((entry) => String(entry)) ?? [],
+    formatAllowFrom: ({ allowFrom }) => allowFrom.map((entry) => String(entry).trim()).filter(Boolean),
+    resolveDefaultTo: ({ cfg, accountId }) => resolveAibotAccount({ cfg, accountId }).config.defaultTo?.trim() || void 0
+  },
+  setup: {
+    resolveAccountId: ({ accountId }) => normalizeAccountId3(accountId),
+    applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection2({
+      cfg,
+      channelKey: "clawpool",
+      accountId,
+      name
+    }),
+    validateInput: ({ input }) => {
+      const values = resolveSetupValues(input);
+      const hasAny = Boolean(values.apiKey || values.wsUrl || values.agentId);
+      if (!hasAny) {
+        return "clawpool setup requires at least one of: --token(api key), --http-url(ws url), --user-id(agent id)";
+      }
+      return null;
+    },
+    applyAccountConfig: ({ cfg, accountId, input }) => {
+      const values = resolveSetupValues(input);
+      return applySetupAccountConfig({
+        cfg,
+        accountId,
+        name: input.name,
+        values
+      });
+    }
+  },
+  security: {
+    resolveDmPolicy: ({ cfg, accountId, account }) => {
+      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID3;
+      const isAccountScoped = Boolean(cfg.channels?.clawpool?.accounts?.[resolvedAccountId]);
+      const basePath = isAccountScoped ? `channels.clawpool.accounts.${resolvedAccountId}.` : "channels.clawpool.";
+      return {
+        policy: account.config.dmPolicy ?? "open",
+        allowFrom: account.config.allowFrom ?? [],
+        policyPath: `${basePath}dmPolicy`,
+        allowFromPath: basePath,
+        approveHint: formatPairingApproveHint("clawpool")
+      };
+    }
+  },
+  messaging: {
+    normalizeTarget: (raw) => normalizeAibotSessionTarget(raw),
+    targetResolver: {
+      looksLikeId: (raw) => Boolean(normalizeAibotSessionTarget(raw)),
+      hint: "<session_id|route.sessionKey>"
+    }
+  },
+  threading: {
+    buildToolContext: ({ context, hasRepliedRef }) => ({
+      currentChannelId: context.To?.trim() || void 0,
+      currentMessageId: context.CurrentMessageId != null ? String(context.CurrentMessageId) : void 0,
+      hasRepliedRef
+    })
+  },
+  agentPrompt: {
+    messageToolHints: () => [
+      "- Clawpool can only unsend the agent's own previously sent messages. Use `action=unsend` with `messageId`; omit `sessionId`/`to` to target the current Clawpool chat."
+    ]
+  },
+  outbound: {
+    deliveryMode: "direct",
+    chunker: chunkTextForOutbound,
+    chunkerMode: "markdown",
+    textChunkLimit: 1200,
+    sendText: async ({ cfg, to, text, accountId, replyToId }) => {
+      const account = resolveAibotAccount({ cfg, accountId });
+      const client = requireActiveAibotClient(account.accountId);
+      const rawTarget = String(to ?? "").trim() || "-";
+      logAibotOutboundAdapter(
+        `sendText target resolve begin accountId=${account.accountId} rawTarget=${rawTarget}`
+      );
+      let resolvedTarget;
+      try {
+        resolvedTarget = await resolveAibotOutboundTarget({
+          client,
+          accountId: account.accountId,
+          to
+        });
+      } catch (err) {
+        logAibotOutboundAdapter(
+          `sendText target resolve failed accountId=${account.accountId} rawTarget=${rawTarget} error=${String(err)}`
+        );
+        throw err;
+      }
+      const sessionId = resolvedTarget.sessionId;
+      const quotedMessageId = normalizeQuotedMessageId(replyToId);
+      logAibotOutboundAdapter(
+        `sendText accountId=${account.accountId} rawTarget=${rawTarget} normalizedTarget=${resolvedTarget.normalizedTarget} resolvedSessionId=${sessionId} resolveSource=${resolvedTarget.resolveSource} textLen=${text.length} quotedMessageId=${quotedMessageId ?? "-"}`
+      );
+      const ack = await client.sendText(sessionId, text, {
+        quotedMessageId
+      });
+      logAibotOutboundAdapter(
+        `sendText ack accountId=${account.accountId} resolvedSessionId=${sessionId} messageId=${String(ack.msg_id ?? ack.client_msg_id ?? "-")}`
+      );
+      return {
+        channel: "clawpool",
+        messageId: String(ack.msg_id ?? ack.client_msg_id ?? Date.now())
+      };
+    },
+    sendMedia: async ({ cfg, to, text, mediaUrl, accountId, replyToId }) => {
+      const account = resolveAibotAccount({ cfg, accountId });
+      const client = requireActiveAibotClient(account.accountId);
+      const rawTarget = String(to ?? "").trim() || "-";
+      logAibotOutboundAdapter(
+        `sendMedia target resolve begin accountId=${account.accountId} rawTarget=${rawTarget}`
+      );
+      let resolvedTarget;
+      try {
+        resolvedTarget = await resolveAibotOutboundTarget({
+          client,
+          accountId: account.accountId,
+          to
+        });
+      } catch (err) {
+        logAibotOutboundAdapter(
+          `sendMedia target resolve failed accountId=${account.accountId} rawTarget=${rawTarget} error=${String(err)}`
+        );
+        throw err;
+      }
+      const sessionId = resolvedTarget.sessionId;
+      if (!mediaUrl) {
+        throw new Error("clawpool sendMedia requires mediaUrl");
+      }
+      const quotedMessageId = normalizeQuotedMessageId(replyToId);
+      logAibotOutboundAdapter(
+        `sendMedia accountId=${account.accountId} rawTarget=${rawTarget} normalizedTarget=${resolvedTarget.normalizedTarget} resolvedSessionId=${sessionId} resolveSource=${resolvedTarget.resolveSource} textLen=${(text ?? "").length} quotedMessageId=${quotedMessageId ?? "-"} mediaUrl=${mediaUrl}`
+      );
+      const ack = await client.sendMedia(sessionId, mediaUrl, text ?? "", {
+        quotedMessageId
+      });
+      logAibotOutboundAdapter(
+        `sendMedia ack accountId=${account.accountId} resolvedSessionId=${sessionId} messageId=${String(ack.msg_id ?? ack.client_msg_id ?? "-")}`
+      );
+      return {
+        channel: "clawpool",
+        messageId: String(ack.msg_id ?? ack.client_msg_id ?? Date.now())
+      };
+    }
+  },
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID3,
+      running: false,
+      connected: false,
+      lastError: null,
+      lastStartAt: null,
+      lastStopAt: null,
+      lastInboundAt: null,
+      lastOutboundAt: null
+    },
+    buildChannelSummary: ({ snapshot }) => ({
+      configured: snapshot.configured ?? false,
+      running: snapshot.running ?? false,
+      connected: snapshot.connected ?? false,
+      lastError: snapshot.lastError ?? null,
+      lastInboundAt: snapshot.lastInboundAt ?? null,
+      lastOutboundAt: snapshot.lastOutboundAt ?? null
+    }),
+    buildAccountSnapshot: ({ account, runtime: runtime2 }) => buildAccountSnapshot({ account, runtime: runtime2 }),
+    collectStatusIssues: (accounts) => accounts.flatMap((account) => {
+      if (!account.enabled) {
+        return [];
+      }
+      if (!account.configured) {
+        return [
+          {
+            channel: "clawpool",
+            accountId: account.accountId,
+            kind: "config",
+            message: "Clawpool account is not configured. Set wsUrl/agentId/apiKey (or CLAWPOOL_WS_URL/CLAWPOOL_AGENT_ID/CLAWPOOL_API_KEY)."
+          }
+        ];
+      }
+      if (account.running && !account.connected) {
+        return [
+          {
+            channel: "clawpool",
+            accountId: account.accountId,
+            kind: "runtime",
+            message: "Clawpool channel is running but not connected."
+          }
+        ];
+      }
+      if (typeof account.lastError === "string" && account.lastError.trim()) {
+        return [
+          {
+            channel: "clawpool",
+            accountId: account.accountId,
+            kind: "runtime",
+            message: account.lastError
+          }
+        ];
+      }
+      return [];
+    })
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const account = ctx.account;
+      if (!account.configured) {
+        throw new Error(
+          `clawpool account "${account.accountId}" not configured: require wsUrl + agentId + apiKey`
+        );
+      }
+      ctx.log?.info?.(
+        `[${account.accountId}] starting clawpool monitor (${redactAibotWsUrl(account.wsUrl)})`
+      );
+      ctx.setStatus({
+        ...ctx.getStatus(),
+        running: true,
+        connected: false,
+        lastError: null,
+        lastStartAt: Date.now()
+      });
+      const monitor = await monitorAibotProvider({
+        account,
+        config: ctx.cfg,
+        runtime: ctx.runtime,
+        abortSignal: ctx.abortSignal,
+        statusSink: (patch) => {
+          ctx.setStatus({
+            ...ctx.getStatus(),
+            ...patch
+          });
+        }
+      });
+      try {
+        await waitUntilAbort(ctx.abortSignal);
+      } finally {
+        monitor.stop();
+        ctx.setStatus({
+          ...ctx.getStatus(),
+          running: false,
+          connected: false,
+          lastStopAt: Date.now()
+        });
+      }
+    },
+    stopAccount: async (ctx) => {
+      const client = getActiveAibotClient(ctx.accountId);
+      client?.stop();
+      ctx.setStatus({
+        ...ctx.getStatus(),
+        running: false,
+        connected: false,
+        lastStopAt: Date.now()
+      });
+    }
+  }
+};
+
+// index.ts
+var plugin = {
+  id: "clawpool",
+  name: "Clawpool",
+  description: "Clawpool channel plugin backed by Aibot Agent API",
+  configSchema: emptyPluginConfigSchema(),
+  register(api) {
+    setAibotRuntime(api.runtime);
+    api.registerChannel({ plugin: aibotPlugin });
+  }
+};
+var index_default = plugin;
+export {
+  index_default as default
+};