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

package/dist/models2.mjs

@@ -0,0 +1,96 @@
+import models_default from "./models.mjs";
+import { modelCatalogSchema } from "./types.mjs";
+
+//#region src/models.ts
+/**
+* Model catalog loader.
+*
+* The bundled `models.json` is the offline default — curated entries we've
+* validated through CF AI Gateway's compat endpoint. Validated at import time
+* so any malformed entry fails startup loudly instead of silently mis-routing.
+*
+* `loadModels()` accepts any unknown value and validates it against the same
+* schema — use it for user-supplied `models` option.
+*
+* `fetchModelsFromEndpoint()` hits the OpenAI-compat `GET /v1/models` route
+* and maps the response into our schema. Right for local runtimes (Ollama /
+* LM Studio / LiteLLM) whose `/v1/models` reflects live-loaded models.
+*/
+function loadModels(source) {
+	return modelCatalogSchema.parse(source);
+}
+const DEFAULT_MODELS = loadModels(models_default);
+/**
+* Type inference from model id.
+*
+* Looks at the id casefolded. Keep the rule list small and documented — a model
+* id whose shape doesn't hint its type defaults to `chat` (the safe fallback).
+*/
+function inferTypeFromId(id) {
+	const s = id.toLowerCase();
+	if (s.includes("embedding") || s.includes("-embed") || /\bembed\b/.test(s)) return "embed";
+	if (s.includes("image") || s.includes("dall-e") || s.includes("imagen") || /\bsdxl\b/.test(s) || s.includes("flux") || s.includes("stable-diffusion")) return "image";
+	if (s.includes("sora") || s.includes("veo") || s.includes("video")) return "video";
+	return "chat";
+}
+/** Best-effort vendor inference from common id prefixes used by Ollama/LM Studio. */
+function inferVendorFromId(id) {
+	const s = id.toLowerCase();
+	if (s.startsWith("llama") || s.startsWith("meta-llama")) return "meta";
+	if (s.startsWith("qwen")) return "alibaba";
+	if (s.startsWith("gemma") || s.startsWith("gemini")) return "google";
+	if (s.startsWith("mistral") || s.startsWith("mixtral") || s.startsWith("codestral")) return "mistral";
+	if (s.startsWith("deepseek")) return "deepseek";
+	if (s.startsWith("phi")) return "microsoft";
+	if (s.startsWith("claude")) return "anthropic";
+	if (s.startsWith("gpt")) return "openai";
+	if (s.startsWith("grok")) return "xai";
+	if (s.startsWith("command") || s.startsWith("c4ai")) return "cohere";
+	if (s.startsWith("nomic")) return "nomic";
+	return null;
+}
+/**
+* Call `GET {baseURL}/models` and map into our `ModelCatalog` schema.
+*
+* The response is validated loosely — we need `data[].id` as a non-empty
+* string; everything else is best-effort inference.
+*/
+async function fetchModelsFromEndpoint(baseURL, apiKey, options = {}) {
+	const fetchImpl = options.fetchImpl ?? fetch;
+	const timeoutMs = options.timeoutMs ?? 5e3;
+	const defaultVendor = options.defaultVendor ?? "local";
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	const url = baseURL.endsWith("/") ? `${baseURL}models` : `${baseURL}/models`;
+	let raw;
+	try {
+		const response = await fetchImpl(url, {
+			signal: controller.signal,
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+				"Content-Type": "application/json"
+			}
+		});
+		if (!response.ok) throw new Error(`GET ${url} → HTTP ${response.status} ${response.statusText}`);
+		raw = await response.json();
+	} finally {
+		clearTimeout(timer);
+	}
+	const parsed = raw;
+	if (!parsed || !Array.isArray(parsed.data)) throw new Error(`Unexpected response from ${url}: missing .data[]`);
+	const entries = [];
+	for (const item of parsed.data) {
+		if (!item || typeof item.id !== "string" || item.id.length === 0) continue;
+		entries.push({
+			model: item.id,
+			nativeModelId: item.id,
+			vendor: inferVendorFromId(item.id) ?? defaultVendor,
+			type: inferTypeFromId(item.id)
+		});
+	}
+	return modelCatalogSchema.parse(entries);
+}
+
+//#endregion
+export { DEFAULT_MODELS, fetchModelsFromEndpoint, loadModels };
+//# sourceMappingURL=models2.mjs.map

package/dist/models2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"models2.mjs","names":["bundled"],"sources":["../src/models.ts"],"sourcesContent":["/**\n * Model catalog loader.\n *\n * The bundled `models.json` is the offline default — curated entries we've\n * validated through CF AI Gateway's compat endpoint. Validated at import time\n * so any malformed entry fails startup loudly instead of silently mis-routing.\n *\n * `loadModels()` accepts any unknown value and validates it against the same\n * schema — use it for user-supplied `models` option.\n *\n * `fetchModelsFromEndpoint()` hits the OpenAI-compat `GET /v1/models` route\n * and maps the response into our schema. Right for local runtimes (Ollama /\n * LM Studio / LiteLLM) whose `/v1/models` reflects live-loaded models.\n */\n\nimport bundled from \"../models.json\" with { type: \"json\" };\nimport { type ModelCatalog, type ModelEntry, type ModelType, modelCatalogSchema } from \"./types.js\";\n\nexport function loadModels(source: unknown): ModelCatalog {\n  return modelCatalogSchema.parse(source);\n}\n\nexport const DEFAULT_MODELS: ModelCatalog = loadModels(bundled);\n\n// ─── /v1/models fetcher ────────────────────────────────────────────────────\n\nexport interface FetchModelsOptions {\n  /** Applied to entries whose vendor can't be inferred from the id. */\n  defaultVendor?: string;\n  /** Fetch timeout in ms — default 5000. */\n  timeoutMs?: number;\n  /** Dependency injection for tests. */\n  fetchImpl?: typeof fetch;\n}\n\n/**\n * Type inference from model id.\n *\n * Looks at the id casefolded. Keep the rule list small and documented — a model\n * id whose shape doesn't hint its type defaults to `chat` (the safe fallback).\n */\nexport function inferTypeFromId(id: string): ModelType {\n  const s = id.toLowerCase();\n  if (s.includes(\"embedding\") || s.includes(\"-embed\") || /\\bembed\\b/.test(s)) return \"embed\";\n  if (\n    s.includes(\"image\") ||\n    s.includes(\"dall-e\") ||\n    s.includes(\"imagen\") ||\n    /\\bsdxl\\b/.test(s) ||\n    s.includes(\"flux\") ||\n    s.includes(\"stable-diffusion\")\n  )\n    return \"image\";\n  if (s.includes(\"sora\") || s.includes(\"veo\") || s.includes(\"video\")) return \"video\";\n  return \"chat\";\n}\n\n/** Best-effort vendor inference from common id prefixes used by Ollama/LM Studio. */\nexport function inferVendorFromId(id: string): string | null {\n  const s = id.toLowerCase();\n  if (s.startsWith(\"llama\") || s.startsWith(\"meta-llama\")) return \"meta\";\n  if (s.startsWith(\"qwen\")) return \"alibaba\";\n  if (s.startsWith(\"gemma\") || s.startsWith(\"gemini\")) return \"google\";\n  if (s.startsWith(\"mistral\") || s.startsWith(\"mixtral\") || s.startsWith(\"codestral\"))\n    return \"mistral\";\n  if (s.startsWith(\"deepseek\")) return \"deepseek\";\n  if (s.startsWith(\"phi\")) return \"microsoft\";\n  if (s.startsWith(\"claude\")) return \"anthropic\";\n  if (s.startsWith(\"gpt\")) return \"openai\";\n  if (s.startsWith(\"grok\")) return \"xai\";\n  if (s.startsWith(\"command\") || s.startsWith(\"c4ai\")) return \"cohere\";\n  if (s.startsWith(\"nomic\")) return \"nomic\";\n  return null;\n}\n\ninterface OpenAIModelListItem {\n  id?: string;\n  object?: string;\n  owned_by?: string;\n}\n\ninterface OpenAIModelListResponse {\n  data?: OpenAIModelListItem[];\n}\n\n/**\n * Call `GET {baseURL}/models` and map into our `ModelCatalog` schema.\n *\n * The response is validated loosely — we need `data[].id` as a non-empty\n * string; everything else is best-effort inference.\n */\nexport async function fetchModelsFromEndpoint(\n  baseURL: string,\n  apiKey: string,\n  options: FetchModelsOptions = {},\n): Promise<ModelCatalog> {\n  const fetchImpl = options.fetchImpl ?? fetch;\n  const timeoutMs = options.timeoutMs ?? 5000;\n  const defaultVendor = options.defaultVendor ?? \"local\";\n\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), timeoutMs);\n  const url = baseURL.endsWith(\"/\") ? `${baseURL}models` : `${baseURL}/models`;\n  let raw: unknown;\n  try {\n    const response = await fetchImpl(url, {\n      signal: controller.signal,\n      headers: {\n        Authorization: `Bearer ${apiKey}`,\n        \"Content-Type\": \"application/json\",\n      },\n    });\n    if (!response.ok) {\n      throw new Error(`GET ${url} → HTTP ${response.status} ${response.statusText}`);\n    }\n    raw = await response.json();\n  } finally {\n    clearTimeout(timer);\n  }\n\n  const parsed = raw as OpenAIModelListResponse;\n  if (!parsed || !Array.isArray(parsed.data)) {\n    throw new Error(`Unexpected response from ${url}: missing .data[]`);\n  }\n\n  const entries: ModelEntry[] = [];\n  for (const item of parsed.data) {\n    if (!item || typeof item.id !== \"string\" || item.id.length === 0) continue;\n    entries.push({\n      model: item.id,\n      nativeModelId: item.id,\n      vendor: inferVendorFromId(item.id) ?? defaultVendor,\n      type: inferTypeFromId(item.id),\n    });\n  }\n  // Re-validate to catch any schema drift.\n  return modelCatalogSchema.parse(entries);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,SAAgB,WAAW,QAA+B;AACxD,QAAO,mBAAmB,MAAM,OAAO;;AAGzC,MAAa,iBAA+B,WAAWA,eAAQ;;;;;;;AAmB/D,SAAgB,gBAAgB,IAAuB;CACrD,MAAM,IAAI,GAAG,aAAa;AAC1B,KAAI,EAAE,SAAS,YAAY,IAAI,EAAE,SAAS,SAAS,IAAI,YAAY,KAAK,EAAE,CAAE,QAAO;AACnF,KACE,EAAE,SAAS,QAAQ,IACnB,EAAE,SAAS,SAAS,IACpB,EAAE,SAAS,SAAS,IACpB,WAAW,KAAK,EAAE,IAClB,EAAE,SAAS,OAAO,IAClB,EAAE,SAAS,mBAAmB,CAE9B,QAAO;AACT,KAAI,EAAE,SAAS,OAAO,IAAI,EAAE,SAAS,MAAM,IAAI,EAAE,SAAS,QAAQ,CAAE,QAAO;AAC3E,QAAO;;;AAIT,SAAgB,kBAAkB,IAA2B;CAC3D,MAAM,IAAI,GAAG,aAAa;AAC1B,KAAI,EAAE,WAAW,QAAQ,IAAI,EAAE,WAAW,aAAa,CAAE,QAAO;AAChE,KAAI,EAAE,WAAW,OAAO,CAAE,QAAO;AACjC,KAAI,EAAE,WAAW,QAAQ,IAAI,EAAE,WAAW,SAAS,CAAE,QAAO;AAC5D,KAAI,EAAE,WAAW,UAAU,IAAI,EAAE,WAAW,UAAU,IAAI,EAAE,WAAW,YAAY,CACjF,QAAO;AACT,KAAI,EAAE,WAAW,WAAW,CAAE,QAAO;AACrC,KAAI,EAAE,WAAW,MAAM,CAAE,QAAO;AAChC,KAAI,EAAE,WAAW,SAAS,CAAE,QAAO;AACnC,KAAI,EAAE,WAAW,MAAM,CAAE,QAAO;AAChC,KAAI,EAAE,WAAW,OAAO,CAAE,QAAO;AACjC,KAAI,EAAE,WAAW,UAAU,IAAI,EAAE,WAAW,OAAO,CAAE,QAAO;AAC5D,KAAI,EAAE,WAAW,QAAQ,CAAE,QAAO;AAClC,QAAO;;;;;;;;AAmBT,eAAsB,wBACpB,SACA,QACA,UAA8B,EAAE,EACT;CACvB,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAM,gBAAgB,QAAQ,iBAAiB;CAE/C,MAAM,aAAa,IAAI,iBAAiB;CACxC,MAAM,QAAQ,iBAAiB,WAAW,OAAO,EAAE,UAAU;CAC7D,MAAM,MAAM,QAAQ,SAAS,IAAI,GAAG,GAAG,QAAQ,UAAU,GAAG,QAAQ;CACpE,IAAI;AACJ,KAAI;EACF,MAAM,WAAW,MAAM,UAAU,KAAK;GACpC,QAAQ,WAAW;GACnB,SAAS;IACP,eAAe,UAAU;IACzB,gBAAgB;IACjB;GACF,CAAC;AACF,MAAI,CAAC,SAAS,GACZ,OAAM,IAAI,MAAM,OAAO,IAAI,UAAU,SAAS,OAAO,GAAG,SAAS,aAAa;AAEhF,QAAM,MAAM,SAAS,MAAM;WACnB;AACR,eAAa,MAAM;;CAGrB,MAAM,SAAS;AACf,KAAI,CAAC,UAAU,CAAC,MAAM,QAAQ,OAAO,KAAK,CACxC,OAAM,IAAI,MAAM,4BAA4B,IAAI,mBAAmB;CAGrE,MAAM,UAAwB,EAAE;AAChC,MAAK,MAAM,QAAQ,OAAO,MAAM;AAC9B,MAAI,CAAC,QAAQ,OAAO,KAAK,OAAO,YAAY,KAAK,GAAG,WAAW,EAAG;AAClE,UAAQ,KAAK;GACX,OAAO,KAAK;GACZ,eAAe,KAAK;GACpB,QAAQ,kBAAkB,KAAK,GAAG,IAAI;GACtC,MAAM,gBAAgB,KAAK,GAAG;GAC/B,CAAC;;AAGJ,QAAO,mBAAmB,MAAM,QAAQ"}

package/dist/normalize.cjs

@@ -0,0 +1,49 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let _aigne_afs_ai_device = require("@aigne/afs-ai-device");
+let _aigne_afs_ai_device_catalog_json = require("@aigne/afs-ai-device/catalog.json");
+_aigne_afs_ai_device_catalog_json = require_rolldown_runtime.__toESM(_aigne_afs_ai_device_catalog_json);
+
+//#region src/normalize.ts
+/**
+* Canonical ↔ native model-id resolution for the gateway provider.
+*
+* The `/models/{id}` tree and `.actions/listModels` speak in canonical
+* ids (matching the AI Device catalog). The OpenAI SDK's `model` field
+* speaks in native ids (`{vendor}/{canonical}` for CF compat). This
+* helper resolves requested canonical ids against the configured model
+* list, using both exact matches and catalog alias lookups.
+*
+* Unknown ids pass through untouched so custom gateway deployments can
+* still invoke models the bundled catalog has no entry for — upstream
+* surfaces the error if the native id really doesn't exist.
+*/
+let sharedCatalog = null;
+function getCatalog() {
+	if (sharedCatalog) return sharedCatalog;
+	sharedCatalog = (0, _aigne_afs_ai_device.buildCatalog)(_aigne_afs_ai_device_catalog_json.default);
+	return sharedCatalog;
+}
+function lastSegment(id) {
+	const idx = id.lastIndexOf("/");
+	return idx >= 0 ? id.slice(idx + 1) : id;
+}
+/** Normalize a requested id to the canonical catalog id, or pass through. */
+function toCanonicalModel(id) {
+	if (!id) return id;
+	return getCatalog().resolveCanonicalModel(id) ?? id;
+}
+/** Find the model entry matching a requested canonical id (or alias). */
+function findModelEntry(requestedId, models) {
+	if (!requestedId) return void 0;
+	const canonical = toCanonicalModel(requestedId);
+	for (const m of models) if (m.model === canonical) return m;
+	for (const m of models) {
+		if (m.aliases?.includes(canonical) || m.aliases?.includes(requestedId)) return m;
+		if (lastSegment(m.nativeModelId) === canonical) return m;
+		if (toCanonicalModel(m.model) === canonical) return m;
+	}
+}
+
+//#endregion
+exports.findModelEntry = findModelEntry;
+exports.toCanonicalModel = toCanonicalModel;

package/dist/normalize.d.cts

@@ -0,0 +1,10 @@
+import { ModelEntry } from "./types.cjs";
+
+//#region src/normalize.d.ts
+/** Normalize a requested id to the canonical catalog id, or pass through. */
+declare function toCanonicalModel(id: string): string;
+/** Find the model entry matching a requested canonical id (or alias). */
+declare function findModelEntry(requestedId: string, models: readonly ModelEntry[]): ModelEntry | undefined;
+//#endregion
+export { findModelEntry, toCanonicalModel };
+//# sourceMappingURL=normalize.d.cts.map

package/dist/normalize.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.cts","names":[],"sources":["../src/normalize.ts"],"mappings":";;;;iBAgCgB,gBAAA,CAAiB,EAAA;;iBAMjB,cAAA,CACd,WAAA,UACA,MAAA,WAAiB,UAAA,KAChB,UAAA"}

package/dist/normalize.d.mts

@@ -0,0 +1,10 @@
+import { ModelEntry } from "./types.mjs";
+
+//#region src/normalize.d.ts
+/** Normalize a requested id to the canonical catalog id, or pass through. */
+declare function toCanonicalModel(id: string): string;
+/** Find the model entry matching a requested canonical id (or alias). */
+declare function findModelEntry(requestedId: string, models: readonly ModelEntry[]): ModelEntry | undefined;
+//#endregion
+export { findModelEntry, toCanonicalModel };
+//# sourceMappingURL=normalize.d.mts.map

package/dist/normalize.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.mts","names":[],"sources":["../src/normalize.ts"],"mappings":";;;;iBAgCgB,gBAAA,CAAiB,EAAA;;iBAMjB,cAAA,CACd,WAAA,UACA,MAAA,WAAiB,UAAA,KAChB,UAAA"}

package/dist/normalize.mjs

@@ -0,0 +1,47 @@
+import { buildCatalog } from "@aigne/afs-ai-device";
+import catalogJson from "@aigne/afs-ai-device/catalog.json" with { type: "json" };
+
+//#region src/normalize.ts
+/**
+* Canonical ↔ native model-id resolution for the gateway provider.
+*
+* The `/models/{id}` tree and `.actions/listModels` speak in canonical
+* ids (matching the AI Device catalog). The OpenAI SDK's `model` field
+* speaks in native ids (`{vendor}/{canonical}` for CF compat). This
+* helper resolves requested canonical ids against the configured model
+* list, using both exact matches and catalog alias lookups.
+*
+* Unknown ids pass through untouched so custom gateway deployments can
+* still invoke models the bundled catalog has no entry for — upstream
+* surfaces the error if the native id really doesn't exist.
+*/
+let sharedCatalog = null;
+function getCatalog() {
+	if (sharedCatalog) return sharedCatalog;
+	sharedCatalog = buildCatalog(catalogJson);
+	return sharedCatalog;
+}
+function lastSegment(id) {
+	const idx = id.lastIndexOf("/");
+	return idx >= 0 ? id.slice(idx + 1) : id;
+}
+/** Normalize a requested id to the canonical catalog id, or pass through. */
+function toCanonicalModel(id) {
+	if (!id) return id;
+	return getCatalog().resolveCanonicalModel(id) ?? id;
+}
+/** Find the model entry matching a requested canonical id (or alias). */
+function findModelEntry(requestedId, models) {
+	if (!requestedId) return void 0;
+	const canonical = toCanonicalModel(requestedId);
+	for (const m of models) if (m.model === canonical) return m;
+	for (const m of models) {
+		if (m.aliases?.includes(canonical) || m.aliases?.includes(requestedId)) return m;
+		if (lastSegment(m.nativeModelId) === canonical) return m;
+		if (toCanonicalModel(m.model) === canonical) return m;
+	}
+}
+
+//#endregion
+export { findModelEntry, toCanonicalModel };
+//# sourceMappingURL=normalize.mjs.map

package/dist/normalize.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.mjs","names":[],"sources":["../src/normalize.ts"],"sourcesContent":["/**\n * Canonical ↔ native model-id resolution for the gateway provider.\n *\n * The `/models/{id}` tree and `.actions/listModels` speak in canonical\n * ids (matching the AI Device catalog). The OpenAI SDK's `model` field\n * speaks in native ids (`{vendor}/{canonical}` for CF compat). This\n * helper resolves requested canonical ids against the configured model\n * list, using both exact matches and catalog alias lookups.\n *\n * Unknown ids pass through untouched so custom gateway deployments can\n * still invoke models the bundled catalog has no entry for — upstream\n * surfaces the error if the native id really doesn't exist.\n */\n\nimport { buildCatalog, type LoadedCatalog } from \"@aigne/afs-ai-device\";\nimport catalogJson from \"@aigne/afs-ai-device/catalog.json\" with { type: \"json\" };\nimport type { ModelEntry } from \"./types.js\";\n\nlet sharedCatalog: LoadedCatalog | null = null;\n\nfunction getCatalog(): LoadedCatalog {\n  if (sharedCatalog) return sharedCatalog;\n  sharedCatalog = buildCatalog(catalogJson as readonly unknown[]);\n  return sharedCatalog;\n}\n\nfunction lastSegment(id: string): string {\n  const idx = id.lastIndexOf(\"/\");\n  return idx >= 0 ? id.slice(idx + 1) : id;\n}\n\n/** Normalize a requested id to the canonical catalog id, or pass through. */\nexport function toCanonicalModel(id: string): string {\n  if (!id) return id;\n  return getCatalog().resolveCanonicalModel(id) ?? id;\n}\n\n/** Find the model entry matching a requested canonical id (or alias). */\nexport function findModelEntry(\n  requestedId: string,\n  models: readonly ModelEntry[],\n): ModelEntry | undefined {\n  if (!requestedId) return undefined;\n  const canonical = toCanonicalModel(requestedId);\n\n  // Fast path: exact canonical match.\n  for (const m of models) {\n    if (m.model === canonical) return m;\n  }\n\n  // Secondary: alias list, vendor-stripped, or last path segment.\n  for (const m of models) {\n    if (m.aliases?.includes(canonical) || m.aliases?.includes(requestedId)) return m;\n    if (lastSegment(m.nativeModelId) === canonical) return m;\n    const modelCanonical = toCanonicalModel(m.model);\n    if (modelCanonical === canonical) return m;\n  }\n  return undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAkBA,IAAI,gBAAsC;AAE1C,SAAS,aAA4B;AACnC,KAAI,cAAe,QAAO;AAC1B,iBAAgB,aAAa,YAAkC;AAC/D,QAAO;;AAGT,SAAS,YAAY,IAAoB;CACvC,MAAM,MAAM,GAAG,YAAY,IAAI;AAC/B,QAAO,OAAO,IAAI,GAAG,MAAM,MAAM,EAAE,GAAG;;;AAIxC,SAAgB,iBAAiB,IAAoB;AACnD,KAAI,CAAC,GAAI,QAAO;AAChB,QAAO,YAAY,CAAC,sBAAsB,GAAG,IAAI;;;AAInD,SAAgB,eACd,aACA,QACwB;AACxB,KAAI,CAAC,YAAa,QAAO;CACzB,MAAM,YAAY,iBAAiB,YAAY;AAG/C,MAAK,MAAM,KAAK,OACd,KAAI,EAAE,UAAU,UAAW,QAAO;AAIpC,MAAK,MAAM,KAAK,QAAQ;AACtB,MAAI,EAAE,SAAS,SAAS,UAAU,IAAI,EAAE,SAAS,SAAS,YAAY,CAAE,QAAO;AAC/E,MAAI,YAAY,EAAE,cAAc,KAAK,UAAW,QAAO;AAEvD,MADuB,iBAAiB,EAAE,MAAM,KACzB,UAAW,QAAO"}

package/dist/types.cjs

@@ -0,0 +1,80 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let zod = require("zod");
+
+//#region src/types.ts
+/** Shared vocabulary: the four AI Device capacity types. */
+const modelTypeSchema = zod.z.enum([
+	"chat",
+	"embed",
+	"image",
+	"video"
+]);
+/**
+* One entry in the bundled / user-supplied / remote model list.
+*
+* - `model`      — canonical id the AI Device catalog uses (e.g. "claude-haiku-4-5")
+* - `nativeModelId` — id fed to the underlying OpenAI SDK (e.g. "anthropic/claude-haiku-4-5")
+* - `vendor`     — vendor slug (openai / anthropic / google / …)
+* - `type`       — capacity type
+* - `aliases`    — extra ids users may reference
+* - `available`  — optional availability flag (default true)
+*/
+const modelEntrySchema = zod.z.object({
+	model: zod.z.string().min(1),
+	nativeModelId: zod.z.string().min(1),
+	vendor: zod.z.string().min(1),
+	type: modelTypeSchema,
+	aliases: zod.z.array(zod.z.string()).optional(),
+	available: zod.z.boolean().optional()
+});
+/** A catalog of models — same schema whether from bundled JSON or remote fetch. */
+const modelCatalogSchema = zod.z.array(modelEntrySchema);
+/**
+* Source of truth for the model list.
+*
+* - `"bundled"` (default): use the package's `models.json` + any user `models` override.
+*   Zero network dependency at startup. Right for remote gateways (CF Gateway,
+*   OpenRouter) where the operator has curated the allowlist.
+*
+* - `"endpoint"`: lazily `GET {baseURL}/models` and derive the list from the
+*   response. Right for **local runtimes** (Ollama, LM Studio, LiteLLM) where
+*   the runtime's own `/v1/models` already reflects exactly what's loaded.
+*   Falls back to bundled + user override if the endpoint fails.
+*/
+const listStrategySchema = zod.z.enum(["bundled", "endpoint"]);
+/**
+* Provider options — the `baseURL` must point at an OpenAI-compatible
+* chat/completions root (i.e. POST {baseURL}/chat/completions works).
+*
+* Example baseURLs:
+*   - https://gateway.ai.cloudflare.com/v1/{account}/{gateway}/compat
+*   - https://openrouter.ai/api/v1
+*   - https://api.openai.com/v1
+*   - http://localhost:4000/v1     (LiteLLM proxy)
+*   - http://localhost:11434/v1    (Ollama)
+*   - http://localhost:1234/v1     (LM Studio)
+*/
+const afsAIGatewayOptionsSchema = zod.z.object({
+	name: zod.z.string().default("ai-gateway"),
+	description: zod.z.string().default("AI Gateway provider — OpenAI-compatible backend surfaced as an AI Device hub. Execute inference via .actions/chat, .actions/embed, .actions/generateImage, .actions/generateVideo on any model node."),
+	baseURL: zod.z.string().meta({
+		env: ["AI_GATEWAY_BASE_URL"],
+		description: "OpenAI-compatible base URL (chat/completions will be appended by the SDK)."
+	}),
+	apiKey: zod.z.string().meta({
+		sensitive: true,
+		env: ["AI_GATEWAY_API_KEY"],
+		description: "Bearer token sent as Authorization header."
+	}),
+	listStrategy: listStrategySchema.default("bundled").describe("How to populate the model list — 'bundled' (static) or 'endpoint' (fetch /v1/models)."),
+	vendor: zod.z.string().optional().describe("Default vendor slug applied to entries discovered via listStrategy:endpoint (when no better guess from the id)."),
+	models: modelCatalogSchema.optional().describe("Bundled/override catalog. Used as the primary source for listStrategy:bundled, and as fallback for listStrategy:endpoint when the /v1/models call fails."),
+	extraHeaders: zod.z.record(zod.z.string(), zod.z.string()).optional().describe("Extra HTTP headers forwarded on every request — e.g. cf-aig-cache-ttl for Cloudflare AI Gateway."),
+	endpointTimeoutMs: zod.z.number().positive().optional().describe("Timeout (ms) for the /v1/models fetch when listStrategy:endpoint. Default 5000.")
+});
+
+//#endregion
+exports.afsAIGatewayOptionsSchema = afsAIGatewayOptionsSchema;
+exports.modelCatalogSchema = modelCatalogSchema;
+exports.modelEntrySchema = modelEntrySchema;
+exports.modelTypeSchema = modelTypeSchema;

package/dist/types.d.cts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+
+//#region src/types.d.ts
+/** Shared vocabulary: the four AI Device capacity types. */
+declare const modelTypeSchema: z.ZodEnum<{
+  chat: "chat";
+  embed: "embed";
+  image: "image";
+  video: "video";
+}>;
+type ModelType = z.infer<typeof modelTypeSchema>;
+/**
+ * One entry in the bundled / user-supplied / remote model list.
+ *
+ * - `model`      — canonical id the AI Device catalog uses (e.g. "claude-haiku-4-5")
+ * - `nativeModelId` — id fed to the underlying OpenAI SDK (e.g. "anthropic/claude-haiku-4-5")
+ * - `vendor`     — vendor slug (openai / anthropic / google / …)
+ * - `type`       — capacity type
+ * - `aliases`    — extra ids users may reference
+ * - `available`  — optional availability flag (default true)
+ */
+declare const modelEntrySchema: z.ZodObject<{
+  model: z.ZodString;
+  nativeModelId: z.ZodString;
+  vendor: z.ZodString;
+  type: z.ZodEnum<{
+    chat: "chat";
+    embed: "embed";
+    image: "image";
+    video: "video";
+  }>;
+  aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  available: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ModelEntry = z.infer<typeof modelEntrySchema>;
+/** A catalog of models — same schema whether from bundled JSON or remote fetch. */
+declare const modelCatalogSchema: z.ZodArray<z.ZodObject<{
+  model: z.ZodString;
+  nativeModelId: z.ZodString;
+  vendor: z.ZodString;
+  type: z.ZodEnum<{
+    chat: "chat";
+    embed: "embed";
+    image: "image";
+    video: "video";
+  }>;
+  aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  available: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+type ModelCatalog = z.infer<typeof modelCatalogSchema>;
+/**
+ * Provider options — the `baseURL` must point at an OpenAI-compatible
+ * chat/completions root (i.e. POST {baseURL}/chat/completions works).
+ *
+ * Example baseURLs:
+ *   - https://gateway.ai.cloudflare.com/v1/{account}/{gateway}/compat
+ *   - https://openrouter.ai/api/v1
+ *   - https://api.openai.com/v1
+ *   - http://localhost:4000/v1     (LiteLLM proxy)
+ *   - http://localhost:11434/v1    (Ollama)
+ *   - http://localhost:1234/v1     (LM Studio)
+ */
+declare const afsAIGatewayOptionsSchema: z.ZodObject<{
+  name: z.ZodDefault<z.ZodString>;
+  description: z.ZodDefault<z.ZodString>;
+  baseURL: z.ZodString;
+  apiKey: z.ZodString;
+  listStrategy: z.ZodDefault<z.ZodEnum<{
+    bundled: "bundled";
+    endpoint: "endpoint";
+  }>>;
+  vendor: z.ZodOptional<z.ZodString>;
+  models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    model: z.ZodString;
+    nativeModelId: z.ZodString;
+    vendor: z.ZodString;
+    type: z.ZodEnum<{
+      chat: "chat";
+      embed: "embed";
+      image: "image";
+      video: "video";
+    }>;
+    aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    available: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>>;
+  extraHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  endpointTimeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type AFSAIGatewayOptions = z.infer<typeof afsAIGatewayOptionsSchema>;
+type AFSAIGatewayOptionsInput = z.input<typeof afsAIGatewayOptionsSchema>;
+/** Response shape returned by `.actions/listModels`. */
+interface ListModelsResponse {
+  entries: ListModelsEntry[];
+}
+interface ListModelsEntry {
+  model: string;
+  nativeModelId: string;
+  type: ModelType;
+  vendor: string;
+  available: boolean;
+}
+//#endregion
+export { AFSAIGatewayOptions, AFSAIGatewayOptionsInput, ListModelsEntry, ListModelsResponse, ModelCatalog, ModelEntry, ModelType, afsAIGatewayOptionsSchema, modelCatalogSchema, modelEntrySchema, modelTypeSchema };
+//# sourceMappingURL=types.d.cts.map

package/dist/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;;;cAGa,eAAA,EAAe,CAAA,CAAA,OAAA;;;;;;KAChB,SAAA,GAAY,CAAA,CAAE,KAAA,QAAa,eAAA;;;;;;;AAAvC;;;;cAYa,gBAAA,EAAgB,CAAA,CAAA,SAAA;;;;;;;;;;;;;KAQjB,UAAA,GAAa,CAAA,CAAE,KAAA,QAAa,gBAAA;;cAG3B,kBAAA,EAAkB,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;KACnB,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;;;;;;;;;;;AAJ1C;;cAiCa,yBAAA,EAAyB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;KA6C1B,mBAAA,GAAsB,CAAA,CAAE,KAAA,QAAa,yBAAA;AAAA,KACrC,wBAAA,GAA2B,CAAA,CAAE,KAAA,QAAa,yBAAA;;UAGrC,kBAAA;EACf,OAAA,EAAS,eAAA;AAAA;AAAA,UAGM,eAAA;EACf,KAAA;EACA,aAAA;EACA,IAAA,EAAM,SAAA;EACN,MAAA;EACA,SAAA;AAAA"}

package/dist/types.d.mts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+
+//#region src/types.d.ts
+/** Shared vocabulary: the four AI Device capacity types. */
+declare const modelTypeSchema: z.ZodEnum<{
+  chat: "chat";
+  embed: "embed";
+  image: "image";
+  video: "video";
+}>;
+type ModelType = z.infer<typeof modelTypeSchema>;
+/**
+ * One entry in the bundled / user-supplied / remote model list.
+ *
+ * - `model`      — canonical id the AI Device catalog uses (e.g. "claude-haiku-4-5")
+ * - `nativeModelId` — id fed to the underlying OpenAI SDK (e.g. "anthropic/claude-haiku-4-5")
+ * - `vendor`     — vendor slug (openai / anthropic / google / …)
+ * - `type`       — capacity type
+ * - `aliases`    — extra ids users may reference
+ * - `available`  — optional availability flag (default true)
+ */
+declare const modelEntrySchema: z.ZodObject<{
+  model: z.ZodString;
+  nativeModelId: z.ZodString;
+  vendor: z.ZodString;
+  type: z.ZodEnum<{
+    chat: "chat";
+    embed: "embed";
+    image: "image";
+    video: "video";
+  }>;
+  aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  available: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ModelEntry = z.infer<typeof modelEntrySchema>;
+/** A catalog of models — same schema whether from bundled JSON or remote fetch. */
+declare const modelCatalogSchema: z.ZodArray<z.ZodObject<{
+  model: z.ZodString;
+  nativeModelId: z.ZodString;
+  vendor: z.ZodString;
+  type: z.ZodEnum<{
+    chat: "chat";
+    embed: "embed";
+    image: "image";
+    video: "video";
+  }>;
+  aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  available: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+type ModelCatalog = z.infer<typeof modelCatalogSchema>;
+/**
+ * Provider options — the `baseURL` must point at an OpenAI-compatible
+ * chat/completions root (i.e. POST {baseURL}/chat/completions works).
+ *
+ * Example baseURLs:
+ *   - https://gateway.ai.cloudflare.com/v1/{account}/{gateway}/compat
+ *   - https://openrouter.ai/api/v1
+ *   - https://api.openai.com/v1
+ *   - http://localhost:4000/v1     (LiteLLM proxy)
+ *   - http://localhost:11434/v1    (Ollama)
+ *   - http://localhost:1234/v1     (LM Studio)
+ */
+declare const afsAIGatewayOptionsSchema: z.ZodObject<{
+  name: z.ZodDefault<z.ZodString>;
+  description: z.ZodDefault<z.ZodString>;
+  baseURL: z.ZodString;
+  apiKey: z.ZodString;
+  listStrategy: z.ZodDefault<z.ZodEnum<{
+    bundled: "bundled";
+    endpoint: "endpoint";
+  }>>;
+  vendor: z.ZodOptional<z.ZodString>;
+  models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    model: z.ZodString;
+    nativeModelId: z.ZodString;
+    vendor: z.ZodString;
+    type: z.ZodEnum<{
+      chat: "chat";
+      embed: "embed";
+      image: "image";
+      video: "video";
+    }>;
+    aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    available: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>>;
+  extraHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  endpointTimeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type AFSAIGatewayOptions = z.infer<typeof afsAIGatewayOptionsSchema>;
+type AFSAIGatewayOptionsInput = z.input<typeof afsAIGatewayOptionsSchema>;
+/** Response shape returned by `.actions/listModels`. */
+interface ListModelsResponse {
+  entries: ListModelsEntry[];
+}
+interface ListModelsEntry {
+  model: string;
+  nativeModelId: string;
+  type: ModelType;
+  vendor: string;
+  available: boolean;
+}
+//#endregion
+export { AFSAIGatewayOptions, AFSAIGatewayOptionsInput, ListModelsEntry, ListModelsResponse, ModelCatalog, ModelEntry, ModelType, afsAIGatewayOptionsSchema, modelCatalogSchema, modelEntrySchema, modelTypeSchema };
+//# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;cAGa,eAAA,EAAe,CAAA,CAAA,OAAA;;;;;;KAChB,SAAA,GAAY,CAAA,CAAE,KAAA,QAAa,eAAA;;;;;;;AAAvC;;;;cAYa,gBAAA,EAAgB,CAAA,CAAA,SAAA;;;;;;;;;;;;;KAQjB,UAAA,GAAa,CAAA,CAAE,KAAA,QAAa,gBAAA;;cAG3B,kBAAA,EAAkB,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;KACnB,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;;;;;;;;;;;AAJ1C;;cAiCa,yBAAA,EAAyB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;KA6C1B,mBAAA,GAAsB,CAAA,CAAE,KAAA,QAAa,yBAAA;AAAA,KACrC,wBAAA,GAA2B,CAAA,CAAE,KAAA,QAAa,yBAAA;;UAGrC,kBAAA;EACf,OAAA,EAAS,eAAA;AAAA;AAAA,UAGM,eAAA;EACf,KAAA;EACA,aAAA;EACA,IAAA,EAAM,SAAA;EACN,MAAA;EACA,SAAA;AAAA"}

package/dist/types.mjs

@@ -0,0 +1,77 @@
+import { z } from "zod";
+
+//#region src/types.ts
+/** Shared vocabulary: the four AI Device capacity types. */
+const modelTypeSchema = z.enum([
+	"chat",
+	"embed",
+	"image",
+	"video"
+]);
+/**
+* One entry in the bundled / user-supplied / remote model list.
+*
+* - `model`      — canonical id the AI Device catalog uses (e.g. "claude-haiku-4-5")
+* - `nativeModelId` — id fed to the underlying OpenAI SDK (e.g. "anthropic/claude-haiku-4-5")
+* - `vendor`     — vendor slug (openai / anthropic / google / …)
+* - `type`       — capacity type
+* - `aliases`    — extra ids users may reference
+* - `available`  — optional availability flag (default true)
+*/
+const modelEntrySchema = z.object({
+	model: z.string().min(1),
+	nativeModelId: z.string().min(1),
+	vendor: z.string().min(1),
+	type: modelTypeSchema,
+	aliases: z.array(z.string()).optional(),
+	available: z.boolean().optional()
+});
+/** A catalog of models — same schema whether from bundled JSON or remote fetch. */
+const modelCatalogSchema = z.array(modelEntrySchema);
+/**
+* Source of truth for the model list.
+*
+* - `"bundled"` (default): use the package's `models.json` + any user `models` override.
+*   Zero network dependency at startup. Right for remote gateways (CF Gateway,
+*   OpenRouter) where the operator has curated the allowlist.
+*
+* - `"endpoint"`: lazily `GET {baseURL}/models` and derive the list from the
+*   response. Right for **local runtimes** (Ollama, LM Studio, LiteLLM) where
+*   the runtime's own `/v1/models` already reflects exactly what's loaded.
+*   Falls back to bundled + user override if the endpoint fails.
+*/
+const listStrategySchema = z.enum(["bundled", "endpoint"]);
+/**
+* Provider options — the `baseURL` must point at an OpenAI-compatible
+* chat/completions root (i.e. POST {baseURL}/chat/completions works).
+*
+* Example baseURLs:
+*   - https://gateway.ai.cloudflare.com/v1/{account}/{gateway}/compat
+*   - https://openrouter.ai/api/v1
+*   - https://api.openai.com/v1
+*   - http://localhost:4000/v1     (LiteLLM proxy)
+*   - http://localhost:11434/v1    (Ollama)
+*   - http://localhost:1234/v1     (LM Studio)
+*/
+const afsAIGatewayOptionsSchema = z.object({
+	name: z.string().default("ai-gateway"),
+	description: z.string().default("AI Gateway provider — OpenAI-compatible backend surfaced as an AI Device hub. Execute inference via .actions/chat, .actions/embed, .actions/generateImage, .actions/generateVideo on any model node."),
+	baseURL: z.string().meta({
+		env: ["AI_GATEWAY_BASE_URL"],
+		description: "OpenAI-compatible base URL (chat/completions will be appended by the SDK)."
+	}),
+	apiKey: z.string().meta({
+		sensitive: true,
+		env: ["AI_GATEWAY_API_KEY"],
+		description: "Bearer token sent as Authorization header."
+	}),
+	listStrategy: listStrategySchema.default("bundled").describe("How to populate the model list — 'bundled' (static) or 'endpoint' (fetch /v1/models)."),
+	vendor: z.string().optional().describe("Default vendor slug applied to entries discovered via listStrategy:endpoint (when no better guess from the id)."),
+	models: modelCatalogSchema.optional().describe("Bundled/override catalog. Used as the primary source for listStrategy:bundled, and as fallback for listStrategy:endpoint when the /v1/models call fails."),
+	extraHeaders: z.record(z.string(), z.string()).optional().describe("Extra HTTP headers forwarded on every request — e.g. cf-aig-cache-ttl for Cloudflare AI Gateway."),
+	endpointTimeoutMs: z.number().positive().optional().describe("Timeout (ms) for the /v1/models fetch when listStrategy:endpoint. Default 5000.")
+});
+
+//#endregion
+export { afsAIGatewayOptionsSchema, modelCatalogSchema, modelEntrySchema, modelTypeSchema };
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["import { z } from \"zod\";\n\n/** Shared vocabulary: the four AI Device capacity types. */\nexport const modelTypeSchema = z.enum([\"chat\", \"embed\", \"image\", \"video\"]);\nexport type ModelType = z.infer<typeof modelTypeSchema>;\n\n/**\n * One entry in the bundled / user-supplied / remote model list.\n *\n * - `model`      — canonical id the AI Device catalog uses (e.g. \"claude-haiku-4-5\")\n * - `nativeModelId` — id fed to the underlying OpenAI SDK (e.g. \"anthropic/claude-haiku-4-5\")\n * - `vendor`     — vendor slug (openai / anthropic / google / …)\n * - `type`       — capacity type\n * - `aliases`    — extra ids users may reference\n * - `available`  — optional availability flag (default true)\n */\nexport const modelEntrySchema = z.object({\n  model: z.string().min(1),\n  nativeModelId: z.string().min(1),\n  vendor: z.string().min(1),\n  type: modelTypeSchema,\n  aliases: z.array(z.string()).optional(),\n  available: z.boolean().optional(),\n});\nexport type ModelEntry = z.infer<typeof modelEntrySchema>;\n\n/** A catalog of models — same schema whether from bundled JSON or remote fetch. */\nexport const modelCatalogSchema = z.array(modelEntrySchema);\nexport type ModelCatalog = z.infer<typeof modelCatalogSchema>;\n\n/**\n * Source of truth for the model list.\n *\n * - `\"bundled\"` (default): use the package's `models.json` + any user `models` override.\n *   Zero network dependency at startup. Right for remote gateways (CF Gateway,\n *   OpenRouter) where the operator has curated the allowlist.\n *\n * - `\"endpoint\"`: lazily `GET {baseURL}/models` and derive the list from the\n *   response. Right for **local runtimes** (Ollama, LM Studio, LiteLLM) where\n *   the runtime's own `/v1/models` already reflects exactly what's loaded.\n *   Falls back to bundled + user override if the endpoint fails.\n */\nexport const listStrategySchema = z.enum([\"bundled\", \"endpoint\"]);\nexport type ListStrategy = z.infer<typeof listStrategySchema>;\n\n/**\n * Provider options — the `baseURL` must point at an OpenAI-compatible\n * chat/completions root (i.e. POST {baseURL}/chat/completions works).\n *\n * Example baseURLs:\n *   - https://gateway.ai.cloudflare.com/v1/{account}/{gateway}/compat\n *   - https://openrouter.ai/api/v1\n *   - https://api.openai.com/v1\n *   - http://localhost:4000/v1     (LiteLLM proxy)\n *   - http://localhost:11434/v1    (Ollama)\n *   - http://localhost:1234/v1     (LM Studio)\n */\nexport const afsAIGatewayOptionsSchema = z.object({\n  name: z.string().default(\"ai-gateway\"),\n  description: z\n    .string()\n    .default(\n      \"AI Gateway provider — OpenAI-compatible backend surfaced as an AI Device hub. Execute inference via .actions/chat, .actions/embed, .actions/generateImage, .actions/generateVideo on any model node.\",\n    ),\n  baseURL: z.string().meta({\n    env: [\"AI_GATEWAY_BASE_URL\"],\n    description: \"OpenAI-compatible base URL (chat/completions will be appended by the SDK).\",\n  }),\n  apiKey: z.string().meta({\n    sensitive: true,\n    env: [\"AI_GATEWAY_API_KEY\"],\n    description: \"Bearer token sent as Authorization header.\",\n  }),\n  listStrategy: listStrategySchema\n    .default(\"bundled\")\n    .describe(\n      \"How to populate the model list — 'bundled' (static) or 'endpoint' (fetch /v1/models).\",\n    ),\n  vendor: z\n    .string()\n    .optional()\n    .describe(\n      \"Default vendor slug applied to entries discovered via listStrategy:endpoint (when no better guess from the id).\",\n    ),\n  models: modelCatalogSchema\n    .optional()\n    .describe(\n      \"Bundled/override catalog. Used as the primary source for listStrategy:bundled, and as fallback for listStrategy:endpoint when the /v1/models call fails.\",\n    ),\n  extraHeaders: z\n    .record(z.string(), z.string())\n    .optional()\n    .describe(\n      \"Extra HTTP headers forwarded on every request — e.g. cf-aig-cache-ttl for Cloudflare AI Gateway.\",\n    ),\n  endpointTimeoutMs: z\n    .number()\n    .positive()\n    .optional()\n    .describe(\"Timeout (ms) for the /v1/models fetch when listStrategy:endpoint. Default 5000.\"),\n});\n\nexport type AFSAIGatewayOptions = z.infer<typeof afsAIGatewayOptionsSchema>;\nexport type AFSAIGatewayOptionsInput = z.input<typeof afsAIGatewayOptionsSchema>;\n\n/** Response shape returned by `.actions/listModels`. */\nexport interface ListModelsResponse {\n  entries: ListModelsEntry[];\n}\n\nexport interface ListModelsEntry {\n  model: string;\n  nativeModelId: string;\n  type: ModelType;\n  vendor: string;\n  available: boolean;\n}\n"],"mappings":";;;;AAGA,MAAa,kBAAkB,EAAE,KAAK;CAAC;CAAQ;CAAS;CAAS;CAAQ,CAAC;;;;;;;;;;;AAa1E,MAAa,mBAAmB,EAAE,OAAO;CACvC,OAAO,EAAE,QAAQ,CAAC,IAAI,EAAE;CACxB,eAAe,EAAE,QAAQ,CAAC,IAAI,EAAE;CAChC,QAAQ,EAAE,QAAQ,CAAC,IAAI,EAAE;CACzB,MAAM;CACN,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,UAAU;CACvC,WAAW,EAAE,SAAS,CAAC,UAAU;CAClC,CAAC;;AAIF,MAAa,qBAAqB,EAAE,MAAM,iBAAiB;;;;;;;;;;;;;AAe3D,MAAa,qBAAqB,EAAE,KAAK,CAAC,WAAW,WAAW,CAAC;;;;;;;;;;;;;AAejE,MAAa,4BAA4B,EAAE,OAAO;CAChD,MAAM,EAAE,QAAQ,CAAC,QAAQ,aAAa;CACtC,aAAa,EACV,QAAQ,CACR,QACC,uMACD;CACH,SAAS,EAAE,QAAQ,CAAC,KAAK;EACvB,KAAK,CAAC,sBAAsB;EAC5B,aAAa;EACd,CAAC;CACF,QAAQ,EAAE,QAAQ,CAAC,KAAK;EACtB,WAAW;EACX,KAAK,CAAC,qBAAqB;EAC3B,aAAa;EACd,CAAC;CACF,cAAc,mBACX,QAAQ,UAAU,CAClB,SACC,wFACD;CACH,QAAQ,EACL,QAAQ,CACR,UAAU,CACV,SACC,kHACD;CACH,QAAQ,mBACL,UAAU,CACV,SACC,2JACD;CACH,cAAc,EACX,OAAO,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC,CAC9B,UAAU,CACV,SACC,mGACD;CACH,mBAAmB,EAChB,QAAQ,CACR,UAAU,CACV,UAAU,CACV,SAAS,kFAAkF;CAC/F,CAAC"}