@blaxel/langgraph 0.2.50-dev.215 → 0.2.50

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

@@ -1,107 +0,0 @@
-import { GoogleGenerativeAI, TaskType, } from "@google/generative-ai";
-import { Embeddings } from "@langchain/core/embeddings";
-import { chunkArray } from "@langchain/core/utils/chunk_array";
-import { getEnvironmentVariable } from "@langchain/core/utils/env";
-/**
- * Class that extends the Embeddings class and provides methods for
- * generating embeddings using the Google Palm API.
- * @example
- * ```typescript
- * const model = new GoogleGenerativeAIEmbeddings({
- *   apiKey: "<YOUR API KEY>",
- *   modelName: "embedding-001",
- * });
- *
- * // Embed a single query
- * const res = await model.embedQuery(
- *   "What would be a good company name for a company that makes colorful socks?"
- * );
- * console.log({ res });
- *
- * // Embed multiple documents
- * const documentRes = await model.embedDocuments(["Hello world", "Bye bye"]);
- * console.log({ documentRes });
- * ```
- */
-export class GoogleGenerativeAIEmbeddings extends Embeddings {
-    apiKey;
-    modelName = "embedding-001";
-    model = "embedding-001";
-    taskType;
-    title;
-    stripNewLines = true;
-    maxBatchSize = 100; // Max batch size for embedDocuments set by GenerativeModel client's batchEmbedContents call
-    client;
-    constructor(fields) {
-        super(fields ?? {});
-        this.modelName =
-            fields?.model?.replace(/^models\//, "") ??
-                fields?.modelName?.replace(/^models\//, "") ??
-                this.modelName;
-        this.model = this.modelName;
-        this.taskType = fields?.taskType ?? this.taskType;
-        this.title = fields?.title ?? this.title;
-        if (this.title && this.taskType !== TaskType.RETRIEVAL_DOCUMENT) {
-            throw new Error("title can only be specified with TaskType.RETRIEVAL_DOCUMENT");
-        }
-        this.apiKey = fields?.apiKey ?? getEnvironmentVariable("GOOGLE_API_KEY");
-        if (!this.apiKey) {
-            throw new Error("Please set an API key for Google GenerativeAI " +
-                "in the environmentb variable GOOGLE_API_KEY " +
-                "or in the `apiKey` field of the " +
-                "GoogleGenerativeAIEmbeddings constructor");
-        }
-        this.client = new GoogleGenerativeAI(this.apiKey).getGenerativeModel({
-            model: this.model,
-        });
-    }
-    _convertToContent(text) {
-        const cleanedText = this.stripNewLines ? text.replace(/\n/g, " ") : text;
-        return {
-            content: { role: "user", parts: [{ text: cleanedText }] },
-            taskType: this.taskType,
-            title: this.title,
-        };
-    }
-    async _embedQueryContent(text) {
-        const req = this._convertToContent(text);
-        const res = await this.client.embedContent(req);
-        return res.embedding.values ?? [];
-    }
-    async _embedDocumentsContent(documents) {
-        const batchEmbedChunks = chunkArray(documents, this.maxBatchSize);
-        const batchEmbedRequests = batchEmbedChunks.map((chunk) => ({
-            requests: chunk.map((doc) => this._convertToContent(doc)),
-        }));
-        const responses = await Promise.allSettled(batchEmbedRequests.map((req) => this.client.batchEmbedContents(req)));
-        const embeddings = responses.flatMap((res, idx) => {
-            if (res.status === "fulfilled") {
-                return res.value.embeddings.map((e) => e.values || []);
-            }
-            else {
-                return Array(batchEmbedChunks[idx].length).fill([]);
-            }
-        });
-        return embeddings;
-    }
-    /**
-     * Method that takes a document as input and returns a promise that
-     * resolves to an embedding for the document. It calls the _embedText
-     * method with the document as the input.
-     * @param document Document for which to generate an embedding.
-     * @returns Promise that resolves to an embedding for the input document.
-     */
-    embedQuery(document) {
-        return this.caller.call(this._embedQueryContent.bind(this), document);
-    }
-    /**
-     * Method that takes an array of documents as input and returns a promise
-     * that resolves to a 2D array of embeddings for each document. It calls
-     * the _embedText method for each document in the array.
-     * @param documents Array of documents for which to generate embeddings.
-     * @returns Promise that resolves to a 2D array of embeddings for each input document.
-     */
-    embedDocuments(documents) {
-        return this.caller.call(this._embedDocumentsContent.bind(this), documents);
-    }
-}

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

@@ -1,2 +0,0 @@
-export * from "./chat_models.js";
-export * from "./embeddings.js";

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

@@ -1,47 +0,0 @@
-import { BaseLLMOutputParser, OutputParserException, } from "@langchain/core/output_parsers";
-export class GoogleGenerativeAIToolsOutputParser extends BaseLLMOutputParser {
-    static lc_name() {
-        return "GoogleGenerativeAIToolsOutputParser";
-    }
-    lc_namespace = ["langchain", "google_genai", "output_parsers"];
-    returnId = false;
-    /** The type of tool calls to return. */
-    keyName;
-    /** Whether to return only the first tool call. */
-    returnSingle = false;
-    zodSchema;
-    constructor(params) {
-        super(params);
-        this.keyName = params.keyName;
-        this.returnSingle = params.returnSingle ?? this.returnSingle;
-        // @ts-ignore - Type instantiation depth issue with Zod schemas
-        this.zodSchema = params.zodSchema;
-    }
-    async _validateResult(result) {
-        if (this.zodSchema === undefined) {
-            return result;
-        }
-        const zodParsedResult = await this.zodSchema.safeParseAsync(result);
-        if (zodParsedResult.success) {
-            return zodParsedResult.data;
-        }
-        else {
-            throw new OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, JSON.stringify(result, null, 2));
-        }
-    }
-    async parseResult(generations) {
-        const tools = generations.flatMap((generation) => {
-            const { message } = generation;
-            if (!("tool_calls" in message) || !Array.isArray(message.tool_calls)) {
-                return [];
-            }
-            return message.tool_calls;
-        });
-        if (tools[0] === undefined) {
-            throw new Error("No parseable tool calls provided to GoogleGenerativeAIToolsOutputParser.");
-        }
-        const [tool] = tools;
-        const validatedResult = await this._validateResult(tool.args);
-        return validatedResult;
-    }
-}

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

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

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

@@ -1,381 +0,0 @@
-import { isOpenAITool } from "@langchain/core/language_models/base";
-import { AIMessage, AIMessageChunk, ChatMessage, isBaseMessage, } from "@langchain/core/messages";
-import { ChatGenerationChunk, } from "@langchain/core/outputs";
-import { isLangChainTool } from "@langchain/core/utils/function_calling";
-import { jsonSchemaToGeminiParameters, zodToGenerativeAIParameters, } from "./zod_to_genai_parameters.js";
-export function getMessageAuthor(message) {
-    const type = message._getType();
-    if (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.
- */
-export 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");
-}
-export 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`);
-                }
-                if (!c.image_url) {
-                    throw new Error("Please provide image as base64 encoded data URL");
-                }
-                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];
-}
-export function convertBaseMessagesToContent(messages, isMultimodalModel, convertSystemMessageToHumanContent = false) {
-    return messages.reduce((acc, message, index) => {
-        if (!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;
-}
-export 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 AIMessage({
-            content,
-            tool_calls: functionCalls?.map((fc) => ({
-                ...fc,
-                type: "tool_call",
-            })),
-            additional_kwargs: {
-                ...generationInfo,
-            },
-            usage_metadata: extra?.usageMetadata,
-        }),
-        generationInfo,
-    };
-    return {
-        generations: [generation],
-    };
-}
-export 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 ChatGenerationChunk({
-        text,
-        message: new 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;
-}
-export function convertToGenerativeAITools(tools) {
-    if (tools.every((tool) => "functionDeclarations" in tool &&
-        Array.isArray(tool.functionDeclarations))) {
-        return tools;
-    }
-    return [
-        {
-            functionDeclarations: tools.map((tool) => {
-                if (isLangChainTool(tool) && isZodType(tool.schema)) {
-                    // @ts-ignore - Type instantiation depth issue with Zod schemas
-                    const jsonSchema = zodToGenerativeAIParameters(tool.schema);
-                    return {
-                        name: tool.name,
-                        description: tool.description,
-                        parameters: jsonSchema,
-                    };
-                }
-                if (isOpenAITool(tool)) {
-                    return {
-                        name: tool.function.name,
-                        description: tool.function.description ?? `A function available to call.`,
-                        parameters: jsonSchemaToGeminiParameters(tool.function.parameters),
-                    };
-                }
-                return tool;
-            }),
-        },
-    ];
-}

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

@@ -1,107 +0,0 @@
-import { FunctionCallingMode, } from "@google/generative-ai";
-import { isLangChainTool } from "@langchain/core/utils/function_calling";
-import { isOpenAITool, } from "@langchain/core/language_models/base";
-import { convertToGenerativeAITools } from "./common.js";
-import { removeAdditionalProperties } from "./zod_to_genai_parameters.js";
-export 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 (isLangChainTool(tool)) {
-            const [convertedTool] = convertToGenerativeAITools([
-                tool,
-            ]);
-            if (convertedTool.functionDeclarations) {
-                functionDeclarationTools.push(...convertedTool.functionDeclarations);
-            }
-        }
-        else if (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: removeAdditionalProperties(tool.function.parameters),
-            },
-        ],
-    };
-}
-function createToolConfig(genAITools, extra) {
-    if (!genAITools.length || !extra)
-        return undefined;
-    const { toolChoice, allowedFunctionNames } = extra;
-    const modeMap = {
-        any: FunctionCallingMode.ANY,
-        auto: FunctionCallingMode.AUTO,
-        none: 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: FunctionCallingMode.ANY,
-                allowedFunctionNames: [
-                    ...(allowedFunctionNames ?? []),
-                    ...(toolChoice && typeof toolChoice === "string" ? [toolChoice] : []),
-                ],
-            },
-        };
-    }
-    return undefined;
-}

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

@@ -1,41 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { zodToJsonSchema } from "zod-to-json-schema";
-export 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;
-}
-export function zodToGenerativeAIParameters(zodObj) {
-    // GenerativeAI doesn't accept either the $schema or additionalProperties
-    // attributes, so we need to explicitly remove them.
-    const jsonSchema = removeAdditionalProperties(zodToJsonSchema(zodObj));
-    const { $schema, ...rest } = jsonSchema;
-    return rest;
-}
-export 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;
-}