@easynet-run/node 0.27.14 → 0.36.9

package/README.md

@@ -33,6 +33,18 @@ The SDK ships a native Dendrite bridge binary (loaded via `koffi`) that provides
 npm install @easynet-run/node
 ```
 
+## Development
+
+Runtime `.js` files and package-facing `.d.ts` files under `src/` are generated from the TypeScript sources with `tsc`.
+Edit `src/**/*.ts`, then run:
+
+```bash
+npm run build
+npm run generated:check
+```
+
+Do not hand-edit generated `src/**/*.js` or `src/**/*.d.ts` files.
+
 ## Quick Start
 
 ### Expose an ability

package/native/dendrite-bridge-manifest.json

@@ -1,15 +1,15 @@
 {
-  "dendrite_bridge_version": "0.27.14",
+  "dendrite_bridge_version": "0.36.9",
   "target": "x86_64-unknown-linux-gnu",
   "os": "linux",
   "arch": "x86_64",
   "library": {
     "path": "native/libaxon_dendrite_bridge.so",
-    "sha256": "48d24b376d4c233a4d836f01ad6ede4dd38677a63fd6b687eeabc6a387ee910b"
+    "sha256": "e802bd6d15684b1b3f4c7fd2fc7159b591aaa93c58de78c369cac5d0315f7688"
   },
   "header": {
     "path": "native/include/axon_dendrite_bridge.h",
-    "sha256": "b54e9ce0898c95276e5a2f5752cf7c09255ab04d0ff6c50b1da86f194faf6b75"
+    "sha256": "bb6fdce765a6b1c2fb91a1cee037d00f7ec4297c9a1fd03b39fb829edf2d0fc4"
   },
   "protocol_coverage": {
     "rpc_shapes": ["unary", "server_stream", "client_stream", "bidi_stream"],
@@ -29,10 +29,11 @@
     "axon_dendrite_deploy_mcp_list_dir_json",
     "axon_dendrite_list_mcp_tools_json",
     "axon_dendrite_call_mcp_tool_json",
+    "axon_dendrite_call_mcp_tool_stream_open_json",
     "axon_dendrite_uninstall_capability_json",
     "axon_dendrite_update_mcp_list_dir_json",
     "axon_dendrite_protocol_coverage_json",
     "axon_dendrite_string_free"
   ],
-  "generated_at_utc": "2026-03-19T17:45:33Z"
+  "generated_at_utc": "2026-03-27T17:24:23Z"
 }

package/native/dendrite-bridge.json

@@ -1,6 +1,6 @@
 {
   "language": "node",
-  "dendrite_bridge_version": "0.27.14",
+  "dendrite_bridge_version": "0.36.9",
   "target": "x86_64-unknown-linux-gnu",
   "dendrite_manifest_path": "native/dendrite-bridge-manifest.json",
   "dendrite_library_path": "native/libaxon_dendrite_bridge.so",

package/native/include/axon_dendrite_bridge.h

@@ -251,6 +251,20 @@ char *axon_dendrite_list_mcp_tools_json(uint64_t handle,
 char *axon_dendrite_call_mcp_tool_json(uint64_t handle,
                                        const char *request_json);
 
+// Control helper: open streaming MCP tool call. Returns {"stream_handle": <u64>}.
+// Chunks are read via axon_dendrite_stream_next_json.
+// IMPORTANT: Caller MUST call axon_dendrite_stream_close_json on the returned
+// stream_handle to release the background task and channel. Failure to close
+// will leak resources until the session itself is closed.
+// timeout_ms is split as follows:
+//   - setup: min(timeout_ms, 30000) — capped at 30s for stream open
+//   - per-chunk: timeout_ms — each stream_next call waits up to this value
+// Per-session limit: max 16 concurrent MCP tool streams.
+// input JSON:
+// {"tenant_id":"...","tool_name":"...","target_node_id":"...","arguments_json":{},"timeout_ms":60000}
+char *axon_dendrite_call_mcp_tool_stream_open_json(uint64_t handle,
+                                                    const char *request_json);
+
 // Control helper: deactivate (optional) and uninstall installed capability.
 // input JSON:
 // {
@@ -392,8 +406,8 @@ char *axon_dendrite_voice_watch_transport_events_json(uint64_t handle,
 //   "path":"/axon.v1.Invocation/WatchInvocation",
 //   "request_base64":"...",
 //   "metadata":{"x-foo":"bar"},
-//   "timeout_ms":10000,
-//   "chunk_timeout_ms":30000,
+//   "timeout_ms":10000,        // setup/open timeout
+//   "chunk_timeout_ms":30000,  // per-chunk wait timeout
 //   "chunk_buffer_size":64
 // }
 // output JSON:
@@ -426,8 +440,8 @@ char *axon_dendrite_stream_close_json(uint64_t stream_handle);
 //   "request_base64":"...",
 //   "request_chunks_base64":["..."],
 //   "metadata":{"x-foo":"bar"},
-//   "timeout_ms":10000,
-//   "chunk_timeout_ms":30000,
+//   "timeout_ms":10000,        // setup/open timeout
+//   "chunk_timeout_ms":30000,  // per-chunk wait timeout
 //   "chunk_buffer_size":64,
 //   "request_buffer_size":64
 // }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@easynet-run/node",
-  "version": "0.27.14",
+  "version": "0.36.9",
   "description": "EasyNet Axon Node.js SDK (sidecar-first with Dendrite bridge payload).",
   "license": "Apache-2.0",
   "homepage": "https://easynet.run",
@@ -15,12 +15,14 @@
   },
   "type": "module",
   "scripts": {
-    "build": "tsc",
-    "check": "tsc --noEmit",
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
     "types:check": "tsc -p tsconfig.types.json --noEmit",
     "types:build": "tsc -p tsconfig.types.json",
-    "types:verify": "npm run types:build && test -f dist/types/index.d.ts && test -f dist/types/dendrite_bridge.d.ts",
-    "types": "npm run types:check && npm run types:verify"
+    "types:verify": "npm run types:build && node ./scripts/verify-dist-types.mjs",
+    "generated:check": "npm run build && node ./scripts/verify-generated.mjs",
+    "types": "npm run check && npm run types:verify",
+    "verify": "npm run types && npm run generated:check"
   },
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/runtime/runtime-bridge-manifest.json

@@ -1,11 +1,11 @@
 {
-  "runtime_version": "0.27.14",
+  "runtime_version": "0.36.9",
   "target": "x86_64-unknown-linux-gnu",
   "os": "linux",
   "arch": "x86_64",
   "artifact": {
-    "path": "runtime/easynet-runtime-rs-0.27.14-x86_64-unknown-linux-gnu.tar.gz",
-    "sha256": "382b54020ba9caa97e175fdec8e99a45f52209e40d36214f33efc741482e2072",
+    "path": "runtime/easynet-runtime-rs-0.36.9-x86_64-unknown-linux-gnu.tar.gz",
+    "sha256": "6d4c56411bae31ed11ec94face402c170d7a44d7f0686bac601440d25a9e98b2",
     "binary_name": "axon-runtime"
   },
   "language_bridge_descriptors": [
@@ -16,5 +16,5 @@
     "java/runtime-bridge.json",
     "swift/runtime-bridge.json"
   ],
-  "generated_at_utc": "2026-03-19T17:45:33Z"
+  "generated_at_utc": "2026-03-27T17:24:23Z"
 }

package/runtime/runtime-bridge.json

@@ -1,9 +1,9 @@
 {
   "language": "node",
-  "runtime_version": "0.27.14",
+  "runtime_version": "0.36.9",
   "target": "x86_64-unknown-linux-gnu",
-  "runtime_artifact_path": "runtime/easynet-runtime-rs-0.27.14-x86_64-unknown-linux-gnu.tar.gz",
+  "runtime_artifact_path": "runtime/easynet-runtime-rs-0.36.9-x86_64-unknown-linux-gnu.tar.gz",
   "binary_relative_path": "axon-runtime",
-  "recommended_extract": "tar -xzf runtime/easynet-runtime-rs-0.27.14-x86_64-unknown-linux-gnu.tar.gz -C <runtime_dir>",
+  "recommended_extract": "tar -xzf runtime/easynet-runtime-rs-0.36.9-x86_64-unknown-linux-gnu.tar.gz -C <runtime_dir>",
   "recommended_launch": "AXON_ENFORCE_MTLS=false <runtime_dir>/axon-runtime"
 }

package/src/ability_lifecycle.d.ts

@@ -3,6 +3,7 @@ import { type DeployTrace } from "./receipt.js";
 import type { ToolSpec } from "./tool_adapter.js";
 export interface AbilityDescriptor {
     name: string;
+    toolName: string;
     description: string;
     commandTemplate: string;
     inputSchema: Record<string, unknown>;

package/src/ability_lifecycle.js

@@ -1,5 +1,11 @@
-// sdk/node/src/ability_lifecycle.ts — Ability lifecycle API: create, deploy, and export as Agent Skills.
+// EasyNet Axon for AgentNet
+// =========================
 //
+// File: sdk/node/src/ability_lifecycle.ts
+// Description: Ability lifecycle API: create, deploy, invoke, and export as Agent Skills.
+//
+// Author: Silan.Hu
+// Email: silan.hu@u.nus.edu
 // Copyright (c) 2026-2027 easynet. All rights reserved.
 import { spawn } from "node:child_process";
 import { webcrypto } from "node:crypto";
@@ -219,6 +225,7 @@ export function createAbility(opts) {
     const token = normalizeAbilityName(opts.name);
     return {
         name: opts.name,
+        toolName: token,
         description: opts.description,
         commandTemplate: opts.commandTemplate,
         inputSchema: opts.inputSchema ?? { type: "object", properties: {} },
@@ -232,9 +239,8 @@ export function createAbility(opts) {
 // toToolSpec
 // ---------------------------------------------------------------------------
 export function toToolSpec(descriptor) {
-    const token = normalizeAbilityName(descriptor.name);
     return {
-        name: token,
+        name: descriptor.toolName,
         description: descriptor.description,
         resourceUri: descriptor.resourceUri,
         parameters: descriptor.inputSchema,
@@ -244,7 +250,7 @@ export function toToolSpec(descriptor) {
 // exportAbility
 // ---------------------------------------------------------------------------
 export function exportAbility(descriptor, target = "agent_skills", axonEndpoint) {
-    const token = normalizeAbilityName(descriptor.name);
+    const token = descriptor.toolName;
     const endpoint = axonEndpoint ?? `http://127.0.0.1:${DEFAULT_AXON_PORT}`;
     const invokeScript = generateInvokeScript(descriptor.resourceUri, endpoint);
     const abilityMd = generateAbilityMd(descriptor, target, token);
@@ -270,7 +276,7 @@ export function exportAbility(descriptor, target = "agent_skills", axonEndpoint)
  * ```
  */
 export async function deployToNode(bridge, tenant, nodeId, descriptor, signature) {
-    const token = normalizeAbilityName(descriptor.name);
+    const token = descriptor.toolName;
     const abilityId = token;
     const pkg = buildDeployPackage({
         ability_name: descriptor.name,
@@ -308,7 +314,7 @@ export async function listAbilities(bridge, tenant, nodeId) {
 // invokeAbility
 // ---------------------------------------------------------------------------
 export async function invokeAbility(bridge, tenant, nodeId, toolName, args = {}) {
-    return await bridge.callMcpToolWithArgs(tenant, toolName, nodeId, args);
+    return await bridge.callMcpToolWithArgs(tenant, normalizeAbilityName(toolName), nodeId, args);
 }
 // ---------------------------------------------------------------------------
 // uninstallAbility

package/src/capability_request.js

@@ -23,8 +23,10 @@
 // Author: Silan.Hu
 // Email: silan.hu@u.nus.edu
 // Copyright (c) 2026-2027 easynet. All rights reserved.
+// DendriteError re-exported from errors.ts to break the circular dependency:
+// dendrite_bridge imports validate/build helpers from this module, so we
+// cannot import from dendrite_bridge here. errors.ts has no such dependency.
 import { AxonConfigError } from "./errors.js";
-// DendriteError kept for backward compatibility; validation now uses AxonConfigError.
 export class DendriteError extends Error {
     constructor(message) {
         super(message);

package/src/dendrite_bridge/bridge.d.ts

@@ -1,4 +1,4 @@
-import type { DendriteBridgeOptions, DendriteUnaryCallOptions, DendriteAbilityCallOptions, DendriteStreamCallOptions, DendriteClientStreamCallOptions, DendriteBidiStreamCallOptions, DendriteListNodesOptions, DendriteRegisterNodeOptions, DendritePublishCapabilityOptions, DendriteInstallCapabilityOptions, DendriteListA2aAgentsOptions, DendriteSendA2aTaskOptions, DendriteDeployMcpListDirOptions, DendriteListMcpToolsOptions, DendriteCallMcpToolOptions, DendriteUninstallCapabilityOptions, DendriteUpdateMcpListDirOptions, DendriteVoiceCreateCallOptions, DendriteVoiceJoinCallOptions, DendriteVoiceUpdateMediaPathOptions, DendriteVoiceMetricsOptions, DendriteVoiceEndCallOptions, DendriteVoiceWatchOptions, DendriteVoiceCreateTransportSessionOptions, DendriteVoiceDescriptionOptions, DendriteVoiceCandidateOptions, DendriteVoiceEndTransportSessionOptions, DendriteProtocolInvokeOptions } from "./types.js";
+import type { DendriteBridgeOptions, DendriteUnaryCallOptions, DendriteAbilityCallOptions, DendriteStreamCallOptions, DendriteClientStreamCallOptions, DendriteBidiStreamCallOptions, DendriteListNodesOptions, DendriteRegisterNodeOptions, DendritePublishCapabilityOptions, DendriteInstallCapabilityOptions, DendriteListA2aAgentsOptions, DendriteSendA2aTaskOptions, DendriteDeployMcpListDirOptions, DendriteListMcpToolsOptions, DendriteCallMcpToolOptions, DendriteCallMcpToolStreamOptions, DendriteUninstallCapabilityOptions, DendriteUpdateMcpListDirOptions, DendriteVoiceCreateCallOptions, DendriteVoiceJoinCallOptions, DendriteVoiceUpdateMediaPathOptions, DendriteVoiceMetricsOptions, DendriteVoiceEndCallOptions, DendriteVoiceWatchOptions, DendriteVoiceCreateTransportSessionOptions, DendriteVoiceDescriptionOptions, DendriteVoiceCandidateOptions, DendriteVoiceEndTransportSessionOptions, DendriteProtocolInvokeOptions } from "./types.js";
 import type { DendriteBridgeLib } from "./ffi.js";
 export declare class DendriteBridge {
     private readonly lib;
@@ -33,6 +33,12 @@ export declare class DendriteBridge {
     deployMcpListDir(tenantId: string, nodeId: string, options?: DendriteDeployMcpListDirOptions): Record<string, unknown>;
     listMcpTools(tenantId: string, options?: DendriteListMcpToolsOptions): Record<string, unknown>[];
     callMcpTool(tenantId: string, toolName: string, options?: DendriteCallMcpToolOptions): Record<string, unknown>;
+    /**
+     * Open a streaming MCP tool call that returns incremental response chunks.
+     * Requires native library support for streaming symbols.
+     * Uses DEFAULT_MCP_TOOL_STREAM_TIMEOUT_MS (60s) per chunk if no timeout specified.
+     */
+    callMcpToolStream(tenantId: string, toolName: string, options?: DendriteCallMcpToolStreamOptions): DendriteServerStream;
     uninstallCapability(tenantId: string, nodeId: string, installId: string, options?: DendriteUninstallCapabilityOptions): Record<string, unknown>;
     updateMcpListDir(tenantId: string, nodeId: string, options?: DendriteUpdateMcpListDirOptions): Record<string, unknown>;
     createVoiceCall(tenantId: string, options?: DendriteVoiceCreateCallOptions): Record<string, unknown>;
@@ -69,9 +75,10 @@ export declare class DendriteBridge {
 export declare class DendriteServerStream implements AsyncIterable<Uint8Array> {
     private readonly lib;
     private readonly streamHandle;
+    private readonly defaultChunkTimeoutMs;
     private done;
     private nativeClosed;
-    constructor(lib: DendriteBridgeLib, streamHandle: bigint);
+    constructor(lib: DendriteBridgeLib, streamHandle: bigint, defaultChunkTimeoutMs?: number);
     next(timeoutMs?: number): {
         chunk: Uint8Array | null;
         done: boolean;

package/src/dendrite_bridge/bridge.js

@@ -23,7 +23,7 @@
 // Author: Silan.Hu
 // Email: silan.hu@u.nus.edu
 // Copyright (c) 2026-2027 easynet. All rights reserved.
-import { callJson, loadDendriteLib, resolveLibraryPath, requireBridgeFn, DendriteError, DEFAULT_TIMEOUT_MS, DEFAULT_CONNECT_TIMEOUT_MS, } from "./ffi.js";
+import { callJson, loadDendriteLib, resolveLibraryPath, requireBridgeFn, DendriteError, DEFAULT_TIMEOUT_MS, DEFAULT_CONNECT_TIMEOUT_MS, DEFAULT_MCP_TOOL_STREAM_TIMEOUT_MS, } from "./ffi.js";
 const STREAMING_UNSUPPORTED = "incremental streaming not supported by loaded native library";
 import { validatePublishCapabilityRequest, buildPublishCapabilityPayload, validateInstallCapabilityRequest, buildInstallCapabilityPayload, validateDeployMcpListDirRequest, buildDeployMcpListDirPayload, validateUpdateMcpListDirRequest, buildUpdateMcpListDirPayload, buildUninstallCapabilityPayload, } from "../capability_request.js";
 export class DendriteBridge {
@@ -304,6 +304,37 @@ export class DendriteBridge {
         });
         return callJson(this.lib.axon_dendrite_call_mcp_tool_json, this.handle, req);
     }
+    /**
+     * Open a streaming MCP tool call that returns incremental response chunks.
+     * Requires native library support for streaming symbols.
+     * Uses DEFAULT_MCP_TOOL_STREAM_TIMEOUT_MS (60s) per chunk if no timeout specified.
+     */
+    callMcpToolStream(tenantId, toolName, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const streamOpen = requireBridgeFn(this.lib.axon_dendrite_call_mcp_tool_stream_open_json, STREAMING_UNSUPPORTED);
+        requireBridgeFn(this.lib.axon_dendrite_stream_next_json, STREAMING_UNSUPPORTED);
+        const timeoutMs = typeof options.timeoutMs === "number" && options.timeoutMs > 0
+            ? options.timeoutMs
+            : DEFAULT_MCP_TOOL_STREAM_TIMEOUT_MS;
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            tool_name: toolName,
+            target_node_id: options.targetNodeId ?? "",
+            arguments_json: options.argumentsJson ?? {},
+            arguments_base64: options.argumentsBase64,
+            timeout_ms: timeoutMs,
+        });
+        const resp = callJson(streamOpen, this.handle, req);
+        if (resp.stream_handle == null || resp.stream_handle === "") {
+            throw new DendriteError(`failed to open mcp tool stream: missing stream_handle in ${JSON.stringify(resp)}`);
+        }
+        const streamHandle = BigInt(resp.stream_handle);
+        if (streamHandle <= 0n) {
+            throw new DendriteError(`failed to open mcp tool stream: ${JSON.stringify(resp)}`);
+        }
+        return new DendriteServerStream(this.lib, streamHandle, timeoutMs);
+    }
     uninstallCapability(tenantId, nodeId, installId, options = {}) {
         if (this.handle <= 0n)
             throw new DendriteError("dendrite bridge already closed");
@@ -596,16 +627,20 @@ export class DendriteBridge {
         return new DendriteBidiStream(this.lib, streamHandle);
     }
 }
+/** Maximum consecutive timeout results before aborting iteration (matches Python/Go/Java/Swift). */
+const MAX_CONSECUTIVE_TIMEOUT_RETRIES = 3;
 export class DendriteServerStream {
     lib;
     streamHandle;
+    defaultChunkTimeoutMs;
     done = false;
     nativeClosed = false;
-    constructor(lib, streamHandle) {
+    constructor(lib, streamHandle, defaultChunkTimeoutMs = DEFAULT_TIMEOUT_MS) {
         this.lib = lib;
         this.streamHandle = streamHandle;
+        this.defaultChunkTimeoutMs = defaultChunkTimeoutMs > 0 ? defaultChunkTimeoutMs : DEFAULT_TIMEOUT_MS;
     }
-    next(timeoutMs = DEFAULT_TIMEOUT_MS) {
+    next(timeoutMs = this.defaultChunkTimeoutMs) {
         if (this.done)
             return { chunk: null, done: true };
         const streamNext = requireBridgeFn(this.lib.axon_dendrite_stream_next_json, STREAMING_UNSUPPORTED);
@@ -630,13 +665,20 @@ export class DendriteServerStream {
         }
     }
     async *[Symbol.asyncIterator]() {
+        let consecutiveTimeouts = 0;
         try {
             while (true) {
                 const { chunk, done, timeout } = this.next();
                 if (done)
                     break;
-                if (timeout)
+                if (timeout) {
+                    consecutiveTimeouts++;
+                    if (consecutiveTimeouts >= MAX_CONSECUTIVE_TIMEOUT_RETRIES) {
+                        throw new DendriteError(`stream timed out after ${consecutiveTimeouts} consecutive retries`);
+                    }
                     continue;
+                }
+                consecutiveTimeouts = 0;
                 if (chunk)
                     yield chunk;
             }
@@ -694,13 +736,20 @@ export class DendriteBidiStream {
         }
     }
     async *[Symbol.asyncIterator]() {
+        let consecutiveTimeouts = 0;
         try {
             while (true) {
                 const { chunk, done, timeout } = this.recv();
                 if (done)
                     break;
-                if (timeout)
+                if (timeout) {
+                    consecutiveTimeouts++;
+                    if (consecutiveTimeouts >= MAX_CONSECUTIVE_TIMEOUT_RETRIES) {
+                        throw new DendriteError(`stream timed out after ${consecutiveTimeouts} consecutive retries`);
+                    }
                     continue;
+                }
+                consecutiveTimeouts = 0;
                 if (chunk)
                     yield chunk;
             }

package/src/dendrite_bridge/ffi.d.ts

@@ -1,6 +1,7 @@
 import { DendriteError } from "../capability_request.js";
 export declare const DEFAULT_TIMEOUT_MS = 30000;
 export declare const DEFAULT_CONNECT_TIMEOUT_MS = 5000;
+export declare const DEFAULT_MCP_TOOL_STREAM_TIMEOUT_MS = 60000;
 interface DendriteBridgeJson {
     ok: boolean;
     [key: string]: unknown;
@@ -30,6 +31,8 @@ export type DendriteBridgeLib = {
     axon_dendrite_deploy_mcp_list_dir_json: DendriteJsonFn<[bigint, string]>;
     axon_dendrite_list_mcp_tools_json: DendriteJsonFn<[bigint, string]>;
     axon_dendrite_call_mcp_tool_json: DendriteJsonFn<[bigint, string]>;
+    /** FFI binding to open a streaming MCP tool call. Returns a stream_handle. Optional — unavailable in older native libraries. */
+    axon_dendrite_call_mcp_tool_stream_open_json?: DendriteJsonFn<[bigint, string]>;
     axon_dendrite_uninstall_capability_json: DendriteJsonFn<[bigint, string]>;
     axon_dendrite_update_mcp_list_dir_json: DendriteJsonFn<[bigint, string]>;
     axon_dendrite_voice_create_call_json: DendriteJsonFn<[bigint, string]>;

package/src/dendrite_bridge/ffi.js

@@ -32,6 +32,7 @@ const require = createRequire(import.meta.url);
 const koffi = require("koffi");
 export const DEFAULT_TIMEOUT_MS = 30000;
 export const DEFAULT_CONNECT_TIMEOUT_MS = 5000;
+export const DEFAULT_MCP_TOOL_STREAM_TIMEOUT_MS = 60_000;
 export { DendriteError };
 export function resolveLibraryPath(explicitPath) {
     if (explicitPath)
@@ -88,6 +89,7 @@ export function loadDendriteLib(libraryPath) {
         axon_dendrite_deploy_mcp_list_dir_json: lib.func("axon_dendrite_deploy_mcp_list_dir_json", bridgeString, ["uint64_t", "str"]),
         axon_dendrite_list_mcp_tools_json: lib.func("axon_dendrite_list_mcp_tools_json", bridgeString, ["uint64_t", "str"]),
         axon_dendrite_call_mcp_tool_json: lib.func("axon_dendrite_call_mcp_tool_json", bridgeString, ["uint64_t", "str"]),
+        axon_dendrite_call_mcp_tool_stream_open_json: optionalJsonFn("axon_dendrite_call_mcp_tool_stream_open_json", ["uint64_t", "str"]),
         axon_dendrite_uninstall_capability_json: lib.func("axon_dendrite_uninstall_capability_json", bridgeString, ["uint64_t", "str"]),
         axon_dendrite_update_mcp_list_dir_json: lib.func("axon_dendrite_update_mcp_list_dir_json", bridgeString, ["uint64_t", "str"]),
         axon_dendrite_voice_create_call_json: lib.func("axon_dendrite_voice_create_call_json", bridgeString, ["uint64_t", "str"]),

package/src/dendrite_bridge/types.d.ts

@@ -84,6 +84,10 @@ export interface DendriteCallMcpToolOptions {
     argumentsJson?: unknown;
     argumentsBase64?: string;
 }
+export interface DendriteCallMcpToolStreamOptions extends DendriteCallMcpToolOptions {
+    /** Per-chunk timeout in milliseconds for streaming reads. Default: 60,000 ms. */
+    timeoutMs?: number;
+}
 export interface DendriteUninstallCapabilityOptions {
     deactivateFirst?: boolean;
     deactivateReason?: string;

package/src/errors.js

@@ -1,4 +1,12 @@
-// sdk/node/src/errors.ts — Canonical error taxonomy for the Axon SDK.
+// EasyNet Axon for AgentNet
+// =========================
+//
+// File: sdk/node/src/errors.ts
+// Description: Canonical error taxonomy for the Axon SDK.
+//
+// Author: Silan.Hu
+// Email: silan.hu@u.nus.edu
+// Copyright (c) 2026-2027 easynet. All rights reserved.
 //
 // Terminology:
 //   Ability  — network-addressable governed execution contract
@@ -7,8 +15,6 @@
 //
 // Each error class exposes a `code` property for cross-SDK mapping.
 // See the Rust reference: sdk/rust/src/error.rs
-//
-// Copyright (c) 2026-2027 easynet. All rights reserved.
 /** Base error for all Axon SDK errors. */
 export class AxonError extends Error {
     /** Canonical error code for cross-SDK mapping. */

package/src/index.d.ts

@@ -1,5 +1,5 @@
 export { validateUninstallCapabilityRequest, buildUninstallCapabilityPayload, } from "./capability_request.js";
-export type { McpToolProvider, McpToolResult, } from "./mcp/server.js";
+export type { McpToolProvider, McpToolResult, McpToolStreamHandle, } from "./mcp/server.js";
 export { StdioMcpServer } from "./mcp/server.js";
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [k: string]: JsonValue;
@@ -52,4 +52,4 @@ export { createAbility, exportAbility, deployToNode, listAbilities, invokeAbilit
 export { AxonError, AxonConfigError, AxonBridgeError, AxonNotInstalledError, AxonNotActivatedError, AxonInvocationError, AxonStreamError, AxonPolicyDeniedError, AxonMcpError, AxonPartialSuccessError, AxonJsonError, AxonIoError, AxonSymbolNotFoundError, } from "./errors.js";
 export { beginPhase, skippedReceipt, buildDeployTrace, phaseFromTrace, PhaseReceiptBuilder, type Phase, type PhaseStatus, type PhaseReceipt, type DeployTrace, } from "./receipt.js";
 export { AbilityToolAdapter, type ToolSpec as AdapterToolSpec, type OpenAITool, type OpenAIChatTool, type AnthropicTool, type ToolParameters, type LocalHandler, type RegisterOptions, type AbilityToolAdapterOptions, } from "./tool_adapter.js";
-export { DendriteBridge, DendriteServerStream, DendriteBidiStream, type DendriteBridgeOptions, DendriteError, type DendriteUnaryCallOptions, type DendriteAbilityCallOptions, type DendriteStreamCallOptions, type DendriteClientStreamCallOptions, type DendriteBidiStreamCallOptions, type DendriteListNodesOptions, type DendriteRegisterNodeOptions, type DendritePublishCapabilityOptions, type DendriteInstallCapabilityOptions, type DendriteListA2aAgentsOptions, type DendriteSendA2aTaskOptions, type DendriteDeployMcpListDirOptions, type DendriteListMcpToolsOptions, type DendriteCallMcpToolOptions, type DendriteUninstallCapabilityOptions, type DendriteUpdateMcpListDirOptions, type DendriteVoiceCodecProfileOptions, type DendriteVoiceMetricsOptions, type DendriteVoiceDescriptionOptions, type DendriteVoiceCandidateOptions, type DendriteVoiceCreateCallOptions, type DendriteVoiceJoinCallOptions, type DendriteVoiceUpdateMediaPathOptions, type DendriteVoiceEndCallOptions, type DendriteVoiceWatchOptions, type DendriteVoiceCreateTransportSessionOptions, type DendriteVoiceEndTransportSessionOptions, type DendriteProtocolInvokeOptions, } from "./dendrite_bridge.js";
+export { DendriteBridge, DendriteServerStream, DendriteBidiStream, type DendriteBridgeOptions, DendriteError, type DendriteUnaryCallOptions, type DendriteAbilityCallOptions, type DendriteStreamCallOptions, type DendriteClientStreamCallOptions, type DendriteBidiStreamCallOptions, type DendriteListNodesOptions, type DendriteRegisterNodeOptions, type DendritePublishCapabilityOptions, type DendriteInstallCapabilityOptions, type DendriteListA2aAgentsOptions, type DendriteSendA2aTaskOptions, type DendriteDeployMcpListDirOptions, type DendriteListMcpToolsOptions, type DendriteCallMcpToolOptions, type DendriteCallMcpToolStreamOptions, type DendriteUninstallCapabilityOptions, type DendriteUpdateMcpListDirOptions, type DendriteVoiceCodecProfileOptions, type DendriteVoiceMetricsOptions, type DendriteVoiceDescriptionOptions, type DendriteVoiceCandidateOptions, type DendriteVoiceCreateCallOptions, type DendriteVoiceJoinCallOptions, type DendriteVoiceUpdateMediaPathOptions, type DendriteVoiceEndCallOptions, type DendriteVoiceWatchOptions, type DendriteVoiceCreateTransportSessionOptions, type DendriteVoiceEndTransportSessionOptions, type DendriteProtocolInvokeOptions, } from "./dendrite_bridge.js";

package/src/mcp/server.d.ts

@@ -2,9 +2,20 @@ export interface McpToolResult {
     payload: Record<string, unknown>;
     isError: boolean;
 }
+/** Handle returned by streaming MCP tool providers. Consumers iterate `stream` and must call `close()` when done. */
+export interface McpToolStreamHandle {
+    stream: AsyncIterable<Uint8Array>;
+    close(): void;
+}
 export interface McpToolProvider {
     toolSpecs(): Array<Record<string, unknown>>;
     handleToolCall(name: string, args: Record<string, unknown>): McpToolResult | Promise<McpToolResult>;
+    /**
+     * Optional streaming handler. Return a `McpToolStreamHandle` to stream incremental chunks,
+     * or `null` to fall back to the unary `handleToolCall` path.
+     * When called via a non-streaming transport, the server buffers chunks into a single response.
+     */
+    handleToolCallStream?(name: string, args: Record<string, unknown>): McpToolStreamHandle | null;
 }
 interface McpTransportOptions {
     protocolVersion?: string;
@@ -14,16 +25,27 @@ interface McpTransportOptions {
 interface JsonMessage {
     [key: string]: unknown;
 }
+/** Callback used by the MCP server to write JSON-RPC messages to the transport. */
+export type McpWriteFn = (payload: JsonMessage) => Promise<void>;
 export declare class StdioMcpServer {
     private readonly provider;
     private readonly protocolVersion;
     private readonly serverName;
     private readonly serverVersion;
     private _closed;
+    private _pendingWrite;
     constructor(provider: McpToolProvider, options?: McpTransportOptions);
     close(): void;
     run(input: NodeJS.ReadableStream, output: NodeJS.WritableStream): void;
-    handleRawLine(raw: string): JsonMessage | Promise<JsonMessage> | null;
-    handleRequest(request: JsonMessage): JsonMessage | Promise<JsonMessage> | null;
+    private dispatchRequest;
+    private enqueueWrite;
+    handleRawLine(raw: string, writeFn?: McpWriteFn): JsonMessage | Promise<JsonMessage | null> | null;
+    handleRequest(request: JsonMessage, writeFn?: McpWriteFn): JsonMessage | Promise<JsonMessage | null> | null;
 }
+/**
+ * Buffer all chunks from a streaming MCP tool handle into a single result.
+ * Stops accumulating after `maxBytes` (default 64 MiB) to prevent unbounded
+ * memory growth.  Always closes the handle when done, even on error.
+ */
+export declare function consumeStream(handle: McpToolStreamHandle, maxBytes?: number): Promise<McpToolResult>;
 export {};