agents 0.28.0 → 0.29.0

package/dist/{images-Ce9SCu3X.js → images-xaDv2Fqe.js}

@@ -1,3 +1,44 @@
+//#region src/models/core/catalog.ts
+/**
+* Whether an id names an AI Gateway dynamic route: `dynamic/` and a route
+* name after it.
+*
+* @experimental This surface is experimental and may change.
+*/
+function isDynamicRouteId(modelId) {
+	return modelId.startsWith("dynamic/") && modelId.length > 8;
+}
+/**
+* Whether an id names a Workers AI model, served by Workers AI itself rather
+* than by AI Gateway's `/run`.
+*
+* @experimental This surface is experimental and may change.
+*/
+function isWorkersAIId(modelId) {
+	return modelId.startsWith("@cf/") || modelId.startsWith("@hf/");
+}
+/**
+* Whether an id names an AI Gateway catalog model: an author and a model,
+* neither empty, and none of the other id namespaces (`@cf/`, `@hf/`,
+* `dynamic/`).
+*
+* @experimental This surface is experimental and may change.
+*/
+function isCatalogModelId(modelId) {
+	if (modelId.startsWith("@") || modelId.startsWith("dynamic/")) return false;
+	const slash = modelId.indexOf("/");
+	return slash > 0 && slash < modelId.length - 1;
+}
+/**
+* Whether a string names a language model that runs on `env.AI.run`: a
+* Workers AI id or an AI Gateway dynamic route.
+*
+* @experimental This surface is experimental and may change.
+*/
+function isRunPathLanguageModelId(modelId) {
+	return modelId.startsWith("@cf/") || isDynamicRouteId(modelId);
+}
+//#endregion
 //#region src/models/core/errors.ts
 /**
 * Error thrown for every failed Cloudflare AI call, whether it came back as a
@@ -126,9 +167,155 @@ function normalizeThrownError(error, context) {
 	});
 }
 //#endregion
+//#region src/models/core/resume.ts
+/**
+* Resuming a streamed `/run` answer that dropped mid-way.
+*
+* AI Gateway's Run Durable Object keeps every SSE event of a streamed run and
+* names the run in `cf-aig-run-id`. The binding can replay the stream from any
+* event index:
+*
+* ```ts
+* env.AI.fetch(`https://workers-binding.ai/ai-gateway/gateways/${id}/run/${runId}/resume?from=${n}`)
+* ```
+*
+* The run keeps going on the gateway after the client is gone, so a replay
+* from the right index continues the same answer rather than starting a new
+* one. This wrapper makes that transparent: it reads the original body, and
+* when a read fails it reconnects to the resume route and keeps feeding the
+* same consumer, which never sees the break.
+*
+* The one subtlety is alignment. `from` counts complete SSE events, so the
+* wrapper only ever passes complete events on and holds back a trailing
+* partial one. After a drop the partial is discarded and the replay starts at
+* the count of events already delivered: no byte is duplicated or lost.
+*
+* @experimental This surface is experimental and may change.
+*/
+const EMPTY = /* @__PURE__ */ new Uint8Array(0);
+function concat(a, b) {
+	const out = new Uint8Array(a.length + b.length);
+	out.set(a, 0);
+	out.set(b, a.length);
+	return out;
+}
+/** Index just past the last `\n\n` in `buffer`, or -1 when none is complete. */
+function lastEventBoundary(buffer) {
+	for (let i = buffer.length - 2; i >= 0; i--) if (buffer[i] === 10 && buffer[i + 1] === 10) return i + 2;
+	return -1;
+}
+/** Complete SSE events in `buffer`: `\n\n` terminators, counted once each. */
+function countEvents(buffer) {
+	let count = 0;
+	for (let i = 0; i + 1 < buffer.length; i++) if (buffer[i] === 10 && buffer[i + 1] === 10) {
+		count++;
+		i++;
+	}
+	return count;
+}
+/**
+* Wraps a streamed `/run` body so a dropped connection resumes from the last
+* complete event. Errors once the replay buffer has expired (404), when a
+* replay fails, or after `maxReconnects` drops.
+*
+* @experimental This surface is experimental and may change.
+*/
+function resumableBody(options) {
+	const maxReconnects = options.maxReconnects ?? 5;
+	let delivered = 0;
+	let pending = EMPTY;
+	let reconnects = 0;
+	let cancelled = false;
+	let reader;
+	const stopped = () => cancelled || options.signal?.aborted === true;
+	const failure = (message, extra = {}) => new CloudflareAIError({
+		code: "provider-error",
+		isRetryable: false,
+		message,
+		model: options.model,
+		requestBodyValues: void 0,
+		url: options.url,
+		...extra
+	});
+	/** The replay from the events already delivered, or undefined after an error. */
+	async function replay(controller) {
+		let response;
+		try {
+			response = await options.resume(delivered, options.signal);
+		} catch (error) {
+			controller.error(failure(`The stream dropped at event ${delivered} and the resume request failed.`, { cause: error }));
+			return;
+		}
+		if (response.status === 404) {
+			controller.error(failure(`The stream dropped at event ${delivered}, and AI Gateway no longer holds the run to resume it.`, { status: 404 }));
+			return;
+		}
+		if (!response.ok || response.body === null) {
+			controller.error(failure(`The stream dropped at event ${delivered} and resuming it failed (${response.status}).`, { status: response.status }));
+			return;
+		}
+		return response.body;
+	}
+	return new ReadableStream({
+		async start(controller) {
+			let current = options.initial;
+			for (;;) {
+				reader = current.getReader();
+				try {
+					for (;;) {
+						const { done, value } = await reader.read();
+						if (done) {
+							if (pending.length > 0) controller.enqueue(pending);
+							pending = EMPTY;
+							controller.close();
+							return;
+						}
+						if (value === void 0 || value.length === 0) continue;
+						pending = concat(pending, value);
+						const boundary = lastEventBoundary(pending);
+						if (boundary > 0) {
+							const complete = pending.slice(0, boundary);
+							controller.enqueue(complete);
+							delivered += countEvents(complete);
+							pending = pending.slice(boundary);
+						}
+					}
+				} catch (error) {
+					try {
+						reader.releaseLock();
+					} catch {}
+					if (stopped()) {
+						if (!cancelled) controller.error(error);
+						return;
+					}
+					if (reconnects >= maxReconnects) {
+						controller.error(failure(`The stream dropped ${reconnects + 1} times; giving up at event ${delivered}.`, { cause: error }));
+						return;
+					}
+					pending = EMPTY;
+					reconnects++;
+					const body = await replay(controller);
+					if (body === void 0) return;
+					current = body;
+				}
+			}
+		},
+		cancel(reason) {
+			cancelled = true;
+			reader?.cancel(reason).catch(() => {});
+		}
+	});
+}
+//#endregion
 //#region src/models/core/transport.ts
-/** The reported `url` for a universal call made through the binding. */
-const UNIVERSAL_BINDING_URL = "ai-gateway-binding";
+/** The reported `url` for a provider-native call made through the binding. */
+const NATIVE_BINDING_URL = "ai-gateway-binding-native";
+/** The origin the binding's own `fetch` answers on. */
+const BINDING_ORIGIN = "https://workers-binding.ai";
+/** The REST API's run path, for a model id reached with an account and token. */
+const REST_API_ORIGIN = "https://api.cloudflare.com/client/v4/accounts";
+/** The provider-native path, for a model object reached with a token. */
+const GATEWAY_ORIGIN = "https://gateway.ai.cloudflare.com/v1";
 /**
 * Drops entries whose value is `undefined`. The AI SDK types call headers as
 * `Record<string, string | undefined>`, and an undefined value reaches the
@@ -222,23 +409,85 @@ async function errorFromResponse(response, context) {
 	});
 }
 /**
-* The gateway's own options for the universal call. The id is not among them:
-* it selects the gateway (`env.AI.gateway(id)`), and the binding's own `id`
-* field is deprecated.
+* The gateway options as the `cf-aig-*` request headers AI Gateway reads.
+* The provider-native path has no options object, so every option travels
+* this way; the names are the gateway's own.
 */
-function universalGatewayOptions(gateway) {
-	const options = { id: gateway.id };
-	if (gateway.skipCache !== void 0) options.skipCache = gateway.skipCache;
-	if (gateway.cacheTtl !== void 0) options.cacheTtl = gateway.cacheTtl;
-	if (gateway.cacheKey !== void 0) options.cacheKey = gateway.cacheKey;
-	if (gateway.metadata !== void 0) options.metadata = gateway.metadata;
-	if (gateway.collectLog !== void 0) options.collectLog = gateway.collectLog;
-	if (gateway.eventId !== void 0) options.eventId = gateway.eventId;
-	if (gateway.requestTimeoutMs !== void 0) options.requestTimeoutMs = gateway.requestTimeoutMs;
-	if (gateway.retries !== void 0) options.retries = gateway.retries;
-	return options;
+function gatewayHeaders(gateway) {
+	const headers = {};
+	if (gateway.cacheTtl !== void 0) headers["cf-aig-cache-ttl"] = String(gateway.cacheTtl);
+	if (gateway.skipCache !== void 0) headers["cf-aig-skip-cache"] = String(gateway.skipCache);
+	if (gateway.cacheKey !== void 0) headers["cf-aig-cache-key"] = gateway.cacheKey;
+	if (gateway.metadata !== void 0) headers["cf-aig-metadata"] = JSON.stringify(gateway.metadata);
+	if (gateway.collectLog !== void 0) headers["cf-aig-collect-log"] = String(gateway.collectLog);
+	if (gateway.eventId !== void 0) headers["cf-aig-event-id"] = gateway.eventId;
+	if (gateway.requestTimeoutMs !== void 0) headers["cf-aig-request-timeout"] = String(gateway.requestTimeoutMs);
+	const retries = gateway.retries;
+	if (retries?.maxAttempts !== void 0) headers["cf-aig-max-attempts"] = String(retries.maxAttempts);
+	if (retries?.retryDelayMs !== void 0) headers["cf-aig-retry-delay"] = String(retries.retryDelayMs);
+	if (retries?.backoff !== void 0) headers["cf-aig-backoff"] = retries.backoff;
+	if (gateway.byokAlias !== void 0) headers["cf-aig-byok-alias"] = gateway.byokAlias;
+	if (gateway.zdr !== void 0) headers["cf-aig-zdr"] = String(gateway.zdr);
+	return headers;
 }
 /**
+* The run path's gateway options, and the headers for the ones the binding's
+* `GatewayOptions` type does not define. Both transports use it: the binding
+* takes `gateway` as an options object, HTTP as `cf-aig-*` headers.
+*
+* `byokAlias` reaches `/run` as `cf-aig-byok-alias`, which `/run` reads for a
+* catalog model's stored key. `zdr` is left off: `/run` does not read it, so it
+* applies to provider-native requests only.
+*/
+function runOptions(request) {
+	const { byokAlias, zdr: _zdr, ...gateway } = request.gateway;
+	return {
+		gateway,
+		headers: {
+			...request.headers,
+			...byokAlias !== void 0 && isCatalogModelId(request.model) ? { "cf-aig-byok-alias": byokAlias } : {}
+		}
+	};
+}
+/**
+* The binding's resume route for the run a response names. Only called for a
+* response {@link withResume} has checked carries `cf-aig-run-id`.
+*/
+function resumeUrl(gatewayId, response, from) {
+	const runId = response.headers.get("cf-aig-run-id") ?? "";
+	return `${BINDING_ORIGIN}/ai-gateway/gateways/${encodeURIComponent(gatewayId)}/run/${encodeURIComponent(runId)}/resume?from=${from}`;
+}
+/**
+* A streamed `/run` answer that names its run (`cf-aig-run-id`) resumes from
+* the last complete event if the connection drops; see `resume.ts`. Anything
+* else — a JSON answer, an error, a Workers AI stream with no run id — is
+* returned as it is.
+*/
+function withResume(response, request, resume) {
+	const contentType = response.headers.get("content-type") ?? "";
+	if (!response.ok || response.body === null || !contentType.includes("text/event-stream") || response.headers.get("cf-aig-run-id") === null) return response;
+	return new Response(resumableBody({
+		initial: response.body,
+		model: request.model,
+		resume,
+		signal: request.signal,
+		url: "workers-ai-binding"
+	}), {
+		headers: response.headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+/**
+* What `/run` calls each request format in the binding's `openaiEndpoint`
+* option, which `aig-entry` turns into `/run`'s `requestFormat`.
+*/
+const OPENAI_ENDPOINTS = {
+	"chat-completions": "/v1/chat/completions",
+	messages: "/v1/messages",
+	responses: "/v1/responses"
+};
+/**
 * Whether a parsed body is the gateway's own error envelope rather than a
 * vendor payload — `{ success: false, error: [{ code, message }] }`, named
 * `AiGatewayError`. The gateway answers this for its own failures (no such
@@ -257,7 +506,7 @@ function isGatewayErrorEnvelope(json) {
 }
 /**
 * Builds a {@link CloudflareAIError} from the gateway's own error envelope, so
-* a gateway failure on the universal path classifies and retries exactly as
+* a gateway failure on the provider-native path classifies and retries exactly as
 * one on the Workers AI run path.
 *
 * @experimental This surface is experimental and may change.
@@ -277,18 +526,6 @@ function errorFromGatewayEnvelope(body, context) {
 		url: context.url
 	});
 }
-/**
-* The model id a universal request is about, for error reporting. Every vendor
-* body carries `model`; the endpoint is the fallback.
-*/
-function universalModel(request) {
-	const query = request.query;
-	if (query !== null && typeof query === "object" && !Array.isArray(query)) {
-		const model = query.model;
-		if (typeof model === "string") return model;
-	}
-	return `${request.provider}/${request.endpoint}`;
-}
 /** The keyless in-Worker backend: `env.AI.run(...)`. */
 function bindingTransport(binding) {
 	const raw = binding;
@@ -299,15 +536,32 @@ function bindingTransport(binding) {
 		},
 		async run(request) {
 			try {
-				const response = await raw.run(request.model, request.input, {
+				if (request.audio !== void 0) return await raw.run(request.model, {
+					...request.input,
+					audio: {
+						body: new Response(new Uint8Array(request.audio.bytes)).body,
+						contentType: request.audio.contentType
+					}
+				}, {
 					...Object.keys(request.headers).length > 0 ? { extraHeaders: request.headers } : {},
-					gateway: request.gateway,
 					returnRawResponse: true,
 					signal: request.signal
 				});
+				const run = runOptions(request);
+				const response = await raw.run(request.model, request.input, {
+					...Object.keys(run.headers).length > 0 ? { extraHeaders: run.headers } : {},
+					gateway: run.gateway,
+					...isWorkersAIId(request.model) ? {} : { openaiEndpoint: OPENAI_ENDPOINTS[request.format ?? "chat-completions"] },
+					returnRawResponse: true,
+					signal: request.signal
+				});
+				const resumable = withResume(response, request, (from, signal) => binding.fetch(resumeUrl(run.gateway.id, response, from), {
+					method: "GET",
+					signal
+				}));
 				const logId = binding.aiGatewayLogId;
-				if (logId !== null && logId !== void 0) logIds.set(response, logId);
-				return response;
+				if (logId !== null && logId !== void 0) logIds.set(resumable, logId);
+				return resumable;
 			} catch (error) {
 				throw normalizeThrownError(error, {
 					model: request.model,
@@ -316,23 +570,22 @@ function bindingTransport(binding) {
 				});
 			}
 		},
-		async universal(request) {
+		async native(request) {
 			try {
-				return await binding.gateway(request.gateway.id).run({
-					endpoint: request.endpoint,
-					headers: request.headers,
-					provider: request.provider,
-					query: request.query
-				}, {
-					...request.extraHeaders === void 0 ? {} : { extraHeaders: request.extraHeaders },
-					gateway: universalGatewayOptions(request.gateway),
+				return await binding.fetch(`${BINDING_ORIGIN}/ai-gateway/gateways/${encodeURIComponent(request.gateway.id)}/${request.provider}/${request.endpoint}`, {
+					body: request.body ?? null,
+					headers: {
+						...request.headers,
+						...gatewayHeaders(request.gateway)
+					},
+					method: request.method,
 					signal: request.signal
 				});
 			} catch (error) {
 				throw normalizeThrownError(error, {
-					model: universalModel(request),
-					requestBodyValues: request.query,
-					url: UNIVERSAL_BINDING_URL
+					model: `${request.provider}/${request.endpoint}`,
+					requestBodyValues: void 0,
+					url: NATIVE_BINDING_URL
 				});
 			}
 		},
@@ -340,6 +593,140 @@ function bindingTransport(binding) {
 	};
 }
 /**
+* Request headers with the credential set last. `Headers` matches names
+* case-insensitively, so a caller's `Authorization` is replaced rather than
+* sent alongside the token.
+*/
+function withCredential(headers, name, token) {
+	const result = new Headers(headers);
+	result.set(name, `Bearer ${token}`);
+	return result;
+}
+/**
+* A Workers AI answer as the binding returns it. The REST API wraps a JSON
+* answer in the `{ success, result }` envelope where the binding returns the
+* bare result, so a successful envelope is unwrapped; anything else is left
+* for the caller, as it is on the binding.
+*/
+async function bareWorkersAIAnswer(response) {
+	const contentType = response.headers.get("content-type") ?? "";
+	if (!response.ok || !contentType.includes("application/json")) return response;
+	const text = await response.text();
+	let body;
+	try {
+		body = JSON.parse(text);
+	} catch {
+		body = void 0;
+	}
+	const record = body !== null && typeof body === "object" && !Array.isArray(body) ? body : void 0;
+	const unwrapped = record?.success === true && "result" in record ? record.result : void 0;
+	const headers = new Headers(response.headers);
+	headers.delete("content-length");
+	return new Response(unwrapped === void 0 ? text : JSON.stringify(unwrapped), {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+/**
+* The HTTP backend, for an account id and API token. A model id goes to the
+* REST API, which serves it with the same `/run` call the binding makes: a
+* Workers AI id on `/ai/run/{model}` with its own input, any other id on the
+* endpoint for its request format with the model in the body. A model object
+* goes to the provider-native path on `gateway.ai.cloudflare.com`, exactly as
+* the binding's `fetch` forwards it.
+*
+* A dropped stream is not resumed: the binding has a resume route, but the
+* public one is not open to every gateway yet.
+*/
+function httpTransport({ accountId, apiToken }) {
+	const account = encodeURIComponent(accountId);
+	const runBase = `${REST_API_ORIGIN}/${account}/ai`;
+	/**
+	* A raw audio body goes to Workers AI's own run route, with the model's
+	* other fields as query parameters. TODO: send it through the gateway once
+	* AI Gateway accepts the body; today the REST API answers `500` when
+	* `cf-aig-gateway-id` is set.
+	*/
+	async function runRawAudio(request, audio) {
+		const query = new URLSearchParams();
+		for (const [key, value] of Object.entries(request.input)) if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") query.set(key, String(value));
+		const search = query.size > 0 ? `?${query}` : "";
+		const url = `${runBase}/run/${request.model}${search}`;
+		try {
+			return await bareWorkersAIAnswer(await fetch(url, {
+				body: new Uint8Array(audio.bytes),
+				headers: withCredential({
+					...request.headers,
+					"content-type": audio.contentType
+				}, "authorization", apiToken),
+				method: "POST",
+				signal: request.signal
+			}));
+		} catch (error) {
+			throw normalizeThrownError(error, {
+				model: request.model,
+				requestBodyValues: request.input,
+				url
+			});
+		}
+	}
+	return {
+		logIdFallback() {},
+		async run(request) {
+			if (request.audio !== void 0) return runRawAudio(request, request.audio);
+			const workersAI = isWorkersAIId(request.model);
+			const run = runOptions(request);
+			const url = workersAI ? `${runBase}/run/${request.model}` : `${runBase}${OPENAI_ENDPOINTS[request.format ?? "chat-completions"]}`;
+			try {
+				const response = await fetch(url, {
+					body: JSON.stringify(workersAI ? request.input : {
+						...request.input,
+						model: request.model
+					}),
+					headers: withCredential({
+						"content-type": "application/json",
+						...gatewayHeaders(run.gateway),
+						"cf-aig-gateway-id": run.gateway.id,
+						...run.headers
+					}, "authorization", apiToken),
+					method: "POST",
+					signal: request.signal
+				});
+				return workersAI ? await bareWorkersAIAnswer(response) : response;
+			} catch (error) {
+				throw normalizeThrownError(error, {
+					model: request.model,
+					requestBodyValues: request.input,
+					url
+				});
+			}
+		},
+		async native(request) {
+			const url = `${GATEWAY_ORIGIN}/${account}/${encodeURIComponent(request.gateway.id)}/${request.provider}/${request.endpoint}`;
+			try {
+				return await fetch(url, {
+					body: request.body ?? null,
+					...request.body instanceof ReadableStream ? { duplex: "half" } : {},
+					headers: withCredential({
+						...request.headers,
+						...gatewayHeaders(request.gateway)
+					}, "cf-aig-authorization", apiToken),
+					method: request.method,
+					signal: request.signal
+				});
+			} catch (error) {
+				throw normalizeThrownError(error, {
+					model: `${request.provider}/${request.endpoint}`,
+					requestBodyValues: void 0,
+					url
+				});
+			}
+		},
+		url: runBase
+	};
+}
+/**
 * Builds the transport for a set of provider settings. The model id, not the
 * caller, decides the wire format; the transport only decides how the request
 * physically leaves the Worker.
@@ -347,14 +734,15 @@ function bindingTransport(binding) {
 * @experimental This surface is experimental and may change.
 */
 function createTransport(settings) {
-	if (settings.binding === void 0) throw new Error("createAI requires { binding }: the Workers AI binding.");
-	return bindingTransport(settings.binding);
+	if (settings.binding !== void 0) return bindingTransport(settings.binding);
+	if (settings.accountId && settings.apiToken) return httpTransport(settings);
+	throw new Error("createAI requires { binding } (the AI binding) or { accountId, apiToken }.");
 }
 //#endregion
 //#region src/models/core/gateway-providers.ts
 /**
 * The AI Gateway provider table: which gateway provider slug a vendor's own
-* base URL belongs to, and what the universal request's `endpoint` is for a
+* base URL belongs to, and what the provider-native `endpoint` is for a
 * given upstream URL.
 *
 * This is platform knowledge, not vendor knowledge — the gateway publishes the
@@ -649,7 +1037,7 @@ const STRICT_OPENAI = {
 	imageUrls: "any",
 	jsonSchema: "supported",
 	jsonSchemaStrict: false,
-	maxTokensField: "max_tokens",
+	maxTokensField: "max_completion_tokens",
 	modelEchoSuffix: void 0,
 	nullAssistantContent: "allowed",
 	reasoningEffortLevels: "basic",
@@ -664,6 +1052,7 @@ const STRICT_OPENAI = {
 const WORKERS_AI = {
 	...STRICT_OPENAI,
 	chatTemplateKwargs: "supported",
+	maxTokensField: "max_tokens",
 	imageUrls: "data-only",
 	nullAssistantContent: "empty-string",
 	reasoningOff: "chat-template",
@@ -712,7 +1101,7 @@ function isWorkersAI(modelId) {
 * The rewrite never throws: a feature the model cannot take is dropped and
 * reported as a {@link CompatWarning}.
 */
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function clampEffort(effort) {
@@ -725,8 +1114,8 @@ function stripImageUrls(message, warnings) {
 	if (!Array.isArray(message.content)) return message;
 	let dropped = 0;
 	const content = message.content.filter((part) => {
-		if (!isRecord$2(part) || part.type !== "image_url") return true;
-		const image = isRecord$2(part.image_url) ? part.image_url : void 0;
+		if (!isRecord$3(part) || part.type !== "image_url") return true;
+		const image = isRecord$3(part.image_url) ? part.image_url : void 0;
 		if ((typeof image?.url === "string" ? image.url : "").startsWith("data:")) return true;
 		dropped += 1;
 		return false;
@@ -768,9 +1157,9 @@ function toolCallIdsIn(messages) {
 		ids.push(value);
 	};
 	for (const message of messages) {
-		if (!isRecord$2(message)) continue;
+		if (!isRecord$3(message)) continue;
 		if (Array.isArray(message.tool_calls)) {
-			for (const call of message.tool_calls) if (isRecord$2(call)) add(call.id);
+			for (const call of message.tool_calls) if (isRecord$3(call)) add(call.id);
 		}
 		add(message.tool_call_id);
 	}
@@ -800,7 +1189,7 @@ function rewriteToolCallIds(message, plan) {
 	if (Array.isArray(rewritten.tool_calls)) rewritten = {
 		...rewritten,
 		tool_calls: rewritten.tool_calls.map((call) => {
-			if (!isRecord$2(call) || typeof call.id !== "string") return call;
+			if (!isRecord$3(call) || typeof call.id !== "string") return call;
 			const replacement = plan.get(call.id);
 			return replacement === void 0 ? call : {
 				...call,
@@ -840,7 +1229,7 @@ function prepareChatCompletionsRequest(input, modelId) {
 		if (effort === null) {
 			delete body.reasoning_effort;
 			if (quirks.reasoningOff === "chat-template") body.chat_template_kwargs = {
-				...isRecord$2(body.chat_template_kwargs) ? body.chat_template_kwargs : {},
+				...isRecord$3(body.chat_template_kwargs) ? body.chat_template_kwargs : {},
 				enable_thinking: false
 			};
 			else warnings.push({
@@ -856,14 +1245,14 @@ function prepareChatCompletionsRequest(input, modelId) {
 			message: `${modelId} does not take chat_template_kwargs; they were dropped.`
 		});
 	}
-	if (isRecord$2(body.response_format)) {
+	if (isRecord$3(body.response_format)) {
 		if (quirks.jsonSchema === "unsupported") {
 			delete body.response_format;
 			warnings.push({
 				feature: "response-format",
 				message: `${modelId} does not support response_format; the request was sent without it.`
 			});
-		} else if (body.response_format.type === "json_schema" && isRecord$2(body.response_format.json_schema)) {
+		} else if (body.response_format.type === "json_schema" && isRecord$3(body.response_format.json_schema)) {
 			const { strict: _strict, ...envelope } = body.response_format.json_schema;
 			body.response_format = {
 				...body.response_format,
@@ -876,8 +1265,8 @@ function prepareChatCompletionsRequest(input, modelId) {
 	}
 	if (body.tool_choice === "required" && quirks.toolChoiceRequired === "named-fallback") {
 		const tools = Array.isArray(body.tools) ? body.tools : [];
-		const only = tools.length === 1 && isRecord$2(tools[0]) ? tools[0] : void 0;
-		const name = only !== void 0 && isRecord$2(only.function) && typeof only.function.name === "string" ? only.function.name : void 0;
+		const only = tools.length === 1 && isRecord$3(tools[0]) ? tools[0] : void 0;
+		const name = only !== void 0 && isRecord$3(only.function) && typeof only.function.name === "string" ? only.function.name : void 0;
 		if (name !== void 0) body.tool_choice = {
 			function: { name },
 			type: "function"
@@ -899,7 +1288,7 @@ function prepareChatCompletionsRequest(input, modelId) {
 		const messages = [];
 		let previousRole;
 		for (const entry of body.messages) {
-			if (!isRecord$2(entry)) continue;
+			if (!isRecord$3(entry)) continue;
 			let message = entry;
 			if (toolCallIds.size > 0) message = rewriteToolCallIds(message, toolCallIds);
 			if (message.role === "user" && quirks.imageUrls === "data-only") message = stripImageUrls(message, warnings);
@@ -928,7 +1317,7 @@ function prepareChatCompletionsRequest(input, modelId) {
 	}
 	return {
 		body,
-		reasoningOff: isRecord$2(body.chat_template_kwargs) && body.chat_template_kwargs.enable_thinking === false,
+		reasoningOff: isRecord$3(body.chat_template_kwargs) && body.chat_template_kwargs.enable_thinking === false,
 		warnings
 	};
 }
@@ -939,13 +1328,13 @@ function prepareChatCompletionsRequest(input, modelId) {
 * strict OpenAI `chat.completion` shape, so framework parsers never see
 * Workers AI's native envelope or its field spellings.
 */
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 /** Native `{ name, arguments: object }` → OpenAI `{ id, type, function }`. */
 function normalizeToolCall(entry, index) {
-	if (!isRecord$1(entry)) return void 0;
-	const fn = isRecord$1(entry.function) ? entry.function : void 0;
+	if (!isRecord$2(entry)) return void 0;
+	const fn = isRecord$2(entry.function) ? entry.function : void 0;
 	const name = typeof fn?.name === "string" ? fn.name : typeof entry.name === "string" ? entry.name : void 0;
 	if (name === void 0) return void 0;
 	const rawArguments = fn !== void 0 && "arguments" in fn ? fn.arguments : entry.arguments;
@@ -994,12 +1383,12 @@ function normalizeMessage(message) {
 * lifted into `choices[0]`.
 */
 function normalizeChatCompletion(body, modelId) {
-	if (!isRecord$1(body)) return { choices: [] };
+	if (!isRecord$2(body)) return { choices: [] };
 	if (Array.isArray(body.choices)) {
 		const choices = body.choices.map((choice) => {
-			if (!isRecord$1(choice)) return choice;
-			const message = isRecord$1(choice.message) ? normalizeMessage(choice.message) : choice.message;
-			const hasToolCalls = isRecord$1(message) && Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
+			if (!isRecord$2(choice)) return choice;
+			const message = isRecord$2(choice.message) ? normalizeMessage(choice.message) : choice.message;
+			const hasToolCalls = isRecord$2(message) && Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
 			return {
 				...choice,
 				message,
@@ -1033,6 +1422,122 @@ function normalizeChatCompletion(body, modelId) {
 	return body;
 }
 //#endregion
+//#region src/models/core/chat-completions/anthropic-stream.ts
+function isRecord$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Anthropic's stop reasons, as chat-completions finish reasons. */
+const FINISH_REASONS = {
+	end_turn: "stop",
+	max_tokens: "length",
+	pause_turn: "stop",
+	refusal: "content_filter",
+	stop_sequence: "stop",
+	tool_use: "tool_calls"
+};
+/** Whether a parsed SSE payload is an Anthropic Messages event. */
+function isAnthropicEvent(event) {
+	return typeof event.type === "string" && !("choices" in event);
+}
+/**
+* A stateful translator for one stream. Returns the chat-completions chunks
+* an Anthropic event becomes — possibly none — or `undefined` for an event
+* that is not Anthropic, which the caller handles as it is.
+*/
+function createAnthropicStreamTranslator() {
+	let id;
+	let model;
+	let inputTokens = 0;
+	let outputTokens = 0;
+	let cachedTokens = 0;
+	const toolIndexes = /* @__PURE__ */ new Map();
+	const chunk = (delta, finishReason = null) => ({
+		choices: [{
+			delta,
+			finish_reason: finishReason,
+			index: 0
+		}],
+		...id === void 0 ? {} : { id },
+		...model === void 0 ? {} : { model },
+		object: "chat.completion.chunk"
+	});
+	return (event) => {
+		if (!isAnthropicEvent(event)) return void 0;
+		switch (event.type) {
+			case "message_start": {
+				const message = isRecord$1(event.message) ? event.message : {};
+				if (typeof message.id === "string") id = message.id;
+				if (typeof message.model === "string") model = message.model;
+				const usage = isRecord$1(message.usage) ? message.usage : {};
+				const cacheRead = Number(usage.cache_read_input_tokens ?? 0) || 0;
+				const cacheWrite = Number(usage.cache_creation_input_tokens ?? 0) || 0;
+				inputTokens = (Number(usage.input_tokens ?? 0) || 0) + cacheRead + cacheWrite;
+				cachedTokens = cacheRead;
+				outputTokens = Number(usage.output_tokens ?? 0) || 0;
+				return [chunk({ role: "assistant" })];
+			}
+			case "content_block_start": {
+				const block = isRecord$1(event.content_block) ? event.content_block : {};
+				const index = Number(event.index ?? 0);
+				if (block.type !== "tool_use") return [];
+				const toolIndex = toolIndexes.size;
+				toolIndexes.set(index, toolIndex);
+				return [chunk({ tool_calls: [{
+					function: {
+						arguments: "",
+						name: typeof block.name === "string" ? block.name : ""
+					},
+					id: typeof block.id === "string" ? block.id : void 0,
+					index: toolIndex,
+					type: "function"
+				}] })];
+			}
+			case "content_block_delta": {
+				const delta = isRecord$1(event.delta) ? event.delta : {};
+				if (delta.type === "text_delta" && typeof delta.text === "string") return [chunk({ content: delta.text })];
+				if (delta.type === "thinking_delta" && typeof delta.thinking === "string") return [chunk({ reasoning_content: delta.thinking })];
+				if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+					const toolIndex = toolIndexes.get(Number(event.index ?? 0));
+					if (toolIndex === void 0) return [];
+					return [chunk({ tool_calls: [{
+						function: { arguments: delta.partial_json },
+						index: toolIndex
+					}] })];
+				}
+				return [];
+			}
+			case "message_delta": {
+				const usage = isRecord$1(event.usage) ? event.usage : {};
+				if (typeof usage.output_tokens === "number") outputTokens = usage.output_tokens;
+				const delta = isRecord$1(event.delta) ? event.delta : {};
+				const stop = typeof delta.stop_reason === "string" ? delta.stop_reason : void 0;
+				if (stop === void 0) return [];
+				return [chunk({}, FINISH_REASONS[stop] ?? "stop")];
+			}
+			case "message_stop": return [{
+				choices: [],
+				...id === void 0 ? {} : { id },
+				...model === void 0 ? {} : { model },
+				object: "chat.completion.chunk",
+				usage: {
+					completion_tokens: outputTokens,
+					prompt_tokens: inputTokens,
+					...cachedTokens > 0 ? { prompt_tokens_details: { cached_tokens: cachedTokens } } : {},
+					total_tokens: inputTokens + outputTokens
+				}
+			}];
+			case "error": {
+				const error = isRecord$1(event.error) ? event.error : {};
+				return [{ error: {
+					message: typeof error.message === "string" ? error.message : "The model's stream ended with an error.",
+					type: typeof error.type === "string" ? error.type : "error"
+				} }];
+			}
+			default: return [];
+		}
+	};
+}
+//#endregion
 //#region src/models/core/chat-completions/stream.ts
 /**
 * Normalizes a chat-completions SSE stream from the run path into strict
@@ -1111,6 +1616,7 @@ function normalizeChatCompletionsStream(modelId, options = {}) {
 	let finalUsage;
 	let finalUsageTemplate;
 	const perDeltaUsage = isWorkersAI(modelId);
+	const translateAnthropic = createAnthropicStreamTranslator();
 	const envelope = (extra) => ({
 		...id !== void 0 ? { id } : {},
 		object: "chat.completion.chunk",
@@ -1140,6 +1646,90 @@ function normalizeChatCompletionsStream(modelId, options = {}) {
 		}
 		if (sawDone) controller.enqueue("[DONE]");
 	};
+	/** Normalizes one chat-completions chunk (or native Workers AI event). */
+	const handle = (parsed, controller) => {
+		const chunk = stripEchoSuffix(stripNoise(parsed), modelId);
+		if (typeof chunk.id === "string") id ??= chunk.id;
+		if (typeof chunk.model === "string") model ??= chunk.model;
+		if (typeof chunk.created === "number") created ??= chunk.created;
+		if (isRecord(chunk.error)) {
+			sawFinishReason = true;
+			controller.enqueue(JSON.stringify(chunk));
+			return;
+		}
+		if (Array.isArray(chunk.choices)) {
+			if (chunk.choices.length === 0) {
+				if (isRecord(chunk.usage)) {
+					finalUsage = chunk.usage;
+					finalUsageTemplate = {
+						...chunk,
+						usage: void 0
+					};
+					delete finalUsageTemplate.usage;
+				}
+				return;
+			}
+			const choices = chunk.choices.map((choice) => {
+				if (!isRecord(choice)) return choice;
+				if (typeof choice.finish_reason === "string") sawFinishReason = true;
+				const delta = isRecord(choice.delta) ? normalizeDelta(choice.delta, relabelReasoning) : choice.delta;
+				if (isRecord(delta)) {
+					if (typeof delta.content === "string" && delta.content !== "") sawContent = true;
+					if (typeof delta.reasoning_content === "string") sawContent = true;
+					if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) sawToolCalls = true;
+				}
+				if (!perDeltaUsage) return {
+					...choice,
+					delta
+				};
+				const { usage: _perDeltaUsage, ...rest } = choice;
+				return {
+					...rest,
+					delta
+				};
+			});
+			if (perDeltaUsage) {
+				const { usage: _usage, ...rest } = chunk;
+				emit(controller, {
+					...rest,
+					choices
+				});
+			} else emit(controller, {
+				...chunk,
+				choices
+			});
+			return;
+		}
+		if ("response" in chunk || "tool_calls" in chunk) {
+			const text = chunk.response;
+			const hasText = typeof text === "string" && text !== "";
+			const calls = Array.isArray(chunk.tool_calls) ? chunk.tool_calls.map((call, index) => normalizeToolCall(call, index)).filter((call) => call !== void 0) : [];
+			if (hasText || calls.length > 0) {
+				if (hasText) sawContent = true;
+				if (calls.length > 0) sawToolCalls = true;
+				emit(controller, envelope({ choices: [{
+					delta: {
+						...hasText ? { content: text } : {},
+						...calls.length > 0 ? { tool_calls: calls } : {}
+					},
+					finish_reason: null,
+					index: 0
+				}] }));
+			}
+			if (isRecord(chunk.usage)) {
+				finalUsage = chunk.usage;
+				finalUsageTemplate = void 0;
+			}
+			if (typeof chunk.finish_reason === "string") {
+				sawFinishReason = true;
+				emit(controller, envelope({ choices: [{
+					delta: {},
+					finish_reason: chunk.finish_reason,
+					index: 0
+				}] }));
+			}
+		}
+	};
 	return new TransformStream({
 		flush(controller) {
 			emitTail(controller);
@@ -1157,87 +1747,7 @@ function normalizeChatCompletionsStream(modelId, options = {}) {
 				return;
 			}
 			if (!isRecord(parsed)) return;
-			const chunk = stripEchoSuffix(stripNoise(parsed), modelId);
-			if (typeof chunk.id === "string") id ??= chunk.id;
-			if (typeof chunk.model === "string") model ??= chunk.model;
-			if (typeof chunk.created === "number") created ??= chunk.created;
-			if (isRecord(chunk.error)) {
-				sawFinishReason = true;
-				controller.enqueue(JSON.stringify(chunk));
-				return;
-			}
-			if (Array.isArray(chunk.choices)) {
-				if (chunk.choices.length === 0) {
-					if (isRecord(chunk.usage)) {
-						finalUsage = chunk.usage;
-						finalUsageTemplate = {
-							...chunk,
-							usage: void 0
-						};
-						delete finalUsageTemplate.usage;
-					}
-					return;
-				}
-				const choices = chunk.choices.map((choice) => {
-					if (!isRecord(choice)) return choice;
-					if (typeof choice.finish_reason === "string") sawFinishReason = true;
-					const delta = isRecord(choice.delta) ? normalizeDelta(choice.delta, relabelReasoning) : choice.delta;
-					if (isRecord(delta)) {
-						if (typeof delta.content === "string" && delta.content !== "") sawContent = true;
-						if (typeof delta.reasoning_content === "string") sawContent = true;
-						if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) sawToolCalls = true;
-					}
-					if (!perDeltaUsage) return {
-						...choice,
-						delta
-					};
-					const { usage: _perDeltaUsage, ...rest } = choice;
-					return {
-						...rest,
-						delta
-					};
-				});
-				if (perDeltaUsage) {
-					const { usage: _usage, ...rest } = chunk;
-					emit(controller, {
-						...rest,
-						choices
-					});
-				} else emit(controller, {
-					...chunk,
-					choices
-				});
-				return;
-			}
-			if ("response" in chunk || "tool_calls" in chunk) {
-				const text = chunk.response;
-				const hasText = typeof text === "string" && text !== "";
-				const calls = Array.isArray(chunk.tool_calls) ? chunk.tool_calls.map((call, index) => normalizeToolCall(call, index)).filter((call) => call !== void 0) : [];
-				if (hasText || calls.length > 0) {
-					if (hasText) sawContent = true;
-					if (calls.length > 0) sawToolCalls = true;
-					emit(controller, envelope({ choices: [{
-						delta: {
-							...hasText ? { content: text } : {},
-							...calls.length > 0 ? { tool_calls: calls } : {}
-						},
-						finish_reason: null,
-						index: 0
-					}] }));
-				}
-				if (isRecord(chunk.usage)) {
-					finalUsage = chunk.usage;
-					finalUsageTemplate = void 0;
-				}
-				if (typeof chunk.finish_reason === "string") {
-					sawFinishReason = true;
-					emit(controller, envelope({ choices: [{
-						delta: {},
-						finish_reason: chunk.finish_reason,
-						index: 0
-					}] }));
-				}
-			}
+			for (const event of translateAnthropic(parsed) ?? [parsed]) handle(event, controller);
 		}
 	});
 }
@@ -1380,6 +1890,6 @@ function imageMediaTypeOf(base64) {
 	return "image/png";
 }
 //#endregion
-export { isRetryableStatus as S, isGatewayErrorEnvelope as _, normalizeChatCompletion as a, classifyStatus as b, gatewaySlugForBaseUrl as c, resolveGatewayProvider as d, createTransport as f, headersToObject as g, errorFromResponse as h, normalizeChatCompletionsStream as i, isGatewayShapedUrl as l, errorFromGatewayEnvelope as m, imageMediaTypeOf as n, prepareChatCompletionsRequest as o, definedHeaders as p, sseDataStream as r, GATEWAY_PROVIDER_NAMES as s, buildImageInput as t, requireGatewayProvider as u, unwrapEnvelope as v, isAbortError as x, CloudflareAIError as y };
+export { isCatalogModelId as C, isRetryableStatus as S, isRunPathLanguageModelId as T, isGatewayErrorEnvelope as _, normalizeChatCompletion as a, classifyStatus as b, gatewaySlugForBaseUrl as c, resolveGatewayProvider as d, createTransport as f, headersToObject as g, errorFromResponse as h, normalizeChatCompletionsStream as i, isGatewayShapedUrl as l, errorFromGatewayEnvelope as m, imageMediaTypeOf as n, prepareChatCompletionsRequest as o, definedHeaders as p, sseDataStream as r, GATEWAY_PROVIDER_NAMES as s, buildImageInput as t, requireGatewayProvider as u, unwrapEnvelope as v, isDynamicRouteId as w, isAbortError as x, CloudflareAIError as y };
 
-//# sourceMappingURL=images-Ce9SCu3X.js.map
+//# sourceMappingURL=images-xaDv2Fqe.js.map