veryfront 0.1.283 → 0.1.284

package/src/src/agent/agent-service.ts

@@ -26,21 +26,70 @@ export interface AgentServiceServerConfig {
   cors?: boolean;
 }
 
-/**
- * Phase-0 contract draft for the future framework-owned hosted agent service.
- */
-export interface AgentContract<
+export type AgentRegistry = Record<string, Agent>;
+
+export interface AgentServiceContractBase<
   TStartInput = void,
   TRun = unknown,
   TEvent = unknown,
   TTerminalState = unknown,
 > {
   serviceName: string;
-  agent: Agent;
   server?: AgentServiceServerConfig;
   durableRunSink?: DurableRunSink<TStartInput, TRun, TEvent, TTerminalState>;
 }
 
+/**
+ * Multi-agent hosted-service contract. Framework services route to
+ * `defaultAgentId` unless the host chooses another registered agent.
+ */
+export interface AgentServiceRegistryContract<
+  TStartInput = void,
+  TRun = unknown,
+  TEvent = unknown,
+  TTerminalState = unknown,
+> extends AgentServiceContractBase<TStartInput, TRun, TEvent, TTerminalState> {
+  agents: AgentRegistry;
+  defaultAgentId: string;
+}
+
+/**
+ * Single-agent convenience accepted by `defineAgentService()`. Implementations
+ * must normalize this shape into the same registry path used by multi-agent
+ * services so framework users are not boxed into one-agent-per-process.
+ */
+export interface AgentServiceSingleAgentContract<
+  TStartInput = void,
+  TRun = unknown,
+  TEvent = unknown,
+  TTerminalState = unknown,
+> extends AgentServiceContractBase<TStartInput, TRun, TEvent, TTerminalState> {
+  agent: Agent;
+  defaultAgentId?: string;
+}
+
+/**
+ * Phase-0 contract draft for the future framework-owned hosted agent service.
+ */
+export type AgentContract<
+  TStartInput = void,
+  TRun = unknown,
+  TEvent = unknown,
+  TTerminalState = unknown,
+> =
+  | AgentServiceRegistryContract<TStartInput, TRun, TEvent, TTerminalState>
+  | AgentServiceSingleAgentContract<TStartInput, TRun, TEvent, TTerminalState>;
+
+export interface NormalizedAgentServiceContract<
+  TStartInput = void,
+  TRun = unknown,
+  TEvent = unknown,
+  TTerminalState = unknown,
+> extends AgentServiceContractBase<TStartInput, TRun, TEvent, TTerminalState> {
+  agents: AgentRegistry;
+  defaultAgentId: string;
+}
+
 /**
  * Type-preserving service definition reserved ahead of the runtime
  * implementation landing in a later migration phase.
@@ -51,12 +100,47 @@ export interface AgentServiceDefinition<
   TEvent = unknown,
   TTerminalState = unknown,
 > {
-  contract: AgentContract<TStartInput, TRun, TEvent, TTerminalState>;
+  contract: NormalizedAgentServiceContract<TStartInput, TRun, TEvent, TTerminalState>;
 }
 
 const DEFINE_AGENT_SERVICE_STUB_ERROR =
   "defineAgentService() is a Phase 0 stub. The framework contract is reserved, but the hosted runtime implementation has not landed yet.";
 
+function getSingleAgentDefaultId(contract: {
+  agent: Agent;
+  defaultAgentId?: string;
+}): string {
+  return contract.defaultAgentId ?? contract.agent.id ?? "default";
+}
+
+function normalizeAgentServiceContract<
+  TStartInput = void,
+  TRun = unknown,
+  TEvent = unknown,
+  TTerminalState = unknown,
+>(
+  contract: AgentContract<TStartInput, TRun, TEvent, TTerminalState>,
+): NormalizedAgentServiceContract<TStartInput, TRun, TEvent, TTerminalState> {
+  if ("agents" in contract) {
+    return {
+      serviceName: contract.serviceName,
+      agents: contract.agents,
+      defaultAgentId: contract.defaultAgentId,
+      server: contract.server,
+      durableRunSink: contract.durableRunSink,
+    };
+  }
+
+  const defaultAgentId = getSingleAgentDefaultId(contract);
+  return {
+    serviceName: contract.serviceName,
+    agents: { [defaultAgentId]: contract.agent },
+    defaultAgentId,
+    server: contract.server,
+    durableRunSink: contract.durableRunSink,
+  };
+}
+
 /**
  * Reserve the public hosted agent-service signature before the runtime
  * implementation lands.
@@ -69,6 +153,6 @@ export function defineAgentService<
 >(
   contract: AgentContract<TStartInput, TRun, TEvent, TTerminalState>,
 ): AgentServiceDefinition<TStartInput, TRun, TEvent, TTerminalState> {
-  void contract;
+  void normalizeAgentServiceContract(contract);
   throw new Error(DEFINE_AGENT_SERVICE_STUB_ERROR);
 }

package/src/src/agent/index.ts

@@ -143,10 +143,14 @@ export {
 export { agent } from "./factory.js";
 export {
   type AgentContract,
+  type AgentRegistry,
   type AgentServiceDefinition,
+  type AgentServiceRegistryContract,
   type AgentServiceServerConfig,
+  type AgentServiceSingleAgentContract,
   defineAgentService,
   type DurableRunSink,
+  type NormalizedAgentServiceContract,
 } from "./agent-service.js";
 export {
   type AgUiRuntimeHandlerConfig,

package/src/src/embedding/resolve.ts

@@ -1,11 +1,11 @@
 import { createError, toError } from "../errors/veryfront-error.js";
 import { getGoogleGenAIEnvConfig, getOpenAIEnvConfig } from "../config/env.js";
 import { createLocalEmbeddingModel } from "../provider/local/embedding-runtime-adapter.js";
-import {
-  createGoogleEmbeddingRuntime,
-  createOpenAIEmbeddingRuntime,
-} from "../provider/runtime-loader.js";
+import { createGoogleEmbeddingRuntime } from "../provider/runtime-loader.js";
 import type { EmbeddingRuntime } from "../provider/types.js";
+import { tryResolve } from "../extensions/contracts.js";
+import type { AIProviderRegistry } from "../extensions/interfaces/index.js";
+import { AIProviderRegistryName } from "../extensions/interfaces/index.js";
 import { createVeryfrontCloudEmbeddingModel } from "./veryfront-cloud/provider.js";
 
 type EmbeddingProviderFactory = (modelId: string) => EmbeddingRuntime;
@@ -44,9 +44,20 @@ function autoInitializeFromEnv(): void {
           }),
         );
       }
-      return createOpenAIEmbeddingRuntime(
-        { apiKey: config.apiKey, baseURL: config.baseURL },
-        id,
+      const registry = tryResolve<AIProviderRegistry>(AIProviderRegistryName);
+      const provider = registry?.get("openai");
+      if (provider?.createEmbedding) {
+        return provider.createEmbedding(id, {
+          credential: config.apiKey,
+          baseURL: config.baseURL,
+        });
+      }
+      throw toError(
+        createError({
+          type: "config",
+          message:
+            "OpenAI provider not installed. Add @veryfront/ext-openai to use openai/* embedding models.",
+        }),
       );
     });
   }

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

@@ -1,8 +1,5 @@
 import { createError, toError } from "../../errors/veryfront-error.js";
-import {
-  createGoogleEmbeddingRuntime,
-  createOpenAIEmbeddingRuntime,
-} from "../../provider/runtime-loader.js";
+import { createGoogleEmbeddingRuntime } from "../../provider/runtime-loader.js";
 import type { EmbeddingRuntime } from "../../provider/types.js";
 import {
   createVeryfrontCloudFetch,
@@ -19,12 +16,9 @@ export function createVeryfrontCloudEmbeddingModel(modelId: string): EmbeddingRu
 
   switch (provider) {
     case "openai":
-      return createOpenAIEmbeddingRuntime({
-        apiKey: apiToken,
-        baseURL,
-        name: "veryfront-cloud",
-        fetch,
-      }, upstreamModelId);
+      throw new Error(
+        "OpenAI provider not installed. Add @veryfront/ext-openai to use openai embedding models via veryfront-cloud.",
+      );
 
     case "google":
       return createGoogleEmbeddingRuntime({

package/src/src/extensions/contracts.ts

@@ -14,9 +14,9 @@ export function resolve<T>(name: string): T {
   if (impl === undefined) {
     const recommendation = getRecommendation(name);
     throw MISSING_EXTENSION_ERROR.create({
-      message: `Missing extension for contract "${name}"${
-        recommendation ? `. Recommended: ${recommendation}` : ""
-      }`,
+      message: recommendation
+        ? `Missing extension for contract "${name}". Install it with: deno add ${recommendation}`
+        : `Missing extension for contract "${name}"`,
       detail: recommendation ? `Install it with: deno add ${recommendation}` : undefined,
     });
   }

package/src/src/extensions/interfaces/ai-provider.ts

@@ -0,0 +1,54 @@
+/**
+ * Contract interface for LLM provider extensions.
+ *
+ * A single `AIProviderRegistry` impl lives in the contract registry under
+ * {@link AIProviderRegistryName}. Each provider extension resolves the
+ * registry in its `setup()` and calls `registry.register(provider)`.
+ * Core consumers (model-registry, veryfront-cloud) resolve the registry
+ * and dispatch on provider id parsed from `"provider/model"` strings.
+ *
+ * @module extensions/interfaces/ai-provider
+ */
+
+import type { EmbeddingRuntime, ModelRuntime } from "../../provider/types.js";
+
+/** Config passed to any provider's create* method. */
+export interface AIProviderConfig {
+  /** API credential — maps to OpenAI `apiKey`, Anthropic `authToken`, Google `apiKey` internally. */
+  credential: string;
+  /** Override the provider's base URL (e.g. Azure OpenAI, self-hosted gateway). */
+  baseURL?: string;
+  /** Override fetch (veryfront-cloud uses this to inject project auth headers). */
+  fetch?: typeof fetch;
+  /** Display name shown in errors + telemetry. Defaults to provider id. */
+  name?: string;
+  /** Provider-specific extras. */
+  [key: string]: unknown;
+}
+
+/**
+ * An LLM provider implementation. Extensions register one of these with the
+ * {@link AIProviderRegistry} during setup(). `createModel` is required;
+ * `createEmbedding` and `createResponses` are optional and absent on
+ * providers that don't support them.
+ */
+export interface AIProvider {
+  /** Stable id used in model strings: "openai" / "anthropic" / "google". */
+  readonly id: string;
+  createModel(modelId: string, config: AIProviderConfig): ModelRuntime;
+  createEmbedding?(modelId: string, config: AIProviderConfig): EmbeddingRuntime;
+  createResponses?(modelId: string, config: AIProviderConfig): ModelRuntime;
+}
+
+/** Registry contract. Single impl created at bootstrap. */
+export interface AIProviderRegistry {
+  register(provider: AIProvider): void;
+  unregister(id: string): void;
+  get(id: string): AIProvider | undefined;
+  require(id: string): AIProvider;
+  list(): AIProvider[];
+  has(id: string): boolean;
+}
+
+/** Contract name used for `resolve()` / `provide()`. */
+export const AIProviderRegistryName = "AIProviderRegistry" as const;

package/src/src/extensions/interfaces/code-parser.ts

@@ -74,6 +74,12 @@ export interface GenerateResult {
  * Implementations parse source code into ASTs, traverse/transform
  * nodes, and generate code back from modified trees.
  */
+/** Options for {@link CodeParser.injectJsxNodePositions}. */
+export interface InjectJsxNodePositionsOptions {
+  /** Source file path — emitted into `data-node-file` attributes. */
+  filePath: string;
+}
+
 export interface CodeParser {
   /** Parse source code into an abstract syntax tree. */
   parse(options: ParseOptions): Promise<ASTNode>;
@@ -81,4 +87,10 @@ export interface CodeParser {
   traverse(ast: ASTNode, visitor: TraverseVisitor): void;
   /** Generate source code from an AST. */
   generate(ast: ASTNode, options?: GenerateOptions): Promise<GenerateResult>;
+  /**
+   * Inject `data-node-*` attributes into every JSX element in the source,
+   * enabling Studio Navigator to map rendered elements back to their
+   * source positions. Parsing failures return the input unchanged.
+   */
+  injectJsxNodePositions(source: string, options: InjectJsxNodePositionsOptions): string;
 }

package/src/src/extensions/interfaces/css-processor.ts

@@ -1,40 +1,61 @@
 /**
- * Contract interface for CSS processing engines.
+ * Contract interface for CSS processing engines (Tailwind-style compile
+ * pipelines).
  *
  * Default implementation: `@veryfront/ext-tailwind`
  *
+ * The contract mirrors the Tailwind v4 `compile()` surface: a stateful
+ * compiler is constructed once per stylesheet and emits CSS output for the
+ * set of class-name candidates discovered at render time. Core scans the
+ * rendered HTML for candidates and calls `CSSCompiler.build(candidates)`
+ * on each request; the compiler accumulates state across calls, so per-
+ * project isolation is the caller's responsibility (see
+ * `tailwind-compiler-cache.ts`).
+ *
  * @module extensions/interfaces/css-processor
  */
 
-/** Options passed to {@link CSSProcessor.process}. */
-export interface CSSProcessOptions {
-  /** Raw CSS or utility-class input. */
+/** A loaded stylesheet body with the base path used to resolve relative imports. */
+export interface CSSStylesheetSource {
   content: string;
-  /** Paths to source files used for scanning class usage. */
-  sources?: string[];
-  /** Enable minification of the output. */
-  minify?: boolean;
-  /** Extra implementation-specific options. */
-  [key: string]: unknown;
+  base: string;
+  path: string;
+}
+
+/** A loaded module (Tailwind plugin). `module` is the plugin's default export. */
+export interface CSSModuleSource {
+  module: unknown;
+  base: string;
+  path: string;
+}
+
+/** Options passed to {@link CSSProcessor.compile}. */
+export interface CSSCompileOptions {
+  /** Base path used to resolve relative `@import` specifiers. */
+  base: string;
+  /** Resolver invoked when the compiler encounters an `@import` it doesn't recognize. */
+  loadStylesheet(id: string): Promise<CSSStylesheetSource>;
+  /** Resolver invoked for `@plugin` directives. */
+  loadModule(id: string): Promise<CSSModuleSource>;
 }
 
-/** Result returned from {@link CSSProcessor.process}. */
-export interface CSSProcessResult {
-  /** Processed CSS output. */
-  css: string;
-  /** Source map, if generated. */
-  map?: string;
+/** Stateful compiler returned by {@link CSSProcessor.compile}. */
+export interface CSSCompiler {
+  /**
+   * Emit CSS for the supplied list of class-name candidates. Stateful — the
+   * compiler accumulates candidates across calls for the lifetime of the
+   * underlying compile session.
+   */
+  build(candidates: string[]): string;
 }
 
 /**
  * CSSProcessor contract interface.
  *
- * Implementations compile utility classes or raw CSS into optimized
- * stylesheets ready for the browser.
+ * Implementations wire a utility-class compiler (Tailwind, UnoCSS, etc.) so
+ * core's styles-builder can emit per-request CSS without importing the
+ * underlying engine directly.
  */
 export interface CSSProcessor {
-  /** Process CSS input and return the compiled result. */
-  process(options: CSSProcessOptions): Promise<CSSProcessResult>;
-  /** Merge class names using the processor's conflict-resolution strategy. */
-  mergeClasses?(...classes: string[]): string;
+  compile(stylesheet: string, options: CSSCompileOptions): Promise<CSSCompiler>;
 }

package/src/src/extensions/interfaces/index.ts

@@ -27,7 +27,13 @@ export type { CacheStore } from "./cache-store.js";
 export type { TokenCacheEntry, TokenCacheStats, TokenCacheStore } from "./token-cache-store.js";
 
 // CSS processor
-export type { CSSProcessOptions, CSSProcessor, CSSProcessResult } from "./css-processor.js";
+export type {
+  CSSCompileOptions,
+  CSSCompiler,
+  CSSModuleSource,
+  CSSProcessor,
+  CSSStylesheetSource,
+} from "./css-processor.js";
 
 // Content transformer
 export type {
@@ -51,16 +57,9 @@ export type {
 // Tracing exporter
 export type { SpanData, TracerProvider, TracingExporter } from "./tracing-exporter.js";
 
-// AI model provider
-export type {
-  AIModelProvider,
-  ChatMessage,
-  CompletionOptions,
-  CompletionResult,
-  ContentPart,
-  StreamChunk,
-  ToolDefinition,
-} from "./ai-model-provider.js";
+// AI provider (registry + per-provider contract)
+export type { AIProvider, AIProviderConfig, AIProviderRegistry } from "./ai-provider.js";
+export { AIProviderRegistryName } from "./ai-provider.js";
 
 // Embedding provider
 export type { EmbeddingOptions, EmbeddingProvider, EmbeddingResult } from "./embedding-provider.js";
@@ -71,6 +70,7 @@ export type {
   CodeParser,
   GenerateOptions,
   GenerateResult,
+  InjectJsxNodePositionsOptions,
   NodePath,
   ParseOptions,
   TraverseVisitor,
@@ -78,8 +78,12 @@ export type {
 
 // Schema validator
 export type {
+  InferSchema,
+  InferShape,
   Schema,
+  SchemaFactory,
   SchemaValidator,
+  SchemaValidatorCoerce,
   ValidationFailure,
   ValidationIssue,
   ValidationResult,

package/src/src/extensions/interfaces/schema-validator.ts

@@ -3,15 +3,68 @@
  *
  * Default implementation: `@veryfront/ext-zod`
  *
+ * The interface exposes a small DSL (inspired by zod) that lets core modules
+ * declare validation schemas without importing zod directly. Schemas are
+ * constructed lazily via `defineSchema()` so that an extension-provided
+ * implementation can be registered before any schema is materialized.
+ *
  * @module extensions/interfaces/schema-validator
  */
 
-/** An opaque schema definition that validates and infers type `T`. */
+/**
+ * An opaque schema definition that validates and infers type `T`.
+ *
+ * Implementations may use this as a nominal wrapper around a native validator
+ * (e.g. a zod schema). Core code only calls the methods defined here.
+ */
 export interface Schema<T = unknown> {
-  /** Brand field for nominal typing -- not used at runtime. */
+  /** Brand field for nominal typing — not used at runtime. */
   readonly _output: T;
+
+  // Refinement / modifier chainables
+  optional(): Schema<T | undefined>;
+  nullable(): Schema<T | null>;
+  nullish(): Schema<T | null | undefined>;
+  default(value: T | (() => T)): Schema<T>;
+  describe(description: string): Schema<T>;
+  refine(check: (value: T) => boolean, message?: string | { message?: string }): Schema<T>;
+  transform<U>(fn: (value: T) => U): Schema<U>;
+
+  // Object-level chainables (no-op / type-preserving on non-object schemas;
+  // implementations should only call these on object schemas).
+  strict(): Schema<T>;
+  passthrough(): Schema<T>;
+  partial(): Schema<Partial<T>>;
+  extend<U extends Record<string, Schema<unknown>>>(
+    shape: U,
+  ): Schema<T & { [K in keyof U]: InferSchema<U[K]> }>;
+  merge<U>(other: Schema<U>): Schema<T & U>;
+
+  // String-level chainables
+  min(value: number, message?: string): Schema<T>;
+  max(value: number, message?: string): Schema<T>;
+  int(message?: string): Schema<T>;
+  positive(message?: string): Schema<T>;
+  nonnegative(message?: string): Schema<T>;
+  regex(pattern: RegExp, message?: string): Schema<T>;
+  email(message?: string): Schema<T>;
+  url(message?: string): Schema<T>;
+  uuid(message?: string): Schema<T>;
+  datetime(message?: string): Schema<T>;
+
+  // Validation
+  parse(data: unknown): T;
+  safeParse(data: unknown): ValidationResult<T>;
 }
 
+/** Extracts the inferred output type `T` from a `Schema<T>`. */
+export type InferSchema<S> = S extends Schema<infer T> ? T : never;
+
+/** Maps a raw object shape to its inferred object type. */
+export type InferShape<S extends Record<string, Schema<unknown>>> = {
+  [K in keyof S]: InferSchema<S[K]>;
+};
+
 /** A single validation issue with location context. */
 export interface ValidationIssue {
   /** Dot-path to the offending field (e.g. `"user.email"`). */
@@ -34,18 +87,72 @@ export interface ValidationFailure {
   success: false;
   /** List of issues found during validation. */
   issues: ValidationIssue[];
+  /** Native error thrown by the underlying validator (if any). */
+  error?: unknown;
 }
 
 /** Discriminated union of validation outcomes. */
 export type ValidationResult<T> = ValidationSuccess<T> | ValidationFailure;
 
+/**
+ * Namespace for `coerce.*` constructors — accepts input in any form and
+ * coerces to the target type before validation.
+ */
+export interface SchemaValidatorCoerce {
+  string(): Schema<string>;
+  number(): Schema<number>;
+  boolean(): Schema<boolean>;
+  date(): Schema<Date>;
+}
+
 /**
  * SchemaValidator contract interface.
  *
- * Implementations validate unknown input against a typed schema and
- * return a discriminated success/failure result.
+ * Exposes a zod-inspired DSL. The `object(shape)`, `array(schema)`, etc.
+ * constructors produce opaque `Schema<T>` instances that can be further
+ * refined via chainables and finally validated with `.parse` / `.safeParse`.
  */
 export interface SchemaValidator {
-  /** Validate `data` against the given schema. */
+  // Primitive constructors
+  string(): Schema<string>;
+  number(): Schema<number>;
+  boolean(): Schema<boolean>;
+  date(): Schema<Date>;
+  null(): Schema<null>;
+  unknown(): Schema<unknown>;
+  // deno-lint-ignore no-explicit-any -- `any` constructor intentionally mirrors zod
+  any(): Schema<any>;
+
+  // Composite constructors
+  object<S extends Record<string, Schema<unknown>>>(shape: S): Schema<InferShape<S>>;
+  array<T>(element: Schema<T>): Schema<T[]>;
+  record<K extends string | number | symbol, V>(
+    keys: Schema<K>,
+    values: Schema<V>,
+  ): Schema<Record<K, V>>;
+  union<T extends readonly [Schema<unknown>, ...Schema<unknown>[]]>(
+    schemas: T,
+  ): Schema<InferSchema<T[number]>>;
+  discriminatedUnion<
+    K extends string,
+    T extends readonly [Schema<unknown>, ...Schema<unknown>[]],
+  >(
+    discriminator: K,
+    schemas: T,
+  ): Schema<InferSchema<T[number]>>;
+  literal<T extends string | number | boolean | null>(value: T): Schema<T>;
+  enum<T extends readonly [string, ...string[]]>(values: T): Schema<T[number]>;
+
+  /** Coercing constructors — accept any input and coerce to the target. */
+  coerce: SchemaValidatorCoerce;
+
+  /**
+   * Convenience that runs validation on an already-constructed schema.
+   * Equivalent to `schema.safeParse(data)`; kept for ergonomic parity with
+   * earlier revisions of this contract.
+   */
   validate<T>(schema: Schema<T>, data: unknown): ValidationResult<T>;
 }
+
+/** Factory type accepted by `defineSchema`. */
+export type SchemaFactory<T> = (v: SchemaValidator) => Schema<T>;

package/src/src/extensions/loader.ts

@@ -17,6 +17,16 @@ import type { Extension, ExtensionContext, ExtensionLogger, ResolvedExtension }
 export class ExtensionLoader {
   private logger: ExtensionLogger;
   private setupOrder: ResolvedExtension[] = [];
+  private primed: Record<string, unknown> = {};
+
+  /**
+   * Register contracts that will be re-applied after each `setupAll()`
+   * teardown pass. Used by `orchestrateExtensions()` to seed infrastructure
+   * (e.g. `AIProviderRegistry`) before per-extension `setup()` runs.
+   */
+  primeContracts(contracts: Record<string, unknown>): void {
+    this.primed = { ...this.primed, ...contracts };
+  }
 
   constructor(logger: ExtensionLogger) {
     this.logger = logger;
@@ -154,6 +164,10 @@ export class ExtensionLoader {
     // registry even when nothing is loaded yet.
     await this.teardownAll();
 
+    for (const [name, impl] of Object.entries(this.primed)) {
+      register(name, impl);
+    }
+
     // Check for contract conflicts before loading
     const conflicts = detectConflicts(extensions);
     if (conflicts.length > 0) {

package/src/src/extensions/orchestrate.ts

@@ -30,6 +30,8 @@ export interface OrchestrateOptions {
   projectDir: string;
   config: { extensions?: ExtensionConfigEntry[] };
   logger: ExtensionLogger;
+  /** Contracts to seed into the registry after teardown, before setup(). */
+  primeContracts?: Record<string, unknown>;
   /** @internal Override discovery functions in tests. */
   discovery?: {
     discoverPackageExtensions: typeof defaultDiscovery.discoverPackageExtensions;
@@ -167,6 +169,9 @@ export async function orchestrateExtensions(
   );
 
   const loader = new ExtensionLoader(logger);
+  if (options.primeContracts) {
+    loader.primeContracts(options.primeContracts);
+  }
   await loader.setupAll(merged, config as Record<string, unknown>);
   return loader;
 }

package/src/src/extensions/recommendations.ts

@@ -13,7 +13,10 @@ const recommendations = new Map<string, string>([
   ["DatabaseClient", "@veryfront/ext-postgres"],
   ["AuthProvider", "@veryfront/ext-jwt"],
   ["TracingExporter", "@veryfront/ext-opentelemetry"],
-  ["AIModelProvider", "@veryfront/ext-openai"],
+  ["AIProviderRegistry", "@veryfront/ext-openai"],
+  ["AIProvider:openai", "@veryfront/ext-openai"],
+  ["AIProvider:anthropic", "@veryfront/ext-anthropic"],
+  ["AIProvider:google", "@veryfront/ext-google"],
   ["EmbeddingProvider", "@veryfront/ext-embeddings"],
   ["CodeParser", "@veryfront/ext-babel"],
   ["SchemaValidator", "@veryfront/ext-zod"],