agent-harness 0.7.2 → 0.7.4

data/lib/agent_harness/providers/registry.rb

@@ -486,6 +486,7 @@ module AgentHarness
             uses_subcommand: nil,
             supports_mcp: false,
             supported_mcp_transports: [],
+            supports_token_counting: false,
             supports_sessions: false,
             supports_dangerous_mode: false
           },

data/lib/agent_harness/providers/token_usage_parsing.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module AgentHarness
+  module Providers
+    # Shared token-usage parsing helpers for providers that extract token
+    # counts from JSON/JSONL CLI output.
+    #
+    # Include this module in any provider that needs to inspect usage
+    # payloads (hashes with keys like "input_tokens", "prompt_tokens",
+    # "output_tokens", "completion_tokens" and their camelCase variants).
+    #
+    # Provider-specific behaviour (e.g. where to locate the payload in the
+    # CLI output) stays in the provider class; only the reusable parsing
+    # and comparison logic lives here.
+    module TokenUsageParsing
+      private
+
+      TOKEN_COUNT_KEYS = %w[
+        input_tokens
+        prompt_tokens
+        output_tokens
+        completion_tokens
+        inputTokens
+        promptTokens
+        outputTokens
+        completionTokens
+      ].freeze
+
+      def normalized_model_name(value)
+        return nil unless value.is_a?(String)
+
+        stripped = value.strip
+        stripped.empty? ? nil : stripped
+      end
+
+      def effective_model_name(runtime = nil)
+        normalized_model_name(runtime&.model) || normalized_model_name(@config.model)
+      end
+
+      def nested_hash_value(value, *keys)
+        keys.reduce(value) do |current, key|
+          break nil unless current.is_a?(Hash)
+
+          current[key]
+        end
+      end
+
+      def normalize_token_count(value)
+        count = case value
+        when Integer
+          value
+        when String
+          Integer(value, exception: false)
+        end
+
+        count if count && count >= 0
+      end
+
+      def token_count_for(usage, *keys)
+        keys.each do |key|
+          value = normalize_token_count(usage[key])
+          return value unless value.nil?
+        end
+        nil
+      end
+
+      def select_best_usage_payload(candidates)
+        candidates
+          .select { |usage| usage_with_token_counts?(usage) }
+          .max_by { |usage| [usage_token_field_count(usage), usage_token_total(usage)] }
+      end
+
+      def usage_token_field_count(usage)
+        return 0 unless usage.is_a?(Hash)
+
+        [
+          token_count_for(usage, "input_tokens", "prompt_tokens", "inputTokens", "promptTokens"),
+          token_count_for(usage, "output_tokens", "completion_tokens", "outputTokens", "completionTokens")
+        ].count { |value| !value.nil? }
+      end
+
+      def usage_token_total(usage)
+        return 0 unless usage.is_a?(Hash)
+
+        [
+          token_count_for(usage, "input_tokens", "prompt_tokens", "inputTokens", "promptTokens"),
+          token_count_for(usage, "output_tokens", "completion_tokens", "outputTokens", "completionTokens")
+        ].compact.sum
+      end
+
+      def usage_with_token_counts?(usage)
+        return false unless usage.is_a?(Hash)
+        return false unless TOKEN_COUNT_KEYS.any? { |key| usage.key?(key) }
+        return false if negative_token_count_present?(usage)
+
+        token_count_for(usage, "input_tokens", "prompt_tokens", "inputTokens", "promptTokens") ||
+          token_count_for(usage, "output_tokens", "completion_tokens", "outputTokens", "completionTokens")
+      end
+
+      def negative_token_count_present?(usage)
+        TOKEN_COUNT_KEYS.any? do |key|
+          count = case usage[key]
+          when Integer
+            usage[key]
+          when String
+            Integer(usage[key], exception: false)
+          end
+
+          count && count < 0
+        end
+      end
+
+      def token_count_keys
+        TOKEN_COUNT_KEYS
+      end
+    end
+  end
+end

data/lib/agent_harness/text_transport.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module AgentHarness
+  # Direct HTTP transport for text-only provider interactions.
+  #
+  # Bypasses the CLI entirely by calling the provider's REST API directly.
+  # Currently supports Anthropic's Messages API. This transport is used when
+  # callers declare a task as text-only via +mode: :text+ on +send_message+.
+  #
+  # The transport preserves the same Response structure, token tracking,
+  # and error classification semantics as the CLI path so that callers
+  # do not need to distinguish between transport modes after the call.
+  #
+  # @example
+  #   transport = AgentHarness::TextTransport.new(api_key: "sk-ant-...")
+  #   response = transport.send_message("Summarize this PR", model: "claude-sonnet-4-20250514")
+  class TextTransport
+    ANTHROPIC_API_URL = "https://api.anthropic.com/v1/messages"
+    ANTHROPIC_API_VERSION = "2023-06-01"
+    DEFAULT_MODEL = "claude-sonnet-4-20250514"
+    DEFAULT_MAX_TOKENS = 4096
+    DEFAULT_TIMEOUT = 300
+
+    # @param api_key [String] Anthropic API key
+    # @param logger [Logger, nil] optional logger
+    def initialize(api_key:, logger: nil)
+      @api_key = api_key
+      @logger = logger
+    end
+
+    # Send a text-only message via the Anthropic Messages API.
+    #
+    # @param prompt [String] the user prompt
+    # @param model [String, nil] model to use (defaults to DEFAULT_MODEL)
+    # @param timeout [Integer, nil] request timeout in seconds
+    # @param max_tokens [Integer, nil] maximum tokens in the response
+    # @return [Response] the response
+    # @raise [AuthenticationError] on 401 responses
+    # @raise [RateLimitError] on 429 responses
+    # @raise [TimeoutError] on network timeouts
+    # @raise [ProviderError] on other HTTP errors
+    def send_message(prompt, model: nil, timeout: nil, max_tokens: nil)
+      model ||= DEFAULT_MODEL
+      timeout ||= DEFAULT_TIMEOUT
+      max_tokens ||= DEFAULT_MAX_TOKENS
+
+      uri = URI(ANTHROPIC_API_URL)
+      body = {
+        model: model,
+        max_tokens: max_tokens,
+        messages: [{role: "user", content: prompt}]
+      }
+
+      start_time = Time.now
+      http_response = make_request(uri, body, timeout: timeout)
+      duration = Time.now - start_time
+
+      parse_response(http_response, duration: duration, model: model)
+    end
+
+    private
+
+    def make_request(uri, body, timeout:)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.open_timeout = [timeout, 30].min
+      http.read_timeout = timeout
+
+      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)
+
+      @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 parse_response(http_response, duration:, model:)
+      status_code = http_response.code.to_i
+
+      unless status_code == 200
+        handle_error_response(http_response, status_code)
+      end
+
+      body = JSON.parse(http_response.body)
+      output = extract_text_content(body)
+      tokens = extract_tokens(body)
+
+      Response.new(
+        output: output,
+        exit_code: 0,
+        duration: duration,
+        provider: :claude,
+        model: body["model"] || model,
+        tokens: tokens,
+        metadata: {transport: :http}
+      )
+    rescue JSON::ParserError => e
+      raise ProviderError.new(
+        "Invalid JSON in API response: #{e.message}",
+        original_error: e
+      )
+    end
+
+    def extract_text_content(body)
+      content = body["content"]
+      return "" unless content.is_a?(Array)
+
+      content
+        .select { |block| block["type"] == "text" }
+        .map { |block| block["text"] }
+        .join
+    end
+
+    def extract_tokens(body)
+      usage = body["usage"]
+      return nil unless usage
+
+      input = usage["input_tokens"] || 0
+      output = usage["output_tokens"] || 0
+
+      {input: input, output: output, total: input + output}
+    end
+
+    def handle_error_response(http_response, status_code)
+      message = begin
+        body = JSON.parse(http_response.body)
+        body.dig("error", "message") || body.dig("error", "type") || http_response.body
+      rescue JSON::ParserError
+        http_response.body
+      end
+
+      case status_code
+      when 401
+        raise AuthenticationError.new(
+          "API authentication failed: #{message}",
+          provider: :claude
+        )
+      when 403
+        raise AuthenticationError.new(
+          "API access forbidden: #{message}",
+          provider: :claude
+        )
+      when 429
+        raise RateLimitError.new(
+          "API rate limit exceeded: #{message}",
+          provider: :claude
+        )
+      when 400
+        raise ProviderError.new("Bad request: #{message}")
+      when 500, 502, 503, 529
+        raise ProviderError.new("Server error (#{status_code}): #{message}")
+      else
+        raise ProviderError.new("HTTP #{status_code}: #{message}")
+      end
+    end
+  end
+end

data/lib/agent_harness/version.rb

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

data/lib/agent_harness.rb

@@ -245,6 +245,7 @@ require_relative "agent_harness/docker_command_executor"
 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/authentication"
 require_relative "agent_harness/provider_health_check"
 
@@ -252,6 +253,7 @@ require_relative "agent_harness/provider_health_check"
 require_relative "agent_harness/providers/registry"
 require_relative "agent_harness/providers/adapter"
 require_relative "agent_harness/providers/base"
+require_relative "agent_harness/providers/token_usage_parsing"
 require_relative "agent_harness/providers/anthropic"
 require_relative "agent_harness/providers/aider"
 require_relative "agent_harness/providers/codex"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agent-harness
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.7.4
 platform: ruby
 authors:
 - Bart Agapinan
@@ -127,7 +127,9 @@ files:
 - lib/agent_harness/providers/mistral_vibe.rb
 - lib/agent_harness/providers/opencode.rb
 - lib/agent_harness/providers/registry.rb
+- lib/agent_harness/providers/token_usage_parsing.rb
 - lib/agent_harness/response.rb
+- lib/agent_harness/text_transport.rb
 - lib/agent_harness/token_tracker.rb
 - lib/agent_harness/version.rb
 - release-please-config.json