langchain 0.0.152 → 0.0.153

package/chat_models/fireworks.cjs

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

package/chat_models/fireworks.d.ts

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

package/chat_models/fireworks.js

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

package/dist/agents/executor.cjs

@@ -147,8 +147,15 @@ class AgentExecutor extends base_js_1.BaseChain {
                 // eslint-disable-next-line no-instanceof/no-instanceof
                 if (e instanceof output_parser_js_1.OutputParserException) {
                     let observation;
+                    let text = e.message;
                     if (this.handleParsingErrors === true) {
-                        observation = "Invalid or incomplete response";
+                        if (e.sendToLLM) {
+                            observation = e.observation;
+                            text = e.llmOutput ?? "";
+                        }
+                        else {
+                            observation = "Invalid or incomplete response";
+                        }
                     }
                     else if (typeof this.handleParsingErrors === "string") {
                         observation = this.handleParsingErrors;
@@ -162,7 +169,7 @@ class AgentExecutor extends base_js_1.BaseChain {
                     output = {
                         tool: "_Exception",
                         toolInput: observation,
-                        log: e.message,
+                        log: text,
                     };
                 }
                 else {

package/dist/agents/executor.js

@@ -143,8 +143,15 @@ export class AgentExecutor extends BaseChain {
                 // eslint-disable-next-line no-instanceof/no-instanceof
                 if (e instanceof OutputParserException) {
                     let observation;
+                    let text = e.message;
                     if (this.handleParsingErrors === true) {
-                        observation = "Invalid or incomplete response";
+                        if (e.sendToLLM) {
+                            observation = e.observation;
+                            text = e.llmOutput ?? "";
+                        }
+                        else {
+                            observation = "Invalid or incomplete response";
+                        }
                     }
                     else if (typeof this.handleParsingErrors === "string") {
                         observation = this.handleParsingErrors;
@@ -158,7 +165,7 @@ export class AgentExecutor extends BaseChain {
                     output = {
                         tool: "_Exception",
                         toolInput: observation,
-                        log: e.message,
+                        log: text,
                     };
                 }
                 else {

package/dist/base_language/count_tokens.cjs

@@ -58,7 +58,7 @@ exports.getModelContextSize = getModelContextSize;
 const calculateMaxTokens = async ({ prompt, modelName, }) => {
     let numTokens;
     try {
-        numTokens = (await (0, tiktoken_js_1.encodingForModel)(modelName)).encode(prompt).length;
+        numTokens = (await (0, tiktoken_js_1.encodingForModel)((0, exports.getModelNameForTiktoken)(modelName))).encode(prompt).length;
     }
     catch (error) {
         console.warn("Failed to calculate number of tokens, falling back to approximate count");

package/dist/base_language/count_tokens.js

@@ -52,7 +52,7 @@ export const getModelContextSize = (modelName) => {
 export const calculateMaxTokens = async ({ prompt, modelName, }) => {
     let numTokens;
     try {
-        numTokens = (await encodingForModel(modelName)).encode(prompt).length;
+        numTokens = (await encodingForModel(getModelNameForTiktoken(modelName))).encode(prompt).length;
     }
     catch (error) {
         console.warn("Failed to calculate number of tokens, falling back to approximate count");

package/dist/chains/openai_functions/structured_output.d.ts

@@ -46,5 +46,5 @@ export declare class FunctionCallStructuredOutputParser<T extends z.AnyZodObject
  * as well as an additional required "outputSchema" JSON Schema object.
  * @returns OpenAPIChain
  */
-export declare function createStructuredOutputChain<T extends z.AnyZodObject = z.AnyZodObject>(input: StructuredOutputChainInput): LLMChain<any, ChatOpenAI | BaseChatModel<BaseFunctionCallOptions>>;
-export declare function createStructuredOutputChainFromZod<T extends z.AnyZodObject>(zodSchema: T, input: Omit<StructuredOutputChainInput, "outputSchema">): LLMChain<any, ChatOpenAI | BaseChatModel<BaseFunctionCallOptions>>;
+export declare function createStructuredOutputChain<T extends z.AnyZodObject = z.AnyZodObject>(input: StructuredOutputChainInput): LLMChain<any, BaseChatModel<BaseFunctionCallOptions> | ChatOpenAI<BaseFunctionCallOptions>>;
+export declare function createStructuredOutputChainFromZod<T extends z.AnyZodObject>(zodSchema: T, input: Omit<StructuredOutputChainInput, "outputSchema">): LLMChain<any, BaseChatModel<BaseFunctionCallOptions> | ChatOpenAI<BaseFunctionCallOptions>>;

package/dist/chat_models/base.d.ts

@@ -109,7 +109,7 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
  * An abstract class that extends BaseChatModel and provides a simple
  * implementation of _generate.
  */
-export declare abstract class SimpleChatModel extends BaseChatModel {
+export declare abstract class SimpleChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseChatModel<CallOptions> {
     abstract _call(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
 }

package/dist/chat_models/fireworks.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatFireworks = void 0;
+const openai_js_1 = require("./openai.cjs");
+const env_js_1 = require("../util/env.cjs");
+/**
+ * Wrapper around Fireworks API for large language models fine-tuned for chat
+ *
+ * Fireworks API is compatible to the OpenAI API with some limitations described in
+ * https://readme.fireworks.ai/docs/openai-compatibility.
+ *
+ * To use, you should have the `openai` package installed and
+ * the `FIREWORKS_API_KEY` environment variable set.
+ */
+class ChatFireworks extends openai_js_1.ChatOpenAI {
+    static lc_name() {
+        return "ChatFireworks";
+    }
+    _llmType() {
+        return "fireworks";
+    }
+    get lc_secrets() {
+        return {
+            fireworksApiKey: "FIREWORKS_API_KEY",
+        };
+    }
+    constructor(fields) {
+        const fireworksApiKey = fields?.fireworksApiKey || (0, env_js_1.getEnvironmentVariable)("FIREWORKS_API_KEY");
+        if (!fireworksApiKey) {
+            throw new Error(`Fireworks API key not found. Please set the FIREWORKS_API_KEY environment variable or provide the key into "fireworksApiKey"`);
+        }
+        super({
+            ...fields,
+            modelName: fields?.modelName || "accounts/fireworks/models/llama-v2-13b-chat",
+            openAIApiKey: fireworksApiKey,
+            configuration: {
+                baseURL: "https://api.fireworks.ai/inference/v1",
+            },
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "fireworksApiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fireworksApiKey = fireworksApiKey;
+    }
+    toJSON() {
+        const result = super.toJSON();
+        if ("kwargs" in result &&
+            typeof result.kwargs === "object" &&
+            result.kwargs != null) {
+            delete result.kwargs.openai_api_key;
+            delete result.kwargs.configuration;
+        }
+        return result;
+    }
+    /**
+     * Calls the Fireworks API with retry logic in case of failures.
+     * @param request The request to send to the Fireworks API.
+     * @param options Optional configuration for the API call.
+     * @returns The response from the Fireworks API.
+     */
+    async completionWithRetry(request, options) {
+        delete request.frequency_penalty;
+        delete request.presence_penalty;
+        delete request.logit_bias;
+        delete request.functions;
+        if (request.stream === true) {
+            return super.completionWithRetry(request, options);
+        }
+        return super.completionWithRetry(request, options);
+    }
+}
+exports.ChatFireworks = ChatFireworks;

package/dist/chat_models/fireworks.d.ts

@@ -0,0 +1,33 @@
+import type { OpenAI as OpenAIClient } from "openai";
+import type { ChatOpenAICallOptions, OpenAIChatInput } from "./openai.js";
+import type { OpenAICoreRequestOptions } from "../types/openai-types.js";
+import type { BaseChatModelParams } from "./base.js";
+import { ChatOpenAI } from "./openai.js";
+type FireworksUnsupportedArgs = "frequencyPenalty" | "presencePenalty" | "logitBias" | "functions";
+type FireworksUnsupportedCallOptions = "functions" | "function_call" | "tools";
+export type ChatFireworksCallOptions = Partial<Omit<ChatOpenAICallOptions, FireworksUnsupportedCallOptions>>;
+/**
+ * Wrapper around Fireworks API for large language models fine-tuned for chat
+ *
+ * Fireworks API is compatible to the OpenAI API with some limitations described in
+ * https://readme.fireworks.ai/docs/openai-compatibility.
+ *
+ * To use, you should have the `openai` package installed and
+ * the `FIREWORKS_API_KEY` environment variable set.
+ */
+export declare class ChatFireworks extends ChatOpenAI<ChatFireworksCallOptions> {
+    static lc_name(): string;
+    _llmType(): string;
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    lc_serializable: boolean;
+    fireworksApiKey?: string;
+    constructor(fields?: Partial<Omit<OpenAIChatInput, "openAIApiKey" | FireworksUnsupportedArgs>> & BaseChatModelParams & {
+        fireworksApiKey?: string;
+    });
+    toJSON(): import("../load/serializable.js").Serialized;
+    completionWithRetry(request: OpenAIClient.Chat.ChatCompletionCreateParamsStreaming, options?: OpenAICoreRequestOptions): Promise<AsyncIterable<OpenAIClient.Chat.Completions.ChatCompletionChunk>>;
+    completionWithRetry(request: OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming, options?: OpenAICoreRequestOptions): Promise<OpenAIClient.Chat.Completions.ChatCompletion>;
+}
+export {};

package/dist/chat_models/fireworks.js

@@ -0,0 +1,77 @@
+import { ChatOpenAI } from "./openai.js";
+import { getEnvironmentVariable } from "../util/env.js";
+/**
+ * Wrapper around Fireworks API for large language models fine-tuned for chat
+ *
+ * Fireworks API is compatible to the OpenAI API with some limitations described in
+ * https://readme.fireworks.ai/docs/openai-compatibility.
+ *
+ * To use, you should have the `openai` package installed and
+ * the `FIREWORKS_API_KEY` environment variable set.
+ */
+export class ChatFireworks extends ChatOpenAI {
+    static lc_name() {
+        return "ChatFireworks";
+    }
+    _llmType() {
+        return "fireworks";
+    }
+    get lc_secrets() {
+        return {
+            fireworksApiKey: "FIREWORKS_API_KEY",
+        };
+    }
+    constructor(fields) {
+        const fireworksApiKey = fields?.fireworksApiKey || getEnvironmentVariable("FIREWORKS_API_KEY");
+        if (!fireworksApiKey) {
+            throw new Error(`Fireworks API key not found. Please set the FIREWORKS_API_KEY environment variable or provide the key into "fireworksApiKey"`);
+        }
+        super({
+            ...fields,
+            modelName: fields?.modelName || "accounts/fireworks/models/llama-v2-13b-chat",
+            openAIApiKey: fireworksApiKey,
+            configuration: {
+                baseURL: "https://api.fireworks.ai/inference/v1",
+            },
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "fireworksApiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fireworksApiKey = fireworksApiKey;
+    }
+    toJSON() {
+        const result = super.toJSON();
+        if ("kwargs" in result &&
+            typeof result.kwargs === "object" &&
+            result.kwargs != null) {
+            delete result.kwargs.openai_api_key;
+            delete result.kwargs.configuration;
+        }
+        return result;
+    }
+    /**
+     * Calls the Fireworks API with retry logic in case of failures.
+     * @param request The request to send to the Fireworks API.
+     * @param options Optional configuration for the API call.
+     * @returns The response from the Fireworks API.
+     */
+    async completionWithRetry(request, options) {
+        delete request.frequency_penalty;
+        delete request.presence_penalty;
+        delete request.logit_bias;
+        delete request.functions;
+        if (request.stream === true) {
+            return super.completionWithRetry(request, options);
+        }
+        return super.completionWithRetry(request, options);
+    }
+}

package/dist/chat_models/ollama.cjs

@@ -303,11 +303,28 @@ class ChatOllama extends base_js_1.SimpleChatModel {
             prompt: this._formatMessagesAsPrompt(input),
         }, options));
         for await (const chunk of stream) {
-            yield new index_js_1.ChatGenerationChunk({
-                text: chunk.response,
-                message: new index_js_1.AIMessageChunk({ content: chunk.response }),
-            });
-            await runManager?.handleLLMNewToken(chunk.response ?? "");
+            if (!chunk.done) {
+                yield new index_js_1.ChatGenerationChunk({
+                    text: chunk.response,
+                    message: new index_js_1.AIMessageChunk({ content: chunk.response }),
+                });
+                await runManager?.handleLLMNewToken(chunk.response ?? "");
+            }
+            else {
+                yield new index_js_1.ChatGenerationChunk({
+                    text: "",
+                    message: new index_js_1.AIMessageChunk({ content: "" }),
+                    generationInfo: {
+                        model: chunk.model,
+                        total_duration: chunk.total_duration,
+                        load_duration: chunk.load_duration,
+                        prompt_eval_count: chunk.prompt_eval_count,
+                        prompt_eval_duration: chunk.prompt_eval_duration,
+                        eval_count: chunk.eval_count,
+                        eval_duration: chunk.eval_duration,
+                    },
+                });
+            }
         }
     }
     _formatMessagesAsPrompt(messages) {

package/dist/chat_models/ollama.d.ts

@@ -14,8 +14,7 @@ export interface OllamaCallOptions extends BaseLanguageModelCallOptions {
  * models in a chat-like fashion. It extends the SimpleChatModel class and
  * implements the OllamaInput interface.
  */
-export declare class ChatOllama extends SimpleChatModel implements OllamaInput {
-    CallOptions: OllamaCallOptions;
+export declare class ChatOllama extends SimpleChatModel<OllamaCallOptions> implements OllamaInput {
     static lc_name(): string;
     lc_serializable: boolean;
     model: string;

package/dist/chat_models/ollama.js

@@ -300,11 +300,28 @@ export class ChatOllama extends SimpleChatModel {
             prompt: this._formatMessagesAsPrompt(input),
         }, options));
         for await (const chunk of stream) {
-            yield new ChatGenerationChunk({
-                text: chunk.response,
-                message: new AIMessageChunk({ content: chunk.response }),
-            });
-            await runManager?.handleLLMNewToken(chunk.response ?? "");
+            if (!chunk.done) {
+                yield new ChatGenerationChunk({
+                    text: chunk.response,
+                    message: new AIMessageChunk({ content: chunk.response }),
+                });
+                await runManager?.handleLLMNewToken(chunk.response ?? "");
+            }
+            else {
+                yield new ChatGenerationChunk({
+                    text: "",
+                    message: new AIMessageChunk({ content: "" }),
+                    generationInfo: {
+                        model: chunk.model,
+                        total_duration: chunk.total_duration,
+                        load_duration: chunk.load_duration,
+                        prompt_eval_count: chunk.prompt_eval_count,
+                        prompt_eval_duration: chunk.prompt_eval_duration,
+                        eval_count: chunk.eval_count,
+                        eval_duration: chunk.eval_duration,
+                    },
+                });
+            }
         }
     }
     _formatMessagesAsPrompt(messages) {

package/dist/chat_models/openai.d.ts

@@ -37,9 +37,9 @@ export interface ChatOpenAICallOptions extends OpenAICallOptions, BaseFunctionCa
  * `openai.createChatCompletion`} can be passed through {@link modelKwargs}, even
  * if not explicitly available on this class.
  */
-export declare class ChatOpenAI extends BaseChatModel<ChatOpenAICallOptions> implements OpenAIChatInput, AzureOpenAIInput {
+export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = ChatOpenAICallOptions> extends BaseChatModel<CallOptions> implements OpenAIChatInput, AzureOpenAIInput {
     static lc_name(): string;
-    get callKeys(): (keyof ChatOpenAICallOptions)[];
+    get callKeys(): string[];
     lc_serializable: boolean;
     get lc_secrets(): {
         [key: string]: string;

package/dist/llms/fireworks.cjs

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fireworks = void 0;
+const env_js_1 = require("../util/env.cjs");
+const openai_js_1 = require("./openai.cjs");
+/**
+ * Wrapper around Fireworks API for large language models
+ *
+ * Fireworks API is compatible to the OpenAI API with some limitations described in
+ * https://readme.fireworks.ai/docs/openai-compatibility.
+ *
+ * To use, you should have the `openai` package installed and
+ * the `FIREWORKS_API_KEY` environment variable set.
+ */
+class Fireworks extends openai_js_1.OpenAI {
+    static lc_name() {
+        return "Fireworks";
+    }
+    _llmType() {
+        return "fireworks";
+    }
+    get lc_secrets() {
+        return {
+            fireworksApiKey: "FIREWORKS_API_KEY",
+        };
+    }
+    constructor(fields) {
+        const fireworksApiKey = fields?.fireworksApiKey || (0, env_js_1.getEnvironmentVariable)("FIREWORKS_API_KEY");
+        if (!fireworksApiKey) {
+            throw new Error(`Fireworks API key not found. Please set the FIREWORKS_API_KEY environment variable or provide the key into "fireworksApiKey"`);
+        }
+        super({
+            ...fields,
+            openAIApiKey: fireworksApiKey,
+            modelName: fields?.modelName || "accounts/fireworks/models/llama-v2-13b",
+            configuration: {
+                baseURL: "https://api.fireworks.ai/inference/v1",
+            },
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "fireworksApiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fireworksApiKey = fireworksApiKey;
+    }
+    toJSON() {
+        const result = super.toJSON();
+        if ("kwargs" in result &&
+            typeof result.kwargs === "object" &&
+            result.kwargs != null) {
+            delete result.kwargs.openai_api_key;
+            delete result.kwargs.configuration;
+        }
+        return result;
+    }
+    /**
+     * Calls the Fireworks API with retry logic in case of failures.
+     * @param request The request to send to the Fireworks API.
+     * @param options Optional configuration for the API call.
+     * @returns The response from the Fireworks API.
+     */
+    async completionWithRetry(request, options) {
+        // https://readme.fireworks.ai/docs/openai-compatibility#api-compatibility
+        if (Array.isArray(request.prompt)) {
+            if (request.prompt.length > 1) {
+                throw new Error("Multiple prompts are not supported by Fireworks");
+            }
+            const prompt = request.prompt[0];
+            if (typeof prompt !== "string") {
+                throw new Error("Only string prompts are supported by Fireworks");
+            }
+            request.prompt = prompt;
+        }
+        delete request.frequency_penalty;
+        delete request.presence_penalty;
+        delete request.best_of;
+        delete request.logit_bias;
+        if (request.stream === true) {
+            return super.completionWithRetry(request, options);
+        }
+        return super.completionWithRetry(request, options);
+    }
+}
+exports.Fireworks = Fireworks;

package/dist/llms/fireworks.d.ts

@@ -0,0 +1,33 @@
+import type { OpenAI as OpenAIClient } from "openai";
+import type { BaseLLMParams } from "./base.js";
+import type { OpenAICallOptions, OpenAIInput } from "./openai.js";
+import type { OpenAICoreRequestOptions } from "../types/openai-types.js";
+import { OpenAI } from "./openai.js";
+type FireworksUnsupportedArgs = "frequencyPenalty" | "presencePenalty" | "bestOf" | "logitBias";
+type FireworksUnsupportedCallOptions = "functions" | "function_call" | "tools";
+export type FireworksCallOptions = Partial<Omit<OpenAICallOptions, FireworksUnsupportedCallOptions>>;
+/**
+ * Wrapper around Fireworks API for large language models
+ *
+ * Fireworks API is compatible to the OpenAI API with some limitations described in
+ * https://readme.fireworks.ai/docs/openai-compatibility.
+ *
+ * To use, you should have the `openai` package installed and
+ * the `FIREWORKS_API_KEY` environment variable set.
+ */
+export declare class Fireworks extends OpenAI<FireworksCallOptions> {
+    static lc_name(): string;
+    _llmType(): string;
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    lc_serializable: boolean;
+    fireworksApiKey?: string;
+    constructor(fields?: Partial<Omit<OpenAIInput, "openAIApiKey" | FireworksUnsupportedArgs>> & BaseLLMParams & {
+        fireworksApiKey?: string;
+    });
+    toJSON(): import("../load/serializable.js").Serialized;
+    completionWithRetry(request: OpenAIClient.CompletionCreateParamsStreaming, options?: OpenAICoreRequestOptions): Promise<AsyncIterable<OpenAIClient.Completion>>;
+    completionWithRetry(request: OpenAIClient.CompletionCreateParamsNonStreaming, options?: OpenAICoreRequestOptions): Promise<OpenAIClient.Completions.Completion>;
+}
+export {};

package/dist/llms/fireworks.js

@@ -0,0 +1,88 @@
+import { getEnvironmentVariable } from "../util/env.js";
+import { OpenAI } from "./openai.js";
+/**
+ * Wrapper around Fireworks API for large language models
+ *
+ * Fireworks API is compatible to the OpenAI API with some limitations described in
+ * https://readme.fireworks.ai/docs/openai-compatibility.
+ *
+ * To use, you should have the `openai` package installed and
+ * the `FIREWORKS_API_KEY` environment variable set.
+ */
+export class Fireworks extends OpenAI {
+    static lc_name() {
+        return "Fireworks";
+    }
+    _llmType() {
+        return "fireworks";
+    }
+    get lc_secrets() {
+        return {
+            fireworksApiKey: "FIREWORKS_API_KEY",
+        };
+    }
+    constructor(fields) {
+        const fireworksApiKey = fields?.fireworksApiKey || getEnvironmentVariable("FIREWORKS_API_KEY");
+        if (!fireworksApiKey) {
+            throw new Error(`Fireworks API key not found. Please set the FIREWORKS_API_KEY environment variable or provide the key into "fireworksApiKey"`);
+        }
+        super({
+            ...fields,
+            openAIApiKey: fireworksApiKey,
+            modelName: fields?.modelName || "accounts/fireworks/models/llama-v2-13b",
+            configuration: {
+                baseURL: "https://api.fireworks.ai/inference/v1",
+            },
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "fireworksApiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fireworksApiKey = fireworksApiKey;
+    }
+    toJSON() {
+        const result = super.toJSON();
+        if ("kwargs" in result &&
+            typeof result.kwargs === "object" &&
+            result.kwargs != null) {
+            delete result.kwargs.openai_api_key;
+            delete result.kwargs.configuration;
+        }
+        return result;
+    }
+    /**
+     * Calls the Fireworks API with retry logic in case of failures.
+     * @param request The request to send to the Fireworks API.
+     * @param options Optional configuration for the API call.
+     * @returns The response from the Fireworks API.
+     */
+    async completionWithRetry(request, options) {
+        // https://readme.fireworks.ai/docs/openai-compatibility#api-compatibility
+        if (Array.isArray(request.prompt)) {
+            if (request.prompt.length > 1) {
+                throw new Error("Multiple prompts are not supported by Fireworks");
+            }
+            const prompt = request.prompt[0];
+            if (typeof prompt !== "string") {
+                throw new Error("Only string prompts are supported by Fireworks");
+            }
+            request.prompt = prompt;
+        }
+        delete request.frequency_penalty;
+        delete request.presence_penalty;
+        delete request.best_of;
+        delete request.logit_bias;
+        if (request.stream === true) {
+            return super.completionWithRetry(request, options);
+        }
+        return super.completionWithRetry(request, options);
+    }
+}

package/dist/llms/ollama.cjs

@@ -290,14 +290,30 @@ class Ollama extends base_js_1.LLM {
     async *_streamResponseChunks(prompt, options, runManager) {
         const stream = await this.caller.call(async () => (0, ollama_js_1.createOllamaStream)(this.baseUrl, { ...this.invocationParams(options), prompt }, options));
         for await (const chunk of stream) {
-            yield new index_js_1.GenerationChunk({
-                text: chunk.response,
-                generationInfo: {
-                    ...chunk,
-                    response: undefined,
-                },
-            });
-            await runManager?.handleLLMNewToken(chunk.response ?? "");
+            if (!chunk.done) {
+                yield new index_js_1.GenerationChunk({
+                    text: chunk.response,
+                    generationInfo: {
+                        ...chunk,
+                        response: undefined,
+                    },
+                });
+                await runManager?.handleLLMNewToken(chunk.response ?? "");
+            }
+            else {
+                yield new index_js_1.GenerationChunk({
+                    text: "",
+                    generationInfo: {
+                        model: chunk.model,
+                        total_duration: chunk.total_duration,
+                        load_duration: chunk.load_duration,
+                        prompt_eval_count: chunk.prompt_eval_count,
+                        prompt_eval_duration: chunk.prompt_eval_duration,
+                        eval_count: chunk.eval_count,
+                        eval_duration: chunk.eval_duration,
+                    },
+                });
+            }
         }
     }
     /** @ignore */

package/dist/llms/ollama.d.ts

@@ -6,8 +6,7 @@ import { GenerationChunk } from "../schema/index.js";
  * Class that represents the Ollama language model. It extends the base
  * LLM class and implements the OllamaInput interface.
  */
-export declare class Ollama extends LLM implements OllamaInput {
-    CallOptions: OllamaCallOptions;
+export declare class Ollama extends LLM<OllamaCallOptions> implements OllamaInput {
     static lc_name(): string;
     lc_serializable: boolean;
     model: string;