@elvatis_com/openclaw-cli-bridge-elvatis 3.0.0 → 3.1.1

package/README.md

@@ -2,7 +2,7 @@
 
 > OpenClaw plugin that bridges locally installed AI CLIs (Codex, Gemini, Claude Code, OpenCode, Pi) as model providers — with slash commands for instant model switching, restore, health testing, and model listing.
 
-**Current version:** `3.0.0`
+**Current version:** `3.1.1`
 
 ---
 
@@ -406,6 +406,16 @@ npm run ci          # lint + typecheck + test
 
 ## Changelog
 
+### v3.1.1
+- **fix:** empty-response detection — models returning zero content now trigger the next fallback instead of silently stopping the chain. Previously Haiku would return empty (0 bytes) and the bridge treated it as success, leaving the user with no response.
+- **feat:** `[EMPTY]` and `[FALLBACK-EMPTY]` debug log categories for diagnosing empty model responses
+
+### v3.1.0
+- **feat:** cross-provider fallback chains — Sonnet → Haiku → Gemini Flash → Codex (was single-model fallback only)
+- **feat:** fallback chain loop — tries each model in order until one succeeds, logs each attempt
+- **fix:** live logs newest-on-top — latest entries now appear at the top of the log viewer
+- **feat:** SSE fallback notifications for each chain attempt so user sees what's happening
+
 ### v3.0.0
 - **feat:** dashboard v2 — sidebar navigation with 9 sections (Overview, Providers, Active, Requests, Fallbacks, Sessions, Live Logs, Timeouts, Models)
 - **feat:** live log viewer — SSE-powered real-time log streaming with color-coded categories, auto-scroll, pause/resume, 500-line client buffer

package/SKILL.md

@@ -68,4 +68,4 @@ On gateway restart, if any session has expired, a **WhatsApp alert** is sent aut
 
 See `README.md` for full configuration reference and architecture diagram.
 
-**Version:** 3.0.0
+**Version:** 3.1.1

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw-cli-bridge-elvatis",
   "slug": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "3.0.0",
+  "version": "3.1.1",
   "license": "MIT",
   "description": "Phase 1: openai-codex auth bridge. Phase 2: local HTTP proxy routing model calls through gemini/claude CLIs (vllm provider).",
   "providers": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvatis_com/openclaw-cli-bridge-elvatis",
-  "version": "3.0.0",
+  "version": "3.1.1",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {

package/src/config.ts

@@ -138,15 +138,21 @@ export const DEFAULT_MODEL_TIMEOUTS: Record<string, number> = {
 // ──────────────────────────────────────────────────────────────────────────────
 
 /**
- * Default fallback chain: when a primary model fails (timeout, error),
- * retry once with the lighter variant.
+ * Default fallback chains: when a primary model fails (timeout, stale, error),
+ * try each fallback in order. Cross-provider chains ensure we use all available
+ * models instead of just falling back within one provider.
+ *
+ * Strategy: same-provider fast model first, then cross-provider alternatives.
  */
-export const DEFAULT_MODEL_FALLBACKS: Record<string, string> = {
-  "cli-gemini/gemini-2.5-pro":        "cli-gemini/gemini-2.5-flash",
-  "cli-gemini/gemini-3-pro-preview":  "cli-gemini/gemini-3-flash-preview",
-  "cli-claude/claude-opus-4-6":       "cli-claude/claude-sonnet-4-6",
-  "cli-claude/claude-sonnet-4-6":     "cli-claude/claude-haiku-4-5",
-  "gemini-api/gemini-2.5-pro":       "gemini-api/gemini-2.5-flash",
+export const DEFAULT_MODEL_FALLBACKS: Record<string, string[]> = {
+  "cli-claude/claude-opus-4-6":       ["cli-claude/claude-sonnet-4-6", "cli-gemini/gemini-2.5-pro", "cli-claude/claude-haiku-4-5"],
+  "cli-claude/claude-sonnet-4-6":     ["cli-claude/claude-haiku-4-5", "cli-gemini/gemini-2.5-flash", "openai-codex/gpt-5.3-codex"],
+  "cli-claude/claude-haiku-4-5":      ["cli-gemini/gemini-2.5-flash", "openai-codex/gpt-5.1-codex-mini"],
+  "cli-gemini/gemini-2.5-pro":        ["cli-gemini/gemini-2.5-flash", "cli-claude/claude-haiku-4-5"],
+  "cli-gemini/gemini-3-pro-preview":  ["cli-gemini/gemini-3-flash-preview", "cli-gemini/gemini-2.5-flash"],
+  "openai-codex/gpt-5.4":             ["openai-codex/gpt-5.3-codex", "cli-claude/claude-haiku-4-5"],
+  "openai-codex/gpt-5.3-codex":       ["openai-codex/gpt-5.1-codex-mini", "cli-gemini/gemini-2.5-flash"],
+  "gemini-api/gemini-2.5-pro":        ["gemini-api/gemini-2.5-flash"],
 };
 
 // ──────────────────────────────────────────────────────────────────────────────

package/src/debug-log.ts

@@ -62,7 +62,7 @@ export function getLogTail(lines = 100): string | null {
   try {
     const content = readFileSync(LOG_FILE, "utf8");
     const allLines = content.split("\n").filter(Boolean);
-    return allLines.slice(-lines).join("\n");
+    return allLines.slice(-lines).reverse().join("\n");
   } catch {
     return null;
   }

package/src/proxy-server.ts

@@ -117,7 +117,7 @@ export interface ProxyServerOptions {
    * When a CLI model fails (timeout, error), the request is retried once
    * with the fallback model. Example: "cli-gemini/gemini-2.5-pro" → "cli-gemini/gemini-2.5-flash"
    */
-  modelFallbacks?: Record<string, string>;
+  modelFallbacks?: Record<string, string | string[]>;
   /**
    * Per-model timeout overrides (ms). Keys are model IDs (without "vllm/" prefix).
    * Use this to give heavy models more time or limit fast models.
@@ -905,6 +905,12 @@ async function handleRequest(
     try {
       result = await routeToCliRunner(usedModel, cleanMessages, effectiveTimeout, routeOpts);
       const latencyMs = Date.now() - cliStart;
+      const hasContent = !!(result.content?.trim()) || !!(result.tool_calls?.length);
+      // Empty response = model returned nothing useful. Treat as error to trigger fallback.
+      if (!hasContent) {
+        debugLog("EMPTY", `${usedModel} returned empty after ${(latencyMs / 1000).toFixed(1)}s`, {});
+        throw new Error(`empty response: ${usedModel} returned no content and no tool_calls`);
+      }
       const estCompletionTokens = estimateTokens(result.content ?? "");
       metrics.recordRequest(usedModel, latencyMs, true, estPromptTokens, estCompletionTokens, promptPreview);
       providerSessions.recordRun(session.id, false);
@@ -917,36 +923,60 @@ async function handleRequest(
       debugLog("FAIL", `${model} failed after ${(primaryDuration / 1000).toFixed(1)}s`, { isTimeout, error: msg.slice(0, 200) });
       // Record the run (with timeout flag) — session is preserved, not deleted
       providerSessions.recordRun(session.id, isTimeout);
-      const fallbackModel = opts.modelFallbacks?.[model];
-      if (fallbackModel) {
+      // ── Multi-model fallback chain: try each fallback in order ──────────
+      // Chains cross providers: Sonnet → Haiku → Gemini Flash → Codex
+      const rawFallbacks = opts.modelFallbacks?.[model];
+      const fallbackChain: string[] = Array.isArray(rawFallbacks) ? rawFallbacks
+        : typeof rawFallbacks === "string" ? [rawFallbacks]
+        : [];
+
+      if (fallbackChain.length > 0) {
         metrics.recordRequest(model, primaryDuration, false, estPromptTokens, undefined, promptPreview);
         const reason = isTimeout ? `timeout by supervisor, session=${session.id} preserved` : msg;
-        opts.warn(`[cli-bridge] ${model} failed (${reason}), falling back to ${fallbackModel}`);
-        debugLog("FALLBACK", `${model} → ${fallbackModel}`, { reason: isTimeout ? "timeout" : "error", primaryDuration: Math.round(primaryDuration / 1000) });
-        // Notify the user via SSE that we're retrying with a different model
-        if (sseHeadersSent) {
-          res.write(`: fallback — ${model} ${isTimeout ? "timed out" : "failed"} after ${Math.round(primaryDuration / 1000)}s, retrying with ${fallbackModel}\n\n`);
+        opts.warn(`[cli-bridge] ${model} failed (${reason}), trying fallback chain: ${fallbackChain.join(" → ")}`);
+
+        let chainSuccess = false;
+        for (const fallbackModel of fallbackChain) {
+          debugLog("FALLBACK", `${model} → ${fallbackModel}`, { reason: isTimeout ? "timeout" : "error", primaryDuration: Math.round(primaryDuration / 1000), chain: fallbackChain });
+          if (sseHeadersSent) {
+            res.write(`: fallback — trying ${fallbackModel}\n\n`);
+          }
+          const fallbackStart = Date.now();
+          try {
+            result = await routeToCliRunner(fallbackModel, cleanMessages, effectiveTimeout, routeOpts);
+            const fbHasContent = !!(result.content?.trim()) || !!(result.tool_calls?.length);
+            if (!fbHasContent) {
+              debugLog("FALLBACK-EMPTY", `${fallbackModel} returned empty`, {});
+              throw new Error(`empty response from ${fallbackModel}`);
+            }
+            const fbCompTokens = estimateTokens(result.content ?? "");
+            metrics.recordRequest(fallbackModel, Date.now() - fallbackStart, true, estPromptTokens, fbCompTokens, promptPreview);
+            metrics.recordFallback(model, fallbackModel, isTimeout ? "timeout" : "error", primaryDuration, true);
+            usedModel = fallbackModel;
+            debugLog("FALLBACK-OK", `${fallbackModel} succeeded in ${((Date.now() - fallbackStart) / 1000).toFixed(1)}s`, { toolCalls: result.tool_calls?.length ?? 0 });
+            opts.log(`[cli-bridge] fallback to ${fallbackModel} succeeded`);
+            chainSuccess = true;
+            break;
+          } catch (fallbackErr) {
+            const fbDuration = Date.now() - fallbackStart;
+            metrics.recordRequest(fallbackModel, fbDuration, false, estPromptTokens, undefined, promptPreview);
+            metrics.recordFallback(model, fallbackModel, isTimeout ? "timeout" : "error", primaryDuration, false);
+            const fallbackMsg = (fallbackErr as Error).message;
+            debugLog("FALLBACK-FAIL", `${fallbackModel} failed after ${(fbDuration / 1000).toFixed(1)}s`, { error: fallbackMsg.slice(0, 150) });
+            opts.warn(`[cli-bridge] fallback ${fallbackModel} failed: ${fallbackMsg.slice(0, 100)}`);
+            // Continue to next fallback in chain
+          }
         }
-        const fallbackStart = Date.now();
-        try {
-          result = await routeToCliRunner(fallbackModel, cleanMessages, effectiveTimeout, routeOpts);
-          const fbCompTokens = estimateTokens(result.content ?? "");
-          metrics.recordRequest(fallbackModel, Date.now() - fallbackStart, true, estPromptTokens, fbCompTokens, promptPreview);
-          metrics.recordFallback(model, fallbackModel, isTimeout ? "timeout" : "error", primaryDuration, true);
-          usedModel = fallbackModel;
-          opts.log(`[cli-bridge] fallback to ${fallbackModel} succeeded (response will report original model: ${model})`);
-        } catch (fallbackErr) {
-          metrics.recordRequest(fallbackModel, Date.now() - fallbackStart, false, estPromptTokens, undefined, promptPreview);
-          metrics.recordFallback(model, fallbackModel, isTimeout ? "timeout" : "error", primaryDuration, false);
-          const fallbackMsg = (fallbackErr as Error).message;
-          opts.warn(`[cli-bridge] fallback ${fallbackModel} also failed: ${fallbackMsg}`);
+
+        if (!chainSuccess) {
+          const chainStr = fallbackChain.join(", ");
           if (sseHeadersSent) {
-            res.write(`data: ${JSON.stringify({ error: { message: `${model}: ${msg} | fallback ${fallbackModel}: ${fallbackMsg}`, type: "cli_error" } })}\n\n`);
+            res.write(`data: ${JSON.stringify({ error: { message: `${model} and all fallbacks (${chainStr}) failed`, type: "cli_error" } })}\n\n`);
             res.write("data: [DONE]\n\n");
             res.end();
           } else {
             res.writeHead(500, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: { message: `${model}: ${msg} | fallback ${fallbackModel}: ${fallbackMsg}`, type: "cli_error" } }));
+            res.end(JSON.stringify({ error: { message: `${model} and all fallbacks (${chainStr}) failed`, type: "cli_error" } }));
           }
           return;
         }

package/src/status-template.ts

@@ -694,18 +694,20 @@ export function renderStatusPage(opts: StatusTemplateOptions): string {
     function appendLog(text) {
       if (!logOutput) return;
       var lines = text.split('\\n').filter(function(l) { return l.trim(); });
+      // Newest on top — prepend lines in reverse order
+      var html = '';
       lines.forEach(function(line) {
-        logOutput.innerHTML += colorLogLine(line.replace(/</g, '&lt;').replace(/>/g, '&gt;')) + '\\n';
+        html = colorLogLine(line.replace(/</g, '&lt;').replace(/>/g, '&gt;')) + '\\n' + html;
         logLineCount++;
       });
-      // Trim old lines
+      logOutput.innerHTML = html + logOutput.innerHTML;
+      // Trim old lines from bottom
       while (logLineCount > MAX_LOG_LINES) {
-        var idx = logOutput.innerHTML.indexOf('\\n');
+        var idx = logOutput.innerHTML.lastIndexOf('\\n');
         if (idx === -1) break;
-        logOutput.innerHTML = logOutput.innerHTML.slice(idx + 1);
+        logOutput.innerHTML = logOutput.innerHTML.slice(0, idx);
         logLineCount--;
       }
-      if (autoScroll) logOutput.scrollTop = logOutput.scrollHeight;
     }
 
     function connectLog() {

package/test/config.test.ts

@@ -71,11 +71,15 @@ describe("config.ts exports", () => {
     expect(DEFAULT_MODEL_TIMEOUTS["gemini-api/gemini-2.5-flash"]).toBe(180_000);
   });
 
-  it("exports model fallback chains", () => {
-    expect(DEFAULT_MODEL_FALLBACKS["cli-claude/claude-sonnet-4-6"]).toBe("cli-claude/claude-haiku-4-5");
-    expect(DEFAULT_MODEL_FALLBACKS["cli-claude/claude-opus-4-6"]).toBe("cli-claude/claude-sonnet-4-6");
-    expect(DEFAULT_MODEL_FALLBACKS["cli-gemini/gemini-2.5-pro"]).toBe("cli-gemini/gemini-2.5-flash");
-    expect(DEFAULT_MODEL_FALLBACKS["gemini-api/gemini-2.5-pro"]).toBe("gemini-api/gemini-2.5-flash");
+  it("exports model fallback chains as arrays", () => {
+    expect(DEFAULT_MODEL_FALLBACKS["cli-claude/claude-sonnet-4-6"]).toEqual(["cli-claude/claude-haiku-4-5", "cli-gemini/gemini-2.5-flash", "openai-codex/gpt-5.3-codex"]);
+    expect(DEFAULT_MODEL_FALLBACKS["cli-claude/claude-opus-4-6"]).toContain("cli-claude/claude-sonnet-4-6");
+    expect(DEFAULT_MODEL_FALLBACKS["cli-gemini/gemini-2.5-pro"]).toContain("cli-gemini/gemini-2.5-flash");
+    expect(DEFAULT_MODEL_FALLBACKS["gemini-api/gemini-2.5-pro"]).toContain("gemini-api/gemini-2.5-flash");
+    // All values must be arrays
+    for (const chain of Object.values(DEFAULT_MODEL_FALLBACKS)) {
+      expect(Array.isArray(chain)).toBe(true);
+    }
   });
 
   it("exports path constants rooted in ~/.openclaw", () => {