@easynet-run/node 0.27.14

package/src/dendrite_bridge/bridge.js

@@ -0,0 +1,712 @@
+// EasyNet Axon for AgentNet
+// =========================
+//
+// File: sdk/node/src/dendrite_bridge/bridge.ts
+// Description: DendriteBridge class implementation; provides the high-level API surface for interacting with the native dendrite bridge over FFI/JSON.
+//
+// Protocol Responsibility:
+// - Implements the DendriteBridge class with all RPC, capability, voice, and transport methods.
+// - Preserves stable request/response semantics and error mapping.
+//
+// Implementation Approach:
+// - Delegates FFI calls to the ffi submodule.
+// - Delegates validation/payload building to capability_request helpers.
+//
+// Usage Contract:
+// - Callers construct a DendriteBridge with endpoint options and invoke methods for each protocol surface.
+// - Errors are surfaced as DendriteError instances.
+//
+// Architectural Position:
+// - Part of the Node SDK dendrite_bridge submodule layer.
+// - Should not embed FFI loading or type declarations outside this class's responsibility.
+//
+// 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";
+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 {
+    lib;
+    handle;
+    constructor(options) {
+        const libraryPath = resolveLibraryPath(options.libraryPath);
+        this.lib = loadDendriteLib(libraryPath);
+        const payload = JSON.stringify({
+            endpoint: options.endpoint,
+            connect_timeout_ms: options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS,
+        });
+        const resp = callJson(this.lib.axon_dendrite_client_open_json, payload);
+        const handleRaw = resp.handle;
+        if (typeof handleRaw !== "number" && typeof handleRaw !== "string") {
+            throw new DendriteError(`invalid dendrite handle payload: ${JSON.stringify(resp)}`);
+        }
+        this.handle = BigInt(handleRaw);
+        if (this.handle <= 0n) {
+            throw new DendriteError(`invalid dendrite handle: ${this.handle.toString()}`);
+        }
+    }
+    close() {
+        if (this.handle <= 0n)
+            return;
+        callJson(this.lib.axon_dendrite_client_close_json, this.handle);
+        this.handle = 0n;
+    }
+    protocolCoverage() {
+        return callJson(this.lib.axon_dendrite_protocol_coverage_json);
+    }
+    protocolCatalog() {
+        return callJson(this.lib.axon_dendrite_protocol_catalog_json);
+    }
+    invokeProtocol(options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const payload = {
+            service: options.service,
+            rpc: options.rpc,
+            path: options.path,
+            metadata: options.metadata ?? {},
+            timeout_ms: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            max_chunks: options.maxChunks ?? 4096,
+            max_request_chunks: options.maxRequestChunks ?? 4096,
+            max_response_chunks: options.maxResponseChunks ?? 4096,
+        };
+        if (options.requestChunks !== undefined) {
+            payload.request_chunks_base64 = options.requestChunks.map((v) => Buffer.from(v).toString("base64"));
+        }
+        else if (options.requestBytes !== undefined) {
+            payload.request_base64 = Buffer.from(options.requestBytes).toString("base64");
+        }
+        const req = JSON.stringify(payload);
+        return callJson(this.lib.axon_dendrite_invoke_protocol_json, this.handle, req);
+    }
+    unaryCall(path, requestBytes, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const payload = JSON.stringify({
+            path,
+            request_base64: Buffer.from(requestBytes).toString("base64"),
+            metadata: options.metadata ?? {},
+            timeout_ms: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        });
+        const resp = callJson(this.lib.axon_dendrite_unary_call_json, this.handle, payload);
+        const b64 = String(resp.response_base64 ?? "");
+        if (!b64) {
+            throw new DendriteError(`missing unary response payload: ${JSON.stringify(resp)}`);
+        }
+        return Buffer.from(b64, "base64");
+    }
+    serverStreamCall(path, requestBytes, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const payload = JSON.stringify({
+            path,
+            request_base64: Buffer.from(requestBytes).toString("base64"),
+            metadata: options.metadata ?? {},
+            timeout_ms: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            max_chunks: options.maxChunks ?? 4096,
+        });
+        const resp = callJson(this.lib.axon_dendrite_server_stream_call_json, this.handle, payload);
+        const chunksRaw = Array.isArray(resp.chunks_base64) ? resp.chunks_base64 : [];
+        const chunks = chunksRaw.map((v) => Buffer.from(String(v), "base64"));
+        const truncated = Boolean(resp.truncated ?? false);
+        return { chunks, truncated };
+    }
+    clientStreamCall(path, requestChunks, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const payload = JSON.stringify({
+            path,
+            request_chunks_base64: requestChunks.map((v) => Buffer.from(v).toString("base64")),
+            metadata: options.metadata ?? {},
+            timeout_ms: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            max_request_chunks: options.maxRequestChunks ?? 4096,
+        });
+        const resp = callJson(this.lib.axon_dendrite_client_stream_call_json, this.handle, payload);
+        const b64 = String(resp.response_base64 ?? "");
+        if (!b64) {
+            throw new DendriteError(`missing client-stream response payload: ${JSON.stringify(resp)}`);
+        }
+        return Buffer.from(b64, "base64");
+    }
+    bidiStreamCall(path, requestChunks, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const payload = JSON.stringify({
+            path,
+            request_chunks_base64: requestChunks.map((v) => Buffer.from(v).toString("base64")),
+            metadata: options.metadata ?? {},
+            timeout_ms: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            max_request_chunks: options.maxRequestChunks ?? 4096,
+            max_response_chunks: options.maxResponseChunks ?? 4096,
+        });
+        const resp = callJson(this.lib.axon_dendrite_bidi_stream_call_json, this.handle, payload);
+        const chunksRaw = Array.isArray(resp.chunks_base64) ? resp.chunks_base64 : [];
+        const chunks = chunksRaw.map((v) => Buffer.from(String(v), "base64"));
+        const truncated = Boolean(resp.truncated ?? false);
+        return { chunks, truncated };
+    }
+    abilityCall(tenantId, resourceUri, payload, options = {}) {
+        return this.abilityCallRaw(tenantId, resourceUri, payload, options);
+    }
+    abilityCallRaw(tenantId, resourceUri, payload, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            resource_uri: resourceUri,
+            payload_json: payload,
+            subject_id: options.subjectId,
+            timeout_ms: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            metadata: options.metadata ?? {},
+        });
+        const resp = callJson(this.lib.axon_dendrite_invoke_ability_json, this.handle, req);
+        const out = {};
+        for (const [k, v] of Object.entries(resp)) {
+            if (k === "ok")
+                continue;
+            out[k] = v;
+        }
+        return out;
+    }
+    listNodes(tenantId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            owner_id: options.ownerId ?? "",
+        });
+        const resp = callJson(this.lib.axon_dendrite_list_nodes_json, this.handle, req);
+        return Array.isArray(resp.nodes) ? resp.nodes : [];
+    }
+    registerNode(tenantId, nodeId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            node_id: nodeId,
+            display_name: options.displayName,
+        });
+        return callJson(this.lib.axon_dendrite_register_node_json, this.handle, req);
+    }
+    deregisterNode(tenantId, nodeId, reason = "") {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        if (!this.lib.axon_dendrite_deregister_node_json) {
+            throw new DendriteError("dendrite bridge symbol not available: axon_dendrite_deregister_node_json");
+        }
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            node_id: nodeId,
+            reason,
+        });
+        return callJson(this.lib.axon_dendrite_deregister_node_json, this.handle, req);
+    }
+    heartbeat(tenantId, nodeId) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            node_id: nodeId,
+        });
+        return callJson(this.lib.axon_dendrite_heartbeat_json, this.handle, req);
+    }
+    publishCapability(tenantId, packageId, capabilityName, options) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        validatePublishCapabilityRequest(tenantId, packageId, capabilityName, options);
+        const payload = buildPublishCapabilityPayload(tenantId, packageId, capabilityName, options);
+        const req = JSON.stringify(payload);
+        return callJson(this.lib.axon_dendrite_publish_capability_json, this.handle, req);
+    }
+    installCapability(tenantId, nodeId, packageId, options) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        validateInstallCapabilityRequest(tenantId, nodeId, packageId, options);
+        const payload = buildInstallCapabilityPayload(tenantId, nodeId, packageId, options);
+        const req = JSON.stringify(payload);
+        return callJson(this.lib.axon_dendrite_install_capability_json, this.handle, req);
+    }
+    activateCapability(tenantId, nodeId, installId) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            node_id: nodeId,
+            install_id: installId,
+        });
+        return callJson(this.lib.axon_dendrite_activate_capability_json, this.handle, req);
+    }
+    listA2aAgents(tenantId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            tags: options.tags ?? [],
+            owner_id: options.ownerId ?? "",
+            limit: options.limit ?? 100,
+        });
+        const resp = callJson(this.lib.axon_dendrite_list_a2a_agents_json, this.handle, req);
+        return Array.isArray(resp.agents) ? resp.agents : [];
+    }
+    getA2aAgentCard(tenantId, nodeId) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            node_id: nodeId,
+        });
+        return callJson(this.lib.axon_dendrite_get_a2a_agent_card_json, this.handle, req);
+    }
+    sendA2aTask(tenantId, targetAgentId, skillId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            target_agent_id: targetAgentId,
+            skill_id: skillId,
+            input_json: options.inputJson ?? {},
+            input_base64: options.inputBase64,
+            task_id: options.taskId,
+            idempotency_key: options.idempotencyKey,
+        });
+        return callJson(this.lib.axon_dendrite_send_a2a_task_json, this.handle, req);
+    }
+    deployMcpListDir(tenantId, nodeId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        validateDeployMcpListDirRequest(tenantId, nodeId, options);
+        const payload = buildDeployMcpListDirPayload(tenantId, nodeId, options);
+        const req = JSON.stringify(payload);
+        return callJson(this.lib.axon_dendrite_deploy_mcp_list_dir_json, this.handle, req);
+    }
+    listMcpTools(tenantId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            name_pattern: options.namePattern ?? "",
+            tags: options.tags ?? [],
+            node_id: options.nodeId ?? "",
+        });
+        const resp = callJson(this.lib.axon_dendrite_list_mcp_tools_json, this.handle, req);
+        return Array.isArray(resp.tools) ? resp.tools : [];
+    }
+    callMcpTool(tenantId, toolName, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            tool_name: toolName,
+            target_node_id: options.targetNodeId ?? "",
+            arguments_json: options.argumentsJson ?? {},
+            arguments_base64: options.argumentsBase64,
+        });
+        return callJson(this.lib.axon_dendrite_call_mcp_tool_json, this.handle, req);
+    }
+    uninstallCapability(tenantId, nodeId, installId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const payload = buildUninstallCapabilityPayload(tenantId, nodeId, installId, options);
+        const req = JSON.stringify(payload);
+        return callJson(this.lib.axon_dendrite_uninstall_capability_json, this.handle, req);
+    }
+    updateMcpListDir(tenantId, nodeId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        validateUpdateMcpListDirRequest(tenantId, nodeId, options);
+        const payload = buildUpdateMcpListDirPayload(tenantId, nodeId, options);
+        const req = JSON.stringify(payload);
+        return callJson(this.lib.axon_dendrite_update_mcp_list_dir_json, this.handle, req);
+    }
+    createVoiceCall(tenantId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: options.callId,
+            display_name: options.displayName,
+            participant_limit: options.participantLimit,
+            preferred_codec: options.preferredCodec
+                ? {
+                    codec: options.preferredCodec.codec,
+                    sample_rate_hz: options.preferredCodec.sampleRateHz,
+                    channels: options.preferredCodec.channels,
+                    ptime_ms: options.preferredCodec.ptimeMs,
+                    max_bitrate_kbps: options.preferredCodec.maxBitrateKbps,
+                    fec_enabled: options.preferredCodec.fecEnabled,
+                    dtx_enabled: options.preferredCodec.dtxEnabled,
+                }
+                : undefined,
+            metadata: options.metadata ?? {},
+        });
+        return callJson(this.lib.axon_dendrite_voice_create_call_json, this.handle, req);
+    }
+    getVoiceCall(tenantId, callId) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+        });
+        return callJson(this.lib.axon_dendrite_voice_get_call_json, this.handle, req);
+    }
+    joinVoiceCall(tenantId, callId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            participant_id: options.participantId,
+            node_id: options.nodeId,
+            transport: options.transport,
+            stream_session_id: options.streamSessionId,
+            codec_profile: options.codecProfile
+                ? {
+                    codec: options.codecProfile.codec,
+                    sample_rate_hz: options.codecProfile.sampleRateHz,
+                    channels: options.codecProfile.channels,
+                    ptime_ms: options.codecProfile.ptimeMs,
+                    max_bitrate_kbps: options.codecProfile.maxBitrateKbps,
+                    fec_enabled: options.codecProfile.fecEnabled,
+                    dtx_enabled: options.codecProfile.dtxEnabled,
+                }
+                : undefined,
+            muted: options.muted ?? false,
+        });
+        return callJson(this.lib.axon_dendrite_voice_join_call_json, this.handle, req);
+    }
+    leaveVoiceCall(tenantId, callId, participantId, reason) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            participant_id: participantId,
+            reason,
+        });
+        return callJson(this.lib.axon_dendrite_voice_leave_call_json, this.handle, req);
+    }
+    updateVoiceMediaPath(tenantId, callId, participantId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            participant_id: participantId,
+            transport: options.transport,
+            stream_session_id: options.streamSessionId,
+            muted: options.muted ?? false,
+        });
+        return callJson(this.lib.axon_dendrite_voice_update_media_path_json, this.handle, req);
+    }
+    reportVoiceCallMetrics(tenantId, callId, participantId, metrics = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            participant_id: participantId,
+            metrics: {
+                rtt_ms: metrics.rttMs,
+                jitter_ms: metrics.jitterMs,
+                packet_loss_ratio: metrics.packetLossRatio,
+                concealed_samples: metrics.concealedSamples,
+                audio_level_dbov: metrics.audioLevelDbov,
+            },
+        });
+        return callJson(this.lib.axon_dendrite_voice_report_call_metrics_json, this.handle, req);
+    }
+    endVoiceCall(tenantId, callId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            end_reason: options.endReason,
+            detail: options.detail,
+        });
+        return callJson(this.lib.axon_dendrite_voice_end_call_json, this.handle, req);
+    }
+    watchVoiceCallEvents(tenantId, callId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            from_sequence: options.fromSequence ?? 0,
+            max_events: options.maxEvents ?? 256,
+            timeout_ms: options.timeoutMs ?? 1500,
+        });
+        return callJson(this.lib.axon_dendrite_voice_watch_call_events_json, this.handle, req);
+    }
+    createVoiceTransportSession(tenantId, callId, participantId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            participant_id: participantId,
+            transport_session_id: options.transportSessionId,
+            transport: options.transport,
+            local_description: options.localDescription
+                ? {
+                    sdp_type: options.localDescription.sdpType,
+                    sdp: options.localDescription.sdp,
+                    updated_at_unix_ms: options.localDescription.updatedAtUnixMs,
+                    revision_id: options.localDescription.revisionId,
+                }
+                : undefined,
+            requested_ttl_seconds: options.requestedTtlSeconds,
+            metadata: options.metadata ?? {},
+        });
+        return callJson(this.lib.axon_dendrite_voice_create_transport_session_json, this.handle, req);
+    }
+    getVoiceTransportSession(tenantId, callId, transportSessionId) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            transport_session_id: transportSessionId,
+        });
+        return callJson(this.lib.axon_dendrite_voice_get_transport_session_json, this.handle, req);
+    }
+    setVoiceTransportDescription(tenantId, callId, transportSessionId, side, description) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            transport_session_id: transportSessionId,
+            side,
+            description: {
+                sdp_type: description.sdpType,
+                sdp: description.sdp,
+                updated_at_unix_ms: description.updatedAtUnixMs,
+                revision_id: description.revisionId,
+            },
+        });
+        return callJson(this.lib.axon_dendrite_voice_set_transport_description_json, this.handle, req);
+    }
+    addVoiceTransportCandidate(tenantId, callId, transportSessionId, side, candidate) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            transport_session_id: transportSessionId,
+            side,
+            candidate: {
+                candidate: candidate.candidate,
+                sdp_mid: candidate.sdpMid,
+                sdp_mline_index: candidate.sdpMlineIndex,
+                username_fragment: candidate.usernameFragment,
+                gathered_at_unix_ms: candidate.gatheredAtUnixMs,
+            },
+        });
+        return callJson(this.lib.axon_dendrite_voice_add_transport_candidate_json, this.handle, req);
+    }
+    refreshVoiceTransportLease(tenantId, callId, transportSessionId, requestedTtlSeconds = 0) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            transport_session_id: transportSessionId,
+            requested_ttl_seconds: requestedTtlSeconds,
+        });
+        return callJson(this.lib.axon_dendrite_voice_refresh_transport_lease_json, this.handle, req);
+    }
+    endVoiceTransportSession(tenantId, callId, transportSessionId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            transport_session_id: transportSessionId,
+            failed: options.failed ?? false,
+            reason: options.reason,
+        });
+        return callJson(this.lib.axon_dendrite_voice_end_transport_session_json, this.handle, req);
+    }
+    watchVoiceTransportEvents(tenantId, callId, transportSessionId, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const req = JSON.stringify({
+            tenant_id: tenantId,
+            call_id: callId,
+            transport_session_id: transportSessionId,
+            from_sequence: options.fromSequence ?? 0,
+            max_events: options.maxEvents ?? 256,
+            timeout_ms: options.timeoutMs ?? 1500,
+        });
+        return callJson(this.lib.axon_dendrite_voice_watch_transport_events_json, this.handle, req);
+    }
+    // -- Incremental streaming (pull model) ---------------------------------
+    serverStreamOpen(path, requestBytes, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const streamOpen = requireBridgeFn(this.lib.axon_dendrite_server_stream_open_json, STREAMING_UNSUPPORTED);
+        requireBridgeFn(this.lib.axon_dendrite_stream_next_json, STREAMING_UNSUPPORTED);
+        const payload = {
+            path,
+            request_base64: Buffer.from(requestBytes).toString("base64"),
+            metadata: options.metadata ?? {},
+            timeout_ms: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            chunk_buffer_size: options.chunkBufferSize ?? 64,
+        };
+        if (options.chunkTimeoutMs !== undefined) {
+            payload.chunk_timeout_ms = options.chunkTimeoutMs;
+        }
+        const resp = callJson(streamOpen, this.handle, JSON.stringify(payload));
+        const streamHandle = BigInt(resp.stream_handle);
+        if (streamHandle <= 0n) {
+            throw new DendriteError(`failed to open server stream: ${JSON.stringify(resp)}`);
+        }
+        return new DendriteServerStream(this.lib, streamHandle);
+    }
+    bidiStreamOpen(path, options = {}) {
+        if (this.handle <= 0n)
+            throw new DendriteError("dendrite bridge already closed");
+        const streamOpen = requireBridgeFn(this.lib.axon_dendrite_bidi_stream_open_json, STREAMING_UNSUPPORTED);
+        requireBridgeFn(this.lib.axon_dendrite_stream_next_json, STREAMING_UNSUPPORTED);
+        requireBridgeFn(this.lib.axon_dendrite_bidi_stream_send_json, STREAMING_UNSUPPORTED);
+        const payload = {
+            path,
+            metadata: options.metadata ?? {},
+            timeout_ms: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            chunk_buffer_size: options.chunkBufferSize ?? 64,
+            request_buffer_size: options.requestBufferSize ?? 64,
+        };
+        if (options.chunkTimeoutMs !== undefined) {
+            payload.chunk_timeout_ms = options.chunkTimeoutMs;
+        }
+        if (options.requestBytes !== undefined) {
+            payload.request_base64 = Buffer.from(options.requestBytes).toString("base64");
+        }
+        if (options.requestChunks !== undefined) {
+            payload.request_chunks_base64 = options.requestChunks.map((v) => Buffer.from(v).toString("base64"));
+        }
+        const resp = callJson(streamOpen, this.handle, JSON.stringify(payload));
+        const streamHandle = BigInt(resp.stream_handle);
+        if (streamHandle <= 0n) {
+            throw new DendriteError(`failed to open bidi stream: ${JSON.stringify(resp)}`);
+        }
+        return new DendriteBidiStream(this.lib, streamHandle);
+    }
+}
+export class DendriteServerStream {
+    lib;
+    streamHandle;
+    done = false;
+    nativeClosed = false;
+    constructor(lib, streamHandle) {
+        this.lib = lib;
+        this.streamHandle = streamHandle;
+    }
+    next(timeoutMs = DEFAULT_TIMEOUT_MS) {
+        if (this.done)
+            return { chunk: null, done: true };
+        const streamNext = requireBridgeFn(this.lib.axon_dendrite_stream_next_json, STREAMING_UNSUPPORTED);
+        const resp = callJson(streamNext, this.streamHandle, JSON.stringify({ timeout_ms: timeoutMs }));
+        if (resp.done) {
+            this.done = true;
+            return { chunk: null, done: true };
+        }
+        if (resp.timeout) {
+            return { chunk: null, done: false, timeout: true };
+        }
+        const b64 = String(resp.chunk_base64 ?? "");
+        return { chunk: Buffer.from(b64, "base64"), done: false };
+    }
+    close() {
+        if (!this.nativeClosed) {
+            this.nativeClosed = true;
+            this.done = true;
+            if (this.lib.axon_dendrite_stream_close_json) {
+                callJson(this.lib.axon_dendrite_stream_close_json, this.streamHandle);
+            }
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            while (true) {
+                const { chunk, done, timeout } = this.next();
+                if (done)
+                    break;
+                if (timeout)
+                    continue;
+                if (chunk)
+                    yield chunk;
+            }
+        }
+        finally {
+            this.close();
+        }
+    }
+}
+export class DendriteBidiStream {
+    lib;
+    streamHandle;
+    done = false;
+    nativeClosed = false;
+    constructor(lib, streamHandle) {
+        this.lib = lib;
+        this.streamHandle = streamHandle;
+    }
+    send(chunk) {
+        if (this.done)
+            throw new DendriteError("bidi stream is closed");
+        const streamSend = requireBridgeFn(this.lib.axon_dendrite_bidi_stream_send_json, STREAMING_UNSUPPORTED);
+        const resp = callJson(streamSend, this.streamHandle, JSON.stringify({ chunk_base64: Buffer.from(chunk).toString("base64") }));
+        return Boolean(resp.sent);
+    }
+    finishSend() {
+        if (this.done)
+            throw new DendriteError("bidi stream is closed");
+        const streamSend = requireBridgeFn(this.lib.axon_dendrite_bidi_stream_send_json, STREAMING_UNSUPPORTED);
+        const resp = callJson(streamSend, this.streamHandle, JSON.stringify({ done: true }));
+        return Boolean(resp.request_stream_closed);
+    }
+    recv(timeoutMs = DEFAULT_TIMEOUT_MS) {
+        if (this.done)
+            return { chunk: null, done: true };
+        const streamNext = requireBridgeFn(this.lib.axon_dendrite_stream_next_json, STREAMING_UNSUPPORTED);
+        const resp = callJson(streamNext, this.streamHandle, JSON.stringify({ timeout_ms: timeoutMs }));
+        if (resp.done) {
+            this.done = true;
+            return { chunk: null, done: true };
+        }
+        if (resp.timeout) {
+            return { chunk: null, done: false, timeout: true };
+        }
+        const b64 = String(resp.chunk_base64 ?? "");
+        return { chunk: Buffer.from(b64, "base64"), done: false };
+    }
+    close() {
+        if (!this.nativeClosed) {
+            this.nativeClosed = true;
+            this.done = true;
+            if (this.lib.axon_dendrite_stream_close_json) {
+                callJson(this.lib.axon_dendrite_stream_close_json, this.streamHandle);
+            }
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            while (true) {
+                const { chunk, done, timeout } = this.recv();
+                if (done)
+                    break;
+                if (timeout)
+                    continue;
+                if (chunk)
+                    yield chunk;
+            }
+        }
+        finally {
+            this.close();
+        }
+    }
+}