agentbridge-openclaw-skill 1.0.0

package/README.md

@@ -0,0 +1,206 @@
+# @agentbridge/openclaw-skill
+
+OpenClaw 插件，将你的 Agent 接入 AgentBridge，实现跨 Agent 通信、智能路由和企业级治理。
+
+## 安装
+
+```bash
+# 方式一：从本地路径安装
+openclaw plugins install /path/to/agentbridge-openclaw-skill
+
+# 方式二：从 npm 安装（发布后）
+openclaw plugins install @agentbridge/openclaw-skill
+```
+
+安装后重启 Gateway：
+
+```bash
+openclaw gateway stop
+openclaw gateway
+```
+
+## 配置
+
+在 OpenClaw 的 `~/.openclaw/openclaw.json` 中，`plugins.entries` 下添加：
+
+```json
+{
+  "hooks": {
+    "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"
+        }
+      }
+    }
+  }
+}
+```
+
+注意：`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 及其技能
+
+2. **启动后台消息监听**：
+   - `delivery: "poll"`（默认）— 每 5 秒自动轮询
+   - `delivery: "sse"` — 通过 SSE 长连接实时接收，零延迟，自动重连
+
+3. **自动回复**（需启用 hooks）：收到消息后通过 Gateway `/hooks/agent` 端点注入给 LLM，Agent 可自动调用 `agentbridge_send` 回复发送方
+
+4. **自动注册到 AgentBridge**，把 OpenClaw 上的其他工具作为技能注册
+
+## 使用方式
+
+### 发送消息
+
+在 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 智能路由 |
+
+### 发现 Agent
+
+```
+你: "查看 AgentBridge 上有哪些可用的 Agent"
+
+Agent 调用 agentbridge_discover，返回所有 Agent 及其技能列表
+```
+
+### 接收消息
+
+消息会自动出现在 Gateway 日志中（后台监听）。也可以手动检查：
+
+```
+你: "检查一下有没有新消息"
+
+Agent 调用 agentbridge_poll
+```
+
+## 投递模式
+
+| 模式 | 配置 | 延迟 | 说明 |
+|------|------|------|------|
+| Poll（默认） | `"delivery": "poll"` | ~5 秒 | 定时轮询，简单可靠 |
+| SSE | `"delivery": "sse"` | 实时 | 长连接推送，自动重连，附带低频 fallback poll 兜底 |
+
+SSE 模式推荐用于需要实时响应的场景。
+
+## 配置项
+
+| 配置项 | 必填 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `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 的慢查询
+```

package/index.ts

@@ -0,0 +1,240 @@
+/**
+ * @agentbridge/openclaw-skill — OpenClaw plugin for AgentBridge.
+ *
+ * Connects your OpenClaw agent to AgentBridge for cross-agent communication,
+ * intelligent routing, and auto-registration of tools as skills.
+ *
+ * When autoReply is enabled (default), incoming messages are injected into the
+ * OpenClaw agent via the Gateway HTTP API, triggering an LLM turn that can
+ * decide to reply using agentbridge_send.
+ */
+
+import { AgentBridgeClient } from "./src/agentbridge-client.js";
+import { createSendTool, createPollTool, createDiscoverTool } from "./src/tools.js";
+
+export default function register(api: any) {
+  const pluginCfg = api.pluginConfig || {};
+  const agentId = pluginCfg.agentId;
+
+  if (!agentId) {
+    // Silently skip during CLI validation (pluginConfig is incomplete)
+    return;
+  }
+
+  const consoleEndpoint = pluginCfg.consoleEndpoint || "http://localhost:18080";
+  const workerEndpoint = pluginCfg.workerEndpoint || "http://localhost:18081";
+  const bridgeId = pluginCfg.bridgeId || "prod-bridge";
+
+  const client = new AgentBridgeClient({
+    consoleEndpoint, workerEndpoint, bridgeId,
+    agentId: agentId,
+    apiKey: pluginCfg.apiKey,
+    apiSecret: pluginCfg.apiSecret,
+    delivery: pluginCfg.delivery || "poll",
+  });
+
+  // Register tools
+  api.registerTool(createSendTool(client));
+  api.registerTool(createPollTool(client));
+
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (pluginCfg.apiKey) headers["X-API-Key"] = pluginCfg.apiKey;
+  if (pluginCfg.apiSecret) headers["X-API-Secret"] = pluginCfg.apiSecret;
+  api.registerTool(createDiscoverTool(consoleEndpoint, headers));
+
+  api.logger.info("AgentBridge: registered 3 tools (send, poll, discover)");
+
+  // --- Auto-reply: inject incoming messages into OpenClaw agent via Gateway API ---
+  const autoReply = pluginCfg.autoReply !== false;
+  const gatewayPort = pluginCfg.gatewayPort || api.gateway?.port || 18789;
+  const gatewayToken = pluginCfg.gatewayToken || api.gateway?.auth?.token || "";
+  const hooksToken = pluginCfg.hooksToken || "";
+  const maxAutoReplyDepth = pluginCfg.maxAutoReplyDepth ?? 3;
+
+  // Track recent auto-replies to prevent ping-pong loops.
+  // Key: sender agentId, Value: { count, firstSeen }
+  const replyTracker = new Map<string, { count: number; firstSeen: number }>();
+  const replyWindowMs = pluginCfg.replyWindowMs ?? 60_000;
+
+  /**
+   * Forward an incoming AgentBridge message to the local OpenClaw Gateway,
+   * triggering an LLM agent turn. The agent sees the message and can use
+   * agentbridge_send to reply.
+   *
+   * Tries multiple Gateway API paths in order:
+   *   1. POST /hooks/agent (webhook hook — requires hooks.enabled=true)
+   *   2. POST /v1/chat/completions (OpenAI-compatible endpoint)
+   */
+  async function injectToAgent(sender: string, content: string) {
+    if (!autoReply) return;
+
+    // --- Loop guard: limit auto-replies per sender within a sliding window ---
+    const now = Date.now();
+    const tracker = replyTracker.get(sender);
+    if (tracker) {
+      if (now - tracker.firstSeen < replyWindowMs) {
+        if (tracker.count >= maxAutoReplyDepth) {
+          api.logger.warn(
+            `AgentBridge: suppressed auto-reply to ${sender} (${tracker.count} replies in ${Math.round((now - tracker.firstSeen) / 1000)}s, limit=${maxAutoReplyDepth})`
+          );
+          return;
+        }
+        tracker.count++;
+      } else {
+        // Window expired, reset
+        replyTracker.set(sender, { count: 1, firstSeen: now });
+      }
+    } else {
+      replyTracker.set(sender, { count: 1, firstSeen: now });
+    }
+
+    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",
+        }),
+      });
+      if (resp.ok) {
+        api.logger.info(`AgentBridge: injected via /hooks/agent 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 Gateway API)`);
+  }
+
+  // Background message listener
+  const delivery = pluginCfg.delivery || "poll";
+  const pollIntervalMs = pluginCfg.pollIntervalMs ?? 5000;
+  const sseFallbackPollMs = pluginCfg.sseFallbackPollMs ?? 30_000;
+
+  // Dedup set: track recently seen messageIds to avoid double-processing
+  // when SSE + fallback poll both deliver the same message.
+  const seenMessageIds = new Set<string>();
+  const SEEN_MAX = 500;
+
+  function dedup(msg: any): boolean {
+    const id = msg?.id || (msg as any)?.extensions?.["ab-traceid"];
+    if (!id) return false; // no id → can't dedup, process it
+    if (seenMessageIds.has(id)) return true; // already seen
+    seenMessageIds.add(id);
+    if (seenMessageIds.size > SEEN_MAX) {
+      // Evict oldest entries (Set preserves insertion order)
+      const iter = seenMessageIds.values();
+      for (let i = 0; i < 100; i++) iter.next();
+      // Rebuild without the oldest 100
+      const keep = [...seenMessageIds].slice(100);
+      seenMessageIds.clear();
+      keep.forEach(k => seenMessageIds.add(k));
+    }
+    return false;
+  }
+
+  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)}`);
+    injectToAgent(sender, content);
+  }
+
+  if (delivery === "sse") {
+    // SSE mode: real-time push via persistent connection
+    setTimeout(() => {
+      const disconnect = client.connectSSE((msg: any) => {
+        handleIncomingMessage(msg, "SSE");
+      });
+      api.logger.info("AgentBridge: SSE listener connected (real-time push)");
+      api.on?.("shutdown", disconnect);
+    }, 5000);
+
+    // Fallback poll: catch messages missed during SSE reconnect gaps
+    if (sseFallbackPollMs > 0) {
+      let fallbackInterval: ReturnType<typeof setInterval> | null = null;
+
+      async function fallbackPoll() {
+        try {
+          const messages = await client.poll(10);
+          for (const msg of messages) {
+            handleIncomingMessage(msg, "fallback-poll");
+          }
+        } catch { /* ignore */ }
+      }
+
+      setTimeout(() => {
+        fallbackInterval = setInterval(fallbackPoll, sseFallbackPollMs);
+        api.logger.info(`AgentBridge: SSE fallback poll started (every ${sseFallbackPollMs / 1000}s)`);
+      }, 10000); // start later than SSE to let SSE connect first
+
+      api.on?.("shutdown", () => { if (fallbackInterval) clearInterval(fallbackInterval); });
+    }
+  } else if (pollIntervalMs > 0) {
+    // Poll mode: periodic background polling
+    let pollInterval: ReturnType<typeof setInterval> | null = null;
+
+    async function backgroundPoll() {
+      try {
+        const messages = await client.poll(10);
+        for (const msg of messages) {
+          handleIncomingMessage(msg, "poll");
+        }
+      } catch { /* ignore */ }
+    }
+
+    setTimeout(() => {
+      pollInterval = setInterval(backgroundPoll, pollIntervalMs);
+      api.logger.info(`AgentBridge: poll listener started (every ${pollIntervalMs / 1000}s)`);
+    }, 5000);
+
+    api.on?.("shutdown", () => { if (pollInterval) clearInterval(pollInterval); });
+  }
+
+  // Auto-register with AgentBridge
+  if (pluginCfg.autoRegister !== false) {
+    setTimeout(async () => {
+      try {
+        const skills = Array.isArray(pluginCfg.skills) ? pluginCfg.skills : [];
+        await client.register(
+          pluginCfg.agentName || `OpenClaw Agent (${agentId})`,
+          skills,
+          pluginCfg.tags || []
+        );
+        api.logger.info(`AgentBridge: registered '${agentId}' with ${skills.length} skills`);
+      } catch (err) {
+        api.logger.error(`AgentBridge: registration failed: ${err}`);
+      }
+    }, 3000);
+  }
+}

package/openclaw.plugin.json

@@ -0,0 +1,21 @@
+{
+  "id": "@agentbridge/openclaw-skill",
+  "name": "AgentBridge",
+  "description": "Connect OpenClaw to AgentBridge for cross-agent communication and intelligent routing",
+  "entrypoint": "index.ts",
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "consoleEndpoint": { "type": "string", "default": "http://localhost:18080" },
+      "workerEndpoint": { "type": "string", "default": "http://localhost:18081" },
+      "bridgeId": { "type": "string", "default": "prod-bridge" },
+      "agentId": { "type": "string" },
+      "apiKey": { "type": "string" },
+      "apiSecret": { "type": "string" },
+      "delivery": { "type": "string", "default": "poll" },
+      "tags": { "type": "array", "items": { "type": "string" }, "default": [] },
+      "autoRegister": { "type": "boolean", "default": true }
+    },
+    "required": []
+  }
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "agentbridge-openclaw-skill",
+  "version": "1.0.0",
+  "description": "OpenClaw plugin — connect to AgentBridge for cross-agent communication and intelligent routing.",
+  "type": "module",
+  "main": "index.ts",
+  "openclaw": {
+    "extensions": ["./index.ts"]
+  },
+  "files": [
+    "index.ts",
+    "src/",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
+  "keywords": ["openclaw", "agentbridge", "a2a", "agent-to-agent", "routing", "plugin"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentbridge/agentbridge",
+    "directory": "agentbridge-openclaw-skill"
+  },
+  "dependencies": {}
+}

package/src/agentbridge-client.ts

@@ -0,0 +1,213 @@
+/**
+ * Lightweight AgentBridge HTTP client for Node.js.
+ * Handles Console API (registration) and Worker Gateway API (messaging).
+ */
+
+export interface AgentBridgeConfig {
+  consoleEndpoint: string;
+  workerEndpoint: string;
+  bridgeId: string;
+  apiKey?: string;
+  apiSecret?: string;
+  agentId: string;
+  delivery?: "poll" | "sse" | "webhook";
+}
+
+export interface Skill {
+  name: string;
+  description: string;
+  inputSchema?: Record<string, unknown>;
+}
+
+export class AgentBridgeClient {
+  private config: AgentBridgeConfig;
+  private token: string | null = null;
+
+  constructor(config: AgentBridgeConfig) {
+    this.config = config;
+  }
+
+  private consoleHeaders(): Record<string, string> {
+    const h: Record<string, string> = { "Content-Type": "application/json" };
+    if (this.config.apiKey) h["X-API-Key"] = this.config.apiKey;
+    if (this.config.apiSecret) h["X-API-Secret"] = this.config.apiSecret;
+    return h;
+  }
+
+  private workerHeaders(): Record<string, string> {
+    const h: Record<string, string> = { "Content-Type": "application/json" };
+    if (this.token) h["Authorization"] = `Bearer ${this.token}`;
+    return h;
+  }
+
+  /**
+   * Register this agent with AgentBridge Console.
+   * Skills are auto-extracted from OpenClaw tools and passed here.
+   *
+   * NOTE: Server-side delivery is always "poll" regardless of client config.
+   * The client-side delivery setting (sse/poll) only controls how the plugin
+   * listens for messages locally. This avoids SSE connection conflicts when
+   * multiple OpenClaw processes (gateway + agent CLI) share the same agentId.
+   */
+  async register(name: string, skills: Skill[] = [], tags: string[] = []): Promise<void> {
+    const body = {
+      agentId: this.config.agentId,
+      name,
+      bridgeIds: [this.config.bridgeId],
+      protocol: "HTTP",
+      delivery: "poll",
+      accessMode: "HIGHCODE",
+      status: "active",
+      skills,
+      tags,
+    };
+
+    const resp = await fetch(`${this.config.consoleEndpoint}/api/v1/agents`, {
+      method: "POST",
+      headers: this.consoleHeaders(),
+      body: JSON.stringify(body),
+    });
+
+    if (resp.status === 400) {
+      // Agent might already exist — try update
+      const updateResp = await fetch(
+        `${this.config.consoleEndpoint}/api/v1/agents/${this.config.agentId}`,
+        { method: "PUT", headers: this.consoleHeaders(), body: JSON.stringify(body) }
+      );
+      if (!updateResp.ok) throw new Error(`Register/update failed: ${await updateResp.text()}`);
+    } else if (!resp.ok) {
+      throw new Error(`Register failed: ${await resp.text()}`);
+    }
+
+    // Issue JWT token
+    const tokenResp = await fetch(`${this.config.consoleEndpoint}/api/v1/tokens`, {
+      method: "POST",
+      headers: this.consoleHeaders(),
+      body: JSON.stringify({
+        agentId: this.config.agentId,
+        bridgeId: this.config.bridgeId,
+        scopes: ["send", "receive"],
+        expirationMinutes: 1440, // 24h
+      }),
+    });
+    if (!tokenResp.ok) throw new Error(`Token issue failed: ${await tokenResp.text()}`);
+    const tokenData = await tokenResp.json() as { token: string };
+    this.token = tokenData.token;
+  }
+
+  /** Send a message through the Worker Gateway. */
+  async send(receiver: string, data: unknown, taskId?: 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",
+      receiver,
+      data,
+      taskId: taskId || `oc-${this.config.agentId}-${Date.now().toString(36)}`,
+    };
+
+    const resp = await fetch(`${this.config.workerEndpoint}/api/v1/messages`, {
+      method: "POST",
+      headers: this.workerHeaders(),
+      body: JSON.stringify(body),
+    });
+    if (!resp.ok) throw new Error(`Send failed: ${await resp.text()}`);
+    return resp.json() as Promise<{ messageId: string }>;
+  }
+
+  /** Poll for messages from the Worker Gateway. */
+  async poll(maxMessages = 10): Promise<unknown[]> {
+    if (!this.token) {
+      await this.issueToken();
+    }
+    const url = `${this.config.workerEndpoint}/api/v1/messages/poll?agentId=${
+      encodeURIComponent(this.config.agentId)}&maxMessages=${maxMessages}`;
+    const resp = await fetch(url, { headers: this.workerHeaders() });
+    if (!resp.ok) return [];
+    return resp.json() as Promise<unknown[]>;
+  }
+
+  /** Issue a JWT token from Console. */
+  private async issueToken(): Promise<void> {
+    const tokenResp = await fetch(`${this.config.consoleEndpoint}/api/v1/tokens`, {
+      method: "POST",
+      headers: this.consoleHeaders(),
+      body: JSON.stringify({
+        agentId: this.config.agentId,
+        bridgeId: this.config.bridgeId,
+        scopes: ["send", "receive"],
+        expirationMinutes: 1440,
+      }),
+    });
+    if (!tokenResp.ok) throw new Error(`Token issue failed: ${await tokenResp.text()}`);
+    const tokenData = await tokenResp.json() as { token: string };
+    this.token = tokenData.token;
+  }
+
+  /**
+   * Connect to SSE endpoint for real-time message push.
+   * Calls onMessage for each received event. Returns an abort function.
+   */
+  connectSSE(onMessage: (data: unknown) => void): () => void {
+    const controller = new AbortController();
+    const url = `${this.config.workerEndpoint}/api/v1/events`;
+
+    const connect = async () => {
+      try {
+        const resp = await fetch(url, {
+          headers: { ...this.workerHeaders(), "Accept": "text/event-stream" },
+          signal: controller.signal,
+        });
+        if (!resp.ok || !resp.body) {
+          // Server rejected — retry after delay
+          if (!controller.signal.aborted) setTimeout(connect, 5000);
+          return;
+        }
+
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+
+          let eventData = "";
+          for (const line of lines) {
+            if (line.startsWith("data:")) {
+              eventData += line.slice(5).trim();
+            } else if (line === "" && eventData) {
+              try {
+                onMessage(JSON.parse(eventData));
+              } catch {
+                onMessage({ raw: eventData });
+              }
+              eventData = "";
+            }
+          }
+        }
+
+        // Stream ended (server closed connection / kicked by another client).
+        // Auto-reconnect unless explicitly aborted.
+        if (!controller.signal.aborted) {
+          setTimeout(connect, 3000);
+        }
+      } catch (err: any) {
+        if (err?.name !== "AbortError") {
+          // Network error — reconnect after delay
+          setTimeout(connect, 3000);
+        }
+      }
+    };
+
+    connect();
+    return () => controller.abort();
+  }
+}

package/src/skill-extractor.ts

@@ -0,0 +1,44 @@
+/**
+ * Extracts AgentBridge skills from OpenClaw registered tools.
+ *
+ * Converts OpenClaw's TypeBox-based tool schemas into AgentBridge's
+ * skill format: {name, description, inputSchema}.
+ */
+
+import type { Skill } from "./agentbridge-client.js";
+
+interface OpenClawTool {
+  name: string;
+  description?: string;
+  input?: unknown; // TypeBox schema
+}
+
+/**
+ * Extracts skills from OpenClaw tools registered via the plugin API.
+ * Filters out AgentBridge's own tools (agentbridge_*) to avoid circular registration.
+ */
+export function extractSkillsFromOpenClawTools(tools: OpenClawTool[]): Skill[] {
+  return tools
+    .filter((t) => !t.name.startsWith("agentbridge_"))
+    .map((tool) => {
+      const skill: Skill = {
+        name: tool.name,
+        description: tool.description || "",
+      };
+
+      // Convert TypeBox schema to JSON Schema if possible
+      if (tool.input && typeof tool.input === "object") {
+        try {
+          // TypeBox objects have a toJSON-compatible structure
+          const schema = tool.input as Record<string, unknown>;
+          if (schema.type || schema.properties) {
+            skill.inputSchema = schema as Record<string, unknown>;
+          }
+        } catch {
+          // Skip schema extraction on error
+        }
+      }
+
+      return skill;
+    });
+}

package/src/tools.ts

@@ -0,0 +1,98 @@
+/**
+ * OpenClaw agent tools for AgentBridge communication.
+ *
+ * OpenClaw tool interface:
+ *   name: string
+ *   description: string
+ *   parameters: TypeBox schema or JSON Schema object
+ *   execute(_id: string, params: T): Promise<{content: [{type:"text", text:string}]}>
+ */
+
+import type { AgentBridgeClient } from "./agentbridge-client.js";
+
+function textResult(text: string) {
+  return { content: [{ type: "text" as const, text }] };
+}
+
+export function createSendTool(client: AgentBridgeClient) {
+  return {
+    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.",
+    parameters: {
+      type: "object",
+      properties: {
+        receiver: { type: "string", description: "Target agent ID or query" },
+        message: { type: "string", description: "Message content" },
+        taskId: { type: "string", description: "Task ID for correlation" },
+      },
+      required: ["receiver", "message"],
+    },
+    async execute(_id: string, params: { receiver: string; message: string; taskId?: string }) {
+      try {
+        const result = await client.send(params.receiver, { content: params.message }, params.taskId);
+        return textResult(`Message sent to ${params.receiver}. MessageId: ${result.messageId}`);
+      } catch (err) {
+        return textResult(`Send failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    },
+  };
+}
+
+export function createPollTool(client: AgentBridgeClient) {
+  return {
+    name: "agentbridge_poll",
+    description: "Poll for incoming messages from other agents through AgentBridge.",
+    parameters: {
+      type: "object",
+      properties: {
+        maxMessages: { type: "number", description: "Max messages to retrieve (default 5)" },
+      },
+    },
+    async execute(_id: string, params: { maxMessages?: number }) {
+      try {
+        const messages = await client.poll(params?.maxMessages || 5);
+        if (messages.length === 0) {
+          return textResult("No messages waiting.");
+        }
+        return textResult(`Received ${messages.length} message(s):\n${JSON.stringify(messages, null, 2)}`);
+      } catch (err) {
+        return textResult(`Poll failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    },
+  };
+}
+
+export function createDiscoverTool(consoleEndpoint: string, headers: Record<string, string>) {
+  return {
+    name: "agentbridge_discover",
+    description: "Discover available agents and their skills on AgentBridge.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query (name, skill, tag)" },
+        tags: { type: "string", description: "Filter by tags (comma-separated)" },
+      },
+    },
+    async execute(_id: string, params: { query?: string; tags?: string }) {
+      try {
+        const urlParams = new URLSearchParams();
+        if (params?.query) urlParams.set("query", params.query);
+        if (params?.tags) urlParams.set("tags", params.tags);
+        const resp = await fetch(`${consoleEndpoint}/api/v1/agents/discover?${urlParams}`, { headers });
+        if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+        const agents = (await resp.json()) as Array<Record<string, unknown>>;
+        if (agents.length === 0) {
+          return textResult("No agents found.");
+        }
+        const summary = agents.map((a: any) =>
+          `- ${a.agentId} (${a.name || '?'}): skills=${(a.skills||[]).map((s:any)=>s.name).join(',') || 'none'}, tags=${(a.tags||[]).join(',') || 'none'}, status=${a.status}`
+        ).join('\n');
+        return textResult(`Found ${agents.length} agent(s):\n${summary}`);
+      } catch (err) {
+        return textResult(`Discover failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    },
+  };
+}