agents 0.24.0 → 0.26.0

package/dist/images-iiTDSyRu.js

@@ -0,0 +1,1631 @@
+//#region src/models/core/errors.ts
+/**
+* Error thrown for every failed Cloudflare AI call, whether it came back as a
+* non-2xx `Response` or as a thrown Workers AI binding error. Framework
+* modules wrap it into their own error type at their boundary (the AI SDK
+* module into an `APICallError`, so `ai`'s retry loop honours
+* {@link CloudflareAIError.isRetryable}).
+*
+* @experimental This surface is experimental and may change.
+*/
+var CloudflareAIError = class extends Error {
+	constructor(options) {
+		super(options.message);
+		this.name = "CloudflareAIError";
+		this.status = options.status;
+		this.code = options.code;
+		this.logId = options.logId;
+		this.model = options.model;
+		this.url = options.url;
+		this.requestBodyValues = options.requestBodyValues;
+		this.responseHeaders = options.responseHeaders;
+		this.responseBody = options.responseBody;
+		this.isRetryable = options.isRetryable ?? isRetryableStatus(options.status);
+		this.data = options.data;
+		this.cause = options.cause;
+		this.attempts = options.attempts;
+	}
+};
+/**
+* Whether a status is worth retrying. Missing status means a transport-level
+* failure (connection reset, DNS, abort-adjacent), which is retryable.
+*
+* @experimental This surface is experimental and may change.
+*/
+function isRetryableStatus(status) {
+	if (status === void 0) return true;
+	return status === 408 || status === 409 || status === 429 || status >= 500;
+}
+/**
+* Classifies an HTTP status into a {@link CloudflareAIErrorCode}. The
+* `AiGatewayError` envelope name catches gateway-level statuses that are not
+* otherwise meaningful (notably 402 "insufficient balance").
+*/
+function classifyStatus(status, envelopeName) {
+	if (status === 401 || status === 403) return "auth";
+	if (status === 429) return "rate-limit";
+	if (status === 404) return "not-found";
+	if (status === 400 || status === 422) return "bad-request";
+	if (status !== void 0 && status >= 500) return "provider-error";
+	if (envelopeName === "AiGatewayError") return "gateway-error";
+	return "unknown";
+}
+/**
+* Workers AI binding error codes that map onto an HTTP status.
+*
+* @see https://developers.cloudflare.com/workers-ai/platform/errors/
+*/
+const BINDING_CODE_STATUS = {
+	3003: 400,
+	3006: 413,
+	3007: 408,
+	3008: 408,
+	3023: 403,
+	3036: 429,
+	3039: 400,
+	3040: 429,
+	3041: 403,
+	3042: 404,
+	5004: 400,
+	5005: 405,
+	5007: 400,
+	5016: 403,
+	5018: 403,
+	5019: 405
+};
+/** Abort-shaped errors must propagate untouched so callers can detect them. */
+function isAbortError(error) {
+	const name = error instanceof Error || error instanceof DOMException ? error.name : void 0;
+	return name === "AbortError" || name === "ResponseAborted" || name === "TimeoutError";
+}
+function messageOf(error) {
+	if (typeof error === "string") return error;
+	if (error instanceof Error) return error.message;
+	if (error !== null && typeof error === "object" && "message" in error) {
+		const message = error.message;
+		if (typeof message === "string") return message;
+	}
+	return String(error);
+}
+/**
+* Extracts a Workers AI internal error code from a thrown binding error. The
+* binding reports codes inside the message text (`"3040: Capacity temporarily
+* exceeded"`) rather than as a status, so only known codes are accepted — an
+* unrelated leading number must not be misread as a code.
+*/
+function bindingErrorCode(error) {
+	if (error !== null && typeof error === "object" && "code" in error) {
+		const code = error.code;
+		if (typeof code === "number" && code in BINDING_CODE_STATUS) return code;
+	}
+	const matches = messageOf(error).matchAll(/\b(\d{3,5})\s*:/g);
+	for (const match of matches) {
+		const code = Number(match[1]);
+		if (code in BINDING_CODE_STATUS) return code;
+	}
+}
+/**
+* Normalizes a thrown Workers AI binding error into a {@link CloudflareAIError}.
+* Abort errors and errors that are already {@link CloudflareAIError}s pass through.
+*/
+function normalizeThrownError(error, context) {
+	if (isAbortError(error)) return error;
+	if (error instanceof CloudflareAIError) return error;
+	const code = bindingErrorCode(error);
+	const status = code === void 0 ? void 0 : BINDING_CODE_STATUS[code];
+	return new CloudflareAIError({
+		cause: error,
+		code: classifyStatus(status),
+		data: code === void 0 ? void 0 : { code },
+		isRetryable: status === void 0 ? false : isRetryableStatus(status),
+		message: messageOf(error),
+		model: context.model,
+		requestBodyValues: context.requestBodyValues,
+		status,
+		url: context.url
+	});
+}
+/** Key that per-call options live under in a framework's per-call options bag. */
+const PROVIDER_OPTIONS_KEY = "cloudflare";
+/** The id legs of a fallback list; model objects are their module's business. */
+function idLegs(fallback) {
+	return (fallback ?? []).filter((leg) => typeof leg === "string");
+}
+/** Strips `undefined` values so a later layer never blanks an earlier one. */
+function defined(value) {
+	const result = {};
+	for (const [key, entry] of Object.entries(value)) if (entry !== void 0) result[key] = entry;
+	return result;
+}
+function normalizeGateway(gateway) {
+	if (gateway === void 0) return {};
+	return typeof gateway === "string" ? { id: gateway } : defined(gateway);
+}
+/**
+* Folds one layer's flat gateway sugar into its `gateway` object. The flat key
+* wins over the nested one, and an explicit `undefined` on either never blanks
+* a lower layer.
+*/
+function layerGateway(options) {
+	if (options === void 0) return {};
+	return {
+		...normalizeGateway(options.gateway),
+		...defined({
+			cacheKey: options.cacheKey,
+			cacheTtl: options.cacheTtl,
+			collectLog: options.collectLog,
+			eventId: options.eventId,
+			id: options.id,
+			metadata: options.metadata,
+			requestTimeoutMs: options.requestTimeoutMs,
+			retries: options.retries,
+			skipCache: options.skipCache
+		})
+	};
+}
+/** The flat gateway sugar {@link layerGateway} folds into `gateway`. */
+const FLAT_GATEWAY_KEYS = [
+	"cacheKey",
+	"cacheTtl",
+	"collectLog",
+	"eventId",
+	"gateway",
+	"id",
+	"metadata",
+	"requestTimeoutMs",
+	"retries",
+	"skipCache"
+];
+/**
+* One layer's gateway options as a single object, both spellings folded in.
+* Exported so a module that collapses two option layers into one bag (a
+* fallback leg inheriting a chain's gateway) can merge them field by field
+* rather than replacing one object with the other.
+*
+* @experimental This surface is experimental and may change.
+*/
+function gatewayLayerOf(options) {
+	return layerGateway(options);
+}
+/** An option bag without the gateway keys, whichever spelling they used. */
+function withoutGatewayKeys(options) {
+	const rest = { ...options };
+	for (const key of FLAT_GATEWAY_KEYS) delete rest[key];
+	return defined(rest);
+}
+/**
+* Collapses two option layers into one bag, `override` winning field by field.
+*
+* The gateway keys of both are folded into a single `gateway` object, so
+* neither layer's flat sugar can out-rank the other's nested spelling when the
+* bag is resolved later, and `metadata` merges rather than replaces — the same
+* rules {@link resolveOptions} applies across its three layers.
+*
+* @experimental This surface is experimental and may change.
+*/
+function mergeModelOptions(base, override) {
+	if (base === void 0) return override;
+	if (override === void 0) return base;
+	const layers = [layerGateway(base), layerGateway(override)];
+	const gateway = Object.assign({}, ...layers);
+	const metadata = Object.assign({}, ...layers.map((layer) => layer.metadata));
+	const retries = mergeRetries(layers);
+	const headers = {
+		...base.headers,
+		...override.headers
+	};
+	return {
+		...withoutGatewayKeys(base),
+		...withoutGatewayKeys(override),
+		...Object.keys(headers).length > 0 ? { headers } : {},
+		gateway: {
+			...gateway,
+			...Object.keys(metadata).length > 0 ? { metadata } : {},
+			...retries === void 0 ? {} : { retries }
+		}
+	};
+}
+/**
+* Merges the retry policies field by field, so a provider-wide `backoff` still
+* applies when a call only sets `maxAttempts`. `undefined` on any layer means
+* "not set" and never blanks a lower one.
+*/
+function mergeRetries(layers) {
+	const merged = layers.reduce((result, layer) => ({
+		...result,
+		...layer.retries === void 0 ? {} : defined(layer.retries)
+	}), {});
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+/**
+* Merges the option layers. Precedence is per-call
+* (`providerOptions.cloudflare`) > per-model (`ai(id, options)`) >
+* provider (`createAI({ ... })`).
+*
+* The provider layer takes the whole settings object as well as a bare
+* `gateway` value, so `createAI({ binding, id: "prod", cacheTtl: 60 })` reads
+* the same as `createAI({ binding, gateway: { id: "prod", cacheTtl: 60 } })`.
+*
+* @experimental This surface is experimental and may change.
+*/
+function resolveOptions(provider, model, call) {
+	const layers = typeof provider === "string" ? [
+		normalizeGateway(provider),
+		layerGateway(model),
+		layerGateway(call)
+	] : [
+		layerGateway(provider),
+		layerGateway(model),
+		layerGateway(call)
+	];
+	const gateway = Object.assign({}, ...layers);
+	const metadata = Object.assign({}, ...layers.map((layer) => layer.metadata));
+	const retries = mergeRetries(layers);
+	return {
+		chatTemplateKwargs: call?.chatTemplateKwargs ?? model?.chatTemplateKwargs,
+		fallback: idLegs(call?.fallback ?? model?.fallback),
+		gateway: {
+			...gateway,
+			id: gateway.id ?? "default",
+			...Object.keys(metadata).length > 0 ? { metadata } : {},
+			...retries === void 0 ? {} : { retries }
+		},
+		headers: {
+			...model?.headers,
+			...call?.headers
+		},
+		reasoningEffort: call?.reasoningEffort !== void 0 ? call.reasoningEffort : model?.reasoningEffort,
+		sessionAffinity: call?.sessionAffinity ?? model?.sessionAffinity
+	};
+}
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function asStringRecord(value) {
+	const record = asRecord(value);
+	if (record === void 0) return void 0;
+	const result = {};
+	for (const [key, entry] of Object.entries(record)) if (typeof entry === "string") result[key] = entry;
+	return result;
+}
+function asString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+	return typeof value === "number" ? value : void 0;
+}
+function asBoolean(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function asReasoningEffort(value) {
+	if (value === null) return null;
+	if (value === "low" || value === "medium" || value === "high") return value;
+}
+/**
+* Metadata values the gateway accepts are scalars only; a nested object or
+* array would be rejected by the binding, so drop those rather than forward
+* them.
+*/
+function asMetadata(value) {
+	const record = asRecord(value);
+	if (record === void 0) return void 0;
+	const result = {};
+	for (const [key, entry] of Object.entries(record)) if (entry === null || typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean") result[key] = entry;
+	return result;
+}
+const BACKOFFS = [
+	"constant",
+	"linear",
+	"exponential"
+];
+/** Reads the retry policy field by field; the binding validates it strictly. */
+function asRetries(value) {
+	const record = asRecord(value);
+	if (record === void 0) return void 0;
+	const maxAttempts = asNumber(record.maxAttempts);
+	const backoff = asString(record.backoff);
+	const retries = defined({
+		backoff: BACKOFFS.find((entry) => entry === backoff),
+		maxAttempts: maxAttempts !== void 0 && Number.isInteger(maxAttempts) && maxAttempts >= 1 && maxAttempts <= 5 ? maxAttempts : void 0,
+		retryDelayMs: asNumber(record.retryDelayMs)
+	});
+	return Object.keys(retries).length > 0 ? retries : void 0;
+}
+/** Reads the shared gateway keys out of a loosely-typed record. */
+function parseGatewayFields(raw) {
+	return defined({
+		cacheKey: asString(raw.cacheKey),
+		cacheTtl: asNumber(raw.cacheTtl),
+		collectLog: asBoolean(raw.collectLog),
+		eventId: asString(raw.eventId),
+		id: asString(raw.id),
+		metadata: asMetadata(raw.metadata),
+		requestTimeoutMs: asNumber(raw.requestTimeoutMs),
+		retries: asRetries(raw.retries),
+		skipCache: asBoolean(raw.skipCache)
+	});
+}
+/**
+* Reads per-call options out of a loosely-typed options bag (the value a
+* framework keeps under {@link PROVIDER_OPTIONS_KEY}).
+*
+* The bag is plain JSON, so every field is read defensively: anything of an
+* unexpected type is dropped rather than thrown, because a malformed
+* observability hint should never fail a generation.
+*
+* @experimental This surface is experimental and may change.
+*/
+function parseModelOptions(value) {
+	const raw = asRecord(value);
+	if (raw === void 0) return void 0;
+	const nested = asRecord(raw.gateway);
+	const gateway = typeof raw.gateway === "string" ? raw.gateway : nested !== void 0 ? parseGatewayFields(nested) : void 0;
+	const fallback = Array.isArray(raw.fallback) ? raw.fallback.filter((entry) => typeof entry === "string") : void 0;
+	return defined({
+		...parseGatewayFields(raw),
+		chatTemplateKwargs: asRecord(raw.chatTemplateKwargs),
+		fallback,
+		gateway,
+		headers: asStringRecord(raw.headers),
+		reasoningEffort: asReasoningEffort(raw.reasoningEffort),
+		sessionAffinity: asString(raw.sessionAffinity)
+	});
+}
+//#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";
+/**
+* Drops entries whose value is `undefined`. The AI SDK types call headers as
+* `Record<string, string | undefined>`, and an undefined value reaches the
+* binding as the string "undefined" rather than as an absent header.
+*/
+function definedHeaders(headers) {
+	const result = {};
+	for (const [key, value] of Object.entries(headers ?? {})) if (value !== void 0) result[key] = value;
+	return result;
+}
+/** Copies response headers into a plain object. */
+function headersToObject(headers) {
+	const result = {};
+	headers.forEach((value, key) => {
+		result[key] = value;
+	});
+	return result;
+}
+/**
+* Some run-path responses arrive bare and some wrapped in the Cloudflare API
+* envelope. Unwrap only when the envelope keys are actually present, so a
+* provider payload that happens to have a `result` field is left alone.
+*/
+function unwrapEnvelope(value, context) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+	const record = value;
+	if (record.success === false && firstEnvelopeError(record) !== void 0 || "success" in record && "result" in record) {
+		if (record.success === true) return record.result;
+		throw new CloudflareAIError({
+			code: classifyStatus(context?.status, typeof record.name === "string" ? record.name : void 0),
+			data: value,
+			message: errorMessageFrom(value, context?.status),
+			model: context?.model ?? "",
+			requestBodyValues: void 0,
+			status: context?.status,
+			url: context?.url ?? ""
+		});
+	}
+	return value;
+}
+function firstEnvelopeError(record) {
+	for (const key of ["error", "errors"]) {
+		const value = record[key];
+		if (Array.isArray(value) && value.length > 0) {
+			const first = value[0];
+			if (first !== null && typeof first === "object") return first;
+		}
+		if (value !== null && typeof value === "object" && !Array.isArray(value)) return value;
+	}
+}
+/**
+* Pulls a human message out of any of the error envelopes the platform emits:
+* the gateway envelope (`error: [{ code, message }]`), the Workers AI
+* validation envelope (`message`/`description` only), a bare
+* `{ error: "..." }`, and the "Model ID missing" internal error, which carries
+* only `description`.
+*/
+function errorMessageFrom(body, status) {
+	const record = body !== null && typeof body === "object" && !Array.isArray(body) ? body : void 0;
+	if (record !== void 0) {
+		const envelope = firstEnvelopeError(record);
+		if (typeof envelope?.message === "string") return envelope.message;
+		if (typeof record.error === "string") return record.error;
+		if (typeof record.message === "string") return record.message;
+		if (typeof record.description === "string") return record.description;
+	}
+	if (typeof body === "string" && body !== "") return body;
+	return `HTTP ${status ?? "error"}`;
+}
+/** Builds a {@link CloudflareAIError} from a non-2xx run-path response. */
+async function errorFromResponse(response, context) {
+	const text = await response.text().catch(() => "");
+	let body = text;
+	try {
+		body = text === "" ? void 0 : JSON.parse(text);
+	} catch {}
+	const record = body !== null && typeof body === "object" && !Array.isArray(body) ? body : void 0;
+	const envelopeName = typeof record?.name === "string" ? record.name : void 0;
+	const headers = headersToObject(response.headers);
+	return new CloudflareAIError({
+		code: classifyStatus(response.status, envelopeName),
+		data: body,
+		logId: headers["cf-aig-log-id"],
+		message: errorMessageFrom(body, response.status),
+		model: context.model,
+		requestBodyValues: context.requestBodyValues,
+		responseBody: text,
+		responseHeaders: headers,
+		status: response.status,
+		url: context.url
+	});
+}
+/**
+* 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.
+*/
+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;
+}
+/**
+* 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
+* gateway, unified billing unpaid, provider not configured); everything else
+* on this path is the vendor's own error, which the vendor's provider reads.
+*
+* @experimental This surface is experimental and may change.
+*/
+function isGatewayErrorEnvelope(json) {
+	if (json === null || typeof json !== "object" || Array.isArray(json)) return false;
+	const record = json;
+	if (record.name === "AiGatewayError") return true;
+	if (record.success !== false) return false;
+	const errors = record.error ?? record.errors;
+	return Array.isArray(errors) && errors.some((entry) => entry !== null && typeof entry === "object" && typeof entry.message === "string");
+}
+/**
+* Builds a {@link CloudflareAIError} from the gateway's own error envelope, so
+* a gateway failure on the universal path classifies and retries exactly as
+* one on the Workers AI run path.
+*
+* @experimental This surface is experimental and may change.
+*/
+function errorFromGatewayEnvelope(body, context) {
+	const record = body !== null && typeof body === "object" && !Array.isArray(body) ? body : void 0;
+	return new CloudflareAIError({
+		code: classifyStatus(context.status, typeof record?.name === "string" ? record.name : "AiGatewayError"),
+		data: body,
+		logId: context.responseHeaders?.["cf-aig-log-id"],
+		message: errorMessageFrom(body, context.status),
+		model: context.model,
+		requestBodyValues: context.requestBodyValues,
+		responseBody: context.responseBody,
+		responseHeaders: context.responseHeaders,
+		status: context.status,
+		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;
+	const logIds = /* @__PURE__ */ new WeakMap();
+	return {
+		logIdFallback(response) {
+			return logIds.get(response);
+		},
+		async run(request) {
+			try {
+				const response = await raw.run(request.model, request.input, {
+					...Object.keys(request.headers).length > 0 ? { extraHeaders: request.headers } : {},
+					gateway: request.gateway,
+					returnRawResponse: true,
+					signal: request.signal
+				});
+				const logId = binding.aiGatewayLogId;
+				if (logId !== null && logId !== void 0) logIds.set(response, logId);
+				return response;
+			} catch (error) {
+				throw normalizeThrownError(error, {
+					model: request.model,
+					requestBodyValues: request.input,
+					url: "workers-ai-binding"
+				});
+			}
+		},
+		async universal(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),
+					signal: request.signal
+				});
+			} catch (error) {
+				throw normalizeThrownError(error, {
+					model: universalModel(request),
+					requestBodyValues: request.query,
+					url: UNIVERSAL_BINDING_URL
+				});
+			}
+		},
+		url: "workers-ai-binding"
+	};
+}
+/**
+* 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.
+*
+* @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);
+}
+//#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
+* given upstream URL.
+*
+* This is platform knowledge, not vendor knowledge — the gateway publishes the
+* list, and every entry here appears in `AIGatewayProviders` from
+* `@cloudflare/workers-types`. Nothing about a vendor's wire format, model ids
+* or capabilities lives here: the vendor's own provider package builds the
+* request, and this table only says where it goes.
+*
+* Adapted from `@cloudflare/ai-gateway-provider`'s `providers.ts`.
+*
+* @experimental This surface is experimental and may change.
+*/
+/**
+* The gateway provider slugs this table maps onto. A subset of the ambient
+* `AIGatewayProviders` union; {@link GatewayProviderNameCheck} keeps it one.
+*
+* @experimental This surface is experimental and may change.
+*/
+const GATEWAY_PROVIDER_NAMES = [
+	"workers-ai",
+	"anthropic",
+	"openai",
+	"azure-openai",
+	"google-ai-studio",
+	"google-vertex-ai",
+	"grok",
+	"mistral",
+	"perplexity-ai",
+	"replicate",
+	"groq",
+	"deepseek",
+	"openrouter",
+	"cerebras",
+	"cohere",
+	"huggingface",
+	"aws-bedrock",
+	"elevenlabs",
+	"cartesia"
+];
+/** The default credential header; providers add their own on top. */
+const AUTHORIZATION = ["authorization"];
+/** Path after the host, leading slash removed, query string kept. */
+function pathOf(url) {
+	return `${url.pathname.replace(/^\/+/, "")}${url.search}`;
+}
+function buildProvider(spec) {
+	const map = spec.endpoint ?? ((url) => {
+		const path = pathOf(url);
+		return spec.pathPrefix === void 0 ? path : path.replace(spec.pathPrefix, "");
+	});
+	return {
+		authHeaders: spec.authHeaders ?? AUTHORIZATION,
+		endpoint(url) {
+			const parsed = parseUrl(url);
+			if (parsed === void 0 || !spec.host.test(parsed.host)) return;
+			return map(parsed);
+		},
+		host: spec.host,
+		name: spec.name
+	};
+}
+function parseUrl(url) {
+	try {
+		return new URL(url);
+	} catch {
+		return;
+	}
+}
+/**
+* Azure names the deployment in the path; the gateway names it in the
+* endpoint as `<resource>/<deployment>/<rest>`.
+*/
+function azureEndpoint(url) {
+	const resource = /^([^.]+)\.openai\.azure\.com$/.exec(url.host)?.[1];
+	const rest = /^\/openai\/deployments\/([^/]+)\/(.+)$/.exec(url.pathname);
+	if (resource === void 0 || rest === null) return void 0;
+	return `${resource}/${rest[1]}/${rest[2]}${url.search}`;
+}
+/**
+* Bedrock's region and service live in the host; the gateway wants them as the
+* first two endpoint segments.
+*/
+function bedrockEndpoint(url) {
+	const match = /^(bedrock[a-z0-9-]*)\.([a-z0-9-]+)\.amazonaws\.com$/.exec(url.host);
+	if (match === null) return void 0;
+	return `${match[1]}/${match[2]}/${pathOf(url)}`;
+}
+/**
+* The provider table, in declaration order. Hosts do not overlap, so the order
+* only decides which row a future overlapping host would win.
+*
+* @experimental This surface is experimental and may change.
+*/
+const GATEWAY_PROVIDERS = [
+	{
+		host: /^api\.cloudflare\.com$/,
+		name: "workers-ai",
+		pathPrefix: /^client\/v4\/accounts\/[^/]+\/ai\//
+	},
+	{
+		authHeaders: ["authorization", "x-api-key"],
+		host: /^api\.anthropic\.com$/,
+		name: "anthropic"
+	},
+	{
+		host: /^api\.openai\.com$/,
+		name: "openai"
+	},
+	{
+		authHeaders: ["authorization", "api-key"],
+		endpoint: azureEndpoint,
+		host: /^[^.]+\.openai\.azure\.com$/,
+		name: "azure-openai"
+	},
+	{
+		authHeaders: ["authorization", "x-goog-api-key"],
+		host: /^generativelanguage\.googleapis\.com$/,
+		name: "google-ai-studio"
+	},
+	{
+		host: /^(?:[a-z0-9-]+-)?aiplatform\.googleapis\.com$/,
+		name: "google-vertex-ai"
+	},
+	{
+		host: /^api\.x\.ai$/,
+		name: "grok"
+	},
+	{
+		host: /^api\.mistral\.ai$/,
+		name: "mistral"
+	},
+	{
+		host: /^api\.perplexity\.ai$/,
+		name: "perplexity-ai"
+	},
+	{
+		host: /^api\.replicate\.com$/,
+		name: "replicate"
+	},
+	{
+		host: /^api\.groq\.com$/,
+		name: "groq",
+		pathPrefix: /^openai\/v1\//
+	},
+	{
+		host: /^api\.deepseek\.com$/,
+		name: "deepseek"
+	},
+	{
+		host: /^openrouter\.ai$/,
+		name: "openrouter",
+		pathPrefix: /^api\//
+	},
+	{
+		host: /^api\.cerebras\.ai$/,
+		name: "cerebras"
+	},
+	{
+		host: /^api\.cohere\.(?:ai|com)$/,
+		name: "cohere"
+	},
+	{
+		host: /^(?:api-inference|router)\.huggingface\.co$/,
+		name: "huggingface",
+		pathPrefix: /^models\//
+	},
+	{
+		endpoint: bedrockEndpoint,
+		host: /^bedrock.*\.amazonaws\.com$/,
+		name: "aws-bedrock"
+	},
+	{
+		host: /^api\.elevenlabs\.io$/,
+		name: "elevenlabs"
+	},
+	{
+		host: /^api\.cartesia\.ai$/,
+		name: "cartesia"
+	}
+].map(buildProvider);
+/**
+* The table row for a bare host (`api.anthropic.com`) or for anything a `URL`
+* can be built from. pi-ai models carry a `baseUrl` rather than a full request
+* URL, so both spellings resolve.
+*
+* @experimental This surface is experimental and may change.
+*/
+function gatewayProviderForHost(hostOrUrl) {
+	const host = parseUrl(hostOrUrl)?.host ?? hostOf(hostOrUrl);
+	if (host === void 0) return void 0;
+	return GATEWAY_PROVIDERS.find((provider) => provider.host.test(host));
+}
+/** Reads a host out of a bare host, `host/path` or `//host` spelling. */
+function hostOf(value) {
+	const host = value.replace(/^\/\//, "").split("/")[0];
+	return host === "" ? void 0 : host;
+}
+/**
+* Maps a vendor request URL onto `{ provider, endpoint, authHeaders }` for the
+* universal gateway request, or `undefined` when the host is not a gateway
+* provider.
+*
+* @experimental This surface is experimental and may change.
+*/
+function resolveGatewayProvider(url) {
+	const parsed = parseUrl(url);
+	if (parsed === void 0) return void 0;
+	for (const provider of GATEWAY_PROVIDERS) {
+		if (!provider.host.test(parsed.host)) continue;
+		const endpoint = provider.endpoint(url);
+		if (endpoint === void 0) continue;
+		return {
+			authHeaders: provider.authHeaders,
+			endpoint,
+			provider: provider.name
+		};
+	}
+}
+/**
+* {@link resolveGatewayProvider}, throwing a `TypeError` that names the host
+* and the provider list when the URL belongs to no gateway provider.
+*
+* @experimental This surface is experimental and may change.
+*/
+function requireGatewayProvider(url) {
+	const resolved = resolveGatewayProvider(url);
+	if (resolved !== void 0) return resolved;
+	const host = parseUrl(url)?.host ?? url;
+	throw new TypeError(`AI Gateway has no provider for ${host}. Requests are routed by host; the supported providers are ${GATEWAY_PROVIDER_NAMES.join(", ")}.`);
+}
+/** The host a gateway-shaped base URL points at. */
+const GATEWAY_HOST = "gateway.ai.cloudflare.com";
+/**
+* The provider slug of a gateway-shaped base URL —
+* `https://gateway.ai.cloudflare.com/v1/{account}/{gateway}/{slug}`. Generated
+* registries write models that way (pi-ai's Cloudflare AI Gateway catalog
+* leaves the account and gateway as literal placeholders), so the slug is
+* already in the path rather than implied by a vendor host. The account and
+* gateway segments are ignored: the binding has already chosen both.
+*/
+function gatewayShapedSlug(url) {
+	if (url.host !== GATEWAY_HOST) return void 0;
+	const segments = url.pathname.split("/").filter((part) => part !== "");
+	if (segments[0] !== "v1" || segments.length < 4) return void 0;
+	return segments[3];
+}
+/**
+* Whether a base URL is written in the gateway's own shape
+* (`https://gateway.ai.cloudflare.com/v1/{account}/{gateway}/{slug}`) rather
+* than as a vendor's. A generated Cloudflare registry writes models that way,
+* and the path after the slug is then the vendor's own, so a caller that
+* derives an endpoint from a base URL has to tell the two apart.
+*
+* @experimental This surface is experimental and may change.
+*/
+function isGatewayShapedUrl(url) {
+	return parseUrl(url)?.host === GATEWAY_HOST;
+}
+function isGatewayProviderName(slug) {
+	return GATEWAY_PROVIDER_NAMES.includes(slug);
+}
+/**
+* The gateway provider slug a model's base URL belongs to. Two spellings
+* resolve, because two kinds of registry write them:
+*
+* - a vendor's own base URL (`https://api.anthropic.com` → `anthropic`), which
+*   is what a provider package configured for the vendor carries;
+* - a gateway-shaped base URL
+*   (`https://gateway.ai.cloudflare.com/v1/{account}/{gateway}/anthropic` →
+*   `anthropic`), which is what a generated Cloudflare registry carries.
+*
+* A base URL neither shape resolves is a wiring mistake rather than a request
+* failure, so it throws a `TypeError` naming what was not recognised.
+*
+* @experimental This surface is experimental and may change.
+*/
+function gatewaySlugForBaseUrl(baseUrl) {
+	const url = parseUrl(baseUrl);
+	const shaped = url === void 0 ? void 0 : gatewayShapedSlug(url);
+	if (shaped !== void 0) {
+		if (isGatewayProviderName(shaped)) return shaped;
+		throw new TypeError(`AI Gateway has no provider "${shaped}" (from ${baseUrl}). The supported providers are ${GATEWAY_PROVIDER_NAMES.join(", ")}.`);
+	}
+	const provider = gatewayProviderForHost(baseUrl);
+	if (provider !== void 0) return provider.name;
+	throw new TypeError(`AI Gateway has no provider for ${url?.host ?? baseUrl}. Requests are routed by the model's base URL; the supported providers are ${GATEWAY_PROVIDER_NAMES.join(", ")}.`);
+}
+//#endregion
+//#region src/models/core/chat-completions/quirks.ts
+const STRICT_OPENAI = {
+	chatTemplateKwargs: "unsupported",
+	imageUrls: "any",
+	jsonSchema: "supported",
+	jsonSchemaStrict: false,
+	maxTokensField: "max_tokens",
+	modelEchoSuffix: void 0,
+	nullAssistantContent: "allowed",
+	reasoningEffortLevels: "basic",
+	reasoningOff: "unsupported",
+	reasoningOffStreamLabel: "content",
+	reasoningReplay: "drop",
+	requiresAssistantAfterToolResult: false,
+	toolCallIds: "any",
+	toolChoiceRequired: "supported"
+};
+/** Workers AI's vLLM front end: what every `@cf/` model has in common. */
+const WORKERS_AI = {
+	...STRICT_OPENAI,
+	chatTemplateKwargs: "supported",
+	imageUrls: "data-only",
+	nullAssistantContent: "empty-string",
+	reasoningOff: "chat-template",
+	reasoningReplay: "reasoning_content"
+};
+/**
+* Longest-prefix overrides. Keep each one evidence-backed (the capture that
+* proves it is named in the comment) and delete it when the platform fixes
+* the deviation.
+*/
+const OVERRIDES = [
+	["@cf/zai-org/glm-4.7-flash", { toolChoiceRequired: "named-fallback" }],
+	["@cf/moonshotai/", { reasoningOff: "unsupported" }],
+	["@cf/openai/", { reasoningOff: "unsupported" }],
+	["@cf/mistralai/", {
+		chatTemplateKwargs: "unsupported",
+		jsonSchema: "unsupported",
+		reasoningOff: "unsupported",
+		requiresAssistantAfterToolResult: true,
+		toolCallIds: "alnum-9"
+	}],
+	["@cf/google/", { modelEchoSuffix: "-external" }],
+	["@cf/nvidia/nemotron-", { reasoningOffStreamLabel: "reasoning" }]
+];
+/** The quirks for a catalog id: base profile plus the longest matching override. */
+function quirksFor(modelId) {
+	const base = modelId.startsWith("@cf/") ? WORKERS_AI : STRICT_OPENAI;
+	let best;
+	for (const entry of OVERRIDES) if (modelId.startsWith(entry[0]) && (best === void 0 || entry[0].length > best[0].length)) best = entry;
+	return best === void 0 ? base : {
+		...base,
+		...best[1]
+	};
+}
+/** Whether an id is a Workers AI model rather than a third-party catalog model. */
+function isWorkersAI(modelId) {
+	return modelId.startsWith("@cf/");
+}
+//#endregion
+//#region src/models/core/chat-completions/request.ts
+/**
+* Rewrites a strict OpenAI chat-completions request body into what a given
+* catalog model accepts. Frameworks build the strict body from their own
+* prompt types; everything Cloudflare- or vendor-specific happens here, once.
+*
+* The rewrite never throws: a feature the model cannot take is dropped and
+* reported as a {@link CompatWarning}.
+*/
+function isRecord$2(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function clampEffort(effort) {
+	if (effort === "minimal") return "low";
+	if (effort === "xhigh") return "high";
+	return effort;
+}
+/** Drops URL image parts (keeps inline data URLs) from a user message. */
+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 ((typeof image?.url === "string" ? image.url : "").startsWith("data:")) return true;
+		dropped += 1;
+		return false;
+	});
+	if (dropped > 0) warnings.push({
+		feature: "image-url",
+		message: `Workers AI models need image bytes; ${dropped} image URL${dropped === 1 ? " was" : "s were"} dropped.`
+	});
+	return {
+		...message,
+		content
+	};
+}
+/** Nine `[A-Za-z0-9]` characters: what Mistral accepts as a tool-call id. */
+const CONFORMANT_TOOL_CALL_ID = /^[0-9A-Za-z]{9}$/;
+const TOOL_CALL_ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+/**
+* A deterministic nine-character id for an original id: the same conversation
+* replayed twice produces the same ids, so a provider cache or a log stays
+* comparable. `salt` is bumped only to break a collision.
+*/
+function hashedToolCallId(original, salt) {
+	let state = (2166136261 ^ salt) >>> 0;
+	for (let index = 0; index < original.length; index += 1) state = Math.imul(state ^ original.charCodeAt(index), 16777619) >>> 0;
+	let id = "";
+	for (let index = 0; index < 9; index += 1) {
+		state = Math.imul(state ^ state >>> 15, 16777619) >>> 0;
+		id += TOOL_CALL_ID_ALPHABET[state % 62];
+	}
+	return id;
+}
+/** Every tool-call id a message set mentions, in the order it mentions them. */
+function toolCallIdsIn(messages) {
+	const ids = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (value) => {
+		if (typeof value !== "string" || seen.has(value)) return;
+		seen.add(value);
+		ids.push(value);
+	};
+	for (const message of messages) {
+		if (!isRecord$2(message)) continue;
+		if (Array.isArray(message.tool_calls)) {
+			for (const call of message.tool_calls) if (isRecord$2(call)) add(call.id);
+		}
+		add(message.tool_call_id);
+	}
+	return ids;
+}
+/**
+* Plans the rewrite: which ids have to change, and to what. Ids that already
+* conform are kept exactly as they are — including as reserved values, so a
+* rewritten id can never collide with one.
+*/
+function planToolCallIds(messages) {
+	const plan = /* @__PURE__ */ new Map();
+	const ids = toolCallIdsIn(messages);
+	const taken = new Set(ids.filter((id) => CONFORMANT_TOOL_CALL_ID.test(id)));
+	for (const id of ids) {
+		if (taken.has(id)) continue;
+		let replacement = hashedToolCallId(id, 0);
+		for (let salt = 1; taken.has(replacement) && salt <= 64; salt += 1) replacement = hashedToolCallId(id, salt);
+		taken.add(replacement);
+		plan.set(id, replacement);
+	}
+	return plan;
+}
+/** Applies the plan to an assistant `tool_calls` turn or a `tool` result. */
+function rewriteToolCallIds(message, plan) {
+	let rewritten = message;
+	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;
+			const replacement = plan.get(call.id);
+			return replacement === void 0 ? call : {
+				...call,
+				id: replacement
+			};
+		})
+	};
+	if (typeof rewritten.tool_call_id === "string") {
+		const replacement = plan.get(rewritten.tool_call_id);
+		if (replacement !== void 0) rewritten = {
+			...rewritten,
+			tool_call_id: replacement
+		};
+	}
+	return rewritten;
+}
+/**
+* Applies the model's quirks to a strict OpenAI chat-completions body.
+*
+* Conventions the strict body follows, which this function translates:
+* - `max_tokens` is the cap; it becomes `max_completion_tokens` where needed.
+* - `reasoning_effort: null` means "turn reasoning off".
+* - Replayed assistant reasoning sits in `reasoning_content`.
+* - `response_format.json_schema` is the OpenAI `{ name, schema }` envelope.
+* - `chat_template_kwargs` may be present; it is only meaningful on Workers AI.
+*/
+function prepareChatCompletionsRequest(input, modelId) {
+	const quirks = quirksFor(modelId);
+	const warnings = [];
+	const body = { ...input };
+	if (quirks.maxTokensField === "max_completion_tokens" && "max_tokens" in body) {
+		body.max_completion_tokens = body.max_tokens;
+		delete body.max_tokens;
+	}
+	if ("reasoning_effort" in body) {
+		const effort = body.reasoning_effort;
+		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 : {},
+				enable_thinking: false
+			};
+			else warnings.push({
+				feature: "reasoning-off",
+				message: `Reasoning cannot be turned off on ${modelId}; the request was sent with the model's default effort.`
+			});
+		} else if (typeof effort === "string" && quirks.reasoningEffortLevels === "basic") body.reasoning_effort = clampEffort(effort);
+	}
+	if ("chat_template_kwargs" in body && quirks.chatTemplateKwargs === "unsupported") {
+		delete body.chat_template_kwargs;
+		warnings.push({
+			feature: "chat-template-kwargs",
+			message: `${modelId} does not take chat_template_kwargs; they were dropped.`
+		});
+	}
+	if (isRecord$2(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)) {
+			const { strict: _strict, ...envelope } = body.response_format.json_schema;
+			body.response_format = {
+				...body.response_format,
+				json_schema: quirks.jsonSchemaStrict ? {
+					...envelope,
+					strict: true
+				} : envelope
+			};
+		}
+	}
+	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;
+		if (name !== void 0) body.tool_choice = {
+			function: { name },
+			type: "function"
+		};
+		else {
+			delete body.tool_choice;
+			warnings.push({
+				feature: "tool-choice-required",
+				message: `${modelId} rejects tool_choice "required"; the model was left free to choose.`
+			});
+		}
+	}
+	if (Array.isArray(body.messages)) {
+		const toolCallIds = quirks.toolCallIds === "alnum-9" ? planToolCallIds(body.messages) : /* @__PURE__ */ new Map();
+		if (toolCallIds.size > 0) warnings.push({
+			feature: "tool-call-id",
+			message: `${modelId} needs 9-character alphanumeric tool-call ids; ${toolCallIds.size} id${toolCallIds.size === 1 ? " was" : "s were"} rewritten.`
+		});
+		const messages = [];
+		let previousRole;
+		for (const entry of body.messages) {
+			if (!isRecord$2(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);
+			if (message.role === "assistant" && message.content === null && quirks.nullAssistantContent === "empty-string") message = {
+				...message,
+				content: ""
+			};
+			if (message.role === "assistant" && "reasoning_content" in message) {
+				if (quirks.reasoningReplay === "drop") {
+					const { reasoning_content: _reasoning, ...rest } = message;
+					message = rest;
+					warnings.push({
+						feature: "assistant-reasoning",
+						message: `${modelId} has no field for replayed reasoning; the assistant reasoning was dropped.`
+					});
+				}
+			}
+			if (quirks.requiresAssistantAfterToolResult && previousRole === "tool" && message.role === "user") messages.push({
+				content: "",
+				role: "assistant"
+			});
+			messages.push(message);
+			previousRole = message.role;
+		}
+		body.messages = messages;
+	}
+	return {
+		body,
+		reasoningOff: isRecord$2(body.chat_template_kwargs) && body.chat_template_kwargs.enable_thinking === false,
+		warnings
+	};
+}
+//#endregion
+//#region src/models/core/chat-completions/response.ts
+/**
+* Normalizes a chat-completions response body from the run path into the
+* strict OpenAI `chat.completion` shape, so framework parsers never see
+* Workers AI's native envelope or its field spellings.
+*/
+function isRecord$1(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;
+	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;
+	const args = typeof rawArguments === "string" ? rawArguments : rawArguments === void 0 || rawArguments === null ? "{}" : JSON.stringify(rawArguments);
+	return {
+		...typeof entry.index === "number" ? { index: entry.index } : { index },
+		...typeof entry.id === "string" ? { id: entry.id } : {},
+		function: {
+			arguments: args,
+			name
+		},
+		type: "function",
+		...entry.extra_content !== void 0 ? { extra_content: entry.extra_content } : {}
+	};
+}
+/** Text as the model produced it; structured-output models may return an object. */
+function contentText(value) {
+	if (typeof value === "string") return value;
+	if (value === null || value === void 0) return null;
+	return JSON.stringify(value);
+}
+function stripEchoSuffix$1(model, modelId) {
+	const suffix = quirksFor(modelId).modelEchoSuffix;
+	if (typeof model !== "string" || suffix === void 0) return model;
+	return model.endsWith(suffix) ? model.slice(0, -suffix.length) : model;
+}
+/** Puts reasoning under `reasoning_content` whichever spelling the model used. */
+function normalizeMessage(message) {
+	const out = { ...message };
+	const reasoning = typeof out.reasoning_content === "string" && out.reasoning_content !== "" ? out.reasoning_content : typeof out.reasoning === "string" && out.reasoning !== "" ? out.reasoning : void 0;
+	delete out.reasoning;
+	if (reasoning !== void 0) out.reasoning_content = reasoning;
+	else delete out.reasoning_content;
+	if ("content" in out) out.content = contentText(out.content);
+	if (Array.isArray(out.tool_calls)) {
+		const calls = out.tool_calls.map((call, index) => normalizeToolCall(call, index)).filter((call) => call !== void 0);
+		if (calls.length > 0) out.tool_calls = calls;
+		else delete out.tool_calls;
+	}
+	return out;
+}
+/**
+* Returns the body in the strict `chat.completion` shape. Already-OpenAI
+* bodies come back with their reasoning spelling unified and the echoed model
+* id cleaned; native Workers AI `{ response, tool_calls, usage }` bodies are
+* lifted into `choices[0]`.
+*/
+function normalizeChatCompletion(body, modelId) {
+	if (!isRecord$1(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;
+			return {
+				...choice,
+				message,
+				finish_reason: choice.finish_reason ?? (hasToolCalls ? "tool_calls" : "stop")
+			};
+		});
+		return {
+			...body,
+			choices,
+			model: stripEchoSuffix$1(body.model, modelId)
+		};
+	}
+	if ("response" in body || "tool_calls" in body) {
+		const toolCalls = Array.isArray(body.tool_calls) ? body.tool_calls.map((call, index) => normalizeToolCall(call, index)).filter((call) => call !== void 0) : [];
+		const { response, tool_calls: _toolCalls, usage, ...rest } = body;
+		return {
+			...rest,
+			choices: [{
+				finish_reason: typeof body.finish_reason === "string" ? body.finish_reason : toolCalls.length > 0 ? "tool_calls" : "stop",
+				index: 0,
+				message: {
+					content: contentText(response),
+					role: "assistant",
+					...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+				}
+			}],
+			model: stripEchoSuffix$1(body.model, modelId),
+			...usage !== void 0 ? { usage } : {}
+		};
+	}
+	return body;
+}
+//#endregion
+//#region src/models/core/chat-completions/stream.ts
+/**
+* Normalizes a chat-completions SSE stream from the run path into strict
+* OpenAI `chat.completion.chunk` events.
+*
+* Every Workers AI model streams the same three-part hybrid (live captures,
+* all families): OpenAI-shaped delta chunks that each carry a per-delta
+* `usage`, then a `choices: []` heartbeat, then a native
+* `{ response: "", usage }` tail with the cumulative usage, then `[DONE]`.
+* Some models also emit native `{ response: "<text>" }` deltas or top-level
+* `tool_calls`. After this transform a consumer sees only:
+*
+* - delta chunks without per-delta usage and with reasoning under
+*   `reasoning_content`;
+* - at most one final `choices: []` chunk carrying the cumulative usage
+*   (the OpenAI `stream_options.include_usage` shape);
+* - a `finish_reason` on some chunk before the end, synthesized when the
+*   model finished cleanly without sending one;
+* - `[DONE]`.
+*
+* Input and output are SSE `data` payloads (strings), so it slots between the
+* SSE decoder and either framework's OpenAI chunk parser.
+*/
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+const NOISE_FIELDS = [
+	"p",
+	"token_ids",
+	"prompt_token_ids",
+	"kv_transfer_params"
+];
+/** Fields the run path adds to every chunk that mean nothing to a consumer. */
+function stripNoise(chunk) {
+	const out = { ...chunk };
+	for (const key of NOISE_FIELDS) delete out[key];
+	return out;
+}
+function stripEchoSuffix(chunk, modelId) {
+	const suffix = quirksFor(modelId).modelEchoSuffix;
+	if (suffix === void 0 || typeof chunk.model !== "string") return chunk;
+	return chunk.model.endsWith(suffix) ? {
+		...chunk,
+		model: chunk.model.slice(0, -suffix.length)
+	} : chunk;
+}
+function normalizeDelta(delta, relabelReasoning) {
+	const out = { ...delta };
+	const reasoning = typeof out.reasoning_content === "string" && out.reasoning_content !== "" ? out.reasoning_content : typeof out.reasoning === "string" && out.reasoning !== "" ? out.reasoning : void 0;
+	delete out.reasoning;
+	delete out.reasoning_content;
+	if (reasoning !== void 0) if (relabelReasoning) out.content = (typeof out.content === "string" ? out.content : "") + reasoning;
+	else out.reasoning_content = reasoning;
+	if (Array.isArray(out.tool_calls)) out.tool_calls = out.tool_calls.map((call, index) => {
+		if (!isRecord(call)) return call;
+		const fn = isRecord(call.function) ? call.function : void 0;
+		const args = fn !== void 0 ? fn.arguments : call.arguments;
+		return fn === void 0 && typeof call.name === "string" || isRecord(args) ? normalizeToolCall(call, index) ?? call : call;
+	});
+	return out;
+}
+/**
+* The transform. Backpressure is preserved: nothing is buffered except the
+* single pending usage chunk, which must wait for the tail.
+*/
+function normalizeChatCompletionsStream(modelId, options = {}) {
+	const quirks = quirksFor(modelId);
+	const relabelReasoning = options.reasoningOff === true && quirks.reasoningOffStreamLabel === "reasoning";
+	let id;
+	let model;
+	let created;
+	let sawFinishReason = false;
+	let sawContent = false;
+	let sawToolCalls = false;
+	let sawDone = false;
+	let finalUsage;
+	let finalUsageTemplate;
+	const perDeltaUsage = isWorkersAI(modelId);
+	const envelope = (extra) => ({
+		...id !== void 0 ? { id } : {},
+		object: "chat.completion.chunk",
+		...created !== void 0 ? { created } : {},
+		...model !== void 0 ? { model } : {},
+		...extra
+	});
+	const emit = (controller, chunk) => {
+		controller.enqueue(JSON.stringify(chunk));
+	};
+	const emitTail = (controller) => {
+		if (!sawFinishReason && sawDone && (sawContent || sawToolCalls)) {
+			emit(controller, envelope({ choices: [{
+				delta: {},
+				finish_reason: sawToolCalls ? "tool_calls" : "stop",
+				index: 0
+			}] }));
+			sawFinishReason = true;
+		}
+		if (finalUsage !== void 0) {
+			emit(controller, {
+				...finalUsageTemplate ?? envelope({}),
+				choices: [],
+				usage: finalUsage
+			});
+			finalUsage = void 0;
+		}
+		if (sawDone) controller.enqueue("[DONE]");
+	};
+	return new TransformStream({
+		flush(controller) {
+			emitTail(controller);
+		},
+		transform(data, controller) {
+			if (data === "") return;
+			if (data === "[DONE]") {
+				sawDone = true;
+				return;
+			}
+			let parsed;
+			try {
+				parsed = JSON.parse(data);
+			} catch {
+				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
+					}] }));
+				}
+			}
+		}
+	});
+}
+//#endregion
+//#region src/models/core/sse.ts
+/**
+* Decodes a `text/event-stream` byte stream into the `data` payload of each
+* event, as a `TransformStream` so the whole pipeline keeps backpressure and
+* nothing is ever buffered beyond the current event.
+*
+* Handles all three line terminators the SSE spec allows (LF, CRLF and a bare
+* CR), multi-line `data:` fields (joined with `\n`, per the spec), comment
+* lines (`:` prefixed), and non-`data` fields (`event:`, `id:`, `retry:`),
+* which are ignored. A trailing event that the server never terminated with a
+* blank line is still flushed.
+*
+* @experimental This surface is experimental and may change.
+*/
+function sseDataStream() {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let data = [];
+	const flushEvent = (controller) => {
+		if (data.length === 0) return;
+		controller.enqueue(data.join("\n"));
+		data = [];
+	};
+	const consumeLine = (line, controller) => {
+		if (line === "") {
+			flushEvent(controller);
+			return;
+		}
+		if (line.startsWith(":")) return;
+		const colon = line.indexOf(":");
+		if ((colon === -1 ? line : line.slice(0, colon)) !== "data") return;
+		let value = colon === -1 ? "" : line.slice(colon + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		data.push(value);
+	};
+	/**
+	* Consumes whole lines out of the buffer. A buffer ending in a lone `\r` is
+	* held back while more bytes may arrive, because the next byte decides
+	* whether that `\r` was a CRLF pair or a bare-CR terminator.
+	*/
+	const drain = (controller, final) => {
+		for (;;) {
+			const match = /\r\n|[\r\n]/.exec(buffer);
+			if (match === null) break;
+			const end = match.index + match[0].length;
+			if (!final && match[0] === "\r" && end === buffer.length) break;
+			consumeLine(buffer.slice(0, match.index), controller);
+			buffer = buffer.slice(end);
+		}
+	};
+	return new TransformStream({
+		flush(controller) {
+			buffer += decoder.decode();
+			drain(controller, true);
+			if (buffer !== "") {
+				consumeLine(buffer, controller);
+				buffer = "";
+			}
+			flushEvent(controller);
+		},
+		transform(chunk, controller) {
+			buffer += decoder.decode(chunk, { stream: true });
+			drain(controller, false);
+		}
+	});
+}
+//#endregion
+//#region src/models/core/images.ts
+/**
+* `flux-1-schnell` takes `{ prompt, steps }` and nothing else — no size, no
+* seed, no guidance. Sending those anyway would be silently ignored, so they
+* come back as warnings instead.
+*
+* @see https://developers.cloudflare.com/workers-ai/models/flux-1-schnell/
+*/
+const PROMPT_AND_STEPS_ONLY = /^@cf\/black-forest-labs\/flux-1/;
+/**
+* Builds the run-path body for a text-to-image model: `prompt`, `width`,
+* `height`, `num_steps`, `guidance`, `strength`, `negative_prompt` and `seed`,
+* or the flux-1 two-key subset with a warning for everything dropped.
+*
+* @experimental This surface is experimental and may change.
+*/
+function buildImageInput(modelId, prompt, settings) {
+	const warnings = [];
+	const input = { prompt };
+	if (PROMPT_AND_STEPS_ONLY.test(modelId)) {
+		if (settings.steps !== void 0) input.steps = settings.steps;
+		for (const [feature, value] of [
+			["size", settings.width ?? settings.height],
+			["seed", settings.seed],
+			["guidance", settings.guidance],
+			["negativePrompt", settings.negativePrompt],
+			["strength", settings.strength],
+			["files", settings.sourceImage === true ? true : void 0],
+			["mask", settings.mask === true ? true : void 0]
+		]) if (value !== void 0) warnings.push({
+			feature,
+			message: `${modelId} takes only a prompt and steps.`
+		});
+		return {
+			input,
+			minimal: true,
+			warnings
+		};
+	}
+	if (settings.width !== void 0) input.width = settings.width;
+	if (settings.height !== void 0) input.height = settings.height;
+	if (settings.seed !== void 0) input.seed = settings.seed;
+	if (settings.steps !== void 0) input.num_steps = settings.steps;
+	if (settings.guidance !== void 0) input.guidance = settings.guidance;
+	if (settings.strength !== void 0) input.strength = settings.strength;
+	if (settings.negativePrompt !== void 0) input.negative_prompt = settings.negativePrompt;
+	return {
+		input,
+		minimal: false,
+		warnings
+	};
+}
+const JPEG_PREFIX = "/9j/";
+const PNG_PREFIX = "iVBORw0KGgo";
+const WEBP_PREFIX = "UklGR";
+const GIF_PREFIX = "R0lGOD";
+/**
+* Sniffs an image media type from the head of its base64. The bytes decide,
+* never the model name: `flux-1-schnell` answers JPEG where every other model
+* in this catalog answers PNG.
+*
+* @experimental This surface is experimental and may change.
+*/
+function imageMediaTypeOf(base64) {
+	if (base64.startsWith(JPEG_PREFIX)) return "image/jpeg";
+	if (base64.startsWith(PNG_PREFIX)) return "image/png";
+	if (base64.startsWith(WEBP_PREFIX)) return "image/webp";
+	if (base64.startsWith(GIF_PREFIX)) return "image/gif";
+	return "image/png";
+}
+//#endregion
+export { resolveOptions as C, isRetryableStatus as D, isAbortError as E, parseModelOptions as S, classifyStatus as T, isGatewayErrorEnvelope as _, normalizeChatCompletion as a, gatewayLayerOf 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, CloudflareAIError as w, mergeModelOptions as x, PROVIDER_OPTIONS_KEY as y };
+
+//# sourceMappingURL=images-iiTDSyRu.js.map