active_harness 0.3.6 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 347d7944af01b44bda7568ac47fc335fd58a48320f80ae71c4a52b83458a710f
-  data.tar.gz: 13343b28d031fd4dd86b4114a7d4c3f7b7223db6402b3c1f2bf9e135073e3bc3
+  metadata.gz: 5c6df0d88c07312b2546e83f5e69c58d5b3628e4ff31b0885e10a72d032a5a5e
+  data.tar.gz: f2427084db1992f1c0cdcd44c7fe6518cfaa0d348f1d3720ce9fcf78e40783c2
 SHA512:
-  metadata.gz: 3eb2200ec4c40e7ecf626d9cff3c5f56917b07dbf5756fa54d986d327ce740b18b95b5806f4e9924674a010196c76bbb11f9c66fbe9f54256ac0cfce4c901a7c
-  data.tar.gz: 8c1c186d855e6ef3ee0e8961665904da7175cf7018c0e4e352eb2b6a15bcd42f2d019963cb996d0bb8407f8eeb9eda98bac13b8def11fd2c43b382a8dce8d8f5
+  metadata.gz: 39575f2575e8dd5d1dc90a512f1d550512d90b57d37d182c10055901c5f15f6bb4a7d425c5a362acacf0be248c237707d0e1362d71d912b2eb449340c20a9ef9
+  data.tar.gz: 41f8adbbb47d9a0e2a17505f470b8a77ffac7f275eb530ee87f3a5f60c3eaa707a6f2610f16f63fc1a73872d75cb02cfad81a0251dd831b685d02fce0f5bad85

data/lib/active_harness/configuration.rb

@@ -105,6 +105,12 @@ module ActiveHarness
     attr_accessor :vercel_api_key
     attr_accessor :vercel_api_url
 
+    # -------------------------------------------------------------------------
+    # Cohere (native v2 Chat API)
+    # -------------------------------------------------------------------------
+    attr_accessor :cohere_api_key
+    attr_accessor :cohere_api_url
+
     # -------------------------------------------------------------------------
     # TypeSafe — direct Jev (System One) API; also any Jev-compatible server
     # -------------------------------------------------------------------------
@@ -210,6 +216,9 @@ module ActiveHarness
       @vercel_api_key = ENV["VERCEL_API_KEY"]
       @vercel_api_url = "https://ai-gateway.vercel.sh/typesafe/v1/systemone"
 
+      @cohere_api_key = ENV["COHERE_API_KEY"]
+      @cohere_api_url = "https://api.cohere.com/v2/chat"
+
       @typesafe_api_key = ENV["TYPESAFE_API_KEY"]
       @typesafe_api_url = "https://api.typesafe.ai/v1/systemone"
 

data/lib/active_harness/http/client.rb

@@ -4,26 +4,82 @@ module ActiveHarness
   module Http
     # Thin Net::HTTP wrapper — no external dependencies.
     class Client
-      # @param url     [URI]
+      METHODS = {
+        get:    Net::HTTP::Get,
+        post:   Net::HTTP::Post,
+        put:    Net::HTTP::Put,
+        patch:  Net::HTTP::Patch,
+        delete: Net::HTTP::Delete
+      }.freeze
+
+      # @param method  [Symbol]   :get, :post, :put, :patch or :delete
+      # @param url     [URI]      https (default) or http — TLS follows the URL scheme
       # @param headers [Hash{String => String}]
-      # @param body    [String]   JSON-serialized body
+      # @param body    [String, nil] request body (usually JSON-serialized); omit for GET/DELETE
       # @param timeout [Integer]  seconds (open + read)
-      # @return        [String]   raw response body
+      # @return        [String]   raw response body; also responds to #http_status
+      #                           (Integer) so providers can classify errors by
+      #                           status without changing the return type
+      def request(method, url, headers: {}, body: nil, timeout: 30)
+        klass = METHODS[method.to_sym] or raise ArgumentError, "Unsupported HTTP method: #{method.inspect}"
+
+        begin
+          res = build_http(url, timeout).request(build_request(klass, url, headers, body))
+        rescue Net::OpenTimeout, Net::ReadTimeout
+          raise Errors::TimeoutError, "Request to #{url.host} timed out"
+        rescue => e
+          raise Errors::ProviderUnavailableError, "#{url.host} unreachable: #{e.message}"
+        end
+
+        with_http_status(res)
+      end
+
       def post(url, headers:, body:, timeout: 30)
+        request(:post, url, headers: headers, body: body, timeout: timeout)
+      end
+
+      def get(url, headers: {}, timeout: 30)
+        request(:get, url, headers: headers, timeout: timeout)
+      end
+
+      def put(url, headers:, body:, timeout: 30)
+        request(:put, url, headers: headers, body: body, timeout: timeout)
+      end
+
+      def patch(url, headers:, body:, timeout: 30)
+        request(:patch, url, headers: headers, body: body, timeout: timeout)
+      end
+
+      def delete(url, headers: {}, timeout: 30)
+        request(:delete, url, headers: headers, timeout: timeout)
+      end
+
+      private
+
+      def build_http(url, timeout)
         http              = Net::HTTP.new(url.host, url.port)
-        http.use_ssl      = true
+        http.use_ssl      = url.scheme == "https"
         http.open_timeout = timeout
         http.read_timeout = timeout
+        http
+      end
 
-        req = Net::HTTP::Post.new(url)
+      def build_request(klass, url, headers, body)
+        req = klass.new(url)
         headers.each { |k, v| req[k] = v }
-        req.body = body
+        req.body = body if body
+        req
+      end
+
+      # Returns the response body with an #http_status accessor attached.
+      def with_http_status(res)
+        body = res.body
+        return body if body.nil?
 
-        http.request(req).body
-      rescue Net::OpenTimeout, Net::ReadTimeout
-        raise Errors::TimeoutError, "Request to #{url.host} timed out"
-      rescue => e
-        raise Errors::ProviderUnavailableError, "#{url.host} unreachable: #{e.message}"
+        body   = body.dup
+        status = res.code.to_i
+        body.define_singleton_method(:http_status) { status }
+        body
       end
     end
   end

data/lib/active_harness/http/streaming_client.rb

@@ -18,7 +18,7 @@ module ActiveHarness
       # @return [Hash]  { content: String, usage: Hash|nil }
       def post(url, headers:, body:, timeout: 60, on_token:, parse_chunk: nil)
         http              = Net::HTTP.new(url.host, url.port)
-        http.use_ssl      = true
+        http.use_ssl      = url.scheme == "https"
         http.open_timeout = timeout
         http.read_timeout = timeout
 
@@ -31,6 +31,10 @@ module ActiveHarness
         usage   = {}
 
         http.request(req) do |response|
+          # Non-2xx: the body is a plain JSON error, not SSE — read it whole and
+          # raise instead of silently returning an empty stream.
+          raise_for_status!(response.code.to_i, response.read_body) unless response.is_a?(Net::HTTPSuccess)
+
           response.read_body do |chunk|
             buffer += chunk
             while (line_end = buffer.index("\n"))
@@ -55,12 +59,40 @@ module ActiveHarness
         { content: content, usage: usage.empty? ? nil : usage }
       rescue Net::OpenTimeout, Net::ReadTimeout
         raise Errors::TimeoutError, "Request to #{url.host} timed out"
+      rescue Errors::ProviderError
+        raise
       rescue => e
         raise Errors::ProviderUnavailableError, "#{url.host} unreachable: #{e.message}"
       end
 
       private
 
+      # Maps an HTTP error status + body to the same error classes the
+      # non-streaming providers raise. The message is pulled from the common
+      # error shapes ({error:{message}}, {message}, {detail}), else the raw body.
+      def raise_for_status!(status, body)
+        msg  = error_message(body)
+        code = status.to_s
+
+        case status
+        when 401, 403 then raise Errors::InvalidApiKeyError.new(msg,       error_code: code)
+        when 429      then raise Errors::RateLimitError.new(msg,           error_code: code)
+        when 503      then raise Errors::ProviderUnavailableError.new(msg, error_code: code)
+        when 500..599 then raise Errors::ServerError.new(msg,              error_code: code)
+        else               raise Errors::InvalidRequestError.new(msg,      error_code: code)
+        end
+      end
+
+      def error_message(body)
+        data = JSON.parse(body.to_s)
+        msg  = data.dig("error", "message") if data["error"].is_a?(Hash)
+        msg ||= data["error"] if data["error"].is_a?(String)
+        msg ||= data["message"] || data["detail"]
+        (msg.is_a?(String) ? msg : data.to_json)
+      rescue JSON::ParserError, NoMethodError, TypeError
+        body.to_s.strip.empty? ? "HTTP error with empty body" : body.to_s.strip[0, 500]
+      end
+
       def default_chunk(parsed)
         token = parsed.dig("choices", 0, "delta", "content")
         raw_u = parsed["usage"]

data/lib/active_harness/providers/cohere.rb

@@ -0,0 +1,101 @@
+require "uri"
+
+module ActiveHarness
+  module Providers
+    # Cohere — native v2 Chat API (not OpenAI-compatible).
+    # https://docs.cohere.com/reference/chat
+    #
+    # Text chat only: tools, citations, documents, rerank and embeddings are not
+    # supported. Thinking blocks returned by reasoning models are discarded —
+    # only `text` blocks make it into the result.
+    #
+    # Example:
+    #   model do
+    #     use provider: :cohere, model: "command-a-03-2025"
+    #   end
+    class Cohere < Base
+      def call(model:, messages:, temperature: 0.7, stream: nil)
+        headers = { "Content-Type" => "application/json", "Authorization" => "Bearer #{api_key}" }
+        body    = { model: model, messages: messages, temperature: temperature }
+
+        return call_streaming(url: config.cohere_api_url, headers: headers, body: body, stream: stream, provider: :cohere, model: model) if stream
+
+        raw  = post_json(URI(config.cohere_api_url), headers: headers, body: body)
+        data = parse!(raw)
+        handle_error!(data, status: raw.respond_to?(:http_status) ? raw.http_status : nil)
+
+        {
+          content:  extract_text(data),
+          provider: :cohere,
+          model:    model,
+          usage:    extract_usage_cohere(data["usage"])
+        }
+      end
+
+      private
+
+      def api_key
+        key = config.cohere_api_key.to_s
+        raise Errors::InvalidApiKeyError, "cohere_api_key is not configured" if key.empty?
+        key
+      end
+
+      # message.content is an array of typed blocks ({type: "text"|"thinking", ...});
+      # keep only the text.
+      def extract_text(data)
+        Array(data.dig("message", "content"))
+          .select { |block| block["type"] == "text" }
+          .map { |block| block["text"].to_s }
+          .join
+          .strip
+      end
+
+      # `tokens` is what the model processed, `billed_units` what Cohere charges
+      # for (it does not bill its own preamble). Prefer `tokens`, like ruby_llm.
+      def extract_usage_cohere(usage)
+        return nil unless usage
+
+        tokens = usage["tokens"] || {}
+        billed = usage["billed_units"] || {}
+        input  = (tokens["input_tokens"]  || billed["input_tokens"]).to_i
+        output = (tokens["output_tokens"] || billed["output_tokens"]).to_i
+        { input_tokens: input, output_tokens: output, total_tokens: input + output }
+      end
+
+      # Cohere errors are flat: { "message": "..." } (validation errors may add
+      # an "id"). Success bodies have no "message" string, only a message Hash.
+      def handle_error!(data, status: nil)
+        return unless data["message"].is_a?(String)
+        return if status && status < 400
+
+        msg  = data["message"]
+        code = status ? status.to_s : nil
+        meta = data["id"] ? { id: data["id"] } : nil
+
+        case status
+        when 401, 403 then raise Errors::InvalidApiKeyError.new(msg,       error_code: code, metadata: meta)
+        when 429      then raise Errors::RateLimitError.new(msg,           error_code: code, metadata: meta)
+        when 503      then raise Errors::ProviderUnavailableError.new(msg, error_code: code, metadata: meta)
+        when 500..599 then raise Errors::ServerError.new(msg,              error_code: code, metadata: meta)
+        else               raise Errors::InvalidRequestError.new(msg,      error_code: code, metadata: meta)
+        end
+      end
+
+      # Cohere streaming takes a plain `stream: true` — no stream_options.
+      def prepare_streaming_body(body)
+        body.merge(stream: true)
+      end
+
+      # Cohere SSE events:
+      #   content-delta → delta.message.content.text (or .thinking, ignored)
+      #   message-end   → delta.usage with token counts
+      def build_streaming_chunk(parsed)
+        token = parsed.dig("delta", "message", "content", "text") if parsed["type"] == "content-delta"
+        usage = extract_usage_cohere(parsed.dig("delta", "usage")) if parsed["type"] == "message-end"
+        usage = usage&.reject { |k, _| k == :total_tokens }
+
+        { token: token, usage: usage }
+      end
+    end
+  end
+end

data/lib/active_harness/providers/vercel.rb

@@ -60,7 +60,7 @@ module ActiveHarness
 
         raw  = post_json(URI(endpoint_url), headers: headers, body: body)
         data = parse!(raw)
-        handle_error!(data)
+        handle_error!(data, status: raw.respond_to?(:http_status) ? raw.http_status : nil)
 
         {
           content:  JSON.pretty_generate(data["answers"]),
@@ -114,15 +114,27 @@ module ActiveHarness
         end
       end
 
+      # Prefer the HTTP status when we have it; fall back to sniffing the
+      # message only when we don't (e.g. a custom HTTP client without #http_status).
+      def detail_error_type(msg, status)
+        case status
+        when 401, 403 then "unauthorized"
+        when 429      then "rate_limit"
+        when 500..599 then "server_error"
+        when nil      then msg =~ /api key|unauthori|authenticat|invalid token|credentials/i ? "unauthorized" : "invalid_request"
+        else               "invalid_request"
+        end
+      end
+
       # Error shapes seen in practice:
       # - TypeSafe direct API: { "detail": ... } (see detail_message)
       # - TypeSafe request-validation errors: { "message": "...", "error_type": "..." }
       # - AI Gateway account/billing errors (OpenAI-style, nested): { "error": { "message": "...", "type": "..." } }
-      def handle_error!(data)
+      def handle_error!(data, status: nil)
         msg, type =
           if data.key?("detail")
             msg = detail_message(data["detail"])
-            [msg, msg =~ /api key|unauthori|authenticat|invalid token|credentials/i ? "unauthorized" : "invalid_request"]
+            [msg, detail_error_type(msg, status)]
           elsif data["message"] && data["error_type"]
             [data["message"].to_s, data["error_type"].to_s]
           elsif data["error"].is_a?(Hash)
@@ -134,6 +146,7 @@ module ActiveHarness
         when "invalid_request"                then raise Errors::InvalidRequestError.new(msg, error_code: type)
         when "unauthorized", "authentication_error" then raise Errors::InvalidApiKeyError.new(msg, error_code: type)
         when "rate_limit", "rate_limit_error" then raise Errors::RateLimitError.new(msg, error_code: type)
+        when "server_error"                   then raise Errors::ServerError.new(msg, error_code: type)
         when "customer_verification_required" then raise Errors::InvalidApiKeyError.new(msg, error_code: type)
         else                                        raise Errors::ProviderError.new(msg, error_code: type)
         end

data/lib/active_harness/request/providers.rb

@@ -37,6 +37,7 @@ module ActiveHarness
       vertexai:    -> { Providers::VertexAI.new },
       custom:      -> { Providers::Custom.new },
       vercel:      -> { Providers::Vercel.new },
+      cohere:      -> { Providers::Cohere.new },
       typesafe:    -> { Providers::TypeSafe.new },
       ollama_cloud: -> { Providers::OllamaCloud.new },
       hetzner:     -> { Providers::Hetzner.new }

data/lib/active_harness.rb

@@ -23,6 +23,7 @@ require_relative "active_harness/providers/vertexai"
 require_relative "active_harness/providers/custom"
 require_relative "active_harness/providers/vercel"
 require_relative "active_harness/providers/typesafe"
+require_relative "active_harness/providers/cohere"
 require_relative "active_harness/providers/ollama_cloud"
 require_relative "active_harness/providers/hetzner"
 require_relative "active_harness/providers/images/openai"
@@ -40,7 +41,7 @@ require_relative "active_harness/pipeline"
 require_relative "active_harness/railtie" if defined?(Rails::Railtie)
 
 module ActiveHarness
-  VERSION = "0.3.6"
+  VERSION = "0.3.8"
 
   class << self
     # Configure ActiveHarness.

data/lib/generators/active_harness/install/templates/initializers/active_harness.rb

@@ -81,6 +81,12 @@ ActiveHarness.configure do |config|
   # config.azure_ai_auth_token = ENV["AZURE_AI_AUTH_TOKEN"]  # OAuth bearer (alternative)
   # config.azure_api_version   = "2024-05-01-preview"
 
+  # ---------------------------------------------------------------------------
+  # Cohere (native v2 Chat API)
+  # ---------------------------------------------------------------------------
+  # config.cohere_api_key = ENV["COHERE_API_KEY"]
+  # config.cohere_api_url = "https://api.cohere.com/v2/chat"
+
   # ---------------------------------------------------------------------------
   # TypeSafe — Jev (System One) evaluation model, direct API
   # ---------------------------------------------------------------------------

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.8
 platform: ruby
 authors:
 - the-teacher
@@ -70,6 +70,7 @@ files:
 - lib/active_harness/providers/azure.rb
 - lib/active_harness/providers/base.rb
 - lib/active_harness/providers/bedrock.rb
+- lib/active_harness/providers/cohere.rb
 - lib/active_harness/providers/custom.rb
 - lib/active_harness/providers/deepseek.rb
 - lib/active_harness/providers/gemini.rb