agent-harness 0.36.24 → 0.37.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a501dcf4ece87de9e617366814b962f131f819c292c81dd6b31edd05e0a3e2dc
-  data.tar.gz: 91411a412a29e9ad2eac69b569eafe06dc3f33ed7017e8669b4b88cb3f73a692
+  metadata.gz: 045e59747b5b64528739836b362b75b21df461fc7955d47506b410a77aabdc01
+  data.tar.gz: 848b47345c5c93bad14bc892a2c8fe9b8c779e81e924e0ee381204581cd66ec9
 SHA512:
-  metadata.gz: '09b4723c8a02567e02b20a0d0c67ef411a854a533df3e57b35feaa47621a9d61eec1fce1df9d1f284b8fb2b442ab76ad7c326cfb4998611d4ad2fddc3c9bd867'
-  data.tar.gz: 3460bd1b2cddb6d10a1152bf23643d8e30cefa6ba1eb6f5d7834730e36335fff782a8a59303cbf96a22ef97c56b58c489d12fab1d9b80da601a042d707a6311b
+  metadata.gz: e5df080c3c51a1992ed0a51d97f755e4d2c761a5903f67aaf72635a3085eb0a8d4e0c87d4765ddad765234f660be2d814b7cebee0b83be3633adce170690d4d9
+  data.tar.gz: 5d8c6ae0a2537011966fc607654a3d2807be8bceb7d1a730415e0e5ddee3a9faa54dd4e683d13c35cc3def5d6c3b9ab97c4293d00ef8ae174692369750252a86

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.36.24"
+  ".": "0.37.0"
 }

data/CHANGELOG.md

@@ -5,6 +5,13 @@
 * 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)).
 * **auth:** add provider-owned PKCE code-exchange API for Claude OAuth (`AgentHarness::Authentication.exchange_code`). Takes an authorization code plus PKCE verifier (and `redirect_uri`/`client_id`), posts an `authorization_code` grant to the Claude token endpoint, and persists the resulting access/refresh tokens in the native `claudeAiOauth` shape. Adds `exchange_code_supported?` and a `code_exchange` key to `auth_capabilities` ([#266](https://github.com/viamin/agent-harness/issues/266)).
 
+## [0.37.0](https://github.com/viamin/agent-harness/compare/agent-harness/v0.36.24...agent-harness/v0.37.0) (2026-09-19)
+
+
+### Features
+
+* **codex:** expose subscription-aware model discovery and bounded rejection recovery ([#414](https://github.com/viamin/agent-harness/issues/414)) ([c7f52b3](https://github.com/viamin/agent-harness/commit/c7f52b32bb00f8ba988cd0656749b70546043b78))
+
 ## [0.36.24](https://github.com/viamin/agent-harness/compare/agent-harness/v0.36.23...agent-harness/v0.36.24) (2026-09-16)
 
 

data/lib/agent_harness/command_executor.rb

@@ -203,6 +203,20 @@ module AgentHarness
       !which(binary).nil?
     end
 
+    # Execute a command while allowing a caller to exchange messages over its
+    # stdio before stdin is closed. The block must consume the stdout it needs
+    # and return it; any remaining stdout is appended after the exchange.
+    def execute_interactive(command, timeout: nil, env: {})
+      validate_duration!(timeout, name: :timeout, allow_nil: true)
+      cmd_array = normalize_command(command)
+      start_time = current_time
+
+      stdout, stderr, status = interactive_process(cmd_array, timeout:, env:) do |stdin, stdout_io|
+        yield(stdin, stdout_io)
+      end
+      Result.new(stdout:, stderr:, exit_code: status.exitstatus, duration: current_time - start_time)
+    end
+
     protected
 
     def normalize_command(command)
@@ -218,6 +232,38 @@ module AgentHarness
 
     private
 
+    def interactive_process(cmd_array, timeout:, env:)
+      Open3.popen3(env, *cmd_array, pgroup: true) do |stdin, stdout_io, stderr_io, wait_thr|
+        stderr_reader = Thread.new { stderr_io.read }
+        begin
+          stdout, status = run_interactive_exchange(stdin, stdout_io, wait_thr, cmd_array, timeout) do
+            yield(stdin, stdout_io)
+          end
+          [stdout, stderr_reader.value, status]
+        rescue
+          terminate_process(wait_thr) if wait_thr.alive?
+          raise
+        ensure
+          stdin.close unless stdin.closed?
+          stderr_reader.join
+        end
+      end
+    end
+
+    def run_interactive_exchange(stdin, stdout_io, wait_thr, cmd_array, timeout)
+      exchange = proc do
+        consumed_stdout = yield.to_s
+        stdin.close unless stdin.closed?
+        [consumed_stdout + stdout_io.read, wait_thr.value]
+      end
+      return exchange.call unless timeout
+
+      Timeout.timeout(timeout, &exchange)
+    rescue Timeout::Error
+      terminate_process(wait_thr)
+      raise TimeoutError, "Command timed out after #{timeout} seconds: #{cmd_array.first}"
+    end
+
     def acquire_preparation_locks(preparation, env:, timeout:, deadline:, command_name:)
       return [] if preparation.nil? || preparation.empty?
 

data/lib/agent_harness/docker_command_executor.rb

@@ -189,6 +189,16 @@ module AgentHarness
       result.success? ? result.stdout.strip : nil
     end
 
+    def execute_interactive(command, timeout: nil, env: {}, &exchange)
+      docker_cmd = build_docker_command_for_execution(
+        normalize_command(command),
+        env: env,
+        stdin_data: "",
+        execution_tracking: nil
+      )
+      super(docker_cmd, timeout:, env: {}, &exchange)
+    end
+
     private
 
     def preparation_lock_scope

data/lib/agent_harness/provider_health_check.rb

@@ -338,13 +338,26 @@ module AgentHarness
         end
         smoke = provider_instance.smoke_test(timeout: smoke_timeout, provider_runtime: provider_runtime)
         unless smoke[:ok]
+          recovered = recover_smoke_test_model_rejection(
+            provider_instance,
+            smoke,
+            provider_runtime,
+            provider_name: provider_name,
+            start_time: start_time,
+            discovery_timeout: smoke_timeout || timeout,
+            smoke_timeout: smoke_timeout
+          )
+          return recovered if recovered
+
           return build_result(
             name: provider_name,
             status: smoke[:status] || "error",
             message: smoke[:message] || "Smoke test failed",
             start_time: start_time,
             error_category: normalize_smoke_error_category(smoke[:error_category], smoke[:message]),
-            check: :smoke_test
+            check: :smoke_test,
+            model: smoke[:model],
+            recovery: smoke[:recovery]
           )
         end
 
@@ -376,7 +389,71 @@ module AgentHarness
           status: "ok",
           message: message,
           start_time: start_time,
-          check: :smoke_test
+          check: :smoke_test,
+          model: smoke[:model]
+        )
+      end
+
+      def recover_smoke_test_model_rejection(provider_instance, smoke, provider_runtime, provider_name:, start_time:,
+        discovery_timeout:, smoke_timeout:)
+        return unless provider_instance.respond_to?(:resolve_model_rejection_recovery)
+
+        env = build_preflight_env(provider_instance, provider_runtime)
+        recovery = provider_instance.resolve_model_rejection_recovery(
+          failure: smoke,
+          provider_runtime: provider_runtime,
+          env: env,
+          timeout: discovery_timeout
+        )
+        return unless recovery
+
+        runtime = recovery[:provider_runtime]
+        unless runtime
+          failure = recovery_failure_result(smoke, recovery)
+          return build_smoke_result(provider_name, failure, start_time)
+        end
+
+        retried_smoke = provider_instance.smoke_test(timeout: smoke_timeout, provider_runtime: runtime)
+        if retried_smoke[:ok]
+          success = recovery_success_result(retried_smoke, recovery)
+          return build_smoke_result(provider_name, success, start_time)
+        end
+
+        failure = recovery_failure_result(retried_smoke.merge(original_failure: smoke), recovery)
+        build_smoke_result(provider_name, failure, start_time)
+      end
+
+      def recovery_success_result(smoke, recovery)
+        {
+          status: "ok",
+          message: "Smoke test passed after Codex model replacement",
+          error_category: nil,
+          check: :smoke_test,
+          model: smoke[:model],
+          recovery: recovery.except(:provider_runtime).merge(outcome: :recovered)
+        }
+      end
+
+      def recovery_failure_result(smoke, recovery)
+        smoke.merge(
+          recovery: recovery.except(:provider_runtime).merge(outcome: :unrecovered),
+          message: [
+            smoke[:message],
+            recovery[:message]
+          ].compact.join(" ")
+        )
+      end
+
+      def build_smoke_result(provider_name, smoke, start_time)
+        build_result(
+          name: provider_name,
+          status: smoke[:status] || "error",
+          message: smoke[:message] || "Smoke test failed",
+          start_time: start_time,
+          error_category: normalize_smoke_error_category(smoke[:error_category], smoke[:message]),
+          check: :smoke_test,
+          model: smoke[:model],
+          recovery: smoke[:recovery]
         )
       end
 
@@ -439,6 +516,8 @@ module AgentHarness
           :rate_limit
         when :quota_exceeded, :quota
           :quota
+        when :subscription_model_rejected
+          :subscription_model_rejected
         when :timeout
           :timeout
         when :transient
@@ -479,7 +558,7 @@ module AgentHarness
         provider_instance.method(method_name).owner != Providers::Adapter
       end
 
-      def build_result(name:, status:, message:, start_time:, error_category: nil, check: nil)
+      def build_result(name:, status:, message:, start_time:, error_category: nil, check: nil, **metadata)
         latency = ((monotonic_now - start_time) * 1000).round
         {
           name: name,
@@ -488,7 +567,7 @@ module AgentHarness
           latency_ms: latency,
           error_category: error_category,
           check: check
-        }
+        }.merge(metadata.compact)
       end
 
       def build_provider(provider_name, klass, executor:)

data/lib/agent_harness/providers/adapter.rb

@@ -1199,7 +1199,8 @@ module AgentHarness
             message: contract[:success_message] || "Smoke test passed",
             error_category: nil,
             output: output,
-            exit_code: response.exit_code
+            exit_code: response.exit_code,
+            model: response.model
           }
         end
 
@@ -1213,7 +1214,8 @@ module AgentHarness
           message: message,
           error_category: classify_smoke_test_message(message),
           output: output,
-          exit_code: response.exit_code
+          exit_code: response.exit_code,
+          model: response.model
         }
       rescue TimeoutError => e
         failure_smoke_test_result(e.message, :timeout)

data/lib/agent_harness/providers/codex.rb

@@ -17,8 +17,32 @@ module AgentHarness
         :type, :turn, :tokens, :error_message, :tool_name, :raw_event
       )
 
+      ModelDiscovery = Struct.new(
+        :status, :recommended_model_id, :models, :source, :reason, :details
+      ) do
+        def available? = status == :available
+
+        def to_h
+          {
+            status: status,
+            recommended_model_id: recommended_model_id,
+            models: models,
+            source: source,
+            reason: reason,
+            details: details
+          }.compact
+        end
+      end
+
       SUPPORTED_CLI_VERSION = "0.149.1"
       SUPPORTED_CLI_REQUIREMENT = Gem::Requirement.new(">= #{SUPPORTED_CLI_VERSION}", "< 0.150.0").freeze
+      MODEL_REJECTION_CACHE_TTL = 300
+      MODEL_REJECTION_CACHE_LIMIT = 128
+      MODEL_REJECTION_CACHE = {}
+      MODEL_REJECTION_PATTERNS = [
+        /The ['"](?<model>[^'"]+)['"] model is not supported when using Codex with a ChatGPT account/i,
+        /model ['"](?<model>[^'"]+)['"] is not supported.*ChatGPT account/i
+      ].freeze
 
       # Default model recommended by the Codex runner contract when callers
       # have no explicit preference. Used as the {AgentHarness::ModelCompatibility::Result#fallback_model_id}
@@ -144,6 +168,31 @@ module AgentHarness
         ],
         transient_error: OAUTH_REFRESH_TRANSIENT_PATTERNS + SHARED_OUTPUT_ERROR_PATTERNS[:transient_error]
       ).tap { |h| h.each_value(&:freeze) }.freeze
+      MODEL_LIST_REQUESTS = [
+        {
+          method: "initialize",
+          id: 1,
+          params: {
+            clientInfo: {
+              name: "agent_harness",
+              title: "Agent Harness",
+              version: "0.1.0"
+            }
+          }
+        },
+        {
+          method: "initialized",
+          params: {}
+        },
+        {
+          method: "model/list",
+          id: 2,
+          params: {
+            limit: 100,
+            includeHidden: false
+          }
+        }
+      ].freeze
 
       class << self
         def provider_name
@@ -493,6 +542,10 @@ module AgentHarness
           nil
         end
 
+        def classify_model_rejection(output, configured_model: nil)
+          parser_instance.send(:classify_model_rejection, output, configured_model: configured_model)
+        end
+
         private
 
         def classify_stdout_chunk(text, buffer)
@@ -687,6 +740,27 @@ module AgentHarness
         QuotaStatus.unavailable
       end
 
+      def resolve_model_rejection_recovery(failure:, provider_runtime:, env:, timeout:)
+        rejection = model_rejection_from_failure(failure, provider_runtime)
+        return unless rejection
+
+        record_model_rejection(rejection, env: env)
+        allowed_model_ids = recovery_allowed_model_ids(provider_runtime)
+        discovery = discover_compatible_model(
+          rejected_model_id: rejection[:model],
+          allowed_model_ids: allowed_model_ids,
+          env: env,
+          timeout: timeout,
+          refresh: true
+        )
+        {
+          rejection: rejection,
+          discovery: discovery.to_h,
+          provider_runtime: replacement_runtime(provider_runtime, discovery, rejection),
+          message: model_rejection_recovery_message(rejection, discovery)
+        }
+      end
+
       def send_message(prompt:, **options)
         super
       ensure
@@ -750,6 +824,7 @@ module AgentHarness
 
       def error_patterns
         {
+          subscription_model_rejected: MODEL_REJECTION_PATTERNS,
           rate_limited: COMMON_ERROR_PATTERNS[:rate_limited],
           timeout: [
             /your access token could not be refreshed.*(?:timeout|timed.?out)/im,
@@ -1002,6 +1077,249 @@ module AgentHarness
 
       private
 
+      def discover_compatible_model(rejected_model_id:, env:, timeout:, allowed_model_ids: nil, refresh: false)
+        cache_key = model_rejection_cache_key(rejected_model_id, env, allowed_model_ids)
+        cached = self.class::MODEL_REJECTION_CACHE[cache_key]
+        if !refresh && cached && cached[:expires_at] > monotonic_now
+          return cached[:discovery]
+        end
+
+        discovery = fetch_model_list(
+          rejected_model_id: rejected_model_id,
+          allowed_model_ids: allowed_model_ids,
+          env: env,
+          timeout: timeout
+        )
+        cache_model_discovery(cache_key, discovery)
+        discovery
+      end
+
+      def fetch_model_list(rejected_model_id:, allowed_model_ids:, env:, timeout:)
+        result = @executor.execute_interactive(
+          [self.class.binary_name, "app-server", "--listen", "stdio://"],
+          timeout: timeout,
+          env: env
+        ) { |stdin, stdout| exchange_model_list_requests(stdin, stdout) }
+        return unavailable_model_discovery(:app_server_failed, stderr: result.stderr) unless result.success?
+
+        response = parse_app_server_response(result.stdout, 2)
+        return unavailable_model_discovery(:model_list_missing_response) unless response
+        return unavailable_model_discovery(:model_list_error, error: response["error"]) if response["error"]
+
+        entries = Array(response.dig("result", "data")).filter_map { |entry| normalize_model_entry(entry) }
+        alternatives = entries.reject { |entry| entry[:id] == rejected_model_id }
+        alternatives.select! { |entry| allowed_model_ids.include?(entry[:id]) } if allowed_model_ids
+        recommended = alternatives.find { |entry| entry[:is_default] } || alternatives.first
+        return unavailable_model_discovery(:no_compatible_model, models: entries) unless recommended
+
+        ModelDiscovery.new(
+          status: :available,
+          recommended_model_id: recommended[:id],
+          models: entries,
+          source: :codex_app_server_model_list,
+          details: {default_model_id: recommended[:id]}
+        )
+      rescue TimeoutError
+        unavailable_model_discovery(:app_server_timeout)
+      rescue ArgumentError, JSON::ParserError
+        unavailable_model_discovery(:model_list_unparseable)
+      end
+
+      def exchange_model_list_requests(stdin, stdout)
+        responses = +""
+        write_app_server_request(stdin, MODEL_LIST_REQUESTS.first)
+        initialized = read_app_server_response(stdout, responses, 1)
+        raise ArgumentError, "app-server rejected initialize" if initialized["error"]
+
+        MODEL_LIST_REQUESTS.drop(1).each { |request| write_app_server_request(stdin, request) }
+        read_app_server_response(stdout, responses, 2)
+        responses
+      end
+
+      def write_app_server_request(stdin, request)
+        stdin.puts(JSON.generate(request))
+        stdin.flush
+      end
+
+      def read_app_server_response(stdout, responses, id)
+        loop do
+          line = stdout.gets
+          raise JSON::ParserError, "app-server closed before response #{id}" unless line
+
+          responses << line
+          message = JSON.parse(line)
+          return message if message.is_a?(Hash) && message["id"] == id
+        rescue JSON::ParserError
+          raise if line.nil?
+        end
+      end
+
+      def parse_app_server_response(stdout, id)
+        stdout.to_s.each_line.filter_map do |line|
+          JSON.parse(line)
+        rescue JSON::ParserError
+          nil
+        end.find { |message| message.is_a?(Hash) && message["id"] == id }
+      end
+
+      def normalize_model_entry(entry)
+        return unless entry.is_a?(Hash)
+
+        id = entry["id"] || entry["model"]
+        return if id.to_s.strip.empty?
+
+        {
+          id: id.to_s,
+          model: (entry["model"] || id).to_s,
+          display_name: entry["displayName"],
+          hidden: entry["hidden"] == true,
+          is_default: entry["isDefault"] == true,
+          source: :codex_app_server_model_list
+        }.compact
+      end
+
+      def unavailable_model_discovery(reason, details = {})
+        ModelDiscovery.new(
+          status: :unavailable,
+          recommended_model_id: nil,
+          models: Array(details.delete(:models)),
+          source: :codex_app_server_model_list,
+          reason: reason,
+          details: details.compact
+        )
+      end
+
+      def replacement_runtime(provider_runtime, discovery, rejection)
+        return unless discovery.available?
+        return if discovery.recommended_model_id == rejection[:model]
+
+        runtime = ProviderRuntime.wrap(provider_runtime)
+        replacement = {model: discovery.recommended_model_id}
+        return ProviderRuntime.new(**replacement) unless runtime
+
+        runtime.merge(replacement)
+      end
+
+      def recovery_allowed_model_ids(provider_runtime)
+        selected_model = ProviderRuntime.wrap(provider_runtime)&.model || @config.model
+        selected_model ? [selected_model] : nil
+      end
+
+      def model_rejection_recovery_message(rejection, discovery)
+        rejected = rejection[:model] || "the selected model"
+        unless discovery.available?
+          return "Codex rejected #{rejected.inspect} for ChatGPT subscription auth, and model/list did not return a usable replacement (#{discovery.reason})."
+        end
+        if discovery.recommended_model_id == rejection[:model]
+          return "Codex rejected #{rejected.inspect}, and model/list recommended the same model."
+        end
+
+        "Codex rejected #{rejected.inspect}; retrying preflight with #{discovery.recommended_model_id.inspect} from model/list."
+      end
+
+      def model_rejection_from_failure(failure, provider_runtime)
+        output = [
+          failure[:message],
+          failure[:output],
+          failure[:error],
+          failure.dig(:metadata, :error)
+        ].compact.join("\n")
+        configured_model = ProviderRuntime.wrap(provider_runtime)&.model || @config.model
+        self.class.classify_model_rejection(output, configured_model: configured_model)
+      end
+
+      def classify_model_rejection(output, configured_model: nil)
+        texts = extract_error_texts(output)
+        texts.each do |text|
+          MODEL_REJECTION_PATTERNS.each do |pattern|
+            match = text.match(pattern)
+            next unless match
+
+            return {
+              type: :subscription_model_rejected,
+              model: match[:model] || configured_model,
+              configured_model: configured_model,
+              auth_mode: :subscription,
+              source: :codex_cli_error
+            }.compact
+          end
+        end
+
+        nil
+      end
+
+      def extract_error_texts(value)
+        case value
+        when Hash
+          value.values.flat_map { |item| extract_error_texts(item) }
+        when Array
+          value.flat_map { |item| extract_error_texts(item) }
+        else
+          text = value.to_s
+          nested = parse_nested_json_text(text)
+          [text] + nested
+        end
+      end
+
+      def parse_nested_json_text(text)
+        parsed = JSON.parse(text)
+        return extract_error_texts(parsed) if parsed.is_a?(Hash) || parsed.is_a?(Array)
+
+        []
+      rescue JSON::ParserError, TypeError
+        text.scan(/\{.*?\}/m).flat_map do |candidate|
+          JSON.parse(candidate).then { |parsed| extract_error_texts(parsed) }
+        rescue JSON::ParserError
+          []
+        end
+      end
+
+      def record_model_rejection(rejection, env:)
+        cache_model_discovery(
+          model_rejection_cache_key(rejection[:model], env),
+          ModelDiscovery.new(
+            status: :unavailable,
+            models: [],
+            source: :codex_cli_error,
+            reason: :subscription_model_rejected,
+            details: rejection
+          )
+        )
+      end
+
+      def cache_model_discovery(cache_key, discovery)
+        cache = self.class::MODEL_REJECTION_CACHE
+        cache.delete(cache_key)
+        cache[cache_key] = {
+          discovery: discovery,
+          expires_at: monotonic_now + MODEL_REJECTION_CACHE_TTL
+        }
+        cache.shift while cache.size > MODEL_REJECTION_CACHE_LIMIT
+      end
+
+      def model_rejection_cache_key(model, env, allowed_model_ids = nil)
+        [
+          :codex,
+          codex_cli_version(env: env, timeout: 2)&.to_s || "unknown",
+          account_identity(env),
+          model.to_s,
+          Array(allowed_model_ids).sort
+        ]
+      end
+
+      def account_identity(env)
+        credentials_path = codex_config_path_for_env(env)
+        [
+          env_fetch(env, "CODEX_HOME"),
+          env_fetch(env, "HOME"),
+          credentials_path
+        ].compact.join("|")
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
       def auth_status_for_env(env)
         api_key = env_fetch(env, "OPENAI_API_KEY")
         # Fall back to process ENV when the provided env hash does not override auth keys

data/lib/agent_harness/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agent-harness
 version: !ruby/object:Gem::Version
-  version: 0.36.24
+  version: 0.37.0
 platform: ruby
 authors:
 - Bart Agapinan