@langchain/core 1.1.24 → 1.1.25

package/dist/runnables/base.js

@@ -1,5 +1,5 @@
-import { Serializable } from "../load/serializable.js";
 import { ToolInputParsingException, _isToolCall } from "../tools/utils.js";
+import { Serializable } from "../load/serializable.js";
 import { AsyncLocalStorageProviderSingleton } from "../singletons/async_local_storage/index.js";
 import "../singletons/index.js";
 import { DEFAULT_RECURSION_LIMIT, ensureConfig, getCallbackManagerForConfig, mergeConfigs, patchConfig, pickRunnableConfigKeys } from "./config.js";
@@ -7,7 +7,7 @@ import { getAbortSignalError, raceWithSignal } from "../utils/signal.js";
 import { AsyncGeneratorWithSetup, IterableReadableStream, atee, concat, pipeGeneratorWithSetup } from "../utils/stream.js";
 import { LogStreamCallbackHandler, RunLog, RunLogPatch, isLogStreamHandler } from "../tracers/log_stream.js";
 import { EventStreamCallbackHandler, isStreamEventsHandler } from "../tracers/event_stream.js";
-import { pRetry } from "../utils/p-retry/index.js";
+import pRetry from "../utils/p-retry/index.js";
 import { AsyncCaller } from "../utils/async_caller.js";
 import { RootListenersTracer } from "../tracers/root_listener.js";
 import { _RootEventFilter, isRunnableInterface } from "./utils.js";
@@ -15,9 +15,9 @@ import { getSchemaDescription, interopParseAsync, isSimpleStringZodSchema } from
 import { Graph } from "./graph.js";
 import { convertToHttpEventStream } from "./wrappers.js";
 import { consumeAsyncIterableInContext, consumeIteratorInContext, isAsyncIterable, isIterableIterator, isIterator } from "./iter.js";
-import { z } from "zod/v3";
 import { v4 } from "uuid";
 import { isTraceableFunction } from "langsmith/singletons/traceable";
+import { z } from "zod/v3";
 
 //#region src/runnables/base.ts
 function _coerceToDict(value, defaultKey) {
@@ -86,17 +86,15 @@ var Runnable = class extends Serializable {
 	}
 	async batch(inputs, options, batchOptions) {
 		const configList = this._getOptionsList(options ?? {}, inputs.length);
-		const maxConcurrency = configList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;
 		const caller = new AsyncCaller({
-			maxConcurrency,
+			maxConcurrency: configList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency,
 			onFailedAttempt: (e) => {
 				throw e;
 			}
 		});
 		const batchCalls = inputs.map((input, i) => caller.call(async () => {
 			try {
-				const result = await this.invoke(input, configList[i]);
-				return result;
+				return await this.invoke(input, configList[i]);
 			} catch (e) {
 				if (batchOptions?.returnExceptions) return e;
 				throw e;
@@ -158,13 +156,11 @@ var Runnable = class extends Serializable {
 	}
 	async _callWithConfig(func, input, options) {
 		const config = ensureConfig(options);
-		const callbackManager_ = await getCallbackManagerForConfig(config);
-		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, config?.runType, void 0, void 0, config?.runName ?? this.getName());
+		const runManager = await (await getCallbackManagerForConfig(config))?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, config?.runType, void 0, void 0, config?.runName ?? this.getName());
 		delete config.runId;
 		let output;
 		try {
-			const promise = func.call(this, input, config, runManager);
-			output = await raceWithSignal(promise, options?.signal);
+			output = await raceWithSignal(func.call(this, input, config, runManager), options?.signal);
 		} catch (e) {
 			await runManager?.handleChainError(e);
 			throw e;
@@ -191,8 +187,7 @@ var Runnable = class extends Serializable {
 		}));
 		let outputs;
 		try {
-			const promise = func.call(this, inputs, optionsList, runManagers, batchOptions);
-			outputs = await raceWithSignal(promise, optionsList?.[0]?.signal);
+			outputs = await raceWithSignal(func.call(this, inputs, optionsList, runManagers, batchOptions), optionsList?.[0]?.signal);
 		} catch (e) {
 			await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
 			throw e;
@@ -451,16 +446,16 @@ var Runnable = class extends Serializable {
 			if (runLog.state === void 0) throw new Error(`Internal error: "streamEvents" state is missing. Please open a bug report.`);
 			if (!hasEncounteredStartEvent) {
 				hasEncounteredStartEvent = true;
-				const state$2 = { ...runLog.state };
+				const state = { ...runLog.state };
 				const event = {
-					run_id: state$2.id,
-					event: `on_${state$2.type}_start`,
+					run_id: state.id,
+					event: `on_${state.type}_start`,
 					name: rootName,
 					tags: rootTags,
 					metadata: rootMetadata,
 					data: { input }
 				};
-				if (rootEventFilter.includeEvent(event, state$2.type)) yield event;
+				if (rootEventFilter.includeEvent(event, state.type)) yield event;
 			}
 			const paths = log.ops.filter((op) => op.path.startsWith("/logs/")).map((op) => op.path.split("/")[2]);
 			const dedupedPaths = [...new Set(paths)];
@@ -491,21 +486,21 @@ var Runnable = class extends Serializable {
 					data
 				};
 			}
-			const { state: state$1 } = runLog;
-			if (state$1.streamed_output.length > 0) {
-				const chunkCount = state$1.streamed_output.length;
-				if (chunkCount !== 1) throw new Error(`Expected exactly one chunk of streamed output, got ${chunkCount} instead. Encountered in: "${state$1.name}"`);
-				const data = { chunk: state$1.streamed_output[0] };
-				state$1.streamed_output = [];
+			const { state } = runLog;
+			if (state.streamed_output.length > 0) {
+				const chunkCount = state.streamed_output.length;
+				if (chunkCount !== 1) throw new Error(`Expected exactly one chunk of streamed output, got ${chunkCount} instead. Encountered in: "${state.name}"`);
+				const data = { chunk: state.streamed_output[0] };
+				state.streamed_output = [];
 				const event = {
-					event: `on_${state$1.type}_stream`,
-					run_id: state$1.id,
+					event: `on_${state.type}_stream`,
+					run_id: state.id,
 					tags: rootTags,
 					metadata: rootMetadata,
 					name: rootName,
 					data
 				};
-				if (rootEventFilter.includeEvent(event, state$1.type)) yield event;
+				if (rootEventFilter.includeEvent(event, state.type)) yield event;
 			}
 		}
 		const state = runLog?.state;
@@ -931,18 +926,13 @@ var RunnableSequence = 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"), config.runId, void 0, void 0, void 0, config?.runName);
+		const runManager = await (await getCallbackManagerForConfig(config))?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, void 0, void 0, void 0, config?.runName);
 		delete config.runId;
 		let nextStepInput = input;
 		let finalOutput;
 		try {
 			const initialSteps = [this.first, ...this.middle];
-			for (let i = 0; i < initialSteps.length; i += 1) {
-				const step = initialSteps[i];
-				const promise = step.invoke(nextStepInput, patchConfig(config, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`) }));
-				nextStepInput = await raceWithSignal(promise, options?.signal);
-			}
+			for (let i = 0; i < initialSteps.length; i += 1) nextStepInput = await raceWithSignal(initialSteps[i].invoke(nextStepInput, patchConfig(config, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`) })), options?.signal);
 			if (options?.signal?.aborted) throw getAbortSignalError(options.signal);
 			finalOutput = await this.last.invoke(nextStepInput, patchConfig(config, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${this.steps.length}`) }));
 		} catch (e) {
@@ -962,14 +952,10 @@ var RunnableSequence = class RunnableSequence extends Runnable {
 		}));
 		let nextStepInputs = inputs;
 		try {
-			for (let i = 0; i < this.steps.length; i += 1) {
-				const step = this.steps[i];
-				const promise = step.batch(nextStepInputs, runManagers.map((runManager, j) => {
-					const childRunManager = runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`);
-					return patchConfig(configList[j], { callbacks: childRunManager });
-				}), batchOptions);
-				nextStepInputs = await raceWithSignal(promise, configList[0]?.signal);
-			}
+			for (let i = 0; i < this.steps.length; i += 1) nextStepInputs = await raceWithSignal(this.steps[i].batch(nextStepInputs, runManagers.map((runManager, j) => {
+				const childRunManager = runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`);
+				return patchConfig(configList[j], { callbacks: childRunManager });
+			}), batchOptions), configList[0]?.signal);
 		} catch (e) {
 			await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
 			throw e;
@@ -983,7 +969,7 @@ var RunnableSequence = class RunnableSequence extends Runnable {
 	}
 	async *_streamIterator(input, options) {
 		const callbackManager_ = await getCallbackManagerForConfig(options);
-		const { runId,...otherOptions } = options ?? {};
+		const { runId, ...otherOptions } = options ?? {};
 		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, void 0, void 0, void 0, otherOptions?.runName);
 		const steps = [
 			this.first,
@@ -997,10 +983,7 @@ var RunnableSequence = class RunnableSequence extends Runnable {
 		}
 		try {
 			let finalGenerator = steps[0].transform(inputGenerator(), patchConfig(otherOptions, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:1`) }));
-			for (let i = 1; i < steps.length; i += 1) {
-				const step = steps[i];
-				finalGenerator = await step.transform(finalGenerator, patchConfig(otherOptions, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`) }));
-			}
+			for (let i = 1; i < steps.length; i += 1) finalGenerator = await steps[i].transform(finalGenerator, patchConfig(otherOptions, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`) }));
 			for await (const chunk of finalGenerator) {
 				options?.signal?.throwIfAborted();
 				yield chunk;
@@ -1102,8 +1085,7 @@ var RunnableMap = class RunnableMap extends Runnable {
 	}
 	async invoke(input, options) {
 		const config = ensureConfig(options);
-		const callbackManager_ = await getCallbackManagerForConfig(config);
-		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), { input }, config.runId, void 0, void 0, void 0, config?.runName);
+		const runManager = await (await getCallbackManagerForConfig(config))?.handleChainStart(this.toJSON(), { input }, config.runId, void 0, void 0, void 0, config?.runName);
 		delete config.runId;
 		const output = {};
 		try {
@@ -1130,15 +1112,14 @@ var RunnableMap = class RunnableMap extends Runnable {
 			}))];
 		}));
 		while (tasks.size) {
-			const promise = Promise.race(tasks.values());
-			const { key, result, gen } = await raceWithSignal(promise, options?.signal);
+			const { key, result, gen } = await raceWithSignal(Promise.race(tasks.values()), options?.signal);
 			tasks.delete(key);
 			if (!result.done) {
 				yield { [key]: result.value };
-				tasks.set(key, gen.next().then((result$1) => ({
+				tasks.set(key, gen.next().then((result) => ({
 					key,
 					gen,
-					result: result$1
+					result
 				})));
 			}
 		}
@@ -1174,8 +1155,7 @@ var RunnableTraceable = class RunnableTraceable extends Runnable {
 	async invoke(input, options) {
 		const [config] = this._getOptionsList(options ?? {}, 1);
 		const callbacks = await getCallbackManagerForConfig(config);
-		const promise = this.func(patchConfig(config, { callbacks }), input);
-		return raceWithSignal(promise, config?.signal);
+		return raceWithSignal(this.func(patchConfig(config, { callbacks }), input), config?.signal);
 	}
 	async *_streamIterator(input, options) {
 		const [config] = this._getOptionsList(options ?? {}, 1);
@@ -1311,11 +1291,10 @@ var RunnableLambda = class RunnableLambda extends Runnable {
 		const output = await new Promise((resolve, reject) => {
 			AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(childConfig), async () => {
 				try {
-					const res = await this.func(finalChunk, {
+					resolve(await this.func(finalChunk, {
 						...childConfig,
 						config: childConfig
-					});
-					resolve(res);
+					}));
 				} catch (e) {
 					reject(e);
 				}
@@ -1473,10 +1452,10 @@ var RunnableWithFallbacks = class extends Runnable {
 	async invoke(input, options) {
 		const config = ensureConfig(options);
 		const callbackManager_ = await getCallbackManagerForConfig(config);
-		const { runId,...otherConfigFields } = config;
+		const { runId, ...otherConfigFields } = config;
 		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, void 0, void 0, void 0, otherConfigFields?.runName);
 		const childConfig = patchConfig(otherConfigFields, { callbacks: runManager?.getChild() });
-		const res = await AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
+		return await AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
 			let firstError;
 			for (const runnable of this.runnables()) {
 				config?.signal?.throwIfAborted();
@@ -1492,12 +1471,11 @@ var RunnableWithFallbacks = class extends Runnable {
 			await runManager?.handleChainError(firstError);
 			throw firstError;
 		});
-		return res;
 	}
 	async *_streamIterator(input, options) {
 		const config = ensureConfig(options);
 		const callbackManager_ = await getCallbackManagerForConfig(config);
-		const { runId,...otherConfigFields } = config;
+		const { runId, ...otherConfigFields } = config;
 		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, void 0, void 0, void 0, otherConfigFields?.runName);
 		let firstError;
 		let stream;
@@ -1505,8 +1483,7 @@ var RunnableWithFallbacks = class extends Runnable {
 			config?.signal?.throwIfAborted();
 			const childConfig = patchConfig(otherConfigFields, { callbacks: runManager?.getChild() });
 			try {
-				const originalStream = await runnable.stream(input, childConfig);
-				stream = consumeAsyncIterableInContext(childConfig, originalStream);
+				stream = consumeAsyncIterableInContext(childConfig, await runnable.stream(input, childConfig));
 				break;
 			} catch (e) {
 				if (firstError === void 0) firstError = e;