void 0.9.1 → 0.9.2

package/dist/cli/cli.mjs

@@ -1568,7 +1568,7 @@ else if (command === "deploy") {
 } else if (command === "auth") runSubcommandGroup("auth", authSubcommands, parseAuthArgs, (root, parsed) => import("../auth-cmd-CPkWrQR9.mjs").then(({ runAuthCommand }) => runAuthCommand(root, parsed)));
 else if (command === "project") runSubcommandGroup("project", projectSubcommands, parseProjectArgs, (root, parsed) => import("../project-cmd-CLrqSbqj.mjs").then(({ runProjectCommand }) => runProjectCommand(root, parsed)));
 else if (command === "secret") runSubcommandGroup("secret", secretSubcommands, parseSecretArgs, (root, parsed) => import("../secret-C_uTY7xx.mjs").then(({ runSecretCommand }) => runSecretCommand(root, parsed)));
-else if (command === "domain") runSubcommandGroup("domain", domainSubcommands, parseDomainArgs, (root, parsed) => import("../domain-DxTc6HDn.mjs").then(({ runDomainCommand }) => runDomainCommand(root, parsed)));
+else if (command === "domain") runSubcommandGroup("domain", domainSubcommands, parseDomainArgs, (root, parsed) => import("../domain-B7RntQ1r.mjs").then(({ runDomainCommand }) => runDomainCommand(root, parsed)));
 else if (command === "db") runSubcommandGroup("db", dbSubcommands, parseDbArgs, (root, parsed) => import("../db-DiddQC2v.mjs").then(({ runDbCommand }) => runDbCommand(root, parsed)));
 else if (command === "env") runSubcommandGroup("env", envSubcommands, parseEnvArgs, (root, parsed) => import("../env-Bvw0wMTI.mjs").then(({ runEnvCommand }) => runEnvCommand(root, parsed)));
 else if (command === "gen") runSubcommandGroup("gen", genSubcommands, parseGenArgs, (root, parsed) => import("../gen-CZdNWIaA.mjs").then(({ runGenCommand }) => runGenCommand(root, parsed)));
@@ -1695,7 +1695,7 @@ else if (command === "-v" || command === "--version") {
 			case "auth": return runSubcommandGroup("auth", authSubcommands, parseAuthArgs, (r, p) => import("../auth-cmd-CPkWrQR9.mjs").then(({ runAuthCommand }) => runAuthCommand(r, p)));
 			case "project": return runSubcommandGroup("project", projectSubcommands, parseProjectArgs, (r, p) => import("../project-cmd-CLrqSbqj.mjs").then(({ runProjectCommand }) => runProjectCommand(r, p)));
 			case "secret": return runSubcommandGroup("secret", secretSubcommands, parseSecretArgs, (r, p) => import("../secret-C_uTY7xx.mjs").then(({ runSecretCommand }) => runSecretCommand(r, p)));
-			case "domain": return runSubcommandGroup("domain", domainSubcommands, parseDomainArgs, (r, p) => import("../domain-DxTc6HDn.mjs").then(({ runDomainCommand }) => runDomainCommand(r, p)));
+			case "domain": return runSubcommandGroup("domain", domainSubcommands, parseDomainArgs, (r, p) => import("../domain-B7RntQ1r.mjs").then(({ runDomainCommand }) => runDomainCommand(r, p)));
 			case "db": return runSubcommandGroup("db", dbSubcommands, parseDbArgs, (r, p) => import("../db-DiddQC2v.mjs").then(({ runDbCommand }) => runDbCommand(r, p)));
 			case "env": return runSubcommandGroup("env", envSubcommands, parseEnvArgs, (r, p) => import("../env-Bvw0wMTI.mjs").then(({ runEnvCommand }) => runEnvCommand(r, p)));
 			case "gen": return runSubcommandGroup("gen", genSubcommands, parseGenArgs, (r, p) => import("../gen-CZdNWIaA.mjs").then(({ runGenCommand }) => runGenCommand(r, p)));

package/dist/{domain-DxTc6HDn.mjs → domain-B7RntQ1r.mjs}

@@ -39,20 +39,13 @@ async function domainAdd(client, projectId, hostname) {
 	R.success(`Domain ${hostname} added (status: ${domain.status})`);
 	let cnameSection;
 	let ownershipSection;
-	let sslSection;
 	if (domain.cname_target) cnameSection = `CNAME (traffic)\n    ${hostname} → ${domain.cname_target}`;
 	if (domain.ownership_verification) ownershipSection = `TXT (ownership verification)\n    ${domain.ownership_verification.name} → ${domain.ownership_verification.value}`;
-	const sslRecords = (domain.ssl_validation_records ?? []).filter((r) => Boolean(r.txt_name) && Boolean(r.txt_value));
-	if (sslRecords.length > 0) sslSection = `TXT (SSL validation)\n${sslRecords.map((r) => `    ${r.txt_name} → ${r.txt_value}`).join("\n")}`;
-	else sslSection = `SSL validation records will appear in \`void domain status\` shortly.`;
-	const summary = `Add the records above to your DNS, then run \`void domain status ${hostname}\` to check progress.`;
-	const sections = [
-		cnameSection,
-		ownershipSection,
-		sslSection,
-		summary
-	].filter((s) => s !== void 0);
-	if (sections.length > 0) Se(sections.join("\n\n"), "DNS Setup");
+	const recordSections = [cnameSection, ownershipSection].filter((s) => s !== void 0);
+	if (recordSections.length > 0) {
+		const summary = `Add ${recordSections.length === 1 ? "the record above" : "the records above"} to your DNS, then run \`void domain status ${hostname}\` to check progress.`;
+		Se([...recordSections, summary].join("\n\n"), "DNS Setup");
+	}
 }
 async function domainRemove(client, projectId, hostname) {
 	const domain = (await client.listDomains(projectId)).find((d) => d.hostname === hostname);
@@ -93,7 +86,7 @@ function computeRollup(status) {
 	};
 	if (status.cf_status === "pending_issuance" || status.cf_status === "active" && status.ssl_status !== "active") return {
 		state: "issuing_cert",
-		diagnostic: "Cloudflare is issuing the SSL certificate (typically <5 minutes)."
+		diagnostic: status.cname_target ? "Cloudflare is issuing the SSL certificate automatically (typically <5 minutes). If this persists, confirm the traffic CNAME below is published." : "Cloudflare is issuing the SSL certificate automatically (typically <5 minutes)."
 	};
 	if (status.cf_status === "pending_deployment") return {
 		state: "deploying_cert",
@@ -125,20 +118,12 @@ async function domainStatus(client, projectId, hostname, verbose) {
 		if (status.verification_errors && status.verification_errors.length > 0) rollupLines.push(`  Errors:      ${status.verification_errors.join(", ")}`);
 	}
 	Se(rollupLines.join("\n"), "Domain Status");
-	const ownershipPending = Boolean(status.ownership_verification);
-	const sslPending = status.ssl_status !== "active";
-	if (ownershipPending || sslPending) {
-		const pendingSections = [];
-		if (ownershipPending && status.ownership_verification) pendingSections.push(`TXT (ownership verification)\n    ${status.ownership_verification.name} → ${status.ownership_verification.value}`);
-		if (sslPending) {
-			const sslRecords = (status.ssl_validation_records ?? []).filter((r) => Boolean(r.txt_name) && Boolean(r.txt_value) && r.status !== "active");
-			if (sslRecords.length > 0) {
-				const lines = sslRecords.map((r) => `    ${r.txt_name} → ${r.txt_value}`).join("\n");
-				pendingSections.push(`TXT (SSL validation)\n${lines}`);
-			}
-		}
-		if (pendingSections.length > 0) Se(pendingSections.join("\n\n"), "Add these DNS records to your provider");
-	}
+	let cnameSection;
+	let ownershipSection;
+	if (status.cname_target && status.ssl_status !== "active") cnameSection = `CNAME (traffic)\n    ${status.hostname} → ${status.cname_target}`;
+	if (status.ownership_verification) ownershipSection = `TXT (ownership verification)\n    ${status.ownership_verification.name} → ${status.ownership_verification.value}`;
+	const pendingRecords = [cnameSection, ownershipSection].filter((s) => s !== void 0);
+	if (pendingRecords.length > 0) Se(pendingRecords.join("\n\n"), pendingRecords.length === 1 ? "Add this DNS record to your provider" : "Add these DNS records to your provider");
 }
 //#endregion
 export { runDomainCommand };

package/dist/runtime/ai.d.mts

@@ -1,102 +1,20 @@
 //#region src/runtime/ai-types.d.ts
-type ThirdPartyProvider = "openai" | "anthropic" | "google-ai-studio" | "groq" | "mistral" | "grok" | "deepseek" | "openrouter" | "perplexity" | "cohere" | "cerebras" | "huggingface" | "replicate" | "baseten" | "cartesia" | "deepgram" | "elevenlabs" | "fal" | "ideogram" | "parallel";
-type ThirdPartyModel = `${ThirdPartyProvider}/${string}`;
-type ChatContent = string | Array<{
-  type: "text";
-  text: string;
-} | {
-  type: "image_url";
-  image_url: {
-    url: string;
-    detail?: "auto" | "low" | "high";
-  };
-}>;
-type ChatMessage = {
-  role: "system" | "user" | "assistant";
-  content: ChatContent;
-};
-type ChatCompletionInputs = {
-  messages: Array<ChatMessage>;
-  temperature?: number;
-  max_tokens?: number;
-  top_p?: number;
-  frequency_penalty?: number;
-  presence_penalty?: number;
-  stop?: string | Array<string>;
-  stream?: boolean;
-};
-type ChatCompletionResponse = {
-  id: string;
-  object: string;
-  created: number;
-  model: string;
-  choices: Array<ChatCompletionChoice>;
-  usage: ChatCompletionUsage;
-};
-type ChatCompletionChoice = {
-  index: number;
-  message: ChatMessage;
-  finish_reason: string;
-};
-type ChatCompletionUsage = {
-  prompt_tokens: number;
-  completion_tokens: number;
-  total_tokens: number;
-};
-type ChatCompletionChunk = {
-  id: string;
-  choices: Array<{
-    index: number;
-    delta: {
-      role?: string;
-      content?: string;
-    };
-    finish_reason: string | null;
-  }>;
-};
-type ImageGatewayEndpoint = "images/generations" | "images/edits";
+type AiProviderName = "openai" | "anthropic" | "google-ai-studio" | "groq" | "mistral" | "grok" | "deepseek" | "openrouter" | "perplexity" | "cohere" | "cerebras" | "huggingface" | "replicate" | "baseten" | "cartesia" | "deepgram" | "elevenlabs" | "fal" | "ideogram" | "parallel";
+type AiProvider = AiProviderName | (string & {});
 type ImageFileInput = Blob | ArrayBuffer | ArrayBufferView | {
   data: string;
   name?: string;
   type?: string;
 };
-type ImageGenerationInputs = {
-  prompt: string;
-  n?: number;
-  size?: string;
-  quality?: string;
-  response_format?: "url" | "b64_json";
-  user?: string;
-  [key: string]: unknown;
-};
-type ImageGenerationData = {
-  url?: string;
-  b64_json?: string;
-  revised_prompt?: string;
-};
-type ImageGenerationResponse = {
-  created?: number;
-  data: Array<ImageGenerationData>;
-  usage?: unknown;
-  [key: string]: unknown;
-};
-type ImageGenerationOptions = {
-  endpoint?: "images/generations";
-  [key: string]: unknown;
-};
-type ImageEditOptions = {
-  endpoint: "images/edits";
-  [key: string]: unknown;
+type AiProviderOptions = {
+  apiKeyEnv?: string;
+  apiKeyHeader?: string;
+  apiKeyPrefix?: string;
 };
-type ImageEditInputs = {
-  prompt: string;
-  image: ImageFileInput | Array<ImageFileInput>;
-  mask?: ImageFileInput;
-  n?: number;
-  size?: string;
-  response_format?: "url" | "b64_json";
-  user?: string;
-  [key: string]: unknown;
+type AiProviderFetchInit = {
+  method?: string;
+  headers?: HeadersInit;
+  body?: unknown;
 };
 //#endregion
 //#region src/runtime/ai.d.ts
@@ -107,14 +25,16 @@ type ImageEditInputs = {
 * in a `Response` with SSE headers — ready to return from a route handler.
 */
 type VoidAi = Omit<Ai, "run"> & {
-  /** Workers AI inference (existing) */run<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: AiOptions): Promise<AiModels[Name]["postProcessedOutputs"]>; /** Third-party chat completions (OpenAI, Anthropic, etc.) */
-  run(model: ThirdPartyModel, inputs: ChatCompletionInputs, options?: AiOptions): Promise<ChatCompletionResponse>; /** Image generation. Returns the proxy response so callers can return or parse it. */
-  image<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: ImageGenerationOptions): Promise<Response>; /** Third-party image generation or editing through AI Gateway. */
-  image(model: ThirdPartyModel, inputs: ImageEditInputs, options: ImageEditOptions): Promise<Response>; /** Third-party image generation through AI Gateway. */
-  image(model: ThirdPartyModel, inputs: ImageGenerationInputs, options?: ImageGenerationOptions): Promise<Response>; /** Stream Workers AI response as SSE */
-  stream<Name extends keyof AiModels>(model: Name, inputs: Omit<AiModels[Name]["inputs"], "stream">, options?: AiOptions): Promise<Response>; /** Stream third-party chat completions as SSE */
-  stream(model: ThirdPartyModel, inputs: Omit<ChatCompletionInputs, "stream">, options?: AiOptions): Promise<Response>;
+  /** Workers AI inference (existing) */run<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: AiOptions): Promise<AiModels[Name]["postProcessedOutputs"]>; /** Cloudflare AI Gateway model inference. Accepts Cloudflare model IDs unchanged. */
+  run(model: string, inputs: unknown, options?: AiOptions): Promise<unknown>; /** Image generation. Returns the proxy response so callers can return or parse it. */
+  image<Name extends keyof AiModels>(model: Name, inputs: AiModels[Name]["inputs"], options?: AiOptions): Promise<Response>; /** Cloudflare AI Gateway model inference returned as a Response. */
+  image(model: string, inputs: unknown, options?: AiOptions): Promise<Response>; /** Provider-native AI Gateway requests using a project secret for the provider API key. */
+  provider(provider: AiProvider, options?: AiProviderOptions): {
+    fetch(path: string, init?: AiProviderFetchInit): Promise<Response>;
+  }; /** Stream Workers AI response as SSE */
+  stream<Name extends keyof AiModels>(model: Name, inputs: Omit<AiModels[Name]["inputs"], "stream">, options?: AiOptions): Promise<Response>; /** Stream any Cloudflare AI Gateway model response as SSE */
+  stream(model: string, inputs: Record<string, unknown>, options?: AiOptions): Promise<Response>;
 };
 declare const ai: VoidAi;
 //#endregion
-export { type ChatCompletionChoice, type ChatCompletionChunk, type ChatCompletionInputs, type ChatCompletionResponse, type ChatCompletionUsage, type ChatContent, type ChatMessage, type ImageEditInputs, type ImageEditOptions, type ImageFileInput, type ImageGatewayEndpoint, type ImageGenerationData, type ImageGenerationInputs, type ImageGenerationOptions, type ImageGenerationResponse, type ThirdPartyModel, type ThirdPartyProvider, VoidAi, ai };
+export { type AiProvider, type AiProviderFetchInit, type AiProviderName, type AiProviderOptions, type ImageFileInput, VoidAi, ai };

package/dist/runtime/ai.mjs

@@ -32,9 +32,6 @@ const VOID_FILE_MARKER = "__voidFile";
 function hasStreamFlag(value) {
 	return typeof value === "object" && value !== null && "stream" in value;
 }
-function isThirdPartyModel(model) {
-	return model.split("/")[0] in PROVIDER_KEY_MAP;
-}
 function mediaTypeFromContentType(contentType) {
 	if (!contentType) return null;
 	const [mediaType] = contentType.split(";", 1);
@@ -109,8 +106,70 @@ async function serializeProxyValue(value, serializeDataObjectAsFile = false) {
 	}
 	return value;
 }
-async function serializeImageInputs(inputs, endpoint) {
-	return endpoint === "images/edits" ? serializeProxyValue(inputs) : inputs;
+function formFileName(value, fallback) {
+	return fileNameFromBlob(value) ?? fallback;
+}
+async function serializeFormData(form) {
+	const entries = [];
+	for (const [name, value] of form.entries()) {
+		if (typeof value === "string") {
+			entries.push({
+				name,
+				value
+			});
+			continue;
+		}
+		entries.push({
+			name,
+			value: {
+				[VOID_FILE_MARKER]: true,
+				data: arrayBufferToBase64(await value.arrayBuffer()),
+				name: formFileName(value, name),
+				type: value.type || void 0
+			}
+		});
+	}
+	return {
+		type: "form",
+		entries
+	};
+}
+async function serializeProviderBody(body) {
+	if (body === void 0 || body === null) return { type: "none" };
+	if (typeof body === "string") return {
+		type: "text",
+		data: body
+	};
+	if (body instanceof URLSearchParams) return {
+		type: "text",
+		data: body.toString(),
+		contentType: "application/x-www-form-urlencoded;charset=UTF-8"
+	};
+	if (body instanceof FormData) return serializeFormData(body);
+	if (body instanceof Blob) return {
+		type: "base64",
+		data: arrayBufferToBase64(await body.arrayBuffer()),
+		contentType: body.type || void 0
+	};
+	if (body instanceof ArrayBuffer) return {
+		type: "base64",
+		data: arrayBufferToBase64(body)
+	};
+	if (isBinaryView(body)) return {
+		type: "base64",
+		data: arrayBufferToBase64(copyBinaryView(body))
+	};
+	return {
+		type: "json",
+		value: await serializeProxyValue(body)
+	};
+}
+function headersToRecord(headers) {
+	if (!headers) return;
+	const result = {};
+	const normalized = new Headers(headers);
+	for (const [key, value] of normalized.entries()) result[key] = value;
+	return result;
 }
 async function responseFromResult(result) {
 	if (result instanceof Response) return result;
@@ -132,9 +191,8 @@ function splitImageOptions(options) {
 		runOptions: Object.keys(runOptions).length > 0 ? runOptions : void 0
 	};
 }
-function resolveProviderKey(model, runtimeEnv) {
-	const provider = model.split("/")[0];
-	const envVar = PROVIDER_KEY_MAP[provider];
+function resolveProviderKey(provider, runtimeEnv, options) {
+	const envVar = options?.apiKeyEnv ?? PROVIDER_KEY_MAP[provider];
 	if (!envVar) throw new Error(`ai: Unknown provider '${provider}'. Use one of: ${Object.keys(PROVIDER_KEY_MAP).join(", ")}.`);
 	const key = runtimeEnv[envVar];
 	if (typeof key !== "string" || key.length === 0) throw new Error(`ai: Missing ${envVar} secret. Add it as a project secret for provider '${provider}'.`);
@@ -159,6 +217,7 @@ function resolveBackend() {
 			const { runOptions } = splitImageOptions(options);
 			return responseFromResult(await directAi.run(model, inputs, runOptions));
 		},
+		providerFetch: unsupportedProviderFetch,
 		models: directAi.models.bind(directAi),
 		toMarkdown: directAi.toMarkdown?.bind(directAi) ?? unsupported("toMarkdown")
 	};
@@ -169,8 +228,23 @@ function unsupported(method) {
 		throw new Error(`ai: ai.${method}() is not supported in this environment.`);
 	};
 }
+function unsupportedProviderFetch() {
+	throw new Error("ai: ai.provider().fetch() is not supported in this environment.");
+}
+async function providerRequestBody(provider, path, init, options, runtimeEnv) {
+	return {
+		provider,
+		path,
+		method: init?.method,
+		headers: headersToRecord(init?.headers),
+		body: await serializeProviderBody(init?.body),
+		providerKey: resolveProviderKey(provider, runtimeEnv, options),
+		apiKeyHeader: options?.apiKeyHeader,
+		apiKeyPrefix: options?.apiKeyPrefix
+	};
+}
 function makeServiceBindingBackend(proxy, runtimeEnv) {
-	async function proxyFetch(action, body) {
+	async function proxyFetch(action, body, options = {}) {
 		const res = await proxy.fetch(`https://ai-proxy/ai/${action}`, {
 			method: "POST",
 			headers: { "content-type": "application/json" },
@@ -179,7 +253,7 @@ function makeServiceBindingBackend(proxy, runtimeEnv) {
 				...body
 			})
 		});
-		if (!res.ok) {
+		if (options.throwOnError !== false && !res.ok) {
 			const text = await res.text();
 			throw new Error(`ai: Proxy request failed with ${res.status}: '${text}'.`);
 		}
@@ -189,17 +263,6 @@ function makeServiceBindingBackend(proxy, runtimeEnv) {
 		async run(model, inputs, options) {
 			const projectId = runtimeEnv.__PROJECT_ID;
 			const aiToken = runtimeEnv.__VOID_PROXY_TOKEN;
-			if (isThirdPartyModel(model)) {
-				const res = await proxyFetch("gateway", {
-					model,
-					inputs,
-					providerKey: resolveProviderKey(model, runtimeEnv),
-					projectId,
-					aiToken
-				});
-				if (hasStreamFlag(inputs) && inputs.stream) return res.body;
-				return readProxyResult(res);
-			}
 			const res = await proxyFetch("run", {
 				model,
 				inputs,
@@ -213,18 +276,7 @@ function makeServiceBindingBackend(proxy, runtimeEnv) {
 		async image(model, inputs, options) {
 			const projectId = runtimeEnv.__PROJECT_ID;
 			const aiToken = runtimeEnv.__VOID_PROXY_TOKEN;
-			const { endpoint, runOptions } = splitImageOptions(options);
-			if (isThirdPartyModel(model)) {
-				const providerKey = resolveProviderKey(model, runtimeEnv);
-				return proxyFetch("gateway", {
-					model,
-					endpoint,
-					inputs: await serializeImageInputs(inputs, endpoint),
-					providerKey,
-					projectId,
-					aiToken
-				});
-			}
+			const { runOptions } = splitImageOptions(options);
 			return proxyFetch("run", {
 				model,
 				inputs,
@@ -233,6 +285,15 @@ function makeServiceBindingBackend(proxy, runtimeEnv) {
 				aiToken
 			});
 		},
+		async providerFetch(provider, path, init, options) {
+			const projectId = runtimeEnv.__PROJECT_ID;
+			const aiToken = runtimeEnv.__VOID_PROXY_TOKEN;
+			return proxyFetch("provider", {
+				...await providerRequestBody(provider, path, init, options, runtimeEnv),
+				projectId,
+				aiToken
+			}, { throwOnError: false });
+		},
 		async models(params) {
 			const projectId = runtimeEnv.__PROJECT_ID;
 			const aiToken = runtimeEnv.__VOID_PROXY_TOKEN;
@@ -261,7 +322,7 @@ function makeHttpBackend(token, projectId, runtimeEnv) {
 		authorization: `Bearer ${token}`,
 		...cfAccessHeaders(runtimeEnv)
 	};
-	async function proxyFetch(action, body) {
+	async function proxyFetch(action, body, options = {}) {
 		const res = await fetch(`${base}/${action}`, {
 			method: "POST",
 			headers,
@@ -271,7 +332,7 @@ function makeHttpBackend(token, projectId, runtimeEnv) {
 				projectId
 			})
 		});
-		if (!res.ok) {
+		if (options.throwOnError !== false && !res.ok) {
 			const text = await res.text();
 			throw new Error(`ai: Proxy request failed with ${res.status}: '${text}'.`);
 		}
@@ -279,15 +340,6 @@ function makeHttpBackend(token, projectId, runtimeEnv) {
 	}
 	return {
 		async run(model, inputs, options) {
-			if (isThirdPartyModel(model)) {
-				const res = await proxyFetch("gateway", {
-					model,
-					inputs,
-					providerKey: resolveProviderKey(model, runtimeEnv)
-				});
-				if (hasStreamFlag(inputs) && inputs.stream) return res.body;
-				return readProxyResult(res);
-			}
 			const res = await proxyFetch("run", {
 				model,
 				inputs,
@@ -297,22 +349,16 @@ function makeHttpBackend(token, projectId, runtimeEnv) {
 			return readProxyResult(res);
 		},
 		async image(model, inputs, options) {
-			const { endpoint, runOptions } = splitImageOptions(options);
-			if (isThirdPartyModel(model)) {
-				const providerKey = resolveProviderKey(model, runtimeEnv);
-				return proxyFetch("gateway", {
-					model,
-					endpoint,
-					inputs: await serializeImageInputs(inputs, endpoint),
-					providerKey
-				});
-			}
+			const { runOptions } = splitImageOptions(options);
 			return proxyFetch("run", {
 				model,
 				inputs,
 				options: runOptions
 			});
 		},
+		async providerFetch(provider, path, init, options) {
+			return proxyFetch("provider", await providerRequestBody(provider, path, init, options, runtimeEnv), { throwOnError: false });
+		},
 		async models(params) {
 			return (await proxyFetch("models", { inputs: params })).json();
 		},
@@ -341,6 +387,7 @@ const ai = new Proxy({}, { get(_, prop) {
 	};
 	if (prop === "run") return backend().run;
 	if (prop === "image") return backend().image;
+	if (prop === "provider") return (provider, options) => ({ fetch: (path, init) => backend().providerFetch(provider, path, init, options) });
 	if (prop === "models") return backend().models;
 	if (prop === "toMarkdown") return backend().toMarkdown;
 } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "void",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voidzero-dev/void.git",
@@ -353,7 +353,7 @@
     "valibot": ">=1.0.0-beta.7",
     "vite": "^8.0.0",
     "zod": "^3.25.0 || ^4.0.0",
-    "@void/md": "0.9.1"
+    "@void/md": "0.9.2"
   },
   "peerDependenciesMeta": {
     "@void/md": {

package/skills/void/docs/guide/ai.md

@@ -4,7 +4,7 @@ outline: deep
 
 # AI
 
-Void provides a typed AI client powered by Cloudflare's [AI Gateway](https://developers.cloudflare.com/ai-gateway/). It supports both [Workers AI](https://developers.cloudflare.com/workers-ai/) models and third-party providers such as OpenAI, Anthropic, and Google through bring-your-own-key credentials. Import `ai` from `void/ai` and run inference directly from your route handlers. Usage is metered through Void.
+Void provides a typed AI client powered by Cloudflare's [AI Gateway](https://developers.cloudflare.com/ai-gateway/). Import `ai` from `void/ai` and run inference directly from your route handlers. Usage is metered through Void.
 
 ```ts
 import { ai } from 'void/ai';
@@ -29,7 +29,7 @@ export const POST = defineHandler(async (c) => {
 });
 ```
 
-You can use any model available on [Workers AI](https://developers.cloudflare.com/workers-ai/models/), including text generation, image classification, image-to-text, text-to-image, embeddings, translation, and more. Models that return binary data, such as generated images, are returned as a `Blob` from `ai.run()`.
+You can use any model available through Cloudflare's AI binding, including Workers AI models such as `@cf/meta/llama-3.1-8b-instruct` and Cloudflare Gateway models such as `google/gemini-2.5-flash` or `openai/gpt-4.1-mini`. The input object must match the selected Cloudflare model's schema. Models that return binary data, such as generated images, are returned as a `Blob` from `ai.run()`.
 
 ## Streaming
 
@@ -87,11 +87,52 @@ Workers AI usage is metered in [**neurons**](https://developers.cloudflare.com/w
 
 On the **free tier**, AI requests return a `429` error once the limit is reached. On **paid tiers**, usage beyond the included allowance is tracked as overage on your monthly bill.
 
-## Third-Party Providers (BYOK)
+## Cloudflare Gateway Models
 
-You can use models from OpenAI, Anthropic, Google, and other providers by passing a `provider/model` identifier. Bring your own API key, add it as a project secret, and Void handles the rest. Third-party inference is billed directly by the provider, and Void does not mark up API calls. Requests still route through AI Gateway so usage shows up on the dashboard.
+`ai.run()` mirrors Cloudflare's `env.AI.run()` model naming and input schemas. Third-party models use Cloudflare model IDs and Cloudflare-managed credentials.
 
-### Usage
+```ts
+const result = await ai.run('google/gemini-2.5-flash', {
+  contents: [
+    {
+      role: 'user',
+      parts: [{ text: 'Explain Durable Objects in one paragraph.' }],
+    },
+  ],
+});
+```
+
+OpenAI-compatible models use OpenAI-style `messages`:
+
+```ts
+const result = await ai.run('openai/gpt-4.1-mini', {
+  messages: [{ role: 'user', content: 'Summarize this deploy.' }],
+});
+```
+
+Pass Cloudflare AI Gateway options as the third argument:
+
+```ts
+const result = await ai.run(
+  'openai/gpt-4.1-mini',
+  {
+    messages: [{ role: 'user', content: 'Summarize this deploy.' }],
+  },
+  {
+    gateway: {
+      skipCache: true,
+    },
+  },
+);
+```
+
+Void always injects the `void` gateway ID and project metadata for metering.
+
+## Provider-Native Requests
+
+Use `ai.provider(provider).fetch(path, init)` when you want to call a provider-native API with your own provider key. The request still routes through Cloudflare AI Gateway and Void metering, but the request shape is the provider's native HTTP API.
+
+### OpenAI
 
 ```ts
 import { defineHandler } from 'void';
@@ -100,85 +141,99 @@ import { ai } from 'void/ai';
 export const POST = defineHandler(async (c) => {
   const { prompt } = await c.req.json();
 
-  const result = await ai.run('openai/gpt-4o', {
-    messages: [{ role: 'user', content: prompt }],
-    max_tokens: 512,
+  const response = await ai.provider('openai').fetch('/chat/completions', {
+    body: {
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: prompt }],
+      max_tokens: 512,
+    },
   });
 
+  const result = await response.json();
   return c.json(result);
 });
 ```
 
-The same `ai.run()` and `ai.stream()` methods work for both Workers AI and third-party models. The framework detects the provider from the model string and routes the request through [AI Gateway](https://developers.cloudflare.com/ai-gateway/) automatically.
-
-The options follow each provider's conventions. All third-party providers use the OpenAI-compatible chat completions format, including `messages`, `max_tokens`, and `temperature`. TypeScript narrows the input and return types based on the model string: Workers AI models get per-model typed inputs from `@cloudflare/workers-types`, while third-party models such as `"provider/model"` get `ChatCompletionInputs` and `ChatCompletionResponse`.
-
-### Vision
-
-Third-party chat models that accept image inputs can receive OpenAI-compatible multimodal message content:
+### Google AI Studio
 
 ```ts
-const result = await ai.run('openai/gpt-4o', {
-  messages: [
-    {
-      role: 'user',
-      content: [
-        { type: 'text', text: 'What is in this image?' },
+const response = await ai
+  .provider('google-ai-studio')
+  .fetch('/v1/models/gemini-2.5-flash:generateContent', {
+    body: {
+      contents: [
         {
-          type: 'image_url',
-          image_url: { url: 'data:image/png;base64,...', detail: 'high' },
+          role: 'user',
+          parts: [{ text: 'What is Cloudflare?' }],
         },
       ],
     },
-  ],
-});
+  });
+
+const result = await response.json();
+```
+
+### Custom Providers
+
+For providers that are not in Void's default key map, pass the secret name and API-key header:
+
+```ts
+const response = await ai
+  .provider('custom-provider', {
+    apiKeyEnv: 'CUSTOM_PROVIDER_API_KEY',
+    apiKeyHeader: 'x-api-key',
+    apiKeyPrefix: '',
+  })
+  .fetch('/v1/respond', {
+    body: { prompt: 'Hello' },
+  });
 ```
 
 ### Image Generation
 
-Use `ai.image()` for image-generation providers or Workers AI image models. It returns a `Response`, so route handlers can return it directly or parse it as JSON depending on the provider:
+Use `ai.run()` or `ai.image()` for Cloudflare-native image models:
 
 ```ts
 export const POST = defineHandler(async (c) => {
   const { prompt } = await c.req.json();
-
-  return ai.image('openai/gpt-image-1.5', {
-    prompt,
-    size: '1024x1024',
-    response_format: 'b64_json',
-  });
+  return ai.image('@cf/black-forest-labs/flux-1-schnell', { prompt });
 });
 ```
 
-For Workers AI text-to-image models, pass the model name and input shape from Cloudflare's model docs:
+Use `ai.provider().fetch()` for provider-native image APIs:
 
 ```ts
 export const POST = defineHandler(async (c) => {
   const { prompt } = await c.req.json();
-  return ai.image('@cf/black-forest-labs/flux-1-schnell', { prompt });
+
+  return ai.provider('openai').fetch('/images/generations', {
+    body: {
+      model: 'gpt-image-1.5',
+      prompt,
+      size: '1024x1024',
+      response_format: 'b64_json',
+    },
+  });
 });
 ```
 
-For image edits, pass the file-like input and select the edit endpoint. Void serializes the file through the proxy and forwards it to AI Gateway as multipart form data:
+For multipart provider APIs, pass a `FormData` body. Void serializes the body through the proxy and reconstructs it before forwarding to AI Gateway:
 
 ```ts
 export const POST = defineHandler(async (c) => {
   const body = await c.req.parseBody();
+  const form = new FormData();
+  form.set('model', 'gpt-image-1.5');
+  form.set('prompt', String(body.prompt));
+  form.set('image', body.image as Blob, 'source.png');
 
-  return ai.image(
-    'openai/gpt-image-1.5',
-    {
-      prompt: String(body.prompt),
-      image: body.image as Blob,
-    },
-    { endpoint: 'images/edits' },
-  );
+  return ai.provider('openai').fetch('/images/edits', { body: form });
 });
 ```
 
 ### Provider Key Convention
 
-Each provider requires an API key set as a project secret. The env var name is automatically derived from the provider prefix:
+Provider-native requests require an API key set as a project secret. The env var name is automatically derived from the provider name:
 
 | Provider prefix    | Env var               |
 | ------------------ | --------------------- |
@@ -203,7 +258,7 @@ Each provider requires an API key set as a project secret. The env var name is a
 | `ideogram`         | `IDEOGRAM_API_KEY`    |
 | `parallel`         | `PARALLEL_API_KEY`    |
 
-All [AI Gateway providers](https://developers.cloudflare.com/ai-gateway/usage/providers/) that accept a Bearer API key are supported. Providers with non-standard auth (Amazon Bedrock, Azure OpenAI, Google Vertex) are not yet supported.
+OpenAI-style providers use `Authorization: Bearer <key>`. Google AI Studio uses `x-goog-api-key`. Use `apiKeyHeader` and `apiKeyPrefix` for custom providers.
 
 For production, add your API key as a project secret:
 
@@ -217,19 +272,22 @@ For local development, add it to `.env.local` in your project root:
 OPENAI_API_KEY=sk-...
 ```
 
-If the key is missing at runtime, `ai.run()` throws a descriptive error telling you which env var to set.
+If the key is missing at runtime, `ai.provider().fetch()` throws a descriptive error telling you which env var to set.
 
-### Streaming with Third-Party Models
+### Streaming with Provider-Native APIs
 
-`ai.stream()` works the same way. The response is always SSE regardless of provider:
+Provider-native streaming APIs return the provider response directly:
 
 ```ts
 export const POST = defineHandler(async (c) => {
   const { prompt } = await c.req.json();
 
-  return ai.stream('anthropic/claude-sonnet-4-20250514', {
-    messages: [{ role: 'user', content: prompt }],
-    max_tokens: 512,
+  return ai.provider('openai').fetch('/chat/completions', {
+    body: {
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: prompt }],
+      stream: true,
+    },
   });
 });
 ```

package/skills/void/docs/node_modules/void/AGENTS.md

@@ -101,7 +101,7 @@ src/
 | `void/ws`        | `defineRoom()`, `defineWebSocket()`, typed `connect()`, and WebSocket context types                                     |
 | `void/db`        | `db` Drizzle D1 instance (auto-wired with user schema) + `createDb()` for custom D1 bindings                            |
 | `void/queues`    | `queues` typed proxy + `QueueMap` stub interface (augmented by generated `queues.d.ts`)                                 |
-| `void/ai`        | `ai` proxy — `ai.run()`, `ai.stream()`, `ai.models()` with auto-detected backend (service binding / HTTPS / direct)     |
+| `void/ai`        | `ai` proxy — Cloudflare-native `ai.run()`/`ai.stream()`, provider-native `ai.provider().fetch()`, `ai.models()`         |
 | `void/log`       | `logger.error/warn/info(msg, fields?)` — emits stringified JSON to `console.*` so Cloudflare Tail captures level + msg  |
 | `void/env`       | `defineEnv()`, typed `env` proxy, built-in schema helpers (`string`, `number`, `oneOf`, …) + global Cloudflare types    |
 

package/skills/void/docs/reference/api.md

@@ -675,7 +675,7 @@ Imported from `"void/ai"`.
 
 ### `ai`
 
-Typed AI client for Workers AI models and AI Gateway-backed third-party providers.
+Typed AI client for Cloudflare AI models and provider-native AI Gateway requests.
 
 ```ts
 import { ai } from 'void/ai';
@@ -683,9 +683,16 @@ import { ai } from 'void/ai';
 const result = await ai.run('@cf/meta/llama-3.1-8b-instruct', {
   messages: [{ role: 'user', content: 'Summarize this release note.' }],
 });
+
+const response = await ai.provider('openai').fetch('/chat/completions', {
+  body: {
+    model: 'gpt-4o',
+    messages: [{ role: 'user', content: 'Summarize this release note.' }],
+  },
+});
 ```
 
-**Key exports:** `ai`, `VoidAi`, model input/response types. See [AI](../guide/ai.md) for provider setup and streaming examples.
+**Key exports:** `ai`, `VoidAi`, provider request types. See [AI](../guide/ai.md) for provider setup and streaming examples.
 
 ## ISR
 

package/skills/void/docs/reference/cli.md

@@ -572,7 +572,9 @@ See [Environment Variables](../guide/env-vars.md) for the full guide.
 void domain add <hostname> [--project <name>]
 ```
 
-Add a custom domain to a project. Prints the CNAME target you need to add in your DNS provider.
+Add a custom domain to a project. Prints the two DNS records to add at your DNS provider: a traffic **CNAME** pointing `<hostname>` at the CNAME target shown in the command output, and a non-rotating `_cf-custom-hostname` ownership **TXT**. Certificates are validated over HTTP at Cloudflare's edge and renew automatically — there are no `_acme-challenge` records to publish, at first issuance or ever. After adding the records the domain activates automatically (no polling required); run `void domain status <hostname>` to check progress.
+
+> Wildcard custom hostnames (`*.example.com`) are not supported — register each subdomain individually.
 
 ### `void domain delete`
 
@@ -596,7 +598,7 @@ List all custom domains and their status (active/pending).
 void domain status <hostname> [--project <name>] [--verbose]
 ```
 
-Check verification and SSL status for a specific domain. Prints a rolled-up state (`awaiting_dns`, `verifying_dns`, `issuing_cert`, `deploying_cert`, `awaiting_deployment`, `active`, `error`, or `pending`) with a one-line diagnostic explaining what Cloudflare is doing and any user action required. When DNS records are still pending, the command also prints the exact TXT records to add at your DNS provider.
+Check verification and SSL status for a specific domain. Prints a rolled-up state (`awaiting_dns`, `verifying_dns`, `issuing_cert`, `deploying_cert`, `awaiting_deployment`, `active`, `error`, or `pending`) with a one-line diagnostic explaining what Cloudflare is doing and any user action required. While the certificate is not yet active, the command also surfaces the records to configure — the traffic **CNAME** and the `_cf-custom-hostname` ownership **TXT** — so you can verify them. Activation is automatic: a background job reconciles pending domains (about every 2 minutes for the first 30 minutes after adding, then hourly), so this command is for instant feedback rather than required polling.
 
 Pass `--verbose` to additionally print the raw multi-line status breakdown (DB status, SSL status, ownership state, verification errors) underneath the rollup.