@clawroom/openclaw 0.5.0 → 0.5.19

package/src/channel.ts

@@ -1,19 +1,18 @@
 import type { ChannelPlugin } from "openclaw/plugin-sdk/core";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { ClawroomClient } from "@clawroom/sdk";
 // import { collectSkills } from "./skill-reporter.js";
 import { getClawroomRuntime } from "./runtime.js";
-import { ClawroomPluginClient } from "./client.js";
 import { setupTaskExecutor } from "./task-executor.js";
 import { setupChatExecutor } from "./chat-executor.js";
 
 // ── Config resolution ────────────────────────────────────────────────
 
-const DEFAULT_ENDPOINT = "https://clawroom.site9.ai/api/machines";
+const DEFAULT_ENDPOINT = "https://clawroom.site9.ai/api/agents";
 const DEFAULT_ACCOUNT_ID = "default";
 
 interface ClawroomAccountConfig {
-  api_key?: string;
-  token?: string; // deprecated, fallback
+  token?: string;
   endpoint?: string;
   skills?: string[];
   enabled?: boolean;
@@ -24,7 +23,7 @@ interface ResolvedClawroomAccount {
   name: string;
   enabled: boolean;
   configured: boolean;
-  apiKey: string;
+  token: string;
   endpoint: string;
   skills: string[];
 }
@@ -40,7 +39,7 @@ function resolveClawroomAccount(opts: {
   accountId?: string | null;
 }): ResolvedClawroomAccount {
   const section = readClawroomSection(opts.cfg);
-  const apiKey = section.api_key ?? section.token ?? "";
+  const token = section.token ?? "";
   const endpoint = section.endpoint || DEFAULT_ENDPOINT;
   const skills = Array.isArray(section.skills) ? section.skills : [];
   const enabled = section.enabled !== false;
@@ -49,8 +48,8 @@ function resolveClawroomAccount(opts: {
     accountId: opts.accountId ?? DEFAULT_ACCOUNT_ID,
     name: "ClawRoom",
     enabled,
-    configured: apiKey.length > 0,
-    apiKey,
+    configured: token.length > 0,
+    token,
     endpoint,
     skills,
   };
@@ -58,7 +57,7 @@ function resolveClawroomAccount(opts: {
 
 // ── Persistent client per gateway lifecycle ───────────────────────
 
-let activeClient: ClawroomPluginClient | null = null;
+let activeClient: ClawroomClient | null = null;
 
 // ── Channel plugin definition ────────────────────────────────────────
 
@@ -105,9 +104,10 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
     deliveryMode: "direct",
 
     sendText: async ({ to, text }) => {
+      void text;
       // Outbound path — task results are sent directly by executors,
-      // this is a fallback if openclaw routing triggers outbound delivery.
-      // No-op for machine client (executors handle it).
+      // this is a fallback if OpenClaw routing triggers outbound delivery.
+      // Direct agent delivery is handled by the executors.
       return { channel: "clawroom", messageId: to, to };
     },
   },
@@ -118,16 +118,19 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
 
       if (!account.configured) {
         throw new Error(
-          "ClawRoom is not configured: set channels.clawroom.api_key in your OpenClaw config.",
+          "ClawRoom is not configured: set channels.clawroom.token in your OpenClaw config.",
         );
       }
 
       const runtime = getClawroomRuntime();
       const log = ctx.log ?? undefined;
 
-      const client = new ClawroomPluginClient({
+      const client = new ClawroomClient({
         endpoint: account.endpoint,
-        apiKey: account.apiKey,
+        token: account.token,
+        deviceId: `openclaw:${account.accountId}`,
+        skills: account.skills,
+        kind: "openclaw",
         log,
       });
 
@@ -155,40 +158,22 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
         });
       };
 
-      // Wire up polling events to OpenClaw health status
-      client.onWelcome(() => publishConnected());
-      client.onDisconnect(() => publishDisconnected());
-      client.onFatal((reason) => {
-        log?.error?.(`[clawroom] fatal error: ${reason}`);
-        ctx.setStatus({
-          accountId: account.accountId,
-          running: false,
-          connected: false,
-          lastStopAt: Date.now(),
-          lastStartAt: null,
-          lastError: `Fatal: ${reason}`,
-        });
-      });
+      client.onConnected(() => publishConnected());
+      client.onDisconnected(() => publishDisconnected());
 
+      if (activeClient && activeClient !== client) {
+        activeClient.disconnect();
+      }
       setupTaskExecutor({ client: client, runtime, log });
       setupChatExecutor({ client: client, runtime, log });
       client.connect();
       activeClient = client;
 
-      publishDisconnected("connecting via HTTP polling...");
-
-      // Health check: if client somehow stopped, restart it.
-      const healthCheck = setInterval(() => {
-        if (!client.isAlive) {
-          log?.warn?.("[clawroom] client died unexpectedly, restarting...");
-          client.connect();
-        }
-      }, 30_000);
+      publishDisconnected("connecting via agent polling...");
 
       // Keep alive until gateway shuts down — only then disconnect
       await new Promise<void>((resolve) => {
         ctx.abortSignal.addEventListener("abort", () => {
-          clearInterval(healthCheck);
           client.disconnect();
           activeClient = null;
           ctx.setStatus({
@@ -235,24 +220,3 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
     }),
   },
 };
-
-// ── Helpers ──────────────────────────────────────────────────────────
-
-/**
- * Build a stable device identifier. We use the machine hostname from the
- * runtime environment when available, falling back to a random id.
- */
-function resolveDeviceId(ctx: {
-  runtime?: unknown;
-}): string {
-  // The RuntimeEnv may expose hostname or machineId depending on version
-  const r = ctx.runtime as Record<string, unknown>;
-  if (typeof r.machineId === "string" && r.machineId) {
-    return r.machineId;
-  }
-  if (typeof r.hostname === "string" && r.hostname) {
-    return r.hostname;
-  }
-  // Fallback: random id for this session
-  return `agent-${Math.random().toString(36).slice(2, 10)}`;
-}

package/src/chat-executor.ts

@@ -1,5 +1,6 @@
 import type { PluginRuntime } from "openclaw/plugin-sdk/core";
-import type { ClawroomPluginClient } from "./client.js";
+import type { AgentChatProfile, ClawroomClient, ServerChatMessage } from "@clawroom/sdk";
+import { extractToolNames, reportPluginReflectionSoon } from "./reflections.js";
 
 /** Default timeout for chat reply subagent (2 minutes). */
 const CHAT_TIMEOUT_MS = 2 * 60 * 1000;
@@ -11,7 +12,7 @@ const CHAT_TIMEOUT_MS = 2 * 60 * 1000;
  *   3. Send reply back to channel
  */
 export function setupChatExecutor(opts: {
-  client: ClawroomPluginClient;
+  client: ClawroomClient;
   runtime: PluginRuntime;
   log?: {
     info?: (message: string, ...args: unknown[]) => void;
@@ -20,8 +21,27 @@ export function setupChatExecutor(opts: {
   };
 }): void {
   const { client, runtime, log } = opts;
+  const pendingMessages: ServerChatMessage[] = [];
 
-  client.onAgentChat((agentId: string, messages: any[]) => {
+  const flushPending = (agentId: string) => {
+    if (pendingMessages.length === 0) return;
+    const queued = pendingMessages.splice(0, pendingMessages.length);
+    for (const msg of queued) {
+      void handleChatMention({ client, runtime, msg, agentId, log });
+    }
+  };
+
+  client.onConnected((agentId) => {
+    flushPending(agentId);
+  });
+
+  client.onChatMessage((messages: ServerChatMessage[]) => {
+    const agentId = client.agentId;
+    if (!agentId) {
+      log?.warn?.("[clawroom:chat] received chat before agent registration completed");
+      pendingMessages.push(...messages);
+      return;
+    }
     for (const msg of messages) {
       void handleChatMention({ client, runtime, msg, agentId, log });
     }
@@ -29,9 +49,9 @@ export function setupChatExecutor(opts: {
 }
 
 async function handleChatMention(opts: {
-  client: ClawroomPluginClient;
+  client: ClawroomClient;
   runtime: PluginRuntime;
-  msg: any;
+  msg: ServerChatMessage;
   agentId: string;
   log?: {
     info?: (message: string, ...args: unknown[]) => void;
@@ -45,31 +65,72 @@ async function handleChatMention(opts: {
   log?.info?.(`[clawroom:chat] processing mention in channel ${msg.channelId}: "${msg.content.slice(0, 80)}"`);
 
   // Send typing indicator
-  client.sendTyping(agentId, msg.channelId).catch(() => {});
+  client.sendTyping(msg.channelId).catch(() => {});
 
   // Build context from recent messages
-  const contextLines = msg.context
-    .map((c) => `[${c.senderName}]: ${c.content}`)
+  const contextLines = (msg.context ?? [])
+    .map((c: { senderName: string; content: string }) => `[${c.senderName}]: ${c.content}`)
     .join("\n");
+  const attachmentLines = msg.attachments && msg.attachments.length > 0
+    ? msg.attachments.map((attachment: { filename: string; mimeType: string; byteSize?: number; downloadUrl: string }) => {
+      const size = typeof attachment.byteSize === "number" ? ` (${attachment.byteSize} bytes)` : "";
+      return `- ${attachment.filename} [${attachment.mimeType}]${size} ${attachment.downloadUrl}`;
+    }).join("\n")
+    : "(none)";
+  const agentProfileBlock = formatAgentProfile(msg.agentProfile);
 
-  const isMention = (msg as any).isMention ?? false;
+  const isMention = msg.isMention ?? false;
+  const isFollowThroughWake = msg.wakeReason === "follow_through";
+  const isGoalDriftWake = msg.wakeReason === "goal_drift";
+  const isTriggerWake = msg.wakeReason === "trigger";
+  const isCoordinationWake = msg.wakeReason === "coordination";
   const agentMessage = [
     isMention
       ? "You were @mentioned in a chat channel. Reply directly and helpfully."
+      : isCoordinationWake
+        ? `You were woken for persisted coordination on an active tracked mission.${msg.triggerReason ? ` ${msg.triggerReason}` : ""}`
+      : isFollowThroughWake
+        ? `Your follow-through engine woke you up because an open loop needs attention.${msg.triggerReason ? ` ${msg.triggerReason}` : ""}`
+      : isGoalDriftWake
+        ? `Potential goal drift was detected in this channel.${msg.triggerReason ? ` ${msg.triggerReason}` : ""}`
+      : isTriggerWake
+        ? `A scheduled or proactive trigger woke you up.${msg.triggerReason ? ` ${msg.triggerReason}` : ""}`
       : "A new message appeared in a channel you're in. You are a participant in this channel — reply naturally as a teammate would. If the message is a greeting or directed at the group, respond. Only stay silent if the message is clearly a private conversation between other people that has nothing to do with you.",
     "",
+    "## Your saved profile",
+    agentProfileBlock,
+    "",
     "## Recent messages",
     contextLines,
     "",
-    isMention ? "## Message that mentioned you" : "## Latest message",
+    "## Attachments",
+    attachmentLines,
+    "",
+    isMention ? "## Message that mentioned you" : isCoordinationWake ? "## Message that woke you" : "## Latest message",
     msg.content,
   ].join("\n");
 
+  let typingInterval: ReturnType<typeof setInterval> | null = null;
+  let shouldDeleteSession = false;
+
   try {
+    reportPluginReflectionSoon(client, {
+      scope: "chat",
+      status: "started",
+      summary: `Started reply for message ${msg.messageId}.`,
+      channelId: msg.channelId,
+      messageId: msg.messageId,
+      detail: {
+        wakeReason: msg.wakeReason ?? null,
+        isMention,
+      },
+    }, log);
+
     // Keep typing indicator alive during execution
-    const typingInterval = setInterval(() => {
-      client.sendTyping(agentId, msg.channelId).catch(() => {});
+    typingInterval = setInterval(() => {
+      client.sendTyping(msg.channelId).catch(() => {});
     }, 3000);
+    typingInterval.unref();
 
     const { runId } = await runtime.subagent.run({
       sessionKey,
@@ -77,33 +138,74 @@ async function handleChatMention(opts: {
       message: agentMessage,
       extraSystemPrompt: isMention
         ? "You are responding to a direct @mention in ClawRoom. " +
+          "Always follow your configured Role, System Prompt, and Memory for this reply. " +
           "You MUST reply with a helpful response. " +
           "Keep your reply SHORT and conversational (1-3 sentences). " +
           "Do NOT include file paths, system info, or markdown headers."
+        : isCoordinationWake
+          ? "You are coordinating a tracked multi-agent mission in ClawRoom. " +
+            "Always follow your configured Role, System Prompt, and Memory for this turn. " +
+            "Clarify the root task until the next execution step is concrete. Stay read-only while clarifying or planning. " +
+            "Create or follow up only on bounded child work when needed, synthesize returned results yourself, and drive convergence instead of open-ended chatter. " +
+            "If coordination drifts, decide directly or surface one concrete blocker. " +
+            "Do not respond with SKIP."
+        : isFollowThroughWake
+          ? "Your follow-through engine woke you up in ClawRoom because an open loop needs progress. " +
+            "Always follow your configured Role, System Prompt, and Memory for this reply. " +
+            "Move the work forward, close the loop, or ask the minimum clarifying question needed. " +
+            "Do not ignore the wake-up. Keep replies SHORT (1-3 sentences)."
+        : isGoalDriftWake
+          ? "Potential goal drift was detected in ClawRoom. " +
+            "Always follow your configured Role, System Prompt, and Memory for this reply. " +
+            "Surface the misalignment clearly and ask for re-alignment if needed. " +
+            "Do not respond with SKIP. Keep replies SHORT (1-3 sentences)."
+        : isTriggerWake
+          ? "A scheduled or proactive trigger woke you up in ClawRoom. " +
+            "Always follow your configured Role, System Prompt, and Memory for this reply. " +
+            "Do the triggered work directly, then report concise progress or outcome. " +
+            "Do not respond with SKIP unless the trigger is obviously stale or invalid."
         : "You are a member of a chat channel in ClawRoom. " +
+          "Always follow your configured Role, System Prompt, and Memory for this reply. " +
           "Respond naturally as a teammate. If someone greets the channel, greet back. " +
           "If someone asks a question, help if you can. " +
           "Only respond with exactly SKIP if the message is clearly a private exchange between others that doesn't involve you at all. " +
           "Keep replies SHORT (1-3 sentences).",
       lane: "clawroom",
     });
+    shouldDeleteSession = true;
 
     const waitResult = await runtime.subagent.waitForRun({
       runId,
       timeoutMs: CHAT_TIMEOUT_MS,
     });
 
-    clearInterval(typingInterval);
-
     if (waitResult.status === "error") {
       log?.error?.(`[clawroom:chat] subagent error: ${waitResult.error}`);
-      await client.sendChatReply(agentId, msg.channelId, "Sorry, I encountered an error processing your message.");
+      reportPluginReflectionSoon(client, {
+        scope: "chat",
+        status: "error",
+        summary: `Reply failed for message ${msg.messageId}.`,
+        channelId: msg.channelId,
+        messageId: msg.messageId,
+        responseExcerpt: waitResult.error ?? null,
+        detail: {
+          error: waitResult.error ?? "Unknown error",
+        },
+      }, log);
+      await client.sendChatReply(msg.channelId, "Sorry, I encountered an error processing your message.");
       return;
     }
 
     if (waitResult.status === "timeout") {
       log?.error?.(`[clawroom:chat] subagent timeout for message ${msg.messageId}`);
-      await client.sendChatReply(agentId, msg.channelId, "Sorry, I took too long to respond. Please try again.");
+      reportPluginReflectionSoon(client, {
+        scope: "chat",
+        status: "timeout",
+        summary: `Reply timed out for message ${msg.messageId}.`,
+        channelId: msg.channelId,
+        messageId: msg.messageId,
+      }, log);
+      await client.sendChatReply(msg.channelId, "Sorry, I took too long to respond. Please try again.");
       return;
     }
 
@@ -112,26 +214,62 @@ async function handleChatMention(opts: {
       limit: 10,
     });
 
-    const reply = extractLastAssistantMessage(messages);
+    const reply = normalizeChatReplyContent(extractLastAssistantMessage(messages));
 
     // If agent chose to skip (awareness message, not relevant), don't reply
-    if (reply.trim() === "SKIP" || reply.trim() === "skip") {
+    const replyNorm = reply.trim().toLowerCase().replace(/[_\-\s]/g, "");
+    if (replyNorm === "skip" || replyNorm === "noreply" || replyNorm === "pass") {
       log?.info?.(`[clawroom:chat] skipping ${msg.messageId} (not relevant)`);
-      await runtime.subagent.deleteSession({ sessionKey, deleteTranscript: true });
+      reportPluginReflectionSoon(client, {
+        scope: "chat",
+        status: "skipped",
+        summary: `Skipped reply for message ${msg.messageId}.`,
+        channelId: msg.channelId,
+        messageId: msg.messageId,
+        toolsUsed: extractToolNames(messages),
+        responseExcerpt: reply.slice(0, 400),
+      }, log);
       return;
     }
 
     log?.info?.(`[clawroom:chat] replying to ${msg.messageId}: "${reply.slice(0, 80)}"`);
-    await client.sendChatReply(agentId, msg.channelId, reply);
-
-    await runtime.subagent.deleteSession({
-      sessionKey,
-      deleteTranscript: true,
-    });
+    await client.sendChatReply(msg.channelId, reply);
+    reportPluginReflectionSoon(client, {
+      scope: "chat",
+      status: "completed",
+      summary: `Replied in channel ${msg.channelId}.`,
+      channelId: msg.channelId,
+      messageId: msg.messageId,
+      toolsUsed: extractToolNames(messages),
+      responseExcerpt: reply.slice(0, 400),
+      detail: {
+        wakeReason: msg.wakeReason ?? null,
+        isMention,
+      },
+    }, log);
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     log?.error?.(`[clawroom:chat] unexpected error: ${reason}`);
-    await client.sendChatReply(agentId, msg.channelId, "Sorry, something went wrong. Please try again.");
+    reportPluginReflectionSoon(client, {
+      scope: "chat",
+      status: "error",
+      summary: `Unexpected chat executor failure for message ${msg.messageId}.`,
+      channelId: msg.channelId,
+      messageId: msg.messageId,
+      responseExcerpt: reason.slice(0, 400),
+      detail: {
+        error: reason,
+      },
+    }, log);
+    await client.sendChatReply(msg.channelId, "Sorry, something went wrong. Please try again.");
+  } finally {
+    if (typingInterval) clearInterval(typingInterval);
+    if (shouldDeleteSession) {
+      await runtime.subagent.deleteSession({
+        sessionKey,
+        deleteTranscript: true,
+      }).catch(() => {});
+    }
   }
 }
 
@@ -152,3 +290,24 @@ function extractLastAssistantMessage(messages: unknown[]): string {
   }
   return "I'm not sure how to respond to that.";
 }
+
+function normalizeChatReplyContent(content: string): string {
+  return content
+    .replace(/^(?:[ \t]*\r?\n)+/, "")
+    .trimEnd();
+}
+
+function formatAgentProfile(profile: AgentChatProfile): string {
+  return [
+    `Role: ${profile.role}`,
+    "",
+    "System Prompt:",
+    profile.systemPrompt,
+    "",
+    "Memory:",
+    profile.memory,
+    "",
+    "Continuity Packet:",
+    profile.continuityPacket,
+  ].join("\n");
+}

package/src/reflections.ts

@@ -0,0 +1,60 @@
+import type { ClawroomClient } from "@clawroom/sdk";
+
+export type ReflectionScope = "chat" | "task";
+export type ReflectionStatus = "started" | "completed" | "skipped" | "timeout" | "error";
+type ReflectionParams = {
+  scope: ReflectionScope;
+  status: ReflectionStatus;
+  summary: string;
+  channelId?: string | null;
+  taskId?: string | null;
+  messageId?: string | null;
+  toolsUsed?: string[];
+  responseExcerpt?: string | null;
+  detail?: Record<string, unknown>;
+};
+
+export async function reportPluginReflection(
+  client: ClawroomClient,
+  params: ReflectionParams,
+): Promise<void> {
+  await client.sendReflection({
+    scope: params.scope,
+    status: params.status,
+    summary: params.summary,
+    channelId: params.channelId ?? null,
+    taskId: params.taskId ?? null,
+    messageId: params.messageId ?? null,
+    toolsUsed: params.toolsUsed ?? [],
+    responseExcerpt: params.responseExcerpt ?? null,
+    detail: {
+      source: "plugin",
+      ...(params.detail ?? {}),
+    },
+  });
+}
+
+export function reportPluginReflectionSoon(
+  client: ClawroomClient,
+  params: ReflectionParams,
+  log?: { warn?: (message: string, ...args: unknown[]) => void },
+): void {
+  void reportPluginReflection(client, params).catch((error) => {
+    log?.warn?.(`[clawroom:${params.scope}] reflection report failed`, error);
+  });
+}
+
+export function extractToolNames(messages: unknown[]): string[] {
+  const names = new Set<string>();
+  for (const message of messages) {
+    const msg = message as Record<string, unknown> | undefined;
+    if (!msg || !Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      const item = block as Record<string, unknown>;
+      if (item.type !== "tool_use" && item.type !== "tool_call") continue;
+      const name = item.name ?? item.function;
+      if (typeof name === "string" && name) names.add(name);
+    }
+  }
+  return Array.from(names);
+}

package/src/runtime.ts

@@ -3,4 +3,5 @@ import { createPluginRuntimeStore } from "openclaw/plugin-sdk";
 
 const { setRuntime: setClawroomRuntime, getRuntime: getClawroomRuntime } =
   createPluginRuntimeStore<PluginRuntime>("ClawRoom runtime not initialized");
+
 export { getClawroomRuntime, setClawroomRuntime };