veryfront 0.1.320 → 0.1.322

package/src/extensions/ext-tailwind/src/index.ts

@@ -0,0 +1,80 @@
+/**
+ * ext-tailwind — CSSProcessor implementation backed by Tailwind CSS v4.
+ *
+ * Provides the `CSSProcessor` contract:
+ *  - `compile(stylesheet, options)` — delegates to tailwindcss `compile()`
+ *    and returns a compiler whose `build(candidates)` emits CSS for the
+ *    class-name candidates discovered at render time.
+ *
+ * The extension also installs three `globalThis` shims on setup so that
+ * Tailwind plugin bundles loaded at runtime from esm.sh can bind their
+ * `tailwindcss/plugin`, `tailwindcss/defaultTheme`, and `tailwindcss/colors`
+ * imports to the same tailwindcss copy this extension ships. Core's
+ * `plugin-loader.ts` rewrites plugin bundle code to reference these shims
+ * by name; without the shims installed, dynamic plugin loading fails.
+ *
+ * @module extensions/ext-tailwind
+ */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+import type { ExtensionFactory } from "../../../src/extensions/index.js";
+import type { CSSCompileOptions, CSSCompiler, CSSProcessor } from "../../../src/extensions/interfaces/index.js";
+
+import { compile } from "tailwindcss";
+import plugin from "tailwindcss/plugin";
+import defaultTheme from "tailwindcss/defaultTheme";
+import colors from "tailwindcss/colors";
+
+type ShimGlobal = Record<string, unknown>;
+
+function installTailwindPluginShims(): void {
+  const g = dntShim.dntGlobalThis as ShimGlobal;
+  g.__tailwindPluginShim = { default: plugin, __esModule: true };
+  g.__tailwindDefaultThemeShim = { default: defaultTheme, __esModule: true };
+  g.__tailwindColorsShim = { default: colors, __esModule: true };
+}
+
+class TailwindCSSProcessor implements CSSProcessor {
+  async compile(stylesheet: string, options: CSSCompileOptions): Promise<CSSCompiler> {
+    const native = await compile(stylesheet, {
+      base: options.base,
+      loadStylesheet: options.loadStylesheet,
+      loadModule: async (id: string) => {
+        const loaded = await options.loadModule(id);
+        // deno-lint-ignore no-explicit-any -- loaded plugin modules are opaque to the contract
+        return { module: loaded.module as any, base: loaded.base, path: loaded.path };
+      },
+    });
+    return {
+      build(candidates: string[]): string {
+        return native.build(candidates);
+      },
+    };
+  }
+}
+
+const extTailwind: ExtensionFactory = () => {
+  const impl = new TailwindCSSProcessor();
+  return {
+    name: "ext-tailwind",
+    version: "0.1.0",
+    capabilities: [
+      { type: "contract", name: "CSSProcessor" },
+      { type: "net", hosts: ["esm.sh"] },
+    ],
+    setup(ctx) {
+      installTailwindPluginShims();
+      ctx.provide("CSSProcessor", impl);
+      ctx.logger.info("[ext-tailwind] CSSProcessor registered");
+    },
+    teardown() {
+      // Shims stay installed — removing them could break in-flight plugin
+      // loads. The globalThis pollution is intentional and scoped to keys
+      // with `__tailwind` prefix.
+    },
+  };
+};
+
+export default extTailwind;
+export { TailwindCSSProcessor };

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

@@ -7,6 +7,7 @@ import {
   parseVeryfrontCloudModelId,
   requireVeryfrontCloudBootstrap,
 } from "../../provider/veryfront-cloud/shared.js";
+import { createVeryfrontCloudOpenAIEmbeddingModel } from "../../provider/veryfront-cloud/openai.js";
 
 export function createVeryfrontCloudEmbeddingModel(modelId: string): EmbeddingRuntime {
   const { provider, modelId: upstreamModelId } = parseVeryfrontCloudModelId(modelId, "embedding");
@@ -16,9 +17,11 @@ export function createVeryfrontCloudEmbeddingModel(modelId: string): EmbeddingRu
 
   switch (provider) {
     case "openai":
-      throw new Error(
-        "OpenAI provider not installed. Add @veryfront/ext-openai to use openai embedding models via veryfront-cloud.",
-      );
+      return createVeryfrontCloudOpenAIEmbeddingModel(upstreamModelId, {
+        apiToken,
+        baseURL,
+        fetch,
+      });
 
     case "google":
       return createGoogleEmbeddingRuntime({

package/src/src/html/styles-builder/tailwind-compiler-cache.ts

@@ -14,7 +14,10 @@
  * @module html/styles-builder/tailwind-compiler-cache
  */
 
-import { tryResolve as tryResolveContract } from "../../extensions/contracts.js";
+import {
+  register as registerContract,
+  tryResolve as tryResolveContract,
+} from "../../extensions/contracts.js";
 import type { CSSCompiler, CSSProcessor } from "../../extensions/interfaces/index.js";
 import { serverLogger } from "../../utils/index.js";
 import { DEPENDENCY_MISSING, NETWORK_ERROR } from "../../errors/index.js";
@@ -71,6 +74,37 @@ async function getTailwindBaseCSS(): Promise<string> {
   return tailwindBaseCSS;
 }
 
+async function resolveCSSProcessor(): Promise<CSSProcessor | undefined> {
+  const registeredProcessor = tryResolveContract<CSSProcessor>("CSSProcessor");
+  if (registeredProcessor) return registeredProcessor;
+
+  try {
+    const { default: createTailwindExtension } = await import(
+      "../../../extensions/ext-tailwind/src/index.js"
+    );
+    const extension = createTailwindExtension();
+    await extension.setup?.({
+      config: {},
+      logger,
+      provide: (name: string, impl: unknown) => registerContract(name, impl),
+      get: () => undefined,
+      require: <T>(name: string): T => {
+        const contract = tryResolveContract<T>(name);
+        if (contract === undefined) {
+          throw new Error(`Missing required extension contract: ${name}`);
+        }
+        return contract;
+      },
+    });
+  } catch (error) {
+    logger.warn("Failed to register built-in CSSProcessor extension", {
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+
+  return tryResolveContract<CSSProcessor>("CSSProcessor");
+}
+
 function evictOldestCompiler(): void {
   if (compilerCache.size < MAX_CACHED_COMPILERS) return;
 
@@ -108,7 +142,7 @@ export async function getCompiler(
 
   logger.debug("Creating new compiler", { hash, projectSlug });
 
-  const processor = tryResolveContract<CSSProcessor>("CSSProcessor");
+  const processor = await resolveCSSProcessor();
   if (!processor) {
     logger.warn(
       "No CSSProcessor extension registered — CSS output will be empty. Install it with: deno add @veryfront/ext-tailwind",

package/src/src/provider/shared/index.ts

@@ -0,0 +1,62 @@
+/**
+ * Shared plumbing consumed by the `@veryfront/ext-*` provider extensions.
+ *
+ * This barrel is the stable public surface: implementations currently live
+ * in `runtime-loader.ts` and `runtime-loader/` subdirectory. Future PRs
+ * (post ext-anthropic / ext-google extraction) may move the implementations
+ * into this directory; extensions keep importing from here unchanged.
+ *
+ * @module provider/shared
+ */
+
+// URL builders
+export {
+  getAnthropicMessagesUrl,
+  getGoogleEmbeddingUrl,
+  getGoogleGenerateContentUrl,
+  getGoogleStreamGenerateContentUrl,
+  getOpenAIChatCompletionsUrl,
+  getOpenAIEmbeddingUrl,
+  getOpenAIResponsesUrl,
+} from "../runtime-loader/provider-endpoints.js";
+
+// Request init builders
+export {
+  createAnthropicRequestInit,
+  createGoogleRequestInit,
+  createOpenAIRequestInit,
+} from "../runtime-loader/provider-request-init.js";
+
+// Tool-input status transitions
+export {
+  TOOL_INPUT_PENDING_THRESHOLD_MS,
+  withToolInputStatusTransitions,
+} from "../runtime-loader/tool-input-status.js";
+
+// Retry / error / HTTP plumbing (currently in runtime-loader.ts).
+export {
+  buildProviderError,
+  createWarningCollector,
+  isNumberArray,
+  mergeUsage,
+  parseRetryAfterMs,
+  ProviderError,
+  ProviderOverloadedError,
+  ProviderQuotaError,
+  ProviderRateLimitError,
+  ProviderRequestError,
+  readProviderOptions,
+  readRecord,
+  readTextParts,
+  requestJson,
+  requestStream,
+  stringifyJsonValue,
+  toOpenAICompatibleMessages,
+  toOpenAICompatibleTools,
+} from "../runtime-loader.js";
+
+export type {
+  OpenAICompatibleChatMessage,
+  OpenAICompatibleChatRequest,
+  RuntimePromptMessage,
+} from "../runtime-loader.js";

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

@@ -0,0 +1,34 @@
+import type { EmbeddingRuntime, ModelRuntime } from "../types.js";
+import { OpenAIProvider } from "../../../extensions/ext-openai/src/openai-provider.js";
+
+const openAIProvider = new OpenAIProvider();
+
+interface VeryfrontCloudOpenAIConfig {
+  apiToken: string;
+  baseURL: string;
+  fetch: typeof globalThis.fetch;
+}
+
+export function createVeryfrontCloudOpenAIModel(
+  modelId: string,
+  config: VeryfrontCloudOpenAIConfig,
+): ModelRuntime {
+  return openAIProvider.createModel(modelId, {
+    credential: config.apiToken,
+    baseURL: config.baseURL,
+    name: "veryfront-cloud",
+    fetch: config.fetch,
+  });
+}
+
+export function createVeryfrontCloudOpenAIEmbeddingModel(
+  modelId: string,
+  config: VeryfrontCloudOpenAIConfig,
+): EmbeddingRuntime {
+  return openAIProvider.createEmbedding(modelId, {
+    credential: config.apiToken,
+    baseURL: config.baseURL,
+    name: "veryfront-cloud",
+    fetch: config.fetch,
+  });
+}

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

@@ -10,6 +10,7 @@ import {
   parseVeryfrontCloudModelId,
   requireVeryfrontCloudBootstrap,
 } from "./shared.js";
+import { createVeryfrontCloudOpenAIModel } from "./openai.js";
 
 export function createVeryfrontCloudModel(modelId: string): ModelRuntime {
   const { provider, modelId: upstreamModelId } = parseVeryfrontCloudModelId(modelId, "language");
@@ -61,9 +62,11 @@ export function createVeryfrontCloudModel(modelId: string): ModelRuntime {
           fetch,
         });
       }
-      throw new Error(
-        "OpenAI provider not installed. Add @veryfront/ext-openai to use openai/moonshotai models via veryfront-cloud.",
-      );
+      return createVeryfrontCloudOpenAIModel(upstreamModelId, {
+        apiToken,
+        baseURL,
+        fetch,
+      });
     }
 
     default: {

package/src/src/proxy/main.ts

@@ -25,6 +25,8 @@ import * as dntShim from "../../_dnt.shims.js";
 import { createProxyHandler, INTERNAL_PROXY_HEADERS, type ProxyConfig } from "./handler.js";
 import { createCacheFromEnv } from "./cache/index.js";
 import { isRetryableConnectionError } from "./retry.js";
+import { register } from "../extensions/contracts.js";
+import { createAuthProvider } from "../../extensions/ext-jwt/src/index.js";
 import {
   endSpan,
   extractContext,
@@ -112,6 +114,8 @@ const VERYFRONT_SERVER_RETRY_DELAY_MS = parseInt(
   getEnv("VERYFRONT_SERVER_RETRY_DELAY_MS") || String(DEFAULT_SERVER_RETRY_DELAY_MS),
 );
 
+register("AuthProvider", createAuthProvider({}));
+
 // Initialize cache and proxy handler
 const cache = await createCacheFromEnv();
 const proxyHandler = createProxyHandler({

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.320";
+export const VERSION = "0.1.322";