ai 7.0.123 → 7.0.126

package/dist/index.js

@@ -1102,7 +1102,7 @@ function cloneValue(value) {
 }
 //#endregion
 //#region src/version.ts
-const VERSION = "7.0.123";
+const VERSION = "7.0.126";
 //#endregion
 //#region src/util/download/download.ts
 /**
@@ -4356,11 +4356,15 @@ function createTelemetryDispatcher({ telemetry }) {
 		includeToolsContext: telemetry?.includeToolsContext
 	};
 	const mergeTelemetryCallback = (key) => {
-		const mergedIntegrationCallback = mergeCallbacks(...integrations.map((integration) => integration[key]?.bind(integration)).filter(Boolean).map((callback) => ((event) => callback(augmentEvent(event, telemetryMetadata)))));
+		const integrationCallbacks = integrations.map((integration) => integration[key]?.bind(integration)).filter(Boolean).map((callback) => ((event) => callback(augmentEvent(event, telemetryMetadata))));
+		if (integrationCallbacks.length === 0) return;
+		const mergedIntegrationCallback = mergeCallbacks(...integrationCallbacks);
 		return async (event) => {
 			await mergedIntegrationCallback(event);
 		};
 	};
+	const onStepEnd = mergeTelemetryCallback("onStepEnd");
+	const onStepFinish = mergeTelemetryCallback("onStepFinish");
 	const executeLanguageModelCallWrappers = integrations.map((integration) => integration.executeLanguageModelCall?.bind(integration)).filter(Boolean);
 	const executeToolWrappers = integrations.map((integration) => integration.executeTool?.bind(integration)).filter(Boolean);
 	return {
@@ -4381,7 +4385,7 @@ function createTelemetryDispatcher({ telemetry }) {
 		onLanguageModelCallEnd: mergeTelemetryCallback("onLanguageModelCallEnd"),
 		onToolExecutionStart: mergeTelemetryCallback("onToolExecutionStart"),
 		onToolExecutionEnd: mergeTelemetryCallback("onToolExecutionEnd"),
-		onStepEnd: mergeCallbacks(mergeTelemetryCallback("onStepEnd"), mergeTelemetryCallback("onStepFinish")),
+		onStepEnd: onStepEnd == null && onStepFinish == null ? void 0 : mergeCallbacks(onStepEnd, onStepFinish),
 		onObjectStepStart: mergeTelemetryCallback("onObjectStepStart"),
 		onObjectStepEnd: mergeTelemetryCallback("onObjectStepEnd"),
 		onEmbedStart: mergeTelemetryCallback("onEmbedStart"),
@@ -4392,6 +4396,8 @@ function createTelemetryDispatcher({ telemetry }) {
 		experimental_onEvaluationModelCallStart: mergeTelemetryCallback("experimental_onEvaluationModelCallStart"),
 		experimental_onEvaluationModelCallEnd: mergeTelemetryCallback("experimental_onEvaluationModelCallEnd"),
 		experimental_onEvaluateEnd: mergeTelemetryCallback("experimental_onEvaluateEnd"),
+		experimental_onStreamTranscriptionStart: mergeTelemetryCallback("experimental_onStreamTranscriptionStart"),
+		experimental_onStreamTranscriptionEnd: mergeTelemetryCallback("experimental_onStreamTranscriptionEnd"),
 		onEnd: mergeTelemetryCallback("onEnd"),
 		onAbort: mergeTelemetryCallback("onAbort"),
 		onError: mergeTelemetryCallback("onError"),
@@ -5041,7 +5047,7 @@ const originalGenerateId$4 = createIdGenerator$1({
 	prefix: "aitxt",
 	size: 24
 });
-const originalGenerateCallId$6 = createIdGenerator$1({
+const originalGenerateCallId$9 = createIdGenerator$1({
 	prefix: "call",
 	size: 24
 });
@@ -5112,7 +5118,7 @@ const originalGenerateCallId$6 = 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$6, 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, 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,
@@ -7948,7 +7954,7 @@ const originalGenerateId$3 = createIdGenerator$1({
 	prefix: "aitxt",
 	size: 24
 });
-const originalGenerateCallId$5 = createIdGenerator$1({
+const originalGenerateCallId$8 = createIdGenerator$1({
 	prefix: "call",
 	size: 24
 });
@@ -8001,7 +8007,7 @@ const originalGenerateCallId$5 = createIdGenerator$1({
 *
 * @returns A stream of model call parts together with request and response metadata when available.
 */
-async function streamLanguageModelCall({ model, tools, toolOrder, output, toolChoice, prompt, system, instructions, messages, allowSystemInMessages, download, abortSignal, headers, includeRawChunks, providerOptions, repairToolCall, refineToolInput, executeLanguageModelCallInTelemetryContext = async ({ execute }) => await execute(), callId, toolsContext, experimental_sandbox: sandbox, _internal: { generateId = originalGenerateId$3, generateCallId = originalGenerateCallId$5, now: now$3 = now } = {}, onStart, onLanguageModelCallStart, onLanguageModelCallEnd, ...callSettings }) {
+async function streamLanguageModelCall({ model, tools, toolOrder, output, toolChoice, prompt, system, instructions, messages, allowSystemInMessages, download, abortSignal, headers, includeRawChunks, providerOptions, repairToolCall, refineToolInput, executeLanguageModelCallInTelemetryContext = async ({ execute }) => await execute(), callId, toolsContext, experimental_sandbox: sandbox, _internal: { generateId = originalGenerateId$3, generateCallId = originalGenerateCallId$8, now: now$3 = now } = {}, onStart, onLanguageModelCallStart, onLanguageModelCallEnd, ...callSettings }) {
 	const resolvedModel = resolveLanguageModel(model);
 	const effectiveCallId = callId ?? generateCallId();
 	const standardizedPrompt = await standardizePrompt({
@@ -8464,7 +8470,7 @@ const originalGenerateId$2 = createIdGenerator$1({
 	prefix: "aitxt",
 	size: 24
 });
-const originalGenerateCallId$4 = createIdGenerator$1({
+const originalGenerateCallId$7 = createIdGenerator$1({
 	prefix: "call",
 	size: 24
 });
@@ -8574,7 +8580,7 @@ function isOutputChunk(chunk) {
 * @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$4 } = {}, ...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, 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 totalTimeoutMs = getTotalTimeoutMs(timeout);
 	const stepTimeoutMs = getStepTimeoutMs(timeout);
 	const firstChunkTimeoutMs = getFirstChunkTimeoutMs(timeout);
@@ -11198,6 +11204,7 @@ async function validateUIMessagesForAgent(options) {
 *
 * @param agent - The agent to run.
 * @param uiMessages - The input UI messages.
+* @param convertDataPart - Optional function to convert custom data parts to text or file model message parts.
 * @param abortSignal - The abort signal. Optional.
 * @param timeout - Timeout in milliseconds. Optional.
 * @param experimental_sandbox - The sandbox environment that is passed through to tool execution. Optional.
@@ -11208,12 +11215,15 @@ async function validateUIMessagesForAgent(options) {
 *
 * @returns The UI message stream.
 */
-async function createAgentUIStream({ agent, uiMessages, options, abortSignal, timeout, experimental_sandbox: sandbox, experimental_transform, onStepEnd, onStepFinish, ...uiMessageStreamOptions }) {
+async function createAgentUIStream({ agent, uiMessages, convertDataPart, options, abortSignal, timeout, experimental_sandbox: sandbox, experimental_transform, onStepEnd, onStepFinish, ...uiMessageStreamOptions }) {
 	const validatedMessages = await validateUIMessagesForAgent({
 		messages: uiMessages,
 		tools: agent.tools
 	});
-	const modelMessages = await convertToModelMessages(validatedMessages, { tools: agent.tools });
+	const modelMessages = await convertToModelMessages(validatedMessages, {
+		tools: agent.tools,
+		convertDataPart
+	});
 	const result = await agent.stream({
 		prompt: modelMessages,
 		options,
@@ -11238,6 +11248,7 @@ async function createAgentUIStream({ agent, uiMessages, options, abortSignal, ti
 *
 * @param agent - The agent to run.
 * @param uiMessages - The input UI messages.
+* @param convertDataPart - Optional function to convert custom data parts to text or file model message parts.
 * @param abortSignal - Abort signal. Optional.
 * @param timeout - Timeout in milliseconds. Optional.
 * @param experimental_sandbox - The sandbox environment that is passed through to tool execution. Optional.
@@ -11271,6 +11282,7 @@ async function createAgentUIStreamResponse({ headers, status, statusText, keepAl
 * @param response - The Node.js ServerResponse object to pipe to.
 * @param agent - The agent to run.
 * @param uiMessages - The input UI messages.
+* @param convertDataPart - Optional function to convert custom data parts to text or file model message parts.
 * @param abortSignal - Abort signal. Optional.
 * @param timeout - Timeout in milliseconds. Optional.
 * @param experimental_sandbox - The sandbox environment that is passed through to tool execution. Optional.
@@ -11992,7 +12004,7 @@ function createRestrictedTelemetryDispatcher$2({ telemetry }) {
 }
 //#endregion
 //#region src/embed/embed.ts
-const originalGenerateCallId$3 = createIdGenerator$1({
+const originalGenerateCallId$6 = createIdGenerator$1({
 	prefix: "call",
 	size: 24
 });
@@ -12015,7 +12027,7 @@ const originalGenerateCallId$3 = createIdGenerator$1({
 *
 * @returns A result object that contains the embedding, the value, and additional information.
 */
-async function embed({ model: modelArg, value, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry, telemetry = experimental_telemetry, runtimeContext = {}, onStart, experimental_onStart, onEnd, experimental_onEnd, _internal: { generateCallId = originalGenerateCallId$3 } = {} }) {
+async function embed({ model: modelArg, value, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry, telemetry = experimental_telemetry, runtimeContext = {}, onStart, experimental_onStart, onEnd, experimental_onEnd, _internal: { generateCallId = originalGenerateCallId$6 } = {} }) {
 	const model = resolveEmbeddingModel(modelArg);
 	const { maxRetries, retry } = prepareRetries({
 		maxRetries: maxRetriesArg,
@@ -12175,7 +12187,7 @@ function splitArray(array, chunkSize) {
 }
 //#endregion
 //#region src/embed/embed-many.ts
-const originalGenerateCallId$2 = createIdGenerator$1({
+const originalGenerateCallId$5 = createIdGenerator$1({
 	prefix: "call",
 	size: 24
 });
@@ -12207,7 +12219,7 @@ const originalGenerateCallId$2 = createIdGenerator$1({
 *
 * @returns A result object that contains the embeddings, the value, and additional information.
 */
-async function embedMany({ model: modelArg, values, maxParallelCalls = Infinity, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry, telemetry = experimental_telemetry, runtimeContext = {}, onStart, experimental_onStart, onEnd, experimental_onEnd, _internal: { generateCallId = originalGenerateCallId$2 } = {} }) {
+async function embedMany({ model: modelArg, values, maxParallelCalls = Infinity, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry, telemetry = experimental_telemetry, runtimeContext = {}, onStart, experimental_onStart, onEnd, experimental_onEnd, _internal: { generateCallId = originalGenerateCallId$5 } = {} }) {
 	const model = resolveEmbeddingModel(modelArg);
 	const { maxRetries, retry } = prepareRetries({
 		maxRetries: maxRetriesArg,
@@ -12611,12 +12623,12 @@ function validateEvaluationAnswers({ questions, answers, rounding }) {
 }
 //#endregion
 //#region src/evaluate/evaluate.ts
-const originalGenerateCallId$1 = createIdGenerator$1({
+const originalGenerateCallId$4 = createIdGenerator$1({
 	prefix: "call",
 	size: 24
 });
 /** Evaluate typed questions against one shared state. Experimental. */
-async function evaluate({ model: modelArg, state, questions, maxRetries, abortSignal, headers, providerOptions = {}, telemetry, runtimeContext = {}, onStart, onEnd, _internal: { generateCallId = originalGenerateCallId$1 } = {} }) {
+async function evaluate({ model: modelArg, state, questions, maxRetries, abortSignal, headers, providerOptions = {}, telemetry, runtimeContext = {}, onStart, onEnd, _internal: { generateCallId = originalGenerateCallId$4 } = {} }) {
 	const model = resolveEvaluationModel(modelArg);
 	validateEvaluationInput({
 		state,
@@ -14071,6 +14083,10 @@ var DefaultGeneratedAudioFile = class extends DefaultGeneratedFile {
 };
 //#endregion
 //#region src/generate-speech/generate-speech.ts
+const originalGenerateCallId$3 = createIdGenerator$1({
+	prefix: "call",
+	size: 24
+});
 /**
 * Generates speech audio using a speech model.
 *
@@ -14086,48 +14102,126 @@ var DefaultGeneratedAudioFile = class extends DefaultGeneratedFile {
 * @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
 * @param abortSignal - An optional abort signal that can be used to cancel the call.
 * @param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+* @param telemetry - Optional telemetry configuration.
 *
 * @returns A result object that contains the generated audio data.
 */
-async function generateSpeech({ model, text, voice, outputFormat, instructions, speed, language, providerOptions = {}, maxRetries: maxRetriesArg, abortSignal, headers }) {
+async function generateSpeech({ model, text, voice, outputFormat, instructions, speed, language, providerOptions = {}, maxRetries: maxRetriesArg, abortSignal, headers, telemetry, _internal: { generateCallId = originalGenerateCallId$3 } = {} }) {
 	const resolvedModel = resolveSpeechModel(model);
 	if (!resolvedModel) throw new Error("Model could not be resolved");
 	const headersWithUserAgent = withUserAgentSuffix(headers ?? {}, `ai/${VERSION}`);
-	const { retry } = prepareRetries({
+	const { maxRetries, retry } = prepareRetries({
 		maxRetries: maxRetriesArg,
 		abortSignal
 	});
-	const result = await retry(() => resolvedModel.doGenerate({
+	const callId = generateCallId();
+	const telemetryDispatcher = createTelemetryDispatcher({ telemetry });
+	const runInTracingChannelSpan = telemetryDispatcher.runInTracingChannelSpan ?? (async ({ execute }) => await execute());
+	const startEvent = {
+		callId,
+		operationId: "ai.generateSpeech",
+		provider: resolvedModel.provider,
+		modelId: resolvedModel.modelId,
 		text,
 		voice,
 		outputFormat,
 		instructions,
 		speed,
 		language,
-		abortSignal,
-		headers: headersWithUserAgent,
+		maxRetries,
+		headers,
 		providerOptions
-	}));
-	if (!result.audio || result.audio.length === 0) throw new NoSpeechGeneratedError({ responses: [result.response] });
-	logWarnings({
-		warnings: result.warnings,
-		provider: resolvedModel.provider,
-		model: resolvedModel.modelId
-	});
-	const detectedMediaType = detectMediaType({
-		data: result.audio,
-		topLevelType: "audio"
-	});
-	return new DefaultSpeechResult({
-		audio: new DefaultGeneratedAudioFile({
-			data: result.audio,
-			mediaType: detectedMediaType ?? getResponseAudioMediaType(result.response.headers) ?? getOutputFormatMediaType(outputFormat) ?? "audio/mp3"
-		}),
-		warnings: result.warnings,
-		responses: [result.response],
-		providerMetadata: result.providerMetadata
+	};
+	return await runInTracingChannelSpan({
+		type: "generateSpeech",
+		event: startEvent,
+		execute: async () => {
+			await notify({
+				event: startEvent,
+				callbacks: [telemetryDispatcher.onStart]
+			});
+			try {
+				const result = await retry(() => resolvedModel.doGenerate({
+					text,
+					voice,
+					outputFormat,
+					instructions,
+					speed,
+					language,
+					abortSignal,
+					headers: headersWithUserAgent,
+					providerOptions
+				}));
+				if (!result.audio || result.audio.length === 0) throw new NoSpeechGeneratedError({ responses: [result.response] });
+				logWarnings({
+					warnings: result.warnings,
+					provider: resolvedModel.provider,
+					model: resolvedModel.modelId
+				});
+				const detectedMediaType = detectMediaType({
+					data: result.audio,
+					topLevelType: "audio"
+				});
+				const audio = new DefaultGeneratedAudioFile({
+					data: result.audio,
+					mediaType: detectedMediaType ?? getResponseAudioMediaType(result.response.headers) ?? getOutputFormatMediaType(outputFormat) ?? "audio/mp3"
+				});
+				if (telemetryDispatcher.onEnd != null) await notify({
+					event: {
+						callId,
+						operationId: "ai.generateSpeech",
+						provider: resolvedModel.provider,
+						modelId: resolvedModel.modelId,
+						text,
+						audio: {
+							byteLength: getBase64OrBinaryByteLength(result.audio),
+							mediaType: audio.mediaType,
+							format: audio.format
+						},
+						usage: result.usage,
+						warnings: result.warnings,
+						providerMetadata: result.providerMetadata,
+						response: getTelemetryResponseMetadata(result.response)
+					},
+					callbacks: [telemetryDispatcher.onEnd]
+				});
+				return new DefaultSpeechResult({
+					audio,
+					warnings: result.warnings,
+					responses: [result.response],
+					providerMetadata: result.providerMetadata
+				});
+			} catch (error) {
+				await telemetryDispatcher.onError?.({
+					callId,
+					error
+				});
+				throw error;
+			}
+		}
 	});
 }
+function getBase64OrBinaryByteLength(audio) {
+	if (audio instanceof Uint8Array) return audio.byteLength;
+	let characterCount = 0;
+	let lastCharacter = "";
+	let secondLastCharacter = "";
+	for (const character of audio) {
+		if (/\s/.test(character)) continue;
+		characterCount++;
+		secondLastCharacter = lastCharacter;
+		lastCharacter = character;
+	}
+	const padding = lastCharacter === "=" ? secondLastCharacter === "=" ? 2 : 1 : 0;
+	return Math.floor(characterCount * 3 / 4) - padding;
+}
+function getTelemetryResponseMetadata(response) {
+	return {
+		timestamp: response.timestamp,
+		modelId: response.modelId,
+		headers: response.headers
+	};
+}
 function getResponseAudioMediaType(headers) {
 	const mediaType = Object.entries(headers ?? {}).find(([name]) => name.toLowerCase() === "content-type")?.[1];
 	if (mediaType == null) return;
@@ -18187,7 +18281,7 @@ function createRestrictedTelemetryDispatcher({ telemetry }) {
 }
 //#endregion
 //#region src/rerank/rerank.ts
-const originalGenerateCallId = createIdGenerator$1({
+const originalGenerateCallId$2 = createIdGenerator$1({
 	prefix: "call",
 	size: 24
 });
@@ -18208,7 +18302,7 @@ const originalGenerateCallId = createIdGenerator$1({
 *
 * @returns A result object that contains the reranked documents, the reranked indices, and additional information.
 */
-async function rerank({ model: modelArg, documents, query, topN, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry, telemetry = experimental_telemetry, runtimeContext = {}, onStart, experimental_onStart, onEnd, experimental_onEnd, _internal: { generateCallId = originalGenerateCallId } = {} }) {
+async function rerank({ model: modelArg, documents, query, topN, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry, telemetry = experimental_telemetry, runtimeContext = {}, onStart, experimental_onStart, onEnd, experimental_onEnd, _internal: { generateCallId = originalGenerateCallId$2 } = {} }) {
 	const model = resolveRerankingModel(modelArg);
 	const callId = generateCallId();
 	const resolvedOnStart = onStart ?? experimental_onStart;
@@ -18415,6 +18509,10 @@ var DefaultRerankResult = class {
 };
 //#endregion
 //#region src/transcribe/transcribe.ts
+const originalGenerateCallId$1 = createIdGenerator$1({
+	prefix: "call",
+	size: 24
+});
 /**
 * Generates transcripts using a transcription model.
 *
@@ -18425,47 +18523,149 @@ var DefaultRerankResult = class {
 * @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
 * @param abortSignal - An optional abort signal that can be used to cancel the call.
 * @param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+* @param telemetry - Optional telemetry configuration.
 *
 * @returns A result object that contains the generated transcript.
 */
 const defaultDownload = createDownload();
-async function transcribe({ model, audio, providerOptions = {}, maxRetries: maxRetriesArg, abortSignal, headers, download: downloadFn = defaultDownload }) {
+async function transcribe({ model, audio, providerOptions = {}, maxRetries: maxRetriesArg, abortSignal, headers, telemetry, download: downloadFn = defaultDownload, _internal: { generateCallId = originalGenerateCallId$1 } = {} }) {
 	const resolvedModel = resolveTranscriptionModel(model);
 	if (!resolvedModel) throw new Error("Model could not be resolved");
-	const { retry } = prepareRetries({
+	const { maxRetries, retry } = prepareRetries({
 		maxRetries: maxRetriesArg,
 		abortSignal
 	});
 	const headersWithUserAgent = withUserAgentSuffix(headers ?? {}, `ai/${VERSION}`);
-	const audioData = audio instanceof URL ? (await downloadFn({
-		url: audio,
-		abortSignal
-	})).data : convertDataContentToUint8Array(audio);
-	const result = await retry(() => resolvedModel.doGenerate({
-		audio: audioData,
-		abortSignal,
-		headers: headersWithUserAgent,
-		providerOptions,
-		mediaType: detectMediaType({
-			data: audioData,
-			topLevelType: "audio"
-		}) ?? "audio/wav"
-	}));
-	logWarnings({
-		warnings: result.warnings,
+	const callId = generateCallId();
+	const telemetryDispatcher = createTelemetryDispatcher({ telemetry });
+	const runInTracingChannelSpan = telemetryDispatcher.runInTracingChannelSpan ?? (async ({ execute }) => await execute());
+	const createStartEvent = ({ byteLength, mediaType }) => ({
+		callId,
+		operationId: "ai.transcribe",
 		provider: resolvedModel.provider,
-		model: resolvedModel.modelId
+		modelId: resolvedModel.modelId,
+		audio: {
+			byteLength,
+			mediaType
+		},
+		inputAudioFormat: void 0,
+		maxRetries,
+		headers,
+		providerOptions
 	});
-	if (!result.text) throw new NoTranscriptGeneratedError({ responses: [result.response] });
-	return new DefaultTranscriptionResult({
-		text: result.text,
-		segments: result.segments,
-		language: result.language,
-		durationInSeconds: result.durationInSeconds,
-		warnings: result.warnings,
-		responses: [result.response],
-		providerMetadata: result.providerMetadata
+	const executeWithStartEvent = async ({ startEvent, execute }) => await runInTracingChannelSpan({
+		type: "transcribe",
+		event: startEvent,
+		execute: async () => {
+			await notify({
+				event: startEvent,
+				callbacks: [telemetryDispatcher.onStart]
+			});
+			return await execute();
+		}
 	});
+	let preparationError;
+	let preparationFailed = false;
+	let audioData;
+	let downloadedMediaType;
+	try {
+		if (audio instanceof URL) {
+			const downloadResult = await downloadFn({
+				url: audio,
+				abortSignal
+			});
+			audioData = downloadResult.data;
+			downloadedMediaType = downloadResult.mediaType;
+		} else audioData = convertDataContentToUint8Array(audio);
+	} catch (error) {
+		preparationFailed = true;
+		preparationError = error;
+		audioData = /* @__PURE__ */ new Uint8Array();
+	}
+	if (preparationFailed) {
+		const startEvent = createStartEvent({
+			byteLength: void 0,
+			mediaType: void 0
+		});
+		try {
+			return await executeWithStartEvent({
+				startEvent,
+				execute: () => {
+					throw preparationError;
+				}
+			});
+		} catch (error) {
+			await telemetryDispatcher.onError?.({
+				callId,
+				error
+			});
+			throw error;
+		}
+	}
+	const mediaType = downloadedMediaType ?? detectMediaType({
+		data: audioData,
+		topLevelType: "audio"
+	}) ?? "audio/wav";
+	const startEvent = createStartEvent({
+		byteLength: audioData.byteLength,
+		mediaType
+	});
+	try {
+		return await executeWithStartEvent({
+			startEvent,
+			execute: async () => {
+				const result = await retry(() => resolvedModel.doGenerate({
+					audio: audioData,
+					abortSignal,
+					headers: headersWithUserAgent,
+					providerOptions,
+					mediaType
+				}));
+				logWarnings({
+					warnings: result.warnings,
+					provider: resolvedModel.provider,
+					model: resolvedModel.modelId
+				});
+				if (!result.text) throw new NoTranscriptGeneratedError({ responses: [result.response] });
+				await notify({
+					event: {
+						callId,
+						operationId: "ai.transcribe",
+						provider: resolvedModel.provider,
+						modelId: resolvedModel.modelId,
+						audio: {
+							byteLength: audioData.byteLength,
+							mediaType
+						},
+						text: result.text,
+						segments: result.segments,
+						language: result.language,
+						durationInSeconds: result.durationInSeconds,
+						usage: result.usage,
+						warnings: result.warnings,
+						providerMetadata: result.providerMetadata,
+						response: result.response
+					},
+					callbacks: [telemetryDispatcher.onEnd]
+				});
+				return new DefaultTranscriptionResult({
+					text: result.text,
+					segments: result.segments,
+					language: result.language,
+					durationInSeconds: result.durationInSeconds,
+					warnings: result.warnings,
+					responses: [result.response],
+					providerMetadata: result.providerMetadata
+				});
+			}
+		});
+	} catch (error) {
+		await telemetryDispatcher.onError?.({
+			callId,
+			error
+		});
+		throw error;
+	}
 }
 var DefaultTranscriptionResult = class {
 	constructor(options) {
@@ -18480,6 +18680,10 @@ var DefaultTranscriptionResult = class {
 };
 //#endregion
 //#region src/transcribe/stream-transcribe.ts
+const originalGenerateCallId = createIdGenerator$1({
+	prefix: "call",
+	size: 24
+});
 /**
 * Streams transcripts using a transcription model.
 *
@@ -18489,10 +18693,11 @@ var DefaultTranscriptionResult = class {
 * @param providerOptions - Additional provider-specific options.
 * @param abortSignal - An optional abort signal that can be used to cancel the call.
 * @param headers - Additional HTTP/WebSocket headers to send when supported by the provider.
+* @param telemetry - Optional telemetry configuration.
 *
 * @returns A result object that contains the streaming transcript and final transcript metadata.
 */
-function streamTranscribe({ model, audio, inputAudioFormat, providerOptions = {}, abortSignal, headers, includeRawChunks, _internal: { currentDate = () => /* @__PURE__ */ new Date() } = {} }) {
+function streamTranscribe({ model, audio, inputAudioFormat, providerOptions = {}, abortSignal, headers, includeRawChunks, telemetry, _internal: { currentDate = () => /* @__PURE__ */ new Date(), generateCallId = originalGenerateCallId } = {} }) {
 	const resolvedModel = resolveTranscriptionModel(model);
 	if (!resolvedModel) throw new Error("Model could not be resolved");
 	const doStream = resolvedModel.doStream?.bind(resolvedModel);
@@ -18501,6 +18706,27 @@ function streamTranscribe({ model, audio, inputAudioFormat, providerOptions = {}
 		message: `The ${resolvedModel.provider} model "${resolvedModel.modelId}" does not support streaming transcription.` + (typeof model === "string" ? " String model IDs resolve through the global provider (AI Gateway by default). If that provider does not support streaming transcription, pass a provider model instance instead (e.g. openai.transcription('gpt-realtime-whisper')) or upgrade @ai-sdk/gateway to a version with streaming transcription support." : "")
 	});
 	const headersWithUserAgent = withUserAgentSuffix(headers ?? {}, `ai/${VERSION}`);
+	const callId = generateCallId();
+	const telemetryDispatcher = createTelemetryDispatcher({ telemetry });
+	const runInTracingChannelSpan = telemetryDispatcher.runInTracingChannelSpan ?? (async ({ execute }) => await execute());
+	let audioByteLength = 0;
+	const countedAudio = telemetryDispatcher.experimental_onStreamTranscriptionEnd != null ? createByteCountingStream(audio, (byteLength) => {
+		audioByteLength += byteLength;
+	}) : audio;
+	const startEvent = {
+		callId,
+		operationId: "ai.streamTranscribe",
+		provider: resolvedModel.provider,
+		modelId: resolvedModel.modelId,
+		audio: {
+			byteLength: void 0,
+			mediaType: inputAudioFormat.type
+		},
+		inputAudioFormat,
+		maxRetries: void 0,
+		headers,
+		providerOptions
+	};
 	const textPromise = new DelayedPromise();
 	const segmentsPromise = new DelayedPromise();
 	const languagePromise = new DelayedPromise();
@@ -18508,6 +18734,8 @@ function streamTranscribe({ model, audio, inputAudioFormat, providerOptions = {}
 	const warningsPromise = new DelayedPromise();
 	const responsesPromise = new DelayedPromise();
 	const providerMetadataPromise = new DelayedPromise();
+	let warnings = [];
+	let telemetrySettled = false;
 	const rejectPendingPromises = (error) => {
 		for (const promise of [
 			textPromise,
@@ -18525,17 +18753,18 @@ function streamTranscribe({ model, audio, inputAudioFormat, providerOptions = {}
 		timestamp: startedAt,
 		modelId: resolvedModel.modelId
 	};
-	const resolveWarnings = (warnings) => {
-		warningsPromise.resolve(warnings);
+	const resolveWarnings = (resolvedWarnings) => {
+		warnings = resolvedWarnings;
+		warningsPromise.resolve(resolvedWarnings);
 		logWarnings({
-			warnings,
+			warnings: resolvedWarnings,
 			provider: resolvedModel.provider,
 			model: resolvedModel.modelId
 		});
 	};
 	const pipeAbortController = new AbortController();
 	const transform = new TransformStream({
-		transform(value, controller) {
+		async transform(value, controller) {
 			switch (value.type) {
 				case "stream-start":
 					resolveWarnings(value.warnings);
@@ -18563,6 +18792,28 @@ function streamTranscribe({ model, audio, inputAudioFormat, providerOptions = {}
 					durationInSecondsPromise.resolve(value.durationInSeconds);
 					responsesPromise.resolve([currentResponseMetadata()]);
 					providerMetadataPromise.resolve(value.providerMetadata ?? {});
+					telemetrySettled = true;
+					if (telemetryDispatcher.experimental_onStreamTranscriptionEnd != null) await notify({
+						event: {
+							callId,
+							operationId: "ai.streamTranscribe",
+							provider: resolvedModel.provider,
+							modelId: resolvedModel.modelId,
+							audio: {
+								byteLength: audioByteLength,
+								mediaType: inputAudioFormat.type
+							},
+							text: value.text,
+							segments: value.segments,
+							language: value.language,
+							durationInSeconds: value.durationInSeconds,
+							usage: value.usage,
+							warnings,
+							providerMetadata: value.providerMetadata,
+							response: currentResponseMetadata()
+						},
+						callbacks: [telemetryDispatcher.experimental_onStreamTranscriptionEnd]
+					});
 			}
 		},
 		flush() {
@@ -18572,25 +18823,40 @@ function streamTranscribe({ model, audio, inputAudioFormat, providerOptions = {}
 			pipeAbortController.abort(reason ?? /* @__PURE__ */ new Error("Transcription stream was cancelled."));
 		}
 	});
-	(async () => {
-		const result = await doStream({
-			audio,
-			inputAudioFormat,
-			providerOptions,
-			abortSignal: mergeAbortSignals(abortSignal, pipeAbortController.signal),
-			headers: headersWithUserAgent,
-			includeRawChunks
-		});
-		response = {
-			timestamp: result.response?.timestamp ?? startedAt,
-			modelId: result.response?.modelId ?? resolvedModel.modelId,
-			headers: result.response?.headers
-		};
-		await result.stream.pipeTo(transform.writable, { signal: pipeAbortController.signal });
-	})().catch((error) => {
+	runInTracingChannelSpan({
+		type: "streamTranscribe",
+		event: startEvent,
+		execute: async () => {
+			await notify({
+				event: startEvent,
+				callbacks: [telemetryDispatcher.experimental_onStreamTranscriptionStart]
+			});
+			const result = await doStream({
+				audio: countedAudio,
+				inputAudioFormat,
+				providerOptions,
+				abortSignal: mergeAbortSignals(abortSignal, pipeAbortController.signal),
+				headers: headersWithUserAgent,
+				includeRawChunks
+			});
+			response = {
+				timestamp: result.response?.timestamp ?? startedAt,
+				modelId: result.response?.modelId ?? resolvedModel.modelId,
+				headers: result.response?.headers
+			};
+			await result.stream.pipeTo(transform.writable, { signal: pipeAbortController.signal });
+		}
+	}).catch(async (error) => {
 		const reason = error ?? /* @__PURE__ */ new Error("Transcription stream was cancelled or errored.");
 		rejectPendingPromises(reason);
-		audio.cancel(reason).catch(() => {});
+		if (!telemetrySettled) {
+			telemetrySettled = true;
+			await telemetryDispatcher.onError?.({
+				callId,
+				error: reason
+			});
+		}
+		countedAudio.cancel(reason).catch(() => {});
 		transform.writable.abort(reason).catch(() => {});
 	});
 	let streamOwner = "unclaimed";
@@ -18641,6 +18907,38 @@ function streamTranscribe({ model, audio, inputAudioFormat, providerOptions = {}
 		}
 	};
 }
+function createByteCountingStream(audio, onChunk) {
+	let audioReader;
+	return new ReadableStream({
+		async pull(controller) {
+			audioReader ??= audio.getReader();
+			const { done, value } = await audioReader.read();
+			if (done) {
+				controller.close();
+				return;
+			}
+			onChunk(typeof value === "string" ? getBase64ByteLength(value) : value.byteLength);
+			controller.enqueue(value);
+		},
+		async cancel(reason) {
+			if (audioReader != null) await audioReader.cancel(reason);
+			else await audio.cancel(reason);
+		}
+	});
+}
+function getBase64ByteLength(value) {
+	let characterCount = 0;
+	let lastCharacter = "";
+	let secondLastCharacter = "";
+	for (const character of value) {
+		if (/\s/.test(character)) continue;
+		characterCount++;
+		secondLastCharacter = lastCharacter;
+		lastCharacter = character;
+	}
+	const padding = lastCharacter === "=" ? secondLastCharacter === "=" ? 2 : 1 : 0;
+	return Math.floor(characterCount * 3 / 4) - padding;
+}
 //#endregion
 //#region src/transcribe/index.ts
 /**
@@ -19222,15 +19520,32 @@ var AbstractChat = class {
 				}
 			});
 		});
-		this.addToolOutput = async ({ state = "output-available", toolCallId, output, errorText, options }) => this.jobExecutor.run(async () => {
+		this.addToolOutput = async ({ state, toolCallId, output, errorText, options }) => this.jobExecutor.run(async () => {
 			const messages = this.state.messages;
 			const lastMessage = messages[messages.length - 1];
-			const updatePart = (part) => isToolUIPart(part) && part.toolCallId === toolCallId ? {
-				...part,
-				state,
-				output,
-				errorText
-			} : part;
+			const updatePart = (part) => {
+				if (!isToolUIPart(part) || part.toolCallId !== toolCallId) return part;
+				const { approval: existingApproval, ...toolPart } = part;
+				const approval = existingApproval?.approved === true ? { approval: {
+					...existingApproval,
+					approved: existingApproval.approved
+				} } : {};
+				return state === "output-error" ? {
+					...toolPart,
+					...approval,
+					state,
+					input: part.input,
+					output: void 0,
+					errorText
+				} : {
+					...toolPart,
+					...approval,
+					state: "output-available",
+					input: part.input,
+					output,
+					errorText: void 0
+				};
+			};
 			this.state.replaceMessage(messages.length - 1, {
 				...lastMessage,
 				parts: lastMessage.parts.map(updatePart)