agent-harness 0.37.5 → 0.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 689dc0db60fba2154368f84887018123219d2933eabf037b8592bd0c4ab4c6a6
-  data.tar.gz: 1a66d12fde96441a8220656cb49ef1b742372c12de8873f6b5676a6f8540dc6e
+  metadata.gz: 07b7223207e544b8728f23b9800ddc774b0c70d16cdd899ccac23550e4a10270
+  data.tar.gz: d004705a37d7d83fa6e27f16f2b3593ffb81a06f30980e4aa699a92bb9f06237
 SHA512:
-  metadata.gz: c966600212a4920c975efa9f7155b64c31aa8129a524eceedf993acbc0d3d099c3ef59cddaf1f23d51edafdad9b9e88a38e5fb18e8bcf36322beecb4f37eb8d7
-  data.tar.gz: 05cd073a1878124085ced27da8b297dc67e84ccc900ef9e38e1d2893b1de4f3b72a4c11e516b3575d9b6bcf66eaf0c1976bf8b8ee5ee94fc54c17e0f8f16e42e
+  metadata.gz: 9d59ea2adf8708b5eb6177fa2314d01e6eb83cb5b8d7748ccc19b7bc07394b1edea040015071df52d53ffb39b1684920092d393a94eeb690058356e05a4eafe5
+  data.tar.gz: d9851948407b188ed95b18413b1eb647245cfe76ea0770e1952972c2a3f83c2a8bd979c90161cc04d4af78241d7dcc83f197451523af233314c28b8d853f9f12

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.37.5"
+  ".": "0.38.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.38.0](https://github.com/viamin/agent-harness/compare/agent-harness/v0.37.5...agent-harness/v0.38.0) (2026-09-24)
+
+
+### Features
+
+* **codex:** expose account-local discovery for container recovery ([#428](https://github.com/viamin/agent-harness/issues/428)) ([a67c11f](https://github.com/viamin/agent-harness/commit/a67c11f46aaf99cd440cbb69edbd3272f3ed9312))
+
 ## [0.37.5](https://github.com/viamin/agent-harness/compare/agent-harness/v0.37.4...agent-harness/v0.37.5) (2026-09-21)
 
 

data/README.md

@@ -419,6 +419,24 @@ result.fallback_model_id     # => "gpt-5.2-codex"
 result.source                # => :static_contract
 ```
 
+For account-local Codex discovery, use the same executor and credential
+environment as execution:
+
+```ruby
+provider = AgentHarness::Providers::Codex.new(executor: container_executor)
+discovery = provider.discover_available_models(env: subscription_env, timeout: 15)
+discovery.models                 # normalized visible entries from model/list
+discovery.recommended_model_id   # provider default, not proof of execution
+```
+
+This method performs a fresh, paginated app-server exchange within the supplied
+execution context. It supports execute-only container transports using Node
+(already required by the Codex npm installation). It never changes auth mode or
+selects a model on the caller's behalf. Apply project policy, verify the chosen
+model with `smoke_test`, and persist successful evidence in the calling system.
+`classify_model_rejection_from_result(stdout:, stderr:)` excludes ordinary
+assistant/tool stdout from rejection classification.
+
 Outcomes follow three explicit shapes:
 
 - **Supported** — `result.supported?` is `true`. The runner contract

data/lib/agent_harness/providers/codex.rb

@@ -3,6 +3,7 @@
 require "json"
 require "net/http"
 require "uri"
+require_relative "codex_model_discovery"
 
 module AgentHarness
   module Providers
@@ -12,6 +13,7 @@ module AgentHarness
     class Codex < Base
       include RateLimitResetParsing
       include McpConfigFileSupport
+      include CodexModelDiscovery
 
       StreamingEvent = Struct.new(
         :type, :turn, :tokens, :error_message, :tool_name, :raw_event
@@ -546,6 +548,24 @@ module AgentHarness
           parser_instance.send(:classify_model_rejection, output, configured_model: configured_model)
         end
 
+        # Successful assistant/tool output can quote the exact rejection text.
+        # Only CLI stderr and explicit JSONL error envelopes are evidence.
+        def classify_model_rejection_from_result(stdout:, stderr:, configured_model: nil)
+          texts = stdout.to_s.each_line.filter_map do |line|
+            event = parse_stdout_jsonl_event(line.strip)
+            next unless event.is_a?(Hash)
+
+            event = unwrap_classification_event(event)
+            extract_jsonl_error_text(event) if event.is_a?(Hash)
+          end
+          texts << stderr.to_s
+          texts.each do |text|
+            rejection = classify_model_rejection(text, configured_model: configured_model)
+            return rejection if rejection
+          end
+          nil
+        end
+
         private
 
         def classify_stdout_chunk(text, buffer)
@@ -1095,11 +1115,15 @@ module AgentHarness
       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) }
+        result = if @executor.respond_to?(:execute_interactive)
+          @executor.execute_interactive(
+            [self.class.binary_name, "app-server", "--listen", "stdio://"],
+            timeout: timeout,
+            env: env
+          ) { |stdin, stdout| exchange_model_list_requests(stdin, stdout) }
+        else
+          execute_model_discovery(env: env, timeout: timeout)
+        end
         return unavailable_model_discovery(:app_server_failed, stderr: result.stderr) unless result.success?
 
         response = parse_app_server_response(result.stdout, 2)

data/lib/agent_harness/providers/codex_model_discovery.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module AgentHarness
+  module Providers
+    # Runs the interactive protocol beside the CLI, including for executors that
+    # only expose execute (Docker/remote transports). Codex's npm installation
+    # already requires Node. No shell, host credentials, or host CLI is used.
+    module CodexModelDiscovery
+      SCRIPT = <<~'JS'
+        const { spawn } = require('node:child_process');
+        const child = spawn(process.argv[1], ['app-server', '--listen', 'stdio://'], {stdio: ['pipe', 'pipe', 'pipe']});
+        let buffer = '', bytes = 0, page = 0, done = false;
+        const models = [], cursors = new Set();
+        const send = value => child.stdin.write(JSON.stringify(value) + '\n');
+        const finish = (code, value) => {
+          if (done) return;
+          done = true;
+          clearTimeout(timer);
+          if (value) process.stdout.write(JSON.stringify(value) + '\n');
+          process.exitCode = code;
+          child.stdin.end();
+          child.kill('SIGTERM');
+          setTimeout(() => child.kill('SIGKILL'), 250).unref();
+        };
+        const timer = setTimeout(() => finish(1), Number(process.argv[2]));
+        child.on('error', () => finish(1));
+        child.stdin.on('error', () => finish(1));
+        child.stderr.on('data', () => {});
+        child.on('close', () => { if (!done) finish(1); });
+        child.stdout.on('data', chunk => {
+          bytes += chunk.length;
+          if (bytes > 1048576) return finish(1);
+          buffer += chunk.toString();
+          let end;
+          while (!done && (end = buffer.indexOf('\n')) >= 0) {
+            const line = buffer.slice(0, end); buffer = buffer.slice(end + 1);
+            let msg; try { msg = JSON.parse(line); } catch { continue; }
+            if (msg.id !== 1 && msg.id !== 2) continue;
+            if (msg.error) return finish(0, {id: 2, error: msg.error});
+            if (msg.id === 1) {
+              send({method: 'initialized', params: {}});
+              send({id: 2, method: 'model/list', params: {limit: 100}});
+            } else {
+              if (!Array.isArray(msg.result?.data)) return finish(1);
+              models.push(...msg.result.data);
+              const cursor = msg.result.nextCursor;
+              if (!cursor) return finish(0, {id: 2, result: {data: models}});
+              if (++page >= 10 || cursors.has(cursor)) return finish(1);
+              cursors.add(cursor);
+              send({id: 2, method: 'model/list', params: {limit: 100, cursor}});
+            }
+          }
+        });
+        send({id: 1, method: 'initialize', params: {clientInfo: {name: 'agent-harness', version: '1.0.0'}}});
+      JS
+
+      # Fresh account-local discovery. The caller owns selection policy and must
+      # still smoke-test its selected model; model/list is not execution proof.
+      def discover_available_models(env:, timeout: 15)
+        result = execute_model_discovery(env: env, timeout: timeout)
+        return unavailable_model_discovery(:app_server_failed) 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) if response["error"]
+
+        entries = Array(response.dig("result", "data")).filter_map { |entry| normalize_model_entry(entry) }
+          .reject { |entry| entry[:hidden] }.uniq { |entry| entry[:id] }
+        return unavailable_model_discovery(:no_compatible_model) if entries.empty?
+
+        preferred = entries.find { |entry| entry[:is_default] } || entries.first
+        self.class::ModelDiscovery.new(status: :available, models: entries,
+          recommended_model_id: preferred[:id], source: :codex_app_server_model_list)
+      rescue TimeoutError
+        unavailable_model_discovery(:app_server_timeout)
+      end
+
+      private
+
+      def execute_model_discovery(env:, timeout:)
+        @executor.execute(
+          ["node", "-e", SCRIPT, self.class.binary_name, [(timeout * 1000).to_i - 500, 100].max.to_s],
+          env: env, timeout: timeout
+        )
+      end
+    end
+  end
+end

data/lib/agent_harness/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agent-harness
 version: !ruby/object:Gem::Version
-  version: 0.37.5
+  version: 0.38.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -128,6 +128,7 @@ files:
 - lib/agent_harness/providers/anthropic.rb
 - lib/agent_harness/providers/base.rb
 - lib/agent_harness/providers/codex.rb
+- lib/agent_harness/providers/codex_model_discovery.rb
 - lib/agent_harness/providers/cursor.rb
 - lib/agent_harness/providers/gemini.rb
 - lib/agent_harness/providers/github_copilot.rb