openclaw-navigator 5.6.0 → 5.6.2

package/cli.mjs

@@ -1136,42 +1136,161 @@ function handleRequest(req, res) {
     return;
   }
 
-  // ── Chat send: store user message + broadcast via WebSocket ────────────
-  // The bridge IS the chat backend — messages are stored here in-memory.
-  // The OC agent reads them via navigator_get_chat_messages MCP tool,
-  // processes them, and pushes responses via navigator_chat_respond.
+  // ── Chat send: store locally + respond immediately ─────────────────────
+  // 1. Store user message in bridge memory (for MCP tools to read)
+  // 2. Respond to Navigator immediately (don't block on gateway)
+  // 3. In background: try relaying to gateway for AI processing
+  //    - If gateway responds → store assistant message + broadcast via WS
+  //    - If gateway hangs/fails → agent will respond via MCP tools later
   if (path === "/api/sessions/send" && req.method === "POST") {
     readBody(req)
-      .then((body) => {
+      .then((bodyStr) => {
+        let data;
         try {
-          const data = JSON.parse(body);
-          const message = data.message || data.content || data.text || "";
-          const sessionKey = data.sessionKey || "main";
-          if (!message) {
-            sendJSON(res, 400, { ok: false, error: "Missing 'message'" });
-            return;
-          }
-          // Store user message in local session
-          const session = getChatSession(sessionKey);
-          session.messages.push({
-            role: "user",
-            content: message,
-            timestamp: Date.now(),
-          });
-          // Broadcast via WebSocket so any listening UI gets it
-          broadcastToWS({
-            type: "chat.user",
-            text: message,
-            content: message,
-            sessionKey,
-            role: "user",
-            timestamp: Date.now(),
-          });
-          console.log(`  ${DIM}Chat send [${sessionKey}]: ${message.substring(0, 60)}...${RESET}`);
-          sendJSON(res, 200, { ok: true, stored: true, messageCount: session.messages.length });
+          data = JSON.parse(bodyStr);
         } catch {
           sendJSON(res, 400, { ok: false, error: "Invalid JSON" });
+          return;
         }
+
+        const message = data.message || data.content || data.text || "";
+        const sessionKey = data.sessionKey || "main";
+        if (!message) {
+          sendJSON(res, 400, { ok: false, error: "Missing 'message'" });
+          return;
+        }
+
+        // 1. Store user message locally
+        const session = getChatSession(sessionKey);
+        session.messages.push({
+          role: "user",
+          content: message,
+          timestamp: Date.now(),
+        });
+        console.log(`  ${DIM}Chat send [${sessionKey}]: ${message.substring(0, 60)}...${RESET}`);
+
+        // 2. Respond immediately — don't block Navigator
+        sendJSON(res, 200, { ok: true, stored: true, messageCount: session.messages.length });
+
+        // 3. Background: relay to gateway for AI processing
+        const proxyBody = JSON.stringify({ message, sessionKey });
+        const proxyOpts = {
+          hostname: "127.0.0.1",
+          port: ocGatewayPort,
+          path: `/api/sessions/send`,
+          method: "POST",
+          timeout: 60000, // 60s — agent may take a while to respond
+          headers: {
+            "content-type": "application/json",
+            "content-length": Buffer.byteLength(proxyBody),
+          },
+        };
+
+        const proxyReq = httpRequest(proxyOpts, (proxyRes) => {
+          const contentType = (proxyRes.headers["content-type"] || "").toLowerCase();
+          const isSSE = contentType.includes("text/event-stream");
+
+          if (isSSE) {
+            // SSE response: collect stream, broadcast chunks via WebSocket
+            let fullText = "";
+            let buffer = "";
+            proxyRes.setEncoding("utf-8");
+            proxyRes.on("data", (chunk) => {
+              buffer += chunk;
+              const lines = buffer.split("\n");
+              buffer = lines.pop() || "";
+              for (const line of lines) {
+                if (line.startsWith("data: ")) {
+                  const raw = line.slice(6).trim();
+                  if (raw === "[DONE]") continue;
+                  try {
+                    const evt = JSON.parse(raw);
+                    const text =
+                      evt.text || evt.content || evt.delta?.text || evt.delta?.content || "";
+                    if (text) {
+                      fullText += text;
+                      broadcastToWS({
+                        type: "chat.delta",
+                        text: fullText,
+                        delta: text,
+                        sessionKey,
+                        timestamp: Date.now(),
+                      });
+                    }
+                  } catch {
+                    if (raw && raw !== "[DONE]") fullText += raw;
+                  }
+                }
+              }
+            });
+            proxyRes.on("end", () => {
+              if (buffer.startsWith("data: ")) {
+                const raw = buffer.slice(6).trim();
+                if (raw && raw !== "[DONE]") {
+                  try {
+                    const evt = JSON.parse(raw);
+                    fullText += evt.text || evt.content || evt.delta?.text || "";
+                  } catch {
+                    fullText += raw;
+                  }
+                }
+              }
+              if (fullText) {
+                session.messages.push({ role: "assistant", content: fullText, timestamp: Date.now() });
+                broadcastToWS({
+                  type: "chat.final",
+                  text: fullText,
+                  content: fullText,
+                  sessionKey,
+                  role: "assistant",
+                  timestamp: Date.now(),
+                });
+                console.log(`  ${GREEN}✓${RESET} Gateway SSE response: ${fullText.substring(0, 80)}...`);
+              }
+            });
+            proxyRes.on("error", () => {});
+          } else {
+            // JSON response from gateway
+            const chunks = [];
+            proxyRes.on("data", (c) => chunks.push(c));
+            proxyRes.on("end", () => {
+              const body = Buffer.concat(chunks).toString("utf-8");
+              try {
+                const jsonBody = JSON.parse(body);
+                const inlineResponse =
+                  jsonBody.response || jsonBody.message || jsonBody.answer || jsonBody.text || "";
+                if (inlineResponse) {
+                  session.messages.push({ role: "assistant", content: inlineResponse, timestamp: Date.now() });
+                  broadcastToWS({
+                    type: "chat.final",
+                    text: inlineResponse,
+                    content: inlineResponse,
+                    sessionKey,
+                    role: "assistant",
+                    timestamp: Date.now(),
+                  });
+                  console.log(`  ${GREEN}✓${RESET} Gateway JSON response: ${inlineResponse.substring(0, 80)}...`);
+                } else {
+                  console.log(`  ${DIM}Gateway returned JSON with no response field — waiting for MCP${RESET}`);
+                }
+              } catch {
+                console.log(`  ${DIM}Gateway returned non-JSON — waiting for MCP${RESET}`);
+              }
+            });
+          }
+        });
+
+        proxyReq.on("timeout", () => {
+          proxyReq.destroy();
+          console.log(`  ${DIM}Gateway relay timed out — agent will respond via MCP${RESET}`);
+        });
+
+        proxyReq.on("error", (err) => {
+          console.log(`  ${DIM}Gateway relay failed (${err.message}) — agent will respond via MCP${RESET}`);
+        });
+
+        proxyReq.write(proxyBody);
+        proxyReq.end();
       })
       .catch(() => sendJSON(res, 400, { ok: false, error: "Bad request body" }));
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-navigator",
-  "version": "5.6.0",
+  "version": "5.6.2",
   "description": "One-command bridge + tunnel for the Navigator browser — works on any machine, any OS",
   "keywords": [
     "browser",