@agentbus/agentbus-client 0.11.2

package/README.md

@@ -0,0 +1,77 @@
+# @agentbus/agentbus-client
+
+TypeScript / Node.js EventEmitter client for [AgentBus](https://github.com/onicarps/agentbus).
+
+- Resolves `events.db` from `AGENTBUS_WORKSPACE`
+- Debounced `fs.watch` + slow fallback timer to trigger polls
+- Spawns `agentbus mcp-serve` over stdio (or accepts an injected MCP client)
+- `publish` / `poll` map to `agentbus_publish` / `agentbus_poll`
+- Emits `event` and per-topic events (`bus.on('okf/handoff', ...)`)
+
+## Prerequisites
+
+1. Python AgentBus installed and on `PATH` (or set `AGENTBUS_BIN`):
+
+   ```bash
+   pip install 'okf-agentbus[devex]'
+   # or use a repo venv:
+   export AGENTBUS_BIN=/path/to/agentbus/.venv/bin/agentbus
+   ```
+
+2. Workspace initialized:
+
+   ```bash
+   export AGENTBUS_WORKSPACE=/path/to/project
+   agentbus token ensure --workspace "$AGENTBUS_WORKSPACE"
+   ```
+
+## Install
+
+```bash
+cd packages/js/agentbus-client
+npm install
+npm test
+```
+
+## Usage
+
+### Auto stdio (recommended)
+
+```ts
+import { AgentBus } from "@agentbus/agentbus-client";
+
+const bus = new AgentBus({
+  workspace: process.env.AGENTBUS_WORKSPACE,
+  topics: ["okf/handoff"], // or ["*"] to expand via agentbus_status
+});
+
+bus.on("okf/handoff", (payload, meta) => {
+  console.log("handoff", payload, meta.event_id);
+});
+
+await bus.connect(); // spawns `agentbus mcp-serve`
+await bus.publish("okf/handoff", {
+  from: "node-agent",
+  to: "swarm",
+  summary: "hello from TS",
+});
+
+// later
+await bus.disconnect();
+```
+
+### Injected MCP client (tests / custom transports)
+
+```ts
+import { AgentBus, createStdioMcpClient } from "@agentbus/agentbus-client";
+
+const mcp = await createStdioMcpClient({
+  workspace: process.env.AGENTBUS_WORKSPACE!,
+  command: process.env.AGENTBUS_BIN, // optional
+});
+
+const bus = new AgentBus({ mcp, workspace: process.env.AGENTBUS_WORKSPACE });
+await bus.connect();
+```
+
+Set `AGENTBUS_WORKSPACE` to the project root that contains `.agentbus/events.db`.

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+import { EventEmitter } from "events";
+import type { AgentBusOptions, BusEvent } from "./types";
+export { getDatabasePath } from "./locator";
+export { DatabaseWatcher } from "./watcher";
+export { createStdioMcpClient } from "./stdio";
+export type { AgentBusOptions, BusEvent, McpToolClient, } from "./types";
+export type { StdioMcpOptions } from "./stdio";
+/**
+ * Idiomatic Node client: EventEmitter + publish/poll over AgentBus MCP tools,
+ * with fs.watch-triggered polls and a slow timer fallback.
+ *
+ * When `options.mcp` is omitted, `connect()` spawns `agentbus mcp-serve` over
+ * stdio (requires `agentbus` on PATH or `AGENTBUS_BIN`).
+ */
+export declare class AgentBus extends EventEmitter {
+    private watcher;
+    private options;
+    /** Global high-water (min of per-topic cursors after last poll). */
+    private lastId;
+    /** Exclusive since_id per topic — avoids skipping pages across topics. */
+    private topicCursors;
+    private initialSince;
+    private connected;
+    private polling;
+    private ownsMcp;
+    private mcp;
+    constructor(options?: AgentBusOptions);
+    connect(): Promise<void>;
+    publish(topic: string, payload: unknown, opts?: {
+        producerId?: string;
+    }): Promise<unknown>;
+    /** Force a poll (also used by watcher). Drains each topic fully. */
+    poll(): Promise<BusEvent[]>;
+    get cursor(): number;
+    /** Per-topic exclusive cursors (for diagnostics / multi-topic correctness). */
+    getTopicCursor(topic: string): number;
+    disconnect(): Promise<void>;
+    private reportBackgroundError;
+    private rollbackConnect;
+    private requireMcp;
+    private resolveTopics;
+}
+/** Pull JSON out of MCP CallToolResult envelopes or raw values. */
+export declare function unwrapToolResult(raw: unknown): unknown;
+export declare function parsePollPage(raw: unknown): {
+    events: BusEvent[];
+    hasMore: boolean;
+};
+export declare function normalizePollResult(raw: unknown): BusEvent[];

package/dist/index.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentBus = exports.createStdioMcpClient = exports.DatabaseWatcher = exports.getDatabasePath = void 0;
+exports.unwrapToolResult = unwrapToolResult;
+exports.parsePollPage = parsePollPage;
+exports.normalizePollResult = normalizePollResult;
+const events_1 = require("events");
+const watcher_1 = require("./watcher");
+const locator_1 = require("./locator");
+const stdio_1 = require("./stdio");
+var locator_2 = require("./locator");
+Object.defineProperty(exports, "getDatabasePath", { enumerable: true, get: function () { return locator_2.getDatabasePath; } });
+var watcher_2 = require("./watcher");
+Object.defineProperty(exports, "DatabaseWatcher", { enumerable: true, get: function () { return watcher_2.DatabaseWatcher; } });
+var stdio_2 = require("./stdio");
+Object.defineProperty(exports, "createStdioMcpClient", { enumerable: true, get: function () { return stdio_2.createStdioMcpClient; } });
+const DEFAULT_POLL_LIMIT = 50;
+/**
+ * Idiomatic Node client: EventEmitter + publish/poll over AgentBus MCP tools,
+ * with fs.watch-triggered polls and a slow timer fallback.
+ *
+ * When `options.mcp` is omitted, `connect()` spawns `agentbus mcp-serve` over
+ * stdio (requires `agentbus` on PATH or `AGENTBUS_BIN`).
+ */
+class AgentBus extends events_1.EventEmitter {
+    watcher = null;
+    options;
+    /** Global high-water (min of per-topic cursors after last poll). */
+    lastId;
+    /** Exclusive since_id per topic — avoids skipping pages across topics. */
+    topicCursors = new Map();
+    initialSince;
+    connected = false;
+    polling = false;
+    ownsMcp = false;
+    mcp;
+    constructor(options = {}) {
+        super();
+        this.options = options;
+        this.initialSince = options.sinceId ?? 0;
+        this.lastId = this.initialSince;
+        this.mcp = options.mcp;
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        const spawnedMcpHere = !this.mcp;
+        try {
+            if (!this.mcp) {
+                const producerId = this.options.producerId ?? process.env.AGENTBUS_PRODUCER_ID;
+                const env = {
+                    ...(this.options.stdio?.env ?? {}),
+                };
+                if (producerId) {
+                    env.AGENTBUS_PRODUCER_ID = producerId;
+                }
+                this.mcp = await (0, stdio_1.createStdioMcpClient)({
+                    workspace: this.options.workspace,
+                    command: this.options.stdio?.command,
+                    args: this.options.stdio?.args,
+                    cwd: this.options.stdio?.cwd,
+                    env,
+                });
+                this.ownsMcp = true;
+            }
+            const dbPath = (0, locator_1.getDatabasePath)(this.options.workspace);
+            this.watcher = new watcher_1.DatabaseWatcher(dbPath, () => {
+                void this.poll().catch((err) => {
+                    this.reportBackgroundError(err);
+                });
+            }, this.options.fallbackMs ?? 5000);
+            this.watcher.start();
+            // Initial catch-up poll — must succeed before we mark connected.
+            await this.poll();
+            this.connected = true;
+        }
+        catch (err) {
+            await this.rollbackConnect(spawnedMcpHere);
+            throw err;
+        }
+    }
+    async publish(topic, payload, opts) {
+        const mcp = this.requireMcp();
+        // Server expects payload as object (dict), not a JSON string.
+        const body = typeof payload === "string"
+            ? safeParseJson(payload) ?? { text: payload }
+            : payload;
+        const producerId = opts?.producerId ??
+            this.options.producerId ??
+            process.env.AGENTBUS_PRODUCER_ID;
+        const args = {
+            topic,
+            payload: body,
+        };
+        if (producerId) {
+            args.producer_id = producerId;
+        }
+        const result = await mcp.callTool("agentbus_publish", args);
+        return unwrapToolResult(result);
+    }
+    /** Force a poll (also used by watcher). Drains each topic fully. */
+    async poll() {
+        if (this.polling)
+            return [];
+        this.polling = true;
+        try {
+            const mcp = this.mcp;
+            if (!mcp) {
+                // Without MCP, watcher still runs; no events to emit.
+                return [];
+            }
+            const topics = await this.resolveTopics(mcp);
+            const merged = [];
+            const seen = new Set();
+            // Commit + emit per topic after that topic drains. If a later topic fails,
+            // earlier topics keep their events and cursors (no silent drops).
+            for (const topic of topics) {
+                let since = this.topicCursors.get(topic) ?? this.initialSince;
+                let hasMore = true;
+                const topicEvents = [];
+                while (hasMore) {
+                    const raw = await mcp.callTool("agentbus_poll", {
+                        topic,
+                        since_id: since,
+                        limit: DEFAULT_POLL_LIMIT,
+                    });
+                    const page = parsePollPage(raw);
+                    hasMore = page.hasMore;
+                    for (const ev of page.events) {
+                        if (ev.event_id > since) {
+                            since = ev.event_id;
+                        }
+                        if (seen.has(ev.event_id))
+                            continue;
+                        seen.add(ev.event_id);
+                        topicEvents.push(ev);
+                    }
+                    // Safety: empty page ends the loop even if has_more is stale.
+                    if (page.events.length === 0) {
+                        hasMore = false;
+                    }
+                }
+                this.topicCursors.set(topic, since);
+                // Preserve arrival order within a topic (server returns ASC by event_id).
+                for (const ev of topicEvents) {
+                    this.emit("event", ev);
+                    this.emit(ev.topic, ev.payload, ev);
+                }
+                merged.push(...topicEvents);
+            }
+            // Global cursor = min of topic cursors (never claims past unfetched pages).
+            if (topics.length > 0) {
+                let minCursor = Number.POSITIVE_INFINITY;
+                for (const topic of topics) {
+                    const c = this.topicCursors.get(topic) ?? this.initialSince;
+                    if (c < minCursor)
+                        minCursor = c;
+                }
+                if (Number.isFinite(minCursor)) {
+                    this.lastId = minCursor;
+                }
+            }
+            return merged;
+        }
+        finally {
+            this.polling = false;
+        }
+    }
+    get cursor() {
+        return this.lastId;
+    }
+    /** Per-topic exclusive cursors (for diagnostics / multi-topic correctness). */
+    getTopicCursor(topic) {
+        return this.topicCursors.get(topic) ?? this.initialSince;
+    }
+    async disconnect() {
+        if (this.watcher) {
+            this.watcher.stop();
+            this.watcher = null;
+        }
+        this.connected = false;
+        // Only close MCP clients we spawned; injected clients are caller-owned.
+        if (this.ownsMcp && this.mcp?.close) {
+            await this.mcp.close();
+            this.mcp = undefined;
+            this.ownsMcp = false;
+        }
+    }
+    reportBackgroundError(err) {
+        // EventEmitter "error" throws if no listeners — guard that path.
+        if (this.listenerCount("error") > 0) {
+            this.emit("error", err);
+        }
+        else {
+            this.emit("pollError", err);
+        }
+    }
+    async rollbackConnect(spawnedMcpHere) {
+        if (this.watcher) {
+            this.watcher.stop();
+            this.watcher = null;
+        }
+        this.connected = false;
+        if (spawnedMcpHere && this.ownsMcp && this.mcp?.close) {
+            try {
+                await this.mcp.close();
+            }
+            catch {
+                /* ignore close errors during rollback */
+            }
+            this.mcp = undefined;
+            this.ownsMcp = false;
+        }
+    }
+    requireMcp() {
+        if (!this.mcp) {
+            throw new Error("AgentBus.publish requires connect() first (or pass options.mcp)");
+        }
+        return this.mcp;
+    }
+    async resolveTopics(mcp) {
+        const configured = this.options.topics ?? ["okf/handoff"];
+        if (!configured.includes("*")) {
+            return configured;
+        }
+        const raw = await mcp.callTool("agentbus_status", {});
+        const status = unwrapToolResult(raw);
+        const listed = Array.isArray(status?.topics) ? status.topics : [];
+        // Keep any explicit topics alongside *, drop the star marker.
+        const explicit = configured.filter((t) => t !== "*");
+        const set = new Set([...explicit, ...listed]);
+        return set.size > 0 ? [...set] : ["okf/handoff"];
+    }
+}
+exports.AgentBus = AgentBus;
+function safeParseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+/** Pull JSON out of MCP CallToolResult envelopes or raw values. */
+function unwrapToolResult(raw) {
+    if (raw == null)
+        return null;
+    if (typeof raw === "string") {
+        return safeParseJson(raw) ?? raw;
+    }
+    if (typeof raw === "object") {
+        const obj = raw;
+        if (Array.isArray(obj.content)) {
+            for (const part of obj.content) {
+                if (part.type === "text" && typeof part.text === "string") {
+                    return safeParseJson(part.text) ?? part.text;
+                }
+            }
+        }
+    }
+    return raw;
+}
+function parsePollPage(raw) {
+    const data = unwrapToolResult(raw);
+    if (data == null)
+        return { events: [], hasMore: false };
+    if (Array.isArray(data)) {
+        return {
+            events: data.map(normalizeEvent),
+            hasMore: data.length >= DEFAULT_POLL_LIMIT,
+        };
+    }
+    if (typeof data === "object") {
+        const obj = data;
+        if (Array.isArray(obj.events)) {
+            const events = obj.events.map(normalizeEvent);
+            const hasMore = typeof obj.has_more === "boolean"
+                ? obj.has_more
+                : events.length >= DEFAULT_POLL_LIMIT;
+            return { events, hasMore };
+        }
+    }
+    return { events: [], hasMore: false };
+}
+function normalizePollResult(raw) {
+    return parsePollPage(raw).events;
+}
+function normalizeEvent(ev) {
+    // Payload may still be a JSON string from older projections.
+    if (typeof ev.payload === "string") {
+        const parsed = safeParseJson(ev.payload);
+        if (parsed != null)
+            return { ...ev, payload: parsed };
+    }
+    return ev;
+}

package/dist/locator.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Resolve the AgentBus SQLite events.db path from AGENTBUS_WORKSPACE
+ * (or an explicit workspace override).
+ */
+export declare function getDatabasePath(workspace?: string): string;

package/dist/locator.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDatabasePath = getDatabasePath;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Resolve the AgentBus SQLite events.db path from AGENTBUS_WORKSPACE
+ * (or an explicit workspace override).
+ */
+function getDatabasePath(workspace) {
+    const ws = workspace ?? process.env.AGENTBUS_WORKSPACE;
+    if (!ws) {
+        throw new Error("AGENTBUS_WORKSPACE environment variable must be set");
+    }
+    if (!fs_1.default.existsSync(ws)) {
+        throw new Error("Workspace directory not found: " + ws);
+    }
+    return path_1.default.join(ws, ".agentbus", "events.db");
+}

package/dist/stdio.d.ts

@@ -0,0 +1,23 @@
+import type { McpToolClient } from "./types";
+export type StdioMcpOptions = {
+    /** Workspace root containing `.agentbus/` (defaults to AGENTBUS_WORKSPACE). */
+    workspace?: string;
+    /** Binary to spawn (default: AGENTBUS_BIN or `agentbus`). */
+    command?: string;
+    /** Args after command (default: `mcp-serve --workspace <ws>`). */
+    args?: string[];
+    cwd?: string;
+    /** Extra env merged on top of MCP-safe defaults. */
+    env?: Record<string, string>;
+    /** Client name reported to the MCP server. */
+    clientName?: string;
+    /** Client version reported to the MCP server. */
+    clientVersion?: string;
+};
+/**
+ * Spawn `agentbus mcp-serve` over stdio and return a minimal tool client.
+ *
+ * Requires `agentbus` on PATH (or `AGENTBUS_BIN` / `options.command`) and a
+ * workspace with a valid token (`agentbus init` / `token ensure`).
+ */
+export declare function createStdioMcpClient(options?: StdioMcpOptions): Promise<McpToolClient>;

package/dist/stdio.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStdioMcpClient = createStdioMcpClient;
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+/**
+ * Spawn `agentbus mcp-serve` over stdio and return a minimal tool client.
+ *
+ * Requires `agentbus` on PATH (or `AGENTBUS_BIN` / `options.command`) and a
+ * workspace with a valid token (`agentbus init` / `token ensure`).
+ */
+async function createStdioMcpClient(options = {}) {
+    const workspace = options.workspace ?? process.env.AGENTBUS_WORKSPACE;
+    if (!workspace) {
+        throw new Error("createStdioMcpClient: workspace or AGENTBUS_WORKSPACE is required");
+    }
+    const command = options.command ?? process.env.AGENTBUS_BIN ?? "agentbus";
+    const args = options.args ?? ["mcp-serve", "--workspace", workspace];
+    const env = {
+        ...(0, stdio_js_1.getDefaultEnvironment)(),
+        ...options.env,
+        AGENTBUS_WORKSPACE: workspace,
+    };
+    // Preserve PATH so the child can resolve `agentbus` / python when needed.
+    if (process.env.PATH && !env.PATH) {
+        env.PATH = process.env.PATH;
+    }
+    const transport = new stdio_js_1.StdioClientTransport({
+        command,
+        args,
+        env,
+        cwd: options.cwd,
+        stderr: "pipe",
+    });
+    const client = new index_js_1.Client({
+        name: options.clientName ?? "@agentbus/agentbus-client",
+        version: options.clientVersion ?? "0.1.0",
+    });
+    await client.connect(transport);
+    return {
+        async callTool(name, toolArgs) {
+            const result = await client.callTool({
+                name,
+                arguments: toolArgs,
+            });
+            if (result.isError) {
+                const text = extractText(result);
+                throw new Error(text || `MCP tool ${name} returned isError without detail`);
+            }
+            return result;
+        },
+        async close() {
+            await client.close();
+        },
+    };
+}
+function extractText(result) {
+    if (result == null || typeof result !== "object")
+        return "";
+    const content = result.content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((p) => !!p &&
+        typeof p === "object" &&
+        p.type === "text" &&
+        typeof p.text === "string")
+        .map((p) => p.text)
+        .join("\n");
+}

package/dist/types.d.ts

@@ -0,0 +1,44 @@
+/** Minimal MCP tool surface used by AgentBus (stdio or mock). */
+export type McpToolClient = {
+    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+    close?(): Promise<void> | void;
+};
+export type BusEvent = {
+    event_id: number;
+    topic: string;
+    producer_id?: string;
+    timestamp?: string;
+    status?: string;
+    payload: unknown;
+};
+export type AgentBusOptions = {
+    /** Override workspace (defaults to AGENTBUS_WORKSPACE). */
+    workspace?: string;
+    /** Fallback poll interval when fs.watch is quiet (ms). */
+    fallbackMs?: number;
+    /**
+     * Injected MCP tool caller for tests / custom transports.
+     * If omitted, `connect()` spawns stdio via `createStdioMcpClient`.
+     */
+    mcp?: McpToolClient;
+    /** Initial poll cursor (exclusive). */
+    sinceId?: number;
+    /**
+     * Default producer id for publish (also set as AGENTBUS_PRODUCER_ID on stdio).
+     * Falls back to process.env.AGENTBUS_PRODUCER_ID.
+     */
+    producerId?: string;
+    /**
+     * Topics to poll each cycle.
+     * Default: `["okf/handoff"]`.
+     * Pass `["*"]` to expand via `agentbus_status` topics list each poll.
+     */
+    topics?: string[];
+    /** Options for auto stdio spawn when `mcp` is not injected. */
+    stdio?: {
+        command?: string;
+        args?: string[];
+        cwd?: string;
+        env?: Record<string, string>;
+    };
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/watcher.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Debounced fs.watch on the events.db (or parent dir) plus a slow fallback poll.
+ * WAL renames can make watching the file alone flaky — we prefer the .agentbus dir
+ * when the db path does not exist yet.
+ */
+export declare class DatabaseWatcher {
+    private dbPath;
+    private onTrigger;
+    private fallbackMs;
+    private debounceMs;
+    private timer;
+    private watcher;
+    private debounceTimer;
+    constructor(dbPath: string, onTrigger: () => void, fallbackMs?: number, debounceMs?: number);
+    start(): void;
+    private trigger;
+    stop(): void;
+}

package/dist/watcher.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseWatcher = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Debounced fs.watch on the events.db (or parent dir) plus a slow fallback poll.
+ * WAL renames can make watching the file alone flaky — we prefer the .agentbus dir
+ * when the db path does not exist yet.
+ */
+class DatabaseWatcher {
+    dbPath;
+    onTrigger;
+    fallbackMs;
+    debounceMs;
+    timer = null;
+    watcher = null;
+    debounceTimer = null;
+    constructor(dbPath, onTrigger, fallbackMs = 5000, debounceMs = 50) {
+        this.dbPath = dbPath;
+        this.onTrigger = onTrigger;
+        this.fallbackMs = fallbackMs;
+        this.debounceMs = debounceMs;
+    }
+    start() {
+        this.timer = setInterval(() => this.trigger(), this.fallbackMs);
+        const watchTarget = fs_1.default.existsSync(this.dbPath)
+            ? this.dbPath
+            : path_1.default.dirname(this.dbPath);
+        try {
+            this.watcher = fs_1.default.watch(watchTarget, () => {
+                if (this.debounceTimer)
+                    clearTimeout(this.debounceTimer);
+                this.debounceTimer = setTimeout(() => this.trigger(), this.debounceMs);
+            });
+            // Async watch failures (deleted path, etc.) must not crash the process;
+            // fallback timer continues to drive polls.
+            this.watcher.on("error", () => {
+                if (this.watcher) {
+                    try {
+                        this.watcher.close();
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                    this.watcher = null;
+                }
+            });
+        }
+        catch {
+            // Ignore if path is not watchable yet; fallback timer still runs.
+        }
+    }
+    trigger() {
+        this.onTrigger();
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        if (this.watcher)
+            this.watcher.close();
+        this.timer = null;
+        this.debounceTimer = null;
+        this.watcher = null;
+    }
+}
+exports.DatabaseWatcher = DatabaseWatcher;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@agentbus/agentbus-client",
+  "version": "0.11.2",
+  "description": "TypeScript/Node EventEmitter client for AgentBus (MCP + fs.watch poll)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "agentbus",
+    "okf",
+    "mcp",
+    "agents"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/onicarps/agentbus.git",
+    "directory": "packages/js/agentbus-client"
+  },
+  "homepage": "https://github.com/onicarps/agentbus/tree/main/packages/js/agentbus-client",
+  "bugs": {
+    "url": "https://github.com/onicarps/agentbus/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.2"
+  }
+}