claudish 3.0.2 → 3.0.4

package/dist/index.js

@@ -38305,19 +38305,105 @@ 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+(?:if|that|the|this|I\s+(?:need|should|will|have|already))/i,
+    /^Wait[.!]?\s*$/i,
+    /^Let\s+me\s+(think|check|verify|see|look|analyze|consider|first|start)/i,
+    /^Let's\s+(check|see|look|start|first|try|think|verify|examine|analyze)/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+(?:first|now|start|begin|try|check|fix|look|examine|modify|create|update|read|investigate|adjust|improve|integrate|mark|also|verify|need|rethink|add|help|use|run|search|find|explore|analyze|review|test|implement|write|make|set|get|see|open|close|save|load|fetch|call|send|build|compile|execute|process|handle|parse|format|validate|clean|clear|remove|delete|move|copy|rename|install|configure|setup|initialize|prepare|work|continue|proceed|ensure|confirm)/i,
+    /^I\s+should\s+/i,
+    /^I\s+will\s+(?:first|now|start|verify|check|create|modify|look|need|also|add|help|use|run|search|find|explore|analyze|review|test|implement|write)/i,
+    /^(?:Debug|Checking|Verifying|Looking\s+at):/i,
+    /^I\s+also\s+(?:notice|need|see|want)/i,
+    /^The\s+(?:goal|issue|problem|idea|plan)\s+is/i,
+    /^In\s+the\s+(?:old|current|previous|new|existing)\s+/i,
+    /^`[^`]+`\s+(?:is|has|does|needs|should|will|doesn't|hasn't)/i
+  ];
+  REASONING_CONTINUATION_PATTERNS = [
+    /^And\s+(?:then|I|now|so)/i,
+    /^And\s+I(?:'ll|\s+will)/i,
+    /^But\s+(?:I|first|wait|actually|the|if)/i,
+    /^Actually[,.]?\s+/i,
+    /^Also[,.]?\s+(?:I|the|check|note)/i,
+    /^\d+\.\s+(?:I|First|Check|Run|Create|Update|Read|Modify|Add|Fix|Look)/i,
+    /^-\s+(?:I|First|Check|Run|Create|Update|Read|Modify|Add|Fix)/i,
+    /^Or\s+(?:I|just|we|maybe|perhaps)/i,
+    /^Since\s+(?:I|the|this|we|it)/i,
+    /^Because\s+(?:I|the|this|we|it)/i,
+    /^If\s+(?:I|the|this|we|it)\s+/i,
+    /^This\s+(?:is|means|requires|should|will|confirms|suggests)/i,
+    /^That\s+(?:means|is|should|will|explains|confirms)/i,
+    /^Lines?\s+\d+/i,
+    /^The\s+`[^`]+`\s+(?:is|has|contains|needs|should)/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;
@@ -38362,6 +38448,7 @@ var init_gemini_adapter = __esm(() => {
     }
     reset() {
       this.thoughtSignatures.clear();
+      this.resetReasoningState();
     }
     shouldHandle(modelId) {
       return modelId.includes("gemini") || modelId.includes("google/");
@@ -39953,6 +40040,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")
@@ -40055,13 +40157,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: {
@@ -40084,9 +40187,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 });
@@ -40160,9 +40263,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: "" } });
@@ -40178,6 +40310,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;

package/package.json

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