agent-harness 0.11.3 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a00dc60851ef15dfa731370add2fb28ac8af98975d61194801afb8a34afc5623
-  data.tar.gz: 3422826728017a83203ab285d0e733b2958dd77bf8832c9c57dc16eead4e2a5d
+  metadata.gz: 5248389a9a7500880e23672e9daad822c4c2038f5424ed2b278ab7c6276cf9a5
+  data.tar.gz: 806895feee0bd65477498453d32de90985849a70476560dabd7f0330995db6a2
 SHA512:
-  metadata.gz: 32065b807ea92963f0694f28517ca0ad17fe860ac73da96d96a1b51090450cad1324f99bd761f28f55b915c0ca14d59731e10166a4ef7f206b2887a5fdfb1a81
-  data.tar.gz: 7d4d571e6b98f2769e05ab637938cc41f7ea2ee1bbe2b73b8a8fed9a6c4d6c1a85aca58cf38578b0f81b983818e3df98251bc1e59f0d14e08d69f486429a8ee1
+  metadata.gz: 48652585f74b61a2a70a4c118a23cb93977dca88e743ec76cd6c12802cb005cc24c703f25b0994a8b5d423f59114be93c8ab040f957191ac782d6260f6d5ffde
+  data.tar.gz: f37ece29dc1dbd311713abd42aeb99363f7bf41ede1e31185fea16c41a312ace62d8247fb3e6034a38ac519797c131000480832921376141a2fe88bbc2b6e822

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.11.3"
+  ".": "0.13.0"
 }

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
 
+## [0.13.0](https://github.com/viamin/agent-harness/compare/agent-harness/v0.12.0...agent-harness/v0.13.0) (2026-05-03)
+
+
+### Features
+
+* Expose public parse_container_output method on provider interface ([#187](https://github.com/viamin/agent-harness/issues/187)) ([ecdb7ba](https://github.com/viamin/agent-harness/commit/ecdb7bac56e47cf75e1379508cca64a9c7a0ffff))
+
+## [0.12.0](https://github.com/viamin/agent-harness/compare/agent-harness/v0.11.3...agent-harness/v0.12.0) (2026-05-01)
+
+
+### Features
+
+* streaming JSONL event parser for real-time Codex progress tracking ([#184](https://github.com/viamin/agent-harness/issues/184)) ([4905539](https://github.com/viamin/agent-harness/commit/490553992904f39e52028b2140ab99755aad1fb1))
+
 ## [0.11.3](https://github.com/viamin/agent-harness/compare/agent-harness/v0.11.2...agent-harness/v0.11.3) (2026-04-28)
 
 

data/lib/agent_harness/providers/aider.rb

@@ -263,6 +263,33 @@ module AgentHarness
         cleanup_llm_history_file!(llm_history_path)
       end
 
+      # Parse raw container output into a Response.
+      #
+      # Overrides the base implementation to support the
+      # +llm_history_path+ option for token usage extraction from
+      # Aider's LLM history file.
+      #
+      # @param stdout [String] captured standard output
+      # @param stderr [String] captured standard error
+      # @param exit_code [Integer] process exit code
+      # @param duration [Float] execution duration in seconds
+      # @param options [Hash] additional options
+      # @option options [String, nil] :llm_history_path path to LLM history file
+      # @return [Response] parsed response
+      def parse_container_output(stdout:, stderr: "", exit_code: 0, duration: 0.0, **options)
+        result = CommandExecutor::Result.new(
+          stdout: stdout,
+          stderr: stderr,
+          exit_code: exit_code,
+          duration: duration
+        )
+        parse_response(
+          result,
+          duration: duration,
+          llm_history_path: options[:llm_history_path]
+        )
+      end
+
       protected
 
       def build_command(prompt, options)

data/lib/agent_harness/providers/base.rb

@@ -265,6 +265,29 @@ module AgentHarness
         handle_error(e, prompt: (last_msg&.dig(:content) || last_msg&.dig("content")).to_s, options: options)
       end
 
+      # Parse raw container output into a Response.
+      #
+      # This is the public interface for parsing CLI output captured from
+      # external execution (e.g. Docker containers) without going through
+      # send_message. It accepts the same data a CommandExecutor::Result
+      # holds and returns an AgentHarness::Response.
+      #
+      # @param stdout [String] captured standard output
+      # @param stderr [String] captured standard error
+      # @param exit_code [Integer] process exit code
+      # @param duration [Float] execution duration in seconds
+      # @param options [Hash] additional provider-specific options
+      # @return [Response] parsed response
+      def parse_container_output(stdout:, stderr: "", exit_code: 0, duration: 0.0, **options)
+        result = CommandExecutor::Result.new(
+          stdout: stdout,
+          stderr: stderr,
+          exit_code: exit_code,
+          duration: duration
+        )
+        parse_response(result, duration: duration)
+      end
+
       # Provider name for display
       #
       # @return [String] display name

data/lib/agent_harness/providers/codex.rb

@@ -11,6 +11,11 @@ module AgentHarness
       include RateLimitResetParsing
       include McpConfigFileSupport
 
+      StreamingEvent = Struct.new(
+        :type, :turn, :tokens, :error_message, :tool_name, :raw_event,
+        keyword_init: true
+      )
+
       SUPPORTED_CLI_VERSION = "0.116.0"
       SUPPORTED_CLI_REQUIREMENT = Gem::Requirement.new(">= #{SUPPORTED_CLI_VERSION}", "< 0.117.0").freeze
       OAUTH_REFRESH_FAILURE_PATTERNS = [
@@ -142,15 +147,31 @@ module AgentHarness
         end
 
         def parse_cli_jsonl_transcript(raw_output, max_events: nil)
-          return new.send(:parse_jsonl_output, "") if max_events && max_events <= 0
+          return parser_instance.send(:parse_jsonl_output, "") if max_events && max_events <= 0
 
           output = max_events ? tail_nonempty_lines(raw_output, limit: max_events).join("\n") : raw_output
 
-          new.send(:parse_jsonl_output, output)
+          parser_instance.send(:parse_jsonl_output, output)
+        end
+
+        # Parse a single Codex JSONL event as it arrives on stdout and classify it
+        # for real-time progress tracking. Returns nil for malformed JSON, scalar
+        # JSON values, plain-text output, or unsupported event types.
+        def parse_streaming_event(line)
+          event = JSON.parse(line.to_s)
+          return unless event.is_a?(Hash)
+
+          parser_instance.send(:build_streaming_event, event)
+        rescue JSON::ParserError, TypeError
+          nil
         end
 
         private
 
+        def parser_instance
+          @parser_instance ||= allocate.freeze
+        end
+
         def tail_nonempty_lines(text, limit:)
           return [] if limit <= 0
 
@@ -507,6 +528,152 @@ module AgentHarness
 
       private
 
+      def build_streaming_event(event)
+        raw_event, payload, dispatch_type = unwrap_streaming_event(event)
+        return unless payload.is_a?(Hash)
+
+        case dispatch_type
+        when "message.delta", "agent_message_delta"
+          build_progress_streaming_event(raw_event, payload)
+        when "turn.completed", "task_complete", "turn_complete"
+          build_turn_complete_streaming_event(raw_event, payload)
+        when "turn.failed"
+          build_error_streaming_event(raw_event, payload)
+        when "item.completed", "response_item", "agent_message"
+          build_item_streaming_event(raw_event, payload)
+        when "token_count"
+          build_token_usage_streaming_event(raw_event, payload)
+        end
+      end
+
+      def unwrap_streaming_event(event)
+        event_type = event["type"]
+
+        if event_type == "event_msg"
+          payload = event["payload"]
+          [event, payload, payload.is_a?(Hash) ? payload["type"] : nil]
+        elsif event_type == "response_item"
+          # Preserve the original "response_item" dispatch type so
+          # build_streaming_event routes to build_item_streaming_event
+          # even after unwrapping the inner payload.
+          [event, event["payload"], "response_item"]
+        else
+          [event, event, event_type]
+        end
+      end
+
+      def build_progress_streaming_event(raw_event, payload)
+        return unless progress_payload?(payload)
+
+        StreamingEvent.new(
+          type: :progress,
+          turn: extract_streaming_turn(payload),
+          raw_event: raw_event
+        )
+      end
+
+      def build_turn_complete_streaming_event(raw_event, payload)
+        StreamingEvent.new(
+          type: :turn_complete,
+          turn: extract_streaming_turn(payload),
+          tokens: compact_streaming_tokens(build_token_usage(payload["usage"])),
+          raw_event: raw_event
+        )
+      end
+
+      def build_error_streaming_event(raw_event, payload)
+        StreamingEvent.new(
+          type: :error,
+          turn: extract_streaming_turn(payload),
+          tokens: compact_streaming_tokens(build_token_usage(payload["usage"])),
+          error_message: extract_error_message(payload),
+          raw_event: raw_event
+        )
+      end
+
+      def build_item_streaming_event(raw_event, payload)
+        item = payload["item"].is_a?(Hash) ? payload["item"] : payload
+
+        if tool_use_payload?(item)
+          return StreamingEvent.new(
+            type: :tool_use,
+            turn: extract_streaming_turn(payload),
+            tool_name: extract_tool_name(item),
+            raw_event: raw_event
+          )
+        end
+
+        return unless assistant_message_item?(item) || response_item_assistant_payload?(item) || wrapped_assistant_payload?(item)
+
+        StreamingEvent.new(
+          type: :progress,
+          turn: extract_streaming_turn(payload),
+          raw_event: raw_event
+        )
+      end
+
+      def build_token_usage_streaming_event(raw_event, payload)
+        wrapped_token_usage = extract_wrapped_tokens(payload["info"])
+        usage = wrapped_token_usage&.fetch(:last, nil) || wrapped_token_usage&.fetch(:total, nil)
+        return unless usage
+
+        StreamingEvent.new(
+          type: :token_usage,
+          turn: extract_streaming_turn(payload),
+          tokens: compact_streaming_tokens(usage),
+          raw_event: raw_event
+        )
+      end
+
+      def progress_payload?(payload)
+        case payload["type"]
+        when "message.delta"
+          payload["delta"].is_a?(Hash)
+        when "agent_message_delta"
+          wrapped_assistant_payload?(payload)
+        else
+          false
+        end
+      end
+
+      def tool_use_payload?(item)
+        item.is_a?(Hash) && item["type"] == "tool_call"
+      end
+
+      def extract_tool_name(item)
+        item["tool_name"] || item["name"] || item.dig("function", "name") || item.dig("call", "name")
+      end
+
+      def extract_streaming_turn(payload)
+        value = payload["turn"] || payload["turn_id"] || payload["turn_index"] || payload.dig("context", "turn")
+        return value if value.is_a?(Integer)
+
+        value.to_i if value.is_a?(String) && /\A\d+\z/.match?(value.strip)
+      end
+
+      def compact_streaming_tokens(usage)
+        return unless usage
+
+        {
+          input: usage[:input],
+          output: usage[:output],
+          total: usage[:total]
+        }
+      end
+
+      def extract_error_message(payload)
+        error = payload["error"]
+
+        case error
+        when String
+          error
+        when Hash
+          error["message"] || error["error"] || error["detail"]
+        else
+          payload["message"]
+        end
+      end
+
       def escape_toml_string(val)
         val.to_s.gsub("\\") { "\\\\" }.gsub('"') { "\\\"" }.gsub("\n") { "\\n" }
       end

data/lib/agent_harness/providers/github_copilot.rb

@@ -345,6 +345,33 @@ module AgentHarness
         handle_error(e, prompt: prompt, options: options)
       end
 
+      # Parse raw container output into a Response.
+      #
+      # Overrides the base implementation to support the
+      # +json_output_requested+ option, which controls whether JSONL
+      # output is parsed for token extraction.
+      #
+      # @param stdout [String] captured standard output
+      # @param stderr [String] captured standard error
+      # @param exit_code [Integer] process exit code
+      # @param duration [Float] execution duration in seconds
+      # @param options [Hash] additional options
+      # @option options [Boolean] :json_output_requested whether to parse JSONL output
+      # @return [Response] parsed response
+      def parse_container_output(stdout:, stderr: "", exit_code: 0, duration: 0.0, **options)
+        result = CommandExecutor::Result.new(
+          stdout: stdout,
+          stderr: stderr,
+          exit_code: exit_code,
+          duration: duration
+        )
+        parse_response(
+          result,
+          duration: duration,
+          json_output_requested: options.fetch(:json_output_requested, false)
+        )
+      end
+
       protected
 
       def build_command(prompt, options)

data/lib/agent_harness/version.rb

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

metadata

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