graphlit-client 1.0.20250924005 → 1.0.20250925002

package/README.md

@@ -16,6 +16,13 @@ Graphlit is a cloud platform that handles the complex parts of building AI appli
 
 ## ✨ What's New
 
+### v1.3.0 - Google SDK Migration 🔄
+
+- **BREAKING CHANGE**: Migrated from deprecated `@google/generative-ai` to new `@google/genai` SDK
+- **Improved Thinking Support** - Better detection of Google Gemini thinking/reasoning with proper `part.thought` API
+- **Enhanced Streaming** - More reliable streaming with the new Google SDK
+- **Migration Required** - See [Migration Guide](#migrating-from-google-generative-ai) below
+
 ### v1.2.0 - Reasoning & Cancellation Support 🧠
 
 - **Reasoning/Thinking Detection** - See how AI models think through problems (Bedrock Nova, Deepseek, Anthropic)
@@ -35,6 +42,7 @@ Graphlit is a cloud platform that handles the complex parts of building AI appli
 - [Quick Start](#quick-start)
 - [Installation](#installation)
 - [Setting Up](#setting-up)
+- [Migrating from @google/generative-ai](#migrating-from-google-generative-ai) 🔄
 - [Reasoning Support (New!)](#reasoning-support-new) 🧠
 - [Stream Cancellation (New!)](#stream-cancellation-new) 🛑
 - [Network Resilience](#network-resilience)
@@ -107,7 +115,7 @@ npm install openai
 npm install @anthropic-ai/sdk
 
 # For Google streaming
-npm install @google/generative-ai
+npm install @google/genai
 
 # For Groq streaming (OpenAI-compatible)
 npm install groq-sdk
@@ -155,6 +163,55 @@ AWS_ACCESS_KEY_ID=your_key
 AWS_SECRET_ACCESS_KEY=your_secret
 ```
 
+## Migrating from @google/generative-ai
+
+### ⚠️ Breaking Change in v1.3.0
+
+The deprecated `@google/generative-ai` SDK has been replaced with the new `@google/genai` SDK. This change provides better thinking/reasoning support and improved streaming reliability.
+
+### Migration Steps
+
+1. **Update your dependencies:**
+```bash
+# Remove old SDK
+npm uninstall @google/generative-ai
+
+# Install new SDK
+npm install @google/genai
+```
+
+2. **Update your client initialization:**
+```typescript
+// Old (deprecated)
+import { GoogleGenerativeAI } from "@google/generative-ai";
+const googleClient = new GoogleGenerativeAI(apiKey);
+client.setGoogleClient(googleClient);
+
+// New
+import { GoogleGenAI } from "@google/genai";
+const googleClient = new GoogleGenAI({ apiKey });
+client.setGoogleClient(googleClient);
+```
+
+3. **No other code changes required!**
+   - The Graphlit SDK handles all the API differences internally
+   - Your existing specifications and conversations will continue to work
+   - Thinking/reasoning detection is now more reliable with proper `part.thought` support
+
+### Why the Migration?
+
+- The `@google/generative-ai` SDK is deprecated by Google
+- New SDK provides better support for Gemini 2.x features including thinking mode
+- Improved streaming performance and reliability
+- Proper detection of thought parts without markdown parsing hacks
+
+### Benefits
+
+- **Better Thinking Detection**: Properly detects and separates thinking content using Google's official API
+- **Improved Performance**: More efficient streaming with the new SDK architecture
+- **Future-Proof**: Ensures compatibility with upcoming Gemini models and features
+- **Cleaner API**: Simplified configuration and better TypeScript types
+
 ## Reasoning Support (New!) 🧠
 
 The SDK can detect and expose AI reasoning processes, showing you how models "think" through problems. This feature works with models that support reasoning output.
@@ -308,6 +365,7 @@ The SDK includes automatic retry logic for network errors and transient failures
 By default, the client will automatically retry on these status codes:
 
 - `429` - Too Many Requests
+- `500` - Internal Server Error
 - `502` - Bad Gateway
 - `503` - Service Unavailable
 - `504` - Gateway Timeout
@@ -380,7 +438,7 @@ The Graphlit SDK supports real-time streaming responses from 9 different LLM pro
 | --------------- | --------------------------------------------- | --------------------------------- | ------------------- |
 | **OpenAI**      | GPT-4, GPT-4o, GPT-4.1, O1, O3, O4            | `openai`                          | `OPENAI_API_KEY`    |
 | **Anthropic**   | Claude 3, Claude 3.5, Claude 3.7, Claude 4    | `@anthropic-ai/sdk`               | `ANTHROPIC_API_KEY` |
-| **Google**      | Gemini 1.5, Gemini 2.0, Gemini 2.5            | `@google/generative-ai`           | `GOOGLE_API_KEY`    |
+| **Google**      | Gemini 1.5, Gemini 2.0, Gemini 2.5            | `@google/genai`                   | `GOOGLE_API_KEY`    |
 | **Groq**        | Llama 4, Llama 3.3, Mixtral, Deepseek R1      | `groq-sdk`                        | `GROQ_API_KEY`      |
 | **Cerebras**    | Llama 3.3, Llama 3.1                          | `openai`                          | `CEREBRAS_API_KEY`  |
 | **Cohere**      | Command R+, Command R, Command R7B, Command A | `cohere-ai`                       | `COHERE_API_KEY`    |

package/dist/client.d.ts

@@ -63,7 +63,7 @@ declare class Graphlit {
     setAnthropicClient(client: any): void;
     /**
      * Set a custom Google Generative AI client instance for streaming
-     * @param client - Google GenerativeAI client instance (e.g., new GoogleGenerativeAI(apiKey))
+     * @param client - Google GenAI client instance (e.g., new GoogleGenAI({apiKey}))
      */
     setGoogleClient(client: any): void;
     /**

package/dist/client.js

@@ -17,7 +17,7 @@ import { createRequire } from "node:module";
 const optionalRequire = createRequire(import.meta.url);
 let OpenAI;
 let Anthropic;
-let GoogleGenerativeAI;
+let GoogleGenAI;
 let Groq;
 let CohereClient;
 let CohereClientV2;
@@ -51,15 +51,15 @@ catch (e) {
     }
 }
 try {
-    GoogleGenerativeAI = optionalRequire("@google/generative-ai").GoogleGenerativeAI;
+    GoogleGenAI = optionalRequire("@google/genai").GoogleGenAI;
     if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
-        console.log("[SDK Loading] Google Generative AI SDK loaded successfully");
+        console.log("[SDK Loading] Google Gen AI SDK loaded successfully");
     }
 }
 catch (e) {
-    // Google Generative AI not installed
+    // Google Gen AI not installed
     if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
-        console.log("[SDK Loading] Google Generative AI SDK not found:", e.message);
+        console.log("[SDK Loading] Google Gen AI SDK not found:", e.message);
     }
 }
 try {
@@ -205,7 +205,7 @@ class Graphlit {
             maxAttempts: 5,
             initialDelay: 300,
             maxDelay: 30000,
-            retryableStatusCodes: [429, 502, 503, 504],
+            retryableStatusCodes: [429, 500, 502, 503, 504],
             jitter: true,
             ...options.retryConfig,
         };
@@ -321,7 +321,7 @@ class Graphlit {
     }
     /**
      * Set a custom Google Generative AI client instance for streaming
-     * @param client - Google GenerativeAI client instance (e.g., new GoogleGenerativeAI(apiKey))
+     * @param client - Google GenAI client instance (e.g., new GoogleGenAI({apiKey}))
      */
     setGoogleClient(client) {
         this.googleClient = client;
@@ -1832,7 +1832,7 @@ class Graphlit {
                     instanceOpenAI: this.openaiClient !== undefined,
                     moduleAnthropic: Anthropic !== undefined,
                     instanceAnthropic: this.anthropicClient !== undefined,
-                    moduleGoogle: GoogleGenerativeAI !== undefined,
+                    moduleGoogle: GoogleGenAI !== undefined,
                     instanceGoogle: this.googleClient !== undefined,
                 });
             }
@@ -1842,7 +1842,7 @@ class Graphlit {
                 case Types.ModelServiceTypes.Anthropic:
                     return Anthropic !== undefined || this.anthropicClient !== undefined;
                 case Types.ModelServiceTypes.Google:
-                    return (GoogleGenerativeAI !== undefined || this.googleClient !== undefined);
+                    return (GoogleGenAI !== undefined || this.googleClient !== undefined);
                 case Types.ModelServiceTypes.Groq:
                     return Groq !== undefined || this.groqClient !== undefined;
                 case Types.ModelServiceTypes.Cerebras:
@@ -1880,7 +1880,7 @@ class Graphlit {
         // Check both module-level SDKs and instance-level clients
         const hasOpenAI = OpenAI !== undefined || this.openaiClient !== undefined;
         const hasAnthropic = Anthropic !== undefined || this.anthropicClient !== undefined;
-        const hasGoogle = GoogleGenerativeAI !== undefined || this.googleClient !== undefined;
+        const hasGoogle = GoogleGenAI !== undefined || this.googleClient !== undefined;
         const hasGroq = Groq !== undefined || this.groqClient !== undefined;
         const hasCerebras = Cerebras !== undefined || this.cerebrasClient !== undefined;
         const hasCohere = CohereClient !== undefined ||
@@ -2338,7 +2338,7 @@ class Graphlit {
                 console.log(`\n🔀 [Streaming Decision] Service: ${serviceType}, Round: ${currentRound}`);
                 console.log(`   OpenAI available: ${!!(OpenAI || this.openaiClient)}`);
                 console.log(`   Anthropic available: ${!!(Anthropic || this.anthropicClient)}`);
-                console.log(`   Google available: ${!!(GoogleGenerativeAI || this.googleClient)}`);
+                console.log(`   Google available: ${!!(GoogleGenAI || this.googleClient)}`);
             }
             if (serviceType === Types.ModelServiceTypes.OpenAi &&
                 (OpenAI || this.openaiClient)) {
@@ -2381,7 +2381,7 @@ class Graphlit {
                 }
             }
             else if (serviceType === Types.ModelServiceTypes.Google &&
-                (GoogleGenerativeAI || this.googleClient)) {
+                (GoogleGenAI || this.googleClient)) {
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n✅ [Streaming] Using Google native streaming (Round ${currentRound})`);
                 }
@@ -2959,13 +2959,13 @@ class Graphlit {
      */
     async streamWithGoogle(specification, messages, systemPrompt, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Google module or a provided client
-        if (!GoogleGenerativeAI && !this.googleClient) {
+        if (!GoogleGenAI && !this.googleClient) {
             throw new Error("Google GenerativeAI client not available");
         }
         // Use provided client or create a new one
         const googleClient = this.googleClient ||
-            (GoogleGenerativeAI
-                ? new GoogleGenerativeAI(process.env.GOOGLE_API_KEY || "")
+            (GoogleGenAI
+                ? new GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY || "" })
                 : (() => {
                     throw new Error("Google GenerativeAI module not available");
                 })());

package/dist/streaming/providers.js

@@ -1007,36 +1007,85 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
                 includeThoughts: false,
             };
         }
-        const model = googleClient.getGenerativeModel({
+        // Convert messages to Google format for the new SDK
+        // The new SDK expects contents as an array of message objects with role and parts
+        const contents = messages.map((msg) => ({
+            role: msg.role,
+            parts: msg.parts,
+        }));
+        // Build the config object for the new SDK
+        const config = {
+            ...generationConfig,
+        };
+        // Add tools to config if provided
+        if (googleTools) {
+            config.tools = googleTools;
+        }
+        // Call generateContentStream with conversation history
+        const streamResponse = await googleClient.models.generateContentStream({
             model: modelName,
-            generationConfig,
-            tools: googleTools,
+            contents: contents, // Full conversation history
+            config: config,
         });
-        // Convert messages to Google chat format
-        const history = messages.slice(0, -1); // All but last message
-        const prompt = messages[messages.length - 1]?.parts[0]?.text || "";
-        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) {
+        // Track last chunk for usage metadata
+        let lastChunk = null;
+        // Process streaming chunks
+        for await (const chunk of streamResponse) {
+            lastChunk = chunk; // Keep track for usage metadata
+            // Process parts separately to handle thought vs regular text
+            let regularText = "";
+            if (chunk.candidates?.[0]?.content?.parts) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`[Google] Chunk has ${chunk.candidates[0].content.parts.length} parts during streaming`);
+                    // Log details about each part
+                    for (let i = 0; i < chunk.candidates[0].content.parts.length; i++) {
+                        const part = chunk.candidates[0].content.parts[i];
+                        console.log(`[Google]   Part ${i}: thought=${!!part.thought}, text length=${part.text?.length || 0}`);
+                        if (part.thought && part.text) {
+                            console.log(`[Google]     THOUGHT CONTENT: "${part.text.substring(0, 100)}${part.text.length > 100 ? '...' : ''}"`);
+                        }
+                    }
+                }
                 for (const part of chunk.candidates[0].content.parts) {
-                    if (part.thought && part.text) {
-                        // Emit thinking content as reasoning events
+                    if (part.thought && part.text && thinkingConfig) {
+                        // This is a thought part - emit as reasoning only
                         if (!hasEmittedThinkingStart) {
                             onEvent({ type: "reasoning_start", format: "markdown" });
                             hasEmittedThinkingStart = true;
                             allThinkingContent = "";
+                            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                                console.log(`[Google] Started reasoning from thought part`);
+                            }
                         }
                         allThinkingContent += part.text + "\n";
+                        // Emit delta for streaming
+                        onEvent({
+                            type: "reasoning_delta",
+                            content: part.text,
+                            format: "markdown",
+                        });
                         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-                            console.log(`[Google] Streaming thought part: ${part.text.length} chars`);
+                            console.log(`[Google] Emitted reasoning delta from thought part: ${part.text.length} chars`);
+                        }
+                    }
+                    else if (!part.thought && part.text) {
+                        // Regular text part - add to message content
+                        regularText += part.text;
+                        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                            console.log(`[Google] Regular text part (NOT thought): "${part.text.substring(0, 100)}${part.text.length > 100 ? '...' : ''}"`);
                         }
                     }
                 }
             }
-            const text = chunk.text();
+            // Use regularText to avoid including thought parts
+            const text = regularText; // Only use text from non-thought parts
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING && text) {
+                console.log(`[Google] Text to add (excluding thoughts): "${text.substring(0, 100)}${text.length > 100 ? '...' : ''}" (${text.length} chars)`);
+            }
             if (text) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`[Google] Adding to fullMessage: "${text.substring(0, 50)}${text.length > 50 ? '...' : ''}" (${text.length} chars)`);
+                }
                 fullMessage += text;
                 tokenCount++;
                 const currentTime = Date.now();
@@ -1148,112 +1197,14 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
                 }
             }
         }
-        // Google might also return function calls or additional text in the final response
-        try {
-            const response = await result.response;
-            const candidate = response.candidates?.[0];
-            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING &&
-                candidate?.content?.parts) {
-                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;
-                        // Skip if this is just the complete message we already have
-                        if (finalText === fullMessage) {
-                            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-                                console.log(`[Google] Skipping duplicate final text (matches fullMessage exactly)`);
-                            }
-                            continue;
-                        }
-                        // Only add if it's not already included in fullMessage
-                        if (!fullMessage.includes(finalText) &&
-                            !fullMessage.endsWith(finalText)) {
-                            fullMessage += finalText;
-                            onEvent({
-                                type: "token",
-                                token: finalText,
-                            });
-                        }
-                    }
-                    // Check for function calls
-                    if (part.functionCall &&
-                        !toolCalls.some((tc) => tc.name === part.functionCall.name)) {
-                        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-                            console.log(`[Google] Found function call in final response: ${part.functionCall.name}`);
-                        }
-                        const toolCall = {
-                            id: `google_tool_${Date.now()}_${toolCalls.length}`,
-                            name: part.functionCall.name,
-                            arguments: JSON.stringify(part.functionCall.args || {}),
-                        };
-                        toolCalls.push(toolCall);
-                        // Emit events for function calls found in final response
-                        onEvent({
-                            type: "tool_call_start",
-                            toolCall: {
-                                id: toolCall.id,
-                                name: toolCall.name,
-                            },
-                        });
-                        onEvent({
-                            type: "tool_call_parsed",
-                            toolCall: {
-                                id: toolCall.id,
-                                name: toolCall.name,
-                                arguments: toolCall.arguments,
-                            },
-                        });
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Log parsing errors when debugging
+        // After streaming is complete, emit reasoning end if needed
+        if (hasEmittedThinkingStart && allThinkingContent) {
+            onEvent({
+                type: "reasoning_end",
+                fullContent: allThinkingContent.trim(),
+            });
             if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-                console.error(`[Google] Error processing final response:`, error);
+                console.log(`[Google] Emitted reasoning_end with ${allThinkingContent.length} chars of thinking`);
             }
         }
         // Final summary logging
@@ -1327,14 +1278,15 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
             }
             console.log(`✅ [Google] Final message (${fullMessage.length} chars): "${fullMessage}"`);
         }
-        // Try to capture usage data from final response
+        // Usage data collection - new SDK may provide this differently
+        // Check last chunk for usage metadata
         try {
-            const response = await result.response;
-            if (response.usageMetadata) {
+            // Check if last chunk has usage metadata
+            if (lastChunk?.usageMetadata) {
                 usageData = {
-                    prompt_tokens: response.usageMetadata.promptTokenCount,
-                    completion_tokens: response.usageMetadata.candidatesTokenCount,
-                    total_tokens: response.usageMetadata.totalTokenCount,
+                    prompt_tokens: lastChunk.usageMetadata.promptTokenCount,
+                    completion_tokens: lastChunk.usageMetadata.candidatesTokenCount,
+                    total_tokens: lastChunk.usageMetadata.totalTokenCount,
                 };
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`[Google] Usage data captured:`, usageData);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20250924005",
+  "version": "1.0.20250925002",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",
@@ -46,6 +46,7 @@
   "dependencies": {
     "@apollo/client": "^3.13.8",
     "@cerebras/cerebras_cloud_sdk": "^1.35.0",
+    "@google/genai": "^1.20.0",
     "@graphql-codegen/cli": "^5.0.7",
     "@graphql-codegen/typescript": "^4.1.6",
     "@graphql-codegen/typescript-operations": "^4.6.1",
@@ -60,9 +61,6 @@
     "@anthropic-ai/sdk": {
       "optional": true
     },
-    "@google/generative-ai": {
-      "optional": true
-    },
     "groq-sdk": {
       "optional": true
     },
@@ -79,7 +77,6 @@
   "optionalDependencies": {
     "@anthropic-ai/sdk": "^0.53.0",
     "@aws-sdk/client-bedrock-runtime": "^3.828.0",
-    "@google/generative-ai": "^0.24.1",
     "@mistralai/mistralai": "^1.7.2",
     "cohere-ai": "^7.17.1",
     "groq-sdk": "^0.25.0",