agent-harness 0.10.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/github_copilot.rb

@@ -2,6 +2,7 @@
 
 require "digest"
 require "json"
+require "pathname"
 
 module AgentHarness
   module Providers
@@ -97,6 +98,10 @@ module AgentHarness
           ]
         end
 
+        def supports_chat?
+          true
+        end
+
         def smoke_test_contract
           SMOKE_TEST_CONTRACT
         end
@@ -194,6 +199,40 @@ module AgentHarness
         ["--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
@@ -801,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

data/lib/agent_harness/text_transport.rb

@@ -25,13 +25,61 @@ module AgentHarness
     DEFAULT_MAX_TOKENS = 4096
     DEFAULT_TIMEOUT = 300
 
+    # @param base_url [String] Anthropic Messages API URL
     # @param api_key [String] Anthropic API key
     # @param logger [Logger, nil] optional logger
-    def initialize(api_key:, logger: nil)
+    def initialize(api_key:, base_url: ANTHROPIC_API_URL, logger: nil)
+      @base_url = base_url
       @api_key = api_key
       @logger = logger
     end
 
+    # Send a multi-turn chat completion request via the Anthropic Messages API.
+    #
+    # @param messages [Array<Hash>] conversation messages with :role and :content
+    # @param tools [Array<Hash>, nil] tool definitions (Anthropic tool format)
+    # @param stream [Boolean] whether to stream the response
+    # @param max_tokens [Integer, nil] maximum tokens in the response
+    # @param temperature [Float, nil] sampling temperature
+    # @yield [Hash] streaming chunks when stream: true
+    # @return [Response] the response
+    def chat(messages:, tools: nil, stream: false, max_tokens: nil, temperature: nil,
+      model: nil, on_chat_chunk: nil, observer: nil, &on_chunk)
+      model ||= DEFAULT_MODEL
+      timeout = DEFAULT_TIMEOUT
+      max_tokens ||= DEFAULT_MAX_TOKENS
+
+      uri = URI(@base_url)
+
+      system_messages = messages.select { |m| m[:role] == "system" || m["role"] == "system" }
+      non_system = messages.reject { |m| m[:role] == "system" || m["role"] == "system" }
+      has_stream_receiver = on_chunk || on_chat_chunk || observer_responds_to?(observer, :on_chat_chunk)
+      request_stream = stream && has_stream_receiver
+
+      body = build_chat_request_body(
+        model: model,
+        max_tokens: max_tokens,
+        messages: non_system,
+        system_messages: system_messages,
+        tools: tools,
+        temperature: temperature,
+        stream: request_stream
+      )
+
+      start_time = Time.now
+
+      if request_stream
+        combined = build_chat_chunk_callback(on_chunk, on_chat_chunk, observer)
+        result = make_streaming_request(uri, body, timeout: timeout, &combined)
+        duration = Time.now - start_time
+        build_streaming_response(result, duration: duration, model: model)
+      else
+        http_response = make_request(uri, body, timeout: timeout)
+        duration = Time.now - start_time
+        parse_response(http_response, duration: duration, model: model)
+      end
+    end
+
     # Send a text-only message via the Anthropic Messages API.
     #
     # @param prompt [String] the user prompt
@@ -48,7 +96,7 @@ module AgentHarness
       timeout ||= DEFAULT_TIMEOUT
       max_tokens ||= DEFAULT_MAX_TOKENS
 
-      uri = URI(ANTHROPIC_API_URL)
+      uri = URI(@base_url)
       body = {
         model: model,
         max_tokens: max_tokens,
@@ -64,25 +112,160 @@ module AgentHarness
 
     private
 
+    def build_chat_request_body(model:, max_tokens:, messages:, system_messages:, tools:, temperature:, stream:)
+      body = {
+        model: model,
+        max_tokens: max_tokens,
+        messages: messages.map { |m| {role: m[:role] || m["role"], content: m[:content] || m["content"]} }
+      }
+      body[:system] = system_messages.map { |m| m[:content] || m["content"] }.join("\n") if system_messages.any?
+      body[:tools] = tools if tools
+      body[:temperature] = temperature if temperature
+      body[:stream] = true if stream
+      body
+    end
+
     def make_request(uri, body, timeout:)
+      http = build_http(uri, timeout: timeout)
+      request = build_post_request(uri, body)
+
+      @logger&.debug("[AgentHarness::TextTransport] POST #{uri} model=#{body[:model]}")
+
+      http.request(request)
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      raise TimeoutError.new(e.message, original_error: e)
+    rescue SocketError, Errno::ECONNREFUSED, Errno::ECONNRESET, IOError => e
+      raise ProviderError.new("HTTP connection error: #{e.message}", original_error: e)
+    end
+
+    def make_streaming_request(uri, body, timeout:, &on_chunk)
+      http = build_http(uri, timeout: timeout)
+      request = build_post_request(uri, body)
+
+      @logger&.debug("[AgentHarness::TextTransport] POST #{uri} model=#{body[:model]} stream=true")
+
+      accumulated = {content: +"", model: nil, usage: nil, tool_calls: []}
+
+      http.request(request) do |http_response|
+        status_code = http_response.code.to_i
+        unless status_code == 200
+          response_body = http_response.read_body
+          handle_error_response_raw(response_body, status_code)
+        end
+
+        parse_sse_stream(http_response, accumulated, &on_chunk)
+      end
+
+      accumulated
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      raise TimeoutError.new(e.message, original_error: e)
+    rescue SocketError, Errno::ECONNREFUSED, Errno::ECONNRESET, IOError => e
+      raise ProviderError.new("HTTP connection error: #{e.message}", original_error: e)
+    end
+
+    def build_http(uri, timeout:)
       http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
+      http.use_ssl = (uri.scheme == "https")
       http.open_timeout = [timeout, 30].min
       http.read_timeout = timeout
+      http
+    end
 
+    def build_post_request(uri, body)
       request = Net::HTTP::Post.new(uri)
       request["Content-Type"] = "application/json"
       request["x-api-key"] = @api_key
       request["anthropic-version"] = ANTHROPIC_API_VERSION
       request.body = JSON.generate(body)
+      request
+    end
 
-      @logger&.debug("[AgentHarness::TextTransport] POST #{uri} model=#{body[:model]}")
+    def parse_sse_stream(http_response, accumulated, &on_chunk)
+      buffer = +""
+      event_name = nil
+      data_lines = []
 
-      http.request(request)
-    rescue Net::OpenTimeout, Net::ReadTimeout => e
-      raise TimeoutError.new(e.message, original_error: e)
-    rescue SocketError, Errno::ECONNREFUSED, Errno::ECONNRESET, IOError => e
-      raise ProviderError.new("HTTP connection error: #{e.message}", original_error: e)
+      http_response.read_body do |chunk|
+        buffer << chunk.delete("\r")
+
+        while (line_end = buffer.index("\n"))
+          line = buffer.slice!(0, line_end + 1).chomp("\n")
+
+          if line.empty?
+            process_sse_event(event_name, data_lines.join("\n"), accumulated, &on_chunk)
+            event_name = nil
+            data_lines = []
+            next
+          end
+
+          if line.start_with?("event:")
+            event_name = line[6..].strip
+          elsif line.start_with?("data:")
+            data_lines << line[5..].lstrip
+          end
+        end
+      end
+
+      process_sse_event(event_name, data_lines.join("\n"), accumulated, &on_chunk) unless data_lines.empty?
+    end
+
+    def process_sse_event(event_name, raw_data, accumulated, &on_chunk)
+      return if raw_data.nil? || raw_data.empty?
+      return if event_name == "ping"
+
+      payload = JSON.parse(raw_data)
+      type = payload["type"] || event_name
+
+      case type
+      when "message_start"
+        message = payload["message"] || {}
+        accumulated[:model] ||= message["model"]
+        merge_usage!(accumulated, message["usage"])
+      when "content_block_start"
+        process_content_block_start(payload, accumulated, &on_chunk)
+      when "content_block_delta"
+        process_content_block_delta(payload, accumulated, &on_chunk)
+      when "content_block_stop"
+        process_content_block_stop(payload, accumulated, &on_chunk)
+      when "message_delta"
+        merge_usage!(accumulated, payload["usage"])
+      when "message_stop"
+        emit_usage_and_done(accumulated, &on_chunk)
+      when "error"
+        message = payload.dig("error", "message") || payload.dig("error", "type") || raw_data
+        raise ProviderError, message
+      end
+    rescue JSON::ParserError => e
+      @logger&.warn("[AgentHarness::TextTransport] Skipping malformed SSE event: #{e.message}")
+    end
+
+    def emit_text_delta(text, accumulated, &on_chunk)
+      return if text.nil? || text.empty?
+
+      accumulated[:content] << text
+      on_chunk.call({type: :text, content: text})
+    end
+
+    def merge_usage!(accumulated, usage)
+      return unless usage
+
+      current = accumulated[:usage] || {input: 0, output: 0, total: 0}
+      current[:input] = usage["input_tokens"] unless usage["input_tokens"].nil?
+      current[:output] = usage["output_tokens"] unless usage["output_tokens"].nil?
+      current[:total] = current[:input].to_i + current[:output].to_i
+      accumulated[:usage] = current
+    end
+
+    def emit_usage_and_done(accumulated, &on_chunk)
+      usage = accumulated[:usage]
+      if usage
+        on_chunk.call({
+          type: :usage,
+          input_tokens: usage[:input],
+          output_tokens: usage[:output]
+        })
+      end
+      on_chunk.call({type: :done})
     end
 
     def parse_response(http_response, duration:, model:)
@@ -95,6 +278,10 @@ module AgentHarness
       body = JSON.parse(http_response.body)
       output = extract_text_content(body)
       tokens = extract_tokens(body)
+      tool_calls = extract_tool_calls(body)
+
+      metadata = {transport: :http}
+      metadata[:tool_calls] = tool_calls if tool_calls
 
       Response.new(
         output: output,
@@ -103,7 +290,7 @@ module AgentHarness
         provider: :claude,
         model: body["model"] || model,
         tokens: tokens,
-        metadata: {transport: :http}
+        metadata: metadata
       )
     rescue JSON::ParserError => e
       raise ProviderError.new(
@@ -112,6 +299,22 @@ module AgentHarness
       )
     end
 
+    def build_streaming_response(accumulated, duration:, model:)
+      tool_calls = accumulated[:tool_calls].compact
+      metadata = {transport: :http, stream: true}
+      metadata[:tool_calls] = tool_calls unless tool_calls.empty?
+
+      Response.new(
+        output: accumulated[:content],
+        exit_code: 0,
+        duration: duration,
+        provider: :claude,
+        model: accumulated[:model] || model,
+        tokens: accumulated[:usage],
+        metadata: metadata
+      )
+    end
+
     def extract_text_content(body)
       content = body["content"]
       return "" unless content.is_a?(Array)
@@ -122,6 +325,23 @@ module AgentHarness
         .join
     end
 
+    def extract_tool_calls(body)
+      content = body["content"]
+      return nil unless content.is_a?(Array)
+
+      tool_calls = content.filter_map do |block|
+        next unless block["type"] == "tool_use"
+
+        {
+          id: block["id"],
+          name: block["name"],
+          arguments: JSON.generate(block["input"] || {})
+        }
+      end
+
+      tool_calls.empty? ? nil : tool_calls
+    end
+
     def extract_tokens(body)
       usage = body["usage"]
       return nil unless usage
@@ -133,11 +353,15 @@ module AgentHarness
     end
 
     def handle_error_response(http_response, status_code)
+      handle_error_response_raw(http_response.body, status_code)
+    end
+
+    def handle_error_response_raw(body_string, status_code)
       message = begin
-        body = JSON.parse(http_response.body)
-        body.dig("error", "message") || body.dig("error", "type") || http_response.body
+        body = JSON.parse(body_string)
+        body.dig("error", "message") || body.dig("error", "type") || body_string
       rescue JSON::ParserError
-        http_response.body
+        body_string
       end
 
       case status_code
@@ -164,5 +388,88 @@ module AgentHarness
         raise ProviderError.new("HTTP #{status_code}: #{message}")
       end
     end
+
+    def build_chat_chunk_callback(on_chunk, on_chat_chunk, observer)
+      proc do |chunk|
+        on_chunk&.call(chunk)
+        on_chat_chunk&.call(chunk)
+        observer.on_chat_chunk(chunk) if observer_responds_to?(observer, :on_chat_chunk)
+      end
+    end
+
+    def process_content_block_start(payload, accumulated, &on_chunk)
+      content_block = payload["content_block"] || {}
+
+      case content_block["type"]
+      when "text"
+        emit_text_delta(content_block["text"], accumulated, &on_chunk)
+      when "tool_use"
+        index = payload["index"] || 0
+        accumulated[:tool_calls][index] = {
+          id: content_block["id"],
+          name: content_block["name"],
+          arguments: +"",
+          structured_input: content_block["input"],
+          saw_delta: false
+        }
+        on_chunk.call({
+          type: :tool_call_start,
+          id: content_block["id"],
+          name: content_block["name"]
+        })
+      end
+    end
+
+    def process_content_block_delta(payload, accumulated, &on_chunk)
+      delta = payload["delta"] || {}
+
+      case delta["type"]
+      when "text_delta"
+        emit_text_delta(delta["text"], accumulated, &on_chunk)
+      when "input_json_delta"
+        index = payload["index"] || 0
+        tool_call = accumulated[:tool_calls][index]
+        return unless tool_call
+
+        partial_json = delta["partial_json"]
+        return if partial_json.nil? || partial_json.empty?
+
+        tool_call[:saw_delta] = true
+        tool_call[:arguments] << partial_json
+        on_chunk.call({
+          type: :tool_call_delta,
+          id: tool_call[:id],
+          arguments: partial_json
+        })
+      end
+    end
+
+    def process_content_block_stop(payload, accumulated, &on_chunk)
+      index = payload["index"] || 0
+      tool_call = accumulated[:tool_calls][index]
+      return unless tool_call
+
+      arguments = finalized_tool_call_arguments(tool_call)
+      tool_call[:arguments] = arguments
+      tool_call.delete(:structured_input)
+      tool_call.delete(:saw_delta)
+
+      on_chunk.call({
+        type: :tool_call_complete,
+        id: tool_call[:id],
+        name: tool_call[:name],
+        arguments: arguments
+      })
+    end
+
+    def finalized_tool_call_arguments(tool_call)
+      return tool_call[:arguments] if tool_call[:saw_delta]
+
+      JSON.generate(tool_call[:structured_input] || {})
+    end
+
+    def observer_responds_to?(observer, method_name)
+      observer&.respond_to?(method_name)
+    end
   end
 end

data/lib/agent_harness/version.rb

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

data/lib/agent_harness.rb

@@ -270,6 +270,8 @@ require_relative "agent_harness/response"
 require_relative "agent_harness/token_tracker"
 require_relative "agent_harness/error_taxonomy"
 require_relative "agent_harness/text_transport"
+require_relative "agent_harness/openai_compatible_transport"
+require_relative "agent_harness/conversation"
 require_relative "agent_harness/authentication"
 require_relative "agent_harness/provider_health_check"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agent-harness
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -102,11 +102,13 @@ files:
 - lib/agent_harness/authentication.rb
 - lib/agent_harness/command_executor.rb
 - lib/agent_harness/configuration.rb
+- lib/agent_harness/conversation.rb
 - lib/agent_harness/docker_command_executor.rb
 - lib/agent_harness/error_taxonomy.rb
 - lib/agent_harness/errors.rb
 - lib/agent_harness/execution_preparation.rb
 - lib/agent_harness/mcp_server.rb
+- lib/agent_harness/openai_compatible_transport.rb
 - lib/agent_harness/orchestration/circuit_breaker.rb
 - lib/agent_harness/orchestration/conductor.rb
 - lib/agent_harness/orchestration/health_monitor.rb