langchain 0.0.176 → 0.0.177

package/dist/chat_models/openai.cjs

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptLayerChatOpenAI = exports.ChatOpenAI = void 0;
 const openai_1 = require("openai");
-const count_tokens_js_1 = require("../base_language/count_tokens.cjs");
 const index_js_1 = require("../schema/index.cjs");
 const convert_to_openai_js_1 = require("../tools/convert_to_openai.cjs");
 const azure_js_1 = require("../util/azure.cjs");
@@ -10,6 +9,7 @@ const env_js_1 = require("../util/env.cjs");
 const prompt_layer_js_1 = require("../util/prompt-layer.cjs");
 const base_js_1 = require("./base.cjs");
 const openai_js_1 = require("../util/openai.cjs");
+const openai_format_fndef_js_1 = require("../util/openai-format-fndef.cjs");
 function extractGenericMessageCustomRole(message) {
     if (message.role !== "system" &&
         message.role !== "assistant" &&
@@ -39,6 +39,19 @@ function messageToOpenAIRole(message) {
             throw new Error(`Unknown message type: ${type}`);
     }
 }
+function messageToOpenAIMessage(message) {
+    const msg = {
+        content: message.content || null,
+        name: message.name,
+        role: messageToOpenAIRole(message),
+        function_call: message.additional_kwargs.function_call,
+    };
+    if (msg.function_call?.arguments) {
+        // Remove spaces, new line characters etc.
+        msg.function_call.arguments = JSON.stringify(JSON.parse(msg.function_call.arguments));
+    }
+    return msg;
+}
 function openAIResponseToChatMessage(message) {
     switch (message.role) {
         case "user":
@@ -414,6 +427,7 @@ class ChatOpenAI extends base_js_1.BaseChatModel {
     }
     /**
      * Get the identifying parameters for the model
+     *
      */
     identifyingParams() {
         return this._identifyingParams();
@@ -430,7 +444,7 @@ class ChatOpenAI extends base_js_1.BaseChatModel {
                 .function_call,
         }));
         if (params.stream) {
-            const stream = await this._streamResponseChunks(messages, options, runManager);
+            const stream = this._streamResponseChunks(messages, options, runManager);
             const finalChunks = {};
             for await (const chunk of stream) {
                 const index = chunk.generationInfo?.completion ?? 0;
@@ -444,7 +458,15 @@ class ChatOpenAI extends base_js_1.BaseChatModel {
             const generations = Object.entries(finalChunks)
                 .sort(([aKey], [bKey]) => parseInt(aKey, 10) - parseInt(bKey, 10))
                 .map(([_, value]) => value);
-            return { generations };
+            const { functions, function_call } = this.invocationParams(options);
+            // OpenAI does not support token usage report under stream mode,
+            // fallback to estimation.
+            const promptTokenUsage = await this.getNumTokensFromPrompt(messages, functions, function_call);
+            const completionTokenUsage = await this.getNumTokensFromGenerations(generations);
+            tokenUsage.promptTokens = promptTokenUsage;
+            tokenUsage.completionTokens = completionTokenUsage;
+            tokenUsage.totalTokens = promptTokenUsage + completionTokenUsage;
+            return { generations, llmOutput: { estimatedTokenUsage: tokenUsage } };
         }
         else {
             const data = await this.completionWithRetry({
@@ -484,16 +506,65 @@ class ChatOpenAI extends base_js_1.BaseChatModel {
             };
         }
     }
+    /**
+     * Estimate the number of tokens a prompt will use.
+     * Modified from: https://github.com/hmarr/openai-chat-tokens/blob/main/src/index.ts
+     */
+    async getNumTokensFromPrompt(messages, functions, function_call) {
+        // It appears that if functions are present, the first system message is padded with a trailing newline. This
+        // was inferred by trying lots of combinations of messages and functions and seeing what the token counts were.
+        // let paddedSystem = false;
+        const openaiMessages = messages.map((m) => messageToOpenAIMessage(m));
+        let tokens = (await this.getNumTokensFromMessages(messages)).totalCount;
+        // If there are functions, add the function definitions as they count towards token usage
+        if (functions && function_call !== "auto") {
+            const promptDefinitions = (0, openai_format_fndef_js_1.formatFunctionDefinitions)(functions);
+            tokens += await this.getNumTokens(promptDefinitions);
+            tokens += 9; // Add nine per completion
+        }
+        // If there's a system message _and_ functions are present, subtract four tokens. I assume this is because
+        // functions typically add a system message, but reuse the first one if it's already there. This offsets
+        // the extra 9 tokens added by the function definitions.
+        if (functions && openaiMessages.find((m) => m.role === "system")) {
+            tokens -= 4;
+        }
+        // If function_call is 'none', add one token.
+        // If it's a FunctionCall object, add 4 + the number of tokens in the function name.
+        // If it's undefined or 'auto', don't add anything.
+        if (function_call === "none") {
+            tokens += 1;
+        }
+        else if (typeof function_call === "object") {
+            tokens += (await this.getNumTokens(function_call.name)) + 4;
+        }
+        return tokens;
+    }
+    /**
+     * Estimate the number of tokens an array of generations have used.
+     */
+    async getNumTokensFromGenerations(generations) {
+        const generationUsages = await Promise.all(generations.map(async (generation) => {
+            const openAIMessage = messageToOpenAIMessage(generation.message);
+            if (openAIMessage.function_call) {
+                return (await this.getNumTokensFromMessages([generation.message]))
+                    .countPerMessage[0];
+            }
+            else {
+                return await this.getNumTokens(generation.message.content);
+            }
+        }));
+        return generationUsages.reduce((a, b) => a + b, 0);
+    }
     async getNumTokensFromMessages(messages) {
         let totalCount = 0;
         let tokensPerMessage = 0;
         let tokensPerName = 0;
         // From: https://github.com/openai/openai-cookbook/blob/main/examples/How_to_format_inputs_to_ChatGPT_models.ipynb
-        if ((0, count_tokens_js_1.getModelNameForTiktoken)(this.modelName) === "gpt-3.5-turbo") {
+        if (this.modelName === "gpt-3.5-turbo-0301") {
             tokensPerMessage = 4;
             tokensPerName = -1;
         }
-        else if ((0, count_tokens_js_1.getModelNameForTiktoken)(this.modelName).startsWith("gpt-4")) {
+        else {
             tokensPerMessage = 3;
             tokensPerName = 1;
         }
@@ -503,7 +574,21 @@ class ChatOpenAI extends base_js_1.BaseChatModel {
             const nameCount = message.name !== undefined
                 ? tokensPerName + (await this.getNumTokens(message.name))
                 : 0;
-            const count = textCount + tokensPerMessage + roleCount + nameCount;
+            let count = textCount + tokensPerMessage + roleCount + nameCount;
+            // From: https://github.com/hmarr/openai-chat-tokens/blob/main/src/index.ts messageTokenEstimate
+            const openAIMessage = messageToOpenAIMessage(message);
+            if (openAIMessage.role === "function") {
+                count -= 2;
+            }
+            if (openAIMessage.function_call) {
+                count += 3;
+            }
+            if (openAIMessage.function_call?.name) {
+                count += await this.getNumTokens(openAIMessage.function_call?.name);
+            }
+            if (openAIMessage.function_call?.arguments) {
+                count += await this.getNumTokens(openAIMessage.function_call?.arguments);
+            }
             totalCount += count;
             return count;
         }));

package/dist/chat_models/openai.d.ts

@@ -83,12 +83,22 @@ export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = Chat
     _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
     /**
      * Get the identifying parameters for the model
+     *
      */
     identifyingParams(): Omit<OpenAIClient.Chat.Completions.ChatCompletionCreateParams, "messages"> & {
         model_name: string;
     } & ClientOptions;
     /** @ignore */
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    /**
+     * Estimate the number of tokens a prompt will use.
+     * Modified from: https://github.com/hmarr/openai-chat-tokens/blob/main/src/index.ts
+     */
+    private getNumTokensFromPrompt;
+    /**
+     * Estimate the number of tokens an array of generations have used.
+     */
+    private getNumTokensFromGenerations;
     getNumTokensFromMessages(messages: BaseMessage[]): Promise<{
         totalCount: number;
         countPerMessage: number[];

package/dist/chat_models/openai.js

@@ -1,5 +1,4 @@
 import { OpenAI as OpenAIClient } from "openai";
-import { getModelNameForTiktoken } from "../base_language/count_tokens.js";
 import { AIMessage, AIMessageChunk, ChatGenerationChunk, ChatMessage, ChatMessageChunk, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, } from "../schema/index.js";
 import { formatToOpenAIFunction } from "../tools/convert_to_openai.js";
 import { getEndpoint } from "../util/azure.js";
@@ -7,6 +6,7 @@ import { getEnvironmentVariable } from "../util/env.js";
 import { promptLayerTrackRequest } from "../util/prompt-layer.js";
 import { BaseChatModel } from "./base.js";
 import { wrapOpenAIClientError } from "../util/openai.js";
+import { formatFunctionDefinitions, } from "../util/openai-format-fndef.js";
 function extractGenericMessageCustomRole(message) {
     if (message.role !== "system" &&
         message.role !== "assistant" &&
@@ -36,6 +36,19 @@ function messageToOpenAIRole(message) {
             throw new Error(`Unknown message type: ${type}`);
     }
 }
+function messageToOpenAIMessage(message) {
+    const msg = {
+        content: message.content || null,
+        name: message.name,
+        role: messageToOpenAIRole(message),
+        function_call: message.additional_kwargs.function_call,
+    };
+    if (msg.function_call?.arguments) {
+        // Remove spaces, new line characters etc.
+        msg.function_call.arguments = JSON.stringify(JSON.parse(msg.function_call.arguments));
+    }
+    return msg;
+}
 function openAIResponseToChatMessage(message) {
     switch (message.role) {
         case "user":
@@ -411,6 +424,7 @@ export class ChatOpenAI extends BaseChatModel {
     }
     /**
      * Get the identifying parameters for the model
+     *
      */
     identifyingParams() {
         return this._identifyingParams();
@@ -427,7 +441,7 @@ export class ChatOpenAI extends BaseChatModel {
                 .function_call,
         }));
         if (params.stream) {
-            const stream = await this._streamResponseChunks(messages, options, runManager);
+            const stream = this._streamResponseChunks(messages, options, runManager);
             const finalChunks = {};
             for await (const chunk of stream) {
                 const index = chunk.generationInfo?.completion ?? 0;
@@ -441,7 +455,15 @@ export class ChatOpenAI extends BaseChatModel {
             const generations = Object.entries(finalChunks)
                 .sort(([aKey], [bKey]) => parseInt(aKey, 10) - parseInt(bKey, 10))
                 .map(([_, value]) => value);
-            return { generations };
+            const { functions, function_call } = this.invocationParams(options);
+            // OpenAI does not support token usage report under stream mode,
+            // fallback to estimation.
+            const promptTokenUsage = await this.getNumTokensFromPrompt(messages, functions, function_call);
+            const completionTokenUsage = await this.getNumTokensFromGenerations(generations);
+            tokenUsage.promptTokens = promptTokenUsage;
+            tokenUsage.completionTokens = completionTokenUsage;
+            tokenUsage.totalTokens = promptTokenUsage + completionTokenUsage;
+            return { generations, llmOutput: { estimatedTokenUsage: tokenUsage } };
         }
         else {
             const data = await this.completionWithRetry({
@@ -481,16 +503,65 @@ export class ChatOpenAI extends BaseChatModel {
             };
         }
     }
+    /**
+     * Estimate the number of tokens a prompt will use.
+     * Modified from: https://github.com/hmarr/openai-chat-tokens/blob/main/src/index.ts
+     */
+    async getNumTokensFromPrompt(messages, functions, function_call) {
+        // It appears that if functions are present, the first system message is padded with a trailing newline. This
+        // was inferred by trying lots of combinations of messages and functions and seeing what the token counts were.
+        // let paddedSystem = false;
+        const openaiMessages = messages.map((m) => messageToOpenAIMessage(m));
+        let tokens = (await this.getNumTokensFromMessages(messages)).totalCount;
+        // If there are functions, add the function definitions as they count towards token usage
+        if (functions && function_call !== "auto") {
+            const promptDefinitions = formatFunctionDefinitions(functions);
+            tokens += await this.getNumTokens(promptDefinitions);
+            tokens += 9; // Add nine per completion
+        }
+        // If there's a system message _and_ functions are present, subtract four tokens. I assume this is because
+        // functions typically add a system message, but reuse the first one if it's already there. This offsets
+        // the extra 9 tokens added by the function definitions.
+        if (functions && openaiMessages.find((m) => m.role === "system")) {
+            tokens -= 4;
+        }
+        // If function_call is 'none', add one token.
+        // If it's a FunctionCall object, add 4 + the number of tokens in the function name.
+        // If it's undefined or 'auto', don't add anything.
+        if (function_call === "none") {
+            tokens += 1;
+        }
+        else if (typeof function_call === "object") {
+            tokens += (await this.getNumTokens(function_call.name)) + 4;
+        }
+        return tokens;
+    }
+    /**
+     * Estimate the number of tokens an array of generations have used.
+     */
+    async getNumTokensFromGenerations(generations) {
+        const generationUsages = await Promise.all(generations.map(async (generation) => {
+            const openAIMessage = messageToOpenAIMessage(generation.message);
+            if (openAIMessage.function_call) {
+                return (await this.getNumTokensFromMessages([generation.message]))
+                    .countPerMessage[0];
+            }
+            else {
+                return await this.getNumTokens(generation.message.content);
+            }
+        }));
+        return generationUsages.reduce((a, b) => a + b, 0);
+    }
     async getNumTokensFromMessages(messages) {
         let totalCount = 0;
         let tokensPerMessage = 0;
         let tokensPerName = 0;
         // From: https://github.com/openai/openai-cookbook/blob/main/examples/How_to_format_inputs_to_ChatGPT_models.ipynb
-        if (getModelNameForTiktoken(this.modelName) === "gpt-3.5-turbo") {
+        if (this.modelName === "gpt-3.5-turbo-0301") {
             tokensPerMessage = 4;
             tokensPerName = -1;
         }
-        else if (getModelNameForTiktoken(this.modelName).startsWith("gpt-4")) {
+        else {
             tokensPerMessage = 3;
             tokensPerName = 1;
         }
@@ -500,7 +571,21 @@ export class ChatOpenAI extends BaseChatModel {
             const nameCount = message.name !== undefined
                 ? tokensPerName + (await this.getNumTokens(message.name))
                 : 0;
-            const count = textCount + tokensPerMessage + roleCount + nameCount;
+            let count = textCount + tokensPerMessage + roleCount + nameCount;
+            // From: https://github.com/hmarr/openai-chat-tokens/blob/main/src/index.ts messageTokenEstimate
+            const openAIMessage = messageToOpenAIMessage(message);
+            if (openAIMessage.role === "function") {
+                count -= 2;
+            }
+            if (openAIMessage.function_call) {
+                count += 3;
+            }
+            if (openAIMessage.function_call?.name) {
+                count += await this.getNumTokens(openAIMessage.function_call?.name);
+            }
+            if (openAIMessage.function_call?.arguments) {
+                count += await this.getNumTokens(openAIMessage.function_call?.arguments);
+            }
             totalCount += count;
             return count;
         }));

package/dist/embeddings/hf.cjs

@@ -24,6 +24,12 @@ class HuggingFaceInferenceEmbeddings extends base_js_1.Embeddings {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "endpointUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
@@ -34,7 +40,10 @@ class HuggingFaceInferenceEmbeddings extends base_js_1.Embeddings {
             fields?.model ?? "sentence-transformers/distilbert-base-nli-mean-tokens";
         this.apiKey =
             fields?.apiKey ?? (0, env_js_1.getEnvironmentVariable)("HUGGINGFACEHUB_API_KEY");
-        this.client = new inference_1.HfInference(this.apiKey);
+        this.endpointUrl = fields?.endpointUrl;
+        this.client = this.endpointUrl
+            ? new inference_1.HfInference(this.apiKey).endpoint(this.endpointUrl)
+            : new inference_1.HfInference(this.apiKey);
     }
     async _embed(texts) {
         // replace newlines, which can negatively affect performance.

package/dist/embeddings/hf.d.ts

@@ -1,4 +1,4 @@
-import { HfInference } from "@huggingface/inference";
+import { HfInference, HfInferenceEndpoint } from "@huggingface/inference";
 import { Embeddings, EmbeddingsParams } from "./base.js";
 /**
  * Interface that extends EmbeddingsParams and defines additional
@@ -7,6 +7,7 @@ import { Embeddings, EmbeddingsParams } from "./base.js";
 export interface HuggingFaceInferenceEmbeddingsParams extends EmbeddingsParams {
     apiKey?: string;
     model?: string;
+    endpointUrl?: string;
 }
 /**
  * Class that extends the Embeddings class and provides methods for
@@ -16,7 +17,8 @@ export interface HuggingFaceInferenceEmbeddingsParams extends EmbeddingsParams {
 export declare class HuggingFaceInferenceEmbeddings extends Embeddings implements HuggingFaceInferenceEmbeddingsParams {
     apiKey?: string;
     model: string;
-    client: HfInference;
+    endpointUrl?: string;
+    client: HfInference | HfInferenceEndpoint;
     constructor(fields?: HuggingFaceInferenceEmbeddingsParams);
     _embed(texts: string[]): Promise<number[][]>;
     /**

package/dist/embeddings/hf.js

@@ -21,6 +21,12 @@ export class HuggingFaceInferenceEmbeddings extends Embeddings {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "endpointUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
@@ -31,7 +37,10 @@ export class HuggingFaceInferenceEmbeddings extends Embeddings {
             fields?.model ?? "sentence-transformers/distilbert-base-nli-mean-tokens";
         this.apiKey =
             fields?.apiKey ?? getEnvironmentVariable("HUGGINGFACEHUB_API_KEY");
-        this.client = new HfInference(this.apiKey);
+        this.endpointUrl = fields?.endpointUrl;
+        this.client = this.endpointUrl
+            ? new HfInference(this.apiKey).endpoint(this.endpointUrl)
+            : new HfInference(this.apiKey);
     }
     async _embed(texts) {
         // replace newlines, which can negatively affect performance.

package/dist/embeddings/llama_cpp.cjs

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlamaCppEmbeddings = void 0;
+const llama_cpp_js_1 = require("../util/llama_cpp.cjs");
+const base_js_1 = require("./base.cjs");
+class LlamaCppEmbeddings extends base_js_1.Embeddings {
+    constructor(inputs) {
+        super(inputs);
+        Object.defineProperty(this, "_model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const _inputs = inputs;
+        _inputs.embedding = true;
+        this._model = (0, llama_cpp_js_1.createLlamaModel)(_inputs);
+        this._context = (0, llama_cpp_js_1.createLlamaContext)(this._model, _inputs);
+    }
+    /**
+     * Generates embeddings for an array of texts.
+     * @param texts - An array of strings to generate embeddings for.
+     * @returns A Promise that resolves to an array of embeddings.
+     */
+    async embedDocuments(texts) {
+        const tokensArray = [];
+        for (const text of texts) {
+            const encodings = await this.caller.call(() => new Promise((resolve) => {
+                resolve(this._context.encode(text));
+            }));
+            tokensArray.push(encodings);
+        }
+        const embeddings = [];
+        for (const tokens of tokensArray) {
+            const embedArray = [];
+            for (let i = 0; i < tokens.length; i += 1) {
+                const nToken = +tokens[i];
+                embedArray.push(nToken);
+            }
+            embeddings.push(embedArray);
+        }
+        return embeddings;
+    }
+    /**
+     * Generates an embedding for a single text.
+     * @param text - A string to generate an embedding for.
+     * @returns A Promise that resolves to an array of numbers representing the embedding.
+     */
+    async embedQuery(text) {
+        const tokens = [];
+        const encodings = await this.caller.call(() => new Promise((resolve) => {
+            resolve(this._context.encode(text));
+        }));
+        for (let i = 0; i < encodings.length; i += 1) {
+            const token = +encodings[i];
+            tokens.push(token);
+        }
+        return tokens;
+    }
+}
+exports.LlamaCppEmbeddings = LlamaCppEmbeddings;

package/dist/embeddings/llama_cpp.d.ts

@@ -0,0 +1,26 @@
+import { LlamaModel, LlamaContext } from "node-llama-cpp";
+import { LlamaBaseCppInputs } from "../util/llama_cpp.js";
+import { Embeddings, EmbeddingsParams } from "./base.js";
+/**
+ * Note that the modelPath is the only required parameter. For testing you
+ * can set this in the environment variable `LLAMA_PATH`.
+ */
+export interface LlamaCppEmbeddingsParams extends LlamaBaseCppInputs, EmbeddingsParams {
+}
+export declare class LlamaCppEmbeddings extends Embeddings {
+    _model: LlamaModel;
+    _context: LlamaContext;
+    constructor(inputs: LlamaCppEmbeddingsParams);
+    /**
+     * Generates embeddings for an array of texts.
+     * @param texts - An array of strings to generate embeddings for.
+     * @returns A Promise that resolves to an array of embeddings.
+     */
+    embedDocuments(texts: string[]): Promise<number[][]>;
+    /**
+     * Generates an embedding for a single text.
+     * @param text - A string to generate an embedding for.
+     * @returns A Promise that resolves to an array of numbers representing the embedding.
+     */
+    embedQuery(text: string): Promise<number[]>;
+}

package/dist/embeddings/llama_cpp.js

@@ -0,0 +1,63 @@
+import { createLlamaModel, createLlamaContext, } from "../util/llama_cpp.js";
+import { Embeddings } from "./base.js";
+export class LlamaCppEmbeddings extends Embeddings {
+    constructor(inputs) {
+        super(inputs);
+        Object.defineProperty(this, "_model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const _inputs = inputs;
+        _inputs.embedding = true;
+        this._model = createLlamaModel(_inputs);
+        this._context = createLlamaContext(this._model, _inputs);
+    }
+    /**
+     * Generates embeddings for an array of texts.
+     * @param texts - An array of strings to generate embeddings for.
+     * @returns A Promise that resolves to an array of embeddings.
+     */
+    async embedDocuments(texts) {
+        const tokensArray = [];
+        for (const text of texts) {
+            const encodings = await this.caller.call(() => new Promise((resolve) => {
+                resolve(this._context.encode(text));
+            }));
+            tokensArray.push(encodings);
+        }
+        const embeddings = [];
+        for (const tokens of tokensArray) {
+            const embedArray = [];
+            for (let i = 0; i < tokens.length; i += 1) {
+                const nToken = +tokens[i];
+                embedArray.push(nToken);
+            }
+            embeddings.push(embedArray);
+        }
+        return embeddings;
+    }
+    /**
+     * Generates an embedding for a single text.
+     * @param text - A string to generate an embedding for.
+     * @returns A Promise that resolves to an array of numbers representing the embedding.
+     */
+    async embedQuery(text) {
+        const tokens = [];
+        const encodings = await this.caller.call(() => new Promise((resolve) => {
+            resolve(this._context.encode(text));
+        }));
+        for (let i = 0; i < encodings.length; i += 1) {
+            const token = +encodings[i];
+            tokens.push(token);
+        }
+        return tokens;
+    }
+}

package/dist/embeddings/ollama.cjs

@@ -81,7 +81,13 @@ class OllamaEmbeddings extends base_js_1.Embeddings {
     }
     async _request(prompt) {
         const { model, baseUrl, requestOptions } = this;
-        const response = await fetch(`${baseUrl}/api/embeddings`, {
+        let formattedBaseUrl = baseUrl;
+        if (formattedBaseUrl.startsWith("http://localhost:")) {
+            // Node 18 has issues with resolving "localhost"
+            // See https://github.com/node-fetch/node-fetch/issues/1624
+            formattedBaseUrl = formattedBaseUrl.replace("http://localhost:", "http://127.0.0.1:");
+        }
+        const response = await fetch(`${formattedBaseUrl}/api/embeddings`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({

package/dist/embeddings/ollama.js

@@ -78,7 +78,13 @@ export class OllamaEmbeddings extends Embeddings {
     }
     async _request(prompt) {
         const { model, baseUrl, requestOptions } = this;
-        const response = await fetch(`${baseUrl}/api/embeddings`, {
+        let formattedBaseUrl = baseUrl;
+        if (formattedBaseUrl.startsWith("http://localhost:")) {
+            // Node 18 has issues with resolving "localhost"
+            // See https://github.com/node-fetch/node-fetch/issues/1624
+            formattedBaseUrl = formattedBaseUrl.replace("http://localhost:", "http://127.0.0.1:");
+        }
+        const response = await fetch(`${formattedBaseUrl}/api/embeddings`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({

package/dist/llms/bedrock.cjs

@@ -92,6 +92,12 @@ class Bedrock extends base_js_1.LLM {
             writable: true,
             value: new eventstream_codec_1.EventStreamCodec(util_utf8_1.toUtf8, util_utf8_1.fromUtf8)
         });
+        Object.defineProperty(this, "streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         this.model = fields?.model ?? this.model;
         const allowedModels = ["ai21", "anthropic", "amazon"];
         if (!allowedModels.includes(this.model.split(".")[0])) {
@@ -109,6 +115,7 @@ class Bedrock extends base_js_1.LLM {
         this.endpointHost = fields?.endpointHost ?? fields?.endpointUrl;
         this.stopSequences = fields?.stopSequences;
         this.modelKwargs = fields?.modelKwargs;
+        this.streaming = fields?.streaming ?? this.streaming;
     }
     /** Call out to Bedrock service model.
       Arguments:
@@ -120,10 +127,23 @@ class Bedrock extends base_js_1.LLM {
       Example:
         response = model.call("Tell me a joke.")
     */
-    async _call(prompt, options) {
+    async _call(prompt, options, runManager) {
         const service = "bedrock-runtime";
         const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
         const provider = this.model.split(".")[0];
+        if (this.streaming) {
+            const stream = this._streamResponseChunks(prompt, options, runManager);
+            let finalResult;
+            for await (const chunk of stream) {
+                if (finalResult === undefined) {
+                    finalResult = chunk;
+                }
+                else {
+                    finalResult = finalResult.concat(chunk);
+                }
+            }
+            return finalResult?.text ?? "";
+        }
         const response = await this._signedFetch(prompt, options, {
             bedrockMethod: "invoke",
             endpointHost,
@@ -204,7 +224,8 @@ class Bedrock extends base_js_1.LLM {
                         text,
                         generationInfo: {},
                     });
-                    await runManager?.handleLLMNewToken(text);
+                    // eslint-disable-next-line no-void
+                    void runManager?.handleLLMNewToken(text);
                 }
             }
         }
@@ -215,7 +236,8 @@ class Bedrock extends base_js_1.LLM {
                 text,
                 generationInfo: {},
             });
-            await runManager?.handleLLMNewToken(text);
+            // eslint-disable-next-line no-void
+            void runManager?.handleLLMNewToken(text);
         }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any