@vellumai/assistant 0.10.9 → 0.10.10-dev.202607170046.8482d40

package/src/config/llm-resolver.ts

@@ -8,7 +8,6 @@ import {
   MANAGED_ROUTABLE_PROVIDERS,
   VELLUM_MANAGED_CONNECTION_NAME,
 } from "../providers/vellum-model-routing.js";
-import { isAssistantFeatureFlagEnabled } from "./assistant-feature-flags.js";
 import { CALL_SITE_DEFAULTS } from "./call-site-defaults.js";
 import {
   getEffectiveProfile,
@@ -23,73 +22,50 @@ import {
 } from "./schemas/llm.js";
 
 /**
- * Resolves a fully-specified `LLMConfigBase` for a given call site by layering
- * call-site overrides, optional per-call profile, an optional ad-hoc override
- * profile, the workspace's active profile, and the required `llm.default`.
+ * Resolves a fully-specified `LLMConfigBase` for a given call site.
  *
- * Merge layers (low → high precedence; later layers override earlier) for
- * non-main-agent call sites:
- *   1. `llm.default` fields (required base)
- *   2. `llm.profiles[llm.activeProfile]` (workspace-wide active profile) —
- *      folded in ONLY when the call site resolves no profile of its own (a
- *      profile-less leaf like `vision`/`workflowLeaf`, or a BYOK install whose
- *      pinned managed profile was stripped). When the call site resolves a
- *      profile, that profile is the authoritative provider config and the
- *      active profile does not contribute — otherwise a deep-merge would let
- *      its orphan fields bleed onto a different provider.
- *   3. `llm.profiles[opts.overrideProfile]` (per-call ad-hoc override)
- *   4. `llm.profiles[site.profile]` fields (call-site's named profile)
- *   5. `llm.callSites[callSite]` fields (call-site override)
+ * Selection is a single-winner chain (see `selectWinningProfile`): the
+ * highest-precedence rung that names a usable, complete profile wins, and the
+ * resolved config is composed as code-owned schema defaults + the winning
+ * profile's fragment + the call site's own tuning tweak. No profile ever
+ * contributes a field to another profile — `deepMerge` here only lets nested
+ * tweaks (e.g. `thinking.enabled`) combine leaf-wise with the winner rather
+ * than wholesale-replacing sibling fields.
  *
- * For `mainAgent`, the selected active/conversation profile is the direct
- * user intent for the chat loop, so profile layers intentionally sit above
- * any static `llm.callSites.mainAgent` defaults seeded by migrations or UI
- * settings:
- *   1. `llm.default`
- *   2. `llm.profiles[site.profile]`
- *   3. `llm.callSites.mainAgent`
- *   4. `llm.profiles[llm.activeProfile]`
- *   5. `llm.profiles[opts.overrideProfile]`
+ * Precedence of the selection chain (high → low):
+ *   1. `opts.overrideProfile` (per-turn / per-conversation pin)
+ *   2. `llm.activeProfile` — `mainAgent` only, since it IS that call site's
+ *      user-facing chat-model selection
+ *   3. `llm.callSites[callSite].profile` (the call site's named profile)
+ *   4. `CALL_SITE_DEFAULTS[callSite].profile` intent resolved through
+ *      `llm.defaultProvider`
+ *   5. balanced intent through `llm.defaultProvider` — the code-owned anchor
+ *      for profileless call sites, or when nothing above is usable
  *
- * `opts.forceOverrideProfile` is an explicit escape hatch for non-main-agent
- * call sites: when true (and `opts.overrideProfile` resolves to a defined
- * profile), the override profile floats ABOVE the call-site layers — the
- * non-main ordering becomes default → activeProfile → site profile →
- * call-site override → overrideProfile. This mirrors how `mainAgent` treats
- * the user's chat-model selection as authoritative, and exists for callers
- * that must run a background call site under a specific conversation's
- * inference profile (e.g. fork-based memory retrospectives matching the
- * source conversation for provider prompt-cache reuse). When the referenced
- * profile is missing, the flag is inert and the normal precedence applies
- * (same silent fall-through as any `overrideProfile` reference); for
- * `mainAgent` the flag is a no-op because the override already sits on top.
+ * A winner must carry its own `provider` AND `model`: the base layer's schema
+ * default identity never stands in for a selected profile. The anchor is
+ * code-owned and resolved through `llm.defaultProvider`, never through
+ * user-mutable state.
  *
- * Nested objects (`thinking`, `contextWindow`, and
- * `contextWindow.overflowRecovery`) are deep-merged so partial overrides at
- * any nesting level merge into — rather than replace — the corresponding
- * base value.
+ * `temperature`/`top_p` come only from the winner (or an explicit call-site
+ * tweak); `logitBias` only ever from the winner. These are provider-coupled, so
+ * a shadowed profile can never leak its sampling onto a different provider.
  *
- * `temperature` and `top_p` are provider-coupled, so they do NOT deep-merge
- * field-by-field with the rest of the config: only the winning profile (the
- * highest-precedence profile that determines provider/model) contributes them,
- * and an explicit `llm.callSites[callSite]` override still wins. A lower-
- * precedence profile whose model is shadowed never leaks its sampling onto a
- * different provider (which would trip e.g. Anthropic's "temperature and top_p
- * cannot both be specified" constraint). `logitBias` is winning-profile-scoped
- * the same way.
+ * `opts.forceOverrideProfile` is a no-op here: the override profile already
+ * sits at the top of the chain for every call site.
  *
- * `activeProfile` and `overrideProfile` are resolved by name lookup against
- * the effective profile catalog (code-defined defaults + workspace
- * `llm.profiles`; see `getEffectiveProfile`). Missing references silently
- * fall through (no throw) so the
- * resolver stays pure; schema validation in `LLMSchema.superRefine` catches
- * unknown `activeProfile` references at config-load time.
+ * Profile names are resolved against the effective profile catalog
+ * (code-defined defaults + workspace `llm.profiles`; see `getEffectiveProfile`).
+ * A "mix" profile is expanded to one of its arms by a seeded weighted pick (see
+ * `resolveProfileFragment` and `opts.selectionSeed`), uniformly wherever a name
+ * is dereferenced. Missing references silently fall through (no throw) so the
+ * resolver stays pure; schema validation catches unknown static references at
+ * config-load time.
  *
- * A profile reference that points at a "mix" profile is expanded to one of its
- * constituent profiles by a seeded weighted pick (see `resolveProfileFragment`
- * and `opts.selectionSeed`). Expansion happens uniformly at every dereference
- * spot, so a mix works as `activeProfile`, `overrideProfile`, or a call-site
- * `profile`.
+ * Nested objects (`thinking`, `contextWindow`, and
+ * `contextWindow.overflowRecovery`) are deep-merged so partial tweaks at any
+ * nesting level merge into — rather than replace — the corresponding base
+ * value.
  *
  * Pure & synchronous: no I/O, no async work. (Random selection only occurs for
  * mix profiles when no `selectionSeed` is supplied; with a seed the pick is
@@ -98,11 +74,11 @@ import {
 export interface ResolveCallSiteOpts {
   overrideProfile?: string;
   /**
-   * Float `overrideProfile` above the call-site layers (named site profile +
-   * call-site override) for non-main-agent call sites. See the
-   * `resolveCallSiteConfig` docstring for the resulting precedence and the
-   * use case. Inert when `overrideProfile` is absent or references a missing
-   * profile, and a no-op for `mainAgent`.
+   * Float `overrideProfile` above the call-site layers for non-main-agent call
+   * sites. Retained for API compatibility; under single-winner selection the
+   * override already sits at the top of the chain, so this is effectively a
+   * no-op. Inert when `overrideProfile` is absent or references a missing
+   * profile.
    */
   forceOverrideProfile?: boolean;
   /**
@@ -121,167 +97,29 @@ export interface ResolveCallSiteOpts {
    */
   onMixSelected?: (info: { mixProfile: string; chosenProfile: string }) => void;
   /**
-   * Override-or-default semantics only: invoked once per chain rung that
-   * named a profile the resolver could not use, before resolution continues
-   * to the next rung. Fallback is silent to the call but must be visible in
-   * logs — callers on user-facing paths should log at warn.
+   * Invoked once per chain rung that named a profile the resolver could not
+   * use, before resolution continues to the next rung. Fallback is silent to
+   * the call but must be visible in logs — callers on user-facing paths should
+   * log at warn.
    */
   onResolutionFallback?: (info: {
     callSite: LLMCallSite;
     requested: string;
     reason: ResolutionFallbackReason;
   }) => void;
-  /**
-   * Test/caller override for the resolution semantics. When absent, the
-   * `override-or-default-resolution` feature flag decides (ships enabled;
-   * disabling it is the kill switch back to the legacy merge cascade).
-   */
-  resolutionSemantics?: "override-or-default" | "legacy-merge";
 }
 
 export type ResolutionFallbackReason = "missing" | "disabled" | "incomplete";
 
-export const OVERRIDE_OR_DEFAULT_RESOLUTION_FLAG =
-  "override-or-default-resolution";
-
-/**
- * The flag read ignores its config argument (the override cache and registry
- * are module state), so the resolver stays call-site-compatible without
- * threading `AssistantConfig` through every consumer.
- */
-export function isOverrideOrDefaultResolutionEnabled(): boolean {
-  return isAssistantFeatureFlagEnabled(
-    OVERRIDE_OR_DEFAULT_RESOLUTION_FLAG,
-    undefined as never,
-  );
-}
-
-function useOverrideOrDefaultSemantics(opts: ResolveCallSiteOpts): boolean {
-  if (opts.resolutionSemantics != null) {
-    return opts.resolutionSemantics === "override-or-default";
-  }
-  return isOverrideOrDefaultResolutionEnabled();
-}
-
 export function resolveCallSiteConfig(
   callSite: LLMCallSite,
   llm: z.infer<typeof LLMSchema>,
   opts: ResolveCallSiteOpts = {},
 ): z.infer<typeof LLMConfigBase> {
-  if (useOverrideOrDefaultSemantics(opts)) {
-    return resolveOverrideOrDefault(callSite, llm, opts);
-  }
-  const layers: Mergeable[] = [llm.default as Mergeable];
-
-  // Effective logit-bias preset, tracked outside the deep-merge so it ties to
-  // the single highest-precedence *profile* that wins resolution rather than
-  // inheriting from a lower one. Profile layers are appended low→high, and each
-  // one fully determines the preset (a profile that omits `logitBias` clears
-  // any value a lower-precedence profile set), so the last profile appended
-  // wins — matching the merge's own precedence and including the implicit
-  // call-site default selected by `effectiveDefault`.
-  const biasRef: LogitBiasRef = { preset: undefined };
-
-  // Effective sampling params, tracked outside the deep-merge for the same
-  // reason as `logitBias`: `temperature`/`top_p` are provider-coupled, so only
-  // the winning profile may contribute them. A profile clears what a lower
-  // PROFILE set where it is silent (so a shadowed profile's sampling can't
-  // leak), while an explicit call-site override is sticky and survives a later
-  // silent profile (see `applyProfileSampling` / `appendCallSiteLayers`).
-  const samplingRef: SamplingRef = {
-    temperature: undefined,
-    topP: undefined,
-    temperatureFromCallSite: false,
-    topPFromCallSite: false,
-  };
-
-  const activeFragment = resolveProfileFragment(llm.activeProfile, llm, opts);
-  const overrideFragment = resolveProfileFragment(
-    opts.overrideProfile,
-    llm,
-    opts,
-  );
-  const site =
-    llm.callSites?.[callSite] ??
-    effectiveDefault(callSite, llm, opts.overrideProfile != null);
-
-  if (callSite === "mainAgent") {
-    appendCallSiteLayers(
-      layers,
-      callSite,
-      llm,
-      site,
-      opts,
-      biasRef,
-      samplingRef,
-    );
-    appendProfileLayer(layers, activeFragment, biasRef, samplingRef);
-    appendProfileLayer(layers, overrideFragment, biasRef, samplingRef);
-  } else if (opts.forceOverrideProfile === true && overrideFragment != null) {
-    // Escape hatch: float the override profile above the call-site layers,
-    // mirroring mainAgent's treatment of the user's chat-model selection.
-    // Guarded on a resolved fragment so a missing profile reference degrades
-    // to the normal precedence below instead of silently dropping the
-    // call-site layers' standing. The active profile stays the bottom fallback
-    // (its sampling can't leak — a higher profile's REPLACE clears it).
-    appendProfileLayer(layers, activeFragment, biasRef, samplingRef);
-    appendCallSiteLayers(
-      layers,
-      callSite,
-      llm,
-      site,
-      opts,
-      biasRef,
-      samplingRef,
-    );
-    appendProfileLayer(layers, overrideFragment, biasRef, samplingRef);
-  } else {
-    // The active profile is a low-precedence FALLBACK for call sites that
-    // resolve no profile of their own — profile-less leaves (`vision`,
-    // `workflowLeaf`) and BYOK installs where the pinned managed profile was
-    // stripped. When the call site DOES resolve its own profile, that profile
-    // is the authoritative provider config, so the active profile must not
-    // contribute its orphan fields to a different provider.
-    if (site?.profile == null) {
-      appendProfileLayer(layers, activeFragment, biasRef, samplingRef);
-    }
-    appendProfileLayer(layers, overrideFragment, biasRef, samplingRef);
-    appendCallSiteLayers(
-      layers,
-      callSite,
-      llm,
-      site,
-      opts,
-      biasRef,
-      samplingRef,
-    );
-  }
-
-  const resolved = finalize(deepMerge(...withImpliedProviders(layers)));
-  // `logitBias` is profile-scoped: the winning profile is its only source.
-  // Overwrite — or clear — whatever the deep-merge may have copied from a
-  // non-profile layer (`llm.default` or a call-site fragment), so a preset set
-  // outside a profile can't apply to a profile that didn't opt in.
-  if (biasRef.preset !== undefined) {
-    resolved.logitBias = biasRef.preset;
-  } else {
-    delete (resolved as { logitBias?: unknown }).logitBias;
-  }
-  // `temperature`/`top_p` are winning-profile-scoped like `logitBias`, but an
-  // explicit call-site override may also set them. Apply the tracked value,
-  // overriding whatever a shadowed profile may have left in the merge. An
-  // `undefined` ref means no profile or override opted in, so the `llm.default`
-  // base already in `resolved` stands.
-  if (samplingRef.temperature !== undefined) {
-    resolved.temperature = samplingRef.temperature;
-  }
-  if (samplingRef.topP !== undefined) {
-    resolved.topP = samplingRef.topP;
-  }
-  return resolved;
+  return resolveOverrideOrDefault(callSite, llm, opts);
 }
 
-// ─── Override-or-default resolution (flag-on path) ──────────────────────────
+// ─── Single-winner profile resolution ───────────────────────────────────────
 //
 // Selection is a single-winner chain — each rung is either a complete
 // explicit choice or skipped with a reported reason — bottoming out on the
@@ -294,9 +132,8 @@ export function resolveCallSiteConfig(
 //      above usable)
 // A winner must carry its own `provider` AND `model`: the base layer's
 // schema-default identity must never stand in for a selected profile (that
-// would be merge inheritance by the back door). The legacy `custom-${intent}`
-// hop is deliberately absent — a fallback anchor must be code-owned, never
-// user-mutable state.
+// would be merge inheritance by the back door). A fallback anchor must be
+// code-owned, never user-mutable state.
 //
 // The request config is the base + winner + site-tweak composition:
 // code-owned schema defaults, then the single winning profile, then the call
@@ -508,8 +345,8 @@ function usableDefaultIntent(
 
 /**
  * Schema-default base for composition. Non-identity fields a winner omits
- * fall to these code-owned defaults (never to `llm.default`); the winner's
- * identity fields are guaranteed present by `selectWinningProfile`.
+ * fall to these code-owned defaults; the winner's identity fields are
+ * guaranteed present by `selectWinningProfile`.
  */
 const CODE_DEFAULT_BASE: z.infer<typeof LLMConfigBase> = LLMConfigBase.parse(
   {},
@@ -525,8 +362,7 @@ function resolveOverrideOrDefault(
     selection.entry == null ? {} : winnerConfigFragment(selection.entry);
 
   // The call site's own tweak fragment: the workspace override replaces the
-  // code default wholesale (matching legacy `llm.callSites[site] ??
-  // CALL_SITE_DEFAULTS[site]`). `profile` is the selection discriminator and
+  // code default wholesale. `profile` is the selection discriminator and
   // `logitBias` is winner-owned, so neither enters the merge.
   const site = llm.callSites?.[callSite] ?? CALL_SITE_DEFAULTS[callSite];
   const {
@@ -585,20 +421,6 @@ function winnerConfigFragment(entry: ProfileEntry): Mergeable {
   return config as Mergeable;
 }
 
-type LogitBiasRef = { preset: ProfileEntry["logitBias"] };
-
-type SamplingRef = {
-  temperature: ProfileEntry["temperature"];
-  topP: ProfileEntry["topP"];
-  // Provenance of the current pair: `true` when a field came from an explicit
-  // call-site override (deliberate, sticky), `false` when it came from a profile
-  // (clearable by a higher-precedence profile that determines the model). Lets a
-  // silent higher profile clear a lower profile's sampling without discarding a
-  // deliberate call-site override.
-  temperatureFromCallSite: boolean;
-  topPFromCallSite: boolean;
-};
-
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -634,11 +456,15 @@ function weightedPick<T extends { weight: number }>(
 ): T {
   const total = entries.reduce((sum, e) => sum + e.weight, 0);
   // Defensive: a degenerate total (unreachable post-schema) → first arm.
-  if (!(total > 0)) return entries[0];
+  if (!(total > 0)) {
+    return entries[0];
+  }
   let threshold = unit * total;
   for (const entry of entries) {
     threshold -= entry.weight;
-    if (threshold < 0) return entry;
+    if (threshold < 0) {
+      return entry;
+    }
   }
   // Floating-point fall-through (unit ≈ 1): return the last arm.
   return entries[entries.length - 1];
@@ -664,9 +490,13 @@ function resolveProfileFragment(
   lookupEntry: (name: string) => ProfileEntry | undefined = (n) =>
     getEffectiveProfile(llm.profiles, n),
 ): ProfileEntry | undefined {
-  if (name == null) return undefined;
+  if (name == null) {
+    return undefined;
+  }
   const entry = lookupEntry(name);
-  if (entry?.mix == null) return entry;
+  if (entry?.mix == null) {
+    return entry;
+  }
 
   // Mix: pick one constituent. Seed by per-conversation seed + the mix's own
   // name so two different mixes in the same conversation pick independently,
@@ -683,71 +513,33 @@ function resolveProfileFragment(
 }
 
 /**
- * Returns the effective default profile key the resolver would actually
- * select for a call site when no per-turn `overrideProfile` is supplied.
- *
- * Mirrors the layering in `resolveCallSiteConfig`:
- * - For `mainAgent`, the workspace's `activeProfile` sits ABOVE the
- *   call-site catalog default (and above any static `llm.callSites.mainAgent`
- *   override), so a non-disabled `activeProfile` wins.
- * - For other call sites, the catalog default sits ABOVE `activeProfile`,
- *   so the catalog default (with `custom-*` fallback) wins.
+ * Returns the profile key `resolveCallSiteConfig` selects as the winner for a
+ * call site when no per-turn `overrideProfile` is supplied — the highest-
+ * precedence rung that resolves to a usable, complete profile (see
+ * `selectWinningProfile`). Returns `undefined` when the winner is the
+ * code-owned anchor rather than a named profile.
  */
 export function resolveDefaultProfileKey(
   callSite: LLMCallSite,
   llm: z.infer<typeof LLMSchema>,
 ): string | undefined {
-  if (useOverrideOrDefaultSemantics({})) {
-    return selectWinningProfile(callSite, llm, {}).profileName ?? undefined;
-  }
-  if (callSite === "mainAgent" && llm.activeProfile != null) {
-    const active = getEffectiveProfile(llm.profiles, llm.activeProfile);
-    if (active != null && active.status !== "disabled") {
-      return llm.activeProfile;
-    }
-  }
-
-  const dflt = CALL_SITE_DEFAULTS[callSite];
-  if (dflt?.profile == null) return undefined;
-  const target = getEffectiveProfile(llm.profiles, dflt.profile);
-  if (target != null && target.status !== "disabled") return dflt.profile;
-  const customKey = `custom-${dflt.profile}`;
-  const customTarget = getEffectiveProfile(llm.profiles, customKey);
-  if (customTarget != null && customTarget.status !== "disabled")
-    return customKey;
-  return undefined;
+  return selectWinningProfile(callSite, llm, {}).profileName ?? undefined;
 }
 
 /**
- * Returns the profile key that `resolveCallSiteConfig` would actually treat as
- * the winning (highest-precedence) profile for a turn — the profile whose
- * fragment supplies the resolved provider/model. Unlike `resolveDefaultProfileKey`
- * this accounts for the per-turn `overrideProfile`/`forceOverrideProfile` and
- * for `effectiveDefault` stripping the catalog default when an override is
- * present, so error attribution names the slot the resolver really used:
- * - `mainAgent`: override → active → catalog default.
- * - forced override: the override.
- * - other sites: the call-site's own profile (explicit or catalog default) when
- *   one survives; otherwise override → active. A pinned override on a bare call
- *   site therefore attributes to the override, not the stripped catalog default.
+ * Returns the profile key that `resolveCallSiteConfig` treats as the winning
+ * (highest-precedence) profile for a turn — the profile whose fragment supplies
+ * the resolved provider/model. Accounts for the per-turn `overrideProfile`, so
+ * error attribution names the slot the resolver really used. Returns
+ * `undefined` when the winner is the code-owned anchor rather than a named
+ * profile.
  */
 export function resolveEffectiveProfileKey(
   callSite: LLMCallSite,
   llm: z.infer<typeof LLMSchema>,
   opts: ResolveCallSiteOpts = {},
 ): string | undefined {
-  const override = opts.overrideProfile ?? undefined;
-  if (callSite === "mainAgent") {
-    return override ?? resolveDefaultProfileKey(callSite, llm);
-  }
-  if (opts.forceOverrideProfile === true && override != null) {
-    return override;
-  }
-  const site =
-    llm.callSites?.[callSite] ??
-    effectiveDefault(callSite, llm, override != null);
-  if (site?.profile != null) return site.profile;
-  return override ?? llm.activeProfile ?? undefined;
+  return selectWinningProfile(callSite, llm, opts).profileName ?? undefined;
 }
 
 /**
@@ -763,191 +555,10 @@ export function resolveProfilelessModelKey(
   try {
     return resolveCallSiteConfig(callSite, llm, opts).model;
   } catch {
-    return llm.default?.model ?? "default";
-  }
-}
-
-function effectiveDefault(
-  callSite: LLMCallSite,
-  llm: z.infer<typeof LLMSchema>,
-  hasOverrideProfile = false,
-): z.infer<typeof LLMSchema>["callSites"][LLMCallSite] | undefined {
-  const dflt = CALL_SITE_DEFAULTS[callSite];
-  if (dflt == null) return undefined;
-  const targetProfile =
-    dflt.profile != null
-      ? getEffectiveProfile(llm.profiles, dflt.profile)
-      : undefined;
-  const profileUnavailable =
-    dflt.profile != null &&
-    (targetProfile == null || targetProfile.status === "disabled");
-
-  if (profileUnavailable && !hasOverrideProfile) {
-    const customKey = `custom-${dflt.profile}`;
-    const customProfile = getEffectiveProfile(llm.profiles, customKey);
-    if (customProfile != null && customProfile.status !== "disabled") {
-      return { ...dflt, profile: customKey };
-    }
-  }
-
-  const stripProfile = hasOverrideProfile || profileUnavailable;
-  if (stripProfile) {
-    const { profile: _profile, ...rest } = dflt;
-    return Object.keys(rest).length > 0 ? rest : undefined;
-  }
-  return dflt;
-}
-
-/**
- * Stamp a catalog-implied provider onto model-only layers whose model the
- * provider applicable at that point in the merge does not serve. Layers are
- * scanned in merge order (low → high precedence), tracking the provider the
- * merged config would carry at each layer: when that provider already lists
- * the layer's model in its own catalog, no implication is needed and the
- * layer stays provider-less so the lower-precedence provider wins. Models
- * unknown to the catalog never imply a provider.
- */
-function withImpliedProviders(layers: Mergeable[]): Mergeable[] {
-  let applicableProvider: string | undefined;
-  return layers.map((layer) => {
-    if (layer.provider !== undefined) {
-      if (typeof layer.provider === "string") {
-        applicableProvider = layer.provider;
-      }
-      return layer;
-    }
-    const model = layer.model;
-    if (typeof model !== "string" || model.length === 0) {
-      return layer;
-    }
-    if (
-      applicableProvider !== undefined &&
-      isModelInCatalog(applicableProvider, model)
-    ) {
-      return layer;
-    }
-    const provider = getCatalogProviderForModel(model);
-    if (provider === undefined) {
-      return layer;
-    }
-    applicableProvider = provider;
-    return { ...layer, provider };
-  });
-}
-
-/**
- * Fold a profile's sampling into `samplingRef`. A profile determines
- * provider/model, so its pair supersedes any LOWER PROFILE's: set each field the
- * profile specifies, and clear a lower profile's value where the profile is
- * silent. A deliberate call-site override is NOT a profile and outranks a silent
- * profile — it survives until a profile EXPLICITLY sets the field. (The mirror
- * COALESCE for call-site overrides lives in `appendCallSiteLayers`.)
- */
-function applyProfileSampling(
-  samplingRef: SamplingRef,
-  profile: ProfileEntry,
-): void {
-  if (profile.temperature !== undefined) {
-    samplingRef.temperature = profile.temperature;
-    samplingRef.temperatureFromCallSite = false;
-  } else if (!samplingRef.temperatureFromCallSite) {
-    samplingRef.temperature = undefined;
-  }
-  if (profile.topP !== undefined) {
-    samplingRef.topP = profile.topP;
-    samplingRef.topPFromCallSite = false;
-  } else if (!samplingRef.topPFromCallSite) {
-    samplingRef.topP = undefined;
-  }
-}
-
-function appendProfileLayer(
-  layers: Mergeable[],
-  profile: ProfileEntry | undefined,
-  biasRef: LogitBiasRef,
-  samplingRef: SamplingRef,
-): void {
-  if (profile != null) {
-    biasRef.preset = profile.logitBias;
-    applyProfileSampling(samplingRef, profile);
-    layers.push(profileConfigFragment(profile));
+    return "default";
   }
 }
 
-function appendCallSiteLayers(
-  layers: Mergeable[],
-  callSite: LLMCallSite,
-  llm: z.infer<typeof LLMSchema>,
-  site: z.infer<typeof LLMSchema>["callSites"][LLMCallSite] | undefined,
-  opts: ResolveCallSiteOpts,
-  biasRef: LogitBiasRef,
-  samplingRef: SamplingRef,
-): void {
-  if (site != null) {
-    if (site.profile != null) {
-      const profileFragment = resolveProfileFragment(site.profile, llm, opts);
-      if (profileFragment == null) {
-        // Defensive: `LLMSchema.superRefine` already rejects unknown profile
-        // references (and unknown mix arms) at config load, so this branch is
-        // unreachable for any config that survived schema validation. Throw a
-        // clear error in case a hand-crafted (un-parsed) config slips through.
-        throw new Error(
-          `LLM call site "${callSite}" references undefined profile "${site.profile}"`,
-        );
-      }
-      biasRef.preset = profileFragment.logitBias;
-      applyProfileSampling(samplingRef, profileFragment);
-      layers.push(profileConfigFragment(profileFragment));
-    }
-    // Strip the `profile` discriminator (not a `LLMConfigBase` field) and the
-    // sampling params before merging. An explicit call-site `temperature` /
-    // `topP` is a deliberate per-site choice, so it COALESCES over the winning
-    // profile's pair (only overriding the fields it sets) and is marked sticky
-    // so a later silent profile can't clear it — routed through `samplingRef` so
-    // it never inherits a shadowed profile's value via merge.
-    const {
-      profile: _profile,
-      temperature: siteTemperature,
-      topP: siteTopP,
-      ...siteFragment
-    } = site;
-    if (siteTemperature !== undefined) {
-      samplingRef.temperature = siteTemperature;
-      samplingRef.temperatureFromCallSite = true;
-    }
-    if (siteTopP !== undefined) {
-      samplingRef.topP = siteTopP;
-      samplingRef.topPFromCallSite = true;
-    }
-    layers.push(siteFragment as Mergeable);
-  }
-}
-
-function profileConfigFragment(profile: ProfileEntry): Mergeable {
-  const {
-    source: _source,
-    label: _label,
-    description: _description,
-    // `mix` never reaches here in practice (a mix expands to a standard
-    // profile before this point), but strip it defensively so it can never
-    // leak into the merged `LLMConfigBase`.
-    mix: _mix,
-    // `logitBias` is profile-identity metadata, not inheritable config: a
-    // preset must apply only to the profile that opted in, never bleed from a
-    // lower-precedence (e.g. active) profile into one that merely inherited it.
-    // `RetryProvider` resolves it from the applied profile, not the merge.
-    logitBias: _logitBias,
-    // `temperature`/`top_p` are provider-coupled: only the winning profile
-    // contributes them (tracked via `samplingRef`, applied post-merge), so a
-    // shadowed profile's sampling can never reach a different provider through
-    // the deep-merge. Strip here so no profile's sampling enters the merge.
-    temperature: _temperature,
-    topP: _topP,
-    ...config
-  } = profile;
-  return config as Mergeable;
-}
-
 /**
  * Returns true for objects we should recurse into during deep merge. We
  * deliberately exclude arrays so that array-valued fields (e.g.
@@ -972,15 +583,17 @@ function isPlainObject(value: unknown): value is Mergeable {
  *
  * Plain-object values are always cloned (via recursion) rather than aliased,
  * so the returned config is an isolated snapshot — mutating any nested object
- * on the result cannot affect `llm.default`, named profiles, or other call
- * sites' resolutions. Arrays and primitives are copied by reference; the
- * resolver does not return arrays, and primitives are immutable.
+ * on the result cannot affect named profiles or other call sites' resolutions.
+ * Arrays and primitives are copied by reference; the resolver does not return
+ * arrays, and primitives are immutable.
  */
 function deepMerge(...sources: Mergeable[]): Mergeable {
   const out: Mergeable = {};
   for (const source of sources) {
     for (const [key, value] of Object.entries(source)) {
-      if (value === undefined) continue;
+      if (value === undefined) {
+        continue;
+      }
       const existing = out[key];
       if (isPlainObject(value)) {
         // Recurse for any plain-object source. Using `existing` as the base
@@ -998,9 +611,9 @@ function deepMerge(...sources: Mergeable[]): Mergeable {
 }
 
 /**
- * Cast helper that documents the intent: after merging `llm.default` (which
- * is `LLMConfigBase`) with optional fragments, every required field is still
- * present, so the result satisfies `LLMConfigBase`.
+ * Cast helper that documents the intent: after merging the code-owned base
+ * (which is `LLMConfigBase`) with optional fragments, every required field is
+ * still present, so the result satisfies `LLMConfigBase`.
  */
 function finalize(merged: Mergeable): z.infer<typeof LLMConfigBase> {
   return merged as unknown as z.infer<typeof LLMConfigBase>;