Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript
24.4 KB
Raw Blame
/**
 * v0.28: tests for the unified model resolver. Pure-function-style tests using
 * a tiny stub engine — no DB, no PGLite, no Postgres needed.
 */
import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
import {
  resolveModel,
  resolveModelDetailed,
  resolveAlias,
  resolveTierDefault,
  resolveEffectiveChatModel,
  providerKeyReady,
  openaiStaticTierFallback,
  DEFAULT_ALIASES,
  TIER_DEFAULTS,
  PROVIDER_TIER_DEFAULTS,
  isAnthropicProvider,
  isOpenRouterAnthropic,
  isOpenRouterSubagentFamily,
  _resetDeprecationWarningsForTest,
} from '../src/core/model-config.ts';
import type { GBrainConfig } from '../src/core/config.ts';
import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { withEnv } from './helpers/with-env.ts';

class StubEngine {
  readonly kind = 'pglite' as const;
  private cfg = new Map<string, string>();
  set(key: string, value: string) { this.cfg.set(key, value); }
  async getConfig(key: string) { return this.cfg.get(key) ?? null; }
  // unused stubs to satisfy the BrainEngine duck-type at the resolveModel boundary
  async setConfig() {}
}

let stub: StubEngine;
let stderrCapture: string;
const origWrite = process.stderr.write.bind(process.stderr);

// Hermetic-env pinning (TODOS:1200 class): the key-aware tier default reads
// provider keys from process.env AND ~/.gbrain/config.json. Without pinning,
// every default-path assertion below would flip on a dev shell that exports
// only OPENAI_API_KEY (or carries keys in config.json). Save/delete the key
// envs and point GBRAIN_HOME at a nonexistent dir so the config read misses —
// local runs then match keyless CI byte-for-byte.
const PINNED_ENV_KEYS = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GBRAIN_HOME'] as const;
let savedEnv: Record<string, string | undefined>;

beforeEach(() => {
  stub = new StubEngine();
  stderrCapture = '';
  process.stderr.write = ((chunk: string | Uint8Array) => {
    stderrCapture += typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString();
    return true;
  }) as typeof process.stderr.write;
  delete process.env.GBRAIN_MODEL;
  savedEnv = {};
  for (const k of PINNED_ENV_KEYS) {
    savedEnv[k] = process.env[k];
    delete process.env[k];
  }
  process.env.GBRAIN_HOME = '/nonexistent-gbrain-home-for-model-config-tests';
  _resetDeprecationWarningsForTest();
});

afterEach(() => {
  process.stderr.write = origWrite;
  for (const k of PINNED_ENV_KEYS) {
    if (savedEnv[k] === undefined) delete process.env[k];
    else process.env[k] = savedEnv[k];
  }
});

describe('resolveAlias', () => {
  test('built-in aliases resolve to full ids', async () => {
    expect(await resolveAlias(null, 'opus')).toBe(DEFAULT_ALIASES.opus);
    expect(await resolveAlias(null, 'sonnet')).toBe(DEFAULT_ALIASES.sonnet);
    expect(await resolveAlias(null, 'haiku')).toBe(DEFAULT_ALIASES.haiku);
  });

  test('unknown alias passes through (treats as full id)', async () => {
    expect(await resolveAlias(null, 'claude-experimental-9000')).toBe('claude-experimental-9000');
  });

  test('user-defined alias overrides built-in', async () => {
    stub.set('models.aliases.opus', 'claude-opus-4-7-1m');
    expect(await resolveAlias(stub as never, 'opus')).toBe('claude-opus-4-7-1m');
  });

  test('cycle in aliases breaks at depth 2', async () => {
    stub.set('models.aliases.a', 'b');
    stub.set('models.aliases.b', 'a');
    const result = await resolveAlias(stub as never, 'a');
    expect(typeof result).toBe('string');
  });
});

describe('resolveModel — 6-tier precedence', () => {
  test('CLI flag wins over everything', async () => {
    stub.set('models.dream.synthesize', 'sonnet');
    stub.set('models.default', 'opus');
    process.env.GBRAIN_MODEL = 'haiku';
    const m = await resolveModel(stub as never, {
      cliFlag: 'gemini',
      configKey: 'models.dream.synthesize',
      fallback: 'sonnet',
    });
    expect(m).toBe(DEFAULT_ALIASES.gemini);
  });

  test('new-key config wins over deprecated key, deprecated key wins over default', async () => {
    stub.set('models.dream.synthesize', 'opus');
    stub.set('dream.synthesize.model', 'sonnet');
    stub.set('models.default', 'haiku');
    const m = await resolveModel(stub as never, {
      configKey: 'models.dream.synthesize',
      deprecatedConfigKey: 'dream.synthesize.model',
      fallback: 'sonnet',
    });
    expect(m).toBe(DEFAULT_ALIASES.opus);
    expect(stderrCapture).toContain('deprecated config "dream.synthesize.model" ignored');
  });

  test('deprecated key honored when new key absent (with warning)', async () => {
    stub.set('dream.synthesize.model', 'opus');
    const m = await resolveModel(stub as never, {
      configKey: 'models.dream.synthesize',
      deprecatedConfigKey: 'dream.synthesize.model',
      fallback: 'sonnet',
    });
    expect(m).toBe(DEFAULT_ALIASES.opus);
    expect(stderrCapture).toContain('deprecated config "dream.synthesize.model" honored');
  });

  test('global default used when per-key keys absent', async () => {
    stub.set('models.default', 'opus');
    const m = await resolveModel(stub as never, {
      configKey: 'models.dream.synthesize',
      fallback: 'sonnet',
    });
    expect(m).toBe(DEFAULT_ALIASES.opus);
  });

  test('env var used when no config set', async () => {
    process.env.GBRAIN_MODEL = 'haiku';
    const m = await resolveModel(stub as never, {
      configKey: 'models.dream.synthesize',
      fallback: 'sonnet',
    });
    expect(m).toBe(DEFAULT_ALIASES.haiku);
  });

  test('hardcoded fallback last', async () => {
    const m = await resolveModel(stub as never, {
      configKey: 'models.dream.synthesize',
      fallback: 'sonnet',
    });
    expect(m).toBe(DEFAULT_ALIASES.sonnet);
  });

  test('subagent tier: loop-incapable models.tier.subagent falls back to TIER_DEFAULTS with warn', async () => {
    // moonshot supports tools but declares supports_subagent_loop: false —
    // pre-fix enforceSubagentCapable classified it tools-sufficient and let
    // the inherited tier value drive the loop.
    stub.set('models.tier.subagent', 'moonshot:kimi-k2.5');
    const m = await resolveModel(stub as never, {
      tier: 'subagent',
      configKey: 'models.subagent',
      fallback: TIER_DEFAULTS.subagent,
    });
    expect(m).toBe(TIER_DEFAULTS.subagent);
    expect(stderrCapture).toContain('supports_subagent_loop: false');
  });

  test('deprecation warning fires once per process per key', async () => {
    stub.set('dream.synthesize.model', 'opus');
    await resolveModel(stub as never, {
      configKey: 'models.dream.synthesize',
      deprecatedConfigKey: 'dream.synthesize.model',
      fallback: 'sonnet',
    });
    const firstWarn = stderrCapture;
    stderrCapture = '';
    await resolveModel(stub as never, {
      configKey: 'models.dream.synthesize',
      deprecatedConfigKey: 'dream.synthesize.model',
      fallback: 'sonnet',
    });
    expect(firstWarn).toContain('deprecated config');
    expect(stderrCapture).toBe('');
  });
});

describe('resolveModel — v0.31.12 tier system', () => {
  test('models.tier.<tier> beats models.default (#3873 — specific over generic)', async () => {
    stub.set('models.default', 'opus');
    stub.set('models.tier.reasoning', 'haiku');
    const m = await resolveModel(stub as never, {
      tier: 'reasoning',
      fallback: 'sonnet',
    });
    expect(m).toBe(DEFAULT_ALIASES.haiku);
  });

  test('models.default still applies when the call has no tier (#3873)', async () => {
    stub.set('models.default', 'opus');
    stub.set('models.tier.reasoning', 'haiku');
    const m = await resolveModel(stub as never, {
      fallback: 'sonnet',
    });
    expect(m).toBe(DEFAULT_ALIASES.opus);
  });

  test('models.default still applies when the tier has no override (#3873)', async () => {
    stub.set('models.default', 'opus');
    const m = await resolveModel(stub as never, {
      tier: 'reasoning',
      fallback: 'sonnet',
    });
    expect(m).toBe(DEFAULT_ALIASES.opus);
  });

  test('models.tier.<tier> beats env + fallback', async () => {
    stub.set('models.tier.reasoning', 'opus');
    process.env.GBRAIN_MODEL = 'haiku';
    const m = await resolveModel(stub as never, {
      tier: 'reasoning',
      fallback: 'sonnet',
    });
    expect(m).toBe(DEFAULT_ALIASES.opus);
  });

  test('TIER_DEFAULTS wins over caller fallback when no override', async () => {
    const m = await resolveModel(stub as never, {
      tier: 'reasoning',
      fallback: 'haiku',
    });
    expect(m).toBe(TIER_DEFAULTS.reasoning);
  });

  test('v0.38 D7: tier.subagent accepts non-Anthropic models that support tools (with cost warn)', async () => {
    // Pre-v0.38 the resolver hard-fell-back to TIER_DEFAULTS.subagent for any
    // non-Anthropic model. v0.38 (D6/D7) replaces that with a capability check:
    // a provider with tools but no prompt caching → resolved unchanged + warn
    // about the cost regression on long loops (not a refusal).
    stub.set('models.default', 'google:gemini-1.5-pro');
    const m = await resolveModel(stub as never, {
      tier: 'subagent',
      fallback: 'sonnet',
    });
    expect(m).toBe('google:gemini-1.5-pro');
    expect(stderrCapture).toContain('caching');
  });

  test('v0.38 D7: a provider that caches automatically is accepted WITHOUT the cost warn', async () => {
    // The warn advises moving to an Anthropic model "for lower cost on long
    // loops". On providers that already cache prompt prefixes server-side that
    // advice is backwards, so the capability check must not fire it.
    stub.set('models.default', 'openai:gpt-5.2');
    const m = await resolveModel(stub as never, {
      tier: 'subagent',
      fallback: 'sonnet',
    });
    expect(m).toBe('openai:gpt-5.2');
    expect(stderrCapture).not.toContain('caching');
  });

  test('v0.38 D7: tier.subagent rejects unknown providers (falls back to default)', async () => {
    // Unknown providers fail the capability check (verdict='unknown'); the
    // resolver falls back to TIER_DEFAULTS.subagent rather than burn money on
    // an unverified model.
    stub.set('models.tier.subagent', 'madeup-provider:weird-model');
    const m = await resolveModel(stub as never, {
      tier: 'subagent',
      fallback: 'sonnet',
    });
    expect(m).toBe(TIER_DEFAULTS.subagent);
    expect(stderrCapture).toContain('tier.subagent');
  });

  test('tier.subagent accepts explicit Anthropic override', async () => {
    stub.set('models.tier.subagent', 'anthropic:claude-opus-4-7');
    const m = await resolveModel(stub as never, {
      tier: 'subagent',
      fallback: 'sonnet',
    });
    expect(m).toBe('anthropic:claude-opus-4-7');
    expect(stderrCapture).toBe('');
  });

  test('isAnthropicProvider matches provider-prefixed and bare claude-* ids', () => {
    expect(isAnthropicProvider('anthropic:claude-sonnet-4-6')).toBe(true);
    expect(isAnthropicProvider('claude-opus-4-7')).toBe(true);
    expect(isAnthropicProvider('openai:gpt-5.5')).toBe(false);
    expect(isAnthropicProvider('gemini-3-pro')).toBe(false);
    expect(isAnthropicProvider('')).toBe(false);
  });

  test('v0.41.20.0: isAnthropicProvider classifies slash-form (subagent-guard fix)', () => {
    // Pre-fix: 'anthropic/claude-sonnet-4-6' had no colon and didn't start
    // with 'claude-' (started with 'anthropic') → returned false → silent
    // subagent-guard bypass → fall back to TIER_DEFAULTS.subagent without
    // honoring the user's explicit slash-form config.
    expect(isAnthropicProvider('anthropic/claude-sonnet-4-6')).toBe(true);
    expect(isAnthropicProvider('anthropic/claude-opus-4-7')).toBe(true);
    // Non-Anthropic slash forms STILL return false (don't accidentally
    // widen the guard).
    expect(isAnthropicProvider('openai/gpt-5')).toBe(false);
    expect(isAnthropicProvider('google/gemini-3-pro')).toBe(false);
    // OpenRouter Anthropic is a proxy route, not the Messages API.
    expect(isAnthropicProvider('openrouter:anthropic/claude-haiku-4.5')).toBe(false);
  });

  test('isOpenRouterAnthropic matches only openrouter:anthropic/… routes', () => {
    expect(isOpenRouterAnthropic('openrouter:anthropic/claude-haiku-4.5')).toBe(true);
    expect(isOpenRouterAnthropic('openrouter:anthropic/claude-sonnet-4.6')).toBe(true);
    expect(isOpenRouterAnthropic('openrouter:openai/gpt-5.2')).toBe(false);
    expect(isOpenRouterAnthropic('openrouter:deepseek/deepseek-chat')).toBe(false);
    expect(isOpenRouterAnthropic('anthropic:claude-sonnet-4-6')).toBe(false);
    expect(isOpenRouterAnthropic('')).toBe(false);
  });

  test('isOpenRouterSubagentFamily matches the OR families with a live abort/retry pin', () => {
    expect(isOpenRouterSubagentFamily('openrouter:anthropic/claude-haiku-4.5')).toBe(true);
    expect(isOpenRouterSubagentFamily('openrouter:deepseek/deepseek-v4-flash')).toBe(true);
    expect(isOpenRouterSubagentFamily('openrouter:DeepSeek/deepseek-chat')).toBe(true);
    expect(isOpenRouterSubagentFamily('openrouter:openai/gpt-5.2')).toBe(false);
    expect(isOpenRouterSubagentFamily('openrouter:google/gemini-3-flash-preview')).toBe(false);
    expect(isOpenRouterSubagentFamily('deepseek:deepseek-v4-flash')).toBe(false);
    expect(isOpenRouterSubagentFamily('anthropic:claude-sonnet-4-6')).toBe(false);
    expect(isOpenRouterSubagentFamily('')).toBe(false);
  });

  test('alias-chain conflict: forward + reverse for same id (Codex F6)', async () => {
    // Codex F6: if both forward and reverse aliases exist, depth cap (2)
    // prevents infinite loop. Canonicalization is deterministic — terminates
    // and returns a valid string, no NaN/undefined fall-through.
    stub.set('models.aliases.claude-sonnet-4-6', 'claude-sonnet-5');
    stub.set('models.aliases.claude-sonnet-5', 'claude-sonnet-4-6');
    const result = await resolveAlias(stub as never, 'claude-sonnet-4-6');
    expect(typeof result).toBe('string');
    expect(result.length).toBeGreaterThan(0);
  });
});

describe('resolveTierDefault — key-aware matrix (injected env used exclusively)', () => {
  test('anthropic-only → anthropic tier defaults (unchanged behavior)', () => {
    const env = { ANTHROPIC_API_KEY: 'sk-ant-test' };
    expect(resolveTierDefault('reasoning', env)).toBe(TIER_DEFAULTS.reasoning);
    expect(resolveTierDefault('utility', env)).toBe(TIER_DEFAULTS.utility);
    expect(resolveTierDefault('deep', env)).toBe(TIER_DEFAULTS.deep);
    expect(resolveTierDefault('subagent', env)).toBe(TIER_DEFAULTS.subagent);
  });

  test('openai-only → recipe-ranked openai tier defaults (no literal pins anywhere)', () => {
    const env = { OPENAI_API_KEY: 'sk-test' };
    const fallback = openaiStaticTierFallback();
    // Behavioral, not literal: the expected ids derive from the openai
    // recipe's chat list through the shared ranking grammar — updating the
    // recipe at a release updates this test's expectations automatically.
    expect(resolveTierDefault('reasoning', env)).toBe(fallback.reasoning);
    expect(resolveTierDefault('utility', env)).toBe(fallback.utility);
    expect(resolveTierDefault('deep', env)).toBe(fallback.deep);
    expect(resolveTierDefault('subagent', env)).toBe(fallback.subagent);
    // Shape sanity: all openai-prefixed, cheap ≠ top unless the recipe list
    // collapses to one family member.
    for (const id of Object.values(fallback)) expect(id.startsWith('openai:')).toBe(true);
  });

  test('both keys → anthropic wins (first table entry; zero change for keyed installs)', () => {
    const env = { ANTHROPIC_API_KEY: 'sk-ant-test', OPENAI_API_KEY: 'sk-test' };
    expect(resolveTierDefault('reasoning', env)).toBe(TIER_DEFAULTS.reasoning);
  });

  test('no keys → TIER_DEFAULTS unchanged (keyless shape preserved)', () => {
    expect(resolveTierDefault('reasoning', {})).toBe(TIER_DEFAULTS.reasoning);
  });

  test('empty-string keys treated absent (#1249 posture)', () => {
    const env = { ANTHROPIC_API_KEY: '', OPENAI_API_KEY: '' };
    expect(resolveTierDefault('reasoning', env)).toBe(TIER_DEFAULTS.reasoning);
    const openaiOnly = { ANTHROPIC_API_KEY: '', OPENAI_API_KEY: 'sk-test' };
    expect(resolveTierDefault('reasoning', openaiOnly)).toBe(openaiStaticTierFallback().reasoning);
  });

  test('table order is the precedence contract: anthropic first, openai second', () => {
    expect(PROVIDER_TIER_DEFAULTS[0].provider).toBe('anthropic');
    expect(PROVIDER_TIER_DEFAULTS[1].provider).toBe('openai');
  });
});

describe('resolveModelDetailed — sources + key-aware step 7', () => {
  test('tier default resolves key-aware with source tier_default (openai-only env)', async () => {
    process.env.OPENAI_API_KEY = 'sk-test';
    try {
      const r = await resolveModelDetailed(null, { tier: 'reasoning', fallback: 'sonnet' });
      expect(r.model).toBe(openaiStaticTierFallback().reasoning);
      expect(r.source).toBe('tier_default');
    } finally {
      delete process.env.OPENAI_API_KEY;
    }
  });

  test('GBRAIN_MODEL env still beats the key-aware tier default (source env)', async () => {
    process.env.GBRAIN_MODEL = 'haiku';
    process.env.OPENAI_API_KEY = 'sk-test';
    try {
      const r = await resolveModelDetailed(null, { tier: 'reasoning', fallback: 'sonnet' });
      expect(r.model).toBe(DEFAULT_ALIASES.haiku);
      expect(r.source).toBe('env');
    } finally {
      delete process.env.GBRAIN_MODEL;
      delete process.env.OPENAI_API_KEY;
    }
  });

  test('models.tier.<tier> config still beats the key-aware default (source tier_config)', async () => {
    process.env.OPENAI_API_KEY = 'sk-test';
    try {
      stub.set('models.tier.reasoning', 'opus');
      const r = await resolveModelDetailed(stub as never, { tier: 'reasoning', fallback: 'sonnet' });
      expect(r.model).toBe(DEFAULT_ALIASES.opus);
      expect(r.source).toBe('tier_config');
    } finally {
      delete process.env.OPENAI_API_KEY;
    }
  });

  test('config key wins with source config_key; fallback labels fallback', async () => {
    stub.set('facts.extraction_model', 'openai:gpt-4o-mini');
    const withKey = await resolveModelDetailed(stub as never, {
      configKey: 'facts.extraction_model', tier: 'reasoning', fallback: 'sonnet',
    });
    expect(withKey).toEqual({ model: 'openai:gpt-4o-mini', source: 'config_key' });
    const noTier = await resolveModelDetailed(null, { fallback: 'sonnet' });
    expect(noTier.source).toBe('fallback');
    expect(noTier.model).toBe(DEFAULT_ALIASES.sonnet);
  });

  test('subagent + openai-only: returns cache-capable openai without a no-caching warn', async () => {
    process.env.OPENAI_API_KEY = 'sk-test';
    try {
      const r = await resolveModelDetailed(null, { tier: 'subagent', fallback: 'sonnet' });
      expect(r.model).toBe(openaiStaticTierFallback().subagent);
      expect(stderrCapture).not.toContain('caching');
      const before = stderrCapture.length;
      await resolveModelDetailed(null, { tier: 'subagent', fallback: 'sonnet' });
      expect(stderrCapture.length).toBe(before); // remains warning-free
    } finally {
      delete process.env.OPENAI_API_KEY;
    }
  });
});

describe('providerKeyReady + resolveEffectiveChatModel (shared runtime/report resolution)', () => {
  const fileCfg = (partial: Partial<GBrainConfig>): GBrainConfig =>
    ({ engine: 'pglite', ...partial }) as GBrainConfig;

  test('providerKeyReady: recipe auth_env drives readiness; bare/unknown ids are not servable', () => {
    expect(providerKeyReady('openai:gpt-5.2', { OPENAI_API_KEY: 'sk-test' })).toBe(true);
    expect(providerKeyReady('openai:gpt-5.2', {})).toBe(false);
    expect(providerKeyReady('claude-sonnet-4-6', { ANTHROPIC_API_KEY: 'x' })).toBe(false); // bare id
    expect(providerKeyReady('not-a-provider:x', { OPENAI_API_KEY: 'sk-test' })).toBe(false);
    // No required keys + a chat touchpoint (the CLI owns auth) → ready.
    expect(providerKeyReady('claude-cli:claude-sonnet-4-6', {})).toBe(true);
    // A keyed/keyless but CHAT-LESS recipe is NOT ready: honoring an
    // embedding-only pin as chat_model would install a model
    // isAvailable('chat') rejects instead of falling back to the key-aware
    // default. (voyage is embedding-only, hence false despite a live key.
    // ollama gained a local chat touchpoint in #4073/#4315, so keyless → ready.)
    expect(providerKeyReady('voyage:voyage-4-large', { VOYAGE_API_KEY: 'x' })).toBe(false);
    expect(providerKeyReady('ollama:llama3', {})).toBe(true);
  });

  test('servable file pin wins (init-era openai pin + live key)', () => {
    const r = resolveEffectiveChatModel(
      fileCfg({ chat_model: 'openai:gpt-5.2', openai_api_key: 'sk-file' }), {});
    expect(r).toEqual({ model: 'openai:gpt-5.2', source: 'file_pin' });
  });

  test('unservable pin falls through to key-aware default with one warn (provider switch)', () => {
    // Stale init-era openai pin, but the only live key is Anthropic.
    const cfg = fileCfg({ chat_model: 'openai:gpt-5.2' });
    const env = { ANTHROPIC_API_KEY: 'sk-ant-test' };
    const r = resolveEffectiveChatModel(cfg, env);
    expect(r).toEqual({ model: TIER_DEFAULTS.reasoning, source: 'tier_default' });
    expect(stderrCapture).toContain('openai:gpt-5.2');
    const before = stderrCapture.length;
    resolveEffectiveChatModel(cfg, env);
    expect(stderrCapture.length).toBe(before); // warned once per pin per process
  });

  test('GBRAIN_MODEL beats the file pin (env_model source)', () => {
    const r = resolveEffectiveChatModel(
      fileCfg({ chat_model: 'openai:gpt-5.2', openai_api_key: 'sk-file' }),
      { GBRAIN_MODEL: 'anthropic:claude-sonnet-4-6' });
    expect(r).toEqual({ model: 'anthropic:claude-sonnet-4-6', source: 'env_model' });
  });

  test('no pin, no env model → key-aware tier default (keyless → anthropic shape)', () => {
    expect(resolveEffectiveChatModel(null, {})).toEqual({
      model: TIER_DEFAULTS.reasoning, source: 'tier_default',
    });
    expect(resolveEffectiveChatModel(null, { OPENAI_API_KEY: 'sk-test' })).toEqual({
      model: openaiStaticTierFallback().reasoning, source: 'tier_default',
    });
  });
});

// ─── #3813: no anthropic/openai key + a SERVABLE file-plane pin ────────────
// resolveTierDefault walked PROVIDER_TIER_DEFAULTS (anthropic, openai) and
// returned the Anthropic TIER_DEFAULTS floor when neither key was present —
// even when ~/.gbrain/config.json pinned a servable third provider (the
// DeepSeek-only install from the issue). Every bare `resolveTierDefault(tier)`
// caller (extract_atoms, facts classify, page-summary, ...) then called a
// provider with no key. Real config.json under a temp GBRAIN_HOME: the
// no-env branch is the code path under test, so no injected env here.
describe('resolveTierDefault — servable file-plane pin beats the Anthropic floor when no anthropic/openai key (#3813)', () => {
  let home: string;

  beforeEach(() => {
    home = mkdtempSync(join(tmpdir(), 'gbrain-model-config-pin-'));
    mkdirSync(join(home, '.gbrain'));
    writeFileSync(
      join(home, '.gbrain', 'config.json'),
      JSON.stringify({
        engine: 'pglite',
        expansion_model: 'deepseek:deepseek-v4-flash',
        chat_model: 'deepseek:deepseek-v4-pro',
      }),
    );
    process.env.GBRAIN_HOME = home;
  });

  afterEach(() => {
    rmSync(home, { recursive: true, force: true });
  });

  test('DEEPSEEK_API_KEY only → utility follows expansion_model, other tiers follow chat_model', async () => {
    await withEnv({ DEEPSEEK_API_KEY: 'sk-test' }, () => {
      expect(resolveTierDefault('utility')).toBe('deepseek:deepseek-v4-flash');
      expect(resolveTierDefault('reasoning')).toBe('deepseek:deepseek-v4-pro');
      expect(resolveTierDefault('deep')).toBe('deepseek:deepseek-v4-pro');
    });
  });

  test('no key at all → the pin is unservable → TIER_DEFAULTS unchanged', async () => {
    await withEnv({ DEEPSEEK_API_KEY: undefined }, () => {
      expect(resolveTierDefault('utility')).toBe(TIER_DEFAULTS.utility);
      expect(resolveTierDefault('reasoning')).toBe(TIER_DEFAULTS.reasoning);
    });
  });

  test('ANTHROPIC_API_KEY present → key walk wins, the pin is ignored (keyed routing unchanged)', async () => {
    await withEnv({ ANTHROPIC_API_KEY: 'sk-ant-test', DEEPSEEK_API_KEY: 'sk-test' }, () => {
      expect(resolveTierDefault('utility')).toBe(TIER_DEFAULTS.utility);
      expect(resolveTierDefault('reasoning')).toBe(TIER_DEFAULTS.reasoning);
    });
  });

  test('injected env stays hermetic: no config read, so no pin', async () => {
    await withEnv({ DEEPSEEK_API_KEY: 'sk-test' }, () => {
      expect(resolveTierDefault('utility', { DEEPSEEK_API_KEY: 'sk-test' })).toBe(TIER_DEFAULTS.utility);
    });
  });
});