agentbnb 4.0.2 → 5.1.0

package/dist/chunk-C6KPAFCC.js

@@ -0,0 +1,387 @@
+// src/relay/websocket-client.ts
+import WebSocket from "ws";
+import { randomUUID } from "crypto";
+
+// src/relay/types.ts
+import { z } from "zod";
+var RegisterMessageSchema = z.object({
+  type: z.literal("register"),
+  owner: z.string().min(1),
+  token: z.string().min(1),
+  card: z.record(z.unknown()),
+  // CapabilityCard (validated separately)
+  cards: z.array(z.record(z.unknown())).optional()
+  // Additional cards (e.g., conductor card)
+});
+var RegisteredMessageSchema = z.object({
+  type: z.literal("registered"),
+  agent_id: z.string()
+});
+var RelayRequestMessageSchema = z.object({
+  type: z.literal("relay_request"),
+  id: z.string().uuid(),
+  target_owner: z.string().min(1),
+  card_id: z.string(),
+  skill_id: z.string().optional(),
+  params: z.record(z.unknown()).default({}),
+  requester: z.string().optional(),
+  escrow_receipt: z.record(z.unknown()).optional()
+});
+var IncomingRequestMessageSchema = z.object({
+  type: z.literal("incoming_request"),
+  id: z.string().uuid(),
+  from_owner: z.string().min(1),
+  card_id: z.string(),
+  skill_id: z.string().optional(),
+  params: z.record(z.unknown()).default({}),
+  requester: z.string().optional(),
+  escrow_receipt: z.record(z.unknown()).optional()
+});
+var RelayResponseMessageSchema = z.object({
+  type: z.literal("relay_response"),
+  id: z.string().uuid(),
+  result: z.unknown().optional(),
+  error: z.object({
+    code: z.number(),
+    message: z.string()
+  }).optional()
+});
+var ResponseMessageSchema = z.object({
+  type: z.literal("response"),
+  id: z.string().uuid(),
+  result: z.unknown().optional(),
+  error: z.object({
+    code: z.number(),
+    message: z.string()
+  }).optional()
+});
+var ErrorMessageSchema = z.object({
+  type: z.literal("error"),
+  code: z.string(),
+  message: z.string(),
+  request_id: z.string().optional()
+});
+var RelayProgressMessageSchema = z.object({
+  type: z.literal("relay_progress"),
+  id: z.string().uuid(),
+  // request ID this progress relates to
+  progress: z.number().min(0).max(100).optional(),
+  // optional percentage
+  message: z.string().optional()
+  // optional status message
+});
+var RelayMessageSchema = z.discriminatedUnion("type", [
+  RegisterMessageSchema,
+  RegisteredMessageSchema,
+  RelayRequestMessageSchema,
+  IncomingRequestMessageSchema,
+  RelayResponseMessageSchema,
+  ResponseMessageSchema,
+  ErrorMessageSchema,
+  RelayProgressMessageSchema
+]);
+
+// src/relay/websocket-client.ts
+var RelayClient = class {
+  ws = null;
+  opts;
+  pendingRequests = /* @__PURE__ */ new Map();
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  intentionalClose = false;
+  registered = false;
+  pongTimeout = null;
+  pingInterval = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Connect to the registry relay and register.
+   * Resolves when registration is acknowledged.
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.intentionalClose = false;
+      this.registered = false;
+      const wsUrl = this.buildWsUrl();
+      this.ws = new WebSocket(wsUrl);
+      let resolved = false;
+      this.ws.on("open", () => {
+        this.reconnectAttempts = 0;
+        this.startPingInterval();
+        this.send({
+          type: "register",
+          owner: this.opts.owner,
+          token: this.opts.token,
+          card: this.opts.card,
+          ...this.opts.cards && this.opts.cards.length > 0 ? { cards: this.opts.cards } : {}
+        });
+      });
+      this.ws.on("message", (raw) => {
+        this.handleMessage(raw, (err) => {
+          if (!resolved) {
+            resolved = true;
+            if (err) reject(err);
+            else resolve();
+          }
+        });
+      });
+      this.ws.on("close", () => {
+        this.cleanup();
+        if (!this.intentionalClose) {
+          if (!resolved) {
+            resolved = true;
+            reject(new Error("WebSocket closed before registration"));
+          }
+          this.scheduleReconnect();
+        }
+      });
+      this.ws.on("error", (err) => {
+        if (!resolved) {
+          resolved = true;
+          reject(err);
+        }
+      });
+      setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          reject(new Error("Connection timeout"));
+          this.ws?.close();
+        }
+      }, 1e4);
+    });
+  }
+  /**
+   * Disconnect from the registry relay.
+   */
+  disconnect() {
+    this.intentionalClose = true;
+    this.cleanup();
+    if (this.ws) {
+      try {
+        this.ws.close(1e3, "Client disconnect");
+      } catch {
+      }
+      this.ws = null;
+    }
+    for (const [id, pending] of this.pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Client disconnected"));
+      this.pendingRequests.delete(id);
+    }
+  }
+  /**
+   * Send a relay request to another agent via the registry.
+   * @returns The result from the target agent.
+   */
+  async request(opts) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.registered) {
+      throw new Error("Not connected to registry relay");
+    }
+    const id = randomUUID();
+    const timeoutMs = opts.timeoutMs ?? 3e5;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error("Relay request timeout"));
+      }, timeoutMs);
+      this.pendingRequests.set(id, { resolve, reject, timeout, timeoutMs, onProgress: opts.onProgress });
+      this.send({
+        type: "relay_request",
+        id,
+        target_owner: opts.targetOwner,
+        card_id: opts.cardId,
+        skill_id: opts.skillId,
+        params: opts.params,
+        requester: opts.requester ?? this.opts.owner,
+        escrow_receipt: opts.escrowReceipt
+      });
+    });
+  }
+  /**
+   * Send a relay_progress message to the relay server for a given request.
+   * Used by the onRequest handler to forward SkillExecutor progress updates
+   * to the requesting agent so it can reset its timeout window.
+   *
+   * @param requestId - The relay request ID to associate progress with.
+   * @param info - Progress details (step, total, message).
+   */
+  sendProgress(requestId, info) {
+    this.send({
+      type: "relay_progress",
+      id: requestId,
+      progress: Math.round(info.step / info.total * 100),
+      message: info.message
+    });
+  }
+  /** Whether the client is connected and registered */
+  get isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN && this.registered;
+  }
+  // ── Private methods ─────────────────────────────────────────────────────────
+  buildWsUrl() {
+    let url = this.opts.registryUrl;
+    if (url.startsWith("http://")) {
+      url = "ws://" + url.slice(7);
+    } else if (url.startsWith("https://")) {
+      url = "wss://" + url.slice(8);
+    } else if (!url.startsWith("ws://") && !url.startsWith("wss://")) {
+      url = "wss://" + url;
+    }
+    if (!url.endsWith("/ws")) {
+      url = url.replace(/\/$/, "") + "/ws";
+    }
+    return url;
+  }
+  handleMessage(raw, onRegistered) {
+    let data;
+    try {
+      data = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf-8"));
+    } catch {
+      return;
+    }
+    const parsed = RelayMessageSchema.safeParse(data);
+    if (!parsed.success) return;
+    const msg = parsed.data;
+    switch (msg.type) {
+      case "registered":
+        this.registered = true;
+        if (!this.opts.silent) {
+          console.log(`  \u2713 Registered with registry (agent_id: ${msg.agent_id})`);
+        }
+        onRegistered?.();
+        break;
+      case "incoming_request":
+        this.handleIncomingRequest(msg);
+        break;
+      case "response":
+        this.handleResponse(msg);
+        break;
+      case "error":
+        this.handleError(msg);
+        break;
+      case "relay_progress":
+        this.handleProgress(msg);
+        break;
+      default:
+        break;
+    }
+  }
+  async handleIncomingRequest(msg) {
+    try {
+      const result = await this.opts.onRequest(msg);
+      this.send({
+        type: "relay_response",
+        id: msg.id,
+        result: result.result,
+        error: result.error
+      });
+    } catch (err) {
+      this.send({
+        type: "relay_response",
+        id: msg.id,
+        error: {
+          code: -32603,
+          message: err instanceof Error ? err.message : "Internal error"
+        }
+      });
+    }
+  }
+  handleResponse(msg) {
+    const pending = this.pendingRequests.get(msg.id);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.pendingRequests.delete(msg.id);
+    if (msg.error) {
+      pending.reject(new Error(msg.error.message));
+    } else {
+      pending.resolve(msg.result);
+    }
+  }
+  handleError(msg) {
+    if (msg.request_id) {
+      const pending = this.pendingRequests.get(msg.request_id);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(msg.request_id);
+        pending.reject(new Error(`${msg.code}: ${msg.message}`));
+      }
+    }
+  }
+  handleProgress(msg) {
+    const pending = this.pendingRequests.get(msg.id);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    const newTimeout = setTimeout(() => {
+      this.pendingRequests.delete(msg.id);
+      pending.reject(new Error("Relay request timeout"));
+    }, pending.timeoutMs);
+    pending.timeout = newTimeout;
+    if (pending.onProgress) {
+      pending.onProgress({ id: msg.id, progress: msg.progress, message: msg.message });
+    }
+  }
+  send(msg) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  startPingInterval() {
+    this.stopPingInterval();
+    this.pingInterval = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.ws.ping();
+        this.pongTimeout = setTimeout(() => {
+          if (!this.opts.silent) {
+            console.log("  \u26A0 Registry pong timeout, reconnecting...");
+          }
+          this.ws?.terminate();
+        }, 15e3);
+      }
+    }, 3e4);
+    this.ws?.on("pong", () => {
+      if (this.pongTimeout) {
+        clearTimeout(this.pongTimeout);
+        this.pongTimeout = null;
+      }
+    });
+  }
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+    if (this.pongTimeout) {
+      clearTimeout(this.pongTimeout);
+      this.pongTimeout = null;
+    }
+  }
+  cleanup() {
+    this.stopPingInterval();
+    this.registered = false;
+  }
+  scheduleReconnect() {
+    if (this.intentionalClose) return;
+    if (this.reconnectTimer) return;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+    this.reconnectAttempts++;
+    if (!this.opts.silent) {
+      console.log(`  \u21BB Reconnecting to registry in ${delay / 1e3}s...`);
+    }
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      try {
+        await this.connect();
+        if (!this.opts.silent) {
+          console.log("  \u2713 Reconnected to registry");
+        }
+      } catch {
+      }
+    }, delay);
+  }
+};
+
+export {
+  RelayMessageSchema,
+  RelayClient
+};