ai 7.0.134 → 7.0.136

package/dist/index.js

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { GatewayAuthenticationError, GatewayError, createGateway, gateway, gateway as gateway$1 } from "@ai-sdk/gateway";
-import { DEFAULT_MAX_DOWNLOAD_SIZE, DelayedPromise, DownloadError, DownloadError as DownloadError$1, EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL, EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER, asArray, asSchema, asSchema as asSchema$1, cancelResponseBody, convertBase64ToUint8Array, convertUint8ArrayToBase64, createIdGenerator, createIdGenerator as createIdGenerator$1, delay, detectMediaType, dynamicTool, executeTool, experimental_getToolCaller, experimental_toolCaller, fetchUntrustedUrl, filterNullable, generateId, generateId as generateId$1, getErrorMessage, getRuntimeEnvironmentUserAgent, isAbortError, isBuffer, isExecutableTool, isFullMediaType, isNonNullable, isProviderReference, isProviderStreamError, isUrlSupported, jsonSchema, jsonSchema as jsonSchema$1, lazySchema, normalizeHeaders, parseJsonEventStream, parseJsonEventStream as parseJsonEventStream$1, readResponseWithSizeLimit, resolve, retryWithExponentialBackoff, safeParseJSON, safeValidateTypes, tool, tool as tool$1, validateTypes, withUserAgentSuffix, zodSchema, zodSchema as zodSchema$1 } from "@ai-sdk/provider-utils";
+import { DEFAULT_MAX_DOWNLOAD_SIZE, DelayedPromise, DownloadError, DownloadError as DownloadError$1, EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL, EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER, asArray, asSchema, asSchema as asSchema$1, cancelResponseBody, convertBase64ToUint8Array, convertUint8ArrayToBase64, createIdGenerator, createIdGenerator as createIdGenerator$1, delay, detectMediaType, dynamicTool, executeTool, experimental_getToolCaller, experimental_toolCaller, fetchUntrustedUrl, filterNullable, generateId, generateId as generateId$1, getErrorMessage, getRuntimeEnvironmentUserAgent, getWebSocketConstructor, isAbortError, isBuffer, isExecutableTool, isFullMediaType, isNonNullable, isProviderReference, isProviderStreamError, isUrlSupported, jsonSchema, jsonSchema as jsonSchema$1, lazySchema, normalizeHeaders, parseJsonEventStream, parseJsonEventStream as parseJsonEventStream$1, readResponseWithSizeLimit, readWebSocketMessageText, resolve, retryWithExponentialBackoff, safeParseJSON, safeValidateTypes, toWebSocketUrl, tool, tool as tool$1, validateTypes, waitForWebSocketBufferDrain, withUserAgentSuffix, zodSchema, zodSchema as zodSchema$1 } from "@ai-sdk/provider-utils";
 import { AISDKError, AISDKError as AISDKError$1, APICallError, APICallError as APICallError$1, EmptyResponseBodyError, EmptyResponseBodyError as EmptyResponseBodyError$1, Experimental_DecisionRefusalError, Experimental_DecisionRefusalError as Experimental_DecisionRefusalError$1, Experimental_DecisionUnsupportedQuestionTypeError, Experimental_DecisionUnsupportedQuestionTypeError as Experimental_DecisionUnsupportedQuestionTypeError$1, InvalidArgumentError as InvalidArgumentError$1, InvalidPromptError, InvalidPromptError as InvalidPromptError$1, InvalidResponseDataError, InvalidResponseDataError as InvalidResponseDataError$1, JSONParseError, JSONParseError as JSONParseError$1, LoadAPIKeyError, LoadSettingError, NoContentGeneratedError, NoSuchModelError, NoSuchModelError as NoSuchModelError$1, NoSuchProviderReferenceError, TooManyEmbeddingValuesForCallError, TypeValidationError, TypeValidationError as TypeValidationError$1, UnsupportedFunctionalityError, UnsupportedFunctionalityError as UnsupportedFunctionalityError$1, getErrorMessage as getErrorMessage$1, isJSONArray, isJSONObject } from "@ai-sdk/provider";
 import { array, boolean, custom, discriminatedUnion, enum as enum$1, instanceof as instanceof$1, lazy, literal, looseObject, never, null as null$1, number, object, record, string, union, unknown } from "zod/v4";
 //#region src/error/invalid-argument-error.ts
@@ -1174,7 +1174,7 @@ function cloneValue(value) {
 }
 //#endregion
 //#region src/version.ts
-const VERSION = "7.0.134";
+const VERSION = "7.0.136";
 //#endregion
 //#region src/util/download/download.ts
 /**
@@ -6603,7 +6603,7 @@ function createStreamingUIMessageState({ lastMessage, messageId }) {
 		partialToolCalls
 	};
 }
-function processUIMessageStream({ stream, messageMetadataSchema, dataPartSchemas, runUpdateMessageJob, onError, onToolCall, onData, resetStateOnMessageIdChange = false }) {
+function processUIMessageStream({ stream, messageMetadataSchema, dataPartSchemas, runUpdateMessageJob, onError, onToolCall, onData, resetStateOnMessageIdChange = false, resetStateOnFirstMessageStart = false }) {
 	return stream.pipeThrough(new TransformStream({ async transform(chunk, controller) {
 		await runUpdateMessageJob(async ({ state, write }) => {
 			function getCurrentStepParts() {
@@ -7069,7 +7069,7 @@ function processUIMessageStream({ stream, messageMetadataSchema, dataPartSchemas
 					break;
 				}
 				case "start":
-					if (resetStateOnMessageIdChange && chunk.messageId != null && chunk.messageId !== state.message.id) Object.assign(state, createStreamingUIMessageState({
+					if (chunk.messageId != null && (resetStateOnFirstMessageStart || resetStateOnMessageIdChange && chunk.messageId !== state.message.id)) Object.assign(state, createStreamingUIMessageState({
 						lastMessage: void 0,
 						messageId: chunk.messageId
 					}), { finishReason: void 0 });
@@ -9511,6 +9511,7 @@ var DefaultStreamTextResult = class {
 				let chunkTimeoutId = void 0;
 				function resetChunkTimeout() {
 					if (chunkTimeoutId != null) clearTimeout(chunkTimeoutId);
+					if (abortSignal?.aborted) return;
 					chunkTimeoutId = setAbortTimeout({
 						abortController: chunkAbortController,
 						label: "Chunk",
@@ -9523,13 +9524,16 @@ var DefaultStreamTextResult = class {
 						chunkTimeoutId = void 0;
 					}
 				}
+				function clearModelOutputTimeouts() {
+					clearFirstChunkTimeout();
+					clearChunkTimeout();
+				}
 				function clearStepTimeout() {
 					if (stepTimeoutId != null) clearTimeout(stepTimeoutId);
 				}
 				function clearStepTimeouts() {
 					clearStepTimeout();
-					clearFirstChunkTimeout();
-					clearChunkTimeout();
+					clearModelOutputTimeouts();
 				}
 				function cleanupStepTimeouts() {
 					abortSignal?.removeEventListener("abort", cleanupStepTimeouts);
@@ -9664,7 +9668,6 @@ var DefaultStreamTextResult = class {
 					let automaticStreamRetryCount = 0;
 					let callbackStreamRetryCount = 0;
 					let bufferedAttemptParts = [];
-					const outputChunksHandledBeforeBuffering = /* @__PURE__ */ new WeakSet();
 					const openTextParts = /* @__PURE__ */ new Set();
 					const openReasoningParts = /* @__PURE__ */ new Set();
 					let enqueueStreamRetryAttemptBoundary = false;
@@ -9703,28 +9706,36 @@ var DefaultStreamTextResult = class {
 								openReasoningParts.clear();
 							};
 							while (true) {
-								const { done, value } = await languageModelStreamReader.read();
+								let result;
+								try {
+									result = await languageModelStreamReader.read();
+								} catch (error) {
+									clearModelOutputTimeouts();
+									throw error;
+								}
+								const { done, value } = result;
 								if (enqueueStreamRetryAttemptBoundary) {
 									controller.enqueue(createStreamRetryAttemptBoundaryPart({ warnings: !done && value.type === "model-call-start" ? value.warnings : [] }));
 									enqueueStreamRetryAttemptBoundary = false;
 								}
 								if (done) {
+									clearModelOutputTimeouts();
 									flushBufferedAttemptParts();
 									controller.close();
 									return;
 								}
 								const isToolPart = value.type === "tool-input-start" || value.type === "tool-input-delta" || value.type === "tool-input-end" || value.type === "tool-call" || value.type === "tool-approval-request" || value.type === "tool-approval-response" || value.type === "tool-result" || value.type === "tool-error";
 								if (value.type === "model-call-end") {
+									clearModelOutputTimeouts();
 									flushBufferedAttemptParts();
 									enqueueAttemptPart(value);
 									return;
 								}
+								if (isOutputChunk(value)) {
+									clearFirstChunkTimeout();
+									resetChunkTimeout();
+								}
 								if (shouldBufferToolParts && value.type !== "error" && (isToolPart || bufferedAttemptParts.length > 0)) {
-									if (isOutputChunk(value)) {
-										clearFirstChunkTimeout();
-										resetChunkTimeout();
-										outputChunksHandledBeforeBuffering.add(value);
-									}
 									bufferedAttemptParts.push(value);
 									continue;
 								}
@@ -9732,6 +9743,7 @@ var DefaultStreamTextResult = class {
 									enqueueAttemptPart(value);
 									return;
 								}
+								clearModelOutputTimeouts();
 								await notify({
 									event: { chunk: value },
 									callbacks: onChunk
@@ -9769,10 +9781,12 @@ var DefaultStreamTextResult = class {
 								request = retryLanguageModelCall.request;
 								response = retryLanguageModelCall.response;
 								languageModelStreamReader = retryLanguageModelCall.stream.getReader();
+								startFirstChunkTimeout();
 								enqueueStreamRetryAttemptBoundary = true;
 							}
 						},
 						cancel(reason) {
+							clearModelOutputTimeouts();
 							return languageModelStreamReader.cancel(reason);
 						}
 					});
@@ -9875,12 +9889,7 @@ var DefaultStreamTextResult = class {
 								});
 							}
 							const chunkType = chunk.type;
-							if (isOutputChunk(chunk)) {
-								const timeoutHandledBeforeBuffering = outputChunksHandledBeforeBuffering.has(chunk);
-								if (!hasReceivedOutputChunk && !timeoutHandledBeforeBuffering) clearFirstChunkTimeout();
-								hasReceivedOutputChunk = true;
-								if (!timeoutHandledBeforeBuffering) resetChunkTimeout();
-							}
+							if (isOutputChunk(chunk)) hasReceivedOutputChunk = true;
 							switch (chunkType) {
 								case "file":
 								case "custom":
@@ -10310,6 +10319,27 @@ var DefaultStreamTextResult = class {
 	}
 };
 //#endregion
+//#region src/agent/default-stop-condition.ts
+/**
+* Stop conditions are only evaluated when the tool loop can otherwise continue,
+* so logging here avoids warning when a call finishes naturally at the limit.
+*/
+function createDefaultStopCondition(stepCount) {
+	return ({ steps }) => {
+		if (steps.length !== stepCount) return false;
+		const { provider, modelId } = steps[steps.length - 1].model;
+		logWarnings({
+			provider,
+			model: modelId,
+			warnings: [{
+				type: "other",
+				message: `The tool loop stopped because it reached the default stopWhen condition, isStepCount(${stepCount}). To allow more steps, set stopWhen to isStepCount(...) with a higher limit or provide a custom stop condition. Learn more: https://ai-sdk.dev/docs/agents/loop-control`
+			}]
+		});
+		return true;
+	};
+}
+//#endregion
 //#region src/agent/tool-loop-agent.ts
 /**
 * A tool loop agent is an agent that runs tools in a loop. In each step,
@@ -10358,7 +10388,7 @@ var ToolLoopAgent = class {
 		const { onStart: _settingsStableOnStart, experimental_onStart: _settingsExperimentalOnStart, onStepStart: _settingsStableOnStepStart, experimental_onStepStart: _settingsExperimentalOnStepStart, onToolExecutionStart: _settingsOnToolExecutionStart, onToolExecutionEnd: _settingsOnToolExecutionEnd, onStepEnd: _settingsOnStepEnd, onStepFinish: _settingsOnStepFinish, onFinish: _settingsOnFinish, onEnd: _settingsOnEnd, ...settingsWithoutCallbacks } = this.settings;
 		const baseCallArgs = {
 			...settingsWithoutCallbacks,
-			stopWhen: this.settings.stopWhen ?? isStepCount(20),
+			stopWhen: this.settings.stopWhen ?? createDefaultStopCondition(20),
 			...options
 		};
 		const { instructions, allowSystemInMessages, messages, prompt, runtimeContext, ...callArgs } = await this.settings.prepareCall?.(baseCallArgs) ?? baseCallArgs;
@@ -12184,6 +12214,15 @@ function createRestrictedTelemetryDispatcher$2({ telemetry }) {
 	};
 }
 //#endregion
+//#region src/embed/validate-embedding-dimensions.ts
+function validateEmbeddingDimensions(dimensions) {
+	if (dimensions !== void 0 && (!Number.isInteger(dimensions) || dimensions <= 0)) throw new InvalidArgumentError({
+		parameter: "dimensions",
+		value: dimensions,
+		message: "dimensions must be a positive integer"
+	});
+}
+//#endregion
 //#region src/embed/embed.ts
 const originalGenerateCallId$6 = createIdGenerator$1({
 	prefix: "call",
@@ -12195,6 +12234,8 @@ const originalGenerateCallId$6 = createIdGenerator$1({
 * @param model - The embedding model to use.
 * @param value - The value that should be embedded.
 *
+* @param dimensions - Requested output dimensions. Must be a positive integer. Requires provider support.
+*
 * @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.
@@ -12208,7 +12249,8 @@ const originalGenerateCallId$6 = 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$6 } = {} }) {
+async function embed({ model: modelArg, value, dimensions, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry, telemetry = experimental_telemetry, runtimeContext = {}, onStart, experimental_onStart, onEnd, experimental_onEnd, _internal: { generateCallId = originalGenerateCallId$6 } = {} }) {
+	validateEmbeddingDimensions(dimensions);
 	const model = resolveEmbeddingModel(modelArg);
 	const { maxRetries, retry } = prepareRetries({
 		maxRetries: maxRetriesArg,
@@ -12227,6 +12269,7 @@ async function embed({ model: modelArg, value, providerOptions, maxRetries: maxR
 		provider: model.provider,
 		modelId: model.modelId,
 		value,
+		dimensions,
 		maxRetries,
 		headers: headersWithUserAgent,
 		providerOptions
@@ -12249,12 +12292,14 @@ async function embed({ model: modelArg, value, providerOptions, maxRetries: maxR
 							operationId: "ai.embed.doEmbed",
 							provider: model.provider,
 							modelId: model.modelId,
-							values: [value]
+							values: [value],
+							dimensions
 						},
 						callbacks: [telemetryDispatcher.onEmbedStart]
 					});
 					const modelResponse = await model.doEmbed({
 						values: [value],
+						dimensions,
 						abortSignal,
 						headers: headersWithUserAgent,
 						providerOptions
@@ -12383,6 +12428,8 @@ const originalGenerateCallId$5 = createIdGenerator$1({
 * @param model - The embedding model to use.
 * @param values - The values that should be embedded.
 *
+* @param dimensions - Requested output dimensions. Must be a positive integer. Requires provider support.
+*
 * @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.
@@ -12400,7 +12447,8 @@ const originalGenerateCallId$5 = 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$5 } = {} }) {
+async function embedMany({ model: modelArg, values, dimensions, maxParallelCalls = Infinity, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry, telemetry = experimental_telemetry, runtimeContext = {}, onStart, experimental_onStart, onEnd, experimental_onEnd, _internal: { generateCallId = originalGenerateCallId$5 } = {} }) {
+	validateEmbeddingDimensions(dimensions);
 	const model = resolveEmbeddingModel(modelArg);
 	const { maxRetries, retry } = prepareRetries({
 		maxRetries: maxRetriesArg,
@@ -12419,6 +12467,7 @@ async function embedMany({ model: modelArg, values, maxParallelCalls = Infinity,
 		provider: model.provider,
 		modelId: model.modelId,
 		value: values,
+		dimensions,
 		maxRetries,
 		headers: headersWithUserAgent,
 		providerOptions
@@ -12449,12 +12498,14 @@ async function embedMany({ model: modelArg, values, maxParallelCalls = Infinity,
 								operationId: "ai.embedMany.doEmbed",
 								provider: model.provider,
 								modelId: model.modelId,
-								values
+								values,
+								dimensions
 							},
 							callbacks: [telemetryDispatcher.onEmbedStart]
 						});
 						const modelResponse = await model.doEmbed({
 							values,
+							dimensions,
 							abortSignal,
 							headers: headersWithUserAgent,
 							providerOptions
@@ -12548,12 +12599,14 @@ async function embedMany({ model: modelArg, values, maxParallelCalls = Infinity,
 									operationId: "ai.embedMany.doEmbed",
 									provider: model.provider,
 									modelId: model.modelId,
-									values: chunk
+									values: chunk,
+									dimensions
 								},
 								callbacks: [telemetryDispatcher.onEmbedStart]
 							});
 							const modelResponse = await model.doEmbed({
 								values: chunk,
+								dimensions,
 								abortSignal,
 								headers: headersWithUserAgent,
 								providerOptions: chunkProviderOptions
@@ -12733,7 +12786,7 @@ function createRestrictedTelemetryDispatcher$1({ telemetry }) {
 //#endregion
 //#region src/decide/validate-decision.ts
 const tolerance = 1e-6;
-function isRecord(value) {
+function isRecord$1(value) {
 	if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
 	const prototype = Object.getPrototypeOf(value);
 	return prototype === Object.prototype || prototype === null;
@@ -12741,7 +12794,7 @@ function isRecord(value) {
 function isJSON(value, ancestors = /* @__PURE__ */ new Set()) {
 	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
 	if (typeof value === "number") return Number.isFinite(value);
-	if (typeof value !== "object" || !Array.isArray(value) && !isRecord(value)) return false;
+	if (typeof value !== "object" || !Array.isArray(value) && !isRecord$1(value)) return false;
 	if (ancestors.has(value)) return false;
 	ancestors.add(value);
 	const valid = Object.getOwnPropertySymbols(value).length === 0 && (Array.isArray(value) ? Array.from(value).every((item) => isJSON(item, ancestors)) : Object.values(value).every((item) => isJSON(item, ancestors)));
@@ -12749,7 +12802,7 @@ function isJSON(value, ancestors = /* @__PURE__ */ new Set()) {
 	return valid;
 }
 function isInput(value) {
-	return (typeof value === "string" || Array.isArray(value) || isRecord(value)) && isJSON(value);
+	return (typeof value === "string" || Array.isArray(value) || isRecord$1(value)) && isJSON(value);
 }
 function invalidInput(parameter, value, message) {
 	throw new InvalidArgumentError({
@@ -12760,29 +12813,29 @@ function invalidInput(parameter, value, message) {
 }
 function validateDecisionInput({ state, questions }) {
 	if (!(Array.isArray(state) ? Array.from(state).every((part) => {
-		if (!isRecord(part)) return false;
+		if (!isRecord$1(part)) return false;
 		switch (part.type) {
 			case "text": return textPartSchema.safeParse(part).success;
 			case "file": return filePartSchema.safeParse(part).success;
 			case "json": return isJSON(part.value);
 			default: return false;
 		}
-	}) : (typeof state === "string" || isRecord(state)) && isJSON(state))) invalidInput("state", state, "must be a string, JSON object, or array of text, file, or json parts");
-	if (!isRecord(questions) || Object.keys(questions).length === 0) invalidInput("questions", questions, "must be a nonempty question map");
+	}) : (typeof state === "string" || isRecord$1(state)) && isJSON(state))) invalidInput("state", state, "must be a string, JSON object, or array of text, file, or json parts");
+	if (!isRecord$1(questions) || Object.keys(questions).length === 0) invalidInput("questions", questions, "must be a nonempty question map");
 	for (const [id, question] of Object.entries(questions)) {
 		const parameter = `questions.${id}`;
-		if (!isRecord(question) || !isInput(question.instructions)) invalidInput(parameter, question, "instructions must be a JSON-compatible string, object, or array");
+		if (!isRecord$1(question) || !isInput(question.instructions)) invalidInput(parameter, question, "instructions must be a JSON-compatible string, object, or array");
 		const criteria = question.criteria;
 		switch (question.type) {
 			case "choice":
-				if (!isRecord(criteria) || Object.keys(criteria).length === 0) invalidInput(parameter, question, "choice criteria must be a nonempty option map");
+				if (!isRecord$1(criteria) || Object.keys(criteria).length === 0) invalidInput(parameter, question, "choice criteria must be a nonempty option map");
 				break;
 			case "score":
 				if (!Array.isArray(criteria) || criteria.length < 2) invalidInput(parameter, question, "score criteria must contain at least two ordered levels");
 				break;
 			case "boolean":
 				if (criteria === void 0) continue;
-				if (!isRecord(criteria) || Object.keys(criteria).some((key) => key !== "true" && key !== "false")) invalidInput(parameter, question, "boolean criteria may only describe true and false");
+				if (!isRecord$1(criteria) || Object.keys(criteria).some((key) => key !== "true" && key !== "false")) invalidInput(parameter, question, "boolean criteria may only describe true and false");
 				break;
 			default: invalidInput(parameter, question, "question type must be choice, score, or boolean");
 		}
@@ -12802,7 +12855,7 @@ function hasExactKeys(value, keys) {
 	return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
 }
 function validateDistribution(value, keys, answers, id, roundingError) {
-	if (!isRecord(value) || !hasExactKeys(value, keys) || !Object.values(value).every(isProbability)) invalidAnswer(answers, `Question "${id}" must have a complete distribution of finite probabilities in [0, 1].`);
+	if (!isRecord$1(value) || !hasExactKeys(value, keys) || !Object.values(value).every(isProbability)) invalidAnswer(answers, `Question "${id}" must have a complete distribution of finite probabilities in [0, 1].`);
 	const sum = Object.values(value).reduce((total, probability) => total + probability, 0);
 	if (Math.abs(sum - 1) > tolerance + keys.length * roundingError) invalidAnswer(answers, `Question "${id}" probabilities must sum to 1 within the declared rounding precision.`);
 }
@@ -12814,11 +12867,11 @@ function validateDecisionAnswers({ questions, answers, rounding }) {
 	}
 	const probabilityError = roundingError(rounding?.probabilityDecimals);
 	const scoreError = roundingError(rounding?.scoreDecimals);
-	if (!isRecord(answers) || !hasExactKeys(answers, Object.keys(questions))) invalidAnswer(answers, "Decision must return exactly one answer for every question.");
+	if (!isRecord$1(answers) || !hasExactKeys(answers, Object.keys(questions))) invalidAnswer(answers, "Decision must return exactly one answer for every question.");
 	for (const [id, question] of Object.entries(questions)) {
 		const answer = answers[id];
-		if (isRecord(answer) && answer.type === "refusal") continue;
-		if (!isRecord(answer) || answer.type !== question.type) invalidAnswer(answers, `Question "${id}" returned an answer with the wrong type.`);
+		if (isRecord$1(answer) && answer.type === "refusal") continue;
+		if (!isRecord$1(answer) || answer.type !== question.type) invalidAnswer(answers, `Question "${id}" returned an answer with the wrong type.`);
 		switch (question.type) {
 			case "choice":
 				if (typeof answer.choice !== "string" || !Object.hasOwn(question.criteria, answer.choice)) invalidAnswer(answers, `Question "${id}" selected an unknown option.`);
@@ -13721,15 +13774,20 @@ var SerialJobExecutor = class {
 	constructor() {
 		this.queue = [];
 		this.isProcessing = false;
+		this.idleWaiters = [];
 	}
 	async processQueue() {
 		if (this.isProcessing) return;
 		this.isProcessing = true;
-		while (this.queue.length > 0) {
-			await this.queue[0]();
-			this.queue.shift();
+		try {
+			while (this.queue.length > 0) {
+				await this.queue[0]();
+				this.queue.shift();
+			}
+		} finally {
+			this.isProcessing = false;
+			for (const resolve of this.idleWaiters.splice(0)) resolve();
 		}
-		this.isProcessing = false;
 	}
 	async run(job) {
 		return new Promise((resolve, reject) => {
@@ -13744,6 +13802,12 @@ var SerialJobExecutor = class {
 			this.processQueue();
 		});
 	}
+	async waitForIdle() {
+		if (!this.isProcessing && this.queue.length === 0) return;
+		await new Promise((resolve) => {
+			this.idleWaiters.push(resolve);
+		});
+	}
 };
 //#endregion
 //#region src/util/simulate-readable-stream.ts
@@ -19677,6 +19741,8 @@ var AbstractChat = class {
 		this.activeResumeRequest = void 0;
 		this.resumableStreamState = void 0;
 		this.jobExecutor = new SerialJobExecutor();
+		this.activeStopCount = 0;
+		this.stopGeneration = 0;
 		this.sendMessage = async (message, options) => {
 			if (message == null) {
 				let messageId = this.pendingApprovalMessageId;
@@ -19793,15 +19859,16 @@ var AbstractChat = class {
 				this.pendingApprovalMessageId = message.id;
 			}
 			if (this.activeResponse) this.activeResponse.state.message.parts = this.activeResponse.state.message.parts.map(updatePart);
-			if (this.status !== "streaming" && this.status !== "submitted" && this.sendAutomaticallyWhen) {
-				if (await this.shouldSendAutomatically()) {
+			if (messageIndex !== -1 && this.status !== "streaming" && this.status !== "submitted" && this.sendAutomaticallyWhen) {
+				const shouldSend = await this.shouldSendAutomatically();
+				if (shouldSend) this.runAutomaticRequest(() => {
 					const messageId = messageIndex === -1 ? this.lastMessage?.id : messages[messageIndex].id;
-					this.makeRequestForToolApproval({
+					return this.makeRequestForToolApproval({
 						messageId,
 						messageIndex,
 						...options
 					});
-				}
+				}, shouldSend);
 			}
 		});
 		this.addToolOutput = async ({ state, toolCallId, output, errorText, options }) => this.jobExecutor.run(async () => {
@@ -19836,18 +19903,33 @@ var AbstractChat = class {
 			});
 			if (this.activeResponse) this.activeResponse.state.message.parts = this.activeResponse.state.message.parts.map(updatePart);
 			if (this.status !== "streaming" && this.status !== "submitted" && this.sendAutomaticallyWhen) {
-				if (await this.shouldSendAutomatically()) this.makeRequest({
+				const shouldSend = await this.shouldSendAutomatically();
+				if (shouldSend) this.runAutomaticRequest(() => this.makeRequest({
 					trigger: "submit-message",
 					messageId: this.lastMessage?.id,
 					...options
-				});
+				}), shouldSend);
 			}
 		});
 		this.addToolResult = this.addToolOutput;
 		this.stop = async () => {
-			for (const controller of this.pendingMessagePreparations) controller.abort();
-			this.activeResumeRequest?.abortController.abort();
-			this.activeResponse?.abortController.abort();
+			this.activeStopCount++;
+			this.stopGeneration++;
+			try {
+				const activeResumeRequest = this.activeResumeRequest;
+				const activeResponse = this.activeResponse;
+				for (const controller of this.pendingMessagePreparations) controller.abort();
+				activeResumeRequest?.abortController.abort();
+				activeResponse?.abortController.abort();
+				await Promise.all([activeResumeRequest?.completionPromise, activeResponse?.completionPromise]);
+				await this.jobExecutor.waitForIdle();
+			} finally {
+				this.activeStopCount--;
+			}
+		};
+		this.dispose = async () => {
+			await this.stop();
+			this.transport.close?.();
 		};
 		this.id = id;
 		this.transport = transport;
@@ -19898,6 +19980,13 @@ var AbstractChat = class {
 		if (result && typeof result === "object" && "then" in result) return await result;
 		return result;
 	}
+	async runAutomaticRequest(request, shouldSend) {
+		const stopGeneration = this.stopGeneration;
+		const startedWhileStopping = this.activeStopCount > 0;
+		if (!(shouldSend ?? await this.shouldSendAutomatically())) return;
+		if (startedWhileStopping || stopGeneration !== this.stopGeneration || this.activeStopCount > 0) return;
+		await request();
+	}
 	async makeRequestForToolApproval({ messageId, messageIndex, ...options }) {
 		const consumesPendingApproval = messageId != null && messageId === this.pendingApprovalMessageId;
 		if (consumesPendingApproval) this.pendingApprovalMessageId = void 0;
@@ -19908,10 +19997,24 @@ var AbstractChat = class {
 		});
 		if (consumesPendingApproval && this.status === "error" && this.pendingApprovalMessageId == null) this.pendingApprovalMessageId = this.state.messages[messageIndex]?.id ?? messageId;
 	}
-	async makeRequest({ trigger, metadata, headers, body, messageId }) {
+	async makeRequest(options) {
+		const completion = createResolvablePromise();
+		try {
+			await this.makeRequestImpl({
+				...options,
+				completionPromise: completion.promise
+			});
+		} finally {
+			completion.resolve();
+		}
+	}
+	async makeRequestImpl({ trigger, metadata, headers, body, messageId, completionPromise }) {
 		if (trigger !== "resume-stream") this.resumableStreamState = void 0;
 		const abortController = new AbortController();
-		const activeResumeRequest = trigger === "resume-stream" ? { abortController } : void 0;
+		const activeResumeRequest = trigger === "resume-stream" ? {
+			abortController,
+			completionPromise
+		} : void 0;
 		if (activeResumeRequest) {
 			this.activeResumeRequest?.abortController.abort();
 			this.activeResumeRequest = activeResumeRequest;
@@ -19982,7 +20085,8 @@ var AbstractChat = class {
 					lastMessage: trigger === "resume-stream" ? resumableResponseMessage : trigger === "regenerate-message" ? void 0 : this.state.snapshot(responseMessage),
 					messageId: this.generateId()
 				}),
-				abortController
+				abortController,
+				completionPromise
 			};
 			activeResponse = response;
 			response.abortController.signal.addEventListener("abort", () => {
@@ -20018,6 +20122,7 @@ var AbstractChat = class {
 				stream: processUIMessageStream({
 					stream,
 					resetStateOnMessageIdChange: trigger === "resume-stream",
+					resetStateOnFirstMessageStart: trigger === "resume-stream" && this.transport.resumeStreamIsReplay,
 					onToolCall: this.onToolCall,
 					onData: this.onData,
 					messageMetadataSchema: this.messageMetadataSchema,
@@ -20080,13 +20185,13 @@ var AbstractChat = class {
 				clearActiveResumeRequest();
 			}
 		}
-		if (!isError && await this.shouldSendAutomatically()) await this.makeRequest({
+		if (!isAbort && !isError) await this.runAutomaticRequest(() => this.makeRequest({
 			trigger: "submit-message",
 			messageId: this.lastMessage?.id,
 			metadata,
 			headers,
 			body
-		});
+		}));
 	}
 };
 //#endregion
@@ -20221,6 +20326,460 @@ var TextStreamChatTransport = class extends HttpChatTransport {
 	}
 };
 //#endregion
+//#region src/ui/websocket-chat-transport.ts
+const WEBSOCKET_OPEN_STATE = 1;
+function createAbortError(signal) {
+	const reason = signal?.reason;
+	if (reason instanceof Error) return reason;
+	const error = /* @__PURE__ */ new Error("The WebSocket chat request was aborted.");
+	error.name = "AbortError";
+	return error;
+}
+function asError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+function isRecord(value) {
+	return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function isStringRecord(value) {
+	return isRecord(value) && Object.values(value).every((item) => typeof item === "string");
+}
+function isSequence(value) {
+	return Number.isSafeInteger(value) && value >= 0;
+}
+/**
+* Validates an untrusted client-to-server WebSocket chat frame.
+*/
+async function safeValidateWebSocketChatTransportRequest({ value }) {
+	try {
+		if (!isRecord(value) || typeof value.type !== "string") throw new Error("Invalid WebSocket chat request frame.");
+		if (value.type === "abort") {
+			if (typeof value.requestId !== "string") throw new Error("Invalid WebSocket chat abort request.");
+			return {
+				success: true,
+				data: value
+			};
+		}
+		if (typeof value.requestId !== "string" || typeof value.id !== "string" || !isStringRecord(value.headers) || !isRecord(value.body)) throw new Error("Invalid WebSocket chat request frame.");
+		if (value.type === "resume") {
+			if (value.lastSequence !== void 0 && !isSequence(value.lastSequence)) throw new Error("Invalid WebSocket chat resume sequence.");
+			return {
+				success: true,
+				data: value
+			};
+		}
+		if (value.type !== "send" || !["submit-message", "regenerate-message"].includes(value.trigger) || value.messageId !== void 0 && typeof value.messageId !== "string") throw new Error("Invalid WebSocket chat send request.");
+		const messages = await safeValidateUIMessages({ messages: value.messages });
+		if (!messages.success) throw new Error("Invalid UI messages in WebSocket chat request.", { cause: messages.error });
+		return {
+			success: true,
+			data: {
+				...value,
+				messages: messages.data
+			}
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: asError(error)
+		};
+	}
+}
+/**
+* A `ChatTransport` that multiplexes correlated UI message streams over one
+* persistent WebSocket connection.
+*
+* The server must implement the protocol represented by
+* `WebSocketChatTransportRequest` and `WebSocketChatTransportResponse`.
+*/
+var WebSocketChatTransport = class {
+	constructor(options) {
+		this.resumeStreamIsReplay = true;
+		this.activeRequests = /* @__PURE__ */ new Map();
+		this.sendQueue = Promise.resolve();
+		this.url = options.url;
+		this.protocols = options.protocols;
+		this.params = options.params;
+		this.headers = options.headers;
+		this.body = options.body;
+		this.webSocket = options.webSocket;
+		this.prepareSendMessagesRequest = options.prepareSendMessagesRequest;
+		this.prepareReconnectToStreamRequest = options.prepareReconnectToStreamRequest;
+	}
+	async sendMessages({ abortSignal, ...options }) {
+		this.throwIfAborted(abortSignal);
+		const [resolvedHeaders, resolvedBody] = await Promise.all([resolve(this.headers), resolve(this.body)]);
+		this.throwIfAborted(abortSignal);
+		const headers = {
+			...normalizeHeaders(resolvedHeaders),
+			...normalizeHeaders(options.headers)
+		};
+		const body = {
+			...resolvedBody,
+			...options.body
+		};
+		const preparedRequest = await this.prepareSendMessagesRequest?.({
+			id: options.chatId,
+			messages: options.messages,
+			requestMetadata: options.metadata,
+			body,
+			headers,
+			trigger: options.trigger,
+			messageId: options.messageId
+		});
+		this.throwIfAborted(abortSignal);
+		const socket = await this.getSocket(abortSignal);
+		const requestId = generateId$1();
+		const request = this.createActiveRequest({
+			requestId,
+			kind: "send",
+			lastSequence: -1,
+			abortSignal
+		});
+		const frame = {
+			type: "send",
+			requestId,
+			id: options.chatId,
+			trigger: options.trigger,
+			messageId: options.messageId,
+			messages: preparedRequest?.messages ?? options.messages,
+			headers: preparedRequest?.headers == null ? headers : normalizeHeaders(preparedRequest.headers),
+			body: preparedRequest?.body ?? body,
+			metadata: options.metadata
+		};
+		try {
+			await this.sendFrame(socket, frame, abortSignal);
+			return request.stream;
+		} catch (error) {
+			const requestError = asError(error);
+			this.failRequest(request, requestError);
+			throw requestError;
+		}
+	}
+	async reconnectToStream(options) {
+		this.throwIfAborted(options.abortSignal);
+		const [resolvedHeaders, resolvedBody] = await Promise.all([resolve(this.headers), resolve(this.body)]);
+		this.throwIfAborted(options.abortSignal);
+		const headers = {
+			...normalizeHeaders(resolvedHeaders),
+			...normalizeHeaders(options.headers)
+		};
+		const body = {
+			...resolvedBody,
+			...options.body
+		};
+		const preparedRequest = await this.prepareReconnectToStreamRequest?.({
+			id: options.chatId,
+			requestMetadata: options.metadata,
+			body,
+			headers
+		});
+		this.throwIfAborted(options.abortSignal);
+		const socket = await this.getSocket(options.abortSignal);
+		const requestId = generateId$1();
+		let resolveResponse;
+		let rejectResponse;
+		const responsePromise = new Promise((resolve, reject) => {
+			resolveResponse = resolve;
+			rejectResponse = reject;
+		});
+		responsePromise.catch(() => {});
+		const request = this.createActiveRequest({
+			requestId,
+			kind: "resume",
+			lastSequence: -1,
+			abortSignal: options.abortSignal,
+			resolveResponse,
+			rejectResponse
+		});
+		const frame = {
+			type: "resume",
+			requestId,
+			id: options.chatId,
+			lastSequence: void 0,
+			headers: preparedRequest?.headers == null ? headers : normalizeHeaders(preparedRequest.headers),
+			body: preparedRequest?.body ?? body,
+			metadata: options.metadata
+		};
+		try {
+			await this.sendFrame(socket, frame, options.abortSignal);
+		} catch (error) {
+			const requestError = asError(error);
+			request.responseSettled = true;
+			this.failRequest(request, requestError);
+			throw requestError;
+		}
+		return responsePromise;
+	}
+	/**
+	* Closes the current connection and errors any active response streams.
+	* A later request opens a new connection.
+	*/
+	close() {
+		const error = /* @__PURE__ */ new Error("WebSocket chat transport was closed.");
+		const connection = this.connection;
+		this.connection = void 0;
+		this.failAllRequests(error);
+		if (connection != null) {
+			this.rejectConnection(connection, error);
+			try {
+				connection.socket?.close(1e3, "Client closed transport");
+			} catch {}
+		}
+	}
+	throwIfAborted(abortSignal) {
+		if (abortSignal?.aborted) throw createAbortError(abortSignal);
+	}
+	async getSocket(abortSignal) {
+		const existingSocket = this.connection?.socket;
+		if (existingSocket?.readyState === WEBSOCKET_OPEN_STATE) return existingSocket;
+		if (this.connection == null) {
+			let resolveConnection;
+			let rejectConnection;
+			const connection = {
+				promise: new Promise((resolve, reject) => {
+					resolveConnection = resolve;
+					rejectConnection = reject;
+				}),
+				resolve: resolveConnection,
+				reject: rejectConnection,
+				settled: false
+			};
+			this.connection = connection;
+			this.initializeConnection(connection);
+		}
+		const connection = this.connection;
+		if (connection == null) throw new Error("Failed to initialize WebSocket connection.");
+		return this.waitForConnection(connection.promise, abortSignal);
+	}
+	async initializeConnection(connection) {
+		try {
+			const params = await resolve(this.params);
+			if (this.connection !== connection) return;
+			const url = this.buildUrl(params);
+			const socket = new (getWebSocketConstructor(this.webSocket))(url, this.protocols);
+			connection.socket = socket;
+			let messageTail = Promise.resolve();
+			socket.onopen = () => {
+				if (this.connection !== connection) return;
+				this.resolveConnection(connection, socket);
+			};
+			socket.onmessage = (event) => {
+				messageTail = messageTail.then(() => readWebSocketMessageText(event.data)).then((text) => this.handleResponseFrame(connection, text)).catch((error) => {
+					this.terminateConnection(connection, asError(error));
+				});
+			};
+			socket.onerror = () => {
+				this.terminateConnection(connection, /* @__PURE__ */ new TypeError("WebSocket chat network connection failed."));
+			};
+			socket.onclose = (event) => {
+				messageTail = messageTail.then(() => {
+					if (this.connection !== connection) return;
+					const closeEvent = event;
+					const code = typeof closeEvent?.code === "number" ? closeEvent.code : void 0;
+					const reason = typeof closeEvent?.reason === "string" && closeEvent.reason !== "" ? `: ${closeEvent.reason}` : "";
+					this.terminateConnection(connection, /* @__PURE__ */ new TypeError(`WebSocket chat network connection closed${code == null ? "" : ` (code ${code}${reason})`}.`), false);
+				}).catch((error) => {
+					this.terminateConnection(connection, asError(error));
+				});
+			};
+		} catch (error) {
+			this.terminateConnection(connection, asError(error), false);
+		}
+	}
+	buildUrl(params) {
+		let url;
+		try {
+			const baseUrl = typeof globalThis.location === "undefined" ? void 0 : globalThis.location.href;
+			url = new URL(this.url, baseUrl);
+			url = toWebSocketUrl(url);
+		} catch {
+			throw new Error("Invalid WebSocket chat URL. Use an absolute URL outside the browser.");
+		}
+		if (!["ws:", "wss:"].includes(url.protocol) || url.hostname === "") throw new Error("Invalid WebSocket chat URL. Expected ws:// or wss://.");
+		if (url.hash !== "") throw new Error("Invalid WebSocket chat URL. Fragments are not allowed.");
+		for (const [key, value] of Object.entries(params ?? {})) url.searchParams.set(key, value);
+		return url;
+	}
+	waitForConnection(promise, abortSignal) {
+		if (abortSignal == null) return promise;
+		if (abortSignal.aborted) return Promise.reject(createAbortError(abortSignal));
+		return new Promise((resolve, reject) => {
+			const onAbort = () => {
+				reject(createAbortError(abortSignal));
+			};
+			abortSignal.addEventListener("abort", onAbort, { once: true });
+			promise.then((socket) => {
+				abortSignal.removeEventListener("abort", onAbort);
+				resolve(socket);
+			}, (error) => {
+				abortSignal.removeEventListener("abort", onAbort);
+				reject(error);
+			});
+		});
+	}
+	resolveConnection(connection, socket) {
+		if (connection.settled) return;
+		connection.settled = true;
+		connection.resolve(socket);
+	}
+	rejectConnection(connection, error) {
+		if (connection.settled) return;
+		connection.settled = true;
+		connection.reject(error);
+	}
+	terminateConnection(connection, error, closeSocket = true) {
+		if (this.connection !== connection) return;
+		this.connection = void 0;
+		this.rejectConnection(connection, error);
+		this.failAllRequests(error);
+		if (closeSocket) try {
+			connection.socket?.close(1011, "WebSocket chat transport error");
+		} catch {}
+	}
+	createActiveRequest({ requestId, kind, lastSequence, abortSignal, resolveResponse, rejectResponse }) {
+		let controller;
+		const request = {
+			requestId,
+			kind,
+			lastSequence,
+			stream: new ReadableStream({
+				start(streamController) {
+					controller = streamController;
+				},
+				cancel: () => {
+					this.abortRequest(requestId, false);
+				}
+			}),
+			controller,
+			responseSettled: false,
+			resolveResponse,
+			rejectResponse,
+			abortSignal
+		};
+		this.activeRequests.set(requestId, request);
+		if (abortSignal != null) {
+			const abortListener = () => {
+				this.abortRequest(requestId, true);
+			};
+			request.abortListener = abortListener;
+			abortSignal.addEventListener("abort", abortListener, { once: true });
+			if (abortSignal.aborted) abortListener();
+		}
+		return request;
+	}
+	abortRequest(requestId, closeStream) {
+		const request = this.activeRequests.get(requestId);
+		if (request == null) return;
+		const error = createAbortError(request.abortSignal);
+		if (request.kind === "resume" && !request.responseSettled) {
+			request.responseSettled = true;
+			request.rejectResponse?.(error);
+		}
+		this.cleanupRequest(request);
+		if (closeStream) try {
+			request.controller.close();
+		} catch {}
+		const socket = this.connection?.socket;
+		if (socket?.readyState === WEBSOCKET_OPEN_STATE) this.sendFrame(socket, {
+			type: "abort",
+			requestId
+		}).catch(() => {});
+	}
+	cleanupRequest(request) {
+		this.activeRequests.delete(request.requestId);
+		if (request.abortListener != null) {
+			request.abortSignal?.removeEventListener("abort", request.abortListener);
+			request.abortListener = void 0;
+		}
+	}
+	failRequest(request, error) {
+		if (!this.activeRequests.has(request.requestId)) return;
+		if (request.kind === "resume" && !request.responseSettled) {
+			request.responseSettled = true;
+			request.rejectResponse?.(error);
+		}
+		this.cleanupRequest(request);
+		try {
+			request.controller.error(error);
+		} catch {}
+	}
+	failAllRequests(error) {
+		for (const request of [...this.activeRequests.values()]) this.failRequest(request, error);
+	}
+	resolveResumeStream(request) {
+		if (request.kind !== "resume" || request.responseSettled) return;
+		request.responseSettled = true;
+		request.resolveResponse?.(request.stream);
+	}
+	async validateResponseChunk(value) {
+		const chunk = await safeValidateTypes({
+			value,
+			schema: uiMessageChunkSchema
+		});
+		if (!chunk.success) throw new Error("Invalid UI message chunk in WebSocket response.");
+		return chunk.value;
+	}
+	async handleResponseFrame(connection, text) {
+		if (this.connection !== connection) return;
+		const parsed = await safeParseJSON({ text });
+		if (!parsed.success || !isRecord(parsed.value)) throw new Error("Invalid WebSocket chat response frame.");
+		const type = parsed.value.type;
+		const requestId = parsed.value.requestId;
+		if (typeof type !== "string" || typeof requestId !== "string") throw new Error("Invalid WebSocket chat response frame.");
+		const request = this.activeRequests.get(requestId);
+		if (request == null) return;
+		switch (type) {
+			case "start":
+				this.resolveResumeStream(request);
+				return;
+			case "chunk": {
+				if (!isSequence(parsed.value.sequence)) throw new Error("Invalid WebSocket chat chunk sequence.");
+				if (parsed.value.sequence <= request.lastSequence) return;
+				if (parsed.value.sequence !== request.lastSequence + 1) throw new Error("Out-of-order WebSocket chat chunk sequence.");
+				const chunk = await this.validateResponseChunk(parsed.value.chunk);
+				if (this.activeRequests.get(requestId) !== request) return;
+				this.resolveResumeStream(request);
+				try {
+					request.controller.enqueue(chunk);
+				} catch {
+					return;
+				}
+				request.lastSequence = parsed.value.sequence;
+				return;
+			}
+			case "end":
+				this.resolveResumeStream(request);
+				this.cleanupRequest(request);
+				request.controller.close();
+				return;
+			case "no-active":
+				if (request.kind === "resume" && !request.responseSettled) {
+					request.responseSettled = true;
+					request.resolveResponse?.(null);
+				}
+				this.cleanupRequest(request);
+				request.controller.close();
+				return;
+			case "error":
+				if (parsed.value.errorText !== void 0 && typeof parsed.value.errorText !== "string") throw new Error("Invalid WebSocket chat error response.");
+				this.failRequest(request, new Error(parsed.value.errorText ?? "WebSocket chat server returned an error."));
+				return;
+			default: throw new Error(`Unknown WebSocket chat response type: ${type}.`);
+		}
+	}
+	async sendFrame(socket, frame, abortSignal) {
+		const send = this.sendQueue.then(async () => {
+			await waitForWebSocketBufferDrain(socket, { abortSignal });
+			this.throwIfAborted(abortSignal);
+			if (this.connection?.socket !== socket || socket.readyState !== WEBSOCKET_OPEN_STATE) throw new TypeError("WebSocket chat network connection is not open.");
+			socket.send(JSON.stringify(frame));
+		});
+		this.sendQueue = send.catch(() => {});
+		return send;
+	}
+};
+//#endregion
 //#region src/upload-file/upload-file.ts
 /**
 * Uploads a file using a files API interface.
@@ -20321,6 +20880,6 @@ async function uploadSkill({ api, files, displayTitle, providerOptions }) {
 	});
 }
 //#endregion
-export { AISDKError, AI_SDK_TELEMETRY_TRACING_CHANNEL, APICallError, AbstractChat, DefaultChatTransport, DefaultGeneratedFile, DirectChatTransport, DownloadError, EmptyResponseBodyError, AbstractRealtimeSession as Experimental_AbstractRealtimeSession, ToolLoopAgent as Experimental_Agent, ToolLoopAgent, Experimental_DecisionRefusalError, Experimental_DecisionUnsupportedQuestionTypeError, Experimental_EvaluationUnsupportedQuestionTypeError, HttpChatTransport, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidPromptError, InvalidResponseDataError, InvalidStreamPartError, InvalidToolApprovalError, InvalidToolApprovalSignatureError, InvalidToolInputError, JSONParseError, JsonToSseTransformStream, LoadAPIKeyError, LoadSettingError, MessageConversionError, MissingToolResultsError, NoContentGeneratedError, NoImageGeneratedError, NoObjectGeneratedError, NoOutputGeneratedError, NoSpeechGeneratedError, NoSuchModelError, NoSuchProviderError, NoSuchProviderReferenceError, NoSuchToolError, NoTranscriptGeneratedError, NoTranslationGeneratedError, NoVideoGeneratedError, output_exports as Output, RetryError, SerialJobExecutor, StreamProviderError, TextStreamChatTransport, TooManyEmbeddingValuesForCallError, ToolCallNotFoundForApprovalError, ToolCallRepairError, ToolChoiceViolationError, TypeValidationError, UIMessageStreamError, UI_MESSAGE_STREAM_HEADERS, UnsupportedFunctionalityError, UnsupportedModelVersionError, addToolInputExamplesMiddleware, asSchema, assistantModelMessageSchema, callCompletionApi, consumeStream, convertDataContentToBase64String, convertFileListToFileUIParts, convertToModelMessages, cosineSimilarity, createAgentUIStream, createAgentUIStreamResponse, createDownload, createGateway, createIdGenerator, createProviderRegistry, createTextStreamResponse, createUIMessageStream, createUIMessageStreamResponse, customProvider, defaultEmbeddingSettingsMiddleware, defaultInstructionsMiddleware, defaultSettingsMiddleware, detectToolDrift, dynamicTool, embed, embedMany, cancelBatch as experimental_cancelBatch, experimental_createProviderRegistry, decide as experimental_decide, decodeRealtimeAudio as experimental_decodeRealtimeAudio, encodeRealtimeAudio as experimental_encodeRealtimeAudio, experimental_evaluate, filterActiveTools as experimental_filterActiveTools, experimental_generateSpeech, experimental_generateVideo, getBatchResults as experimental_getBatchResults, getBatchStatus as experimental_getBatchStatus, getRealtimeToolDefinitions as experimental_getRealtimeToolDefinitions, experimental_getVideoStatus, listBatches as experimental_listBatches, resampleAudio as experimental_resampleAudio, startBatch as experimental_startBatch, experimental_startVideo, streamLanguageModelCall as experimental_streamLanguageModelCall, streamTranscribe as experimental_streamTranscribe, streamTranslate as experimental_streamTranslate, experimental_toolCaller, experimental_transcribe, extractJsonMiddleware, extractReasoningMiddleware, fingerprintTools, gateway, generateId, generateImage, generateObject, generateSpeech, generateText, getChunkTimeoutMs, getFirstChunkTimeoutMs, getStaticToolName, getStepTimeoutMs, getTextFromDataUrl, getToolName, getToolOrDynamicToolName, getToolTimeoutMs, getTotalTimeoutMs, hasToolCall, isCustomContentUIPart, isDataUIPart, isDeepEqualData, isDynamicToolUIPart, isFileUIPart, isLoopFinished, isReasoningFileUIPart, isReasoningUIPart, isStaticToolUIPart, isStepCount, isStepCount as stepCountIs, isTextUIPart, isToolOutputErrorUIPart, isToolUIPart, jsonSchema, lastAssistantMessageIsCompleteWithApprovalResponses, lastAssistantMessageIsCompleteWithToolCalls, modelMessageSchema, parseJsonEventStream, parsePartialJson, pipeAgentUIStreamToResponse, pipeTextStreamToResponse, pipeUIMessageStreamToResponse, pruneMessages, readUIMessageStream, registerTelemetry, rerank, safeValidateUIMessages, simulateReadableStream, simulateStreamingMiddleware, smoothStream, streamObject, streamText, systemModelMessageSchema, toTextStream, toUIMessageChunk, toUIMessageStream, tool, toolModelMessageSchema, toolSearch, transcribe, uiMessageChunkSchema, uploadFile, uploadSkill, userModelMessageSchema, validateUIMessages, wrapEmbeddingModel, wrapImageModel, wrapLanguageModel, wrapProvider, zodSchema };
+export { AISDKError, AI_SDK_TELEMETRY_TRACING_CHANNEL, APICallError, AbstractChat, DefaultChatTransport, DefaultGeneratedFile, DirectChatTransport, DownloadError, EmptyResponseBodyError, AbstractRealtimeSession as Experimental_AbstractRealtimeSession, ToolLoopAgent as Experimental_Agent, ToolLoopAgent, Experimental_DecisionRefusalError, Experimental_DecisionUnsupportedQuestionTypeError, Experimental_EvaluationUnsupportedQuestionTypeError, HttpChatTransport, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidPromptError, InvalidResponseDataError, InvalidStreamPartError, InvalidToolApprovalError, InvalidToolApprovalSignatureError, InvalidToolInputError, JSONParseError, JsonToSseTransformStream, LoadAPIKeyError, LoadSettingError, MessageConversionError, MissingToolResultsError, NoContentGeneratedError, NoImageGeneratedError, NoObjectGeneratedError, NoOutputGeneratedError, NoSpeechGeneratedError, NoSuchModelError, NoSuchProviderError, NoSuchProviderReferenceError, NoSuchToolError, NoTranscriptGeneratedError, NoTranslationGeneratedError, NoVideoGeneratedError, output_exports as Output, RetryError, SerialJobExecutor, StreamProviderError, TextStreamChatTransport, TooManyEmbeddingValuesForCallError, ToolCallNotFoundForApprovalError, ToolCallRepairError, ToolChoiceViolationError, TypeValidationError, UIMessageStreamError, UI_MESSAGE_STREAM_HEADERS, UnsupportedFunctionalityError, UnsupportedModelVersionError, WebSocketChatTransport, addToolInputExamplesMiddleware, asSchema, assistantModelMessageSchema, callCompletionApi, consumeStream, convertDataContentToBase64String, convertFileListToFileUIParts, convertToModelMessages, cosineSimilarity, createAgentUIStream, createAgentUIStreamResponse, createDownload, createGateway, createIdGenerator, createProviderRegistry, createTextStreamResponse, createUIMessageStream, createUIMessageStreamResponse, customProvider, defaultEmbeddingSettingsMiddleware, defaultInstructionsMiddleware, defaultSettingsMiddleware, detectToolDrift, dynamicTool, embed, embedMany, cancelBatch as experimental_cancelBatch, experimental_createProviderRegistry, decide as experimental_decide, decodeRealtimeAudio as experimental_decodeRealtimeAudio, encodeRealtimeAudio as experimental_encodeRealtimeAudio, experimental_evaluate, filterActiveTools as experimental_filterActiveTools, experimental_generateSpeech, experimental_generateVideo, getBatchResults as experimental_getBatchResults, getBatchStatus as experimental_getBatchStatus, getRealtimeToolDefinitions as experimental_getRealtimeToolDefinitions, experimental_getVideoStatus, listBatches as experimental_listBatches, resampleAudio as experimental_resampleAudio, startBatch as experimental_startBatch, experimental_startVideo, streamLanguageModelCall as experimental_streamLanguageModelCall, streamTranscribe as experimental_streamTranscribe, streamTranslate as experimental_streamTranslate, experimental_toolCaller, experimental_transcribe, extractJsonMiddleware, extractReasoningMiddleware, fingerprintTools, gateway, generateId, generateImage, generateObject, generateSpeech, generateText, getChunkTimeoutMs, getFirstChunkTimeoutMs, getStaticToolName, getStepTimeoutMs, getTextFromDataUrl, getToolName, getToolOrDynamicToolName, getToolTimeoutMs, getTotalTimeoutMs, hasToolCall, isCustomContentUIPart, isDataUIPart, isDeepEqualData, isDynamicToolUIPart, isFileUIPart, isLoopFinished, isReasoningFileUIPart, isReasoningUIPart, isStaticToolUIPart, isStepCount, isStepCount as stepCountIs, isTextUIPart, isToolOutputErrorUIPart, isToolUIPart, jsonSchema, lastAssistantMessageIsCompleteWithApprovalResponses, lastAssistantMessageIsCompleteWithToolCalls, modelMessageSchema, parseJsonEventStream, parsePartialJson, pipeAgentUIStreamToResponse, pipeTextStreamToResponse, pipeUIMessageStreamToResponse, pruneMessages, readUIMessageStream, registerTelemetry, rerank, safeValidateUIMessages, safeValidateWebSocketChatTransportRequest, simulateReadableStream, simulateStreamingMiddleware, smoothStream, streamObject, streamText, systemModelMessageSchema, toTextStream, toUIMessageChunk, toUIMessageStream, tool, toolModelMessageSchema, toolSearch, transcribe, uiMessageChunkSchema, uploadFile, uploadSkill, userModelMessageSchema, validateUIMessages, wrapEmbeddingModel, wrapImageModel, wrapLanguageModel, wrapProvider, zodSchema };
 
 //# sourceMappingURL=index.js.map