workers-ai-provider 3.1.13 → 3.2.0

package/dist/gateway-provider-1USFWm7c.mjs

@@ -0,0 +1,583 @@
+//#region \0@oxc-project+runtime@0.135.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.135.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.135.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.135.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region src/errors.ts
+/** Map an HTTP status to a {@link GatewayErrorCode} + recoverability hint. */
+function classifyStatus(status) {
+	if (status === 401 || status === 403) return {
+		code: "auth",
+		recoverable: false
+	};
+	if (status === 429) return {
+		code: "rate-limit",
+		recoverable: true
+	};
+	if (status === 404) return {
+		code: "not-found",
+		recoverable: false
+	};
+	if (status === 400 || status === 422) return {
+		code: "bad-request",
+		recoverable: false
+	};
+	if (status >= 500) return {
+		code: "provider-error",
+		recoverable: true
+	};
+	return {
+		code: "unknown",
+		recoverable: false
+	};
+}
+/** Best-effort extraction of a human message from a CF/provider error envelope. */
+function extractErrorMessage(raw) {
+	if (typeof raw === "string") {
+		const trimmed = raw.trim();
+		if (!trimmed) return void 0;
+		try {
+			return extractErrorMessage(JSON.parse(trimmed));
+		} catch {
+			return trimmed.slice(0, 500);
+		}
+	}
+	if (!raw || typeof raw !== "object") return void 0;
+	const obj = raw;
+	if (Array.isArray(obj.errors) && obj.errors.length > 0) {
+		const first = obj.errors[0];
+		if (typeof first?.message === "string") return first.message;
+	}
+	if (obj.error && typeof obj.error === "object") {
+		const err = obj.error;
+		if (typeof err.message === "string") return err.message;
+	}
+	if (typeof obj.error === "string") return obj.error;
+	if (typeof obj.message === "string") return obj.message;
+}
+/** A single dispatch failure through AI Gateway (run or gateway path). */
+var WorkersAIGatewayError = class WorkersAIGatewayError extends Error {
+	constructor(code, message, opts = {}) {
+		super(message);
+		_defineProperty(this, "code", void 0);
+		_defineProperty(this, "recoverable", void 0);
+		_defineProperty(this, "status", void 0);
+		_defineProperty(this, "context", void 0);
+		_defineProperty(this, "raw", void 0);
+		_defineProperty(this, "cause", void 0);
+		this.name = "WorkersAIGatewayError";
+		this.code = code;
+		this.recoverable = opts.recoverable ?? false;
+		this.status = opts.status ?? null;
+		this.context = opts.context ?? {};
+		this.raw = opts.raw;
+		this.cause = opts.cause;
+	}
+	/**
+	* Classify an arbitrary thrown value. Understands AI SDK `APICallError`
+	* (reads `statusCode` / `responseBody` / `isRetryable`); falls back to a
+	* recoverable `gateway-error` for transport/connection failures so a fallback
+	* chain keeps trying.
+	*/
+	static fromUnknown(e) {
+		if (e instanceof WorkersAIGatewayError) return e;
+		const obj = e && typeof e === "object" ? e : {};
+		const status = typeof obj.statusCode === "number" ? obj.statusCode : null;
+		const responseBody = typeof obj.responseBody === "string" ? obj.responseBody : void 0;
+		if (status !== null) {
+			const classified = classifyStatus(status);
+			const recoverable = typeof obj.isRetryable === "boolean" ? obj.isRetryable : classified.recoverable;
+			const message = extractErrorMessage(responseBody) ?? (e instanceof Error ? e.message : `Gateway dispatch failed (HTTP ${status}).`);
+			let raw = responseBody;
+			try {
+				raw = responseBody ? JSON.parse(responseBody) : responseBody;
+			} catch {}
+			return new WorkersAIGatewayError(classified.code, message, {
+				recoverable,
+				status,
+				raw,
+				cause: e
+			});
+		}
+		return new WorkersAIGatewayError("gateway-error", e instanceof Error ? e.message : String(e), {
+			recoverable: true,
+			cause: e
+		});
+	}
+	/** Build from an HTTP `Response` (reads the body for the envelope). */
+	static async fromResponse(resp, context = {}) {
+		const text = await resp.text().catch(() => "");
+		const { code, recoverable } = classifyStatus(resp.status);
+		const message = extractErrorMessage(text) ?? `Gateway dispatch failed (HTTP ${resp.status}).`;
+		let raw = text;
+		try {
+			raw = text ? JSON.parse(text) : text;
+		} catch {}
+		return new WorkersAIGatewayError(code, message, {
+			recoverable,
+			status: resp.status,
+			raw,
+			context: {
+				...context,
+				status: resp.status,
+				logId: resp.headers.get("cf-aig-log-id"),
+				runId: resp.headers.get("cf-aig-run-id")
+			}
+		});
+	}
+};
+/** Every model in a client-side fallback chain failed. */
+var WorkersAIFallbackError = class extends Error {
+	constructor(attempts, message) {
+		const tried = attempts.map((a) => a.model).join(" → ");
+		super(message ?? `All fallback models failed: ${tried}.`);
+		_defineProperty(this, "attempts", void 0);
+		this.name = "WorkersAIFallbackError";
+		this.attempts = attempts;
+	}
+	/** The last (most recent) attempt's error, if any. */
+	get lastError() {
+		for (let i = this.attempts.length - 1; i >= 0; i--) {
+			const e = this.attempts[i].error;
+			if (e) return e;
+		}
+	}
+};
+//#endregion
+//#region src/gateway-providers.ts
+/** Strip a leading `https://<host>/` prefix, leaving the endpoint path + query. */
+function hostStrip(pattern) {
+	return (url) => url.replace(pattern, "");
+}
+const OPENAI_HOST = /^https:\/\/api\.openai\.com\//;
+const ANTHROPIC_HOST = /^https:\/\/api\.anthropic\.com\//;
+const GOOGLE_HOST = /^https:\/\/generativelanguage\.googleapis\.com\//;
+const VERTEX_HOST = /^https:\/\/(?:[a-z0-9-]+-)?aiplatform\.googleapis\.com\//;
+const XAI_HOST = /^https:\/\/api\.x\.ai\//;
+const GROQ_HOST = /^https:\/\/api\.groq\.com\/openai\/v1\//;
+const DEEPSEEK_HOST = /^https:\/\/api\.deepseek\.com\//;
+const MISTRAL_HOST = /^https:\/\/api\.mistral\.ai\//;
+const PERPLEXITY_HOST = /^https:\/\/api\.perplexity\.ai\//;
+const CEREBRAS_HOST = /^https:\/\/api\.cerebras\.ai\//;
+const OPENROUTER_HOST = /^https:\/\/openrouter\.ai\/api\//;
+const FIREWORKS_HOST = /^https:\/\/api\.fireworks\.ai\/inference\/v1\//;
+const COHERE_HOST = /^https:\/\/api\.cohere\.(?:com|ai)\//;
+const REPLICATE_HOST = /^https:\/\/api\.replicate\.com\//;
+const HUGGINGFACE_HOST = /^https:\/\/api-inference\.huggingface\.co\/models\//;
+const CARTESIA_HOST = /^https:\/\/api\.cartesia\.ai\//;
+const FAL_HOST = /^https:\/\/fal\.run\//;
+const IDEOGRAM_HOST = /^https:\/\/api\.ideogram\.ai\//;
+const DEEPGRAM_HOST = /^https:\/\/api\.deepgram\.com\//;
+const ELEVENLABS_HOST = /^https:\/\/api\.elevenlabs\.io\//;
+const GROK_KEY = "grok";
+const BEDROCK_HOST = /^https:\/\/bedrock-runtime\.(?<region>[^.]+)\.amazonaws\.com\//;
+function bedrockTransform(url) {
+	const m = url.match(/^https:\/\/bedrock-runtime\.(?<region>[^.]+)\.amazonaws\.com\/(?<rest>.*)$/);
+	if (!m?.groups) return url;
+	const { region, rest } = m.groups;
+	if (!region || rest === void 0) return url;
+	return `bedrock-runtime/${region}/${rest}`;
+}
+const AZURE_HOST = /^https:\/\/(?<resource>[^.]+)\.openai\.azure\.com\/openai\/deployments\/(?<deployment>[^/]+)\/(?<rest>.*)$/;
+function azureTransform(url) {
+	const m = url.match(AZURE_HOST);
+	if (!m?.groups) return url;
+	const { resource, deployment, rest } = m.groups;
+	if (!resource || !deployment || !rest) return url;
+	return `${resource}/${deployment}/${rest}`;
+}
+/**
+* The provider table. Order matters only for `detectProviderByUrl` (first match
+* wins); slugs are looked up by `resolverKey`.
+*/
+const GATEWAY_PROVIDERS = [
+	{
+		resolverKey: "openai",
+		gatewayProviderId: "openai",
+		wireFormat: "openai",
+		runCatalog: true,
+		billing: "unified",
+		authHeaders: ["authorization"],
+		hostPattern: OPENAI_HOST,
+		transformEndpoint: hostStrip(OPENAI_HOST)
+	},
+	{
+		resolverKey: "anthropic",
+		gatewayProviderId: "anthropic",
+		wireFormat: "anthropic",
+		runWireFormat: "anthropic",
+		runCatalog: true,
+		billing: "unified",
+		authHeaders: ["x-api-key", "authorization"],
+		hostPattern: ANTHROPIC_HOST,
+		transformEndpoint: hostStrip(ANTHROPIC_HOST)
+	},
+	{
+		resolverKey: "google",
+		gatewayProviderId: "google-ai-studio",
+		wireFormat: "google",
+		runCatalog: true,
+		billing: "unified",
+		authHeaders: ["x-goog-api-key", "authorization"],
+		hostPattern: GOOGLE_HOST,
+		transformEndpoint: hostStrip(GOOGLE_HOST)
+	},
+	{
+		resolverKey: "xai",
+		gatewayProviderId: GROK_KEY,
+		wireFormat: "openai",
+		baseURL: "https://api.x.ai/v1",
+		runCatalog: true,
+		billing: "unified",
+		authHeaders: ["authorization"],
+		hostPattern: XAI_HOST,
+		transformEndpoint: hostStrip(XAI_HOST)
+	},
+	{
+		resolverKey: "groq",
+		gatewayProviderId: "groq",
+		wireFormat: "openai",
+		baseURL: "https://api.groq.com/openai/v1",
+		runCatalog: true,
+		billing: "unified",
+		authHeaders: ["authorization"],
+		hostPattern: GROQ_HOST,
+		transformEndpoint: hostStrip(GROQ_HOST)
+	},
+	{
+		resolverKey: "alibaba",
+		gatewayProviderId: "alibaba",
+		wireFormat: "openai",
+		runCatalog: true,
+		gatewayPath: false,
+		billing: "unified",
+		authHeaders: ["authorization"]
+	},
+	{
+		resolverKey: "minimax",
+		gatewayProviderId: "minimax",
+		wireFormat: "openai",
+		runCatalog: true,
+		gatewayPath: false,
+		billing: "unified",
+		authHeaders: ["authorization"]
+	},
+	{
+		resolverKey: "google-vertex",
+		gatewayProviderId: "google-vertex-ai",
+		runCatalog: false,
+		billing: "unified",
+		authHeaders: ["authorization"],
+		hostPattern: VERTEX_HOST,
+		transformEndpoint: hostStrip(VERTEX_HOST)
+	},
+	{
+		resolverKey: "deepseek",
+		gatewayProviderId: "deepseek",
+		wireFormat: "openai",
+		baseURL: "https://api.deepseek.com",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"],
+		hostPattern: DEEPSEEK_HOST,
+		transformEndpoint: hostStrip(DEEPSEEK_HOST)
+	},
+	{
+		resolverKey: "mistral",
+		gatewayProviderId: "mistral",
+		wireFormat: "openai",
+		baseURL: "https://api.mistral.ai/v1",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"],
+		hostPattern: MISTRAL_HOST,
+		transformEndpoint: hostStrip(MISTRAL_HOST)
+	},
+	{
+		resolverKey: "perplexity",
+		gatewayProviderId: "perplexity-ai",
+		wireFormat: "openai",
+		baseURL: "https://api.perplexity.ai",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"],
+		hostPattern: PERPLEXITY_HOST,
+		transformEndpoint: hostStrip(PERPLEXITY_HOST)
+	},
+	{
+		resolverKey: "cerebras",
+		gatewayProviderId: "cerebras",
+		wireFormat: "openai",
+		baseURL: "https://api.cerebras.ai/v1",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"],
+		hostPattern: CEREBRAS_HOST,
+		transformEndpoint: hostStrip(CEREBRAS_HOST)
+	},
+	{
+		resolverKey: "openrouter",
+		gatewayProviderId: "openrouter",
+		wireFormat: "openai",
+		baseURL: "https://openrouter.ai/api/v1",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"],
+		hostPattern: OPENROUTER_HOST,
+		transformEndpoint: hostStrip(OPENROUTER_HOST)
+	},
+	{
+		resolverKey: "fireworks",
+		gatewayProviderId: "fireworks",
+		wireFormat: "openai",
+		baseURL: "https://api.fireworks.ai/inference/v1",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"],
+		hostPattern: FIREWORKS_HOST,
+		transformEndpoint: hostStrip(FIREWORKS_HOST)
+	},
+	{
+		resolverKey: "cohere",
+		gatewayProviderId: "cohere",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"],
+		hostPattern: COHERE_HOST,
+		transformEndpoint: hostStrip(COHERE_HOST)
+	},
+	{
+		resolverKey: "baseten",
+		gatewayProviderId: "baseten",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"]
+	},
+	{
+		resolverKey: "parallel",
+		gatewayProviderId: "parallel",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization", "x-api-key"]
+	},
+	{
+		resolverKey: "azure-openai",
+		gatewayProviderId: "azure-openai",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["api-key", "authorization"],
+		hostPattern: AZURE_HOST,
+		transformEndpoint: azureTransform
+	},
+	{
+		resolverKey: "aws-bedrock",
+		gatewayProviderId: "aws-bedrock",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"],
+		hostPattern: BEDROCK_HOST,
+		transformEndpoint: bedrockTransform
+	},
+	{
+		resolverKey: "huggingface",
+		gatewayProviderId: "huggingface",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"],
+		hostPattern: HUGGINGFACE_HOST,
+		transformEndpoint: hostStrip(HUGGINGFACE_HOST)
+	},
+	{
+		resolverKey: "replicate",
+		gatewayProviderId: "replicate",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"],
+		hostPattern: REPLICATE_HOST,
+		transformEndpoint: hostStrip(REPLICATE_HOST)
+	},
+	{
+		resolverKey: "fal",
+		gatewayProviderId: "fal",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"],
+		hostPattern: FAL_HOST,
+		transformEndpoint: hostStrip(FAL_HOST)
+	},
+	{
+		resolverKey: "ideogram",
+		gatewayProviderId: "ideogram",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization"],
+		hostPattern: IDEOGRAM_HOST,
+		transformEndpoint: hostStrip(IDEOGRAM_HOST)
+	},
+	{
+		resolverKey: "cartesia",
+		gatewayProviderId: "cartesia",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization", "x-api-key"],
+		hostPattern: CARTESIA_HOST,
+		transformEndpoint: hostStrip(CARTESIA_HOST)
+	},
+	{
+		resolverKey: "deepgram",
+		gatewayProviderId: "deepgram",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["authorization", "token"],
+		hostPattern: DEEPGRAM_HOST,
+		transformEndpoint: hostStrip(DEEPGRAM_HOST)
+	},
+	{
+		resolverKey: "elevenlabs",
+		gatewayProviderId: "elevenlabs",
+		runCatalog: false,
+		billing: "byok",
+		authHeaders: ["xi-api-key", "authorization"],
+		hostPattern: ELEVENLABS_HOST,
+		transformEndpoint: hostStrip(ELEVENLABS_HOST)
+	}
+];
+/** Aliases that map a friendly slug prefix to a canonical `resolverKey`. */
+const RESOLVER_ALIASES = {
+	grok: "xai",
+	"google-ai-studio": "google",
+	"google-vertex-ai": "google-vertex",
+	bedrock: "aws-bedrock",
+	azure: "azure-openai"
+};
+const BY_RESOLVER_KEY = new Map(GATEWAY_PROVIDERS.map((p) => [p.resolverKey, p]));
+/** Look up a provider by the slug prefix the user typed (honoring aliases). */
+function findProviderBySlug(resolverKey) {
+	const canonical = RESOLVER_ALIASES[resolverKey] ?? resolverKey;
+	return BY_RESOLVER_KEY.get(canonical);
+}
+/** Detect the gateway provider from a wrapped provider's request URL (BYOG). */
+function detectProviderByUrl(url) {
+	return GATEWAY_PROVIDERS.find((p) => p.hostPattern?.test(url));
+}
+/** All slug keys with a built-in parser (auto-wireable by the slug delegate). */
+function wireableProviders() {
+	return GATEWAY_PROVIDERS.filter((p) => p.wireFormat !== void 0);
+}
+//#endregion
+//#region src/gateway-provider.ts
+const STRIP_HEADERS_BASE = new Set(["content-length", "host"]);
+function asText(body) {
+	if (typeof body === "string") return body;
+	if (body instanceof Uint8Array) return new TextDecoder().decode(body);
+	if (body instanceof ArrayBuffer) return new TextDecoder().decode(body);
+	return "{}";
+}
+function headersToObject(h) {
+	const out = {};
+	if (!h) return out;
+	if (h instanceof Headers) for (const [k, v] of h) out[k] = v;
+	else if (Array.isArray(h)) for (const [k, v] of h) out[k] = v;
+	else Object.assign(out, h);
+	return out;
+}
+/**
+* A `fetch` that dispatches the wrapped provider's request through AI Gateway.
+* Detects the gateway provider id from the request URL (or uses `config.provider`),
+* strips the provider host to the endpoint path, and forwards the body verbatim.
+*/
+function createGatewayFetch(config) {
+	if (!config?.binding) throw new WorkersAIGatewayError("gateway-error", "createGatewayFetch requires a `binding` (e.g. { binding: env.AI }).");
+	const gatewayId = typeof config.gateway === "string" ? config.gateway : config.gateway?.id;
+	if (!gatewayId) throw new WorkersAIGatewayError("gateway-error", "createGatewayFetch requires a `gateway` id (e.g. gateway: \"my-gateway\").");
+	return (async (input, init) => {
+		const rawUrl = typeof input === "string" ? input : input.toString();
+		let info;
+		if (config.provider) info = void 0;
+		else {
+			info = detectProviderByUrl(rawUrl);
+			if (!info) throw new WorkersAIGatewayError("gateway-error", `Could not detect a gateway provider from URL "${rawUrl}". Pass \`provider: "<gateway-provider-id>"\` explicitly.`, { recoverable: false });
+		}
+		const providerId = config.provider ?? info.gatewayProviderId;
+		const endpoint = info?.transformEndpoint ? info.transformEndpoint(rawUrl) : rawUrl.replace(/^https?:\/\/[^/]+\//, "");
+		const body = JSON.parse(asText(init?.body));
+		const strip = new Set(STRIP_HEADERS_BASE);
+		if (!config.byok && info) for (const h of info.authHeaders) strip.add(h.toLowerCase());
+		const headers = {};
+		for (const [k, v] of Object.entries(headersToObject(init?.headers))) if (!strip.has(k.toLowerCase())) headers[k] = v;
+		if (config.extraHeaders) Object.assign(headers, config.extraHeaders);
+		if (config.cacheTtl !== void 0) headers["cf-aig-cache-ttl"] = String(config.cacheTtl);
+		if (config.skipCache) headers["cf-aig-skip-cache"] = "true";
+		const entry = {
+			provider: providerId,
+			endpoint,
+			headers,
+			query: body
+		};
+		const gw = config.binding.gateway(gatewayId);
+		const runOptions = {};
+		if (init?.signal) runOptions.signal = init.signal;
+		return gw.run([entry], runOptions);
+	});
+}
+/**
+* Wrap an `@ai-sdk/*` provider factory so its traffic flows through AI Gateway.
+* A thin convenience over {@link createGatewayFetch} — it injects the gateway
+* `fetch` (and a placeholder `apiKey` unless you supply one for BYOK).
+*
+* @example
+* ```ts
+* import { createOpenAI } from "@ai-sdk/openai";
+* import { createGatewayProvider } from "workers-ai-provider/gateway";
+*
+* const openai = createGatewayProvider(createOpenAI, {
+*   binding: env.AI,
+*   gateway: "my-gw",
+* });
+* const model = openai("gpt-5");
+* ```
+*/
+function createGatewayProvider(factory, config) {
+	return factory({
+		apiKey: config.apiKey ?? "unused",
+		...config.baseURL ? { baseURL: config.baseURL } : {},
+		fetch: createGatewayFetch(config)
+	});
+}
+//#endregion
+export { findProviderBySlug as a, WorkersAIGatewayError as c, detectProviderByUrl as i, _defineProperty as l, createGatewayProvider as n, wireableProviders as o, GATEWAY_PROVIDERS as r, WorkersAIFallbackError as s, createGatewayFetch as t };
+
+//# sourceMappingURL=gateway-provider-1USFWm7c.mjs.map