@ai-sdk/gateway 4.0.121 → 4.0.123

package/dist/index.js

@@ -1,11 +1,11 @@
-import { EXPERIMENTAL_TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE, EXPERIMENTAL_TRANSCRIPTION_STREAM_START_FRAME_TYPE, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, connectToWebSocket, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertUint8ArrayToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonLinesResponseHandler, createJsonResponseHandler, createProviderExecutedToolFactory, experimental_parseTranscriptionStreamPart, getErrorMessage, getFromApi, lazySchema, loadOptionalSetting, normalizeBatchRequestCounts, normalizeHeaders, parseJsonEventStream, parseProviderOptions, postJsonToApi, resolve, safeValidateTypes, secureJsonParse, serializeModelOptions, waitForWebSocketBufferDrain, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
+import { EXPERIMENTAL_SPEECH_STREAM_START_FRAME_TYPE, EXPERIMENTAL_SPEECH_STREAM_TEXT_DELTA_FRAME_TYPE, EXPERIMENTAL_SPEECH_STREAM_TEXT_DONE_FRAME_TYPE, EXPERIMENTAL_TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE, EXPERIMENTAL_TRANSCRIPTION_STREAM_START_FRAME_TYPE, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, connectToWebSocket, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertUint8ArrayToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonLinesResponseHandler, createJsonResponseHandler, createProviderExecutedToolFactory, experimental_parseSpeechStreamPart, experimental_parseTranscriptionStreamPart, getErrorMessage, getFromApi, lazySchema, loadOptionalSetting, normalizeBatchRequestCounts, normalizeHeaders, parseJsonEventStream, parseProviderOptions, postJsonToApi, resolve, safeValidateTypes, secureJsonParse, serializeModelOptions, waitForWebSocketBufferDrain, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
 import { any, array, boolean, discriminatedUnion, enum as enum$1, json, literal, number, object, record, string, union, unknown } from "zod/v4";
 import { APICallError, InvalidArgumentError, UnsupportedFunctionalityError, getErrorMessage as getErrorMessage$1 } from "@ai-sdk/provider";
 import { getContext, getVercelOidcToken } from "@vercel/oidc";
 //#region src/gateway-realtime-auth.ts
 /**
-* Shared WebSocket subprotocol contract for AI Gateway realtime and streaming
-* transcription auth.
+* Shared WebSocket subprotocol contract for AI Gateway realtime, streaming
+* transcription, and streaming speech auth.
 *
 * The browser `WebSocket` API cannot set request headers, so the Gateway auth
 * (bearer) token is carried through the `Sec-WebSocket-Protocol` handshake
@@ -14,7 +14,8 @@ import { getContext, getVercelOidcToken } from "@vercel/oidc";
 *
 * This module is the single source of truth for that contract so the client and
 * the Gateway server can't drift: the client encodes values with
-* `getGatewayRealtimeProtocols` / `getGatewayTranscriptionProtocols`, and the
+* `getGatewayRealtimeProtocols` / `getGatewayTranscriptionProtocols` /
+* `getGatewaySpeechProtocols`, and the
 * Gateway server decodes them with `getGatewayRealtimeAuthToken` /
 * `getGatewayRealtimeTeamIdOrSlug`.
 *
@@ -35,6 +36,11 @@ const GATEWAY_REALTIME_SUBPROTOCOL = "ai-gateway-realtime.v1";
 * purpose as `GATEWAY_REALTIME_SUBPROTOCOL`).
 */
 const GATEWAY_TRANSCRIPTION_SUBPROTOCOL = "ai-gateway-transcription.v1";
+/**
+* Marker subprotocol for streaming speech handshakes (same negotiation
+* purpose as `GATEWAY_REALTIME_SUBPROTOCOL`).
+*/
+const GATEWAY_SPEECH_SUBPROTOCOL = "ai-gateway-speech.v1";
 /** Subprotocol prefix that carries the Gateway auth (bearer) token. */
 const GATEWAY_AUTH_SUBPROTOCOL_PREFIX = "ai-gateway-auth.";
 /** Subprotocol prefix that carries optional Vercel team scoping. */
@@ -53,6 +59,13 @@ function getGatewayRealtimeProtocols(token, options) {
 function getGatewayTranscriptionProtocols(token, options) {
 	return buildGatewayProtocols(GATEWAY_TRANSCRIPTION_SUBPROTOCOL, token, options);
 }
+/**
+* Client-side: `getGatewayRealtimeProtocols`, but with the streaming speech
+* marker subprotocol.
+*/
+function getGatewaySpeechProtocols(token, options) {
+	return buildGatewayProtocols(GATEWAY_SPEECH_SUBPROTOCOL, token, options);
+}
 function buildGatewayProtocols(marker, token, options) {
 	const protocols = [marker, `${GATEWAY_AUTH_SUBPROTOCOL_PREFIX}${token}`];
 	if (options?.teamIdOrSlug) protocols.push(`${GATEWAY_TEAM_SUBPROTOCOL_PREFIX}${encodeSubprotocolValue(options.teamIdOrSlug)}`);
@@ -2044,93 +2057,47 @@ const gatewayRerankingResponseSchema = lazySchema(() => zodSchema(z.object({
 	providerMetadata: z.record(z.string(), z.record(z.string(), z.unknown())).optional()
 })));
 //#endregion
-//#region src/gateway-speech-model.ts
-var GatewaySpeechModel = class {
-	constructor(modelId, config) {
-		this.modelId = modelId;
-		this.config = config;
-		this.specificationVersion = "v4";
-	}
-	get provider() {
-		return this.config.provider;
-	}
-	async doGenerate({ text, voice, outputFormat, instructions, speed, language, providerOptions, headers, abortSignal }) {
-		const resolvedHeaders = this.config.headers ? await resolve(this.config.headers) : void 0;
-		try {
-			const { responseHeaders, value: responseBody, rawValue } = await postJsonToApi({
-				url: this.getUrl(),
-				headers: combineHeaders(resolvedHeaders, headers ?? {}, this.getModelConfigHeaders(), await resolve(this.config.o11yHeaders)),
-				body: {
-					text,
-					...voice && { voice },
-					...outputFormat && { outputFormat },
-					...instructions && { instructions },
-					...speed != null && { speed },
-					...language && { language },
-					...providerOptions && { providerOptions }
-				},
-				successfulResponseHandler: createJsonResponseHandler(gatewaySpeechResponseSchema),
-				failedResponseHandler: createJsonErrorResponseHandler({
-					errorSchema: z.any(),
-					errorToMessage: (data) => getErrorMessage(data) ?? "unknown error"
-				}),
-				...abortSignal && { abortSignal },
-				fetch: this.config.fetch
-			});
-			return {
-				audio: responseBody.audio,
-				warnings: responseBody.warnings ?? [],
-				...responseBody.usage != null && { usage: responseBody.usage },
-				providerMetadata: responseBody.providerMetadata,
-				response: {
-					timestamp: /* @__PURE__ */ new Date(),
-					modelId: this.modelId,
-					headers: responseHeaders,
-					body: rawValue
-				}
-			};
-		} catch (error) {
-			throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders ?? {}));
-		}
-	}
-	getUrl() {
-		return `${this.config.baseURL}/speech-model`;
-	}
-	getModelConfigHeaders() {
-		return {
-			"ai-speech-model-specification-version": "4",
-			"ai-model-id": this.modelId
-		};
-	}
+//#region src/gateway-stream-errors.ts
+/**
+* `asGatewayError` is async while the WebSocket event handlers are
+* synchronous, hence this helper.
+*/
+async function errorControllerWithGatewayError(controller, error, authMethod) {
+	controller.error(await asGatewayError(error, authMethod));
+}
+/**
+* Extract a human-readable message from an `error` stream part's payload for
+* the terminal close error.
+*/
+function getServerErrorMessage(error) {
+	if (error != null && typeof error === "object" && "message" in error && typeof error.message === "string") return error.message;
+	return getErrorMessage$1(error);
+}
+/** Canonical status codes for server error-part types (no HTTP status exists on the WebSocket). */
+const SERVER_ERROR_STATUS_CODES = {
+	authentication_error: 401,
+	failed_dependency: 424,
+	forbidden: 403,
+	internal_server_error: 500,
+	invalid_request_error: 400,
+	model_not_found: 404,
+	rate_limit_exceeded: 429
 };
-const providerMetadataEntrySchema$1 = () => z.object({}).catchall(z.unknown());
-const gatewaySpeechWarningSchema = () => z.discriminatedUnion("type", [
-	z.object({
-		type: z.literal("unsupported"),
-		feature: z.string(),
-		details: z.string().optional()
-	}),
-	z.object({
-		type: z.literal("compatibility"),
-		feature: z.string(),
-		details: z.string().optional()
-	}),
-	z.object({
-		type: z.literal("deprecated"),
-		setting: z.string(),
-		message: z.string()
-	}),
-	z.object({
-		type: z.literal("other"),
-		message: z.string()
-	})
-]);
-const gatewaySpeechResponseSchema = lazySchema(() => zodSchema(z.object({
-	audio: z.string(),
-	warnings: z.array(gatewaySpeechWarningSchema()).optional(),
-	usage: z.record(z.string(), z.json()).optional(),
-	providerMetadata: z.record(z.string(), providerMetadataEntrySchema$1()).optional()
-})));
+/**
+* Maps a server error-part payload (`{ message, type }`) to the public
+* Gateway error class for its type; unknown shapes keep the generic message.
+*/
+async function createErrorFromServerErrorPart(error, authMethod, streamLabel = "transcription") {
+	if (typeof error === "object" && error != null && "message" in error && typeof error.message === "string" && "type" in error && typeof error.type === "string" && error.type in SERVER_ERROR_STATUS_CODES) return createGatewayErrorFromResponse({
+		response: { error: {
+			message: error.message,
+			type: error.type
+		} },
+		statusCode: SERVER_ERROR_STATUS_CODES[error.type],
+		authMethod
+	});
+	return /* @__PURE__ */ new Error(`AI Gateway ${streamLabel} stream failed: ${getServerErrorMessage(error)}`);
+}
 //#endregion
 //#region src/gateway-transcription-model.ts
 var GatewayTranscriptionModel = class {
@@ -2252,11 +2219,11 @@ function toGatewayTranscriptionUrl(baseURL, modelId) {
 * case-insensitive because `combineHeaders` does not normalize casing and
 * callers can pass arbitrary casing via the `headers` option.
 */
-function getProtocolsFromHeaders(headers) {
+function getProtocolsFromHeaders(headers, { marker = GATEWAY_TRANSCRIPTION_SUBPROTOCOL, getProtocols = getGatewayTranscriptionProtocols } = {}) {
 	const normalizedHeaders = normalizeHeaders(headers);
 	const authorization = normalizedHeaders.authorization;
 	const token = authorization?.startsWith("Bearer ") ? authorization.slice(7) : void 0;
-	return token == null ? [GATEWAY_TRANSCRIPTION_SUBPROTOCOL] : getGatewayTranscriptionProtocols(token, { teamIdOrSlug: normalizedHeaders[VERCEL_AI_GATEWAY_TEAM_HEADER] });
+	return token == null ? [marker] : getProtocols(token, { teamIdOrSlug: normalizedHeaders[VERCEL_AI_GATEWAY_TEAM_HEADER] });
 }
 /** Audio frames stay under server frame-size limits (envelope rule 7). */
 const MAX_AUDIO_FRAME_BYTES = 65536;
@@ -2363,7 +2330,7 @@ function createGatewayTranscriptionStream({ webSocket, url, protocols, headers,
 		}
 	});
 }
-const providerMetadataEntrySchema = () => z.object({}).catchall(z.unknown());
+const providerMetadataEntrySchema$1 = () => z.object({}).catchall(z.unknown());
 const gatewayTranscriptionWarningSchema = () => z.discriminatedUnion("type", [
 	z.object({
 		type: z.literal("unsupported"),
@@ -2396,48 +2363,274 @@ const gatewayTranscriptionResponseSchema = lazySchema(() => zodSchema(z.object({
 	durationInSeconds: z.number().nullish(),
 	warnings: z.array(gatewayTranscriptionWarningSchema()).optional(),
 	usage: z.record(z.string(), z.json()).optional(),
-	providerMetadata: z.record(z.string(), providerMetadataEntrySchema()).optional()
+	providerMetadata: z.record(z.string(), providerMetadataEntrySchema$1()).optional()
 })));
+//#endregion
+//#region src/gateway-speech-model.ts
+var GatewaySpeechModel = class {
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async doGenerate({ text, voice, outputFormat, instructions, speed, language, providerOptions, headers, abortSignal }) {
+		const resolvedHeaders = this.config.headers ? await resolve(this.config.headers) : void 0;
+		try {
+			const { responseHeaders, value: responseBody, rawValue } = await postJsonToApi({
+				url: this.getUrl(),
+				headers: combineHeaders(resolvedHeaders, headers ?? {}, this.getModelConfigHeaders(), await resolve(this.config.o11yHeaders)),
+				body: {
+					text,
+					...voice && { voice },
+					...outputFormat && { outputFormat },
+					...instructions && { instructions },
+					...speed != null && { speed },
+					...language && { language },
+					...providerOptions && { providerOptions }
+				},
+				successfulResponseHandler: createJsonResponseHandler(gatewaySpeechResponseSchema),
+				failedResponseHandler: createJsonErrorResponseHandler({
+					errorSchema: z.any(),
+					errorToMessage: (data) => getErrorMessage(data) ?? "unknown error"
+				}),
+				...abortSignal && { abortSignal },
+				fetch: this.config.fetch
+			});
+			return {
+				audio: responseBody.audio,
+				warnings: responseBody.warnings ?? [],
+				...responseBody.usage != null && { usage: responseBody.usage },
+				providerMetadata: responseBody.providerMetadata,
+				response: {
+					timestamp: /* @__PURE__ */ new Date(),
+					modelId: this.modelId,
+					headers: responseHeaders,
+					body: rawValue
+				}
+			};
+		} catch (error) {
+			throw await asGatewayError(error, await parseAuthMethod(resolvedHeaders ?? {}));
+		}
+	}
+	async doStream(options) {
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const headers = combineHeaders(await resolve(this.config.headers ?? {}), options.headers ?? {}, this.getModelConfigHeaders(), await resolve(this.config.o11yHeaders));
+		const authMethod = await parseAuthMethod(headers);
+		const startFrame = {
+			type: EXPERIMENTAL_SPEECH_STREAM_START_FRAME_TYPE,
+			...options.voice != null && { voice: options.voice },
+			...options.outputFormat != null && { outputFormat: options.outputFormat },
+			...options.instructions != null && { instructions: options.instructions },
+			...options.speed != null && { speed: options.speed },
+			...options.language != null && { language: options.language },
+			...options.providerOptions != null && { providerOptions: options.providerOptions },
+			...options.includeRawChunks != null && { includeRawChunks: options.includeRawChunks }
+		};
+		return {
+			stream: createGatewaySpeechStream({
+				webSocket: this.config.webSocket,
+				url: toGatewaySpeechUrl(this.config.baseURL, this.modelId),
+				protocols: getProtocolsFromHeaders(headers, {
+					marker: GATEWAY_SPEECH_SUBPROTOCOL,
+					getProtocols: getGatewaySpeechProtocols
+				}),
+				headers,
+				startFrame,
+				text: options.text,
+				abortSignal: options.abortSignal,
+				authMethod
+			}),
+			request: { body: startFrame },
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId
+			}
+		};
+	}
+	getUrl() {
+		return `${this.config.baseURL}/speech-model`;
+	}
+	getModelConfigHeaders() {
+		return {
+			"ai-speech-model-specification-version": "4",
+			"ai-model-id": this.modelId
+		};
+	}
+};
 /**
-* `asGatewayError` is async while the WebSocket event handlers are
-* synchronous, hence this helper.
+* Gateway streaming speech WebSocket URL: HTTP(S) base upgraded to WS(S),
+* model id in `?ai-model-id=` (browser `WebSocket` cannot set headers).
 */
-async function errorControllerWithGatewayError(controller, error, authMethod) {
-	controller.error(await asGatewayError(error, authMethod));
+function toGatewaySpeechUrl(baseURL, modelId) {
+	const url = new URL(`${baseURL.replace(/^http/, "ws")}/speech-model`);
+	url.searchParams.set("ai-model-id", modelId);
+	return url.toString();
 }
 /**
-* Extract a human-readable message from an `error` stream part's payload for
-* the terminal close error.
+* Keeps text-delta frames under 64 KiB (envelope rule 7) even when JSON
+* escapes every code unit as `\uXXXX`.
 */
-function getServerErrorMessage(error) {
-	if (error != null && typeof error === "object" && "message" in error && typeof error.message === "string") return error.message;
-	return getErrorMessage$1(error);
-}
-/** Canonical status codes for server error-part types (no HTTP status exists on the WebSocket). */
-const SERVER_ERROR_STATUS_CODES = {
-	authentication_error: 401,
-	failed_dependency: 424,
-	forbidden: 403,
-	internal_server_error: 500,
-	invalid_request_error: 400,
-	model_not_found: 404,
-	rate_limit_exceeded: 429
-};
+const MAX_TEXT_DELTA_CODE_UNITS = 8192;
 /**
-* Maps a server error-part payload (`{ message, type }`) to the public
-* Gateway error class for its type; unknown shapes keep the generic message.
+* Splits a long text delta into pieces of at most `MAX_TEXT_DELTA_CODE_UNITS`
+* UTF-16 code units without separating a surrogate pair.
 */
-async function createErrorFromServerErrorPart(error, authMethod) {
-	if (typeof error === "object" && error != null && "message" in error && typeof error.message === "string" && "type" in error && typeof error.type === "string" && error.type in SERVER_ERROR_STATUS_CODES) return createGatewayErrorFromResponse({
-		response: { error: {
-			message: error.message,
-			type: error.type
-		} },
-		statusCode: SERVER_ERROR_STATUS_CODES[error.type],
-		authMethod
+function splitTextDelta(delta) {
+	const pieces = [];
+	let offset = 0;
+	while (offset < delta.length) {
+		let end = Math.min(offset + MAX_TEXT_DELTA_CODE_UNITS, delta.length);
+		const lastCodeUnit = delta.charCodeAt(end - 1);
+		if (end < delta.length && lastCodeUnit >= 55296 && lastCodeUnit <= 56319) end--;
+		pieces.push(delta.slice(offset, end));
+		offset = end;
+	}
+	return pieces;
+}
+function createGatewaySpeechStream({ webSocket, url, protocols, headers, startFrame, text, abortSignal, authMethod }) {
+	let finished = false;
+	let cleanup = () => {};
+	return new ReadableStream({
+		start: (controller) => {
+			let textReader;
+			let hasServerErrorPart = false;
+			let lastServerError;
+			let textStopped = false;
+			let connection;
+			const cancelText = () => {
+				if (textReader != null) {
+					textReader.cancel().catch(() => {});
+					textReader = void 0;
+				} else text.cancel().catch(() => {});
+			};
+			cleanup = (closeCode) => {
+				cancelText();
+				connection?.close(closeCode);
+			};
+			const finishWithError = (error) => {
+				if (finished) return;
+				finished = true;
+				cleanup();
+				errorControllerWithGatewayError(controller, error, authMethod);
+			};
+			const sendText = async (socket) => {
+				const reader = text.getReader();
+				textReader = reader;
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done || finished || textStopped) break;
+						let first = true;
+						const pieces = splitTextDelta(value.text);
+						if (pieces.length === 0 && (value.voice != null || value.providerOptions != null)) pieces.push("");
+						for (const delta of pieces) {
+							if (finished || textStopped) break;
+							const frame = {
+								type: EXPERIMENTAL_SPEECH_STREAM_TEXT_DELTA_FRAME_TYPE,
+								delta,
+								...value.voice != null && { voice: value.voice },
+								...first && value.providerOptions != null && { providerOptions: value.providerOptions }
+							};
+							first = false;
+							socket.send(JSON.stringify(frame));
+							await waitForWebSocketBufferDrain(socket);
+						}
+					}
+				} finally {
+					reader.releaseLock();
+					if (textReader === reader) textReader = void 0;
+				}
+				if (!finished && !textStopped) socket.send(JSON.stringify({ type: EXPERIMENTAL_SPEECH_STREAM_TEXT_DONE_FRAME_TYPE }));
+			};
+			connection = connectToWebSocket({
+				url,
+				protocols,
+				headers,
+				webSocket,
+				abortSignal,
+				onAbort: (reason) => {
+					if (finished) return;
+					finished = true;
+					cleanup();
+					controller.error(reason);
+				},
+				onProcessingError: finishWithError,
+				onOpen: (socket) => {
+					socket.send(JSON.stringify(startFrame));
+					sendText(socket).catch(finishWithError);
+				},
+				onMessageText: async (messageText) => {
+					if (finished) return;
+					const part = experimental_parseSpeechStreamPart(messageText);
+					if (part == null) return;
+					if (part.type === "finish") {
+						finished = true;
+						controller.enqueue(part);
+						controller.close();
+						cleanup(1e3);
+						return;
+					}
+					if (part.type === "error") {
+						hasServerErrorPart = true;
+						lastServerError = part.error;
+						textStopped = true;
+						cancelText();
+						part.error = await createErrorFromServerErrorPart(part.error, authMethod, "speech");
+						if (finished) return;
+					}
+					controller.enqueue(part);
+				},
+				onSocketError: () => {
+					finishWithError(/* @__PURE__ */ new Error("Connection error on AI Gateway speech stream"));
+				},
+				onClose: ({ code, reason }) => {
+					if (hasServerErrorPart) {
+						if (finished) return;
+						createErrorFromServerErrorPart(lastServerError, authMethod, "speech").then(finishWithError);
+						return;
+					}
+					finishWithError(/* @__PURE__ */ new Error("AI Gateway speech stream closed before a finish part was received" + (code != null ? ` (code ${code}${reason ? `: ${reason}` : ""})` : "") + "."));
+				}
+			});
+		},
+		cancel: () => {
+			if (finished) return;
+			finished = true;
+			cleanup();
+		}
 	});
-	return /* @__PURE__ */ new Error(`AI Gateway transcription stream failed: ${getServerErrorMessage(error)}`);
 }
+const providerMetadataEntrySchema = () => z.object({}).catchall(z.unknown());
+const gatewaySpeechWarningSchema = () => z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("unsupported"),
+		feature: z.string(),
+		details: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("compatibility"),
+		feature: z.string(),
+		details: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("deprecated"),
+		setting: z.string(),
+		message: z.string()
+	}),
+	z.object({
+		type: z.literal("other"),
+		message: z.string()
+	})
+]);
+const gatewaySpeechResponseSchema = lazySchema(() => zodSchema(z.object({
+	audio: z.string(),
+	warnings: z.array(gatewaySpeechWarningSchema()).optional(),
+	usage: z.record(z.string(), z.json()).optional(),
+	providerMetadata: z.record(z.string(), providerMetadataEntrySchema()).optional()
+})));
 //#endregion
 //#region src/gateway-realtime-model.ts
 /**
@@ -2697,39 +2890,65 @@ const exaSearchToolFactory = createProviderExecutedToolFactory({
 const exaSearch = (config = {}) => exaSearchToolFactory(config);
 //#endregion
 //#region src/tool/parallel-search.ts
+const parallelSearchModes = [
+	"turbo",
+	"fast",
+	"basic",
+	"advanced",
+	"one-shot",
+	"agentic"
+];
 const parallelSearchInputSchema = lazySchema(() => zodSchema(z.object({
 	objective: z.string().describe("Natural-language description of the web research goal, including source or freshness guidance and broader context from the task. Maximum 5000 characters."),
-	search_queries: z.array(z.string()).optional().describe("Optional search queries to supplement the objective. Maximum 200 characters per query."),
-	mode: z.enum(["one-shot", "agentic"]).optional().describe("Mode preset: \"one-shot\" for comprehensive results with longer excerpts (default), \"agentic\" for concise, token-efficient results for multi-step workflows."),
+	search_queries: z.array(z.string()).optional().describe("Provide 2-3 concise keyword queries, 3-6 words each (max 5, 200 chars each). Strongly recommended; the search runs on these queries."),
+	mode: z.enum(parallelSearchModes).optional().describe("Search mode: \"turbo\" and \"fast\" return quickly with shorter excerpts, \"basic\" is balanced (default), \"advanced\" is the most thorough. \"turbo\" supports English and Japanese only. \"one-shot\" and \"agentic\" are deprecated aliases of \"basic\" and \"advanced\"."),
 	max_results: z.number().optional().describe("Maximum number of results to return (1-20). Defaults to 10 if not specified."),
 	source_policy: z.object({
-		include_domains: z.array(z.string()).optional().describe("Limit results to these domains. Use plain domain names only — e.g. example.com or sub.example.gov, or a bare extension like .edu. Do not include a scheme, path, or port (e.g. not https://example.com/page)."),
-		exclude_domains: z.array(z.string()).optional().describe("Exclude results from these domains. Use plain domain names only — e.g. example.com or sub.example.gov, or a bare extension like .edu. Do not include a scheme, path, or port (e.g. not https://example.com/page)."),
-		after_date: z.string().optional().describe("Only include results published after this date. Use an ISO 8601 calendar date formatted YYYY-MM-DD (e.g. 2025-01-01); do not include a time.")
+		include_domains: z.array(z.string()).optional().describe("Domains or domain/path prefixes to restrict results to, without scheme or port. Example: ['wikipedia.org', 'docs.python.org/3']."),
+		exclude_domains: z.array(z.string()).optional().describe("Domains or domain/path prefixes to exclude, without scheme or port. Example: ['reddit.com']."),
+		after_date: z.string().optional().describe("Only include results published on or after this date. Use an ISO 8601 calendar date formatted YYYY-MM-DD (e.g. 2025-01-01); do not include a time.")
 	}).optional().describe("Source policy for controlling which domains to include/exclude and freshness."),
 	excerpts: z.object({
 		max_chars_per_result: z.number().optional().describe("Maximum characters per result."),
-		max_chars_total: z.number().optional().describe("Maximum total characters across all results.")
+		max_chars_total: z.number().optional().describe("Deprecated: use the top-level max_chars_total.")
 	}).optional().describe("Excerpt configuration for controlling result length."),
-	fetch_policy: z.object({ max_age_seconds: z.number().optional().describe("Maximum age in seconds for cached content. Set to 0 to always fetch fresh content.") }).optional().describe("Fetch policy for controlling content freshness.")
+	max_chars_total: z.number().optional().describe("Maximum total characters across all result excerpts."),
+	fetch_policy: z.object({
+		max_age_seconds: z.number().optional().describe("Maximum age of cached content in seconds before a live fetch, minimum 600."),
+		timeout_seconds: z.number().optional().describe("Timeout in seconds for a live fetch when content is not cached. Capped by the gateway tool timeout."),
+		disable_cache_fallback: z.boolean().optional().describe("Return an error instead of older cached content when a live fetch fails.")
+	}).optional().describe("Fetch policy for controlling content freshness."),
+	location: z.string().optional().describe("ISO 3166-1 alpha-2 country code to localize results, e.g. \"us\".")
 })));
 const parallelSearchOutputSchema = lazySchema(() => zodSchema(z.union([z.object({
-	searchId: z.string(),
+	search_id: z.string(),
 	results: z.array(z.object({
 		url: z.string(),
-		title: z.string(),
-		excerpt: z.string(),
-		publishDate: z.string().nullable().optional(),
-		relevanceScore: z.number().optional()
-	}))
+		title: z.string().nullable().optional(),
+		publish_date: z.string().nullable().optional(),
+		excerpts: z.array(z.string())
+	})),
+	warnings: z.array(z.object({
+		type: z.string(),
+		message: z.string(),
+		detail: z.record(z.string(), z.unknown()).nullable().optional()
+	})).nullable().optional(),
+	usage: z.array(z.object({
+		name: z.string(),
+		count: z.number().optional()
+	})).nullable().optional(),
+	session_id: z.string().optional()
 }), z.object({
 	error: z.enum([
 		"api_error",
+		"configuration_error",
+		"execution_error",
+		"gateway_rate_limit",
+		"invalid_input",
 		"rate_limit",
 		"timeout",
-		"invalid_input",
-		"configuration_error",
-		"unknown"
+		"unknown",
+		"unknown_tool"
 	]),
 	statusCode: z.number().optional(),
 	message: z.string()
@@ -3052,7 +3271,7 @@ async function getVercelRequestId() {
 }
 //#endregion
 //#region src/version.ts
-const VERSION = "4.0.121";
+const VERSION = "4.0.123";
 //#endregion
 //#region src/gateway-provider.ts
 const AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
@@ -3289,11 +3508,24 @@ function createGateway(options = {}) {
 			baseURL,
 			headers: getHeaders,
 			fetch: options.fetch,
-			o11yHeaders: createO11yHeaders()
+			o11yHeaders: createO11yHeaders(),
+			webSocket: options.webSocket
 		});
 	};
 	provider.speechModel = createSpeechModel;
 	provider.speech = createSpeechModel;
+	provider.experimental_speech = Object.assign((modelId) => createSpeechModel(modelId), { getToken: async (tokenOptions) => {
+		const secret = await mintClientSecret({
+			modelId: tokenOptions.model,
+			routeKind: "speech",
+			...tokenOptions.expiresAfterSeconds != null && { expiresAfterSeconds: tokenOptions.expiresAfterSeconds }
+		});
+		return {
+			token: secret.token,
+			url: toGatewaySpeechUrl(baseURL, tokenOptions.model),
+			...secret.expiresAt != null && { expiresAt: secret.expiresAt }
+		};
+	} });
 	const createTranscriptionModel = (modelId) => {
 		return new GatewayTranscriptionModel(modelId, {
 			provider: "gateway",
@@ -3356,9 +3588,9 @@ async function getGatewayAuthToken(options) {
 	};
 }
 function assertGatewayClientSecretServerEnvironment() {
-	if (typeof globalThis.window !== "undefined") throw new Error("AI Gateway client secrets must be minted server-side: minting needs your Gateway credential, which must never reach the browser. Call gateway.experimental_realtime.getToken() or gateway.experimental_transcription.getToken() from your server and pass the returned token to the client.");
+	if (typeof globalThis.window !== "undefined") throw new Error("AI Gateway client secrets must be minted server-side: minting needs your Gateway credential, which must never reach the browser. Call gateway.experimental_realtime.getToken(), gateway.experimental_transcription.getToken(), or gateway.experimental_speech.getToken() from your server and pass the returned token to the client.");
 }
 //#endregion
-export { GATEWAY_AUTH_SUBPROTOCOL_PREFIX, GATEWAY_REALTIME_SUBPROTOCOL, GATEWAY_TEAM_SUBPROTOCOL_PREFIX, GATEWAY_TRANSCRIPTION_SUBPROTOCOL, GatewayAuthenticationError, GatewayError, GatewayFailedDependencyError, GatewayForbiddenError, GatewayInternalServerError, GatewayInvalidRequestError, GatewayModelNotFoundError, GatewayNotFoundError, GatewayRateLimitError, GatewayResponseError, VERSION, createGateway, createGateway as createGatewayProvider, gateway, getGatewayRealtimeAuthToken, getGatewayRealtimeProtocols, getGatewayRealtimeTeamIdOrSlug, getGatewayTranscriptionProtocols };
+export { GATEWAY_AUTH_SUBPROTOCOL_PREFIX, GATEWAY_REALTIME_SUBPROTOCOL, GATEWAY_SPEECH_SUBPROTOCOL, GATEWAY_TEAM_SUBPROTOCOL_PREFIX, GATEWAY_TRANSCRIPTION_SUBPROTOCOL, GatewayAuthenticationError, GatewayError, GatewayFailedDependencyError, GatewayForbiddenError, GatewayInternalServerError, GatewayInvalidRequestError, GatewayModelNotFoundError, GatewayNotFoundError, GatewayRateLimitError, GatewayResponseError, VERSION, createGateway, createGateway as createGatewayProvider, gateway, getGatewayRealtimeAuthToken, getGatewayRealtimeProtocols, getGatewayRealtimeTeamIdOrSlug, getGatewaySpeechProtocols, getGatewayTranscriptionProtocols };
 
 //# sourceMappingURL=index.js.map