claudish 3.0.2 → 3.0.3

package/dist/index.js

@@ -38305,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;
@@ -38362,6 +38429,7 @@ var init_gemini_adapter = __esm(() => {
     }
     reset() {
       this.thoughtSignatures.clear();
+      this.resetReasoningState();
     }
     shouldHandle(modelId) {
       return modelId.includes("gemini") || modelId.includes("google/");
@@ -39953,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")
@@ -40055,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: {
@@ -40084,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 });
@@ -40160,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: "" } });
@@ -40178,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;

package/package.json

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