@elvatis_com/openclaw-cli-bridge-elvatis 3.5.0 → 3.6.0

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.5.0`
+**Current version:** `3.6.0`
 
 ---
 

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.5.0
+**Version:** 3.6.0

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw-cli-bridge-elvatis",
   "slug": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "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.5.0",
+  "version": "3.6.0",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {

package/src/cli-runner.ts

@@ -1003,6 +1003,108 @@ function detectProjectFromPrompt(prompt: string): { name: string; path: string }
   return null;
 }
 
+// ── Skill hint injection ─────────────────────────────────────────────────────
+// Scans ~/.openclaw/skills/ for skill directories with SKILL.md files.
+// When user prompt mentions a skill name (from the directory name or the SKILL.md
+// description), injects a pointer so the model knows where to find it.
+
+interface SkillEntry {
+  name: string;
+  path: string;
+  description: string;
+  keywords: string[];
+  scripts: string[];
+}
+
+let _skillRegistry: SkillEntry[] | null = null;
+let _skillRegistryRefreshedAt = 0;
+const SKILL_REGISTRY_CACHE_TTL = 120_000; // refresh every 2 min
+
+function getSkillRegistry(): SkillEntry[] {
+  const now = Date.now();
+  if (_skillRegistry && (now - _skillRegistryRefreshedAt) < SKILL_REGISTRY_CACHE_TTL) {
+    return _skillRegistry;
+  }
+  _skillRegistry = [];
+  const skillsDir = join(homedir(), ".openclaw", "skills");
+  try {
+    if (!existsSync(skillsDir)) return _skillRegistry;
+    const entries = readdirSync(skillsDir);
+    for (const name of entries) {
+      const skillDir = join(skillsDir, name);
+      const skillMd = join(skillDir, "SKILL.md");
+      try {
+        if (!statSync(skillDir).isDirectory()) continue;
+        if (!existsSync(skillMd)) continue;
+        // Read first 500 chars of SKILL.md to extract description and keywords
+        const content = readFileSync(skillMd, "utf8").slice(0, 500);
+        const descMatch = content.match(/description:\s*"([^"]+)"/);
+        const description = descMatch?.[1] ?? "";
+        // Build keywords from: skill name, words in description, hyphen-split name parts
+        const keywords = [
+          name,
+          ...name.split("-"),
+          ...description.toLowerCase().split(/[\s,.:;]+/).filter(w => w.length > 3),
+        ];
+        // Find scripts
+        const scriptsDir = join(skillDir, "scripts");
+        let scripts: string[] = [];
+        try {
+          if (existsSync(scriptsDir) && statSync(scriptsDir).isDirectory()) {
+            scripts = readdirSync(scriptsDir).filter(f => f.endsWith(".py") || f.endsWith(".sh"));
+          }
+        } catch { /* no scripts dir */ }
+        _skillRegistry.push({ name, path: skillDir, description, keywords, scripts });
+      } catch { /* skip unreadable skill */ }
+    }
+  } catch { /* no skills dir */ }
+  _skillRegistryRefreshedAt = now;
+  return _skillRegistry;
+}
+
+function detectSkillHints(userText: string): string | null {
+  const skills = getSkillRegistry();
+  if (!skills.length) return null;
+
+  const lower = userText.toLowerCase();
+  const matched: SkillEntry[] = [];
+
+  for (const skill of skills) {
+    // Match by exact skill name in prompt
+    const nameRegex = new RegExp(`\\b${skill.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i");
+    if (nameRegex.test(userText)) {
+      matched.push(skill);
+      continue;
+    }
+    // Match by description keywords (need at least 2 keyword hits)
+    const uniqueKeywords = [...new Set(skill.keywords)];
+    const hits = uniqueKeywords.filter(kw => lower.includes(kw.toLowerCase()));
+    if (hits.length >= 2) {
+      matched.push(skill);
+    }
+  }
+
+  if (!matched.length) return null;
+
+  const hints = matched.map(skill => {
+    const lines = [
+      `[Skill: ${skill.name}]`,
+      `Read the skill instructions with the read tool: ${skill.path}/SKILL.md`,
+      `Then follow the workflow step by step using the available tools (read, exec, web_fetch, etc.).`,
+    ];
+    if (skill.scripts.length > 0) {
+      lines.push(`Available scripts (use exec tool to run them):`);
+      for (const s of skill.scripts) {
+        lines.push(`  - python3 ${skill.path}/scripts/${s}`);
+      }
+      lines.push(`Always use exec to run scripts. Do NOT output results as plain text when a script can do it.`);
+    }
+    return lines.join("\n");
+  });
+
+  return hints.join("\n\n");
+}
+
 /**
  * Route a chat completion to the correct CLI based on model prefix.
  *   cli-gemini/<id>      → gemini CLI
@@ -1027,9 +1129,14 @@ export async function routeToCliRunner(
   let prompt = formatPrompt(messages, toolCount);
   const hasTools = toolCount > 0;
 
-  // Auto-detect project from prompt and set workdir + inject context
+  // Auto-detect project from user messages only (not tool results which mention other projects)
+  const userText = messages
+    .filter((m) => m.role === "user")
+    .map((m) => typeof m.content === "string" ? m.content : "")
+    .join(" ");
+
   if (!opts.workdir) {
-    const detected = detectProjectFromPrompt(prompt);
+    const detected = detectProjectFromPrompt(userText);
     if (detected) {
       opts = { ...opts, workdir: detected.path };
       prompt = `[Context: Working directory is ${detected.path}]\n\n${prompt}`;
@@ -1037,6 +1144,13 @@ export async function routeToCliRunner(
     }
   }
 
+  // Skill hints: inject pointers to local skill files when user prompt matches known patterns
+  const skillHints = detectSkillHints(userText);
+  if (skillHints) {
+    prompt = `${skillHints}\n\n${prompt}`;
+    debugLog("SKILL-HINT", "injected skill hints", { len: skillHints.length });
+  }
+
   // Strip "vllm/" prefix if present — OpenClaw sends the full provider path
   // (e.g. "vllm/cli-claude/claude-sonnet-4-6") but the router only needs the
   // "cli-<type>/<model>" portion.

package/src/proxy-server.ts

@@ -448,6 +448,9 @@ async function handleRequest(
     const promptPreview = typeof lastUserMsg?.content === "string" ? lastUserMsg.content.slice(0, 80) : "";
 
     debugLog("REQ", `${model} start`, { msgs: cleanMessages.length, tools: tools?.length ?? 0, stream, media: mediaFiles.length, promptPreview: promptPreview.slice(0, 60) });
+    if (hasTools && tools!.length > 0) {
+      debugLog("TOOLS", `${tools!.length} tools available`, { names: tools!.map(t => t.function?.name ?? t.name ?? "?").join(", ") });
+    }
 
     // Track active request for dashboard
     activeRequests.set(id, { id, model, startedAt: Date.now(), messageCount: cleanMessages.length, toolCount: tools?.length ?? 0, promptPreview });
@@ -939,7 +942,14 @@ async function handleRequest(
         opts.warn(`[cli-bridge] ${model} failed (${reason}), trying fallback chain: ${fallbackChain.join(" → ")}`);
 
         let chainSuccess = false;
+        const lastMsg = cleanMessages[cleanMessages.length - 1];
+        const inToolLoop = hasTools && (lastMsg?.role === "tool" || lastMsg?.role === "function");
         for (const fallbackModel of fallbackChain) {
+          // Skip Haiku in tool loops — it consistently returns text instead of tool_calls, wasting ~8-12s
+          if (inToolLoop && fallbackModel.includes("haiku")) {
+            debugLog("FALLBACK-SKIP", `skipping ${fallbackModel} in tool loop (unreliable for tool_calls)`, {});
+            continue;
+          }
           debugLog("FALLBACK", `${model} → ${fallbackModel}`, { reason: isTimeout ? "timeout" : "error", primaryDuration: Math.round(primaryDuration / 1000), chain: fallbackChain });
           if (sseHeadersSent) {
             res.write(`: fallback — trying ${fallbackModel}\n\n`);
@@ -952,12 +962,9 @@ async function handleRequest(
               debugLog("FALLBACK-EMPTY", `${fallbackModel} returned empty`, {});
               throw new Error(`empty response from ${fallbackModel}`);
             }
-            // If tools were requested and the last message was a tool result (gateway expects
-            // tool continuation), but the fallback model returned text instead of tool_calls —
+            // If we're in a tool loop but the fallback returned text instead of tool_calls —
             // it ignored the JSON format. Try next model in chain.
-            const lastMsg = cleanMessages[cleanMessages.length - 1];
-            const inToolLoop = lastMsg?.role === "tool" || lastMsg?.role === "function";
-            if (hasTools && inToolLoop && !result.tool_calls?.length && result.content) {
+            if (inToolLoop && !result.tool_calls?.length && result.content) {
               debugLog("FALLBACK-NO-TOOLS", `${fallbackModel} returned text instead of tool_calls in tool loop`, { contentLen: result.content.length, preview: result.content.slice(0, 80) });
               throw new Error(`${fallbackModel} returned text instead of tool_calls`);
             }

package/src/tool-protocol.ts

@@ -188,6 +188,16 @@ export function parseToolCallResponse(text: string): CliToolResult {
     }
   }
 
+  // Last resort: try to rescue tool_calls from anywhere in the text
+  // Models sometimes output tool_calls JSON with surrounding text that breaks other strategies
+  if (trimmed.includes("tool_calls")) {
+    const rescued = tryRescueToolCallsFromContent(trimmed);
+    if (rescued) {
+      debugLog("PARSE", `rescue-from-raw → tool_calls`, { toolCalls: rescued.tool_calls?.length ?? 0 });
+      return rescued;
+    }
+  }
+
   // Fallback: treat entire text as content
   debugLog("PARSE", "no JSON found → raw content", { len: trimmed.length, preview });
   return { content: trimmed || null };
@@ -307,37 +317,49 @@ function tryExtractCodeBlock(text: string): string | null {
   return match?.[1]?.trim() ?? null;
 }
 
-/** Find the first { ... } JSON object in text (greedy, balanced braces). */
+/** Find a balanced { ... } JSON object in text. Tries multiple start positions if the first fails to parse. */
 function tryExtractEmbeddedJson(text: string): string | null {
-  const start = text.indexOf("{");
-  if (start === -1) return null;
-
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-
-  for (let i = start; i < text.length; i++) {
-    const ch = text[i];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (ch === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (ch === '"') {
-      inString = !inString;
-      continue;
-    }
-    if (inString) continue;
-    if (ch === "{") depth++;
-    if (ch === "}") {
-      depth--;
-      if (depth === 0) {
-        return text.slice(start, i + 1);
+  let searchFrom = 0;
+  while (searchFrom < text.length) {
+    const start = text.indexOf("{", searchFrom);
+    if (start === -1) return null;
+
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+
+    for (let i = start; i < text.length; i++) {
+      const ch = text[i];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (inString) continue;
+      if (ch === "{") depth++;
+      if (ch === "}") {
+        depth--;
+        if (depth === 0) {
+          const candidate = text.slice(start, i + 1);
+          // Verify it actually parses as JSON before returning
+          try {
+            JSON.parse(candidate);
+            return candidate;
+          } catch {
+            // This balanced-brace block isn't valid JSON — try next { in text
+            break;
+          }
+        }
       }
     }
+    searchFrom = start + 1;
   }
   return null;
 }