agent-harness 0.9.0 → 0.11.0

data/lib/agent_harness/providers/base.rb

@@ -181,6 +181,65 @@ module AgentHarness
         handle_error(e, prompt: prompt, options: options)
       end
 
+      # Send a multi-turn chat message via the provider's chat transport.
+      #
+      # Providers that support chat mode can accept either +conversation:+
+      # or +messages:+ as the conversation history payload.
+      #
+      # Structured streaming events are delivered through three channels:
+      # - +on_chat_chunk+ proc (keyword argument)
+      # - +observer+ object responding to +on_chat_chunk+
+      # - block (yield)
+      #
+      # When multiple receivers are provided, all receive every event.
+      #
+      # @param conversation [Array<Hash>, nil] message history
+      # @param messages [Array<Hash>, nil] alias for +conversation+
+      # @param tools [Array<Hash>, nil] tool/function definitions
+      # @param stream [Boolean] whether to stream the response
+      # @param on_chat_chunk [Proc, nil] callback for structured streaming events
+      # @param observer [#on_chat_chunk, nil] observer receiving streaming events
+      # @param options [Hash] additional options
+      # @yield [Hash] streaming chunks when stream: true
+      # @return [Response] the response
+      # @raise [ProviderError] if the provider does not support chat mode
+      def send_chat_message(conversation: nil, messages: nil, tools: nil, stream: false,
+        on_chat_chunk: nil, observer: nil, **options, &on_chunk)
+        unless supports_chat?
+          raise ProviderError, "#{name} does not support chat mode"
+        end
+
+        options = normalize_provider_runtime(options)
+        runtime = options[:provider_runtime]
+        conversation ||= messages
+        raise ArgumentError, "conversation or messages is required" unless conversation
+        tools = runtime.chat_tools if tools.nil? && runtime&.chat_tools
+
+        transport = resolve_chat_transport(options)
+        messages = format_messages_for_transport(conversation, transport)
+        transport_opts = chat_transport_options(runtime, options)
+        transport_opts[:on_chat_chunk] = on_chat_chunk if on_chat_chunk
+        transport_opts[:observer] = observer if observer
+
+        response = transport.chat(
+          messages: messages,
+          tools: tools,
+          stream: stream,
+          **transport_opts,
+          &on_chunk
+        )
+
+        track_tokens(response) if response.tokens
+        log_debug("send_chat_message_complete", duration: response.duration, tokens: response.tokens)
+
+        response
+      rescue ProviderError, AuthenticationError, RateLimitError, TimeoutError
+        raise
+      rescue => e
+        last_msg = conversation&.last || messages&.last
+        handle_error(e, prompt: (last_msg&.dig(:content) || last_msg&.dig("content")).to_s, options: options)
+      end
+
       # Provider name for display
       #
       # @return [String] display name
@@ -466,6 +525,89 @@ module AgentHarness
         end
       end
 
+      def resolve_chat_transport(options)
+        runtime = options[:provider_runtime]
+
+        # When the runtime specifies chat-specific overrides (base_url, api_key),
+        # build a fresh transport instead of reusing the memoized default.
+        if runtime && (runtime.chat_base_url || runtime.chat_api_key)
+          transport = build_runtime_chat_transport(runtime)
+          if transport
+            return transport
+          end
+        end
+
+        transport = chat_transport
+        raise ProviderError, "#{name} chat_transport returned nil" unless transport
+
+        transport
+      end
+
+      # Build a one-off chat transport from ProviderRuntime overrides.
+      #
+      # Subclasses that support chat must override this when the runtime
+      # carries chat_base_url or chat_api_key so those overrides are
+      # actually applied. The base implementation raises to surface the
+      # misconfiguration early rather than silently ignoring the overrides.
+      def build_runtime_chat_transport(_runtime)
+        raise ProviderError,
+          "#{name} does not support chat_base_url/chat_api_key overrides on ProviderRuntime"
+      end
+
+      def format_messages_for_transport(conversation, transport)
+        normalized = conversation.map { |msg| normalize_transport_message(msg) }
+        return normalized unless anthropic_transport?(transport)
+        return normalized unless anthropic_conversion_required?(normalized)
+
+        anthropic = anthropic_conversation(normalized)
+        system_messages = anthropic[:system] ? [{role: "system", content: anthropic[:system]}] : []
+
+        system_messages + anthropic[:messages]
+      end
+
+      def normalize_transport_message(message)
+        message.each_with_object({}) do |(key, value), memo|
+          memo[key.is_a?(String) ? key.to_sym : key] = value
+        end.tap do |normalized|
+          normalized[:role] = normalized[:role].to_s if normalized.key?(:role)
+        end
+      end
+
+      def anthropic_transport?(transport)
+        chat_transport_type == :anthropic || transport.is_a?(TextTransport)
+      end
+
+      def anthropic_conversion_required?(messages)
+        messages.any? do |msg|
+          msg[:role] == "tool" || msg.key?(:tool_calls)
+        end
+      end
+
+      def anthropic_conversation(messages)
+        conversation = Conversation.new
+
+        messages.each do |msg|
+          conversation.add_message(
+            msg.fetch(:role).to_sym,
+            msg[:content],
+            tool_calls: msg[:tool_calls],
+            tool_call_id: msg[:tool_call_id]
+          )
+        end
+
+        conversation.to_anthropic_messages
+      end
+
+      def chat_transport_options(runtime, options)
+        opts = {}
+        max_tok = options[:chat_max_tokens] || options[:max_tokens] || runtime&.chat_max_tokens
+        opts[:max_tokens] = max_tok if max_tok
+        model = runtime&.chat_model || runtime&.model
+        opts[:model] = model if model
+        opts[:temperature] = options[:temperature] if options[:temperature]
+        opts
+      end
+
       def log_debug(action, **context)
         @logger&.debug("[AgentHarness::#{self.class.provider_name}] #{action}: #{context.inspect}")
       end

data/lib/agent_harness/providers/codex.rb

@@ -139,6 +139,28 @@ module AgentHarness
         def smoke_test_contract
           Base::DEFAULT_SMOKE_TEST_CONTRACT
         end
+
+        def parse_cli_jsonl_transcript(raw_output, max_events: nil)
+          return new.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)
+        end
+
+        private
+
+        def tail_nonempty_lines(text, limit:)
+          return [] if limit <= 0
+
+          text.to_s.each_line.each_with_object([]) do |line, lines|
+            stripped = line.strip
+            next if stripped.empty?
+
+            lines.shift if lines.size >= limit
+            lines << stripped
+          end
+        end
       end
 
       def name
@@ -603,10 +625,11 @@ module AgentHarness
           when "turn.completed"
             turn_usage = build_token_usage(event["usage"])
             result = event["result"]
+            result_parts = result.is_a?(String) ? [result] : extract_task_complete_parts(event)
             wrapped_completion_without_new_output =
               pending_turn_usage_source == :wrapped &&
               pending_turn_usage &&
-              !result.is_a?(String) &&
+              result_parts.nil? &&
               (turn_usage.nil? || current_turn_parts.empty? || current_turn_parts.equal?(pending_wrapped_output_parts))
 
             if wrapped_completion_without_new_output
@@ -663,8 +686,8 @@ module AgentHarness
               pending_wrapped_same_turn_finalization = false
             end
 
-            if result.is_a?(String)
-              current_turn_parts = [result]
+            if result_parts
+              current_turn_parts = result_parts
               saw_assistant_output = true
               current_turn_finalized_output = true
             end

data/lib/agent_harness/providers/github_copilot.rb

@@ -2,18 +2,19 @@
 
 require "digest"
 require "json"
+require "pathname"
 
 module AgentHarness
   module Providers
     class GithubCopilot < Base
       include TokenUsageParsing
 
-      PACKAGE_NAME = "@githubnext/github-copilot-cli"
-      SUPPORTED_CLI_VERSION = "0.1.36"
-      SUPPORTED_CLI_REQUIREMENT = Gem::Requirement.new(">= #{SUPPORTED_CLI_VERSION}", "< 0.2.0").freeze
-
       MODEL_PATTERN = /^gpt-[\d.o-]+(?:-turbo)?(?:-mini)?$/i
       JSON_OUTPUT_MIN_VERSION = Gem::Version.new("0.0.422").freeze
+      SUBCOMMAND_CLI_MIN_VERSION = Gem::Version.new("0.1.0").freeze
+      UNSUPPORTED_SUBCOMMAND_CLI_MESSAGE =
+        "github-copilot-cli 0.1.x does not expose a non-interactive send interface; " \
+        "the what-the-shell subcommand is interactive and cannot be used by AgentHarness."
 
       SMOKE_TEST_CONTRACT = {
         prompt: "Reply with exactly OK.",
@@ -34,41 +35,22 @@ module AgentHarness
 
         def available?
           executor = AgentHarness.configuration.command_executor
-          !!executor.which(binary_name)
-        end
-
-        def installation_contract(version: SUPPORTED_CLI_VERSION)
-          version = version.strip if version.respond_to?(:strip)
-          validate_install_version!(version)
-          package_spec = "#{PACKAGE_NAME}@#{version}".freeze
-          install_command_prefix = ["npm", "install", "-g", "--ignore-scripts"].freeze
-          install_command = (install_command_prefix + [package_spec]).freeze
-          version_requirement = SUPPORTED_CLI_REQUIREMENT.requirements
-            .map { |op, ver| "#{op} #{ver}".freeze }
-            .freeze
-
-          contract = {
-            source: {
-              type: :npm,
-              package: PACKAGE_NAME
-            }.freeze,
-            install_command_prefix: install_command_prefix,
-            install_command: install_command,
-            binary_name: binary_name,
-            default_version: SUPPORTED_CLI_VERSION,
-            version: version,
-            version_requirement: version_requirement,
-            supported_version_requirement: SUPPORTED_CLI_REQUIREMENT.to_s
-          }
+          return false unless executor.which(binary_name)
 
-          contract.each_value do |value|
-            value.freeze if value.is_a?(String)
-          end
-          contract.freeze
+          !subcommand_cli_version?(copilot_cli_version(executor: executor))
+        rescue
+          false
         end
 
-        def install_command(version: SUPPORTED_CLI_VERSION)
-          installation_contract(version: version)[:install_command]
+        def installation_contract(version: nil)
+          # The published @githubnext/github-copilot-cli package only has
+          # 0.1.x releases, and those expose an interactive subcommand instead
+          # of the non-interactive -p prompt path AgentHarness uses.
+          nil
+        end
+
+        def install_command(version: nil)
+          installation_contract(version: version)&.fetch(:install_command)
         end
 
         def provider_metadata_overrides
@@ -116,6 +98,10 @@ module AgentHarness
           ]
         end
 
+        def supports_chat?
+          true
+        end
+
         def smoke_test_contract
           SMOKE_TEST_CONTRACT
         end
@@ -134,26 +120,26 @@ module AgentHarness
 
         private
 
-        def validate_install_version!(version)
-          unless version.is_a?(String) && !version.strip.empty?
-            raise ArgumentError,
-              "Unsupported GitHub Copilot CLI version #{version.inspect}; " \
-              "supported versions must satisfy #{SUPPORTED_CLI_REQUIREMENT}"
-          end
+        def copilot_cli_version(executor:)
+          result = executor.execute([binary_name, "--version"], timeout: 5, env: {})
+          extract_version(result)
+        rescue
+          nil
+        end
 
-          parsed_version = begin
-            Gem::Version.new(version)
-          rescue ArgumentError
-            raise ArgumentError,
-              "Unsupported GitHub Copilot CLI version #{version.inspect}; " \
-              "supported versions must satisfy #{SUPPORTED_CLI_REQUIREMENT}"
-          end
+        def subcommand_cli_version?(version)
+          !version.nil? && version >= SUBCOMMAND_CLI_MIN_VERSION
+        end
+
+        def extract_version(result)
+          return nil unless result.success?
 
-          return if SUPPORTED_CLI_REQUIREMENT.satisfied_by?(parsed_version)
+          version_string = [result.stdout, result.stderr].compact.join("\n")[/\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?/]
+          return nil if version_string.nil? || version_string.empty?
 
-          raise ArgumentError,
-            "Unsupported GitHub Copilot CLI version #{version.inspect}; " \
-            "supported versions must satisfy #{SUPPORTED_CLI_REQUIREMENT}"
+          Gem::Version.new(version_string)
+        rescue ArgumentError
+          nil
         end
       end
 
@@ -194,21 +180,59 @@ module AgentHarness
         }
       end
 
-      def dangerous_mode_flags(probe_timeout: nil, env: {})
-        return [] unless supports_json_output_format?(probe_timeout: probe_timeout, env: env)
+      def dangerous_mode_flags(probe_timeout: nil, env: {}, version: nil)
+        version ||= copilot_cli_version(probe_timeout: probe_timeout, env: env)
+        return [] if subcommand_cli_version?(version)
+        return [] unless supports_json_output_format?(version: version)
 
         ["--allow-all"]
       end
 
-      def supports_sessions?
-        true
+      def supports_sessions?(probe_timeout: nil, env: {}, version: nil)
+        legacy_prompt_cli?(version: version, probe_timeout: probe_timeout, env: env)
       end
 
-      def session_flags(session_id)
+      def session_flags(session_id, version: nil, probe_timeout: nil, env: {})
         return [] unless session_id && !session_id.empty?
+        return [] unless legacy_prompt_cli?(version: version, probe_timeout: probe_timeout, env: env)
+
         ["--resume", session_id]
       end
 
+      GITHUB_MODELS_BASE_URL = "https://models.inference.ai.azure.com"
+      CHAT_DEFAULT_MODEL = "gpt-4o"
+      CHAT_MODELS = %w[gpt-4o gpt-4o-mini gpt-4-turbo].freeze
+
+      def supports_chat?
+        true
+      end
+
+      def chat_models
+        CHAT_MODELS
+      end
+
+      def chat_transport
+        @chat_transport ||= OpenAICompatibleTransport.new(
+          base_url: GITHUB_MODELS_BASE_URL,
+          api_key: resolve_chat_api_key,
+          model: CHAT_DEFAULT_MODEL,
+          logger: @logger
+        )
+      end
+
+      def build_runtime_chat_transport(runtime)
+        OpenAICompatibleTransport.new(
+          base_url: runtime.chat_base_url || GITHUB_MODELS_BASE_URL,
+          api_key: runtime.chat_api_key || resolve_chat_api_key,
+          model: runtime.chat_model || runtime.model || CHAT_DEFAULT_MODEL,
+          logger: @logger
+        )
+      end
+
+      def chat_transport_type
+        :openai_compatible
+      end
+
       def auth_type
         :oauth
       end
@@ -221,7 +245,7 @@ module AgentHarness
           output_format: :text,
           sandbox_aware: false,
           uses_subcommand: false,
-          non_interactive_flag: "-p",
+          non_interactive_flag: nil,
           legitimate_exit_codes: [0],
           stderr_is_diagnostic: true,
           parses_rate_limit_reset: false
@@ -324,11 +348,15 @@ module AgentHarness
       protected
 
       def build_command(prompt, options)
-        cmd = [self.class.binary_name, "-p", prompt]
         env = options.fetch(:_command_env) { build_env(options) }
         runtime = options[:provider_runtime]
+        version = copilot_cli_version(probe_timeout: options[:_version_probe_timeout], env: env)
+
+        raise unsupported_subcommand_cli_error if subcommand_cli_version?(version)
 
-        if supports_json_output_format?(probe_timeout: options[:_version_probe_timeout], env: env)
+        cmd = [self.class.binary_name, "-p", prompt]
+
+        if supports_json_output_format?(version: version)
           cmd += ["--output-format", "json"]
         else
           # Silent mode suppresses the model/stats decoration older CLIs print in
@@ -340,11 +368,11 @@ module AgentHarness
         cmd += ["--model", model] if model
         if options[:dangerous_mode] && supports_dangerous_mode?
           cmd += programmatic_tool_approval_flags
-          cmd += dangerous_mode_flags(probe_timeout: options[:_version_probe_timeout], env: env)
+          cmd += dangerous_mode_flags(version: version)
         end
 
         if options[:session] && !options[:session].empty?
-          cmd += session_flags(options[:session])
+          cmd += session_flags(options[:session], version: version)
         end
 
         cmd
@@ -385,9 +413,22 @@ module AgentHarness
         ["--allow-all-tools"]
       end
 
-      def supports_json_output_format?(probe_timeout: nil, env: {})
-        version = copilot_cli_version(probe_timeout: probe_timeout, env: env)
-        !version.nil? && version >= JSON_OUTPUT_MIN_VERSION
+      def supports_json_output_format?(probe_timeout: nil, env: {}, version: nil)
+        version ||= copilot_cli_version(probe_timeout: probe_timeout, env: env)
+        !version.nil? && !subcommand_cli_version?(version) && version >= JSON_OUTPUT_MIN_VERSION
+      end
+
+      def legacy_prompt_cli?(probe_timeout: nil, env: {}, version: nil)
+        version ||= copilot_cli_version(probe_timeout: probe_timeout, env: env)
+        !version.nil? && !subcommand_cli_version?(version)
+      end
+
+      def subcommand_cli_version?(version)
+        self.class.send(:subcommand_cli_version?, version)
+      end
+
+      def unsupported_subcommand_cli_error
+        ProviderError.new(UNSUPPORTED_SUBCOMMAND_CLI_MESSAGE)
       end
 
       def copilot_cli_version(probe_timeout: nil, env: {})
@@ -443,14 +484,7 @@ module AgentHarness
       end
 
       def extract_version(result)
-        return nil unless result.success?
-
-        version_string = [result.stdout, result.stderr].compact.join("\n")[/\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?/]
-        return nil if version_string.nil? || version_string.empty?
-
-        Gem::Version.new(version_string)
-      rescue ArgumentError
-        nil
+        self.class.send(:extract_version, result)
       end
 
       def parse_jsonl_output(output)
@@ -806,6 +840,28 @@ module AgentHarness
       def hash_key_present?(value, key)
         value.is_a?(Hash) && value.key?(key)
       end
+
+      def resolve_chat_api_key
+        key = ENV["GITHUB_TOKEN"] || ENV["GH_TOKEN"] || read_copilot_cli_access_token
+
+        if key.nil? || key.strip.empty?
+          raise AuthenticationError.new(
+            "Chat mode requires a GitHub token. Set GITHUB_TOKEN or GH_TOKEN, or authenticate the Copilot CLI.",
+            provider: :github_copilot
+          )
+        end
+
+        key.strip
+      end
+
+      def read_copilot_cli_access_token
+        path = Pathname.new(File.join(Dir.home, ".copilot-cli-access-token"))
+        return nil unless path.file?
+
+        path.read
+      rescue Errno::ENOENT, Errno::EACCES, IOError
+        nil
+      end
     end
   end
 end