agentbridge-openclaw-skill 1.0.0 → 1.1.0

package/README.md

@@ -1,206 +1,124 @@
 # @agentbridge/openclaw-skill
 
-OpenClaw 插件，将你的 Agent 接入 AgentBridge，实现跨 Agent 通信、智能路由和企业级治理。
+OpenClaw 插件，将你的 Agent 接入 AgentBridge，实现跨 Agent 通信、智能路由、事件规则路由和多 Agent 协作。
+
+## v1.1.0 新特性
+
+- 消息直接注入 main chat（WebSocket chat.send + v2 设备签名），用户能实时看到 Agent 处理过程
+- `agentbridge_send` 支持 `type` 和 `source` 参数，用于事件规则路由链路
+- Hop count 防循环机制（`maxAutoHops`），支持多 Agent 协作不死循环
+- 消息缓冲 + `agentbridge_poll` 优先返回缓冲消息
+- 配置驱动的 smart-ack 模式（可选）
 
 ## 安装
 
 ```bash
-# 方式一：从本地路径安装
-openclaw plugins install /path/to/agentbridge-openclaw-skill
-
-# 方式二：从 npm 安装（发布后）
-openclaw plugins install @agentbridge/openclaw-skill
+openclaw plugins install agentbridge-openclaw-skill
 ```
 
 安装后重启 Gateway：
 
 ```bash
-openclaw gateway stop
-openclaw gateway
+openclaw gateway --force
 ```
 
 ## 配置
 
-在 OpenClaw 的 `~/.openclaw/openclaw.json` 中，`plugins.entries` 下添加：
+在 `~/.openclaw/openclaw.json` 的 `plugins.entries` 中添加：
 
 ```json
 {
-  "hooks": {
+  "@agentbridge/openclaw-skill": {
     "enabled": true,
-    "token": "your-hooks-token",
-    "path": "/hooks"
-  },
-  "plugins": {
-    "entries": {
-      "@agentbridge/openclaw-skill": {
-        "enabled": true,
-        "config": {
-          "consoleEndpoint": "http://localhost:18080",
-          "workerEndpoint": "http://localhost:18081",
-          "bridgeId": "prod-bridge",
-          "agentId": "my-openclaw-agent",
-          "apiKey": "your-api-key",
-          "apiSecret": "your-api-secret",
-          "delivery": "poll",
-          "tags": ["openclaw", "assistant"],
-          "skills": [
-            {"name": "web_search", "description": "Search the web for information"},
-            {"name": "code_review", "description": "Review code and suggest improvements"}
-          ],
-          "autoRegister": true,
-          "autoReply": true,
-          "gatewayPort": 18789,
-          "gatewayToken": "your-gateway-token",
-          "hooksToken": "your-hooks-token"
-        }
-      }
+    "config": {
+      "consoleEndpoint": "http://localhost:18080",
+      "workerEndpoint": "http://localhost:18081",
+      "bridgeId": "prod-bridge",
+      "agentId": "my-agent",
+      "agentName": "My OpenClaw Agent",
+      "apiKey": "your-api-key",
+      "apiSecret": "your-api-secret",
+      "delivery": "poll",
+      "pollIntervalMs": 3000,
+      "tags": ["openclaw"],
+      "skills": [
+        {"name": "web_search", "description": "搜索网页信息"}
+      ],
+      "autoRegister": true,
+      "autoReply": true,
+      "autoReplyMode": "llm",
+      "gatewayToken": "your-gateway-token",
+      "gatewayPort": 18789,
+      "hooksToken": "your-hooks-token",
+      "maxAutoHops": 2
     }
   }
 }
 ```
 
-注意：`hooks.token` 必须与 `gateway.auth.token` 不同，否则 OpenClaw 会拒绝启动。
-
-## 验证安装
-
-```bash
-# 检查插件是否加载
-openclaw plugins list | grep agentbridge
-
-# 检查 Gateway 日志
-openclaw health
-# 应看到: AgentBridge: registered 3 tools (send, poll, discover)
-```
-
-## 插件做了什么
-
-启动时，插件会：
-
-1. **注册 3 个工具**给你的 OpenClaw Agent：
-   - `agentbridge_send` — 向其他 Agent 发送消息（支持智能路由）
-   - `agentbridge_poll` — 手动检查消息（通常不需要，后台监听会自动处理）
-   - `agentbridge_discover` — 发现可用的 Agent 及其技能
+注意：`hooks.token` 必须与 `gateway.auth.token` 不同。
 
-2. **启动后台消息监听**：
-   - `delivery: "poll"`（默认）— 每 5 秒自动轮询
-   - `delivery: "sse"` — 通过 SSE 长连接实时接收，零延迟，自动重连
+## 工具
 
-3. **自动回复**（需启用 hooks）：收到消息后通过 Gateway `/hooks/agent` 端点注入给 LLM，Agent 可自动调用 `agentbridge_send` 回复发送方
+插件注册 3 个工具：
 
-4. **自动注册到 AgentBridge**，把 OpenClaw 上的其他工具作为技能注册
+| 工具 | 说明 |
+|------|------|
+| `agentbridge_send` | 发送消息，支持智能路由和事件规则路由 |
+| `agentbridge_poll` | 接收消息（后台自动 poll + 手动调用） |
+| `agentbridge_discover` | 发现可用 Agent 及技能 |
 
-## 使用方式
+### agentbridge_send 参数
 
-### 发送消息
-
-在 OpenClaw 对话中直接说：
-
-```
-你: "让 DBA Agent 帮我分析 rds-prod-01 的慢查询"
-
-Agent 自动调用 agentbridge_send:
-  receiver: "?skill=slow_query_analysis"
-  message: "分析 rds-prod-01 的慢查询"
-```
-
-### 智能路由
-
-`agentbridge_send` 的 `receiver` 参数支持：
-
-| 格式 | 示例 | 行为 |
+| 参数 | 必填 | 说明 |
 |------|------|------|
-| Agent ID | `dba-agent` | 直接发送 |
-| 技能查询 | `?skill=slow_query_analysis` | 路由到具备该技能的 Agent（round-robin） |
-| 标签查询 | `?tag=ops` | 路由到带该标签的 Agent |
-| 意图查询 | `?intent=分析数据库性能` | 通过 Orchestrator Agent + LLM 智能路由 |
+| `receiver` | 是 | 目标：agentId / `?skill=X` / `?tag=X` / `?intent=X` / `?rule` |
+| `message` | 是 | 消息内容 |
+| `type` | 否 | CloudEvents 类型，如 `alert.escalate`（用于规则路由） |
+| `source` | 否 | 消息来源标识，如 `alert-screener`（用于规则路由） |
 
-### 发现 Agent
-
-```
-你: "查看 AgentBridge 上有哪些可用的 Agent"
+## 自动回复模式
 
-Agent 调用 agentbridge_discover，返回所有 Agent 及其技能列表
-```
-
-### 接收消息
-
-消息会自动出现在 Gateway 日志中（后台监听）。也可以手动检查：
+| 模式 | 配置 | 行为 |
+|------|------|------|
+| `llm` | `"autoReplyMode": "llm"` | 通过 WebSocket 注入 main chat，LLM 处理后回复 |
+| `ack` | `"autoReplyMode": "ack"` | 直接发送确认回复，不走 LLM |
+| `smart-ack` | `"autoReplyMode": "smart-ack"` | 配置驱动的规则判定，不走 LLM |
 
-```
-你: "检查一下有没有新消息"
+`llm` 模式通过 Gateway WebSocket 协议的 `chat.send` 方法注入消息到 main agent 对话，使用 v2 设备签名认证，无需 `dangerouslyDisableDeviceAuth`。
 
-Agent 调用 agentbridge_poll
-```
+## 防循环
 
-## 投递模式
+`maxAutoHops`（默认 2）控制消息自动处理的最大跳数：
 
-| 模式 | 配置 | 延迟 | 说明 |
-|------|------|------|------|
-| Poll（默认） | `"delivery": "poll"` | ~5 秒 | 定时轮询，简单可靠 |
-| SSE | `"delivery": "sse"` | 实时 | 长连接推送，自动重连，附带低频 fallback poll 兜底 |
+- 外部事件 → A（hop=0 ✅ 自动处理）
+- A → B（hop=1 ✅ 自动处理）
+- B → A（hop=2 ≥ 阈值 ❌ 缓冲，不自动处理）
 
-SSE 模式推荐用于需要实时响应的场景。
+多 Agent 链路（A→B→C）设 `maxAutoHops: 3`。
 
 ## 配置项
 
-| 配置项 | 必填 | 默认值 | 说明 |
-|--------|------|--------|------|
-| `consoleEndpoint` | 否 | `http://localhost:18080` | AgentBridge Console 地址 |
-| `workerEndpoint` | 否 | `http://localhost:18081` | AgentBridge Worker Gateway 地址 |
-| `bridgeId` | 否 | `prod-bridge` | 要加入的 Bridge ID |
-| `agentId` | 是 | — | Agent 在 AgentBridge 中的唯一标识 |
-| `agentName` | 否 | 自动生成 | Agent 显示名称 |
-| `apiKey` | 否 | — | Console API Key |
-| `apiSecret` | 否 | — | Console API Secret |
-| `delivery` | 否 | `poll` | 客户端监听模式：`poll`（定时轮询）/ `sse`（实时推送 + fallback poll）。注意：Agent 在 AgentBridge 服务端始终注册为 poll 投递，避免 SSE 连接冲突 |
-| `tags` | 否 | `[]` | Agent 标签 |
-| `skills` | 否 | `[]` | Agent 技能列表，格式 `[{"name":"x","description":"y"}]`。OpenClaw Plugin SDK 不提供查询已注册工具的 API，需手动声明 |
-| `autoRegister` | 否 | `true` | 是否自动注册到 AgentBridge |
-| `pollIntervalMs` | 否 | `5000` | Poll 模式轮询间隔（毫秒），设为 0 关闭后台监听 |
-| `sseFallbackPollMs` | 否 | `30000` | SSE 模式下 fallback poll 间隔（毫秒），兜底 SSE 断连期间的消息丢失，设为 0 关闭 |
-| `autoReply` | 否 | `true` | 收到消息后是否自动注入 Gateway 触发 LLM 回复 |
-| `maxAutoReplyDepth` | 否 | `3` | 同一发送方在滑动窗口内最多自动回复次数（防乒乓循环） |
-| `replyWindowMs` | 否 | `60000` | 自动回复滑动窗口时长（毫秒） |
-| `gatewayPort` | 否 | `18789` | 本地 Gateway 端口（用于 autoReply 注入） |
-| `gatewayToken` | 否 | — | Gateway auth token |
-| `hooksToken` | 否 | — | Gateway hooks token（需在 openclaw.json 中启用 hooks） |
-
-## 技能注册
-
-在配置中声明要暴露给 AgentBridge 的 skills：
-
-```json
-"skills": [
-  {"name": "web_search", "description": "Search the web for information"},
-  {"name": "code_review", "description": "Review code and suggest improvements"}
-]
-```
-
-只有声明的 skills 会注册到 AgentBridge，其他 Agent 可以通过 `?skill=web_search` 路由到你的 OpenClaw Agent。
-
-未声明的工具（如 `exec`、`write` 等）不会暴露，确保安全性。AgentBridge 自身的工具（`agentbridge_send/poll/discover`）也不需要声明。
-
-## 完整示例
-
-```bash
-# 1. 确保 AgentBridge 在运行
-docker-compose up -d
-
-# 2. 安装插件
-openclaw plugins install /path/to/agentbridge-openclaw-skill
-
-# 3. 配置（编辑 ~/.openclaw/openclaw.json 添加上面的 plugins 配置）
-
-# 4. 重启 Gateway
-openclaw gateway stop && openclaw gateway
-
-# 5. 验证
-openclaw health
-# → AgentBridge: registered 3 tools (send, poll, discover)
-# → AgentBridge: poll listener started (every 5s)
-
-# 6. 开始对话
-openclaw tui
-# > 查看 AgentBridge 上有哪些 Agent
-# > 让 DBA Agent 分析 rds-prod-01 的慢查询
-```
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| `consoleEndpoint` | `http://localhost:18080` | Console 地址 |
+| `workerEndpoint` | `http://localhost:18081` | Worker Gateway 地址 |
+| `bridgeId` | `prod-bridge` | Bridge ID |
+| `agentId` | — | Agent 唯一标识（必填） |
+| `agentName` | 自动生成 | 显示名称 |
+| `apiKey` / `apiSecret` | — | Console API 凭证 |
+| `delivery` | `poll` | 监听模式：`poll` / `sse` |
+| `pollIntervalMs` | `5000` | Poll 间隔（毫秒） |
+| `autoReply` | `true` | 是否自动处理收到的消息 |
+| `autoReplyMode` | `ack` | 自动回复模式：`llm` / `ack` / `smart-ack` |
+| `maxAutoHops` | `2` | 防循环最大跳数 |
+| `maxAutoReplyDepth` | `3` | 同一发送方最大回复次数 |
+| `tags` | `[]` | Agent 标签 |
+| `skills` | `[]` | 暴露的技能列表 |
+| `gatewayToken` | — | Gateway auth token |
+| `hooksToken` | — | Hooks token（需与 gateway token 不同） |
+| `gatewayPort` | `18789` | Gateway 端口 |
+
+## K8s 部署
+
+参考 `deploy/openclaw-agentbridge-configmap.yaml`，通过 ConfigMap + Secret 注入配置，支持另一个产品通过 K8s API 动态创建 OpenClaw 实例并自动接入 AgentBridge。

package/index.ts

@@ -12,6 +12,23 @@
 import { AgentBridgeClient } from "./src/agentbridge-client.js";
 import { createSendTool, createPollTool, createDiscoverTool } from "./src/tools.js";
 
+/**
+ * Simple pattern matcher for smart-ack rules.
+ * - "value"       → exact match
+ * - "a|b|c"       → OR match (any of)
+ * - "!value"      → NOT match
+ * - "!a|b"        → NOT any of
+ * - "*"           → match anything
+ */
+function matchSmartAckPattern(actual: string, pattern: string): boolean {
+  if (pattern === "*") return true;
+  const negate = pattern.startsWith("!");
+  const p = negate ? pattern.slice(1) : pattern;
+  const values = p.split("|").map(v => v.trim());
+  const hit = values.some(v => actual === v);
+  return negate ? !hit : hit;
+}
+
 export default function register(api: any) {
   const pluginCfg = api.pluginConfig || {};
   const agentId = pluginCfg.agentId;
@@ -33,9 +50,12 @@ export default function register(api: any) {
     delivery: pluginCfg.delivery || "poll",
   });
 
+  // Shared message buffer: background poll fills it, agentbridge_poll drains it
+  const messageBuffer: any[] = [];
+
   // Register tools
   api.registerTool(createSendTool(client));
-  api.registerTool(createPollTool(client));
+  api.registerTool(createPollTool(client, messageBuffer));
 
   const headers: Record<string, string> = { "Content-Type": "application/json" };
   if (pluginCfg.apiKey) headers["X-API-Key"] = pluginCfg.apiKey;
@@ -68,7 +88,7 @@ export default function register(api: any) {
   async function injectToAgent(sender: string, content: string) {
     if (!autoReply) return;
 
-    // --- Loop guard: limit auto-replies per sender within a sliding window ---
+    // --- Loop guard ---
     const now = Date.now();
     const tracker = replyTracker.get(sender);
     if (tracker) {
@@ -81,57 +101,165 @@ export default function register(api: any) {
         }
         tracker.count++;
       } else {
-        // Window expired, reset
         replyTracker.set(sender, { count: 1, firstSeen: now });
       }
     } else {
       replyTracker.set(sender, { count: 1, firstSeen: now });
     }
 
+    const replyMode = pluginCfg.autoReplyMode || "ack"; // "ack" | "llm" | "smart-ack"
+
+    // Mode: smart-ack — config-driven auto-response without LLM
+    // Rules are declared in pluginCfg.smartAckRules as an array of:
+    //   { match: { field: value, ... }, verdict, reason, replyType }
+    // Fields in "match" are checked against the message data (AND logic).
+    // Supports exact match and simple patterns: "P0|P1" (OR), "!test" (NOT).
+    // First matching rule wins. If no rule matches, falls back to defaultVerdict.
+    if (replyMode === "smart-ack") {
+      try {
+        let parsed: any = {};
+        try { parsed = typeof content === 'string' ? JSON.parse(content) : content; } catch { parsed = { content }; }
+
+        // Skip auto-reply / ack messages (prevent ping-pong)
+        const dataPayload = parsed?.data || parsed;
+        if (dataPayload?.autoReply || dataPayload?.content?.toString().startsWith("[Auto-reply")) {
+          api.logger.info(`AgentBridge: smart-ack skipping auto-reply from ${sender}`);
+          return;
+        }
+        if (!dataPayload?.alertName && !dataPayload?.severity && !dataPayload?.verdict) {
+          api.logger.info(`AgentBridge: smart-ack skipping non-alert message from ${sender}`);
+          return;
+        }
+
+        const alertData = dataPayload;
+        const rules: any[] = pluginCfg.smartAckRules || [];
+        const defaultVerdict = pluginCfg.smartAckDefault?.verdict || "archive";
+        const defaultReplyType = pluginCfg.smartAckDefault?.replyType || "alert.archive";
+        const defaultReason = pluginCfg.smartAckDefault?.reason || "默认归档处理";
+
+        let verdict = defaultVerdict;
+        let reason = defaultReason;
+        let replyType = defaultReplyType;
+        let matched = false;
+
+        for (const rule of rules) {
+          if (!rule.match) continue;
+          let allMatch = true;
+          for (const [field, pattern] of Object.entries(rule.match as Record<string, string>)) {
+            const actual = String(alertData?.[field] ?? "");
+            if (!matchSmartAckPattern(actual, pattern)) { allMatch = false; break; }
+          }
+          if (allMatch) {
+            verdict = rule.verdict || defaultVerdict;
+            // Support template strings in reason: ${field} replaced with alert data
+            reason = (rule.reason || defaultReason).replace(/\$\{(\w+)\}/g, (_: string, k: string) => alertData?.[k] ?? k);
+            replyType = rule.replyType || `alert.${verdict}`;
+            matched = true;
+            break;
+          }
+        }
+
+        if (!matched && rules.length > 0) {
+          reason = `${alertData?.severity || "unknown"} 级别告警，${defaultReason}`;
+        }
+
+        const verdictPayload = {
+          verdict, reason,
+          severity: alertData?.severity, alertName: alertData?.alertName,
+          service: alertData?.service, environment: alertData?.environment,
+          screenedBy: agentId, screenedAt: new Date().toISOString(),
+        };
+
+        await client.send("?rule", verdictPayload, undefined, replyType, agentId);
+        api.logger.info(`AgentBridge: smart-ack verdict=${verdict} for alert "${alertData?.alertName || "?"}" from ${sender} → ?rule (type=${replyType}, source=${agentId})`);
+      } catch (err) {
+        api.logger.warn(`AgentBridge: smart-ack failed: ${err}`);
+      }
+      return;
+    }
+
+    // Mode: ack — send a direct acknowledgment reply without LLM
+    if (replyMode === "ack") {
+      try {
+        const ackContent = typeof content === 'string' && content.length > 100
+          ? content.slice(0, 100) + '...'
+          : content;
+        await client.send(sender, {
+          content: `[Auto-reply from ${agentId}] Received your message. Processing: ${ackContent}`,
+          from: agentId,
+          autoReply: true,
+        });
+        api.logger.info(`AgentBridge: ack reply sent to ${sender}`);
+      } catch (err) {
+        api.logger.warn(`AgentBridge: ack reply failed: ${err}`);
+      }
+      return;
+    }
+
+    // Mode: llm — inject into main agent chat via Gateway WebSocket (chat.send)
+    // This puts the message directly into the main conversation context,
+    // so the user can see it and the agent processes it with full history.
+
+    const prompt = `[AgentBridge 收到新消息]\n来源: ${sender}\n内容:\n${content}\n\n` +
+      `请处理这条消息，然后必须调用 agentbridge_send 工具发送处理结果。调用时参数如下：\n` +
+      `- receiver: "?rule"\n` +
+      `- source: "${agentId}"\n` +
+      `- type 和 message: 根据你的分析结果设置`;
+
+    // Try WebSocket chat.send first (main chat injection, secure device auth)
+    const wsOk = await injectViaWs(prompt);
+    if (wsOk) {
+      api.logger.info(`AgentBridge: injected via WebSocket chat.send from ${sender} (main chat)`);
+      return;
+    }
+
+    // Fallback: /hooks/agent (creates nested conversation, not ideal)
     const baseUrl = `http://127.0.0.1:${gatewayPort}`;
-    const prompt = `[AgentBridge message from ${sender}]\n${content}\n\n` +
-      `Reply to ${sender} using agentbridge_send tool.`;
     const hdrs: Record<string, string> = { "Content-Type": "application/json" };
-    // Use hooksToken for /hooks/agent, fall back to gatewayToken
     const hookAuth = hooksToken || gatewayToken;
     if (hookAuth) hdrs["Authorization"] = `Bearer ${hookAuth}`;
 
-    // Try 1: /hooks/agent
     try {
       const resp = await fetch(`${baseUrl}/hooks/agent`, {
         method: "POST", headers: hdrs,
-        body: JSON.stringify({
-          message: prompt,
-          wakeMode: "now",
-        }),
+        body: JSON.stringify({ message: prompt, wakeMode: "now" }),
       });
       if (resp.ok) {
-        api.logger.info(`AgentBridge: injected via /hooks/agent from ${sender}`);
+        api.logger.info(`AgentBridge: injected via /hooks/agent (fallback) from ${sender}`);
         return;
       }
     } catch { /* fall through */ }
 
-    // Try 2: /v1/chat/completions (OpenAI-compatible)
-    try {
-      const chatHdrs: Record<string, string> = { "Content-Type": "application/json" };
-      if (gatewayToken) chatHdrs["Authorization"] = `Bearer ${gatewayToken}`;
-      const resp = await fetch(`${baseUrl}/v1/chat/completions`, {
-        method: "POST", headers: chatHdrs,
-        body: JSON.stringify({
-          model: "openclaw",
-          messages: [
-            { role: "system", content: "You are an AI agent connected to AgentBridge. When you receive messages from other agents, process them and reply using the agentbridge_send tool." },
-            { role: "user", content: prompt },
-          ],
-        }),
-      });
-      if (resp.ok) {
-        api.logger.info(`AgentBridge: injected via /v1/chat/completions from ${sender}`);
-        return;
-      }
-    } catch { /* fall through */ }
+    api.logger.warn(`AgentBridge: could not inject message from ${sender} (no working injection path)`);
+  }
+
+  // --- Main chat injection via child process (secure device auth) ---
+  // Uses a standalone .mjs script that runs outside the plugin sandbox,
+  // with full access to Node.js crypto for v2 device signature.
+  const { execFile } = require('child_process');
+  const path = require('path');
 
-    api.logger.warn(`AgentBridge: could not inject message from ${sender} (no working Gateway API)`);
+  // Resolve the ws-inject.mjs script path relative to this plugin
+  const wsInjectScript = path.join(__dirname, 'src', 'ws-inject.mjs');
+
+  /**
+   * Inject a message into the main agent chat via WebSocket (child process).
+   * Returns true if successful, false if failed (caller should use fallback).
+   */
+  function injectViaWs(message: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      execFile('node', [wsInjectScript, String(gatewayPort), gatewayToken, 'auto', message],
+        { timeout: 15000 },
+        (err: any, stdout: string, stderr: string) => {
+          if (!err && stdout.includes('OK:sent')) {
+            resolve(true);
+          } else {
+            api.logger.debug(`AgentBridge: ws-inject failed: ${stderr || stdout || err?.message}`);
+            resolve(false);
+          }
+        }
+      );
+    });
   }
 
   // Background message listener
@@ -161,12 +289,68 @@ export default function register(api: any) {
     return false;
   }
 
-  function handleIncomingMessage(msg: any, channel: string) {
+  async function handleIncomingMessage(msg: any, channel: string) {
     if (dedup(msg)) return;
     const data = msg?.data || msg;
     const sender = msg?.extensions?.["ab-sender"] || (data as any)?.from || "unknown";
     const content = typeof data === "object" ? JSON.stringify(data) : String(data);
     api.logger.info(`AgentBridge [${channel}]: message from ${sender}: ${content.slice(0, 100)}`);
+
+    if (!autoReply) return;
+
+    // Anti-loop: check hop count in message data.
+    // Each agent processing increments _abHop. When it exceeds maxHops, don't auto-inject.
+    const maxHops = pluginCfg.maxAutoHops ?? 2; // default: allow 2 hops (source→A→B, but B won't auto-reply back)
+    let hopCount = 0;
+    try {
+      const parsed = typeof data === 'string' ? JSON.parse(data) : data;
+      hopCount = parsed?._abHop || parsed?.data?._abHop || 0;
+    } catch { /* not JSON, hop=0 */ }
+
+    if (hopCount >= maxHops) {
+      messageBuffer.push(msg);
+      api.logger.info(`AgentBridge: hop limit reached (${hopCount}>=${maxHops}) from ${sender}, buffered for manual poll`);
+      return;
+    }
+
+    // Skip system messages
+    const msgType = msg?.type || "";
+    if (msgType.includes("system.capabilities-sync")) return;
+
+    const replyMode = pluginCfg.autoReplyMode || "ack";
+
+    // For llm mode: inject directly into main chat via WebSocket (ws-inject)
+    if (replyMode === "llm") {
+      const preview = content.length > 80 ? content.slice(0, 80) + '...' : content;
+      const prompt = `[AgentBridge 收到新消息]\n来源: ${sender}\n内容:\n${content}\n\n` +
+        `请根据你的职责处理这条消息。如需通过 AgentBridge 发送处理结果，使用 agentbridge_send 工具，` +
+        `receiver 设为 "?rule"（规则路由），同时设置 type 和 source="${agentId}" 字段。`;
+
+      // Try ws-inject (main chat, secure device auth)
+      const wsOk = await injectViaWs(prompt);
+      if (wsOk) {
+        api.logger.info(`AgentBridge: injected via WebSocket chat.send from ${sender} (main chat)`);
+        return;
+      }
+
+      // Fallback: buffer + hooks notification
+      messageBuffer.push(msg);
+      api.logger.info(`AgentBridge: ws-inject failed, buffered message from ${sender} (buffer=${messageBuffer.length})`);
+      const baseUrl = `http://127.0.0.1:${gatewayPort}`;
+      const hdrs: Record<string, string> = { "Content-Type": "application/json" };
+      const hookAuth = hooksToken || gatewayToken;
+      if (hookAuth) hdrs["Authorization"] = `Bearer ${hookAuth}`;
+      fetch(`${baseUrl}/hooks/agent`, {
+        method: "POST", headers: hdrs,
+        body: JSON.stringify({
+          message: `[AgentBridge 新消息通知]\n来自: ${sender}\n预览: ${preview}\n\n请调用 agentbridge_poll 工具获取完整消息并处理。`,
+          wakeMode: "now",
+        }),
+      }).catch(() => {});
+      return;
+    }
+
+    // Other modes (ack, smart-ack): use injectToAgent as before
     injectToAgent(sender, content);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbridge-openclaw-skill",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "OpenClaw plugin — connect to AgentBridge for cross-agent communication and intelligent routing.",
   "type": "module",
   "main": "index.ts",

package/src/agentbridge-client.ts

@@ -96,18 +96,21 @@ export class AgentBridgeClient {
   }
 
   /** Send a message through the Worker Gateway. */
-  async send(receiver: string, data: unknown, taskId?: string): Promise<{ messageId: string }> {
+  async send(receiver: string, data: unknown, taskId?: string, type?: string, source?: string): Promise<{ messageId: string }> {
     // Ensure we have a token
     if (!this.token) {
       await this.issueToken();
     }
 
     const body: Record<string, unknown> = {
-      type: "com.agentbridge.task.dispatch",
+      type: type || "com.agentbridge.task.dispatch",
       receiver,
       data,
       taskId: taskId || `oc-${this.config.agentId}-${Date.now().toString(36)}`,
     };
+    if (source) {
+      body.source = source;
+    }
 
     const resp = await fetch(`${this.config.workerEndpoint}/api/v1/messages`, {
       method: "POST",

package/src/tools.ts

@@ -19,19 +19,29 @@ export function createSendTool(client: AgentBridgeClient) {
     name: "agentbridge_send",
     description:
       "Send a message to another agent through AgentBridge. " +
-      "Receiver can be an agent ID, ?skill=X, ?tag=X, or ?intent=text.",
+      "Receiver can be an agent ID, ?skill=X, ?tag=X, ?intent=text, or ?rule (for event rule routing).",
     parameters: {
       type: "object",
       properties: {
-        receiver: { type: "string", description: "Target agent ID or query" },
+        receiver: { type: "string", description: "Target agent ID, query, or ?rule for event rule routing" },
         message: { type: "string", description: "Message content" },
         taskId: { type: "string", description: "Task ID for correlation" },
+        type: { type: "string", description: "CloudEvents type (e.g. alert.escalate). Defaults to task.dispatch" },
+        source: { type: "string", description: "CloudEvents source (e.g. alert-screener). Defaults to agentId" },
       },
       required: ["receiver", "message"],
     },
-    async execute(_id: string, params: { receiver: string; message: string; taskId?: string }) {
+    async execute(_id: string, params: { receiver: string; message: string; taskId?: string; type?: string; source?: string }) {
       try {
-        const result = await client.send(params.receiver, { content: params.message }, params.taskId);
+        // Inject hop count for anti-loop: each send increments _abHop
+        let msgData: any = { content: params.message, _abHop: 1 };
+        try {
+          const parsed = JSON.parse(params.message);
+          if (typeof parsed === 'object' && parsed !== null) {
+            msgData = { ...parsed, _abHop: (parsed._abHop || 0) + 1 };
+          }
+        } catch { /* not JSON, use default */ }
+        const result = await client.send(params.receiver, msgData, params.taskId, params.type, params.source);
         return textResult(`Message sent to ${params.receiver}. MessageId: ${result.messageId}`);
       } catch (err) {
         return textResult(`Send failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -40,7 +50,7 @@ export function createSendTool(client: AgentBridgeClient) {
   };
 }
 
-export function createPollTool(client: AgentBridgeClient) {
+export function createPollTool(client: AgentBridgeClient, messageBuffer?: any[]) {
   return {
     name: "agentbridge_poll",
     description: "Poll for incoming messages from other agents through AgentBridge.",
@@ -52,11 +62,23 @@ export function createPollTool(client: AgentBridgeClient) {
     },
     async execute(_id: string, params: { maxMessages?: number }) {
       try {
-        const messages = await client.poll(params?.maxMessages || 5);
-        if (messages.length === 0) {
+        // First drain any buffered messages (from background poll)
+        const buffered: any[] = [];
+        if (messageBuffer) {
+          while (messageBuffer.length > 0 && buffered.length < (params?.maxMessages || 5)) {
+            buffered.push(messageBuffer.shift());
+          }
+        }
+        // Then poll for more if needed
+        const remaining = (params?.maxMessages || 5) - buffered.length;
+        if (remaining > 0) {
+          const fresh = await client.poll(remaining);
+          buffered.push(...fresh);
+        }
+        if (buffered.length === 0) {
           return textResult("No messages waiting.");
         }
-        return textResult(`Received ${messages.length} message(s):\n${JSON.stringify(messages, null, 2)}`);
+        return textResult(`Received ${buffered.length} message(s):\n${JSON.stringify(buffered, null, 2)}`);
       } catch (err) {
         return textResult(`Poll failed: ${err instanceof Error ? err.message : String(err)}`);
       }

package/src/ws-inject.mjs

@@ -0,0 +1,98 @@
+/**
+ * Standalone WebSocket injector for OpenClaw main chat.
+ * Uses correct v2 device auth: raw ed25519 public key (32 bytes, base64url).
+ * 
+ * Usage: node ws-inject.mjs <port> <token> <sessionKey> <message>
+ */
+import crypto from 'node:crypto';
+
+const [,, port, token, sessionKey, message] = process.argv;
+if (!port || !token || !message) {
+  console.error('Usage: node ws-inject.mjs <port> <token> <sessionKey> <message>');
+  process.exit(1);
+}
+
+// base64url encode/decode (no padding, - and _ instead of + and /)
+function b64url(buf) { return buf.toString('base64').replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/g, ''); }
+
+const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');
+
+const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
+const spkiDer = publicKey.export({ type: 'spki', format: 'der' });
+// Extract raw 32-byte public key from SPKI DER
+const rawPub = spkiDer.subarray(ED25519_SPKI_PREFIX.length);
+// Device ID = sha256 of raw public key bytes (not SPKI DER)
+const deviceId = crypto.createHash('sha256').update(rawPub).digest('hex');
+// Public key sent to server: raw 32 bytes, base64url encoded
+const pubKeyB64Url = b64url(rawPub);
+
+const ws = new WebSocket(`ws://127.0.0.1:${port}`, {
+  headers: { 'Origin': `http://127.0.0.1:${port}` }
+});
+
+let done = false;
+
+ws.onmessage = (e) => {
+  const msg = JSON.parse(e.data);
+
+  if (msg.type === 'event' && msg.event === 'connect.challenge') {
+    const nonce = msg.payload.nonce;
+    const signedAt = Date.now();
+    const scopes = 'operator.read,operator.write';
+    // v2 payload: v2|deviceId|clientId|clientMode|role|scopes|signedAtMs|token|nonce
+    const payload = `v2|${deviceId}|openclaw-control-ui|webchat|operator|${scopes}|${signedAt}|${token}|${nonce}`;
+    const sigRaw = crypto.sign(null, Buffer.from(payload), privateKey);
+    // Signature: base64url encoded
+    const sig = b64url(sigRaw);
+
+    ws.send(JSON.stringify({
+      type: 'req', id: '1', method: 'connect',
+      params: {
+        minProtocol: 3, maxProtocol: 3,
+        client: { id: 'openclaw-control-ui', version: '1.0.0', platform: 'macos', mode: 'webchat' },
+        role: 'operator', scopes: ['operator.read', 'operator.write'],
+        caps: [], commands: [], permissions: {},
+        auth: { token },
+        locale: 'zh-CN', userAgent: 'agentbridge-ws-inject/1.0.0',
+        device: { id: deviceId, publicKey: pubKeyB64Url, signature: sig, signedAt, nonce }
+      }
+    }));
+  }
+
+  if (msg.type === 'res' && msg.id === '1') {
+    if (msg.ok) {
+      if (!sessionKey || sessionKey === 'auto') {
+        ws.send(JSON.stringify({ type: 'req', id: 'sessions', method: 'sessions.list', params: {} }));
+      } else {
+        sendChat(sessionKey);
+      }
+    } else {
+      console.error('CONNECT_FAIL:' + (msg.error?.message || 'unknown'));
+      ws.close(); process.exit(1);
+    }
+  }
+
+  if (msg.type === 'res' && msg.id === 'sessions' && msg.ok) {
+    const sessions = msg.payload?.sessions || [];
+    const main = sessions.find(s => s.key?.includes(':main:') && !s.key?.includes(':hook:')) || sessions[0];
+    sendChat(main?.key || 'agent:main:main');
+  }
+
+  if (msg.type === 'res' && msg.id === 'chat' && !done) {
+    done = true;
+    console.log('OK:' + (msg.ok ? 'sent' : (msg.error?.message || 'fail')));
+    ws.close(); process.exit(msg.ok ? 0 : 1);
+  }
+};
+
+function sendChat(sk) {
+  const ik = `ab-${Date.now().toString(36)}-${Math.random().toString(36).slice(2,8)}`;
+  ws.send(JSON.stringify({
+    type: 'req', id: 'chat', method: 'chat.send',
+    params: { sessionKey: sk, message, idempotencyKey: ik }
+  }));
+}
+
+ws.onerror = () => { process.exit(1); };
+ws.onclose = () => { if (!done) process.exit(1); };
+setTimeout(() => { ws.close(); process.exit(1); }, 15000);