@axiom-lattice/gateway 2.1.88 → 2.1.90

package/dist/index.mjs

@@ -6409,8 +6409,183 @@ function registerChannelBindingRoutes(app2) {
   app2.delete("/api/channel-bindings/:id", deleteBinding);
 }
 
+// src/routes/a2a-bridge.ts
+import { v4 as v42 } from "uuid";
+var log = {
+  info(msg, ctx) {
+    console.log(JSON.stringify({ level: "info", msg, ...ctx }));
+  },
+  warn(msg, ctx) {
+    console.warn(JSON.stringify({ level: "warn", msg, ...ctx }));
+  },
+  error(msg, ctx) {
+    console.error(JSON.stringify({ level: "error", msg, ...ctx }));
+  }
+};
+var connections = /* @__PURE__ */ new Map();
+var pending = /* @__PURE__ */ new Map();
+function getAgentIdFromPath(path3) {
+  const match = path3.match(/^\/api\/a2a\/bridge\/proxy\/([^/]+)/);
+  return match ? match[1] : null;
+}
+function handleBridgeConnection(socket, _request) {
+  let agentId = null;
+  log.info("Bridge WebSocket connected");
+  socket.on("message", (raw) => {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch {
+      log.warn("Bridge invalid message");
+      return;
+    }
+    switch (msg.type) {
+      case "agent:register": {
+        agentId = msg.agentId;
+        if (!agentId) {
+          socket.send(JSON.stringify({ type: "error", message: "agentId required" }));
+          socket.close();
+          return;
+        }
+        connections.set(agentId, {
+          ws: socket,
+          agentId,
+          agentCard: msg.agentCard ?? {},
+          connectedAt: Date.now()
+        });
+        log.info("Agent registered via bridge", { agentId });
+        socket.send(JSON.stringify({ type: "agent:registered", agentId }));
+        break;
+      }
+      case "http:response": {
+        const requestId = msg.requestId;
+        const p = pending.get(requestId);
+        if (p) {
+          clearTimeout(p.timer);
+          pending.delete(requestId);
+          p.resolve({
+            status: msg.status ?? 200,
+            headers: msg.headers ?? {},
+            body: msg.body ?? ""
+          });
+        }
+        break;
+      }
+      case "http:error": {
+        const requestId = msg.requestId;
+        const p = pending.get(requestId);
+        if (p) {
+          clearTimeout(p.timer);
+          pending.delete(requestId);
+          p.reject(new Error(msg.message ?? "Agent error"));
+        }
+        break;
+      }
+    }
+  });
+  socket.on("close", () => {
+    if (agentId) {
+      connections.delete(agentId);
+      log.info("Bridge WebSocket disconnected", { agentId });
+      for (const [reqId, p] of pending) {
+        if (p.agentId === agentId) {
+          clearTimeout(p.timer);
+          p.reject(new Error("Agent disconnected"));
+          pending.delete(reqId);
+        }
+      }
+    }
+  });
+  socket.on("error", (err) => {
+    log.error("Bridge WebSocket error", { agentId, error: err.message });
+  });
+}
+async function handleBridgeProxy(request, reply) {
+  const agentId = getAgentIdFromPath(request.url);
+  if (!agentId) {
+    reply.status(400).send({ error: "Agent ID not found in path" });
+    return;
+  }
+  const conn = connections.get(agentId);
+  if (!conn) {
+    reply.status(503).send({
+      error: "Agent not connected",
+      message: `Agent "${agentId}" is not connected via WebSocket bridge`
+    });
+    return;
+  }
+  const requestId = v42();
+  const subPath = request.url.replace(`/api/a2a/bridge/proxy/${agentId}`, "") || "/";
+  let body;
+  if (request.method === "POST" || request.method === "PUT") {
+    body = typeof request.body === "string" ? request.body : JSON.stringify(request.body ?? {});
+  }
+  const bridgeRequest = {
+    type: "http:request",
+    requestId,
+    method: request.method,
+    path: subPath,
+    headers: {
+      "content-type": request.headers["content-type"] ?? "application/json",
+      "accept": request.headers["accept"] ?? "*/*"
+    },
+    body: body ?? ""
+  };
+  const timeout = 3e5;
+  try {
+    const response = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(requestId);
+        reject(new Error(`Bridge request timeout after ${timeout}ms`));
+      }, timeout);
+      pending.set(requestId, { resolve, reject, timer, agentId });
+      try {
+        if (conn.ws.readyState !== conn.ws.OPEN) {
+          pending.delete(requestId);
+          reject(new Error("WebSocket not open"));
+          return;
+        }
+        conn.ws.send(JSON.stringify(bridgeRequest));
+      } catch (err) {
+        clearTimeout(timer);
+        pending.delete(requestId);
+        reject(err);
+      }
+    });
+    for (const [key, value] of Object.entries(response.headers)) {
+      if (!["content-length", "transfer-encoding", "connection"].includes(key.toLowerCase())) {
+        reply.header(key, value);
+      }
+    }
+    reply.status(response.status);
+    try {
+      const parsed = JSON.parse(response.body);
+      reply.send(parsed);
+    } catch {
+      reply.send(response.body);
+    }
+  } catch (err) {
+    log.error("Bridge proxy error", { agentId, error: err.message });
+    reply.status(502).send({
+      error: "Bridge proxy error",
+      message: err.message
+    });
+  }
+}
+function registerA2ABridgeRoutes(app2) {
+  app2.get("/api/a2a/bridge", { websocket: true }, (socket, req) => {
+    handleBridgeConnection(socket, req);
+  });
+  app2.route({
+    method: ["GET", "POST", "PUT", "DELETE", "PATCH"],
+    url: "/api/a2a/bridge/proxy/*",
+    handler: handleBridgeProxy
+  });
+}
+
 // src/routes/index.ts
 var registerLatticeRoutes = (app2, channelDeps) => {
+  registerA2ABridgeRoutes(app2);
   app2.post("/api/runs", createRun);
   app2.post("/api/resume_stream", resumeStream);
   app2.post("/api/assistants/:assistantId/threads/:threadId/abort", abortRun);
@@ -6637,14 +6812,39 @@ var BindingNotFoundError = class extends Error {
 };
 var MessageRouter = class {
   constructor(config) {
+    /**
+     * Tracks reply subscriptions per thread+channel to avoid duplicate
+     * `subscribeOnce` registrations and ensure proper cleanup.
+     *
+     * Key format: `{threadId}:{adapterChannel}:reply`
+     */
+    this._replySubs = /* @__PURE__ */ new Map();
     this.middlewares = [...config.middlewares];
     this.bindingRegistry = config.bindingRegistry;
     this.adapterRegistry = config.adapterRegistry;
     this.installationStore = config.installationStore;
   }
+  /**
+   * Register an additional middleware at the end of the chain.
+   *
+   * @param middleware - A {@link MessageMiddleware} function
+   */
   use(middleware) {
     this.middlewares.push(middleware);
   }
+  /**
+   * Dispatch an inbound channel message to the bound agent.
+   *
+   * Full pipeline: middleware chain → binding resolution → thread lifecycle
+   * → agent.addMessage() → (async) reply via {@link ChannelAdapter.sendReply}.
+   *
+   * If the message has a {@link InboundMessage.replyTarget}, the router subscribes
+   * to the agent's `reply:ready` event before enqueuing the message, and sends
+   * the AI response back to the channel when it arrives.
+   *
+   * @param message - Normalized inbound message from a channel adapter
+   * @returns {@link DispatchResult} with success status, bindingId, and threadId
+   */
   async dispatch(message) {
     const ctx = {
       inboundMessage: message,
@@ -6791,32 +6991,96 @@ var MessageRouter = class {
           workspace_id: ctx.binding.workspaceId || "",
           project_id: ctx.binding.projectId || ""
         });
-        const addResult = await agent.addMessage({
-          input: { message: message.content.text },
-          custom_run_config: message.content.metadata || {}
-        });
-        console.log({
-          event: "dispatch:complete",
-          agentId: ctx.binding.agentId,
-          threadId,
-          messageId: addResult?.messageId,
-          result: JSON.stringify(addResult)
-        }, "Agent dispatch complete \u2014 messageId = " + (addResult?.messageId || "N/A"));
         if (message.replyTarget) {
+          const replySubKey = `${threadId}:${message.replyTarget.adapterChannel}:reply`;
           const adapter = this.adapterRegistry.get(message.replyTarget.adapterChannel);
           if (adapter) {
             const installation = await this.installationStore.getInstallationById(
               message.channelInstallationId
             );
             if (installation) {
-              await adapter.sendReply(
-                message.replyTarget,
-                { text: ctx.result || "" },
-                installation
-              );
+              const existing = this._replySubs.get(replySubKey);
+              if (!existing || existing.count === 0) {
+                const timer = setTimeout(() => {
+                  const entry = this._replySubs.get(replySubKey);
+                  if (entry) {
+                    this._replySubs.delete(replySubKey);
+                    console.warn({
+                      event: "dispatch:reply:timeout",
+                      threadId,
+                      channel: message.replyTarget.adapterChannel
+                    }, "Reply subscription timed out \u2014 no reply:ready fired within 1h");
+                  }
+                }, 36e5);
+                this._replySubs.set(replySubKey, { count: 1, timer });
+                console.log({
+                  event: "dispatch:reply:subscribed",
+                  threadId,
+                  channel: message.replyTarget.adapterChannel,
+                  senderId: message.sender.id
+                }, "Subscribed to reply:ready for thread");
+                agent.subscribeOnce("reply:ready", (data) => {
+                  const messages = data.state?.values?.messages;
+                  const lastAI = messages?.filter((m) => m.type === "ai" || m.getType?.() === "ai").pop();
+                  const replyText = lastAI?.content ?? "";
+                  const entry = this._replySubs.get(replySubKey);
+                  if (entry) {
+                    entry.count--;
+                    if (entry.count <= 0) {
+                      clearTimeout(entry.timer);
+                      this._replySubs.delete(replySubKey);
+                    }
+                  }
+                  if (replyText) {
+                    console.log({
+                      event: "dispatch:reply:sending",
+                      threadId,
+                      channel: message.replyTarget.adapterChannel,
+                      replyLength: replyText.length
+                    }, "Sending channel reply");
+                    adapter.sendReply(message.replyTarget, { text: replyText }, installation).then(() => {
+                      console.log({
+                        event: "dispatch:reply:sent",
+                        threadId,
+                        channel: message.replyTarget.adapterChannel
+                      }, "Channel reply sent successfully");
+                    }).catch((err) => console.error({
+                      event: "dispatch:reply:failed",
+                      threadId,
+                      channel: message.replyTarget.adapterChannel,
+                      error: err instanceof Error ? err.message : String(err)
+                    }, "Failed to send channel reply"));
+                  } else {
+                    console.warn({
+                      event: "dispatch:reply:empty",
+                      threadId,
+                      channel: message.replyTarget.adapterChannel
+                    }, "Agent produced no text output \u2014 skipping reply");
+                  }
+                });
+              } else {
+                existing.count++;
+                console.log({
+                  event: "dispatch:reply:incremented",
+                  threadId,
+                  channel: message.replyTarget.adapterChannel,
+                  count: existing.count
+                }, "Incremented reply counter for thread (already subscribed)");
+              }
             }
           }
         }
+        const addResult = await agent.addMessage({
+          input: { message: message.content.text },
+          custom_run_config: message.replyTarget ? { ...message.content.metadata || {}, _replyTarget: message.replyTarget } : message.content.metadata || {}
+        });
+        console.log({
+          event: "dispatch:complete",
+          agentId: ctx.binding.agentId,
+          threadId,
+          messageId: addResult?.messageId,
+          result: JSON.stringify(addResult)
+        }, "Agent dispatch complete \u2014 messageId = " + (addResult?.messageId || "N/A"));
       });
       return {
         success: true,
@@ -7357,6 +7621,12 @@ app.addHook("preHandler", async (request, reply) => {
     error: "Unauthorized - Missing or invalid token"
   });
 });
+app.addHook("onRequest", (request, reply, done) => {
+  if (!request.headers["x-project-id"]) {
+    request.headers["x-project-id"] = "default";
+  }
+  done();
+});
 app.addHook("onRequest", (request, reply, done) => {
   const context = {
     "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
@@ -7464,6 +7734,14 @@ var start = async (config) => {
         installationStore
       });
       channelDeps = { router, installationStore };
+      try {
+        const a2aKeyStore = getStoreLattice16("default", "a2aApiKey").store;
+        const a2a = await import("./a2a-ERG5RMUW.mjs");
+        a2a.setA2AKeyStore(a2aKeyStore);
+        await a2a.refreshStoreKeyMap();
+        logger3.info("A2A key store initialized");
+      } catch {
+      }
     } catch {
     }
     registerLatticeRoutes(app, channelDeps);