ai 7.0.139 → 7.0.141

package/dist/index.js

@@ -1174,7 +1174,7 @@ function cloneValue(value) {
 }
 //#endregion
 //#region src/version.ts
-const VERSION = "7.0.139";
+const VERSION = "7.0.141";
 //#endregion
 //#region src/util/download/download.ts
 /**
@@ -2722,9 +2722,14 @@ function collectToolApprovals({ messages }) {
 		deniedToolApprovals: []
 	};
 	const toolCallsByToolCallId = Object.create(null);
+	const toolCallOrder = Object.create(null);
+	let nextToolCallIndex = 0;
 	for (const message of messages) if (message.role === "assistant" && typeof message.content !== "string") {
 		const content = message.content;
-		for (const part of content) if (part.type === "tool-call") toolCallsByToolCallId[part.toolCallId] = part;
+		for (const part of content) if (part.type === "tool-call") {
+			toolCallsByToolCallId[part.toolCallId] = part;
+			toolCallOrder[part.toolCallId] = nextToolCallIndex++;
+		}
 	}
 	const toolApprovalRequestsByApprovalId = Object.create(null);
 	for (const message of messages) if (message.role === "assistant" && typeof message.content !== "string") {
@@ -2755,6 +2760,7 @@ function collectToolApprovals({ messages }) {
 		if (approvalResponse.approved) approvedToolApprovals.push(approval);
 		else deniedToolApprovals.push(approval);
 	}
+	approvedToolApprovals.sort((a, b) => toolCallOrder[a.toolCall.toolCallId] - toolCallOrder[b.toolCall.toolCallId]);
 	return {
 		approvedToolApprovals,
 		deniedToolApprovals
@@ -5212,6 +5218,52 @@ async function validateApprovedToolApprovals({ approvedToolApprovals, tools, too
 	};
 }
 //#endregion
+//#region src/generate-text/tool-call-concurrency.ts
+/**
+* Validates the maximum number of tool calls that may execute concurrently.
+*/
+function prepareToolCallConcurrency(toolCallConcurrency) {
+	if (toolCallConcurrency == null) return;
+	if (!Number.isInteger(toolCallConcurrency)) throw new InvalidArgumentError({
+		parameter: "toolCallConcurrency",
+		value: toolCallConcurrency,
+		message: "toolCallConcurrency must be an integer"
+	});
+	if (toolCallConcurrency < 1) throw new InvalidArgumentError({
+		parameter: "toolCallConcurrency",
+		value: toolCallConcurrency,
+		message: "toolCallConcurrency must be >= 1"
+	});
+	return toolCallConcurrency;
+}
+/**
+* Maps items with an optional concurrency limit while preserving result order.
+*
+* Workers claim items in input order. When the signal is aborted or an
+* execution rejects, no additional queued items are started.
+*/
+async function mapWithConcurrency({ items, concurrency, abortSignal, execute }) {
+	if (concurrency == null || concurrency >= items.length) return Promise.all(items.map(execute));
+	const results = new Array(items.length);
+	let nextIndex = 0;
+	let stopped = false;
+	const worker = async () => {
+		while (!stopped) {
+			abortSignal?.throwIfAborted();
+			const index = nextIndex++;
+			if (index >= items.length) return;
+			try {
+				results[index] = await execute(items[index], index);
+			} catch (error) {
+				stopped = true;
+				throw error;
+			}
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker));
+	return results;
+}
+//#endregion
 //#region src/generate-text/generate-text.ts
 const originalGenerateId$4 = createIdGenerator$1({
 	prefix: "aitxt",
@@ -5231,6 +5283,7 @@ const originalGenerateCallId$9 = createIdGenerator$1({
 * @param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
 * @param toolChoice - The tool choice strategy. Default: 'auto'.
 * @param toolOrder - Controls the order in which tools are sent to the provider. Tools not listed are appended alphabetically.
+* @param toolCallConcurrency - Maximum number of tool calls that may execute concurrently within a step. Set to 1 for sequential execution. Default: unlimited.
 *
 * @param system - A system message that will be part of the prompt.
 * @param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
@@ -5288,12 +5341,13 @@ const originalGenerateCallId$9 = createIdGenerator$1({
 * @returns
 * A result object that contains the generated text, the results of the tool calls, and additional information.
 */
-async function generateText({ model: modelArg, tools, toolChoice, instructions, system, prompt, messages, allowSystemInMessages, maxRetries: maxRetriesArg, abortSignal, timeout, headers, stopWhen = isStepCount(1), experimental_sandbox: sandbox, output, toolApproval, experimental_toolCallers, experimental_toolApprovalSecret, experimental_telemetry, telemetry = experimental_telemetry, providerOptions, activeTools, toolOrder, prepareStep, experimental_repairToolCall, repairToolCall = experimental_repairToolCall, experimental_refineToolInput: refineToolInput, experimental_download: download, runtimeContext = {}, toolsContext = {}, experimental_include, include = experimental_include, _internal: { generateId = originalGenerateId$4, generateCallId = originalGenerateCallId$9, now: now$4 = now } = {}, onStart, experimental_onStart, onStepStart, experimental_onStepStart, onLanguageModelCallStart, experimental_onLanguageModelCallStart, onLanguageModelCallEnd, experimental_onLanguageModelCallEnd, onToolExecutionStart, onToolExecutionEnd, experimental_onToolCallStart, experimental_onToolCallFinish, onStepEnd, onStepFinish, onFinish, onEnd = onFinish, ...settings }) {
+async function generateText({ model: modelArg, tools, toolChoice, instructions, system, prompt, messages, allowSystemInMessages, maxRetries: maxRetriesArg, abortSignal, timeout, headers, stopWhen = isStepCount(1), experimental_sandbox: sandbox, output, toolApproval, experimental_toolCallers, experimental_toolApprovalSecret, experimental_telemetry, telemetry = experimental_telemetry, providerOptions, activeTools, toolOrder, toolCallConcurrency, prepareStep, experimental_repairToolCall, repairToolCall = experimental_repairToolCall, experimental_refineToolInput: refineToolInput, experimental_download: download, runtimeContext = {}, toolsContext = {}, experimental_include, include = experimental_include, _internal: { generateId = originalGenerateId$4, generateCallId = originalGenerateCallId$9, now: now$4 = now } = {}, onStart, experimental_onStart, onStepStart, experimental_onStepStart, onLanguageModelCallStart, experimental_onLanguageModelCallStart, onLanguageModelCallEnd, experimental_onLanguageModelCallEnd, onToolExecutionStart, onToolExecutionEnd, experimental_onToolCallStart, experimental_onToolCallFinish, onStepEnd, onStepFinish, onFinish, onEnd = onFinish, ...settings }) {
 	include = {
 		requestBody: include?.requestBody ?? false,
 		requestMessages: include?.requestMessages ?? false,
 		responseBody: include?.responseBody ?? false
 	};
+	const resolvedToolCallConcurrency = prepareToolCallConcurrency(toolCallConcurrency);
 	const model = resolveLanguageModel(modelArg);
 	const resolvedToolCallers = resolveToolCallerConfiguration({
 		tools,
@@ -5418,7 +5472,8 @@ async function generateText({ model: modelArg, tools, toolChoice, instructions,
 						callbacks: [resolvedOnToolExecutionEnd, telemetryDispatcher.onToolExecutionEnd]
 					}),
 					executeToolInTelemetryContext: telemetryDispatcher.executeTool,
-					runInTracingChannelSpan
+					runInTracingChannelSpan,
+					toolCallConcurrency: resolvedToolCallConcurrency
 				});
 				const toolContent = [];
 				for (const result of toolResults) {
@@ -5796,7 +5851,8 @@ async function generateText({ model: modelArg, tools, toolChoice, instructions,
 										callbacks: [resolvedOnToolExecutionEnd, telemetryDispatcher.onToolExecutionEnd]
 									}),
 									executeToolInTelemetryContext: telemetryDispatcher.executeTool,
-									runInTracingChannelSpan
+									runInTracingChannelSpan,
+									toolCallConcurrency: resolvedToolCallConcurrency
 								});
 								for (const result of toolExecutionResults) {
 									toolExecutionMs[result.output.toolCallId] = result.toolExecutionMs;
@@ -5976,21 +6032,26 @@ async function generateText({ model: modelArg, tools, toolChoice, instructions,
 		execute: executeGenerateText
 	});
 }
-async function executeTools({ toolCalls, tools, callId, messages, abortSignal, timeout, experimental_sandbox: sandbox, toolsContext, onToolExecutionStart, onToolExecutionEnd, executeToolInTelemetryContext, runInTracingChannelSpan }) {
-	return (await Promise.all(toolCalls.map(async (toolCall) => await executeToolCall({
-		toolCall,
-		tools,
-		callId,
-		messages,
+async function executeTools({ toolCalls, tools, callId, messages, abortSignal, timeout, experimental_sandbox: sandbox, toolsContext, onToolExecutionStart, onToolExecutionEnd, executeToolInTelemetryContext, runInTracingChannelSpan, toolCallConcurrency }) {
+	return (await mapWithConcurrency({
+		items: toolCalls,
+		concurrency: toolCallConcurrency,
 		abortSignal,
-		timeout,
-		experimental_sandbox: sandbox,
-		toolsContext,
-		onToolExecutionStart,
-		onToolExecutionEnd,
-		executeToolInTelemetryContext,
-		runInTracingChannelSpan
-	})))).filter((result) => result != null);
+		execute: async (toolCall) => await executeToolCall({
+			toolCall,
+			tools,
+			callId,
+			messages,
+			abortSignal,
+			timeout,
+			experimental_sandbox: sandbox,
+			toolsContext,
+			onToolExecutionStart,
+			onToolExecutionEnd,
+			executeToolInTelemetryContext,
+			runInTracingChannelSpan
+		})
+	})).filter((result) => result != null);
 }
 //#endregion
 //#region src/util/prepare-headers.ts
@@ -7808,7 +7869,7 @@ function isStreamRetryAttemptBoundaryPart(part) {
 }
 //#endregion
 //#region src/generate-text/execute-tools-from-stream.ts
-function executeToolsFromStream({ stream, tools, callId, messages, abortSignal, timeout, experimental_sandbox: sandbox, toolsContext, toolApproval, runtimeContext, toolApprovalSecret, generateId, onToolExecutionStart, onToolExecutionEnd, executeToolInTelemetryContext, runInTracingChannelSpan }) {
+function executeToolsFromStream({ stream, tools, callId, messages, abortSignal, timeout, experimental_sandbox: sandbox, toolsContext, toolApproval, runtimeContext, toolApprovalSecret, generateId, onToolExecutionStart, onToolExecutionEnd, executeToolInTelemetryContext, runInTracingChannelSpan, toolCallConcurrency }) {
 	const toolCallsToExecute = [];
 	return stream.pipeThrough(new TransformStream({ async transform(chunk, controller) {
 		controller.enqueue(chunk);
@@ -7895,40 +7956,45 @@ function executeToolsFromStream({ stream, tools, callId, messages, abortSignal,
 			}
 			case "model-call-end":
 				if (!isToolExecutionAllowedFinishReason(chunk.finishReason)) return;
-				await Promise.all(toolCallsToExecute.map(async (toolCall) => {
-					try {
-						const result = await executeToolCall({
-							toolCall,
-							tools,
-							callId,
-							messages,
-							abortSignal,
-							timeout,
-							experimental_sandbox: sandbox,
-							toolsContext,
-							onToolExecutionStart,
-							onToolExecutionEnd,
-							executeToolInTelemetryContext,
-							runInTracingChannelSpan,
-							onPreliminaryToolResult: (result) => {
-								controller.enqueue(result);
+				await mapWithConcurrency({
+					items: toolCallsToExecute,
+					concurrency: toolCallConcurrency,
+					abortSignal,
+					execute: async (toolCall) => {
+						try {
+							const result = await executeToolCall({
+								toolCall,
+								tools,
+								callId,
+								messages,
+								abortSignal,
+								timeout,
+								experimental_sandbox: sandbox,
+								toolsContext,
+								onToolExecutionStart,
+								onToolExecutionEnd,
+								executeToolInTelemetryContext,
+								runInTracingChannelSpan,
+								onPreliminaryToolResult: (result) => {
+									controller.enqueue(result);
+								}
+							});
+							if (result != null) {
+								controller.enqueue({
+									type: "tool-execution-end",
+									toolCallId: result.output.toolCallId,
+									toolExecutionMs: result.toolExecutionMs
+								});
+								controller.enqueue(result.output);
 							}
-						});
-						if (result != null) {
+						} catch (error) {
 							controller.enqueue({
-								type: "tool-execution-end",
-								toolCallId: result.output.toolCallId,
-								toolExecutionMs: result.toolExecutionMs
+								type: "error",
+								error
 							});
-							controller.enqueue(result.output);
 						}
-					} catch (error) {
-						controller.enqueue({
-							type: "error",
-							error
-						});
 					}
-				}));
+				});
 		}
 	} }));
 }
@@ -8654,6 +8720,7 @@ const originalGenerateCallId$7 = createIdGenerator$1({
 * @param model - The language model to use.
 * @param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
 * @param toolOrder - Controls the order in which tools are sent to the provider. Tools not listed are appended alphabetically.
+* @param toolCallConcurrency - Maximum number of tool calls that may execute concurrently within a step. Set to 1 for sequential execution. Default: unlimited.
 *
 * @param system - A system message that will be part of the prompt.
 * @param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
@@ -8713,7 +8780,8 @@ const originalGenerateCallId$7 = createIdGenerator$1({
 * @returns
 * A result object for accessing different stream types and additional information.
 */
-function streamText({ model, tools, toolChoice, instructions, system, prompt, messages, allowSystemInMessages, maxRetries, streamRetries, abortSignal, timeout, headers, stopWhen = isStepCount(1), experimental_sandbox: sandbox, output, toolApproval, experimental_toolCallers, experimental_toolApprovalSecret, experimental_telemetry, telemetry = experimental_telemetry, prepareStep, providerOptions, activeTools, toolOrder, experimental_repairToolCall, repairToolCall = experimental_repairToolCall, experimental_refineToolInput: refineToolInput, experimental_transform: transform, experimental_download: download, includeRawChunks, onChunk, onError: onErrorArg, onFinish, onEnd = onFinish, onAbort, onStepEnd, onStepFinish, onStart, experimental_onStart, onStepStart, experimental_onStepStart, onLanguageModelCallStart, experimental_onLanguageModelCallStart, onLanguageModelCallEnd, experimental_onLanguageModelCallEnd, onToolExecutionStart, onToolExecutionEnd, experimental_onToolCallStart, experimental_onToolCallFinish, runtimeContext = {}, toolsContext = {}, experimental_include, include = experimental_include, _internal: { now: now$2 = now, generateId = originalGenerateId$2, generateCallId = originalGenerateCallId$7 } = {}, ...settings }) {
+function streamText({ model, tools, toolChoice, instructions, system, prompt, messages, allowSystemInMessages, maxRetries, streamRetries, abortSignal, timeout, headers, stopWhen = isStepCount(1), experimental_sandbox: sandbox, output, toolApproval, experimental_toolCallers, experimental_toolApprovalSecret, experimental_telemetry, telemetry = experimental_telemetry, prepareStep, providerOptions, activeTools, toolOrder, toolCallConcurrency, experimental_repairToolCall, repairToolCall = experimental_repairToolCall, experimental_refineToolInput: refineToolInput, experimental_transform: transform, experimental_download: download, includeRawChunks, onChunk, onError: onErrorArg, onFinish, onEnd = onFinish, onAbort, onStepEnd, onStepFinish, onStart, experimental_onStart, onStepStart, experimental_onStepStart, onLanguageModelCallStart, experimental_onLanguageModelCallStart, onLanguageModelCallEnd, experimental_onLanguageModelCallEnd, onToolExecutionStart, onToolExecutionEnd, experimental_onToolCallStart, experimental_onToolCallFinish, runtimeContext = {}, toolsContext = {}, experimental_include, include = experimental_include, _internal: { now: now$2 = now, generateId = originalGenerateId$2, generateCallId = originalGenerateCallId$7 } = {}, ...settings }) {
+	const resolvedToolCallConcurrency = prepareToolCallConcurrency(toolCallConcurrency);
 	const totalTimeoutMs = getTotalTimeoutMs(timeout);
 	const stepTimeoutMs = getStepTimeoutMs(timeout);
 	const firstChunkTimeoutMs = getFirstChunkTimeoutMs(timeout);
@@ -8758,6 +8826,7 @@ function streamText({ model, tools, toolChoice, instructions, system, prompt, me
 		transforms: asArray(transform),
 		activeTools,
 		toolOrder,
+		toolCallConcurrency: resolvedToolCallConcurrency,
 		repairToolCall,
 		refineToolInput,
 		stopConditions: asArray(stopWhen),
@@ -8964,7 +9033,7 @@ function applyStreamTextTransforms({ stream, transforms, tools, stopStream }) {
 	});
 }
 var DefaultStreamTextResult = class {
-	constructor({ model, telemetry, headers, settings, maxRetries: maxRetriesArg, streamRetries: streamRetriesArg, abortSignal, stepTimeoutMs, stepAbortController, firstChunkTimeoutMs, firstChunkAbortController, chunkTimeoutMs, chunkAbortController, instructions, system, prompt, messages, allowSystemInMessages, experimental_sandbox: sandbox, tools, toolChoice, transforms, activeTools, toolOrder, repairToolCall, refineToolInput, stopConditions, output, toolApproval, experimental_toolCallers, experimental_toolApprovalSecret, providerOptions, prepareStep, now, generateId, generateCallId, timeout, onChunk, onError, canRetryStreamViaOnError, onEnd, onAbort, onStepFinish, onStart, onStepStart, onLanguageModelCallStart, onLanguageModelCallEnd, onToolExecutionStart, onToolExecutionEnd, runtimeContext, toolsContext, download, include }) {
+	constructor({ model, telemetry, headers, settings, maxRetries: maxRetriesArg, streamRetries: streamRetriesArg, abortSignal, stepTimeoutMs, stepAbortController, firstChunkTimeoutMs, firstChunkAbortController, chunkTimeoutMs, chunkAbortController, instructions, system, prompt, messages, allowSystemInMessages, experimental_sandbox: sandbox, tools, toolChoice, transforms, activeTools, toolOrder, toolCallConcurrency, repairToolCall, refineToolInput, stopConditions, output, toolApproval, experimental_toolCallers, experimental_toolApprovalSecret, providerOptions, prepareStep, now, generateId, generateCallId, timeout, onChunk, onError, canRetryStreamViaOnError, onEnd, onAbort, onStepFinish, onStart, onStepStart, onLanguageModelCallStart, onLanguageModelCallEnd, onToolExecutionStart, onToolExecutionEnd, runtimeContext, toolsContext, download, include }) {
 		this._totalUsage = new DelayedPromise();
 		this._finishReason = new DelayedPromise();
 		this._rawFinishReason = new DelayedPromise();
@@ -9438,29 +9507,34 @@ var DefaultStreamTextResult = class {
 						...toolApproval.toolCall.toolMetadata != null ? { toolMetadata: toolApproval.toolCall.toolMetadata } : {}
 					});
 					const toolOutputs = [];
-					await Promise.all(localApprovedToolApprovals.map(async (toolApproval) => {
-						const result = await executeToolCall({
-							toolCall: toolApproval.toolCall,
-							tools,
-							callId,
-							messages: initialMessages,
-							abortSignal,
-							timeout,
-							experimental_sandbox: sandbox,
-							toolsContext,
-							onToolExecutionStart: filterNullable(onToolExecutionStart, telemetryDispatcher.onToolExecutionStart),
-							onToolExecutionEnd: filterNullable(onToolExecutionEnd, telemetryDispatcher.onToolExecutionEnd),
-							executeToolInTelemetryContext: telemetryDispatcher.executeTool,
-							runInTracingChannelSpan: runInTracingChannelSpanInStreamText,
-							onPreliminaryToolResult: (result) => {
-								toolExecutionStepStreamController?.enqueue(result);
+					await mapWithConcurrency({
+						items: localApprovedToolApprovals,
+						concurrency: toolCallConcurrency,
+						abortSignal,
+						execute: async (toolApproval) => {
+							const result = await executeToolCall({
+								toolCall: toolApproval.toolCall,
+								tools,
+								callId,
+								messages: initialMessages,
+								abortSignal,
+								timeout,
+								experimental_sandbox: sandbox,
+								toolsContext,
+								onToolExecutionStart: filterNullable(onToolExecutionStart, telemetryDispatcher.onToolExecutionStart),
+								onToolExecutionEnd: filterNullable(onToolExecutionEnd, telemetryDispatcher.onToolExecutionEnd),
+								executeToolInTelemetryContext: telemetryDispatcher.executeTool,
+								runInTracingChannelSpan: runInTracingChannelSpanInStreamText,
+								onPreliminaryToolResult: (result) => {
+									toolExecutionStepStreamController?.enqueue(result);
+								}
+							});
+							if (result != null) {
+								toolExecutionStepStreamController?.enqueue(result.output);
+								toolOutputs.push(result.output);
 							}
-						});
-						if (result != null) {
-							toolExecutionStepStreamController?.enqueue(result.output);
-							toolOutputs.push(result.output);
 						}
-					}));
+					});
 					if (toolOutputs.length > 0 || localDeniedToolApprovalsWithoutResults.length > 0 || invalidToolApprovals.length > 0) {
 						const localToolContent = [];
 						for (const output of toolOutputs) localToolContent.push({
@@ -9834,7 +9908,8 @@ var DefaultStreamTextResult = class {
 						onToolExecutionStart: filterNullable(onToolExecutionStart, telemetryDispatcher.onToolExecutionStart),
 						onToolExecutionEnd: filterNullable(onToolExecutionEnd, telemetryDispatcher.onToolExecutionEnd),
 						executeToolInTelemetryContext: telemetryDispatcher.executeTool,
-						runInTracingChannelSpan: runInTracingChannelSpanInStep
+						runInTracingChannelSpan: runInTracingChannelSpanInStep,
+						toolCallConcurrency
 					});
 					const getStepRequest = () => ({
 						...request,