langchain 0.0.75 → 0.0.76

package/dist/base_language/count_tokens.cjs

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateMaxTokens = exports.importTiktoken = exports.getModelContextSize = exports.getEmbeddingContextSize = exports.getModelNameForTiktoken = void 0;
-// https://www.npmjs.com/package/@dqbd/tiktoken
+exports.calculateMaxTokens = exports.getModelContextSize = exports.getEmbeddingContextSize = exports.getModelNameForTiktoken = void 0;
+const tiktoken_js_1 = require("../util/tiktoken.cjs");
+// https://www.npmjs.com/package/js-tiktoken
 const getModelNameForTiktoken = (modelName) => {
     if (modelName.startsWith("gpt-3.5-turbo-")) {
         return "gpt-3.5-turbo";
@@ -49,31 +50,14 @@ const getModelContextSize = (modelName) => {
     }
 };
 exports.getModelContextSize = getModelContextSize;
-const importTiktoken = async () => {
-    try {
-        const { encoding_for_model } = await import("@dqbd/tiktoken");
-        return { encoding_for_model };
-    }
-    catch (error) {
-        console.log(error);
-        return { encoding_for_model: null };
-    }
-};
-exports.importTiktoken = importTiktoken;
 const calculateMaxTokens = async ({ prompt, modelName, }) => {
-    const { encoding_for_model } = await (0, exports.importTiktoken)();
     // fallback to approximate calculation if tiktoken is not available
     let numTokens = Math.ceil(prompt.length / 4);
     try {
-        if (encoding_for_model) {
-            const encoding = encoding_for_model((0, exports.getModelNameForTiktoken)(modelName));
-            const tokenized = encoding.encode(prompt);
-            numTokens = tokenized.length;
-            encoding.free();
-        }
+        numTokens = (await (0, tiktoken_js_1.encodingForModel)(modelName)).encode(prompt).length;
     }
     catch (error) {
-        console.warn("Failed to calculate number of tokens with tiktoken, falling back to approximate count", error);
+        console.warn("Failed to calculate number of tokens, falling back to approximate count");
     }
     const maxTokens = (0, exports.getModelContextSize)(modelName);
     return maxTokens - numTokens;

package/dist/base_language/count_tokens.d.ts

@@ -1,4 +1,4 @@
-import type { TiktokenModel } from "@dqbd/tiktoken";
+import { type TiktokenModel } from "js-tiktoken/lite";
 export declare const getModelNameForTiktoken: (modelName: string) => TiktokenModel;
 export declare const getEmbeddingContextSize: (modelName?: string) => number;
 export declare const getModelContextSize: (modelName: string) => number;
@@ -6,10 +6,5 @@ interface CalculateMaxTokenProps {
     prompt: string;
     modelName: TiktokenModel;
 }
-export declare const importTiktoken: () => Promise<{
-    encoding_for_model: typeof import("@dqbd/tiktoken").encoding_for_model;
-} | {
-    encoding_for_model: null;
-}>;
 export declare const calculateMaxTokens: ({ prompt, modelName, }: CalculateMaxTokenProps) => Promise<number>;
 export {};

package/dist/base_language/count_tokens.js

@@ -1,4 +1,5 @@
-// https://www.npmjs.com/package/@dqbd/tiktoken
+import { encodingForModel } from "../util/tiktoken.js";
+// https://www.npmjs.com/package/js-tiktoken
 export const getModelNameForTiktoken = (modelName) => {
     if (modelName.startsWith("gpt-3.5-turbo-")) {
         return "gpt-3.5-turbo";
@@ -43,30 +44,14 @@ export const getModelContextSize = (modelName) => {
             return 4097;
     }
 };
-export const importTiktoken = async () => {
-    try {
-        const { encoding_for_model } = await import("@dqbd/tiktoken");
-        return { encoding_for_model };
-    }
-    catch (error) {
-        console.log(error);
-        return { encoding_for_model: null };
-    }
-};
 export const calculateMaxTokens = async ({ prompt, modelName, }) => {
-    const { encoding_for_model } = await importTiktoken();
     // fallback to approximate calculation if tiktoken is not available
     let numTokens = Math.ceil(prompt.length / 4);
     try {
-        if (encoding_for_model) {
-            const encoding = encoding_for_model(getModelNameForTiktoken(modelName));
-            const tokenized = encoding.encode(prompt);
-            numTokens = tokenized.length;
-            encoding.free();
-        }
+        numTokens = (await encodingForModel(modelName)).encode(prompt).length;
     }
     catch (error) {
-        console.warn("Failed to calculate number of tokens with tiktoken, falling back to approximate count", error);
+        console.warn("Failed to calculate number of tokens, falling back to approximate count");
     }
     const maxTokens = getModelContextSize(modelName);
     return maxTokens - numTokens;

package/dist/base_language/index.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseLanguageModel = exports.BaseLangChain = void 0;
 const async_caller_js_1 = require("../util/async_caller.cjs");
 const count_tokens_js_1 = require("./count_tokens.cjs");
+const tiktoken_js_1 = require("../util/tiktoken.cjs");
 const getVerbosity = () => false;
 /**
  * Base class for language models, chains, tools.
@@ -60,38 +61,23 @@ class BaseLanguageModel extends BaseLangChain {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "_registry", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.caller = new async_caller_js_1.AsyncCaller(params ?? {});
     }
     async getNumTokens(text) {
         // fallback to approximate calculation if tiktoken is not available
         let numTokens = Math.ceil(text.length / 4);
-        try {
-            if (!this._encoding) {
-                const { encoding_for_model } = await (0, count_tokens_js_1.importTiktoken)();
-                // modelName only exists in openai subclasses, but tiktoken only supports
-                // openai tokenisers anyway, so for other subclasses we default to gpt2
-                if (encoding_for_model) {
-                    this._encoding = encoding_for_model("modelName" in this
-                        ? (0, count_tokens_js_1.getModelNameForTiktoken)(this.modelName)
-                        : "gpt2");
-                    // We need to register a finalizer to free the tokenizer when the
-                    // model is garbage collected.
-                    this._registry = new FinalizationRegistry((t) => t.free());
-                    this._registry.register(this, this._encoding);
-                }
+        if (!this._encoding) {
+            try {
+                this._encoding = await (0, tiktoken_js_1.encodingForModel)("modelName" in this
+                    ? (0, count_tokens_js_1.getModelNameForTiktoken)(this.modelName)
+                    : "gpt2");
             }
-            if (this._encoding) {
-                numTokens = this._encoding.encode(text).length;
+            catch (error) {
+                console.warn("Failed to calculate number of tokens, falling back to approximate count", error);
             }
         }
-        catch (error) {
-            console.warn("Failed to calculate number of tokens with tiktoken, falling back to approximate count", error);
+        if (this._encoding) {
+            numTokens = this._encoding.encode(text).length;
         }
         return numTokens;
     }

package/dist/base_language/index.d.ts

@@ -1,4 +1,4 @@
-import { BasePromptValue, LLMResult } from "../schema/index.js";
+import { BaseChatMessage, BasePromptValue, LLMResult } from "../schema/index.js";
 import { CallbackManager, Callbacks } from "../callbacks/manager.js";
 import { AsyncCaller, AsyncCallerParams } from "../util/async_caller.js";
 export type SerializedLLM = {
@@ -63,10 +63,11 @@ export declare abstract class BaseLanguageModel extends BaseLangChain implements
     caller: AsyncCaller;
     constructor(params: BaseLanguageModelParams);
     abstract generatePrompt(promptValues: BasePromptValue[], options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<LLMResult>;
+    abstract predict(text: string, options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<string>;
+    abstract predictMessages(messages: BaseChatMessage[], options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<BaseChatMessage>;
     abstract _modelType(): string;
     abstract _llmType(): string;
     private _encoding?;
-    private _registry?;
     getNumTokens(text: string): Promise<number>;
     /**
      * Get the identifying parameters of the LLM.

package/dist/base_language/index.js

@@ -1,5 +1,6 @@
 import { AsyncCaller } from "../util/async_caller.js";
-import { getModelNameForTiktoken, importTiktoken } from "./count_tokens.js";
+import { getModelNameForTiktoken } from "./count_tokens.js";
+import { encodingForModel } from "../util/tiktoken.js";
 const getVerbosity = () => false;
 /**
  * Base class for language models, chains, tools.
@@ -56,38 +57,23 @@ export class BaseLanguageModel extends BaseLangChain {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "_registry", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.caller = new AsyncCaller(params ?? {});
     }
     async getNumTokens(text) {
         // fallback to approximate calculation if tiktoken is not available
         let numTokens = Math.ceil(text.length / 4);
-        try {
-            if (!this._encoding) {
-                const { encoding_for_model } = await importTiktoken();
-                // modelName only exists in openai subclasses, but tiktoken only supports
-                // openai tokenisers anyway, so for other subclasses we default to gpt2
-                if (encoding_for_model) {
-                    this._encoding = encoding_for_model("modelName" in this
-                        ? getModelNameForTiktoken(this.modelName)
-                        : "gpt2");
-                    // We need to register a finalizer to free the tokenizer when the
-                    // model is garbage collected.
-                    this._registry = new FinalizationRegistry((t) => t.free());
-                    this._registry.register(this, this._encoding);
-                }
+        if (!this._encoding) {
+            try {
+                this._encoding = await encodingForModel("modelName" in this
+                    ? getModelNameForTiktoken(this.modelName)
+                    : "gpt2");
             }
-            if (this._encoding) {
-                numTokens = this._encoding.encode(text).length;
+            catch (error) {
+                console.warn("Failed to calculate number of tokens, falling back to approximate count", error);
             }
         }
-        catch (error) {
-            console.warn("Failed to calculate number of tokens with tiktoken, falling back to approximate count", error);
+        if (this._encoding) {
+            numTokens = this._encoding.encode(text).length;
         }
         return numTokens;
     }

package/dist/cache/redis.d.ts

@@ -1,8 +1,10 @@
-import type { RedisClientType } from "redis";
+import type { createCluster, createClient } from "redis";
 import { BaseCache, Generation } from "../schema/index.js";
+type RedisClientType = ReturnType<typeof createClient> | ReturnType<typeof createCluster>;
 export declare class RedisCache extends BaseCache {
     private redisClient;
     constructor(redisClient: RedisClientType);
     lookup(prompt: string, llmKey: string): Promise<Generation[] | null>;
     update(prompt: string, llmKey: string, value: Generation[]): Promise<void>;
 }
+export {};

package/dist/callbacks/base.d.ts

@@ -12,7 +12,7 @@ declare abstract class BaseCallbackHandlerMethodsClass {
      */
     handleLLMStart?(llm: {
         name: string;
-    }, prompts: string[], runId: string, parentRunId?: string): Promise<void> | void;
+    }, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>): Promise<void> | void;
     /**
      * Called when an LLM/ChatModel in `streaming` mode produces a new token
      */
@@ -31,7 +31,7 @@ declare abstract class BaseCallbackHandlerMethodsClass {
      */
     handleChatModelStart?(llm: {
         name: string;
-    }, messages: BaseChatMessage[][], runId: string, parentRunId?: string): Promise<void> | void;
+    }, messages: BaseChatMessage[][], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>): Promise<void> | void;
     /**
      * Called at the start of a Chain run, with the chain name and inputs
      * and the run ID.
@@ -103,7 +103,7 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
          */
         handleLLMStart?(llm: {
             name: string;
-        }, prompts: string[], runId: string, parentRunId?: string | undefined): void | Promise<void>;
+        }, prompts: string[], runId: string, parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined): void | Promise<void>;
         /**
          * Called when an LLM/ChatModel in `streaming` mode produces a new token
          */
@@ -122,7 +122,7 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
          */
         handleChatModelStart?(llm: {
             name: string;
-        }, messages: BaseChatMessage[][], runId: string, parentRunId?: string | undefined): void | Promise<void>;
+        }, messages: BaseChatMessage[][], runId: string, parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined): void | Promise<void>;
         /**
          * Called at the start of a Chain run, with the chain name and inputs
          * and the run ID.

package/dist/callbacks/handlers/initialize.cjs

@@ -14,14 +14,7 @@ async function getTracingCallbackHandler(session) {
     return tracer;
 }
 exports.getTracingCallbackHandler = getTracingCallbackHandler;
-async function getTracingV2CallbackHandler(session) {
-    const tracer = new tracer_langchain_js_1.LangChainTracer();
-    if (session) {
-        await tracer.loadSession(session);
-    }
-    else {
-        await tracer.loadDefaultSession();
-    }
-    return tracer;
+async function getTracingV2CallbackHandler() {
+    return new tracer_langchain_js_1.LangChainTracer();
 }
 exports.getTracingV2CallbackHandler = getTracingV2CallbackHandler;

package/dist/callbacks/handlers/initialize.d.ts

@@ -1,4 +1,4 @@
 import { LangChainTracer } from "./tracer_langchain.js";
 import { LangChainTracerV1 } from "./tracer_langchain_v1.js";
 export declare function getTracingCallbackHandler(session?: string): Promise<LangChainTracerV1>;
-export declare function getTracingV2CallbackHandler(session?: string): Promise<LangChainTracer>;
+export declare function getTracingV2CallbackHandler(): Promise<LangChainTracer>;

package/dist/callbacks/handlers/initialize.js

@@ -10,13 +10,6 @@ export async function getTracingCallbackHandler(session) {
     }
     return tracer;
 }
-export async function getTracingV2CallbackHandler(session) {
-    const tracer = new LangChainTracer();
-    if (session) {
-        await tracer.loadSession(session);
-    }
-    else {
-        await tracer.loadDefaultSession();
-    }
-    return tracer;
+export async function getTracingV2CallbackHandler() {
+    return new LangChainTracer();
 }

package/dist/callbacks/handlers/tracer.cjs

@@ -24,37 +24,28 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             if (parentRun) {
                 this._addChildRun(parentRun, run);
             }
-            else {
-                throw new Error(`Caller run ${run.parent_run_id} not found`);
-            }
         }
         this.runMap.set(run.id, run);
     }
     async _endTrace(run) {
-        if (!run.parent_run_id) {
-            await this.persistRun(run);
+        const parentRun = run.parent_run_id !== undefined && this.runMap.get(run.parent_run_id);
+        if (parentRun) {
+            parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order);
         }
         else {
-            const parentRun = this.runMap.get(run.parent_run_id);
-            if (parentRun === undefined) {
-                throw new Error(`Parent run ${run.parent_run_id} not found`);
-            }
-            parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order);
+            await this.persistRun(run);
         }
         this.runMap.delete(run.id);
     }
     _getExecutionOrder(parentRunId) {
+        const parentRun = parentRunId !== undefined && this.runMap.get(parentRunId);
         // If a run has no parent then execution order is 1
-        if (parentRunId === undefined) {
+        if (!parentRun) {
             return 1;
         }
-        const parentRun = this.runMap.get(parentRunId);
-        if (parentRun === undefined) {
-            throw new Error(`Parent run ${parentRunId} not found`);
-        }
         return parentRun.child_execution_order + 1;
     }
-    async handleLLMStart(llm, prompts, runId, parentRunId) {
+    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const run = {
             id: runId,
@@ -68,16 +59,13 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             child_runs: [],
             child_execution_order: execution_order,
             run_type: "llm",
+            extra: extraParams,
         };
         this._startTrace(run);
         await this.onLLMStart?.(run);
     }
-    async handleChatModelStart(llm, messages, runId, parentRunId) {
+    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams) {
         const execution_order = this._getExecutionOrder(parentRunId);
-        const convertedMessages = messages.map((batch) => batch.map((message) => ({
-            _type: message._getType(),
-            content: message.text, // TODO: Unify serialization btwn languages
-        })));
         const run = {
             id: runId,
             name: llm.name,
@@ -85,11 +73,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             start_time: Date.now(),
             end_time: 0,
             serialized: llm,
-            inputs: { messages: convertedMessages },
+            inputs: { messages },
             execution_order,
             child_runs: [],
             child_execution_order: execution_order,
             run_type: "llm",
+            extra: extraParams,
         };
         this._startTrace(run);
         await this.onLLMStart?.(run);

package/dist/callbacks/handlers/tracer.d.ts

@@ -35,10 +35,10 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
     protected _getExecutionOrder(parentRunId: string | undefined): number;
     handleLLMStart(llm: {
         name: string;
-    }, prompts: string[], runId: string, parentRunId?: string): Promise<void>;
+    }, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>): Promise<void>;
     handleChatModelStart(llm: {
         name: string;
-    }, messages: BaseChatMessage[][], runId: string, parentRunId?: string): Promise<void>;
+    }, messages: BaseChatMessage[][], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>): Promise<void>;
     handleLLMEnd(output: LLMResult, runId: string): Promise<void>;
     handleLLMError(error: Error, runId: string): Promise<void>;
     handleChainStart(chain: {

package/dist/callbacks/handlers/tracer.js

@@ -21,37 +21,28 @@ export class BaseTracer extends BaseCallbackHandler {
             if (parentRun) {
                 this._addChildRun(parentRun, run);
             }
-            else {
-                throw new Error(`Caller run ${run.parent_run_id} not found`);
-            }
         }
         this.runMap.set(run.id, run);
     }
     async _endTrace(run) {
-        if (!run.parent_run_id) {
-            await this.persistRun(run);
+        const parentRun = run.parent_run_id !== undefined && this.runMap.get(run.parent_run_id);
+        if (parentRun) {
+            parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order);
         }
         else {
-            const parentRun = this.runMap.get(run.parent_run_id);
-            if (parentRun === undefined) {
-                throw new Error(`Parent run ${run.parent_run_id} not found`);
-            }
-            parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order);
+            await this.persistRun(run);
         }
         this.runMap.delete(run.id);
     }
     _getExecutionOrder(parentRunId) {
+        const parentRun = parentRunId !== undefined && this.runMap.get(parentRunId);
         // If a run has no parent then execution order is 1
-        if (parentRunId === undefined) {
+        if (!parentRun) {
             return 1;
         }
-        const parentRun = this.runMap.get(parentRunId);
-        if (parentRun === undefined) {
-            throw new Error(`Parent run ${parentRunId} not found`);
-        }
         return parentRun.child_execution_order + 1;
     }
-    async handleLLMStart(llm, prompts, runId, parentRunId) {
+    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const run = {
             id: runId,
@@ -65,16 +56,13 @@ export class BaseTracer extends BaseCallbackHandler {
             child_runs: [],
             child_execution_order: execution_order,
             run_type: "llm",
+            extra: extraParams,
         };
         this._startTrace(run);
         await this.onLLMStart?.(run);
     }
-    async handleChatModelStart(llm, messages, runId, parentRunId) {
+    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams) {
         const execution_order = this._getExecutionOrder(parentRunId);
-        const convertedMessages = messages.map((batch) => batch.map((message) => ({
-            _type: message._getType(),
-            content: message.text, // TODO: Unify serialization btwn languages
-        })));
         const run = {
             id: runId,
             name: llm.name,
@@ -82,11 +70,12 @@ export class BaseTracer extends BaseCallbackHandler {
             start_time: Date.now(),
             end_time: 0,
             serialized: llm,
-            inputs: { messages: convertedMessages },
+            inputs: { messages },
             execution_order,
             child_runs: [],
             child_execution_order: execution_order,
             run_type: "llm",
+            extra: extraParams,
         };
         this._startTrace(run);
         await this.onLLMStart?.(run);