@blockrun/clawrouter 0.6.4 → 0.6.7

package/dist/index.js

@@ -467,6 +467,7 @@ var blockrunProvider = {
 
 // src/proxy.ts
 import { createServer } from "http";
+import { finished } from "stream";
 import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 
 // src/x402.ts
@@ -2365,6 +2366,15 @@ function prioritizeNonRateLimited(models) {
   }
   return [...available, ...rateLimited];
 }
+function canWrite(res) {
+  return !res.writableEnded && !res.destroyed && res.socket !== null && !res.socket.destroyed && res.socket.writable;
+}
+function safeWrite(res, data) {
+  if (!canWrite(res)) {
+    return false;
+  }
+  return res.write(data);
+}
 var BALANCE_CHECK_BUFFER = 1.5;
 function getProxyPort() {
   const envPort = process.env.BLOCKRUN_PROXY_PORT;
@@ -2573,7 +2583,24 @@ async function startProxy(options) {
   };
   const deduplicator = new RequestDeduplicator();
   const sessionStore = new SessionStore(options.sessionConfig);
+  const connections = /* @__PURE__ */ new Set();
   const server = createServer(async (req, res) => {
+    req.on("error", (err) => {
+      console.error(`[ClawRouter] Request stream error: ${err.message}`);
+    });
+    res.on("error", (err) => {
+      console.error(`[ClawRouter] Response stream error: ${err.message}`);
+    });
+    finished(res, (err) => {
+      if (err && err.code !== "ERR_STREAM_DESTROYED") {
+        console.error(`[ClawRouter] Response finished with error: ${err.message}`);
+      }
+    });
+    finished(req, (err) => {
+      if (err && err.code !== "ERR_STREAM_DESTROYED") {
+        console.error(`[ClawRouter] Request finished with error: ${err.message}`);
+      }
+    });
     if (req.url === "/health" || req.url?.startsWith("/health?")) {
       const url = new URL(req.url, "http://localhost");
       const full = url.searchParams.get("full") === "true";
@@ -2686,14 +2713,54 @@ async function startProxy(options) {
       const port = addr.port;
       const baseUrl = `http://127.0.0.1:${port}`;
       options.onReady?.(port);
+      server.on("error", (err) => {
+        console.error(`[ClawRouter] Server runtime error: ${err.message}`);
+        options.onError?.(err);
+      });
+      server.on("clientError", (err, socket) => {
+        console.error(`[ClawRouter] Client error: ${err.message}`);
+        if (socket.writable && !socket.destroyed) {
+          socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+        }
+      });
+      server.on("connection", (socket) => {
+        connections.add(socket);
+        socket.setTimeout(3e5);
+        socket.on("timeout", () => {
+          console.error(`[ClawRouter] Socket timeout, destroying connection`);
+          socket.destroy();
+        });
+        socket.on("end", () => {
+        });
+        socket.on("error", (err) => {
+          console.error(`[ClawRouter] Socket error: ${err.message}`);
+        });
+        socket.on("close", () => {
+          connections.delete(socket);
+        });
+      });
       resolve({
         port,
         baseUrl,
         walletAddress: account.address,
         balanceMonitor,
         close: () => new Promise((res, rej) => {
+          const timeout = setTimeout(() => {
+            rej(new Error("[ClawRouter] Close timeout after 4s"));
+          }, 4e3);
           sessionStore.close();
-          server.close((err) => err ? rej(err) : res());
+          for (const socket of connections) {
+            socket.destroy();
+          }
+          connections.clear();
+          server.close((err) => {
+            clearTimeout(timeout);
+            if (err) {
+              rej(err);
+            } else {
+              res();
+            }
+          });
         })
       });
     });
@@ -2901,10 +2968,13 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
       connection: "keep-alive"
     });
     headersSentEarly = true;
-    res.write(": heartbeat\n\n");
+    safeWrite(res, ": heartbeat\n\n");
     heartbeatInterval = setInterval(() => {
-      if (!res.writableEnded) {
-        res.write(": heartbeat\n\n");
+      if (canWrite(res)) {
+        safeWrite(res, ": heartbeat\n\n");
+      } else {
+        clearInterval(heartbeatInterval);
+        heartbeatInterval = void 0;
       }
     }, HEARTBEAT_INTERVAL_MS);
   }
@@ -3022,8 +3092,8 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
         const errEvent = `data: ${JSON.stringify({ error: { message: errBody, type: "provider_error", status: errStatus } })}
 
 `;
-        res.write(errEvent);
-        res.write("data: [DONE]\n\n");
+        safeWrite(res, errEvent);
+        safeWrite(res, "data: [DONE]\n\n");
         res.end();
         const errBuf = Buffer.from(errEvent + "data: [DONE]\n\n");
         deduplicator.complete(dedupKey, {
@@ -3088,7 +3158,7 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
               const roleData = `data: ${JSON.stringify(roleChunk)}
 
 `;
-              res.write(roleData);
+              safeWrite(res, roleData);
               responseChunks.push(Buffer.from(roleData));
               if (content) {
                 const contentChunk = {
@@ -3098,7 +3168,7 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
                 const contentData = `data: ${JSON.stringify(contentChunk)}
 
 `;
-                res.write(contentData);
+                safeWrite(res, contentData);
                 responseChunks.push(Buffer.from(contentData));
               }
               const toolCalls = choice.message?.tool_calls ?? choice.delta?.tool_calls;
@@ -3117,7 +3187,7 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
                 const toolCallData = `data: ${JSON.stringify(toolCallChunk)}
 
 `;
-                res.write(toolCallData);
+                safeWrite(res, toolCallData);
                 responseChunks.push(Buffer.from(toolCallData));
               }
               const finishChunk = {
@@ -3134,7 +3204,7 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
               const finishData = `data: ${JSON.stringify(finishChunk)}
 
 `;
-              res.write(finishData);
+              safeWrite(res, finishData);
               responseChunks.push(Buffer.from(finishData));
             }
           }
@@ -3142,11 +3212,11 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
           const sseData = `data: ${jsonStr}
 
 `;
-          res.write(sseData);
+          safeWrite(res, sseData);
           responseChunks.push(Buffer.from(sseData));
         }
       }
-      res.write("data: [DONE]\n\n");
+      safeWrite(res, "data: [DONE]\n\n");
       responseChunks.push(Buffer.from("data: [DONE]\n\n"));
       res.end();
       deduplicator.complete(dedupKey, {
@@ -3169,8 +3239,9 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
           while (true) {
             const { done, value } = await reader.read();
             if (done) break;
-            res.write(value);
-            responseChunks.push(Buffer.from(value));
+            const chunk = Buffer.from(value);
+            safeWrite(res, chunk);
+            responseChunks.push(chunk);
           }
         } finally {
           reader.releaseLock();