@langchain/core 1.2.0-dev-1765937705265 → 1.2.0

package/dist/runnables/base.cjs

@@ -1,25 +1,24 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_load_serializable = require('../load/serializable.cjs');
-const require_utils = require('../tools/utils.cjs');
-const require_index = require('../singletons/async_local_storage/index.cjs');
-require('../singletons/index.cjs');
-const require_config = require('./config.cjs');
-const require_signal = require('../utils/signal.cjs');
-const require_utils_stream = require('../utils/stream.cjs');
-const require_tracers_log_stream = require('../tracers/log_stream.cjs');
-const require_event_stream = require('../tracers/event_stream.cjs');
-const require_index$1 = require('../utils/p-retry/index.cjs');
-const require_utils_async_caller = require('../utils/async_caller.cjs');
-const require_root_listener = require('../tracers/root_listener.cjs');
-const require_utils$1 = require('./utils.cjs');
-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"));
-
+require("../_virtual/_rolldown/runtime.cjs");
+const require_utils = require("../tools/utils.cjs");
+const require_load_serializable = require("../load/serializable.cjs");
+const require_utils_uuid_index = require("../utils/uuid/index.cjs");
+const require_index = require("../singletons/async_local_storage/index.cjs");
+require("../singletons/index.cjs");
+const require_config = require("./config.cjs");
+const require_signal = require("../utils/signal.cjs");
+const require_utils_stream = require("../utils/stream.cjs");
+const require_tracers_log_stream = require("../tracers/log_stream.cjs");
+const require_event_stream = require("../tracers/event_stream.cjs");
+const require_index$1 = require("../utils/p-retry/index.cjs");
+const require_utils_async_caller = require("../utils/async_caller.cjs");
+const require_root_listener = require("../tracers/root_listener.cjs");
+const require_utils$1 = require("./utils.cjs");
+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");
+let langsmith_singletons_traceable = require("langsmith/singletons/traceable");
+let zod_v3 = require("zod/v3");
 //#region src/runnables/base.ts
 function _coerceToDict(value, defaultKey) {
 	return value && !Array.isArray(value) && !(value instanceof Date) && typeof value === "object" ? value : { [defaultKey]: value };
@@ -87,17 +86,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 +156,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), config.signal);
 		} catch (e) {
 			await runManager?.handleChainError(e);
 			throw e;
@@ -192,8 +187,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;
@@ -232,7 +226,7 @@ var Runnable = class extends require_load_serializable.Serializable {
 		}
 		let runManager;
 		try {
-			const pipe = await require_utils_stream.pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, void 0, void 0, config.runName ?? this.getName()), options?.signal, config);
+			const pipe = await require_utils_stream.pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, void 0, void 0, config.runName ?? this.getName(), void 0, { lc_defers_inputs: true }), config.signal, config);
 			delete config.runId;
 			runManager = pipe.setup;
 			const streamEventsHandler = runManager?.handlers.find(require_event_stream.isStreamEventsHandler);
@@ -315,6 +309,9 @@ var Runnable = class extends require_load_serializable.Serializable {
 	* jsonpatch ops that describe how the state of the run has changed in each
 	* step, and the final state of the run.
 	* The jsonpatch ops can be applied in order to construct state.
+	*
+	* @deprecated Use `.stream()` instead.
+	*
 	* @param input
 	* @param options
 	* @param streamOptions
@@ -374,7 +371,7 @@ var Runnable = class extends require_load_serializable.Serializable {
 			autoClose: false
 		});
 		const config = require_config.ensureConfig(options);
-		const runId = config.runId ?? (0, uuid.v4)();
+		const runId = config.runId ?? require_utils_uuid_index.v7();
 		config.runId = runId;
 		const callbacks = config.callbacks;
 		if (callbacks === void 0) config.callbacks = [eventStreamer];
@@ -388,15 +385,13 @@ var Runnable = class extends require_load_serializable.Serializable {
 		const outerThis = this;
 		async function consumeRunnableStream() {
 			let signal;
-			let listener = null;
 			try {
-				if (options?.signal) if ("any" in AbortSignal) signal = AbortSignal.any([abortController.signal, options.signal]);
+				if (config.signal) if ("any" in AbortSignal) signal = AbortSignal.any([abortController.signal, config.signal]);
 				else {
-					signal = options.signal;
-					listener = () => {
-						abortController.abort();
-					};
-					options.signal.addEventListener("abort", listener, { once: true });
+					const composed = new AbortController();
+					config.signal.addEventListener("abort", () => composed.abort(), { once: true });
+					abortController.signal.addEventListener("abort", () => composed.abort(), { once: true });
+					signal = composed.signal;
 				}
 				else signal = abortController.signal;
 				const runnableStream = await outerThis.stream(input, {
@@ -407,7 +402,6 @@ var Runnable = class extends require_load_serializable.Serializable {
 				for await (const _ of tappedStream) if (abortController.signal.aborted) break;
 			} finally {
 				await eventStreamer.finish();
-				if (signal && listener) signal.removeEventListener("abort", listener);
 			}
 		}
 		const runnableStreamConsumePromise = consumeRunnableStream();
@@ -452,16 +446,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 +486,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 +830,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 +852,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,19 +926,14 @@ 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);
-			}
-			if (options?.signal?.aborted) throw require_signal.getAbortSignalError(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}`) })), config.signal);
+			if (config.signal?.aborted) throw require_signal.getAbortSignalError(config.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) {
 			await runManager?.handleChainError(e);
@@ -963,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 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 +969,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 +983,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,15 +1085,14 @@ 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 {
 			const promises = Object.entries(this.steps).map(async ([key, runnable]) => {
 				output[key] = await runnable.invoke(input, require_config.patchConfig(config, { callbacks: runManager?.getChild(`map:key:${key}`) }));
 			});
-			await require_signal.raceWithSignal(Promise.all(promises), options?.signal);
+			await require_signal.raceWithSignal(Promise.all(promises), config.signal);
 		} catch (e) {
 			await runManager?.handleChainError(e);
 			throw e;
@@ -1131,15 +1112,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 +1155,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);
@@ -1251,7 +1230,7 @@ var RunnableLambda = class RunnableLambda extends Runnable {
 		return new Promise((resolve, reject) => {
 			const childConfig = require_config.patchConfig(config, {
 				callbacks: runManager?.getChild(),
-				recursionLimit: (config?.recursionLimit ?? require_config.DEFAULT_RECURSION_LIMIT) - 1
+				recursionLimit: (config?.recursionLimit ?? 25) - 1
 			});
 			require_index.AsyncLocalStorageProviderSingleton.runWithConfig(require_config.pickRunnableConfigKeys(childConfig), async () => {
 				try {
@@ -1260,7 +1239,7 @@ var RunnableLambda = class RunnableLambda extends Runnable {
 						if (config?.recursionLimit === 0) throw new Error("Recursion limit reached.");
 						output = await output.invoke(input, {
 							...childConfig,
-							recursionLimit: (childConfig.recursionLimit ?? require_config.DEFAULT_RECURSION_LIMIT) - 1
+							recursionLimit: (childConfig.recursionLimit ?? 25) - 1
 						});
 					} else if (require_iter.isAsyncIterable(output)) {
 						let finalOutput;
@@ -1307,16 +1286,15 @@ var RunnableLambda = class RunnableLambda extends Runnable {
 		}
 		const childConfig = require_config.patchConfig(config, {
 			callbacks: runManager?.getChild(),
-			recursionLimit: (config?.recursionLimit ?? require_config.DEFAULT_RECURSION_LIMIT) - 1
+			recursionLimit: (config?.recursionLimit ?? 25) - 1
 		});
 		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 +1452,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 +1471,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 +1483,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;
@@ -1771,7 +1747,6 @@ function convertRunnableToTool(runnable, fields) {
 		bound: runnable
 	});
 }
-
 //#endregion
 exports.Runnable = Runnable;
 exports.RunnableAssign = RunnableAssign;
@@ -1787,4 +1762,5 @@ exports.RunnableToolLike = RunnableToolLike;
 exports.RunnableWithFallbacks = RunnableWithFallbacks;
 exports._coerceToDict = _coerceToDict;
 exports._coerceToRunnable = _coerceToRunnable;
+
 //# sourceMappingURL=base.cjs.map