openclaw-pincer 0.2.7 → 0.3.0

package/README.md

@@ -1,49 +1,42 @@
 # openclaw-pincer
 
-Pincer channel plugin for OpenClaw — connects agents to [Pincer](https://github.com/claw-works/pincer) rooms and DMs.
-
-Replaces the `daemon.py` polling approach with a proper OpenClaw channel plugin.
+OpenClaw channel plugin for [Pincer](https://github.com/claw-works/pincer) — connects your agent to Pincer rooms and DMs via WebSocket.
 
 ## Install
 
 ```bash
-openclaw plugins install claw-works/openclaw-pincer
-# or from local path:
-openclaw plugins install ./openclaw-pincer
+openclaw plugin install openclaw-pincer
 ```
 
 ## Configure
 
-Add to your `~/.openclaw/openclaw.json`:
+Edit `~/.openclaw/openclaw.json`:
 
 ```json
 {
+  "plugins": {
+    "allow": ["openclaw-pincer"],
+    "entries": {
+      "openclaw-pincer": { "enabled": true }
+    }
+  },
   "channels": {
-    "pincer": {
-      "baseUrl": "https://your-pincer-server.example.com",
-      "apiKey": "your-api-key",
-      "agentId": "your-agent-uuid",
-      "rooms": ["room-uuid-1", "room-uuid-2"],
-      "pollMs": 2000
+    "openclaw-pincer": {
+      "baseUrl": "https://your-pincer-server.com",
+      "token": "your-api-token"
     }
   }
 }
 ```
 
-Restart OpenClaw once after installing the plugin. Config changes (token, rooms) hot-reload without restart.
-
-## How it works
-
-- **Inbound**: polls `GET /rooms/{roomId}/messages?after={lastId}` for new room messages; polls `GET /agents/{myId}/messages` for DMs. Injects into OpenClaw session via `api.injectMessage()`.
-- **Outbound**: OpenClaw calls `api.registerSend()` to deliver agent replies back to Pincer rooms or DMs.
+`token` is the API key you registered on your Pincer server.
 
-Session keys:
-- Room: `pincer:channel:{roomId}`
-- DM: `pincer:dm:{peerId}`
+Restart OpenClaw after installing. Config changes (token, baseUrl) hot-reload without restart.
 
-## Migration from daemon.py
+## How it works
 
-Once the channel plugin is stable (running for ~1 week), remove `daemon.py` and the polling loop from `skill-pincer`. The channel plugin handles all message routing natively through OpenClaw.
+- **Inbound**: WebSocket connection to `wss://<host>/api/v1/ws?token=<token>` receives server-pushed messages in real time.
+- **Outbound**: Agent replies are sent via HTTP POST to the Pincer API.
 
 ## License
 

package/dist/index.js

@@ -1,8 +1,8 @@
 import { pincerChannel } from "./src/channel.js";
 const plugin = {
-    id: "pincer",
+    id: "openclaw-pincer",
     name: "Pincer",
-    description: "Pincer channel plugin — rooms and DMs for OpenClaw agents",
+    description: "Pincer channel plugin — WebSocket connection for OpenClaw agents",
     register(api) {
         api.registerChannel(pincerChannel);
     },

package/dist/src/channel.d.ts

@@ -1,17 +1,9 @@
 /**
- * channel.ts — Pincer channel plugin core
- *
- * Implements the OpenClaw ChannelPlugin interface for Pincer rooms and DMs.
+ * channel.ts — Pincer channel plugin (WebSocket inbound, HTTP outbound)
  */
 export interface PincerConfig {
     baseUrl: string;
-    apiKey: string;
-    agentId: string;
-    agentName?: string;
-    rooms?: string[];
-    pollMs?: number;
-    requireMention?: boolean;
-    historyLimit?: number;
+    token: string;
 }
 export declare const pincerChannel: {
     id: string;
@@ -30,12 +22,6 @@ export declare const pincerChannel: {
         reactions: boolean;
         threads: boolean;
     };
-    agentPrompt: {
-        messageToolHints: () => string[];
-    };
-    groups: {
-        resolveRequireMention: (params: any) => boolean;
-    };
     config: {
         listAccountIds: (cfg: any) => string[];
         resolveAccount: (_cfg: any, accountId: string) => {

package/dist/src/channel.js

@@ -1,220 +1,112 @@
 /**
- * channel.ts — Pincer channel plugin core
- *
- * Implements the OpenClaw ChannelPlugin interface for Pincer rooms and DMs.
+ * channel.ts — Pincer channel plugin (WebSocket inbound, HTTP outbound)
  */
+import WebSocket from "ws";
 function resolveConfig(cfg) {
-    return (cfg?.channels?.pincer ?? {});
+    return (cfg?.channels?.["openclaw-pincer"] ?? {});
 }
-async function pincerFetch(baseUrl, apiKey, path, options = {}) {
-    const url = `${baseUrl.replace(/\/$/, "")}/api/v1${path}`;
-    const res = await fetch(url, {
-        ...options,
-        headers: {
-            "X-API-Key": apiKey,
-            "Content-Type": "application/json",
-            ...(options.headers ?? {}),
-        },
-    });
-    if (!res.ok) {
-        throw new Error(`Pincer API error ${res.status}: ${await res.text()}`);
-    }
-    return res.json();
+function wsUrl(config) {
+    const base = config.baseUrl.replace(/\/$/, "").replace(/^http/, "ws");
+    return `${base}/api/v1/ws?token=${config.token}`;
 }
-async function sendToPincerRoom(config, roomId, agentId, text) {
-    await pincerFetch(config.baseUrl, config.apiKey, `/rooms/${roomId}/messages`, {
-        method: "POST",
-        body: JSON.stringify({ sender_agent_id: agentId, content: text }),
-    });
-}
-async function sendToPincerDm(config, peerId, text) {
-    await pincerFetch(config.baseUrl, config.apiKey, "/messages/send", {
+async function httpPost(config, path, body) {
+    const url = `${config.baseUrl.replace(/\/$/, "")}/api/v1${path}`;
+    const res = await fetch(url, {
         method: "POST",
-        body: JSON.stringify({
-            from_agent_id: config.agentId,
-            to_agent_id: peerId,
-            payload: { text },
-        }),
+        headers: { Authorization: `Bearer ${config.token}`, "Content-Type": "application/json" },
+        body: JSON.stringify(body),
     });
+    if (!res.ok)
+        throw new Error(`Pincer POST ${path} ${res.status}`);
 }
-/** Check if a room message mentions this agent (by agentId or agentName). */
-function isMentioned(text, config) {
-    if (text.includes(config.agentId))
-        return true;
-    if (config.agentName && text.includes(config.agentName))
-        return true;
-    return false;
-}
-/** Fetch recent room messages to use as conversation history. */
-async function fetchRoomHistory(config, roomId, limit) {
-    try {
-        const msgs = await pincerFetch(config.baseUrl, config.apiKey, `/rooms/${roomId}/messages?limit=${limit}`);
-        return msgs.map((m) => ({
-            sender: m.sender_agent_id ?? "unknown",
-            body: m.content ?? "",
-            timestamp: m.created_at ? new Date(m.created_at).getTime() : undefined,
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-function startRoomPoller(params) {
-    const { config, roomId, ctx, signal, pollMs } = params;
-    const requireMention = config.requireMention !== false; // default true
-    const historyLimit = config.historyLimit ?? 10;
-    let lastId = null;
-    const poll = async () => {
+function connectWs(params) {
+    const { config, ctx, signal } = params;
+    let retryMs = 1000;
+    function connect() {
         if (signal.aborted)
             return;
-        try {
-            const query = lastId ? `?after=${lastId}&limit=50` : "?limit=1";
-            const msgs = await pincerFetch(config.baseUrl, config.apiKey, `/rooms/${roomId}/messages${query}`);
-            // On first poll, just record the latest ID to avoid replaying history
-            if (lastId === null) {
-                if (msgs.length > 0)
-                    lastId = msgs[msgs.length - 1].id;
-                return;
-            }
-            const channelRuntime = ctx.channelRuntime;
-            for (const msg of msgs) {
-                // Skip own messages
-                if (msg.sender_agent_id === config.agentId) {
-                    lastId = msg.id;
-                    continue;
-                }
-                if (!channelRuntime) {
-                    console.warn("[pincer] channelRuntime not available, skipping room message dispatch");
-                    lastId = msg.id;
-                    continue;
-                }
-                const messageText = msg.content ?? "";
-                // Require mention in group rooms (default: on)
-                if (requireMention && !isMentioned(messageText, config)) {
-                    lastId = msg.id;
-                    continue;
-                }
-                const senderId = msg.sender_agent_id ?? "unknown";
-                // Fetch recent history for context
-                const history = await fetchRoomHistory(config, roomId, historyLimit);
-                const route = channelRuntime.routing.resolveAgentRoute({
-                    cfg: ctx.cfg,
-                    channel: "pincer",
-                    accountId: ctx.accountId,
-                    peer: { kind: "group", id: roomId },
-                });
-                await channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
-                    ctx: {
-                        Body: messageText,
-                        BodyForAgent: messageText,
-                        From: senderId,
-                        SessionKey: route.sessionKey,
-                        Channel: "pincer",
-                        AccountId: ctx.accountId,
-                        InboundHistory: history,
-                    },
-                    cfg: ctx.cfg,
-                    dispatcherOptions: {
-                        deliver: async (payload) => {
-                            await sendToPincerRoom(config, roomId, config.agentId, payload.text);
-                        },
-                    },
-                    replyOptions: {
-                        extraSystemPrompt: [
-                            "You are in a Pincer agent room (group chat). Rules:",
-                            "- Only respond when directly mentioned or asked a question.",
-                            "- Keep responses concise and on-topic.",
-                            "- Do NOT engage in idle chit-chat or filler responses.",
-                            "- Do NOT respond to every message — quality over quantity.",
-                        ].join("\n"),
-                    },
-                });
-                lastId = msg.id;
+        const ws = new WebSocket(wsUrl(config));
+        ws.on("open", () => {
+            retryMs = 1000;
+            console.log("[openclaw-pincer] WebSocket connected");
+        });
+        ws.on("message", (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                handleMessage(config, ctx, msg);
             }
-        }
-        catch (err) {
-            if (!signal.aborted) {
-                console.error(`[pincer] room ${roomId} poll error:`, err?.message);
-            }
-        }
-    };
-    const interval = setInterval(poll, pollMs);
-    signal.addEventListener("abort", () => clearInterval(interval));
-    poll();
-}
-function startDmPoller(params) {
-    const { config, ctx, signal, pollMs } = params;
-    let lastId = null;
-    let initialized = false;
-    const poll = async () => {
-        if (signal.aborted)
-            return;
-        try {
-            const query = lastId ? `?after=${lastId}&limit=50` : "?limit=1";
-            const msgs = await pincerFetch(config.baseUrl, config.apiKey, `/agents/${config.agentId}/messages${query}`);
-            if (!initialized) {
-                initialized = true;
-                if (msgs.length > 0)
-                    lastId = msgs[msgs.length - 1].id;
+            catch { }
+        });
+        ws.on("close", () => {
+            if (signal.aborted)
                 return;
-            }
-            const channelRuntime = ctx.channelRuntime;
-            for (const msg of msgs) {
-                if (msg.from_agent_id === config.agentId) {
-                    lastId = msg.id;
-                    continue;
+            console.log(`[openclaw-pincer] WS closed, reconnecting in ${retryMs}ms`);
+            setTimeout(connect, retryMs);
+            retryMs = Math.min(retryMs * 2, 30000);
+        });
+        ws.on("error", (err) => {
+            if (!signal.aborted)
+                console.error("[openclaw-pincer] WS error:", err.message);
+            ws.close();
+        });
+        signal.addEventListener("abort", () => ws.close(), { once: true });
+    }
+    connect();
+}
+function handleMessage(config, ctx, msg) {
+    const runtime = ctx.channelRuntime;
+    if (!runtime)
+        return;
+    const sessionKey = msg.room_id
+        ? `openclaw-pincer:channel:${msg.room_id}`
+        : `openclaw-pincer:dm:${msg.from_agent_id ?? msg.sender_agent_id ?? "unknown"}`;
+    const senderId = msg.from_agent_id ?? msg.sender_agent_id ?? "unknown";
+    const text = msg.content ?? msg.payload?.text ?? "";
+    if (!text)
+        return;
+    const peer = msg.room_id
+        ? { kind: "group", id: msg.room_id }
+        : { kind: "direct", id: senderId };
+    const route = runtime.routing.resolveAgentRoute({
+        cfg: ctx.cfg,
+        channel: "openclaw-pincer",
+        accountId: ctx.accountId,
+        peer,
+    });
+    runtime.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: {
+            Body: text,
+            BodyForAgent: text,
+            From: senderId,
+            SessionKey: route.sessionKey,
+            Channel: "openclaw-pincer",
+            AccountId: ctx.accountId,
+        },
+        cfg: ctx.cfg,
+        dispatcherOptions: {
+            deliver: async (payload) => {
+                if (msg.room_id) {
+                    await httpPost(config, `/rooms/${msg.room_id}/messages`, { content: payload.text });
                 }
-                if (!channelRuntime) {
-                    console.warn("[pincer] channelRuntime not available, skipping DM dispatch");
-                    lastId = msg.id;
-                    continue;
+                else {
+                    await httpPost(config, "/messages/send", {
+                        to_agent_id: senderId,
+                        payload: { text: payload.text },
+                    });
                 }
-                const peerId = msg.from_agent_id ?? "unknown";
-                const messageText = msg.payload?.text ?? "";
-                const route = channelRuntime.routing.resolveAgentRoute({
-                    cfg: ctx.cfg,
-                    channel: "pincer",
-                    accountId: ctx.accountId,
-                    peer: { kind: "direct", id: peerId },
-                });
-                await channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
-                    ctx: {
-                        Body: messageText,
-                        BodyForAgent: messageText,
-                        From: peerId,
-                        SessionKey: route.sessionKey,
-                        Channel: "pincer",
-                        AccountId: ctx.accountId,
-                    },
-                    cfg: ctx.cfg,
-                    dispatcherOptions: {
-                        deliver: async (payload) => {
-                            await sendToPincerDm(config, peerId, payload.text);
-                        },
-                    },
-                });
-                lastId = msg.id;
-            }
-        }
-        catch (err) {
-            if (!signal.aborted) {
-                console.error("[pincer] DM poll error:", err?.message);
-            }
-        }
-    };
-    const interval = setInterval(poll, pollMs * 2); // DM poll at half rate
-    signal.addEventListener("abort", () => clearInterval(interval));
-    poll();
+            },
+        },
+    });
 }
 export const pincerChannel = {
-    id: "pincer",
+    id: "openclaw-pincer",
     meta: {
-        id: "pincer",
+        id: "openclaw-pincer",
         label: "Pincer",
         selectionLabel: "Pincer (agent hub)",
         docsPath: "/channels/pincer",
         docsLabel: "pincer",
-        blurb: "Pincer agent hub — rooms and DMs.",
+        blurb: "Pincer agent hub — WebSocket connection.",
         order: 80,
     },
     capabilities: {
@@ -223,48 +115,26 @@ export const pincerChannel = {
         reactions: false,
         threads: false,
     },
-    agentPrompt: {
-        messageToolHints: () => [
-            "- In Pincer rooms, only respond when @mentioned or directly asked. No idle chit-chat.",
-            "- In Pincer DMs, respond normally.",
-        ],
-    },
-    groups: {
-        resolveRequireMention: (params) => {
-            const config = resolveConfig(params.cfg);
-            return config.requireMention !== false; // default true
-        },
-    },
     config: {
         listAccountIds: (cfg) => {
-            const config = resolveConfig(cfg);
-            if (!config.agentId)
-                return [];
-            return [config.agentId];
-        },
-        resolveAccount: (_cfg, accountId) => {
-            return { accountId };
+            const c = resolveConfig(cfg);
+            return c.baseUrl && c.token ? ["default"] : [];
         },
+        resolveAccount: (_cfg, accountId) => ({ accountId }),
     },
     gateway: {
         startAccount: async (ctx) => {
             const config = resolveConfig(ctx.cfg);
-            if (!config.baseUrl || !config.apiKey || !config.agentId) {
-                console.warn("[pincer] Missing required config (baseUrl, apiKey, agentId). Channel not started.");
+            if (!config.baseUrl || !config.token) {
+                console.warn("[openclaw-pincer] Missing baseUrl or token. Channel not started.");
                 return;
             }
             const signal = ctx.abortSignal;
-            const pollMs = config.pollMs ?? 15000;
-            for (const roomId of config.rooms ?? []) {
-                startRoomPoller({ config, roomId, ctx, signal, pollMs });
-            }
-            startDmPoller({ config, ctx, signal, pollMs });
-            console.log(`[pincer] Started. requireMention=${config.requireMention !== false}. Monitoring ${(config.rooms ?? []).length} room(s) + DMs as agent ${config.agentId}`);
+            connectWs({ config, ctx, signal });
+            console.log("[openclaw-pincer] Started, connecting via WebSocket");
             await new Promise((resolve) => {
-                if (signal.aborted) {
-                    resolve();
-                    return;
-                }
+                if (signal.aborted)
+                    return resolve();
                 signal.addEventListener("abort", () => resolve(), { once: true });
             });
         },
@@ -275,11 +145,13 @@ export const pincerChannel = {
             const config = resolveConfig(ctx.cfg);
             const to = ctx.to ?? "";
             if (to.startsWith("room:")) {
-                const roomId = to.slice("room:".length);
-                await sendToPincerRoom(config, roomId, config.agentId, ctx.text);
+                await httpPost(config, `/rooms/${to.slice(5)}/messages`, { content: ctx.text });
             }
             else {
-                await sendToPincerDm(config, to, ctx.text);
+                await httpPost(config, "/messages/send", {
+                    to_agent_id: to,
+                    payload: { text: ctx.text },
+                });
             }
             return { ok: true };
         },

package/index.ts

@@ -1,9 +1,9 @@
 import { pincerChannel } from "./src/channel.js";
 
 const plugin = {
-  id: "pincer",
+  id: "openclaw-pincer",
   name: "Pincer",
-  description: "Pincer channel plugin — rooms and DMs for OpenClaw agents",
+  description: "Pincer channel plugin — WebSocket connection for OpenClaw agents",
   register(api: any) {
     api.registerChannel(pincerChannel);
   },

package/openclaw.plugin.json

@@ -1,18 +1,15 @@
 {
-  "id": "pincer",
+  "id": "openclaw-pincer",
   "name": "Pincer",
-  "description": "Pincer channel plugin for OpenClaw — connects agents to Pincer rooms and DMs",
-  "version": "0.2.7",
-  "channels": ["pincer"],
+  "description": "Pincer channel plugin for OpenClaw — connects agents to Pincer via WebSocket",
+  "version": "0.3.0",
+  "channels": ["openclaw-pincer"],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
     "properties": {
       "baseUrl": { "type": "string" },
-      "apiKey": { "type": "string" },
-      "agentId": { "type": "string" },
-      "rooms": { "type": "array", "items": { "type": "string" } },
-      "pollMs": { "type": "number" }
+      "token": { "type": "string" }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-pincer",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "description": "Pincer channel plugin for OpenClaw",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/channel.ts

@@ -1,304 +1,133 @@
 /**
- * channel.ts — Pincer channel plugin core
- *
- * Implements the OpenClaw ChannelPlugin interface for Pincer rooms and DMs.
+ * channel.ts — Pincer channel plugin (WebSocket inbound, HTTP outbound)
  */
 
+import WebSocket from "ws";
+
 export interface PincerConfig {
   baseUrl: string;
-  apiKey: string;
-  agentId: string;
-  agentName?: string;       // display name for mention detection (e.g. "蔻儿")
-  rooms?: string[];
-  pollMs?: number;
-  requireMention?: boolean; // default: true — only respond in rooms when @mentioned
-  historyLimit?: number;    // how many messages to include as context (default: 10)
-}
-
-interface PincerMessage {
-  id: string;
-  room_id?: string;
-  sender_agent_id?: string;
-  from_agent_id?: string;
-  to_agent_id?: string;
-  content?: string;
-  payload?: { text: string };
-  created_at: string;
+  token: string;
 }
 
 function resolveConfig(cfg: any): PincerConfig {
-  return (cfg?.channels?.pincer ?? {}) as PincerConfig;
+  return (cfg?.channels?.["openclaw-pincer"] ?? {}) as PincerConfig;
 }
 
-async function pincerFetch(
-  baseUrl: string,
-  apiKey: string,
-  path: string,
-  options: RequestInit = {}
-): Promise<any> {
-  const url = `${baseUrl.replace(/\/$/, "")}/api/v1${path}`;
-  const res = await fetch(url, {
-    ...options,
-    headers: {
-      "X-API-Key": apiKey,
-      "Content-Type": "application/json",
-      ...(options.headers ?? {}),
-    },
-  });
-  if (!res.ok) {
-    throw new Error(`Pincer API error ${res.status}: ${await res.text()}`);
-  }
-  return res.json();
+function wsUrl(config: PincerConfig): string {
+  const base = config.baseUrl.replace(/\/$/, "").replace(/^http/, "ws");
+  return `${base}/api/v1/ws?token=${config.token}`;
 }
 
-async function sendToPincerRoom(
-  config: PincerConfig,
-  roomId: string,
-  agentId: string,
-  text: string
-): Promise<void> {
-  await pincerFetch(config.baseUrl, config.apiKey, `/rooms/${roomId}/messages`, {
-    method: "POST",
-    body: JSON.stringify({ sender_agent_id: agentId, content: text }),
-  });
-}
-
-async function sendToPincerDm(
-  config: PincerConfig,
-  peerId: string,
-  text: string
-): Promise<void> {
-  await pincerFetch(config.baseUrl, config.apiKey, "/messages/send", {
+async function httpPost(config: PincerConfig, path: string, body: any): Promise<void> {
+  const url = `${config.baseUrl.replace(/\/$/, "")}/api/v1${path}`;
+  const res = await fetch(url, {
     method: "POST",
-    body: JSON.stringify({
-      from_agent_id: config.agentId,
-      to_agent_id: peerId,
-      payload: { text },
-    }),
+    headers: { Authorization: `Bearer ${config.token}`, "Content-Type": "application/json" },
+    body: JSON.stringify(body),
   });
+  if (!res.ok) throw new Error(`Pincer POST ${path} ${res.status}`);
 }
 
-/** Check if a room message mentions this agent (by agentId or agentName). */
-function isMentioned(text: string, config: PincerConfig): boolean {
-  if (text.includes(config.agentId)) return true;
-  if (config.agentName && text.includes(config.agentName)) return true;
-  return false;
-}
-
-/** Fetch recent room messages to use as conversation history. */
-async function fetchRoomHistory(
-  config: PincerConfig,
-  roomId: string,
-  limit: number
-): Promise<Array<{ sender: string; body: string; timestamp?: number }>> {
-  try {
-    const msgs: PincerMessage[] = await pincerFetch(
-      config.baseUrl,
-      config.apiKey,
-      `/rooms/${roomId}/messages?limit=${limit}`
-    );
-    return msgs.map((m) => ({
-      sender: m.sender_agent_id ?? "unknown",
-      body: m.content ?? "",
-      timestamp: m.created_at ? new Date(m.created_at).getTime() : undefined,
-    }));
-  } catch {
-    return [];
-  }
-}
-
-function startRoomPoller(params: {
+function connectWs(params: {
   config: PincerConfig;
-  roomId: string;
   ctx: any;
   signal: AbortSignal;
-  pollMs: number;
 }) {
-  const { config, roomId, ctx, signal, pollMs } = params;
-  const requireMention = config.requireMention !== false; // default true
-  const historyLimit = config.historyLimit ?? 10;
-  let lastId: string | null = null;
+  const { config, ctx, signal } = params;
+  let retryMs = 1000;
 
-  const poll = async () => {
+  function connect() {
     if (signal.aborted) return;
-    try {
-      const query = lastId ? `?after=${lastId}&limit=50` : "?limit=1";
-      const msgs: PincerMessage[] = await pincerFetch(
-        config.baseUrl,
-        config.apiKey,
-        `/rooms/${roomId}/messages${query}`
-      );
-
-      // On first poll, just record the latest ID to avoid replaying history
-      if (lastId === null) {
-        if (msgs.length > 0) lastId = msgs[msgs.length - 1].id;
-        return;
-      }
-
-      const channelRuntime = ctx.channelRuntime;
-      for (const msg of msgs) {
-        // Skip own messages
-        if (msg.sender_agent_id === config.agentId) {
-          lastId = msg.id;
-          continue;
-        }
-
-        if (!channelRuntime) {
-          console.warn("[pincer] channelRuntime not available, skipping room message dispatch");
-          lastId = msg.id;
-          continue;
-        }
-
-        const messageText = msg.content ?? "";
-
-        // Require mention in group rooms (default: on)
-        if (requireMention && !isMentioned(messageText, config)) {
-          lastId = msg.id;
-          continue;
-        }
-
-        const senderId = msg.sender_agent_id ?? "unknown";
-
-        // Fetch recent history for context
-        const history = await fetchRoomHistory(config, roomId, historyLimit);
-
-        const route = channelRuntime.routing.resolveAgentRoute({
-          cfg: ctx.cfg,
-          channel: "pincer",
-          accountId: ctx.accountId,
-          peer: { kind: "group", id: roomId },
-        });
-
-        await channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
-          ctx: {
-            Body: messageText,
-            BodyForAgent: messageText,
-            From: senderId,
-            SessionKey: route.sessionKey,
-            Channel: "pincer",
-            AccountId: ctx.accountId,
-            InboundHistory: history,
-          },
-          cfg: ctx.cfg,
-          dispatcherOptions: {
-            deliver: async (payload: any) => {
-              await sendToPincerRoom(config, roomId, config.agentId, payload.text);
-            },
-          },
-          replyOptions: {
-            extraSystemPrompt: [
-              "You are in a Pincer agent room (group chat). Rules:",
-              "- Only respond when directly mentioned or asked a question.",
-              "- Keep responses concise and on-topic.",
-              "- Do NOT engage in idle chit-chat or filler responses.",
-              "- Do NOT respond to every message — quality over quantity.",
-            ].join("\n"),
-          } as any,
-        });
 
-        lastId = msg.id;
-      }
-    } catch (err: any) {
-      if (!signal.aborted) {
-        console.error(`[pincer] room ${roomId} poll error:`, err?.message);
-      }
-    }
-  };
+    const ws = new WebSocket(wsUrl(config));
+
+    ws.on("open", () => {
+      retryMs = 1000;
+      console.log("[openclaw-pincer] WebSocket connected");
+    });
+
+    ws.on("message", (data: WebSocket.Data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        handleMessage(config, ctx, msg);
+      } catch {}
+    });
+
+    ws.on("close", () => {
+      if (signal.aborted) return;
+      console.log(`[openclaw-pincer] WS closed, reconnecting in ${retryMs}ms`);
+      setTimeout(connect, retryMs);
+      retryMs = Math.min(retryMs * 2, 30000);
+    });
+
+    ws.on("error", (err: Error) => {
+      if (!signal.aborted) console.error("[openclaw-pincer] WS error:", err.message);
+      ws.close();
+    });
+
+    signal.addEventListener("abort", () => ws.close(), { once: true });
+  }
 
-  const interval = setInterval(poll, pollMs);
-  signal.addEventListener("abort", () => clearInterval(interval));
-  poll();
+  connect();
 }
 
-function startDmPoller(params: {
-  config: PincerConfig;
-  ctx: any;
-  signal: AbortSignal;
-  pollMs: number;
-}) {
-  const { config, ctx, signal, pollMs } = params;
-  let lastId: string | null = null;
-  let initialized = false;
+function handleMessage(config: PincerConfig, ctx: any, msg: any) {
+  const runtime = ctx.channelRuntime;
+  if (!runtime) return;
 
-  const poll = async () => {
-    if (signal.aborted) return;
-    try {
-      const query = lastId ? `?after=${lastId}&limit=50` : "?limit=1";
-      const msgs: PincerMessage[] = await pincerFetch(
-        config.baseUrl,
-        config.apiKey,
-        `/agents/${config.agentId}/messages${query}`
-      );
+  const sessionKey = msg.room_id
+    ? `openclaw-pincer:channel:${msg.room_id}`
+    : `openclaw-pincer:dm:${msg.from_agent_id ?? msg.sender_agent_id ?? "unknown"}`;
 
-      if (!initialized) {
-        initialized = true;
-        if (msgs.length > 0) lastId = msgs[msgs.length - 1].id;
-        return;
-      }
-
-      const channelRuntime = ctx.channelRuntime;
-      for (const msg of msgs) {
-        if (msg.from_agent_id === config.agentId) {
-          lastId = msg.id;
-          continue;
-        }
-
-        if (!channelRuntime) {
-          console.warn("[pincer] channelRuntime not available, skipping DM dispatch");
-          lastId = msg.id;
-          continue;
-        }
-
-        const peerId = msg.from_agent_id ?? "unknown";
-        const messageText = msg.payload?.text ?? "";
+  const senderId = msg.from_agent_id ?? msg.sender_agent_id ?? "unknown";
+  const text = msg.content ?? msg.payload?.text ?? "";
+  if (!text) return;
 
-        const route = channelRuntime.routing.resolveAgentRoute({
-          cfg: ctx.cfg,
-          channel: "pincer",
-          accountId: ctx.accountId,
-          peer: { kind: "direct", id: peerId },
-        });
+  const peer = msg.room_id
+    ? { kind: "group" as const, id: msg.room_id }
+    : { kind: "direct" as const, id: senderId };
 
-        await channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
-          ctx: {
-            Body: messageText,
-            BodyForAgent: messageText,
-            From: peerId,
-            SessionKey: route.sessionKey,
-            Channel: "pincer",
-            AccountId: ctx.accountId,
-          },
-          cfg: ctx.cfg,
-          dispatcherOptions: {
-            deliver: async (payload: any) => {
-              await sendToPincerDm(config, peerId, payload.text);
-            },
-          },
-        });
-
-        lastId = msg.id;
-      }
-    } catch (err: any) {
-      if (!signal.aborted) {
-        console.error("[pincer] DM poll error:", err?.message);
-      }
-    }
-  };
+  const route = runtime.routing.resolveAgentRoute({
+    cfg: ctx.cfg,
+    channel: "openclaw-pincer",
+    accountId: ctx.accountId,
+    peer,
+  });
 
-  const interval = setInterval(poll, pollMs * 2); // DM poll at half rate
-  signal.addEventListener("abort", () => clearInterval(interval));
-  poll();
+  runtime.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx: {
+      Body: text,
+      BodyForAgent: text,
+      From: senderId,
+      SessionKey: route.sessionKey,
+      Channel: "openclaw-pincer",
+      AccountId: ctx.accountId,
+    },
+    cfg: ctx.cfg,
+    dispatcherOptions: {
+      deliver: async (payload: any) => {
+        if (msg.room_id) {
+          await httpPost(config, `/rooms/${msg.room_id}/messages`, { content: payload.text });
+        } else {
+          await httpPost(config, "/messages/send", {
+            to_agent_id: senderId,
+            payload: { text: payload.text },
+          });
+        }
+      },
+    },
+  });
 }
 
 export const pincerChannel = {
-  id: "pincer",
+  id: "openclaw-pincer",
   meta: {
-    id: "pincer",
+    id: "openclaw-pincer",
     label: "Pincer",
     selectionLabel: "Pincer (agent hub)",
     docsPath: "/channels/pincer",
     docsLabel: "pincer",
-    blurb: "Pincer agent hub — rooms and DMs.",
+    blurb: "Pincer agent hub — WebSocket connection.",
     order: 80,
   },
   capabilities: {
@@ -307,51 +136,28 @@ export const pincerChannel = {
     reactions: false,
     threads: false,
   },
-  agentPrompt: {
-    messageToolHints: () => [
-      "- In Pincer rooms, only respond when @mentioned or directly asked. No idle chit-chat.",
-      "- In Pincer DMs, respond normally.",
-    ],
-  },
-  groups: {
-    resolveRequireMention: (params: any) => {
-      const config = resolveConfig(params.cfg);
-      return config.requireMention !== false; // default true
-    },
-  },
   config: {
     listAccountIds: (cfg: any) => {
-      const config = resolveConfig(cfg);
-      if (!config.agentId) return [];
-      return [config.agentId];
-    },
-    resolveAccount: (_cfg: any, accountId: string) => {
-      return { accountId };
+      const c = resolveConfig(cfg);
+      return c.baseUrl && c.token ? ["default"] : [];
     },
+    resolveAccount: (_cfg: any, accountId: string) => ({ accountId }),
   },
   gateway: {
     startAccount: async (ctx: any) => {
       const config = resolveConfig(ctx.cfg);
-      if (!config.baseUrl || !config.apiKey || !config.agentId) {
-        console.warn("[pincer] Missing required config (baseUrl, apiKey, agentId). Channel not started.");
+      if (!config.baseUrl || !config.token) {
+        console.warn("[openclaw-pincer] Missing baseUrl or token. Channel not started.");
         return;
       }
 
       const signal: AbortSignal = ctx.abortSignal;
-      const pollMs = config.pollMs ?? 15000;
+      connectWs({ config, ctx, signal });
 
-      for (const roomId of config.rooms ?? []) {
-        startRoomPoller({ config, roomId, ctx, signal, pollMs });
-      }
-
-      startDmPoller({ config, ctx, signal, pollMs });
-
-      console.log(
-        `[pincer] Started. requireMention=${config.requireMention !== false}. Monitoring ${(config.rooms ?? []).length} room(s) + DMs as agent ${config.agentId}`
-      );
+      console.log("[openclaw-pincer] Started, connecting via WebSocket");
 
       await new Promise<void>((resolve) => {
-        if (signal.aborted) { resolve(); return; }
+        if (signal.aborted) return resolve();
         signal.addEventListener("abort", () => resolve(), { once: true });
       });
     },
@@ -362,10 +168,12 @@ export const pincerChannel = {
       const config = resolveConfig(ctx.cfg);
       const to: string = ctx.to ?? "";
       if (to.startsWith("room:")) {
-        const roomId = to.slice("room:".length);
-        await sendToPincerRoom(config, roomId, config.agentId, ctx.text);
+        await httpPost(config, `/rooms/${to.slice(5)}/messages`, { content: ctx.text });
       } else {
-        await sendToPincerDm(config, to, ctx.text);
+        await httpPost(config, "/messages/send", {
+          to_agent_id: to,
+          payload: { text: ctx.text },
+        });
       }
       return { ok: true };
     },