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

package/dist/model/google-genai/utils/common.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMessageAuthor = getMessageAuthor;
+exports.convertAuthorToRole = convertAuthorToRole;
+exports.convertMessageContentToParts = convertMessageContentToParts;
+exports.convertBaseMessagesToContent = convertBaseMessagesToContent;
+exports.mapGenerateContentResultToChatResult = mapGenerateContentResultToChatResult;
+exports.convertResponseContentToChatGenerationChunk = convertResponseContentToChatGenerationChunk;
+exports.convertToGenerativeAITools = convertToGenerativeAITools;
+const base_1 = require("@langchain/core/language_models/base");
+const messages_1 = require("@langchain/core/messages");
+const outputs_1 = require("@langchain/core/outputs");
+const function_calling_1 = require("@langchain/core/utils/function_calling");
+const zod_to_genai_parameters_js_1 = require("./zod_to_genai_parameters.js");
+function getMessageAuthor(message) {
+    const type = message._getType();
+    if (messages_1.ChatMessage.isInstance(message)) {
+        return message.role;
+    }
+    if (type === "tool") {
+        return type;
+    }
+    return message.name ?? type;
+}
+/**
+ * Maps a message type to a Google Generative AI chat author.
+ * @param message The message to map.
+ * @param model The model to use for mapping.
+ * @returns The message type mapped to a Google Generative AI chat author.
+ */
+function convertAuthorToRole(author) {
+    switch (author) {
+        /**
+         *  Note: Gemini currently is not supporting system messages
+         *  we will convert them to human messages and merge with following
+         * */
+        case "ai":
+        case "model": // getMessageAuthor returns message.name. code ex.: return message.name ?? type;
+            return "model";
+        case "system":
+            return "system";
+        case "human":
+            return "user";
+        case "tool":
+        case "function":
+            return "function";
+        default:
+            throw new Error(`Unknown / unsupported author: ${author}`);
+    }
+}
+function messageContentMedia(content) {
+    if ("mimeType" in content && "data" in content) {
+        return {
+            inlineData: {
+                mimeType: content.mimeType,
+                data: content.data,
+            },
+        };
+    }
+    if ("mimeType" in content && "fileUri" in content) {
+        return {
+            fileData: {
+                mimeType: content.mimeType,
+                fileUri: content.fileUri,
+            },
+        };
+    }
+    throw new Error("Invalid media content");
+}
+function convertMessageContentToParts(message, isMultimodalModel) {
+    if (typeof message.content === "string" && message.content !== "") {
+        return [{ text: message.content }];
+    }
+    let functionCalls = [];
+    let functionResponses = [];
+    let messageParts = [];
+    if ("tool_calls" in message &&
+        Array.isArray(message.tool_calls) &&
+        message.tool_calls.length > 0) {
+        functionCalls = message.tool_calls
+            .map((tc) => {
+            if (typeof tc.name === "string") {
+                return {
+                    functionCall: {
+                        name: tc.name,
+                        args: tc.args,
+                    },
+                };
+            }
+            return null;
+        })
+            .filter(Boolean);
+    }
+    else if (message.getType() === "tool" && message.name && message.content) {
+        functionResponses = [
+            {
+                functionResponse: {
+                    name: message.name,
+                    response: message.content,
+                },
+            },
+        ];
+    }
+    else if (Array.isArray(message.content)) {
+        messageParts = message.content.map((c) => {
+            if (c.type === "text") {
+                return {
+                    text: c.text,
+                };
+            }
+            else if (c.type === "executableCode") {
+                return {
+                    executableCode: c.executableCode,
+                };
+            }
+            else if (c.type === "codeExecutionResult") {
+                return {
+                    codeExecutionResult: c.codeExecutionResult,
+                };
+            }
+            if (c.type === "image_url") {
+                if (!isMultimodalModel) {
+                    throw new Error(`This model does not support images`);
+                }
+                let source;
+                if (typeof c.image_url === "string") {
+                    source = c.image_url;
+                }
+                else if (typeof c.image_url === "object" && "url" in c.image_url) {
+                    source = c.image_url.url;
+                }
+                else {
+                    throw new Error("Please provide image as base64 encoded data URL");
+                }
+                const [dm, data] = source.split(",");
+                if (!dm.startsWith("data:")) {
+                    throw new Error("Please provide image as base64 encoded data URL");
+                }
+                const [mimeType, encoding] = dm.replace(/^data:/, "").split(";");
+                if (encoding !== "base64") {
+                    throw new Error("Please provide image as base64 encoded data URL");
+                }
+                return {
+                    inlineData: {
+                        data,
+                        mimeType,
+                    },
+                };
+            }
+            else if (c.type === "media") {
+                return messageContentMedia(c);
+            }
+            else if (c.type === "tool_use") {
+                return {
+                    functionCall: {
+                        name: c.name,
+                        args: c.input,
+                    },
+                };
+            }
+            else if (c.type?.includes("/") &&
+                // Ensure it's a single slash.
+                c.type.split("/").length === 2 &&
+                "data" in c &&
+                typeof c.data === "string") {
+                return {
+                    inlineData: {
+                        mimeType: c.type,
+                        data: c.data,
+                    },
+                };
+            }
+            throw new Error(`Unknown content type ${c.type}`);
+        });
+    }
+    return [...messageParts, ...functionCalls, ...functionResponses];
+}
+function convertBaseMessagesToContent(messages, isMultimodalModel, convertSystemMessageToHumanContent = false) {
+    return messages.reduce((acc, message, index) => {
+        if (!(0, messages_1.isBaseMessage)(message)) {
+            throw new Error("Unsupported message input");
+        }
+        const author = getMessageAuthor(message);
+        if (author === "system" && index !== 0) {
+            throw new Error("System message should be the first one");
+        }
+        const role = convertAuthorToRole(author);
+        const prevContent = acc.content[acc.content.length];
+        if (!acc.mergeWithPreviousContent &&
+            prevContent &&
+            prevContent.role === role) {
+            throw new Error("Google Generative AI requires alternate messages between authors");
+        }
+        const parts = convertMessageContentToParts(message, isMultimodalModel);
+        if (acc.mergeWithPreviousContent) {
+            const prevContent = acc.content[acc.content.length - 1];
+            if (!prevContent) {
+                throw new Error("There was a problem parsing your system message. Please try a prompt without one.");
+            }
+            prevContent.parts.push(...parts);
+            return {
+                mergeWithPreviousContent: false,
+                content: acc.content,
+            };
+        }
+        let actualRole = role;
+        if (actualRole === "function" ||
+            (actualRole === "system" && !convertSystemMessageToHumanContent)) {
+            // GenerativeAI API will throw an error if the role is not "user" or "model."
+            actualRole = "user";
+        }
+        const content = {
+            role: actualRole,
+            parts,
+        };
+        return {
+            mergeWithPreviousContent: author === "system" && !convertSystemMessageToHumanContent,
+            content: [...acc.content, content],
+        };
+    }, { content: [], mergeWithPreviousContent: false }).content;
+}
+function mapGenerateContentResultToChatResult(response, extra) {
+    // if rejected or error, return empty generations with reason in filters
+    if (!response.candidates ||
+        response.candidates.length === 0 ||
+        !response.candidates[0]) {
+        return {
+            generations: [],
+            llmOutput: {
+                filters: response.promptFeedback,
+            },
+        };
+    }
+    const functionCalls = response.functionCalls();
+    const [candidate] = response.candidates;
+    const { content: candidateContent, ...generationInfo } = candidate;
+    let content;
+    if (candidateContent?.parts.length === 1 && candidateContent.parts[0].text) {
+        content = candidateContent.parts[0].text;
+    }
+    else {
+        content = candidateContent.parts.map((p) => {
+            if ("text" in p) {
+                return {
+                    type: "text",
+                    text: p.text,
+                };
+            }
+            else if ("executableCode" in p) {
+                return {
+                    type: "executableCode",
+                    executableCode: p.executableCode,
+                };
+            }
+            else if ("codeExecutionResult" in p) {
+                return {
+                    type: "codeExecutionResult",
+                    codeExecutionResult: p.codeExecutionResult,
+                };
+            }
+            return p;
+        });
+    }
+    let text = "";
+    if (typeof content === "string") {
+        text = content;
+    }
+    else if ("text" in content[0]) {
+        text = content[0].text;
+    }
+    const generation = {
+        text,
+        message: new messages_1.AIMessage({
+            content,
+            tool_calls: functionCalls?.map((fc) => ({
+                ...fc,
+                type: "tool_call",
+            })),
+            additional_kwargs: {
+                ...generationInfo,
+            },
+            usage_metadata: extra?.usageMetadata,
+        }),
+        generationInfo,
+    };
+    return {
+        generations: [generation],
+    };
+}
+function convertResponseContentToChatGenerationChunk(response, extra) {
+    if (!response.candidates || response.candidates.length === 0) {
+        return null;
+    }
+    const functionCalls = response.functionCalls();
+    const [candidate] = response.candidates;
+    const { content: candidateContent, ...generationInfo } = candidate;
+    let content;
+    // Checks if some parts do not have text. If false, it means that the content is a string.
+    if (candidateContent?.parts &&
+        candidateContent.parts.every((p) => "text" in p)) {
+        content = candidateContent.parts.map((p) => p.text).join("");
+    }
+    else if (candidateContent.parts) {
+        content = candidateContent.parts.map((p) => {
+            if ("text" in p) {
+                return {
+                    type: "text",
+                    text: p.text,
+                };
+            }
+            else if ("executableCode" in p) {
+                return {
+                    type: "executableCode",
+                    executableCode: p.executableCode,
+                };
+            }
+            else if ("codeExecutionResult" in p) {
+                return {
+                    type: "codeExecutionResult",
+                    codeExecutionResult: p.codeExecutionResult,
+                };
+            }
+            return p;
+        });
+    }
+    let text = "";
+    if (content && typeof content === "string") {
+        text = content;
+    }
+    else if (content && typeof content === "object" && "text" in content[0]) {
+        text = content[0].text;
+    }
+    const toolCallChunks = [];
+    if (functionCalls) {
+        toolCallChunks.push(...functionCalls.map((fc) => ({
+            ...fc,
+            args: JSON.stringify(fc.args),
+            index: extra.index,
+            type: "tool_call_chunk",
+        })));
+    }
+    return new outputs_1.ChatGenerationChunk({
+        text,
+        message: new messages_1.AIMessageChunk({
+            content: content || "",
+            name: !candidateContent ? undefined : candidateContent.role,
+            tool_call_chunks: toolCallChunks,
+            // Each chunk can have unique "generationInfo", and merging strategy is unclear,
+            // so leave blank for now.
+            additional_kwargs: {},
+            usage_metadata: extra.usageMetadata,
+        }),
+        generationInfo,
+    });
+}
+function isZodType(schema) {
+    return typeof schema === "object" && schema !== null && "_def" in schema;
+}
+function convertToGenerativeAITools(tools) {
+    if (tools.every((tool) => "functionDeclarations" in tool &&
+        Array.isArray(tool.functionDeclarations))) {
+        return tools;
+    }
+    return [
+        {
+            functionDeclarations: tools.map((tool) => {
+                if ((0, function_calling_1.isLangChainTool)(tool) && isZodType(tool.schema)) {
+                    const jsonSchema = (0, zod_to_genai_parameters_js_1.zodToGenerativeAIParameters)(tool.schema);
+                    return {
+                        name: tool.name,
+                        description: tool.description,
+                        parameters: jsonSchema,
+                    };
+                }
+                if ((0, base_1.isOpenAITool)(tool)) {
+                    return {
+                        name: tool.function.name,
+                        description: tool.function.description ?? `A function available to call.`,
+                        parameters: (0, zod_to_genai_parameters_js_1.jsonSchemaToGeminiParameters)(tool.function.parameters),
+                    };
+                }
+                return tool;
+            }),
+        },
+    ];
+}

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

@@ -0,0 +1,10 @@
+import { Tool as GenerativeAITool, ToolConfig } from "@google/generative-ai";
+import { ToolChoice } from "@langchain/core/language_models/chat_models";
+import { GoogleGenerativeAIToolType } from "../types.js";
+export declare function convertToolsToGenAI(tools: GoogleGenerativeAIToolType[], extra?: {
+    toolChoice?: ToolChoice;
+    allowedFunctionNames?: string[];
+}): {
+    tools: GenerativeAITool[];
+    toolConfig?: ToolConfig;
+};

package/dist/model/google-genai/utils/tools.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToolsToGenAI = convertToolsToGenAI;
+const generative_ai_1 = require("@google/generative-ai");
+const function_calling_1 = require("@langchain/core/utils/function_calling");
+const base_1 = require("@langchain/core/language_models/base");
+const common_js_1 = require("./common.js");
+const zod_to_genai_parameters_js_1 = require("./zod_to_genai_parameters.js");
+function convertToolsToGenAI(tools, extra) {
+    // Extract function declaration processing to a separate function
+    const genAITools = processTools(tools);
+    // Simplify tool config creation
+    const toolConfig = createToolConfig(genAITools, extra);
+    return { tools: genAITools, toolConfig };
+}
+function processTools(tools) {
+    let functionDeclarationTools = [];
+    const genAITools = [];
+    tools.forEach((tool) => {
+        if ((0, function_calling_1.isLangChainTool)(tool)) {
+            const [convertedTool] = (0, common_js_1.convertToGenerativeAITools)([
+                tool,
+            ]);
+            if (convertedTool.functionDeclarations) {
+                functionDeclarationTools.push(...convertedTool.functionDeclarations);
+            }
+        }
+        else if ((0, base_1.isOpenAITool)(tool)) {
+            const { functionDeclarations } = convertOpenAIToolToGenAI(tool);
+            if (functionDeclarations) {
+                functionDeclarationTools.push(...functionDeclarations);
+            }
+            else {
+                throw new Error("Failed to convert OpenAI structured tool to GenerativeAI tool");
+            }
+        }
+        else {
+            genAITools.push(tool);
+        }
+    });
+    const genAIFunctionDeclaration = genAITools.find((t) => "functionDeclarations" in t);
+    if (genAIFunctionDeclaration) {
+        return genAITools.map((tool) => {
+            if (functionDeclarationTools?.length > 0 &&
+                "functionDeclarations" in tool) {
+                const newTool = {
+                    functionDeclarations: [
+                        ...(tool.functionDeclarations || []),
+                        ...functionDeclarationTools,
+                    ],
+                };
+                // Clear the functionDeclarationTools array so it is not passed again
+                functionDeclarationTools = [];
+                return newTool;
+            }
+            return tool;
+        });
+    }
+    return [
+        ...genAITools,
+        ...(functionDeclarationTools.length > 0
+            ? [
+                {
+                    functionDeclarations: functionDeclarationTools,
+                },
+            ]
+            : []),
+    ];
+}
+function convertOpenAIToolToGenAI(tool) {
+    return {
+        functionDeclarations: [
+            {
+                name: tool.function.name,
+                description: tool.function.description,
+                parameters: (0, zod_to_genai_parameters_js_1.removeAdditionalProperties)(tool.function.parameters),
+            },
+        ],
+    };
+}
+function createToolConfig(genAITools, extra) {
+    if (!genAITools.length || !extra)
+        return undefined;
+    const { toolChoice, allowedFunctionNames } = extra;
+    const modeMap = {
+        any: generative_ai_1.FunctionCallingMode.ANY,
+        auto: generative_ai_1.FunctionCallingMode.AUTO,
+        none: generative_ai_1.FunctionCallingMode.NONE,
+    };
+    if (toolChoice && ["any", "auto", "none"].includes(toolChoice)) {
+        return {
+            functionCallingConfig: {
+                mode: modeMap[toolChoice] ?? "MODE_UNSPECIFIED",
+                allowedFunctionNames,
+            },
+        };
+    }
+    if (typeof toolChoice === "string" || allowedFunctionNames) {
+        return {
+            functionCallingConfig: {
+                mode: generative_ai_1.FunctionCallingMode.ANY,
+                allowedFunctionNames: [
+                    ...(allowedFunctionNames ?? []),
+                    ...(toolChoice && typeof toolChoice === "string" ? [toolChoice] : []),
+                ],
+            },
+        };
+    }
+    return undefined;
+}

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

@@ -0,0 +1,13 @@
+import { type SchemaType as FunctionDeclarationSchemaType, type FunctionDeclarationSchema as GenerativeAIFunctionDeclarationSchema } from "@google/generative-ai";
+import type { z } from "zod";
+export interface GenerativeAIJsonSchema extends Record<string, unknown> {
+    properties?: Record<string, GenerativeAIJsonSchema>;
+    type: FunctionDeclarationSchemaType;
+}
+export interface GenerativeAIJsonSchemaDirty extends GenerativeAIJsonSchema {
+    properties?: Record<string, GenerativeAIJsonSchemaDirty>;
+    additionalProperties?: boolean;
+}
+export declare function removeAdditionalProperties(obj: Record<string, unknown>): GenerativeAIJsonSchema;
+export declare function zodToGenerativeAIParameters(zodObj: z.ZodType<any>): GenerativeAIFunctionDeclarationSchema;
+export declare function jsonSchemaToGeminiParameters(schema: Record<string, any>): GenerativeAIFunctionDeclarationSchema;

package/dist/model/google-genai/utils/zod_to_genai_parameters.js

@@ -0,0 +1,46 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeAdditionalProperties = removeAdditionalProperties;
+exports.zodToGenerativeAIParameters = zodToGenerativeAIParameters;
+exports.jsonSchemaToGeminiParameters = jsonSchemaToGeminiParameters;
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+function removeAdditionalProperties(
+// eslint-disable @typescript-eslint/no-explicit-any
+obj) {
+    if (typeof obj === "object" && obj !== null) {
+        const newObj = { ...obj };
+        if ("additionalProperties" in newObj) {
+            delete newObj.additionalProperties;
+        }
+        if ("$schema" in newObj) {
+            delete newObj.$schema;
+        }
+        for (const key in newObj) {
+            if (key in newObj) {
+                if (Array.isArray(newObj[key])) {
+                    newObj[key] = newObj[key].map(removeAdditionalProperties);
+                }
+                else if (typeof newObj[key] === "object" && newObj[key] !== null) {
+                    newObj[key] = removeAdditionalProperties(newObj[key]);
+                }
+            }
+        }
+        return newObj;
+    }
+    return obj;
+}
+function zodToGenerativeAIParameters(zodObj) {
+    // GenerativeAI doesn't accept either the $schema or additionalProperties
+    // attributes, so we need to explicitly remove them.
+    const jsonSchema = removeAdditionalProperties((0, zod_to_json_schema_1.zodToJsonSchema)(zodObj));
+    const { $schema, ...rest } = jsonSchema;
+    return rest;
+}
+function jsonSchemaToGeminiParameters(schema) {
+    // Gemini doesn't accept either the $schema or additionalProperties
+    // attributes, so we need to explicitly remove them.
+    const jsonSchema = removeAdditionalProperties(schema);
+    const { $schema, ...rest } = jsonSchema;
+    return rest;
+}

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/xai.d.ts

@@ -0,0 +1,41 @@
+import { Serialized } from "@langchain/core/load/serializable";
+import { ChatOpenAI } from "@langchain/openai";
+/**
+ * Extends the ChatOpenAI class to create a ChatXAI agent with additional configurations.
+ */
+export declare class ChatXAI extends ChatOpenAI {
+    /**
+     * Returns the name of the class for LangChain serialization.
+     * @returns The class name as a string.
+     */
+    static lc_name(): string;
+    /**
+     * Specifies the type of the language model.
+     * @returns The type of the LLM as a string.
+     */
+    _llmType(): string;
+    /**
+     * Specifies the secrets required for serialization.
+     * @returns An object mapping secret names to their keys.
+     */
+    get lc_secrets(): {
+        apiKey: string;
+    };
+    /**
+     * Constructs a new ChatXAI instance.
+     * @param fields - Configuration fields, including the API key.
+     * @throws If the API key is not provided.
+     */
+    constructor(fields: Record<string, unknown>);
+    /**
+     * Serializes the instance to JSON, removing sensitive information.
+     * @returns The serialized JSON object.
+     */
+    toJSON(): Serialized;
+    /**
+     * Retrieves parameters for LangChain based on provided options.
+     * @param options - Additional options for parameter retrieval.
+     * @returns An object containing LangChain parameters.
+     */
+    getLsParams(options: unknown): import("@langchain/core/language_models/chat_models", { with: { "resolution-mode": "import" } }).LangSmithParams;
+}