@langchain/core 0.3.31 → 0.3.33

package/dist/callbacks/base.d.ts

@@ -58,12 +58,12 @@ declare abstract class BaseCallbackHandlerMethodsClass {
     /**
      * Called if an LLM/ChatModel run encounters an error
      */
-    handleLLMError?(err: Error, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handleLLMError?(err: Error, runId: string, parentRunId?: string, tags?: string[], extraParams?: Record<string, unknown>): // eslint-disable-next-line @typescript-eslint/no-explicit-any
     Promise<any> | any;
     /**
      * Called at the end of an LLM/ChatModel run, with the output and the run ID.
      */
-    handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string, tags?: string[]): // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string, tags?: string[], extraParams?: Record<string, unknown>): // eslint-disable-next-line @typescript-eslint/no-explicit-any
     Promise<any> | any;
     /**
      * Called at the start of a Chat Model run, with the prompt(s)
@@ -228,11 +228,11 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
         /**
          * Called if an LLM/ChatModel run encounters an error
          */
-        handleLLMError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
+        handleLLMError?(err: any, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, extraParams?: Record<string, unknown> | undefined): any;
         /**
          * Called at the end of an LLM/ChatModel run, with the output and the run ID.
          */
-        handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined): any;
+        handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string | undefined, tags?: string[] | undefined, extraParams?: Record<string, unknown> | undefined): any;
         /**
          * Called at the start of a Chat Model run, with the prompt(s)
          * and the run ID.

package/dist/callbacks/manager.cjs

@@ -199,11 +199,11 @@ class CallbackManagerForLLMRun extends BaseRunManager {
             }
         }, handler.awaitHandlers)));
     }
-    async handleLLMError(err) {
+    async handleLLMError(err, _runId, _parentRunId, _tags, extraParams) {
         await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
             if (!handler.ignoreLLM) {
                 try {
-                    await handler.handleLLMError?.(err, this.runId, this._parentRunId, this.tags);
+                    await handler.handleLLMError?.(err, this.runId, this._parentRunId, this.tags, extraParams);
                 }
                 catch (err) {
                     const logFunction = handler.raiseError
@@ -217,11 +217,11 @@ class CallbackManagerForLLMRun extends BaseRunManager {
             }
         }, handler.awaitHandlers)));
     }
-    async handleLLMEnd(output) {
+    async handleLLMEnd(output, _runId, _parentRunId, _tags, extraParams) {
         await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
             if (!handler.ignoreLLM) {
                 try {
-                    await handler.handleLLMEnd?.(output, this.runId, this._parentRunId, this.tags);
+                    await handler.handleLLMEnd?.(output, this.runId, this._parentRunId, this.tags, extraParams);
                 }
                 catch (err) {
                     const logFunction = handler.raiseError

package/dist/callbacks/manager.d.ts

@@ -77,8 +77,8 @@ export declare class CallbackManagerForRetrieverRun extends BaseRunManager imple
 }
 export declare class CallbackManagerForLLMRun extends BaseRunManager implements BaseCallbackManagerMethods {
     handleLLMNewToken(token: string, idx?: NewTokenIndices, _runId?: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): Promise<void>;
-    handleLLMError(err: Error | unknown): Promise<void>;
-    handleLLMEnd(output: LLMResult): Promise<void>;
+    handleLLMError(err: Error | unknown, _runId?: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<void>;
+    handleLLMEnd(output: LLMResult, _runId?: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<void>;
 }
 export declare class CallbackManagerForChainRun extends BaseRunManager implements BaseCallbackManagerMethods {
     getChild(tag?: string): CallbackManager;

package/dist/callbacks/manager.js

@@ -192,11 +192,11 @@ export class CallbackManagerForLLMRun extends BaseRunManager {
             }
         }, handler.awaitHandlers)));
     }
-    async handleLLMError(err) {
+    async handleLLMError(err, _runId, _parentRunId, _tags, extraParams) {
         await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
             if (!handler.ignoreLLM) {
                 try {
-                    await handler.handleLLMError?.(err, this.runId, this._parentRunId, this.tags);
+                    await handler.handleLLMError?.(err, this.runId, this._parentRunId, this.tags, extraParams);
                 }
                 catch (err) {
                     const logFunction = handler.raiseError
@@ -210,11 +210,11 @@ export class CallbackManagerForLLMRun extends BaseRunManager {
             }
         }, handler.awaitHandlers)));
     }
-    async handleLLMEnd(output) {
+    async handleLLMEnd(output, _runId, _parentRunId, _tags, extraParams) {
         await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
             if (!handler.ignoreLLM) {
                 try {
-                    await handler.handleLLMEnd?.(output, this.runId, this._parentRunId, this.tags);
+                    await handler.handleLLMEnd?.(output, this.runId, this._parentRunId, this.tags, extraParams);
                 }
                 catch (err) {
                     const logFunction = handler.raiseError

package/dist/language_models/chat_models.cjs

@@ -148,20 +148,27 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
         };
     }
     /** @ignore */
-    async _generateUncached(messages, parsedOptions, handledOptions) {
+    async _generateUncached(messages, parsedOptions, handledOptions, startedRunManagers) {
         const baseMessages = messages.map((messageList) => messageList.map(index_js_1.coerceMessageLikeToMessage));
-        const inheritableMetadata = {
-            ...handledOptions.metadata,
-            ...this.getLsParams(parsedOptions),
-        };
-        // create callback manager and start run
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
-        const extra = {
-            options: parsedOptions,
-            invocation_params: this?.invocationParams(parsedOptions),
-            batch_size: 1,
-        };
-        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions.runName);
+        let runManagers;
+        if (startedRunManagers !== undefined &&
+            startedRunManagers.length === baseMessages.length) {
+            runManagers = startedRunManagers;
+        }
+        else {
+            const inheritableMetadata = {
+                ...handledOptions.metadata,
+                ...this.getLsParams(parsedOptions),
+            };
+            // create callback manager and start run
+            const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
+            const extra = {
+                options: parsedOptions,
+                invocation_params: this?.invocationParams(parsedOptions),
+                batch_size: 1,
+            };
+            runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions.runName);
+        }
         const generations = [];
         const llmOutputs = [];
         // Even if stream is not explicitly called, check if model is implicitly
@@ -279,7 +286,6 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
             options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),
             batch_size: 1,
-            cached: true,
         };
         const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions.runName);
         // generate results
@@ -304,23 +310,45 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
         await Promise.all(cachedResults.map(async ({ result: promiseResult, runManager }, i) => {
             if (promiseResult.status === "fulfilled") {
                 const result = promiseResult.value;
-                generations[i] = result;
+                generations[i] = result.map((result) => {
+                    if ("message" in result &&
+                        (0, index_js_1.isBaseMessage)(result.message) &&
+                        (0, index_js_1.isAIMessage)(result.message)) {
+                        // eslint-disable-next-line no-param-reassign
+                        result.message.usage_metadata = {
+                            input_tokens: 0,
+                            output_tokens: 0,
+                            total_tokens: 0,
+                        };
+                    }
+                    // eslint-disable-next-line no-param-reassign
+                    result.generationInfo = {
+                        ...result.generationInfo,
+                        tokenUsage: {},
+                    };
+                    return result;
+                });
                 if (result.length) {
                     await runManager?.handleLLMNewToken(result[0].text);
                 }
                 return runManager?.handleLLMEnd({
                     generations: [result],
+                }, undefined, undefined, undefined, {
+                    cached: true,
                 });
             }
             else {
                 // status === "rejected"
-                await runManager?.handleLLMError(promiseResult.reason);
+                await runManager?.handleLLMError(promiseResult.reason, undefined, undefined, undefined, {
+                    cached: true,
+                });
                 return Promise.reject(promiseResult.reason);
             }
         }));
         const output = {
             generations,
             missingPromptIndices,
+            startedRunManagers: runManagers,
         };
         // This defines RUN_KEY as a non-enumerable property on the output object
         // so that it is not serialized when the output is stringified, and so that
@@ -357,7 +385,7 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
         }
         const { cache } = this;
         const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
-        const { generations, missingPromptIndices } = await this._generateCached({
+        const { generations, missingPromptIndices, startedRunManagers } = await this._generateCached({
             messages: baseMessages,
             cache,
             llmStringKey,
@@ -366,7 +394,9 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
         });
         let llmOutput = {};
         if (missingPromptIndices.length > 0) {
-            const results = await this._generateUncached(missingPromptIndices.map((i) => baseMessages[i]), callOptions, runnableConfig);
+            const results = await this._generateUncached(missingPromptIndices.map((i) => baseMessages[i]), callOptions, runnableConfig, startedRunManagers !== undefined
+                ? missingPromptIndices.map((i) => startedRunManagers?.[i])
+                : undefined);
             await Promise.all(results.generations.map(async (generation, index) => {
                 const promptIndex = missingPromptIndices[index];
                 generations[promptIndex] = generation;

package/dist/language_models/chat_models.d.ts

@@ -104,7 +104,7 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
     _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;
     getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
     /** @ignore */
-    _generateUncached(messages: BaseMessageLike[][], parsedOptions: this["ParsedCallOptions"], handledOptions: RunnableConfig): Promise<LLMResult>;
+    _generateUncached(messages: BaseMessageLike[][], parsedOptions: this["ParsedCallOptions"], handledOptions: RunnableConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;
     _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }: {
         messages: BaseMessageLike[][];
         cache: BaseCache<Generation[]>;
@@ -113,6 +113,7 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
         handledOptions: RunnableConfig;
     }): Promise<LLMResult & {
         missingPromptIndices: number[];
+        startedRunManagers?: CallbackManagerForLLMRun[];
     }>;
     /**
      * Generates chat based on the input messages.

package/dist/language_models/chat_models.js

@@ -1,5 +1,5 @@
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { AIMessage, HumanMessage, coerceMessageLikeToMessage, isAIMessageChunk, } from "../messages/index.js";
+import { AIMessage, HumanMessage, coerceMessageLikeToMessage, isAIMessageChunk, isBaseMessage, isAIMessage, } from "../messages/index.js";
 import { RUN_KEY, } from "../outputs.js";
 import { BaseLanguageModel, } from "./base.js";
 import { CallbackManager, } from "../callbacks/manager.js";
@@ -144,20 +144,27 @@ export class BaseChatModel extends BaseLanguageModel {
         };
     }
     /** @ignore */
-    async _generateUncached(messages, parsedOptions, handledOptions) {
+    async _generateUncached(messages, parsedOptions, handledOptions, startedRunManagers) {
         const baseMessages = messages.map((messageList) => messageList.map(coerceMessageLikeToMessage));
-        const inheritableMetadata = {
-            ...handledOptions.metadata,
-            ...this.getLsParams(parsedOptions),
-        };
-        // create callback manager and start run
-        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
-        const extra = {
-            options: parsedOptions,
-            invocation_params: this?.invocationParams(parsedOptions),
-            batch_size: 1,
-        };
-        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions.runName);
+        let runManagers;
+        if (startedRunManagers !== undefined &&
+            startedRunManagers.length === baseMessages.length) {
+            runManagers = startedRunManagers;
+        }
+        else {
+            const inheritableMetadata = {
+                ...handledOptions.metadata,
+                ...this.getLsParams(parsedOptions),
+            };
+            // create callback manager and start run
+            const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
+            const extra = {
+                options: parsedOptions,
+                invocation_params: this?.invocationParams(parsedOptions),
+                batch_size: 1,
+            };
+            runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions.runName);
+        }
         const generations = [];
         const llmOutputs = [];
         // Even if stream is not explicitly called, check if model is implicitly
@@ -275,7 +282,6 @@ export class BaseChatModel extends BaseLanguageModel {
             options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),
             batch_size: 1,
-            cached: true,
         };
         const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions.runName);
         // generate results
@@ -300,23 +306,45 @@ export class BaseChatModel extends BaseLanguageModel {
         await Promise.all(cachedResults.map(async ({ result: promiseResult, runManager }, i) => {
             if (promiseResult.status === "fulfilled") {
                 const result = promiseResult.value;
-                generations[i] = result;
+                generations[i] = result.map((result) => {
+                    if ("message" in result &&
+                        isBaseMessage(result.message) &&
+                        isAIMessage(result.message)) {
+                        // eslint-disable-next-line no-param-reassign
+                        result.message.usage_metadata = {
+                            input_tokens: 0,
+                            output_tokens: 0,
+                            total_tokens: 0,
+                        };
+                    }
+                    // eslint-disable-next-line no-param-reassign
+                    result.generationInfo = {
+                        ...result.generationInfo,
+                        tokenUsage: {},
+                    };
+                    return result;
+                });
                 if (result.length) {
                     await runManager?.handleLLMNewToken(result[0].text);
                 }
                 return runManager?.handleLLMEnd({
                     generations: [result],
+                }, undefined, undefined, undefined, {
+                    cached: true,
                 });
             }
             else {
                 // status === "rejected"
-                await runManager?.handleLLMError(promiseResult.reason);
+                await runManager?.handleLLMError(promiseResult.reason, undefined, undefined, undefined, {
+                    cached: true,
+                });
                 return Promise.reject(promiseResult.reason);
             }
         }));
         const output = {
             generations,
             missingPromptIndices,
+            startedRunManagers: runManagers,
         };
         // This defines RUN_KEY as a non-enumerable property on the output object
         // so that it is not serialized when the output is stringified, and so that
@@ -353,7 +381,7 @@ export class BaseChatModel extends BaseLanguageModel {
         }
         const { cache } = this;
         const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
-        const { generations, missingPromptIndices } = await this._generateCached({
+        const { generations, missingPromptIndices, startedRunManagers } = await this._generateCached({
             messages: baseMessages,
             cache,
             llmStringKey,
@@ -362,7 +390,9 @@ export class BaseChatModel extends BaseLanguageModel {
         });
         let llmOutput = {};
         if (missingPromptIndices.length > 0) {
-            const results = await this._generateUncached(missingPromptIndices.map((i) => baseMessages[i]), callOptions, runnableConfig);
+            const results = await this._generateUncached(missingPromptIndices.map((i) => baseMessages[i]), callOptions, runnableConfig, startedRunManagers !== undefined
+                ? missingPromptIndices.map((i) => startedRunManagers?.[i])
+                : undefined);
             await Promise.all(results.generations.map(async (generation, index) => {
                 const promptIndex = missingPromptIndices[index];
                 generations[promptIndex] = generation;

package/dist/language_models/llms.cjs

@@ -126,14 +126,21 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
         return llmResults;
     }
     /** @ignore */
-    async _generateUncached(prompts, parsedOptions, handledOptions) {
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
-        const extra = {
-            options: parsedOptions,
-            invocation_params: this?.invocationParams(parsedOptions),
-            batch_size: prompts.length,
-        };
-        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions?.runName);
+    async _generateUncached(prompts, parsedOptions, handledOptions, startedRunManagers) {
+        let runManagers;
+        if (startedRunManagers !== undefined &&
+            startedRunManagers.length === prompts.length) {
+            runManagers = startedRunManagers;
+        }
+        else {
+            const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+            const extra = {
+                options: parsedOptions,
+                invocation_params: this?.invocationParams(parsedOptions),
+                batch_size: prompts.length,
+            };
+            runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions?.runName);
+        }
         // Even if stream is not explicitly called, check if model is implicitly
         // called from streamEvents() or streamLog() to get all streamed events.
         // Bail out if _streamResponseChunks not overridden
@@ -191,7 +198,6 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
             options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),
             batch_size: prompts.length,
-            cached: true,
         };
         const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, runId, undefined, extra, undefined, undefined, handledOptions?.runName);
         // generate results
@@ -214,23 +220,35 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
         await Promise.all(cachedResults.map(async ({ result: promiseResult, runManager }, i) => {
             if (promiseResult.status === "fulfilled") {
                 const result = promiseResult.value;
-                generations[i] = result;
+                generations[i] = result.map((result) => {
+                    // eslint-disable-next-line no-param-reassign
+                    result.generationInfo = {
+                        ...result.generationInfo,
+                        tokenUsage: {},
+                    };
+                    return result;
+                });
                 if (result.length) {
                     await runManager?.handleLLMNewToken(result[0].text);
                 }
                 return runManager?.handleLLMEnd({
                     generations: [result],
+                }, undefined, undefined, undefined, {
+                    cached: true,
                 });
             }
             else {
                 // status === "rejected"
-                await runManager?.handleLLMError(promiseResult.reason);
+                await runManager?.handleLLMError(promiseResult.reason, undefined, undefined, undefined, {
+                    cached: true,
+                });
                 return Promise.reject(promiseResult.reason);
             }
         }));
         const output = {
             generations,
             missingPromptIndices,
+            startedRunManagers: runManagers,
         };
         // This defines RUN_KEY as a non-enumerable property on the output object
         // so that it is not serialized when the output is stringified, and so that
@@ -264,7 +282,7 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
         }
         const { cache } = this;
         const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
-        const { generations, missingPromptIndices } = await this._generateCached({
+        const { generations, missingPromptIndices, startedRunManagers } = await this._generateCached({
             prompts,
             cache,
             llmStringKey,
@@ -274,7 +292,9 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
         });
         let llmOutput = {};
         if (missingPromptIndices.length > 0) {
-            const results = await this._generateUncached(missingPromptIndices.map((i) => prompts[i]), callOptions, runnableConfig);
+            const results = await this._generateUncached(missingPromptIndices.map((i) => prompts[i]), callOptions, runnableConfig, startedRunManagers !== undefined
+                ? missingPromptIndices.map((i) => startedRunManagers?.[i])
+                : undefined);
             await Promise.all(results.generations.map(async (generation, index) => {
                 const promptIndex = missingPromptIndices[index];
                 generations[promptIndex] = generation;

package/dist/language_models/llms.d.ts

@@ -55,7 +55,7 @@ export declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = B
     invocationParams(_options?: this["ParsedCallOptions"]): any;
     _flattenLLMResult(llmResult: LLMResult): LLMResult[];
     /** @ignore */
-    _generateUncached(prompts: string[], parsedOptions: this["ParsedCallOptions"], handledOptions: BaseCallbackConfig): Promise<LLMResult>;
+    _generateUncached(prompts: string[], parsedOptions: this["ParsedCallOptions"], handledOptions: BaseCallbackConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;
     _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId, }: {
         prompts: string[];
         cache: BaseCache<Generation[]>;
@@ -65,6 +65,7 @@ export declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = B
         runId?: string;
     }): Promise<LLMResult & {
         missingPromptIndices: number[];
+        startedRunManagers?: CallbackManagerForLLMRun[];
     }>;
     /**
      * Run the LLM on the given prompts and input, handling caching.

package/dist/language_models/llms.js

@@ -123,14 +123,21 @@ export class BaseLLM extends BaseLanguageModel {
         return llmResults;
     }
     /** @ignore */
-    async _generateUncached(prompts, parsedOptions, handledOptions) {
-        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
-        const extra = {
-            options: parsedOptions,
-            invocation_params: this?.invocationParams(parsedOptions),
-            batch_size: prompts.length,
-        };
-        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions?.runName);
+    async _generateUncached(prompts, parsedOptions, handledOptions, startedRunManagers) {
+        let runManagers;
+        if (startedRunManagers !== undefined &&
+            startedRunManagers.length === prompts.length) {
+            runManagers = startedRunManagers;
+        }
+        else {
+            const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+            const extra = {
+                options: parsedOptions,
+                invocation_params: this?.invocationParams(parsedOptions),
+                batch_size: prompts.length,
+            };
+            runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions?.runName);
+        }
         // Even if stream is not explicitly called, check if model is implicitly
         // called from streamEvents() or streamLog() to get all streamed events.
         // Bail out if _streamResponseChunks not overridden
@@ -188,7 +195,6 @@ export class BaseLLM extends BaseLanguageModel {
             options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),
             batch_size: prompts.length,
-            cached: true,
         };
         const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, runId, undefined, extra, undefined, undefined, handledOptions?.runName);
         // generate results
@@ -211,23 +217,35 @@ export class BaseLLM extends BaseLanguageModel {
         await Promise.all(cachedResults.map(async ({ result: promiseResult, runManager }, i) => {
             if (promiseResult.status === "fulfilled") {
                 const result = promiseResult.value;
-                generations[i] = result;
+                generations[i] = result.map((result) => {
+                    // eslint-disable-next-line no-param-reassign
+                    result.generationInfo = {
+                        ...result.generationInfo,
+                        tokenUsage: {},
+                    };
+                    return result;
+                });
                 if (result.length) {
                     await runManager?.handleLLMNewToken(result[0].text);
                 }
                 return runManager?.handleLLMEnd({
                     generations: [result],
+                }, undefined, undefined, undefined, {
+                    cached: true,
                 });
             }
             else {
                 // status === "rejected"
-                await runManager?.handleLLMError(promiseResult.reason);
+                await runManager?.handleLLMError(promiseResult.reason, undefined, undefined, undefined, {
+                    cached: true,
+                });
                 return Promise.reject(promiseResult.reason);
             }
         }));
         const output = {
             generations,
             missingPromptIndices,
+            startedRunManagers: runManagers,
         };
         // This defines RUN_KEY as a non-enumerable property on the output object
         // so that it is not serialized when the output is stringified, and so that
@@ -261,7 +279,7 @@ export class BaseLLM extends BaseLanguageModel {
         }
         const { cache } = this;
         const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
-        const { generations, missingPromptIndices } = await this._generateCached({
+        const { generations, missingPromptIndices, startedRunManagers } = await this._generateCached({
             prompts,
             cache,
             llmStringKey,
@@ -271,7 +289,9 @@ export class BaseLLM extends BaseLanguageModel {
         });
         let llmOutput = {};
         if (missingPromptIndices.length > 0) {
-            const results = await this._generateUncached(missingPromptIndices.map((i) => prompts[i]), callOptions, runnableConfig);
+            const results = await this._generateUncached(missingPromptIndices.map((i) => prompts[i]), callOptions, runnableConfig, startedRunManagers !== undefined
+                ? missingPromptIndices.map((i) => startedRunManagers?.[i])
+                : undefined);
             await Promise.all(results.generations.map(async (generation, index) => {
                 const promptIndex = missingPromptIndices[index];
                 generations[promptIndex] = generation;

package/dist/tracers/base.cjs

@@ -178,7 +178,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         await this.onLLMStart?.(run);
         return run;
     }
-    async handleLLMEnd(output, runId) {
+    async handleLLMEnd(output, runId, _parentRunId, _tags, extraParams) {
         const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "llm") {
             throw new Error("No LLM run to end.");
@@ -189,11 +189,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             name: "end",
             time: new Date(run.end_time).toISOString(),
         });
+        run.extra = { ...run.extra, ...extraParams };
         await this.onLLMEnd?.(run);
         await this._endTrace(run);
         return run;
     }
-    async handleLLMError(error, runId) {
+    async handleLLMError(error, runId, _parentRunId, _tags, extraParams) {
         const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "llm") {
             throw new Error("No LLM run to end.");
@@ -204,6 +205,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             name: "error",
             time: new Date(run.end_time).toISOString(),
         });
+        run.extra = { ...run.extra, ...extraParams };
         await this.onLLMError?.(run);
         await this._endTrace(run);
         return run;

package/dist/tracers/base.d.ts

@@ -124,8 +124,8 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
         attachments?: import("langsmith/schemas").Attachments | undefined;
     };
     handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
-    handleLLMEnd(output: LLMResult, runId: string): Promise<Run>;
-    handleLLMError(error: unknown, runId: string): Promise<Run>;
+    handleLLMEnd(output: LLMResult, runId: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<Run>;
+    handleLLMError(error: unknown, runId: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<Run>;
     /**
      * Create and add a run to the run map for chain start events.
      * This must sometimes be done synchronously to avoid race conditions

package/dist/tracers/base.js

@@ -174,7 +174,7 @@ export class BaseTracer extends BaseCallbackHandler {
         await this.onLLMStart?.(run);
         return run;
     }
-    async handleLLMEnd(output, runId) {
+    async handleLLMEnd(output, runId, _parentRunId, _tags, extraParams) {
         const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "llm") {
             throw new Error("No LLM run to end.");
@@ -185,11 +185,12 @@ export class BaseTracer extends BaseCallbackHandler {
             name: "end",
             time: new Date(run.end_time).toISOString(),
         });
+        run.extra = { ...run.extra, ...extraParams };
         await this.onLLMEnd?.(run);
         await this._endTrace(run);
         return run;
     }
-    async handleLLMError(error, runId) {
+    async handleLLMError(error, runId, _parentRunId, _tags, extraParams) {
         const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "llm") {
             throw new Error("No LLM run to end.");
@@ -200,6 +201,7 @@ export class BaseTracer extends BaseCallbackHandler {
             name: "error",
             time: new Date(run.end_time).toISOString(),
         });
+        run.extra = { ...run.extra, ...extraParams };
         await this.onLLMError?.(run);
         await this._endTrace(run);
         return run;

package/dist/tracers/tracer_langchain.cjs

@@ -72,6 +72,7 @@ class LangChainTracer extends base_js_1.BaseTracer {
             trace_id: run.trace_id,
             dotted_order: run.dotted_order,
             parent_run_id: run.parent_run_id,
+            extra: run.extra,
         };
         await this.client.updateRun(run.id, runUpdate);
     }

package/dist/tracers/tracer_langchain.js

@@ -69,6 +69,7 @@ export class LangChainTracer extends BaseTracer {
             trace_id: run.trace_id,
             dotted_order: run.dotted_order,
             parent_run_id: run.parent_run_id,
+            extra: run.extra,
         };
         await this.client.updateRun(run.id, runUpdate);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.3.31",
+  "version": "0.3.33",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -38,7 +38,7 @@
     "camelcase": "6",
     "decamelize": "1.2.0",
     "js-tiktoken": "^1.0.12",
-    "langsmith": "^0.2.8",
+    "langsmith": ">=0.2.8 <0.4.0",
     "mustache": "^4.2.0",
     "p-queue": "^6.6.2",
     "p-retry": "4",