@easynet-run/node 0.27.14 → 0.36.9

package/src/presets/remote_control/kit.test.js

@@ -3,12 +3,20 @@ import assert from "node:assert/strict";
 
 import { RemoteControlCaseKit } from "./kit.js";
 import { remoteControlToolSpecs } from "./specs.js";
+import { consumeStream } from "../../mcp/server.js";
+import { DEFAULT_MCP_TOOL_STREAM_TIMEOUT_MS } from "./config.js";
 
 function makeOrchestrator() {
   return {
     listNodes: () => [],
     listMcpTools: () => [],
     callMcpTool: () => ({ ok: true, state: 5, is_error: false }),
+    callMcpToolStream: () => ({
+      close: () => {},
+      async *[Symbol.asyncIterator]() {
+        yield Buffer.from("chunk");
+      },
+    }),
     disconnectDevice: (nodeId, reason) => ({ node_id: nodeId, reason }),
     uninstallAbility: (nodeId, installId, reason) => ({
       node_id: nodeId,
@@ -26,6 +34,7 @@ describe("RemoteControlCaseKit", () => {
     const names = remoteControlToolSpecs().map((spec) => String(spec.name));
     assert.ok(names.includes("disconnect_device"));
     assert.ok(names.includes("uninstall_ability"));
+    assert.ok(names.includes("call_remote_tool_stream"));
   });
 
   it("dispatches disconnect_device", () => {
@@ -84,4 +93,444 @@ describe("RemoteControlCaseKit", () => {
       },
     });
   });
+
+  it("closes the orchestrator when a streaming handle is closed", () => {
+    let streamClosed = 0;
+    let orchestratorClosed = 0;
+    const stream = {
+      close: () => {
+        streamClosed += 1;
+      },
+      async *[Symbol.asyncIterator]() {
+        yield Buffer.from("chunk");
+      },
+    };
+    const kit = new RemoteControlCaseKit(
+      {
+        endpoint: "http://127.0.0.1:50051",
+        tenant: "tenant-a",
+        connectTimeoutMs: 5000,
+        signatureBase64: "sig",
+      },
+      () => ({
+        ...makeOrchestrator(),
+        callMcpToolStream: () => stream,
+        close: () => {
+          orchestratorClosed += 1;
+        },
+      }),
+    );
+
+    const handle = kit.handleToolCallStream("call_remote_tool_stream", {
+      node_id: "node-a",
+      tool_name: "tool-a",
+    });
+
+    assert.ok(handle);
+    handle.close();
+    handle.close();
+    assert.equal(streamClosed, 1);
+    assert.equal(orchestratorClosed, 1);
+  });
+
+  it("closes the orchestrator after streaming iteration completes", async () => {
+    let streamClosed = 0;
+    let orchestratorClosed = 0;
+    const stream = {
+      close: () => {
+        streamClosed += 1;
+      },
+      async *[Symbol.asyncIterator]() {
+        yield Buffer.from("chunk-1");
+        yield Buffer.from("chunk-2");
+      },
+    };
+    const kit = new RemoteControlCaseKit(
+      {
+        endpoint: "http://127.0.0.1:50051",
+        tenant: "tenant-a",
+        connectTimeoutMs: 5000,
+        signatureBase64: "sig",
+      },
+      () => ({
+        ...makeOrchestrator(),
+        callMcpToolStream: () => stream,
+        close: () => {
+          orchestratorClosed += 1;
+        },
+      }),
+    );
+
+    const handle = kit.handleToolCallStream("call_remote_tool_stream", {
+      node_id: "node-a",
+      tool_name: "tool-a",
+    });
+
+    assert.ok(handle);
+    const chunks = [];
+    for await (const chunk of handle.stream) {
+      chunks.push(Buffer.from(chunk).toString("utf8"));
+    }
+
+    assert.deepEqual(chunks, ["chunk-1", "chunk-2"]);
+    assert.equal(streamClosed, 1);
+    assert.equal(orchestratorClosed, 1);
+  });
+
+  it("closes the orchestrator after an empty stream completes", async () => {
+    let streamClosed = 0;
+    let orchestratorClosed = 0;
+    const stream = {
+      close: () => {
+        streamClosed += 1;
+      },
+      async *[Symbol.asyncIterator]() {
+        // empty stream
+      },
+    };
+    const kit = new RemoteControlCaseKit(
+      {
+        endpoint: "http://127.0.0.1:50051",
+        tenant: "tenant-a",
+        connectTimeoutMs: 5000,
+        signatureBase64: "sig",
+      },
+      () => ({
+        ...makeOrchestrator(),
+        callMcpToolStream: () => stream,
+        close: () => {
+          orchestratorClosed += 1;
+        },
+      }),
+    );
+
+    const handle = kit.handleToolCallStream("call_remote_tool_stream", {
+      node_id: "node-a",
+      tool_name: "tool-a",
+    });
+
+    assert.ok(handle);
+    const chunks = [];
+    for await (const chunk of handle.stream) {
+      chunks.push(Buffer.from(chunk).toString("utf8"));
+    }
+
+    assert.deepEqual(chunks, []);
+    assert.equal(streamClosed, 1);
+    assert.equal(orchestratorClosed, 1);
+  });
+
+  it("closes the orchestrator when streaming iteration fails", async () => {
+    let streamClosed = 0;
+    let orchestratorClosed = 0;
+    const stream = {
+      close: () => {
+        streamClosed += 1;
+      },
+      async *[Symbol.asyncIterator]() {
+        yield Buffer.from("chunk-1");
+        throw new Error("stream chunk timeout");
+      },
+    };
+    const kit = new RemoteControlCaseKit(
+      {
+        endpoint: "http://127.0.0.1:50051",
+        tenant: "tenant-a",
+        connectTimeoutMs: 5000,
+        signatureBase64: "sig",
+      },
+      () => ({
+        ...makeOrchestrator(),
+        callMcpToolStream: () => stream,
+        close: () => {
+          orchestratorClosed += 1;
+        },
+      }),
+    );
+
+    const handle = kit.handleToolCallStream("call_remote_tool_stream", {
+      node_id: "node-a",
+      tool_name: "tool-a",
+    });
+
+    assert.ok(handle);
+    const chunks = [];
+    await assert.rejects(async () => {
+      for await (const chunk of handle.stream) {
+        chunks.push(Buffer.from(chunk).toString("utf8"));
+      }
+    }, /stream chunk timeout/);
+
+    assert.deepEqual(chunks, ["chunk-1"]);
+    assert.equal(streamClosed, 1);
+    assert.equal(orchestratorClosed, 1);
+  });
+
+  it("passes timeout_ms through to the orchestrator", () => {
+    let capturedOptions = null;
+    const kit = new RemoteControlCaseKit(
+      {
+        endpoint: "http://127.0.0.1:50051",
+        tenant: "tenant-a",
+        connectTimeoutMs: 5000,
+        signatureBase64: "sig",
+      },
+      () => ({
+        ...makeOrchestrator(),
+        callMcpToolStream: (_toolName, _nodeId, _args, opts) => {
+          capturedOptions = opts;
+          return {
+            close: () => {},
+            async *[Symbol.asyncIterator]() {},
+          };
+        },
+        close: () => {},
+      }),
+    );
+
+    const handle = kit.handleToolCallStream("call_remote_tool_stream", {
+      node_id: "node-a",
+      tool_name: "tool-a",
+      timeout_ms: 42000,
+    });
+    assert.ok(handle);
+    handle.close();
+    assert.ok(capturedOptions);
+    assert.equal(capturedOptions.timeoutMs, 42000);
+  });
+
+  it("returns null for unknown tool in handleToolCallStream", () => {
+    const kit = new RemoteControlCaseKit(
+      {
+        endpoint: "http://127.0.0.1:50051",
+        tenant: "tenant-a",
+        connectTimeoutMs: 5000,
+        signatureBase64: "sig",
+      },
+      () => makeOrchestrator(),
+    );
+
+    const handle = kit.handleToolCallStream("nonexistent_tool", {
+      node_id: "node-a",
+      tool_name: "tool-a",
+    });
+    assert.equal(handle, null);
+  });
+
+  it("buffers call_remote_tool_stream via unary handleToolCall", async () => {
+    const kit = new RemoteControlCaseKit(
+      {
+        endpoint: "http://127.0.0.1:50051",
+        tenant: "tenant-a",
+        connectTimeoutMs: 5000,
+        signatureBase64: "sig",
+      },
+      () => makeOrchestrator(),
+    );
+
+    const result = await kit.handleToolCall("call_remote_tool_stream", {
+      node_id: "node-a",
+      tool_name: "tool-a",
+    });
+    assert.equal(result.isError, false);
+    assert.equal(result.payload.ok, true);
+    assert.equal(result.payload.chunk_count, 1);
+    assert.deepEqual(result.payload.chunks, ["chunk"]);
+  });
+
+  it("keeps unary and buffered-stream payload shapes distinct", async () => {
+    const kit = new RemoteControlCaseKit(
+      {
+        endpoint: "http://127.0.0.1:50051",
+        tenant: "tenant-a",
+        connectTimeoutMs: 5000,
+        signatureBase64: "sig",
+      },
+      () => makeOrchestrator(),
+    );
+
+    const unaryResult = await kit.handleToolCall("call_remote_tool", {
+      node_id: "node-a",
+      tool_name: "tool-a",
+    });
+    const bufferedStreamResult = await kit.handleToolCall("call_remote_tool_stream", {
+      node_id: "node-a",
+      tool_name: "tool-a",
+    });
+
+    assert.equal(unaryResult.isError, false);
+    assert.equal(unaryResult.payload.ok, true);
+    assert.ok("call" in unaryResult.payload);
+    assert.equal("chunks" in unaryResult.payload, false);
+
+    assert.equal(bufferedStreamResult.isError, false);
+    assert.equal(bufferedStreamResult.payload.ok, true);
+    assert.equal(bufferedStreamResult.payload.chunk_count, 1);
+    assert.deepEqual(bufferedStreamResult.payload.chunks, ["chunk"]);
+    assert.equal("call" in bufferedStreamResult.payload, false);
+  });
+
+  it("returns an error payload when unary stream buffering cannot open the stream", async () => {
+    const kit = new RemoteControlCaseKit(
+      {
+        endpoint: "http://127.0.0.1:50051",
+        tenant: "tenant-a",
+        connectTimeoutMs: 5000,
+        signatureBase64: "sig",
+      },
+      () => ({
+        ...makeOrchestrator(),
+        callMcpToolStream: () => {
+          throw new Error("stream open failed");
+        },
+        close: () => {},
+      }),
+    );
+
+    const result = await kit.handleToolCall("call_remote_tool_stream", {
+      node_id: "node-a",
+      tool_name: "tool-a",
+    });
+
+    assert.equal(result.isError, true);
+    assert.equal(result.payload.ok, false);
+    assert.match(String(result.payload.error), /stream open failed/);
+  });
+
+  it("consumeStream enforces 64 MiB buffer limit", async () => {
+    // Each chunk is 1 MiB; yield 65 chunks to exceed the 64 MiB limit.
+    const oneMiB = Buffer.alloc(1024 * 1024, 0x41); // 'A'
+    let closeCalled = 0;
+    const handle = {
+      close: () => {
+        closeCalled += 1;
+      },
+      stream: {
+        async *[Symbol.asyncIterator]() {
+          for (let i = 0; i < 65; i++) {
+            yield oneMiB;
+          }
+        },
+      },
+    };
+
+    const result = await consumeStream(handle);
+
+    assert.equal(result.isError, true);
+    assert.equal(result.payload.ok, false);
+    assert.match(String(result.payload.error), /64 MiB/);
+    assert.equal(closeCalled, 1);
+  });
+
+  it("consumeStream detects lossy UTF-8 in binary chunks", async () => {
+    let closeCalled = 0;
+    const handle = {
+      close: () => {
+        closeCalled += 1;
+      },
+      stream: {
+        async *[Symbol.asyncIterator]() {
+          yield Buffer.from([0xff, 0xfe, 0x41]);
+        },
+      },
+    };
+
+    const result = await consumeStream(handle);
+
+    assert.equal(result.isError, false);
+    assert.equal(result.payload.ok, true);
+    assert.equal(result.payload.contains_invalid_utf8, true);
+    assert.equal(closeCalled, 1);
+  });
+
+  it("StdioMcpServer tries stream handler before unary", async () => {
+    const { StdioMcpServer } = await import("../../mcp/server.js");
+
+    let streamCalled = false;
+    let unaryCalled = false;
+
+    const provider = {
+      toolSpecs() {
+        return [
+          {
+            name: "my_tool",
+            description: "A test tool",
+            inputSchema: { type: "object", properties: {} },
+          },
+        ];
+      },
+      handleToolCall(_name, _args) {
+        unaryCalled = true;
+        return { payload: { ok: true, source: "unary" }, isError: false };
+      },
+      handleToolCallStream(_name, _args) {
+        streamCalled = true;
+        return {
+          stream: {
+            async *[Symbol.asyncIterator]() {
+              yield Buffer.from("stream-chunk-1");
+              yield Buffer.from("stream-chunk-2");
+            },
+          },
+          close() {},
+        };
+      },
+    };
+
+    const server = new StdioMcpServer(provider);
+    const request = JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: { name: "my_tool", arguments: { foo: "bar" } },
+    });
+
+    const response = await server.handleRawLine(request);
+
+    assert.equal(streamCalled, true, "handleToolCallStream should have been called");
+    assert.equal(unaryCalled, false, "handleToolCall should NOT have been called");
+
+    // The server buffers the stream into a JSON-RPC success response
+    assert.equal(response.jsonrpc, "2.0");
+    assert.equal(response.id, 1);
+    assert.ok(response.result);
+    assert.ok(response.result.content);
+    const text = response.result.content[0].text;
+    const payload = JSON.parse(text);
+    assert.equal(payload.ok, true);
+    assert.equal(payload.chunk_count, 2);
+    assert.deepEqual(payload.chunks, ["stream-chunk-1", "stream-chunk-2"]);
+  });
+
+  it("uses default timeout when timeout_ms is missing", () => {
+    let capturedOptions = null;
+    const kit = new RemoteControlCaseKit(
+      {
+        endpoint: "http://127.0.0.1:50051",
+        tenant: "tenant-a",
+        connectTimeoutMs: 5000,
+        signatureBase64: "sig",
+      },
+      () => ({
+        ...makeOrchestrator(),
+        callMcpToolStream: (_toolName, _nodeId, _args, opts) => {
+          capturedOptions = opts;
+          return {
+            close: () => {},
+            async *[Symbol.asyncIterator]() {},
+          };
+        },
+        close: () => {},
+      }),
+    );
+
+    const handle = kit.handleToolCallStream("call_remote_tool_stream", {
+      node_id: "node-a",
+      tool_name: "tool-a",
+    });
+    assert.ok(handle);
+    handle.close();
+    assert.ok(capturedOptions);
+    assert.equal(capturedOptions.timeoutMs, DEFAULT_MCP_TOOL_STREAM_TIMEOUT_MS);
+  });
 });

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

@@ -1,3 +1,4 @@
+import { DendriteServerStream } from "../../dendrite_bridge.js";
 import type { JsonRecord, AbilityPackageDescriptor } from "./descriptor.js";
 export type { JsonRecord };
 export type OrchestratorFactory = (config: {
@@ -10,6 +11,10 @@ export interface RemoteOrchestrator {
     listNodes(ownerId?: string): JsonRecord[];
     listMcpTools(namePattern?: string, tags?: string[], nodeId?: string): JsonRecord[];
     callMcpTool(toolName: string, targetNodeId: string, argumentsJson: JsonRecord): JsonRecord;
+    /** Call an MCP tool on a remote node and return a stream of incremental response chunks. */
+    callMcpToolStream(toolName: string, targetNodeId: string, argumentsJson: JsonRecord, options?: {
+        timeoutMs?: number;
+    }): DendriteServerStream;
     disconnectDevice(nodeId: string, reason: string): JsonRecord;
     uninstallAbility(nodeId: string, installId: string, reason: string): JsonRecord;
     deployAbilityPackage(descriptor: AbilityPackageDescriptor, nodeId: string, cleanupOnActivateFailure: boolean): JsonRecord;

package/src/presets/remote_control/orchestrator.js

@@ -1,4 +1,4 @@
-import { DendriteBridge } from "../../dendrite_bridge.js";
+import { DendriteBridge, } from "../../dendrite_bridge.js";
 import { DEFAULT_EXECUTION_MODE, DEFAULT_INSTALL_TIMEOUT_SECONDS } from "./config.js";
 export function buildOrchestrator(config, tenant) {
     return new OrchestratorAdapter(config, tenant);
@@ -26,6 +26,14 @@ class OrchestratorAdapter {
         const options = { targetNodeId, argumentsJson };
         return this.bridge.callMcpTool(this.tenant, toolName, options);
     }
+    callMcpToolStream(toolName, targetNodeId, argumentsJson = {}, options = {}) {
+        const streamOptions = {
+            targetNodeId,
+            argumentsJson,
+            timeoutMs: options.timeoutMs,
+        };
+        return this.bridge.callMcpToolStream(this.tenant, toolName, streamOptions);
+    }
     disconnectDevice(nodeId, reason) {
         return this.bridge.deregisterNode(this.tenant, nodeId, reason);
     }