langchain 0.0.186 → 0.0.188

package/dist/callbacks/handlers/llmonitor.cjs

@@ -19,8 +19,19 @@ const parseRole = (id) => {
         return "ai";
     if (roleHint.includes("Function"))
         return "function";
+    if (roleHint.includes("Tool"))
+        return "tool";
     return "ai";
 };
+const PARAMS_TO_CAPTURE = [
+    "stop",
+    "stop_sequences",
+    "function_call",
+    "functions",
+    "tools",
+    "tool_choice",
+    "response_format",
+];
 const convertToLLMonitorMessages = (input) => {
     const parseMessage = (raw) => {
         if (typeof raw === "string")
@@ -35,11 +46,10 @@ const convertToLLMonitorMessages = (input) => {
             const role = parseRole(message.id);
             const obj = message.kwargs;
             const text = message.text ?? obj.content;
-            const functionCall = obj.additional_kwargs?.function_call;
             return {
                 role,
                 text,
-                functionCall,
+                ...(obj.additional_kwargs ?? {}),
             };
         }
         catch (e) {
@@ -83,6 +93,21 @@ const parseOutput = (rawOutput) => {
         return result;
     return rawOutput;
 };
+const parseExtraAndName = (llm, extraParams, metadata) => {
+    const params = {
+        ...(extraParams?.invocation_params ?? {}),
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore this is a valid property
+        ...(llm?.kwargs ?? {}),
+        ...(metadata || {}),
+    };
+    const { model, model_name, modelName, model_id, userId, userProps, ...rest } = params;
+    const name = model || modelName || model_name || model_id || llm.id.at(-1);
+    // Filter rest to only include params we want to capture
+    const extra = Object.fromEntries(Object.entries(rest).filter(([key]) => PARAMS_TO_CAPTURE.includes(key) ||
+        ["string", "number", "boolean"].includes(typeof rest[key])));
+    return { name, extra, userId, userProps };
+};
 class LLMonitorHandler extends base_js_1.BaseCallbackHandler {
     constructor(fields = {}) {
         super(fields);
@@ -109,18 +134,13 @@ class LLMonitorHandler extends base_js_1.BaseCallbackHandler {
         }
     }
     async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata) {
-        const params = {
-            ...(extraParams?.invocation_params || {}),
-            ...(metadata || {}),
-        };
-        const { model, model_name, modelName, userId, userProps, ...rest } = params;
-        const name = model || modelName || model_name || llm.id.at(-1);
+        const { name, extra, userId, userProps } = parseExtraAndName(llm, extraParams, metadata);
         await this.monitor.trackEvent("llm", "start", {
             runId,
             parentRunId,
             name,
             input: (0, exports.convertToLLMonitorMessages)(prompts),
-            extra: rest,
+            extra,
             userId,
             userProps,
             tags,
@@ -128,19 +148,13 @@ class LLMonitorHandler extends base_js_1.BaseCallbackHandler {
         });
     }
     async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata) {
-        const params = {
-            ...(extraParams?.invocation_params || {}),
-            ...(metadata || {}),
-        };
-        // Expand them so they're excluded from the "extra" field
-        const { model, model_name, modelName, userId, userProps, ...rest } = params;
-        const name = model || modelName || model_name || llm.id.at(-1);
+        const { name, extra, userId, userProps } = parseExtraAndName(llm, extraParams, metadata);
         await this.monitor.trackEvent("llm", "start", {
             runId,
             parentRunId,
             name,
             input: (0, exports.convertToLLMonitorMessages)(messages),
-            extra: rest,
+            extra,
             userId,
             userProps,
             tags,

package/dist/callbacks/handlers/llmonitor.js

@@ -13,8 +13,19 @@ const parseRole = (id) => {
         return "ai";
     if (roleHint.includes("Function"))
         return "function";
+    if (roleHint.includes("Tool"))
+        return "tool";
     return "ai";
 };
+const PARAMS_TO_CAPTURE = [
+    "stop",
+    "stop_sequences",
+    "function_call",
+    "functions",
+    "tools",
+    "tool_choice",
+    "response_format",
+];
 export const convertToLLMonitorMessages = (input) => {
     const parseMessage = (raw) => {
         if (typeof raw === "string")
@@ -29,11 +40,10 @@ export const convertToLLMonitorMessages = (input) => {
             const role = parseRole(message.id);
             const obj = message.kwargs;
             const text = message.text ?? obj.content;
-            const functionCall = obj.additional_kwargs?.function_call;
             return {
                 role,
                 text,
-                functionCall,
+                ...(obj.additional_kwargs ?? {}),
             };
         }
         catch (e) {
@@ -76,6 +86,21 @@ const parseOutput = (rawOutput) => {
         return result;
     return rawOutput;
 };
+const parseExtraAndName = (llm, extraParams, metadata) => {
+    const params = {
+        ...(extraParams?.invocation_params ?? {}),
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore this is a valid property
+        ...(llm?.kwargs ?? {}),
+        ...(metadata || {}),
+    };
+    const { model, model_name, modelName, model_id, userId, userProps, ...rest } = params;
+    const name = model || modelName || model_name || model_id || llm.id.at(-1);
+    // Filter rest to only include params we want to capture
+    const extra = Object.fromEntries(Object.entries(rest).filter(([key]) => PARAMS_TO_CAPTURE.includes(key) ||
+        ["string", "number", "boolean"].includes(typeof rest[key])));
+    return { name, extra, userId, userProps };
+};
 export class LLMonitorHandler extends BaseCallbackHandler {
     constructor(fields = {}) {
         super(fields);
@@ -102,18 +127,13 @@ export class LLMonitorHandler extends BaseCallbackHandler {
         }
     }
     async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata) {
-        const params = {
-            ...(extraParams?.invocation_params || {}),
-            ...(metadata || {}),
-        };
-        const { model, model_name, modelName, userId, userProps, ...rest } = params;
-        const name = model || modelName || model_name || llm.id.at(-1);
+        const { name, extra, userId, userProps } = parseExtraAndName(llm, extraParams, metadata);
         await this.monitor.trackEvent("llm", "start", {
             runId,
             parentRunId,
             name,
             input: convertToLLMonitorMessages(prompts),
-            extra: rest,
+            extra,
             userId,
             userProps,
             tags,
@@ -121,19 +141,13 @@ export class LLMonitorHandler extends BaseCallbackHandler {
         });
     }
     async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata) {
-        const params = {
-            ...(extraParams?.invocation_params || {}),
-            ...(metadata || {}),
-        };
-        // Expand them so they're excluded from the "extra" field
-        const { model, model_name, modelName, userId, userProps, ...rest } = params;
-        const name = model || modelName || model_name || llm.id.at(-1);
+        const { name, extra, userId, userProps } = parseExtraAndName(llm, extraParams, metadata);
         await this.monitor.trackEvent("llm", "start", {
             runId,
             parentRunId,
             name,
             input: convertToLLMonitorMessages(messages),
-            extra: rest,
+            extra,
             userId,
             userProps,
             tags,

package/dist/chat_models/bedrock/web.cjs

@@ -158,7 +158,7 @@ class BedrockChat extends base_js_1.SimpleChatModel {
             value: true
         });
         this.model = fields?.model ?? this.model;
-        const allowedModels = ["ai21", "anthropic", "amazon", "cohere"];
+        const allowedModels = ["ai21", "anthropic", "amazon", "cohere", "meta"];
         if (!allowedModels.includes(this.model.split(".")[0])) {
             throw new Error(`Unknown model: '${this.model}', only these are supported: ${allowedModels}`);
         }
@@ -260,7 +260,7 @@ class BedrockChat extends base_js_1.SimpleChatModel {
         const provider = this.model.split(".")[0];
         const service = "bedrock-runtime";
         const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
-        const bedrockMethod = provider === "anthropic" || provider === "cohere"
+        const bedrockMethod = provider === "anthropic" || provider === "cohere" || provider === "meta"
             ? "invoke-with-response-stream"
             : "invoke";
         const response = await this._signedFetch(messages, options, {
@@ -271,7 +271,9 @@ class BedrockChat extends base_js_1.SimpleChatModel {
         if (response.status < 200 || response.status >= 300) {
             throw Error(`Failed to access underlying url '${endpointHost}': got ${response.status} ${response.statusText}: ${await response.text()}`);
         }
-        if (provider === "anthropic" || provider === "cohere") {
+        if (provider === "anthropic" ||
+            provider === "cohere" ||
+            provider === "meta") {
             const reader = response.body?.getReader();
             const decoder = new TextDecoder();
             for await (const chunk of this._readChunks(reader)) {

package/dist/chat_models/bedrock/web.js

@@ -153,7 +153,7 @@ export class BedrockChat extends SimpleChatModel {
             value: true
         });
         this.model = fields?.model ?? this.model;
-        const allowedModels = ["ai21", "anthropic", "amazon", "cohere"];
+        const allowedModels = ["ai21", "anthropic", "amazon", "cohere", "meta"];
         if (!allowedModels.includes(this.model.split(".")[0])) {
             throw new Error(`Unknown model: '${this.model}', only these are supported: ${allowedModels}`);
         }
@@ -255,7 +255,7 @@ export class BedrockChat extends SimpleChatModel {
         const provider = this.model.split(".")[0];
         const service = "bedrock-runtime";
         const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
-        const bedrockMethod = provider === "anthropic" || provider === "cohere"
+        const bedrockMethod = provider === "anthropic" || provider === "cohere" || provider === "meta"
             ? "invoke-with-response-stream"
             : "invoke";
         const response = await this._signedFetch(messages, options, {
@@ -266,7 +266,9 @@ export class BedrockChat extends SimpleChatModel {
         if (response.status < 200 || response.status >= 300) {
             throw Error(`Failed to access underlying url '${endpointHost}': got ${response.status} ${response.statusText}: ${await response.text()}`);
         }
-        if (provider === "anthropic" || provider === "cohere") {
+        if (provider === "anthropic" ||
+            provider === "cohere" ||
+            provider === "meta") {
             const reader = response.body?.getReader();
             const decoder = new TextDecoder();
             for await (const chunk of this._readChunks(reader)) {

package/dist/embeddings/cohere.cjs

@@ -27,6 +27,12 @@ class CohereEmbeddings extends base_js_1.Embeddings {
             writable: true,
             value: 48
         });
+        Object.defineProperty(this, "inputType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "apiKey", {
             enumerable: true,
             configurable: true,
@@ -45,6 +51,7 @@ class CohereEmbeddings extends base_js_1.Embeddings {
         }
         this.modelName = fieldsWithDefaults?.modelName ?? this.modelName;
         this.batchSize = fieldsWithDefaults?.batchSize ?? this.batchSize;
+        this.inputType = fieldsWithDefaults?.inputType;
         this.apiKey = apiKey;
     }
     /**
@@ -58,14 +65,15 @@ class CohereEmbeddings extends base_js_1.Embeddings {
         const batchRequests = batches.map((batch) => this.embeddingWithRetry({
             model: this.modelName,
             texts: batch,
+            inputType: this.inputType,
         }));
         const batchResponses = await Promise.all(batchRequests);
         const embeddings = [];
         for (let i = 0; i < batchResponses.length; i += 1) {
             const batch = batches[i];
-            const { body: batchResponse } = batchResponses[i];
+            const { embeddings: batchResponse } = batchResponses[i];
             for (let j = 0; j < batch.length; j += 1) {
-                embeddings.push(batchResponse.embeddings[j]);
+                embeddings.push(batchResponse[j]);
             }
         }
         return embeddings;
@@ -77,11 +85,11 @@ class CohereEmbeddings extends base_js_1.Embeddings {
      */
     async embedQuery(text) {
         await this.maybeInitClient();
-        const { body } = await this.embeddingWithRetry({
+        const { embeddings } = await this.embeddingWithRetry({
             model: this.modelName,
             texts: [text],
         });
-        return body.embeddings[0];
+        return embeddings[0];
     }
     /**
      * Generates embeddings with retry capabilities.
@@ -97,16 +105,17 @@ class CohereEmbeddings extends base_js_1.Embeddings {
      */
     async maybeInitClient() {
         if (!this.client) {
-            const { cohere } = await CohereEmbeddings.imports();
-            this.client = cohere;
-            this.client.init(this.apiKey);
+            const { CohereClient } = await CohereEmbeddings.imports();
+            this.client = new CohereClient({
+                token: this.apiKey,
+            });
         }
     }
     /** @ignore */
     static async imports() {
         try {
-            const { default: cohere } = await import("cohere-ai");
-            return { cohere };
+            const { CohereClient } = await import("cohere-ai");
+            return { CohereClient };
         }
         catch (e) {
             throw new Error("Please install cohere-ai as a dependency with, e.g. `yarn add cohere-ai`");

package/dist/embeddings/cohere.d.ts

@@ -10,6 +10,17 @@ export interface CohereEmbeddingsParams extends EmbeddingsParams {
      * limited by the Cohere API to a maximum of 96.
      */
     batchSize?: number;
+    /**
+     * Specifies the type of input you're giving to the model.
+     * Not required for older versions of the embedding models (i.e. anything lower than v3),
+     * but is required for more recent versions (i.e. anything bigger than v2).
+     *
+     * * `search_document` - Use this when you encode documents for embeddings that you store in a vector database for search use-cases.
+     * * `search_query` - Use this when you query your vector DB to find relevant documents.
+     * * `classification` - Use this when you use the embeddings as an input to a text classifier.
+     * * `clustering` - Use this when you want to cluster the embeddings.
+     */
+    inputType?: string;
 }
 /**
  * A class for generating embeddings using the Cohere API.
@@ -17,6 +28,7 @@ export interface CohereEmbeddingsParams extends EmbeddingsParams {
 export declare class CohereEmbeddings extends Embeddings implements CohereEmbeddingsParams {
     modelName: string;
     batchSize: number;
+    inputType: string | undefined;
     private apiKey;
     private client;
     /**
@@ -51,6 +63,6 @@ export declare class CohereEmbeddings extends Embeddings implements CohereEmbedd
     private maybeInitClient;
     /** @ignore */
     static imports(): Promise<{
-        cohere: typeof import("cohere-ai");
+        CohereClient: typeof import("cohere-ai").CohereClient;
     }>;
 }

package/dist/embeddings/cohere.js

@@ -24,6 +24,12 @@ export class CohereEmbeddings extends Embeddings {
             writable: true,
             value: 48
         });
+        Object.defineProperty(this, "inputType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "apiKey", {
             enumerable: true,
             configurable: true,
@@ -42,6 +48,7 @@ export class CohereEmbeddings extends Embeddings {
         }
         this.modelName = fieldsWithDefaults?.modelName ?? this.modelName;
         this.batchSize = fieldsWithDefaults?.batchSize ?? this.batchSize;
+        this.inputType = fieldsWithDefaults?.inputType;
         this.apiKey = apiKey;
     }
     /**
@@ -55,14 +62,15 @@ export class CohereEmbeddings extends Embeddings {
         const batchRequests = batches.map((batch) => this.embeddingWithRetry({
             model: this.modelName,
             texts: batch,
+            inputType: this.inputType,
         }));
         const batchResponses = await Promise.all(batchRequests);
         const embeddings = [];
         for (let i = 0; i < batchResponses.length; i += 1) {
             const batch = batches[i];
-            const { body: batchResponse } = batchResponses[i];
+            const { embeddings: batchResponse } = batchResponses[i];
             for (let j = 0; j < batch.length; j += 1) {
-                embeddings.push(batchResponse.embeddings[j]);
+                embeddings.push(batchResponse[j]);
             }
         }
         return embeddings;
@@ -74,11 +82,11 @@ export class CohereEmbeddings extends Embeddings {
      */
     async embedQuery(text) {
         await this.maybeInitClient();
-        const { body } = await this.embeddingWithRetry({
+        const { embeddings } = await this.embeddingWithRetry({
             model: this.modelName,
             texts: [text],
         });
-        return body.embeddings[0];
+        return embeddings[0];
     }
     /**
      * Generates embeddings with retry capabilities.
@@ -94,16 +102,17 @@ export class CohereEmbeddings extends Embeddings {
      */
     async maybeInitClient() {
         if (!this.client) {
-            const { cohere } = await CohereEmbeddings.imports();
-            this.client = cohere;
-            this.client.init(this.apiKey);
+            const { CohereClient } = await CohereEmbeddings.imports();
+            this.client = new CohereClient({
+                token: this.apiKey,
+            });
         }
     }
     /** @ignore */
     static async imports() {
         try {
-            const { default: cohere } = await import("cohere-ai");
-            return { cohere };
+            const { CohereClient } = await import("cohere-ai");
+            return { CohereClient };
         }
         catch (e) {
             throw new Error("Please install cohere-ai as a dependency with, e.g. `yarn add cohere-ai`");

package/dist/experimental/chat_models/ollama_functions.cjs

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaFunctions = void 0;
+const base_js_1 = require("../../chat_models/base.cjs");
+const index_js_1 = require("../../schema/index.cjs");
+const ollama_js_1 = require("../../chat_models/ollama.cjs");
+const prompt_js_1 = require("../../prompts/prompt.cjs");
+const TOOL_SYSTEM_PROMPT = 
+/* #__PURE__ */
+prompt_js_1.PromptTemplate.fromTemplate(`You have access to the following tools:
+
+{tools}
+
+To use a tool, respond with a JSON object with the following structure:
+{{
+  "tool": <name of the called tool>,
+  "tool_input": <parameters for the tool matching the above JSON schema>
+}}`);
+class OllamaFunctions extends base_js_1.BaseChatModel {
+    static lc_name() {
+        return "OllamaFunctions";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "llm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "toolSystemPrompt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: TOOL_SYSTEM_PROMPT
+        });
+        Object.defineProperty(this, "defaultResponseFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                name: "__conversational_response",
+                description: "Respond conversationally if no other tools should be called for a given query.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        response: {
+                            type: "string",
+                            description: "Conversational response to the user.",
+                        },
+                    },
+                    required: ["response"],
+                },
+            }
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "experimental", "chat_models"]
+        });
+        this.llm = fields?.llm ?? new ollama_js_1.ChatOllama({ ...fields, format: "json" });
+        this.toolSystemPrompt = fields?.toolSystemPrompt ?? this.toolSystemPrompt;
+    }
+    invocationParams() {
+        return this.llm.invocationParams();
+    }
+    /** @ignore */
+    _identifyingParams() {
+        return this.llm._identifyingParams();
+    }
+    async _generate(messages, options, runManager) {
+        let functions = options.functions ?? [];
+        if (options.function_call !== undefined) {
+            functions = functions.filter((fn) => fn.name === options.function_call?.name);
+            if (!functions.length) {
+                throw new Error(`If "function_call" is specified, you must also pass a matching function in "functions".`);
+            }
+        }
+        else if (functions.length === 0) {
+            functions.push(this.defaultResponseFunction);
+        }
+        const defaultContent = await this.toolSystemPrompt.format({
+            tools: JSON.stringify(functions, null, 2),
+        });
+        const systemMessage = new index_js_1.SystemMessage({ content: defaultContent });
+        const chatResult = await this.llm._generate([systemMessage, ...messages], options, runManager);
+        const chatGenerationContent = chatResult.generations[0].message.content;
+        if (typeof chatGenerationContent !== "string") {
+            throw new Error("OllamaFunctions does not support non-string output.");
+        }
+        let parsedChatResult;
+        try {
+            parsedChatResult = JSON.parse(chatGenerationContent);
+        }
+        catch (e) {
+            throw new Error(`"${this.llm.model}" did not respond with valid JSON. Please try again.`);
+        }
+        const calledToolName = parsedChatResult.tool;
+        const calledToolArguments = parsedChatResult.tool_input;
+        const calledTool = functions.find((fn) => fn.name === calledToolName);
+        if (calledTool === undefined) {
+            throw new Error(`Failed to parse a function call from ${this.llm.model} output: ${chatGenerationContent}`);
+        }
+        if (calledTool.name === this.defaultResponseFunction.name) {
+            return {
+                generations: [
+                    {
+                        message: new index_js_1.AIMessage({
+                            content: calledToolArguments.response,
+                        }),
+                        text: calledToolArguments.response,
+                    },
+                ],
+            };
+        }
+        const responseMessageWithFunctions = new index_js_1.AIMessage({
+            content: "",
+            additional_kwargs: {
+                function_call: {
+                    name: calledToolName,
+                    arguments: calledToolArguments
+                        ? JSON.stringify(calledToolArguments)
+                        : "",
+                },
+            },
+        });
+        return {
+            generations: [{ message: responseMessageWithFunctions, text: "" }],
+        };
+    }
+    _llmType() {
+        return "ollama_functions";
+    }
+    /** @ignore */
+    _combineLLMOutput() {
+        return [];
+    }
+}
+exports.OllamaFunctions = OllamaFunctions;

package/dist/experimental/chat_models/ollama_functions.d.ts

@@ -0,0 +1,76 @@
+import { BaseChatModel, BaseChatModelParams } from "../../chat_models/base.js";
+import { CallbackManagerForLLMRun } from "../../callbacks/manager.js";
+import { BaseMessage, ChatResult } from "../../schema/index.js";
+import { ChatOllama } from "../../chat_models/ollama.js";
+import { OllamaInput } from "../../util/ollama.js";
+import { BaseFunctionCallOptions } from "../../base_language/index.js";
+import type { BasePromptTemplate } from "../../prompts/base.js";
+export interface ChatOllamaFunctionsCallOptions extends BaseFunctionCallOptions {
+}
+export type OllamaFunctionsInput = Partial<OllamaInput> & BaseChatModelParams & {
+    llm?: ChatOllama;
+    toolSystemPrompt?: BasePromptTemplate;
+};
+export declare class OllamaFunctions extends BaseChatModel<ChatOllamaFunctionsCallOptions> {
+    llm: ChatOllama;
+    toolSystemPrompt: BasePromptTemplate;
+    protected defaultResponseFunction: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                response: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    lc_namespace: string[];
+    static lc_name(): string;
+    constructor(fields?: OllamaFunctionsInput);
+    invocationParams(): {
+        model: string;
+        format: import("../../util/types.js").StringWithAutocomplete<"json"> | undefined;
+        options: {
+            embedding_only: boolean | undefined;
+            f16_kv: boolean | undefined;
+            frequency_penalty: number | undefined;
+            logits_all: boolean | undefined;
+            low_vram: boolean | undefined;
+            main_gpu: number | undefined;
+            mirostat: number | undefined;
+            mirostat_eta: number | undefined;
+            mirostat_tau: number | undefined;
+            num_batch: number | undefined;
+            num_ctx: number | undefined;
+            num_gpu: number | undefined;
+            num_gqa: number | undefined;
+            num_keep: number | undefined;
+            num_thread: number | undefined;
+            penalize_newline: boolean | undefined;
+            presence_penalty: number | undefined;
+            repeat_last_n: number | undefined;
+            repeat_penalty: number | undefined;
+            rope_frequency_base: number | undefined;
+            rope_frequency_scale: number | undefined;
+            temperature: number | undefined;
+            stop: string[] | undefined;
+            tfs_z: number | undefined;
+            top_k: number | undefined;
+            top_p: number | undefined;
+            typical_p: number | undefined; /** @ignore */
+            use_mlock: boolean | undefined;
+            use_mmap: boolean | undefined;
+            vocab_only: boolean | undefined;
+        };
+    };
+    /** @ignore */
+    _identifyingParams(): Record<string, any>;
+    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun | undefined): Promise<ChatResult>;
+    _llmType(): string;
+    /** @ignore */
+    _combineLLMOutput(): never[];
+}