graphlit-client 1.0.20250924003 → 1.0.20250924005

package/dist/streaming/providers.js

@@ -914,6 +914,9 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
     let toolArgumentTokens = 0;
     let lastEventTime = 0;
     const interTokenDelays = [];
+    // Thinking content detection state for Google
+    let hasEmittedThinkingStart = false;
+    let allThinkingContent = "";
     // Tool calling metrics
     const toolMetrics = {
         totalTools: 0,
@@ -984,14 +987,25 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
             maxOutputTokens: streamConfig.max_tokens,
         };
         if (thinkingConfig) {
-            // Google Gemini Flash 2.5+ supports thinking mode
-            // The API may use a different parameter name than Anthropic
+            // Google Gemini 2.5 supports thinking mode
+            // -1 = dynamic thinking (model decides), 0 = disabled, >0 = specific budget
+            const budget = thinkingConfig.budget_tokens === 0 ? 0 :
+                thinkingConfig.budget_tokens || -1; // Default to dynamic if not specified
+            generationConfig.thinkingConfig = {
+                thinkingBudget: budget,
+                includeThoughts: budget !== 0, // Include thoughts unless explicitly disabled
+            };
             if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-                console.log(`🧠 [Google] Extended thinking enabled | Budget: ${thinkingConfig.budget_tokens} tokens`);
+                const mode = budget === -1 ? "dynamic" : budget === 0 ? "disabled" : `${budget} tokens`;
+                console.log(`🧠 [Google] Thinking mode: ${mode} | Include thoughts: ${budget !== 0}`);
             }
-            // Note: Google's thinking API implementation may differ from Anthropic
-            // This is a placeholder for when Google releases their thinking API
-            // generationConfig.thinking = { enabled: true, maxTokens: thinkingConfig.budget_tokens };
+        }
+        else {
+            // Explicitly disable thinking when not configured
+            generationConfig.thinkingConfig = {
+                thinkingBudget: 0, // Disable thinking by setting budget to 0
+                includeThoughts: false,
+            };
         }
         const model = googleClient.getGenerativeModel({
             model: modelName,
@@ -1004,6 +1018,23 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
         const chat = model.startChat({ history });
         const result = await chat.sendMessageStream(prompt);
         for await (const chunk of result.stream) {
+            // Check for thought parts in streaming chunks first (Google's thinking API)
+            if (thinkingConfig && chunk.candidates?.[0]?.content?.parts) {
+                for (const part of chunk.candidates[0].content.parts) {
+                    if (part.thought && part.text) {
+                        // Emit thinking content as reasoning events
+                        if (!hasEmittedThinkingStart) {
+                            onEvent({ type: "reasoning_start", format: "markdown" });
+                            hasEmittedThinkingStart = true;
+                            allThinkingContent = "";
+                        }
+                        allThinkingContent += part.text + "\n";
+                        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                            console.log(`[Google] Streaming thought part: ${part.text.length} chars`);
+                        }
+                    }
+                }
+            }
             const text = chunk.text();
             if (text) {
                 fullMessage += text;
@@ -1126,7 +1157,47 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
                 console.log(`[Google] Processing final response with ${candidate.content.parts.length} parts`);
             }
             if (candidate?.content?.parts) {
+                let collectedThoughts = "";
+                let hasThoughts = false;
+                // First pass: collect all thought parts from final response
                 for (const part of candidate.content.parts) {
+                    // Check for thinking/thought parts (Google's thinking API)
+                    if (part.thought && thinkingConfig) {
+                        hasThoughts = true;
+                        collectedThoughts += (part.text || "") + "\n";
+                        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                            console.log(`[Google] Found thought part in final response: ${part.text?.length || 0} chars`);
+                        }
+                    }
+                }
+                // Emit thinking events if we found thoughts
+                if (hasThoughts && collectedThoughts) {
+                    if (!hasEmittedThinkingStart) {
+                        onEvent({ type: "reasoning_start", format: "markdown" });
+                    }
+                    // Combine with any streaming thoughts
+                    const finalThoughts = allThinkingContent + collectedThoughts;
+                    onEvent({
+                        type: "reasoning_end",
+                        fullContent: finalThoughts.trim(),
+                    });
+                    if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                        console.log(`[Google] Emitted complete thinking: ${finalThoughts.length} chars`);
+                    }
+                }
+                else if (hasEmittedThinkingStart && allThinkingContent) {
+                    // Close thinking from streaming if no final thoughts
+                    onEvent({
+                        type: "reasoning_end",
+                        fullContent: allThinkingContent.trim(),
+                    });
+                }
+                // Second pass: handle regular text parts
+                for (const part of candidate.content.parts) {
+                    // Skip thought parts - we already handled them
+                    if (part.thought) {
+                        continue;
+                    }
                     // Check for any final text we might have missed
                     if (part.text) {
                         const finalText = part.text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20250924003",
+  "version": "1.0.20250924005",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",