agent-harness 0.14.0 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffc18c8e54d6a675c551c68e9d3aa3a39352995be92f33bf3aee01cf9dad3134
-  data.tar.gz: 884049b284c3ced78ecbe22fbf744aa6d6307da57f3b913b732d313e2fba5d75
+  metadata.gz: 972e7e3144da1a59c0a25dbf4668766d07693870dde63c74dece4842c960dfe5
+  data.tar.gz: 3988ed1d19d61ce9144224302c0246c2c32442abdfa1d1c9bc4616abcb4e11c3
 SHA512:
-  metadata.gz: 9792c3e83b4b6cd2672a9863c3eca7a0c1a9502cd5d42334caf1d7c52cb3e13c1d3764e72189c80fed65d67fd620c8a8b7f181a944d8fb6dafe9c9dd9e347def
-  data.tar.gz: 37d1825a1361ae4bd3d625f535a1ec52d53dd70eca7e0ec1d40434fd8e53a00cd7ad08efc94d8c866b7835fafda24f204592ce5d3357d56e04d904292af0700f
+  metadata.gz: 97d598d30445ef7617c172b692d43f3c8d8c896b9c12f28f7f0e56f822128e298312129bdae67adbbfc81eb407686587db677787bda70a2292c3a1f07aea9a60
+  data.tar.gz: 863739d9ace22d47b37799e44b36c19cacf221a4042947a627525f542838ccaafb933e03c3e0c10141c0d30971283046791b44d4ca8cc7c84c4a0e50184010a8

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.14.0"
+  ".": "0.14.1"
 }

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.14.1](https://github.com/viamin/agent-harness/compare/agent-harness/v0.14.0...agent-harness/v0.14.1) (2026-05-03)
+
+
+### Bug Fixes
+
+* **kilocode:** test_command_overrides never wired into smoke test — kilo hangs without --auto ([#191](https://github.com/viamin/agent-harness/issues/191)) ([7c01d49](https://github.com/viamin/agent-harness/commit/7c01d49713cbedb6fb93758be95b7d92aa4599d3))
+
 ## [0.14.0](https://github.com/viamin/agent-harness/compare/agent-harness/v0.13.1...agent-harness/v0.14.0) (2026-05-03)
 
 

data/lib/agent_harness/providers/adapter.rb

@@ -765,6 +765,11 @@ module AgentHarness
       #   For providers that delegate to Providers::Base#send_message, a plain Hash
       #   is automatically coerced into a ProviderRuntime. Providers that override
       #   #send_message directly are responsible for handling this option.
+      # @option options [Boolean] :smoke_test when +true+, signals that this
+      #   invocation is a lightweight connectivity/health check issued by
+      #   {#smoke_test}. Providers may use this flag to adjust command-line
+      #   arguments (e.g. Kilocode appends +--auto --print-logs+) or skip
+      #   interactive features that would cause the process to hang.
       # @return [Response] response object with output and metadata
       def send_message(prompt:, **options)
         raise NotImplementedError, "#{self.class} must implement #send_message"
@@ -1061,7 +1066,8 @@ module AgentHarness
         response = send_message(
           prompt: prompt,
           timeout: timeout || contract[:timeout],
-          provider_runtime: provider_runtime
+          provider_runtime: provider_runtime,
+          smoke_test: true
         )
 
         output = response.output.to_s.strip

data/lib/agent_harness/providers/codex.rb

@@ -42,6 +42,62 @@ module AgentHarness
         /failed to refresh token\b.*service(?:\s+(?:is|was))?\s+(?:temporarily\s+)?unavailable/im
       ].freeze
 
+      SHARED_OUTPUT_ERROR_PATTERNS = {
+        quota_exceeded: [
+          /free tier limit reached/i,
+          /please upgrade to a paid plan/i,
+          /quota.*exceeded/i,
+          /insufficient.*quota/i,
+          /billing/i
+        ],
+        rate_limited: [
+          /rate.?limit/i,
+          /too.?many.?requests/i,
+          /\b429\b/
+        ],
+        auth_expired: [
+          /authentication_error/i,
+          /invalid_grant/i,
+          /Token is expired or invalid/i,
+          /unauthorized/i
+        ],
+        sandbox_failure: [
+          /bwrap.*no permissions/i,
+          /no permissions to create a new namespace/i,
+          /unprivileged.*namespace/i
+        ],
+        transient_error: [
+          /timeout/i,
+          /connection.*error/i,
+          /service.*unavailable/i,
+          /\b503\b/,
+          /\b502\b/,
+          /connection.*reset/i
+        ]
+      }.tap { |h| h.each_value(&:freeze) }.freeze
+
+      STDOUT_ERROR_PATTERNS = SHARED_OUTPUT_ERROR_PATTERNS.merge(
+        auth_expired: [
+          /authentication_error/i,
+          /invalid_grant/i,
+          /Token is expired or invalid/i,
+          /unauthorized/i
+        ]
+      ).tap { |h| h.each_value(&:freeze) }.freeze
+
+      STDERR_ERROR_PATTERNS = SHARED_OUTPUT_ERROR_PATTERNS.merge(
+        auth_expired: OAUTH_REFRESH_FAILURE_PATTERNS + [
+          /invalid.*api.*key/i,
+          /unauthorized/i,
+          /authentication_error/i,
+          /invalid_grant/i,
+          /Token is expired or invalid/i,
+          /\b401\b/,
+          /incorrect.*api.*key/i
+        ],
+        transient_error: OAUTH_REFRESH_TRANSIENT_PATTERNS + SHARED_OUTPUT_ERROR_PATTERNS[:transient_error]
+      ).tap { |h| h.each_value(&:freeze) }.freeze
+
       class << self
         def provider_name
           :codex
@@ -51,6 +107,34 @@ module AgentHarness
           "codex"
         end
 
+        # Classify a chunk of output text from the provider CLI in real-time
+        #
+        # Can be called during streaming to classify both stdout and stderr
+        # chunks as they arrive. For stdout, attempts to parse JSONL events
+        # and extract error information from structured output.
+        #
+        # Because CommandExecutor reads arbitrary 4096-byte chunks, a single
+        # JSONL event may be split across consecutive calls. Pass a String
+        # buffer via +stdout_buffer+ that persists across calls so incomplete
+        # trailing lines are re-assembled before parsing.
+        #
+        # @param text [String] the output chunk to classify
+        # @param stream [:stdout, :stderr] which stream the text came from
+        # @param stdout_buffer [String, nil] mutable String accumulator for
+        #   incomplete stdout lines across calls (ignored for stderr)
+        # @return [nil, Hash] nil if no error detected, or a Hash with
+        #   :reason (Symbol)
+        def classify_output_chunk(text, stream:, stdout_buffer: nil)
+          return nil if text.nil? || text.strip.empty?
+
+          case normalize_output_stream(stream)
+          when :stdout
+            classify_stdout_chunk(text, stdout_buffer)
+          when :stderr
+            classify_stderr_chunk(text)
+          end
+        end
+
         def available?
           executor = AgentHarness.configuration.command_executor
           !!executor.which(binary_name)
@@ -168,10 +252,129 @@ module AgentHarness
 
         private
 
+        def classify_stdout_chunk(text, buffer)
+          # Prepend any leftover data from a previous partial chunk.
+          data = buffer ? (buffer.slice!(0..-1) + text) : text
+
+          lines = data.split("\n", -1)
+
+          # If the chunk does not end with a newline the last element is an
+          # incomplete line — stash it in the buffer for the next call.
+          if buffer && !data.end_with?("\n")
+            buffer.replace(lines.pop.to_s)
+          end
+
+          lines.each do |line|
+            stripped = line.strip
+            next if stripped.empty?
+
+            event = parse_stdout_jsonl_event(stripped)
+            next unless event
+
+            result = classify_jsonl_event(event)
+            return result if result
+          end
+
+          nil
+        end
+
+        def classify_stderr_chunk(text)
+          match_patterns(text, STDERR_ERROR_PATTERNS)
+        end
+
+        def normalize_output_stream(stream)
+          normalized_stream = case stream
+          when Symbol
+            stream
+          when String
+            stream.strip.to_sym
+          end
+
+          return normalized_stream if %i[stdout stderr].include?(normalized_stream)
+
+          raise ArgumentError, "Unknown stream: #{stream.inspect}"
+        end
+
+        def parse_stdout_jsonl_event(text)
+          escaped_newline_trimmed = text.sub(/(?:\\r)?\\n\z/, "")
+          candidates = if escaped_newline_trimmed == text
+            [text]
+          else
+            [text, escaped_newline_trimmed]
+          end
+
+          candidates.each do |candidate|
+            return JSON.parse(candidate)
+          rescue JSON::ParserError
+            next
+          end
+
+          # Non-JSON stdout line — skip, only classify explicit error events
+          nil
+        end
+
+        def classify_jsonl_event(event)
+          return nil unless event.is_a?(Hash)
+
+          payload = unwrap_classification_event(event)
+          event = payload if payload.is_a?(Hash)
+
+          # Only classify events with explicit error payloads — not normal
+          # assistant messages whose text happens to contain error-ish words.
+          error_text = extract_jsonl_error_text(event)
+          return nil unless error_text
+
+          match_patterns(error_text, STDOUT_ERROR_PATTERNS)
+        end
+
+        def extract_jsonl_error_text(event)
+          # Direct error field (top-level "error" key)
+          error = event["error"]
+          return error if error.is_a?(String) && !error.empty?
+
+          if error.is_a?(Hash)
+            msg = error["message"]
+            return msg if msg.is_a?(String) && !msg.empty?
+          end
+
+          return nil unless explicit_jsonl_error_event?(event["type"])
+
+          # "message" appears on both error events and normal assistant output.
+          # Restricting message-based extraction to explicit error event types
+          # avoids false positives from user-facing assistant content.
+          message = event["message"]
+          return message if message.is_a?(String) && !message.empty?
+
+          nil
+        end
+
+        def match_patterns(text, pattern_groups)
+          pattern_groups.each do |category, patterns|
+            if patterns.any? { |p| text.match?(p) }
+              return {reason: category}
+            end
+          end
+
+          nil
+        end
+
         def parser_instance
           @parser_instance ||= allocate.freeze
         end
 
+        def unwrap_classification_event(event)
+          case event["type"]
+          when "event_msg", "response_item"
+            event["payload"]
+          else
+            event
+          end
+        end
+
+        def explicit_jsonl_error_event?(event_type)
+          %w[error turn.failed].include?(event_type)
+        end
+
         def tail_nonempty_lines(text, limit:)
           return [] if limit <= 0
 
@@ -317,7 +520,10 @@ module AgentHarness
           ],
           abort: [
             /free tier limit reached/i,
-            /please upgrade to a paid plan/i
+            /please upgrade to a paid plan/i,
+            /bwrap.*no permissions/i,
+            /no permissions to create a new namespace/i,
+            /unprivileged.*namespace/i
           ]
         )
       end
@@ -1017,7 +1223,11 @@ module AgentHarness
             total: total_tokens
           } : nil
         }
-      rescue
+      rescue JSON::ParserError => e
+        AgentHarness.logger&.warn("[AgentHarness::Codex] JSONL parse error: #{e.message}")
+        nil
+      rescue => e
+        AgentHarness.logger&.warn("[AgentHarness::Codex] Unexpected error parsing JSONL output: #{e.class}: #{e.message}")
         nil
       end
 

data/lib/agent_harness/providers/kilocode.rb

@@ -157,6 +157,7 @@ module AgentHarness
 
       def build_command(prompt, options)
         cmd = [self.class.binary_name, "run", "--format", "json"]
+        cmd.concat(test_command_overrides) if options[:smoke_test]
         cmd << prompt
         cmd
       end

data/lib/agent_harness/version.rb

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

metadata

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