@langchain/core 0.1.53 → 0.1.55-rc.0

package/dist/callbacks/manager.cjs

@@ -372,34 +372,36 @@ class CallbackManager extends BaseCallbackManager {
     getParentRunId() {
         return this._parentRunId;
     }
-    async handleLLMStart(llm, prompts, _runId = undefined, _parentRunId = undefined, extraParams = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        return Promise.all(prompts.map(async (prompt) => {
-            const runId = (0, uuid_1.v4)();
+    async handleLLMStart(llm, prompts, runId = undefined, _parentRunId = undefined, extraParams = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
+        return Promise.all(prompts.map(async (prompt, idx) => {
+            // Can't have duplicate runs with the same run ID (if provided)
+            const runId_ = idx === 0 && runId ? runId : (0, uuid_1.v4)();
             await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
                 if (!handler.ignoreLLM) {
                     try {
-                        await handler.handleLLMStart?.(llm, [prompt], runId, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                        await handler.handleLLMStart?.(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
                     }
                     catch (err) {
                         console.error(`Error in handler ${handler.constructor.name}, handleLLMStart: ${err}`);
                     }
                 }
             }, handler.awaitHandlers)));
-            return new CallbackManagerForLLMRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
+            return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
         }));
     }
-    async handleChatModelStart(llm, messages, _runId = undefined, _parentRunId = undefined, extraParams = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        return Promise.all(messages.map(async (messageGroup) => {
-            const runId = (0, uuid_1.v4)();
+    async handleChatModelStart(llm, messages, runId = undefined, _parentRunId = undefined, extraParams = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
+        return Promise.all(messages.map(async (messageGroup, idx) => {
+            // Can't have duplicate runs with the same run ID (if provided)
+            const runId_ = idx === 0 && runId ? runId : (0, uuid_1.v4)();
             await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
                 if (!handler.ignoreLLM) {
                     try {
                         if (handler.handleChatModelStart) {
-                            await handler.handleChatModelStart?.(llm, [messageGroup], runId, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                            await handler.handleChatModelStart?.(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
                         }
                         else if (handler.handleLLMStart) {
                             const messageString = (0, index_js_1.getBufferString)(messageGroup);
-                            await handler.handleLLMStart?.(llm, [messageString], runId, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                            await handler.handleLLMStart?.(llm, [messageString], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
                         }
                     }
                     catch (err) {
@@ -407,7 +409,7 @@ class CallbackManager extends BaseCallbackManager {
                     }
                 }
             }, handler.awaitHandlers)));
-            return new CallbackManagerForLLMRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
+            return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
         }));
     }
     async handleChainStart(chain, inputs, runId = (0, uuid_1.v4)(), runType = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {

package/dist/callbacks/manager.d.ts

@@ -34,6 +34,11 @@ export interface BaseCallbackConfig {
      * Tags are passed to all callbacks, metadata is passed to handle*Start callbacks.
      */
     callbacks?: Callbacks;
+    /**
+     * Unique identifier for the tracer run for this call. If not provided, a new UUID
+     * will be generated.
+     */
+    runId?: string;
 }
 export declare function parseCallbackConfigArg(arg: Callbacks | BaseCallbackConfig | undefined): BaseCallbackConfig;
 /**
@@ -130,8 +135,8 @@ export declare class CallbackManager extends BaseCallbackManager implements Base
      * @returns The parent run ID.
      */
     getParentRunId(): string | undefined;
-    handleLLMStart(llm: Serialized, prompts: string[], _runId?: string | undefined, _parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, _tags?: string[] | undefined, _metadata?: Record<string, unknown> | undefined, runName?: string | undefined): Promise<CallbackManagerForLLMRun[]>;
-    handleChatModelStart(llm: Serialized, messages: BaseMessage[][], _runId?: string | undefined, _parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, _tags?: string[] | undefined, _metadata?: Record<string, unknown> | undefined, runName?: string | undefined): Promise<CallbackManagerForLLMRun[]>;
+    handleLLMStart(llm: Serialized, prompts: string[], runId?: string | undefined, _parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, _tags?: string[] | undefined, _metadata?: Record<string, unknown> | undefined, runName?: string | undefined): Promise<CallbackManagerForLLMRun[]>;
+    handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId?: string | undefined, _parentRunId?: string | undefined, extraParams?: Record<string, unknown> | undefined, _tags?: string[] | undefined, _metadata?: Record<string, unknown> | undefined, runName?: string | undefined): Promise<CallbackManagerForLLMRun[]>;
     handleChainStart(chain: Serialized, inputs: ChainValues, runId?: string, runType?: string | undefined, _tags?: string[] | undefined, _metadata?: Record<string, unknown> | undefined, runName?: string | undefined): Promise<CallbackManagerForChainRun>;
     handleToolStart(tool: Serialized, input: string, runId?: string, _parentRunId?: string | undefined, _tags?: string[] | undefined, _metadata?: Record<string, unknown> | undefined, runName?: string | undefined): Promise<CallbackManagerForToolRun>;
     handleRetrieverStart(retriever: Serialized, query: string, runId?: string, _parentRunId?: string | undefined, _tags?: string[] | undefined, _metadata?: Record<string, unknown> | undefined, runName?: string | undefined): Promise<CallbackManagerForRetrieverRun>;

package/dist/callbacks/manager.js

@@ -363,34 +363,36 @@ export class CallbackManager extends BaseCallbackManager {
     getParentRunId() {
         return this._parentRunId;
     }
-    async handleLLMStart(llm, prompts, _runId = undefined, _parentRunId = undefined, extraParams = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        return Promise.all(prompts.map(async (prompt) => {
-            const runId = uuidv4();
+    async handleLLMStart(llm, prompts, runId = undefined, _parentRunId = undefined, extraParams = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
+        return Promise.all(prompts.map(async (prompt, idx) => {
+            // Can't have duplicate runs with the same run ID (if provided)
+            const runId_ = idx === 0 && runId ? runId : uuidv4();
             await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
                 if (!handler.ignoreLLM) {
                     try {
-                        await handler.handleLLMStart?.(llm, [prompt], runId, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                        await handler.handleLLMStart?.(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
                     }
                     catch (err) {
                         console.error(`Error in handler ${handler.constructor.name}, handleLLMStart: ${err}`);
                     }
                 }
             }, handler.awaitHandlers)));
-            return new CallbackManagerForLLMRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
+            return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
         }));
     }
-    async handleChatModelStart(llm, messages, _runId = undefined, _parentRunId = undefined, extraParams = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        return Promise.all(messages.map(async (messageGroup) => {
-            const runId = uuidv4();
+    async handleChatModelStart(llm, messages, runId = undefined, _parentRunId = undefined, extraParams = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
+        return Promise.all(messages.map(async (messageGroup, idx) => {
+            // Can't have duplicate runs with the same run ID (if provided)
+            const runId_ = idx === 0 && runId ? runId : uuidv4();
             await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
                 if (!handler.ignoreLLM) {
                     try {
                         if (handler.handleChatModelStart) {
-                            await handler.handleChatModelStart?.(llm, [messageGroup], runId, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                            await handler.handleChatModelStart?.(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
                         }
                         else if (handler.handleLLMStart) {
                             const messageString = getBufferString(messageGroup);
-                            await handler.handleLLMStart?.(llm, [messageString], runId, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                            await handler.handleLLMStart?.(llm, [messageString], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
                         }
                     }
                     catch (err) {
@@ -398,7 +400,7 @@ export class CallbackManager extends BaseCallbackManager {
                     }
                 }
             }, handler.awaitHandlers)));
-            return new CallbackManagerForLLMRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
+            return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
         }));
     }
     async handleChainStart(chain, inputs, runId = uuidv4(), runType = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {

package/dist/language_models/chat_models.cjs

@@ -76,7 +76,7 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
                 invocation_params: this?.invocationParams(callOptions),
                 batch_size: 1,
             };
-            const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), [messages], undefined, undefined, extra, undefined, undefined, runnableConfig.runName);
+            const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), [messages], runnableConfig.runId, undefined, extra, undefined, undefined, runnableConfig.runName);
             let generationChunk;
             try {
                 for await (const chunk of this._streamResponseChunks(messages, callOptions, runManagers?.[0])) {
@@ -113,7 +113,7 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
             invocation_params: this?.invocationParams(parsedOptions),
             batch_size: 1,
         };
-        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, undefined, undefined, extra, undefined, undefined, handledOptions.runName);
+        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions.runName);
         // generate results
         const results = await Promise.allSettled(baseMessages.map((messageList, i) => this._generate(messageList, { ...parsedOptions, promptIndex: i }, runManagers?.[i])));
         // handle results
@@ -172,7 +172,7 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
             batch_size: 1,
             cached: true,
         };
-        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, undefined, undefined, extra, undefined, undefined, handledOptions.runName);
+        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions.runName);
         // generate results
         const missingPromptIndices = [];
         const results = await Promise.allSettled(baseMessages.map(async (baseMessage, index) => {

package/dist/language_models/chat_models.js

@@ -72,7 +72,7 @@ export class BaseChatModel extends BaseLanguageModel {
                 invocation_params: this?.invocationParams(callOptions),
                 batch_size: 1,
             };
-            const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), [messages], undefined, undefined, extra, undefined, undefined, runnableConfig.runName);
+            const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), [messages], runnableConfig.runId, undefined, extra, undefined, undefined, runnableConfig.runName);
             let generationChunk;
             try {
                 for await (const chunk of this._streamResponseChunks(messages, callOptions, runManagers?.[0])) {
@@ -109,7 +109,7 @@ export class BaseChatModel extends BaseLanguageModel {
             invocation_params: this?.invocationParams(parsedOptions),
             batch_size: 1,
         };
-        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, undefined, undefined, extra, undefined, undefined, handledOptions.runName);
+        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions.runName);
         // generate results
         const results = await Promise.allSettled(baseMessages.map((messageList, i) => this._generate(messageList, { ...parsedOptions, promptIndex: i }, runManagers?.[i])));
         // handle results
@@ -168,7 +168,7 @@ export class BaseChatModel extends BaseLanguageModel {
             batch_size: 1,
             cached: true,
         };
-        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, undefined, undefined, extra, undefined, undefined, handledOptions.runName);
+        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions.runName);
         // generate results
         const missingPromptIndices = [];
         const results = await Promise.allSettled(baseMessages.map(async (baseMessage, index) => {

package/dist/language_models/llms.cjs

@@ -57,7 +57,7 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
                 invocation_params: this?.invocationParams(callOptions),
                 batch_size: 1,
             };
-            const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), [prompt.toString()], undefined, undefined, extra, undefined, undefined, runnableConfig.runName);
+            const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), [prompt.toString()], runnableConfig.runId, undefined, extra, undefined, undefined, runnableConfig.runName);
             let generation = new outputs_js_1.GenerationChunk({
                 text: "",
             });
@@ -132,7 +132,7 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
             invocation_params: this?.invocationParams(parsedOptions),
             batch_size: prompts.length,
         };
-        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, undefined, undefined, extra, undefined, undefined, handledOptions?.runName);
+        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions?.runName);
         let output;
         try {
             output = await this._generate(prompts, parsedOptions, runManagers?.[0]);
@@ -153,7 +153,7 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
         });
         return output;
     }
-    async _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, }) {
+    async _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId, }) {
         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,
@@ -161,7 +161,7 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
             batch_size: prompts.length,
             cached: true,
         };
-        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, undefined, undefined, extra, undefined, undefined, handledOptions?.runName);
+        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, runId, undefined, extra, undefined, undefined, handledOptions?.runName);
         // generate results
         const missingPromptIndices = [];
         const results = await Promise.allSettled(prompts.map(async (prompt, index) => {
@@ -238,6 +238,7 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
             llmStringKey,
             parsedOptions: callOptions,
             handledOptions: runnableConfig,
+            runId: runnableConfig.runId,
         });
         let llmOutput = {};
         if (missingPromptIndices.length > 0) {

package/dist/language_models/llms.d.ts

@@ -23,6 +23,7 @@ interface LLMGenerateCachedParameters<T extends BaseLLM<CallOptions>, CallOption
     llmStringKey: string;
     parsedOptions: T["ParsedCallOptions"];
     handledOptions: RunnableConfig;
+    runId?: string;
 }
 /**
  * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.
@@ -63,7 +64,7 @@ export declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = B
     _flattenLLMResult(llmResult: LLMResult): LLMResult[];
     /** @ignore */
     _generateUncached(prompts: string[], parsedOptions: this["ParsedCallOptions"], handledOptions: BaseCallbackConfig): Promise<LLMResult>;
-    _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, }: LLMGenerateCachedParameters<typeof this>): Promise<LLMResult & {
+    _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId, }: LLMGenerateCachedParameters<typeof this>): Promise<LLMResult & {
         missingPromptIndices: number[];
     }>;
     /**

package/dist/language_models/llms.js

@@ -54,7 +54,7 @@ export class BaseLLM extends BaseLanguageModel {
                 invocation_params: this?.invocationParams(callOptions),
                 batch_size: 1,
             };
-            const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), [prompt.toString()], undefined, undefined, extra, undefined, undefined, runnableConfig.runName);
+            const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), [prompt.toString()], runnableConfig.runId, undefined, extra, undefined, undefined, runnableConfig.runName);
             let generation = new GenerationChunk({
                 text: "",
             });
@@ -129,7 +129,7 @@ export class BaseLLM extends BaseLanguageModel {
             invocation_params: this?.invocationParams(parsedOptions),
             batch_size: prompts.length,
         };
-        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, undefined, undefined, extra, undefined, undefined, handledOptions?.runName);
+        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions?.runName);
         let output;
         try {
             output = await this._generate(prompts, parsedOptions, runManagers?.[0]);
@@ -150,7 +150,7 @@ export class BaseLLM extends BaseLanguageModel {
         });
         return output;
     }
-    async _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, }) {
+    async _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId, }) {
         const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
         const extra = {
             options: parsedOptions,
@@ -158,7 +158,7 @@ export class BaseLLM extends BaseLanguageModel {
             batch_size: prompts.length,
             cached: true,
         };
-        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, undefined, undefined, extra, undefined, undefined, handledOptions?.runName);
+        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, runId, undefined, extra, undefined, undefined, handledOptions?.runName);
         // generate results
         const missingPromptIndices = [];
         const results = await Promise.allSettled(prompts.map(async (prompt, index) => {
@@ -235,6 +235,7 @@ export class BaseLLM extends BaseLanguageModel {
             llmStringKey,
             parsedOptions: callOptions,
             handledOptions: runnableConfig,
+            runId: runnableConfig.runId,
         });
         let llmOutput = {};
         if (missingPromptIndices.length > 0) {

package/dist/messages/index.d.ts

@@ -30,7 +30,11 @@ export type MessageContentImageUrl = {
         detail?: ImageDetail;
     };
 };
-export type MessageContentComplex = MessageContentText | MessageContentImageUrl;
+export type MessageContentComplex = MessageContentText | MessageContentImageUrl | (Record<string, any> & {
+    type?: "text" | "image_url" | string;
+}) | (Record<string, any> & {
+    type?: never;
+});
 export type MessageContent = string | MessageContentComplex[];
 export interface FunctionCall {
     /**

package/dist/output_parsers/string.cjs

@@ -62,14 +62,21 @@ class StringOutputParser extends transform_js_1.BaseTransformOutputParser {
     _messageContentComplexToString(content) {
         switch (content.type) {
             case "text":
-                return this._textContentToString(content);
+                if ("text" in content) {
+                    // Type guard for MessageContentText
+                    return this._textContentToString(content);
+                }
+                break;
             case "image_url":
-                return this._imageUrlContentToString(content);
+                if ("image_url" in content) {
+                    // Type guard for MessageContentImageUrl
+                    return this._imageUrlContentToString(content);
+                }
+                break;
             default:
-                throw new Error(
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                `Cannot coerce "${content.type}" message part into a string.`);
+                throw new Error(`Cannot coerce "${content.type}" message part into a string.`);
         }
+        throw new Error(`Invalid content type: ${content.type}`);
     }
     _baseMessageContentToString(content) {
         return content.reduce((acc, item) => acc + this._messageContentComplexToString(item), "");

package/dist/output_parsers/string.js

@@ -59,14 +59,21 @@ export class StringOutputParser extends BaseTransformOutputParser {
     _messageContentComplexToString(content) {
         switch (content.type) {
             case "text":
-                return this._textContentToString(content);
+                if ("text" in content) {
+                    // Type guard for MessageContentText
+                    return this._textContentToString(content);
+                }
+                break;
             case "image_url":
-                return this._imageUrlContentToString(content);
+                if ("image_url" in content) {
+                    // Type guard for MessageContentImageUrl
+                    return this._imageUrlContentToString(content);
+                }
+                break;
             default:
-                throw new Error(
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                `Cannot coerce "${content.type}" message part into a string.`);
+                throw new Error(`Cannot coerce "${content.type}" message part into a string.`);
         }
+        throw new Error(`Invalid content type: ${content.type}`);
     }
     _baseMessageContentToString(content) {
         return content.reduce((acc, item) => acc + this._messageContentComplexToString(item), "");

package/dist/prompts/chat.cjs

@@ -463,14 +463,32 @@ function _coerceMessagePromptTemplateLike(messagePromptTemplateLike) {
         return new MessagesPlaceholder({ variableName, optional: true });
     }
     const message = (0, index_js_1.coerceMessageLikeToMessage)(messagePromptTemplateLike);
+    let templateData;
+    if (typeof message.content === "string") {
+        templateData = message.content;
+    }
+    else {
+        // Assuming message.content is an array of complex objects, transform it.
+        templateData = message.content.map((item) => {
+            if ("text" in item) {
+                return { text: item.text };
+            }
+            else if ("image_url" in item) {
+                return { image_url: item.image_url };
+            }
+            else {
+                throw new Error("Invalid message content");
+            }
+        });
+    }
     if (message._getType() === "human") {
-        return HumanMessagePromptTemplate.fromTemplate(message.content);
+        return HumanMessagePromptTemplate.fromTemplate(templateData);
     }
     else if (message._getType() === "ai") {
-        return AIMessagePromptTemplate.fromTemplate(message.content);
+        return AIMessagePromptTemplate.fromTemplate(templateData);
     }
     else if (message._getType() === "system") {
-        return SystemMessagePromptTemplate.fromTemplate(message.content);
+        return SystemMessagePromptTemplate.fromTemplate(templateData);
     }
     else if (index_js_1.ChatMessage.isInstance(message)) {
         return ChatMessagePromptTemplate.fromTemplate(message.content, message.role);

package/dist/prompts/chat.js

@@ -452,14 +452,32 @@ function _coerceMessagePromptTemplateLike(messagePromptTemplateLike) {
         return new MessagesPlaceholder({ variableName, optional: true });
     }
     const message = coerceMessageLikeToMessage(messagePromptTemplateLike);
+    let templateData;
+    if (typeof message.content === "string") {
+        templateData = message.content;
+    }
+    else {
+        // Assuming message.content is an array of complex objects, transform it.
+        templateData = message.content.map((item) => {
+            if ("text" in item) {
+                return { text: item.text };
+            }
+            else if ("image_url" in item) {
+                return { image_url: item.image_url };
+            }
+            else {
+                throw new Error("Invalid message content");
+            }
+        });
+    }
     if (message._getType() === "human") {
-        return HumanMessagePromptTemplate.fromTemplate(message.content);
+        return HumanMessagePromptTemplate.fromTemplate(templateData);
     }
     else if (message._getType() === "ai") {
-        return AIMessagePromptTemplate.fromTemplate(message.content);
+        return AIMessagePromptTemplate.fromTemplate(templateData);
     }
     else if (message._getType() === "system") {
-        return SystemMessagePromptTemplate.fromTemplate(message.content);
+        return SystemMessagePromptTemplate.fromTemplate(templateData);
     }
     else if (ChatMessage.isInstance(message)) {
         return ChatMessagePromptTemplate.fromTemplate(message.content, message.role);

package/dist/retrievers/index.cjs

@@ -65,7 +65,7 @@ class BaseRetriever extends base_js_1.Runnable {
     async getRelevantDocuments(query, config) {
         const parsedConfig = (0, config_js_1.ensureConfig)((0, manager_js_1.parseCallbackConfigArg)(config));
         const callbackManager_ = await manager_js_1.CallbackManager.configure(parsedConfig.callbacks, this.callbacks, parsedConfig.tags, this.tags, parsedConfig.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, undefined, undefined, undefined, undefined, parsedConfig.runName);
+        const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, parsedConfig.runId, undefined, undefined, undefined, parsedConfig.runName);
         try {
             const results = await this._getRelevantDocuments(query, runManager);
             await runManager?.handleRetrieverEnd(results);

package/dist/retrievers/index.js

@@ -62,7 +62,7 @@ export class BaseRetriever extends Runnable {
     async getRelevantDocuments(query, config) {
         const parsedConfig = ensureConfig(parseCallbackConfigArg(config));
         const callbackManager_ = await CallbackManager.configure(parsedConfig.callbacks, this.callbacks, parsedConfig.tags, this.tags, parsedConfig.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, undefined, undefined, undefined, undefined, parsedConfig.runName);
+        const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, parsedConfig.runId, undefined, undefined, undefined, parsedConfig.runName);
         try {
             const results = await this._getRelevantDocuments(query, runManager);
             await runManager?.handleRetrieverEnd(results);

package/dist/runnables/base.cjs

@@ -112,12 +112,17 @@ class Runnable extends serializable_js_1.Serializable {
         });
     }
     _getOptionsList(options, length = 0) {
+        if (Array.isArray(options) && options.length !== length) {
+            throw new Error(`Passed "options" must be an array with the same length as the inputs, but got ${options.length} options for ${length} inputs`);
+        }
         if (Array.isArray(options)) {
-            if (options.length !== length) {
-                throw new Error(`Passed "options" must be an array with the same length as the inputs, but got ${options.length} options for ${length} inputs`);
-            }
             return options.map(config_js_1.ensureConfig);
         }
+        if (length > 1 && !Array.isArray(options) && options.runId) {
+            console.warn("Provided runId will be used only for the first element of the batch.");
+            const subsequent = Object.fromEntries(Object.entries(options).filter(([key]) => key !== "runId"));
+            return Array.from({ length }, (_, i) => (0, config_js_1.ensureConfig)(i === 0 ? options : subsequent));
+        }
         return Array.from({ length }, () => (0, config_js_1.ensureConfig)(options));
     }
     async batch(inputs, options, batchOptions) {
@@ -179,6 +184,7 @@ class Runnable extends serializable_js_1.Serializable {
                 configurable: options.configurable,
                 recursionLimit: options.recursionLimit,
                 maxConcurrency: options.maxConcurrency,
+                runId: options.runId,
             });
         }
         const callOptions = { ...options };
@@ -189,12 +195,14 @@ class Runnable extends serializable_js_1.Serializable {
         delete callOptions.configurable;
         delete callOptions.recursionLimit;
         delete callOptions.maxConcurrency;
+        delete callOptions.runId;
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
         const config = (0, config_js_1.ensureConfig)(options);
         const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, config?.runType, undefined, undefined, config?.runName ?? this.getName());
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, config?.runType, undefined, undefined, config?.runName ?? this.getName());
+        delete config.runId;
         let output;
         try {
             output = await func.call(this, input, config, runManager);
@@ -218,7 +226,11 @@ class Runnable extends serializable_js_1.Serializable {
     async _batchWithConfig(func, inputs, options, batchOptions) {
         const optionsList = this._getOptionsList(options ?? {}, inputs.length);
         const callbackManagers = await Promise.all(optionsList.map(config_js_1.getCallbackManagerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, optionsList[i].runType, undefined, undefined, optionsList[i].runName ?? this.getName())));
+        const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
+            const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), optionsList[i].runId, optionsList[i].runType, undefined, undefined, optionsList[i].runName ?? this.getName());
+            delete optionsList[i].runId;
+            return handleStartRes;
+        }));
         let outputs;
         try {
             outputs = await func.call(this, inputs, optionsList, runManagers, batchOptions);
@@ -264,7 +276,8 @@ class Runnable extends serializable_js_1.Serializable {
         }
         let runManager;
         try {
-            const pipe = await (0, stream_js_1.pipeGeneratorWithSetup)(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, undefined, config?.runType, undefined, undefined, config?.runName ?? this.getName()), config);
+            const pipe = await (0, stream_js_1.pipeGeneratorWithSetup)(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, undefined, undefined, config.runName ?? this.getName()), config);
+            delete config.runId;
             runManager = pipe.setup;
             const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer";
             const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
@@ -1042,7 +1055,8 @@ class RunnableSequence extends Runnable {
     async invoke(input, options) {
         const config = (0, config_js_1.ensureConfig)(options);
         const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, config?.runName);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, undefined, undefined, undefined, config?.runName);
+        delete config.runId;
         let nextStepInput = input;
         let finalOutput;
         try {
@@ -1068,7 +1082,11 @@ class RunnableSequence extends Runnable {
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
         const callbackManagers = await Promise.all(configList.map(config_js_1.getCallbackManagerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, undefined, undefined, undefined, configList[i].runName)));
+        const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
+            const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), configList[i].runId, undefined, undefined, undefined, configList[i].runName);
+            delete configList[i].runId;
+            return handleStartRes;
+        }));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let nextStepInputs = inputs;
         try {
@@ -1089,7 +1107,8 @@ class RunnableSequence extends Runnable {
     }
     async *_streamIterator(input, options) {
         const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+        const { runId, ...otherOptions } = options ?? {};
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherOptions?.runName);
         const steps = [this.first, ...this.middle, this.last];
         let concatSupported = true;
         let finalOutput;
@@ -1097,12 +1116,12 @@ class RunnableSequence extends Runnable {
             yield input;
         }
         try {
-            let finalGenerator = steps[0].transform(inputGenerator(), (0, config_js_1.patchConfig)(options, {
+            let finalGenerator = steps[0].transform(inputGenerator(), (0, config_js_1.patchConfig)(otherOptions, {
                 callbacks: runManager?.getChild(`seq:step:1`),
             }));
             for (let i = 1; i < steps.length; i += 1) {
                 const step = steps[i];
-                finalGenerator = await step.transform(finalGenerator, (0, config_js_1.patchConfig)(options, {
+                finalGenerator = await step.transform(finalGenerator, (0, config_js_1.patchConfig)(otherOptions, {
                     callbacks: runManager?.getChild(`seq:step:${i + 1}`),
                 }));
             }
@@ -1248,7 +1267,8 @@ class RunnableMap extends Runnable {
         const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), {
             input,
-        }, undefined, undefined, undefined, undefined, config?.runName);
+        }, config.runId, undefined, undefined, undefined, config?.runName);
+        delete config.runId;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const output = {};
         try {
@@ -1469,11 +1489,12 @@ class RunnableWithFallbacks extends Runnable {
     }
     async invoke(input, options) {
         const callbackManager_ = await manager_js_1.CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+        const { runId, ...otherOptions } = options ?? {};
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherOptions?.runName);
         let firstError;
         for (const runnable of this.runnables()) {
             try {
-                const output = await runnable.invoke(input, (0, config_js_1.patchConfig)(options, { callbacks: runManager?.getChild() }));
+                const output = await runnable.invoke(input, (0, config_js_1.patchConfig)(otherOptions, { callbacks: runManager?.getChild() }));
                 await runManager?.handleChainEnd(_coerceToDict(output, "output"));
                 return output;
             }
@@ -1495,7 +1516,11 @@ class RunnableWithFallbacks extends Runnable {
         }
         const configList = this._getOptionsList(options ?? {}, inputs.length);
         const callbackManagers = await Promise.all(configList.map((config) => manager_js_1.CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata)));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, undefined, undefined, undefined, configList[i].runName)));
+        const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
+            const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), configList[i].runId, undefined, undefined, undefined, configList[i].runName);
+            delete configList[i].runId;
+            return handleStartRes;
+        }));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let firstError;
         for (const runnable of this.runnables()) {

package/dist/runnables/base.js

@@ -105,12 +105,17 @@ export class Runnable extends Serializable {
         });
     }
     _getOptionsList(options, length = 0) {
+        if (Array.isArray(options) && options.length !== length) {
+            throw new Error(`Passed "options" must be an array with the same length as the inputs, but got ${options.length} options for ${length} inputs`);
+        }
         if (Array.isArray(options)) {
-            if (options.length !== length) {
-                throw new Error(`Passed "options" must be an array with the same length as the inputs, but got ${options.length} options for ${length} inputs`);
-            }
             return options.map(ensureConfig);
         }
+        if (length > 1 && !Array.isArray(options) && options.runId) {
+            console.warn("Provided runId will be used only for the first element of the batch.");
+            const subsequent = Object.fromEntries(Object.entries(options).filter(([key]) => key !== "runId"));
+            return Array.from({ length }, (_, i) => ensureConfig(i === 0 ? options : subsequent));
+        }
         return Array.from({ length }, () => ensureConfig(options));
     }
     async batch(inputs, options, batchOptions) {
@@ -172,6 +177,7 @@ export class Runnable extends Serializable {
                 configurable: options.configurable,
                 recursionLimit: options.recursionLimit,
                 maxConcurrency: options.maxConcurrency,
+                runId: options.runId,
             });
         }
         const callOptions = { ...options };
@@ -182,12 +188,14 @@ export class Runnable extends Serializable {
         delete callOptions.configurable;
         delete callOptions.recursionLimit;
         delete callOptions.maxConcurrency;
+        delete callOptions.runId;
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
         const config = ensureConfig(options);
         const callbackManager_ = await getCallbackManagerForConfig(config);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, config?.runType, undefined, undefined, config?.runName ?? this.getName());
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, config?.runType, undefined, undefined, config?.runName ?? this.getName());
+        delete config.runId;
         let output;
         try {
             output = await func.call(this, input, config, runManager);
@@ -211,7 +219,11 @@ export class Runnable extends Serializable {
     async _batchWithConfig(func, inputs, options, batchOptions) {
         const optionsList = this._getOptionsList(options ?? {}, inputs.length);
         const callbackManagers = await Promise.all(optionsList.map(getCallbackManagerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, optionsList[i].runType, undefined, undefined, optionsList[i].runName ?? this.getName())));
+        const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
+            const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), optionsList[i].runId, optionsList[i].runType, undefined, undefined, optionsList[i].runName ?? this.getName());
+            delete optionsList[i].runId;
+            return handleStartRes;
+        }));
         let outputs;
         try {
             outputs = await func.call(this, inputs, optionsList, runManagers, batchOptions);
@@ -257,7 +269,8 @@ export class Runnable extends Serializable {
         }
         let runManager;
         try {
-            const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, undefined, config?.runType, undefined, undefined, config?.runName ?? this.getName()), config);
+            const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, undefined, undefined, config.runName ?? this.getName()), config);
+            delete config.runId;
             runManager = pipe.setup;
             const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer";
             const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
@@ -1031,7 +1044,8 @@ export class RunnableSequence extends Runnable {
     async invoke(input, options) {
         const config = ensureConfig(options);
         const callbackManager_ = await getCallbackManagerForConfig(config);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, config?.runName);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, undefined, undefined, undefined, config?.runName);
+        delete config.runId;
         let nextStepInput = input;
         let finalOutput;
         try {
@@ -1057,7 +1071,11 @@ export class RunnableSequence extends Runnable {
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
         const callbackManagers = await Promise.all(configList.map(getCallbackManagerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, undefined, undefined, undefined, configList[i].runName)));
+        const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
+            const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), configList[i].runId, undefined, undefined, undefined, configList[i].runName);
+            delete configList[i].runId;
+            return handleStartRes;
+        }));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let nextStepInputs = inputs;
         try {
@@ -1078,7 +1096,8 @@ export class RunnableSequence extends Runnable {
     }
     async *_streamIterator(input, options) {
         const callbackManager_ = await getCallbackManagerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+        const { runId, ...otherOptions } = options ?? {};
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherOptions?.runName);
         const steps = [this.first, ...this.middle, this.last];
         let concatSupported = true;
         let finalOutput;
@@ -1086,12 +1105,12 @@ export class RunnableSequence extends Runnable {
             yield input;
         }
         try {
-            let finalGenerator = steps[0].transform(inputGenerator(), patchConfig(options, {
+            let finalGenerator = steps[0].transform(inputGenerator(), patchConfig(otherOptions, {
                 callbacks: runManager?.getChild(`seq:step:1`),
             }));
             for (let i = 1; i < steps.length; i += 1) {
                 const step = steps[i];
-                finalGenerator = await step.transform(finalGenerator, patchConfig(options, {
+                finalGenerator = await step.transform(finalGenerator, patchConfig(otherOptions, {
                     callbacks: runManager?.getChild(`seq:step:${i + 1}`),
                 }));
             }
@@ -1236,7 +1255,8 @@ export class RunnableMap extends Runnable {
         const callbackManager_ = await getCallbackManagerForConfig(config);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), {
             input,
-        }, undefined, undefined, undefined, undefined, config?.runName);
+        }, config.runId, undefined, undefined, undefined, config?.runName);
+        delete config.runId;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const output = {};
         try {
@@ -1454,11 +1474,12 @@ export class RunnableWithFallbacks extends Runnable {
     }
     async invoke(input, options) {
         const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+        const { runId, ...otherOptions } = options ?? {};
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherOptions?.runName);
         let firstError;
         for (const runnable of this.runnables()) {
             try {
-                const output = await runnable.invoke(input, patchConfig(options, { callbacks: runManager?.getChild() }));
+                const output = await runnable.invoke(input, patchConfig(otherOptions, { callbacks: runManager?.getChild() }));
                 await runManager?.handleChainEnd(_coerceToDict(output, "output"));
                 return output;
             }
@@ -1480,7 +1501,11 @@ export class RunnableWithFallbacks extends Runnable {
         }
         const configList = this._getOptionsList(options ?? {}, inputs.length);
         const callbackManagers = await Promise.all(configList.map((config) => CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata)));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, undefined, undefined, undefined, configList[i].runName)));
+        const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
+            const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), configList[i].runId, undefined, undefined, undefined, configList[i].runName);
+            delete configList[i].runId;
+            return handleStartRes;
+        }));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let firstError;
         for (const runnable of this.runnables()) {

package/dist/runnables/branch.cjs

@@ -140,7 +140,7 @@ class RunnableBranch extends base_js_1.Runnable {
     }
     async *_streamIterator(input, config) {
         const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), undefined, undefined, undefined, undefined, config?.runName);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), config?.runId, undefined, undefined, undefined, config?.runName);
         let finalOutput;
         let finalOutputSupported = true;
         let stream;

package/dist/runnables/branch.js

@@ -137,7 +137,7 @@ export class RunnableBranch extends Runnable {
     }
     async *_streamIterator(input, config) {
         const callbackManager_ = await getCallbackManagerForConfig(config);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, config?.runName);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config?.runId, undefined, undefined, undefined, config?.runName);
         let finalOutput;
         let finalOutputSupported = true;
         let stream;

package/dist/runnables/config.cjs

@@ -95,6 +95,7 @@ function ensureConfig(config) {
         metadata: {},
         callbacks: undefined,
         recursionLimit: 25,
+        runId: undefined,
     };
     if (loadedConfig) {
         empty = { ...empty, ...loadedConfig };
@@ -116,7 +117,7 @@ exports.ensureConfig = ensureConfig;
 /**
  * Helper function that patches runnable configs with updated properties.
  */
-function patchConfig(config = {}, { callbacks, maxConcurrency, recursionLimit, runName, configurable, } = {}) {
+function patchConfig(config = {}, { callbacks, maxConcurrency, recursionLimit, runName, configurable, runId, } = {}) {
     const newConfig = ensureConfig(config);
     if (callbacks !== undefined) {
         /**
@@ -138,6 +139,9 @@ function patchConfig(config = {}, { callbacks, maxConcurrency, recursionLimit, r
     if (configurable !== undefined) {
         newConfig.configurable = { ...newConfig.configurable, ...configurable };
     }
+    if (runId !== undefined) {
+        delete newConfig.runId;
+    }
     return newConfig;
 }
 exports.patchConfig = patchConfig;

package/dist/runnables/config.d.ts

@@ -25,4 +25,4 @@ export declare function ensureConfig<CallOptions extends RunnableConfig>(config?
 /**
  * Helper function that patches runnable configs with updated properties.
  */
-export declare function patchConfig<CallOptions extends RunnableConfig>(config?: Partial<CallOptions>, { callbacks, maxConcurrency, recursionLimit, runName, configurable, }?: RunnableConfig): Partial<CallOptions>;
+export declare function patchConfig<CallOptions extends RunnableConfig>(config?: Partial<CallOptions>, { callbacks, maxConcurrency, recursionLimit, runName, configurable, runId, }?: RunnableConfig): Partial<CallOptions>;

package/dist/runnables/config.js

@@ -90,6 +90,7 @@ export function ensureConfig(config) {
         metadata: {},
         callbacks: undefined,
         recursionLimit: 25,
+        runId: undefined,
     };
     if (loadedConfig) {
         empty = { ...empty, ...loadedConfig };
@@ -110,7 +111,7 @@ export function ensureConfig(config) {
 /**
  * Helper function that patches runnable configs with updated properties.
  */
-export function patchConfig(config = {}, { callbacks, maxConcurrency, recursionLimit, runName, configurable, } = {}) {
+export function patchConfig(config = {}, { callbacks, maxConcurrency, recursionLimit, runName, configurable, runId, } = {}) {
     const newConfig = ensureConfig(config);
     if (callbacks !== undefined) {
         /**
@@ -132,5 +133,8 @@ export function patchConfig(config = {}, { callbacks, maxConcurrency, recursionL
     if (configurable !== undefined) {
         newConfig.configurable = { ...newConfig.configurable, ...configurable };
     }
+    if (runId !== undefined) {
+        delete newConfig.runId;
+    }
     return newConfig;
 }

package/dist/tools.cjs

@@ -69,7 +69,8 @@ class StructuredTool extends base_js_1.BaseLangChain {
         }
         const config = (0, manager_js_1.parseCallbackConfigArg)(configArg);
         const callbackManager_ = await manager_js_1.CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), undefined, undefined, undefined, undefined, config.runName);
+        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), config.runId, undefined, undefined, undefined, config.runName);
+        delete config.runId;
         let result;
         try {
             result = await this._call(parsed, runManager, config);

package/dist/tools.js

@@ -65,7 +65,8 @@ export class StructuredTool extends BaseLangChain {
         }
         const config = parseCallbackConfigArg(configArg);
         const callbackManager_ = await CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), undefined, undefined, undefined, undefined, config.runName);
+        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), config.runId, undefined, undefined, undefined, config.runName);
+        delete config.runId;
         let result;
         try {
             result = await this._call(parsed, runManager, config);

package/dist/utils/testing/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyntheticEmbeddings = exports.FakeEmbeddings = exports.FakeTool = exports.FakeTracer = exports.FakeListChatMessageHistory = exports.FakeChatMessageHistory = exports.FakeListChatModel = exports.FakeRetriever = exports.FakeChatModel = exports.FakeStreamingLLM = exports.FakeLLM = exports.FakeRunnable = exports.FakeSplitIntoListParser = void 0;
+exports.SingleRunExtractor = exports.SyntheticEmbeddings = exports.FakeEmbeddings = exports.FakeTool = exports.FakeTracer = exports.FakeListChatMessageHistory = exports.FakeChatMessageHistory = exports.FakeListChatModel = exports.FakeRetriever = exports.FakeStreamingChatModel = exports.FakeChatModel = exports.FakeStreamingLLM = exports.FakeLLM = exports.FakeRunnable = exports.FakeSplitIntoListParser = void 0;
 const chat_history_js_1 = require("../../chat_history.cjs");
 const document_js_1 = require("../../documents/document.cjs");
 const chat_models_js_1 = require("../../language_models/chat_models.cjs");
@@ -172,6 +172,79 @@ class FakeChatModel extends chat_models_js_1.BaseChatModel {
     }
 }
 exports.FakeChatModel = FakeChatModel;
+class FakeStreamingChatModel extends chat_models_js_1.BaseChatModel {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "sleep", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 50
+        });
+        Object.defineProperty(this, "responses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "thrownErrorString", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.sleep = fields.sleep ?? this.sleep;
+        this.responses = fields.responses;
+        this.thrownErrorString = fields.thrownErrorString;
+    }
+    _llmType() {
+        return "fake";
+    }
+    async _generate(messages, _options, _runManager) {
+        if (this.thrownErrorString) {
+            throw new Error(this.thrownErrorString);
+        }
+        const content = this.responses?.[0].content ?? messages[0].content;
+        const generation = {
+            generations: [
+                {
+                    text: "",
+                    message: new index_js_1.AIMessage({
+                        content,
+                    }),
+                },
+            ],
+        };
+        return generation;
+    }
+    async *_streamResponseChunks(messages, _options, _runManager) {
+        if (this.thrownErrorString) {
+            throw new Error(this.thrownErrorString);
+        }
+        const content = this.responses?.[0].content ?? messages[0].content;
+        if (typeof content !== "string") {
+            for (const _ of this.responses ?? messages) {
+                yield new outputs_js_1.ChatGenerationChunk({
+                    text: "",
+                    message: new index_js_1.AIMessageChunk({
+                        content,
+                    }),
+                });
+            }
+        }
+        else {
+            for (const _ of this.responses ?? messages) {
+                yield new outputs_js_1.ChatGenerationChunk({
+                    text: content,
+                    message: new index_js_1.AIMessageChunk({
+                        content,
+                    }),
+                });
+            }
+        }
+    }
+}
+exports.FakeStreamingChatModel = FakeStreamingChatModel;
 class FakeRetriever extends index_js_2.BaseRetriever {
     constructor(fields) {
         super();
@@ -518,3 +591,37 @@ class SyntheticEmbeddings extends embeddings_js_1.Embeddings {
     }
 }
 exports.SyntheticEmbeddings = SyntheticEmbeddings;
+class SingleRunExtractor extends base_js_3.BaseTracer {
+    constructor() {
+        super();
+        Object.defineProperty(this, "runPromiseResolver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "runPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The name of the callback handler. */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "single_run_extractor"
+        });
+        this.runPromise = new Promise((extract) => {
+            this.runPromiseResolver = extract;
+        });
+    }
+    async persistRun(run) {
+        this.runPromiseResolver(run);
+    }
+    async extract() {
+        return this.runPromise;
+    }
+}
+exports.SingleRunExtractor = SingleRunExtractor;

package/dist/utils/testing/index.d.ts

@@ -58,6 +58,19 @@ export declare class FakeChatModel extends BaseChatModel {
     _llmType(): string;
     _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
 }
+export declare class FakeStreamingChatModel extends BaseChatModel {
+    sleep?: number;
+    responses?: BaseMessage[];
+    thrownErrorString?: string;
+    constructor(fields: {
+        sleep?: number;
+        responses?: BaseMessage[];
+        thrownErrorString?: string;
+    } & BaseLLMParams);
+    _llmType(): string;
+    _generate(messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    _streamResponseChunks(messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}
 export declare class FakeRetriever extends BaseRetriever {
     lc_namespace: string[];
     output: Document<Record<string, any>>[];
@@ -206,4 +219,13 @@ export declare class SyntheticEmbeddings extends Embeddings implements Synthetic
      */
     embedQuery(document: string): Promise<number[]>;
 }
+export declare class SingleRunExtractor extends BaseTracer {
+    runPromiseResolver: (run: Run) => void;
+    runPromise: Promise<Run>;
+    /** The name of the callback handler. */
+    name: string;
+    constructor();
+    persistRun(run: Run): Promise<void>;
+    extract(): Promise<Run>;
+}
 export {};

package/dist/utils/testing/index.js

@@ -164,6 +164,78 @@ export class FakeChatModel extends BaseChatModel {
         };
     }
 }
+export class FakeStreamingChatModel extends BaseChatModel {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "sleep", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 50
+        });
+        Object.defineProperty(this, "responses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "thrownErrorString", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.sleep = fields.sleep ?? this.sleep;
+        this.responses = fields.responses;
+        this.thrownErrorString = fields.thrownErrorString;
+    }
+    _llmType() {
+        return "fake";
+    }
+    async _generate(messages, _options, _runManager) {
+        if (this.thrownErrorString) {
+            throw new Error(this.thrownErrorString);
+        }
+        const content = this.responses?.[0].content ?? messages[0].content;
+        const generation = {
+            generations: [
+                {
+                    text: "",
+                    message: new AIMessage({
+                        content,
+                    }),
+                },
+            ],
+        };
+        return generation;
+    }
+    async *_streamResponseChunks(messages, _options, _runManager) {
+        if (this.thrownErrorString) {
+            throw new Error(this.thrownErrorString);
+        }
+        const content = this.responses?.[0].content ?? messages[0].content;
+        if (typeof content !== "string") {
+            for (const _ of this.responses ?? messages) {
+                yield new ChatGenerationChunk({
+                    text: "",
+                    message: new AIMessageChunk({
+                        content,
+                    }),
+                });
+            }
+        }
+        else {
+            for (const _ of this.responses ?? messages) {
+                yield new ChatGenerationChunk({
+                    text: content,
+                    message: new AIMessageChunk({
+                        content,
+                    }),
+                });
+            }
+        }
+    }
+}
 export class FakeRetriever extends BaseRetriever {
     constructor(fields) {
         super();
@@ -502,3 +574,36 @@ export class SyntheticEmbeddings extends Embeddings {
         return ret;
     }
 }
+export class SingleRunExtractor extends BaseTracer {
+    constructor() {
+        super();
+        Object.defineProperty(this, "runPromiseResolver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "runPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The name of the callback handler. */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "single_run_extractor"
+        });
+        this.runPromise = new Promise((extract) => {
+            this.runPromiseResolver = extract;
+        });
+    }
+    async persistRun(run) {
+        this.runPromiseResolver(run);
+    }
+    async extract() {
+        return this.runPromise;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.1.53",
+  "version": "0.1.55-rc.0",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {