@blaxel/langgraph 0.2.49-dev.214 → 0.2.49-dev1

package/dist/model/xai.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatXAI = void 0;
+const env_1 = require("@langchain/core/utils/env");
+const openai_1 = require("@langchain/openai");
+/**
+ * Extends the ChatOpenAI class to create a ChatXAI agent with additional configurations.
+ */
+class ChatXAI extends openai_1.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 || (0, env_1.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;
+    }
+}
+exports.ChatXAI = ChatXAI;

package/dist/model.d.ts

@@ -0,0 +1,2 @@
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+export declare const blModel: (model: string, options?: Record<string, unknown>) => Promise<LanguageModelLike>;

package/dist/model.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blModel = void 0;
+const core_1 = require("@blaxel/core");
+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 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
+ * 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);
+    if (!modelData) {
+        throw new Error(`Model ${model} not found`);
+    }
+    await (0, core_1.authenticate)();
+    const type = modelData?.spec?.runtime?.type || "openai";
+    try {
+        if (type === "gemini") {
+            return new google_genai_js_1.AuthenticatedChatGoogleGenerativeAI({
+                apiKey: core_1.settings.token,
+                model: modelData?.spec?.runtime?.model,
+                baseUrl: url,
+                customHeaders: core_1.settings.headers,
+                ...options,
+            });
+        }
+        else if (type === "mistral") {
+            return new openai_1.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 cohere_1.ChatCohere({
+                apiKey: "replaced",
+                model: modelData?.spec?.runtime?.model,
+                client: new cohere_ai_1.CohereClient({
+                    token: "replaced",
+                    environment: url,
+                    fetcher: (0, cohere_js_1.createCohereFetcher)(),
+                }),
+                ...options,
+            });
+        }
+        else if (type === "deepseek") {
+            return new deepseek_1.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 anthropic_1.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 xai_js_1.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 openai_1.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 openai_1.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) {
+        (0, core_1.handleDynamicImportError)(err);
+        throw err;
+    }
+};
+exports.blModel = blModel;

package/dist/telemetry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/telemetry.js

@@ -0,0 +1,24 @@
+"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],
+});

package/dist/tools.d.ts

@@ -0,0 +1,15 @@
+import { ToolOptions } from "@blaxel/core/tools/mcpTool";
+export declare function blTool(name: string, options?: ToolOptions | number): Promise<import("@langchain/core/tools").DynamicStructuredTool<import("zod").ZodObject<any, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>, unknown, {
+    [x: string]: any;
+}>[]>;
+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;
+}>, unknown, {
+    [x: string]: any;
+}>[]>;

package/dist/tools.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blTool = blTool;
+exports.blTools = blTools;
+const core_1 = require("@blaxel/core");
+const tools_1 = require("@langchain/core/tools");
+async function blTool(name, options) {
+    try {
+        const blaxelTool = await (0, core_1.getTool)(name, options);
+        return blaxelTool.map((t) => (0, tools_1.tool)(t.call.bind(t), {
+            name: t.name,
+            description: t.description,
+            schema: t.inputSchema,
+        }));
+    }
+    catch (err) {
+        (0, core_1.handleDynamicImportError)(err);
+        throw err;
+    }
+}
+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.49-dev.214",
+  "version": "0.2.49-dev1",
   "description": "Blaxel SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -52,7 +52,7 @@
     "langchain": "^0.3.24",
     "zod": "^3.24.3",
     "zod-to-json-schema": "^3.24.5",
-    "@blaxel/core": "0.2.49-dev.214"
+    "@blaxel/core": "0.2.49-dev1"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",