active_harness 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 348fea391f00283a45f57b119081ec4c820559e5df34651f988f3d5c68538d03
-  data.tar.gz: a5be81902bc6ff447ec64e434a08a25bc9ea193f8d89706cc6e3ec1a7514007e
+  metadata.gz: 54990f7712275af0727b75a7518f30f2ecf5ea798fb14548b5872997a6b272bc
+  data.tar.gz: d81370f86507d5c1d42bc12aac01209afb76bed63d2bb5545bb686ef85cb49ad
 SHA512:
-  metadata.gz: 1bd229ceed23615fbb1d59de9d4a8747722eb19849791d9911b218ee474672b6fdf3779f6bb6449af55150b6a8ad99bc5437e106789dc4f85550cc97077c7cca
-  data.tar.gz: 6011181b558cfb445f8479e27dc19af4086daa38c994c2d57d61c66c15228638b8a18dee842524c1e590d855b029235eae80a9929e8385874876972d1aea4bb9
+  metadata.gz: cc8f9d543c65fde9818611d68073b2a7de6285f37c815d81e6730c393103add7aed45ba9c9eaf7e9461ddbcf5062b3bd2e4978b3b690cbb190b0cf8eeff19209
+  data.tar.gz: 73f6e6c7a606e4f36bebf8cdd330534d4a37fd028f5f53fd2133c8a365caa136e62e5044baa54518b9ff8883022a6c4e4af4a01f84ea0d4bb4798c0d9b584d01

data/lib/active_harness/configuration.rb

@@ -105,6 +105,42 @@ 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
+    # -------------------------------------------------------------------------
+    attr_accessor :typesafe_api_key
+    attr_accessor :typesafe_api_url
+
+    # -------------------------------------------------------------------------
+    # Ollama Cloud (hosted — key required)
+    # -------------------------------------------------------------------------
+    attr_accessor :ollama_cloud_api_key
+    attr_accessor :ollama_cloud_api_url
+
+    # -------------------------------------------------------------------------
+    # Hetzner Inference
+    # -------------------------------------------------------------------------
+    attr_accessor :hetzner_api_key
+    attr_accessor :hetzner_api_url
+
+    # -------------------------------------------------------------------------
+    # Deepgram (audio transcription only)
+    # -------------------------------------------------------------------------
+    attr_accessor :deepgram_api_key
+    attr_accessor :deepgram_api_url
+
+    # -------------------------------------------------------------------------
+    # ElevenLabs (audio transcription only)
+    # -------------------------------------------------------------------------
+    attr_accessor :elevenlabs_api_key
+    attr_accessor :elevenlabs_api_url
+
     # -------------------------------------------------------------------------
     # Custom providers
     #
@@ -179,6 +215,24 @@ 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"
+
+      @ollama_cloud_api_key = ENV["OLLAMA_CLOUD_API_KEY"]
+      @ollama_cloud_api_url = "https://ollama.com/v1/chat/completions"
+
+      @hetzner_api_key = ENV["HETZNER_API_KEY"]
+      @hetzner_api_url = "https://inference.hetzner.com/api/v1/chat/completions"
+
+      @deepgram_api_key = ENV["DEEPGRAM_API_KEY"]
+      @deepgram_api_url = "https://api.deepgram.com/v1/listen"
+
+      @elevenlabs_api_key = ENV["ELEVENLABS_API_KEY"]
+      @elevenlabs_api_url = "https://api.elevenlabs.io/v1/speech-to-text"
     end
   end
 end

data/lib/active_harness/http/client.rb

@@ -8,7 +8,9 @@ module ActiveHarness
       # @param headers [Hash{String => String}]
       # @param body    [String]   JSON-serialized body
       # @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 post(url, headers:, body:, timeout: 30)
         http              = Net::HTTP.new(url.host, url.port)
         http.use_ssl      = true
@@ -19,7 +21,14 @@ module ActiveHarness
         headers.each { |k, v| req[k] = v }
         req.body = body
 
-        http.request(req).body
+        res  = http.request(req)
+        body = res.body
+        return body if body.nil?
+
+        body = body.dup
+        status = res.code.to_i
+        body.define_singleton_method(:http_status) { status }
+        body
       rescue Net::OpenTimeout, Net::ReadTimeout
         raise Errors::TimeoutError, "Request to #{url.host} timed out"
       rescue => e

data/lib/active_harness/providers/audio/deepgram.rb

@@ -0,0 +1,81 @@
+require "uri"
+
+module ActiveHarness
+  module Providers
+    module Audio
+      class Deepgram < Base
+        CONTENT_TYPES = {
+          "mp3"  => "audio/mpeg",
+          "mp4"  => "audio/mp4",
+          "m4a"  => "audio/mp4",
+          "wav"  => "audio/wav",
+          "flac" => "audio/flac",
+          "ogg"  => "audio/ogg",
+          "opus" => "audio/ogg",
+          "webm" => "audio/webm",
+          "aac"  => "audio/aac"
+        }.freeze
+
+        # @param model        [String]  e.g. "nova-3", "nova-2"
+        # @param audio_data   [String]  raw binary audio bytes
+        # @param audio_format [String]  one of CONTENT_TYPES.keys
+        # @param language     [String]  BCP-47 code, e.g. "en" (optional)
+        #
+        # Synchronous pre-recorded transcription: the audio bytes are the raw
+        # request body (no multipart, no base64), options go in the query string.
+        # Deepgram bills by audio duration and reports no token usage, so
+        # `usage` is always nil.
+        def call(model:, audio_data:, audio_format:, language: nil, **_)
+          content_type = CONTENT_TYPES[audio_format]
+          unless content_type
+            raise Errors::InvalidRequestError,
+              "deepgram transcription does not support .#{audio_format} — use one of: #{CONTENT_TYPES.keys.join(', ')}"
+          end
+
+          query = { "model" => model, "smart_format" => "true" }
+          query["language"] = language if language
+
+          url = URI(config.deepgram_api_url)
+          url.query = URI.encode_www_form(query)
+
+          headers = { "Content-Type" => content_type, "Authorization" => "Token #{api_key}" }
+
+          raw  = HTTP.post(url, headers: headers, body: audio_data, timeout: 90)
+          data = parse!(raw)
+          handle_error!(data)
+
+          text = data.dig("results", "channels", 0, "alternatives", 0, "transcript")
+          raise Errors::ProviderError, "No transcription text in response: #{data.keys}" if text.nil?
+
+          { content: text, provider: :deepgram, model: model, usage: nil }
+        end
+
+        private
+
+        def api_key
+          key = config.deepgram_api_key.to_s
+          raise Errors::InvalidApiKeyError, "deepgram_api_key is not configured" if key.empty?
+          key
+        end
+
+        # Deepgram errors look like { "err_code": "INVALID_AUTH", "err_msg": "..." }.
+        def handle_error!(data)
+          return unless data["err_code"] || data["err_msg"]
+
+          msg  = data["err_msg"].to_s
+          code = data["err_code"].to_s
+          meta = data["request_id"] ? { request_id: data["request_id"] } : nil
+
+          case code
+          when "INVALID_AUTH", "INSUFFICIENT_PERMISSIONS"
+            raise Errors::InvalidApiKeyError.new(msg, error_code: code, metadata: meta)
+          when "TOO_MANY_REQUESTS", "RATE_LIMIT"
+            raise Errors::RateLimitError.new(msg,     error_code: code, metadata: meta)
+          else
+            raise Errors::InvalidRequestError.new(msg, error_code: code, metadata: meta)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_harness/providers/audio/elevenlabs.rb

@@ -0,0 +1,103 @@
+require "uri"
+require "securerandom"
+
+module ActiveHarness
+  module Providers
+    module Audio
+      class ElevenLabs < Base
+        CONTENT_TYPES = {
+          "mp3"  => "audio/mpeg",
+          "mp4"  => "audio/mp4",
+          "m4a"  => "audio/mp4",
+          "wav"  => "audio/wav",
+          "flac" => "audio/flac",
+          "ogg"  => "audio/ogg",
+          "webm" => "audio/webm",
+          "aac"  => "audio/aac"
+        }.freeze
+
+        # @param model        [String]  e.g. "scribe_v1", "scribe_v2"
+        # @param audio_data   [String]  raw binary audio bytes
+        # @param audio_format [String]  one of CONTENT_TYPES.keys
+        # @param language     [String]  ISO-639-1/3 code (optional — auto-detected if omitted)
+        #
+        # Synchronous multipart/form-data request. ElevenLabs reports no token
+        # usage for speech-to-text, so `usage` is always nil.
+        def call(model:, audio_data:, audio_format:, language: nil, **_)
+          content_type = CONTENT_TYPES[audio_format]
+          unless content_type
+            raise Errors::InvalidRequestError,
+              "elevenlabs transcription does not support .#{audio_format} — use one of: #{CONTENT_TYPES.keys.join(', ')}"
+          end
+
+          boundary = SecureRandom.hex(16)
+          fields   = { "model_id" => model }
+          fields["language_code"] = language if language
+
+          headers = {
+            "Content-Type" => "multipart/form-data; boundary=#{boundary}",
+            "xi-api-key"   => api_key
+          }
+          body = build_multipart_body(boundary, fields, audio_data, "audio.#{audio_format}", content_type)
+
+          raw  = HTTP.post(URI(config.elevenlabs_api_url), headers: headers, body: body, timeout: 90)
+          data = parse!(raw)
+          handle_error!(data)
+
+          text = data["text"]
+          raise Errors::ProviderError, "No transcription text in response: #{data.keys}" if text.nil?
+
+          { content: text, provider: :elevenlabs, model: model, usage: nil }
+        end
+
+        private
+
+        def build_multipart_body(boundary, fields, file_data, filename, content_type)
+          body = +""
+          fields.each do |name, value|
+            body << "--#{boundary}\r\n"
+            body << "Content-Disposition: form-data; name=\"#{name}\"\r\n\r\n"
+            body << "#{value}\r\n"
+          end
+
+          body << "--#{boundary}\r\n"
+          body << "Content-Disposition: form-data; name=\"file\"; filename=\"#{filename}\"\r\n"
+          body << "Content-Type: #{content_type}\r\n\r\n"
+          body << file_data
+          body << "\r\n--#{boundary}--\r\n"
+          body
+        end
+
+        def api_key
+          key = config.elevenlabs_api_key.to_s
+          raise Errors::InvalidApiKeyError, "elevenlabs_api_key is not configured" if key.empty?
+          key
+        end
+
+        # Errors are { "detail": { "status": "...", "message": "..." } }, or for
+        # request-validation failures { "detail": [ { "msg": "...", ... } ] }.
+        def handle_error!(data)
+          detail = data["detail"]
+          return unless detail
+
+          if detail.is_a?(Hash)
+            msg  = detail["message"].to_s
+            code = detail["status"].to_s
+          else
+            msg  = Array(detail).map { |d| d.is_a?(Hash) ? d["msg"] : d }.join("; ")
+            code = "validation_error"
+          end
+
+          case code
+          when "invalid_api_key", "unauthorized", "needs_authorization"
+            raise Errors::InvalidApiKeyError.new(msg, error_code: code)
+          when "too_many_concurrent_requests", "rate_limit_exceeded", "system_busy"
+            raise Errors::RateLimitError.new(msg,     error_code: code)
+          else
+            raise Errors::InvalidRequestError.new(msg, error_code: code)
+          end
+        end
+      end
+    end
+  end
+end

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/hetzner.rb

@@ -0,0 +1,69 @@
+require "uri"
+
+module ActiveHarness
+  module Providers
+    # Hetzner Inference — OpenAI-compatible Chat Completions API.
+    # https://inference.hetzner.com
+    #
+    # Hetzner's servers cannot fetch image URLs, so image inputs must be sent
+    # inline (data URIs); plain-text chat is unaffected.
+    #
+    # Example:
+    #   model do
+    #     use provider: :hetzner, model: "meta-llama/Llama-3.3-70B-Instruct"
+    #   end
+    class Hetzner < 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.hetzner_api_url, headers: headers, body: body, stream: stream, provider: :hetzner, model: model) if stream
+
+        raw  = post_json(URI(config.hetzner_api_url), headers: headers, body: body)
+        data = parse!(raw)
+        handle_error!(data)
+
+        {
+          content:  data.dig("choices", 0, "message", "content").to_s.strip,
+          provider: :hetzner,
+          model:    data["model"] || model,
+          usage:    extract_usage_openai(data)
+        }
+      end
+
+      private
+
+      def api_key
+        key = config.hetzner_api_key.to_s
+        raise Errors::InvalidApiKeyError, "hetzner_api_key is not configured" if key.empty?
+        key
+      end
+
+      def handle_error!(data)
+        return unless data["error"]
+
+        err      = data["error"]
+        msg      = err.is_a?(Hash) ? err["message"].to_s : err.to_s
+        code     = err.is_a?(Hash) ? err["code"].to_s : ""
+        type     = err.is_a?(Hash) ? err["type"].to_s : ""
+        metadata = err.is_a?(Hash) ? err.reject { |k, _| %w[message code type].include?(k) } : {}
+        metadata = nil if metadata.empty?
+
+        case code
+        when "401", "invalid_api_key", "unauthorized"
+          raise Errors::InvalidApiKeyError.new(msg,       error_code: code, metadata: metadata)
+        when "429", "rate_limit_exceeded"
+          raise Errors::RateLimitError.new(msg,           error_code: code, metadata: metadata)
+        when "500", "502", "503", "504"
+          raise Errors::ProviderUnavailableError.new(msg, error_code: code, metadata: metadata)
+        else
+          if type == "server_error"
+            raise Errors::ServerError.new(msg,            error_code: code, metadata: metadata)
+          else
+            raise Errors::InvalidRequestError.new(msg,    error_code: code, metadata: metadata)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_harness/providers/ollama_cloud.rb

@@ -0,0 +1,63 @@
+require "uri"
+
+module ActiveHarness
+  module Providers
+    # Ollama Cloud — hosted Ollama models, OpenAI-compatible API (key required).
+    # https://docs.ollama.com/cloud
+    #
+    # For a local Ollama server use provider: :ollama instead.
+    #
+    # Example:
+    #   model do
+    #     use provider: :ollama_cloud, model: "gpt-oss:120b"
+    #   end
+    class OllamaCloud < 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.ollama_cloud_api_url, headers: headers, body: body, stream: stream, provider: :ollama_cloud, model: model) if stream
+
+        raw  = post_json(URI(config.ollama_cloud_api_url), headers: headers, body: body)
+        data = parse!(raw)
+        handle_error!(data)
+
+        {
+          content:  data.dig("choices", 0, "message", "content").to_s.strip,
+          provider: :ollama_cloud,
+          model:    data["model"] || model,
+          usage:    extract_usage_openai(data)
+        }
+      end
+
+      private
+
+      def api_key
+        key = config.ollama_cloud_api_key.to_s
+        raise Errors::InvalidApiKeyError, "ollama_cloud_api_key is not configured" if key.empty?
+        key
+      end
+
+      def handle_error!(data)
+        return unless data["error"]
+
+        err      = data["error"]
+        msg      = err.is_a?(Hash) ? err["message"].to_s : err.to_s
+        code     = err.is_a?(Hash) ? err["code"].to_s : ""
+        metadata = err.is_a?(Hash) ? err.reject { |k, _| %w[message code].include?(k) } : {}
+        metadata = nil if metadata.empty?
+
+        case code
+        when "401", "invalid_api_key", "unauthorized"
+          raise Errors::InvalidApiKeyError.new(msg,       error_code: code, metadata: metadata)
+        when "429", "rate_limit_exceeded"
+          raise Errors::RateLimitError.new(msg,           error_code: code, metadata: metadata)
+        when "500", "502", "503", "504"
+          raise Errors::ProviderUnavailableError.new(msg, error_code: code, metadata: metadata)
+        else
+          raise Errors::InvalidRequestError.new(msg,      error_code: code, metadata: metadata)
+        end
+      end
+    end
+  end
+end

data/lib/active_harness/providers/typesafe.rb

@@ -0,0 +1,35 @@
+require "uri"
+
+module ActiveHarness
+  module Providers
+    # TypeSafe — direct access to Jev, TypeSafe's "System One" evaluation model
+    # (https://api.typesafe.ai/v1/systemone). Same request/response contract as
+    # provider: :vercel (which reaches the same model through Vercel AI Gateway),
+    # so `questions:` and everything else in Providers::Vercel apply unchanged.
+    #
+    # Also works with any Jev-compatible server: point `typesafe_api_url` at it.
+    #
+    #   model do
+    #     use provider: :typesafe, model: "jev-latest", questions: {
+    #       urgent: { type: "noul", instructions: "Is this urgent?" }
+    #     }
+    #   end
+    class TypeSafe < Vercel
+      private
+
+      def provider_name
+        :typesafe
+      end
+
+      def endpoint_url
+        config.typesafe_api_url
+      end
+
+      def api_key
+        key = config.typesafe_api_key.to_s
+        raise Errors::InvalidApiKeyError, "typesafe_api_key is not configured" if key.empty?
+        key
+      end
+    end
+  end
+end

data/lib/active_harness/providers/vercel.rb

@@ -44,7 +44,7 @@ module ActiveHarness
       DEFAULT_INSTRUCTIONS = "Evaluate the given state.".freeze
 
       def call(model:, messages:, temperature: nil, stream: nil, questions: nil)
-        raise Errors::InvalidRequestError, "provider: :vercel (Jev) does not support token streaming" if stream
+        raise Errors::InvalidRequestError, "provider: :#{provider_name} (Jev) does not support token streaming" if stream
 
         state = messages.reverse.find { |m| m[:role] == "user" }&.fetch(:content, nil).to_s
 
@@ -58,13 +58,13 @@ module ActiveHarness
           questions: questions || default_questions(messages)
         }
 
-        raw  = post_json(URI(config.vercel_api_url), headers: headers, body: body)
+        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"]),
-          provider: :vercel,
+          provider: provider_name,
           model:    data["model"] || model,
           usage:    extract_usage(data)
         }
@@ -78,6 +78,15 @@ module ActiveHarness
         { answer: { type: "noul", instructions: instructions } }
       end
 
+      # Subclasses (e.g. TypeSafe) reuse everything above and only swap these.
+      def provider_name
+        :vercel
+      end
+
+      def endpoint_url
+        config.vercel_api_url
+      end
+
       def api_key
         key = config.vercel_api_key.to_s
         raise Errors::InvalidApiKeyError, "vercel_api_key is not configured" if key.empty?
@@ -95,12 +104,38 @@ module ActiveHarness
         { input_tokens: input, output_tokens: output, total_tokens: input + output }
       end
 
-      # Two error shapes seen in practice:
+      # TypeSafe's own API reports { "detail": String | { "message": ... } |
+      # [ { "loc": [...], "msg": "..." } ] } (FastAPI-style).
+      def detail_message(detail)
+        case detail
+        when Hash  then detail["message"].to_s
+        when Array then detail.map { |e| e.is_a?(Hash) ? [Array(e["loc"]).join("."), e["msg"]].reject { |x| x.to_s.empty? }.join(": ") : e.to_s }.join("; ")
+        else            detail.to_s
+        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["message"] && data["error_type"]
+          if data.key?("detail")
+            msg = detail_message(data["detail"])
+            [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)
             [data["error"]["message"].to_s, data["error"]["type"].to_s]
@@ -111,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

@@ -36,7 +36,11 @@ module ActiveHarness
       bedrock:     -> { Providers::Bedrock.new },
       vertexai:    -> { Providers::VertexAI.new },
       custom:      -> { Providers::Custom.new },
-      vercel:      -> { Providers::Vercel.new }
+      vercel:      -> { Providers::Vercel.new },
+      cohere:      -> { Providers::Cohere.new },
+      typesafe:    -> { Providers::TypeSafe.new },
+      ollama_cloud: -> { Providers::OllamaCloud.new },
+      hetzner:     -> { Providers::Hetzner.new }
     }.freeze
 
     IMAGE_PROVIDERS = {
@@ -46,7 +50,9 @@ module ActiveHarness
 
     TRANSCRIPTION_PROVIDERS = {
       openai:      -> { Providers::Audio::OpenAI.new },
-      openrouter:  -> { Providers::Audio::OpenRouter.new }
+      openrouter:  -> { Providers::Audio::OpenRouter.new },
+      deepgram:    -> { Providers::Audio::Deepgram.new },
+      elevenlabs:  -> { Providers::Audio::ElevenLabs.new }
     }.freeze
 
     private

data/lib/active_harness.rb

@@ -22,10 +22,16 @@ require_relative "active_harness/providers/bedrock"
 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"
 require_relative "active_harness/providers/images/openrouter"
 require_relative "active_harness/providers/audio/openai"
 require_relative "active_harness/providers/audio/openrouter"
+require_relative "active_harness/providers/audio/deepgram"
+require_relative "active_harness/providers/audio/elevenlabs"
 require "active_harness_pricing"
 require_relative "active_harness/memory"
 require_relative "active_harness/request"
@@ -35,7 +41,7 @@ require_relative "active_harness/pipeline"
 require_relative "active_harness/railtie" if defined?(Rails::Railtie)
 
 module ActiveHarness
-  VERSION = "0.3.5"
+  VERSION = "0.3.7"
 
   class << self
     # Configure ActiveHarness.

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

@@ -81,6 +81,36 @@ 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
+  # ---------------------------------------------------------------------------
+  # config.typesafe_api_key = ENV["TYPESAFE_API_KEY"]
+  # config.typesafe_api_url = "https://api.typesafe.ai/v1/systemone"
+
+  # ---------------------------------------------------------------------------
+  # Ollama Cloud (hosted — API key required)
+  # ---------------------------------------------------------------------------
+  # config.ollama_cloud_api_key = ENV["OLLAMA_CLOUD_API_KEY"]
+  # config.ollama_cloud_api_url = "https://ollama.com/v1/chat/completions"
+
+  # ---------------------------------------------------------------------------
+  # Hetzner Inference
+  # ---------------------------------------------------------------------------
+  # config.hetzner_api_key = ENV["HETZNER_API_KEY"]
+  # config.hetzner_api_url = "https://inference.hetzner.com/api/v1/chat/completions"
+
+  # ---------------------------------------------------------------------------
+  # Deepgram / ElevenLabs (audio transcription only)
+  # ---------------------------------------------------------------------------
+  # config.deepgram_api_key   = ENV["DEEPGRAM_API_KEY"]
+  # config.elevenlabs_api_key = ENV["ELEVENLABS_API_KEY"]
+
   # ---------------------------------------------------------------------------
   # Custom providers — any OpenAI-compatible endpoint
   # Register as many as you need under arbitrary names.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.7
 platform: ruby
 authors:
 - the-teacher
@@ -63,23 +63,29 @@ files:
 - lib/active_harness/pipeline/step.rb
 - lib/active_harness/providers/PROVIDER_CONTRACT.md
 - lib/active_harness/providers/anthropic.rb
+- lib/active_harness/providers/audio/deepgram.rb
+- lib/active_harness/providers/audio/elevenlabs.rb
 - lib/active_harness/providers/audio/openai.rb
 - lib/active_harness/providers/audio/openrouter.rb
 - 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
 - lib/active_harness/providers/gpustack.rb
 - lib/active_harness/providers/groq.rb
+- lib/active_harness/providers/hetzner.rb
 - lib/active_harness/providers/images/openai.rb
 - lib/active_harness/providers/images/openrouter.rb
 - lib/active_harness/providers/mistral.rb
 - lib/active_harness/providers/ollama.rb
+- lib/active_harness/providers/ollama_cloud.rb
 - lib/active_harness/providers/openai.rb
 - lib/active_harness/providers/openrouter.rb
 - lib/active_harness/providers/perplexity.rb
+- lib/active_harness/providers/typesafe.rb
 - lib/active_harness/providers/vercel.rb
 - lib/active_harness/providers/vertexai.rb
 - lib/active_harness/providers/xai.rb