veryfront 0.1.128 → 0.1.129

package/src/src/prompt/types.ts

@@ -1,5 +1,4 @@
-// Re-export schema-based type
-export type { PromptConfig } from "./schemas/index.js";
+export type { PromptConfig } from "./schemas/prompt.schema.js";
 
 export interface Prompt {
   id: string;

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

@@ -13,8 +13,8 @@ import { generate, generateStream } from "./local-engine.js";
 import type { ChatMessage, GenerateOptions } from "./local-engine.js";
 import { DEFAULT_LOCAL_MODEL } from "./model-catalog.js";
 import { serverLogger } from "../../utils/index.js";
-import { createError, fromError, toError } from "../../errors/veryfront-error.js";
-import { isLocalAIDisabled } from "./env.js";
+import { fromError } from "../../errors/veryfront-error.js";
+import { throwIfLocalAIDisabled } from "./env.js";
 
 const logger = serverLogger.component("local-llm");
 
@@ -132,14 +132,7 @@ export function createLocalModel(modelId?: string): LanguageModel {
       // Note: getTransformers() in local-engine.ts also checks this, but we need
       // the check here too because doStream creates a ReadableStream wrapper and
       // errors inside it would be swallowed as in-band stream errors.
-      if (isLocalAIDisabled()) {
-        throw toError(
-          createError({
-            type: "no_ai_available",
-            message: "Local AI disabled via VERYFRONT_DISABLE_LOCAL_AI environment variable.",
-          }),
-        );
-      }
+      throwIfLocalAIDisabled();
 
       const messages = convertPrompt(options.prompt);
       const genOptions = toGenerateOptions(options);

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

@@ -6,13 +6,18 @@
  *
  * @module provider/local
  */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+import { createError, toError } from "../../errors/veryfront-error.js";
+
+const LOCAL_AI_DISABLED_MESSAGE =
+  "Local AI disabled via VERYFRONT_DISABLE_LOCAL_AI environment variable.";
 
 /**
  * Check whether local AI is explicitly disabled via environment variable.
  * Works in Deno, Node, and compiled binaries.
  */
-import * as dntShim from "../../../_dnt.shims.js";
-
 export function isLocalAIDisabled(): boolean {
   const denoVal = (dntShim.dntGlobalThis as Record<string, unknown>).Deno as
     | { env?: { get?: (key: string) => string | undefined } }
@@ -29,3 +34,18 @@ export function isLocalAIDisabled(): boolean {
 
   return false;
 }
+
+export function createLocalAIDisabledError(): Error {
+  return toError(
+    createError({
+      type: "no_ai_available",
+      message: LOCAL_AI_DISABLED_MESSAGE,
+    }),
+  );
+}
+
+export function throwIfLocalAIDisabled(): void {
+  if (isLocalAIDisabled()) {
+    throw createLocalAIDisabledError();
+  }
+}

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

@@ -15,7 +15,7 @@ import { serverLogger } from "../../utils/index.js";
 import { createError, toError } from "../../errors/veryfront-error.js";
 import { importTransformers } from "../../platform/compat/opaque-deps.js";
 import { DEFAULT_LOCAL_MODEL, type ModelInfo, resolveLocalModel } from "./model-catalog.js";
-import { isLocalAIDisabled } from "./env.js";
+import { throwIfLocalAIDisabled } from "./env.js";
 
 const logger = serverLogger.component("local-llm");
 
@@ -89,14 +89,7 @@ let transformersModule: TransformersModule | null = null;
 export async function getTransformers(): Promise<TransformersModule> {
   if (transformersModule) return transformersModule;
 
-  if (isLocalAIDisabled()) {
-    throw toError(
-      createError({
-        type: "no_ai_available",
-        message: "Local AI disabled via VERYFRONT_DISABLE_LOCAL_AI environment variable.",
-      }),
-    );
-  }
+  throwIfLocalAIDisabled();
 
   logger.info("Loading @huggingface/transformers...");
 

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

@@ -27,7 +27,7 @@ import { ProjectScopedRegistryManager } from "../ai/registry-manager.js";
 import { serverLogger } from "../utils/index.js";
 import { DEFAULT_LOCAL_MODEL } from "./local/model-catalog.js";
 import { createLocalModel } from "./local/ai-sdk-adapter.js";
-import { isLocalAIDisabled } from "./local/env.js";
+import { throwIfLocalAIDisabled } from "./local/env.js";
 import { verifyLocalRuntime } from "./local/local-engine.js";
 import {
   getDefaultVeryfrontCloudModel,
@@ -270,14 +270,7 @@ export function resolveModel(modelString: string): LanguageModel {
       manager.has("local")
     ) {
       // Check if local AI is explicitly disabled (e.g., for testing)
-      if (isLocalAIDisabled()) {
-        throw toError(
-          createError({
-            type: "no_ai_available",
-            message: "Local AI disabled via VERYFRONT_DISABLE_LOCAL_AI environment variable.",
-          }),
-        );
-      }
+      throwIfLocalAIDisabled();
 
       localLogger.info(
         `⚡ "${providerName}" unavailable (missing credentials or configuration). ` +

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

@@ -25,14 +25,6 @@ export function createVeryfrontCloudModel(modelId: string): LanguageModel {
         fetch,
       })(upstreamModelId);
 
-    case "openai":
-      return createOpenAI({
-        apiKey: apiToken,
-        baseURL,
-        name: "veryfront-cloud",
-        fetch,
-      })(upstreamModelId);
-
     case "google":
       return createGoogleGenerativeAI({
         apiKey: apiToken,
@@ -41,6 +33,7 @@ export function createVeryfrontCloudModel(modelId: string): LanguageModel {
         fetch,
       })(upstreamModelId);
 
+    case "openai":
     case "moonshotai":
       return createOpenAI({
         apiKey: apiToken,

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

@@ -32,19 +32,23 @@ function joinUrl(base: string, path: string): string {
   return `${base.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
 }
 
+function createInvalidModelIdError(modelId: string): Error {
+  return toError(
+    createError({
+      type: "config",
+      message: `Invalid veryfront-cloud model string: "${modelId}". Expected ` +
+        `"veryfront-cloud/provider/model".`,
+    }),
+  );
+}
+
 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".`,
-      }),
-    );
+    throw createInvalidModelIdError(modelId);
   }
 
   const rawProvider = modelId.slice(0, slashIndex);
@@ -52,13 +56,7 @@ export function parseVeryfrontCloudModelId(
   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".`,
-      }),
-    );
+    throw createInvalidModelIdError(modelId);
   }
 
   if (
@@ -128,7 +126,6 @@ export function createVeryfrontCloudFetch(apiToken: string): typeof dntShim.fetc
 
     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 }));

package/src/src/proxy/handler.ts

@@ -210,7 +210,7 @@ function extractUserToken(cookieHeader: string): string | undefined {
   return match?.[1] ? decodeURIComponent(match[1]) : undefined;
 }
 
-function getStatusFromError(error: unknown): number | null {
+function parseStatusFromError(error: unknown): number | null {
   const message = error instanceof Error ? error.message : String(error);
   const match = message.match(/failed: (\d+)/);
   return match ? Number(match[1]) : null;
@@ -392,6 +392,75 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
     return `https://veryfront.com/sign-in?from=${encodeURIComponent(returnPath)}`;
   }
 
+  function makePreviewProjectNotFoundContext(
+    base: {
+      scope: TokenScope;
+      host: string;
+      parsedDomain: ParsedDomain;
+    },
+    token?: string,
+  ): ProxyContext {
+    return makeErrorContext(
+      base,
+      404,
+      "Preview project not found",
+      token,
+      undefined,
+      "project-not-found",
+    );
+  }
+
+  async function resolveRequestToken(
+    req: dntShim.Request,
+    scope: TokenScope,
+    host: string,
+    projectSlug: string | undefined,
+    options: {
+      allowSignedInternalControlPlaneToken?: boolean;
+      tokenFetchErrorMessage: string;
+    },
+  ): Promise<{ token?: string; userToken?: string; tokenFetchError?: unknown }> {
+    const userToken = extractUserToken(req.headers.get("cookie") ?? "");
+    const useSignedInternalControlPlaneToken = options.allowSignedInternalControlPlaneToken &&
+      isSignedInternalControlPlaneRequest(req);
+
+    let token: string | undefined;
+    let tokenFetchError: unknown;
+
+    if (useSignedInternalControlPlaneToken) {
+      token = req.headers.get("x-token") ?? undefined;
+      logger?.debug("Using signed control-plane token for internal request", {
+        pathname: new URL(req.url).pathname,
+        scope,
+      });
+    } else if (scope === "preview" && userToken) {
+      token = userToken;
+      logger?.debug("Using user auth token for preview");
+    }
+
+    if (!token && config.apiClientId && config.apiClientSecret) {
+      const customDomain = projectSlug ? undefined : host;
+      if (projectSlug || customDomain) {
+        try {
+          token = await tokenManager.getToken(scope, projectSlug, customDomain);
+        } catch (error) {
+          tokenFetchError = error;
+          logger?.error(options.tokenFetchErrorMessage, error as Error, {
+            projectSlug,
+            customDomain,
+          });
+        }
+      }
+    }
+
+    if (!token && config.apiToken) {
+      token = config.apiToken;
+      logger?.debug("Using static API token fallback");
+    }
+
+    return { token, userToken, tokenFetchError };
+  }
+
   async function checkProtectedAccess(
     req: dntShim.Request,
     matchingEnv: NonNullable<DomainLookupResult["environments"]>[number] | undefined,
@@ -486,6 +555,7 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
     const host = rawHost.replace(/:\d+$/, "");
     const parsedDomain = parseProjectDomain(host);
     const scope = getScope(parsedDomain.environment);
+    const base = { scope, host, parsedDomain };
 
     let projectSlug = parsedDomain.slug ?? undefined;
     let projectId: string | undefined;
@@ -494,7 +564,7 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
 
     const isCustomDomain = !projectSlug && !parsedDomain.isVeryfrontDomain;
 
-    if (!projectSlug && parsedDomain.isVeryfrontDomain && !isCustomDomain) {
+    if (!projectSlug && parsedDomain.isVeryfrontDomain) {
       return {
         token: undefined,
         projectSlug: undefined,
@@ -519,58 +589,29 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
       isCustomDomain,
     });
 
-    const cookieHeader = req.headers.get("cookie") ?? "";
-    const userToken = extractUserToken(cookieHeader);
-    const signedInternalControlPlaneRequest = isSignedInternalControlPlaneRequest(req);
-
+    let userToken: string | undefined;
     let token: string | undefined;
     let tokenFetchError: unknown;
 
     if (isLocalProject) {
       logger?.debug("Local project, skipping token fetch", { localPath });
     } else {
-      if (signedInternalControlPlaneRequest) {
-        token = req.headers.get("x-token") ?? undefined;
-        logger?.debug("Using signed control-plane token for internal request", {
-          pathname: new URL(req.url).pathname,
-          scope,
-        });
-      } else if (scope === "preview" && userToken) {
-        token = userToken;
-        logger?.debug("Using user auth token for preview");
-      }
-
-      if (!token && config.apiClientId && config.apiClientSecret) {
-        const customDomain = projectSlug ? undefined : host;
-        if (projectSlug || customDomain) {
-          try {
-            token = await tokenManager.getToken(scope, projectSlug, customDomain);
-          } catch (error) {
-            tokenFetchError = error;
-            logger?.error("Token fetch failed", error as Error, { projectSlug, customDomain });
-          }
-        }
-      }
-
-      if (!token && config.apiToken) {
-        token = config.apiToken;
-        logger?.debug("Using static API token fallback");
-      }
-
-      const base = { scope, host, parsedDomain };
+      ({ token, userToken, tokenFetchError } = await resolveRequestToken(
+        req,
+        scope,
+        host,
+        projectSlug,
+        {
+          allowSignedInternalControlPlaneToken: true,
+          tokenFetchErrorMessage: "Token fetch failed",
+        },
+      ));
 
       if (projectSlug && scope === "preview" && !token) {
-        const status = getStatusFromError(tokenFetchError);
+        const status = parseStatusFromError(tokenFetchError);
         if (status === 404) {
           logger?.info("Preview project not found", { projectSlug, host });
-          return makeErrorContext(
-            base,
-            404,
-            "Preview project not found",
-            undefined,
-            undefined,
-            "project-not-found",
-          );
+          return makePreviewProjectNotFoundContext(base);
         }
 
         logger?.warn("Preview request has no usable token", {
@@ -686,14 +727,7 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
 
         if (!resolved.projectId) {
           logger?.info("Preview project not found after lookup", { projectSlug, host });
-          return makeErrorContext(
-            base,
-            404,
-            "Preview project not found",
-            token,
-            undefined,
-            "project-not-found",
-          );
+          return makePreviewProjectNotFoundContext(base, token);
         }
 
         projectId = resolved.projectId;
@@ -754,28 +788,10 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
     const parsedDomain = parseProjectDomain(host);
     const scope = getScope(parsedDomain.environment);
     const projectSlug = parsedDomain.slug ?? undefined;
-
-    if (scope === "preview") {
-      const cookieHeader = req.headers.get("cookie") ?? "";
-      const userToken = extractUserToken(cookieHeader);
-      if (userToken) return userToken;
-    }
-
-    if (config.apiClientId && config.apiClientSecret) {
-      const customDomain = projectSlug ? undefined : host;
-      if (projectSlug || customDomain) {
-        try {
-          return await tokenManager.getToken(scope, projectSlug, customDomain);
-        } catch (error) {
-          logger?.error("Token fetch failed for API", error as Error, {
-            projectSlug,
-            customDomain,
-          });
-        }
-      }
-    }
-
-    return config.apiToken;
+    const { token } = await resolveRequestToken(req, scope, host, projectSlug, {
+      tokenFetchErrorMessage: "Token fetch failed for API",
+    });
+    return token;
   }
 
   async function getStats() {

package/src/src/react/compat/hooks-adapter.ts

@@ -16,6 +16,19 @@ function hasReactHook(hookName: string): boolean {
   return typeof (React as Record<string, unknown>)[hookName] === "function";
 }
 
+function createDefaultFormStatus(): FormStatus {
+  return { pending: false, data: null, method: null, action: null };
+}
+
+function supportsConcurrentHooks(): boolean {
+  const { isReact18, isReact19 } = getReactVersionInfo();
+  return isReact18 || isReact19;
+}
+
+function warnHookFallback(hookName: string, fallbackDescription: string): void {
+  logger.warn(`${hookName} not available, ${fallbackDescription}`);
+}
+
 export function createTransitionFallbackScheduler(
   onPendingChange: (pending: boolean) => void,
 ): {
@@ -45,14 +58,14 @@ export function createTransitionFallbackScheduler(
 
 export function useFormStatusCompat(): FormStatus {
   if (!hasFeature("useFormStatus") || !hasReactHook("useFormStatus")) {
-    return { pending: false, data: null, method: null, action: null };
+    return createDefaultFormStatus();
   }
 
   try {
     return (React as typeof React & { useFormStatus: () => FormStatus }).useFormStatus();
-  } catch (_) {
-    logger.warn("useFormStatus not available in current React version");
-    return { pending: false, data: null, method: null, action: null };
+  } catch {
+    warnHookFallback("useFormStatus", "falling back to the default idle state");
+    return createDefaultFormStatus();
   }
 }
 
@@ -70,8 +83,8 @@ export function useOptimisticCompat<State, OptimisticState = State>(
           ) => [S, (action: OptimisticStateAction<O>) => void];
         }
       ).useOptimistic(state, updateFn);
-    } catch (_) {
-      logger.warn("useOptimistic not available in current React version");
+    } catch {
+      warnHookFallback("useOptimistic", "falling back to React.useState");
     }
   }
 
@@ -107,13 +120,11 @@ export function useOptimisticCompat<State, OptimisticState = State>(
 }
 
 export function useTransitionCompat(): ReturnType<typeof React.useTransition> {
-  const versionInfo = getReactVersionInfo();
-
-  if (versionInfo.isReact18 || versionInfo.isReact19) {
+  if (supportsConcurrentHooks()) {
     try {
       return React.useTransition();
-    } catch (_) {
-      logger.warn("useTransition not available, falling back to mock");
+    } catch {
+      warnHookFallback("useTransition", "falling back to the timeout scheduler");
     }
   }
 
@@ -138,13 +149,11 @@ export function useTransitionCompat(): ReturnType<typeof React.useTransition> {
 }
 
 export function useDeferredValueCompat<T>(value: T): T {
-  const versionInfo = getReactVersionInfo();
-
-  if (versionInfo.isReact18 || versionInfo.isReact19) {
+  if (supportsConcurrentHooks()) {
     try {
       return React.useDeferredValue(value);
-    } catch (_) {
-      logger.warn("useDeferredValue not available, returning value directly");
+    } catch {
+      warnHookFallback("useDeferredValue", "returning the value directly");
     }
   }
 
@@ -154,13 +163,11 @@ export function useDeferredValueCompat<T>(value: T): T {
 let idCounter = 0;
 
 export function useIdCompat(): string {
-  const versionInfo = getReactVersionInfo();
-
-  if (versionInfo.isReact18 || versionInfo.isReact19) {
+  if (supportsConcurrentHooks()) {
     try {
       return React.useId();
-    } catch (_) {
-      logger.warn("useId not available, using fallback");
+    } catch {
+      warnHookFallback("useId", "using the incremental fallback id");
     }
   }
 
@@ -191,16 +198,18 @@ export interface CompatHooks {
   useId: typeof useIdCompat;
 }
 
+const defaultCompatHooks: CompatHooks = {
+  useFormStatus: useFormStatusCompat,
+  useOptimistic: useOptimisticCompat,
+  useTransition: useTransitionCompat,
+  useDeferredValue: useDeferredValueCompat,
+  useId: useIdCompat,
+};
+
 let compatHooksContext: React.Context<CompatHooks> | null = null;
 
 function getCompatHooksContext(): React.Context<CompatHooks> {
-  compatHooksContext ??= React.createContext<CompatHooks>({
-    useFormStatus: useFormStatusCompat,
-    useOptimistic: useOptimisticCompat,
-    useTransition: useTransitionCompat,
-    useDeferredValue: useDeferredValueCompat,
-    useId: useIdCompat,
-  });
+  compatHooksContext ??= React.createContext<CompatHooks>(defaultCompatHooks);
 
   return compatHooksContext;
 }
@@ -222,21 +231,11 @@ export function CompatHooksProvider({
 }: {
   children: React.ReactNode;
 }): React.ReactElement {
-  const hooks: CompatHooks = {
-    useFormStatus: useFormStatusCompat,
-    useOptimistic: useOptimisticCompat,
-    useTransition: useTransitionCompat,
-    useDeferredValue: useDeferredValueCompat,
-    useId: useIdCompat,
-  };
-
-  return React.createElement(getCompatHooksContext().Provider, { value: hooks }, children);
+  return React.createElement(
+    getCompatHooksContext().Provider,
+    { value: defaultCompatHooks },
+    children,
+  );
 }
 
-export const compatHooks = {
-  useFormStatus: useFormStatusCompat,
-  useOptimistic: useOptimisticCompat,
-  useTransition: useTransitionCompat,
-  useDeferredValue: useDeferredValueCompat,
-  useId: useIdCompat,
-} as const;
+export const compatHooks = defaultCompatHooks;