clawnexus 0.3.0 → 0.4.0

package/dist/a2a/card.d.ts

@@ -26,4 +26,4 @@ export interface AgentCard {
         url?: string;
     };
 }
-export declare function buildAgentCard(instance: ClawInstance, daemonVersion: string): AgentCard;
+export declare function buildAgentCard(instance: ClawInstance, daemonVersion: string, skills?: AgentSkill[]): AgentCard;

package/dist/a2a/card.js

@@ -8,20 +8,25 @@ const DEFAULT_SKILL = {
     description: "General-purpose AI assistant",
     tags: ["general"],
 };
-function buildAgentCard(instance, daemonVersion) {
+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: [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;