veryfront 0.1.49 → 0.1.51

package/src/src/platform/core-platform.ts

@@ -1,7 +1,7 @@
 import * as dntShim from "../../_dnt.shims.js";
 export type Platform = "deno" | "node" | "bun" | "cloudflare-workers" | "unknown";
 
-export interface PlatformCapabilities {
+interface PlatformCapabilities {
   canRunMCPServer: boolean;
   maxAgentSteps: number;
   cpuTimeLimit: number | null;
@@ -34,6 +34,26 @@ export function detectPlatform(): Platform {
   return "unknown";
 }
 
+/** CPU time limit for Cloudflare Workers (30 seconds) */
+const CF_WORKERS_CPU_TIME_LIMIT_MS = 30_000;
+/** Memory limit for Cloudflare Workers (128 MB) */
+const CF_WORKERS_MEMORY_LIMIT_MB = 128;
+/** Max agent steps for Cloudflare Workers */
+const CF_WORKERS_MAX_AGENT_STEPS = 3;
+
+/** CPU time limit for unknown platforms (60 seconds) */
+const UNKNOWN_PLATFORM_CPU_TIME_LIMIT_MS = 60_000;
+/** Memory limit for unknown platforms (512 MB) */
+const UNKNOWN_PLATFORM_MEMORY_LIMIT_MB = 512;
+/** Max agent steps for unknown platforms */
+const UNKNOWN_PLATFORM_MAX_AGENT_STEPS = 5;
+
+/** Minimum agent steps threshold for generating a warning */
+const MIN_AGENT_STEPS_WARNING_THRESHOLD = 10;
+
+/** CPU time limit below which a platform warning is emitted (60 seconds) */
+const CPU_TIME_WARNING_THRESHOLD_MS = 60_000;
+
 const PLATFORM_CAPABILITIES: Record<Platform, PlatformCapabilities> = {
   deno: {
     canRunMCPServer: true,
@@ -67,9 +87,9 @@ const PLATFORM_CAPABILITIES: Record<Platform, PlatformCapabilities> = {
   },
   "cloudflare-workers": {
     canRunMCPServer: false,
-    maxAgentSteps: 3,
-    cpuTimeLimit: 30000,
-    memoryLimit: 128,
+    maxAgentSteps: CF_WORKERS_MAX_AGENT_STEPS,
+    cpuTimeLimit: CF_WORKERS_CPU_TIME_LIMIT_MS,
+    memoryLimit: CF_WORKERS_MEMORY_LIMIT_MB,
     hasFileSystem: false,
     supportsLongRunning: false,
     streamingRecommended: true,
@@ -77,9 +97,9 @@ const PLATFORM_CAPABILITIES: Record<Platform, PlatformCapabilities> = {
   },
   unknown: {
     canRunMCPServer: false,
-    maxAgentSteps: 5,
-    cpuTimeLimit: 60000,
-    memoryLimit: 512,
+    maxAgentSteps: UNKNOWN_PLATFORM_MAX_AGENT_STEPS,
+    cpuTimeLimit: UNKNOWN_PLATFORM_CPU_TIME_LIMIT_MS,
+    memoryLimit: UNKNOWN_PLATFORM_MEMORY_LIMIT_MB,
     hasFileSystem: false,
     supportsLongRunning: false,
     streamingRecommended: true,
@@ -110,13 +130,16 @@ export function getPlatformWarnings(): string[] {
     );
   }
 
-  if (capabilities.maxAgentSteps < 10) {
+  if (capabilities.maxAgentSteps < MIN_AGENT_STEPS_WARNING_THRESHOLD) {
     warnings.push(
       `${capabilities.displayName} has limited agent steps (${capabilities.maxAgentSteps}). Use simple agents only.`,
     );
   }
 
-  if (capabilities.cpuTimeLimit !== null && capabilities.cpuTimeLimit < 60000) {
+  if (
+    capabilities.cpuTimeLimit !== null &&
+    capabilities.cpuTimeLimit < CPU_TIME_WARNING_THRESHOLD_MS
+  ) {
     warnings.push(
       `${capabilities.displayName} has CPU time limit of ${capabilities.cpuTimeLimit}ms. Enable streaming for better UX.`,
     );
@@ -129,7 +152,7 @@ export function getPlatformWarnings(): string[] {
   return warnings;
 }
 
-export interface CompatibilityConfig {
+interface CompatibilityConfig {
   maxSteps?: number;
   streaming?: boolean;
   requiresFileSystem?: boolean;

package/src/src/provider/local/ai-sdk-adapter.ts

@@ -18,6 +18,9 @@ import { isLocalAIDisabled } from "./env.js";
 
 const logger = serverLogger.component("local-llm");
 
+/** Default maximum new tokens for local model generation */
+const DEFAULT_MAX_NEW_TOKENS = 512;
+
 /** Shape of a single message in the AI SDK LanguageModelV2 prompt array. */
 interface PromptMessage {
   role: string;
@@ -63,9 +66,8 @@ function convertPrompt(prompt: ReadonlyArray<PromptMessage>): ChatMessage[] {
   return messages;
 }
 
-/** AI SDK LanguageModelV2 generation options that both doGenerate and doStream receive. */
 interface LocalModelOptions {
-  prompt: unknown[];
+  prompt: ReadonlyArray<PromptMessage>;
   maxOutputTokens?: number;
   temperature?: number;
   topP?: number;
@@ -76,7 +78,7 @@ interface LocalModelOptions {
 /** Map AI SDK generation options to local engine GenerateOptions. */
 function toGenerateOptions(options: LocalModelOptions): GenerateOptions {
   return {
-    maxNewTokens: options.maxOutputTokens ?? 512,
+    maxNewTokens: options.maxOutputTokens ?? DEFAULT_MAX_NEW_TOKENS,
     temperature: options.temperature ?? 0.7,
     topP: options.topP,
     topK: options.topK,
@@ -105,7 +107,7 @@ export function createLocalModel(modelId?: string): LanguageModel {
     supportedUrls: {},
 
     async doGenerate(options: LocalModelOptions) {
-      const messages = convertPrompt(options.prompt as ReadonlyArray<PromptMessage>);
+      const messages = convertPrompt(options.prompt);
       const genOptions = toGenerateOptions(options);
 
       logger.debug(`[local] doGenerate: ${messages.length} messages → ${resolvedId}`);
@@ -139,7 +141,7 @@ export function createLocalModel(modelId?: string): LanguageModel {
         );
       }
 
-      const messages = convertPrompt(options.prompt as ReadonlyArray<PromptMessage>);
+      const messages = convertPrompt(options.prompt);
       const genOptions = toGenerateOptions(options);
 
       logger.debug(`[local] doStream: ${messages.length} messages → ${resolvedId}`);

package/src/src/provider/local/env.ts

@@ -2,7 +2,7 @@
  * Cross-platform environment helpers for local AI provider.
  *
  * Abstracts Deno/Node env access so all local-AI checks go through
- * a single function — no duplicated `(globalThis as any).Deno?.env` patterns.
+ * a single function — no duplicated `globalThis.Deno?.env` patterns.
  *
  * @module provider/local
  */
@@ -14,9 +14,11 @@
 import * as dntShim from "../../../_dnt.shims.js";
 
 export function isLocalAIDisabled(): boolean {
-  // deno-lint-ignore no-explicit-any
-  const denoVal = (dntShim.dntGlobalThis as any).Deno?.env?.get?.("VERYFRONT_DISABLE_LOCAL_AI");
-  if (denoVal === "1") return true;
+  const denoVal = (dntShim.dntGlobalThis as Record<string, unknown>).Deno as
+    | { env?: { get?: (key: string) => string | undefined } }
+    | undefined;
+  const denoEnvVal = denoVal?.env?.get?.("VERYFRONT_DISABLE_LOCAL_AI");
+  if (denoEnvVal === "1") return true;
 
   if (
     typeof process !== "undefined" &&

package/src/src/provider/local/local-embedding-engine.ts

@@ -14,8 +14,13 @@ import { getTransformers } from "./local-engine.js";
 
 const logger = serverLogger.component("local-embedding");
 
-// deno-lint-ignore no-explicit-any
-type Pipeline = any;
+interface EmbeddingOutput {
+  tolist(): number[][];
+}
+
+interface Pipeline {
+  (texts: string[], options: { pooling: string; normalize: boolean }): Promise<EmbeddingOutput>;
+}
 
 /** Cached pipeline instances keyed by HuggingFace model ID */
 const pipelineCache = new Map<string, Pipeline>();
@@ -43,14 +48,14 @@ async function loadPipeline(modelInfo: ModelInfo): Promise<Pipeline> {
       `Loading local embedding model: ${modelInfo.hfId} (${modelInfo.dtype}, ~${modelInfo.sizeMB}MB)...`,
     );
 
-    const pipe = await transformers.pipeline(
+    const pipe = (await transformers.pipeline(
       "feature-extraction",
       modelInfo.hfId,
       {
         dtype: modelInfo.dtype,
         device: "cpu",
       },
-    );
+    )) as Pipeline;
 
     logger.info(`Embedding model loaded: ${modelInfo.hfId}`);
     pipelineCache.set(cacheKey, pipe);
@@ -84,5 +89,5 @@ export async function embedTexts(
   const pooling = modelInfo.pooling ?? "mean";
   const output = await pipe(texts, { pooling, normalize: true });
 
-  return output.tolist() as number[][];
+  return output.tolist();
 }

package/src/src/provider/local/local-engine.ts

@@ -19,6 +19,9 @@ import { isLocalAIDisabled } from "./env.js";
 
 const logger = serverLogger.component("local-llm");
 
+/** Default maximum new tokens for local model generation */
+const DEFAULT_MAX_NEW_TOKENS = 512;
+
 /** Chat message format expected by Transformers.js */
 export interface ChatMessage {
   role: "system" | "user" | "assistant";
@@ -34,10 +37,42 @@ export interface GenerateOptions {
   stopSequences?: string[];
 }
 
-// deno-lint-ignore no-explicit-any
-type TransformersModule = any;
-// deno-lint-ignore no-explicit-any
-type Pipeline = any;
+interface TransformersEnv {
+  cacheDir: string;
+  useBrowserCache: boolean;
+}
+
+interface TransformersModule {
+  env: TransformersEnv;
+  pipeline: (
+    task: string,
+    model: string,
+    options: { dtype: string; device: string },
+  ) => Promise<unknown>;
+  TextStreamer: new (
+    tokenizer: unknown,
+    options: {
+      skip_prompt: boolean;
+      skip_special_tokens: boolean;
+      callback_function: (text: string) => void;
+    },
+  ) => unknown;
+}
+
+interface Pipeline {
+  tokenizer: unknown;
+  (
+    messages: ChatMessage[],
+    options: {
+      max_new_tokens: number;
+      temperature: number;
+      top_p?: number;
+      top_k?: number;
+      do_sample: boolean;
+      streamer: unknown;
+    },
+  ): Promise<void>;
+}
 
 /** Cached pipeline instances keyed by HuggingFace model ID */
 const pipelineCache = new Map<string, Pipeline>();
@@ -45,7 +80,6 @@ const pipelineCache = new Map<string, Pipeline>();
 /** Whether a model is currently being loaded (prevents concurrent loads) */
 const loadingLocks = new Map<string, Promise<Pipeline>>();
 
-/** Lazily loaded @huggingface/transformers module */
 let transformersModule: TransformersModule | null = null;
 
 /**
@@ -66,26 +100,29 @@ export async function getTransformers(): Promise<TransformersModule> {
 
   logger.info("Loading @huggingface/transformers...");
 
+  let mod: TransformersModule;
   try {
-    transformersModule = await importTransformers();
-  } catch {
+    mod = await importTransformers();
+  } catch (_) {
+    // expected: ONNX runtime not available in some environments (e.g. compiled binaries)
     throw toError(
       createError({
         type: "no_ai_available",
         message:
           "Local AI model unavailable — native ONNX Runtime is not supported in this environment " +
-          "(e.g. compiled binaries). Set OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY " +
-          "in your .env file to use a cloud provider instead.",
+          "(e.g. compiled binaries). Set VERYFRONT_API_TOKEN and VERYFRONT_PROJECT_SLUG, or " +
+          "configure OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY to use a cloud provider instead.",
       }),
     );
   }
 
   // Configure cache directory for model files
-  transformersModule.env.cacheDir = "./.cache/models";
+  mod.env.cacheDir = "./.cache/models";
   // Disable browser-specific features in Node/Deno
-  transformersModule.env.useBrowserCache = false;
+  mod.env.useBrowserCache = false;
 
-  return transformersModule;
+  transformersModule = mod;
+  return mod;
 }
 
 /**
@@ -111,14 +148,14 @@ async function loadPipeline(modelInfo: ModelInfo): Promise<Pipeline> {
       `Loading local model: ${modelInfo.hfId} (${modelInfo.dtype}, ~${modelInfo.sizeMB}MB)...`,
     );
 
-    const pipe = await transformers.pipeline(
+    const pipe = (await transformers.pipeline(
       "text-generation",
       modelInfo.hfId,
       {
         dtype: modelInfo.dtype,
         device: "cpu",
       },
-    );
+    )) as Pipeline;
 
     logger.info(`Model loaded: ${modelInfo.hfId}`);
     pipelineCache.set(cacheKey, pipe);
@@ -148,8 +185,8 @@ async function loadPipeline(modelInfo: ModelInfo): Promise<Pipeline> {
           type: "no_ai_available",
           message:
             "Local AI model unavailable — native ONNX Runtime is not supported in this environment " +
-            "(e.g. compiled binaries). Set OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY " +
-            "in your .env file to use a cloud provider instead.",
+            "(e.g. compiled binaries). Set VERYFRONT_API_TOKEN and VERYFRONT_PROJECT_SLUG, or " +
+            "configure OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY to use a cloud provider instead.",
         }),
       );
     }
@@ -193,7 +230,7 @@ export async function* generateStream(
   const transformers = await getTransformers();
 
   const {
-    maxNewTokens = 512,
+    maxNewTokens = DEFAULT_MAX_NEW_TOKENS,
     temperature = 0.7,
     topP,
     topK,
@@ -204,40 +241,38 @@ export async function* generateStream(
   let resolveWaiting: (() => void) | null = null;
   let done = false;
 
+  function flushWaiting(): void {
+    if (resolveWaiting) {
+      resolveWaiting();
+      resolveWaiting = null;
+    }
+  }
+
   const streamer = new transformers.TextStreamer(pipe.tokenizer, {
     skip_prompt: true,
     skip_special_tokens: true,
     callback_function: (text: string) => {
       tokenQueue.push(text);
-      if (resolveWaiting) {
-        resolveWaiting();
-        resolveWaiting = null;
-      }
+      flushWaiting();
     },
   });
 
   // Start generation in the background
-  const generatePromise = pipe(messages, {
-    max_new_tokens: maxNewTokens,
-    temperature,
-    top_p: topP,
-    top_k: topK,
-    do_sample: temperature > 0,
-    streamer,
-  }).then(() => {
-    done = true;
-    if (resolveWaiting) {
-      resolveWaiting();
-      resolveWaiting = null;
-    }
-  }).catch((error: Error) => {
-    done = true;
-    if (resolveWaiting) {
-      resolveWaiting();
-      resolveWaiting = null;
+  const generatePromise = (async () => {
+    try {
+      await pipe(messages, {
+        max_new_tokens: maxNewTokens,
+        temperature,
+        top_p: topP,
+        top_k: topK,
+        do_sample: temperature > 0,
+        streamer,
+      });
+    } finally {
+      done = true;
+      flushWaiting();
     }
-    throw error;
-  });
+  })();
 
   // Yield tokens as they arrive
   while (true) {

package/src/src/provider/model-registry.ts

@@ -29,6 +29,11 @@ import { DEFAULT_LOCAL_MODEL } from "./local/model-catalog.js";
 import { createLocalModel } from "./local/ai-sdk-adapter.js";
 import { isLocalAIDisabled } from "./local/env.js";
 import { verifyLocalRuntime } from "./local/local-engine.js";
+import {
+  getDefaultVeryfrontCloudModel,
+  isVeryfrontCloudEnabled,
+} from "../platform/cloud/resolver.js";
+import { createVeryfrontCloudModel } from "./veryfront-cloud/provider.js";
 
 const localLogger = serverLogger.component("local-llm");
 
@@ -135,19 +140,30 @@ function autoInitializeFromEnv(): void {
       return createLocalModel(id);
     });
   }
+
+  if (!manager.has("veryfront-cloud")) {
+    manager.registerShared("veryfront-cloud", (id) => {
+      return createVeryfrontCloudModel(id);
+    });
+  }
 }
 
 /**
  * Default cloud models to try when auto-upgrading from a local model.
- * Ordered by preference: Anthropic → OpenAI → Google.
+ * Ordered by preference: Veryfront Cloud → Anthropic → OpenAI → Google.
  *
  * NOTE: model IDs are hardcoded — update when default models change.
  */
 const CLOUD_UPGRADE_CANDIDATES: Array<{
   provider: string;
-  model: string;
+  model: string | (() => string);
   hasKey: () => boolean;
 }> = [
+  {
+    provider: "veryfront-cloud",
+    model: () => getDefaultVeryfrontCloudModel().replace(/^veryfront-cloud\//, ""),
+    hasKey: () => isVeryfrontCloudEnabled(),
+  },
   {
     provider: "anthropic",
     model: "claude-sonnet-4-20250514",
@@ -165,6 +181,15 @@ const CLOUD_UPGRADE_CANDIDATES: Array<{
   },
 ];
 
+function isMissingProviderConfiguration(errorData: ReturnType<typeof fromError>): boolean {
+  if (errorData?.type !== "config") return false;
+
+  const message = errorData.message.toLowerCase();
+  return message.includes("not set") ||
+    message.includes("missing credentials") ||
+    message.includes("missing configuration");
+}
+
 /**
  * Find the first cloud provider with a valid API key.
  *
@@ -179,7 +204,8 @@ export function findAvailableCloudModel(): string | null {
   for (const { provider, model, hasKey } of CLOUD_UPGRADE_CANDIDATES) {
     if (!hasKey()) continue;
     if (!manager.has(provider)) continue;
-    return `${provider}/${model}`;
+    const resolvedModel = typeof model === "function" ? model() : model;
+    return `${provider}/${resolvedModel}`;
   }
   return null;
 }
@@ -238,7 +264,11 @@ export function resolveModel(modelString: string): LanguageModel {
     // Auto-fallback: when a cloud provider fails due to missing API key,
     // transparently switch to the local model so chat works out of the box.
     const errorData = fromError(error);
-    if (errorData?.type === "config" && providerName !== "local" && manager.has("local")) {
+    if (
+      isMissingProviderConfiguration(errorData) &&
+      providerName !== "local" &&
+      manager.has("local")
+    ) {
       // Check if local AI is explicitly disabled (e.g., for testing)
       if (isLocalAIDisabled()) {
         throw toError(
@@ -250,7 +280,8 @@ export function resolveModel(modelString: string): LanguageModel {
       }
 
       localLogger.info(
-        `⚡ "${providerName}" unavailable (missing API key). Falling back to local model.`,
+        `⚡ "${providerName}" unavailable (missing credentials or configuration). ` +
+          "Falling back to local model.",
       );
       const localFactory = manager.get("local")!;
       return localFactory(DEFAULT_LOCAL_MODEL);

package/src/src/provider/veryfront-cloud/provider.ts

@@ -0,0 +1,62 @@
+import type { LanguageModel } from "ai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createError, toError } from "../../errors/veryfront-error.js";
+import {
+  createVeryfrontCloudFetch,
+  getVeryfrontCloudGatewayBaseUrl,
+  parseVeryfrontCloudModelId,
+  requireVeryfrontCloudBootstrap,
+} from "./shared.js";
+
+export function createVeryfrontCloudModel(modelId: string): LanguageModel {
+  const { provider, modelId: upstreamModelId } = parseVeryfrontCloudModelId(modelId, "language");
+  const { apiBaseUrl, apiToken } = requireVeryfrontCloudBootstrap();
+  const baseURL = getVeryfrontCloudGatewayBaseUrl(apiBaseUrl, provider);
+  const fetch = createVeryfrontCloudFetch(apiToken);
+
+  switch (provider) {
+    case "anthropic":
+      return createAnthropic({
+        authToken: apiToken,
+        baseURL,
+        name: "veryfront-cloud",
+        fetch,
+      })(upstreamModelId);
+
+    case "openai":
+      return createOpenAI({
+        apiKey: apiToken,
+        baseURL,
+        name: "veryfront-cloud",
+        fetch,
+      })(upstreamModelId);
+
+    case "google":
+      return createGoogleGenerativeAI({
+        apiKey: apiToken,
+        baseURL,
+        name: "veryfront-cloud",
+        fetch,
+      })(upstreamModelId);
+
+    case "moonshotai":
+      return createOpenAI({
+        apiKey: apiToken,
+        baseURL,
+        name: "veryfront-cloud",
+        fetch,
+      })(upstreamModelId);
+
+    default: {
+      const _exhaustive: never = provider;
+      throw toError(
+        createError({
+          type: "config",
+          message: `Language provider "${_exhaustive}" is not supported for veryfront-cloud.`,
+        }),
+      );
+    }
+  }
+}

package/src/src/provider/veryfront-cloud/shared.ts

@@ -0,0 +1,136 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { createError, toError } from "../../errors/veryfront-error.js";
+import { getVeryfrontCloudBootstrap } from "../../platform/cloud/resolver.js";
+
+export type VeryfrontCloudProviderId =
+  | "anthropic"
+  | "openai"
+  | "google"
+  | "moonshotai";
+
+interface ParsedVeryfrontCloudModelId {
+  provider: VeryfrontCloudProviderId;
+  modelId: string;
+}
+
+const PROVIDER_ALIASES: Record<string, VeryfrontCloudProviderId> = {
+  anthropic: "anthropic",
+  openai: "openai",
+  google: "google",
+  "google-ai-studio": "google",
+  moonshotai: "moonshotai",
+};
+
+const GATEWAY_PATHS: Record<VeryfrontCloudProviderId, string> = {
+  anthropic: "ai/gateway/anthropic/v1",
+  openai: "ai/gateway/openai/v1",
+  google: "ai/gateway/google/v1beta",
+  moonshotai: "ai/gateway/moonshotai/v1",
+};
+
+function joinUrl(base: string, path: string): string {
+  return `${base.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+
+export function parseVeryfrontCloudModelId(
+  modelId: string,
+  kind: "language" | "embedding",
+): ParsedVeryfrontCloudModelId {
+  const slashIndex = modelId.indexOf("/");
+  if (slashIndex === -1) {
+    throw toError(
+      createError({
+        type: "config",
+        message: `Invalid veryfront-cloud model string: "${modelId}". Expected ` +
+          `"veryfront-cloud/provider/model".`,
+      }),
+    );
+  }
+
+  const rawProvider = modelId.slice(0, slashIndex);
+  const normalizedProvider = PROVIDER_ALIASES[rawProvider];
+  const upstreamModelId = modelId.slice(slashIndex + 1);
+
+  if (!normalizedProvider || !upstreamModelId) {
+    throw toError(
+      createError({
+        type: "config",
+        message: `Invalid veryfront-cloud model string: "${modelId}". Expected ` +
+          `"veryfront-cloud/provider/model".`,
+      }),
+    );
+  }
+
+  if (
+    kind === "embedding" && normalizedProvider !== "openai" &&
+    normalizedProvider !== "google"
+  ) {
+    throw toError(
+      createError({
+        type: "config",
+        message: `Embedding provider "${rawProvider}" is not supported for veryfront-cloud. ` +
+          `Supported providers: openai, google.`,
+      }),
+    );
+  }
+
+  return {
+    provider: normalizedProvider,
+    modelId: upstreamModelId,
+  };
+}
+
+export function requireVeryfrontCloudBootstrap(): {
+  apiBaseUrl: string;
+  apiToken: string;
+  projectSlug?: string;
+} {
+  const bootstrap = getVeryfrontCloudBootstrap();
+
+  if (!bootstrap.apiToken) {
+    throw toError(
+      createError({
+        type: "config",
+        message:
+          "VERYFRONT_API_TOKEN not set. Set the environment variable or provide request-scoped " +
+          "Veryfront credentials before using veryfront-cloud providers.",
+      }),
+    );
+  }
+
+  return {
+    apiBaseUrl: bootstrap.apiBaseUrl,
+    apiToken: bootstrap.apiToken,
+    projectSlug: bootstrap.projectSlug,
+  };
+}
+
+export function getVeryfrontCloudGatewayBaseUrl(
+  apiBaseUrl: string,
+  provider: VeryfrontCloudProviderId,
+): string {
+  return joinUrl(apiBaseUrl, GATEWAY_PATHS[provider]);
+}
+
+/**
+ * Creates a fetch wrapper that replaces all SDK-injected auth headers with
+ * a single `Authorization: Bearer` header for the Veryfront Cloud gateway.
+ *
+ * AI SDK providers set their own native auth headers (`x-api-key` for
+ * Anthropic, `x-goog-api-key` for Google, `Authorization` for OpenAI).
+ * The gateway expects only Bearer auth, so we strip all provider-specific
+ * headers to prevent credential leakage to the wrong auth path.
+ */
+export function createVeryfrontCloudFetch(apiToken: string): typeof dntShim.fetch {
+  return (input, init) => {
+    const request = new dntShim.Request(input, init);
+    const headers = new dntShim.Headers(request.headers);
+
+    headers.delete("x-api-key");
+    headers.delete("x-goog-api-key");
+    headers.delete("Authorization");
+    headers.set("Authorization", `Bearer ${apiToken}`);
+
+    return dntShim.fetch(new dntShim.Request(request, { headers }));
+  };
+}