agents 0.28.0 → 0.29.0

package/dist/{ai-sdk-Bdsf6mSA.js → ai-sdk-DRPh2rRa.js}

@@ -1,42 +1,40 @@
 import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
 import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-qMjJ6sHQ.js";
-import { S as isRetryableStatus, _ as isGatewayErrorEnvelope, a as normalizeChatCompletion, b as classifyStatus, f as createTransport$1, g as headersToObject, h as errorFromResponse$1, i as normalizeChatCompletionsStream, m as errorFromGatewayEnvelope$1, n as imageMediaTypeOf, o as prepareChatCompletionsRequest, p as definedHeaders, r as sseDataStream, t as buildImageInput, u as requireGatewayProvider, v as unwrapEnvelope$1, x as isAbortError, y as CloudflareAIError$1 } from "./images-Ce9SCu3X.js";
-import { a as parseModelOptions, i as mergeModelOptions, n as PROVIDER_OPTIONS_KEY, o as resolveOptions, r as gatewayLayerOf } from "./settings-C45hDliX.js";
+import { C as isCatalogModelId, S as isRetryableStatus, T as isRunPathLanguageModelId, _ as isGatewayErrorEnvelope, a as normalizeChatCompletion, b as classifyStatus, f as createTransport$1, g as headersToObject, h as errorFromResponse$1, i as normalizeChatCompletionsStream, m as errorFromGatewayEnvelope$1, n as imageMediaTypeOf, o as prepareChatCompletionsRequest, p as definedHeaders, r as sseDataStream, t as buildImageInput, u as requireGatewayProvider, v as unwrapEnvelope$1, w as isDynamicRouteId, x as isAbortError, y as CloudflareAIError$1 } from "./images-xaDv2Fqe.js";
+import { a as parseModelOptions, i as mergeModelOptions, n as PROVIDER_OPTIONS_KEY, o as resolveOptions, r as gatewayLayerOf } from "./settings-Dk2il2Hf.js";
 import { APICallError, TooManyEmbeddingValuesForCallError } from "@ai-sdk/provider";
 //#region src/models/ai-sdk/errors.ts
-/** The provider packages worth naming when someone passes a vendor id. */
-const VENDOR_PACKAGES = {
-	anthropic: {
-		call: "anthropic(\"claude-opus-4-8\")",
-		package: "@ai-sdk/anthropic"
-	},
-	google: {
-		call: "google(\"gemini-3-flash\")",
-		package: "@ai-sdk/google"
-	},
-	openai: {
-		call: "openai(\"gpt-5-mini\")",
-		package: "@ai-sdk/openai"
-	}
-};
 /**
-* The one error a bad model id produces. Workers AI ids are the only strings
-* this provider knows; a third-party model is a model object built by that
-* vendor's own provider package.
+* The error a string that names no model this provider runs produces.
+* Language models take Workers AI ids, AI Gateway catalog ids and dynamic
+* routes; the modality methods take Workers AI ids only.
 */
-function notAWorkersAIId(modelId) {
-	const vendor = VENDOR_PACKAGES[modelId.split("/")[0] ?? ""];
-	const advice = vendor === void 0 ? "install its AI SDK provider package and pass the model object, e.g. ai(anthropic(\"claude-opus-4-8\"))" : `install ${vendor.package} and pass the model object: ai(${vendor.call})`;
-	return /* @__PURE__ */ new TypeError(`"${modelId}" is not a Workers AI model id. Workers AI ids start with "@cf/", and they are the only ids this provider takes: a third-party model goes through its own provider and is only routed by AI Gateway — ${advice}.`);
+function notAModelId(modelId, accepts) {
+	return /* @__PURE__ */ new TypeError(accepts === "language" ? `"${modelId}" is not a model id this provider knows. Use a Workers AI id ("@cf/zai-org/glm-4.7-flash"), an AI Gateway catalog id ("<author>/<model>", e.g. "openai/gpt-5.5" or "anthropic/claude-opus-4.8"), or a dynamic route ("dynamic/<route>").` : `"${modelId}" is not a Workers AI model id. The embedding, image, speech, transcription and reranking methods take Workers AI ids, which start with "@cf/".`);
 }
 /**
-* The gate every string that names a model passes through, wherever it enters
-* the module: `ai("…")`, a per-model fallback leg, or a leg read out of the
-* per-call `providerOptions.cloudflare` bag. One rule, one message, thrown at
-* the line that supplied the id rather than at the request it would have made.
+* The gate for the modality methods — embedding, image, speech,
+* transcription, reranking — and their fallback legs: a Workers AI id and
+* nothing else. Catalog models and dynamic routes are chat models here.
 */
 function requireWorkersAIId(modelId) {
-	if (!modelId.startsWith("@cf/")) throw notAWorkersAIId(modelId);
+	if (isDynamicRouteId(modelId)) throw new TypeError(`"${modelId}" is an AI Gateway dynamic route, and a dynamic route is a chat model: it answers in the chat-completions shape. Use it as ai("${modelId}"); the embedding, image, speech, transcription and reranking methods take "@cf/" ids.`);
+	if (!modelId.startsWith("@cf/")) throw notAModelId(modelId, "workers-ai");
+	return modelId;
+}
+/** Whether a string names a language model: any of the three id kinds. */
+function isLanguageModelId(modelId) {
+	return isRunPathLanguageModelId(modelId) || isCatalogModelId(modelId);
+}
+/**
+* The gate every string that names a language model passes through, wherever
+* it enters the module: `ai("…")`, a per-model fallback leg, or a leg read
+* out of the per-call `providerOptions.cloudflare` bag. All three kinds run on
+* `env.AI.run`. Thrown at the line that supplied the id rather than at the
+* request it would have made.
+*/
+function requireLanguageModelId(modelId) {
+	if (!isLanguageModelId(modelId)) throw notAModelId(modelId, "language");
 	return modelId;
 }
 /**
@@ -117,6 +115,19 @@ function fallbackLegs(model, call) {
 * @experimental This surface is experimental and may change.
 */
 function parseCallOptions(providerOptions) {
+	const options = parseModelOptions(providerOptions?.[PROVIDER_OPTIONS_KEY]);
+	for (const leg of options?.fallback ?? []) requireLanguageModelId(leg);
+	return options;
+}
+/**
+* Per-call options for the modality models — embedding, image, speech,
+* transcription, reranking. The same bag as {@link parseCallOptions}, but a
+* fallback leg must be a Workers AI id: a dynamic route answers in the
+* chat-completions shape, which none of those models can read.
+*
+* @experimental This surface is experimental and may change.
+*/
+function parseModalityCallOptions(providerOptions) {
 	const options = parseModelOptions(providerOptions?.[PROVIDER_OPTIONS_KEY]);
 	for (const leg of options?.fallback ?? []) requireWorkersAIId(leg);
 	return options;
@@ -164,7 +175,7 @@ function withoutCallFallback(options) {
 //#region src/models/ai-sdk/transport.ts
 /**
 * The typed AI SDK error for the gateway's own error envelope — a missing
-* gateway, an unpaid account — on the universal path.
+* gateway, an unpaid account — on the provider-native path.
 */
 function errorFromGatewayEnvelope(body, context) {
 	return CloudflareAIError.fromCore(errorFromGatewayEnvelope$1(body, context));
@@ -194,16 +205,16 @@ function createTransport(settings) {
 	const inner = createTransport$1(settings);
 	return {
 		logIdFallback: (response) => inner.logIdFallback(response),
-		async run(request) {
+		async native(request) {
 			try {
-				return await inner.run(request);
+				return await inner.native(request);
 			} catch (error) {
 				throw toAISDKError(error);
 			}
 		},
-		async universal(request) {
+		async run(request) {
 			try {
-				return await inner.universal(request);
+				return await inner.run(request);
 			} catch (error) {
 				throw toAISDKError(error);
 			}
@@ -489,7 +500,7 @@ var CloudflareEmbeddingModel = class {
 			provider: this.provider,
 			values: options.values
 		});
-		const resolved = resolveOptions(_classPrivateFieldGet2(_config$3, this).providerGateway, _classPrivateFieldGet2(_options$3, this), parseCallOptions(options.providerOptions));
+		const resolved = resolveOptions(_classPrivateFieldGet2(_config$3, this).providerGateway, _classPrivateFieldGet2(_options$3, this), parseModalityCallOptions(options.providerOptions));
 		const input = { text: options.values };
 		const transport = _classPrivateFieldGet2(_config$3, this).transport;
 		return withFallback(this.modelId, resolved.fallback, transport.url, async (modelId) => {
@@ -1129,12 +1140,12 @@ function callHeaders(options, resolved) {
 * attaches to its result. Shared with the non-language models in
 * `models/modality.ts`.
 */
-function cloudflareMetadata(model, resolved, response, transport, provider) {
+function cloudflareMetadata(model, gateway, response, transport, provider) {
 	const headers = response.headers;
 	const rawStep = headers.get("cf-aig-step");
 	const step = rawStep === null ? NaN : Number(rawStep);
 	const metadata = {
-		gateway: resolved.gateway.id,
+		...gateway === void 0 ? {} : { gateway },
 		model,
 		...provider === void 0 ? {} : { provider },
 		...Number.isNaN(step) ? {} : { step }
@@ -1302,7 +1313,7 @@ var CloudflareLanguageModel = class {
 			return {
 				content: generation.content,
 				finishReason: generation.finishReason,
-				providerMetadata: cloudflareMetadata(modelId, resolved, response, _classPrivateFieldGet2(_config$2, this).transport),
+				providerMetadata: cloudflareMetadata(modelId, resolved.gateway.id, response, _classPrivateFieldGet2(_config$2, this).transport),
 				request: { body: request.body },
 				response: {
 					headers: headersToObject(response.headers),
@@ -1322,7 +1333,7 @@ var CloudflareLanguageModel = class {
 		return _assertClassBrand(_CloudflareLanguageModel_brand, this, _withFallback$1).call(this, call, (model) => model.doStream(legOptions), async (modelId) => {
 			const request = buildRequest(modelId, options, resolved, true);
 			const response = await _assertClassBrand(_CloudflareLanguageModel_brand, this, _send).call(this, modelId, request, options, resolved);
-			const providerMetadata = cloudflareMetadata(modelId, resolved, response, _classPrivateFieldGet2(_config$2, this).transport);
+			const providerMetadata = cloudflareMetadata(modelId, resolved.gateway.id, response, _classPrivateFieldGet2(_config$2, this).transport);
 			const contentType = response.headers.get("content-type") ?? "";
 			const decorate = decorateStream(request.warnings, providerMetadata);
 			let parts;
@@ -1368,6 +1379,7 @@ function _resolve$1(call) {
 }
 async function _send(modelId, request, options, resolved) {
 	const response = await _classPrivateFieldGet2(_config$2, this).transport.run({
+		format: "chat-completions",
 		gateway: resolved.gateway,
 		headers: callHeaders(options, resolved),
 		input: request.body,
@@ -1394,7 +1406,7 @@ function _withFallback$1(call, runLeg, runSelf, mode = "generate") {
 		model: this.modelId,
 		run: () => runSelf(this.modelId)
 	}, ...legs.map((leg) => typeof leg === "string" ? {
-		model: requireWorkersAIId(leg),
+		model: requireLanguageModelId(leg),
 		run: () => runSelf(leg)
 	} : {
 		model: leg.modelId,
@@ -1441,36 +1453,34 @@ function requestUrl(input) {
 }
 /**
 * The body of either `fetch` call form: the `RequestInit`'s when one was
-* given, else the `Request`'s own, read from a clone so the caller's object
-* is neither consumed nor mutated.
+* given, else the `Request`'s own, from a clone so the caller's object is
+* neither consumed nor mutated.
 */
-async function requestBody(input, init) {
+function requestBody(input, init) {
 	if (init?.body !== void 0) return init.body;
-	if (input instanceof Request && input.body !== null) return await input.clone().text();
+	if (input instanceof Request && input.body !== null) return input.clone().body;
 }
-/**
-* The vendor's body as the universal request's `query`. Only JSON travels:
-* the gateway's universal request has one JSON field for the whole upstream
-* body, so a multipart upload or a streamed body cannot be expressed.
-*/
-function universalQuery(body) {
-	if (typeof body !== "string") {
-		const kind = body === null || body === void 0 ? "an empty" : body instanceof FormData ? "a FormData" : `a ${body.constructor?.name ?? typeof body}`;
-		throw new TypeError(`AI Gateway's universal request carries a JSON body only, and this model sent ${kind} body. File uploads and other multipart requests cannot be routed through the gateway; call the vendor directly for those.`);
-	}
+/** The method of either `fetch` call form. */
+function requestMethod(input, init) {
+	return init?.method ?? (input instanceof Request ? input.method : "POST");
+}
+/** The vendor model id out of a JSON body, for error reporting. */
+function modelOfBody(body) {
+	if (typeof body !== "string") return void 0;
 	try {
-		return JSON.parse(body);
-	} catch (error) {
-		throw new TypeError(`AI Gateway's universal request carries a JSON body only, and this model sent a body that is not JSON: ${String(error)}`);
+		return modelOf(JSON.parse(body));
+	} catch {
+		return;
 	}
 }
 /**
-* The vendor's own request headers, minus the credential the gateway supplies
-* itself and the length of a body we are about to re-serialize.
+* The vendor's own request headers, minus the length of a body we are about
+* to re-serialize, and minus the vendor's credential unless the model asked
+* for it to be forwarded.
 */
-function forwardedHeaders(init, input, route) {
+function forwardedHeaders(init, input, route, vendorKey) {
 	const source = init?.headers ?? (input instanceof Request ? input.headers : void 0);
-	const dropped = /* @__PURE__ */ new Set([...route.authHeaders, "content-length"]);
+	const dropped = /* @__PURE__ */ new Set([...vendorKey === "request" ? [] : route.authHeaders, "content-length"]);
 	const headers = {};
 	new Headers(source).forEach((value, key) => {
 		if (!dropped.has(key.toLowerCase())) headers[key] = value;
@@ -1487,42 +1497,42 @@ function replayed(response, text) {
 	});
 }
 /**
-* The `fetch` a routed model is given. It never reaches the vendor: it maps
-* the vendor's URL onto a gateway provider slug and endpoint, hands the body
-* over untouched, and returns the gateway's answer as the vendor's own.
+* The `fetch` a routed model is given. It maps the vendor's URL onto a gateway
+* provider slug and endpoint and sends the request there unchanged, through
+* the binding; the answer is the vendor's own.
 */
 function routedFetch(context) {
 	const routed = async (input, init) => {
 		const route = requireGatewayProvider(requestUrl(input));
-		const query = universalQuery(await requestBody(input, init));
+		const body = requestBody(input, init);
 		const { resolved } = context;
-		const extraHeaders = {
-			...resolved.headers,
-			...resolved.sessionAffinity === void 0 ? {} : { "x-session-affinity": resolved.sessionAffinity }
-		};
-		const response = await context.config.transport.universal({
+		const response = await context.config.transport.native({
+			body,
 			endpoint: route.endpoint,
-			...Object.keys(extraHeaders).length > 0 ? { extraHeaders } : {},
 			gateway: resolved.gateway,
-			headers: forwardedHeaders(init, input, route),
+			headers: {
+				...forwardedHeaders(init, input, route, context.vendorKey),
+				...resolved.headers,
+				...resolved.sessionAffinity === void 0 ? {} : { "x-session-affinity": resolved.sessionAffinity }
+			},
+			method: requestMethod(input, init),
 			provider: route.provider,
-			query,
 			signal: init?.signal ?? (input instanceof Request ? input.signal : void 0) ?? context.signal
 		});
 		context.capture.provider = route.provider;
 		context.capture.response = response;
 		if (response.ok) return response;
 		const text = await response.text();
-		let body;
+		let envelope;
 		try {
-			body = JSON.parse(text);
+			envelope = JSON.parse(text);
 		} catch {
 			return replayed(response, text);
 		}
-		if (!isGatewayErrorEnvelope(body)) return replayed(response, text);
-		throw errorFromGatewayEnvelope(body, {
-			model: modelOf(query) ?? route.provider,
-			requestBodyValues: query,
+		if (!isGatewayErrorEnvelope(envelope)) return replayed(response, text);
+		throw errorFromGatewayEnvelope(envelope, {
+			model: modelOfBody(body) ?? route.provider,
+			requestBodyValues: void 0,
 			responseBody: text,
 			responseHeaders: headersToObject(response.headers),
 			status: response.status,
@@ -1709,7 +1719,8 @@ function _route(resolved, capture, signal) {
 		capture,
 		config: _classPrivateFieldGet2(_config$1, this),
 		resolved,
-		signal
+		signal,
+		vendorKey: _classPrivateFieldGet2(_options$1, this)?.vendorKey ?? "gateway"
 	}));
 }
 function _resolve(call) {
@@ -1717,7 +1728,7 @@ function _resolve(call) {
 }
 function _metadata(resolved, capture) {
 	const response = capture.response ?? new Response(null);
-	return cloudflareMetadata(this.modelId, resolved, response, _classPrivateFieldGet2(_config$1, this).transport, capture.provider);
+	return cloudflareMetadata(this.modelId, resolved.gateway.id, response, _classPrivateFieldGet2(_config$1, this).transport, capture.provider);
 }
 function _response(response, capture) {
 	if (capture.response === void 0) return response;
@@ -1752,14 +1763,14 @@ function _withFallback(call, runLeg, run, mode = "generate") {
 }
 /** A Workers AI leg, carrying this model's gateway options but no chain. */
 function _workersAI(modelId) {
-	return new CloudflareLanguageModel(requireWorkersAIId(modelId), {
+	return new CloudflareLanguageModel(requireLanguageModelId(modelId), {
 		..._classPrivateFieldGet2(_options$1, this),
 		fallback: void 0
 	}, _classPrivateFieldGet2(_config$1, this));
 }
 /**
 * Routes any other AI SDK v4 model the vendor built — embedding, image,
-* speech, transcription — through the same universal gateway request. Only
+* speech, transcription — through the same provider-native request. Only
 * `fetch` is swapped; every `do…` method stays the vendor's, and its result
 * gains `providerMetadata.cloudflare` when the result is an object that can
 * carry one.
@@ -1779,7 +1790,8 @@ function routed(model, options, config) {
 				capture,
 				config,
 				resolved,
-				signal: call?.abortSignal
+				signal: call?.abortSignal,
+				vendorKey: options?.vendorKey ?? "gateway"
 			}));
 			const result = await Reflect.get(clone, property).call(clone, upstream);
 			if (result === null || typeof result !== "object") return result;
@@ -1787,13 +1799,18 @@ function routed(model, options, config) {
 			return {
 				...result,
 				...routedWarnings(result, resolved),
-				providerMetadata: mergeMetadata(existing, metadataFor(result, cloudflareMetadata(String(target.modelId ?? ""), resolved, capture.response ?? new Response(null), config.transport, capture.provider)))
+				providerMetadata: mergeMetadata(existing, metadataFor(result, cloudflareMetadata(String(target.modelId ?? ""), resolved.gateway.id, capture.response ?? new Response(null), config.transport, capture.provider)))
 			};
 		};
 	} });
 }
 //#endregion
 //#region src/models/ai-sdk/models/modality.ts
+/** Whether the caller set any gateway option, the id included. */
+function gatewayConfigured(gateway) {
+	const { id, ...options } = gateway;
+	return id !== "default" || Object.keys(options).length > 0;
+}
 /** The `unsupported` warning shape, which every modality needs. */
 function unsupported(feature, details) {
 	return {
@@ -1843,11 +1860,21 @@ var CloudflareModalityModel = class {
 	* as JSON or as raw bytes depending on what the model sent back.
 	*/
 	async send(call) {
-		const resolved = resolveOptions(_classPrivateFieldGet2(_config, this).providerGateway, _classPrivateFieldGet2(_options, this), parseCallOptions(call.providerOptions));
+		const resolved = resolveOptions(_classPrivateFieldGet2(_config, this).providerGateway, _classPrivateFieldGet2(_options, this), parseModalityCallOptions(call.providerOptions));
 		const transport = _classPrivateFieldGet2(_config, this).transport;
 		return withFallback(this.modelId, resolved.fallback, transport.url, async (modelId) => {
 			const request = call.build(modelId);
+			const direct = request.audio !== void 0;
+			const sent = request.audio === void 0 ? request.input : {
+				...request.input,
+				audio: {
+					body: toBase64(request.audio.bytes),
+					contentType: request.audio.contentType
+				}
+			};
+			const warnings = direct && gatewayConfigured(resolved.gateway) ? [...request.warnings, unsupported("gateway", `${modelId} goes to Workers AI directly, so the gateway options do not apply.`)] : request.warnings;
 			const response = await transport.run({
+				...request.audio === void 0 ? {} : { audio: request.audio },
 				gateway: resolved.gateway,
 				headers: {
 					...definedHeaders(call.headers),
@@ -1860,20 +1887,20 @@ var CloudflareModalityModel = class {
 			});
 			if (!response.ok) throw await errorFromResponse(response, {
 				model: modelId,
-				requestBodyValues: request.input,
+				requestBodyValues: sent,
 				url: transport.url
 			});
 			const mediaType = (response.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
-			const body = await _assertClassBrand(_CloudflareModalityModel_brand, this, _decode).call(this, response, modelId, request.input, mediaType);
+			const body = await _assertClassBrand(_CloudflareModalityModel_brand, this, _decode).call(this, response, modelId, sent, mediaType);
 			const answer = {
 				headers: headersToObject(response.headers),
-				input: request.input,
+				input: sent,
 				mediaType,
 				modelId,
-				providerMetadata: cloudflareMetadata(modelId, resolved, response, transport),
+				providerMetadata: cloudflareMetadata(modelId, direct ? void 0 : resolved.gateway.id, response, transport),
 				timestamp: /* @__PURE__ */ new Date(),
 				url: transport.url,
-				warnings: request.warnings,
+				warnings,
 				...body
 			};
 			call.check?.(answer);
@@ -2244,13 +2271,13 @@ var CloudflareSpeechModel = class extends CloudflareModalityModel {
 */
 const BYTE_ARRAY_AUDIO = /* @__PURE__ */ new Set(["@cf/openai/whisper", "@cf/openai/whisper-tiny-en"]);
 /**
-* Deepgram's recognition models declare `audio: { body: object, contentType }`.
-* Every documented encoding of that shape answered `400 required properties at
-* '/audio' are 'body,contentType'` on the live run path, because `body` has to
-* be the audio object itself and JSON cannot carry it. Refuse early rather
-* than send a body known to fail.
+* Models that declare `audio: { body, contentType }`. JSON cannot carry that
+* body (base64 and byte arrays answer `400 required properties at '/audio' are
+* 'body,contentType'`), so the audio travels as a raw body.
 */
-const UNSUPPORTED = /* @__PURE__ */ new Set(["@cf/deepgram/nova-3", "@cf/deepgram/flux"]);
+const RAW_AUDIO = /* @__PURE__ */ new Set(["@cf/deepgram/nova-3"]);
+/** Deepgram's Flux answers `only supports websocket connections` over HTTP. */
+const WEBSOCKET_ONLY = /* @__PURE__ */ new Set(["@cf/deepgram/flux"]);
 function transcriptionOptions(providerOptions) {
 	const raw = record(providerOptions?.["cloudflare"]) ?? {};
 	const vadFilter = raw.vadFilter;
@@ -2262,10 +2289,32 @@ function transcriptionOptions(providerOptions) {
 		...typeof vadFilter === "boolean" ? { vadFilter } : {}
 	};
 }
-/** Builds the run-path body for one whisper leg. */
+/**
+* Builds the request for a raw-audio model: the audio as a raw body, and
+* `language` as a field. The whisper-only options have no equivalent there.
+*/
+function buildRawAudioRequest(modelId, options, extra) {
+	const warnings = [];
+	for (const feature of [
+		"task",
+		"initialPrompt",
+		"prefix",
+		"vadFilter"
+	]) if (extra[feature] !== void 0) warnings.push(unsupported(feature, `${modelId} has no ${feature}.`));
+	return {
+		audio: {
+			bytes: toBytes(options.audio),
+			contentType: options.mediaType
+		},
+		input: extra.language === void 0 ? {} : { language: extra.language },
+		warnings
+	};
+}
+/** Builds the run-path body for one leg. */
 function buildTranscriptionRequest(modelId, options) {
 	const warnings = [];
 	const extra = transcriptionOptions(options.providerOptions);
+	if (RAW_AUDIO.has(modelId)) return buildRawAudioRequest(modelId, options, extra);
 	const input = BYTE_ARRAY_AUDIO.has(modelId) ? { audio: Array.from(toBytes(options.audio)) } : { audio: toBase64(options.audio) };
 	if (extra.language !== void 0) input.language = extra.language;
 	if (extra.task !== void 0) input.task = extra.task;
@@ -2277,6 +2326,45 @@ function buildTranscriptionRequest(modelId, options) {
 		warnings
 	};
 }
+/** Reads a timed `{ text|word, start, end }` entry as a segment. */
+function timed(entry, textKeys) {
+	const item = record(entry);
+	if (item === void 0) return [];
+	const value = textKeys.map((key) => text(item[key])).find(Boolean);
+	if (value === void 0) return [];
+	return [{
+		endSecond: count(item.end) ?? 0,
+		startSecond: count(item.start) ?? 0,
+		text: value
+	}];
+}
+/**
+* Reads a Deepgram answer: `results.channels[0].alternatives[0]`. Its
+* sentences are the segments when it sends paragraphs, and its words
+* otherwise.
+*/
+function readDeepgram(body) {
+	const channel = record(array(record(body.results)?.channels)?.[0]);
+	const alternative = record(array(channel?.alternatives)?.[0]);
+	const sentences = (array(record(alternative?.paragraphs)?.paragraphs) ?? []).flatMap((paragraph) => array(record(paragraph)?.sentences) ?? []);
+	const segments = sentences.length > 0 ? sentences.flatMap((sentence) => timed(sentence, ["text"])) : (array(alternative?.words) ?? []).flatMap((word) => timed(word, ["punctuated_word", "word"]));
+	return {
+		durationInSeconds: count(record(body.metadata)?.duration),
+		language: text(array(alternative?.languages)?.[0]) ?? text(channel?.detected_language),
+		segments,
+		text: text(alternative?.transcript) ?? ""
+	};
+}
+/** Reads a whisper answer. */
+function readWhisper(body) {
+	const info = record(body.transcription_info);
+	return {
+		durationInSeconds: count(info?.duration),
+		language: text(info?.language),
+		segments: readSegments(body),
+		text: text(body.text) ?? ""
+	};
+}
 /**
 * Reads segments out of a whisper answer. `segments` is what the large models
 * send; the smaller ones send only `words`, whose timings are the best segment
@@ -2318,10 +2406,10 @@ var CloudflareTranscriptionModel = class extends CloudflareModalityModel {
 		const answer = await this.send({
 			abortSignal: options.abortSignal,
 			build: (modelId) => {
-				if (UNSUPPORTED.has(modelId)) throw new CloudflareAIError({
+				if (WEBSOCKET_ONLY.has(modelId)) throw new CloudflareAIError({
 					code: "bad-request",
 					isRetryable: false,
-					message: `${modelId} takes the audio as an object body, which the JSON run path cannot carry. Use @cf/openai/whisper-large-v3-turbo.`,
+					message: `${modelId} takes websocket connections only. Use @cf/deepgram/nova-3 or @cf/openai/whisper-large-v3-turbo.`,
 					model: modelId,
 					requestBodyValues: void 0,
 					url: this.endpoint
@@ -2332,11 +2420,10 @@ var CloudflareTranscriptionModel = class extends CloudflareModalityModel {
 			providerOptions: options.providerOptions
 		});
 		const body = record(answer.json) ?? {};
-		const info = record(body.transcription_info);
-		const language = text(info?.language);
+		const transcript = record(body.results) === void 0 ? readWhisper(body) : readDeepgram(body);
 		return {
-			durationInSeconds: count(info?.duration),
-			language,
+			durationInSeconds: transcript.durationInSeconds,
+			language: transcript.language,
 			providerMetadata: answer.providerMetadata,
 			request: { body: JSON.stringify(answer.input) },
 			response: {
@@ -2345,8 +2432,8 @@ var CloudflareTranscriptionModel = class extends CloudflareModalityModel {
 				modelId: answer.modelId,
 				timestamp: answer.timestamp
 			},
-			segments: readSegments(body),
-			text: text(body.text) ?? "",
+			segments: transcript.segments,
+			text: transcript.text,
 			warnings: answer.warnings
 		};
 	}
@@ -2358,21 +2445,22 @@ function isModel(value) {
 	return typeof value === "object" && value !== null;
 }
 /**
-* Creates a provider over Workers AI, and over every vendor AI Gateway can
-* reach.
+* Creates a provider over Workers AI and the AI Gateway catalog.
 *
-* The Workers AI binding is the only way in — Workers AI models go through
-* `env.AI.run`, vendor models through `env.AI.gateway(id).run`, and there is
-* no HTTP transport and no API token. Gateway options are flat (`id`,
-* `cacheTtl`, …) or nested under `gateway`; per-model options and per-call
-* `providerOptions.cloudflare` override them in that order.
+* A Workers AI id goes to Workers AI and a catalog id or dynamic route to AI
+* Gateway's `/run`, both on `env.AI.run`; a vendor's model object goes to AI
+* Gateway's provider-native path. With `{ accountId, apiToken }` instead of
+* `binding`, the same requests go to the REST API and to
+* `gateway.ai.cloudflare.com`. Gateway
+* options are flat (`id`, `cacheTtl`, …) or nested under `gateway`; per-model
+* options and per-call `providerOptions.cloudflare` override them in that
+* order.
 *
 * ```ts
 * const ai = createAI({ binding: env.AI, id: "prod", cacheTtl: 60 });
-* const anthropic = createAnthropic({ apiKey: "cloudflare" });
 *
 * ai("@cf/zai-org/glm-4.7-flash");
-* ai(anthropic("claude-opus-4-8"), { fallback: [ai("@cf/zai-org/glm-4.7-flash")] });
+* ai("anthropic/claude-opus-4.8", { fallback: ["openai/gpt-5.5"] });
 * ai.embedding("@cf/baai/bge-base-en-v1.5");
 * ```
 *
@@ -2384,36 +2472,34 @@ function createAI(settings) {
 		transport: createTransport(settings)
 	};
 	/**
-	* Fallback legs are normalized once, here: a model object becomes a routed
-	* model, so every leg a model runs is already this provider's.
+	* Fallback legs are normalized once, here. A leg written as an id is gated
+	* at the line that wrote it; a model object is routed like `ai(model)`.
 	*
 	* A leg inherits the chain's *gateway* options and nothing else. The rest of
 	* the bag — `reasoningEffort`, `chatTemplateKwargs`, `headers`,
-	* `sessionAffinity` — was written for the model it was written on, and a leg
-	* that was configured with its own keeps every one of them.
+	* `sessionAffinity`, `vendorKey` — was written for the model it was written
+	* on, and a leg that was configured with its own keeps every one of them.
 	*/
 	const normalize = (options) => {
 		if (options?.fallback === void 0) return options;
 		const inherited = gatewayLayerOf(options);
 		return {
 			...options,
-			fallback: options.fallback.map((leg) => typeof leg === "string" ? requireWorkersAIId(leg) : languageModel(leg, inherited))
+			fallback: options.fallback.map((leg) => typeof leg === "string" ? requireLanguageModelId(leg) : languageModel(leg, inherited))
 		};
 	};
 	function languageModel(model, options) {
 		const resolved = normalize(options);
-		if (isModel(model)) {
-			if (model instanceof CloudflareLanguageModel) {
-				const merged = normalize(mergeModelOptions(optionsOf(model), resolved));
-				return new CloudflareLanguageModel(model.modelId, merged, config);
-			}
-			if (model instanceof GatewayLanguageModel) {
-				const merged = normalize(mergeModelOptions(optionsOf(model), resolved));
-				return new GatewayLanguageModel(model.model, merged, config);
-			}
-			return new GatewayLanguageModel(model, resolved, config);
+		if (!isModel(model)) return new CloudflareLanguageModel(requireLanguageModelId(model), resolved, config);
+		if (model instanceof CloudflareLanguageModel) {
+			const merged = normalize(mergeModelOptions(optionsOf(model), resolved));
+			return new CloudflareLanguageModel(model.modelId, merged, config);
+		}
+		if (model instanceof GatewayLanguageModel) {
+			const merged = normalize(mergeModelOptions(optionsOf(model), resolved));
+			return new GatewayLanguageModel(model.model, merged, config);
 		}
-		return new CloudflareLanguageModel(requireWorkersAIId(model), resolved, config);
+		return new GatewayLanguageModel(model, resolved, config);
 	}
 	const embedding = (modelId, options) => new CloudflareEmbeddingModel(modelId, options, config);
 	const image = (modelId, options) => new CloudflareImageModel(modelId, options, config);
@@ -2441,4 +2527,4 @@ function createAI(settings) {
 //#endregion
 export { GatewayLanguageModel as n, CloudflareAIError as r, createAI as t };
 
-//# sourceMappingURL=ai-sdk-Bdsf6mSA.js.map
+//# sourceMappingURL=ai-sdk-DRPh2rRa.js.map