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

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

@@ -0,0 +1,94 @@
+import { TaskType } from "@google/generative-ai";
+import { Embeddings, EmbeddingsParams } from "@langchain/core/embeddings";
+/**
+ * Interface that extends EmbeddingsParams and defines additional
+ * parameters specific to the GoogleGenerativeAIEmbeddings class.
+ */
+export interface GoogleGenerativeAIEmbeddingsParams extends EmbeddingsParams {
+    /**
+     * Model Name to use
+     *
+     * Alias for `model`
+     *
+     * Note: The format must follow the pattern - `{model}`
+     */
+    modelName?: string;
+    /**
+     * Model Name to use
+     *
+     * Note: The format must follow the pattern - `{model}`
+     */
+    model?: string;
+    /**
+     * Type of task for which the embedding will be used
+     *
+     * Note: currently only supported by `embedding-001` model
+     */
+    taskType?: TaskType;
+    /**
+     * An optional title for the text. Only applicable when TaskType is
+     * `RETRIEVAL_DOCUMENT`
+     *
+     * Note: currently only supported by `embedding-001` model
+     */
+    title?: string;
+    /**
+     * Whether to strip new lines from the input text. Default to true
+     */
+    stripNewLines?: boolean;
+    /**
+     * Google API key to use
+     */
+    apiKey?: string;
+}
+/**
+ * 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 declare class GoogleGenerativeAIEmbeddings extends Embeddings implements GoogleGenerativeAIEmbeddingsParams {
+    apiKey?: string;
+    modelName: string;
+    model: string;
+    taskType?: TaskType;
+    title?: string;
+    stripNewLines: boolean;
+    maxBatchSize: number;
+    private client;
+    constructor(fields?: GoogleGenerativeAIEmbeddingsParams);
+    private _convertToContent;
+    protected _embedQueryContent(text: string): Promise<number[]>;
+    protected _embedDocumentsContent(documents: string[]): Promise<number[][]>;
+    /**
+     * 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: string): Promise<number[]>;
+    /**
+     * 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: string[]): Promise<number[][]>;
+}

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleGenerativeAIEmbeddings = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+const embeddings_1 = require("@langchain/core/embeddings");
+const chunk_array_1 = require("@langchain/core/utils/chunk_array");
+const env_1 = require("@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 });
+ * ```
+ */
+class GoogleGenerativeAIEmbeddings extends embeddings_1.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 !== generative_ai_1.TaskType.RETRIEVAL_DOCUMENT) {
+            throw new Error("title can only be specified with TaskType.RETRIEVAL_DOCUMENT");
+        }
+        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 environmentb variable GOOGLE_API_KEY " +
+                "or in the `apiKey` field of the " +
+                "GoogleGenerativeAIEmbeddings constructor");
+        }
+        this.client = new generative_ai_1.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 = (0, chunk_array_1.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);
+    }
+}
+exports.GoogleGenerativeAIEmbeddings = GoogleGenerativeAIEmbeddings;

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./chat_models.js"), exports);
+__exportStar(require("./embeddings.js"), exports);

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

@@ -0,0 +1,20 @@
+import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
+import { JsonOutputKeyToolsParserParams } from "@langchain/core/output_parsers/openai_tools";
+import { ChatGeneration } from "@langchain/core/outputs";
+import type { z } from "zod";
+interface GoogleGenerativeAIToolsOutputParserParams<T extends Record<string, any>> extends JsonOutputKeyToolsParserParams<T> {
+}
+export declare class GoogleGenerativeAIToolsOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    returnId: boolean;
+    /** The type of tool calls to return. */
+    keyName: string;
+    /** Whether to return only the first tool call. */
+    returnSingle: boolean;
+    zodSchema?: z.ZodType<T>;
+    constructor(params: GoogleGenerativeAIToolsOutputParserParams<T>);
+    protected _validateResult(result: unknown): Promise<T>;
+    parseResult(generations: ChatGeneration[]): Promise<T>;
+}
+export {};

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleGenerativeAIToolsOutputParser = void 0;
+const output_parsers_1 = require("@langchain/core/output_parsers");
+class GoogleGenerativeAIToolsOutputParser extends output_parsers_1.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;
+        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 output_parsers_1.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;
+    }
+}
+exports.GoogleGenerativeAIToolsOutputParser = GoogleGenerativeAIToolsOutputParser;

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

@@ -0,0 +1,3 @@
+import { CodeExecutionTool, FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool, GoogleSearchRetrievalTool } from "@google/generative-ai";
+import { BindToolsInput } from "@langchain/core/language_models/chat_models";
+export type GoogleGenerativeAIToolType = BindToolsInput | GoogleGenerativeAIFunctionDeclarationsTool | CodeExecutionTool | GoogleSearchRetrievalTool;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,22 @@
+import { Content, EnhancedGenerateContentResponse, POSSIBLE_ROLES, Part, type FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool } from "@google/generative-ai";
+import { BaseMessage, UsageMetadata } from "@langchain/core/messages";
+import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
+import { GoogleGenerativeAIToolType } from "../types.js";
+export declare function getMessageAuthor(message: BaseMessage): string;
+/**
+ * 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 declare function convertAuthorToRole(author: string): (typeof POSSIBLE_ROLES)[number];
+export declare function convertMessageContentToParts(message: BaseMessage, isMultimodalModel: boolean): Part[];
+export declare function convertBaseMessagesToContent(messages: BaseMessage[], isMultimodalModel: boolean, convertSystemMessageToHumanContent?: boolean): Content[];
+export declare function mapGenerateContentResultToChatResult(response: EnhancedGenerateContentResponse, extra?: {
+    usageMetadata: UsageMetadata | undefined;
+}): ChatResult;
+export declare function convertResponseContentToChatGenerationChunk(response: EnhancedGenerateContentResponse, extra: {
+    usageMetadata?: UsageMetadata | undefined;
+    index: number;
+}): ChatGenerationChunk | null;
+export declare function convertToGenerativeAITools(tools: GoogleGenerativeAIToolType[]): GoogleGenerativeAIFunctionDeclarationsTool[];