@aigne/afs-ai-gateway 1.12.0-beta.5

package/dist/ai-gateway.mjs

@@ -0,0 +1,1083 @@
+import { afsAIGatewayOptionsSchema } from "./types.mjs";
+import { DEFAULT_MODELS, fetchModelsFromEndpoint } from "./models2.mjs";
+import { findModelEntry, toCanonicalModel } from "./normalize.mjs";
+import { __decorate } from "./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs";
+import { AFSBaseProvider, AFSNotFoundError, Actions, Explain, List, Meta, Read, Stat, makeNsLog } from "@aigne/afs";
+import { zodParse } from "@aigne/afs/utils/zod";
+import { mergeModelResponseChunk } from "@aigne/model-base";
+import { OpenAIChatModel, OpenAIEmbeddingModel } from "@aigne/openai";
+import { joinURL } from "ufo";
+
+//#region src/ai-gateway.ts
+const log = makeNsLog("provider:ai-gateway");
+const TYPES = [
+	"chat",
+	"embed",
+	"image",
+	"video"
+];
+const TYPE_ACTION = {
+	chat: "chat",
+	embed: "embed",
+	image: "generateImage",
+	video: "generateVideo"
+};
+const CHAT_SCHEMA = {
+	type: "object",
+	properties: {
+		prompt: { type: "string" },
+		messages: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					role: { type: "string" },
+					content: { oneOf: [
+						{ type: "string" },
+						{ type: "null" },
+						{ type: "array" }
+					] },
+					tool_calls: { type: "array" },
+					tool_call_id: { type: "string" }
+				},
+				required: ["role"]
+			}
+		},
+		temperature: { type: "number" },
+		topP: { type: "number" },
+		maxTokens: { type: "number" },
+		responseFormat: { type: "object" }
+	}
+};
+const EMBED_SCHEMA = {
+	type: "object",
+	properties: {
+		input: {
+			oneOf: [{ type: "string" }, {
+				type: "array",
+				items: { type: "string" }
+			}],
+			description: "Text(s) to embed"
+		},
+		text: {
+			type: "string",
+			description: "Shorthand for single-text input"
+		}
+	}
+};
+const LIST_MODELS_SCHEMA = {
+	type: "object",
+	properties: { type: {
+		type: "string",
+		enum: [
+			"chat",
+			"embed",
+			"image",
+			"video"
+		]
+	} }
+};
+const HUB_ACTIONS = [{
+	name: "listModels",
+	description: "Return every model exposed by this hub as { entries: [{ model, nativeModelId, available, vendor, type }] }.",
+	schema: LIST_MODELS_SCHEMA
+}, {
+	name: "refresh",
+	description: "Reset client caches (noop for static bundled lists; honored for contract parity).",
+	schema: {
+		type: "object",
+		properties: {}
+	}
+}];
+/**
+* Adapt a `response_format: { type: "json_schema", ... }` payload so it
+* passes Cloudflare AI Gateway's stricter validation than vanilla OpenAI:
+*
+*   1. `strict` defaults to `true` — CF rejects requests where the field
+*      is omitted (`Field required`) and accepts only `true`
+*      (`Input should be True`).
+*   2. Every nested object in the schema gets `additionalProperties: false`
+*      and `required` listing all of its `properties` keys — OpenAI's
+*      strict mode demands this. Without it CF returns 400 like
+*      `For 'object' type, 'additionalProperties' must be explicitly set
+*      to false`.
+*
+* Both transformations are no-ops on schemas that already comply, so
+* callers who write strict-correct schemas keep working unchanged. Without
+* this normaliser scan-spam (`SPAM_JUDGE_SCHEMA`) failed every request
+* with `LLM call failed after 3 attempts` and agent-run returned
+* `{ status: "error" }`, which scan-spam translated to
+* `reason: "no result"` for every message.
+*/
+function normalizeResponseFormatForOpenAI(rf) {
+	if (!rf || typeof rf !== "object") return rf;
+	const obj = rf;
+	if (obj.type !== "json_schema") return rf;
+	const js = obj.jsonSchema;
+	if (!js || typeof js !== "object") return rf;
+	const schema = js.schema;
+	return {
+		...obj,
+		jsonSchema: {
+			...js,
+			strict: typeof js.strict === "boolean" ? js.strict : true,
+			...schema ? { schema: enforceStrictSchema(schema) } : {}
+		}
+	};
+}
+/**
+* Recursively patch a JSON schema for OpenAI strict mode:
+* - `additionalProperties: false` on every object node
+* - `required` listing every key in `properties`
+* - Strip keywords OpenAI strict rejects (`minimum`, `maximum`,
+*   `minLength`, `maxLength`, `minItems`, `maxItems`, `pattern`,
+*   `format`, `multipleOf`, `exclusiveMinimum`, `exclusiveMaximum`).
+*   These are validation hints — losing them means the model's output
+*   isn't bounds-checked server-side, but it's far better than the
+*   alternative (request fails with 400, scan-spam sees "no result"
+*   for every message). Caller-side schema validation can re-apply the
+*   bounds afterward if needed.
+*/
+const STRICT_INCOMPATIBLE_KEYWORDS = [
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"multipleOf",
+	"minLength",
+	"maxLength",
+	"pattern",
+	"format",
+	"minItems",
+	"maxItems",
+	"uniqueItems",
+	"minProperties",
+	"maxProperties"
+];
+function enforceStrictSchema(node) {
+	if (!node || typeof node !== "object" || Array.isArray(node)) return node;
+	const n = node;
+	const out = {};
+	for (const [k, v] of Object.entries(n)) {
+		if (STRICT_INCOMPATIBLE_KEYWORDS.includes(k)) continue;
+		out[k] = v;
+	}
+	if (n.type === "object" && n.properties && typeof n.properties === "object") {
+		const props = n.properties;
+		const patchedProps = {};
+		for (const [k, v] of Object.entries(props)) patchedProps[k] = enforceStrictSchema(v);
+		out.properties = patchedProps;
+		if (out.additionalProperties === void 0) out.additionalProperties = false;
+		if (!Array.isArray(out.required)) out.required = Object.keys(patchedProps);
+	}
+	if (n.type === "array" && n.items) out.items = Array.isArray(n.items) ? n.items.map((it) => enforceStrictSchema(it)) : enforceStrictSchema(n.items);
+	for (const composer of [
+		"anyOf",
+		"oneOf",
+		"allOf"
+	]) if (Array.isArray(n[composer])) out[composer] = n[composer].map((x) => enforceStrictSchema(x));
+	return out;
+}
+function inferenceError(modelName, err) {
+	const raw = err instanceof Error ? err.message : String(err);
+	return {
+		success: false,
+		error: {
+			code: "INFERENCE_ERROR",
+			message: raw.includes("fetch failed") || raw.includes("ECONNREFUSED") || raw.includes("ECONNRESET") || raw.includes("ETIMEDOUT") ? `Connection to gateway lost for ${modelName} (will retry with fresh connection)` : `Inference failed for ${modelName}: ${raw}`
+		}
+	};
+}
+const VALID_ROLES = new Set([
+	"system",
+	"user",
+	"agent",
+	"tool"
+]);
+function mapRole(role) {
+	if (role === "assistant") return "agent";
+	if (typeof role === "string" && VALID_ROLES.has(role)) return role;
+	return "user";
+}
+function blockHasCacheMarker(b) {
+	const raw = b;
+	return raw.cache_control !== void 0 || raw.cacheControl !== void 0;
+}
+function messagesHaveCacheMarkers(messages) {
+	return messages.some((m) => Array.isArray(m.content) && m.content.some(blockHasCacheMarker));
+}
+/** AIGNE role → OpenAI wire role. */
+function toOpenAIRole(role) {
+	return role === "agent" ? "assistant" : role;
+}
+/** Serialise AIGNE messages to the OpenAI-compat JSON shape, forwarding cache_control. */
+function serializeMessagesForWire(messages) {
+	return messages.map((m) => {
+		const out = {
+			role: toOpenAIRole(m.role),
+			content: typeof m.content === "string" ? m.content : m.content?.map((b) => {
+				const raw = b;
+				if (raw.type === "text") {
+					const cc = raw.cache_control ?? raw.cacheControl;
+					return {
+						type: "text",
+						text: raw.text,
+						...cc !== void 0 ? { cache_control: cc } : {}
+					};
+				}
+				if (raw.type === "url") return {
+					type: "image_url",
+					image_url: { url: raw.url }
+				};
+				if (raw.type === "file") return {
+					type: "image_url",
+					image_url: { url: `data:${raw.mimeType || "image/png"};base64,${raw.data}` }
+				};
+				return raw;
+			})
+		};
+		if (m.toolCalls) out.tool_calls = m.toolCalls.map((tc) => ({
+			...tc,
+			function: {
+				...tc.function,
+				arguments: JSON.stringify(tc.function?.arguments)
+			}
+		}));
+		if (m.toolCallId) out.tool_call_id = m.toolCallId;
+		if (m.name) out.name = m.name;
+		return out;
+	});
+}
+/** Parse an OpenAI-wire tool_calls array (string `function.arguments`) into
+*  the AIGNE `toolCalls` shape (parsed-object `function.arguments`). */
+function parseWireToolCalls(raw) {
+	if (!Array.isArray(raw) || raw.length === 0) return void 0;
+	return raw.map((tc) => {
+		const fn = tc.function;
+		const rawArgs = fn?.arguments;
+		let args = rawArgs;
+		if (typeof rawArgs === "string") try {
+			args = JSON.parse(rawArgs);
+		} catch {
+			args = rawArgs;
+		}
+		return {
+			id: tc.id,
+			type: tc.type ?? "function",
+			function: {
+				name: fn?.name,
+				arguments: args
+			}
+		};
+	});
+}
+/** Convert a `normalizeResponseFormatForOpenAI`-normalized responseFormat
+*  (AIGNE shape: `{ type: "json_schema", jsonSchema: {...} }`) into the
+*  OpenAI wire shape (`{ type: "json_schema", json_schema: {...} }`) used by
+*  the raw-fetch bypass body. Non-`json_schema` shapes (e.g. `json_object`)
+*  pass through untouched — same convention as the SDK path. */
+function toWireResponseFormat(normalized) {
+	if (!normalized || typeof normalized !== "object") return normalized;
+	const obj = normalized;
+	if (obj.type !== "json_schema") return obj;
+	return {
+		type: "json_schema",
+		json_schema: obj.jsonSchema
+	};
+}
+/** Convert an OpenAI-compat chat-completion response to the AIGNE output shape. */
+function openAiRespToOutput(data) {
+	const message = (data.choices?.[0])?.message;
+	const text = message?.content ?? null;
+	const u = data.usage;
+	const out = { text };
+	const toolCalls = parseWireToolCalls(message?.tool_calls);
+	if (toolCalls) out.toolCalls = toolCalls;
+	if (u) out.usage = {
+		inputTokens: u.prompt_tokens ?? 0,
+		outputTokens: u.completion_tokens ?? 0
+	};
+	return out;
+}
+/** OpenAI → AIGNE message shape (assistant → agent, snake_case → camelCase). */
+function normalizeMessage(msg) {
+	const out = { role: mapRole(msg.role) };
+	if (msg.content !== void 0 && msg.content !== null) out.content = msg.content;
+	const toolCalls = msg.toolCalls ?? msg.tool_calls;
+	if (toolCalls !== void 0) out.toolCalls = toolCalls;
+	const toolCallId = msg.toolCallId ?? msg.tool_call_id;
+	if (typeof toolCallId === "string") out.toolCallId = toolCallId;
+	if (typeof msg.name === "string") out.name = msg.name;
+	return out;
+}
+var AFSAIGateway = class extends AFSBaseProvider {
+	name;
+	description;
+	accessMode = "readwrite";
+	apiKey;
+	baseURL;
+	extraHeaders;
+	listStrategy;
+	defaultVendor;
+	endpointTimeoutMs;
+	/**
+	* The fallback catalog used (a) directly in bundled mode and (b) when the
+	* endpoint fetch fails in endpoint mode.
+	*/
+	fallbackModels;
+	/**
+	* Current resolved catalog. For `bundled` this is just `fallbackModels`.
+	* For `endpoint` this is `null` until the first fetch completes; subsequent
+	* access goes through `ensureModelsLoaded()`.
+	*/
+	cachedModels;
+	/** De-duplicate concurrent endpoint fetches. */
+	loadInflight = null;
+	chatCache = /* @__PURE__ */ new Map();
+	embedCache = /* @__PURE__ */ new Map();
+	constructor(options) {
+		super();
+		const parsed = zodParse(afsAIGatewayOptionsSchema, options);
+		this.name = parsed.name;
+		this.description = parsed.description;
+		this.baseURL = parsed.baseURL;
+		this.apiKey = parsed.apiKey;
+		this.extraHeaders = parsed.extraHeaders ?? {};
+		this.listStrategy = parsed.listStrategy;
+		this.defaultVendor = parsed.vendor;
+		this.endpointTimeoutMs = parsed.endpointTimeoutMs ?? 5e3;
+		this.fallbackModels = parsed.models && parsed.models.length > 0 ? parsed.models : DEFAULT_MODELS;
+		this.cachedModels = this.listStrategy === "bundled" ? this.fallbackModels : null;
+	}
+	/** Getter for current models — lazy resolves endpoint strategy on first read. */
+	async ensureModelsLoaded() {
+		if (this.cachedModels) return this.cachedModels;
+		if (!this.loadInflight) this.loadInflight = this.loadFromEndpoint();
+		try {
+			await this.loadInflight;
+		} finally {
+			this.loadInflight = null;
+		}
+		return this.cachedModels ?? this.fallbackModels;
+	}
+	async loadFromEndpoint() {
+		try {
+			this.cachedModels = await fetchModelsFromEndpoint(this.baseURL, this.apiKey, {
+				...this.defaultVendor ? { defaultVendor: this.defaultVendor } : {},
+				timeoutMs: this.endpointTimeoutMs
+			});
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			log.warn(`[ai-gateway:${this.name}] /models fetch failed, using fallback catalog: ${detail}`);
+			if (!this.cachedModels) this.cachedModels = this.fallbackModels;
+		}
+	}
+	/** Synchronous read — for routes that need the list right now. */
+	get models() {
+		return this.cachedModels ?? this.fallbackModels;
+	}
+	static manifest() {
+		return {
+			name: "ai-gateway",
+			description: "OpenAI-compatible AI gateway bridge (Cloudflare AI Gateway / OpenRouter / LiteLLM / OpenAI direct)",
+			uriTemplate: "ai-gateway://{name?}",
+			category: "ai",
+			schema: afsAIGatewayOptionsSchema,
+			tags: [
+				"ai",
+				"llm",
+				"gateway",
+				"openai-compatible",
+				"ai:hub"
+			],
+			capabilityTags: [
+				"auth:token",
+				"remote",
+				"http",
+				"rate-limited",
+				"streaming"
+			],
+			security: {
+				riskLevel: "external",
+				resourceAccess: ["internet"],
+				dataSensitivity: ["credentials"],
+				notes: ["Forwards prompts to a remote OpenAI-compatible gateway — API key authorizes usage and incurs cost."]
+			},
+			capabilities: {
+				network: { egress: true },
+				secrets: ["ai-gateway/api-key"]
+			}
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"exec",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": {
+					kind: "ai-gateway:root",
+					operations: [
+						"list",
+						"read",
+						"exec"
+					],
+					actions: ["listModels", "refresh"]
+				},
+				"/models": {
+					kind: "ai-gateway:directory",
+					operations: ["list", "read"]
+				},
+				"/models/{model}": {
+					kind: "ai-gateway:model",
+					operations: ["read", "exec"],
+					actions: [
+						"chat",
+						"embed",
+						"generateImage",
+						"generateVideo"
+					]
+				}
+			},
+			auth: {
+				type: "token",
+				env: ["AI_GATEWAY_API_KEY"]
+			},
+			bestFor: ["AI inference via OpenAI-compatible gateways"],
+			notFor: ["data storage", "model training"]
+		};
+	}
+	findModel(canonical) {
+		const hit = findModelEntry(canonical, this.models);
+		if (!hit) {
+			const avail = this.models.map((m) => m.model).slice(0, 10);
+			throw new AFSNotFoundError(joinURL("/models", canonical), `Model '${canonical}' not found. Available: ${avail.join(", ")}${this.models.length > 10 ? "…" : ""}`);
+		}
+		return hit;
+	}
+	openAIClientOptions() {
+		return Object.keys(this.extraHeaders).length > 0 ? { defaultHeaders: this.extraHeaders } : void 0;
+	}
+	getChatClient(nativeId) {
+		let m = this.chatCache.get(nativeId);
+		if (!m) {
+			const opts = this.openAIClientOptions();
+			m = new OpenAIChatModel({
+				baseURL: this.baseURL,
+				apiKey: this.apiKey,
+				model: nativeId,
+				...opts ? { clientOptions: opts } : {}
+			});
+			this.chatCache.set(nativeId, m);
+		}
+		return m;
+	}
+	getEmbedClient(nativeId) {
+		let m = this.embedCache.get(nativeId);
+		if (!m) {
+			const opts = this.openAIClientOptions();
+			m = new OpenAIEmbeddingModel({
+				baseURL: this.baseURL,
+				apiKey: this.apiKey,
+				model: nativeId,
+				...opts ? { clientOptions: opts } : {}
+			});
+			this.embedCache.set(nativeId, m);
+		}
+		return m;
+	}
+	async listRoot(_ctx) {
+		const models = await this.ensureModelsLoaded();
+		return { data: [this.buildEntry("/models", { meta: {
+			childrenCount: models.length,
+			kind: "ai-gateway:directory"
+		} })] };
+	}
+	async readRoot(_ctx) {
+		const models = await this.ensureModelsLoaded();
+		return this.buildEntry("/", {
+			content: {
+				provider: "ai-gateway",
+				baseURL: this.baseURL,
+				listStrategy: this.listStrategy,
+				modelCount: models.length
+			},
+			meta: {
+				childrenCount: 1,
+				kind: "ai-gateway:root"
+			}
+		});
+	}
+	async rootMeta(_ctx) {
+		const models = await this.ensureModelsLoaded();
+		const byType = {};
+		for (const m of models) byType[m.type] = (byType[m.type] ?? 0) + 1;
+		return this.buildEntry("/.meta", {
+			content: {
+				provider: "ai-gateway",
+				baseURL: this.baseURL,
+				description: this.description,
+				listStrategy: this.listStrategy,
+				modelCount: models.length,
+				modelsByType: byType
+			},
+			meta: { kind: "ai-gateway:root" }
+		});
+	}
+	async statRoot(_ctx) {
+		return { data: this.buildEntry("/", { meta: {
+			childrenCount: 1,
+			kind: "ai-gateway:root"
+		} }) };
+	}
+	async readCapabilities(_ctx) {
+		const operations = this.getOperationsDeclaration();
+		const manifest = {
+			schemaVersion: 1,
+			provider: this.name,
+			description: this.description || "AI Gateway provider",
+			tools: [],
+			operations,
+			actions: [{
+				description: "Hub-level actions",
+				catalog: [{
+					name: "listModels",
+					description: "List every bundled model with vendor + type metadata",
+					inputSchema: LIST_MODELS_SCHEMA
+				}, {
+					name: "refresh",
+					description: "Clear per-model SDK caches",
+					inputSchema: {
+						type: "object",
+						properties: {}
+					}
+				}],
+				discovery: {
+					pathTemplate: "/.actions",
+					note: "Hub-level actions: listModels, refresh"
+				}
+			}, {
+				description: "Model-level actions (varies by model type)",
+				catalog: [{
+					name: "chat",
+					description: "Chat inference (chat models)",
+					inputSchema: CHAT_SCHEMA
+				}, {
+					name: "embed",
+					description: "Embeddings (embed models)",
+					inputSchema: EMBED_SCHEMA
+				}],
+				discovery: {
+					pathTemplate: "/models/:canonical/.actions",
+					note: "Model-level actions depend on type. Chat models expose 'chat', embedding models expose 'embed'."
+				}
+			}]
+		};
+		return this.buildEntry("/.meta/.capabilities", {
+			content: manifest,
+			meta: {
+				kind: "afs:capabilities",
+				...operations
+			}
+		});
+	}
+	async explainRoot(_ctx) {
+		const models = await this.ensureModelsLoaded();
+		const typesWithEntries = TYPES.filter((t) => models.some((m) => m.type === t));
+		return {
+			format: "markdown",
+			content: [
+				`# ${this.name}`,
+				"",
+				this.description ?? "",
+				"",
+				`- **baseURL**: \`${this.baseURL}\``,
+				`- **listStrategy**: \`${this.listStrategy}\``,
+				`- **models**: ${models.length} (${typesWithEntries.join(", ")})`,
+				"",
+				"## Hub Contract",
+				"- `/.actions/listModels` → canonical model list",
+				"- `/models/{canonical}/.actions/chat` (or `embed`, `generateImage`, `generateVideo`)"
+			].join("\n")
+		};
+	}
+	async listRootActions(_ctx) {
+		return { data: HUB_ACTIONS.map((a) => this.buildEntry(joinURL("/.actions", a.name), {
+			content: {
+				description: a.description,
+				schema: a.schema
+			},
+			meta: { kind: "afs:executable" }
+		})) };
+	}
+	async execListModels(_ctx, args) {
+		const models = await this.ensureModelsLoaded();
+		const requested = typeof args.type === "string" ? args.type : void 0;
+		const entries = [];
+		for (const m of models) {
+			if (requested && m.type !== requested) continue;
+			entries.push({
+				model: m.model,
+				nativeModelId: m.nativeModelId,
+				type: m.type,
+				vendor: m.vendor,
+				available: m.available ?? true
+			});
+		}
+		return {
+			success: true,
+			data: { entries }
+		};
+	}
+	async execRefresh() {
+		this.chatCache.clear();
+		this.embedCache.clear();
+		let refetchError = null;
+		if (this.listStrategy === "endpoint") {
+			this.cachedModels = null;
+			try {
+				await this.ensureModelsLoaded();
+			} catch (err) {
+				refetchError = err instanceof Error ? err.message : String(err);
+			}
+		}
+		return {
+			success: true,
+			data: {
+				message: refetchError ? `Caches cleared; endpoint re-fetch failed (${refetchError})` : "Gateway caches cleared.",
+				listStrategy: this.listStrategy,
+				modelCount: this.models.length
+			}
+		};
+	}
+	async listModels(_ctx) {
+		return { data: (await this.ensureModelsLoaded()).map((m) => this.buildEntry(joinURL("/models", m.model), {
+			content: {
+				model: m.model,
+				vendor: m.vendor,
+				type: m.type,
+				nativeModelId: m.nativeModelId
+			},
+			meta: {
+				childrenCount: 2,
+				kind: "ai-gateway:model",
+				vendor: m.vendor,
+				capacity: { type: m.type }
+			}
+		})) };
+	}
+	async readModels(_ctx) {
+		const models = await this.ensureModelsLoaded();
+		return this.buildEntry("/models", {
+			content: { count: models.length },
+			meta: {
+				childrenCount: models.length,
+				kind: "ai-gateway:directory"
+			}
+		});
+	}
+	async metaModels(_ctx) {
+		const models = await this.ensureModelsLoaded();
+		return this.buildEntry("/models/.meta", {
+			content: { count: models.length },
+			meta: { kind: "ai-gateway:directory" }
+		});
+	}
+	async statModels(_ctx) {
+		const models = await this.ensureModelsLoaded();
+		return { data: this.buildEntry("/models", { meta: {
+			childrenCount: models.length,
+			kind: "ai-gateway:directory"
+		} }) };
+	}
+	async listModel(ctx) {
+		await this.ensureModelsLoaded();
+		const base = joinURL("/models", this.findModel(ctx.params.canonical).model);
+		return { data: [this.buildEntry(joinURL(base, ".meta"), { meta: { kind: "ai-gateway:model-meta" } })] };
+	}
+	async readModel(ctx) {
+		await this.ensureModelsLoaded();
+		const m = this.findModel(ctx.params.canonical);
+		return this.buildEntry(joinURL("/models", m.model), {
+			content: {
+				model: m.model,
+				nativeModelId: m.nativeModelId,
+				vendor: m.vendor,
+				type: m.type,
+				aliases: m.aliases ?? []
+			},
+			meta: {
+				childrenCount: 1,
+				kind: "ai-gateway:model",
+				vendor: m.vendor,
+				capacity: { type: m.type }
+			}
+		});
+	}
+	async metaModel(ctx) {
+		await this.ensureModelsLoaded();
+		const m = this.findModel(ctx.params.canonical);
+		return this.buildEntry(joinURL("/models", m.model, ".meta"), {
+			content: {
+				model: m.model,
+				nativeModelId: m.nativeModelId,
+				vendor: m.vendor,
+				capacity: { type: m.type },
+				aliases: m.aliases ?? [],
+				available: m.available ?? true
+			},
+			meta: { kind: "ai-gateway:model-meta" }
+		});
+	}
+	async statModel(ctx) {
+		await this.ensureModelsLoaded();
+		const m = this.findModel(ctx.params.canonical);
+		return { data: this.buildEntry(joinURL("/models", m.model), { meta: {
+			childrenCount: 1,
+			kind: "ai-gateway:model",
+			vendor: m.vendor,
+			capacity: { type: m.type }
+		} }) };
+	}
+	async explainModel(ctx) {
+		await this.ensureModelsLoaded();
+		const m = this.findModel(ctx.params.canonical);
+		const action = TYPE_ACTION[m.type];
+		return {
+			format: "markdown",
+			content: [
+				`# ${m.model}`,
+				"",
+				`Vendor: **${m.vendor}**  ·  Type: **${m.type}**`,
+				"",
+				`Native id: \`${m.nativeModelId}\``,
+				"",
+				"## Invoke",
+				`\`exec ${joinURL("/models", m.model, ".actions", action)} { … }\``
+			].join("\n")
+		};
+	}
+	async listModelActions(ctx) {
+		await this.ensureModelsLoaded();
+		const m = this.findModel(ctx.params.canonical);
+		const base = joinURL("/models", m.model, ".actions");
+		const action = TYPE_ACTION[m.type];
+		const schema = m.type === "chat" ? CHAT_SCHEMA : m.type === "embed" ? EMBED_SCHEMA : { type: "object" };
+		return { data: [this.buildEntry(joinURL(base, action), {
+			content: {
+				description: `${m.type} inference on ${m.model}`,
+				schema
+			},
+			meta: { kind: "afs:executable" }
+		})] };
+	}
+	async execChat(ctx, args) {
+		await this.ensureModelsLoaded();
+		const m = this.findModel(ctx.params.canonical);
+		if (m.type !== "chat") return {
+			success: false,
+			error: {
+				code: "INVALID_ACTION",
+				message: `Model '${m.model}' is type '${m.type}', not 'chat'.`
+			}
+		};
+		try {
+			const messages = this.buildMessages(args);
+			if (messages.length === 0) return {
+				success: false,
+				error: {
+					code: "MISSING_PARAM",
+					message: "'prompt' or 'messages' is required"
+				}
+			};
+			if (m.vendor === "anthropic" && messagesHaveCacheMarkers(messages)) return await this.rawChatFetch(m, messages, args, ctx);
+			const client = this.getChatClient(m.nativeModelId);
+			const input = { messages };
+			const modelOptions = {};
+			if (typeof args.temperature === "number") modelOptions.temperature = args.temperature;
+			if (typeof args.topP === "number") modelOptions.topP = args.topP;
+			if (Object.keys(modelOptions).length > 0) input.modelOptions = modelOptions;
+			if (args.responseFormat) input.responseFormat = normalizeResponseFormatForOpenAI(args.responseFormat);
+			if (args.tools !== void 0) input.tools = args.tools;
+			if (args.toolChoice !== void 0) input.toolChoice = args.toolChoice;
+			const onChunk = ctx.options?.onChunk;
+			if (onChunk) {
+				const output = await this.streamChat(client, input, onChunk);
+				return {
+					success: true,
+					data: this.buildChatData(m, output)
+				};
+			}
+			const result = await client.invoke(input);
+			return {
+				success: true,
+				data: this.buildChatData(m, result)
+			};
+		} catch (err) {
+			return inferenceError(m.model, err);
+		}
+	}
+	/**
+	* Drive a streaming chat completion, relaying text/thoughts deltas to
+	* `onChunk`, and return the fully-merged `ChatModelOutput` (identical to the
+	* buffered `invoke()` result). Runtime-agnostic: uses `getReader()` so it
+	* runs on the Cloudflare workerd isolate as well as Node.
+	*/
+	async streamChat(client, input, onChunk) {
+		const reader = (await client.invoke(input, { streaming: true })).getReader();
+		let merged = {};
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				const chunk = value;
+				merged = mergeModelResponseChunk(merged, chunk);
+				const textDelta = chunk.delta?.text;
+				if (textDelta?.text) onChunk({ text: textDelta.text });
+				if (textDelta?.thoughts) onChunk({ thoughts: textDelta.thoughts });
+			}
+		} finally {
+			reader.releaseLock();
+		}
+		return merged;
+	}
+	/**
+	* Raw HTTP fetch path for Anthropic models that carry prompt-cache markers.
+	* Bypasses OpenAIChatModel.contentsFromInputMessages so cache_control is not
+	* stripped before it reaches the gateway / Anthropic API.  Handles both
+	* buffered and SSE-streaming modes.
+	*/
+	async rawChatFetch(m, messages, args, ctx) {
+		const onChunk = ctx.options?.onChunk;
+		const body = {
+			model: m.nativeModelId,
+			messages: serializeMessagesForWire(messages)
+		};
+		if (typeof args.temperature === "number") body.temperature = args.temperature;
+		if (typeof args.topP === "number") body.top_p = args.topP;
+		if (args.tools !== void 0) body.tools = args.tools;
+		if (args.toolChoice !== void 0) body.tool_choice = args.toolChoice;
+		if (args.responseFormat) body.response_format = toWireResponseFormat(normalizeResponseFormatForOpenAI(args.responseFormat));
+		if (onChunk) body.stream = true;
+		let resp;
+		try {
+			resp = await fetch(`${this.baseURL}/chat/completions`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${this.apiKey}`,
+					...this.extraHeaders
+				},
+				body: JSON.stringify(body)
+			});
+		} catch (err) {
+			return inferenceError(m.model, err);
+		}
+		if (!resp.ok) {
+			const errText = await resp.text().catch(() => resp.statusText);
+			return inferenceError(m.model, /* @__PURE__ */ new Error(`HTTP ${resp.status}: ${errText}`));
+		}
+		if (onChunk) return this.streamRawChat(m, resp, onChunk);
+		try {
+			const data = await resp.json();
+			return {
+				success: true,
+				data: this.buildChatData(m, openAiRespToOutput(data))
+			};
+		} catch (err) {
+			return inferenceError(m.model, err);
+		}
+	}
+	/** Consume an OpenAI-compat SSE stream, forwarding text deltas via onChunk. */
+	async streamRawChat(m, resp, onChunk) {
+		const reader = resp.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let fullText = "";
+		let usage;
+		const toolCallsByIndex = /* @__PURE__ */ new Map();
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buffer += decoder.decode(value, { stream: true });
+				const lines = buffer.split("\n");
+				buffer = lines.pop() ?? "";
+				for (const line of lines) {
+					if (!line.startsWith("data: ")) continue;
+					const raw = line.slice(6).trim();
+					if (raw === "[DONE]") continue;
+					try {
+						const chunk = JSON.parse(raw);
+						const delta = chunk.choices?.[0]?.delta;
+						const text = delta?.content;
+						if (text) {
+							fullText += text;
+							onChunk({ text });
+						}
+						const deltaToolCalls = delta?.tool_calls;
+						if (Array.isArray(deltaToolCalls)) for (const tc of deltaToolCalls) {
+							const index = typeof tc.index === "number" ? tc.index : 0;
+							const fn = tc.function;
+							const existing = toolCallsByIndex.get(index) ?? { arguments: "" };
+							if (typeof tc.id === "string") existing.id = tc.id;
+							if (typeof tc.type === "string") existing.type = tc.type;
+							if (typeof fn?.name === "string") existing.name = fn.name;
+							if (typeof fn?.arguments === "string") existing.arguments += fn.arguments;
+							toolCallsByIndex.set(index, existing);
+						}
+						if (chunk.usage) {
+							const u = chunk.usage;
+							usage = {
+								inputTokens: u.prompt_tokens ?? 0,
+								outputTokens: u.completion_tokens ?? 0
+							};
+						}
+					} catch {}
+				}
+			}
+		} catch (err) {
+			return inferenceError(m.model, err);
+		} finally {
+			reader.releaseLock();
+		}
+		const toolCalls = parseWireToolCalls(toolCallsByIndex.size > 0 ? [...toolCallsByIndex.entries()].sort(([a], [b]) => a - b).map(([, tc]) => ({
+			id: tc.id,
+			type: tc.type ?? "function",
+			function: {
+				name: tc.name,
+				arguments: tc.arguments
+			}
+		})) : void 0);
+		return {
+			success: true,
+			data: this.buildChatData(m, {
+				text: fullText,
+				...toolCalls ? { toolCalls } : {},
+				...usage ? { usage } : {}
+			})
+		};
+	}
+	/**
+	* Build the `/.actions/chat` result `data` from a `ChatModelOutput`. Shared
+	* by the buffered and streaming paths so they can never drift. Forwards
+	* structured-output JSON + reasoning trace + tool calls + usage (without
+	* this, callers using `responseFormat: { type: "json_schema" }` lose the
+	* parsed object — caused scan-spam to log `"reason": "no result"`).
+	*/
+	buildChatData(m, output) {
+		const data = {
+			model: m.model,
+			text: output.text ?? null
+		};
+		if (output.json !== void 0) data.json = output.json;
+		if (output.thoughts !== void 0) data.thoughts = output.thoughts;
+		if (output.toolCalls) data.toolCalls = output.toolCalls;
+		if (output.usage) data.usage = output.usage;
+		return data;
+	}
+	async execEmbed(ctx, args) {
+		await this.ensureModelsLoaded();
+		const m = this.findModel(ctx.params.canonical);
+		if (m.type !== "embed") return {
+			success: false,
+			error: {
+				code: "INVALID_ACTION",
+				message: `Model '${m.model}' is type '${m.type}', not 'embed'.`
+			}
+		};
+		const input = args.input ?? args.text;
+		if (input === void 0) return {
+			success: false,
+			error: {
+				code: "MISSING_PARAM",
+				message: "'input' (or 'text') is required"
+			}
+		};
+		try {
+			const output = await this.getEmbedClient(m.nativeModelId).invoke({ input });
+			return {
+				success: true,
+				data: {
+					model: m.model,
+					embeddings: output.embeddings,
+					...output.usage ? { usage: output.usage } : {}
+				}
+			};
+		} catch (err) {
+			return inferenceError(m.model, err);
+		}
+	}
+	async execGenerateImage(ctx) {
+		await this.ensureModelsLoaded();
+		return {
+			success: false,
+			error: {
+				code: "NOT_IMPLEMENTED",
+				message: `generateImage for ${this.findModel(ctx.params.canonical).model} not supported by this provider yet.`
+			}
+		};
+	}
+	async execGenerateVideo(ctx) {
+		await this.ensureModelsLoaded();
+		return {
+			success: false,
+			error: {
+				code: "NOT_IMPLEMENTED",
+				message: `generateVideo for ${this.findModel(ctx.params.canonical).model} not supported by this provider yet.`
+			}
+		};
+	}
+	buildMessages(args) {
+		const raw = args.messages;
+		if (Array.isArray(raw)) return raw.map((m) => normalizeMessage(m));
+		if (typeof args.prompt === "string" && args.prompt.length > 0) return [{
+			role: "user",
+			content: args.prompt
+		}];
+		return [];
+	}
+};
+__decorate([List("/")], AFSAIGateway.prototype, "listRoot", null);
+__decorate([Read("/")], AFSAIGateway.prototype, "readRoot", null);
+__decorate([Meta("/")], AFSAIGateway.prototype, "rootMeta", null);
+__decorate([Stat("/")], AFSAIGateway.prototype, "statRoot", null);
+__decorate([Read("/.meta/.capabilities")], AFSAIGateway.prototype, "readCapabilities", null);
+__decorate([Explain("/")], AFSAIGateway.prototype, "explainRoot", null);
+__decorate([Actions("/")], AFSAIGateway.prototype, "listRootActions", null);
+__decorate([Actions.Exec("/", "listModels", void 0, { effect: "read" })], AFSAIGateway.prototype, "execListModels", null);
+__decorate([Actions.Exec("/", "refresh", void 0, { effect: "write" })], AFSAIGateway.prototype, "execRefresh", null);
+__decorate([List("/models")], AFSAIGateway.prototype, "listModels", null);
+__decorate([Read("/models")], AFSAIGateway.prototype, "readModels", null);
+__decorate([Meta("/models")], AFSAIGateway.prototype, "metaModels", null);
+__decorate([Stat("/models")], AFSAIGateway.prototype, "statModels", null);
+__decorate([List("/models/:canonical")], AFSAIGateway.prototype, "listModel", null);
+__decorate([Read("/models/:canonical")], AFSAIGateway.prototype, "readModel", null);
+__decorate([Meta("/models/:canonical")], AFSAIGateway.prototype, "metaModel", null);
+__decorate([Stat("/models/:canonical")], AFSAIGateway.prototype, "statModel", null);
+__decorate([Explain("/models/:canonical")], AFSAIGateway.prototype, "explainModel", null);
+__decorate([Actions("/models/:canonical")], AFSAIGateway.prototype, "listModelActions", null);
+__decorate([Actions.Exec("/models/:canonical", "chat", void 0, {
+	effect: "read",
+	billable: true
+})], AFSAIGateway.prototype, "execChat", null);
+__decorate([Actions.Exec("/models/:canonical", "embed", void 0, {
+	effect: "read",
+	billable: true
+})], AFSAIGateway.prototype, "execEmbed", null);
+__decorate([Actions.Exec("/models/:canonical", "generateImage", void 0, {
+	effect: "read",
+	billable: true
+})], AFSAIGateway.prototype, "execGenerateImage", null);
+__decorate([Actions.Exec("/models/:canonical", "generateVideo", void 0, {
+	effect: "read",
+	billable: true
+})], AFSAIGateway.prototype, "execGenerateVideo", null);
+
+//#endregion
+export { AFSAIGateway };
+//# sourceMappingURL=ai-gateway.mjs.map