agent-harness 0.22.5 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 754470184c69b02fa37de51afaba8376d554b26869579dd9494d7e720ee0d425
-  data.tar.gz: 9ec4b741ed03b43859cb3b2565a0e760cbcf2f5e1d80dadf287ae90a18230c25
+  metadata.gz: '0874add2f55550c3c9f9b723c84a4036a2dd79dd717dd62069062cfbde630820'
+  data.tar.gz: 53c6335c3a47e4e0e18ea3151dad061f9302519013e27591c7541ebf6dfe51db
 SHA512:
-  metadata.gz: 24a4027c7f0594760a512456a995f206170e3e41386fc9e4c98386758982cb1b501a9d7bca9beb730a1784453f0436dc079a8923aa6f07bd5a0bd2a900b4f09c
-  data.tar.gz: 9074fe5570d062bed53fe712bae4cdf95ec0d81fd01ed474cc64b3afb040535ca751fe7c79c5c69b49c91714f4fc2c2ff8dbe1c4827eb3a29e683fe944a49a8b
+  metadata.gz: a7297580e4a5a34631421730cab4c0fc5712448864bacefe8c8f3c43c7652b5a42cb9f7c2a603f585f308d2a54117dff918804a45a30c3bb302ec223e545eed4
+  data.tar.gz: 36428c8e91bee3395d235cd4ae309f6a43c177acc6991cdf3cd33ed4f0cc433a566849a8b282137466a455da5becdc63820a87a01a36eb8399f857ecbe457ef7

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.22.5"
+  ".": "0.23.0"
 }

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+### Features
+
+* add runner model compatibility contract (`AgentHarness.model_compatibility`) with structured `ModelCompatibility::Result` outcomes. Codex exposes static facts for CLI-gated models (e.g. `gpt-5.5` requires Codex CLI `>= 0.116.0`), a baseline supported-model list, supported auth modes, and a `DEFAULT_COMPATIBLE_MODEL_ID` fallback so downstream orchestrators can validate tier/model assignments before scheduling agent runs ([#259](https://github.com/viamin/agent-harness/issues/259)).
+
+
+## [0.23.0](https://github.com/viamin/agent-harness/compare/agent-harness/v0.22.5...agent-harness/v0.23.0) (2026-06-15)
+
+
+### Features
+
+* Add runner model compatibility contracts for Codex and CLI-gated models ([#260](https://github.com/viamin/agent-harness/issues/260)) ([4c192a7](https://github.com/viamin/agent-harness/commit/4c192a72f323ecaaea96e87e8ead6634e33669c0))
+
 ## [0.22.5](https://github.com/viamin/agent-harness/compare/agent-harness/v0.22.4...agent-harness/v0.22.5) (2026-06-12)
 
 

data/README.md

@@ -326,6 +326,54 @@ tests assert that the expected binary remains aligned with that contract.
 `source_type`, `package_name`, version fields, and install commands so
 downstream apps do not need provider-specific branching.
 
+### Runner Model Compatibility
+
+Downstream orchestrators that map tiers or task requirements to concrete
+models should consult the runner/model compatibility contract before
+scheduling a run. The contract surfaces the runtime dimensions that
+materially affect whether a model will run — runner identity, model id,
+auth mode, and installed CLI version — and returns a structured result
+instead of forcing callers to parse error strings:
+
+```ruby
+result = AgentHarness.model_compatibility(
+  runner: :codex,
+  model_id: "gpt-5.5",
+  auth_mode: :subscription,
+  cli_version: "0.115.0"
+)
+
+result.supported?            # => false
+result.reason                # => :cli_version_too_old
+result.minimum_cli_version   # => "0.116.0"
+result.fallback_model_id     # => "gpt-5-codex"
+result.source                # => :static_contract
+```
+
+Outcomes follow three explicit shapes:
+
+- **Supported** — `result.supported?` is `true`. The runner contract
+  confirms the model can be driven under the given constraints.
+- **Unsupported** — `result.unsupported?` is `true` with a stable
+  symbolic `reason` such as `:cli_version_too_old` or
+  `:auth_mode_not_supported`, plus any version requirement and a
+  contract-owned `fallback_model_id` to use instead.
+- **Unknown** — `result.unknown?` is `true`. The runner cannot answer
+  definitively — either the model is not in the runner's static
+  contract (`reason: :unknown_model`), or the model is CLI-gated and the
+  caller did not supply a comparable `cli_version`
+  (`reason: :cli_version_unknown`, with `minimum_cli_version` attached).
+  Callers must treat unknown as "ask the provider" — never as implicit
+  approval — so a missing CLI version cannot silently schedule a run
+  onto an older CLI that the model does not support.
+
+Providers that have not opted in to a static contract return an unknown
+result by default, so callers always get a normalized
+`AgentHarness::ModelCompatibility::Result` without provider-specific
+branching. The Codex runner ships static facts for CLI-gated models
+(for example `gpt-5.5` requires Codex CLI `>= 0.116.0`) and a baseline
+list of always-supported models.
+
 ### Custom Providers
 
 ```ruby

data/lib/agent_harness/model_compatibility.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module AgentHarness
+  # Structured runner/model compatibility contract.
+  #
+  # ModelCompatibility is the single source of truth for whether a given
+  # runner (provider) can execute a particular model under specific runtime
+  # constraints such as authentication mode or installed CLI version.
+  # Downstream orchestrators (for example Paid's RDR-040 tier-to-model
+  # mapping) consume this contract before validating tier models, selecting
+  # runners, and starting agent runs — instead of inferring compatibility
+  # from scattered facts like CLI version pins, smoke-test overrides, or
+  # observed runtime errors.
+  #
+  # @example Query Codex compatibility for a CLI-gated model
+  #   AgentHarness.model_compatibility(
+  #     runner: :codex,
+  #     model_id: "gpt-5.5",
+  #     auth_mode: :subscription,
+  #     cli_version: "0.116.0"
+  #   )
+  #   # => #<AgentHarness::ModelCompatibility::Result supported=true ...>
+  module ModelCompatibility
+    # Sentinel for "the runner declares no opinion about this model."
+    UNKNOWN_REASON = :unknown
+    # Issued when a runner does not advertise the requested model at all.
+    UNKNOWN_MODEL_REASON = :unknown_model
+    # Issued when the runner needs a comparable CLI version to answer
+    # definitively for a CLI-gated model but the caller did not supply one
+    # (or it could not be parsed). Pairs with :minimum_cli_version on the
+    # result. Distinct from :unknown_model — the runner *does* know the
+    # model; it just cannot confirm the installed CLI is new enough.
+    UNKNOWN_CLI_VERSION_REASON = :cli_version_unknown
+    # Issued when the runner supports the model but the installed CLI is too
+    # old. Pairs with :minimum_cli_version on the result.
+    UNSUPPORTED_CLI_VERSION_REASON = :cli_version_too_old
+    # Issued when the runner supports the model but the requested auth mode
+    # is not part of the runner's contract for it.
+    UNSUPPORTED_AUTH_MODE_REASON = :auth_mode_not_supported
+    # Default supported reason.
+    SUPPORTED_REASON = :supported
+
+    # Sources for a compatibility decision. Static contracts are baked into
+    # the provider; live probes hit the provider CLI/API; entitlement checks
+    # gate on subscription state. Downstream orchestrators can use this to
+    # decide whether to cache the answer.
+    SOURCES = %i[static_contract live_provider_probe entitlement_check unknown].freeze
+
+    # Structured compatibility outcome.
+    #
+    # The struct intentionally exposes whatever facts the runner contract
+    # knows. Callers should treat unknown fields as nil rather than fail.
+    Result = Struct.new(
+      :runner,
+      :model_id,
+      :auth_mode,
+      :cli_version,
+      :supported,
+      :reason,
+      :minimum_cli_version,
+      :cli_version_requirement,
+      :fallback_model_id,
+      :source,
+      :details,
+      keyword_init: true
+    ) do
+      # @return [Boolean] true when compatibility is known to be supported
+      def supported? = supported == true
+
+      # @return [Boolean] true when compatibility is known to be unsupported
+      def unsupported? = supported == false
+
+      # @return [Boolean] true when the runner did not return a definite answer
+      def unknown? = supported.nil?
+
+      def to_h
+        super.compact
+      end
+    end
+
+    class << self
+      # Build a Result with sensible defaults from a partial Hash.
+      #
+      # Provider implementations call this helper to return a normalized
+      # Result without having to instantiate Struct fields by hand.
+      #
+      # @param runner [Symbol] canonical provider/runner name
+      # @param model_id [String, Symbol, nil] requested model id
+      # @param attributes [Hash] additional Result attributes
+      # @return [Result]
+      def build_result(runner:, model_id:, **attributes)
+        normalized_model_id = model_id.is_a?(Symbol) ? model_id.to_s : model_id
+        source = attributes.fetch(:source, :static_contract)
+        supported = attributes[:supported]
+
+        if supported == false && attributes[:reason].nil?
+          raise ArgumentError,
+            "AgentHarness::ModelCompatibility.build_result requires an explicit " \
+            "`reason:` when `supported: false`. Pass a specific reason " \
+            "(e.g. :cli_version_too_old, :auth_mode_not_supported) so " \
+            "callers can distinguish unsupported from :unknown."
+        end
+
+        reason = attributes[:reason] || default_reason_for(supported)
+
+        Result.new(
+          runner: runner.to_sym,
+          model_id: normalized_model_id,
+          auth_mode: attributes[:auth_mode],
+          cli_version: attributes[:cli_version],
+          supported: supported,
+          reason: reason,
+          minimum_cli_version: attributes[:minimum_cli_version],
+          cli_version_requirement: attributes[:cli_version_requirement],
+          fallback_model_id: attributes[:fallback_model_id],
+          source: source,
+          details: attributes[:details]
+        )
+      end
+
+      # Build an explicit "unknown" Result. Use when the runner has no
+      # static contract for the requested model and cannot probe.
+      def unknown_result(runner:, model_id:, fallback_model_id: nil, **attributes)
+        build_result(
+          runner: runner,
+          model_id: model_id,
+          supported: nil,
+          reason: attributes.delete(:reason) || UNKNOWN_REASON,
+          fallback_model_id: fallback_model_id,
+          source: attributes.delete(:source) || :unknown,
+          **attributes
+        )
+      end
+
+      private
+
+      def default_reason_for(supported)
+        case supported
+        when true then SUPPORTED_REASON
+        else UNKNOWN_REASON
+        end
+      end
+    end
+  end
+end

data/lib/agent_harness/providers/adapter.rb

@@ -709,6 +709,63 @@ module AgentHarness
           nil
         end
 
+        # Runner/model compatibility contract.
+        #
+        # Returns a structured {AgentHarness::ModelCompatibility::Result}
+        # describing whether this runner can execute +model_id+ under the
+        # given +auth_mode+ and installed +cli_version+. Providers that own
+        # CLI-gated or entitlement-gated models should override this to
+        # expose stable, structured facts so downstream orchestrators do not
+        # have to parse error strings or rediscover provider knowledge.
+        #
+        # The default implementation returns an explicit +:unknown+ result
+        # rather than collapsing to "supported" — callers are expected to
+        # handle unknown outcomes explicitly.
+        #
+        # @param model_id [String, Symbol] the requested model identifier
+        # @param auth_mode [Symbol, nil] caller's auth mode (e.g. :api_key,
+        #   :subscription)
+        # @param cli_version [String, Gem::Version, nil] installed CLI
+        #   version, when known
+        # @return [AgentHarness::ModelCompatibility::Result]
+        def model_compatibility(model_id:, auth_mode: nil, cli_version: nil)
+          AgentHarness::ModelCompatibility.unknown_result(
+            runner: provider_name,
+            model_id: model_id,
+            auth_mode: auth_mode,
+            cli_version: normalize_cli_version_for_compatibility(cli_version),
+            fallback_model_id: default_compatible_model_id
+          )
+        end
+
+        # Optional default model the runner can recommend as a fallback when
+        # a requested model is unsupported or unknown. Providers override
+        # this when they own a stable default model for smoke tests or
+        # downstream tier fallback.
+        #
+        # @return [String, nil]
+        def default_compatible_model_id
+          nil
+        end
+
+        # Helper for {#model_compatibility} implementations: coerce a CLI
+        # version string into a +Gem::Version+ when possible, returning the
+        # raw value otherwise. Keeps Result#cli_version stable across
+        # callers that pass either form.
+        def normalize_cli_version_for_compatibility(value)
+          return nil if value.nil?
+          return value if value.is_a?(Gem::Version)
+
+          str = value.respond_to?(:strip) ? value.strip : value.to_s
+          return nil if str.empty?
+
+          begin
+            Gem::Version.new(str)
+          rescue ArgumentError
+            str
+          end
+        end
+
         private
 
         def versioned_installation_contract(version)

data/lib/agent_harness/providers/codex.rb

@@ -20,6 +20,43 @@ module AgentHarness
 
       SUPPORTED_CLI_VERSION = "0.122.0"
       SUPPORTED_CLI_REQUIREMENT = Gem::Requirement.new(">= #{SUPPORTED_CLI_VERSION}", "< 0.123.0").freeze
+
+      # Default model recommended by the Codex runner contract when callers
+      # have no explicit preference. Used as the {AgentHarness::ModelCompatibility::Result#fallback_model_id}
+      # for unsupported/unknown model lookups so downstream orchestrators
+      # (smoke tests, tier fallback) have a stable, contract-backed choice
+      # instead of relying on whichever model the CLI's default points at.
+      DEFAULT_COMPATIBLE_MODEL_ID = "gpt-5-codex"
+
+      # Known CLI-gated model facts. Each entry expresses the minimum Codex
+      # CLI version required to drive that model. Keep entries here only when
+      # the requirement is durable runner contract knowledge — not
+      # provider-side experiments or one-off CLI defaults.
+      #
+      # The +gpt-5.5+ entry tracks the failure class observed in
+      # viamin/agent-harness#245 and viamin/agent-harness#250: older Codex
+      # CLI builds (e.g. 0.115.x) could not drive the +gpt-5.5+ family.
+      MODEL_COMPATIBILITY_FACTS = {
+        "gpt-5.5" => {minimum_cli_version: "0.116.0"},
+        "gpt-5.5-codex" => {minimum_cli_version: "0.116.0"}
+      }.each_value(&:freeze).freeze
+
+      # Models that the runner contract considers supported on every Codex
+      # CLI release we ship. Used by {.model_compatibility} so callers can
+      # distinguish "unknown to the contract" from "explicitly supported."
+      BASELINE_SUPPORTED_MODELS = %w[
+        gpt-5
+        gpt-5-codex
+        gpt-5-mini
+        gpt-4o
+        gpt-4o-mini
+        o4-mini
+      ].freeze
+
+      # Auth modes the Codex runner accepts. Compatibility checks for an
+      # unrecognised auth mode return :auth_mode_not_supported rather than
+      # silently approving the request.
+      SUPPORTED_AUTH_MODES = %i[api_key subscription].freeze
       OAUTH_REFRESH_FAILURE_PATTERNS = [
         /refresh_token_reused/i,
         /failed to refresh token\b.*\b401\b/im,
@@ -232,6 +269,143 @@ module AgentHarness
           Base::DEFAULT_SMOKE_TEST_CONTRACT
         end
 
+        def default_compatible_model_id
+          DEFAULT_COMPATIBLE_MODEL_ID
+        end
+
+        # Structured Codex compatibility contract.
+        #
+        # Returns an {AgentHarness::ModelCompatibility::Result} for the
+        # combination of +model_id+, +auth_mode+, and installed
+        # +cli_version+. The contract surfaces three concrete outcomes:
+        #
+        # 1. **Supported** — the model is in {BASELINE_SUPPORTED_MODELS} (or
+        #    a known CLI-gated model whose minimum CLI version is met).
+        # 2. **Unsupported due to CLI version** — the model is known to need
+        #    a newer Codex CLI than was supplied; the result carries
+        #    +:minimum_cli_version+ so callers can act on it.
+        # 3. **Unknown / dynamic** — the model is not in this static
+        #    contract. Callers must treat this as "ask the provider" rather
+        #    than as approval.
+        #
+        # @param model_id [String, Symbol]
+        # @param auth_mode [Symbol, nil] :api_key or :subscription
+        # @param cli_version [String, Gem::Version, nil]
+        # @return [AgentHarness::ModelCompatibility::Result]
+        def model_compatibility(model_id:, auth_mode: nil, cli_version: nil)
+          normalized_model_id = model_id.to_s
+          normalized_auth_mode = auth_mode&.to_sym
+          normalized_cli_version = normalize_cli_version_for_compatibility(cli_version)
+
+          if normalized_auth_mode && !SUPPORTED_AUTH_MODES.include?(normalized_auth_mode)
+            return AgentHarness::ModelCompatibility.build_result(
+              runner: provider_name,
+              model_id: normalized_model_id,
+              auth_mode: normalized_auth_mode,
+              cli_version: normalized_cli_version,
+              supported: false,
+              reason: AgentHarness::ModelCompatibility::UNSUPPORTED_AUTH_MODE_REASON,
+              fallback_model_id: DEFAULT_COMPATIBLE_MODEL_ID,
+              source: :static_contract,
+              details: {supported_auth_modes: SUPPORTED_AUTH_MODES}
+            )
+          end
+
+          gated_fact = MODEL_COMPATIBILITY_FACTS[normalized_model_id]
+          if gated_fact
+            minimum_version = gated_fact[:minimum_cli_version]
+            requirement = Gem::Requirement.new(">= #{minimum_version}")
+            comparable_version = comparable_cli_version(normalized_cli_version)
+
+            # A CLI-gated model without a comparable installed version must
+            # stay explicit. Returning :supported here would re-introduce the
+            # exact `gpt-5.5` failure class this contract is designed to
+            # prevent — a caller that cannot supply a version would get
+            # `supported? == true` and may still schedule a run onto an old
+            # CLI (e.g. 0.115.x). Surface :unknown with the requirement
+            # attached so callers can decide deliberately.
+            if comparable_version.nil?
+              return AgentHarness::ModelCompatibility.unknown_result(
+                runner: provider_name,
+                model_id: normalized_model_id,
+                auth_mode: normalized_auth_mode,
+                cli_version: normalized_cli_version,
+                reason: AgentHarness::ModelCompatibility::UNKNOWN_CLI_VERSION_REASON,
+                minimum_cli_version: minimum_version,
+                cli_version_requirement: requirement.to_s,
+                fallback_model_id: DEFAULT_COMPATIBLE_MODEL_ID,
+                source: :static_contract
+              )
+            end
+
+            unless requirement.satisfied_by?(comparable_version)
+              return AgentHarness::ModelCompatibility.build_result(
+                runner: provider_name,
+                model_id: normalized_model_id,
+                auth_mode: normalized_auth_mode,
+                cli_version: normalized_cli_version,
+                supported: false,
+                reason: AgentHarness::ModelCompatibility::UNSUPPORTED_CLI_VERSION_REASON,
+                minimum_cli_version: minimum_version,
+                cli_version_requirement: requirement.to_s,
+                fallback_model_id: DEFAULT_COMPATIBLE_MODEL_ID,
+                source: :static_contract
+              )
+            end
+
+            return AgentHarness::ModelCompatibility.build_result(
+              runner: provider_name,
+              model_id: normalized_model_id,
+              auth_mode: normalized_auth_mode,
+              cli_version: normalized_cli_version,
+              supported: true,
+              reason: AgentHarness::ModelCompatibility::SUPPORTED_REASON,
+              minimum_cli_version: minimum_version,
+              cli_version_requirement: requirement.to_s,
+              source: :static_contract
+            )
+          end
+
+          if BASELINE_SUPPORTED_MODELS.include?(normalized_model_id)
+            return AgentHarness::ModelCompatibility.build_result(
+              runner: provider_name,
+              model_id: normalized_model_id,
+              auth_mode: normalized_auth_mode,
+              cli_version: normalized_cli_version,
+              supported: true,
+              reason: AgentHarness::ModelCompatibility::SUPPORTED_REASON,
+              source: :static_contract
+            )
+          end
+
+          AgentHarness::ModelCompatibility.unknown_result(
+            runner: provider_name,
+            model_id: normalized_model_id,
+            auth_mode: normalized_auth_mode,
+            cli_version: normalized_cli_version,
+            reason: AgentHarness::ModelCompatibility::UNKNOWN_MODEL_REASON,
+            fallback_model_id: DEFAULT_COMPATIBLE_MODEL_ID
+          )
+        end
+
+        # Coerce normalized CLI version into a +Gem::Version+ usable for
+        # requirement comparison. Returns +nil+ when the value is missing or
+        # cannot be parsed — callers treat that as "no installed-version
+        # signal," not as a failure.
+        def comparable_cli_version(value)
+          return value if value.is_a?(Gem::Version)
+          return nil if value.nil?
+
+          str = value.respond_to?(:strip) ? value.strip : value.to_s
+          return nil if str.empty?
+
+          begin
+            Gem::Version.new(str)
+          rescue ArgumentError
+            nil
+          end
+        end
+
         def parse_cli_jsonl_transcript(raw_output, max_events: nil)
           return parser_instance.send(:parse_jsonl_output, "") if max_events && max_events <= 0
 

data/lib/agent_harness/providers/registry.rb

@@ -181,6 +181,29 @@ module AgentHarness
         end
       end
 
+      # Query runner/model compatibility contract for a provider.
+      #
+      # Delegates to the provider class's +.model_compatibility+ method,
+      # which returns a structured {AgentHarness::ModelCompatibility::Result}.
+      # The default implementation in {AgentHarness::Providers::Adapter}
+      # returns +:unknown+ for providers that have not opted in to a
+      # static contract.
+      #
+      # @param name [Symbol, String] the provider name or alias
+      # @param model_id [String, Symbol] requested model identifier
+      # @param auth_mode [Symbol, nil] caller's auth mode
+      # @param cli_version [String, Gem::Version, nil] installed CLI version
+      # @return [AgentHarness::ModelCompatibility::Result]
+      # @raise [ConfigurationError] if the provider name is not registered
+      def model_compatibility(name, model_id:, auth_mode: nil, cli_version: nil)
+        klass = get(name)
+        klass.model_compatibility(
+          model_id: model_id,
+          auth_mode: auth_mode,
+          cli_version: cli_version
+        )
+      end
+
       # Get smoke-test metadata for a provider.
       #
       # @param name [Symbol, String] the provider name

data/lib/agent_harness/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AgentHarness
-  VERSION = "0.22.5"
+  VERSION = "0.23.0"
 end

data/lib/agent_harness.rb

@@ -257,6 +257,33 @@ module AgentHarness
       Providers::Registry.instance.smoke_test_contracts
     end
 
+    # Query runner/model compatibility contract.
+    #
+    # Returns a structured {AgentHarness::ModelCompatibility::Result}
+    # describing whether the named runner can execute +model_id+ under
+    # the requested runtime constraints. Downstream orchestrators should
+    # consume this contract before validating tier models, selecting a
+    # runner, or scheduling work — rather than inferring compatibility
+    # from scattered CLI version pins, smoke-test overrides, or runtime
+    # error strings.
+    #
+    # @param runner [Symbol, String] provider/runner name (e.g. :codex)
+    # @param model_id [String, Symbol] requested model identifier
+    # @param auth_mode [Symbol, nil] caller's auth mode (e.g. :api_key,
+    #   :subscription)
+    # @param cli_version [String, Gem::Version, nil] installed CLI
+    #   version, when known
+    # @return [AgentHarness::ModelCompatibility::Result]
+    # @raise [ConfigurationError] if the runner is not registered
+    def model_compatibility(runner:, model_id:, auth_mode: nil, cli_version: nil)
+      Providers::Registry.instance.model_compatibility(
+        runner,
+        model_id: model_id,
+        auth_mode: auth_mode,
+        cli_version: cli_version
+      )
+    end
+
     # Check if authentication is valid for a provider
     # @param provider_name [Symbol] the provider name
     # @return [Boolean] true if auth is valid
@@ -395,6 +422,7 @@ require_relative "agent_harness/authentication"
 require_relative "agent_harness/provider_health_check"
 require_relative "agent_harness/release_registry"
 require_relative "agent_harness/dependency_updater"
+require_relative "agent_harness/model_compatibility"
 
 # Provider layer
 require_relative "agent_harness/providers/registry"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agent-harness
 version: !ruby/object:Gem::Version
-  version: 0.22.5
+  version: 0.23.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -113,6 +113,7 @@ files:
 - lib/agent_harness/mcp_config_loader.rb
 - lib/agent_harness/mcp_config_translator.rb
 - lib/agent_harness/mcp_server.rb
+- lib/agent_harness/model_compatibility.rb
 - lib/agent_harness/openai_compatible_transport.rb
 - lib/agent_harness/orchestration/circuit_breaker.rb
 - lib/agent_harness/orchestration/conductor.rb