@coolclaw/coolclaw 0.2.10 → 0.3.0

package/dist/chunk-GNPSYUMN.js

@@ -0,0 +1,1113 @@
+import {
+  buildWsUrl,
+  resolveAccountToken
+} from "./chunk-Q3NF4NWE.js";
+
+// src/runtime.ts
+var _runtime;
+function setCoolclawRuntime(runtime) {
+  _runtime = runtime;
+}
+function getCoolclawRuntime() {
+  return _runtime;
+}
+
+// src/ack-store.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var InMemoryAckStore = class {
+  cursors = /* @__PURE__ */ new Map();
+  async getLastAckedSeq(accountKey) {
+    return this.cursors.get(accountKey) ?? 0;
+  }
+  async record(accountKey, seq) {
+    if (!Number.isInteger(seq) || seq < 1) {
+      throw new Error(`Invalid ACK seq: ${seq}`);
+    }
+    const current = this.cursors.get(accountKey) ?? 0;
+    if (seq <= current) {
+      return current;
+    }
+    this.cursors.set(accountKey, seq);
+    return seq;
+  }
+};
+var FileAckStore = class {
+  cursors = /* @__PURE__ */ new Map();
+  dir;
+  constructor(dir) {
+    this.dir = dir ?? join(homedir(), ".openclaw", "extensions", "coolclaw", ".ack-store");
+    if (!existsSync(this.dir)) {
+      mkdirSync(this.dir, { recursive: true });
+    }
+  }
+  async getLastAckedSeq(accountKey) {
+    return this.cursors.get(accountKey) ?? this.load(accountKey);
+  }
+  async record(accountKey, seq) {
+    if (!Number.isInteger(seq) || seq < 1) {
+      throw new Error(`Invalid ACK seq: ${seq}`);
+    }
+    const current = this.cursors.get(accountKey) ?? this.load(accountKey);
+    if (seq <= current) {
+      return current;
+    }
+    this.cursors.set(accountKey, seq);
+    this.persist(accountKey, seq);
+    return seq;
+  }
+  load(accountKey) {
+    const filePath = this.filePath(accountKey);
+    if (!existsSync(filePath)) {
+      return 0;
+    }
+    try {
+      const text = readFileSync(filePath, "utf-8").trim();
+      const value = parseInt(text, 10);
+      return Number.isFinite(value) && value >= 0 ? value : 0;
+    } catch {
+      return 0;
+    }
+  }
+  persist(accountKey, lastAckedSeq) {
+    try {
+      writeFileSync(this.filePath(accountKey), String(lastAckedSeq), "utf-8");
+    } catch {
+    }
+  }
+  filePath(accountKey) {
+    const safeName = accountKey.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return join(this.dir, `${safeName}.ack`);
+  }
+};
+
+// src/frame-codec.ts
+import { randomUUID } from "crypto";
+var CoolclawFrameDecodeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CoolclawFrameDecodeError";
+  }
+};
+function createFrame(type, payload) {
+  return {
+    v: 1,
+    type,
+    id: `cli_${randomUUID()}`,
+    ts: Date.now(),
+    payload
+  };
+}
+function encodeFrame(frame) {
+  return JSON.stringify(frame);
+}
+function decodeFrame(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error) {
+    throw new CoolclawFrameDecodeError(`Invalid CoolClaw frame JSON: ${error.message}`);
+  }
+  if (!isRecord(value)) {
+    throw new CoolclawFrameDecodeError("Invalid CoolClaw frame: expected object");
+  }
+  if (!("v" in value)) {
+    throw new CoolclawFrameDecodeError("Invalid CoolClaw frame: missing v");
+  }
+  if (value.v !== 1) {
+    throw new CoolclawFrameDecodeError("Unsupported CoolClaw frame version");
+  }
+  if (typeof value.type !== "string" || value.type.length === 0) {
+    throw new CoolclawFrameDecodeError("Invalid CoolClaw frame: missing type");
+  }
+  if (typeof value.id !== "string" || value.id.length === 0) {
+    throw new CoolclawFrameDecodeError("Invalid CoolClaw frame: missing id");
+  }
+  if (typeof value.ts !== "number" || !Number.isFinite(value.ts)) {
+    throw new CoolclawFrameDecodeError("Invalid CoolClaw frame: missing ts");
+  }
+  if ("ack" in value && value.ack !== void 0 && typeof value.ack !== "string") {
+    throw new CoolclawFrameDecodeError("Invalid CoolClaw frame: ack must be a string");
+  }
+  const frame = {
+    v: 1,
+    type: value.type,
+    id: value.id,
+    ts: value.ts
+  };
+  if (typeof value.ack === "string") {
+    frame.ack = value.ack;
+  }
+  if ("payload" in value) {
+    frame.payload = value.payload;
+  }
+  return frame;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/inbound.ts
+function mapInboundFrame(frame) {
+  if (frame.type === "PRIVATE_MESSAGE") {
+    const payload = assertPrivatePayload(frame.payload);
+    return {
+      id: payload.messageId,
+      channel: "coolclaw",
+      conversationId: `private:${payload.sender.userType}:${payload.sender.userId}`,
+      text: payload.content,
+      messageType: payload.messageType,
+      seq: payload.seq,
+      shouldReply: true,
+      // 私聊本身就是与 Bot 对话的意图
+      sender: payload.sender,
+      recipient: payload.recipient,
+      metadata: {
+        riddleConversationId: payload.conversationId,
+        sentAt: payload.sentAt,
+        sourceFrameId: frame.id
+      }
+    };
+  }
+  if (frame.type === "GROUP_MESSAGE") {
+    const payload = assertGroupPayload(frame.payload);
+    return {
+      id: payload.messageId,
+      channel: "coolclaw",
+      conversationId: `group:${payload.groupId}`,
+      text: payload.content,
+      messageType: payload.messageType,
+      seq: payload.seq,
+      shouldReply: payload.mentioned,
+      // 群聊仅在 @ 时回复
+      sender: payload.sender,
+      group: {
+        groupId: payload.groupId,
+        groupName: payload.groupName
+      },
+      metadata: {
+        riddleConversationId: payload.conversationId,
+        sentAt: payload.sentAt,
+        sourceFrameId: frame.id,
+        agentHint: payload.agentHint
+      }
+    };
+  }
+  if (frame.type === "SYSTEM_NOTIFICATION" || frame.type === "GAME_EVENT" || frame.type === "CONTENT_TASK") {
+    return mapNotificationFrame(frame);
+  }
+  throw new Error(`Unsupported inbound CoolClaw frame type: ${frame.type}`);
+}
+async function handleInboundFrame(input) {
+  const envelope = mapInboundFrame(input.frame);
+  if (!envelope) return;
+  await ackProcessedSeq(input, envelope);
+  await input.dispatch(envelope);
+}
+function mapNotificationFrame(frame) {
+  const payload = isRecord2(frame.payload) ? frame.payload : {};
+  const seq = typeof payload.seq === "number" ? payload.seq : void 0;
+  if (frame.type === "SYSTEM_NOTIFICATION") {
+    const title = typeof payload.title === "string" ? payload.title : "System";
+    const content = typeof payload.content === "string" ? payload.content : JSON.stringify(payload);
+    return {
+      id: frame.id,
+      channel: "coolclaw",
+      conversationId: "notification:system",
+      text: `[\u7CFB\u7EDF\u901A\u77E5] ${title}: ${content}`,
+      messageType: frame.type,
+      seq,
+      shouldReply: false,
+      metadata: { sourceFrameId: frame.id, payload: frame.payload }
+    };
+  }
+  if (frame.type === "GAME_EVENT") {
+    return null;
+  }
+  if (frame.type === "CONTENT_TASK") {
+    const taskType = typeof payload.taskType === "string" ? payload.taskType : "unknown";
+    return {
+      id: frame.id,
+      channel: "coolclaw",
+      conversationId: "notification:content_task",
+      text: `[\u5185\u5BB9\u4EFB\u52A1] ${taskType}: ${JSON.stringify(payload)}`,
+      messageType: frame.type,
+      seq,
+      shouldReply: false,
+      metadata: { sourceFrameId: frame.id, payload: frame.payload }
+    };
+  }
+  return null;
+}
+async function ackProcessedSeq(input, envelope) {
+  if (typeof envelope.seq === "number") {
+    const lastAckedSeq = await input.ackStore.record(input.accountKey, envelope.seq);
+    await input.sendAck(createFrame("ACK", { lastAckedSeq }));
+  }
+}
+function assertPrivatePayload(value) {
+  if (!isRecord2(value) || !isUserRef(value.sender) || !isUserRef(value.recipient)) {
+    throw new Error("Invalid PRIVATE_MESSAGE payload");
+  }
+  return {
+    seq: readNumber(value, "seq"),
+    messageId: readString(value, "messageId"),
+    conversationId: readString(value, "conversationId"),
+    sender: value.sender,
+    recipient: value.recipient,
+    messageType: readString(value, "messageType"),
+    content: readString(value, "content"),
+    mentioned: readBoolean(value, "mentioned"),
+    sentAt: readString(value, "sentAt")
+  };
+}
+function assertGroupPayload(value) {
+  if (!isRecord2(value) || !isUserRef(value.sender)) {
+    throw new Error("Invalid GROUP_MESSAGE payload");
+  }
+  return {
+    seq: readNumber(value, "seq"),
+    messageId: readString(value, "messageId"),
+    groupId: readString(value, "groupId"),
+    groupName: readString(value, "groupName"),
+    conversationId: readString(value, "conversationId"),
+    sender: value.sender,
+    messageType: readString(value, "messageType"),
+    content: readString(value, "content"),
+    mentioned: readBoolean(value, "mentioned"),
+    sentAt: readString(value, "sentAt"),
+    agentHint: readOptionalString(value, "agentHint")
+  };
+}
+function readString(source, key) {
+  const value = source[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Invalid inbound payload: missing ${key}`);
+  }
+  return value;
+}
+function readNumber(source, key) {
+  const value = source[key];
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    throw new Error(`Invalid inbound payload: missing ${key}`);
+  }
+  return value;
+}
+function readBoolean(source, key) {
+  const value = source[key];
+  if (typeof value !== "boolean") {
+    throw new Error(`Invalid inbound payload: missing ${key}`);
+  }
+  return value;
+}
+function readOptionalString(source, key) {
+  const value = source[key];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Invalid inbound payload: ${key} must be a string`);
+  }
+  return value;
+}
+function isUserRef(value) {
+  return isRecord2(value) && typeof value.userId === "string" && (value.userType === "HUMAN" || value.userType === "AGENT") && (value.displayName === void 0 || typeof value.displayName === "string");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/targets.ts
+var TargetParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TargetParseError";
+  }
+};
+function parseCoolclawTarget(raw) {
+  const normalized = normalizeCoolclawTarget(raw);
+  const parts = normalized.split(":");
+  if (parts.length !== 3) {
+    throw new TargetParseError(`Invalid CoolClaw target: ${raw}`);
+  }
+  const [channel, type, id] = parts;
+  if (channel !== "coolclaw" || id.length === 0) {
+    throw new TargetParseError(`Invalid CoolClaw target: ${raw}`);
+  }
+  if (type === "human") {
+    return { kind: "private", userType: "HUMAN", userId: id };
+  }
+  if (type === "agent") {
+    return { kind: "private", userType: "AGENT", userId: id };
+  }
+  if (type === "group") {
+    return { kind: "group", groupId: id };
+  }
+  throw new TargetParseError(`Invalid CoolClaw target type: ${type}`);
+}
+function normalizeCoolclawTarget(raw) {
+  const trimmed = raw.trim();
+  const parts = trimmed.split(":");
+  if (parts.length !== 3) {
+    return trimmed;
+  }
+  const [channel, type, id] = parts;
+  return `${channel.toLowerCase()}:${type.toLowerCase()}:${id.trim()}`;
+}
+function inferCoolclawTargetChatType(raw) {
+  try {
+    const target = parseCoolclawTarget(raw);
+    return target.kind === "private" ? "direct" : "group";
+  } catch {
+    return void 0;
+  }
+}
+function isCoolclawTargetId(raw, normalized = normalizeCoolclawTarget(raw)) {
+  try {
+    parseCoolclawTarget(normalized);
+    return normalized.startsWith("coolclaw:");
+  } catch {
+    return false;
+  }
+}
+async function resolveCoolclawMessagingTarget(raw, preferredKind) {
+  const normalized = normalizeCoolclawTarget(raw);
+  const target = parseCoolclawTarget(normalized);
+  const kind = target.kind === "private" ? "user" : "group";
+  if (preferredKind && preferredKind !== kind) {
+    return null;
+  }
+  const [, type, id] = normalized.split(":");
+  return {
+    to: normalized,
+    kind,
+    display: `${type}:${id}`,
+    source: "normalized"
+  };
+}
+
+// src/outbound.ts
+async function sendText(input) {
+  const target = parseCoolclawTarget(input.target);
+  const frame = target.kind === "private" ? createFrame("SEND_PRIVATE", {
+    target: {
+      userId: target.userId,
+      userType: target.userType
+    },
+    messageType: "TEXT",
+    content: input.text
+  }) : createFrame("SEND_GROUP", {
+    groupId: target.groupId,
+    messageType: "TEXT",
+    content: input.text
+  });
+  const response = await input.client.request(frame);
+  if (response.ok === false) {
+    throw new Error(response.error?.message ?? "CoolClaw message send failed");
+  }
+  if (!response.messageId) {
+    throw new Error("CoolClaw message send response missing messageId");
+  }
+  return response.messageId;
+}
+async function sendMedia(input) {
+  const target = parseCoolclawTarget(input.target);
+  const fs = await import("fs/promises");
+  const fileBuffer = await fs.readFile(input.filePath);
+  const base64Content = fileBuffer.toString("base64");
+  const frame = target.kind === "private" ? createFrame("SEND_PRIVATE_MEDIA", {
+    target: { userId: target.userId, userType: target.userType },
+    messageType: "IMAGE",
+    content: base64Content,
+    mimeType: input.mimeType ?? "image/png"
+  }) : createFrame("SEND_GROUP_MEDIA", {
+    groupId: target.groupId,
+    messageType: "IMAGE",
+    content: base64Content,
+    mimeType: input.mimeType ?? "image/png"
+  });
+  const response = await input.client.request(frame);
+  if (response.ok === false) {
+    throw new Error(response.error?.message ?? "CoolClaw media send failed");
+  }
+  if (!response.messageId) {
+    throw new Error("CoolClaw media send response missing messageId");
+  }
+  return response.messageId;
+}
+
+// src/ws-client.ts
+import WebSocket from "ws";
+var CoolclawWsClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  socket;
+  heartbeatTimer;
+  reconnectTimer;
+  stopped = true;
+  reconnectAttempt = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  async start() {
+    this.stopped = false;
+    await this.connect();
+  }
+  async stop() {
+    this.stopped = true;
+    this.clearHeartbeat();
+    this.clearReconnect();
+    this.rejectPending(new Error("CoolClaw WSS client stopped"));
+    const socket = this.socket;
+    this.socket = void 0;
+    if (!socket || socket.readyState === WebSocket.CLOSED) {
+      return;
+    }
+    await new Promise((resolve) => {
+      socket.once("close", () => resolve());
+      socket.close(1e3, "client stopped");
+    });
+  }
+  async request(frame) {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      throw new Error("CoolClaw WSS client is not connected");
+    }
+    const requestTimeoutMs = this.options.requestTimeoutMs ?? 1e4;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(frame.id);
+        reject(new Error(`CoolClaw request timed out: ${frame.type}`));
+      }, requestTimeoutMs);
+      this.pendingRequests.set(frame.id, {
+        resolve: (payload) => resolve(payload),
+        reject,
+        timeout
+      });
+      this.sendFrame(frame);
+    });
+  }
+  sendFrame(frame) {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      throw new Error("CoolClaw WSS client is not connected");
+    }
+    this.socket.send(encodeFrame(frame));
+  }
+  isConnected() {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+  async connect() {
+    this.notifyState("connecting");
+    const lastAckedSeq = await this.options.ackStore.getLastAckedSeq(this.options.accountKey);
+    const socket = new WebSocket(buildWsUrl(this.options.gatewayUrl, lastAckedSeq), {
+      headers: {
+        Authorization: `Bearer ${this.options.token}`,
+        "X-CoolClaw-Agent-Id": this.options.agentId,
+        "X-CoolClaw-Plugin-Version": this.options.pluginVersion
+      }
+    });
+    this.socket = socket;
+    await new Promise((resolve, reject) => {
+      let helloReceived = false;
+      const failBeforeHello = (error) => {
+        if (!helloReceived) {
+          cleanupBeforeHello();
+          reject(error);
+        }
+      };
+      const cleanupBeforeHello = () => {
+        socket.off("error", failBeforeHello);
+        socket.off("message", onMessageBeforeHello);
+        socket.off("close", onCloseBeforeHello);
+      };
+      const onMessageBeforeHello = (data) => {
+        let frame;
+        try {
+          frame = decodeFrame(data.toString());
+        } catch (error) {
+          failBeforeHello(error);
+          return;
+        }
+        this.handleFrame(frame).catch((error) => {
+          this.rejectPending(error instanceof Error ? error : new Error(String(error)));
+        });
+        if (frame.type === "HELLO") {
+          helloReceived = true;
+          this.reconnectAttempt = 0;
+          cleanupBeforeHello();
+          socket.on("message", (nextData) => {
+            this.handleRawMessage(nextData).catch((error) => {
+              this.rejectPending(error instanceof Error ? error : new Error(String(error)));
+            });
+          });
+          socket.on("close", (code) => this.handleClose(code));
+          this.startHeartbeat(frame);
+          this.notifyState("connected");
+          resolve();
+        }
+      };
+      const onCloseBeforeHello = (code) => {
+        const error = new Error(`CoolClaw WSS closed before HELLO: ${code}`);
+        cleanupBeforeHello();
+        if (!this.isTerminalClose(code) && !this.stopped) {
+          this.scheduleReconnect();
+        }
+        reject(error);
+      };
+      socket.on("error", failBeforeHello);
+      socket.on("message", onMessageBeforeHello);
+      socket.on("close", onCloseBeforeHello);
+    });
+  }
+  async handleRawMessage(data) {
+    await this.handleFrame(decodeFrame(data.toString()));
+  }
+  async handleFrame(frame) {
+    if (frame.ack) {
+      const pending = this.pendingRequests.get(frame.ack);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(frame.ack);
+        if (frame.type === "ERROR") {
+          pending.reject(new Error(readErrorMessage(frame.payload)));
+        } else {
+          pending.resolve(frame.payload);
+        }
+        return;
+      }
+    }
+    if (frame.type === "PING") {
+      const pong = createFrame("PONG", { clientTime: Date.now() });
+      pong.ack = frame.id;
+      this.sendFrame(pong);
+      return;
+    }
+    if (frame.type === "PONG" || frame.type === "HELLO" || frame.type === "RESUME_DONE") {
+      return;
+    }
+    await this.options.onFrame?.(frame, this);
+  }
+  startHeartbeat(helloFrame) {
+    this.clearHeartbeat();
+    const intervalMs = this.options.heartbeatIntervalMs ?? readPingInterval(helloFrame.payload) ?? 2e4;
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      this.sendFrame(createFrame("PING", { clientTime: Date.now() }));
+    }, intervalMs);
+  }
+  handleClose(code) {
+    this.clearHeartbeat();
+    this.rejectPending(new Error(`CoolClaw WSS connection closed: ${code}`));
+    this.notifyState("disconnected");
+    if (this.stopped || this.isTerminalClose(code)) {
+      return;
+    }
+    this.scheduleReconnect();
+  }
+  scheduleReconnect() {
+    this.clearReconnect();
+    this.notifyState("reconnecting");
+    const baseDelay = this.options.reconnectDelayMs ?? 1e3;
+    const maxDelay = 6e4;
+    const attempt = this.reconnectAttempt++;
+    const delayMs = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+    this.reconnectTimer = setTimeout(() => {
+      if (this.stopped) return;
+      this.connect().catch((error) => {
+        if (!this.stopped) {
+          this.scheduleReconnect();
+        }
+      });
+    }, delayMs);
+  }
+  notifyState(state) {
+    this.options.onStateChange?.(state);
+  }
+  clearHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = void 0;
+    }
+  }
+  clearReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
+  }
+  rejectPending(error) {
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(error);
+    }
+    this.pendingRequests.clear();
+  }
+  isTerminalClose(code) {
+    return code === 4001 || code === 4002 || code === 4003 || code === 4004 || code === 4005;
+  }
+};
+function readPingInterval(payload) {
+  if (!isRecord3(payload) || typeof payload.pingIntervalMs !== "number" || payload.pingIntervalMs <= 0) {
+    return void 0;
+  }
+  return payload.pingIntervalMs;
+}
+function readErrorMessage(payload) {
+  if (isRecord3(payload) && typeof payload.message === "string") {
+    return payload.message;
+  }
+  return "CoolClaw request failed";
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/version.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+var _version;
+function getPluginVersion() {
+  if (_version) return _version;
+  try {
+    const pkgPath = join2(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    _version = pkg.version ?? "0.0.0";
+  } catch {
+    _version = "0.0.0";
+  }
+  return _version;
+}
+
+// src/channel.ts
+import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
+import { createAccountStatusSink, runPassiveAccountLifecycle } from "openclaw/plugin-sdk/channel-lifecycle";
+import { logInboundDrop, logAckFailure } from "openclaw/plugin-sdk/channel-logging";
+var runtimeClients = /* @__PURE__ */ new Map();
+function setRuntimeClient(accountKey, client) {
+  runtimeClients.set(accountKey, client);
+}
+function getRuntimeClient(accountKey) {
+  return runtimeClients.get(accountKey);
+}
+function clearRuntimeClient(accountKey) {
+  runtimeClients.delete(accountKey);
+}
+function extractAccountFromConfig(cfg, accountId) {
+  const coolclawSection = cfg.channels?.coolclaw;
+  const accounts = coolclawSection?.accounts;
+  return accounts?.[accountId ?? "default"] ?? {};
+}
+var coolclawChannelPlugin = createChatChannelPlugin({
+  base: {
+    id: "coolclaw",
+    meta: {
+      id: "coolclaw",
+      label: "CoolClaw",
+      selectionLabel: "CoolClaw",
+      docsPath: "/plugins/coolclaw",
+      blurb: "Connect OpenClaw to the CoolClaw/Riddle chat platform."
+    },
+    capabilities: {
+      chatTypes: ["direct", "group"],
+      media: true,
+      blockStreaming: true
+    },
+    streaming: {
+      blockStreamingCoalesceDefaults: {
+        minChars: 200,
+        idleMs: 3e3
+      }
+    },
+    agentPrompt: {
+      messageToolHints: () => [
+        "To send a message on CoolClaw/Riddle, use the message tool with action='send' and set 'to' to a CoolClaw target like 'coolclaw:human:<userId>', 'coolclaw:agent:<agentId>', or 'coolclaw:group:<groupId>'.",
+        "To send an image or file, use the message tool with action='send' and set 'media' to a local file path or a remote URL.",
+        "When sending a message to a CoolClaw group, the agent will only reply if it was mentioned in the group message.",
+        "When creating a cron job for CoolClaw, set delivery.to to the target CoolClaw ID and delivery.accountId to the current accountId."
+      ]
+    },
+    config: {
+      listAccountIds(cfg) {
+        return Object.keys(cfg.channels?.coolclaw?.accounts ?? {});
+      },
+      resolveAccount(cfg, accountId) {
+        return extractAccountFromConfig(cfg, accountId);
+      },
+      defaultAccountId() {
+        return "default";
+      },
+      isConfigured(account) {
+        return Boolean(account.gatewayUrl && account.agentId && (account.tokenSecretRef || "tokenSecret" in account));
+      },
+      isEnabled(account) {
+        return account?.enabled !== false;
+      },
+      describeAccount(account) {
+        return {
+          accountId: "default",
+          name: account.name,
+          enabled: account.enabled !== false,
+          configured: Boolean(account.gatewayUrl && account.agentId && (account.tokenSecretRef || "tokenSecret" in account)),
+          gatewayUrl: account.gatewayUrl,
+          agentId: account.agentId,
+          tokenConfigured: Boolean(account.tokenSecretRef || "tokenSecret" in account),
+          allowFromCount: account.allowFrom?.length ?? 0,
+          dmPolicy: account.dmPolicy ?? "allowlist"
+        };
+      }
+    },
+    resolver: {
+      async resolveTargets({ inputs }) {
+        return inputs.map((input) => {
+          try {
+            const normalized = normalizeCoolclawTarget(input);
+            const [, type, id] = normalized.split(":");
+            parseCoolclawTarget(normalized);
+            return { input, resolved: true, id: normalized, name: `${type}:${id}` };
+          } catch (error) {
+            return { input, resolved: false, note: error instanceof Error ? error.message : String(error) };
+          }
+        });
+      }
+    },
+    messaging: {
+      normalizeTarget(raw) {
+        try {
+          const normalized = normalizeCoolclawTarget(raw);
+          parseCoolclawTarget(normalized);
+          return normalized;
+        } catch {
+          return void 0;
+        }
+      },
+      inferTargetChatType({ to }) {
+        return inferCoolclawTargetChatType(to);
+      },
+      targetResolver: {
+        hint: "Use coolclaw:human:<id>, coolclaw:agent:<id>, or coolclaw:group:<id>.",
+        looksLikeId(raw, normalized) {
+          return isCoolclawTargetId(raw, normalized);
+        },
+        resolveTarget({ input, normalized, preferredKind }) {
+          return resolveCoolclawMessagingTarget(normalized || input, preferredKind);
+        }
+      }
+    },
+    gateway: {
+      async startAccount(ctx) {
+        const account = coolclawChannelPlugin.config.resolveAccount(ctx.cfg, ctx.accountId);
+        const token = await resolveAccountToken(account);
+        if (!account.gatewayUrl || !account.agentId || !token) {
+          ctx.log?.error(`[${ctx.accountId}] CoolClaw account is not fully configured`);
+          return;
+        }
+        const accountKey = `coolclaw:${ctx.accountId ?? "default"}`;
+        const ackStore = new FileAckStore();
+        const statusSink = createAccountStatusSink({
+          accountId: ctx.accountId,
+          setStatus: ctx.setStatus
+        });
+        statusSink({ statusState: "connecting" });
+        ctx.log?.info(`[${ctx.accountId}] starting CoolClaw provider (${account.gatewayUrl})`);
+        await runPassiveAccountLifecycle({
+          abortSignal: ctx.abortSignal,
+          start: async () => {
+            const client = new CoolclawWsClient({
+              gatewayUrl: account.gatewayUrl,
+              agentId: account.agentId,
+              token,
+              pluginVersion: getPluginVersion(),
+              ackStore,
+              accountKey,
+              onStateChange: (state) => {
+                statusSink({ statusState: state });
+              },
+              onFrame: async (frame, wsClient) => {
+                try {
+                  await handleInboundFrame({
+                    frame,
+                    accountKey,
+                    ackStore,
+                    dispatch: async (envelope) => {
+                      const runtime = getCoolclawRuntime();
+                      if (!runtime?.channel) {
+                        logInboundDrop({ log: ctx.log?.warn?.bind(ctx.log) ?? (() => {
+                        }), channel: "coolclaw", reason: "runtime not available; skipping dispatch" });
+                        return;
+                      }
+                      try {
+                        const isGroup = envelope.conversationId.startsWith("group:");
+                        const peer = isGroup ? { kind: "group", id: envelope.group?.groupId ?? envelope.conversationId } : { kind: "direct", id: envelope.conversationId };
+                        if (!runtime.channel.routing?.resolveAgentRoute) {
+                          throw new Error(
+                            "CoolClaw requires runtime.channel.routing.resolveAgentRoute. Please upgrade OpenClaw to >=2026.3.22."
+                          );
+                        }
+                        const route = await runtime.channel.routing.resolveAgentRoute({
+                          cfg: ctx.cfg,
+                          channel: "coolclaw",
+                          accountId: ctx.accountId,
+                          peer
+                        });
+                        if (!runtime.channel.session?.resolveStorePath) {
+                          throw new Error(
+                            "CoolClaw requires runtime.channel.session.resolveStorePath. Please upgrade OpenClaw to >=2026.3.22."
+                          );
+                        }
+                        const storePath = runtime.channel.session.resolveStorePath(
+                          ctx.cfg.session?.store,
+                          { agentId: route.agentId }
+                        );
+                        const senderLabel = envelope.sender ? `${envelope.sender.userType.toLowerCase()}:${envelope.sender.userId}` : "unknown";
+                        let deliveryTarget;
+                        if (envelope.group) {
+                          deliveryTarget = `coolclaw:group:${envelope.group.groupId}`;
+                        } else if (envelope.sender) {
+                          deliveryTarget = `coolclaw:${envelope.sender.userType.toLowerCase()}:${envelope.sender.userId}`;
+                        } else {
+                          deliveryTarget = normalizeCoolclawTarget(envelope.conversationId);
+                        }
+                        const agentHint = envelope.metadata?.agentHint;
+                        const bodyForAgent = agentHint ? envelope.text + agentHint : envelope.text;
+                        const ctxPayload = runtime.channel.reply.finalizeInboundContext({
+                          Body: envelope.text,
+                          BodyForAgent: bodyForAgent,
+                          RawBody: envelope.text,
+                          CommandBody: envelope.text,
+                          From: `coolclaw:${senderLabel}`,
+                          To: deliveryTarget,
+                          SessionKey: route.sessionKey,
+                          AccountId: ctx.accountId,
+                          ChatType: isGroup ? "channel" : "direct",
+                          CommandAuthorized: true,
+                          Provider: "coolclaw",
+                          Surface: "coolclaw",
+                          Channel: "coolclaw",
+                          Peer: peer,
+                          Mentioned: envelope.shouldReply
+                        });
+                        const sessionKey = ctxPayload.SessionKey ?? route.sessionKey;
+                        const mainSessionKey = route.mainSessionKey;
+                        await runtime.channel.session.recordInboundSession({
+                          storePath,
+                          sessionKey,
+                          ctx: ctxPayload,
+                          updateLastRoute: mainSessionKey && mainSessionKey !== sessionKey ? { sessionKey: mainSessionKey, channel: "coolclaw", to: deliveryTarget, accountId: ctx.accountId ?? void 0 } : void 0,
+                          onRecordError: (err) => {
+                            ctx.log?.warn(`recordInboundSession failed: ${err instanceof Error ? err.message : String(err)}`);
+                          }
+                        });
+                        await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                          ctx: ctxPayload,
+                          cfg: ctx.cfg,
+                          dispatcherOptions: {
+                            deliver: async (payload) => {
+                              if (!payload.text) return;
+                              try {
+                                let replyTarget;
+                                if (envelope.group) {
+                                  replyTarget = `coolclaw:group:${envelope.group.groupId}`;
+                                } else if (envelope.sender) {
+                                  replyTarget = `coolclaw:${envelope.sender.userType.toLowerCase()}:${envelope.sender.userId}`;
+                                } else {
+                                  replyTarget = normalizeCoolclawTarget(envelope.conversationId);
+                                }
+                                await sendText({ client: wsClient, target: replyTarget, text: payload.text });
+                              } catch (err) {
+                                ctx.log?.error(`Failed to deliver reply: ${err instanceof Error ? err.message : String(err)}`);
+                              }
+                            },
+                            onError: (err, info) => {
+                              ctx.log?.error(`Reply dispatch error: ${err instanceof Error ? err.message : String(err)}${info ? ` ${JSON.stringify(info)}` : ""}`);
+                            }
+                          }
+                        });
+                      } catch (err) {
+                        ctx.log?.error(`Inbound dispatch error: ${err instanceof Error ? err.message : String(err)}`);
+                      }
+                    },
+                    sendAck: async (ackFrame) => {
+                      try {
+                        wsClient.sendFrame(ackFrame);
+                        ctx.log?.debug?.(`ACK sent: type=${ackFrame.type} lastAckedSeq=${ackFrame.payload?.lastAckedSeq}`);
+                      } catch (err) {
+                        logAckFailure({ log: ctx.log?.warn?.bind(ctx.log) ?? (() => {
+                        }), channel: "coolclaw", error: err });
+                      }
+                    }
+                  });
+                } catch (err) {
+                  ctx.log?.error(`Frame handling error: ${err instanceof Error ? err.message : String(err)}`);
+                }
+              }
+            });
+            await client.start();
+            setRuntimeClient(accountKey, client);
+            statusSink({ statusState: "connected" });
+            ctx.log?.info(`[${ctx.accountId}] CoolClaw provider connected`);
+            return client;
+          },
+          stop: async (client) => {
+            await client.stop();
+            clearRuntimeClient(accountKey);
+          },
+          onStop: () => {
+            statusSink({ statusState: "disconnected" });
+            ctx.log?.info(`[${ctx.accountId}] CoolClaw provider stopped`);
+          }
+        });
+      },
+      /** 显式停止账户连接，清理 WebSocket 客户端资源 */
+      async stopAccount(ctx) {
+        const accountKey = `coolclaw:${ctx.accountId ?? "default"}`;
+        const client = getRuntimeClient(accountKey);
+        if (client) {
+          await client.stop();
+          clearRuntimeClient(accountKey);
+          ctx.log?.info(`[${ctx.accountId}] CoolClaw client stopped via stopAccount`);
+        }
+      }
+    },
+    /** auth 适配器 — 支持 openclaw channels login --channel coolclaw 原生命令 */
+    auth: {
+      async login({ cfg, accountId, verbose }) {
+        const resolvedAccountId = accountId?.trim() || "default";
+        const account = coolclawChannelPlugin.config.resolveAccount(cfg, resolvedAccountId);
+        const { validateAgentToken, runCoolclawSetup } = await import("./setup-T2A3RRG7.js");
+        const existingToken = account.tokenSecretRef ? await resolveAccountToken(account) : void 0;
+        if (existingToken) {
+          const gatewayUrl = account.gatewayUrl ?? "https://agits-xa.baidu.com/riddle";
+          const valid = await validateAgentToken(gatewayUrl, existingToken);
+          if (valid) {
+            if (verbose) console.log("[coolclaw] Already authenticated.");
+            return;
+          }
+        }
+        if (verbose) console.log("[coolclaw] Running setup...");
+        const result = await runCoolclawSetup({
+          gatewayUrl: account.gatewayUrl,
+          accountId: resolvedAccountId,
+          autoRestart: false
+          // login 场景不需要重启网关
+        });
+        if (result.mode === "register") {
+          if (verbose) console.log(`[coolclaw] Agent registered: ${result.agentId}`);
+        } else {
+          if (verbose) console.log(`[coolclaw] Reusing existing agent: ${result.agentId}`);
+        }
+        if (verbose) console.log("[coolclaw] Authentication complete.");
+      }
+    }
+  },
+  security: {
+    dm: {
+      channelKey: "coolclaw",
+      resolvePolicy: (account) => account.dmPolicy ?? "allowlist",
+      resolveAllowFrom: (account) => account.allowFrom ?? [],
+      defaultPolicy: "allowlist",
+      normalizeEntry: (raw) => raw.trim().toLowerCase()
+    }
+  },
+  pairing: {
+    text: {
+      idLabel: "CoolClaw user ID",
+      message: "You are not authorized to message this agent. Send this pairing code to verify:",
+      notify: async ({ id, message }) => {
+        const client = getRuntimeClient("coolclaw:default");
+        if (client) {
+          await sendText({
+            client,
+            target: id,
+            text: message
+          });
+        }
+      }
+    }
+  },
+  threading: {
+    topLevelReplyToMode: "reply"
+  },
+  outbound: {
+    base: {
+      deliveryMode: "direct",
+      resolveTarget({ to }) {
+        if (!to) {
+          return { ok: false, error: new Error("CoolClaw target is required") };
+        }
+        try {
+          const normalized = normalizeCoolclawTarget(to);
+          parseCoolclawTarget(normalized);
+          return { ok: true, to: normalized };
+        } catch (error) {
+          return { ok: false, error: error instanceof Error ? error : new Error(String(error)) };
+        }
+      }
+    },
+    attachedResults: {
+      channel: "coolclaw",
+      async sendText(ctx) {
+        const account = coolclawChannelPlugin.config.resolveAccount(ctx.cfg, ctx.accountId);
+        const token = await resolveAccountToken(account);
+        if (!account.gatewayUrl || !account.agentId || !token) {
+          throw new Error("CoolClaw account is not fully configured");
+        }
+        const accountKey = `coolclaw:${ctx.accountId ?? "default"}`;
+        let client = getRuntimeClient(accountKey);
+        if (!client || !client.isConnected()) {
+          client = new CoolclawWsClient({
+            gatewayUrl: account.gatewayUrl,
+            agentId: account.agentId,
+            token,
+            pluginVersion: getPluginVersion(),
+            ackStore: new InMemoryAckStore(),
+            accountKey
+          });
+          await client.start();
+          try {
+            const messageId2 = await sendText({ client, target: ctx.to, text: ctx.text });
+            return { messageId: messageId2, conversationId: ctx.to, timestamp: Date.now() };
+          } finally {
+            await client.stop();
+          }
+        }
+        const messageId = await sendText({ client, target: ctx.to, text: ctx.text });
+        return { messageId, conversationId: ctx.to, timestamp: Date.now() };
+      },
+      async sendMedia(ctx) {
+        const account = coolclawChannelPlugin.config.resolveAccount(ctx.cfg, ctx.accountId);
+        const token = await resolveAccountToken(account);
+        if (!account.gatewayUrl || !account.agentId || !token) {
+          throw new Error("CoolClaw account is not fully configured");
+        }
+        const accountKey = `coolclaw:${ctx.accountId ?? "default"}`;
+        let client = getRuntimeClient(accountKey);
+        if (!client || !client.isConnected()) {
+          client = new CoolclawWsClient({
+            gatewayUrl: account.gatewayUrl,
+            agentId: account.agentId,
+            token,
+            pluginVersion: getPluginVersion(),
+            ackStore: new InMemoryAckStore(),
+            accountKey
+          });
+          await client.start();
+          try {
+            const messageId2 = await sendMedia({ client, target: ctx.to, filePath: ctx.mediaUrl ?? "" });
+            return { messageId: messageId2, conversationId: ctx.to, timestamp: Date.now() };
+          } finally {
+            await client.stop();
+          }
+        }
+        const messageId = await sendMedia({ client, target: ctx.to, filePath: ctx.mediaUrl ?? "" });
+        return { messageId, conversationId: ctx.to, timestamp: Date.now() };
+      }
+    }
+  }
+});
+
+export {
+  setCoolclawRuntime,
+  coolclawChannelPlugin
+};