@open-mercato/ai-assistant 0.6.1-develop.3246.1.dbef9d7392 → 0.6.1-develop.3256.1.fe3dec2464

package/src/modules/ai_assistant/lib/__tests__/llm-adapters-openai.test.ts

@@ -98,6 +98,46 @@ describe('OpenAIAdapter (OpenAI-compatible provider factory)', () => {
     const provider = createOpenAICompatibleProvider(azurePreset!)
     expect(provider.id).toBe('azure')
   })
+
+  it('preset env baseURL override beats preset default for openai', () => {
+    const openaiPreset = OPENAI_COMPATIBLE_PRESETS.find((p) => p.id === 'openai')!
+    const provider = createOpenAICompatibleProvider(openaiPreset)
+    // Without override the preset baseURL is undefined (uses AI SDK default).
+    const modelDefault = provider.createModel({ apiKey: 'key', modelId: 'gpt-4o-mini' })
+    expect(modelDefault).toBeDefined()
+    // With a per-call baseURL override the adapter must not crash.
+    const modelOverride = provider.createModel({
+      apiKey: 'key',
+      modelId: 'gpt-4o-mini',
+      baseURL: 'https://custom-proxy.example.com/v1',
+    })
+    expect(modelOverride).toBeDefined()
+  })
+
+  it('openai preset declares OPENAI_BASE_URL in baseURLEnvKeys', () => {
+    const openaiPreset = OPENAI_COMPATIBLE_PRESETS.find((p) => p.id === 'openai')!
+    expect(openaiPreset.baseURLEnvKeys).toContain('OPENAI_BASE_URL')
+  })
+
+  it('deepinfra preset declares DEEPINFRA_BASE_URL in baseURLEnvKeys', () => {
+    const preset = OPENAI_COMPATIBLE_PRESETS.find((p) => p.id === 'deepinfra')!
+    expect(preset.baseURLEnvKeys).toContain('DEEPINFRA_BASE_URL')
+  })
+
+  it('groq preset declares GROQ_BASE_URL in baseURLEnvKeys', () => {
+    const preset = OPENAI_COMPATIBLE_PRESETS.find((p) => p.id === 'groq')!
+    expect(preset.baseURLEnvKeys).toContain('GROQ_BASE_URL')
+  })
+
+  it('together preset declares TOGETHER_BASE_URL in baseURLEnvKeys', () => {
+    const preset = OPENAI_COMPATIBLE_PRESETS.find((p) => p.id === 'together')!
+    expect(preset.baseURLEnvKeys).toContain('TOGETHER_BASE_URL')
+  })
+
+  it('fireworks preset declares FIREWORKS_BASE_URL in baseURLEnvKeys', () => {
+    const preset = OPENAI_COMPATIBLE_PRESETS.find((p) => p.id === 'fireworks')!
+    expect(preset.baseURLEnvKeys).toContain('FIREWORKS_BASE_URL')
+  })
 })
 
 describe('OpenAI preset OPENCODE_* fallback env keys', () => {
@@ -124,8 +164,8 @@ describe('OpenAI preset OPENCODE_* fallback env keys', () => {
 })
 
 describe('OPENAI_COMPATIBLE_PRESETS built-in catalog', () => {
-  it('ships at least 8 built-in presets including openai and deepinfra', () => {
-    expect(OPENAI_COMPATIBLE_PRESETS.length).toBeGreaterThanOrEqual(8)
+  it('ships at least 10 built-in presets including openai, openrouter, and lm-studio', () => {
+    expect(OPENAI_COMPATIBLE_PRESETS.length).toBeGreaterThanOrEqual(10)
     const ids = OPENAI_COMPATIBLE_PRESETS.map((p) => p.id)
     expect(ids).toContain('openai')
     expect(ids).toContain('deepinfra')
@@ -135,18 +175,33 @@ describe('OPENAI_COMPATIBLE_PRESETS built-in catalog', () => {
     expect(ids).toContain('azure')
     expect(ids).toContain('litellm')
     expect(ids).toContain('ollama')
+    expect(ids).toContain('openrouter')
+    expect(ids).toContain('lm-studio')
   })
 
-  it('every preset has at least one model and one env key', () => {
+  it('every preset has at least one env key', () => {
     for (const preset of OPENAI_COMPATIBLE_PRESETS) {
       expect(preset.envKeys.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('non-auto-detect presets have at least one model and a non-empty defaultModel', () => {
+    for (const preset of OPENAI_COMPATIBLE_PRESETS) {
+      if (preset.id === 'lm-studio') {
+        // LM Studio deliberately uses empty defaultModel — auto-detects the
+        // loaded model from the request body's model field.
+        expect(preset.defaultModel).toBe('')
+        expect(preset.defaultModels.length).toBe(0)
+        continue
+      }
       expect(preset.defaultModels.length).toBeGreaterThan(0)
       expect(preset.defaultModel.length).toBeGreaterThan(0)
     }
   })
 
-  it('every preset defaultModel exists in its defaultModels array', () => {
+  it('every non-auto-detect preset defaultModel exists in its defaultModels array', () => {
     for (const preset of OPENAI_COMPATIBLE_PRESETS) {
+      if (preset.id === 'lm-studio') continue
       const ids = preset.defaultModels.map((m) => m.id)
       expect(ids).toContain(preset.defaultModel)
     }
@@ -158,3 +213,94 @@ describe('OPENAI_COMPATIBLE_PRESETS built-in catalog', () => {
     expect(unique.size).toBe(ids.length)
   })
 })
+
+describe('OpenRouter preset', () => {
+  const openrouterPreset = OPENAI_COMPATIBLE_PRESETS.find((p) => p.id === 'openrouter')!
+
+  it('has expected shape', () => {
+    expect(openrouterPreset).toBeDefined()
+    expect(openrouterPreset.baseURL).toBe('https://openrouter.ai/api/v1')
+    expect(openrouterPreset.baseURLEnvKeys).toContain('OPENROUTER_BASE_URL')
+    expect(openrouterPreset.envKeys).toContain('OPENROUTER_API_KEY')
+    expect(openrouterPreset.defaultModel).toBe('meta-llama/llama-3.3-70b-instruct')
+  })
+
+  it('isConfigured returns true only when OPENROUTER_API_KEY is set', () => {
+    const provider = createOpenAICompatibleProvider(openrouterPreset)
+    expect(provider.isConfigured({ OPENROUTER_API_KEY: 'or-key' })).toBe(true)
+    expect(provider.isConfigured({ OPENAI_API_KEY: 'unrelated' })).toBe(false)
+    expect(provider.isConfigured({})).toBe(false)
+  })
+
+  it('getConfiguredEnvKey returns OPENROUTER_API_KEY', () => {
+    const provider = createOpenAICompatibleProvider(openrouterPreset)
+    expect(provider.getConfiguredEnvKey({ OPENROUTER_API_KEY: 'key' })).toBe('OPENROUTER_API_KEY')
+    expect(provider.getConfiguredEnvKey({})).toBe('OPENROUTER_API_KEY')
+  })
+
+  it('createModel with default baseURL does not throw', () => {
+    const provider = createOpenAICompatibleProvider(openrouterPreset)
+    const model = provider.createModel({ apiKey: 'or-key', modelId: openrouterPreset.defaultModel })
+    expect(model).toBeDefined()
+  })
+
+  it('createModel with per-call baseURL override does not throw', () => {
+    const provider = createOpenAICompatibleProvider(openrouterPreset)
+    const model = provider.createModel({
+      apiKey: 'or-key',
+      modelId: openrouterPreset.defaultModel,
+      baseURL: 'https://my-openrouter-proxy.example.com/v1',
+    })
+    expect(model).toBeDefined()
+  })
+
+  it('OPENROUTER_BASE_URL env override beats preset default', () => {
+    const provider = createOpenAICompatibleProvider(openrouterPreset)
+    const model = provider.createModel({
+      apiKey: 'or-key',
+      modelId: openrouterPreset.defaultModel,
+      baseURL: 'https://overridden.example.com/v1',
+    })
+    expect(model).toBeDefined()
+  })
+})
+
+describe('LM Studio preset', () => {
+  const lmStudioPreset = OPENAI_COMPATIBLE_PRESETS.find((p) => p.id === 'lm-studio')!
+
+  it('has expected shape with empty defaultModel', () => {
+    expect(lmStudioPreset).toBeDefined()
+    expect(lmStudioPreset.baseURL).toBe('http://localhost:1234/v1')
+    expect(lmStudioPreset.baseURLEnvKeys).toContain('LM_STUDIO_BASE_URL')
+    expect(lmStudioPreset.envKeys).toContain('LM_STUDIO_API_KEY')
+    expect(lmStudioPreset.defaultModel).toBe('')
+    expect(lmStudioPreset.defaultModels).toHaveLength(0)
+  })
+
+  it('isConfigured returns true when LM_STUDIO_API_KEY is set', () => {
+    const provider = createOpenAICompatibleProvider(lmStudioPreset)
+    expect(provider.isConfigured({ LM_STUDIO_API_KEY: 'lm-key' })).toBe(true)
+    expect(provider.isConfigured({})).toBe(false)
+  })
+
+  it('getConfiguredEnvKey returns LM_STUDIO_API_KEY', () => {
+    const provider = createOpenAICompatibleProvider(lmStudioPreset)
+    expect(provider.getConfiguredEnvKey({})).toBe('LM_STUDIO_API_KEY')
+  })
+
+  it('createModel with empty modelId does not throw', () => {
+    const provider = createOpenAICompatibleProvider(lmStudioPreset)
+    const model = provider.createModel({ apiKey: 'lm-key', modelId: '' })
+    expect(model).toBeDefined()
+  })
+
+  it('createModel with per-call baseURL override does not throw', () => {
+    const provider = createOpenAICompatibleProvider(lmStudioPreset)
+    const model = provider.createModel({
+      apiKey: 'lm-key',
+      modelId: '',
+      baseURL: 'http://192.168.1.100:1234/v1',
+    })
+    expect(model).toBeDefined()
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/model-allowlist.test.ts

@@ -0,0 +1,290 @@
+import {
+  agentOverrideModelAllowlistEnvVarName,
+  agentOverrideProviderAllowlistEnvVarName,
+  intersectEffectiveAllowlistWithSnapshot,
+  intersectAllowlists,
+  isModelAllowedForProvider,
+  isModelAllowedForProviderInEffective,
+  isProviderAllowed,
+  isProviderAllowedInEffective,
+  isProviderModelAllowed,
+  isProviderModelAllowedInEffective,
+  modelAllowlistEnvVarName,
+  providerAllowlistEnvVarName,
+  readAgentRuntimeOverrideAllowlist,
+  readAllowedModels,
+  readAllowedProviders,
+  readAllowlistConfig,
+} from '../model-allowlist'
+
+describe('model-allowlist', () => {
+  describe('readAllowedProviders', () => {
+    it('returns null when OM_AI_AVAILABLE_PROVIDERS is unset', () => {
+      expect(readAllowedProviders({})).toBeNull()
+    })
+
+    it('returns null when OM_AI_AVAILABLE_PROVIDERS is blank or whitespace-only', () => {
+      expect(readAllowedProviders({ OM_AI_AVAILABLE_PROVIDERS: '' })).toBeNull()
+      expect(readAllowedProviders({ OM_AI_AVAILABLE_PROVIDERS: '   ' })).toBeNull()
+    })
+
+    it('parses a comma-separated list with whitespace tolerance', () => {
+      expect(readAllowedProviders({ OM_AI_AVAILABLE_PROVIDERS: 'openai, anthropic ,google' }))
+        .toEqual(['openai', 'anthropic', 'google'])
+    })
+
+    it('drops empty entries', () => {
+      expect(readAllowedProviders({ OM_AI_AVAILABLE_PROVIDERS: 'openai,,anthropic, ,' }))
+        .toEqual(['openai', 'anthropic'])
+    })
+  })
+
+  describe('readAllowedModels', () => {
+    it('returns null when no per-provider env is set', () => {
+      expect(readAllowedModels({}, 'openai')).toBeNull()
+    })
+
+    it('reads from OM_AI_AVAILABLE_MODELS_<PROVIDER> uppercased', () => {
+      expect(
+        readAllowedModels({ OM_AI_AVAILABLE_MODELS_OPENAI: 'gpt-5-mini,gpt-5' }, 'openai'),
+      ).toEqual(['gpt-5-mini', 'gpt-5'])
+    })
+
+    it('handles compound provider ids (e.g. lm-studio)', () => {
+      expect(
+        readAllowedModels({ OM_AI_AVAILABLE_MODELS_LM_STUDIO: 'qwen-32b' }, 'lm-studio'),
+      ).toEqual(['qwen-32b'])
+    })
+
+    it('uses the same underscore env variable for underscore aliases', () => {
+      expect(
+        readAllowedModels({ OM_AI_AVAILABLE_MODELS_LM_STUDIO: 'qwen-32b' }, 'lm_studio'),
+      ).toEqual(['qwen-32b'])
+    })
+  })
+
+  describe('isProviderAllowed', () => {
+    it('returns true when no restriction is configured', () => {
+      expect(isProviderAllowed({}, 'openai')).toBe(true)
+    })
+
+    it('is case-insensitive for the provider id', () => {
+      expect(isProviderAllowed({ OM_AI_AVAILABLE_PROVIDERS: 'OpenAI' }, 'openai')).toBe(true)
+      expect(isProviderAllowed({ OM_AI_AVAILABLE_PROVIDERS: 'openai' }, 'OPENAI')).toBe(true)
+    })
+
+    it('treats hyphen and underscore provider spellings as aliases', () => {
+      expect(isProviderAllowed({ OM_AI_AVAILABLE_PROVIDERS: 'lm_studio' }, 'lm-studio'))
+        .toBe(true)
+      expect(isProviderAllowed({ OM_AI_AVAILABLE_PROVIDERS: 'lm-studio' }, 'lm_studio'))
+        .toBe(true)
+    })
+
+    it('returns false when the provider is not in the list', () => {
+      expect(isProviderAllowed({ OM_AI_AVAILABLE_PROVIDERS: 'openai,anthropic' }, 'google'))
+        .toBe(false)
+    })
+  })
+
+  describe('isModelAllowedForProvider', () => {
+    it('returns true when no per-provider restriction is configured', () => {
+      expect(isModelAllowedForProvider({}, 'openai', 'gpt-5-mini')).toBe(true)
+    })
+
+    it('returns true only for case-sensitive exact model id matches', () => {
+      const env = { OM_AI_AVAILABLE_MODELS_OPENAI: 'gpt-5-mini,gpt-5' }
+      expect(isModelAllowedForProvider(env, 'openai', 'gpt-5-mini')).toBe(true)
+      expect(isModelAllowedForProvider(env, 'openai', 'GPT-5-MINI')).toBe(false)
+      expect(isModelAllowedForProvider(env, 'openai', 'gpt-4o')).toBe(false)
+    })
+  })
+
+  describe('isProviderModelAllowed', () => {
+    it('requires both provider and model gates to pass', () => {
+      const env = {
+        OM_AI_AVAILABLE_PROVIDERS: 'openai',
+        OM_AI_AVAILABLE_MODELS_OPENAI: 'gpt-5-mini',
+      }
+      expect(isProviderModelAllowed(env, 'openai', 'gpt-5-mini')).toBe(true)
+      expect(isProviderModelAllowed(env, 'openai', 'gpt-4o')).toBe(false)
+      expect(isProviderModelAllowed(env, 'anthropic', 'claude-haiku-4-5')).toBe(false)
+    })
+  })
+
+  describe('readAllowlistConfig', () => {
+    it('returns no restrictions when env is empty', () => {
+      const snapshot = readAllowlistConfig({}, ['openai', 'anthropic'])
+      expect(snapshot).toEqual({
+        providers: null,
+        modelsByProvider: {},
+        hasRestrictions: false,
+      })
+    })
+
+    it('aggregates per-provider model lists for known providers', () => {
+      const env = {
+        OM_AI_AVAILABLE_PROVIDERS: 'openai,anthropic',
+        OM_AI_AVAILABLE_MODELS_OPENAI: 'gpt-5-mini',
+      }
+      const snapshot = readAllowlistConfig(env, ['openai', 'anthropic', 'google'])
+      expect(snapshot.providers).toEqual(['openai', 'anthropic'])
+      expect(snapshot.modelsByProvider).toEqual({ openai: ['gpt-5-mini'] })
+      expect(snapshot.hasRestrictions).toBe(true)
+    })
+  })
+
+  describe('public env-var-name helpers', () => {
+    it('exposes the canonical env var names for docs/UI hints', () => {
+      expect(providerAllowlistEnvVarName()).toBe('OM_AI_AVAILABLE_PROVIDERS')
+      expect(modelAllowlistEnvVarName('openai')).toBe('OM_AI_AVAILABLE_MODELS_OPENAI')
+      expect(modelAllowlistEnvVarName('lm-studio')).toBe('OM_AI_AVAILABLE_MODELS_LM_STUDIO')
+      expect(agentOverrideProviderAllowlistEnvVarName('catalog.catalog_assistant'))
+        .toBe('OM_AI_AGENT_CATALOG_CATALOG_ASSISTANT_AVAILABLE_PROVIDERS')
+      expect(agentOverrideModelAllowlistEnvVarName('catalog.catalog_assistant', 'lm-studio'))
+        .toBe('OM_AI_AGENT_CATALOG_CATALOG_ASSISTANT_AVAILABLE_MODELS_LM_STUDIO')
+    })
+  })
+
+  describe('Phase 1780-6 — intersectAllowlists / effective allowlist', () => {
+    it('returns env-only when no tenant snapshot is supplied', () => {
+      const env = {
+        OM_AI_AVAILABLE_PROVIDERS: 'openai,anthropic',
+        OM_AI_AVAILABLE_MODELS_OPENAI: 'gpt-5-mini,gpt-5',
+      }
+      const effective = intersectAllowlists(env, ['openai', 'anthropic', 'google'], null)
+      expect(effective.providers).toEqual(['openai', 'anthropic'])
+      expect(effective.modelsByProvider).toEqual({ openai: ['gpt-5-mini', 'gpt-5'] })
+      expect(effective.hasRestrictions).toBe(true)
+      expect(effective.tenantOverridesActive).toBe(false)
+    })
+
+    it('clips tenant providers to the env allowlist (tenant cannot widen env)', () => {
+      const env = { OM_AI_AVAILABLE_PROVIDERS: 'openai,anthropic' }
+      const tenant = {
+        allowedProviders: ['openai', 'google'],
+        allowedModelsByProvider: {},
+      }
+      const effective = intersectAllowlists(env, ['openai', 'anthropic', 'google'], tenant)
+      expect(effective.providers).toEqual(['openai'])
+      expect(effective.tenantOverridesActive).toBe(true)
+    })
+
+    it('clips tenant models to the env per-provider allowlist (tenant cannot widen env)', () => {
+      const env = {
+        OM_AI_AVAILABLE_PROVIDERS: 'openai',
+        OM_AI_AVAILABLE_MODELS_OPENAI: 'gpt-5-mini,gpt-5',
+      }
+      const tenant = {
+        allowedProviders: null,
+        allowedModelsByProvider: { openai: ['gpt-5-mini', 'gpt-4o'] },
+      }
+      const effective = intersectAllowlists(env, ['openai'], tenant)
+      expect(effective.providers).toEqual(['openai'])
+      expect(effective.modelsByProvider.openai).toEqual(['gpt-5-mini'])
+      expect(effective.tenantOverridesActive).toBe(true)
+    })
+
+    it('passes through tenant providers when env imposes no provider restriction', () => {
+      const env: Record<string, string | undefined> = {}
+      const tenant = {
+        allowedProviders: ['openai'],
+        allowedModelsByProvider: {},
+      }
+      const effective = intersectAllowlists(env, ['openai', 'anthropic'], tenant)
+      expect(effective.providers).toEqual(['openai'])
+    })
+
+    it('returns no restriction when both env and tenant are empty', () => {
+      const env: Record<string, string | undefined> = {}
+      const effective = intersectAllowlists(env, ['openai'], null)
+      expect(effective.providers).toBeNull()
+      expect(effective.modelsByProvider).toEqual({})
+      expect(effective.hasRestrictions).toBe(false)
+      expect(effective.tenantOverridesActive).toBe(false)
+    })
+
+    it('isProviderAllowedInEffective is case-insensitive', () => {
+      const env = { OM_AI_AVAILABLE_PROVIDERS: 'OpenAI' }
+      const effective = intersectAllowlists(env, ['openai'], null)
+      expect(isProviderAllowedInEffective(effective, 'openai')).toBe(true)
+      expect(isProviderAllowedInEffective(effective, 'OPENAI')).toBe(true)
+      expect(isProviderAllowedInEffective(effective, 'anthropic')).toBe(false)
+    })
+
+    it('isModelAllowedForProviderInEffective returns true when no per-provider list applies', () => {
+      const effective = intersectAllowlists({}, ['openai'], null)
+      expect(isModelAllowedForProviderInEffective(effective, 'openai', 'any-model')).toBe(true)
+    })
+
+    it('isModelAllowedForProviderInEffective is case-sensitive on model id', () => {
+      const env = { OM_AI_AVAILABLE_MODELS_OPENAI: 'gpt-5-mini' }
+      const effective = intersectAllowlists(env, ['openai'], null)
+      expect(isModelAllowedForProviderInEffective(effective, 'openai', 'gpt-5-mini')).toBe(true)
+      expect(isModelAllowedForProviderInEffective(effective, 'openai', 'GPT-5-MINI')).toBe(false)
+    })
+
+    it('isProviderModelAllowedInEffective enforces both provider and model allowlists', () => {
+      const env = {
+        OM_AI_AVAILABLE_PROVIDERS: 'openai',
+        OM_AI_AVAILABLE_MODELS_OPENAI: 'gpt-5-mini',
+      }
+      const effective = intersectAllowlists(env, ['openai'], null)
+      expect(isProviderModelAllowedInEffective(effective, 'openai', 'gpt-5-mini')).toBe(true)
+      expect(isProviderModelAllowedInEffective(effective, 'openai', 'gpt-4o')).toBe(false)
+      expect(isProviderModelAllowedInEffective(effective, 'anthropic', 'claude-haiku-4-5')).toBe(false)
+    })
+
+    it('canonicalizes hyphen and underscore provider aliases for tenant intersections', () => {
+      const env = {
+        OM_AI_AVAILABLE_PROVIDERS: 'lm_studio',
+        OM_AI_AVAILABLE_MODELS_LM_STUDIO: 'qwen/qwen3.5-9b',
+      }
+      const tenant = {
+        allowedProviders: ['lm-studio'],
+        allowedModelsByProvider: {
+          lm_studio: ['qwen/qwen3.5-9b'],
+        },
+      }
+      const effective = intersectAllowlists(env, ['lm-studio'], tenant)
+
+      expect(effective.providers).toEqual(['lm-studio'])
+      expect(effective.modelsByProvider['lm-studio']).toEqual(['qwen/qwen3.5-9b'])
+      expect(isProviderModelAllowedInEffective(effective, 'lm_studio', 'qwen/qwen3.5-9b'))
+        .toBe(true)
+      expect(isProviderModelAllowedInEffective(effective, 'lm-studio', 'qwen/qwen3.5-9b'))
+        .toBe(true)
+    })
+
+    it('intersects per-agent chat override env and settings with the effective allowlist', () => {
+      const env = {
+        OM_AI_AVAILABLE_PROVIDERS: 'openai,anthropic',
+        OM_AI_AVAILABLE_MODELS_OPENAI: 'gpt-5-mini,gpt-4o',
+        OM_AI_AGENT_CATALOG_CATALOG_ASSISTANT_AVAILABLE_PROVIDERS: 'openai',
+        OM_AI_AGENT_CATALOG_CATALOG_ASSISTANT_AVAILABLE_MODELS_OPENAI: 'gpt-5-mini',
+      }
+      const base = intersectAllowlists(env, ['openai', 'anthropic'], {
+        allowedProviders: ['openai', 'anthropic'],
+        allowedModelsByProvider: { openai: ['gpt-5-mini', 'gpt-4o'] },
+      })
+      const agentEnv = readAgentRuntimeOverrideAllowlist(
+        env,
+        'catalog.catalog_assistant',
+        ['openai', 'anthropic'],
+      )
+      const effective = intersectEffectiveAllowlistWithSnapshot(
+        intersectEffectiveAllowlistWithSnapshot(base, ['openai', 'anthropic'], agentEnv),
+        ['openai', 'anthropic'],
+        {
+          allowedProviders: ['openai', 'anthropic'],
+          allowedModelsByProvider: { openai: ['gpt-4o', 'gpt-5-mini'] },
+        },
+      )
+
+      expect(effective.providers).toEqual(['openai'])
+      expect(effective.modelsByProvider.openai).toEqual(['gpt-5-mini'])
+      expect(isProviderModelAllowedInEffective(effective, 'openai', 'gpt-5-mini')).toBe(true)
+      expect(isProviderModelAllowedInEffective(effective, 'openai', 'gpt-4o')).toBe(false)
+      expect(isProviderAllowedInEffective(effective, 'anthropic')).toBe(false)
+    })
+  })
+})