@blaxel/langgraph 0.2.23-dev.174 → 0.2.23

package/dist/model/cohere.d.ts

@@ -0,0 +1,6 @@
+import { FetchFunction } from "cohere-ai/core";
+/**
+ * Creates a custom fetcher for CohereClient that adds dynamic headers
+ * CohereClient's fetcher expects a function that intercepts fetch requests
+ */
+export declare const createCohereFetcher: () => FetchFunction;

package/dist/model/cohere.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCohereFetcher = void 0;
+const core_1 = require("@blaxel/core");
+/**
+ * Creates a custom fetcher for CohereClient that adds dynamic headers
+ * CohereClient's fetcher expects a function that intercepts fetch requests
+ */
+const createCohereFetcher = () => {
+    // Return a function that matches CohereClient's FetchFunction interface
+    const fetcher = async (args) => {
+        await (0, core_1.authenticate)();
+        const dynamicHeaders = core_1.settings.headers;
+        // 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;
+        if (queryParameters) {
+            const params = new URLSearchParams();
+            Object.entries(queryParameters).forEach(([key, value]) => {
+                if (Array.isArray(value)) {
+                    value.forEach(v => {
+                        if (typeof v === 'object' && v !== null) {
+                            params.append(key, JSON.stringify(v));
+                        }
+                        else {
+                            params.append(key, String(v));
+                        }
+                    });
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    params.append(key, JSON.stringify(value));
+                }
+                else {
+                    params.append(key, String(value));
+                }
+            });
+            const queryString = params.toString();
+            if (queryString) {
+                requestUrl += (url.includes('?') ? '&' : '?') + queryString;
+            }
+        }
+        // Merge headers and filter out undefined values
+        const mergedHeaders = {
+            ...(argsHeaders || {}),
+            ...dynamicHeaders,
+        };
+        // Add content-type if specified
+        if (contentType) {
+            mergedHeaders['Content-Type'] = contentType;
+        }
+        // Filter out undefined values
+        const headers = Object.entries(mergedHeaders).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = value;
+            }
+            return acc;
+        }, {});
+        // Prepare body based on requestType
+        let requestBody;
+        if (body !== undefined) {
+            if (requestType === 'json' || !requestType) {
+                requestBody = JSON.stringify(body);
+            }
+            else if (requestType === 'bytes' && body instanceof Uint8Array) {
+                // Create a new ArrayBuffer from the Uint8Array to avoid SharedArrayBuffer issues
+                const arrayBuffer = new ArrayBuffer(body.length);
+                const view = new Uint8Array(arrayBuffer);
+                view.set(body);
+                requestBody = arrayBuffer;
+            }
+            else if (requestType === 'file' && body instanceof Blob) {
+                requestBody = body;
+            }
+            else if (typeof body === 'string') {
+                requestBody = body;
+            }
+            else {
+                requestBody = JSON.stringify(body);
+            }
+        }
+        try {
+            // Create abort controller for timeout
+            const controller = new AbortController();
+            let timeoutId;
+            if (timeoutMs) {
+                timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            }
+            // Merge abort signals
+            const signal = abortSignal
+                ? AbortSignal.any([abortSignal, controller.signal])
+                : controller.signal;
+            // Make the request with merged headers
+            const requestInit = {
+                method: method,
+                headers,
+                body: requestBody,
+                credentials: withCredentials ? 'include' : 'same-origin',
+                signal,
+            };
+            // Add duplex if specified (for streaming)
+            if (duplex) {
+                requestInit.duplex = duplex;
+            }
+            const response = await fetch(requestUrl, requestInit);
+            // Clear timeout
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            // Handle response based on responseType
+            let responseBody;
+            if (response.ok) {
+                if (responseType === 'blob') {
+                    responseBody = await response.blob();
+                }
+                else if (responseType === 'text') {
+                    responseBody = await response.text();
+                }
+                else if (responseType === 'arrayBuffer') {
+                    responseBody = await response.arrayBuffer();
+                }
+                else if (responseType === 'streaming' || responseType === 'sse') {
+                    // For streaming, return the response body stream
+                    responseBody = response.body;
+                }
+                else {
+                    // Default to JSON
+                    responseBody = await response.json();
+                }
+                // Return success response in the format CohereClient expects
+                return {
+                    ok: true,
+                    body: responseBody,
+                    headers: Object.fromEntries(response.headers.entries()),
+                };
+            }
+            else {
+                // Return error response in the format CohereClient expects
+                const errorBody = await response.text();
+                return {
+                    ok: false,
+                    error: {
+                        reason: "status-code",
+                        statusCode: response.status,
+                        body: errorBody,
+                    },
+                };
+            }
+        }
+        catch (error) {
+            // Check if it's a timeout error
+            if (error instanceof Error && error.name === 'AbortError') {
+                return {
+                    ok: false,
+                    error: {
+                        reason: "timeout",
+                    },
+                };
+            }
+            // Return unknown error
+            return {
+                ok: false,
+                error: {
+                    reason: "unknown",
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    };
+    return fetcher;
+};
+exports.createCohereFetcher = createCohereFetcher;

package/dist/model/google-genai/chat_models.d.ts

@@ -1,4 +1,4 @@
-import { GenerateContentRequest, Part as GenerativeAIPart, ModelParams, RequestOptions, SafetySetting, type CachedContent } from "@google/generative-ai";
+import { GenerateContentRequest, Part as GenerativeAIPart, GenerativeModel, ModelParams, RequestOptions, SafetySetting, type CachedContent } from "@google/generative-ai";
 import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
 import { BaseLanguageModelInput, StructuredOutputMethodOptions } from "@langchain/core/language_models/base";
 import { BaseChatModel, type BaseChatModelCallOptions, type BaseChatModelParams, type LangSmithParams } from "@langchain/core/language_models/chat_models";
@@ -532,9 +532,12 @@ export declare class ChatGoogleGenerativeAI extends BaseChatModel<GoogleGenerati
     streaming: boolean;
     streamUsage: boolean;
     convertSystemMessageToHumanContent: boolean | undefined;
-    private client;
+    baseUrl?: string;
+    apiVersion?: string;
+    client: GenerativeModel;
     get _isMultimodalModel(): boolean;
     constructor(fields?: GoogleGenerativeAIChatInput);
+    initClient(fields?: GoogleGenerativeAIChatInput): GenerativeModel;
     useCachedContent(cachedContent: CachedContent, modelParams?: ModelParams, requestOptions?: RequestOptions): void;
     get useSystemInstruction(): boolean;
     get computeUseSystemInstruction(): boolean;

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

@@ -418,6 +418,8 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
     streaming = false;
     streamUsage = true;
     convertSystemMessageToHumanContent;
+    baseUrl;
+    apiVersion;
     client;
     get _isMultimodalModel() {
         return (this.model.includes("vision") ||
@@ -452,12 +454,8 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
         }
         this.stopSequences = fields?.stopSequences ?? this.stopSequences;
         this.apiKey = fields?.apiKey ?? (0, env_1.getEnvironmentVariable)("GOOGLE_API_KEY");
-        if (!this.apiKey) {
-            throw new Error("Please set an API key for Google GenerativeAI " +
-                "in the environment variable GOOGLE_API_KEY " +
-                "or in the `apiKey` field of the " +
-                "ChatGoogleGenerativeAI constructor");
-        }
+        this.apiVersion = fields?.apiVersion ?? this.apiVersion;
+        this.baseUrl = fields?.baseUrl ?? this.baseUrl;
         this.safetySettings = fields?.safetySettings ?? this.safetySettings;
         if (this.safetySettings && this.safetySettings.length > 0) {
             const safetySettingsSet = new Set(this.safetySettings.map((s) => s.category));
@@ -466,7 +464,15 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
             }
         }
         this.streaming = fields?.streaming ?? this.streaming;
-        this.client = new generative_ai_1.GoogleGenerativeAI(this.apiKey).getGenerativeModel({
+        this.client = this.initClient(fields);
+        this.streamUsage = fields?.streamUsage ?? this.streamUsage;
+    }
+    initClient(fields) {
+        const apiKey = this.apiKey ? this.apiKey : "replaced";
+        const apiVersion = this.apiVersion ?? fields?.apiVersion;
+        const baseUrl = this.baseUrl ?? fields?.baseUrl;
+        const customHeaders = this.customHeaders ?? fields?.customHeaders;
+        return new generative_ai_1.GoogleGenerativeAI(apiKey).getGenerativeModel({
             model: this.model,
             safetySettings: this.safetySettings,
             generationConfig: {
@@ -479,11 +485,10 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
                 ...(fields?.json ? { responseMimeType: "application/json" } : {}),
             },
         }, {
-            apiVersion: fields?.apiVersion,
-            baseUrl: fields?.baseUrl,
-            customHeaders: fields?.customHeaders,
+            apiVersion,
+            baseUrl: baseUrl,
+            customHeaders: customHeaders,
         });
-        this.streamUsage = fields?.streamUsage ?? this.streamUsage;
     }
     useCachedContent(cachedContent, modelParams, requestOptions) {
         if (!this.apiKey)

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

@@ -0,0 +1,11 @@
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { BaseMessage } from "@langchain/core/messages";
+import { ChatResult } from "@langchain/core/outputs";
+import { ChatGoogleGenerativeAI } from "./google-genai/index.js";
+/**
+ * Custom ChatGoogleGenerativeAI that ensures authentication before each request
+ */
+export declare class AuthenticatedChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
+    _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    _streamResponseChunks(messages: BaseMessage[], options?: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<any>;
+}

package/dist/model/google-genai.js

@@ -0,0 +1,30 @@
+"use strict";
+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");
+/**
+ * Custom ChatGoogleGenerativeAI that ensures authentication before each request
+ */
+class AuthenticatedChatGoogleGenerativeAI extends index_js_1.ChatGoogleGenerativeAI {
+    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();
+        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);
+    }
+}
+exports.AuthenticatedChatGoogleGenerativeAI = AuthenticatedChatGoogleGenerativeAI;

package/dist/model.js

@@ -7,8 +7,31 @@ const cohere_1 = require("@langchain/cohere");
 const deepseek_1 = require("@langchain/deepseek");
 const openai_1 = require("@langchain/openai");
 const cohere_ai_1 = require("cohere-ai");
-const index_js_1 = require("./model/google-genai/index.js");
+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
+ * Returns a function compatible with OpenAI SDK's fetch option
+ */
+const authenticatedFetch = () => {
+    const customFetch = async (input, init) => {
+        await (0, core_1.authenticate)();
+        const dynamicHeaders = core_1.settings.headers;
+        // Merge headers: init headers take precedence over dynamic headers
+        const headers = {
+            ...dynamicHeaders,
+            ...(init?.headers || {}),
+        };
+        // Make the request with merged headers
+        return await fetch(input, {
+            ...init,
+            headers,
+        });
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return customFetch;
+};
 const blModel = async (model, options) => {
     const url = `${core_1.settings.runUrl}/${core_1.settings.workspace}/models/${model}`;
     const modelData = await (0, core_1.getModelMetadata)(model);
@@ -19,7 +42,7 @@ const blModel = async (model, options) => {
     const type = modelData?.spec?.runtime?.type || "openai";
     try {
         if (type === "gemini") {
-            return new index_js_1.ChatGoogleGenerativeAI({
+            return new google_genai_js_1.AuthenticatedChatGoogleGenerativeAI({
                 apiKey: core_1.settings.token,
                 model: modelData?.spec?.runtime?.model,
                 baseUrl: url,
@@ -29,30 +52,36 @@ const blModel = async (model, options) => {
         }
         else if (type === "mistral") {
             return new openai_1.ChatOpenAI({
-                apiKey: core_1.settings.token,
+                apiKey: "replaced",
                 model: modelData?.spec?.runtime?.model,
                 configuration: {
                     baseURL: `${url}/v1`,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    fetch: authenticatedFetch(),
                 },
                 ...options,
             });
         }
         else if (type === "cohere") {
             return new cohere_1.ChatCohere({
-                apiKey: core_1.settings.token,
+                apiKey: "replaced",
                 model: modelData?.spec?.runtime?.model,
                 client: new cohere_ai_1.CohereClient({
-                    token: core_1.settings.token,
+                    token: "replaced",
                     environment: url,
+                    fetcher: (0, cohere_js_1.createCohereFetcher)(),
                 }),
+                ...options,
             });
         }
         else if (type === "deepseek") {
             return new deepseek_1.ChatDeepSeek({
-                apiKey: core_1.settings.token,
+                apiKey: "replaced",
                 model: modelData?.spec?.runtime?.model,
                 configuration: {
                     baseURL: `${url}/v1`,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    fetch: authenticatedFetch(),
                 },
                 ...options,
             });
@@ -62,16 +91,19 @@ const blModel = async (model, options) => {
                 anthropicApiUrl: url,
                 model: modelData?.spec?.runtime?.model,
                 clientOptions: {
-                    defaultHeaders: core_1.settings.headers,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    fetch: authenticatedFetch(),
                 },
                 ...options,
             });
         }
         else if (type === "xai") {
             return new xai_js_1.ChatXAI({
-                apiKey: core_1.settings.token,
+                apiKey: "replaced",
                 configuration: {
                     baseURL: `${url}/v1`,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    fetch: authenticatedFetch(),
                 },
                 model: modelData?.spec?.runtime?.model,
                 ...options,
@@ -80,19 +112,23 @@ const blModel = async (model, options) => {
         else if (type === "cerebras") {
             // We don't use ChatCerebras because there is a problem with apiKey headers
             return new openai_1.ChatOpenAI({
-                apiKey: core_1.settings.token,
+                apiKey: "replaced",
                 model: modelData?.spec?.runtime?.model,
                 configuration: {
                     baseURL: `${url}/v1`,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    fetch: authenticatedFetch(),
                 },
                 ...options,
             });
         }
         return new openai_1.ChatOpenAI({
-            apiKey: core_1.settings.token,
+            apiKey: "replaced",
             model: modelData?.spec?.runtime?.model,
             configuration: {
                 baseURL: `${url}/v1`,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                fetch: authenticatedFetch(),
             },
             ...options,
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/langgraph",
-  "version": "0.2.23-dev.174",
+  "version": "0.2.23",
   "description": "Blaxel SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -65,7 +65,7 @@
     "langchain": "^0.3.24",
     "zod": "^3.24.3",
     "zod-to-json-schema": "^3.24.5",
-    "@blaxel/core": "0.2.23-dev.174"
+    "@blaxel/core": "0.2.23"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",