claudish 3.0.1 → 3.0.3

package/dist/index.js

@@ -34800,6 +34800,9 @@ async function parseArgs(args) {
       config3.interactive = true;
     } else if (arg === "--debug" || arg === "-d") {
       config3.debug = true;
+      if (config3.logLevel === "info") {
+        config3.logLevel = "debug";
+      }
     } else if (arg === "--log-level") {
       const levelArg = args[++i];
       if (!levelArg || !["debug", "info", "minimal"].includes(levelArg)) {
@@ -38302,19 +38305,86 @@ var init_grok_adapter = __esm(() => {
 });
 
 // src/adapters/gemini-adapter.ts
-var GeminiAdapter;
+var REASONING_PATTERNS, REASONING_CONTINUATION_PATTERNS, GeminiAdapter;
 var init_gemini_adapter = __esm(() => {
   init_base_adapter();
   init_logger();
+  REASONING_PATTERNS = [
+    /^Wait,?\s+I(?:'m|\s+am)\s+\w+ing\b/i,
+    /^Wait[.!]?\s*$/i,
+    /^Let\s+me\s+(think|check|verify|see|look|analyze|consider)/i,
+    /^I\s+need\s+to\s+/i,
+    /^O[kK](?:ay)?[.,!]?\s*(?:so|let|I|now|first)?/i,
+    /^[Hh]mm+/,
+    /^So[,.]?\s+(?:I|let|first|now|the)/i,
+    /^(?:First|Next|Then|Now)[,.]?\s+(?:I|let|we)/i,
+    /^(?:Thinking\s+about|Considering)/i,
+    /^I(?:'ll|\s+will|\s+should)\s+(?:first|now|start|begin|try)/i,
+    /^(?:Debug|Checking|Verifying|Looking\s+at):/i
+  ];
+  REASONING_CONTINUATION_PATTERNS = [
+    /^And\s+(?:then|I|now|so)/i,
+    /^But\s+(?:I|first|wait|actually)/i,
+    /^Actually[,.]?\s+/i,
+    /^\d+\.\s+(?:I|First|Check|Run|Create|Update|Read)/i
+  ];
   GeminiAdapter = class GeminiAdapter extends BaseModelAdapter {
     thoughtSignatures = new Map;
+    reasoningBuffer = [];
+    inReasoningBlock = false;
+    reasoningBlockDepth = 0;
     processTextContent(textContent, accumulatedText) {
+      if (!textContent || textContent.trim() === "") {
+        return { cleanedText: textContent, extractedToolCalls: [], wasTransformed: false };
+      }
+      const lines = textContent.split(`
+`);
+      const cleanedLines = [];
+      let wasFiltered = false;
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+          cleanedLines.push(line);
+          continue;
+        }
+        const isReasoning = this.isReasoningLine(trimmed);
+        if (isReasoning) {
+          log(`[GeminiAdapter] Filtered reasoning: "${trimmed.substring(0, 50)}..."`);
+          wasFiltered = true;
+          this.inReasoningBlock = true;
+          this.reasoningBlockDepth++;
+          continue;
+        }
+        if (this.inReasoningBlock && this.isReasoningContinuation(trimmed)) {
+          log(`[GeminiAdapter] Filtered reasoning continuation: "${trimmed.substring(0, 50)}..."`);
+          wasFiltered = true;
+          continue;
+        }
+        if (this.inReasoningBlock && trimmed.length > 20 && !this.isReasoningContinuation(trimmed)) {
+          this.inReasoningBlock = false;
+          this.reasoningBlockDepth = 0;
+        }
+        cleanedLines.push(line);
+      }
+      const cleanedText = cleanedLines.join(`
+`);
       return {
-        cleanedText: textContent,
+        cleanedText: wasFiltered ? cleanedText : textContent,
         extractedToolCalls: [],
-        wasTransformed: false
+        wasTransformed: wasFiltered
       };
     }
+    isReasoningLine(line) {
+      return REASONING_PATTERNS.some((pattern) => pattern.test(line));
+    }
+    isReasoningContinuation(line) {
+      return REASONING_CONTINUATION_PATTERNS.some((pattern) => pattern.test(line));
+    }
+    resetReasoningState() {
+      this.reasoningBuffer = [];
+      this.inReasoningBlock = false;
+      this.reasoningBlockDepth = 0;
+    }
     prepareRequest(request, originalRequest) {
       if (originalRequest.thinking) {
         const { budget_tokens } = originalRequest.thinking;
@@ -38359,6 +38429,7 @@ var init_gemini_adapter = __esm(() => {
     }
     reset() {
       this.thoughtSignatures.clear();
+      this.resetReasoningState();
     }
     shouldHandle(modelId) {
       return modelId.includes("gemini") || modelId.includes("google/");
@@ -39864,11 +39935,30 @@ class OpenRouterHandler {
     const claudePayload = payload;
     const target = this.targetModel;
     await this.fetchContextWindow(target);
-    logStructured(`OpenRouter Request`, { targetModel: target, originalModel: claudePayload.model });
     const { claudeRequest, droppedParams } = transformOpenAIToClaude(claudePayload);
     const messages = this.convertMessages(claudeRequest, target);
     const tools = this.convertTools(claudeRequest);
     const supportsReasoning = await doesModelSupportReasoning(target);
+    const systemPromptLength = typeof claudeRequest.system === "string" ? claudeRequest.system.length : 0;
+    logStructured(`OpenRouter Request`, {
+      targetModel: target,
+      originalModel: claudePayload.model,
+      messageCount: messages.length,
+      toolCount: tools.length,
+      systemPromptLength,
+      maxTokens: claudeRequest.max_tokens
+    });
+    if (getLogLevel() === "debug") {
+      const lastUserMsg = messages.filter((m) => m.role === "user").pop();
+      if (lastUserMsg) {
+        const content = typeof lastUserMsg.content === "string" ? lastUserMsg.content : JSON.stringify(lastUserMsg.content);
+        log(`[OpenRouter] Last user message: ${truncateContent(content, 500)}`);
+      }
+      if (tools.length > 0) {
+        const toolNames = tools.map((t) => t.function?.name || t.name).join(", ");
+        log(`[OpenRouter] Tools: ${toolNames}`);
+      }
+    }
     const openRouterPayload = {
       model: target,
       messages,
@@ -39903,8 +39993,12 @@ class OpenRouterHandler {
       },
       body: JSON.stringify(openRouterPayload)
     });
-    if (!response.ok)
-      return c.json({ error: await response.text() }, response.status);
+    log(`[OpenRouter] Response status: ${response.status}`);
+    if (!response.ok) {
+      const errorText = await response.text();
+      log(`[OpenRouter] Error: ${errorText}`);
+      return c.json({ error: errorText }, response.status);
+    }
     if (droppedParams.length > 0)
       c.header("X-Dropped-Params", droppedParams.join(", "));
     return this.handleStreamingResponse(c, response, adapter, target, claudeRequest);
@@ -39927,6 +40021,21 @@ class OpenRouterHandler {
       else
         messages.unshift({ role: "system", content: msg });
     }
+    if (modelId.includes("gemini") || modelId.includes("google/")) {
+      const geminiMsg = `CRITICAL INSTRUCTION FOR OUTPUT FORMAT:
+1. Keep ALL internal reasoning INTERNAL. Never output your thought process as visible text.
+2. Do NOT start responses with phrases like "Wait, I'm...", "Let me think...", "Okay, so...", "First, I need to..."
+3. Do NOT output numbered planning steps or internal debugging statements.
+4. Only output: final responses, tool calls, and code. Nothing else.
+5. When calling tools, proceed directly without announcing your intentions.
+6. Your internal thinking should use the reasoning/thinking API, not visible text output.`;
+      if (messages.length > 0 && messages[0].role === "system")
+        messages[0].content += `
+
+` + geminiMsg;
+      else
+        messages.unshift({ role: "system", content: geminiMsg });
+    }
     if (req.messages) {
       for (const msg of req.messages) {
         if (msg.role === "user")
@@ -40013,6 +40122,7 @@ class OpenRouterHandler {
     const encoder = new TextEncoder;
     const decoder = new TextDecoder;
     const middlewareManager = this.middlewareManager;
+    const writeTokens = (input, output) => this.writeTokenFile(input, output);
     const streamMetadata = new Map;
     return c.body(new ReadableStream({
       async start(controller) {
@@ -40028,13 +40138,14 @@ data: ${JSON.stringify(d)}
         let finalized = false;
         let textStarted = false;
         let textIdx = -1;
-        let reasoningStarted = false;
-        let reasoningIdx = -1;
+        let thinkingStarted = false;
+        let thinkingIdx = -1;
         let curIdx = 0;
         const tools = new Map;
         const toolIds = new Set;
         let accTxt = 0;
         let lastActivity = Date.now();
+        let accumulatedThinking = "";
         send("message_start", {
           type: "message_start",
           message: {
@@ -40057,9 +40168,9 @@ data: ${JSON.stringify(d)}
           if (finalized)
             return;
           finalized = true;
-          if (reasoningStarted) {
-            send("content_block_stop", { type: "content_block_stop", index: reasoningIdx });
-            reasoningStarted = false;
+          if (thinkingStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: thinkingIdx });
+            thinkingStarted = false;
           }
           if (textStarted) {
             send("content_block_stop", { type: "content_block_stop", index: textIdx });
@@ -40070,10 +40181,22 @@ data: ${JSON.stringify(d)}
               send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
               t.closed = true;
             }
+          if (tools.size > 0) {
+            const toolSummary = Array.from(tools.values()).map((t) => `${t.name}(${t.arguments.length} chars)`).join(", ");
+            log(`[OpenRouter] Tool calls: ${toolSummary}`);
+          }
+          if (usage) {
+            log(`[OpenRouter] Usage: prompt=${usage.prompt_tokens || 0}, completion=${usage.completion_tokens || 0}, total=${usage.total_tokens || 0}`);
+            writeTokens(usage.prompt_tokens || 0, usage.completion_tokens || 0);
+          } else {
+            log(`[OpenRouter] Warning: No usage data received from model`);
+          }
           await middlewareManager.afterStreamComplete(target, streamMetadata);
           if (reason === "error") {
+            log(`[OpenRouter] Stream error: ${err}`);
             send("error", { type: "error", error: { type: "api_error", message: err } });
           } else {
+            log(`[OpenRouter] Stream complete: ${reason}`);
             send("message_delta", { type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: usage?.completion_tokens || 0 } });
             send("message_stop", { type: "message_stop" });
           }
@@ -40121,9 +40244,38 @@ data: ${JSON.stringify(d)}
                     delta,
                     metadata: streamMetadata
                   });
+                  if (delta.reasoning_details && delta.reasoning_details.length > 0) {
+                    for (const detail of delta.reasoning_details) {
+                      if (detail.type === "reasoning.text" || detail.type === "reasoning.summary") {
+                        const thinkingContent = detail.content || detail.text || detail.summary || "";
+                        if (thinkingContent) {
+                          lastActivity = Date.now();
+                          if (!thinkingStarted) {
+                            thinkingIdx = curIdx++;
+                            send("content_block_start", {
+                              type: "content_block_start",
+                              index: thinkingIdx,
+                              content_block: { type: "thinking", thinking: "" }
+                            });
+                            thinkingStarted = true;
+                          }
+                          send("content_block_delta", {
+                            type: "content_block_delta",
+                            index: thinkingIdx,
+                            delta: { type: "thinking_delta", thinking: thinkingContent }
+                          });
+                          accumulatedThinking += thinkingContent;
+                        }
+                      }
+                    }
+                  }
                   const txt = delta.content || "";
                   if (txt) {
                     lastActivity = Date.now();
+                    if (thinkingStarted) {
+                      send("content_block_stop", { type: "content_block_stop", index: thinkingIdx });
+                      thinkingStarted = false;
+                    }
                     if (!textStarted) {
                       textIdx = curIdx++;
                       send("content_block_start", { type: "content_block_start", index: textIdx, content_block: { type: "text", text: "" } });
@@ -40139,6 +40291,10 @@ data: ${JSON.stringify(d)}
                       let t = tools.get(idx);
                       if (tc.function?.name) {
                         if (!t) {
+                          if (thinkingStarted) {
+                            send("content_block_stop", { type: "content_block_stop", index: thinkingIdx });
+                            thinkingStarted = false;
+                          }
                           if (textStarted) {
                             send("content_block_stop", { type: "content_block_stop", index: textIdx });
                             textStarted = false;
@@ -40165,6 +40321,8 @@ data: ${JSON.stringify(d)}
                       if (toolSchemas.length > 0) {
                         const validation = validateToolArguments(t.name, t.arguments, toolSchemas);
                         if (!validation.valid) {
+                          log(`[OpenRouter] Tool validation FAILED: ${t.name} - missing: ${validation.missingParams.join(", ")}`);
+                          log(`[OpenRouter] Tool args received: ${truncateContent(t.arguments, 300)}`);
                           const errorIdx = curIdx++;
                           const errorMsg = `
 
@@ -40176,6 +40334,7 @@ data: ${JSON.stringify(d)}
                           continue;
                         }
                       }
+                      log(`[OpenRouter] Tool validated: ${t.name}`);
                       send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
                       t.closed = true;
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",