@blaxel/langgraph 0.2.49 → 0.2.50-preview.115

package/dist/cjs/model/cohere.js

@@ -14,7 +14,9 @@ const createCohereFetcher = () => {
         // Extract all fields from args
         const { url, method, headers: argsHeaders, body, contentType, queryParameters, timeoutMs, withCredentials, abortSignal, requestType, responseType, duplex } = args;
         // Build URL with query parameters
-        let requestUrl = url;
+        // Rewrite /v1/chat to /v2/chat for Cohere API v2 compatibility
+        let requestUrl = url.replace('/v1/chat', '/v2/chat');
+        const isV2Endpoint = requestUrl.includes('/v2/chat');
         if (queryParameters) {
             const params = new URLSearchParams();
             Object.entries(queryParameters).forEach(([key, value]) => {
@@ -60,7 +62,77 @@ const createCohereFetcher = () => {
         let requestBody;
         if (body !== undefined) {
             if (requestType === 'json' || !requestType) {
-                requestBody = JSON.stringify(body);
+                // Transform body for Cohere v2 API compatibility (only if using v2 endpoint)
+                let transformedBody = body;
+                if (isV2Endpoint && typeof body === 'object' && body !== null && !Array.isArray(body)) {
+                    const bodyObj = body;
+                    transformedBody = { ...bodyObj };
+                    const transformedObj = transformedBody;
+                    // Remove v1-only fields that are not supported in v2
+                    const fieldsToRemove = ['chat_history'];
+                    for (const field of fieldsToRemove) {
+                        if (field in transformedObj) {
+                            delete transformedObj[field];
+                        }
+                    }
+                    // Convert 'message' to 'messages' format if message exists and messages doesn't
+                    if ('message' in transformedObj && !('messages' in transformedObj)) {
+                        const message = transformedObj.message;
+                        if (typeof message === 'string' && message.trim().length > 0) {
+                            // Convert single message string to messages array format
+                            transformedObj.messages = [
+                                {
+                                    role: 'user',
+                                    content: message,
+                                },
+                            ];
+                        }
+                        // Remove the old message field
+                        delete transformedObj.message;
+                    }
+                    // Handle tool_results - v2 might use a different format, remove for now
+                    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);
             }
             else if (requestType === 'bytes' && body instanceof Uint8Array) {
                 // Create a new ArrayBuffer from the Uint8Array to avoid SharedArrayBuffer issues
@@ -73,7 +145,82 @@ const createCohereFetcher = () => {
                 requestBody = body;
             }
             else if (typeof body === 'string') {
-                requestBody = body;
+                // Parse and transform JSON strings (only if using v2 endpoint)
+                if (isV2Endpoint) {
+                    try {
+                        const parsed = JSON.parse(body);
+                        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                            const transformed = { ...parsed };
+                            // Remove v1-only fields
+                            if ('chat_history' in transformed) {
+                                delete transformed.chat_history;
+                            }
+                            if ('tool_results' in transformed) {
+                                delete transformed.tool_results;
+                            }
+                            // Convert 'message' to 'messages' format if message exists and messages doesn't
+                            if ('message' in transformed && !('messages' in transformed)) {
+                                const message = transformed.message;
+                                if (typeof message === 'string' && message.trim().length > 0) {
+                                    transformed.messages = [
+                                        {
+                                            role: 'user',
+                                            content: message,
+                                        },
+                                    ];
+                                }
+                                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 {
+                            requestBody = body;
+                        }
+                    }
+                    catch {
+                        requestBody = body;
+                    }
+                }
+                else {
+                    requestBody = body;
+                }
             }
             else {
                 requestBody = JSON.stringify(body);
@@ -126,6 +273,41 @@ const createCohereFetcher = () => {
                 else {
                     // Default to JSON
                     responseBody = await response.json();
+                    // Transform v2 response format to v1 format for ChatCohere compatibility
+                    if (isV2Endpoint && typeof responseBody === 'object' && responseBody !== null) {
+                        const responseObj = responseBody;
+                        if ('message' in responseObj && typeof responseObj.message === 'object' && responseObj.message !== null) {
+                            const v2Message = responseObj.message;
+                            // Extract text from content array
+                            let text = '';
+                            if (Array.isArray(v2Message.content)) {
+                                const contentArray = v2Message.content;
+                                // Find the text content block
+                                const textBlock = contentArray.find((item) => item.type === 'text' && item.text);
+                                if (textBlock && textBlock.text) {
+                                    text = textBlock.text;
+                                }
+                                else {
+                                    // Fallback: join all text-like content
+                                    text = contentArray
+                                        .map((item) => item.text || item.thinking || '')
+                                        .filter(Boolean)
+                                        .join('\n');
+                                }
+                            }
+                            else if (typeof v2Message.content === 'string') {
+                                text = v2Message.content;
+                            }
+                            // Transform to v1-like format that ChatCohere expects
+                            const transformedResponse = {
+                                ...responseObj,
+                                text: text,
+                                // Keep the original message structure in case ChatCohere needs it
+                                message: responseObj.message,
+                            };
+                            responseBody = transformedResponse;
+                        }
+                    }
                 }
                 // Return success response in the format CohereClient expects
                 return {

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

@@ -2,29 +2,92 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthenticatedChatGoogleGenerativeAI = void 0;
 const core_1 = require("@blaxel/core");
-const index_js_1 = require("./google-genai/index.js");
+const google_genai_1 = require("@langchain/google-genai");
+const generative_ai_1 = require("@google/generative-ai");
 /**
  * Custom ChatGoogleGenerativeAI that ensures authentication before each request
+ * and supports custom headers without modifying the library code
  */
-class AuthenticatedChatGoogleGenerativeAI extends index_js_1.ChatGoogleGenerativeAI {
+class AuthenticatedChatGoogleGenerativeAI extends google_genai_1.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 generative_ai_1.GoogleGenerativeAI(apiKey).getGenerativeModel(modelParams, requestOptions);
+    }
     async _generate(messages, options, runManager) {
         // Authenticate before making the request
         await (0, core_1.authenticate)();
-        this.customHeaders = {};
-        for (const header in core_1.settings.headers) {
-            this.customHeaders[header] = core_1.settings.headers[header];
-        }
-        this.client = this.initClient();
+        // Update custom headers from settings
+        this.customHeaders = { ...core_1.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 (0, core_1.authenticate)();
-        this.customHeaders = {};
-        for (const header in core_1.settings.headers) {
-            this.customHeaders[header] = core_1.settings.headers[header];
-        }
-        yield* super._streamResponseChunks(messages, options || {}, runManager);
+        // Update custom headers from settings
+        this.customHeaders = { ...core_1.settings.headers };
+        // Recreate client with updated headers
+        this.recreateClient();
+        yield* super._streamResponseChunks(messages, options, runManager);
+    }
+    bindTools(tools, kwargs) {
+        return super.bindTools(tools, kwargs);
     }
 }
 exports.AuthenticatedChatGoogleGenerativeAI = AuthenticatedChatGoogleGenerativeAI;

package/dist/cjs/model.js

@@ -6,9 +6,9 @@ const anthropic_1 = require("@langchain/anthropic");
 const cohere_1 = require("@langchain/cohere");
 const deepseek_1 = require("@langchain/deepseek");
 const openai_1 = require("@langchain/openai");
+const google_genai_js_1 = require("./model/google-genai.js");
 const cohere_ai_1 = require("cohere-ai");
 const cohere_js_1 = require("./model/cohere.js");
-const google_genai_js_1 = require("./model/google-genai.js");
 const xai_js_1 = require("./model/xai.js");
 /**
  * Creates a custom fetch function that adds dynamic headers to each request
@@ -23,6 +23,24 @@ const authenticatedFetch = () => {
             ...dynamicHeaders,
             ...(init?.headers || {}),
         };
+        // Ensure Content-Type is set for JSON requests if body exists and Content-Type is not already set
+        if (init?.body && !headers['Content-Type'] && !headers['content-type']) {
+            // If body is an object, it will be serialized to JSON by fetch
+            // If body is a string, check if it looks like JSON
+            if (typeof init.body === 'string') {
+                const trimmed = init.body.trim();
+                if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+                    headers['Content-Type'] = 'application/json';
+                }
+            }
+            else {
+                // For non-string bodies (FormData, Blob, etc.), let fetch handle it
+                // For objects, assume JSON
+                if (typeof init.body === 'object' && !(init.body instanceof FormData) && !(init.body instanceof Blob)) {
+                    headers['Content-Type'] = 'application/json';
+                }
+            }
+        }
         // Make the request with merged headers
         return await fetch(input, {
             ...init,
@@ -63,6 +81,11 @@ const blModel = async (model, options) => {
             });
         }
         else if (type === "cohere") {
+            // ChatCohere requires a custom client with fetcher for:
+            // 1. Dynamic authentication headers (settings.headers)
+            // 2. Custom environment URL (url)
+            // 3. URL rewriting (v1 -> v2) and body transformation for v2 compatibility
+            // @ts-ignore Error in langgraph
             return new cohere_1.ChatCohere({
                 apiKey: "replaced",
                 model: modelData?.spec?.runtime?.model,
@@ -75,6 +98,7 @@ const blModel = async (model, options) => {
             });
         }
         else if (type === "deepseek") {
+            // @ts-ignore Error in langgraph
             return new deepseek_1.ChatDeepSeek({
                 apiKey: "replaced",
                 model: modelData?.spec?.runtime?.model,
@@ -87,9 +111,11 @@ const blModel = async (model, options) => {
             });
         }
         else if (type === "anthropic") {
+            // @ts-ignore Error in langgraph
             return new anthropic_1.ChatAnthropic({
                 anthropicApiUrl: url,
                 model: modelData?.spec?.runtime?.model,
+                apiKey: "replaced",
                 clientOptions: {
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                     fetch: authenticatedFetch(),

package/dist/cjs/telemetry.js

@@ -35,16 +35,15 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const RunnableModule = __importStar(require("@langchain/core/runnables"));
 const ToolsModule = __importStar(require("@langchain/core/tools"));
+const AgentsModule = __importStar(require("@langchain/core/agents"));
 const VectorStoresModule = __importStar(require("@langchain/core/vectorstores"));
 const instrumentation_1 = require("@opentelemetry/instrumentation");
 const instrumentation_langchain_1 = require("@traceloop/instrumentation-langchain");
-const AgentsModule = __importStar(require("langchain/agents"));
-const ChainsModule = __importStar(require("langchain/chains"));
 const langchain = new instrumentation_langchain_1.LangChainInstrumentation();
 langchain.manuallyInstrument({
+    // @ts-ignore - Type definitions may be incorrect, but the method accepts these parameters at runtime
     runnablesModule: RunnableModule,
     toolsModule: ToolsModule,
-    chainsModule: ChainsModule,
     agentsModule: AgentsModule,
     vectorStoreModule: VectorStoresModule,
 });

package/dist/cjs/types/model/google-genai.d.ts

@@ -1,11 +1,28 @@
 import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { BaseLanguageModelInput } from "@langchain/core/language_models/base";
 import { BaseMessage } from "@langchain/core/messages";
-import { ChatResult } from "@langchain/core/outputs";
-import { ChatGoogleGenerativeAI } from "./google-genai/index.js";
+import { AIMessageChunk } from "@langchain/core/messages";
+import { ChatResult, ChatGenerationChunk } from "@langchain/core/outputs";
+import { Runnable } from "@langchain/core/runnables";
+import { ChatGoogleGenerativeAI, GoogleGenerativeAIChatCallOptions, GoogleGenerativeAIChatInput } from "@langchain/google-genai";
+type GoogleGenerativeAIToolType = NonNullable<GoogleGenerativeAIChatCallOptions["tools"]>[number];
 /**
  * Custom ChatGoogleGenerativeAI that ensures authentication before each request
+ * and supports custom headers without modifying the library code
  */
 export declare class AuthenticatedChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
+    private customHeaders?;
+    private constructorParams;
+    constructor(fields: GoogleGenerativeAIChatInput & {
+        customHeaders?: Record<string, string>;
+    });
+    /**
+     * Recreates the client with updated custom headers
+     * Uses type assertion to access the private client property
+     */
+    private recreateClient;
     _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    _streamResponseChunks(messages: BaseMessage[], options?: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<any>;
+    _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    bindTools(tools: GoogleGenerativeAIToolType[], kwargs?: Partial<GoogleGenerativeAIChatCallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, GoogleGenerativeAIChatCallOptions>;
 }
+export {};

package/dist/cjs/types/model/xai.d.ts

@@ -1,4 +1,5 @@
 import { Serialized } from "@langchain/core/load/serializable";
+import { type LangSmithParams } from "@langchain/core/language_models/chat_models";
 import { ChatOpenAI } from "@langchain/openai";
 /**
  * Extends the ChatOpenAI class to create a ChatXAI agent with additional configurations.
@@ -37,5 +38,5 @@ export declare class ChatXAI extends ChatOpenAI {
      * @param options - Additional options for parameter retrieval.
      * @returns An object containing LangChain parameters.
      */
-    getLsParams(options: unknown): import("@langchain/core/language_models/chat_models").LangSmithParams;
+    getLsParams(options: unknown): LangSmithParams;
 }

package/dist/cjs/types/tools.d.ts

@@ -3,9 +3,13 @@ export declare function blTool(name: string, options?: ToolOptions | number): Pr
     [x: string]: any;
 }, {
     [x: string]: any;
-}>, any, any, unknown>[]>;
+}>, unknown, {
+    [x: string]: any;
+}, unknown>[]>;
 export declare function blTools(names: string[], ms?: number): Promise<import("@langchain/core/tools").DynamicStructuredTool<import("zod").ZodObject<any, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
     [x: string]: any;
 }, {
     [x: string]: any;
-}>, any, any, unknown>[]>;
+}>, unknown, {
+    [x: string]: any;
+}, unknown>[]>;