agent-harness 0.39.0 → 0.41.0

data/lib/agent_harness/api/ruby_llm_chat_adapter.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "json"
+require "ruby_llm"
+
+module AgentHarness
+  module Api
+    # Translates the normalized public chat values to RubyLLM public objects.
+    class RubyLlmChatAdapter
+      class UnsupportedOptionError < StandardError; end
+      class MissingCredentialError < StandardError; end
+
+      PROVIDER_CONFIG = {
+        anthropic: %i[anthropic_api_key anthropic_api_base],
+        openai: %i[openai_api_key openai_api_base]
+      }.freeze
+      OPENAI_UNSUPPLIED_CONFIG = %i[openai_organization_id openai_project_id openai_use_system_role].freeze
+
+      def call(candidate:, messages:, tools:, max_output_tokens:, temperature:, stream:, timeout:, cancellation:, &on_event)
+        context = build_context(candidate, timeout)
+        chat = context.chat(model: candidate[:model], provider: candidate[:provider], protocol: ruby_llm_protocol(candidate),
+          assume_model_exists: true)
+        configure_chat(chat, candidate, messages, tools, max_output_tokens, temperature)
+        response = generate(chat, stream, cancellation, &on_event)
+        emit_completed_tool_calls(response, &on_event) if stream
+        normalize_response(response)
+      end
+
+      # RubyLLM keys streamed tool-call chunks by a stream index while
+      # continuation chunks carry no call id, so correlation state must live
+      # between chunks. Also remembers the latest cumulative token counts so
+      # duplicate cumulative reports are not re-emitted.
+      class StreamState
+        attr_accessor :input_tokens, :output_tokens
+
+        def initialize
+          @provider_id_by_key = {}
+          @started_ids = {}
+          @latest_provider_id = nil
+          @input_tokens = nil
+          @output_tokens = nil
+        end
+
+        # Links a stream chunk key to its provider call id, returning true
+        # only the first time +provider_id+ is seen.
+        def start(stream_key, provider_id)
+          @provider_id_by_key[stream_key] = provider_id unless stream_key.nil?
+          @latest_provider_id = provider_id
+          return false if @started_ids.key?(provider_id)
+
+          @started_ids[provider_id] = true
+        end
+
+        def provider_id(stream_key)
+          stream_key.nil? ? @latest_provider_id : @provider_id_by_key[stream_key]
+        end
+
+        def usage
+          total = (input_tokens + output_tokens) if input_tokens && output_tokens
+          {input_tokens: input_tokens, output_tokens: output_tokens, total_tokens: total}
+        end
+      end
+
+      private
+
+      def ruby_llm_protocol(candidate)
+        return :anthropic if candidate[:provider].to_sym == :anthropic && candidate[:protocol].to_sym == :messages
+
+        candidate[:protocol]
+      end
+
+      def build_context(candidate, timeout)
+        provider = candidate[:provider].to_sym
+        config_keys = PROVIDER_CONFIG[provider]
+        raise RubyLLM::ConfigurationError, "Unsupported chat provider: #{provider}" unless config_keys
+        raise MissingCredentialError, "API key is required" if candidate.dig(:credentials, :api_key).to_s.empty?
+
+        RubyLLM.context do |config|
+          config.public_send("#{config_keys[0]}=", candidate.dig(:credentials, :api_key))
+          config.public_send("#{config_keys[1]}=", candidate[:endpoint])
+          clear_unsupplied_openai_config(config) if provider == :openai
+          config.max_retries = 0
+          apply_timeout(config, timeout)
+        end
+      end
+
+      def clear_unsupplied_openai_config(config)
+        OPENAI_UNSUPPLIED_CONFIG.each { |key| config.public_send("#{key}=", nil) }
+      end
+
+      def apply_timeout(config, timeout)
+        if timeout&.dig(:connect_seconds)
+          raise UnsupportedOptionError, "RubyLLM does not support request-local connect timeouts"
+        end
+
+        seconds = timeout&.dig(:read_seconds)
+        config.request_timeout = seconds if seconds
+      end
+
+      def configure_chat(chat, candidate, messages, tools, max_output_tokens, temperature)
+        chat.messages = normalize_messages(messages)
+        chat.with_tools(tools.map { |tool| normalized_tool(tool) }) unless tools.empty?
+        chat.with_headers(candidate[:headers] || {})
+        chat.with_max_output_tokens(max_output_tokens) if max_output_tokens
+        chat.with_temperature(temperature) unless temperature.nil?
+      end
+
+      def generate(chat, stream, cancellation)
+        return generate_without_events(chat, cancellation) unless stream
+
+        state = StreamState.new
+        chat.generate do |chunk|
+          if cancelled?(cancellation)
+            chat.cancel
+            raise RubyLLM::CancelledError
+          end
+
+          stream_events(chunk, state).each { |event| yield event }
+        end
+      end
+
+      def generate_without_events(chat, cancellation)
+        raise RubyLLM::CancelledError if cancelled?(cancellation)
+
+        chat.generate
+      end
+
+      def cancelled?(token)
+        return false unless token
+
+        token.respond_to?(:cancelled?) ? token.cancelled? : token.call
+      end
+
+      def normalize_messages(messages)
+        stable_to_provider = tool_id_map(messages)
+        messages.map do |message|
+          role = message.fetch(:role).to_sym
+          normalized = {role: role, content: text_content(message[:content])}
+          normalized[:tool_calls] = normalize_input_tool_calls(message[:tool_calls]) if message[:tool_calls]
+          normalized[:tool_call_id] = stable_to_provider.fetch(message[:tool_call_id], message[:tool_call_id]) if role == :tool
+          normalized
+        end
+      end
+
+      def tool_id_map(messages)
+        messages.each_with_object({}) do |message, ids|
+          Array(message[:tool_calls]).each do |call|
+            ids[call[:id]] = call[:provider_id] || call[:id]
+          end
+        end
+      end
+
+      def normalize_input_tool_calls(tool_calls)
+        Array(tool_calls).to_h do |call|
+          provider_id = call[:provider_id] || call[:id]
+          arguments = JSON.parse(call.fetch(:arguments_json, "{}"))
+          [provider_id, {id: provider_id, name: call[:name], arguments: arguments}]
+        end
+      end
+
+      def text_content(content)
+        return content if content.is_a?(String) || content.nil?
+
+        Array(content).map do |part|
+          unless part[:type]&.to_sym == :text
+            raise UnsupportedOptionError, "unsupported content type: #{part[:type]}"
+          end
+
+          part[:text].to_s
+        end.join
+      end
+
+      def normalized_tool(tool)
+        definition = tool.transform_keys(&:to_sym)
+        name = definition.fetch(:name).to_s
+        Class.new(RubyLLM::Tool).tap do |klass|
+          klass.define_singleton_method(:tool_name) { name }
+          klass.description(definition[:description].to_s)
+          klass.parameters(definition[:input_schema] || definition[:parameters] || {type: "object", properties: {}})
+          klass.define_method(:execute) { |**| raise "AgentHarness transports never execute tools" }
+        end.new
+      end
+
+      def stream_events(chunk, state)
+        [text_event(chunk), *tool_call_events(chunk, state), usage_event(chunk, state)].compact
+      end
+
+      def text_event(chunk)
+        {type: :text_delta, content: chunk.content} unless chunk.content.nil? || chunk.content.empty?
+      end
+
+      def tool_call_events(chunk, state)
+        return [] unless chunk.tool_calls
+
+        chunk.tool_calls.flat_map { |stream_key, call| call_events(stream_key, call, state) }
+      end
+
+      # Continuation chunks have a nil id and carry the provider's raw JSON
+      # fragment as arguments; they join the call that started their key.
+      def call_events(stream_key, call, state)
+        provider_id = call.id || state.provider_id(stream_key)
+        return [] unless provider_id
+
+        events = []
+        if state.start(stream_key, provider_id)
+          events << {type: :tool_call_started, provider_id: provider_id, name: call.name}
+        end
+        fragment = argument_fragment(call.arguments)
+        events << {type: :tool_call_delta, provider_id: provider_id, arguments_json: fragment} if fragment
+        events
+      end
+
+      # Deltas stay appendable JSON text; a start chunk may instead carry a
+      # complete parsed Hash, which becomes JSON once.
+      def argument_fragment(arguments)
+        case arguments
+        when String then arguments.empty? ? nil : arguments
+        when Hash then arguments.empty? ? nil : JSON.generate(arguments)
+        end
+      end
+
+      def usage_event(chunk, state)
+        return unless cumulative_usage_changed?(chunk, state)
+
+        {type: :usage_updated, **state.usage}
+      end
+
+      def cumulative_usage_changed?(chunk, state)
+        tokens = chunk.tokens
+        return false unless tokens
+
+        changed = false
+        if tokens.input && tokens.input != state.input_tokens
+          state.input_tokens = tokens.input
+          changed = true
+        end
+        if tokens.output && tokens.output != state.output_tokens
+          state.output_tokens = tokens.output
+          changed = true
+        end
+        changed
+      end
+
+      def emit_completed_tool_calls(response)
+        Array(response.tool_calls&.values).each do |call|
+          yield(type: :tool_call_completed, **normalize_tool_call(call))
+        end
+      end
+
+      def normalize_response(response)
+        {
+          content: response.content || "",
+          model: response.model,
+          finish_reason: response.finish_reason,
+          usage: normalize_usage(response.tokens),
+          tool_calls: Array(response.tool_calls&.values).map { |call| normalize_tool_call(call) }
+        }
+      end
+
+      def normalize_tool_call(call)
+        {provider_id: call.id, name: call.name, arguments_json: JSON.generate(call.arguments || {})}
+      end
+
+      def normalize_usage(tokens)
+        input = tokens&.input
+        output = tokens&.output
+        return unless input || output
+
+        {input_tokens: input, output_tokens: output, total_tokens: (input && output) ? input + output : nil}
+      end
+    end
+  end
+end

data/lib/agent_harness/embedding_adapter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/net_http"
+require "json"
+
+module AgentHarness
+  # Builds a request-local Faraday adapter for headers and cancellation.
+  module EmbeddingAdapter
+    module_function
+
+    def build(headers:, cancellation: nil)
+      Class.new(Faraday::Adapter::NetHttp) do
+        define_method(:call) do |env|
+          raise CancelledError, "Embedding request cancelled" if cancellation&.call
+
+          env.request_headers.update(headers)
+          super(env).on_complete { |response| EmbeddingAdapter.order_rows(response) }
+        end
+      end
+    end
+
+    def order_rows(response)
+      payload = JSON.parse(response.body)
+      rows = payload["data"]
+      return unless rows.is_a?(Array)
+
+      indices = rows.map { |row| row["index"] if row.is_a?(Hash) }
+      unless indices.all?(Integer) && indices.sort == (0...rows.length).to_a
+        raise MalformedEmbeddingError, "Provider returned invalid embedding indices"
+      end
+
+      payload["data"] = rows.sort_by { |row| row.fetch("index") }
+      response.body = JSON.generate(payload)
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/agent_harness/embedding_result.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module AgentHarness
+  # Normalized result returned by AgentHarness.embed.
+  class EmbeddingResult
+    attr_reader :vectors, :model, :usage, :attempts
+
+    def initialize(vectors:, model:, input_tokens: nil, attempts: [])
+      @vectors = vectors
+      @model = model
+      @usage = {input_tokens: input_tokens}.freeze
+      @attempts = attempts.freeze
+    end
+
+    # Batch usage is never guessed or divided among individual vectors.
+    def per_vector_usage
+      nil
+    end
+  end
+end

data/lib/agent_harness/embeddings.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require "securerandom"
+require "time"
+
+module AgentHarness
+  # Provider-neutral embedding execution backed by RubyLLM.
+  class Embeddings
+    DEFAULT_TIMEOUT = 300
+    DEFAULT_MAX_ATTEMPTS = 3
+    RETRY_BASE_DELAY = 0.25
+    RETRY_MAX_DELAY = 2.0
+    CANCELLATION_POLL_INTERVAL = 0.05
+    TRANSIENT_ERRORS = [RateLimitError, TimeoutError].freeze
+
+    def initialize(model:, credentials:, endpoint: nil, headers: {}, timeout: DEFAULT_TIMEOUT,
+      max_attempts: DEFAULT_MAX_ATTEMPTS, cancellation: nil, observer: nil, request_id: nil)
+      @model = model
+      @api_key = credential(credentials, :api_key)
+      @endpoint = endpoint
+      @headers = headers.to_h.transform_keys(&:to_s).freeze
+      @timeout = timeout
+      @max_attempts = max_attempts
+      @cancellation = cancellation
+      @observer = observer
+      @request_id = request_id || SecureRandom.uuid
+      validate!
+    end
+
+    def call(inputs:, dimensions: nil)
+      inputs = Array(inputs)
+      return EmbeddingResult.new(vectors: [], model: @model) if inputs.empty?
+
+      execute(inputs, dimensions)
+    end
+
+    private
+
+    def execute(inputs, dimensions)
+      attempts = []
+
+      1.upto(@max_attempts) do |number|
+        check_cancellation!
+        result = attempt(inputs, dimensions, number, attempts)
+        return result
+      rescue RateLimitError, TimeoutError, ProviderError => e
+        raise unless retryable?(e) && number < @max_attempts
+
+        wait_before_retry(e, number)
+      end
+    end
+
+    def attempt(inputs, dimensions, number, attempts)
+      started_at = Time.now.utc
+      embedding = request_embedding(inputs, dimensions)
+      validate_result!(embedding.vectors, inputs.length)
+      report = success_report(embedding, number, started_at)
+    rescue CancelledError => e
+      record_attempt(attempts, failure_report(e, number, started_at, :cancelled, :cancelled))
+      raise
+    rescue AuthenticationError, AuthorizationError, RateLimitError, TimeoutError, ProviderError => e
+      record_attempt(attempts, failure_report(e, number, started_at, *error_classification(e)))
+      raise
+    rescue NoMethodError, TypeError => e
+      error = MalformedEmbeddingError.new("Malformed embedding response", original_error: e)
+      record_attempt(attempts, failure_report(error, number, started_at, *error_classification(error)))
+      raise error
+    else
+      record_attempt(attempts, report)
+      EmbeddingResult.new(
+        vectors: embedding.vectors, model: embedding.model,
+        input_tokens: embedding.tokens.input, attempts: attempts
+      )
+    end
+
+    def request_embedding(inputs, dimensions)
+      context.embed(
+        inputs,
+        model: @model,
+        provider: :openai,
+        assume_model_exists: true,
+        dimensions: dimensions
+      )
+    rescue RubyLLM::UnauthorizedError => e
+      raise AuthenticationError.new(e.message, provider: :openai, original_error: e)
+    rescue RubyLLM::ForbiddenError => e
+      raise AuthorizationError.new(e.message, provider: :openai, original_error: e)
+    rescue RubyLLM::RateLimitError => e
+      raise RateLimitError.new(e.message, provider: :openai, reset_time: retry_after(e), original_error: e)
+    rescue Faraday::TimeoutError, Timeout::Error => e
+      raise TimeoutError.new(e.message, original_error: e)
+    rescue Faraday::ConnectionFailed => e
+      raise connection_error(e)
+    rescue RubyLLM::ServerError, RubyLLM::ServiceUnavailableError, RubyLLM::OverloadedError => e
+      raise ProviderError.new(e.message, original_error: e)
+    rescue Faraday::ParsingError, NoMethodError, TypeError => e
+      raise MalformedEmbeddingError.new("Malformed embedding response", original_error: e)
+    rescue RubyLLM::Error => e
+      raise ProviderError.new(e.message, original_error: e)
+    end
+
+    def context
+      RubyLLM.context do |config|
+        config.openai_api_key = @api_key
+        config.openai_api_base = @endpoint if @endpoint
+        config.request_timeout = @timeout
+        config.max_retries = 0
+        config.retry_interval_randomness = 0
+        config.faraday_adapter = EmbeddingAdapter.build(headers: @headers, cancellation: @cancellation)
+      end
+    end
+
+    def success_report(embedding, number, started_at)
+      attempt_report(number, started_at).merge(
+        status: :succeeded,
+        model: embedding.model,
+        usage: usage(embedding.tokens.input),
+        provider_reported: !embedding.tokens.input.nil?,
+        error: nil
+      ).freeze
+    end
+
+    def failure_report(error, number, started_at, category, code)
+      attempt_report(number, started_at).merge(
+        status: (category == :cancelled) ? :cancelled : :failed,
+        usage: usage(nil),
+        provider_reported: false,
+        error: {category: category, code: code}.freeze
+      ).freeze
+    end
+
+    def attempt_report(number, started_at)
+      {
+        attempt_id: "attempt_#{SecureRandom.uuid}", request_id: @request_id,
+        number: number, provider: :openai, model: @model,
+        started_at: started_at.iso8601(6), finished_at: Time.now.utc.iso8601(6),
+        cost: nil, provider_request_id: nil
+      }
+    end
+
+    def usage(input_tokens)
+      {input_tokens: input_tokens, output_tokens: nil, total_tokens: input_tokens}.freeze
+    end
+
+    def record_attempt(attempts, report)
+      attempts << report
+      return unless @observer
+
+      @observer.respond_to?(:on_attempt) ? @observer.on_attempt(report) : @observer.call(report)
+    end
+
+    def error_classification(error)
+      return [error.error_category, error.error_code] if error.is_a?(AuthenticationError) || error.is_a?(AuthorizationError)
+      return [:transient, :rate_limited] if error.is_a?(RateLimitError)
+      return [:transient, :timeout] if error.is_a?(TimeoutError)
+      return transient_provider_classification(error) if transient_provider_error?(error)
+      return [:invalid_response, :malformed_response] if error.is_a?(MalformedEmbeddingError)
+
+      [:unknown, :unclassified_provider_error]
+    end
+
+    def transient_provider_classification(error)
+      original = error.original_error
+      return [:transient, :connection_failed] if original.is_a?(Faraday::ConnectionFailed)
+      return [:transient, :service_unavailable] if original.is_a?(RubyLLM::ServiceUnavailableError)
+      return [:transient, :overloaded] if original.is_a?(RubyLLM::OverloadedError)
+
+      [:transient, :server_error]
+    end
+
+    def retryable?(error)
+      TRANSIENT_ERRORS.any? { |klass| error.is_a?(klass) } || transient_provider_error?(error)
+    end
+
+    def transient_provider_error?(error)
+      original = error.original_error
+      original.is_a?(Faraday::ConnectionFailed) || original.is_a?(RubyLLM::ServerError) ||
+        original.is_a?(RubyLLM::ServiceUnavailableError) || original.is_a?(RubyLLM::OverloadedError)
+    end
+
+    def wait_before_retry(error, attempt_number)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + retry_delay(error, attempt_number)
+      loop do
+        check_cancellation!
+        remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        break unless remaining.positive?
+
+        sleep([remaining, CANCELLATION_POLL_INTERVAL].min)
+      end
+    end
+
+    def retry_delay(error, attempt_number)
+      retry_after_delay = error.reset_time - Time.now if error.is_a?(RateLimitError) && error.reset_time
+      return retry_after_delay if retry_after_delay&.positive?
+
+      [RETRY_BASE_DELAY * (2**(attempt_number - 1)), RETRY_MAX_DELAY].min
+    end
+
+    def check_cancellation!
+      raise CancelledError, "Embedding request cancelled" if @cancellation&.call
+    end
+
+    def validate_result!(vectors, expected_count)
+      valid = vectors.is_a?(Array) && vectors.length == expected_count
+      valid &&= vectors.all? { |vector| valid_vector?(vector) }
+      raise MalformedEmbeddingError, "Provider returned an invalid embedding batch" unless valid
+    end
+
+    def valid_vector?(vector)
+      vector.is_a?(Array) && !vector.empty? && vector.all? { |value| value.is_a?(Numeric) && value.finite? }
+    end
+
+    def credential(credentials, key)
+      return credentials if credentials.is_a?(String)
+
+      credentials&.[](key) || credentials&.[](key.to_s)
+    end
+
+    def validate!
+      raise ArgumentError, "model must be a non-empty string" unless @model.is_a?(String) && !@model.empty?
+      raise ArgumentError, "credentials must include api_key" unless @api_key.is_a?(String) && !@api_key.empty?
+      if @headers.keys.any? { |header| header.casecmp?("authorization") }
+        raise ArgumentError, "headers cannot override Authorization; use credentials"
+      end
+      raise ArgumentError, "timeout must be positive" unless @timeout.is_a?(Numeric) && @timeout.positive?
+      unless @max_attempts.is_a?(Integer) && @max_attempts.positive?
+        raise ArgumentError, "max_attempts must be a positive integer"
+      end
+      unless @request_id.is_a?(String) && !@request_id.empty?
+        raise ArgumentError, "request_id must be a non-empty string"
+      end
+      unless @observer.nil? || @observer.respond_to?(:on_attempt) || @observer.respond_to?(:call)
+        raise ArgumentError, "observer must respond to on_attempt or call"
+      end
+    end
+
+    def retry_after(error)
+      value = error.response&.response_headers&.[]("retry-after")
+      return unless value
+
+      seconds = Float(value, exception: false)
+      seconds ? Time.now + seconds : Time.httpdate(value)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def connection_error(error)
+      wrapped = error.wrapped_exception
+      if wrapped.is_a?(Timeout::Error)
+        TimeoutError.new(error.message, original_error: error)
+      else
+        ProviderError.new(error.message, original_error: error)
+      end
+    end
+  end
+end

data/lib/agent_harness/errors.rb

@@ -15,6 +15,9 @@ module AgentHarness
   # Provider-related errors
   class ProviderError < Error; end
 
+  # Raised when an embedding provider response cannot satisfy the batch contract.
+  class MalformedEmbeddingError < ProviderError; end
+
   class ProviderInstallationError < ProviderError
     attr_reader :provider, :error_category
 
@@ -39,6 +42,9 @@ module AgentHarness
 
   class CommandExecutionError < Error; end
 
+  # Raised when a caller cancels a request before a transport attempt.
+  class CancelledError < Error; end
+
   # Rate limiting and circuit breaker errors
   class RateLimitError < Error
     attr_reader :reset_time, :provider, :error_category
@@ -62,10 +68,24 @@ module AgentHarness
 
   # Authentication errors
   class AuthenticationError < Error
-    attr_reader :provider
+    attr_reader :provider, :error_category, :error_code
 
-    def initialize(message = nil, provider: nil, **kwargs)
+    def initialize(message = nil, provider: nil, error_category: :authentication, error_code: :invalid_credential, **kwargs)
+      @provider = provider
+      @error_category = error_category
+      @error_code = error_code
+      super(message, **kwargs)
+    end
+  end
+
+  # Raised when valid credentials do not grant access to the requested resource.
+  class AuthorizationError < Error
+    attr_reader :provider, :error_category, :error_code
+
+    def initialize(message = nil, provider: nil, error_category: :authorization, error_code: :permission_denied, **kwargs)
       @provider = provider
+      @error_category = error_category
+      @error_code = error_code
       super(message, **kwargs)
     end
   end

data/lib/agent_harness/version.rb

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

data/lib/agent_harness.rb

@@ -87,6 +87,12 @@ module AgentHarness
       conductor.send_message(prompt, provider: provider, executor: executor, **options)
     end
 
+    # Generate embeddings for a batch of strings through a request-local RubyLLM context.
+    # @return [EmbeddingResult] vectors in input order and provider-reported batch usage
+    def embed(inputs:, model:, credentials:, dimensions: nil, **options)
+      Embeddings.new(model: model, credentials: credentials, **options).call(inputs: inputs, dimensions: dimensions)
+    end
+
     # Resolve a canonical extension definition by name or inline object.
     #
     # @param reference [Symbol, String, Extensions::Base]
@@ -456,12 +462,16 @@ require_relative "agent_harness/configuration"
 require_relative "agent_harness/command_executor"
 require_relative "agent_harness/docker_command_executor"
 require_relative "agent_harness/response"
+require_relative "agent_harness/embedding_result"
+require_relative "agent_harness/embedding_adapter"
+require_relative "agent_harness/embeddings"
 require_relative "agent_harness/token_tracker"
 require_relative "agent_harness/token_usage_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/api/chat_transport"
 require_relative "agent_harness/quota_status"
 require_relative "agent_harness/authentication"
 require_relative "agent_harness/provider_health_check"