@the-open-engine/zeroshot 6.4.0 → 6.5.0

package/src/agent-cli-provider/single-agent-runtime.ts

@@ -1,15 +1,23 @@
 import { getProviderAdapter } from './adapters';
+import { normalizeGatewayBuildOptions, resolveGatewayConfiguration } from './gateway-tools';
 import { isRecord } from './json';
+import {
+  getProviderRegistryEntry,
+  resolveProviderCommand,
+  supportsProviderCapability,
+} from './provider-registry';
 import type {
   BuildProviderCommandOptions,
   CliFeatureOverrides,
   CommandSpec,
+  GatewayBuildOptions,
   LevelOverrides,
   ModelLevel,
   ModelSpec,
   ProviderAdapter,
   ProviderCliFeatures,
   ProviderId,
+  ResolvedGatewayBuildOptions,
   ReasoningEffort,
 } from './types';
 
@@ -23,6 +31,7 @@ interface CommandParts {
 interface RuntimeProviderSettings {
   readonly defaultLevel?: ModelLevel;
   readonly levelOverrides: LevelOverrides;
+  readonly gateway?: GatewayBuildOptions;
 }
 
 export interface SingleAgentProviderCommandInput {
@@ -38,6 +47,13 @@ export interface PreparedSingleAgentProviderCommand {
   readonly cliFeatures: CliFeatureOverrides;
 }
 
+export interface RuntimeProviderProbe {
+  readonly available: boolean;
+  readonly helpText: string;
+  readonly versionText: string;
+  readonly capabilities: ProviderCliFeatures;
+}
+
 type MutableModelSpec = {
   level?: ModelLevel;
   model?: string | null;
@@ -46,24 +62,29 @@ type MutableModelSpec = {
 
 const MODEL_LEVELS: readonly ModelLevel[] = ['level1', 'level2', 'level3'];
 const REASONING_EFFORTS: readonly ReasoningEffort[] = ['low', 'medium', 'high', 'xhigh'];
-
 const settingsModule: unknown = require('../../lib/settings');
 const providerDetectionModule: unknown = require('../../lib/provider-detection');
 const claudeAuthModule: unknown = require('../../lib/settings/claude-auth');
 
 const loadSettingsFn = moduleFunction(settingsModule, 'loadSettings');
 const getClaudeCommandFn = moduleFunction(settingsModule, 'getClaudeCommand');
+const commandExistsFn = moduleFunction(providerDetectionModule, 'commandExists');
 const getHelpOutputFn = moduleFunction(providerDetectionModule, 'getHelpOutput');
+const getVersionOutputFn = moduleFunction(providerDetectionModule, 'getVersionOutput');
 const resolveClaudeAuthFn = moduleFunction(claudeAuthModule, 'resolveClaudeAuth');
 
 export function prepareSingleAgentProviderCommand(
   input: SingleAgentProviderCommandInput
 ): PreparedSingleAgentProviderCommand {
+  const baseOptions = input.options ?? {};
   const settings = loadRuntimeSettings();
   const adapter = adapterForRuntimeInput(input.provider, settings);
-  const providerSettings = runtimeProviderSettings(settings, adapter.id);
-  const baseOptions = input.options ?? {};
-  const cliFeatures = baseOptions.cliFeatures ?? detectRuntimeProviderCliFeatures(adapter.id);
+  const providerSettings = runtimeProviderSettings(
+    settings,
+    adapter.id,
+    baseOptions.cwd ?? process.cwd()
+  );
+  const cliFeatures = resolveRuntimeCliFeatures(adapter.id, baseOptions.cliFeatures);
   const authEnv = baseOptions.authEnv ?? resolveRuntimeAuthEnv(adapter.id, settings);
   const options = buildRuntimeOptions(baseOptions, adapter, providerSettings, cliFeatures, authEnv);
   return {
@@ -75,10 +96,81 @@ export function prepareSingleAgentProviderCommand(
 }
 
 export function detectRuntimeProviderCliFeatures(provider: string): ProviderCliFeatures {
+  return probeRuntimeProviderCli(provider).capabilities;
+}
+
+function resolveRuntimeCliFeatures(
+  provider: ProviderId,
+  overrides: CliFeatureOverrides | undefined
+): CliFeatureOverrides {
+  if (provider === 'gateway') {
+    return {
+      ...detectRuntimeProviderCliFeatures(provider),
+      ...overrides,
+      supportsBundledRunner: true,
+    };
+  }
+  if (getProviderRegistryEntry(provider).invoke.lane !== 'acp-stdio') {
+    return overrides ?? detectRuntimeProviderCliFeatures(provider);
+  }
+
+  const detected = detectRuntimeProviderCliFeatures(provider);
+  if (overrides === undefined) return detected;
+  return mergeAcpFailClosedCliFeatures(detected, overrides);
+}
+
+function mergeAcpFailClosedCliFeatures(
+  detected: ProviderCliFeatures,
+  overrides: CliFeatureOverrides
+): CliFeatureOverrides {
+  if (!('supportsAcpStdio' in detected)) return overrides;
+  return {
+    ...detected,
+    ...overrides,
+    supportsAcpStdio: detected.supportsAcpStdio && overrides.supportsAcpStdio !== false,
+    supportsPromptImages:
+      detected.supportsPromptImages && overrides.supportsPromptImages !== false,
+    supportsLoadSession: detected.supportsLoadSession && overrides.supportsLoadSession !== false,
+    supportsSessionCancel:
+      detected.supportsSessionCancel && overrides.supportsSessionCancel !== false,
+    supportsSessionSetModel:
+      detected.supportsSessionSetModel && overrides.supportsSessionSetModel !== false,
+    supportsSessionSetMode:
+      detected.supportsSessionSetMode && overrides.supportsSessionSetMode !== false,
+    supportsRemoteTransport: false,
+    supportsCustomTransport: false,
+    supportsPermissionRequests: false,
+    supportsFsTools: false,
+    supportsTerminalTools: false,
+  };
+}
+
+export function probeRuntimeProviderCli(provider: string): RuntimeProviderProbe {
   const adapter = getProviderAdapter(provider);
+  if (adapter.id === 'gateway') {
+    return probeGatewayProvider(adapter);
+  }
   const helpCommand = runtimeHelpCommand(adapter.id);
-  const helpText = stringResult(getHelpOutputFn(helpCommand.command, helpCommand.args));
-  return adapter.detectCliFeatures(helpText);
+  const commandAvailable = booleanResult(commandExistsFn(helpCommand.command));
+  if (!commandAvailable) {
+    return {
+      available: false,
+      helpText: '',
+      versionText: '',
+      capabilities: adapter.detectCliFeatures(''),
+    };
+  }
+
+  const helpText = stringResult(getHelpOutputFn(helpCommand.command, helpCommand.args)).trim();
+  const versionText = stringResult(getVersionOutputFn(helpCommand.command, helpCommand.args)).trim();
+  const availabilityProbe = getProviderRegistryEntry(adapter.id).availabilityProbe ?? 'command';
+
+  return {
+    available: availabilityProbe === 'help-or-version' ? Boolean(helpText || versionText) : true,
+    helpText,
+    versionText,
+    capabilities: adapter.detectCliFeatures(helpText),
+  };
 }
 
 function buildRuntimeOptions(
@@ -88,15 +180,63 @@ function buildRuntimeOptions(
   cliFeatures: CliFeatureOverrides,
   authEnv: Readonly<Record<string, string>>
 ): BuildProviderCommandOptions {
+  const modelSpec = resolveRuntimeModelSpec(adapter, baseOptions.modelSpec, providerSettings);
+  const gateway = resolveRuntimeGatewayOptions(
+    adapter.id,
+    baseOptions,
+    providerSettings,
+    modelSpec
+  );
   const resolved = {
     ...baseOptions,
-    modelSpec: resolveRuntimeModelSpec(adapter, baseOptions.modelSpec, providerSettings),
+    modelSpec,
+    ...(gateway === undefined ? {} : { gateway }),
     cliFeatures,
   };
+  if (baseOptions.jsonSchema && !supportsProviderCapability(adapter.id, 'jsonSchema')) {
+    if (!shouldIncludeAuthEnv(baseOptions, authEnv)) {
+      return { ...resolved, strictSchema: false };
+    }
+    return { ...resolved, authEnv, strictSchema: false };
+  }
   if (!shouldIncludeAuthEnv(baseOptions, authEnv)) return resolved;
   return { ...resolved, authEnv };
 }
 
+function resolveRuntimeGatewayOptions(
+  provider: ProviderId,
+  baseOptions: BuildProviderCommandOptions,
+  providerSettings: RuntimeProviderSettings,
+  modelSpec: ModelSpec
+): ResolvedGatewayBuildOptions | undefined {
+  if (provider !== 'gateway') return undefined;
+  const cwd = baseOptions.cwd ?? process.cwd();
+  const settingsGateway = providerSettings.gateway ?? {};
+  const requestGateway = baseOptions.gateway ?? {};
+  const mergedHeaders =
+    requestGateway.headers === undefined
+      ? settingsGateway.headers
+      : { ...(settingsGateway.headers ?? {}), ...requestGateway.headers };
+  const mergedGateway: GatewayBuildOptions = {
+    ...(requestGateway.baseUrl ?? settingsGateway.baseUrl
+      ? { baseUrl: requestGateway.baseUrl ?? settingsGateway.baseUrl }
+      : {}),
+    ...(requestGateway.apiKey ?? settingsGateway.apiKey
+      ? { apiKey: requestGateway.apiKey ?? settingsGateway.apiKey }
+      : {}),
+    ...(mergedHeaders === undefined ? {} : { headers: mergedHeaders }),
+    model: requestGateway.model ?? modelSpec.model ?? settingsGateway.model ?? null,
+    ...(requestGateway.toolPolicy ?? settingsGateway.toolPolicy
+      ? { toolPolicy: requestGateway.toolPolicy ?? settingsGateway.toolPolicy }
+      : {}),
+  };
+  return resolveGatewayConfiguration(
+    mergedGateway,
+    'options.gateway',
+    cwd
+  );
+}
+
 function shouldIncludeAuthEnv(
   baseOptions: BuildProviderCommandOptions,
   authEnv: Readonly<Record<string, string>>
@@ -152,7 +292,8 @@ function adapterForRuntimeInput(
 
 function runtimeProviderSettings(
   settings: Record<string, unknown>,
-  provider: ProviderId
+  provider: ProviderId,
+  cwd: string
 ): RuntimeProviderSettings {
   const allSettings = optionalRecord(settings.providerSettings, 'settings.providerSettings');
   const providerValue = allSettings?.[provider];
@@ -166,19 +307,47 @@ function runtimeProviderSettings(
     providerSettings.levelOverrides,
     `settings.providerSettings.${provider}.levelOverrides`
   );
-  if (defaultLevel === undefined) return { levelOverrides };
-  return { defaultLevel, levelOverrides };
+  const gateway =
+    provider === 'gateway'
+      ? normalizeGatewayBuildOptions(
+          providerSettings,
+          'settings.providerSettings.gateway',
+          cwd
+        )
+      : undefined;
+  if (defaultLevel === undefined) {
+    return gateway === undefined ? { levelOverrides } : { levelOverrides, gateway };
+  }
+  return gateway === undefined ? { defaultLevel, levelOverrides } : { defaultLevel, levelOverrides, gateway };
 }
 
 function runtimeHelpCommand(provider: ProviderId): CommandParts {
-  if (provider === 'claude') return getClaudeRuntimeCommand();
-  if (provider === 'codex') return { command: 'codex', args: ['exec'] };
-  if (provider === 'opencode') return { command: 'opencode', args: ['run'] };
-  return { command: 'gemini', args: [] };
-}
-
-function getClaudeRuntimeCommand(): CommandParts {
-  return commandPartsFromUnknown(getClaudeCommandFn(), 'getClaudeCommand');
+  if (provider === 'claude') {
+    return commandPartsFromUnknown(getClaudeCommandFn(), 'getClaudeCommand');
+  }
+  return resolveProviderCommand(provider);
+}
+
+function probeGatewayProvider(adapter: ProviderAdapter): RuntimeProviderProbe {
+  const capabilities = adapter.detectCliFeatures('');
+  try {
+    const settings = loadRuntimeSettings();
+    const providerSettings = runtimeProviderSettings(settings, 'gateway', process.cwd());
+    resolveGatewayConfiguration(providerSettings.gateway, 'settings.providerSettings.gateway', process.cwd());
+    return {
+      available: true,
+      helpText: 'Bundled gateway runner',
+      versionText: process.version,
+      capabilities,
+    };
+  } catch {
+    return {
+      available: false,
+      helpText: 'Bundled gateway runner',
+      versionText: process.version,
+      capabilities,
+    };
+  }
 }
 
 function loadRuntimeSettings(): Record<string, unknown> {
@@ -309,3 +478,8 @@ function stringResult(value: unknown): string {
   if (typeof value === 'string') return value;
   throw new Error('Provider help output must be a string.');
 }
+
+function booleanResult(value: unknown): boolean {
+  if (typeof value === 'boolean') return value;
+  throw new Error('Provider availability probe must return a boolean.');
+}

package/src/agent-cli-provider/types.ts

@@ -1,9 +1,32 @@
-export type ProviderId = 'claude' | 'codex' | 'gemini' | 'opencode';
-export type ProviderAlias = 'anthropic' | 'openai' | 'google';
+import type {
+  providerAliases,
+  providerIds,
+  ProviderCapabilities,
+  ProviderCapabilityState,
+  ProviderCommandSpec,
+  ProviderDockerMetadata,
+  ProviderDockerMountPreset,
+  ProviderDocsMetadata,
+  ProviderInvokeSpec,
+  ProviderRegistryEntry,
+} from './provider-registry';
+
+export type ProviderId = (typeof providerIds)[number];
+export type ProviderAlias = (typeof providerAliases)[number];
 export type KnownProviderName = ProviderId | ProviderAlias;
 export type ModelLevel = 'level1' | 'level2' | 'level3';
 export type ReasoningEffort = 'low' | 'medium' | 'high' | 'xhigh';
 export type OutputFormat = 'text' | 'json' | 'stream-json';
+export type {
+  ProviderCapabilities,
+  ProviderCapabilityState,
+  ProviderCommandSpec,
+  ProviderDockerMetadata,
+  ProviderDockerMountPreset,
+  ProviderDocsMetadata,
+  ProviderInvokeSpec,
+  ProviderRegistryEntry,
+};
 
 export interface AgentCliProviderHelperMetadata {
   readonly packageName: '@the-open-engine/zeroshot';
@@ -36,6 +59,28 @@ export interface ResolvedModelSpec {
 
 export type LevelOverrides = Readonly<Partial<Record<ModelLevel, ModelSpec>>>;
 
+export interface GatewayToolPolicy {
+  readonly roots: readonly string[];
+  readonly commands: readonly string[];
+  readonly commandTimeoutMs?: number;
+}
+
+export interface GatewayBuildOptions {
+  readonly baseUrl?: string;
+  readonly apiKey?: string;
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly model?: string | null;
+  readonly toolPolicy?: GatewayToolPolicy;
+}
+
+export interface ResolvedGatewayBuildOptions {
+  readonly baseUrl: string;
+  readonly apiKey: string;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly model: string;
+  readonly toolPolicy: GatewayToolPolicy;
+}
+
 export interface BaseCliFeatures {
   readonly provider?: ProviderId;
   readonly unknown?: boolean;
@@ -76,15 +121,62 @@ export interface OpencodeCliFeatures extends BaseCliFeatures {
   readonly supportsJson: boolean;
   readonly supportsModel: boolean;
   readonly supportsVariant: boolean;
+  readonly supportsDir: boolean;
   readonly supportsCwd: boolean;
   readonly supportsAutoApprove: false;
 }
 
+export interface PiCliFeatures extends BaseCliFeatures {
+  readonly provider: 'pi';
+  readonly supportsJsonMode: boolean;
+  readonly supportsModel: boolean;
+  readonly supportsNoSession: boolean;
+  readonly supportsNoExtensions: boolean;
+  readonly supportsNoSkills: boolean;
+  readonly supportsNoPromptTemplates: boolean;
+  readonly supportsNoContextFiles: boolean;
+  readonly supportsNoApprove: boolean;
+}
+
+export interface CopilotCliFeatures extends BaseCliFeatures {
+  readonly provider: 'copilot';
+  readonly supportsJsonOutput: boolean;
+  readonly supportsModel: boolean;
+  readonly supportsAllowAll: boolean;
+  readonly supportsNoAskUser: boolean;
+  readonly supportsAddDir: boolean;
+  readonly supportsMcpConfig: boolean;
+}
+
+export interface GatewayCliFeatures extends BaseCliFeatures {
+  readonly provider: 'gateway';
+  readonly supportsBundledRunner: true;
+}
+
+export interface AcpCliFeatures extends BaseCliFeatures {
+  readonly provider: ProviderId;
+  readonly supportsAcpStdio: boolean;
+  readonly supportsPromptImages: boolean;
+  readonly supportsLoadSession: boolean;
+  readonly supportsSessionCancel: boolean;
+  readonly supportsSessionSetModel: boolean;
+  readonly supportsSessionSetMode: boolean;
+  readonly supportsRemoteTransport: false;
+  readonly supportsCustomTransport: false;
+  readonly supportsPermissionRequests: false;
+  readonly supportsFsTools: false;
+  readonly supportsTerminalTools: false;
+}
+
 export type ProviderCliFeatures =
   | ClaudeCliFeatures
   | CodexCliFeatures
   | GeminiCliFeatures
-  | OpencodeCliFeatures;
+  | OpencodeCliFeatures
+  | PiCliFeatures
+  | CopilotCliFeatures
+  | GatewayCliFeatures
+  | AcpCliFeatures;
 
 export interface CliFeatureOverrides {
   readonly supportsOutputFormat?: boolean;
@@ -96,10 +188,35 @@ export interface CliFeatureOverrides {
   readonly supportsModel?: boolean;
   readonly supportsJson?: boolean;
   readonly supportsOutputSchema?: boolean;
+  readonly supportsDir?: boolean;
   readonly supportsCwd?: boolean;
   readonly supportsConfigOverride?: boolean;
   readonly supportsSkipGitRepoCheck?: boolean;
   readonly supportsVariant?: boolean;
+  readonly supportsJsonMode?: boolean;
+  readonly supportsNoSession?: boolean;
+  readonly supportsNoExtensions?: boolean;
+  readonly supportsNoSkills?: boolean;
+  readonly supportsNoPromptTemplates?: boolean;
+  readonly supportsNoContextFiles?: boolean;
+  readonly supportsNoApprove?: boolean;
+  readonly supportsJsonOutput?: boolean;
+  readonly supportsAllowAll?: boolean;
+  readonly supportsNoAskUser?: boolean;
+  readonly supportsAddDir?: boolean;
+  readonly supportsMcpConfig?: boolean;
+  readonly supportsBundledRunner?: boolean;
+  readonly supportsAcpStdio?: boolean;
+  readonly supportsPromptImages?: boolean;
+  readonly supportsLoadSession?: boolean;
+  readonly supportsSessionCancel?: boolean;
+  readonly supportsSessionSetModel?: boolean;
+  readonly supportsSessionSetMode?: boolean;
+  readonly supportsRemoteTransport?: false;
+  readonly supportsCustomTransport?: false;
+  readonly supportsPermissionRequests?: false;
+  readonly supportsFsTools?: false;
+  readonly supportsTerminalTools?: false;
   readonly unknown?: boolean;
 }
 
@@ -144,6 +261,12 @@ export interface BuildProviderCommandOptions {
   readonly cliFeatures?: CliFeatureOverrides;
   readonly authEnv?: Readonly<Record<string, string>>;
   readonly strictSchema?: boolean;
+  readonly gateway?: GatewayBuildOptions;
+  // MCP server configs forwarded to providers that accept an MCP config CLI flag (currently
+  // Copilot's `--additional-mcp-config`). Each entry is an inline JSON string (the standard
+  // `{"mcpServers": {...}}` envelope) or an `@<path>` file reference; adapters emit one flag per
+  // entry. Providers whose adapter models no MCP flag ignore this field.
+  readonly mcpConfig?: readonly string[];
 }
 
 export interface TextEvent {
@@ -189,8 +312,26 @@ export type OutputEvent = TextEvent | ThinkingEvent | ToolCallEvent | ToolResult
 export type ProviderParseResult = OutputEvent | readonly OutputEvent[] | null;
 
 export interface ProviderParserState {
-  provider: ProviderId;
+  readonly provider: ProviderId;
   lastToolId: string | null | undefined;
+  lastAssistantText?: string;
+  lastAssistantThinking?: string;
+  messagePhaseById?: Map<string, string>;
+  assistantTextByMessageId?: Map<string, string>;
+  assistantThinkingByMessageId?: Map<string, string>;
+  toolCalls?: Map<
+    string,
+    {
+      name: string | null | undefined;
+      input: unknown;
+    }
+  >;
+  usage?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadInputTokens?: number;
+    cacheCreationInputTokens?: number;
+  } | null;
 }
 
 export type ErrorClassificationKind =

package/src/config-validator.js

@@ -12,7 +12,11 @@
  */
 
 const { loadSettings } = require('../lib/settings');
-const { VALID_PROVIDERS, normalizeProviderName } = require('../lib/provider-names');
+const {
+  VALID_PROVIDERS,
+  normalizeProviderName,
+  providerSupportsCapability,
+} = require('../lib/provider-names');
 const { getProvider } = require('./providers');
 const { CAPABILITIES } = require('./providers/capabilities');
 const { GUIDANCE_TOPICS } = require('./guidance-topics');
@@ -2026,6 +2030,10 @@ function validateProviderSettings(provider, providerSettings) {
   const providerModule = getProvider(provider);
   const levels = providerModule.getLevelMapping();
   const settings = providerSettings || {};
+  const providerError = providerModule.validateSettings(settings);
+  if (providerError) {
+    throw new Error(providerError);
+  }
 
   const minLevel = settings.minLevel || providerModule.getDefaultMinLevel?.();
   const maxLevel = settings.maxLevel || providerModule.getDefaultMaxLevel?.();
@@ -2042,7 +2050,10 @@ function validateProviderSettings(provider, providerSettings) {
         `Invalid model override (must be non-empty string) for provider "${provider}"`
       );
     }
-    if (override?.reasoningEffort && !['codex', 'opencode'].includes(provider)) {
+    if (override?.model) {
+      providerModule.validateModelId(override.model);
+    }
+    if (override?.reasoningEffort && !providerSupportsCapability(provider, 'reasoningEffort')) {
       throw new Error(`reasoningEffort overrides are only supported for Codex and Opencode`);
     }
     if (
@@ -2068,7 +2079,6 @@ function resolveAgentProvider(agent, config, settings, errors) {
 function buildProviderContext(provider, settings) {
   const providerModule = getProvider(provider);
   const levels = providerModule.getLevelMapping();
-  const catalog = providerModule.getModelCatalog();
   const providerSettings = settings.providerSettings?.[provider] || {};
   const minLevel = providerSettings.minLevel;
   const maxLevel = providerSettings.maxLevel;
@@ -2077,7 +2087,6 @@ function buildProviderContext(provider, settings) {
   return {
     providerModule,
     levels,
-    catalog,
     providerSettings,
     minLevel,
     maxLevel,
@@ -2109,10 +2118,12 @@ function validateModelLevelSupport(agent, provider, levels, warnings) {
 }
 
 function validateModelSelection(agent, context, warnings) {
-  const { provider, catalog, minLevel, maxLevel, rank } = context;
+  const { provider, providerModule, minLevel, maxLevel, rank } = context;
 
   if (agent.model) {
-    if (!catalog[agent.model]) {
+    try {
+      providerModule.validateModelId(agent.model);
+    } catch {
       warnings.push(
         `Agent "${agent.id}" uses model "${agent.model}" which is not valid for ${provider}`
       );
@@ -2137,7 +2148,7 @@ function validateModelSelection(agent, context, warnings) {
   }
 }
 
-function validateModelRulesSupport(agent, provider, catalog, levels, warnings) {
+function validateModelRulesSupport(agent, provider, providerModule, levels, warnings) {
   if (!agent.modelRules || !Array.isArray(agent.modelRules)) return;
 
   for (const rule of agent.modelRules) {
@@ -2146,16 +2157,20 @@ function validateModelRulesSupport(agent, provider, catalog, levels, warnings) {
         `Agent "${agent.id}" uses modelLevel "${rule.modelLevel}" in modelRules which is not valid for ${provider}`
       );
     }
-    if (rule.model && !catalog[rule.model]) {
-      warnings.push(
-        `Agent "${agent.id}" uses model "${rule.model}" in modelRules which is not valid for ${provider}`
-      );
+    if (rule.model) {
+      try {
+        providerModule.validateModelId(rule.model);
+      } catch {
+        warnings.push(
+          `Agent "${agent.id}" uses model "${rule.model}" in modelRules which is not valid for ${provider}`
+        );
+      }
     }
   }
 }
 
 function validateReasoningEffortSupport(agent, provider, warnings) {
-  if (agent.reasoningEffort && !['codex', 'opencode'].includes(provider)) {
+  if (agent.reasoningEffort && !providerSupportsCapability(provider, 'reasoningEffort')) {
     warnings.push(`Agent "${agent.id}" sets reasoningEffort but ${provider} does not support it`);
   } else if (
     agent.reasoningEffort &&
@@ -2193,10 +2208,13 @@ function validateProviderFeatures(config, settings) {
     const provider = resolveAgentProvider(agent, config, settings, errors);
     if (!provider) continue;
 
-    const { levels, catalog, minLevel, maxLevel, rank } = buildProviderContext(provider, settings);
+    const { providerModule, levels, minLevel, maxLevel, rank } = buildProviderContext(
+      provider,
+      settings
+    );
     const modelSelectionContext = {
       provider,
-      catalog,
+      providerModule,
       minLevel,
       maxLevel,
       rank,
@@ -2205,7 +2223,7 @@ function validateProviderFeatures(config, settings) {
     validateJsonSchemaSupport(agent, provider, warnings);
     validateModelLevelSupport(agent, provider, levels, warnings);
     validateModelSelection(agent, modelSelectionContext, warnings);
-    validateModelRulesSupport(agent, provider, catalog, levels, warnings);
+    validateModelRulesSupport(agent, provider, providerModule, levels, warnings);
     validateReasoningEffortSupport(agent, provider, warnings);
   }