feat(das-client): generate gRPC stubs from das-proto + real BusNode (ping/execute_message), in-process tested

Author: MesTTo

.prettierignore

@@ -3,3 +3,6 @@
 packages/core/src/prelude.ts
 corpus/**
 pnpm-lock.yaml
+
+packages/das-client/src/gen/
+packages/das-client/proto/

eslint.config.js

@@ -2,7 +2,7 @@ import tseslint from "typescript-eslint";
 import prettier from "eslint-config-prettier";
 
 export default tseslint.config(
-  { ignores: ["**/dist/**", "**/*.config.*", "packages/*/src/prelude.ts", "docs/**", "corpus/**"] },
+  { ignores: ["**/dist/**", "**/*.config.*", "packages/*/src/prelude.ts", "docs/**", "corpus/**", "**/src/gen/**"] },
   ...tseslint.configs.recommended,
   {
     files: ["packages/*/src/**/*.ts"],

packages/das-client/package.json

@@ -4,8 +4,25 @@
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "exports": { ".": { "types": "./dist/index.d.ts", "default": "./dist/index.js" } },
-  "files": ["dist"],
-  "scripts": { "build": "tsup src/index.ts --format esm --dts --clean" },
-  "dependencies": { "@metta-ts/core": "workspace:*" }
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "gen": "protoc --plugin=protoc-gen-ts_proto=./node_modules/.bin/protoc-gen-ts_proto --ts_proto_out=./src/gen --ts_proto_opt=outputServices=grpc-js,esModuleInterop=true,forceLong=string -I proto proto/*.proto"
+  },
+  "dependencies": {
+    "@metta-ts/core": "workspace:*",
+    "@grpc/grpc-js": "^1.14.4",
+    "@bufbuild/protobuf": "^2.2.3"
+  },
+  "devDependencies": {
+    "ts-proto": "^2.11.8"
+  }
 }

packages/das-client/proto/attention_broker.proto

@@ -0,0 +1,51 @@
+syntax = "proto3";
+import "common.proto";
+package dasproto;
+
+message HandleList {
+    repeated string list = 1;
+    int32 request_type = 2;
+    int64 hebbian_network = 3;
+    string context = 4;
+}
+
+message HandleListList {
+    repeated HandleList list = 1;
+    int32 request_type = 2;
+    int64 hebbian_network = 3;
+    string context = 4;
+}
+
+message HandleCount {
+    map<string, uint32> map = 1;
+    int32 request_type = 2;
+    int64 hebbian_network = 3;
+    string context = 4;
+}
+
+message ImportanceList {
+    repeated float list = 1;
+}
+
+message Parameters {
+    float rent_rate = 1;
+    float spreading_rate_lowerbound = 2;
+    float spreading_rate_upperbound = 3;
+}
+
+message ContextPersistence {
+    string context = 1;
+    string file_name = 2;
+}
+
+service AttentionBroker {
+    rpc ping (Empty) returns (Ack) {}
+    rpc stimulate (HandleCount) returns (Ack) {}
+    rpc correlate (HandleList) returns (Ack) {}
+    rpc asymmetric_correlate (HandleList) returns (Ack) {}
+    rpc get_importance (HandleList) returns (ImportanceList) {}
+    rpc set_determiners (HandleListList) returns (Ack) {}
+    rpc set_parameters (Parameters) returns (Ack) {}
+    rpc save_context (ContextPersistence) returns (Ack) {}
+    rpc drop_and_load_context (ContextPersistence) returns (Ack) {}
+}

packages/das-client/proto/common.proto

@@ -0,0 +1,9 @@
+syntax = "proto3";
+package dasproto;
+
+message Empty {}
+
+message Ack {
+    bool error = 1;
+    string msg = 2;
+}

packages/das-client/proto/distributed_algorithm_node.proto

@@ -0,0 +1,16 @@
+syntax = "proto3";
+import "common.proto";
+package dasproto;
+
+message MessageData {
+    string command = 1;
+    repeated string args = 2;
+    string sender = 3;
+    bool is_broadcast = 4;
+    repeated string visited_recipients = 5;
+}
+
+service DistributedAlgorithmNode {
+    rpc ping (Empty) returns (Ack) {}
+    rpc execute_message (MessageData) returns (Empty) {}
+}

packages/das-client/proto/echo.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+package echo;
+
+service Echo {
+  rpc echo (EchoRequest) returns (EchoResponse) {}
+}
+
+message EchoRequest {
+  string msg = 1;
+}
+
+message EchoResponse {
+  string msg = 1;
+}

packages/das-client/src/bus-node.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { BusNode } from "./bus-node";
+import type { MessageData } from "./gen/distributed_algorithm_node";
+
+// In-process gRPC: two bus nodes exchange a ping and an execute_message command over the real
+// das-proto wire (no live DAS needed — this verifies the gRPC bus layer end to end).
+let nodes: BusNode[] = [];
+afterEach(async () => {
+  await Promise.all(nodes.map((n) => n.stop()));
+  nodes = [];
+});
+
+describe("BusNode (real gRPC over das-proto)", () => {
+  it("ping returns the server's Ack", async () => {
+    const a = new BusNode("127.0.0.1:0");
+    nodes.push(a);
+    // bind on an ephemeral port via the OS, then ping ourselves on a fixed test port
+    const server = new BusNode("127.0.0.1:52771");
+    nodes.push(server);
+    await server.start();
+    const ack = await a.ping("127.0.0.1:52771");
+    expect(ack.error).toBe(false);
+    expect(ack.msg).toBe("pong");
+  });
+
+  it("execute_message delivers a command to the peer", async () => {
+    let received: MessageData | undefined;
+    const server = new BusNode("127.0.0.1:52772", (m) => (received = m));
+    nodes.push(server);
+    await server.start();
+    const client = new BusNode("127.0.0.1:0");
+    nodes.push(client);
+    await client.send("127.0.0.1:52772", {
+      command: "bus_command_proxy",
+      args: ["pattern-matching-query", "(Similarity human $s)"],
+      sender: "127.0.0.1:0",
+      isBroadcast: false,
+      visitedRecipients: [],
+    });
+    expect(received?.command).toBe("bus_command_proxy");
+    expect(received?.args[1]).toBe("(Similarity human $s)");
+  });
+});

packages/das-client/src/bus-node.ts

@@ -0,0 +1,90 @@
+// A DAS bus node over the generated gRPC stubs (das-proto `DistributedAlgorithmNode`). This is the
+// real wire layer the live transport is built on: a participant hosts an inbound node (a gRPC
+// server) and sends `execute_message` commands to peers. The full pattern-matching choreography
+// (the proxy that issues a `bus_command_proxy` and assembles the streamed `query_answer_tokens_flow`)
+// is ported on top of this from the Python `hyperon_das` service_bus/proxy; this layer is what makes
+// a node reachable and lets it ping/exchange messages. Node-only.
+import {
+  Server,
+  ServerCredentials,
+  credentials,
+  type ServerUnaryCall,
+  type sendUnaryData,
+} from "@grpc/grpc-js";
+import {
+  DistributedAlgorithmNodeClient,
+  DistributedAlgorithmNodeService,
+  type MessageData,
+} from "./gen/distributed_algorithm_node";
+import { type Empty, type Ack } from "./gen/common";
+
+/** The bus command vocabulary (from the Python/Rust clients' `service_bus`). */
+export const BusCommand = {
+  ping: "ping",
+  ack: "ack",
+  nodeJoinedNetwork: "node_joined_network",
+  busCommandProxy: "bus_command_proxy",
+  queryAnswerTokensFlow: "query_answer_tokens_flow",
+} as const;
+
+export type MessageHandler = (msg: MessageData) => void;
+
+/** An inbound bus node: a gRPC server implementing `DistributedAlgorithmNode`, plus the ability to
+ *  send `execute_message` to peers. */
+export class BusNode {
+  private server?: Server;
+  constructor(
+    readonly address: string,
+    private readonly onMessage: MessageHandler = () => {},
+  ) {}
+
+  /** Start the inbound gRPC server. Resolves once it is listening. */
+  start(): Promise<void> {
+    const server = new Server();
+    server.addService(DistributedAlgorithmNodeService, {
+      ping: (_call: ServerUnaryCall<Empty, Ack>, cb: sendUnaryData<Ack>) =>
+        cb(null, { error: false, msg: "pong" }),
+      executeMessage: (call: ServerUnaryCall<MessageData, Empty>, cb: sendUnaryData<Empty>) => {
+        this.onMessage(call.request);
+        cb(null, {});
+      },
+    });
+    this.server = server;
+    return new Promise((resolve, reject) => {
+      server.bindAsync(this.address, ServerCredentials.createInsecure(), (err) =>
+        err ? reject(err) : resolve(),
+      );
+    });
+  }
+
+  /** Send a command message to a peer node and await its acknowledgement. */
+  send(peer: string, message: MessageData): Promise<void> {
+    const client = new DistributedAlgorithmNodeClient(peer, credentials.createInsecure());
+    return new Promise((resolve, reject) => {
+      client.executeMessage(message, (err) => {
+        client.close();
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+
+  /** Ping a peer node; resolves with its `Ack`. */
+  ping(peer: string): Promise<Ack> {
+    const client = new DistributedAlgorithmNodeClient(peer, credentials.createInsecure());
+    return new Promise((resolve, reject) => {
+      client.ping({}, (err, ack) => {
+        client.close();
+        if (err) reject(err);
+        else resolve(ack);
+      });
+    });
+  }
+
+  stop(): Promise<void> {
+    return new Promise((resolve) => {
+      if (!this.server) return resolve();
+      this.server.tryShutdown(() => resolve());
+    });
+  }
+}