@langchain/core 1.1.24 → 1.1.25

package/dist/runnables/base.cjs

@@ -1,6 +1,6 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_load_serializable = require('../load/serializable.cjs');
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_utils = require('../tools/utils.cjs');
+const require_load_serializable = require('../load/serializable.cjs');
 const require_index = require('../singletons/async_local_storage/index.cjs');
 require('../singletons/index.cjs');
 const require_config = require('./config.cjs');
@@ -16,9 +16,9 @@ const require_zod = require('../utils/types/zod.cjs');
 const require_runnables_graph = require('./graph.cjs');
 const require_wrappers = require('./wrappers.cjs');
 const require_iter = require('./iter.cjs');
-const zod_v3 = require_rolldown_runtime.__toESM(require("zod/v3"));
-const uuid = require_rolldown_runtime.__toESM(require("uuid"));
-const langsmith_singletons_traceable = require_rolldown_runtime.__toESM(require("langsmith/singletons/traceable"));
+let uuid = require("uuid");
+let langsmith_singletons_traceable = require("langsmith/singletons/traceable");
+let zod_v3 = require("zod/v3");
 
 //#region src/runnables/base.ts
 function _coerceToDict(value, defaultKey) {
@@ -87,17 +87,15 @@ var Runnable = class extends require_load_serializable.Serializable {
 	}
 	async batch(inputs, options, batchOptions) {
 		const configList = this._getOptionsList(options ?? {}, inputs.length);
-		const maxConcurrency = configList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;
 		const caller = new require_utils_async_caller.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;
@@ -159,13 +157,11 @@ var Runnable = class extends require_load_serializable.Serializable {
 	}
 	async _callWithConfig(func, input, options) {
 		const config = require_config.ensureConfig(options);
-		const callbackManager_ = await require_config.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 require_config.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 require_signal.raceWithSignal(promise, options?.signal);
+			output = await require_signal.raceWithSignal(func.call(this, input, config, runManager), options?.signal);
 		} catch (e) {
 			await runManager?.handleChainError(e);
 			throw e;
@@ -192,8 +188,7 @@ var Runnable = class extends require_load_serializable.Serializable {
 		}));
 		let outputs;
 		try {
-			const promise = func.call(this, inputs, optionsList, runManagers, batchOptions);
-			outputs = await require_signal.raceWithSignal(promise, optionsList?.[0]?.signal);
+			outputs = await require_signal.raceWithSignal(func.call(this, inputs, optionsList, runManagers, batchOptions), optionsList?.[0]?.signal);
 		} catch (e) {
 			await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
 			throw e;
@@ -452,16 +447,16 @@ var Runnable = class extends require_load_serializable.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)];
@@ -492,21 +487,21 @@ var Runnable = class extends require_load_serializable.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;
@@ -836,7 +831,7 @@ var RunnableRetry = class extends RunnableBinding {
 		return require_config.patchConfig(config, { callbacks: runManager?.getChild(tag) });
 	}
 	async _invoke(input, config, runManager) {
-		return require_index$1.pRetry((attemptNumber) => super.invoke(input, this._patchConfigForRetry(attemptNumber, config, runManager)), {
+		return require_index$1.default((attemptNumber) => super.invoke(input, this._patchConfigForRetry(attemptNumber, config, runManager)), {
 			onFailedAttempt: ({ error }) => this.onFailedAttempt(error, input),
 			retries: Math.max(this.maxAttemptNumber - 1, 0),
 			randomize: true
@@ -858,7 +853,7 @@ var RunnableRetry = class extends RunnableBinding {
 	async _batch(inputs, configs, runManagers, batchOptions) {
 		const resultsMap = {};
 		try {
-			await require_index$1.pRetry(async (attemptNumber) => {
+			await require_index$1.default(async (attemptNumber) => {
 				const remainingIndexes = inputs.map((_, i) => i).filter((i) => resultsMap[i.toString()] === void 0 || resultsMap[i.toString()] instanceof Error);
 				const remainingInputs = remainingIndexes.map((i) => inputs[i]);
 				const patchedConfigs = remainingIndexes.map((i) => this._patchConfigForRetry(attemptNumber, configs?.[i], runManagers?.[i]));
@@ -932,18 +927,13 @@ var RunnableSequence = class RunnableSequence extends Runnable {
 	}
 	async invoke(input, options) {
 		const config = require_config.ensureConfig(options);
-		const callbackManager_ = await require_config.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 require_config.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, require_config.patchConfig(config, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`) }));
-				nextStepInput = await require_signal.raceWithSignal(promise, options?.signal);
-			}
+			for (let i = 0; i < initialSteps.length; i += 1) nextStepInput = await require_signal.raceWithSignal(initialSteps[i].invoke(nextStepInput, require_config.patchConfig(config, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`) })), options?.signal);
 			if (options?.signal?.aborted) throw require_signal.getAbortSignalError(options.signal);
 			finalOutput = await this.last.invoke(nextStepInput, require_config.patchConfig(config, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${this.steps.length}`) }));
 		} catch (e) {
@@ -963,14 +953,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 require_config.patchConfig(configList[j], { callbacks: childRunManager });
-				}), batchOptions);
-				nextStepInputs = await require_signal.raceWithSignal(promise, configList[0]?.signal);
-			}
+			for (let i = 0; i < this.steps.length; i += 1) nextStepInputs = await require_signal.raceWithSignal(this.steps[i].batch(nextStepInputs, runManagers.map((runManager, j) => {
+				const childRunManager = runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`);
+				return require_config.patchConfig(configList[j], { callbacks: childRunManager });
+			}), batchOptions), configList[0]?.signal);
 		} catch (e) {
 			await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
 			throw e;
@@ -984,7 +970,7 @@ var RunnableSequence = class RunnableSequence extends Runnable {
 	}
 	async *_streamIterator(input, options) {
 		const callbackManager_ = await require_config.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,
@@ -998,10 +984,7 @@ var RunnableSequence = class RunnableSequence extends Runnable {
 		}
 		try {
 			let finalGenerator = steps[0].transform(inputGenerator(), require_config.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, require_config.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, require_config.patchConfig(otherOptions, { callbacks: runManager?.getChild(this.omitSequenceTags ? void 0 : `seq:step:${i + 1}`) }));
 			for await (const chunk of finalGenerator) {
 				options?.signal?.throwIfAborted();
 				yield chunk;
@@ -1103,8 +1086,7 @@ var RunnableMap = class RunnableMap extends Runnable {
 	}
 	async invoke(input, options) {
 		const config = require_config.ensureConfig(options);
-		const callbackManager_ = await require_config.getCallbackManagerForConfig(config);
-		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), { input }, config.runId, void 0, void 0, void 0, config?.runName);
+		const runManager = await (await require_config.getCallbackManagerForConfig(config))?.handleChainStart(this.toJSON(), { input }, config.runId, void 0, void 0, void 0, config?.runName);
 		delete config.runId;
 		const output = {};
 		try {
@@ -1131,15 +1113,14 @@ var RunnableMap = class RunnableMap extends Runnable {
 			}))];
 		}));
 		while (tasks.size) {
-			const promise = Promise.race(tasks.values());
-			const { key, result, gen } = await require_signal.raceWithSignal(promise, options?.signal);
+			const { key, result, gen } = await require_signal.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
 				})));
 			}
 		}
@@ -1175,8 +1156,7 @@ var RunnableTraceable = class RunnableTraceable extends Runnable {
 	async invoke(input, options) {
 		const [config] = this._getOptionsList(options ?? {}, 1);
 		const callbacks = await require_config.getCallbackManagerForConfig(config);
-		const promise = this.func(require_config.patchConfig(config, { callbacks }), input);
-		return require_signal.raceWithSignal(promise, config?.signal);
+		return require_signal.raceWithSignal(this.func(require_config.patchConfig(config, { callbacks }), input), config?.signal);
 	}
 	async *_streamIterator(input, options) {
 		const [config] = this._getOptionsList(options ?? {}, 1);
@@ -1312,11 +1292,10 @@ var RunnableLambda = class RunnableLambda extends Runnable {
 		const output = await new Promise((resolve, reject) => {
 			require_index.AsyncLocalStorageProviderSingleton.runWithConfig(require_config.pickRunnableConfigKeys(childConfig), async () => {
 				try {
-					const res = await this.func(finalChunk, {
+					resolve(await this.func(finalChunk, {
 						...childConfig,
 						config: childConfig
-					});
-					resolve(res);
+					}));
 				} catch (e) {
 					reject(e);
 				}
@@ -1474,10 +1453,10 @@ var RunnableWithFallbacks = class extends Runnable {
 	async invoke(input, options) {
 		const config = require_config.ensureConfig(options);
 		const callbackManager_ = await require_config.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 = require_config.patchConfig(otherConfigFields, { callbacks: runManager?.getChild() });
-		const res = await require_index.AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
+		return await require_index.AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
 			let firstError;
 			for (const runnable of this.runnables()) {
 				config?.signal?.throwIfAborted();
@@ -1493,12 +1472,11 @@ var RunnableWithFallbacks = class extends Runnable {
 			await runManager?.handleChainError(firstError);
 			throw firstError;
 		});
-		return res;
 	}
 	async *_streamIterator(input, options) {
 		const config = require_config.ensureConfig(options);
 		const callbackManager_ = await require_config.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;
@@ -1506,8 +1484,7 @@ var RunnableWithFallbacks = class extends Runnable {
 			config?.signal?.throwIfAborted();
 			const childConfig = require_config.patchConfig(otherConfigFields, { callbacks: runManager?.getChild() });
 			try {
-				const originalStream = await runnable.stream(input, childConfig);
-				stream = require_iter.consumeAsyncIterableInContext(childConfig, originalStream);
+				stream = require_iter.consumeAsyncIterableInContext(childConfig, await runnable.stream(input, childConfig));
 				break;
 			} catch (e) {
 				if (firstError === void 0) firstError = e;