agents 0.24.0 → 0.26.0

package/dist/models/pi-ai/index.js

@@ -0,0 +1,1795 @@
+import { C as resolveOptions, E as isAbortError, _ as isGatewayErrorEnvelope, a as normalizeChatCompletion, b as gatewayLayerOf, c as gatewaySlugForBaseUrl, d as resolveGatewayProvider, f as createTransport, g as headersToObject, h as errorFromResponse, i as normalizeChatCompletionsStream, l as isGatewayShapedUrl, m as errorFromGatewayEnvelope, n as imageMediaTypeOf, o as prepareChatCompletionsRequest, r as sseDataStream, s as GATEWAY_PROVIDER_NAMES, t as buildImageInput, v as unwrapEnvelope, w as CloudflareAIError, x as mergeModelOptions } from "../../images-iiTDSyRu.js";
+import { calculateCost, clampThinkingLevel, createAssistantMessageEventStream, createProvider, getCurrentTools, normalizeContext, parseStreamingJson } from "@earendil-works/pi-ai";
+import { CLOUDFLARE_AI_GATEWAY_MODELS } from "@earendil-works/pi-ai/providers/cloudflare-ai-gateway.models";
+import { CLOUDFLARE_WORKERS_AI_MODELS } from "@earendil-works/pi-ai/providers/cloudflare-workers-ai.models";
+import { convertMessages } from "@earendil-works/pi-ai/api/openai-completions";
+import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+import { adjustMaxTokensForThinking } from "@earendil-works/pi-ai/api/simple-options";
+import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "@earendil-works/pi-ai/api/openai-responses-shared";
+import { clampOpenAIPromptCacheKey } from "@earendil-works/pi-ai/api/openai-prompt-cache";
+//#region src/models/pi-ai/catalog.ts
+/**
+* The `api` marker Workers AI models from this provider carry. It is not a
+* wire format: Workers AI runs on `env.AI.run`, and the compat layer maps that
+* onto strict OpenAI chat completions.
+*
+* @beta This surface is in beta and may change.
+*/
+const CLOUDFLARE_AI_API = "cloudflare-ai";
+/**
+* The pi-ai provider id. A `Models` registry resolves specifiers as
+* `cloudflare/<id>`, e.g. `cloudflare/anthropic/claude-opus-4-8`.
+*
+* @beta This surface is in beta and may change.
+*/
+const CLOUDFLARE_PROVIDER_ID = "cloudflare";
+const MODEL_OPTIONS = Symbol.for("agents.models.pi-ai.options");
+const MODEL_ROUTING = Symbol.for("agents.models.pi-ai.routing");
+function tag(model, key, value) {
+	Object.defineProperty(model, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: false
+	});
+}
+/** Reads the options a model was created with, if it came from this provider. */
+function optionsOf(model) {
+	const options = model[MODEL_OPTIONS];
+	return options !== null && typeof options === "object" ? options : void 0;
+}
+/**
+* The gateway registry entry a model's own id names, for a model this provider
+* built from a `<slug>/<id>` specifier. It is looked up rather than inferred,
+* so a model that lost its symbol tags — `JSON.stringify` and
+* `structuredClone` drop them, and an Agent's state goes through both — still
+* reaches the vendor under the vendor's own spelling.
+*/
+function registryEntryFor(model) {
+	if (model.provider !== "cloudflare" || model.id.startsWith("@cf/")) return;
+	gatewayRegistry ??= buildGatewayRegistry();
+	return gatewayRegistry.get(model.id);
+}
+/**
+* The id the request body must carry. It differs from `model.id` only for a
+* `<slug>/<id>` specifier, whose model is listed under the specifier so a
+* `Models` registry can find it while the vendor still sees its own spelling.
+*/
+function wireModelId(model) {
+	const tagged = model[MODEL_ROUTING]?.modelId;
+	if (tagged !== void 0) return tagged;
+	return registryEntryFor(model)?.id ?? model.id;
+}
+/** The `<slug>/<id>` specifier a model was resolved from, for diagnostics. */
+function specifierOf(model) {
+	const tagged = model[MODEL_ROUTING]?.specifier;
+	if (tagged !== void 0) return tagged;
+	return registryEntryFor(model) === void 0 ? void 0 : model.id;
+}
+/**
+* Copies a caller's model and tags the copy with the resolved options. The
+* caller's object is never mutated, and every field it declares — `api`,
+* `provider`, `id`, `baseUrl`, `compat`, `thinkingLevelMap`, cost and limits —
+* is kept verbatim, because that metadata is the model's own author's, not
+* ours.
+*/
+function withOptions(model, options) {
+	const copy = { ...model };
+	if (options !== void 0) tag(copy, MODEL_OPTIONS, options);
+	return copy;
+}
+const DEFAULT_CONTEXT_WINDOW = 128e3;
+const DEFAULT_MAX_TOKENS = 8192;
+const ZERO_COST = {
+	cacheRead: 0,
+	cacheWrite: 0,
+	input: 0,
+	output: 0
+};
+let workersAI;
+function workersAIEntry(modelId) {
+	workersAI ??= new Map(Object.values(CLOUDFLARE_WORKERS_AI_MODELS).map((entry) => [entry.id, entry]));
+	return workersAI.get(modelId);
+}
+/** Every Workers AI id pi-ai knows, for the provider's static model list. */
+function workersAIModelIds() {
+	workersAI ??= new Map(Object.values(CLOUDFLARE_WORKERS_AI_MODELS).map((entry) => [entry.id, entry]));
+	return [...workersAI.keys()].sort();
+}
+/**
+* Builds the pi-ai model for a Workers AI id. Registry metadata is used when
+* pi-ai knows the id; explicit options override it; everything else falls back
+* to defaults that keep the model usable, because the Workers AI catalog moves
+* faster than any generated registry.
+*/
+function buildWorkersAIModel(modelId, options) {
+	const known = workersAIEntry(modelId);
+	const model = {
+		api: CLOUDFLARE_AI_API,
+		baseUrl: "",
+		contextWindow: options?.contextWindow ?? known?.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
+		cost: options?.cost ?? known?.cost ?? ZERO_COST,
+		id: modelId,
+		input: options?.input ?? known?.input ?? ["text"],
+		maxTokens: options?.maxTokens ?? known?.maxTokens ?? DEFAULT_MAX_TOKENS,
+		name: options?.name ?? known?.name ?? modelId,
+		provider: CLOUDFLARE_PROVIDER_ID,
+		reasoning: options?.reasoning ?? known?.reasoning ?? true,
+		...known?.thinkingLevelMap !== void 0 ? { thinkingLevelMap: known.thinkingLevelMap } : {}
+	};
+	if (options !== void 0) tag(model, MODEL_OPTIONS, options);
+	return model;
+}
+/** The gateway provider slug a registry entry's base URL names. */
+function slugOf(entry) {
+	return entry.baseUrl.split("/").filter((part) => part !== "").at(-1);
+}
+let gatewayRegistry;
+/**
+* pi-ai's generated Cloudflare AI Gateway registry, keyed by `<slug>/<id>`.
+* `/compat` entries are skipped: they alias `@cf/` ids the Workers AI registry
+* already declares, and those belong on the run path.
+*/
+function buildGatewayRegistry() {
+	const map = /* @__PURE__ */ new Map();
+	for (const entry of Object.values(CLOUDFLARE_AI_GATEWAY_MODELS)) {
+		const slug = slugOf(entry);
+		if (slug === void 0 || slug === "compat") continue;
+		map.set(`${slug}/${entry.id}`, entry);
+	}
+	return map;
+}
+/** Every `<slug>/<id>` specifier pi-ai's gateway registry declares. */
+function gatewayModelIds() {
+	gatewayRegistry ??= buildGatewayRegistry();
+	return [...gatewayRegistry.keys()].sort();
+}
+/** An id with case and separators (`.`, `-`, `_`) ignored. */
+function looseId(id) {
+	return id.toLowerCase().replace(/[._-]/g, "-");
+}
+/**
+* Catalog specifiers that differ from `specifier` only in case or separators.
+* AI Gateway's catalog spells `anthropic/claude-opus-4.8` where Anthropic
+* spells `claude-opus-4-8`, and the difference is easy to miss.
+*/
+function nearSpecifiers(specifier, specifiers) {
+	const wanted = looseId(specifier);
+	return [...specifiers].filter((id) => looseId(id) === wanted).sort();
+}
+/**
+* Resolves a `<slug>/<id>` specifier through pi-ai's generated Cloudflare AI
+* Gateway registry. The entry's metadata — api, base URL, compat,
+* `thinkingLevelMap`, cost, limits — is kept exactly as pi generated it; only
+* `id` and `provider` are restated so a `Models` registry can find the model
+* under `cloudflare/<slug>/<id>`, and the vendor's own spelling rides along for
+* the request body.
+*
+* There is no prefix guessing: an id pi-ai does not list is a `TypeError`,
+* pointing at the model-object form, which needs no catalog of ours at all.
+*/
+function buildGatewayModel(specifier, options) {
+	gatewayRegistry ??= buildGatewayRegistry();
+	const separator = specifier.indexOf("/");
+	const slug = separator === -1 ? "" : specifier.slice(0, separator);
+	const vendorId = specifier.slice(separator + 1);
+	if (slug === "workers-ai") throw new TypeError(`"${specifier}" is a Workers AI model: pass its id directly, ai("${vendorId}").`);
+	const entry = gatewayRegistry.get(specifier);
+	if (entry === void 0) {
+		const near = nearSpecifiers(specifier, gatewayRegistry.keys());
+		const suggestion = near.length === 0 ? "" : ` Did you mean ${near.map((id) => `ai("${id}")`).join(" or ")}? The catalog spells ids as AI Gateway does.`;
+		throw new TypeError(`"${specifier}" is not in pi-ai's Cloudflare AI Gateway catalog.${suggestion} Pass the model object instead, e.g. ai(getBuiltinModel("${slug || "anthropic"}", "${vendorId}")) from "@earendil-works/pi-ai/providers/all", or any model from a provider registry you imported.`);
+	}
+	const model = {
+		...entry,
+		id: specifier,
+		provider: CLOUDFLARE_PROVIDER_ID
+	};
+	tag(model, MODEL_ROUTING, {
+		modelId: entry.id,
+		specifier
+	});
+	if (options !== void 0) tag(model, MODEL_OPTIONS, options);
+	return model;
+}
+//#endregion
+//#region src/models/pi-ai/routing.ts
+/**
+* The path each pi api speaks, relative to the model's own `baseUrl` — exactly
+* what pi's SDK clients append to it.
+*/
+const API_PATHS = {
+	"anthropic-messages": "v1/messages",
+	"openai-completions": "chat/completions",
+	"openai-responses": "responses"
+};
+/**
+* The universal request's `endpoint` for a gateway-shaped base URL, whose path
+* already ends at the provider slug, so what follows is the vendor's own path.
+*/
+const GATEWAY_ENDPOINTS = {
+	"anthropic-messages": "v1/messages",
+	"openai-completions": "v1/chat/completions",
+	"openai-responses": "v1/responses"
+};
+/**
+* The gateway provider slug that serves a model, from its own base URL.
+*
+* @throws TypeError when the model carries no base URL, or one AI Gateway has
+* no provider for.
+*/
+function gatewaySlugForModel(model) {
+	if (model.baseUrl === "") throw new TypeError(`The model "${model.id}" has no baseUrl, so AI Gateway cannot tell which provider serves it.`);
+	return gatewaySlugForBaseUrl(model.baseUrl);
+}
+/** `https://api.groq.com/openai/v1` → `https://api.groq.com/openai/v1/`. */
+function asBase(baseUrl) {
+	return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+/**
+* The provider slug and endpoint one model's request travels on.
+*
+* @throws TypeError when the model has no base URL, when AI Gateway has no
+* provider for it, or when this module knows no path for the model's api.
+*/
+function routeForModel(model) {
+	const provider = gatewaySlugForModel(model);
+	if (isGatewayShapedUrl(model.baseUrl)) {
+		const endpoint = GATEWAY_ENDPOINTS[model.api];
+		if (endpoint === void 0) throw noEndpoint(model.api);
+		return {
+			endpoint,
+			provider
+		};
+	}
+	const path = API_PATHS[model.api];
+	if (path === void 0) throw noEndpoint(model.api);
+	const resolved = resolveGatewayProvider(new URL(path, asBase(model.baseUrl)).toString());
+	if (resolved === void 0) return {
+		endpoint: GATEWAY_ENDPOINTS[model.api] ?? path,
+		provider
+	};
+	return {
+		endpoint: resolved.endpoint,
+		provider: resolved.provider
+	};
+}
+function noEndpoint(api) {
+	return /* @__PURE__ */ new TypeError(`No AI Gateway endpoint is known for the "${api}" API.`);
+}
+//#endregion
+//#region src/models/pi-ai/wires/shared.ts
+/** Diagnostic type under which gateway correlation ids are recorded. */
+const CLOUDFLARE_DIAGNOSTIC = "cloudflare";
+/** The diagnostic type under which compat-layer warnings are recorded. */
+const COMPAT_DIAGNOSTIC = "cloudflare-compat";
+/** Records compat warnings on a message as a `cloudflare-compat` diagnostic. */
+/**
+* pi-ai types diagnostic details as JSON. These details are plain data this
+* module built, so a JSON round trip only drops their undefined fields.
+*/
+function jsonDetails(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+function recordWarnings(output, warnings) {
+	if (warnings.length === 0) return;
+	output.diagnostics = [...output.diagnostics ?? [], {
+		details: jsonDetails({ warnings }),
+		timestamp: Date.now(),
+		type: COMPAT_DIAGNOSTIC
+	}];
+}
+/**
+* The Workers-AI-only knobs a vendor model cannot honour. They are not sent —
+* the vendor's own reasoning follows the model's metadata and the pi
+* `reasoning` level — and the drop is recorded rather than silent.
+*/
+function ignoredWorkersAIKnobs(request) {
+	const warnings = [];
+	if (request.resolved.reasoningEffort !== void 0) warnings.push({
+		feature: "reasoning-effort",
+		message: "reasoningEffort is a Workers AI setting and does not apply to a model routed through AI Gateway; use the pi `reasoning` level, which the model's own metadata maps."
+	});
+	if (request.resolved.chatTemplateKwargs !== void 0) warnings.push({
+		feature: "chat-template-kwargs",
+		message: "chatTemplateKwargs is a Workers AI setting and was not sent to a model routed through AI Gateway."
+	});
+	return warnings;
+}
+function emptyUsage() {
+	return {
+		cacheRead: 0,
+		cacheWrite: 0,
+		cost: {
+			cacheRead: 0,
+			cacheWrite: 0,
+			input: 0,
+			output: 0,
+			total: 0
+		},
+		input: 0,
+		output: 0,
+		totalTokens: 0
+	};
+}
+/** The assistant message a stream mutates as events arrive. */
+function startMessage(model) {
+	return {
+		api: model.api,
+		content: [],
+		model: model.id,
+		provider: model.provider,
+		role: "assistant",
+		stopReason: "stop",
+		timestamp: Date.now(),
+		usage: emptyUsage()
+	};
+}
+/**
+* Maps OpenAI-shaped usage onto pi-ai's. `input` excludes cached tokens, as
+* pi-ai's own OpenAI adapter does, and cost comes from the model metadata.
+*/
+function usageFromOpenAI(model, raw) {
+	if (raw === void 0) return emptyUsage();
+	const prompt = raw.prompt_tokens ?? 0;
+	const completion = raw.completion_tokens ?? 0;
+	const cacheRead = raw.prompt_tokens_details?.cached_tokens ?? raw.prompt_cache_hit_tokens ?? 0;
+	const cacheWrite = raw.prompt_tokens_details?.cache_write_tokens ?? 0;
+	const reasoning = raw.completion_tokens_details?.reasoning_tokens;
+	const totalTokens = raw.total_tokens ?? prompt + completion;
+	const output = raw.total_tokens === void 0 ? completion : Math.max(completion, totalTokens - prompt);
+	const usage = {
+		cacheRead,
+		cacheWrite,
+		cost: {
+			cacheRead: 0,
+			cacheWrite: 0,
+			input: 0,
+			output: 0,
+			total: 0
+		},
+		input: Math.max(0, prompt - cacheRead - cacheWrite),
+		output,
+		...reasoning !== void 0 ? { reasoning } : {},
+		totalTokens
+	};
+	usage.cost = calculateCost(model, usage);
+	return usage;
+}
+function correlationOf(response, transport) {
+	const get = (name) => response.headers.get(name) ?? void 0;
+	return {
+		cacheStatus: get("cf-aig-cache-status"),
+		eventId: get("cf-aig-event-id"),
+		logId: get("cf-aig-log-id") ?? transport.logIdFallback(response),
+		runId: get("cf-aig-run-id"),
+		step: get("cf-aig-step"),
+		traceId: get("cf-aig-trace-id")
+	};
+}
+function definedEntries$1(record) {
+	const result = {};
+	for (const [key, value] of Object.entries(record)) if (value !== void 0) result[key] = value;
+	return result;
+}
+/**
+* Records where a response came from on the assistant message, as a pi-ai
+* diagnostic: the gateway log id and friends, the answering model and the
+* gateway id. Callers read it back from `message.diagnostics`.
+*/
+function attachCorrelation(message, details) {
+	const diagnostic = {
+		details: jsonDetails(definedEntries$1({ ...details })),
+		timestamp: Date.now(),
+		type: CLOUDFLARE_DIAGNOSTIC
+	};
+	message.diagnostics = [...message.diagnostics ?? [], diagnostic];
+}
+/**
+* Wraps a body so a gap longer than `idleMs` between chunks rejects the read
+* instead of pending forever. Only an outstanding read is timed, so a slow
+* consumer never trips it; `idleMs <= 0` disables the guard.
+*/
+function withIdleDeadline(body, idleMs) {
+	if (idleMs <= 0) return body;
+	const reader = body.getReader();
+	return new ReadableStream({
+		cancel(reason) {
+			return reader.cancel(reason);
+		},
+		async pull(controller) {
+			let timer;
+			try {
+				const result = await Promise.race([reader.read(), new Promise((_, reject) => {
+					timer = setTimeout(() => {
+						reject(/* @__PURE__ */ new Error(`Model stream stalled: no data received for ${Math.round(idleMs / 1e3)}s.`));
+					}, idleMs);
+				})]);
+				if (result.done) controller.close();
+				else controller.enqueue(result.value);
+			} catch (error) {
+				reader.cancel().catch(() => {});
+				controller.error(error);
+			} finally {
+				clearTimeout(timer);
+			}
+		}
+	});
+}
+/**
+* Iterates the JSON payload of each SSE event. `[DONE]` sentinels and
+* unparseable payloads are skipped; the reader is cancelled if iteration
+* stops early so the upstream request is not left generating.
+*/
+async function* sseJson(body, onDone) {
+	const reader = body.pipeThrough(sseDataStream()).getReader();
+	let finished = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) {
+				finished = true;
+				return;
+			}
+			if (value === "") continue;
+			if (value === "[DONE]") {
+				onDone?.();
+				continue;
+			}
+			try {
+				yield JSON.parse(value);
+			} catch {}
+		}
+	} finally {
+		if (!finished) await reader.cancel().catch(() => {});
+		reader.releaseLock();
+	}
+}
+/** `response.headers` as pi-ai's `onResponse` callback wants them. */
+function responseInfo(response) {
+	return {
+		headers: headersToObject(response.headers),
+		status: response.status
+	};
+}
+/**
+* The Anthropic API version every Messages request must name. pi-ai leaves it
+* to the Anthropic SDK, which we replace, so the wire states it here.
+*/
+const ANTHROPIC_VERSION = "2023-06-01";
+/**
+* The vendor headers an Anthropic Messages request needs. pi-ai normally gets
+* them from the Anthropic SDK's defaults plus its own `createClient`; this
+* wire owns the transport instead, so it sets the ones the vendor requires and
+* sends the beta features pi-ai chose as `anthropic-beta`, as the SDK would.
+* No credential header is sent: the gateway holds the key (unified billing or
+* BYOK).
+*/
+function anthropicVendorHeaders(betas) {
+	return {
+		accept: "application/json",
+		"anthropic-version": ANTHROPIC_VERSION,
+		...betas.length > 0 ? { "anthropic-beta": betas.join(",") } : {},
+		"content-type": "application/json"
+	};
+}
+/** The vendor headers an OpenAI-shaped request needs. */
+function openAIVendorHeaders() {
+	return {
+		accept: "application/json",
+		"content-type": "application/json"
+	};
+}
+/**
+* Sends a vendor's own request body through AI Gateway's universal endpoint.
+*
+* The provider slug comes from the model's base URL and the endpoint from its
+* `api`; the body is what pi-ai's converter built, `model` included, because
+* that is what the universal request carries. The gateway's *own* failures
+* (no such gateway, unified billing unpaid) are lifted into a
+* `CloudflareAIError` so fallback and retry classification behave as they do on
+* the Workers AI run path; a vendor's own error response is left alone for the
+* wire's parser to read.
+*/
+async function sendUniversal(request, transport, body, vendorHeaders, onResponse) {
+	const { model, options, resolved } = request;
+	const route = routeForModel(model);
+	const response = await transport.universal({
+		endpoint: route.endpoint,
+		extraHeaders: Object.keys(request.headers).length > 0 ? request.headers : void 0,
+		gateway: resolved.gateway,
+		headers: vendorHeaders,
+		provider: route.provider,
+		query: body,
+		signal: options.signal
+	});
+	onResponse?.(response);
+	return await liftGatewayError(response, {
+		model: wireModelId(model),
+		requestBodyValues: body,
+		url: transport.url
+	});
+}
+/**
+* Turns the gateway's own error envelope into a `CloudflareAIError`. Only a
+* JSON body can be one, so a streaming response is passed straight through and
+* never buffered.
+*/
+async function liftGatewayError(response, context) {
+	if (!(response.headers.get("content-type") ?? "").includes("application/json")) return response;
+	const text = await response.text().catch(() => "");
+	let parsed;
+	try {
+		parsed = text === "" ? void 0 : JSON.parse(text);
+	} catch {
+		parsed = void 0;
+	}
+	if (isGatewayErrorEnvelope(parsed)) throw errorFromGatewayEnvelope(parsed, {
+		...context,
+		responseBody: text,
+		responseHeaders: headersToObject(response.headers),
+		status: response.status
+	});
+	return new Response(text, response);
+}
+/** The correlation details every wire records, with the routing it used. */
+function correlationDetails(request, response, transport) {
+	const { model, resolved } = request;
+	const specifier = specifierOf(model);
+	return {
+		...correlationOf(response, transport),
+		gateway: resolved.gateway.id,
+		model: model.id,
+		...specifier !== void 0 ? { specifier } : {},
+		...model.api === "cloudflare-ai" ? {} : { provider: gatewaySlugForModel(model) }
+	};
+}
+//#endregion
+//#region src/models/pi-ai/errors.ts
+/** Diagnostic type under which a failed dispatch is recorded. */
+const CLOUDFLARE_ERROR_DIAGNOSTIC = "cloudflare-error";
+function definedEntries(record) {
+	const result = {};
+	for (const [key, value] of Object.entries(record)) if (value !== void 0) result[key] = value;
+	return result;
+}
+/**
+* Terminates a stream with a pi-ai `error` event built from a thrown value.
+* `aborted` when the caller's signal fired or the error is an abort; `error`
+* otherwise, with the failed dispatch recorded as a diagnostic.
+*/
+function failStream(stream, message, error, signal) {
+	const aborted = signal?.aborted === true || isAbortError(error);
+	const reason = aborted ? "aborted" : "error";
+	message.stopReason = reason;
+	message.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+	if (!aborted) {
+		const details = {};
+		if (error instanceof CloudflareAIError) Object.assign(details, definedEntries({
+			code: error.code,
+			logId: error.logId,
+			model: error.model,
+			status: error.status
+		}));
+		message.diagnostics = [...message.diagnostics ?? [], {
+			details: jsonDetails(details),
+			error: {
+				message: message.errorMessage,
+				name: error instanceof Error ? error.name : "Error",
+				...error instanceof CloudflareAIError ? { code: error.code } : {}
+			},
+			timestamp: Date.now(),
+			type: CLOUDFLARE_ERROR_DIAGNOSTIC
+		}];
+	}
+	stream.push({
+		error: message,
+		reason,
+		type: "error"
+	});
+	stream.end(message);
+}
+/** Throws the typed error for a non-2xx response. */
+async function assertOk(response, context) {
+	if (response.ok) return;
+	throw await errorFromResponse(response, context);
+}
+//#endregion
+//#region src/models/pi-ai/wires/chat-completions.ts
+/**
+* Chat-completions wire: Workers AI on the run path, and any pi-ai model whose
+* `api` is `openai-completions` on AI Gateway's universal endpoint.
+*
+* The request is shaped with pi-ai's own message converter so replay rules
+* (tool-call id normalization, reasoning replay, role bridging) match pi's
+* other OpenAI-compatible providers. Workers AI then runs through the shared
+* compat layer, which absorbs its native events, heartbeats, per-delta usage
+* and per-family request quirks so the parser below only ever sees strict
+* OpenAI chunks. A vendor model brings its own `compat` profile and needs none
+* of that: its bytes are already what its author says they are.
+*/
+/**
+* pi-ai's message converter wants a fully resolved compat profile. This is
+* the strict OpenAI profile: replayed reasoning goes to `reasoning_content`,
+* `max_tokens` is the cap, and nothing vendor-specific is applied here — the
+* shared compat layer handles that per model afterwards.
+*/
+const STRICT_OPENAI_COMPAT = {
+	chatTemplateArgs: {},
+	chatTemplateKwargs: {},
+	maxTokensField: "max_tokens",
+	openRouterRouting: {},
+	requiresAssistantAfterToolResult: false,
+	requiresReasoningContentOnAssistantMessages: false,
+	requiresThinkingAsText: false,
+	requiresToolResultName: false,
+	sendSessionAffinityHeaders: false,
+	sessionAffinityFormat: "openai",
+	supportsDeveloperRole: false,
+	supportsFinishReason: true,
+	supportsLongCacheRetention: false,
+	supportsOpenAIGrammarTools: false,
+	supportsReasoningEffort: true,
+	supportsStore: false,
+	supportsStrictMode: false,
+	supportsUsageInStreaming: true,
+	thinkingFormat: "openai",
+	vercelGatewayRouting: {},
+	zaiToolStream: false
+};
+/**
+* The fields an OpenAI-compatible endpoint puts reasoning in, in pi-ai's own
+* order (`dist/api/openai-completions.js`). The first non-empty one wins and
+* the rest are skipped: some endpoints send the same text under two spellings,
+* and reading both would double the thinking block.
+*/
+const REASONING_FIELDS = [
+	"reasoning_content",
+	"reasoning",
+	"reasoning_text"
+];
+function mapFinishReason(reason) {
+	switch (reason) {
+		case "stop":
+		case "eos": return "stop";
+		case "length":
+		case "model_length": return "length";
+		case "tool_calls":
+		case "function_call": return "toolUse";
+		default: return "error";
+	}
+}
+function convertTools(tools) {
+	return tools.map((tool) => ({
+		function: {
+			description: tool.description,
+			name: tool.name,
+			parameters: tool.parameters
+		},
+		type: "function"
+	}));
+}
+/** Whether a tool-call chunk is the null finalizer some vLLM parsers emit. */
+function isFinalizer(call) {
+	const fn = call.function;
+	return call.index === void 0 && (call.id === null || call.id === void 0) && (fn?.name === null || fn?.name === void 0) && (fn?.arguments === null || fn?.arguments === void 0 || fn?.arguments === "");
+}
+/**
+* Incremental state for one streamed completion: the blocks being built on
+* the assistant message and the events that announce them.
+*/
+var CompletionAssembler = class {
+	constructor(model, output, stream) {
+		this.model = model;
+		this.output = output;
+		this.stream = stream;
+		this.openToolCalls = /* @__PURE__ */ new Map();
+		this.closedToolCalls = /* @__PURE__ */ new Set();
+		this.blocks = output.content;
+	}
+	indexOf(block) {
+		return this.blocks.indexOf(block);
+	}
+	stripScratch() {
+		for (const block of this.blocks) if (block.type === "toolCall") delete block.partialArguments;
+	}
+	endText() {
+		if (this.textBlock === void 0) return;
+		this.stream.push({
+			content: this.textBlock.text,
+			contentIndex: this.indexOf(this.textBlock),
+			partial: this.output,
+			type: "text_end"
+		});
+		this.textBlock = void 0;
+	}
+	endThinking() {
+		if (this.thinkingBlock === void 0) return;
+		this.stream.push({
+			content: this.thinkingBlock.thinking,
+			contentIndex: this.indexOf(this.thinkingBlock),
+			partial: this.output,
+			type: "thinking_end"
+		});
+		this.thinkingBlock = void 0;
+	}
+	pushText(delta) {
+		if (delta.length === 0) return;
+		this.endThinking();
+		if (this.textBlock === void 0) {
+			this.textBlock = {
+				text: "",
+				type: "text"
+			};
+			this.blocks.push(this.textBlock);
+			this.stream.push({
+				contentIndex: this.indexOf(this.textBlock),
+				partial: this.output,
+				type: "text_start"
+			});
+		}
+		this.textBlock.text += delta;
+		this.stream.push({
+			contentIndex: this.indexOf(this.textBlock),
+			delta,
+			partial: this.output,
+			type: "text_delta"
+		});
+	}
+	pushThinking(delta, signature) {
+		if (delta.length === 0) return;
+		this.endText();
+		if (this.thinkingBlock === void 0) {
+			this.thinkingBlock = {
+				thinking: "",
+				thinkingSignature: signature,
+				type: "thinking"
+			};
+			this.blocks.push(this.thinkingBlock);
+			this.stream.push({
+				contentIndex: this.indexOf(this.thinkingBlock),
+				partial: this.output,
+				type: "thinking_start"
+			});
+		}
+		this.thinkingBlock.thinking += delta;
+		this.stream.push({
+			contentIndex: this.indexOf(this.thinkingBlock),
+			delta,
+			partial: this.output,
+			type: "thinking_delta"
+		});
+	}
+	closeToolCall(index) {
+		const block = this.openToolCalls.get(index);
+		if (block === void 0 || this.closedToolCalls.has(index)) return;
+		this.closedToolCalls.add(index);
+		block.arguments = parseStreamingJson(block.partialArguments ?? "");
+		delete block.partialArguments;
+		this.stream.push({
+			contentIndex: this.indexOf(block),
+			partial: this.output,
+			toolCall: block,
+			type: "toolcall_end"
+		});
+	}
+	pushToolCalls(calls) {
+		this.endThinking();
+		this.endText();
+		for (const call of calls) {
+			if (isFinalizer(call)) {
+				if (this.lastToolIndex !== void 0) this.closeToolCall(this.lastToolIndex);
+				continue;
+			}
+			const name = call.function?.name ?? void 0;
+			const args = call.function?.arguments ?? "";
+			const index = typeof call.index === "number" ? call.index : this.lastToolIndex ?? 0;
+			if (this.closedToolCalls.has(index)) continue;
+			let block = this.openToolCalls.get(index);
+			if (block === void 0) {
+				if (this.lastToolIndex !== void 0 && this.lastToolIndex !== index) this.closeToolCall(this.lastToolIndex);
+				block = {
+					arguments: {},
+					id: call.id ?? crypto.randomUUID(),
+					name: name ?? "",
+					partialArguments: "",
+					type: "toolCall"
+				};
+				this.openToolCalls.set(index, block);
+				this.blocks.push(block);
+				this.stream.push({
+					contentIndex: this.indexOf(block),
+					partial: this.output,
+					type: "toolcall_start"
+				});
+			} else {
+				if (block.name === "" && name) block.name = name;
+				if (call.id) block.id = call.id;
+			}
+			this.lastToolIndex = index;
+			if (args.length > 0) {
+				block.partialArguments = (block.partialArguments ?? "") + args;
+				block.arguments = parseStreamingJson(block.partialArguments);
+				this.stream.push({
+					contentIndex: this.indexOf(block),
+					delta: args,
+					partial: this.output,
+					type: "toolcall_delta"
+				});
+			}
+		}
+	}
+	applyFinishReason(reason) {
+		if (reason === null || reason === void 0) return false;
+		this.output.stopReason = mapFinishReason(reason);
+		if (this.output.stopReason === "error") this.output.errorMessage = `The model stopped with finish_reason "${reason}".`;
+		return true;
+	}
+	/** Applies one strict chunk (or a whole normalized body); true if it carried a finish reason. */
+	apply(chunk) {
+		if (chunk.error !== void 0) {
+			this.output.stopReason = "error";
+			this.output.errorMessage = chunk.error.message ?? "The model reported an error.";
+			return true;
+		}
+		const choice = chunk.choices?.[0];
+		if (chunk.id !== void 0) this.output.responseId ??= chunk.id;
+		if (typeof chunk.model === "string" && chunk.model.length > 0 && chunk.model !== this.model.id) this.output.responseModel ??= chunk.model;
+		if (chunk.usage !== void 0) this.output.usage = usageFromOpenAI(this.model, chunk.usage);
+		const finished = this.applyFinishReason(choice?.finish_reason);
+		const delta = choice?.delta ?? choice?.message;
+		if (delta !== void 0) {
+			for (const field of REASONING_FIELDS) {
+				const value = delta[field];
+				if (typeof value === "string" && value.length > 0) {
+					this.pushThinking(value, field);
+					break;
+				}
+			}
+			if (typeof delta.content === "string") this.pushText(delta.content);
+			if (Array.isArray(delta.tool_calls)) {
+				const complete = choice?.delta === void 0;
+				this.pushToolCalls(complete ? delta.tool_calls.map((call, position) => ({
+					...call,
+					index: typeof call.index === "number" ? call.index : position
+				})) : delta.tool_calls);
+			}
+		}
+		return finished;
+	}
+	/** Closes open blocks and settles the stop reason. */
+	finish(sawFinishReason, sawDone) {
+		for (const index of this.openToolCalls.keys()) this.closeToolCall(index);
+		this.endThinking();
+		this.endText();
+		const hasToolCalls = this.blocks.some((b) => b.type === "toolCall");
+		if (this.output.stopReason === "error") return;
+		if (!sawFinishReason) if (sawDone) this.output.stopReason = hasToolCalls ? "toolUse" : "stop";
+		else {
+			this.output.stopReason = "error";
+			this.output.errorMessage = this.blocks.length > 0 ? "The stream ended before the model finished its answer." : "The stream ended before the model produced any output.";
+		}
+		else if (this.output.stopReason === "stop" && hasToolCalls) this.output.stopReason = "toolUse";
+	}
+};
+/**
+* Puts the reasoning knobs on a chat-completions body, and reports the ones a
+* model cannot take.
+*
+* Workers AI is the one model family with knobs of ours: `reasoning_effort` on
+* its own three-level scale and `chat_template_kwargs`, both of which the
+* compat layer re-checks against the quirk table afterwards. For every other
+* model the decision is the model author's, read off the merged compat profile
+* exactly as pi-ai's own `openai-completions` implementation reads it: the
+* effort is emitted only when the model reasons, declares
+* `supportsReasoningEffort` and asks for OpenAI's `reasoning_effort` shape,
+* and it is remapped through the model's own `thinkingLevelMap`.
+*/
+function applyReasoning(strict, context) {
+	const { chatTemplateKwargs, compat, effort, model, workersAI } = context;
+	if (workersAI) {
+		if (effort !== void 0) strict.reasoning_effort = effort;
+		if (chatTemplateKwargs !== void 0) strict.chat_template_kwargs = chatTemplateKwargs;
+		return [];
+	}
+	const ignored = [];
+	const thinkingFormat = compat.thinkingFormat;
+	if (typeof effort === "string") {
+		if (model.reasoning === true && compat.supportsReasoningEffort !== false && thinkingFormat === "openai") strict.reasoning_effort = model.thinkingLevelMap?.[effort] ?? effort;
+		else if (thinkingFormat !== "openai") ignored.push({
+			feature: "reasoning-effort",
+			message: `This model declares the "${thinkingFormat}" thinking format, which this wire does not build; its reasoning level was dropped. Reach it through pi-ai's own provider if you need that shape.`
+		});
+	}
+	if (context.workersAIEffort === null) ignored.push({
+		feature: "reasoning-off",
+		message: "`reasoningEffort: null` is a Workers AI setting; a model routed through AI Gateway decides its own reasoning, so it was dropped."
+	});
+	else if (context.workersAIEffort !== void 0) ignored.push({
+		feature: "reasoning-effort",
+		message: "`reasoningEffort` is a Workers AI setting and does not apply to a model routed through AI Gateway; use the pi `reasoning` level, which the model's own metadata maps."
+	});
+	if (chatTemplateKwargs !== void 0) ignored.push({
+		feature: "chat-template-kwargs",
+		message: "`chatTemplateKwargs` is a Workers AI setting and does not apply to a model routed through AI Gateway; it was dropped."
+	});
+	return ignored;
+}
+/** Streams a chat-completions request and maps it onto pi-ai events. */
+function streamCompletions(request, transport) {
+	const { model, context, options, resolved } = request;
+	const stream = createAssistantMessageEventStream();
+	const output = startMessage(model);
+	const assembler = new CompletionAssembler(model, output, stream);
+	const workersAI = model.api === CLOUDFLARE_AI_API;
+	(async () => {
+		let response;
+		try {
+			const compat = workersAI ? STRICT_OPENAI_COMPAT : {
+				...STRICT_OPENAI_COMPAT,
+				...model.compat ?? {}
+			};
+			const strict = {
+				messages: convertMessages(model, context, compat),
+				stream: true,
+				stream_options: { include_usage: true }
+			};
+			if (!workersAI) strict.model = wireModelId(model);
+			const tools = getCurrentTools(context.messages);
+			if (tools.length > 0) strict.tools = convertTools(tools);
+			if (request.toolChoice !== void 0) strict.tool_choice = request.toolChoice;
+			if (options.maxTokens !== void 0) strict.max_tokens = options.maxTokens;
+			if (options.temperature !== void 0) strict.temperature = options.temperature;
+			const ignored = applyReasoning(strict, {
+				chatTemplateKwargs: resolved.chatTemplateKwargs,
+				compat,
+				effort: request.reasoningEffort,
+				model,
+				workersAI,
+				workersAIEffort: resolved.reasoningEffort
+			});
+			const sampling = options.samplingParams;
+			if (sampling !== void 0) Object.assign(strict, sampling);
+			const prepared = workersAI ? prepareChatCompletionsRequest(strict, model.id) : {
+				body: strict,
+				reasoningOff: false,
+				warnings: []
+			};
+			recordWarnings(output, [...ignored, ...prepared.warnings]);
+			const overridden = await options.onPayload?.(prepared.body, model);
+			const payload = overridden === void 0 ? prepared.body : overridden;
+			response = workersAI ? await transport.run({
+				gateway: resolved.gateway,
+				headers: request.headers,
+				input: payload,
+				model: model.id,
+				signal: options.signal
+			}) : await sendUniversal(request, transport, payload, openAIVendorHeaders());
+			await options.onResponse?.(responseInfo(response), model);
+			attachCorrelation(output, correlationDetails(request, response, transport));
+			await assertOk(response, {
+				model: model.id,
+				requestBodyValues: payload,
+				url: transport.url
+			});
+			if (response.body === null) throw new Error("The model returned an empty response body.");
+			stream.push({
+				partial: output,
+				type: "start"
+			});
+			if ((response.headers.get("content-type") ?? "").includes("text/event-stream")) {
+				let sawFinishReason = false;
+				let sawDone = false;
+				const decoded = withIdleDeadline(response.body, request.streamIdleTimeoutMs).pipeThrough(sseDataStream());
+				const reader = (workersAI ? decoded.pipeThrough(normalizeChatCompletionsStream(model.id, { reasoningOff: prepared.reasoningOff })) : decoded).getReader();
+				try {
+					for (;;) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						if (value === "[DONE]") {
+							sawDone = true;
+							continue;
+						}
+						let parsed;
+						try {
+							parsed = JSON.parse(value);
+						} catch {
+							continue;
+						}
+						if (parsed === null || typeof parsed !== "object") continue;
+						sawFinishReason = assembler.apply(parsed) || sawFinishReason;
+					}
+				} finally {
+					reader.releaseLock();
+				}
+				assembler.finish(sawFinishReason, sawDone);
+			} else {
+				const body = await response.json();
+				const json = workersAI ? normalizeChatCompletion(body, model.id) : body;
+				assembler.finish(assembler.apply(json), true);
+			}
+			if (options.signal?.aborted) throw new Error("Request was aborted.");
+			if (output.stopReason === "error") throw new Error(output.errorMessage ?? "The model reported an error stop reason.");
+			stream.push({
+				message: output,
+				reason: output.stopReason,
+				type: "done"
+			});
+			stream.end(output);
+		} catch (error) {
+			if (response?.body !== null && response?.body?.locked === false) response.body.cancel().catch(() => {});
+			assembler.stripScratch();
+			failStream(stream, output, error, options.signal);
+		}
+	})();
+	return stream;
+}
+//#endregion
+//#region src/models/pi-ai/models/image.ts
+/**
+* The `api` marker on image models from this provider.
+*
+* @beta This surface is in beta and may change.
+*/
+const CLOUDFLARE_AI_IMAGES_API = "cloudflare-ai-images";
+const IMAGE_OPTIONS = Symbol.for("agents.models.pi-ai.image-options");
+/** Builds the pi image model for a catalog id. */
+function buildImagesModel(modelId, options) {
+	const model = {
+		api: CLOUDFLARE_AI_IMAGES_API,
+		baseUrl: "",
+		cost: {
+			cacheRead: 0,
+			cacheWrite: 0,
+			input: 0,
+			output: 0
+		},
+		id: modelId,
+		input: ["text", "image"],
+		name: options?.name ?? modelId,
+		output: ["image"],
+		provider: CLOUDFLARE_PROVIDER_ID,
+		type: "image"
+	};
+	if (options !== void 0) Object.defineProperty(model, IMAGE_OPTIONS, {
+		configurable: true,
+		enumerable: true,
+		value: options,
+		writable: false
+	});
+	return model;
+}
+function imageOptionsOf(model) {
+	const options = model[IMAGE_OPTIONS];
+	return options !== null && typeof options === "object" ? options : void 0;
+}
+function base64ToBytes(base64) {
+	const binary = atob(base64);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+function bytesToBase64(bytes) {
+	let binary = "";
+	const chunk = 8192;
+	for (let i = 0; i < bytes.length; i += chunk) binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+	return btoa(binary);
+}
+/** Reads an image out of the run path's response, whichever shape it used. */
+async function readImage(response) {
+	const contentType = response.headers.get("content-type") ?? "";
+	if (contentType.includes("application/json")) {
+		const body = unwrapEnvelope(await response.json());
+		const record = body !== null && typeof body === "object" ? body : {};
+		if (typeof record.image === "string") return {
+			data: record.image,
+			mimeType: imageMediaTypeOf(record.image)
+		};
+		throw new Error("The image model returned JSON without an image field.");
+	}
+	const data = bytesToBase64(new Uint8Array(await response.arrayBuffer()));
+	return {
+		data,
+		mimeType: contentType.split(";")[0] || imageMediaTypeOf(data)
+	};
+}
+/**
+* Generates images with a Cloudflare catalog model. Text input parts join into
+* the prompt; the first image part, when present, is passed as the source
+* image for image-to-image models. Failures are reported through
+* `stopReason`/`errorMessage`, as pi-ai's images contract expects.
+*/
+async function generateImages(config, model, context, options) {
+	const modelOptions = imageOptionsOf(model);
+	const resolved = resolveOptions(config.providerGateway, modelOptions, void 0);
+	const prompt = context.input.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+	const source = context.input.find((part) => part.type === "image");
+	const setting = (key) => options?.[key] !== void 0 ? options[key] : modelOptions?.[key];
+	const built = buildImageInput(model.id, prompt, {
+		...setting("width") === void 0 ? {} : { width: setting("width") },
+		...setting("height") === void 0 ? {} : { height: setting("height") },
+		...setting("steps") === void 0 ? {} : { steps: setting("steps") },
+		...setting("guidance") === void 0 ? {} : { guidance: setting("guidance") },
+		...setting("negativePrompt") === void 0 ? {} : { negativePrompt: setting("negativePrompt") },
+		...setting("seed") === void 0 ? {} : { seed: setting("seed") },
+		...source === void 0 ? {} : { sourceImage: true }
+	});
+	const input = built.input;
+	const warnings = built.warnings;
+	if (!built.minimal && source !== void 0 && source.type === "image") input.image = Array.from(base64ToBytes(source.data));
+	const result = {
+		api: model.api,
+		model: model.id,
+		output: [],
+		provider: model.provider,
+		stopReason: "stop",
+		timestamp: Date.now(),
+		usage: emptyUsage()
+	};
+	try {
+		const response = await config.transport.run({
+			gateway: resolved.gateway,
+			headers: resolved.headers,
+			input,
+			model: model.id,
+			signal: options?.signal
+		});
+		await assertOk(response, {
+			model: model.id,
+			requestBodyValues: input,
+			url: config.transport.url
+		});
+		const image = await readImage(response);
+		result.output.push({
+			data: image.data,
+			mimeType: image.mimeType,
+			type: "image"
+		});
+		const requestId = response.headers.get("cf-aig-log-id");
+		if (requestId !== null) result.responseId = requestId;
+	} catch (error) {
+		result.stopReason = options?.signal?.aborted ? "aborted" : "error";
+		result.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+	}
+	if (warnings.length > 0) result.diagnostics = [{
+		details: { warnings },
+		timestamp: Date.now(),
+		type: COMPAT_DIAGNOSTIC
+	}];
+	return result;
+}
+//#endregion
+//#region src/models/pi-ai/settings.ts
+/** The pi thinking levels, for reading a caller's explicit effort. */
+const THINKING_LEVELS = [
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+function isThinkingLevel(value) {
+	return typeof value === "string" && THINKING_LEVELS.includes(value);
+}
+/**
+* Resolves a pi thinking level onto the effort a request carries.
+*
+* Workers AI is the one catalog with an effort scale of ours: its quirk table
+* declares three levels, so the run path collapses onto them. Every other
+* model keeps its own level name — the wire then applies the model's own
+* `thinkingLevelMap`, the way pi-ai's implementations do — because a table of
+* ours has no business deciding a vendor's efforts.
+*/
+function effortForLevel$1(model, level) {
+	if (level === void 0 || !model.reasoning) return void 0;
+	const clamped = clampThinkingLevel(model, level);
+	if (clamped === "off") return void 0;
+	if (model.api !== "cloudflare-ai") return clamped;
+	switch (clamped) {
+		case "minimal":
+		case "low": return "low";
+		case "medium": return "medium";
+		case "high":
+		case "xhigh":
+		case "max": return "high";
+		default: return clamped;
+	}
+}
+/** Scalars only: the gateway rejects nested metadata. */
+function scalarMetadata(metadata) {
+	if (metadata === void 0) return void 0;
+	const result = {};
+	for (const [key, value] of Object.entries(metadata)) if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") result[key] = value;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/** pi headers allow `null` to suppress a default; those are dropped here. */
+function stringHeaders(headers) {
+	if (headers === void 0) return void 0;
+	const result = {};
+	for (const [key, value] of Object.entries(headers)) if (typeof value === "string") result[key] = value;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/** The per-call layer of options, read off pi-ai's call options. */
+function callLayer(options) {
+	const layer = {};
+	const headers = stringHeaders(options.headers);
+	if (headers !== void 0) layer.headers = headers;
+	const metadata = scalarMetadata(options.metadata);
+	if (metadata !== void 0) layer.metadata = metadata;
+	if (options.sessionId !== void 0) layer.sessionAffinity = options.sessionId;
+	return layer;
+}
+function toolChoiceOf(options) {
+	const raw = options.toolChoice;
+	if (raw === "auto" || raw === "none" || raw === "required") return raw;
+	if (raw === "any") return "required";
+	if (raw !== null && typeof raw === "object") {
+		const record = raw;
+		const name = typeof record.function?.name === "string" ? record.function.name : typeof record.name === "string" ? record.name : void 0;
+		if (name !== void 0) return {
+			function: { name },
+			type: "function"
+		};
+	}
+}
+function buildRequest(model, context, options, simple, config) {
+	const modelOptions = optionsOf(model);
+	const resolved = resolveOptions(config.providerGateway, modelOptions, callLayer(options));
+	const headers = { ...resolved.headers };
+	if (resolved.sessionAffinity !== void 0 && model.api === "cloudflare-ai") headers["x-session-affinity"] = resolved.sessionAffinity;
+	const explicitEffort = options.reasoningEffort;
+	const reasoningEffort = resolved.reasoningEffort !== void 0 && model.api === "cloudflare-ai" ? resolved.reasoningEffort : isThinkingLevel(explicitEffort) ? effortForLevel$1(model, explicitEffort) : explicitEffort === "off" ? void 0 : typeof explicitEffort === "string" ? explicitEffort : simple ? effortForLevel$1(model, options.reasoning) : void 0;
+	return {
+		context,
+		fallback: modelOptions?.fallback ?? [],
+		headers,
+		model,
+		options,
+		reasoningEffort,
+		resolved,
+		simple,
+		streamIdleTimeoutMs: modelOptions?.streamIdleTimeoutMs ?? 3e5,
+		toolChoice: toolChoiceOf(options)
+	};
+}
+//#endregion
+//#region src/models/pi-ai/wires/anthropic.ts
+/**
+* Anthropic Messages wire: pi-ai's own Anthropic implementation, over AI
+* Gateway's universal endpoint.
+*
+* Everything about the wire — request shaping, thinking, tool use, stream
+* parsing, thinking-signature replay — is pi-ai's. It accepts a `client` whose
+* `messages.create(...).asResponse()` returns the raw HTTP response; the one
+* built here routes that call through the gateway instead of the Anthropic
+* SDK, and sets the vendor headers the SDK would otherwise have added.
+*
+* The model object is never rewritten: `api`, `provider` and `id` reach pi's
+* implementation exactly as they will be recorded on the assistant message, so
+* a later turn replaying a thinking block is recognised as the same model.
+*/
+/**
+* Maps a pi thinking level onto an Anthropic effort the way pi-ai's own
+* `streamSimple` does: the model's `thinkingLevelMap` first, then the level's
+* own name. The map is the model author's; nothing here decides it.
+*/
+function effortForLevel(model, level) {
+	const mapped = model.thinkingLevelMap?.[level];
+	if (typeof mapped === "string") return mapped;
+	switch (level) {
+		case "minimal":
+		case "low": return "low";
+		case "medium": return "medium";
+		default: return "high";
+	}
+}
+/**
+* pi-ai's `streamSimple` thinking rules, applied here because that entry point
+* insists on a credential and this transport has none. Which branch a model
+* takes is the model's own `compat.forceAdaptiveThinking`, not a rule of ours.
+*/
+function thinkingOptions(model, options) {
+	const level = options.reasoning;
+	if (level === void 0 || !model.reasoning) return { thinkingEnabled: false };
+	if (model.compat?.forceAdaptiveThinking === true) return {
+		effort: effortForLevel(model, level),
+		thinkingEnabled: true
+	};
+	const { maxTokens, thinkingBudget } = adjustMaxTokensForThinking(options.maxTokens, model.maxTokens, level, options.thinkingBudgets);
+	return {
+		maxTokens,
+		thinkingBudgetTokens: thinkingBudget,
+		thinkingEnabled: true
+	};
+}
+/** Streams an Anthropic request through pi-ai's implementation. */
+function streamAnthropic(request, transport) {
+	const { model, context, options } = request;
+	const outer = createAssistantMessageEventStream();
+	const placeholder = startMessage(model);
+	let correlation;
+	let transportError;
+	const create = (params) => ({ async asResponse() {
+		const { betas, ...vendorParams } = params;
+		const body = {
+			...vendorParams,
+			model: wireModelId(model)
+		};
+		try {
+			const response = await sendUniversal(request, transport, body, anthropicVendorHeaders(Array.isArray(betas) ? betas : []), (raw) => {
+				correlation = correlationDetails(request, raw, transport);
+			});
+			await assertOk(response, {
+				model: model.id,
+				requestBodyValues: body,
+				url: transport.url
+			});
+			if (response.body === null) return response;
+			return new Response(withIdleDeadline(response.body, request.streamIdleTimeoutMs), response);
+		} catch (error) {
+			transportError = error;
+			throw error;
+		}
+	} });
+	const client = {
+		beta: { messages: { create } },
+		messages: { create }
+	};
+	const anthropicOptions = {
+		...options,
+		...request.simple ? thinkingOptions(model, options) : {},
+		client,
+		...request.toolChoice !== void 0 ? { toolChoice: typeof request.toolChoice === "string" ? request.toolChoice === "required" ? "any" : request.toolChoice : {
+			name: request.toolChoice.function.name,
+			type: "tool"
+		} } : {}
+	};
+	(async () => {
+		try {
+			const inner = anthropicMessagesApi().stream(model, context, anthropicOptions);
+			for await (const event of inner) {
+				if (event.type === "error" && transportError !== void 0) {
+					failFrom(event.error);
+					return;
+				}
+				if (event.type === "done" || event.type === "error") {
+					const message = event.type === "done" ? event.message : event.error;
+					if (correlation !== void 0) attachCorrelation(message, correlation);
+					recordWarnings(message, ignoredWorkersAIKnobs(request));
+				}
+				outer.push(event);
+			}
+			if (transportError !== void 0) {
+				failFrom(placeholder);
+				return;
+			}
+			outer.end(await inner.result());
+		} catch (error) {
+			failStream(outer, placeholder, transportError ?? error, options.signal);
+		}
+	})();
+	/** Ends the stream with the transport's own error, keeping any content. */
+	function failFrom(message) {
+		if (correlation !== void 0) attachCorrelation(message, correlation);
+		failStream(outer, message, transportError, options.signal);
+	}
+	return outer;
+}
+//#endregion
+//#region src/models/pi-ai/wires/responses.ts
+/**
+* OpenAI Responses wire: pi-ai's own Responses converters and stream
+* processor, over AI Gateway's universal endpoint.
+*
+* Only the transport differs from talking to OpenAI directly: the body goes to
+* the gateway, which forwards it to `api.openai.com/v1/responses` with the key
+* it holds, and the raw SSE `Response` comes back. The model object is passed
+* through untouched, so the encrypted reasoning items pi replays on a later
+* turn are recognised as the same model's.
+*/
+/**
+* Providers whose tool-call ids carry OpenAI `call|item` pairing across
+* turns. This provider sanitizes ids instead, like pi-ai's own gateway
+* provider, so the set is empty.
+*/
+const TOOL_CALL_ID_PROVIDERS = /* @__PURE__ */ new Set();
+const TERMINAL_EVENTS = /* @__PURE__ */ new Set([
+	"response.completed",
+	"response.incomplete",
+	"response.failed"
+]);
+/** A level through the model's own map, or the level's own name. */
+function mappedEffort(model, effort) {
+	return model.thinkingLevelMap?.[effort] ?? effort;
+}
+/** Streams a Responses request and maps it onto pi-ai events. */
+function streamResponses(request, transport) {
+	const { model, context, options, resolved } = request;
+	const stream = createAssistantMessageEventStream();
+	const output = startMessage(model);
+	const observed = {
+		endedCleanly: false,
+		sawTerminalEvent: false
+	};
+	(async () => {
+		let response;
+		try {
+			const responsesModel = model;
+			const body = {
+				input: convertResponsesMessages(responsesModel, context, TOOL_CALL_ID_PROVIDERS),
+				model: wireModelId(model),
+				store: false,
+				stream: true
+			};
+			const tools = getCurrentTools(context.messages);
+			if (tools.length > 0) body.tools = convertResponsesTools(tools);
+			if (request.toolChoice !== void 0) body.tool_choice = typeof request.toolChoice === "string" ? request.toolChoice : {
+				name: request.toolChoice.function.name,
+				type: "function"
+			};
+			if (options.maxTokens !== void 0) body.max_output_tokens = Math.max(options.maxTokens, 16);
+			if (options.temperature !== void 0) body.temperature = options.temperature;
+			const cacheKey = clampOpenAIPromptCacheKey(resolved.sessionAffinity ?? options.sessionId);
+			if (cacheKey !== void 0) body.prompt_cache_key = cacheKey;
+			if (model.reasoning === true) {
+				body.include = ["reasoning.encrypted_content"];
+				const effort = request.reasoningEffort;
+				if (typeof effort === "string") body.reasoning = {
+					effort: mappedEffort(model, effort),
+					summary: "auto"
+				};
+				else if (model.thinkingLevelMap?.off !== null) body.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+			}
+			const sampling = options.samplingParams;
+			if (sampling !== void 0) Object.assign(body, sampling);
+			const overridden = await options.onPayload?.(body, model);
+			const payload = overridden === void 0 ? body : overridden;
+			response = await sendUniversal(request, transport, payload, openAIVendorHeaders());
+			await options.onResponse?.(responseInfo(response), model);
+			attachCorrelation(output, correlationDetails(request, response, transport));
+			recordWarnings(output, ignoredWorkersAIKnobs(request));
+			await assertOk(response, {
+				model: model.id,
+				requestBodyValues: payload,
+				url: transport.url
+			});
+			if (response.body === null) throw new Error("The model returned an empty response body.");
+			stream.push({
+				partial: output,
+				type: "start"
+			});
+			await processResponsesStream(observe(sseJson(withIdleDeadline(response.body, request.streamIdleTimeoutMs))), output, stream, responsesModel);
+			if (options.signal?.aborted) throw new Error("Request was aborted.");
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "The model reported an error stop reason.");
+			if (observed.endedCleanly && !observed.sawTerminalEvent) throw new Error("The stream ended without a terminal response event.");
+			stream.push({
+				message: output,
+				reason: output.stopReason,
+				type: "done"
+			});
+			stream.end(output);
+		} catch (error) {
+			if (response?.body !== null && response?.body?.locked === false) response.body.cancel().catch(() => {});
+			for (const block of output.content) {
+				delete block.index;
+				delete block.partialJson;
+				delete block.customInput;
+			}
+			failStream(stream, output, error, options.signal);
+		}
+	})();
+	return stream;
+	async function* observe(events) {
+		for await (const event of events) {
+			const type = event?.type;
+			if (typeof type === "string" && TERMINAL_EVENTS.has(type)) observed.sawTerminalEvent = true;
+			yield event;
+		}
+		observed.endedCleanly = true;
+	}
+}
+//#endregion
+//#region src/models/pi-ai/models/fallback.ts
+/**
+* Client-side model fallback for pi-ai streams.
+*
+* A leg is abandoned when its stream terminates with an `error` event before
+* it produced any content; the next model is tried with the same context and
+* options. Once a leg has emitted content it is committed to, and a later
+* error propagates. `start` and the block starts that may follow it carry no
+* content, so they are held back until a leg proves itself.
+*/
+/** Diagnostic type under which abandoned legs are recorded. */
+const FALLBACK_DIAGNOSTIC = "cloudflare-fallback";
+/**
+* Events that announce output without carrying any. A leg that emits only
+* these and then fails has produced nothing, so they are held back with
+* `start` until the leg proves itself.
+*/
+const PREAMBLE_EVENTS = /* @__PURE__ */ new Set([
+	"start",
+	"text_start",
+	"thinking_start",
+	"toolcall_start"
+]);
+function isAbandonable(event) {
+	return event.type === "error" && event.reason === "error";
+}
+/**
+* Runs legs in order, committing to the first one that produces output.
+*
+* The returned stream always ends. A leg that throws, a stream that rejects,
+* a leg that starts answering and then ends without a `done` or `error`
+* event, and a last leg that ends without producing anything all end it
+* with an `error` event, so a caller awaiting the result is never left
+* waiting.
+*/
+function streamWithFallback(legs, signal) {
+	const first = legs[0];
+	if (first === void 0) throw new Error("streamWithFallback needs at least one leg.");
+	const outer = createAssistantMessageEventStream();
+	const attempts = [];
+	let ended = false;
+	const end = (message) => {
+		ended = true;
+		outer.end(message);
+	};
+	const recordAttempts = (message) => {
+		message.diagnostics = [...message.diagnostics ?? [], {
+			details: jsonDetails({ attempts }),
+			timestamp: Date.now(),
+			type: FALLBACK_DIAGNOSTIC
+		}];
+	};
+	(async () => {
+		let current = first;
+		let lastError;
+		try {
+			for (const [index, leg] of legs.entries()) {
+				current = leg;
+				const isLast = index === legs.length - 1;
+				const inner = leg.start();
+				let pending = [];
+				let committed = false;
+				let finished = false;
+				for await (const event of inner) {
+					if (!committed && PREAMBLE_EVENTS.has(event.type)) {
+						pending.push(event);
+						continue;
+					}
+					if (!committed) {
+						if (event.type === "error" && isAbandonable(event) && !isLast) {
+							attempts.push({
+								errorMessage: event.error.errorMessage,
+								model: leg.model.id
+							});
+							lastError = event.error;
+							break;
+						}
+						committed = true;
+						for (const held of pending) outer.push(held);
+						pending = [];
+					}
+					if ((event.type === "done" || event.type === "error") && attempts.length > 0) recordAttempts(event.type === "done" ? event.message : event.error);
+					outer.push(event);
+					if (event.type === "done" || event.type === "error") finished = true;
+				}
+				if (finished) {
+					end(await inner.result());
+					return;
+				}
+				if (committed) throw new Error(`${leg.model.id} ended its stream without a done or error event.`);
+			}
+			if (lastError !== void 0) {
+				recordAttempts(lastError);
+				outer.push({
+					error: lastError,
+					reason: "error",
+					type: "error"
+				});
+				end(lastError);
+				return;
+			}
+			throw new Error(`${current.model.id} ended its stream without output.`);
+		} catch (error) {
+			if (ended) return;
+			const message = startMessage(current.model);
+			if (attempts.length > 0) recordAttempts(message);
+			ended = true;
+			failStream(outer, message, error, signal);
+		}
+	})();
+	return outer;
+}
+//#endregion
+//#region src/models/pi-ai/models/language.ts
+/**
+* The pi-ai language dispatcher: picks the wire from the model's own `api`
+* marker and runs the request through the transport, with client-side fallback
+* across models.
+*
+* The `api` is the model author's declaration, not a guess of ours: Workers AI
+* models carry {@link CLOUDFLARE_AI_API} and run on `env.AI.run`; every other
+* model carries whatever protocol its registry says it speaks, and goes to AI
+* Gateway's universal endpoint.
+*/
+/** A stream that fails immediately, for a model this provider cannot route. */
+function failedStream(request, error) {
+	const stream = createAssistantMessageEventStream();
+	failStream(stream, startMessage(request.model), error, request.options.signal);
+	return stream;
+}
+function dispatchOne(request, transport) {
+	switch (request.model.api) {
+		case CLOUDFLARE_AI_API:
+		case "openai-completions": return streamCompletions(request, transport);
+		case "anthropic-messages": return streamAnthropic(request, transport);
+		case "openai-responses": return streamResponses(request, transport);
+		default: return failedStream(request, /* @__PURE__ */ new TypeError(`agents/models/pi-ai cannot route the "${request.model.api}" API. AI Gateway serves anthropic-messages, openai-responses and openai-completions models; Workers AI models use "${CLOUDFLARE_AI_API}".`));
+	}
+}
+/**
+* The options a fallback leg inherits from the chain: the transport bag, and
+* nothing that describes a model.
+*
+* `name`, `cost`, `contextWindow`, `maxTokens`, `reasoning` and `input` were
+* written about the model they were written on — a leg has its own, from pi's
+* registry — and inheriting them bills the leg's answer at the primary's
+* prices. The leg's own `fallback` is dropped for the same reason `ai()`
+* expands a chain once: a leg is already part of one.
+*/
+function legOptions(options) {
+	if (options === void 0) return void 0;
+	const { fallback: _fallback, name: _name, cost: _cost, contextWindow: _contextWindow, maxTokens: _maxTokens, reasoning: _reasoning, input: _input, ...rest } = options;
+	return rest;
+}
+/** A leg may be given as a Workers AI id or as a model of any kind. */
+function legModel(leg, options) {
+	if (typeof leg === "string") return leg.startsWith("@cf/") ? buildWorkersAIModel(leg, options) : buildGatewayModel(leg, options);
+	const own = optionsOf(leg);
+	const inherited = gatewayLayerOf(options);
+	return withOptions(leg, mergeModelOptions(own, Object.keys(inherited).length > 0 ? inherited : void 0));
+}
+/**
+* Builds pi-ai's `stream` and `streamSimple` for one provider instance. Any
+* model reaches them — this provider's own, or one the caller built from their
+* registry and handed to `ai(model)` — and dispatches on its `api`.
+*/
+function createStreams(config) {
+	const run = (model, context, options, simple) => {
+		const callOptions = options ?? {};
+		const primary = buildRequest(model, context, callOptions, simple, config);
+		if (primary.fallback.length === 0) return dispatchOne(primary, config.transport);
+		const shared = legOptions(optionsOf(model));
+		return streamWithFallback([{
+			model,
+			start: () => dispatchOne(primary, config.transport)
+		}, ...primary.fallback.map((leg) => {
+			const legTarget = legModel(leg, shared);
+			return {
+				model: legTarget,
+				start: () => dispatchOne(buildRequest(legTarget, context, callOptions, simple, config), config.transport)
+			};
+		})], callOptions.signal);
+	};
+	return {
+		stream: (model, context, options) => run(model, context, options, false),
+		streamSimple: (model, context, options) => run(model, context, options, true)
+	};
+}
+//#endregion
+//#region src/models/pi-ai/index.ts
+/**
+* `agents/models/pi-ai` — Cloudflare's AI as a pi-ai provider, with the same
+* shape as `agents/models/ai-sdk`.
+*
+* One rule decides everything here: **Workers AI is the catalog Cloudflare
+* keeps; every other vendor is pi-ai's.** So there are two call forms, and no
+* third:
+*
+* ```ts
+* import { createAI } from "agents/models/pi-ai";
+* import { getBuiltinModel } from "@earendil-works/pi-ai/providers/all";
+*
+* const ai = createAI({ binding: env.AI, id: "prod" });
+*
+* ai("@cf/zai-org/glm-4.7-flash");                     // Workers AI: ours
+* ai(getBuiltinModel("anthropic", "claude-opus-4-8")); // theirs, our transport
+* ai("anthropic/claude-opus-4-8");                     // same, via pi's catalog
+* ```
+*
+* Workers AI runs on `env.AI.run` with Cloudflare's own compat layer. Every
+* other model goes to AI Gateway's universal endpoint, which forwards the
+* vendor's own request to the vendor with the key the gateway holds — so no
+* provider key, and no vendor wire format, lives in your Worker. The model's
+* metadata (`api`, `compat`, `thinkingLevelMap`, cost, limits) is whatever its
+* own registry says, and pi-ai's converters and stream processors do the rest.
+*
+* @beta Everything exported here is in beta: the surface may
+* change in a minor release while the design settles.
+*
+* @module
+*/
+/** The prefixes a bare vendor id is most often written with, for the error. */
+const VENDOR_HINTS = {
+	anthropic: "anthropic",
+	google: "google",
+	openai: "openai"
+};
+/**
+* A string that is neither a Workers AI id nor a `<slug>/<id>` this provider
+* can resolve. There is no guessing here by design: a model we cannot name
+* exactly is the caller's to construct.
+*/
+function unroutableString(specifier) {
+	const hint = VENDOR_HINTS[specifier.split("/")[0] ?? ""];
+	return /* @__PURE__ */ new TypeError(`ai("${specifier}") is not a model this provider knows. Workers AI ids start with "@cf/". A third-party model comes from its own pi-ai registry: ai(getBuiltinModel(${hint === void 0 ? "\"<provider>\"" : `"${hint}"`}, "<model id>")) from "@earendil-works/pi-ai/providers/all", or any Model object you built yourself.`);
+}
+function buildModel(target, options) {
+	for (const leg of options?.fallback ?? []) {
+		if (typeof leg !== "string" || leg.startsWith("@cf/")) continue;
+		if (!leg.includes("/")) throw unroutableString(leg);
+		buildGatewayModel(leg, void 0);
+	}
+	if (typeof target !== "string") return withOptions(target, options);
+	if (target.startsWith("@cf/")) return buildWorkersAIModel(target, options);
+	if (!target.includes("/")) throw unroutableString(target);
+	return buildGatewayModel(target, options);
+}
+/**
+* Creates a pi-ai provider over Cloudflare's AI.
+*
+* The Workers AI binding is the only way in — Workers AI models go through
+* `env.AI.run`, vendor models through `env.AI.gateway(id).run`, and there is
+* no HTTP transport and no API token. Gateway options may be given flat
+* (`{ binding, id: "prod", cacheTtl: 60 }`) or nested under `gateway`;
+* per-model options and per-call pi-ai options (`headers`, `metadata`,
+* `sessionId`) override them in that order.
+*
+* ```ts
+* const ai = createAI({ binding: env.AI, id: "prod" });
+* ai("@cf/zai-org/glm-4.7-flash");
+* ai(anthropicModel, { fallback: ["@cf/zai-org/glm-4.7-flash"] });
+* new Agent({ streamFn: ai.streamFn, initialState: { model: ai(openaiModel) } });
+* ```
+*
+* @beta This surface is in beta and may change.
+*/
+function createAI(settings) {
+	const transport = createTransport(settings);
+	const streams = createStreams({
+		providerGateway: settings,
+		transport
+	});
+	const model = ((target, options) => buildModel(target, options));
+	const provider = createProvider({
+		api: streams,
+		auth: { apiKey: {
+			name: "Cloudflare (the AI binding)",
+			resolve: async () => ({ auth: {} })
+		} },
+		id: CLOUDFLARE_PROVIDER_ID,
+		models: [...workersAIModelIds().map((id) => buildWorkersAIModel(id, void 0)), ...gatewayModelIds().map((id) => buildGatewayModel(id, void 0))],
+		name: "Cloudflare"
+	});
+	const stream = (target, context, options) => streams.stream(target, normalizeContext(context), options);
+	const streamSimple = (target, context, options) => streams.streamSimple(target, normalizeContext(context), options);
+	return Object.assign(model, {
+		complete: (target, context, options) => stream(target, context, options).result(),
+		completeSimple: (target, context, options) => streamSimple(target, context, options).result(),
+		generateImages: (target, context, options) => generateImages({
+			providerGateway: settings,
+			transport
+		}, target, context, options),
+		images: (modelId, options) => buildImagesModel(modelId, options),
+		model,
+		provider,
+		stream,
+		streamFn: streamSimple,
+		streamSimple
+	});
+}
+//#endregion
+export { CLOUDFLARE_AI_API, CLOUDFLARE_AI_IMAGES_API, CLOUDFLARE_DIAGNOSTIC, CLOUDFLARE_ERROR_DIAGNOSTIC, CLOUDFLARE_PROVIDER_ID, CloudflareAIError, FALLBACK_DIAGNOSTIC, GATEWAY_PROVIDER_NAMES, createAI };
+
+//# sourceMappingURL=index.js.map