@blaxel/langgraph 0.2.50-dev.215 → 0.2.50

package/dist/esm/model/cohere.js

@@ -91,6 +91,43 @@ export const createCohereFetcher = () => {
                     if ('tool_results' in transformedObj) {
                         delete transformedObj.tool_results;
                     }
+                    // Transform tools array to ensure each tool has a 'type' field (required by Cohere v2)
+                    if ('tools' in transformedObj && Array.isArray(transformedObj.tools)) {
+                        const tools = transformedObj.tools;
+                        transformedObj.tools = tools.map((tool) => {
+                            if (typeof tool === 'object' && tool !== null) {
+                                const toolObj = tool;
+                                // If tool already has 'type' field, keep it
+                                if ('type' in toolObj) {
+                                    return toolObj;
+                                }
+                                // If tool has 'function' field (OpenAI format), wrap it with type
+                                if ('function' in toolObj) {
+                                    return {
+                                        type: 'function',
+                                        function: toolObj.function,
+                                    };
+                                }
+                                // If tool has name/description/parameters (direct format), wrap it
+                                if ('name' in toolObj && ('description' in toolObj || 'parameters' in toolObj)) {
+                                    return {
+                                        type: 'function',
+                                        function: {
+                                            name: toolObj.name,
+                                            description: toolObj.description || '',
+                                            parameters: toolObj.parameters || toolObj.inputSchema || {},
+                                        },
+                                    };
+                                }
+                                // Default: add type field
+                                return {
+                                    type: 'function',
+                                    ...toolObj,
+                                };
+                            }
+                            return tool;
+                        });
+                    }
                 }
                 requestBody = JSON.stringify(transformedBody);
             }
@@ -131,6 +168,43 @@ export const createCohereFetcher = () => {
                                 }
                                 delete transformed.message;
                             }
+                            // Transform tools array to ensure each tool has a 'type' field (required by Cohere v2)
+                            if ('tools' in transformed && Array.isArray(transformed.tools)) {
+                                const tools = transformed.tools;
+                                transformed.tools = tools.map((tool) => {
+                                    if (typeof tool === 'object' && tool !== null) {
+                                        const toolObj = tool;
+                                        // If tool already has 'type' field, keep it
+                                        if ('type' in toolObj) {
+                                            return toolObj;
+                                        }
+                                        // If tool has 'function' field (OpenAI format), wrap it with type
+                                        if ('function' in toolObj) {
+                                            return {
+                                                type: 'function',
+                                                function: toolObj.function,
+                                            };
+                                        }
+                                        // If tool has name/description/parameters (direct format), wrap it
+                                        if ('name' in toolObj && ('description' in toolObj || 'parameters' in toolObj)) {
+                                            return {
+                                                type: 'function',
+                                                function: {
+                                                    name: toolObj.name,
+                                                    description: toolObj.description || '',
+                                                    parameters: toolObj.parameters || toolObj.inputSchema || {},
+                                                },
+                                            };
+                                        }
+                                        // Default: add type field
+                                        return {
+                                            type: 'function',
+                                            ...toolObj,
+                                        };
+                                    }
+                                    return tool;
+                                });
+                            }
                             requestBody = JSON.stringify(transformed);
                         }
                         else {

package/dist/esm/model/google-genai.js

@@ -1,26 +1,89 @@
 import { authenticate, settings } from "@blaxel/core";
-import { ChatGoogleGenerativeAI } from "./google-genai/index.js";
+import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
+import { GoogleGenerativeAI as GenerativeAI } from "@google/generative-ai";
 /**
  * Custom ChatGoogleGenerativeAI that ensures authentication before each request
+ * and supports custom headers without modifying the library code
  */
 export class AuthenticatedChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
+    customHeaders;
+    constructorParams;
+    constructor(fields) {
+        super(fields);
+        // Store constructor parameters for recreating the client
+        this.constructorParams = {
+            apiKey: fields.apiKey,
+            apiVersion: fields.apiVersion,
+            baseUrl: fields.baseUrl,
+            model: fields.model,
+            safetySettings: fields.safetySettings,
+            stopSequences: fields.stopSequences,
+            maxOutputTokens: fields.maxOutputTokens,
+            temperature: fields.temperature,
+            topP: fields.topP,
+            topK: fields.topK,
+            json: fields.json,
+            thinkingConfig: fields.thinkingConfig,
+        };
+        this.customHeaders = fields.customHeaders;
+        // Initialize client with custom headers if provided
+        if (this.customHeaders) {
+            this.recreateClient();
+        }
+    }
+    /**
+     * Recreates the client with updated custom headers
+     * Uses type assertion to access the private client property
+     */
+    recreateClient() {
+        const apiKey = this.constructorParams.apiKey || this.apiKey;
+        if (!apiKey)
+            return;
+        // Get the processed model name from the base class (it removes "models/" prefix)
+        const model = this.model || this.constructorParams.model.replace(/^models\//, "");
+        const modelParams = {
+            model,
+            safetySettings: this.constructorParams.safetySettings,
+            generationConfig: {
+                candidateCount: 1,
+                stopSequences: this.constructorParams.stopSequences,
+                maxOutputTokens: this.constructorParams.maxOutputTokens,
+                temperature: this.constructorParams.temperature,
+                topP: this.constructorParams.topP,
+                topK: this.constructorParams.topK,
+                ...(this.constructorParams.json ? { responseMimeType: "application/json" } : {}),
+                ...(this.constructorParams.thinkingConfig
+                    ? { thinkingConfig: this.constructorParams.thinkingConfig }
+                    : {}),
+            },
+        };
+        const requestOptions = {
+            apiVersion: this.constructorParams.apiVersion,
+            baseUrl: this.constructorParams.baseUrl,
+            customHeaders: this.customHeaders,
+        };
+        // Use type assertion to access private client property
+        this.client = new GenerativeAI(apiKey).getGenerativeModel(modelParams, requestOptions);
+    }
     async _generate(messages, options, runManager) {
         // Authenticate before making the request
         await authenticate();
-        this.customHeaders = {};
-        for (const header in settings.headers) {
-            this.customHeaders[header] = settings.headers[header];
-        }
-        this.client = this.initClient();
+        // Update custom headers from settings
+        this.customHeaders = { ...settings.headers };
+        // Recreate client with updated headers
+        this.recreateClient();
         return await super._generate(messages, options || {}, runManager);
     }
     async *_streamResponseChunks(messages, options, runManager) {
         // Authenticate before making the request
         await authenticate();
-        this.customHeaders = {};
-        for (const header in settings.headers) {
-            this.customHeaders[header] = settings.headers[header];
-        }
-        yield* super._streamResponseChunks(messages, options || {}, runManager);
+        // Update custom headers from settings
+        this.customHeaders = { ...settings.headers };
+        // Recreate client with updated headers
+        this.recreateClient();
+        yield* super._streamResponseChunks(messages, options, runManager);
+    }
+    bindTools(tools, kwargs) {
+        return super.bindTools(tools, kwargs);
     }
 }

package/dist/esm/model.js

@@ -3,9 +3,9 @@ import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatCohere } from "@langchain/cohere";
 import { ChatDeepSeek } from "@langchain/deepseek";
 import { ChatOpenAI } from "@langchain/openai";
+import { AuthenticatedChatGoogleGenerativeAI } from "./model/google-genai.js";
 import { CohereClient } from "cohere-ai";
 import { createCohereFetcher } from "./model/cohere.js";
-import { AuthenticatedChatGoogleGenerativeAI } from "./model/google-genai.js";
 import { ChatXAI } from "./model/xai.js";
 /**
  * Creates a custom fetch function that adds dynamic headers to each request

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/langgraph",
-  "version": "0.2.50-dev.215",
+  "version": "0.2.50",
   "description": "Blaxel SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -45,6 +45,7 @@
     "@langchain/cohere": "^1.0.0",
     "@langchain/core": "^1.0.6",
     "@langchain/deepseek": "^1.0.1",
+    "@langchain/google-genai": "^1.0.3",
     "@langchain/openai": "^1.1.2",
     "@opentelemetry/instrumentation": "^0.200.0",
     "@traceloop/instrumentation-langchain": "^0.20.0",
@@ -52,7 +53,7 @@
     "langchain": "^1.0.6",
     "zod": "^3.24.3",
     "zod-to-json-schema": "^3.24.5",
-    "@blaxel/core": "0.2.50-dev.215"
+    "@blaxel/core": "0.2.50"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",