langchain 0.0.155 → 0.0.156

package/chat_models/bedrock.cjs

@@ -0,0 +1 @@
+module.exports = require('../dist/chat_models/bedrock.cjs');

package/chat_models/bedrock.d.ts

@@ -0,0 +1 @@
+export * from '../dist/chat_models/bedrock.js'

package/chat_models/bedrock.js

@@ -0,0 +1 @@
+export * from '../dist/chat_models/bedrock.js'

package/dist/chat_models/bedrock.cjs

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatBedrock = exports.convertMessagesToPrompt = exports.convertMessagesToPromptAnthropic = void 0;
+const signature_v4_1 = require("@smithy/signature-v4");
+const credential_provider_node_1 = require("@aws-sdk/credential-provider-node");
+const protocol_http_1 = require("@smithy/protocol-http");
+const eventstream_codec_1 = require("@smithy/eventstream-codec");
+const util_utf8_1 = require("@smithy/util-utf8");
+const sha256_js_1 = require("@aws-crypto/sha256-js");
+const bedrock_js_1 = require("../util/bedrock.cjs");
+const env_js_1 = require("../util/env.cjs");
+const base_js_1 = require("./base.cjs");
+const index_js_1 = require("../schema/index.cjs");
+function convertOneMessageToText(message, humanPrompt, aiPrompt) {
+    if (message._getType() === "human") {
+        return `${humanPrompt} ${message.content}`;
+    }
+    else if (message._getType() === "ai") {
+        return `${aiPrompt} ${message.content}`;
+    }
+    else if (message._getType() === "system") {
+        return `${humanPrompt} <admin>${message.content}</admin>`;
+    }
+    else if (index_js_1.ChatMessage.isInstance(message)) {
+        return `\n\n${message.role[0].toUpperCase() + message.role.slice(1)}: {message.content}`;
+    }
+    throw new Error(`Unknown role: ${message._getType()}`);
+}
+function convertMessagesToPromptAnthropic(messages, humanPrompt = "\n\nHuman:", aiPrompt = "\n\nAssistant:") {
+    const messagesCopy = [...messages];
+    if (messagesCopy.length === 0 ||
+        messagesCopy[messagesCopy.length - 1]._getType() !== "ai") {
+        messagesCopy.push(new index_js_1.AIMessage({ content: "" }));
+    }
+    return messagesCopy
+        .map((message) => convertOneMessageToText(message, humanPrompt, aiPrompt))
+        .join("");
+}
+exports.convertMessagesToPromptAnthropic = convertMessagesToPromptAnthropic;
+/**
+ * Function that converts an array of messages into a single string prompt
+ * that can be used as input for a chat model. It delegates the conversion
+ * logic to the appropriate provider-specific function.
+ * @param messages Array of messages to be converted.
+ * @param options Options to be used during the conversion.
+ * @returns A string prompt that can be used as input for a chat model.
+ */
+function convertMessagesToPrompt(messages, provider) {
+    if (provider === "anthropic") {
+        return convertMessagesToPromptAnthropic(messages);
+    }
+    throw new Error(`Provider ${provider} does not support chat.`);
+}
+exports.convertMessagesToPrompt = convertMessagesToPrompt;
+/**
+ * A type of Large Language Model (LLM) that interacts with the Bedrock
+ * service. It extends the base `LLM` class and implements the
+ * `BaseBedrockInput` interface. The class is designed to authenticate and
+ * interact with the Bedrock service, which is a part of Amazon Web
+ * Services (AWS). It uses AWS credentials for authentication and can be
+ * configured with various parameters such as the model to use, the AWS
+ * region, and the maximum number of tokens to generate.
+ */
+class ChatBedrock extends base_js_1.SimpleChatModel {
+    get lc_secrets() {
+        return {};
+    }
+    _llmType() {
+        return "bedrock";
+    }
+    static lc_name() {
+        return "ChatBedrock";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "amazon.titan-tg1-large"
+        });
+        Object.defineProperty(this, "region", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "credentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "maxTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "fetchFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "endpointHost", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stopSequences", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelKwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "codec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new eventstream_codec_1.EventStreamCodec(util_utf8_1.toUtf8, util_utf8_1.fromUtf8)
+        });
+        this.model = fields?.model ?? this.model;
+        const allowedModels = ["ai21", "anthropic", "amazon"];
+        if (!allowedModels.includes(this.model.split(".")[0])) {
+            throw new Error(`Unknown model: '${this.model}', only these are supported: ${allowedModels}`);
+        }
+        const region = fields?.region ?? (0, env_js_1.getEnvironmentVariable)("AWS_DEFAULT_REGION");
+        if (!region) {
+            throw new Error("Please set the AWS_DEFAULT_REGION environment variable or pass it to the constructor as the region field.");
+        }
+        this.region = region;
+        this.credentials = fields?.credentials ?? (0, credential_provider_node_1.defaultProvider)();
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.maxTokens = fields?.maxTokens ?? this.maxTokens;
+        this.fetchFn = fields?.fetchFn ?? fetch;
+        this.endpointHost = fields?.endpointHost ?? fields?.endpointUrl;
+        this.stopSequences = fields?.stopSequences;
+        this.modelKwargs = fields?.modelKwargs;
+    }
+    /** Call out to Bedrock service model.
+      Arguments:
+        prompt: The prompt to pass into the model.
+  
+      Returns:
+        The string generated by the model.
+  
+      Example:
+        response = model.call("Tell me a joke.")
+    */
+    async _call(messages, options, runManager) {
+        const chunks = [];
+        for await (const chunk of this._streamResponseChunks(messages, options, runManager)) {
+            chunks.push(chunk);
+        }
+        return chunks.map((chunk) => chunk.text).join("");
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        const provider = this.model.split(".")[0];
+        const service = "bedrock-runtime";
+        const inputBody = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareInput(provider, convertMessagesToPromptAnthropic(messages), this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
+        const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
+        const amazonMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
+        const url = new URL(`https://${endpointHost}/model/${this.model}/${amazonMethod}`);
+        const request = new protocol_http_1.HttpRequest({
+            hostname: url.hostname,
+            path: url.pathname,
+            protocol: url.protocol,
+            method: "POST",
+            body: JSON.stringify(inputBody),
+            query: Object.fromEntries(url.searchParams.entries()),
+            headers: {
+                // host is required by AWS Signature V4: https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+                host: url.host,
+                accept: "application/json",
+                "content-type": "application/json",
+            },
+        });
+        const signer = new signature_v4_1.SignatureV4({
+            credentials: this.credentials,
+            service: "bedrock",
+            region: this.region,
+            sha256: sha256_js_1.Sha256,
+        });
+        const signedRequest = await signer.sign(request);
+        // Send request to AWS using the low-level fetch API
+        const response = await this.caller.callWithOptions({ signal: options.signal }, async () => this.fetchFn(url, {
+            headers: signedRequest.headers,
+            body: signedRequest.body,
+            method: signedRequest.method,
+        }));
+        if (response.status < 200 || response.status >= 300) {
+            throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
+        }
+        if (provider === "anthropic") {
+            const reader = response.body?.getReader();
+            const decoder = new TextDecoder();
+            for await (const chunk of this._readChunks(reader)) {
+                const event = this.codec.decode(chunk);
+                if ((event.headers[":event-type"] !== undefined &&
+                    event.headers[":event-type"].value !== "chunk") ||
+                    event.headers[":content-type"].value !== "application/json") {
+                    throw Error(`Failed to get event chunk: got ${chunk}`);
+                }
+                // console.log(decoder.decode(event.body));
+                const body = JSON.parse(decoder.decode(event.body));
+                if (body.message) {
+                    throw new Error(body.message);
+                }
+                if (body.bytes !== undefined) {
+                    const chunkResult = JSON.parse(Buffer.from(body.bytes, "base64").toString());
+                    const text = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareOutput(provider, chunkResult);
+                    yield new index_js_1.ChatGenerationChunk({
+                        text,
+                        message: new index_js_1.AIMessageChunk({ content: text }),
+                    });
+                    await runManager?.handleLLMNewToken(text);
+                }
+            }
+        }
+        else {
+            const json = await response.json();
+            const text = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareOutput(provider, json);
+            yield new index_js_1.ChatGenerationChunk({
+                text,
+                message: new index_js_1.AIMessageChunk({ content: text }),
+            });
+            await runManager?.handleLLMNewToken(text);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _readChunks(reader) {
+        return {
+            async *[Symbol.asyncIterator]() {
+                let readResult = await reader.read();
+                while (!readResult.done) {
+                    yield readResult.value;
+                    readResult = await reader.read();
+                }
+            },
+        };
+    }
+    _combineLLMOutput() {
+        return {};
+    }
+}
+exports.ChatBedrock = ChatBedrock;

package/dist/chat_models/bedrock.d.ts

@@ -0,0 +1,58 @@
+import { EventStreamCodec } from "@smithy/eventstream-codec";
+import { BaseBedrockInput, type CredentialType } from "../util/bedrock.js";
+import { SimpleChatModel, BaseChatModelParams } from "./base.js";
+import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+import { BaseMessage, ChatGenerationChunk } from "../schema/index.js";
+export declare function convertMessagesToPromptAnthropic(messages: BaseMessage[], humanPrompt?: string, aiPrompt?: string): string;
+/**
+ * Function that converts an array of messages into a single string prompt
+ * that can be used as input for a chat model. It delegates the conversion
+ * logic to the appropriate provider-specific function.
+ * @param messages Array of messages to be converted.
+ * @param options Options to be used during the conversion.
+ * @returns A string prompt that can be used as input for a chat model.
+ */
+export declare function convertMessagesToPrompt(messages: BaseMessage[], provider: string): string;
+/**
+ * A type of Large Language Model (LLM) that interacts with the Bedrock
+ * service. It extends the base `LLM` class and implements the
+ * `BaseBedrockInput` interface. The class is designed to authenticate and
+ * interact with the Bedrock service, which is a part of Amazon Web
+ * Services (AWS). It uses AWS credentials for authentication and can be
+ * configured with various parameters such as the model to use, the AWS
+ * region, and the maximum number of tokens to generate.
+ */
+export declare class ChatBedrock extends SimpleChatModel implements BaseBedrockInput {
+    model: string;
+    region: string;
+    credentials: CredentialType;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    fetchFn: typeof fetch;
+    endpointHost?: string;
+    stopSequences?: string[];
+    modelKwargs?: Record<string, unknown>;
+    codec: EventStreamCodec;
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    _llmType(): string;
+    static lc_name(): string;
+    constructor(fields?: Partial<BaseBedrockInput> & BaseChatModelParams);
+    /** Call out to Bedrock service model.
+      Arguments:
+        prompt: The prompt to pass into the model.
+  
+      Returns:
+        The string generated by the model.
+  
+      Example:
+        response = model.call("Tell me a joke.")
+    */
+    _call(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
+    _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    _readChunks(reader: any): {
+        [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;
+    };
+    _combineLLMOutput(): {};
+}

package/dist/chat_models/bedrock.js

@@ -0,0 +1,254 @@
+import { SignatureV4 } from "@smithy/signature-v4";
+import { defaultProvider } from "@aws-sdk/credential-provider-node";
+import { HttpRequest } from "@smithy/protocol-http";
+import { EventStreamCodec } from "@smithy/eventstream-codec";
+import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
+import { Sha256 } from "@aws-crypto/sha256-js";
+import { BedrockLLMInputOutputAdapter, } from "../util/bedrock.js";
+import { getEnvironmentVariable } from "../util/env.js";
+import { SimpleChatModel } from "./base.js";
+import { AIMessageChunk, AIMessage, ChatGenerationChunk, ChatMessage, } from "../schema/index.js";
+function convertOneMessageToText(message, humanPrompt, aiPrompt) {
+    if (message._getType() === "human") {
+        return `${humanPrompt} ${message.content}`;
+    }
+    else if (message._getType() === "ai") {
+        return `${aiPrompt} ${message.content}`;
+    }
+    else if (message._getType() === "system") {
+        return `${humanPrompt} <admin>${message.content}</admin>`;
+    }
+    else if (ChatMessage.isInstance(message)) {
+        return `\n\n${message.role[0].toUpperCase() + message.role.slice(1)}: {message.content}`;
+    }
+    throw new Error(`Unknown role: ${message._getType()}`);
+}
+export function convertMessagesToPromptAnthropic(messages, humanPrompt = "\n\nHuman:", aiPrompt = "\n\nAssistant:") {
+    const messagesCopy = [...messages];
+    if (messagesCopy.length === 0 ||
+        messagesCopy[messagesCopy.length - 1]._getType() !== "ai") {
+        messagesCopy.push(new AIMessage({ content: "" }));
+    }
+    return messagesCopy
+        .map((message) => convertOneMessageToText(message, humanPrompt, aiPrompt))
+        .join("");
+}
+/**
+ * Function that converts an array of messages into a single string prompt
+ * that can be used as input for a chat model. It delegates the conversion
+ * logic to the appropriate provider-specific function.
+ * @param messages Array of messages to be converted.
+ * @param options Options to be used during the conversion.
+ * @returns A string prompt that can be used as input for a chat model.
+ */
+export function convertMessagesToPrompt(messages, provider) {
+    if (provider === "anthropic") {
+        return convertMessagesToPromptAnthropic(messages);
+    }
+    throw new Error(`Provider ${provider} does not support chat.`);
+}
+/**
+ * A type of Large Language Model (LLM) that interacts with the Bedrock
+ * service. It extends the base `LLM` class and implements the
+ * `BaseBedrockInput` interface. The class is designed to authenticate and
+ * interact with the Bedrock service, which is a part of Amazon Web
+ * Services (AWS). It uses AWS credentials for authentication and can be
+ * configured with various parameters such as the model to use, the AWS
+ * region, and the maximum number of tokens to generate.
+ */
+export class ChatBedrock extends SimpleChatModel {
+    get lc_secrets() {
+        return {};
+    }
+    _llmType() {
+        return "bedrock";
+    }
+    static lc_name() {
+        return "ChatBedrock";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "amazon.titan-tg1-large"
+        });
+        Object.defineProperty(this, "region", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "credentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "maxTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "fetchFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "endpointHost", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stopSequences", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelKwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "codec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new EventStreamCodec(toUtf8, fromUtf8)
+        });
+        this.model = fields?.model ?? this.model;
+        const allowedModels = ["ai21", "anthropic", "amazon"];
+        if (!allowedModels.includes(this.model.split(".")[0])) {
+            throw new Error(`Unknown model: '${this.model}', only these are supported: ${allowedModels}`);
+        }
+        const region = fields?.region ?? getEnvironmentVariable("AWS_DEFAULT_REGION");
+        if (!region) {
+            throw new Error("Please set the AWS_DEFAULT_REGION environment variable or pass it to the constructor as the region field.");
+        }
+        this.region = region;
+        this.credentials = fields?.credentials ?? defaultProvider();
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.maxTokens = fields?.maxTokens ?? this.maxTokens;
+        this.fetchFn = fields?.fetchFn ?? fetch;
+        this.endpointHost = fields?.endpointHost ?? fields?.endpointUrl;
+        this.stopSequences = fields?.stopSequences;
+        this.modelKwargs = fields?.modelKwargs;
+    }
+    /** Call out to Bedrock service model.
+      Arguments:
+        prompt: The prompt to pass into the model.
+  
+      Returns:
+        The string generated by the model.
+  
+      Example:
+        response = model.call("Tell me a joke.")
+    */
+    async _call(messages, options, runManager) {
+        const chunks = [];
+        for await (const chunk of this._streamResponseChunks(messages, options, runManager)) {
+            chunks.push(chunk);
+        }
+        return chunks.map((chunk) => chunk.text).join("");
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        const provider = this.model.split(".")[0];
+        const service = "bedrock-runtime";
+        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, convertMessagesToPromptAnthropic(messages), this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
+        const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
+        const amazonMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
+        const url = new URL(`https://${endpointHost}/model/${this.model}/${amazonMethod}`);
+        const request = new HttpRequest({
+            hostname: url.hostname,
+            path: url.pathname,
+            protocol: url.protocol,
+            method: "POST",
+            body: JSON.stringify(inputBody),
+            query: Object.fromEntries(url.searchParams.entries()),
+            headers: {
+                // host is required by AWS Signature V4: https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+                host: url.host,
+                accept: "application/json",
+                "content-type": "application/json",
+            },
+        });
+        const signer = new SignatureV4({
+            credentials: this.credentials,
+            service: "bedrock",
+            region: this.region,
+            sha256: Sha256,
+        });
+        const signedRequest = await signer.sign(request);
+        // Send request to AWS using the low-level fetch API
+        const response = await this.caller.callWithOptions({ signal: options.signal }, async () => this.fetchFn(url, {
+            headers: signedRequest.headers,
+            body: signedRequest.body,
+            method: signedRequest.method,
+        }));
+        if (response.status < 200 || response.status >= 300) {
+            throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
+        }
+        if (provider === "anthropic") {
+            const reader = response.body?.getReader();
+            const decoder = new TextDecoder();
+            for await (const chunk of this._readChunks(reader)) {
+                const event = this.codec.decode(chunk);
+                if ((event.headers[":event-type"] !== undefined &&
+                    event.headers[":event-type"].value !== "chunk") ||
+                    event.headers[":content-type"].value !== "application/json") {
+                    throw Error(`Failed to get event chunk: got ${chunk}`);
+                }
+                // console.log(decoder.decode(event.body));
+                const body = JSON.parse(decoder.decode(event.body));
+                if (body.message) {
+                    throw new Error(body.message);
+                }
+                if (body.bytes !== undefined) {
+                    const chunkResult = JSON.parse(Buffer.from(body.bytes, "base64").toString());
+                    const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, chunkResult);
+                    yield new ChatGenerationChunk({
+                        text,
+                        message: new AIMessageChunk({ content: text }),
+                    });
+                    await runManager?.handleLLMNewToken(text);
+                }
+            }
+        }
+        else {
+            const json = await response.json();
+            const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, json);
+            yield new ChatGenerationChunk({
+                text,
+                message: new AIMessageChunk({ content: text }),
+            });
+            await runManager?.handleLLMNewToken(text);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _readChunks(reader) {
+        return {
+            async *[Symbol.asyncIterator]() {
+                let readResult = await reader.read();
+                while (!readResult.done) {
+                    yield readResult.value;
+                    readResult = await reader.read();
+                }
+            },
+        };
+    }
+    _combineLLMOutput() {
+        return {};
+    }
+}

package/dist/embeddings/cloudflare_workersai.cjs

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudflareWorkersAIEmbeddings = void 0;
+const ai_1 = require("@cloudflare/ai");
+const chunk_js_1 = require("../util/chunk.cjs");
+const base_js_1 = require("./base.cjs");
+class CloudflareWorkersAIEmbeddings extends base_js_1.Embeddings {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "@cf/baai/bge-base-en-v1.5"
+        });
+        Object.defineProperty(this, "batchSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 50
+        });
+        Object.defineProperty(this, "stripNewLines", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "ai", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!fields.binding) {
+            throw new Error("Must supply a Workers AI binding, eg { binding: env.AI }");
+        }
+        this.ai = new ai_1.Ai(fields.binding);
+        this.modelName = fields.modelName ?? this.modelName;
+        this.stripNewLines = fields.stripNewLines ?? this.stripNewLines;
+    }
+    async embedDocuments(texts) {
+        const batches = (0, chunk_js_1.chunkArray)(this.stripNewLines ? texts.map((t) => t.replace(/\n/g, " ")) : texts, this.batchSize);
+        const batchRequests = batches.map((batch) => this.runEmbedding(batch));
+        const batchResponses = await Promise.all(batchRequests);
+        const embeddings = [];
+        for (let i = 0; i < batchResponses.length; i += 1) {
+            const batchResponse = batchResponses[i];
+            for (let j = 0; j < batchResponse.length; j += 1) {
+                embeddings.push(batchResponse[j]);
+            }
+        }
+        return embeddings;
+    }
+    async embedQuery(text) {
+        const data = await this.runEmbedding([
+            this.stripNewLines ? text.replace(/\n/g, " ") : text,
+        ]);
+        return data[0];
+    }
+    async runEmbedding(texts) {
+        return this.caller.call(async () => {
+            const response = await this.ai.run(this.modelName, {
+                text: texts,
+            });
+            return response.data;
+        });
+    }
+}
+exports.CloudflareWorkersAIEmbeddings = CloudflareWorkersAIEmbeddings;

package/dist/embeddings/cloudflare_workersai.d.ts

@@ -0,0 +1,28 @@
+import { Ai } from "@cloudflare/ai";
+import { Fetcher } from "@cloudflare/workers-types";
+import { Embeddings, EmbeddingsParams } from "./base.js";
+export interface CloudflareWorkersAIEmbeddingsParams extends EmbeddingsParams {
+    /** Binding */
+    binding: Fetcher;
+    /** Model name to use */
+    modelName?: string;
+    /**
+     * The maximum number of documents to embed in a single request.
+     */
+    batchSize?: number;
+    /**
+     * Whether to strip new lines from the input text. This is recommended by
+     * OpenAI, but may not be suitable for all use cases.
+     */
+    stripNewLines?: boolean;
+}
+export declare class CloudflareWorkersAIEmbeddings extends Embeddings {
+    modelName: string;
+    batchSize: number;
+    stripNewLines: boolean;
+    ai: Ai;
+    constructor(fields: CloudflareWorkersAIEmbeddingsParams);
+    embedDocuments(texts: string[]): Promise<number[][]>;
+    embedQuery(text: string): Promise<number[]>;
+    private runEmbedding;
+}