openclaw-a2a 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tomas Grasl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,261 @@
+# openclaw-a2a
+
+> What happens when AI agents start talking to each other?
+> Let's find out.
+
+[![CI](https://github.com/freema/openclaw-a2a/actions/workflows/ci.yml/badge.svg)](https://github.com/freema/openclaw-a2a/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/openclaw-a2a)](https://www.npmjs.com/package/openclaw-a2a)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+![Status: Beta](https://img.shields.io/badge/status-beta-orange)
+![A2A: v1.0](https://img.shields.io/badge/A2A-v1.0-blue)
+
+**openclaw-a2a** is a bridge that lets any A2A-compatible agent chat with your
+self-hosted [OpenClaw](https://openclaw.ai) assistant. Think of it as giving your
+OpenClaw a phone number that other agents can call.
+
+This is a **beta experiment**. We're exploring the bleeding edge of agent-to-agent
+communication using Google's [A2A protocol](https://google.github.io/A2A/) v1.0.
+The JS SDK is still on v0.3, so we implemented v1.0 from scratch. YOLO.
+
+## The Idea
+
+You already have OpenClaw running. Maybe on your laptop, maybe on a server.
+It's smart, it has access to your tools, and it talks to your LLM.
+
+Now imagine another agent — running somewhere else, built by someone else —
+wants to ask your OpenClaw something. That's what A2A is for.
+
+```
+   Google ADK Agent ──┐
+   CrewAI Agent ──────┤── A2A Protocol ──> openclaw-a2a ──> OpenClaw Gateway
+   Your Custom Agent ─┤                         |
+   Claude.ai* ────────┘                    (yes, streaming!)
+
+   * via A2A-MCP bridge (because Claude speaks MCP, not A2A... yet)
+```
+
+## Quick Start
+
+### npm
+
+```bash
+npm install -g openclaw-a2a@beta
+
+# Start the bridge
+openclaw-a2a --openclaw-url http://127.0.0.1:18789 --token your-token
+```
+
+### Docker
+
+```bash
+docker run --rm -p 3100:3100 \
+  -e OPENCLAW_URL=http://host.docker.internal:18789 \
+  -e OPENCLAW_GATEWAY_TOKEN=your-token \
+  ghcr.io/freema/openclaw-a2a:beta
+```
+
+### From source
+
+```bash
+git clone https://github.com/freema/openclaw-a2a.git
+cd openclaw-a2a
+npm install
+cp .env.example .env  # edit with your settings
+npm run dev
+```
+
+## Try It
+
+```bash
+# Discover the agent
+curl http://localhost:3100/.well-known/agent-card.json | jq .
+
+# Send a message (A2A v1.0)
+curl -X POST http://localhost:3100/a2a \
+  -H "Content-Type: application/json" \
+  -H "A2A-Version: 1.0" \
+  -d '{
+    "jsonrpc": "2.0", "id": "1", "method": "SendMessage",
+    "params": {
+      "message": {
+        "messageId": "test-1",
+        "role": "ROLE_USER",
+        "parts": [{ "text": "Hello from A2A v1.0!" }]
+      }
+    }
+  }'
+
+# Stream a response
+curl -N -X POST http://localhost:3100/a2a \
+  -H "Content-Type: application/json" \
+  -H "A2A-Version: 1.0" \
+  -d '{
+    "jsonrpc": "2.0", "id": "2", "method": "SendStreamingMessage",
+    "params": {
+      "message": {
+        "messageId": "test-2",
+        "role": "ROLE_USER",
+        "parts": [{ "text": "Stream me something cool!" }]
+      }
+    }
+  }'
+```
+
+## Configuration
+
+| Env Variable | Default | Description |
+|---|---|---|
+| `OPENCLAW_URL` | — | OpenClaw Gateway URL (required) |
+| `OPENCLAW_GATEWAY_TOKEN` | — | Bearer token for gateway auth |
+| `OPENCLAW_INSTANCES` | — | JSON array for multi-instance routing |
+| `PORT` | `3100` | Server port |
+| `HOST` | `0.0.0.0` | Server host |
+| `PUBLIC_URL` | `http://localhost:3100` | Public URL for Agent Card |
+| `DEBUG` | `false` | Enable debug logging |
+
+### Multi-instance
+
+Route requests to different OpenClaw instances based on message metadata:
+
+```bash
+export OPENCLAW_INSTANCES='[
+  {"name":"prod","url":"http://prod:18789","token":"t1","default":true},
+  {"name":"staging","url":"http://staging:18789","token":"t2"}
+]'
+```
+
+Then send with `"metadata": { "instance": "staging" }` in your A2A message.
+
+### CLI Options
+
+```bash
+openclaw-a2a --help
+
+Options:
+  --port, -p        Server port                    [number]
+  --host            Server host                    [string]
+  --openclaw-url    OpenClaw Gateway URL           [string]
+  --token           OpenClaw Gateway token         [string]
+  --debug           Enable debug logging           [boolean]
+```
+
+## What's Inside
+
+This implements the **A2A v1.0 specification** — the full protocol, not a subset:
+
+| Feature | Status |
+|---|---|
+| Agent Card discovery (`.well-known/agent-card.json`) | Done |
+| SendMessage (sync) | Done |
+| SendStreamingMessage (SSE) | Done |
+| GetTask / ListTasks | Done |
+| CancelTask | Done |
+| Multi-turn conversations (INPUT_REQUIRED) | Done |
+| Multi-instance routing | Done |
+| A2A-Version header validation | Done |
+| Push notifications | Stub (returns UNSUPPORTED) |
+| Extended Agent Card | Stub (returns UNSUPPORTED) |
+| SubscribeToTask | Stub (returns UNSUPPORTED) |
+
+### v1.0 Spec Compliance
+
+We implement A2A v1.0 directly from the [proto spec](https://github.com/a2aproject/A2A):
+
+- PascalCase method names (`SendMessage`, not `message/send`)
+- SCREAMING_SNAKE enum values (`TASK_STATE_COMPLETED`, not `completed`)
+- Part discrimination by field presence (not `kind`)
+- `Task.id` (not `taskId`)
+- `A2A-Version` header with fallback to `0.3` (rejected — we only support 1.0)
+- Cursor-based pagination for ListTasks
+- `supportedInterfaces[]` in Agent Card (not top-level `url`)
+
+## Who Can Talk To This?
+
+### Native A2A clients
+
+| Client | Notes |
+|---|---|
+| [Google ADK](https://google.github.io/adk-docs/) | `RemoteA2aAgent` — most mature |
+| [CrewAI](https://crewai.com/) >= v1.10 | Built-in A2A support |
+| [Microsoft Agent Framework](https://github.com/microsoft/agents) | .NET + Python |
+| [BeeAI](https://beeai.dev/) | A2A adapter |
+| [LangGraph](https://langchain-ai.github.io/langgraph/) | Server + client |
+| curl / any HTTP client | JSON-RPC over HTTP |
+
+### Via A2A-MCP bridge (for Claude)
+
+Claude doesn't speak A2A natively (it speaks MCP). But there's a bridge:
+
+1. Run `openclaw-a2a` (this project) — gives OpenClaw an A2A interface
+2. Add an [A2A-MCP bridge](https://github.com/GongRzhe/A2A-MCP-Server) to Claude
+3. Claude discovers and chats with your OpenClaw through A2A
+
+Is this useful? Maybe. Is it cool? Definitely.
+
+## Development
+
+```bash
+# Dev server (hot reload)
+npm run dev
+
+# Run tests (watch mode)
+npm run test
+
+# Full quality check
+npm run check:all    # lint + typecheck + test + build
+
+# Format
+npm run format
+```
+
+### Testing
+
+- **84 unit + integration tests** — run without external dependencies
+- **E2E tests** — require a real OpenClaw Gateway (optional)
+
+```bash
+# Unit + integration (no gateway needed)
+npm run test:run
+
+# E2E (requires gateway on localhost:18789)
+export OPENCLAW_URL=http://127.0.0.1:18789
+export OPENCLAW_GATEWAY_TOKEN=your-token
+npm run test:e2e
+```
+
+## Docker Deployment
+
+```bash
+# Build locally
+docker build -t openclaw-a2a .
+
+# Or use Docker Compose
+cp .env.example .env
+docker compose up -d
+
+# Dev mode (build from source)
+docker compose -f docker-compose.yml -f docker-compose.dev.yml up
+```
+
+## Sister Project
+
+This is the A2A sibling of [openclaw-mcp](https://github.com/freema/openclaw-mcp),
+which bridges OpenClaw to Claude via MCP. Different protocols, same OpenClaw.
+
+| | openclaw-mcp | openclaw-a2a |
+|---|---|---|
+| Protocol | MCP (Anthropic) | A2A v1.0 (Google/Linux Foundation) |
+| For | Claude.ai, Claude Desktop | Any A2A agent |
+| Port | 3000 | 3100 |
+| Status | Stable | Beta |
+
+```
+MCP  = how an agent talks to TOOLS    (vertical: agent → tools)
+A2A  = how AGENTS talk to EACH OTHER  (horizontal: agent ↔ agent)
+```
+
+They're complementary, not competing.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,952 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/config/index.ts
+function parseInstances() {
+  const raw = process.env.OPENCLAW_INSTANCES;
+  if (raw) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed) || parsed.length === 0) {
+        throw new Error("OPENCLAW_INSTANCES must be a non-empty JSON array");
+      }
+      for (const inst of parsed) {
+        if (!inst.name || !inst.url) {
+          throw new Error(`Each instance must have "name" and "url". Got: ${JSON.stringify(inst)}`);
+        }
+      }
+      const defaults = parsed.filter((i) => i.default);
+      if (defaults.length === 0) {
+        parsed[0].default = true;
+      }
+      return parsed;
+    } catch (e) {
+      if (e.message.includes("OPENCLAW_INSTANCES")) throw e;
+      throw new Error(`Failed to parse OPENCLAW_INSTANCES: ${e.message}`);
+    }
+  }
+  const url = process.env.OPENCLAW_URL;
+  if (!url) {
+    throw new Error("OPENCLAW_URL or OPENCLAW_INSTANCES must be set");
+  }
+  return [
+    {
+      name: "default",
+      url: url.replace(/\/+$/, ""),
+      token: process.env.OPENCLAW_GATEWAY_TOKEN ?? "",
+      default: true
+    }
+  ];
+}
+function loadConfig() {
+  const port = parseInt(process.env.PORT ?? "3100", 10);
+  const host = process.env.HOST ?? "0.0.0.0";
+  const debug = process.env.DEBUG === "true";
+  const publicUrl = (process.env.PUBLIC_URL ?? `http://localhost:${port}`).replace(/\/+$/, "");
+  const instances = parseInstances();
+  return { port, host, debug, publicUrl, instances };
+}
+function getDefaultInstance(config2) {
+  return config2.instances.find((i) => i.default) ?? config2.instances[0];
+}
+function getInstanceByName(config2, name) {
+  return config2.instances.find((i) => i.name === name);
+}
+
+// src/server/index.ts
+import express from "express";
+
+// src/a2a/executor.ts
+import { v4 as uuid } from "uuid";
+
+// src/utils/logger.ts
+var debugEnabled = false;
+function setDebug(enabled) {
+  debugEnabled = enabled;
+}
+function formatLog(level, message, data) {
+  const entry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    message
+  };
+  if (data) Object.assign(entry, data);
+  return JSON.stringify(entry);
+}
+function log(message, data) {
+  console.log(formatLog("info", message, data));
+}
+function logError(message, error, data) {
+  const extra = { ...data };
+  if (error instanceof Error) {
+    extra.error = error.message;
+    extra.stack = error.stack;
+  } else if (error !== void 0) {
+    extra.error = String(error);
+  }
+  console.error(formatLog("error", message, extra));
+}
+function logDebug(message, data) {
+  if (debugEnabled) {
+    console.log(formatLog("debug", message, data));
+  }
+}
+
+// src/openclaw/client.ts
+var DEFAULT_TIMEOUT = 12e4;
+var MAX_RESPONSE_SIZE = 10 * 1024 * 1024;
+var OpenClawError = class extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "OpenClawError";
+    this.statusCode = statusCode;
+  }
+};
+var OpenClawClient = class {
+  baseUrl;
+  token;
+  timeout;
+  constructor(instance, timeout = DEFAULT_TIMEOUT) {
+    this.baseUrl = instance.url.replace(/\/+$/, "");
+    this.token = instance.token;
+    this.timeout = timeout;
+  }
+  async health() {
+    const res = await fetch(`${this.baseUrl}/health`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!res.ok) {
+      throw new OpenClawError(`Health check failed: ${res.status}`, res.status);
+    }
+    return await res.json();
+  }
+  async chat(message) {
+    const url = `${this.baseUrl}/v1/chat/completions`;
+    const body = {
+      model: "openclaw",
+      messages: [{ role: "user", content: message }],
+      stream: false
+    };
+    logDebug("OpenClaw chat request", { url, messageLength: message.length });
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.token ? { Authorization: `Bearer ${this.token}` } : {}
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new OpenClawError(
+          `OpenClaw API error: ${res.status} ${res.statusText}${text ? ` \u2014 ${text}` : ""}`,
+          res.status
+        );
+      }
+      const contentLength = res.headers.get("content-length");
+      if (contentLength && parseInt(contentLength, 10) > MAX_RESPONSE_SIZE) {
+        throw new OpenClawError(
+          `Response too large: ${contentLength} bytes (max ${MAX_RESPONSE_SIZE})`
+        );
+      }
+      const data = await res.json();
+      logDebug("OpenClaw chat response", { id: data.id, choices: data.choices?.length });
+      return data;
+    } catch (e) {
+      if (e instanceof OpenClawError) throw e;
+      if (e.name === "AbortError") {
+        throw new OpenClawError(`Request timeout after ${this.timeout}ms`);
+      }
+      throw new OpenClawError(`Connection error: ${e.message}`);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async *chatStream(message, abortSignal) {
+    const url = `${this.baseUrl}/v1/chat/completions`;
+    const body = {
+      model: "openclaw",
+      messages: [{ role: "user", content: message }],
+      stream: true
+    };
+    logDebug("OpenClaw stream request", { url, messageLength: message.length });
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    if (abortSignal) {
+      abortSignal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.token ? { Authorization: `Bearer ${this.token}` } : {}
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new OpenClawError(
+          `OpenClaw API error: ${res.status} ${res.statusText}${text ? ` \u2014 ${text}` : ""}`,
+          res.status
+        );
+      }
+      if (!res.body) {
+        throw new OpenClawError("Response body is null \u2014 streaming not supported?");
+      }
+      const reader = res.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() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") return;
+          if (!data) continue;
+          try {
+            const chunk = JSON.parse(data);
+            const content = chunk.choices?.[0]?.delta?.content;
+            if (content) yield content;
+          } catch {
+            logError("Failed to parse SSE chunk", void 0, { data });
+          }
+        }
+      }
+    } catch (e) {
+      if (e instanceof OpenClawError) throw e;
+      if (e.name === "AbortError") {
+        logDebug("Stream aborted");
+        return;
+      }
+      throw new OpenClawError(`Stream error: ${e.message}`);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+
+// src/a2a/errors.ts
+var A2A_ERROR_CODES = {
+  // Standard JSON-RPC
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  // A2A specific
+  TASK_NOT_FOUND: -32001,
+  TASK_NOT_CANCELABLE: -32002,
+  PUSH_NOTIFICATION_NOT_SUPPORTED: -32003,
+  UNSUPPORTED_OPERATION: -32004,
+  CONTENT_TYPE_NOT_SUPPORTED: -32005,
+  EXTENSION_SUPPORT_REQUIRED: -32008,
+  VERSION_NOT_SUPPORTED: -32009
+};
+var A2AError = class extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "A2AError";
+    this.code = code;
+    this.data = data;
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      ...this.data !== void 0 ? { data: this.data } : {}
+    };
+  }
+};
+
+// src/a2a/types/enums.ts
+var TERMINAL_STATES = /* @__PURE__ */ new Set([
+  "TASK_STATE_COMPLETED" /* COMPLETED */,
+  "TASK_STATE_FAILED" /* FAILED */,
+  "TASK_STATE_CANCELED" /* CANCELED */,
+  "TASK_STATE_REJECTED" /* REJECTED */
+]);
+
+// src/a2a/executor.ts
+var HEARTBEAT_INTERVAL = 15e3;
+var OpenClawExecutor = class {
+  constructor(config2, taskStore) {
+    this.config = config2;
+    this.taskStore = taskStore;
+  }
+  clients = /* @__PURE__ */ new Map();
+  canceledTasks = /* @__PURE__ */ new Set();
+  getClient(instance) {
+    let client = this.clients.get(instance.name);
+    if (!client) {
+      client = new OpenClawClient(instance);
+      this.clients.set(instance.name, client);
+    }
+    return client;
+  }
+  resolveInstance(metadata) {
+    const instanceName = metadata?.instance;
+    if (instanceName) {
+      const inst = getInstanceByName(this.config, instanceName);
+      if (!inst) {
+        throw new A2AError(A2A_ERROR_CODES.INVALID_PARAMS, `Unknown instance: "${instanceName}"`);
+      }
+      return inst;
+    }
+    return getDefaultInstance(this.config);
+  }
+  extractText(message) {
+    return message.parts.filter((p) => p.text !== void 0).map((p) => p.text).join("\n");
+  }
+  cancelTask(taskId) {
+    this.canceledTasks.add(taskId);
+  }
+  isCanceled(taskId) {
+    return this.canceledTasks.has(taskId);
+  }
+  async execute(context, eventBus) {
+    const { task, contextId, userMessage } = context;
+    const text = this.extractText(userMessage);
+    if (!text) {
+      this.publishFailed(eventBus, task.id, contextId, "Empty message \u2014 no text parts found");
+      return;
+    }
+    if (this.isCanceled(task.id)) {
+      this.publishCanceled(eventBus, task.id, contextId);
+      return;
+    }
+    try {
+      const instance = this.resolveInstance(userMessage.metadata);
+      const client = this.getClient(instance);
+      this.publishStatus(eventBus, task.id, contextId, "TASK_STATE_WORKING" /* WORKING */);
+      const response = await client.chat(text);
+      const content = response.choices[0]?.message?.content ?? "";
+      if (this.isCanceled(task.id)) {
+        this.publishCanceled(eventBus, task.id, contextId);
+        return;
+      }
+      eventBus.publish({
+        artifactUpdate: {
+          taskId: task.id,
+          contextId,
+          artifact: {
+            artifactId: uuid(),
+            parts: [{ text: content }]
+          }
+        }
+      });
+      task.artifacts = [{ artifactId: uuid(), parts: [{ text: content }] }];
+      if (this.isInputRequired(content)) {
+        this.publishStatus(eventBus, task.id, contextId, "TASK_STATE_INPUT_REQUIRED" /* INPUT_REQUIRED */, {
+          messageId: uuid(),
+          role: "ROLE_AGENT" /* AGENT */,
+          parts: [{ text: content }]
+        });
+        task.status = { state: "TASK_STATE_INPUT_REQUIRED" /* INPUT_REQUIRED */, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+        this.taskStore.set(task);
+        return;
+      }
+      this.publishStatus(eventBus, task.id, contextId, "TASK_STATE_COMPLETED" /* COMPLETED */);
+      task.status = { state: "TASK_STATE_COMPLETED" /* COMPLETED */, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+      this.taskStore.set(task);
+    } catch (e) {
+      logError("Executor error", e, { taskId: task.id });
+      const msg = e instanceof OpenClawError ? e.message : "Internal execution error";
+      this.publishFailed(eventBus, task.id, contextId, msg);
+      task.status = { state: "TASK_STATE_FAILED" /* FAILED */, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+      this.taskStore.set(task);
+    } finally {
+      eventBus.finish();
+    }
+  }
+  async executeStreaming(context, eventBus) {
+    const { task, contextId, userMessage } = context;
+    const text = this.extractText(userMessage);
+    if (!text) {
+      this.publishFailed(eventBus, task.id, contextId, "Empty message \u2014 no text parts found");
+      eventBus.finish();
+      return;
+    }
+    if (this.isCanceled(task.id)) {
+      this.publishCanceled(eventBus, task.id, contextId);
+      eventBus.finish();
+      return;
+    }
+    const abortController = new AbortController();
+    const heartbeat = setInterval(() => {
+      if (!eventBus.finished) {
+        this.publishStatus(eventBus, task.id, contextId, "TASK_STATE_WORKING" /* WORKING */);
+      }
+    }, HEARTBEAT_INTERVAL);
+    try {
+      const instance = this.resolveInstance(userMessage.metadata);
+      const client = this.getClient(instance);
+      this.publishStatus(eventBus, task.id, contextId, "TASK_STATE_WORKING" /* WORKING */);
+      const artifactId = uuid();
+      let fullContent = "";
+      for await (const chunk of client.chatStream(text, abortController.signal)) {
+        if (this.isCanceled(task.id)) {
+          abortController.abort();
+          this.publishCanceled(eventBus, task.id, contextId);
+          break;
+        }
+        fullContent += chunk;
+        eventBus.publish({
+          artifactUpdate: {
+            taskId: task.id,
+            contextId,
+            artifact: { artifactId, parts: [{ text: chunk }] },
+            append: true
+          }
+        });
+      }
+      if (!this.isCanceled(task.id)) {
+        eventBus.publish({
+          artifactUpdate: {
+            taskId: task.id,
+            contextId,
+            artifact: { artifactId, parts: [{ text: "" }] },
+            lastChunk: true
+          }
+        });
+        task.artifacts = [{ artifactId, parts: [{ text: fullContent }] }];
+        if (this.isInputRequired(fullContent)) {
+          this.publishStatus(eventBus, task.id, contextId, "TASK_STATE_INPUT_REQUIRED" /* INPUT_REQUIRED */, {
+            messageId: uuid(),
+            role: "ROLE_AGENT" /* AGENT */,
+            parts: [{ text: fullContent }]
+          });
+          task.status = { state: "TASK_STATE_INPUT_REQUIRED" /* INPUT_REQUIRED */, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+          this.taskStore.set(task);
+        } else {
+          this.publishStatus(eventBus, task.id, contextId, "TASK_STATE_COMPLETED" /* COMPLETED */);
+          task.status = { state: "TASK_STATE_COMPLETED" /* COMPLETED */, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+          this.taskStore.set(task);
+        }
+      }
+    } catch (e) {
+      logError("Streaming executor error", e, { taskId: task.id });
+      const msg = e instanceof OpenClawError ? e.message : "Internal execution error";
+      this.publishFailed(eventBus, task.id, contextId, msg);
+      task.status = { state: "TASK_STATE_FAILED" /* FAILED */, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+      this.taskStore.set(task);
+    } finally {
+      clearInterval(heartbeat);
+      eventBus.finish();
+    }
+  }
+  // Multi-turn detection heuristic
+  // Returns true if the response indicates more user input is needed
+  isInputRequired(content) {
+    if (!content) return false;
+    if (content.includes("[INPUT_REQUIRED]") || content.includes("[NEEDS_INPUT]")) {
+      return false;
+    }
+    const trimmed = content.trim();
+    const lastSentence = trimmed.split(/[.!]\s/).pop()?.trim() ?? "";
+    if (lastSentence.endsWith("?") && trimmed.length < 500) {
+      return false;
+    }
+    return false;
+  }
+  publishStatus(eventBus, taskId, contextId, state, message) {
+    const status = {
+      state,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...message ? { message } : {}
+    };
+    eventBus.publish({ statusUpdate: { taskId, contextId, status } });
+    logDebug("Status update", { taskId, state });
+  }
+  publishFailed(eventBus, taskId, contextId, errorMsg) {
+    this.publishStatus(eventBus, taskId, contextId, "TASK_STATE_FAILED" /* FAILED */, {
+      messageId: uuid(),
+      role: "ROLE_AGENT" /* AGENT */,
+      parts: [{ text: errorMsg }]
+    });
+  }
+  publishCanceled(eventBus, taskId, contextId) {
+    this.publishStatus(eventBus, taskId, contextId, "TASK_STATE_CANCELED" /* CANCELED */);
+    const task = this.taskStore.get(taskId);
+    if (task) {
+      task.status = { state: "TASK_STATE_CANCELED" /* CANCELED */, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+      this.taskStore.set(task);
+    }
+    this.canceledTasks.delete(taskId);
+  }
+};
+
+// src/a2a/router.ts
+import { Router } from "express";
+
+// src/a2a/agent-card.ts
+function buildAgentCard(config2) {
+  return {
+    name: "OpenClaw A2A Bridge",
+    description: "A2A v1.0 bridge to OpenClaw AI assistant gateway",
+    version: true ? "0.1.0-beta.1" : "0.1.0-beta.1",
+    provider: {
+      organization: "OpenClaw",
+      url: "https://github.com/freema/openclaw-a2a"
+    },
+    supportedInterfaces: [
+      {
+        url: config2.publicUrl,
+        protocolBinding: "JSONRPC",
+        protocolVersion: "1.0"
+      }
+    ],
+    capabilities: {
+      streaming: true,
+      pushNotifications: false,
+      stateTransitionHistory: false,
+      extendedAgentCard: false
+    },
+    defaultInputModes: ["text/plain"],
+    defaultOutputModes: ["text/plain"],
+    skills: [
+      {
+        id: "openclaw-chat",
+        name: "OpenClaw Chat",
+        description: "Chat with OpenClaw AI assistant",
+        tags: ["chat", "ai", "assistant"],
+        examples: ["Hello!", "What can you help me with?"]
+      }
+    ]
+  };
+}
+
+// src/a2a/request-handler.ts
+import { v4 as uuid2 } from "uuid";
+
+// src/a2a/event-bus.ts
+var ExecutionEventBus = class {
+  listeners = [];
+  finishListeners = [];
+  _finished = false;
+  get finished() {
+    return this._finished;
+  }
+  on(listener) {
+    this.listeners.push(listener);
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== listener);
+    };
+  }
+  onFinish(listener) {
+    if (this._finished) {
+      listener();
+      return () => {
+      };
+    }
+    this.finishListeners.push(listener);
+    return () => {
+      this.finishListeners = this.finishListeners.filter((l) => l !== listener);
+    };
+  }
+  publish(event) {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  finish() {
+    this._finished = true;
+    for (const listener of this.finishListeners) {
+      listener();
+    }
+    this.listeners = [];
+    this.finishListeners = [];
+  }
+};
+
+// src/a2a/sse.ts
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  Connection: "keep-alive",
+  "X-Accel-Buffering": "no"
+};
+function formatSSEEvent(data) {
+  return `data: ${JSON.stringify(data)}
+
+`;
+}
+
+// src/a2a/request-handler.ts
+function createRequestHandler(config2, taskStore, executor) {
+  return async (req, res) => {
+    try {
+      resolveAndValidateVersion(req);
+      const rpcReq = parseJsonRpcRequest(req.body);
+      logDebug("JSON-RPC request", { method: rpcReq.method, id: rpcReq.id });
+      const method = rpcReq.method;
+      switch (method) {
+        case "SendMessage":
+          return await handleSendMessage(rpcReq, res, config2, taskStore, executor);
+        case "SendStreamingMessage":
+          return await handleSendStreamingMessage(rpcReq, res, config2, taskStore, executor);
+        case "GetTask":
+          return handleGetTask(rpcReq, res, taskStore);
+        case "ListTasks":
+          return handleListTasks(rpcReq, res, taskStore);
+        case "CancelTask":
+          return handleCancelTask(rpcReq, res, taskStore, executor);
+        case "SubscribeToTask":
+          return handleSubscribeToTask(rpcReq, res);
+        case "CreateTaskPushNotificationConfig":
+        case "GetTaskPushNotificationConfig":
+        case "ListTaskPushNotificationConfigs":
+        case "DeleteTaskPushNotificationConfig":
+          return sendJsonRpcError(
+            res,
+            rpcReq.id,
+            A2A_ERROR_CODES.PUSH_NOTIFICATION_NOT_SUPPORTED,
+            "Push notifications are not supported"
+          );
+        case "GetExtendedAgentCard":
+          return sendJsonRpcError(
+            res,
+            rpcReq.id,
+            A2A_ERROR_CODES.UNSUPPORTED_OPERATION,
+            "Extended agent card is not supported"
+          );
+        default:
+          return sendJsonRpcError(
+            res,
+            rpcReq.id,
+            A2A_ERROR_CODES.METHOD_NOT_FOUND,
+            `Unknown method: ${method}`
+          );
+      }
+    } catch (e) {
+      if (e instanceof A2AError) {
+        return sendJsonRpcError(res, req.body?.id ?? null, e.code, e.message, e.data);
+      }
+      logError("Unhandled request error", e);
+      return sendJsonRpcError(
+        res,
+        req.body?.id ?? null,
+        A2A_ERROR_CODES.INTERNAL_ERROR,
+        "Internal server error"
+      );
+    }
+  };
+}
+function resolveAndValidateVersion(req) {
+  const raw = req.header("A2A-Version")?.trim() || req.query["A2A-Version"];
+  const version = raw || "0.3";
+  if (version !== "1.0") {
+    throw new A2AError(
+      A2A_ERROR_CODES.VERSION_NOT_SUPPORTED,
+      `A2A version "${version}" is not supported. Supported versions: ["1.0"]`,
+      { supportedVersions: ["1.0"] }
+    );
+  }
+  return version;
+}
+function parseJsonRpcRequest(body) {
+  if (!body || typeof body !== "object") {
+    throw new A2AError(A2A_ERROR_CODES.PARSE_ERROR, "Invalid JSON");
+  }
+  if (body.jsonrpc !== "2.0") {
+    throw new A2AError(
+      A2A_ERROR_CODES.INVALID_REQUEST,
+      'Missing or invalid jsonrpc version (must be "2.0")'
+    );
+  }
+  if (!body.method || typeof body.method !== "string") {
+    throw new A2AError(A2A_ERROR_CODES.INVALID_REQUEST, "Missing or invalid method");
+  }
+  return body;
+}
+async function handleSendMessage(rpcReq, res, config2, taskStore, executor) {
+  const params = rpcReq.params;
+  if (!params?.message) {
+    return sendJsonRpcError(
+      res,
+      rpcReq.id,
+      A2A_ERROR_CODES.INVALID_PARAMS,
+      "Missing message in params"
+    );
+  }
+  const context = createTaskContext(params, taskStore);
+  const eventBus = new ExecutionEventBus();
+  await executor.execute(context, eventBus);
+  const task = taskStore.get(context.task.id) ?? context.task;
+  return sendJsonRpcResult(res, rpcReq.id, task);
+}
+async function handleSendStreamingMessage(rpcReq, res, config2, taskStore, executor) {
+  const params = rpcReq.params;
+  if (!params?.message) {
+    return sendJsonRpcError(
+      res,
+      rpcReq.id,
+      A2A_ERROR_CODES.INVALID_PARAMS,
+      "Missing message in params"
+    );
+  }
+  const context = createTaskContext(params, taskStore);
+  const eventBus = new ExecutionEventBus();
+  res.writeHead(200, SSE_HEADERS);
+  eventBus.on((event) => {
+    const rpcResponse = {
+      jsonrpc: "2.0",
+      id: rpcReq.id,
+      result: event
+    };
+    res.write(formatSSEEvent(rpcResponse));
+  });
+  eventBus.onFinish(() => {
+    res.end();
+  });
+  executor.executeStreaming(context, eventBus).catch((e) => {
+    logError("Streaming execution error", e);
+    if (!res.writableEnded) {
+      res.end();
+    }
+  });
+}
+function handleGetTask(rpcReq, res, taskStore) {
+  const params = rpcReq.params;
+  if (!params?.id) {
+    return sendJsonRpcError(res, rpcReq.id, A2A_ERROR_CODES.INVALID_PARAMS, "Missing task id");
+  }
+  const task = taskStore.get(params.id);
+  if (!task) {
+    return sendJsonRpcError(
+      res,
+      rpcReq.id,
+      A2A_ERROR_CODES.TASK_NOT_FOUND,
+      `Task not found: ${params.id}`
+    );
+  }
+  if (params.historyLength !== void 0 && task.history) {
+    task.history = task.history.slice(-params.historyLength);
+  }
+  return sendJsonRpcResult(res, rpcReq.id, task);
+}
+function handleListTasks(rpcReq, res, taskStore) {
+  const params = rpcReq.params ?? {};
+  const result = taskStore.list({
+    contextId: params.contextId,
+    taskStates: params.taskStates,
+    cursor: params.cursor,
+    pageSize: params.pageSize
+  });
+  return sendJsonRpcResult(res, rpcReq.id, result);
+}
+function handleCancelTask(rpcReq, res, taskStore, executor) {
+  const params = rpcReq.params;
+  if (!params?.id) {
+    return sendJsonRpcError(res, rpcReq.id, A2A_ERROR_CODES.INVALID_PARAMS, "Missing task id");
+  }
+  const task = taskStore.get(params.id);
+  if (!task) {
+    return sendJsonRpcError(
+      res,
+      rpcReq.id,
+      A2A_ERROR_CODES.TASK_NOT_FOUND,
+      `Task not found: ${params.id}`
+    );
+  }
+  if (TERMINAL_STATES.has(task.status.state)) {
+    return sendJsonRpcError(
+      res,
+      rpcReq.id,
+      A2A_ERROR_CODES.TASK_NOT_CANCELABLE,
+      `Task is in terminal state: ${task.status.state}`
+    );
+  }
+  executor.cancelTask(params.id);
+  task.status = { state: "TASK_STATE_CANCELED" /* CANCELED */, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+  taskStore.set(task);
+  return sendJsonRpcResult(res, rpcReq.id, task);
+}
+function handleSubscribeToTask(rpcReq, res) {
+  return sendJsonRpcError(
+    res,
+    rpcReq.id,
+    A2A_ERROR_CODES.UNSUPPORTED_OPERATION,
+    "SubscribeToTask is not yet supported"
+  );
+}
+function createTaskContext(params, taskStore) {
+  const message = params.message;
+  let contextId;
+  let existingTask;
+  if (message.taskId) {
+    existingTask = taskStore.get(message.taskId);
+    if (existingTask) {
+      contextId = message.contextId ?? existingTask.contextId;
+    } else {
+      contextId = message.contextId ?? uuid2();
+    }
+  } else {
+    contextId = message.contextId ?? uuid2();
+  }
+  const task = existingTask ?? {
+    id: uuid2(),
+    contextId,
+    status: { state: "TASK_STATE_SUBMITTED" /* SUBMITTED */, timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+    history: [],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (!task.history) task.history = [];
+  task.history.push(message);
+  taskStore.set(task);
+  return { task, contextId, userMessage: message };
+}
+function sendJsonRpcResult(res, id, result) {
+  const response = { jsonrpc: "2.0", id, result };
+  res.json(response);
+}
+function sendJsonRpcError(res, id, code, message, data) {
+  const response = {
+    jsonrpc: "2.0",
+    id: id ?? 0,
+    error: { code, message, ...data !== void 0 ? { data } : {} }
+  };
+  res.json(response);
+}
+
+// src/a2a/router.ts
+function createA2ARouter(config2, taskStore, executor) {
+  const router = Router();
+  const handler = createRequestHandler(config2, taskStore, executor);
+  router.get("/.well-known/agent-card.json", (_req, res) => {
+    res.json(buildAgentCard({ publicUrl: config2.publicUrl }));
+  });
+  router.post("/a2a", handler);
+  return router;
+}
+
+// src/a2a/task-store.ts
+var InMemoryTaskStore = class {
+  tasks = /* @__PURE__ */ new Map();
+  get(id) {
+    return this.tasks.get(id);
+  }
+  set(task) {
+    task.lastModified = (/* @__PURE__ */ new Date()).toISOString();
+    this.tasks.set(task.id, task);
+  }
+  list(options) {
+    let all = Array.from(this.tasks.values());
+    if (options?.contextId) {
+      all = all.filter((t) => t.contextId === options.contextId);
+    }
+    if (options?.taskStates && options.taskStates.length > 0) {
+      const states = new Set(options.taskStates);
+      all = all.filter((t) => states.has(t.status.state));
+    }
+    all.sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
+    const pageSize = options?.pageSize ?? 50;
+    let startIndex = 0;
+    if (options?.cursor) {
+      const cursorIndex = all.findIndex((t) => t.id === options.cursor);
+      if (cursorIndex >= 0) startIndex = cursorIndex + 1;
+    }
+    const page = all.slice(startIndex, startIndex + pageSize);
+    const nextCursor = startIndex + pageSize < all.length ? all[startIndex + pageSize - 1]?.id : void 0;
+    return { tasks: page, nextCursor };
+  }
+  delete(id) {
+    return this.tasks.delete(id);
+  }
+};
+
+// src/server/index.ts
+function createApp(config2) {
+  const app = express();
+  const taskStore = new InMemoryTaskStore();
+  const executor = new OpenClawExecutor(config2, taskStore);
+  app.use(express.json({ limit: "10mb" }));
+  app.get("/health", (_req, res) => {
+    res.json({
+      status: "ok",
+      version: "0.1.0-beta.1",
+      a2aVersion: "1.0",
+      uptime: process.uptime()
+    });
+  });
+  app.get("/instances", (_req, res) => {
+    res.json(
+      config2.instances.map((i) => ({
+        name: i.name,
+        url: i.url,
+        default: i.default ?? false
+      }))
+    );
+  });
+  app.use(createA2ARouter(config2, taskStore, executor));
+  return { app, taskStore, executor };
+}
+function startServer(config2) {
+  const { app } = createApp(config2);
+  const server = app.listen(config2.port, config2.host, () => {
+    log("Server started", {
+      port: config2.port,
+      host: config2.host,
+      publicUrl: config2.publicUrl,
+      instances: config2.instances.length
+    });
+    log(`Agent Card: ${config2.publicUrl}/.well-known/agent-card.json`);
+    log(`A2A endpoint: ${config2.publicUrl}/a2a`);
+  });
+  const shutdown = (signal) => {
+    log(`Received ${signal}, shutting down...`);
+    server.close(() => {
+      log("Server closed");
+      process.exit(0);
+    });
+    setTimeout(() => {
+      log("Forced shutdown");
+      process.exit(1);
+    }, 1e4);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  return server;
+}
+
+// src/index.ts
+var argv = yargs(hideBin(process.argv)).scriptName("openclaw-a2a").version(true ? "0.1.0-beta.1" : "0.1.0-beta.1").option("port", {
+  alias: "p",
+  type: "number",
+  description: "Server port"
+}).option("host", {
+  type: "string",
+  description: "Server host"
+}).option("openclaw-url", {
+  type: "string",
+  description: "OpenClaw Gateway URL"
+}).option("token", {
+  type: "string",
+  description: "OpenClaw Gateway token"
+}).option("debug", {
+  type: "boolean",
+  description: "Enable debug logging"
+}).parseSync();
+if (argv.port) process.env.PORT = String(argv.port);
+if (argv.host) process.env.HOST = argv.host;
+if (argv["openclaw-url"]) process.env.OPENCLAW_URL = argv["openclaw-url"];
+if (argv.token) process.env.OPENCLAW_GATEWAY_TOKEN = argv.token;
+if (argv.debug) process.env.DEBUG = "true";
+var config = loadConfig();
+setDebug(config.debug);
+startServer(config);

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "openclaw-a2a",
+  "version": "0.1.0-beta.1",
+  "description": "A2A v1.0 bridge for OpenClaw AI assistant — agent-to-agent communication",
+  "author": "Tomas Grasl <https://www.tomasgrasl.cz/>",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "openclaw-a2a": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsup",
+    "start": "node dist/index.js",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "check": "npm run lint:fix && npm run typecheck",
+    "check:all": "npm run check && npm run test:run && npm run build",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:e2e": "vitest run --config tests/e2e/vitest.config.ts"
+  },
+  "keywords": [
+    "a2a",
+    "a2a-protocol",
+    "agent-to-agent",
+    "openclaw",
+    "ai-agent",
+    "bridge",
+    "google-a2a"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "express": "^4.21.2",
+    "uuid": "^11.1.0",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.11.0",
+    "@types/supertest": "^6.0.2",
+    "@types/uuid": "^10.0.0",
+    "@types/yargs": "^17.0.32",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "prettier": "^3.3.3",
+    "supertest": "^7.1.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3",
+    "vitest": "^2.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "homepage": "https://github.com/freema/openclaw-a2a#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/freema/openclaw-a2a.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "beta"
+  }
+}