veryfront 0.1.13 → 0.1.15

package/src/src/build/production-build/templates.ts

@@ -5,39 +5,9 @@
  */
 
 /**
- * Client-side CSS styles for loading states, error display, and prose formatting
+ * Client-side CSS styles for error display in production builds
  */
-export const CLIENT_STYLES = `body {
-  margin: 0;
-  font-family:
-    -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
-  line-height: 1.5;
-}
-
-.loading-container {
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  min-height: 100vh;
-  background: #f9fafb;
-}
-
-.loading-spinner {
-  width: 40px;
-  height: 40px;
-  border: 3px solid #e5e7eb;
-  border-top-color: #3b82f6;
-  border-radius: 50%;
-  animation: spin 1s linear infinite;
-}
-
-@keyframes spin {
-  to {
-    transform: rotate(360deg);
-  }
-}
-
-.error-container {
+export const CLIENT_STYLES = `.error-container {
   max-width: 600px;
   margin: 2rem auto;
   padding: 2rem;
@@ -45,42 +15,6 @@ export const CLIENT_STYLES = `body {
   border: 1px solid #fcc;
   border-radius: 8px;
   color: #c00;
-}
-
-.prose {
-  max-width: 65ch;
-  margin: 0 auto;
-  padding: 2rem;
-}
-
-.prose h1, .prose h2, .prose h3 {
-  margin-top: 2em;
-  margin-bottom: 1em;
-}
-
-.prose p {
-  margin-bottom: 1.5em;
-}
-
-.prose code {
-  background: #f3f4f6;
-  padding: 0.2em 0.4em;
-  border-radius: 3px;
-  font-size: 0.875em;
-}
-
-.prose pre {
-  background: #1f2937;
-  color: #f9fafb;
-  padding: 1em;
-  border-radius: 8px;
-  overflow-x: auto;
-}
-
-.prose pre code {
-  background: transparent;
-  padding: 0;
-  color: inherit;
 }`;
 
 /**

package/src/src/chat/index.ts

@@ -98,7 +98,9 @@ export type { AgentTheme, ChatTheme } from "../react/components/ai/theme.js";
 
 export { useChat } from "../agent/react/use-chat/index.js";
 export type {
+  BrowserInferenceStatus,
   DynamicToolUIPart,
+  InferenceMode,
   OnToolCallArg,
   ReasoningUIPart,
   TextUIPart,

package/src/src/errors/veryfront-error.ts

@@ -75,7 +75,8 @@ export type VeryfrontErrorData =
   | { type: "file"; message: string; context?: FileContext }
   | { type: "network"; message: string; context?: NetworkContext }
   | { type: "permission"; message: string; context?: FileContext }
-  | { type: "not_supported"; message: string; feature?: string };
+  | { type: "not_supported"; message: string; feature?: string }
+  | { type: "no_ai_available"; message: string };
 
 export function createError(error: VeryfrontErrorData): VeryfrontErrorData {
   return error;

package/src/src/platform/adapters/runtime/deno/adapter.ts

@@ -393,16 +393,38 @@ export class DenoAdapter implements RuntimeAdapter {
       }
       : handler;
 
-    const server = dntShim.Deno.serve({
+    // Access native Deno.serve via `self` to bypass dnt shim transform.
+    // dnt rewrites both `Deno.*` and `globalThis.*` to use @deno/shim-deno which lacks .serve.
+    // `self` is not shimmed by dnt and equals `globalThis` in Deno.
+    const nativeDeno = (self as unknown as Record<string, typeof dntShim.Deno>)["Deno"]!;
+
+    // Access native Response via `self` to bypass dnt shim transform.
+    // In npm packages, dnt replaces Response with undici's polyfill,
+    // but Deno.serve requires native Response instances.
+    const NativeResponse = (self as unknown as { Response: typeof dntShim.Response })
+      .Response;
+
+    const server = nativeDeno.serve({
       port,
       hostname,
       signal,
       handler: async (request) => {
         try {
-          return await wrappedHandler(request);
+          const response: dntShim.Response = await wrappedHandler(request);
+          // If already native (compiled binary), return as-is
+          if (response instanceof NativeResponse) return response;
+          // Re-wrap polyfilled Response as native Response.
+          // dnt replaces Response with undici's polyfill which fails
+          // Deno.serve's native instanceof check.
+          const r = response as unknown as dntShim.Response;
+          return new NativeResponse(r.body, {
+            status: r.status,
+            statusText: r.statusText,
+            headers: r.headers,
+          });
         } catch (error) {
           serverLogger.error("Request handler error:", error);
-          return new dntShim.Response("Internal Server Error", { status: 500 });
+          return new NativeResponse("Internal Server Error", { status: 500 });
         }
       },
       onListen: (params) => {

package/src/src/platform/compat/http/deno-server.ts

@@ -13,7 +13,34 @@ export class DenoHttpServer implements HttpServer {
 
     onListen?.({ hostname, port });
 
-    await dntShim.Deno.serve({ port, hostname, signal: serveSignal }, handler);
+    // Access native Deno.serve via `self` to bypass dnt shim transform.
+    const nativeDeno = (self as unknown as Record<string, typeof dntShim.Deno>)["Deno"]!;
+
+    // Access native Response via `self` to bypass dnt shim transform.
+    // In npm packages, dnt replaces Response with undici's polyfill,
+    // but Deno.serve requires native Response instances.
+    const NativeResponse = (self as unknown as { Response: typeof dntShim.Response })
+      .Response;
+
+    const wrappedHandler: Handler = async (req) => {
+      const response: dntShim.Response = await handler(req);
+      // If already native (compiled binary or WebSocket upgrade), return as-is
+      if (response instanceof NativeResponse) return response;
+      // Re-wrap polyfilled Response as native Response.
+      // At runtime, `response` may be an undici Response (from dnt shim) that
+      // fails Deno's native instanceof check. Cast to access its properties.
+      const r = response as unknown as dntShim.Response;
+      return new NativeResponse(r.body, {
+        status: r.status,
+        statusText: r.statusText,
+        headers: r.headers,
+      });
+    };
+
+    await nativeDeno.serve(
+      { port, hostname, signal: serveSignal },
+      wrappedHandler,
+    );
   }
 
   close(): Promise<void> {

package/src/src/provider/index.ts

@@ -20,6 +20,7 @@ import "../../_dnt.polyfills.js";
 
 export {
   clearModelProviders,
+  ensureModelReady,
   getRegisteredModelProviders,
   hasModelProvider,
   registerModelProvider,

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

@@ -0,0 +1,207 @@
+/**
+ * AI SDK Adapter for Local Models
+ *
+ * Bridges `@huggingface/transformers` local inference to the AI SDK
+ * `LanguageModelV2` interface. This allows `streamText()` and
+ * `generateText()` to work with local models seamlessly.
+ *
+ * @module provider/local
+ */
+
+import type { LanguageModel } from "ai";
+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";
+
+const logger = serverLogger.component("local-llm");
+
+/**
+ * Convert AI SDK LanguageModelV2 prompt format to simple ChatMessage array.
+ *
+ * The AI SDK prompt is an array of message objects with role and content arrays.
+ * We extract text content for the local model.
+ */
+// deno-lint-ignore no-explicit-any
+function convertPrompt(prompt: any[]): ChatMessage[] {
+  const messages: ChatMessage[] = [];
+
+  for (const msg of prompt) {
+    const role = msg.role as "system" | "user" | "assistant" | "tool";
+    // Skip tool messages — local models don't support tool calling
+    if (role === "tool") continue;
+
+    const mappedRole = role === "system" ? "system" : role === "user" ? "user" : "assistant";
+
+    // Extract text content from content array
+    let text = "";
+    if (typeof msg.content === "string") {
+      text = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part.type === "text" && typeof part.text === "string") {
+          text += part.text;
+        }
+      }
+    }
+
+    if (text) {
+      messages.push({ role: mappedRole, content: text });
+    }
+  }
+
+  return messages;
+}
+
+/**
+ * Create a local AI SDK LanguageModel for the given model ID.
+ *
+ * The returned object implements the LanguageModelV2 interface, making it
+ * compatible with all AI SDK functions (`streamText`, `generateText`, etc.)
+ * and all VeryFront hooks (`useChat`).
+ */
+export function createLocalModel(modelId?: string): LanguageModel {
+  const resolvedId = modelId || DEFAULT_LOCAL_MODEL;
+
+  const model = {
+    /** Marker so ensureModelReady() can distinguish real local-engine models
+     *  from mock/custom providers that happen to use provider:"local". */
+    _isVfLocalModel: true as const,
+    specificationVersion: "v2" as const,
+    provider: "local",
+    modelId: `local/${resolvedId}`,
+
+    supportedUrls: {},
+
+    async doGenerate(options: {
+      prompt: unknown[];
+      maxOutputTokens?: number;
+      temperature?: number;
+      topP?: number;
+      topK?: number;
+      stopSequences?: string[];
+    }) {
+      const messages = convertPrompt(options.prompt as unknown[]);
+      const genOptions: GenerateOptions = {
+        maxNewTokens: options.maxOutputTokens ?? 512,
+        temperature: options.temperature ?? 0.7,
+        topP: options.topP,
+        topK: options.topK,
+        stopSequences: options.stopSequences,
+      };
+
+      logger.debug(`[local] doGenerate: ${messages.length} messages → ${resolvedId}`);
+
+      const text = await generate(resolvedId, messages, genOptions);
+
+      return {
+        content: [{ type: "text" as const, text }],
+        finishReason: "stop" as const,
+        usage: {
+          inputTokens: undefined,
+          outputTokens: undefined,
+          totalTokens: undefined,
+        },
+        warnings: [],
+      };
+    },
+
+    async doStream(options: {
+      prompt: unknown[];
+      maxOutputTokens?: number;
+      temperature?: number;
+      topP?: number;
+      topK?: number;
+      stopSequences?: string[];
+    }) {
+      // Eagerly check if local AI is disabled — must throw before creating the
+      // ReadableStream, otherwise the 200 response headers are already committed.
+      // 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.",
+          }),
+        );
+      }
+
+      const messages = convertPrompt(options.prompt as unknown[]);
+      const genOptions: GenerateOptions = {
+        maxNewTokens: options.maxOutputTokens ?? 512,
+        temperature: options.temperature ?? 0.7,
+        topP: options.topP,
+        topK: options.topK,
+        stopSequences: options.stopSequences,
+      };
+
+      logger.debug(`[local] doStream: ${messages.length} messages → ${resolvedId}`);
+
+      const textId = `text-${Date.now()}`;
+
+      const stream = new ReadableStream({
+        async start(controller) {
+          try {
+            // Emit stream-start
+            controller.enqueue({ type: "stream-start", warnings: [] });
+
+            // Emit response metadata
+            controller.enqueue({
+              type: "response-metadata",
+              id: `local-${Date.now()}`,
+              timestamp: new Date(),
+              modelId: `local/${resolvedId}`,
+            });
+
+            // Emit text-start
+            controller.enqueue({ type: "text-start", id: textId });
+
+            // Stream tokens
+            for await (const token of generateStream(resolvedId, messages, genOptions)) {
+              controller.enqueue({
+                type: "text-delta",
+                id: textId,
+                delta: token,
+              });
+            }
+
+            // Emit text-end
+            controller.enqueue({ type: "text-end", id: textId });
+
+            // Emit finish
+            controller.enqueue({
+              type: "finish",
+              finishReason: "stop",
+              usage: {
+                inputTokens: undefined,
+                outputTokens: undefined,
+                totalTokens: undefined,
+              },
+            });
+
+            controller.close();
+          } catch (error) {
+            // Let no_ai_available propagate — the chat handler needs it
+            // for a proper 503 response instead of a 200 with in-band error.
+            const vfError = fromError(error);
+            if (vfError?.type === "no_ai_available") throw error;
+
+            controller.enqueue({
+              type: "error",
+              error: error instanceof Error ? error : new Error(String(error)),
+            });
+            controller.close();
+          }
+        },
+      });
+
+      return { stream };
+    },
+  };
+
+  return model as LanguageModel;
+}

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

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ *
+ * @module provider/local
+ */
+
+/**
+ * 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 {
+  // deno-lint-ignore no-explicit-any
+  const denoVal = (dntShim.dntGlobalThis as any).Deno?.env?.get?.("VERYFRONT_DISABLE_LOCAL_AI");
+  if (denoVal === "1") return true;
+
+  if (typeof process !== "undefined" && process.env?.VERYFRONT_DISABLE_LOCAL_AI === "1") {
+    return true;
+  }
+
+  return false;
+}