@easynet-run/node 0.27.14 → 0.36.9

package/src/mcp/server.js

@@ -8,6 +8,7 @@ export class StdioMcpServer {
     serverName;
     serverVersion;
     _closed = false;
+    _pendingWrite = Promise.resolve();
     constructor(provider, options = {}) {
         this.provider = provider;
         this.protocolVersion = options.protocolVersion?.trim() || DEFAULT_PROTOCOL_VERSION;
@@ -20,11 +21,11 @@ export class StdioMcpServer {
     run(input, output) {
         let cache = "";
         input.setEncoding("utf8");
+        const writeFn = (payload) => this.enqueueWrite(output, payload);
         input.on("error", (error) => {
             if (this._closed)
                 return;
-            const payload = jsonrpcError(null, -32000, `stream error: ${String(error)}`);
-            write(output, payload);
+            void writeFn(jsonrpcError(null, -32000, `stream error: ${String(error)}`));
         });
         input.on("close", () => {
             // no-op: caller controls lifecycle
@@ -34,7 +35,7 @@ export class StdioMcpServer {
                 return;
             cache += chunk.toString();
             if (cache.length > MAX_LINE_LENGTH && !cache.includes("\n")) {
-                write(output, jsonrpcError(null, -32000, `input line exceeds maximum length (${MAX_LINE_LENGTH} bytes)`));
+                void writeFn(jsonrpcError(null, -32000, `input line exceeds maximum length (${MAX_LINE_LENGTH} bytes)`));
                 cache = "";
                 return;
             }
@@ -47,31 +48,52 @@ export class StdioMcpServer {
                 if (this._closed)
                     break;
                 if (raw.length > MAX_LINE_LENGTH) {
-                    write(output, jsonrpcError(null, -32000, `input line exceeds maximum length (${MAX_LINE_LENGTH} bytes)`));
+                    void writeFn(jsonrpcError(null, -32000, `input line exceeds maximum length (${MAX_LINE_LENGTH} bytes)`));
                     continue;
                 }
                 const requestId = parseJson(raw)?.id ?? null;
-                const response = this.handleRawLine(raw);
-                if (response !== null) {
-                    if (typeof response.then === "function") {
-                        response.then((resolved) => { if (resolved !== null)
-                            write(output, resolved); }, (error) => { write(output, jsonrpcError(requestId, -32000, String(error))); });
-                    }
-                    else {
-                        write(output, response);
-                    }
-                }
+                void this.dispatchRequest(raw, writeFn, requestId);
+            }
+        });
+    }
+    async dispatchRequest(raw, writeFn, fallbackId) {
+        try {
+            const response = await this.handleRawLine(raw, writeFn);
+            if (response !== null && !this._closed) {
+                await writeFn(response);
+            }
+        }
+        catch (error) {
+            if (!this._closed) {
+                await writeFn(jsonrpcError(fallbackId, -32000, String(error)));
+            }
+        }
+    }
+    enqueueWrite(output, payload) {
+        this._pendingWrite = this._pendingWrite
+            .catch(() => undefined)
+            .then(async () => {
+            if (this._closed) {
+                return;
+            }
+            try {
+                await write(output, payload);
+            }
+            catch {
+                this._closed = true;
+                throw new Error("failed to write MCP response");
             }
         });
+        return this._pendingWrite;
     }
-    handleRawLine(raw) {
+    handleRawLine(raw, writeFn) {
         const request = parseJson(raw);
         if (request === null) {
             return jsonrpcError(null, -32700, "parse error");
         }
-        return this.handleRequest(request);
+        return this.handleRequest(request, writeFn);
     }
-    handleRequest(request) {
+    handleRequest(request, writeFn) {
         const id = request.id;
         const method = typeof request.method === "string" ? request.method : "";
         const params = asMap(request.params);
@@ -114,6 +136,28 @@ export class StdioMcpServer {
                 args = {};
             }
             const typedArgs = args;
+            // Try streaming path first.  When a writeFn is available, chunks are
+            // forwarded to the client as JSON-RPC notifications in real time.
+            // Otherwise the stream is buffered into a single response (fallback).
+            let streamHandle = null;
+            try {
+                streamHandle = this.provider.handleToolCallStream?.(name, typedArgs) ?? null;
+            }
+            catch (error) {
+                return jsonrpcSuccess(id, toolResponse({
+                    payload: { ok: false, error: String(error) },
+                    isError: true,
+                }));
+            }
+            if (streamHandle !== null) {
+                const maxBytes = resolveMaxBytes(typedArgs.max_bytes);
+                if (writeFn) {
+                    return streamToClient(streamHandle, id, writeFn, maxBytes);
+                }
+                return consumeStream(streamHandle, maxBytes)
+                    .then((result) => jsonrpcSuccess(id, toolResponse(result)))
+                    .catch((error) => jsonrpcSuccess(id, toolResponse(toolErrorResult(error))));
+            }
             let maybeResult;
             try {
                 maybeResult = this.provider.handleToolCall(name, typedArgs);
@@ -166,7 +210,34 @@ function asString(value) {
     return value.trim();
 }
 function write(stream, payload) {
-    stream.write(`${JSON.stringify(payload)}\n`);
+    return new Promise((resolve, reject) => {
+        const text = `${JSON.stringify(payload)}\n`;
+        const onDrain = () => {
+            cleanup();
+            resolve();
+        };
+        const onError = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const cleanup = () => {
+            stream.removeListener("drain", onDrain);
+            stream.removeListener("error", onError);
+        };
+        try {
+            if (stream.write(text)) {
+                cleanup();
+                resolve();
+                return;
+            }
+            stream.once("drain", onDrain);
+            stream.once("error", onError);
+        }
+        catch (error) {
+            cleanup();
+            reject(error);
+        }
+    });
 }
 function toolResponse(result) {
     const payload = {
@@ -174,6 +245,12 @@ function toolResponse(result) {
     };
     return result.isError ? { ...payload, isError: true } : payload;
 }
+function toolErrorResult(error) {
+    return {
+        payload: { ok: false, error: String(error) },
+        isError: true,
+    };
+}
 function jsonrpcSuccess(id, result) {
     return {
         jsonrpc: "2.0",
@@ -188,3 +265,126 @@ function jsonrpcError(id, code, message) {
         error: { code, message },
     };
 }
+function jsonrpcNotification(method, params) {
+    return { jsonrpc: "2.0", method, params };
+}
+/** Default maximum total bytes (64 MiB) accepted from a single streamed MCP tool call. */
+const DEFAULT_MAX_STREAM_BYTES = 64 * 1024 * 1024; // 64 MiB
+/** Resolve a per-call max_bytes override. 0 or absent → default. */
+function resolveMaxBytes(raw) {
+    if (typeof raw === "number" && raw > 0)
+        return raw;
+    return DEFAULT_MAX_STREAM_BYTES;
+}
+function formatBytes(n) {
+    if (n >= 1024 * 1024 * 1024)
+        return `${(n / (1024 * 1024 * 1024)).toFixed(0)} GiB`;
+    if (n >= 1024 * 1024)
+        return `${(n / (1024 * 1024)).toFixed(0)} MiB`;
+    if (n >= 1024)
+        return `${(n / 1024).toFixed(0)} KiB`;
+    return `${n} bytes`;
+}
+/**
+ * Common helper that iterates a stream handle, converts each chunk to UTF-8,
+ * validates encoding, enforces a byte limit, and closes the handle when done.
+ *
+ * - **Streaming mode** (`onChunk` provided): calls `onChunk` for each decoded
+ *   chunk and does NOT accumulate chunks in memory.
+ * - **Buffer mode** (`onChunk` omitted): accumulates all decoded chunks into
+ *   the returned `chunks` array.
+ */
+async function processStream(handle, maxBytes, onChunk) {
+    const result = {
+        hadError: null,
+        hadInvalidUtf8: false,
+        chunkCount: 0,
+        chunks: [],
+    };
+    let totalBytes = 0;
+    try {
+        for await (const raw of handle.stream) {
+            const buf = Buffer.from(raw);
+            const text = buf.toString("utf8");
+            if (!result.hadInvalidUtf8 && buf.length > 0 && text.includes('\uFFFD')) {
+                result.hadInvalidUtf8 = true;
+            }
+            totalBytes += buf.length;
+            if (totalBytes > maxBytes) {
+                const suffix = onChunk ? "limit" : "buffer limit";
+                result.hadError = `stream output exceeded ${formatBytes(maxBytes)} ${suffix}`;
+                break;
+            }
+            if (onChunk) {
+                await onChunk(text, result.chunkCount);
+            }
+            else {
+                result.chunks.push(text);
+            }
+            result.chunkCount++;
+        }
+    }
+    catch (error) {
+        result.hadError = String(error);
+    }
+    finally {
+        try {
+            handle.close();
+        }
+        catch (e) {
+            console.error("mcp: stream close failed:", e);
+        }
+    }
+    return result;
+}
+/**
+ * Stream tool output to the client in real time using JSON-RPC notifications.
+ *
+ * Each chunk is sent as an `axon/streamChunk` notification as soon as it
+ * arrives from the underlying stream.  After the stream completes (or on
+ * error) a final JSON-RPC response is returned with a summary.
+ *
+ * Clients that do not understand `axon/streamChunk` simply ignore the
+ * notifications and still receive the final summary response.
+ */
+async function streamToClient(handle, requestId, writeFn, maxBytes = DEFAULT_MAX_STREAM_BYTES) {
+    const result = await processStream(handle, maxBytes, async (decoded, seq) => {
+        await writeFn(jsonrpcNotification("axon/streamChunk", {
+            requestId,
+            seq,
+            chunk: decoded,
+        }));
+    });
+    const summary = {
+        ok: result.hadError === null,
+        chunk_count: result.chunkCount,
+        streamed: true,
+    };
+    if (result.hadError)
+        summary.error = result.hadError;
+    if (result.hadInvalidUtf8)
+        summary.contains_invalid_utf8 = true;
+    return jsonrpcSuccess(requestId, toolResponse({
+        payload: summary,
+        isError: result.hadError !== 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 async function consumeStream(handle, maxBytes = DEFAULT_MAX_STREAM_BYTES) {
+    const result = await processStream(handle, maxBytes);
+    if (result.hadError !== null) {
+        return {
+            payload: { ok: false, chunk_count: result.chunks.length, chunks: result.chunks, error: result.hadError },
+            isError: true,
+        };
+    }
+    const payload = { ok: true, chunk_count: result.chunks.length, chunks: result.chunks };
+    if (result.hadInvalidUtf8) {
+        payload.contains_invalid_utf8 = true;
+    }
+    return { payload, isError: false };
+}

package/src/mcp/server.test.js

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { PassThrough } from "node:stream";
+
+import { StdioMcpServer } from "./server.js";
+
+describe("StdioMcpServer", () => {
+  it("keeps buffered stream responses intact when close throws", async () => {
+    const server = new StdioMcpServer({
+      toolSpecs: () => [],
+      handleToolCall: () => ({ payload: { ok: true }, isError: false }),
+      handleToolCallStream: () => ({
+        close() {
+          throw new Error("close failed");
+        },
+        async *[Symbol.asyncIterator]() {
+          yield Buffer.from("chunk-1");
+        },
+      }),
+    });
+
+    const response = await server.handleRequest({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: {
+        name: "streamed_tool",
+        arguments: {},
+      },
+    });
+
+    assert.equal(response.jsonrpc, "2.0");
+    const payload = JSON.parse(response.result.content[0].text);
+    assert.equal(payload.ok, true);
+    assert.deepEqual(payload.chunks, ["chunk-1"]);
+    assert.equal(response.result.isError, undefined);
+  });
+
+  it("serializes writes through drain backpressure", async () => {
+    const input = new PassThrough();
+    const chunks = [];
+    const output = new PassThrough({ highWaterMark: 1 });
+    output.on("data", (chunk) => {
+      chunks.push(chunk.toString("utf8"));
+    });
+    const server = new StdioMcpServer({
+      toolSpecs: () => [],
+      handleToolCall: () => ({ payload: { ok: true }, isError: false }),
+    });
+
+    server.run(input, output);
+    input.write('{"jsonrpc":"2.0","id":1,"method":"ping"}\n');
+    input.write('{"jsonrpc":"2.0","id":2,"method":"ping"}\n');
+    input.end();
+
+    await new Promise((resolve) => setTimeout(resolve, 25));
+
+    assert.equal(chunks.length, 2);
+    assert.match(chunks[0], /"id":1/);
+    assert.match(chunks[1], /"id":2/);
+  });
+});

package/src/presets/remote_control/config.d.ts

@@ -8,9 +8,12 @@ export declare const DEFAULT_SIGNATURE = "__AXON_EPHEMERAL_DO_NOT_USE_IN_PROD__"
 export declare const DEFAULT_VERSION = "1.0.0";
 export declare const DEFAULT_INSTALL_TIMEOUT_SECONDS = 45;
 export declare const DEFAULT_EXECUTION_MODE = "sandbox_first";
+export { DEFAULT_MCP_TOOL_STREAM_TIMEOUT_MS } from "../../dendrite_bridge/ffi.js";
 export declare function loadRemoteControlConfigFromEnv(): RemoteControlRuntimeConfig;
 export declare function loadConfigFromEnv(): RemoteControlRuntimeConfig;
 export declare function ensureRemoteControlNativeLibEnv(): void;
 export declare function ensureNativeLibEnv(): void;
 export declare function parsePositiveInt(raw: string | undefined, fallback: number): number;
 export declare function asString(raw: unknown, fallback?: string): string;
+export declare function asBool(raw: unknown): boolean;
+export declare function asNumber(raw: unknown): number;

package/src/presets/remote_control/config.js

@@ -1,13 +1,12 @@
 // EasyNet Axon for AgentNet
 // =========================
 //
-// File: sdk/node/src/presets/remote_control/config.js
-// Description: AUTO-GENERATED — compiled from config.ts. Runtime configuration for the remote-control preset.
+// File: sdk/node/src/presets/remote_control/config.ts
+// Description: Runtime configuration and constants for the remote-control preset.
 //
 // Author: Silan.Hu
 // Email: silan.hu@u.nus.edu
 // Copyright (c) 2026-2027 easynet. All rights reserved.
-
 import { existsSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -15,6 +14,7 @@ export const DEFAULT_SIGNATURE = "__AXON_EPHEMERAL_DO_NOT_USE_IN_PROD__";
 export const DEFAULT_VERSION = "1.0.0";
 export const DEFAULT_INSTALL_TIMEOUT_SECONDS = 45;
 export const DEFAULT_EXECUTION_MODE = "sandbox_first";
+export { DEFAULT_MCP_TOOL_STREAM_TIMEOUT_MS } from "../../dendrite_bridge/ffi.js";
 export function loadRemoteControlConfigFromEnv() {
     return {
         endpoint: process.env.AXON_ENDPOINT ?? "http://127.0.0.1:50051",
@@ -52,6 +52,20 @@ export function parsePositiveInt(raw, fallback) {
 export function asString(raw, fallback = "") {
     return raw == null ? fallback : String(raw).trim() || fallback;
 }
+export function asBool(raw) {
+    if (typeof raw === "boolean")
+        return raw;
+    if (typeof raw === "number")
+        return raw !== 0;
+    const normalized = String(raw ?? "").trim().toLowerCase();
+    return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
+}
+export function asNumber(raw) {
+    if (typeof raw === "number")
+        return raw;
+    const value = Number.parseInt(String(raw ?? "0"), 10);
+    return Number.isFinite(value) ? value : 0;
+}
 function defaultNativeLibName() {
     if (process.platform === "darwin") {
         return "libaxon_dendrite_bridge.dylib";

package/src/presets/remote_control/descriptor.js

@@ -1,17 +1,19 @@
-import { DEFAULT_VERSION, asString } from "./config.js";
+// EasyNet Axon for AgentNet
+// =========================
+//
+// File: sdk/node/src/presets/remote_control/descriptor.ts
+// Description: Skill package descriptor: build, parse, and serialize for MCP deployment.
+//
+// Author: Silan.Hu
+// Email: silan.hu@u.nus.edu
+// Copyright (c) 2026-2027 easynet. All rights reserved.
+import { DEFAULT_VERSION, asBool, asString } from "./config.js";
 export function resolveTenant(raw, fallback) {
     const value = asString(raw);
     return !value || value === "<nil>" ? fallback : value;
 }
 export function parseBool(raw) {
-    if (typeof raw === "boolean") {
-        return raw;
-    }
-    if (typeof raw === "number") {
-        return raw !== 0;
-    }
-    const normalized = asString(raw).toLowerCase();
-    return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
+    return asBool(raw);
 }
 export function randomSuffix(length = 2) {
     return Math.floor(Math.random() * 1e18).toString(36).slice(0, length);
@@ -67,6 +69,21 @@ export function defaultOutputSchema() {
         required: ["entries"],
     };
 }
+function mergeAdditionalMetadata(base, raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return base;
+    }
+    const merged = { ...base };
+    for (const [rawKey, rawValue] of Object.entries(raw)) {
+        const key = asString(rawKey);
+        const value = asString(rawValue);
+        if (!key || !value || Object.prototype.hasOwnProperty.call(merged, key)) {
+            continue;
+        }
+        merged[key] = value;
+    }
+    return merged;
+}
 export function serializeDescriptor(descriptor) {
     const payload = {
         "ability_name": descriptor.abilityName,
@@ -145,7 +162,7 @@ export function buildDescriptor(args, defaultSignature) {
     const outputSchema = typeof args.output_schema === "object" && !Array.isArray(args.output_schema)
         ? args.output_schema
         : defaultOutputSchema();
-    const metadata = {
+    const metadata = mergeAdditionalMetadata({
         "mcp.tool_name": toolName,
         "mcp.description": description,
         "mcp.input_schema": JSON.stringify(inputSchema),
@@ -153,7 +170,7 @@ export function buildDescriptor(args, defaultSignature) {
         "axon.exec.command": commandTemplate,
         "ability.name": abilityName,
         "ability.version": version,
-    };
+    }, args.metadata);
     const payload = {
         kind: "axon.ability.package.v1",
         ability_name: abilityName,

package/src/presets/remote_control/handlers.d.ts

@@ -4,6 +4,8 @@ export declare function resolveDescriptor(args: JsonRecord, fallbackSignature: s
 export declare function handleDiscoverNodes(orch: RemoteOrchestrator, tenant: string): JsonRecord;
 export declare function handleListRemoteTools(orch: RemoteOrchestrator, tenant: string, args: JsonRecord): JsonRecord;
 export declare function handleCallRemoteTool(orch: RemoteOrchestrator, tenant: string, args: JsonRecord): JsonRecord;
+/** Open a streaming MCP tool call with validated tool_name and node_id. */
+export declare function handleCallRemoteToolStream(orch: RemoteOrchestrator, _tenant: string, args: JsonRecord): ReturnType<RemoteOrchestrator["callMcpToolStream"]>;
 export declare function handleDisconnectDevice(orch: RemoteOrchestrator, tenant: string, args: JsonRecord): JsonRecord;
 export declare function handleUninstallAbility(orch: RemoteOrchestrator, tenant: string, args: JsonRecord): JsonRecord;
 export declare function handlePackageAbility(tenant: string, args: JsonRecord, signature: string): JsonRecord;

package/src/presets/remote_control/handlers.js

@@ -7,8 +7,9 @@
 // Author: Silan.Hu
 // Email: silan.hu@u.nus.edu
 // Copyright (c) 2026-2027 easynet. All rights reserved.
+import { randomBytes } from "node:crypto";
 import { buildDescriptor, buildPythonSubprocessTemplate, parseBool, parseDescriptor, serializeDescriptor, } from "./descriptor.js";
-import { asString } from "./config.js";
+import { asBool, asNumber, asString, DEFAULT_MCP_TOOL_STREAM_TIMEOUT_MS } from "./config.js";
 // ---------------------------------------------------------------------------
 // Architecture: ability_lifecycle vs presets/remote_control
 //
@@ -79,6 +80,21 @@ export function handleCallRemoteTool(orch, tenant, args) {
     const failed = asNumber(call.state) !== INVOCATION_COMPLETED || asBool(call.is_error);
     return { ok: !failed, tenant_id: tenant, tool_name: toolName, node_id: nodeId, call };
 }
+/** Open a streaming MCP tool call with validated tool_name and node_id. */
+export function handleCallRemoteToolStream(orch, _tenant, args) {
+    const toolName = String(args.tool_name || "").trim();
+    const nodeId = String(args.node_id || "").trim();
+    if (!toolName || !nodeId) {
+        throw new Error(!toolName ? "tool_name is required" : "node_id is required");
+    }
+    const callArgs = typeof args.arguments === "object" && !Array.isArray(args.arguments)
+        ? args.arguments
+        : {};
+    const timeoutMs = asNumber(args.timeout_ms);
+    return orch.callMcpToolStream(toolName, nodeId, callArgs, {
+        timeoutMs: timeoutMs > 0 ? timeoutMs : DEFAULT_MCP_TOOL_STREAM_TIMEOUT_MS,
+    });
+}
 export function handleDisconnectDevice(orch, tenant, args) {
     const nodeId = String(args.node_id || "").trim();
     if (!nodeId) {
@@ -149,7 +165,7 @@ export function handleDeployAbility(orch, tenant, args, signature) {
     if (!commandTemplate) {
         return { ok: false, tenant_id: tenant, node_id: nodeId, error: "command_template is required" };
     }
-    const toolName = String(args.tool_name || `tool_${Date.now()}`).trim();
+    const toolName = String(args.tool_name || `tool_${Date.now()}_${randomHex(4)}`).trim();
     const descriptor = buildDescriptor({
         ...args,
         ability_name: toolName,
@@ -177,7 +193,7 @@ export function handleExecuteCommand(orch, tenant, args, signature) {
     if (!command)
         return { ok: false, tenant_id: tenant, node_id: nodeId, error: "command is required" };
     const shouldCleanup = args.cleanup == null ? true : parseBool(args.cleanup);
-    const toolName = `cmd_${Date.now()}_${Math.floor(Math.random() * 1e4).toString(16)}`;
+    const toolName = `cmd_${Date.now()}_${randomHex(4)}`;
     const descriptor = buildDescriptor({
         ability_name: toolName,
         tool_name: toolName,
@@ -221,20 +237,6 @@ export function handleExecuteCommand(orch, tenant, args, signature) {
         };
     }
 }
-function asBool(raw) {
-    if (typeof raw === "boolean")
-        return raw;
-    if (typeof raw === "number")
-        return raw !== 0;
-    const normalized = String(raw ?? "").trim().toLowerCase();
-    return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
-}
-function asNumber(raw) {
-    if (typeof raw === "number")
-        return raw;
-    const value = Number.parseInt(String(raw ?? "0"), 10);
-    return Number.isFinite(value) ? value : 0;
-}
 function parseDeployFailure(error) {
     const message = error instanceof Error ? error.message : String(error ?? "");
     try {
@@ -277,3 +279,6 @@ function parseCleanupSummary(failure, orch, nodeId, shouldCleanup) {
         },
     ]);
 }
+function randomHex(bytes) {
+    return randomBytes(bytes).toString("hex");
+}

package/src/presets/remote_control/kit.d.ts

@@ -1,4 +1,4 @@
-import type { McpToolProvider, McpToolResult } from "../../mcp/server.js";
+import { type McpToolProvider, type McpToolResult, type McpToolStreamHandle } from "../../mcp/server.js";
 import { type RemoteControlRuntimeConfig } from "./config.js";
 import { type JsonRecord } from "./descriptor.js";
 import { type OrchestratorFactory } from "./orchestrator.js";
@@ -14,7 +14,9 @@ export declare class RemoteControlCaseKit implements McpToolProvider {
     static ensureNativeLibEnv(): void;
     static ensureRemoteControlNativeLibEnv(): void;
     toolSpecs(): Array<JsonRecord>;
-    handleToolCall(name: string, args: JsonRecord): McpToolResult;
+    handleToolCall(name: string, args: JsonRecord): McpToolResult | Promise<McpToolResult>;
+    /** Handle streaming calls for `call_remote_tool_stream`. Returns null for unknown tools. */
+    handleToolCallStream(name: string, args: JsonRecord): McpToolStreamHandle | null;
     private dispatch;
     private withOrchestrator;
     private toolResult;

package/src/presets/remote_control/kit.js

@@ -1,8 +1,47 @@
+import { consumeStream } from "../../mcp/server.js";
 import { ensureRemoteControlNativeLibEnv, ensureNativeLibEnv, loadConfigFromEnv, loadRemoteControlConfigFromEnv, } from "./config.js";
 import { resolveTenant } from "./descriptor.js";
-import { handleCallRemoteTool, handleDeployAbility, handleDeployAbilityPackage, handleDiscoverNodes, handleDisconnectDevice, handleExecuteCommand, handleListRemoteTools, handlePackageAbility, handleUninstallAbility, } from "./handlers.js";
+import { handleCallRemoteTool, handleCallRemoteToolStream, handleDeployAbility, handleDeployAbilityPackage, handleDiscoverNodes, handleDisconnectDevice, handleExecuteCommand, handleListRemoteTools, handlePackageAbility, handleUninstallAbility, } from "./handlers.js";
 import { remoteControlToolSpecs } from "./specs.js";
 import { buildOrchestrator } from "./orchestrator.js";
+/**
+ * Wraps a remote tool stream with automatic orchestrator cleanup.
+ * Ensures the orchestrator is closed when the stream is consumed or explicitly closed.
+ * Close is idempotent — safe to call multiple times.
+ */
+class ManagedMcpToolStreamHandle {
+    inner;
+    cleanup;
+    stream;
+    closed = false;
+    constructor(inner, cleanup) {
+        this.inner = inner;
+        this.cleanup = cleanup;
+        this.stream = this.iterate();
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        try {
+            this.inner.close();
+        }
+        finally {
+            this.cleanup();
+        }
+    }
+    async *iterate() {
+        try {
+            for await (const chunk of this.inner) {
+                yield chunk;
+            }
+        }
+        finally {
+            this.close();
+        }
+    }
+}
 export class RemoteControlCaseKit {
     config;
     orchestratorFactory;
@@ -26,9 +65,39 @@ export class RemoteControlCaseKit {
         return remoteControlToolSpecs();
     }
     handleToolCall(name, args) {
+        if (name === "call_remote_tool_stream") {
+            // Buffer streaming result so callers that bypass handleToolCallStream
+            // (e.g. direct handleToolCall invocation) still get a valid response.
+            try {
+                const handle = this.handleToolCallStream(name, args);
+                if (handle) {
+                    return consumeStream(handle);
+                }
+                return this.toolResult(true, { ok: false, error: "streaming not available" });
+            }
+            catch (error) {
+                return this.toolResult(true, { ok: false, error: String(error) });
+            }
+        }
         const tenant = resolveTenant(args.tenant_id, this.config.tenant);
         return this.withOrchestrator(tenant, (orchestrator) => this.dispatch(name, args, orchestrator, tenant));
     }
+    /** Handle streaming calls for `call_remote_tool_stream`. Returns null for unknown tools. */
+    handleToolCallStream(name, args) {
+        if (name !== "call_remote_tool_stream") {
+            return null;
+        }
+        const tenant = resolveTenant(args.tenant_id, this.config.tenant);
+        const orchestrator = this.orchestratorFactory(this.config, tenant);
+        try {
+            const stream = handleCallRemoteToolStream(orchestrator, tenant, args);
+            return new ManagedMcpToolStreamHandle(stream, () => orchestrator.close());
+        }
+        catch (error) {
+            orchestrator.close();
+            throw error;
+        }
+    }
     dispatch(name, args, orchestrator, tenant) {
         switch (name) {
             case "discover_nodes":