@easynet-run/node 0.27.14 → 0.39.29

package/src/presets/remote_control/kit.js

@@ -1,8 +1,71 @@
+// EasyNet Axon for AgentNet
+// =========================
+//
+// File: sdk/node/src/presets/remote_control/kit.ts
+// Description: Node `RemoteControlCaseKit` MCP provider that wires handlers, tool specs, and managed tool streams.
+//
+// Protocol Responsibility:
+// - Assembles remote-control tool specs, handler dispatch, and orchestrator lifecycle into one MCP provider surface.
+// - Owns bridge or orchestrator cleanup for unary and streaming tool calls so callers do not leak resources.
+//
+// Implementation Approach:
+// - Keeps entrypoints thin by delegating validation and business logic to focused handler/orchestrator modules.
+// - Caches or scopes transport resources according to the SDK runtime model while preserving per-tenant correctness.
+//
+// Usage Contract:
+// - Use this as the preset-level integration point when exposing EasyNet remote-control tools over MCP.
+// - Factory injection points should preserve the same request/response semantics as the default orchestrator.
+//
+// Architectural Position:
+// - Preset composition boundary above handler modules and below case/example entrypoints.
+//
+// Author: Silan.Hu
+// Email: silan.hu@u.nus.edu
+// Copyright (c) 2026-2027 easynet. All rights reserved.
+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, handleCreateAbility, handleDeployAbility, handleDeployAbilityPackage, handleDiscoverNodes, handleDisconnectDevice, handleDrainDevice, handleExecuteCommand, handleExportAbilitySkill, handleForgetAll, handleListAbilities, handleListRemoteTools, handlePackageAbility, handleUninstallAbility, handleRedeployAbility, } 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 +89,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":
@@ -49,6 +142,18 @@ export class RemoteControlCaseKit {
                 return this.toolResultWithPayload(handleDeployAbility(orchestrator, tenant, args, this.config.signatureBase64));
             case "execute_command":
                 return this.toolResultWithPayload(handleExecuteCommand(orchestrator, tenant, args, this.config.signatureBase64));
+            case "drain_device":
+                return this.toolResultWithPayload(handleDrainDevice(orchestrator, tenant, args));
+            case "build_ability_descriptor":
+                return this.toolResultWithPayload(handleCreateAbility(args));
+            case "export_ability_skill":
+                return this.toolResultWithPayload(handleExportAbilitySkill(args));
+            case "redeploy_ability":
+                return this.toolResultWithPayload(handleRedeployAbility(orchestrator, tenant, args, this.config.signatureBase64));
+            case "list_abilities":
+                return this.toolResultWithPayload(handleListAbilities(orchestrator, tenant, args));
+            case "forget_all":
+                return this.toolResultWithPayload(handleForgetAll(orchestrator, tenant, args));
             default:
                 return this.toolResult(true, { ok: false, tenant_id: tenant, error: `unknown tool: ${name}` });
         }