agents 0.28.1 → 0.29.0

package/dist/{agent-routing-BMvWTFEp.d.ts → agent-routing-CDbpVjYq.d.ts}

@@ -4492,13 +4492,12 @@ interface AgentStaticOptions {
    * reset (the isolate exceeded its 128 MB limit) before the alarm-boundary
    * circuit breaker stops the platform's auto-retry loop and seals the looping
    * recovery work (#1825). Default: 3. Set to `0` to seal on the first such
-   * reset. This is the universal backstop for the case where the in-DO recovery
-   * budgets (`chatRecovery.maxOomRetries` / `maxRecoveryWork`) can't engage
-   * because the OOM bypasses them — e.g. it is thrown before the budget code
-   * runs, or its own writes also OOM. The boundary handler runs at the outermost
-   * alarm frame, after the heavy turn has unwound and GC has reclaimed its
-   * footprint, so its small seal/purge writes can land where mid-turn writes
-   * could not.
+   * reset. The strike counter is written after the reset, so it only advances
+   * when that isolate's storage still accepts writes, for example when the
+   * reset error came from another isolate such as D1. A Durable Object's own
+   * memory-limit reset rejects every later storage call in that invocation, so
+   * chat recovery does not rely on this counter: it counts each interrupted
+   * attempt in the next isolate (`chatRecovery.maxInterruptedAttempts`, #2613).
    */
   maxAlarmMemoryLimitStrikes?: number;
 }
@@ -7046,4 +7045,4 @@ export {
   AgentToolEventState as z,
   MCPClientOAuthResult as zt
 };
-//# sourceMappingURL=agent-routing-BMvWTFEp.d.ts.map
+//# sourceMappingURL=agent-routing-CDbpVjYq.d.ts.map

package/dist/agent-routing.d.ts

@@ -4,7 +4,7 @@ import {
   n as AgentOptions,
   r as RoutingRetryOptions,
   t as AgentGetOptions
-} from "./agent-routing-BMvWTFEp.js";
+} from "./agent-routing-CDbpVjYq.js";
 export {
   AgentGetOptions,
   AgentOptions,

package/dist/agent-tool-types.d.ts

@@ -27,7 +27,7 @@ import {
   rt as RunAgentToolResult,
   tt as DetachedRunAgentToolResult,
   z as AgentToolEventState
-} from "./agent-routing-BMvWTFEp.js";
+} from "./agent-routing-CDbpVjYq.js";
 export {
   AGENT_TOOL_MILESTONE_PART,
   AGENT_TOOL_PROGRESS_PART,

package/dist/{agent-tools-ohoewW-B.d.ts → agent-tools-C8DH8Yii.d.ts}

@@ -4,7 +4,7 @@ import {
   W as AgentToolProgress,
   Z as AgentToolStoredChunk,
   z as AgentToolEventState
-} from "./agent-routing-BMvWTFEp.js";
+} from "./agent-routing-CDbpVjYq.js";
 
 //#region src/chat/agent-tools.d.ts
 type AgentToolProgressEmitResult = "emitted" | "coalesced" | "inactive";
@@ -144,4 +144,4 @@ export {
   interceptAgentToolBroadcast as s,
   AgentToolBroadcastHooks as t
 };
-//# sourceMappingURL=agent-tools-ohoewW-B.d.ts.map
+//# sourceMappingURL=agent-tools-C8DH8Yii.d.ts.map

package/dist/agent-tools.d.ts

@@ -20,7 +20,7 @@ import {
   rt as RunAgentToolResult,
   tt as DetachedRunAgentToolResult,
   z as AgentToolEventState
-} from "./agent-routing-BMvWTFEp.js";
+} from "./agent-routing-CDbpVjYq.js";
 import { FlexibleSchema, InferSchema, Tool } from "ai";
 
 //#region src/agent-tools.d.ts

package/dist/{ai-ahruGw7e.d.ts → ai-iXw0uOGj.d.ts}

@@ -1,13 +1,13 @@
 import {
   d as BrowserBinding,
   n as BrowserSessionStore
-} from "./session-store-DoPY12xM.js";
+} from "./session-store-_IK6dV-w.js";
 import {
   l as QuickActionBinding,
   r as BrowserConnectorSessionOptions,
   t as BrowserConnector,
   u as QuickActionCommonOptions
-} from "./connector-DEXzVoaY.js";
+} from "./connector-20DJ6p4k.js";
 import { ToolSet } from "ai";
 import { CodemodeRuntimeHandle } from "@cloudflare/codemode";
 
@@ -236,4 +236,4 @@ export {
   createQuickActionTools as s,
   BrowserRuntime as t
 };
-//# sourceMappingURL=ai-ahruGw7e.d.ts.map
+//# sourceMappingURL=ai-iXw0uOGj.d.ts.map

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

@@ -1,52 +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 { C as isDynamicRouteId, 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, w as isRunPathLanguageModelId, x as isAbortError, y as CloudflareAIError$1 } from "./images-C4hiIexM.js";
-import { a as parseModelOptions, i as mergeModelOptions, n as PROVIDER_OPTIONS_KEY, o as resolveOptions, r as gatewayLayerOf } from "./settings-BjAiPd6Z.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, accepts = "workers-ai") {
-	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/"${accepts === "workers-ai-or-route" ? " (and AI Gateway dynamic routes with \"dynamic/\")" : ""}, 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 (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 notAWorkersAIId(modelId);
+	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 for ids that name a language model: a Workers AI id, or an AI
-* Gateway dynamic route. Both run on `env.AI.run`; any other string is a
-* vendor id, which is never a string here.
+* 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 (!isRunPathLanguageModelId(modelId)) throw notAWorkersAIId(modelId, "workers-ai-or-route");
+	if (!isLanguageModelId(modelId)) throw notAModelId(modelId, "language");
 	return modelId;
 }
 /**
@@ -187,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));
@@ -217,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);
 			}
@@ -1152,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 }
@@ -1325,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),
@@ -1345,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;
@@ -1391,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,
@@ -1464,27 +1453,24 @@ 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;
 	}
 }
 /**
@@ -1511,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, context.vendorKey),
+			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,
@@ -1742,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;
@@ -1784,7 +1770,7 @@ function _workersAI(modelId) {
 }
 /**
 * 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.
@@ -1813,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 {
@@ -1873,7 +1864,17 @@ var CloudflareModalityModel = class {
 		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),
@@ -1886,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);
@@ -2270,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;
@@ -2288,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;
@@ -2303,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
@@ -2344,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
@@ -2358,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: {
@@ -2371,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
 		};
 	}
@@ -2384,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");
 * ```
 *
@@ -2410,13 +2472,13 @@ 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;
@@ -2428,18 +2490,16 @@ function createAI(settings) {
 	};
 	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(requireLanguageModelId(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);
@@ -2467,4 +2527,4 @@ function createAI(settings) {
 //#endregion
 export { GatewayLanguageModel as n, CloudflareAIError as r, createAI as t };
 
-//# sourceMappingURL=ai-sdk-C2iTAwUd.js.map
+//# sourceMappingURL=ai-sdk-DRPh2rRa.js.map