clawnexus 0.3.1 → 0.4.0

package/dist/a2a/card.js

@@ -9,19 +9,24 @@ const DEFAULT_SKILL = {
     tags: ["general"],
 };
 function buildAgentCard(instance, daemonVersion, skills) {
+    // Skill priority: remote_card.skills (remote) > skills param (local) > DEFAULT_SKILL
+    const resolvedSkills = instance.remote_card?.skills?.length
+        ? instance.remote_card.skills
+        : (skills && skills.length > 0 ? skills : [DEFAULT_SKILL]);
+    const remoteCapabilities = instance.remote_card?.capabilities;
     return {
         name: instance.alias ?? instance.auto_name,
         description: instance.display_name || instance.assistant_name,
         url: `http://${instance.address}:17890`,
         version: daemonVersion,
         capabilities: {
-            streaming: false,
-            pushNotifications: false,
-            stateTransitionHistory: false,
+            streaming: remoteCapabilities?.streaming ?? false,
+            pushNotifications: remoteCapabilities?.pushNotifications ?? false,
+            stateTransitionHistory: remoteCapabilities?.stateTransitionHistory ?? false,
         },
-        skills: skills && skills.length > 0 ? skills : [DEFAULT_SKILL],
-        defaultInputModes: ["text/plain"],
-        defaultOutputModes: ["text/plain"],
+        skills: resolvedSkills,
+        defaultInputModes: instance.remote_card?.input_modes ?? ["text/plain"],
+        defaultOutputModes: instance.remote_card?.output_modes ?? ["text/plain"],
         provider: {
             name: "ClawNexus",
             url: "https://github.com/SilverstreamsAI/ClawNexus",

package/dist/a2a/fetcher.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from "node:events";
+import type { RegistryStore } from "../registry/store.js";
+import type { ClawInstance, RemoteCard } from "../types.js";
+export interface CardFetcherOptions {
+    refreshIntervalMs?: number;
+    fetchTimeoutMs?: number;
+    staleMs?: number;
+}
+export declare class CardFetcher extends EventEmitter {
+    private readonly store;
+    private readonly refreshIntervalMs;
+    private readonly fetchTimeoutMs;
+    private readonly staleMs;
+    private refreshTimer;
+    private readonly pendingKeys;
+    private stopped;
+    constructor(store: RegistryStore, opts?: CardFetcherOptions);
+    start(): void;
+    stop(): void;
+    private onUpsert;
+    private shouldSkip;
+    private fetchAndApply;
+    fetchCard(instance: ClawInstance): Promise<RemoteCard | null>;
+    refreshAll(): Promise<void>;
+    determineCardUrl(instance: ClawInstance): string;
+}

package/dist/a2a/fetcher.js

@@ -0,0 +1,152 @@
+"use strict";
+// CardFetcher — fetches remote Agent Cards from discovered instances
+// Listens to store "upsert" events and populates remote_card on each instance.
+// Self instances are skipped (they use local SkillsRegistry).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CardFetcher = void 0;
+const node_events_1 = require("node:events");
+const REFRESH_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+const FETCH_TIMEOUT_MS = 3000;
+const STALE_MS = 5 * 60 * 1000; // 5 minutes
+class CardFetcher extends node_events_1.EventEmitter {
+    store;
+    refreshIntervalMs;
+    fetchTimeoutMs;
+    staleMs;
+    refreshTimer = null;
+    pendingKeys = new Set();
+    stopped = false;
+    constructor(store, opts = {}) {
+        super();
+        this.store = store;
+        this.refreshIntervalMs = opts.refreshIntervalMs ?? REFRESH_INTERVAL_MS;
+        this.fetchTimeoutMs = opts.fetchTimeoutMs ?? FETCH_TIMEOUT_MS;
+        this.staleMs = opts.staleMs ?? STALE_MS;
+    }
+    start() {
+        if (this.refreshTimer !== null)
+            return; // already running
+        this.stopped = false;
+        this.store.on("upsert", this.onUpsert);
+        // Initial fetch for all existing instances
+        this.refreshAll().catch((err) => {
+            console.log(`[clawnexus] [CardFetcher] Initial refresh failed (non-fatal): ${err}`);
+        });
+        // Periodic refresh
+        this.refreshTimer = setInterval(() => {
+            this.refreshAll().catch((err) => {
+                console.log(`[clawnexus] [CardFetcher] Periodic refresh failed (non-fatal): ${err}`);
+            });
+        }, this.refreshIntervalMs);
+    }
+    stop() {
+        this.stopped = true;
+        this.store.off("upsert", this.onUpsert);
+        if (this.refreshTimer) {
+            clearInterval(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+        this.pendingKeys.clear();
+    }
+    onUpsert = (instance) => {
+        if (this.stopped)
+            return;
+        if (this.shouldSkip(instance))
+            return;
+        const key = this.store.networkKey(instance.address, instance.gateway_port);
+        // Guard against infinite loop: if we're currently processing this key, skip
+        if (this.pendingKeys.has(key))
+            return;
+        this.pendingKeys.add(key);
+        this.fetchAndApply(instance, key).finally(() => {
+            this.pendingKeys.delete(key);
+        });
+    };
+    shouldSkip(instance) {
+        // Skip self instances — they use local SkillsRegistry
+        if (instance.is_self)
+            return true;
+        // Skip offline instances
+        if (instance.status === "offline")
+            return true;
+        // Skip if remote_card is fresh enough
+        if (instance.remote_card) {
+            const age = Date.now() - new Date(instance.remote_card.fetched_at).getTime();
+            if (age < this.staleMs)
+                return true;
+        }
+        return false;
+    }
+    async fetchAndApply(instance, key) {
+        try {
+            const card = await this.fetchCard(instance);
+            if (!card || this.stopped)
+                return;
+            // Re-fetch the instance from store (it may have been updated during fetch)
+            const current = this.store.getByNetworkKey(instance.address, instance.gateway_port);
+            if (!current)
+                return;
+            // Apply remote_card directly and re-upsert
+            current.remote_card = card;
+            // Use upsert so it persists (the pendingKeys guard prevents re-entry)
+            this.store.upsert(current);
+            this.emit("card_fetched", { key, skills_count: card.skills.length });
+            console.log(`[clawnexus] [CardFetcher] Fetched card for ${current.auto_name}: ${card.skills.length} skill(s)`);
+        }
+        catch (err) {
+            this.emit("card_error", { key, error: err });
+        }
+    }
+    async fetchCard(instance) {
+        const url = this.determineCardUrl(instance);
+        try {
+            const resp = await fetch(url, {
+                signal: AbortSignal.timeout(this.fetchTimeoutMs),
+                headers: { Accept: "application/json" },
+            });
+            if (!resp.ok)
+                return null;
+            const data = (await resp.json());
+            if (!data || !Array.isArray(data.skills))
+                return null;
+            return {
+                skills: data.skills,
+                capabilities: data.capabilities,
+                input_modes: data.defaultInputModes,
+                output_modes: data.defaultOutputModes,
+                card_url: url,
+                fetched_at: new Date().toISOString(),
+            };
+        }
+        catch {
+            // Timeout, network error, JSON parse error — all graceful
+            return null;
+        }
+    }
+    async refreshAll() {
+        if (this.stopped)
+            return;
+        const instances = this.store.getAll();
+        const promises = [];
+        for (const inst of instances) {
+            if (this.shouldSkip(inst))
+                continue;
+            const key = this.store.networkKey(inst.address, inst.gateway_port);
+            if (this.pendingKeys.has(key))
+                continue;
+            this.pendingKeys.add(key);
+            promises.push(this.fetchAndApply(inst, key).finally(() => {
+                this.pendingKeys.delete(key);
+            }));
+        }
+        await Promise.allSettled(promises);
+    }
+    determineCardUrl(instance) {
+        const proto = instance.tls ? "https" : "http";
+        // CDP-discovered instances have a ClawNexus daemon on port 17890
+        // Other discovery sources: try the daemon port too (if they have ClawNexus)
+        const port = 17890;
+        return `${proto}://${instance.address}:${port}/.well-known/agent-card.json`;
+    }
+}
+exports.CardFetcher = CardFetcher;

package/dist/a2a/handler.d.ts

@@ -0,0 +1,30 @@
+import type { A2ATask, A2AError } from "./types.js";
+import type { A2ATaskStore } from "./store.js";
+export interface A2AHandlerOptions {
+    gatewayUrl?: string;
+    timeoutMs?: number;
+    maxConcurrent?: number;
+    store?: A2ATaskStore;
+}
+export declare class A2AHandler {
+    private readonly gatewayUrl;
+    private readonly timeoutMs;
+    private readonly maxConcurrent;
+    private readonly store;
+    private conn;
+    private connecting;
+    private reconnectAttempt;
+    private readonly sessions;
+    private activeTasks;
+    constructor(opts?: A2AHandlerOptions);
+    handleTaskSend(params: unknown): Promise<A2ATask | A2AError>;
+    getTask(taskId: string): A2ATask | undefined;
+    /** Clean up connection and pending sessions. */
+    close(): void;
+    private getConnection;
+    private connect;
+    private scheduleReconnect;
+    private sendAndWait;
+    private extractResponse;
+    private persistTask;
+}

package/dist/a2a/handler.js

@@ -0,0 +1,228 @@
+"use strict";
+// A2A Task Handler — manages tasks/send and tasks/get
+// Uses a persistent Gateway connection (lazy init, auto-reconnect) shared across
+// concurrent tasks. Each task is identified by a unique sessionKey for multiplexing.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A2AHandler = void 0;
+const node_crypto_1 = require("node:crypto");
+const ws_1 = require("ws");
+const gateway_js_1 = require("../agent/gateway.js");
+const types_js_1 = require("./types.js");
+const DEFAULT_TIMEOUT_MS = 60_000;
+const DEFAULT_MAX_CONCURRENT = 5;
+const RECONNECT_BASE_MS = 1_000;
+const RECONNECT_MAX_MS = 30_000;
+class A2AHandler {
+    gatewayUrl;
+    timeoutMs;
+    maxConcurrent;
+    store;
+    // Persistent Gateway connection
+    conn = null;
+    connecting = null;
+    reconnectAttempt = 0;
+    // Session-based dispatch for multiplexed tasks
+    sessions = new Map();
+    activeTasks = 0;
+    constructor(opts = {}) {
+        this.gatewayUrl = opts.gatewayUrl ?? "ws://127.0.0.1:18789";
+        this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.maxConcurrent = opts.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+        this.store = opts.store ?? null;
+    }
+    async handleTaskSend(params) {
+        const p = params;
+        if (!p?.message?.parts?.length) {
+            return { code: types_js_1.JSON_RPC_INVALID_PARAMS, message: "Missing message with parts" };
+        }
+        const textParts = p.message.parts.filter((part) => part.type === "text");
+        if (textParts.length === 0) {
+            return { code: types_js_1.JSON_RPC_INVALID_PARAMS, message: "No text parts in message" };
+        }
+        // Concurrency guard
+        if (this.activeTasks >= this.maxConcurrent) {
+            return {
+                code: types_js_1.JSON_RPC_TASK_LIMIT_EXCEEDED,
+                message: `Too many concurrent tasks (max: ${this.maxConcurrent})`,
+            };
+        }
+        const userText = textParts.map((part) => part.text).join("\n");
+        const taskId = (0, node_crypto_1.randomUUID)();
+        const sessionKey = `agent:main:main:dm:a2a-task-${taskId}`;
+        const task = {
+            id: taskId,
+            status: { state: "submitted" },
+            history: [p.message],
+        };
+        this.persistTask(task);
+        this.activeTasks++;
+        // Acquire shared connection
+        let conn;
+        try {
+            conn = await this.getConnection();
+        }
+        catch (err) {
+            this.activeTasks--;
+            task.status = {
+                state: "failed",
+                message: { role: "agent", parts: [{ type: "text", text: `Gateway connection failed: ${err.message}` }] },
+            };
+            this.persistTask(task);
+            return task;
+        }
+        task.status.state = "working";
+        this.persistTask(task);
+        try {
+            const result = await this.sendAndWait(conn.ws, sessionKey, userText);
+            const agentMsg = { role: "agent", parts: [{ type: "text", text: result }] };
+            task.status = { state: "completed", message: agentMsg };
+            task.artifacts = [{ parts: [{ type: "text", text: result }] }];
+            if (task.history)
+                task.history.push(agentMsg);
+        }
+        catch (err) {
+            task.status = {
+                state: "failed",
+                message: { role: "agent", parts: [{ type: "text", text: err.message }] },
+            };
+        }
+        finally {
+            this.activeTasks--;
+            this.persistTask(task);
+        }
+        return task;
+    }
+    getTask(taskId) {
+        return this.store?.get(taskId);
+    }
+    /** Clean up connection and pending sessions. */
+    close() {
+        for (const [, session] of this.sessions) {
+            clearTimeout(session.timer);
+            session.reject(new Error("Handler closed"));
+        }
+        this.sessions.clear();
+        if (this.conn) {
+            this.conn.close();
+            this.conn = null;
+        }
+        this.connecting = null;
+    }
+    // --- Connection management ---
+    async getConnection() {
+        if (this.conn && this.conn.ws.readyState === ws_1.WebSocket.OPEN) {
+            return this.conn;
+        }
+        // Avoid duplicate connect attempts
+        if (this.connecting)
+            return this.connecting;
+        this.connecting = this.connect();
+        try {
+            return await this.connecting;
+        }
+        finally {
+            this.connecting = null;
+        }
+    }
+    async connect() {
+        const conn = await (0, gateway_js_1.connectGateway)({ gatewayUrl: this.gatewayUrl });
+        this.conn = conn;
+        this.reconnectAttempt = 0;
+        // Shared event dispatch: route incoming events to the right session
+        conn.ws.on("message", (data) => {
+            let msg;
+            try {
+                msg = JSON.parse(data.toString());
+            }
+            catch {
+                return;
+            }
+            if (msg.type !== "event")
+                return;
+            const event = msg.event;
+            if (event !== "chat" && event !== "chat.update")
+                return;
+            const payload = msg.payload;
+            const sk = payload?.sessionKey ?? msg.sessionKey;
+            if (!sk)
+                return;
+            const session = this.sessions.get(sk);
+            if (!session)
+                return;
+            const state = payload?.state;
+            if (state === "final") {
+                this.sessions.delete(sk);
+                clearTimeout(session.timer);
+                session.resolve(this.extractResponse(payload));
+            }
+            else if (state === "error") {
+                this.sessions.delete(sk);
+                clearTimeout(session.timer);
+                session.reject(new Error(payload?.errorMessage ?? "OpenClaw chat error"));
+            }
+        });
+        conn.ws.on("close", () => {
+            this.conn = null;
+            // Reject all pending sessions — they'll fail their tasks gracefully
+            for (const [sk, session] of this.sessions) {
+                clearTimeout(session.timer);
+                session.reject(new Error("Gateway connection closed during task execution"));
+                this.sessions.delete(sk);
+            }
+            this.scheduleReconnect();
+        });
+        return conn;
+    }
+    scheduleReconnect() {
+        // Only reconnect if there could be future tasks (handler not closed)
+        const delay = Math.min(RECONNECT_BASE_MS * 2 ** this.reconnectAttempt, RECONNECT_MAX_MS);
+        this.reconnectAttempt++;
+        setTimeout(() => {
+            // Lazy: don't eagerly reconnect, just clear state so next getConnection() will connect fresh
+            this.connecting = null;
+        }, delay);
+    }
+    // --- Task execution ---
+    sendAndWait(ws, sessionKey, message) {
+        return new Promise((resolve, reject) => {
+            const requestId = (0, node_crypto_1.randomUUID)();
+            const timer = setTimeout(() => {
+                this.sessions.delete(sessionKey);
+                reject(new Error("Task execution timed out"));
+            }, this.timeoutMs);
+            this.sessions.set(sessionKey, { resolve, reject, timer });
+            ws.send(JSON.stringify({
+                type: "req",
+                id: requestId,
+                method: "chat.send",
+                params: { sessionKey, message, idempotencyKey: requestId },
+            }));
+        });
+    }
+    extractResponse(payload) {
+        if (!payload)
+            return "Task completed (no output)";
+        const messages = payload.messages;
+        if (messages && messages.length > 0) {
+            const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+            if (lastAssistant) {
+                const content = lastAssistant.content;
+                if (typeof content === "string")
+                    return content;
+                if (Array.isArray(content)) {
+                    return content
+                        .filter((b) => b.type === "text")
+                        .map((b) => b.text)
+                        .join("\n");
+                }
+            }
+        }
+        return payload.content ?? "Task completed (no output)";
+    }
+    // --- Persistence ---
+    persistTask(task) {
+        if (this.store)
+            this.store.put(task);
+    }
+}
+exports.A2AHandler = A2AHandler;

package/dist/a2a/store.d.ts

@@ -0,0 +1,17 @@
+import type { A2ATask } from "./types.js";
+export declare class A2ATaskStore {
+    private readonly tasks;
+    private readonly filePath;
+    private flushTimer;
+    private flushInProgress;
+    private dirty;
+    constructor(configDir?: string);
+    init(): Promise<void>;
+    get(taskId: string): A2ATask | undefined;
+    put(task: A2ATask): void;
+    getAll(): A2ATask[];
+    close(): Promise<void>;
+    private evict;
+    private scheduleDirtyFlush;
+    private flushNow;
+}

package/dist/a2a/store.js

@@ -0,0 +1,134 @@
+"use strict";
+// A2A Task Store — persists task records to ~/.clawnexus/a2a-tasks.json
+// FIFO eviction: keeps at most MAX_TASKS entries.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A2ATaskStore = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const CLAWNEXUS_DIR = path.join(os.homedir(), ".clawnexus");
+const DEFAULT_FILE = "a2a-tasks.json";
+const MAX_TASKS = 100;
+const DEBOUNCE_MS = 500;
+class A2ATaskStore {
+    tasks = new Map();
+    filePath;
+    flushTimer = null;
+    flushInProgress = null;
+    dirty = false;
+    constructor(configDir) {
+        const dir = configDir ?? CLAWNEXUS_DIR;
+        this.filePath = path.join(dir, DEFAULT_FILE);
+    }
+    async init() {
+        await fs.promises.mkdir(path.dirname(this.filePath), { recursive: true });
+        if (fs.existsSync(this.filePath)) {
+            try {
+                const raw = await fs.promises.readFile(this.filePath, "utf-8");
+                const data = JSON.parse(raw);
+                if (data.version === 1 && Array.isArray(data.tasks)) {
+                    for (const t of data.tasks) {
+                        this.tasks.set(t.id, t);
+                    }
+                }
+            }
+            catch {
+                // Corrupted file — start fresh
+            }
+        }
+    }
+    get(taskId) {
+        return this.tasks.get(taskId);
+    }
+    put(task) {
+        this.tasks.set(task.id, task);
+        this.evict();
+        this.scheduleDirtyFlush();
+    }
+    getAll() {
+        return Array.from(this.tasks.values());
+    }
+    async close() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        // Wait for any in-progress timer-based flush before deciding whether to flush again
+        if (this.flushInProgress) {
+            await this.flushInProgress;
+        }
+        if (this.dirty) {
+            await this.flushNow();
+        }
+    }
+    evict() {
+        if (this.tasks.size <= MAX_TASKS)
+            return;
+        // Map iteration order = insertion order; delete oldest entries
+        const excess = this.tasks.size - MAX_TASKS;
+        let removed = 0;
+        for (const key of this.tasks.keys()) {
+            if (removed >= excess)
+                break;
+            this.tasks.delete(key);
+            removed++;
+        }
+    }
+    scheduleDirtyFlush() {
+        this.dirty = true;
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            this.flushInProgress = this.flushNow().finally(() => {
+                this.flushInProgress = null;
+            });
+        }, DEBOUNCE_MS);
+    }
+    async flushNow() {
+        const data = {
+            version: 1,
+            updated_at: new Date().toISOString(),
+            tasks: Array.from(this.tasks.values()),
+        };
+        const json = JSON.stringify(data, null, 2);
+        const tmpPath = this.filePath + ".tmp";
+        await fs.promises.writeFile(tmpPath, json, "utf-8");
+        await fs.promises.rename(tmpPath, this.filePath);
+        this.dirty = false;
+    }
+}
+exports.A2ATaskStore = A2ATaskStore;

package/dist/a2a/types.d.ts

@@ -0,0 +1,45 @@
+export interface A2ARequest {
+    jsonrpc: "2.0";
+    method: string;
+    id: string | number;
+    params?: unknown;
+}
+export interface A2AResponse {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: unknown;
+    error?: A2AError;
+}
+export interface A2AError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface A2ATask {
+    id: string;
+    status: A2ATaskStatus;
+    artifacts?: A2AArtifact[];
+    history?: A2AMessage[];
+}
+export interface A2ATaskStatus {
+    state: "submitted" | "working" | "completed" | "failed" | "canceled";
+    message?: A2AMessage;
+}
+export interface A2AMessage {
+    role: "user" | "agent";
+    parts: A2APart[];
+}
+export type A2APart = {
+    type: "text";
+    text: string;
+};
+export interface A2AArtifact {
+    name?: string;
+    parts: A2APart[];
+}
+export declare const JSON_RPC_PARSE_ERROR = -32700;
+export declare const JSON_RPC_INVALID_REQUEST = -32600;
+export declare const JSON_RPC_METHOD_NOT_FOUND = -32601;
+export declare const JSON_RPC_INVALID_PARAMS = -32602;
+export declare const JSON_RPC_INTERNAL_ERROR = -32603;
+export declare const JSON_RPC_TASK_LIMIT_EXCEEDED = -32005;

package/dist/a2a/types.js

@@ -0,0 +1,11 @@
+"use strict";
+// A2A JSON-RPC 2.0 types and Task model (spec v0.2.1)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSON_RPC_TASK_LIMIT_EXCEEDED = exports.JSON_RPC_INTERNAL_ERROR = exports.JSON_RPC_INVALID_PARAMS = exports.JSON_RPC_METHOD_NOT_FOUND = exports.JSON_RPC_INVALID_REQUEST = exports.JSON_RPC_PARSE_ERROR = void 0;
+// --- JSON-RPC Error Codes ---
+exports.JSON_RPC_PARSE_ERROR = -32700;
+exports.JSON_RPC_INVALID_REQUEST = -32600;
+exports.JSON_RPC_METHOD_NOT_FOUND = -32601;
+exports.JSON_RPC_INVALID_PARAMS = -32602;
+exports.JSON_RPC_INTERNAL_ERROR = -32603;
+exports.JSON_RPC_TASK_LIMIT_EXCEEDED = -32005;

package/dist/agent/router.js

@@ -47,7 +47,11 @@ class AgentRouter extends node_events_1.EventEmitter {
         }
     }
     sendMessage(roomId, envelope) {
-        return this.connector.sendData(roomId, JSON.stringify(envelope));
+        const result = this.connector.sendData(roomId, JSON.stringify(envelope));
+        if (!result) {
+            console.log(`[clawnexus] [Router] sendMessage FAILED — room=${roomId} (no room or no session_key)`);
+        }
+        return result;
     }
     /** Initiate a propose to a peer (outbound task) */
     propose(roomId, targetClawId, task) {
@@ -67,7 +71,8 @@ class AgentRouter extends node_events_1.EventEmitter {
             room_id: roomId,
         };
         this.tasks.create(record);
-        this.sendMessage(roomId, envelope);
+        const sent = this.sendMessage(roomId, envelope);
+        console.log(`[clawnexus] [Router] propose sent=${sent} room=${roomId} target=${targetClawId}`);
         this.emit("outbound", envelope);
         return record;
     }

package/dist/api/server.d.ts

@@ -15,6 +15,8 @@ import { RegistryClient } from "../registry/client.js";
 import { AutoRegister } from "../registry/auto-register.js";
 import { RemoteDiscovery } from "../registry/discovery.js";
 import { RelayConnector } from "../relay/connector.js";
+import { CardFetcher } from "../a2a/fetcher.js";
+import { A2AHandler } from "../a2a/handler.js";
 import { SkillsRegistry } from "../agent/services.js";
 export declare function registerRelayRoutes(app: FastifyInstance, getConnector: () => RelayConnector | null, getTokenRefresher?: () => (() => Promise<string>) | null): void;
 export interface AgentDeps {
@@ -43,7 +45,7 @@ export interface DiagnosticsDeps {
     unreachable: UnreachableInstance[];
 }
 export declare function registerDiagnosticsRoutes(app: FastifyInstance, deps: DiagnosticsDeps): void;
-export declare function registerA2aRoutes(app: FastifyInstance, store: RegistryStore, daemonVersion: string, skillsRegistry?: SkillsRegistry): void;
+export declare function registerA2aRoutes(app: FastifyInstance, store: RegistryStore, daemonVersion: string, skillsRegistry?: SkillsRegistry, a2aHandler?: A2AHandler): void;
 export interface DaemonOptions {
     port?: number;
     host?: string;
@@ -62,6 +64,7 @@ export interface DaemonHandle {
     tasks: TaskManager;
     getRouter: () => AgentRouter | null;
     skillsRegistry: SkillsRegistry;
+    cardFetcher: CardFetcher;
     registryClient: RegistryClient | null;
     autoRegister: AutoRegister | null;
     remoteDiscovery: RemoteDiscovery | null;

package/dist/api/server.js

@@ -30,6 +30,10 @@ const auto_register_js_1 = require("../registry/auto-register.js");
 const discovery_js_1 = require("../registry/discovery.js");
 const connector_js_1 = require("../relay/connector.js");
 const card_js_1 = require("../a2a/card.js");
+const fetcher_js_1 = require("../a2a/fetcher.js");
+const handler_js_1 = require("../a2a/handler.js");
+const store_js_2 = require("../a2a/store.js");
+const types_js_1 = require("../a2a/types.js");
 const services_js_1 = require("../agent/services.js");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -344,7 +348,7 @@ function registerDiagnosticsRoutes(app, deps) {
         };
     });
 }
-function registerA2aRoutes(app, store, daemonVersion, skillsRegistry) {
+function registerA2aRoutes(app, store, daemonVersion, skillsRegistry, a2aHandler) {
     // A2A standard well-known endpoint — returns card for the local (is_self) instance
     app.get("/.well-known/agent-card.json", async (_request, reply) => {
         const self = store.getAll().find((i) => i.is_self);
@@ -356,8 +360,8 @@ function registerA2aRoutes(app, store, daemonVersion, skillsRegistry) {
     // All instances as Agent Cards
     app.get("/a2a/cards", async () => {
         const instances = store.getAll();
-        const skills = skillsRegistry?.getSkills();
-        const cards = instances.map((i) => (0, card_js_1.buildAgentCard)(i, daemonVersion, skills));
+        const localSkills = skillsRegistry?.getSkills();
+        const cards = instances.map((i) => (0, card_js_1.buildAgentCard)(i, daemonVersion, i.is_self ? localSkills : undefined));
         return { count: cards.length, cards };
     });
     // Single instance Agent Card by name
@@ -366,8 +370,69 @@ function registerA2aRoutes(app, store, daemonVersion, skillsRegistry) {
         if (!inst) {
             return reply.status(404).send({ error: "Instance not found" });
         }
-        return (0, card_js_1.buildAgentCard)(inst, daemonVersion, skillsRegistry?.getSkills());
-    });
+        const localSkills = inst.is_self ? skillsRegistry?.getSkills() : undefined;
+        return (0, card_js_1.buildAgentCard)(inst, daemonVersion, localSkills);
+    });
+    // A2A JSON-RPC 2.0 endpoint
+    if (a2aHandler) {
+        app.post("/a2a", async (request, reply) => {
+            const body = request.body;
+            if (!body || body.jsonrpc !== "2.0" || typeof body.method !== "string") {
+                const id = body?.id ?? null;
+                const resp = {
+                    jsonrpc: "2.0",
+                    id: id,
+                    error: { code: types_js_1.JSON_RPC_INVALID_REQUEST, message: "Invalid JSON-RPC 2.0 request" },
+                };
+                return reply.status(200).send(resp);
+            }
+            const req = body;
+            if (req.method === "tasks/send") {
+                const result = await a2aHandler.handleTaskSend(req.params);
+                // Check if result is an error
+                if ("code" in result && "message" in result && !("id" in result)) {
+                    return reply.status(200).send({
+                        jsonrpc: "2.0",
+                        id: req.id,
+                        error: result,
+                    });
+                }
+                return reply.status(200).send({
+                    jsonrpc: "2.0",
+                    id: req.id,
+                    result,
+                });
+            }
+            if (req.method === "tasks/get") {
+                const params = req.params;
+                if (!params?.id) {
+                    return reply.status(200).send({
+                        jsonrpc: "2.0",
+                        id: req.id,
+                        error: { code: -32602, message: "Missing task id" },
+                    });
+                }
+                const task = a2aHandler.getTask(params.id);
+                if (!task) {
+                    return reply.status(200).send({
+                        jsonrpc: "2.0",
+                        id: req.id,
+                        error: { code: -32001, message: "Task not found" },
+                    });
+                }
+                return reply.status(200).send({
+                    jsonrpc: "2.0",
+                    id: req.id,
+                    result: task,
+                });
+            }
+            return reply.status(200).send({
+                jsonrpc: "2.0",
+                id: req.id,
+                error: { code: types_js_1.JSON_RPC_METHOD_NOT_FOUND, message: `Method not found: ${req.method}` },
+            });
+        });
+    }
 }
 async function startDaemon(options = {}) {
     const port = options.port ?? PORT;
@@ -402,6 +467,8 @@ async function startDaemon(options = {}) {
     });
     // 6c. Create SkillsRegistry
     const skillsRegistry = new services_js_1.SkillsRegistry();
+    // 6d. Create CardFetcher (fetches remote Agent Cards from discovered instances)
+    const cardFetcher = new fetcher_js_1.CardFetcher(store);
     // 7. Detect WireGuard interfaces
     const wgInfo = await (0, wireguard_js_1.detectWireGuard)();
     // 8. Create and configure Fastify app
@@ -421,11 +488,12 @@ async function startDaemon(options = {}) {
     else {
         console.log("[clawnexus] [WireGuard] No WireGuard interfaces detected");
     }
+    const daemonPkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "../../package.json"), "utf-8"));
     // Health endpoint with component status
     app.get("/health", async () => ({
         status: "ok",
         service: "clawnexus-daemon",
-        version: "0.3.1",
+        version: daemonPkg.version,
         timestamp: new Date().toISOString(),
         components: {
             registry: { instances: store.size },
@@ -476,9 +544,11 @@ async function startDaemon(options = {}) {
         getAutoRegister: () => autoRegister,
         unreachable,
     });
-    // A2A Agent Card routes
-    const daemonPkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "../../package.json"), "utf-8"));
-    registerA2aRoutes(app, store, daemonPkg.version, skillsRegistry);
+    // A2A Agent Card + JSON-RPC routes
+    const a2aTaskStore = new store_js_2.A2ATaskStore();
+    await a2aTaskStore.init();
+    const a2aHandler = new handler_js_1.A2AHandler({ store: a2aTaskStore });
+    registerA2aRoutes(app, store, daemonPkg.version, skillsRegistry, a2aHandler);
     // 9. Initialize Registry integration (non-fatal — LAN must work without it)
     let identityKeys = null;
     let registryClient = null;
@@ -491,15 +561,27 @@ async function startDaemon(options = {}) {
         broadcast.sendAnnounce();
         // Start skills registry once we know the local Gateway is available
         skillsRegistry.start();
+        // Start fetching remote Agent Cards
+        cardFetcher.start();
     });
     localProbe.on("local:unavailable", () => {
         app.log.info("No local OpenClaw instance on :18789");
+        // Still start CardFetcher — remote cards are useful even without local instance
+        cardFetcher.start();
     });
     // Initialize registry after LocalProbe (needs agentId for registration)
     try {
         identityKeys = await (0, keys_js_1.loadOrCreateKeys)();
         registryClient = new client_js_1.RegistryClient(identityKeys);
-        autoRegister = new auto_register_js_1.AutoRegister(registryClient, store, localProbe, identityKeys);
+        autoRegister = new auto_register_js_1.AutoRegister(registryClient, store, localProbe, identityKeys, daemonPkg.version, () => {
+            const skills = skillsRegistry.getSkills();
+            if (!skills || skills.length === 0)
+                return null;
+            return {
+                skills_count: skills.length,
+                skills: skills.map((s) => s.name ?? s.id ?? "unknown"),
+            };
+        });
         remoteDiscovery = new discovery_js_1.RemoteDiscovery(registryClient, store);
         registerRegistryRoutes(app, {
             autoRegister,
@@ -632,6 +714,7 @@ async function startDaemon(options = {}) {
     app.addHook("onClose", async () => {
         if (tokenRefreshTimer)
             clearInterval(tokenRefreshTimer);
+        cardFetcher.stop();
         skillsRegistry.stop();
         await taskExecutor.close();
         autoRegister?.stop();
@@ -642,6 +725,8 @@ async function startDaemon(options = {}) {
         mdns.stop();
         await broadcast.stop();
         connector?.disconnect();
+        a2aHandler.close();
+        await a2aTaskStore.close();
         await store.close();
     });
     await app.listen({ port, host });
@@ -683,6 +768,7 @@ async function startDaemon(options = {}) {
         tasks: taskManager,
         getRouter: () => agentRouter,
         skillsRegistry,
+        cardFetcher,
         registryClient,
         autoRegister,
         remoteDiscovery,

package/dist/cli/index.js

@@ -434,6 +434,12 @@ async function cmdInfo(args) {
         if (inst.labels && Object.keys(inst.labels).length > 0) {
             console.log(`Labels:        ${JSON.stringify(inst.labels)}`);
         }
+        if (inst.remote_card?.skills?.length) {
+            const names = inst.remote_card.skills.map((s) => s.name || s.id).join(", ");
+            console.log(`Skills:        ${names} (${inst.remote_card.skills.length} skill${inst.remote_card.skills.length === 1 ? "" : "s"})`);
+            console.log(`Card URL:      ${inst.remote_card.card_url}`);
+            console.log(`Card Fetched:  ${new Date(inst.remote_card.fetched_at).toLocaleString()}`);
+        }
     }
 }
 async function cmdForget(args) {

package/dist/registry/auto-register.d.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from "node:events";
 import type { RegistryClient } from "./client.js";
+import type { AgentCardSummary } from "./client.js";
 import type { RegistryStore } from "./store.js";
 import type { LocalProbe } from "../local/probe.js";
 import type { IdentityKeys } from "../crypto/keys.js";
@@ -8,10 +9,13 @@ export declare class AutoRegister extends EventEmitter {
     private readonly store;
     private readonly localProbe;
     private readonly keys;
+    private readonly daemonVersion;
+    private readonly getCardSummary?;
     private heartbeatTimer;
     private initialTimer;
     private registeredClawName;
-    constructor(client: RegistryClient, store: RegistryStore, localProbe: LocalProbe, keys: IdentityKeys);
+    private readonly startedAt;
+    constructor(client: RegistryClient, store: RegistryStore, localProbe: LocalProbe, keys: IdentityKeys, daemonVersion?: string, getCardSummary?: (() => AgentCardSummary | null) | undefined);
     get clawName(): string | null;
     get publicKey(): string;
     start(): void;

package/dist/registry/auto-register.js

@@ -4,6 +4,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoRegister = void 0;
 const node_events_1 = require("node:events");
+const node_os_1 = require("node:os");
 const client_js_1 = require("./client.js");
 const keys_js_1 = require("../crypto/keys.js");
 const INITIAL_DELAY_MS = 5_000;
@@ -13,15 +14,20 @@ class AutoRegister extends node_events_1.EventEmitter {
     store;
     localProbe;
     keys;
+    daemonVersion;
+    getCardSummary;
     heartbeatTimer = null;
     initialTimer = null;
     registeredClawName = null;
-    constructor(client, store, localProbe, keys) {
+    startedAt = Date.now();
+    constructor(client, store, localProbe, keys, daemonVersion = "unknown", getCardSummary) {
         super();
         this.client = client;
         this.store = store;
         this.localProbe = localProbe;
         this.keys = keys;
+        this.daemonVersion = daemonVersion;
+        this.getCardSummary = getCardSummary;
     }
     get clawName() {
         return this.registeredClawName;
@@ -65,6 +71,15 @@ class AutoRegister extends node_events_1.EventEmitter {
         const bases = [agentId];
         if (autoName && autoName !== agentId)
             bases.push(autoName);
+        // Build metadata and card summary for this heartbeat
+        const uptimeHours = Math.round((Date.now() - this.startedAt) / 3_600_000 * 100) / 100;
+        const metadata = {
+            software_version: this.daemonVersion,
+            uptime_hours: uptimeHours,
+            os_platform: (0, node_os_1.platform)(),
+            instance_count: this.store.getAll().length,
+        };
+        const cardSummary = this.getCardSummary?.() ?? undefined;
         // Try each base with suffixes -1, -2, ... up to MAX_SUFFIX if taken by another owner
         const MAX_SUFFIX = 10;
         let result = null;
@@ -72,7 +87,11 @@ class AutoRegister extends node_events_1.EventEmitter {
             for (let i = 0; i <= MAX_SUFFIX; i++) {
                 const clawId = i === 0 ? base : `${base}-${i}`;
                 try {
-                    result = await this.client.register({ claw_id: clawId });
+                    result = await this.client.register({
+                        claw_id: clawId,
+                        metadata,
+                        agent_card: cardSummary,
+                    });
                     break outer;
                 }
                 catch (err) {

package/dist/registry/client.d.ts

@@ -33,11 +33,28 @@ export interface CheckNameResult {
     name: string;
     available: boolean;
 }
+export interface InstanceMetadata {
+    software_version: string;
+    openclaw_version?: string;
+    uptime_hours: number;
+    os_platform: string;
+    instance_count: number;
+}
+export interface AgentCardSummary {
+    skills_count: number;
+    skills: string[];
+    capabilities?: Record<string, unknown>;
+    input_modes?: string[];
+    output_modes?: string[];
+    card_url?: string;
+}
 export interface RegisterParams {
     claw_id: string;
     capabilities?: string[];
     relay_hint?: string;
     visibility?: "public" | "unlisted";
+    metadata?: InstanceMetadata;
+    agent_card?: AgentCardSummary;
 }
 export declare class RegistryClient {
     private readonly keys;

package/dist/registry/client.js

@@ -36,6 +36,8 @@ class RegistryClient {
             ...(params.capabilities && { capabilities: params.capabilities }),
             ...(params.relay_hint && { relay_hint: params.relay_hint }),
             ...(params.visibility && { visibility: params.visibility }),
+            ...(params.metadata && { metadata: params.metadata }),
+            ...(params.agent_card && { agent_card: params.agent_card }),
         };
         const body = {
             payload,

package/dist/registry/store.js

@@ -65,12 +65,16 @@ class RegistryStore extends node_events_1.EventEmitter {
             try {
                 const raw = await fs.promises.readFile(this.registryPath, "utf-8");
                 const data = JSON.parse(raw);
-                if (data.schema_version === "5" && Array.isArray(data.instances)) {
-                    // v5: current schema, load directly
+                if ((data.schema_version === "6" || data.schema_version === "5") && Array.isArray(data.instances)) {
+                    // v5/v6: compatible schemas (remote_card is optional), load directly
                     for (const inst of data.instances) {
                         const key = this.networkKey(inst.address, inst.gateway_port);
                         this.instances.set(key, inst);
                     }
+                    if (data.schema_version === "5") {
+                        // Bump to v6 on next flush
+                        this.scheduleDirtyFlush();
+                    }
                 }
                 else if (data.schema_version === "4" && Array.isArray(data.instances)) {
                     // v4 → v5 migration: no data changes, just bump version
@@ -203,6 +207,8 @@ class RegistryStore extends node_events_1.EventEmitter {
             instance.owner_pubkey = instance.owner_pubkey ?? existing.owner_pubkey;
             // Preserve implementation (prefer new value if provided)
             instance.implementation = instance.implementation ?? existing.implementation;
+            // Preserve remote_card (fetched by CardFetcher)
+            instance.remote_card = instance.remote_card ?? existing.remote_card;
             this.instances.set(key, instance);
             this.scheduleDirtyFlush();
             this.emit("upsert", instance);
@@ -318,6 +324,7 @@ class RegistryStore extends node_events_1.EventEmitter {
             connectivity: incoming.connectivity ?? existing.connectivity,
             is_self: existing.is_self || incoming.is_self,
             implementation: incoming.implementation ?? existing.implementation,
+            remote_card: existing.remote_card ?? incoming.remote_card,
         };
     }
     /** Numeric priority for network scope: local > vpn > public */
@@ -343,7 +350,7 @@ class RegistryStore extends node_events_1.EventEmitter {
     }
     async flushNow() {
         const data = {
-            schema_version: "5",
+            schema_version: "6",
             updated_at: new Date().toISOString(),
             instances: Array.from(this.instances.values()),
         };

package/dist/relay/connector.js

@@ -190,9 +190,13 @@ class RelayConnector extends node_events_1.EventEmitter {
                         this.emit("data", msg.room_id, plaintext);
                     }
                     catch {
-                        this.emit("error", new Error("Failed to decrypt message"));
+                        // Decrypt failed — log and skip, do not emit "error" (would crash if no listener)
+                        console.log(`[clawnexus] [Relay] Failed to decrypt message in room ${msg.room_id} — skipping`);
                     }
                 }
+                else {
+                    console.log(`[clawnexus] [Relay] DATA in room ${msg.room_id} — no session_key yet, dropping`);
+                }
                 break;
             }
             case "PEER_LEFT": {

package/dist/types.d.ts

@@ -1,3 +1,16 @@
+import type { AgentSkill } from "./a2a/card.js";
+export interface RemoteCard {
+    skills: AgentSkill[];
+    capabilities?: {
+        streaming?: boolean;
+        pushNotifications?: boolean;
+        stateTransitionHistory?: boolean;
+    };
+    input_modes?: string[];
+    output_modes?: string[];
+    card_url: string;
+    fetched_at: string;
+}
 export type ClawImplementation = "openclaw" | "goclaw" | "zeroclaw" | "picoclaw" | "nanoclaw" | "nanobot" | "openfang" | "unknown";
 export interface ClawInstance {
     agent_id: string;
@@ -20,6 +33,7 @@ export interface ClawInstance {
     claw_name?: string;
     owner_pubkey?: string;
     implementation?: ClawImplementation;
+    remote_card?: RemoteCard;
     labels?: Record<string, string>;
 }
 export interface Connectivity {
@@ -39,7 +53,7 @@ export interface UnreachableInstance {
     discovered_at: string;
 }
 export interface RegistryFile {
-    schema_version: "2" | "3" | "4" | "5";
+    schema_version: "2" | "3" | "4" | "5" | "6";
     updated_at: string;
     instances: ClawInstance[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawnexus",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "ClawNexus daemon and CLI — AI instance registry for OpenClaw",
   "license": "MIT",
   "author": "alan-silverstreams <alan@silverstream.tech>",