active_harness 0.3.4 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eaf485a5e22b0e8896fde6333964ccfb2f9739a6f366707587d4c3a9a1cbcec7
-  data.tar.gz: 9fe117e4d320affd189bd8ef8f601d0481c858f8087d509529bd79d04d710a1d
+  metadata.gz: 347d7944af01b44bda7568ac47fc335fd58a48320f80ae71c4a52b83458a710f
+  data.tar.gz: 13343b28d031fd4dd86b4114a7d4c3f7b7223db6402b3c1f2bf9e135073e3bc3
 SHA512:
-  metadata.gz: e115a0659d759419465014e3a5dbdbecabb6e26b9fb6aa0f4909debd117ea0f1aca33f302170dc4d4a9ea4d3769edbc3ba64b230bf824ad2cc787ef1e384336c
-  data.tar.gz: f04b58a682ae1af32e56a7afb96517a376136e9990366529406706f1c6af66ae6f446185da5d775df50ad93f95ef54b95deb86d0d98981169e20acd165570094
+  metadata.gz: 3eb2200ec4c40e7ecf626d9cff3c5f56917b07dbf5756fa54d986d327ce740b18b95b5806f4e9924674a010196c76bbb11f9c66fbe9f54256ac0cfce4c901a7c
+  data.tar.gz: 8c1c186d855e6ef3ee0e8961665904da7175cf7018c0e4e352eb2b6a15bcd42f2d019963cb996d0bb8407f8eeb9eda98bac13b8def11fd2c43b382a8dce8d8f5

data/lib/active_harness/configuration.rb

@@ -105,6 +105,36 @@ module ActiveHarness
     attr_accessor :vercel_api_key
     attr_accessor :vercel_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 +209,21 @@ module ActiveHarness
 
       @vercel_api_key = ENV["VERCEL_API_KEY"]
       @vercel_api_url = "https://ai-gateway.vercel.sh/typesafe/v1/systemone"
+
+      @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/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/audio/openai.rb

@@ -27,7 +27,18 @@ module ActiveHarness
         # Synchronous — this endpoint has no job/polling API. Unlike OpenRouter's
         # transcription endpoint, OpenAI's is multipart/form-data only (no
         # base64/JSON request mode).
-        def call(model:, audio_data:, audio_format:, language: nil, **_)
+        # @param response_format [String] "json" (default, plain text) or,
+        #   for gpt-4o-transcribe-diarize, "diarized_json" — returns per-segment
+        #   speaker/text/start/end instead of just plain text.
+        # @param chunking_strategy [String, Hash] required by
+        #   gpt-4o-transcribe-diarize for any audio over 30 seconds; "auto" is
+        #   the simple/common value, or a voice-activity-detection config hash.
+        # @param known_speaker_names [Array<String>] up to 4 labels, paired
+        #   positionally with known_speaker_references, for gpt-4o-transcribe-diarize.
+        # @param known_speaker_references [Array<String>] up to 4 short (2-10s)
+        #   reference clips as base64 data URLs, e.g. "data:audio/wav;base64,...".
+        def call(model:, audio_data:, audio_format:, language: nil, response_format: nil,
+                 chunking_strategy: nil, known_speaker_names: nil, known_speaker_references: nil, **_)
           content_type = CONTENT_TYPES[audio_format]
           unless content_type
             raise Errors::InvalidRequestError,
@@ -36,9 +47,16 @@ module ActiveHarness
 
           boundary = SecureRandom.hex(16)
           fields   = { "model" => model }
-          fields["language"] = language if language
+          fields["language"]          = language if language
+          fields["response_format"]   = response_format if response_format
+          fields["chunking_strategy"] = chunking_strategy if chunking_strategy
 
-          body = build_multipart_body(boundary, fields, audio_data, "audio.#{audio_format}", content_type)
+          array_fields = {
+            "known_speaker_names[]"      => known_speaker_names,
+            "known_speaker_references[]" => known_speaker_references
+          }
+
+          body = build_multipart_body(boundary, fields, audio_data, "audio.#{audio_format}", content_type, array_fields: array_fields)
           headers = {
             "Content-Type"  => "multipart/form-data; boundary=#{boundary}",
             "Authorization" => "Bearer #{api_key}"
@@ -48,15 +66,24 @@ module ActiveHarness
           data = parse!(raw)
           handle_error!(data)
 
-          text = data["text"]
-          raise Errors::ProviderError, "No transcription text in response: #{data.keys}" if text.nil?
+          # diarized_json returns a structured { segments: [...] } shape (each
+          # with speaker/text/start/end) — hand the whole thing back as JSON
+          # text so `format :json` on the Request subclass parses it into a
+          # Hash. Plain "json"/unset keeps the existing behavior: just the
+          # flat text.
+          content =
+            if response_format == "diarized_json"
+              data.to_json
+            else
+              data["text"].tap { |t| raise Errors::ProviderError, "No transcription text in response: #{data.keys}" if t.nil? }
+            end
 
-          { content: text, provider: :openai, model: model, usage: extract_transcription_usage(data) }
+          { content: content, provider: :openai, model: model, usage: extract_transcription_usage(data) }
         end
 
         private
 
-        def build_multipart_body(boundary, fields, file_data, filename, content_type)
+        def build_multipart_body(boundary, fields, file_data, filename, content_type, array_fields: {})
           body = +""
           fields.each do |name, value|
             body << "--#{boundary}\r\n"
@@ -64,6 +91,14 @@ module ActiveHarness
             body << "#{value}\r\n"
           end
 
+          array_fields.each do |name, values|
+            Array(values).each do |value|
+              body << "--#{boundary}\r\n"
+              body << "Content-Disposition: form-data; name=\"#{name}\"\r\n\r\n"
+              body << "#{value}\r\n"
+            end
+          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"

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

@@ -13,11 +13,22 @@ module ActiveHarness
         # @param audio_data   [String]  raw binary audio bytes
         # @param audio_format [String]  "wav", "mp3", "flac", "m4a", "ogg", "webm", "aac"
         # @param language     [String]  ISO-639-1 code, e.g. "en" (optional — auto-detected if omitted)
+        # @param response_format [String] "json" (default, plain text) or "verbose_json"
+        #   — the latter returns per-segment start/end timestamps (and a "speaker"
+        #   index per segment when the provider supports diarization).
+        # @param timestamp_granularities [Array<String>] e.g. ["segment", "word"] —
+        #   only meaningful with response_format: "verbose_json".
+        # @param provider_options [Hash] passed through as-is to the request body's
+        #   `provider.options` — this is how provider-specific features (e.g. Azure
+        #   speaker diarization) are enabled: { azure: { diarization: { enabled: true } } }.
+        #   Only specific provider/model combos support this; most will just ignore
+        #   an option they don't recognize, but some may 400 on it.
         #
         # Synchronous call — OpenRouter's transcription endpoint has no job/polling
         # API. Upstream providers time out after ~60s per request, so long audio
         # should be split into shorter chunks by the caller before transcribing.
-        def call(model:, audio_data:, audio_format:, language: nil, **_)
+        def call(model:, audio_data:, audio_format:, language: nil, response_format: nil,
+                 timestamp_granularities: nil, provider_options: nil, **_)
           headers = {
             "Content-Type"  => "application/json",
             "Authorization" => "Bearer #{api_key}"
@@ -29,16 +40,27 @@ module ActiveHarness
             model: model,
             input_audio: { data: Base64.strict_encode64(audio_data), format: audio_format }
           }
-          body[:language] = language if language
+          body[:language]                 = language if language
+          body[:response_format]          = response_format if response_format
+          body[:timestamp_granularities]  = timestamp_granularities if timestamp_granularities
+          body[:provider]                 = { options: provider_options } if provider_options
 
           raw  = post_json(URI(ENDPOINT), 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?
+          # verbose_json returns a richer structure (language/duration/segments with
+          # timestamps and, when supported, speaker) — hand the whole thing back as
+          # JSON text so `format :json` on the Request subclass parses it into a Hash.
+          # Plain "json"/unset keeps the existing behavior: just the flat text.
+          content =
+            if response_format == "verbose_json"
+              data.to_json
+            else
+              data["text"].tap { |t| raise Errors::ProviderError, "No transcription text in response: #{data.keys}" if t.nil? }
+            end
 
-          { content: text, provider: :openrouter, model: model, usage: extract_transcription_usage(data) }
+          { content: content, provider: :openrouter, model: model, usage: extract_transcription_usage(data) }
         end
 
         private

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)
 
         {
           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,26 @@ 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
+
+      # 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)
         msg, type =
-          if data["message"] && data["error_type"]
+          if data.key?("detail")
+            msg = detail_message(data["detail"])
+            [msg, msg =~ /api key|unauthori|authenticat|invalid token|credentials/i ? "unauthorized" : "invalid_request"]
+          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]

data/lib/active_harness/request/models.rb

@@ -134,17 +134,25 @@ module ActiveHarness
       @models = []
     end
 
-    def use(provider:, model:, temperature: nil, name: nil, size: nil, quality: nil, retry_attempts: nil, retry_delay: nil, questions: nil)
+    def use(provider:, model:, temperature: nil, name: nil, size: nil, quality: nil, retry_attempts: nil, retry_delay: nil,
+            questions: nil, response_format: nil, timestamp_granularities: nil, provider_options: nil,
+            chunking_strategy: nil, known_speaker_names: nil, known_speaker_references: nil)
       @models << {
-        provider:       provider,
-        model:          model,
-        temperature:    temperature,
-        name:           name,
-        size:           size,
-        quality:        quality,
-        retry_attempts: retry_attempts,
-        retry_delay:    retry_delay,
-        questions:      questions
+        provider:                 provider,
+        model:                    model,
+        temperature:              temperature,
+        name:                     name,
+        size:                     size,
+        quality:                  quality,
+        retry_attempts:           retry_attempts,
+        retry_delay:              retry_delay,
+        questions:                questions,
+        response_format:          response_format,
+        timestamp_granularities:  timestamp_granularities,
+        provider_options:         provider_options,
+        chunking_strategy:        chunking_strategy,
+        known_speaker_names:      known_speaker_names,
+        known_speaker_references: known_speaker_references
       }.compact
     end
 

data/lib/active_harness/request/providers.rb

@@ -36,7 +36,10 @@ module ActiveHarness
       bedrock:     -> { Providers::Bedrock.new },
       vertexai:    -> { Providers::VertexAI.new },
       custom:      -> { Providers::Custom.new },
-      vercel:      -> { Providers::Vercel.new }
+      vercel:      -> { Providers::Vercel.new },
+      typesafe:    -> { Providers::TypeSafe.new },
+      ollama_cloud: -> { Providers::OllamaCloud.new },
+      hetzner:     -> { Providers::Hetzner.new }
     }.freeze
 
     IMAGE_PROVIDERS = {
@@ -46,7 +49,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
@@ -100,7 +105,13 @@ module ActiveHarness
 
       opts = { model: entry[:model], audio_data: File.binread(path), audio_format: format }
       language = entry[:language] || @config[:transcribe_language]
-      opts[:language] = language if language
+      opts[:language]                 = language if language
+      opts[:response_format]          = entry[:response_format] if entry[:response_format]
+      opts[:timestamp_granularities]  = entry[:timestamp_granularities] if entry[:timestamp_granularities]
+      opts[:provider_options]         = entry[:provider_options] if entry[:provider_options]
+      opts[:chunking_strategy]        = entry[:chunking_strategy] if entry[:chunking_strategy]
+      opts[:known_speaker_names]      = entry[:known_speaker_names] if entry[:known_speaker_names]
+      opts[:known_speaker_references] = entry[:known_speaker_references] if entry[:known_speaker_references]
       factory.call.call(**opts)
     end
 

data/lib/active_harness/request.rb

@@ -140,6 +140,7 @@ module ActiveHarness
         model:          entry[:model],
         error:          error.message,
         error_code:     error.respond_to?(:error_code) ? error.error_code : nil,
+        error_metadata: error.respond_to?(:metadata) ? error.metadata : nil,
         execution_time: elapsed
       }
     end

data/lib/active_harness.rb

@@ -22,10 +22,15 @@ 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/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 +40,7 @@ require_relative "active_harness/pipeline"
 require_relative "active_harness/railtie" if defined?(Rails::Railtie)
 
 module ActiveHarness
-  VERSION = "0.3.4"
+  VERSION = "0.3.6"
 
   class << self
     # Configure ActiveHarness.

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

@@ -81,6 +81,30 @@ 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"
 
+  # ---------------------------------------------------------------------------
+  # 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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.6
 platform: ruby
 authors:
 - the-teacher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-09-25 00:00:00.000000000 Z
+date: 2026-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -63,6 +63,8 @@ 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
@@ -73,13 +75,16 @@ files:
 - 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