openclaw-abacusai-auth 1.2.4 → 1.2.6

package/index.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -15,8 +15,9 @@ const DEFAULT_MAX_TOKENS = 8192;
 
 // Proxy configuration
 const PROXY_HOST = "127.0.0.1";
-// Dynamic port - will be assigned when proxy starts
-let proxyPort = 0;
+// Fixed port for the proxy so the baseUrl saved at auth time always works
+const PROXY_PORT_DEFAULT = 18862;
+let proxyPort = PROXY_PORT_DEFAULT;
 
 // Models available on AbacusAI RouteLLM endpoint (OpenAI-compatible, with
 // function calling support). Verified 2026-02.
@@ -269,6 +270,8 @@ async function validateApiKey(
 
 let proxyServer: ReturnType<typeof createServer> | null = null;
 let proxyApiKey = "";
+let activeProxyRequests = 0;
+let proxyShuttingDown = false;
 
 function readBody(req: IncomingMessage): Promise<Buffer> {
   return new Promise((resolve, reject) => {
@@ -443,6 +446,13 @@ function normalizeToolsForRouteLLM(tools: unknown[]): unknown[] {
         fn.parameters = cleanSchema(fn.parameters);
       }
 
+      // RouteLLM REQUIRES every tool to have a `parameters` field.
+      // If a tool has no parameters (e.g. cognitive_assess, flare_plan),
+      // add a default empty object schema.
+      if (!fn.parameters) {
+        fn.parameters = { type: "object", properties: {} };
+      }
+
       copy.function = fn;
 
       // Promote name and parameters to top level for RouteLLM
@@ -546,6 +556,19 @@ function normalizeResponseToolCalls(json: Record<string, unknown>): Record<strin
 }
 
 async function handleProxyRequest(req: IncomingMessage, res: ServerResponse) {
+  if (proxyShuttingDown) {
+    sendJsonResponse(res, 503, { error: { message: "Proxy is shutting down", type: "service_unavailable" } });
+    return;
+  }
+  activeProxyRequests++;
+  try {
+    await handleProxyRequestInner(req, res);
+  } finally {
+    activeProxyRequests--;
+  }
+}
+
+async function handleProxyRequestInner(req: IncomingMessage, res: ServerResponse) {
   const path = req.url ?? "/";
   const target = `${ROUTELLM_BASE}${path}`;
   const headers: Record<string, string> = {
@@ -559,6 +582,8 @@ async function handleProxyRequest(req: IncomingMessage, res: ServerResponse) {
     const parsed = JSON.parse(raw.toString()) as Record<string, unknown>;
     // Normalize tools for RouteLLM: remove `strict` field, clean schemas
     // (remove patternProperties, add additionalProperties: false, etc.)
+
+
     if (Array.isArray(parsed.tools)) {
       parsed.tools = normalizeToolsForRouteLLM(parsed.tools);
     }
@@ -677,18 +702,76 @@ function startProxy(apiKey: string): Promise<void> {
         sendJsonResponse(res, 500, { error: { message: String(err) } });
       });
     });
-    // Use port 0 to let the OS assign a random available port
-    proxyServer.listen(0, PROXY_HOST, () => {
-      const addr = proxyServer?.address();
-      if (addr && typeof addr === "object") {
-        proxyPort = addr.port;
-      }
-      console.log(`[abacusai] proxy listening on http://${PROXY_HOST}:${proxyPort}`);
+
+    // Try fixed port first, then retry with port+1, +2, etc.
+    const tryListen = (port: number, attempt: number) => {
+      proxyServer!.listen(port, PROXY_HOST, () => {
+        proxyPort = port;
+        console.log(`[abacusai] proxy listening on http://${PROXY_HOST}:${proxyPort}`);
+        resolve();
+      });
+      proxyServer!.once("error", (err: NodeJS.ErrnoException) => {
+        if (err.code === "EADDRINUSE" && attempt < 10) {
+          console.log(`[abacusai] port ${port} in use, trying ${port + 1}...`);
+          proxyServer!.removeAllListeners("error");
+          proxyServer!.close(() => {
+            proxyServer = createServer((req, res) => {
+              handleProxyRequest(req, res).catch((e) => {
+                console.error("[abacusai] proxy error:", e);
+                sendJsonResponse(res, 500, { error: { message: String(e) } });
+              });
+            });
+            tryListen(port + 1, attempt + 1);
+          });
+        } else {
+          reject(err);
+        }
+      });
+    };
+
+    tryListen(PROXY_PORT_DEFAULT, 0);
+  });
+}
+
+/**
+ * Gracefully stop the RouteLLM proxy server.
+ * 1. Stop accepting new connections
+ * 2. Wait for all in-flight requests to complete (up to 10s timeout)
+ * 3. Close the server and release the port
+ */
+function stopProxy(): Promise<void> {
+  return new Promise((resolve) => {
+    if (!proxyServer) {
+      resolve();
+      return;
+    }
+
+    proxyShuttingDown = true;
+    console.log(`[abacusai] Proxy shutting down (${activeProxyRequests} active requests)...`);
+
+    // Stop accepting new connections immediately
+    proxyServer.close(() => {
+      console.log("[abacusai] Proxy server closed, port released.");
+      proxyServer = null;
+      proxyShuttingDown = false;
+      activeProxyRequests = 0;
       resolve();
     });
-    proxyServer.on("error", (err: NodeJS.ErrnoException) => {
-      reject(err);
-    });
+
+    // Force-close after 10s if requests don't drain
+    const forceTimeout = setTimeout(() => {
+      console.warn(`[abacusai] Force-closing proxy (${activeProxyRequests} requests still active after 10s).`);
+      proxyServer?.closeAllConnections?.();
+    }, 10_000);
+
+    // Poll for active requests to finish, resolve early if all done
+    const drainInterval = setInterval(() => {
+      if (activeProxyRequests <= 0) {
+        clearInterval(drainInterval);
+        clearTimeout(forceTimeout);
+        // server.close callback will resolve
+      }
+    }, 200);
   });
 }
 
@@ -742,7 +825,9 @@ function updateBaseUrlInConfig(): void {
     const configPath = join(stateDir, "openclaw.json");
     if (!existsSync(configPath)) return;
 
-    const raw = readFileSync(configPath, "utf-8");
+    let raw = readFileSync(configPath, "utf-8");
+    // Strip UTF-8 BOM if present
+    if (raw.charCodeAt(0) === 0xFEFF) raw = raw.slice(1);
     const config = JSON.parse(raw);
     const currentUrl = config?.models?.providers?.abacusai?.baseUrl;
 
@@ -783,18 +868,39 @@ interface PluginAuthContext {
 }
 
 const abacusaiPlugin = {
-  id: "abacusai-auth",
+  id: "openclaw-abacusai-auth",
   name: "AbacusAI Auth",
   description: "AbacusAI RouteLLM provider plugin with direct connection and schema normalization",
   configSchema: emptyPluginConfigSchema(),
   register(api: unknown) {
     const pluginApi = api as {
       registerProvider: (config: unknown) => void;
+      registerHook?: (events: string | string[], handler: Function, opts?: { name?: string }) => void;
       config?: {
         models?: { providers?: { abacusai?: { compat?: { supportsStrictMode?: boolean } } } };
       };
     };
 
+    // ================================================================
+    // Register gateway_stop hook for graceful proxy shutdown
+    // ================================================================
+    if (typeof pluginApi.registerHook === "function") {
+      pluginApi.registerHook(
+        "gateway_stop",
+        async () => {
+          await stopProxy();
+        },
+        { name: "openclaw-abacusai-auth:gateway-stop" },
+      );
+    }
+
+    // Fallback: handle process signals if gateway_stop hook is unavailable
+    const shutdownHandler = () => {
+      stopProxy().then(() => process.exit(0));
+    };
+    process.once("SIGTERM", shutdownHandler);
+    process.once("SIGINT", shutdownHandler);
+
     // Use local proxy mode to handle schema cleaning internally
     // This is required because OpenClaw core may not support requiresCleanSchema yet
     // The proxy normalizes tool schemas before forwarding to RouteLLM
@@ -934,7 +1040,7 @@ const abacusaiPlugin = {
                         // and adding `additionalProperties: false`
                         baseUrl: `http://${PROXY_HOST}:${proxyPort}`,
                         api: "openai-completions",
-                        auth: "token",
+                        apiKey: "abacusai-proxy",
                         models: modelIds.map((id) => buildModelDefinition(id)),
                       },
                     },
@@ -965,3 +1071,4 @@ const abacusaiPlugin = {
 };
 
 export default abacusaiPlugin;
+

package/openclaw.plugin.json

@@ -1,5 +1,5 @@
 {
-  "id": "abacusai-auth",
+  "id": "openclaw-abacusai-auth",
   "providers": [
     "abacusai"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-abacusai-auth",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "OpenClaw AbacusAI provider plugin - Third-party plugin for AbacusAI RouteLLM integration",
   "type": "module",
   "main": "index.ts",
@@ -18,6 +18,9 @@
   ],
   "author": "tonyhu2006",
   "license": "MIT",
+  "scripts": {
+    "build": "tsc"
+  },
   "peerDependencies": {
     "openclaw": ">=2026.2.0"
   },
@@ -25,5 +28,9 @@
     "extensions": [
       "./index.ts"
     ]
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "typescript": "^5.9.3"
   }
 }

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "target": "es2022",
+        "module": "nodenext",
+        "moduleResolution": "nodenext",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "outDir": "./dist",
+        "declaration": true
+    },
+    "include": [
+        "index.ts"
+    ]
+}