@clawroom/openclaw 0.5.0 → 0.5.1

package/node_modules/@clawroom/protocol/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@clawroom/protocol",
+  "version": "0.5.1",
+  "description": "ClawRoom shared types — models, messages, and protocol definitions",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/clawroom/clawroom.git"
+  },
+  "files": [
+    "src"
+  ],
+  "exports": {
+    ".": "./src/index.ts"
+  }
+}

package/node_modules/@clawroom/protocol/src/index.ts

@@ -0,0 +1,102 @@
+export interface AgentHeartbeat {
+  type: "agent.heartbeat";
+}
+
+export interface AgentResultFile {
+  filename: string;
+  mimeType: string;
+  data: string;
+}
+
+export interface AgentComplete {
+  type: "agent.complete";
+  taskId: string;
+  output: string;
+  attachments?: AgentResultFile[];
+}
+
+export interface AgentProgress {
+  type: "agent.progress";
+  taskId: string;
+  message: string;
+  percent?: number;
+}
+
+export interface AgentFail {
+  type: "agent.fail";
+  taskId: string;
+  reason: string;
+}
+
+export interface AgentChatReply {
+  type: "agent.chat.reply";
+  channelId: string;
+  content: string;
+  replyTo?: string;
+}
+
+export interface AgentTyping {
+  type: "agent.typing";
+  channelId: string;
+}
+
+export type AgentMessage =
+  | AgentHeartbeat
+  | AgentComplete
+  | AgentProgress
+  | AgentFail
+  | AgentChatReply
+  | AgentTyping;
+
+export interface ServerTask {
+  type: "server.task";
+  taskId: string;
+  title: string;
+  description: string;
+  input: string;
+  skillTags: string[];
+}
+
+export interface ServerChatMessage {
+  messageId: string;
+  channelId: string;
+  content: string;
+  context: Array<{
+    id: string;
+    senderType: string;
+    senderName: string;
+    content: string;
+    createdAt: number;
+  }>;
+}
+
+export type ServerMessage = ServerTask | ServerChatMessage;
+
+/**
+ * Runtime definitions — shared between bridge, server, and UI.
+ *
+ * bridgeManaged = true:  executed by bridge daemon (spawns CLI process, messages via /api/bridge/poll)
+ * bridgeManaged = false: executed by something else (e.g. OpenClaw plugin, messages via /api/machines/poll)
+ */
+export interface RuntimeDef {
+  id: string;
+  displayName: string;
+  /** CLI binary name to detect on PATH (empty = not detectable) */
+  binary: string;
+  /** Whether the bridge daemon spawns and manages a CLI process for this runtime */
+  bridgeManaged: boolean;
+  /** Badge color for UI */
+  badgeColor: string;
+}
+
+export const RUNTIMES: RuntimeDef[] = [
+  { id: "claude-code", displayName: "Claude Code", binary: "claude", bridgeManaged: true, badgeColor: "bg-[#7c5cbf] text-white" },
+  { id: "codex", displayName: "Codex", binary: "codex", bridgeManaged: true, badgeColor: "bg-[#2ea043] text-white" },
+  { id: "qwen-code", displayName: "Qwen Code", binary: "qwen", bridgeManaged: true, badgeColor: "bg-[#1a73e8] text-white" },
+  { id: "kimi", displayName: "Kimi", binary: "kimi", bridgeManaged: true, badgeColor: "bg-[#ff6b35] text-white" },
+  { id: "openclaw", displayName: "OpenClaw", binary: "", bridgeManaged: false, badgeColor: "bg-[var(--color-border)] text-[var(--color-text-secondary)]" },
+];
+
+/** Bridge-managed runtimes: server skips dequeue in /api/machines/poll (they use /api/bridge/poll instead) */
+export const BRIDGE_MANAGED_RUNTIME_IDS = new Set(RUNTIMES.filter((r) => r.bridgeManaged).map((r) => r.id));
+export const RUNTIME_MAP = new Map(RUNTIMES.map((r) => [r.id, r]));

package/node_modules/@clawroom/sdk/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@clawroom/sdk",
+  "version": "0.5.1",
+  "description": "ClawRoom SDK — polling client and protocol types for connecting any agent to ClawRoom",
+  "type": "module",
+  "license": "MIT",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/clawroom/clawroom.git"
+  },
+  "keywords": [
+    "clawroom",
+    "sdk",
+    "agent",
+    "workspace"
+  ],
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "@clawroom/protocol": "^0.5.1"
+  }
+}

package/node_modules/@clawroom/sdk/src/client.ts

@@ -0,0 +1,180 @@
+import type {
+  AgentMessage,
+  ServerTask,
+  ServerChatMessage,
+} from "./protocol.js";
+import { WsTransport } from "./ws-transport.js";
+
+const DEFAULT_ENDPOINT = "https://clawroom.site9.ai/api/agents";
+const HEARTBEAT_INTERVAL_MS = 30_000;
+const POLL_INTERVAL_MS = 10_000;
+
+export type TaskCallback = (task: ServerTask) => void;
+export type ChatCallback = (messages: ServerChatMessage[]) => void;
+
+export type ClawroomClientOptions = {
+  endpoint?: string;
+  token: string;
+  deviceId: string;
+  skills: string[];
+  kind?: string;
+  wsUrl?: string;
+  log?: {
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
+  };
+};
+
+/**
+ * ClawRoom SDK client.
+ * WebSocket primary for real-time push, HTTP polling as fallback.
+ */
+export class ClawroomClient {
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  protected stopped = false;
+  protected readonly httpBase: string;
+  protected readonly options: ClawroomClientOptions;
+  protected taskCallbacks: TaskCallback[] = [];
+  protected chatCallbacks: ChatCallback[] = [];
+  private wsTransport: WsTransport | null = null;
+
+  constructor(options: ClawroomClientOptions) {
+    this.options = options;
+    this.httpBase = (options.endpoint || DEFAULT_ENDPOINT).replace(/\/+$/, "");
+  }
+
+  private get wsUrl(): string {
+    if (this.options.wsUrl) return this.options.wsUrl;
+    return this.httpBase.replace(/\/api\/agents$/, "").replace(/^http/, "ws") + "/api/ws";
+  }
+
+  connect(): void {
+    this.stopped = false;
+    this.startHeartbeat();
+    void this.register();
+
+    // WebSocket transport
+    this.wsTransport = new WsTransport({
+      url: this.wsUrl,
+      token: this.options.token,
+      log: { info: (m) => this.options.log?.info?.(m), warn: (m) => this.options.log?.warn?.(m) },
+      onConnected: () => { this.options.log?.info?.("[clawroom] WebSocket connected"); },
+      onDisconnected: () => { this.options.log?.info?.("[clawroom] WebSocket disconnected"); },
+      onMessage: (msg) => {
+        if (msg.type === "task" && msg.task) {
+          for (const cb of this.taskCallbacks) cb(msg.task);
+        }
+        if (msg.type === "chat" && Array.isArray(msg.messages)) {
+          for (const cb of this.chatCallbacks) cb(msg.messages);
+        }
+      },
+    });
+    this.wsTransport.connect();
+
+    // HTTP poll fallback — only when WS is down
+    this.stopPolling();
+    this.pollTimer = setInterval(() => {
+      if (this.wsTransport?.connected) return;
+      void this.pollTick();
+    }, POLL_INTERVAL_MS);
+  }
+
+  disconnect(): void {
+    this.stopped = true;
+    this.stopHeartbeat();
+    this.stopPolling();
+    this.wsTransport?.disconnect();
+    this.wsTransport = null;
+  }
+
+  send(message: AgentMessage): void {
+    this.sendViaHttp(message).catch(() => {});
+  }
+
+  onTask(cb: TaskCallback): void { this.taskCallbacks.push(cb); }
+  onChatMessage(cb: ChatCallback): void { this.chatCallbacks.push(cb); }
+
+  // ── Heartbeat ─────────────────────────────────────────
+
+  private startHeartbeat(): void {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.stopped) void this.register();
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null; }
+  }
+
+  private stopPolling(): void {
+    if (this.pollTimer) { clearInterval(this.pollTimer); this.pollTimer = null; }
+  }
+
+  protected async register(): Promise<void> {
+    try {
+      await this.httpRequest("POST", "/heartbeat", {
+        deviceId: this.options.deviceId,
+        skills: this.options.skills,
+        kind: this.options.kind ?? "openclaw",
+      });
+      this.onPollSuccess(undefined);
+    } catch (err) {
+      this.options.log?.warn?.(`[clawroom] heartbeat error: ${err}`);
+      this.onPollError(err);
+    }
+  }
+
+  protected async pollTick(): Promise<void> {
+    if (this.stopped) return;
+    try {
+      const res = await this.httpRequest("POST", "/poll", {});
+      this.onPollSuccess(res?.agentId);
+      if (res.task) {
+        this.options.log?.info?.(`[clawroom] received task ${res.task.taskId}: ${res.task.title}`);
+        for (const cb of this.taskCallbacks) cb(res.task);
+      }
+      if (res.chat && Array.isArray(res.chat) && res.chat.length > 0) {
+        this.options.log?.info?.(`[clawroom] received ${res.chat.length} chat mention(s)`);
+        for (const cb of this.chatCallbacks) cb(res.chat);
+      }
+    } catch (err) {
+      this.options.log?.warn?.(`[clawroom] poll error: ${err}`);
+      this.onPollError(err);
+    }
+  }
+
+  protected onPollSuccess(_agentId: string | undefined): void {}
+  protected onPollError(_err: unknown): void {}
+
+  // ── HTTP ──────────────────────────────────────────────
+
+  private async sendViaHttp(message: AgentMessage): Promise<void> {
+    switch (message.type) {
+      case "agent.complete": await this.httpRequest("POST", "/complete", { taskId: message.taskId, output: message.output, attachments: message.attachments }); break;
+      case "agent.fail": await this.httpRequest("POST", "/fail", { taskId: message.taskId, reason: message.reason }); break;
+      case "agent.progress": await this.httpRequest("POST", "/progress", { taskId: message.taskId, message: message.message, percent: message.percent }); break;
+      case "agent.heartbeat": await this.httpRequest("POST", "/heartbeat", {}); break;
+      case "agent.chat.reply": await this.httpRequest("POST", "/chat/reply", { channelId: message.channelId, content: message.content, replyTo: message.replyTo }); break;
+      case "agent.typing": await this.httpRequest("POST", "/typing", { channelId: message.channelId }); break;
+    }
+  }
+
+  protected async httpRequest(method: string, path: string, body: unknown): Promise<any> {
+    const res = await fetch(`${this.httpBase}${path}`, {
+      method,
+      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${this.options.token}` },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      this.onHttpError(res.status, text);
+      throw new Error(`HTTP ${res.status}: ${text}`);
+    }
+    return res.json();
+  }
+
+  protected onHttpError(_status: number, _text: string): void {}
+}

package/node_modules/@clawroom/sdk/src/index.ts

@@ -0,0 +1,20 @@
+export { ClawroomClient } from "./client.js";
+export type { ClawroomClientOptions } from "./client.js";
+export { ClawroomMachineClient } from "./machine-client.js";
+export type { ClawroomMachineClientOptions } from "./machine-client.js";
+export { WsTransport } from "./ws-transport.js";
+export type { WsTransportOptions } from "./ws-transport.js";
+
+export type {
+  AgentMessage,
+  AgentHeartbeat,
+  AgentComplete,
+  AgentProgress,
+  AgentResultFile,
+  AgentFail,
+  AgentChatReply,
+  AgentTyping,
+  ServerMessage,
+  ServerTask,
+  ServerChatMessage,
+} from "./protocol.js";

package/node_modules/@clawroom/sdk/src/machine-client.ts

@@ -0,0 +1,209 @@
+/**
+ * ClawRoom Machine Client — machine-level auth with multi-agent support.
+ * WebSocket primary for real-time push, HTTP polling as fallback.
+ */
+
+import * as os from "node:os";
+import { WsTransport } from "./ws-transport.js";
+
+export type ClawroomMachineClientOptions = {
+  endpoint?: string;
+  apiKey: string;
+  hostname?: string;
+  capabilities?: string[];
+  wsUrl?: string;
+  log?: {
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
+  };
+};
+
+type AgentWork = {
+  agentId: string;
+  agentName: string;
+  task: { type: "server.task"; taskId: string; title: string; description: string; input: string; skillTags: string[] } | null;
+  chat: Array<{ messageId: string; channelId: string; content: string; isMention: boolean; context: unknown[] }> | null;
+};
+
+type MachineHeartbeatResponse = {
+  machineId: string;
+  agents?: Array<{ id: string }>;
+};
+
+type MachinePollResponse = {
+  machineId: string;
+  agents: AgentWork[];
+};
+
+export class ClawroomMachineClient {
+  private options: ClawroomMachineClientOptions;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  private taskHandler: ((agentId: string, task: AgentWork["task"]) => void) | null = null;
+  private chatHandler: ((agentId: string, messages: NonNullable<AgentWork["chat"]>) => void) | null = null;
+  private _connected = false;
+  private _stopped = false;
+  private wsTransport: WsTransport | null = null;
+  private subscribedAgentIds = new Set<string>();
+  private recentChatIds = new Map<string, number>();
+
+  constructor(options: ClawroomMachineClientOptions) {
+    this.options = options;
+  }
+
+  private get baseUrl(): string {
+    return this.options.endpoint ?? "http://localhost:3000/api/machines";
+  }
+
+  private get wsUrl(): string {
+    if (this.options.wsUrl) return this.options.wsUrl;
+    return this.baseUrl.replace(/\/api\/machines$/, "").replace(/^http/, "ws") + "/api/ws";
+  }
+
+  private async httpRequest(method: string, path: string, body?: unknown): Promise<unknown> {
+    const url = `${this.baseUrl}${path}`;
+    const res = await fetch(url, {
+      method,
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${this.options.apiKey}` },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    return res.json();
+  }
+
+  onAgentTask(handler: (agentId: string, task: AgentWork["task"]) => void) { this.taskHandler = handler; }
+  onAgentChat(handler: (agentId: string, messages: NonNullable<AgentWork["chat"]>) => void) { this.chatHandler = handler; }
+
+  async sendAgentComplete(agentId: string, taskId: string, output: string, attachments?: Array<{ filename: string; mimeType: string; data: string }>) {
+    await this.httpRequest("POST", "/complete", { agentId, taskId, output, attachments });
+  }
+
+  async sendAgentFail(agentId: string, taskId: string, reason: string) {
+    await this.httpRequest("POST", "/fail", { agentId, taskId, reason });
+  }
+
+  async sendAgentChatReply(agentId: string, channelId: string, content: string) {
+    await this.httpRequest("POST", "/chat-reply", { agentId, channelId, content });
+  }
+
+  async sendAgentTyping(agentId: string, channelId: string) {
+    await this.httpRequest("POST", "/typing", { agentId, channelId });
+  }
+
+  get connected() { return this._connected; }
+  get stopped() { return this._stopped; }
+
+  private rememberChat(messageId: string): boolean {
+    if (!messageId) return true;
+    const now = Date.now();
+    for (const [id, seenAt] of this.recentChatIds) {
+      if (now - seenAt > 10 * 60_000) this.recentChatIds.delete(id);
+    }
+    if (this.recentChatIds.has(messageId)) return false;
+    this.recentChatIds.set(messageId, now);
+    return true;
+  }
+
+  private syncAgentSubscriptions(agentIds: string[]) {
+    if (agentIds.length === 0) return;
+    for (const agentId of agentIds) {
+      this.subscribedAgentIds.add(agentId);
+      this.wsTransport?.send({ type: "subscribe_agent", agentId });
+    }
+  }
+
+  private async pollOnce() {
+    if (!this._connected) return;
+    try {
+      const result = (await this.httpRequest("POST", "/poll", {})) as MachinePollResponse;
+      this.syncAgentSubscriptions(result.agents.map((agent) => agent.agentId));
+      for (const agent of result.agents) {
+        if (agent.task && this.taskHandler) this.taskHandler(agent.agentId, agent.task);
+        if (agent.chat && agent.chat.length > 0 && this.chatHandler) {
+          const freshMessages = agent.chat.filter((message) => this.rememberChat(message.messageId));
+          if (freshMessages.length > 0) this.chatHandler(agent.agentId, freshMessages);
+        }
+      }
+    } catch (err) {
+      this.options.log?.warn?.(`[machine] poll error: ${err}`);
+    }
+  }
+
+  connect() {
+    this._stopped = false;
+    const hostname = this.options.hostname ?? os.hostname();
+    const hbBody = { hostname, capabilities: this.options.capabilities };
+
+    // Heartbeat every 30s (always HTTP)
+    this.heartbeatTimer = setInterval(async () => {
+      try {
+        const result = (await this.httpRequest("POST", "/heartbeat", hbBody)) as MachineHeartbeatResponse;
+        this.syncAgentSubscriptions((result.agents ?? []).map((agent) => agent.id));
+        if (!this._connected) { this._connected = true; this.options.log?.info?.("[machine] connected"); }
+      } catch {
+        if (this._connected) { this._connected = false; this.options.log?.warn?.("[machine] disconnected"); }
+      }
+    }, 30_000);
+
+    this.httpRequest("POST", "/heartbeat", hbBody)
+      .then((result) => {
+        const data = result as MachineHeartbeatResponse;
+        this._connected = true;
+        this.syncAgentSubscriptions((data.agents ?? []).map((agent) => agent.id));
+        this.options.log?.info?.("[machine] connected");
+      })
+      .catch((err) => this.options.log?.warn?.(`[machine] initial heartbeat failed: ${err}`));
+
+    // WebSocket transport
+    this.wsTransport = new WsTransport({
+      url: this.wsUrl,
+      token: this.options.apiKey,
+      log: { info: (m) => this.options.log?.info?.(m), warn: (m) => this.options.log?.warn?.(m) },
+      onConnected: () => {
+        this.syncAgentSubscriptions([...this.subscribedAgentIds]);
+        this.options.log?.info?.("[machine] WebSocket connected");
+      },
+      onDisconnected: () => {
+        this.options.log?.info?.("[machine] WebSocket disconnected, HTTP polling active");
+      },
+      onMessage: (msg) => {
+        if (msg.type === "message") {
+          const m = msg.message;
+          const targetAgentId = msg.agentId ?? m?.agentId;
+          const messageId = m?.id ?? msg.messageId ?? "";
+          if (m && targetAgentId && this.chatHandler && this.rememberChat(messageId)) {
+            this.chatHandler(targetAgentId, [{
+              messageId,
+              channelId: m.channelId ?? "",
+              content: m.content ?? "",
+              isMention: msg.isMention ?? false,
+              context: msg.context ?? [],
+            }]);
+          }
+        }
+        if (msg.type === "task" && msg.agentId && this.taskHandler) {
+          this.taskHandler(msg.agentId, msg.task);
+        }
+      },
+    });
+    this.wsTransport.connect();
+
+    // Keep HTTP polling active even when WS is up.
+    // Machine WS chat delivery is best-effort; polling is the durable delivery path.
+    this.pollTimer = setInterval(async () => {
+      await this.pollOnce();
+    }, 10_000);
+
+    void this.pollOnce();
+  }
+
+  disconnect() {
+    this._stopped = true;
+    this._connected = false;
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    this.wsTransport?.disconnect();
+    this.wsTransport = null;
+  }
+}

package/node_modules/@clawroom/sdk/src/protocol.ts

@@ -0,0 +1,20 @@
+export type {
+  AgentHeartbeat,
+  AgentResultFile,
+  AgentComplete,
+  AgentProgress,
+  AgentFail,
+  AgentChatReply,
+  AgentTyping,
+  AgentMessage,
+  ServerTask,
+  ServerChatMessage,
+  ServerMessage,
+  RuntimeDef,
+} from "@clawroom/protocol";
+
+export {
+  RUNTIMES,
+  BRIDGE_MANAGED_RUNTIME_IDS,
+  RUNTIME_MAP,
+} from "@clawroom/protocol";

package/node_modules/@clawroom/sdk/src/ws-transport.ts

@@ -0,0 +1,123 @@
+/**
+ * Shared WebSocket transport with auto-reconnect and fallback support.
+ * Used by both ClawroomClient and ClawroomMachineClient.
+ */
+
+export type WsTransportOptions = {
+  url: string;
+  token: string;
+  onMessage: (msg: any) => void;
+  onConnected: () => void;
+  onDisconnected: () => void;
+  log?: {
+    info?: (message: string) => void;
+    warn?: (message: string) => void;
+  };
+};
+
+export class WsTransport {
+  private ws: any = null;
+  private options: WsTransportOptions;
+  private _connected = false;
+  private stopped = false;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private reconnectDelay = 1000;
+  private failCount = 0;
+
+  static readonly MAX_RECONNECT_DELAY = 60_000;
+  static readonly MAX_RECONNECT_FAILS = 10;
+
+  constructor(options: WsTransportOptions) {
+    this.options = options;
+  }
+
+  get connected() { return this._connected; }
+
+  async connect() {
+    if (this.stopped) return;
+
+    let WebSocket: any;
+    try {
+      WebSocket = (await import("ws")).default;
+    } catch {
+      this.options.log?.info?.("ws module not available, skipping WebSocket");
+      return;
+    }
+
+    try {
+      this.ws = new WebSocket(this.options.url);
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+
+    this.ws.on("open", () => {
+      this.reconnectDelay = 1000;
+      this.ws.send(JSON.stringify({ type: "auth", token: this.options.token }));
+    });
+
+    this.ws.on("message", (raw: any) => {
+      let msg: any;
+      try { msg = JSON.parse(raw.toString()); } catch { return; }
+
+      if (msg.type === "auth_ok") {
+        this._connected = true;
+        this.failCount = 0;
+        this.options.onConnected();
+        return;
+      }
+
+      if (msg.type === "auth_error") {
+        this._connected = false;
+        this.options.log?.warn?.(`WS auth failed: ${msg.error ?? "unknown"}`);
+        this.ws?.close();
+        return;
+      }
+
+      if (msg.type === "pong") return;
+
+      this.options.onMessage(msg);
+    });
+
+    this.ws.on("close", () => {
+      const wasConnected = this._connected;
+      this._connected = false;
+      if (wasConnected) this.options.onDisconnected();
+      if (!this.stopped) this.scheduleReconnect();
+    });
+
+    this.ws.on("error", () => {
+      this._connected = false;
+    });
+  }
+
+  send(msg: any) {
+    if (this._connected && this.ws?.readyState === 1) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+
+  disconnect() {
+    this.stopped = true;
+    this._connected = false;
+    if (this.reconnectTimer) { clearTimeout(this.reconnectTimer); this.reconnectTimer = null; }
+    if (this.ws) { this.ws.close(); this.ws = null; }
+  }
+
+  private scheduleReconnect() {
+    if (this.stopped || this.reconnectTimer) return;
+
+    this.failCount++;
+    if (this.failCount > WsTransport.MAX_RECONNECT_FAILS) {
+      this.options.log?.warn?.(`WS reconnect failed ${this.failCount} times, giving up. HTTP polling active.`);
+      return;
+    }
+
+    const jitter = Math.random() * 3000;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, Math.min(this.reconnectDelay + jitter, WsTransport.MAX_RECONNECT_DELAY));
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, WsTransport.MAX_RECONNECT_DELAY);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawroom/openclaw",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "OpenClaw channel plugin for ClawRoom",
   "type": "module",
   "license": "MIT",
@@ -22,7 +22,7 @@
     "@clawroom/sdk"
   ],
   "dependencies": {
-    "@clawroom/sdk": "^0.5.0"
+    "@clawroom/sdk": "^0.5.1"
   },
   "peerDependencies": {
     "openclaw": "*"

package/src/client.ts

@@ -30,7 +30,7 @@ export class ClawroomPluginClient {
   onAgentChat(handler: (agentId: string, messages: any[]) => void) { this.inner.onAgentChat(handler); }
 
   async sendComplete(agentId: string, taskId: string, output: string, attachments?: Array<{ filename: string; mimeType: string; data: string }>) {
-    await this.inner.sendAgentComplete(agentId, taskId, output);
+    await this.inner.sendAgentComplete(agentId, taskId, output, attachments);
   }
 
   async sendFail(agentId: string, taskId: string, reason: string) {