@net-mesh/core 0.24.0 → 0.25.0

package/mesh_rpc.d.ts

@@ -72,6 +72,13 @@ export interface RawMeshRpc {
     call(targetNodeId: bigint, service: string, request: Buffer, opts?: CallOptions): Promise<Buffer>;
     callService(service: string, request: Buffer, opts?: CallOptions): Promise<Buffer>;
     callStreaming(targetNodeId: bigint, service: string, request: Buffer, opts?: CallOptions): Promise<RawRpcStream>;
+    /**
+     * Capability-routed streaming. Optional in the interface for
+     * backwards-compat with hand-rolled `RawMeshRpc` test stubs that
+     * predate the streaming-caller addition; required on real napi-
+     * backed bindings.
+     */
+    callServiceStreaming?(service: string, request: Buffer, opts?: CallOptions): Promise<RawRpcStream>;
     /**
      * Open a client-streaming call. Returns a `RawClientStreamCall`
      * — push chunks via `send`, then `finish` to await the terminal
@@ -100,6 +107,19 @@ export interface RawMeshRpc {
      * `appError(code, body)` to surface a typed Application status.
      */
     serveDuplex(service: string, handler: (args: [RawRequestStream, RawResponseSink]) => Promise<Buffer>): ServeHandle;
+    /**
+     * Register a server-streaming handler. The napi side passes a
+     * 2-tuple `[req, sink]` to the handler — the request Buffer plus
+     * a sink to push chunks into. The Promise resolving signals
+     * "handler done"; substrate emits the terminal frame at that
+     * point. Throw `appError(code, body)` to surface a typed
+     * Application status.
+     *
+     * Optional in the interface for backwards-compat with hand-rolled
+     * `RawMeshRpc` test stubs that predate the streaming-serve
+     * addition; required on real napi-backed bindings.
+     */
+    serveStreaming?(service: string, handler: (args: [Buffer, RawResponseSink]) => Promise<Buffer>): ServeHandle;
     findServiceNodes(service: string): bigint[];
     /** Mint a fresh cancel token (`bigint`). */
     reserveCancelToken(): bigint;
@@ -363,6 +383,15 @@ export declare class TypedMeshRpc {
      * yields decoded `Resp` values per `next()` until EOF.
      */
     callStreaming<Req = unknown, Resp = unknown>(targetNodeId: bigint, service: string, req: Req, opts?: CallOptions): Promise<TypedRpcStream<Resp>>;
+    /**
+     * Capability-routed typed streaming call. Mirrors `callService`
+     * for target resolution + cap-auth gate; mirrors `callStreaming`
+     * for the chunk-iterator return shape.
+     *
+     * Use this for streaming tool invocations: `callToolStreaming`
+     * builds on top.
+     */
+    callServiceStreaming<Req = unknown, Resp = unknown>(service: string, req: Req, opts?: CallOptions): Promise<TypedRpcStream<Resp>>;
     /** Pass-through to `MeshRpc.findServiceNodes`. */
     findServiceNodes(service: string): bigint[];
     /**
@@ -419,6 +448,18 @@ export declare class TypedMeshRpc {
      * terminal frame automatically. To surface a typed Application
      * status, throw `appError(code, body)` from the handler.
      */
+    /**
+     * Register a typed server-streaming handler. The user signature
+     * is `(req: Req, sink: TypedResponseSink<Resp>) => Promise<void>`
+     * — the wrapper decodes the request, calls the handler, and
+     * resolves to a sentinel Buffer the substrate discards. To
+     * surface a typed Application status, throw `appError(code,
+     * body)` from the handler.
+     *
+     * Used by `serveToolStreaming` in tool.ts to expose ToolEvent-
+     * emitting handlers.
+     */
+    serveStreaming<Req = unknown, Resp = unknown>(service: string, handler: (req: Req, sink: TypedResponseSink<Resp>) => Promise<void>): ServeHandle;
     serveDuplex<Req = unknown, Resp = unknown>(service: string, handler: (stream: TypedRequestStream<Req>, sink: TypedResponseSink<Resp>) => Promise<void>): ServeHandle;
     /**
      * Install (pass a handler) or clear (pass `null`) the caller-side

package/mesh_rpc.js

@@ -186,6 +186,24 @@ class TypedMeshRpc {
         const inner = await this._raw.callStreaming(targetNodeId, service, reqBuf, opts);
         return new TypedRpcStream(inner);
     }
+    /**
+     * Capability-routed typed streaming call. Mirrors `callService`
+     * for target resolution + cap-auth gate; mirrors `callStreaming`
+     * for the chunk-iterator return shape.
+     *
+     * Use this for streaming tool invocations: `callToolStreaming`
+     * builds on top.
+     */
+    async callServiceStreaming(service, req, opts) {
+        if (this._raw.callServiceStreaming === undefined) {
+            throw new Error('TypedMeshRpc.callServiceStreaming: the underlying raw binding ' +
+                "does not expose `callServiceStreaming`. Rebuild the native " +
+                'addon against a version that supports streaming tool calls.');
+        }
+        const reqBuf = jsonEncode(req);
+        const inner = await this._raw.callServiceStreaming(service, reqBuf, opts);
+        return new TypedRpcStream(inner);
+    }
     /** Pass-through to `MeshRpc.findServiceNodes`. */
     findServiceNodes(service) {
         return this._raw.findServiceNodes(service);
@@ -272,6 +290,30 @@ class TypedMeshRpc {
      * terminal frame automatically. To surface a typed Application
      * status, throw `appError(code, body)` from the handler.
      */
+    /**
+     * Register a typed server-streaming handler. The user signature
+     * is `(req: Req, sink: TypedResponseSink<Resp>) => Promise<void>`
+     * — the wrapper decodes the request, calls the handler, and
+     * resolves to a sentinel Buffer the substrate discards. To
+     * surface a typed Application status, throw `appError(code,
+     * body)` from the handler.
+     *
+     * Used by `serveToolStreaming` in tool.ts to expose ToolEvent-
+     * emitting handlers.
+     */
+    serveStreaming(service, handler) {
+        if (this._raw.serveStreaming === undefined) {
+            throw new Error('TypedMeshRpc.serveStreaming: the underlying raw binding ' +
+                "does not expose `serveStreaming`. Rebuild the native " +
+                'addon against a version that supports streaming-serve.');
+        }
+        return this._raw.serveStreaming(service, async ([rawReq, rawSink]) => {
+            const req = jsonDecode(rawReq);
+            const typedSink = new TypedResponseSink(rawSink);
+            await handler(req, typedSink);
+            return DUPLEX_TERMINAL_SENTINEL;
+        });
+    }
     serveDuplex(service, handler) {
         return this._raw.serveDuplex(service, async ([rawStream, rawSink]) => {
             const typedStream = new TypedRequestStream(rawStream);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@net-mesh/core",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "High-performance, schema-agnostic event bus for AI runtime workloads",
   "main": "index.js",
   "types": "index.d.ts",
@@ -24,6 +24,10 @@
     "./aggregator": {
       "types": "./aggregator.d.ts",
       "default": "./aggregator.js"
+    },
+    "./tool": {
+      "types": "./tool.d.ts",
+      "default": "./tool.js"
     }
   },
   "napi": {
@@ -64,6 +68,8 @@
     "meshdb.d.ts",
     "aggregator.js",
     "aggregator.d.ts",
+    "tool.js",
+    "tool.d.ts",
     "*.node"
   ],
   "devDependencies": {
@@ -91,13 +97,13 @@
     "node": ">=20"
   },
   "optionalDependencies": {
-    "@net-mesh/core-win32-x64-msvc": "0.24.0",
-    "@net-mesh/core-win32-arm64-msvc": "0.24.0",
-    "@net-mesh/core-darwin-x64": "0.24.0",
-    "@net-mesh/core-darwin-arm64": "0.24.0",
-    "@net-mesh/core-linux-x64-gnu": "0.24.0",
-    "@net-mesh/core-linux-x64-musl": "0.24.0",
-    "@net-mesh/core-linux-arm64-gnu": "0.24.0",
-    "@net-mesh/core-linux-arm64-musl": "0.24.0"
+    "@net-mesh/core-win32-x64-msvc": "0.25.0",
+    "@net-mesh/core-win32-arm64-msvc": "0.25.0",
+    "@net-mesh/core-darwin-x64": "0.25.0",
+    "@net-mesh/core-darwin-arm64": "0.25.0",
+    "@net-mesh/core-linux-x64-gnu": "0.25.0",
+    "@net-mesh/core-linux-x64-musl": "0.25.0",
+    "@net-mesh/core-linux-arm64-gnu": "0.25.0",
+    "@net-mesh/core-linux-arm64-musl": "0.25.0"
   }
 }