@blaxel/langgraph 0.2.36-dev.185 → 0.2.36-dev.190

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

@@ -0,0 +1,26 @@
+import { authenticate, settings } from "@blaxel/core";
+import { ChatGoogleGenerativeAI } from "./google-genai/index.js";
+/**
+ * Custom ChatGoogleGenerativeAI that ensures authentication before each request
+ */
+export class AuthenticatedChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
+    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();
+        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);
+    }
+}

package/dist/esm/model/xai.js

@@ -0,0 +1,78 @@
+import { getEnvironmentVariable } from "@langchain/core/utils/env";
+import { ChatOpenAI } from "@langchain/openai";
+/**
+ * Extends the ChatOpenAI class to create a ChatXAI agent with additional configurations.
+ */
+export class ChatXAI extends ChatOpenAI {
+    /**
+     * Returns the name of the class for LangChain serialization.
+     * @returns The class name as a string.
+     */
+    static lc_name() {
+        return "ChatXAI";
+    }
+    /**
+     * Specifies the type of the language model.
+     * @returns The type of the LLM as a string.
+     */
+    _llmType() {
+        return "xAI";
+    }
+    /**
+     * Specifies the secrets required for serialization.
+     * @returns An object mapping secret names to their keys.
+     */
+    get lc_secrets() {
+        return {
+            apiKey: "XAI_API_KEY",
+        };
+    }
+    /**
+     * Constructs a new ChatXAI instance.
+     * @param fields - Configuration fields, including the API key.
+     * @throws If the API key is not provided.
+     */
+    constructor(fields) {
+        const apiKey = fields?.apiKey || getEnvironmentVariable("XAI_API_KEY");
+        if (!apiKey) {
+            throw new Error(`xAI API key not found. Please set the XAI_API_KEY environment variable or provide the key into "apiKey" field.`);
+        }
+        super(fields);
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true,
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "chat_models", "xai"],
+        });
+    }
+    /**
+     * Serializes the instance to JSON, removing sensitive information.
+     * @returns The serialized JSON object.
+     */
+    toJSON() {
+        const result = super.toJSON();
+        if ("kwargs" in result &&
+            typeof result.kwargs === "object" &&
+            result.kwargs != null) {
+            delete result.kwargs.openai_api_key;
+            delete result.kwargs.configuration;
+        }
+        return result;
+    }
+    /**
+     * Retrieves parameters for LangChain based on provided options.
+     * @param options - Additional options for parameter retrieval.
+     * @returns An object containing LangChain parameters.
+     */
+    getLsParams(options) {
+        const params = super.getLsParams(options);
+        params.ls_provider = "xai";
+        return params;
+    }
+}

package/dist/esm/model.js

@@ -0,0 +1,137 @@
+import { authenticate, getModelMetadata, handleDynamicImportError, settings } from "@blaxel/core";
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatCohere } from "@langchain/cohere";
+import { ChatDeepSeek } from "@langchain/deepseek";
+import { ChatOpenAI } from "@langchain/openai";
+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
+ * Returns a function compatible with OpenAI SDK's fetch option
+ */
+const authenticatedFetch = () => {
+    const customFetch = async (input, init) => {
+        await authenticate();
+        const dynamicHeaders = 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;
+};
+export const blModel = async (model, options) => {
+    const url = `${settings.runUrl}/${settings.workspace}/models/${model}`;
+    const modelData = await getModelMetadata(model);
+    if (!modelData) {
+        throw new Error(`Model ${model} not found`);
+    }
+    await authenticate();
+    const type = modelData?.spec?.runtime?.type || "openai";
+    try {
+        if (type === "gemini") {
+            return new AuthenticatedChatGoogleGenerativeAI({
+                apiKey: settings.token,
+                model: modelData?.spec?.runtime?.model,
+                baseUrl: url,
+                customHeaders: settings.headers,
+                ...options,
+            });
+        }
+        else if (type === "mistral") {
+            return new ChatOpenAI({
+                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 ChatCohere({
+                apiKey: "replaced",
+                model: modelData?.spec?.runtime?.model,
+                client: new CohereClient({
+                    token: "replaced",
+                    environment: url,
+                    fetcher: createCohereFetcher(),
+                }),
+                ...options,
+            });
+        }
+        else if (type === "deepseek") {
+            return new ChatDeepSeek({
+                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 === "anthropic") {
+            return new ChatAnthropic({
+                anthropicApiUrl: url,
+                model: modelData?.spec?.runtime?.model,
+                clientOptions: {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    fetch: authenticatedFetch(),
+                },
+                ...options,
+            });
+        }
+        else if (type === "xai") {
+            return new ChatXAI({
+                apiKey: "replaced",
+                configuration: {
+                    baseURL: `${url}/v1`,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    fetch: authenticatedFetch(),
+                },
+                model: modelData?.spec?.runtime?.model,
+                ...options,
+            });
+        }
+        else if (type === "cerebras") {
+            // We don't use ChatCerebras because there is a problem with apiKey headers
+            return new ChatOpenAI({
+                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 ChatOpenAI({
+            apiKey: "replaced",
+            model: modelData?.spec?.runtime?.model,
+            configuration: {
+                baseURL: `${url}/v1`,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                fetch: authenticatedFetch(),
+            },
+            ...options,
+        });
+    }
+    catch (err) {
+        handleDynamicImportError(err);
+        throw err;
+    }
+};

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/telemetry.js

@@ -0,0 +1,19 @@
+import * as RunnableModule from "@langchain/core/runnables";
+import * as ToolsModule from "@langchain/core/tools";
+import * as VectorStoresModule from "@langchain/core/vectorstores";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { LangChainInstrumentation } from "@traceloop/instrumentation-langchain";
+import * as AgentsModule from "langchain/agents";
+import * as ChainsModule from "langchain/chains";
+const langchain = new LangChainInstrumentation();
+langchain.manuallyInstrument({
+    runnablesModule: RunnableModule,
+    toolsModule: ToolsModule,
+    chainsModule: ChainsModule,
+    agentsModule: AgentsModule,
+    vectorStoreModule: VectorStoresModule,
+});
+langchain.enable();
+registerInstrumentations({
+    instrumentations: [langchain],
+});

package/dist/esm/tools.js

@@ -0,0 +1,22 @@
+import { getTool, handleDynamicImportError } from "@blaxel/core";
+import { tool } from "@langchain/core/tools";
+export async function blTool(name, options) {
+    try {
+        const blaxelTool = await getTool(name, options);
+        return blaxelTool.map((t) => 
+        // @ts-ignore - Type instantiation depth issue with tool schemas
+        tool(t.call.bind(t), {
+            name: t.name,
+            description: t.description,
+            schema: t.inputSchema,
+        }));
+    }
+    catch (err) {
+        handleDynamicImportError(err);
+        throw err;
+    }
+}
+export async function blTools(names, ms) {
+    const toolArrays = await Promise.all(names.map((n) => blTool(n, ms)));
+    return toolArrays.flat();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/langgraph",
-  "version": "0.2.36-dev.185",
+  "version": "0.2.36-dev.190",
   "description": "Blaxel SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -17,38 +17,22 @@
     "agent",
     "mcp"
   ],
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/cjs/types/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+      "types": "./dist/cjs/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/cjs/index.js"
     },
-    "./*": {
-      "import": {
-        "types": "./dist/*.d.ts",
-        "default": "./dist/*.js"
-      },
-      "require": {
-        "types": "./dist/*.d.ts",
-        "default": "./dist/*.js"
-      }
-    }
+    "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {
       ".": [
-        "./dist/index.d.ts"
-      ],
-      "*": [
-        "./dist/*"
+        "./dist/cjs/types/index.d.ts"
       ]
     }
   },
@@ -68,7 +52,7 @@
     "langchain": "^0.3.24",
     "zod": "^3.24.3",
     "zod-to-json-schema": "^3.24.5",
-    "@blaxel/core": "0.2.36-dev.185"
+    "@blaxel/core": "0.2.36-dev.190"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",
@@ -79,6 +63,10 @@
   "scripts": {
     "lint": "eslint src/",
     "dev": "tsc --watch",
-    "build": "tsc"
+    "build": "npm run build:cjs && npm run build:esm && npm run build:fix-esm && npm run build:esm-package",
+    "build:cjs": "NODE_OPTIONS='--max-old-space-size=8192' tsc -p tsconfig.cjs.json",
+    "build:esm": "NODE_OPTIONS='--max-old-space-size=8192' tsc -p tsconfig.esm.json",
+    "build:fix-esm": "node fix-esm-imports.js",
+    "build:esm-package": "echo '{\"type\":\"module\"}' > dist/esm/package.json"
   }
 }

package/dist/telemetry.js

@@ -1,24 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const runnables_1 = __importDefault(require("@langchain/core/runnables"));
-const tools_1 = __importDefault(require("@langchain/core/tools"));
-const vectorstores_1 = __importDefault(require("@langchain/core/vectorstores"));
-const instrumentation_1 = require("@opentelemetry/instrumentation");
-const instrumentation_langchain_1 = require("@traceloop/instrumentation-langchain");
-const agents_1 = __importDefault(require("langchain/agents"));
-const chains_1 = __importDefault(require("langchain/chains"));
-const langchain = new instrumentation_langchain_1.LangChainInstrumentation();
-langchain.manuallyInstrument({
-    runnablesModule: runnables_1.default,
-    toolsModule: tools_1.default,
-    chainsModule: chains_1.default,
-    agentsModule: agents_1.default,
-    vectorStoreModule: vectorstores_1.default,
-});
-langchain.enable();
-(0, instrumentation_1.registerInstrumentations)({
-    instrumentations: [langchain],
-});