active_harness 0.2.9 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15017e6a42df89f5372596d3b75deb192117a680ad297196eda52111a8931a96
-  data.tar.gz: 135fdfb6b453c4c2bfaef6ff8ed7f022b2c3fb1b45923f2ed282701fd106864d
+  metadata.gz: 38c99c81636b8ffa378a8f753fbdc86f269d843bf3c78769cbb6600c5ef9b9af
+  data.tar.gz: b515af2c5c13e84db218059490302bc16f0b7726d7c11b0ebc18e3e6fe883978
 SHA512:
-  metadata.gz: 253c875d86e0d52535ba46ef206679a8cd5920e10b0cc0bcc82fad743e4a7bed1d1a3a28c8063db72400f17f057070ae0ac8cf61e14a3fe5708a766d9fa3b00f
-  data.tar.gz: f7f5a376c825d3ee9ace72f0512cb55f835dc7bad6b4dc419517d14b42f100b78b4bff1e6bf70cc6e7a137624d0ccf91fa71286805e3408560d3eb4fff54b904
+  metadata.gz: f7e1f9b8a0c0f88d300df2fc018dc5580524fd67b44c04df359a77bab67a987b20d19823d88fa7d42c9ae6dbfc140e520c0791c7260119b5787687bb6d22c8ca
+  data.tar.gz: c7c24cb33a57a75f9edce08484573dabdd35a938543de5acf46ab670c78fc8cffe7a288ed2a9ddf703ef350519888609c80c54bc42242ff48febd7e245c9cce6

data/lib/active_harness/http/streaming_client.rb

@@ -7,13 +7,16 @@ module ActiveHarness
     # Calls +on_token+ for each content token as it arrives via SSE.
     # Accumulates and returns the full content string when the stream ends.
     class StreamingClient
-      # @param url      [URI]
-      # @param headers  [Hash{String => String}]
-      # @param body     [String]  JSON-serialized body
-      # @param timeout  [Integer] seconds (open + read)
-      # @param on_token [Proc]    called with each partial token string
-      # @return         [String]  full accumulated content
-      def post(url, headers:, body:, timeout: 60, on_token:)
+      # @param url         [URI]
+      # @param headers     [Hash{String => String}]
+      # @param body        [String]  JSON-serialized body
+      # @param timeout     [Integer] seconds (open + read)
+      # @param on_token    [Proc]    called with each partial token string
+      # @param parse_chunk [Proc, nil] receives each parsed SSE JSON hash;
+      #                    must return { token: String|nil, usage: Hash|nil }.
+      #                    Defaults to OpenAI-compatible format.
+      # @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.open_timeout = timeout
@@ -25,6 +28,7 @@ module ActiveHarness
 
         buffer  = ""
         content = ""
+        usage   = {}
 
         http.request(req) do |response|
           response.read_body do |chunk|
@@ -36,25 +40,33 @@ module ActiveHarness
               data = line.delete_prefix("data: ")
               next if data == "[DONE]"
 
-              parsed = JSON.parse(data)
-              token  = parsed.dig("choices", 0, "delta", "content")
+              parsed = JSON.parse(data) rescue next
+              info   = parse_chunk ? parse_chunk.call(parsed) : default_chunk(parsed)
+              token  = info[:token]
               if token && !token.empty?
                 on_token.call(token)
                 content += token
               end
+              usage = usage.merge(info[:usage]) if info[:usage]
             end
           end
         end
 
-        content
+        { content: content, usage: usage.empty? ? nil : usage }
       rescue Net::OpenTimeout, Net::ReadTimeout
         raise Errors::TimeoutError, "Request to #{url.host} timed out"
-      rescue JSON::ParserError
-        # ignore malformed SSE chunks
-        content
       rescue => e
         raise Errors::ProviderUnavailableError, "#{url.host} unreachable: #{e.message}"
       end
+
+      private
+
+      def default_chunk(parsed)
+        token = parsed.dig("choices", 0, "delta", "content")
+        raw_u = parsed["usage"]
+        usage = raw_u ? { input_tokens: raw_u["prompt_tokens"].to_i, output_tokens: raw_u["completion_tokens"].to_i } : nil
+        { token: token, usage: usage }
+      end
     end
   end
 end

data/lib/active_harness/providers/anthropic.rb

@@ -8,25 +8,26 @@ module ActiveHarness
       ANTHROPIC_VERSION = "2023-06-01"
       DEFAULT_MAX_TOKENS = 1024
 
-      def call(model:, messages:, temperature: 0.7)
+      def call(model:, messages:, temperature: 0.7, stream: nil)
         system_msg, chat_messages = extract_system(messages)
 
         body = {
-          model:      model,
-          max_tokens: DEFAULT_MAX_TOKENS,
+          model:       model,
+          max_tokens:  DEFAULT_MAX_TOKENS,
           temperature: temperature,
-          messages:   chat_messages
+          messages:    chat_messages
         }
         body[:system] = system_msg if system_msg
 
-        raw  = post_json(URI(config.anthropic_api_url),
-          headers: {
-            "Content-Type"      => "application/json",
-            "x-api-key"         => api_key,
-            "anthropic-version" => ANTHROPIC_VERSION
-          },
-          body: body
-        )
+        headers = {
+          "Content-Type"      => "application/json",
+          "x-api-key"         => api_key,
+          "anthropic-version" => ANTHROPIC_VERSION
+        }
+
+        return call_streaming(url: config.anthropic_api_url, headers: headers, body: body, stream: stream, provider: :anthropic, model: model) if stream
+
+        raw  = post_json(URI(config.anthropic_api_url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 
@@ -77,6 +78,30 @@ module ActiveHarness
           raise Errors::InvalidRequestError.new(msg,      error_code: type, metadata: metadata)
         end
       end
+
+      # Anthropic streaming uses plain stream: true — no stream_options.
+      def prepare_streaming_body(body)
+        body.merge(stream: true)
+      end
+
+      # Anthropic SSE events:
+      #   message_start       → input token count
+      #   content_block_delta → text token
+      #   message_delta       → output token count
+      def build_streaming_chunk(parsed)
+        token = if parsed["type"] == "content_block_delta" && parsed.dig("delta", "type") == "text_delta"
+                  parsed.dig("delta", "text")
+                end
+
+        usage = case parsed["type"]
+                when "message_start"
+                  { input_tokens: parsed.dig("message", "usage", "input_tokens").to_i }
+                when "message_delta"
+                  { output_tokens: parsed.dig("usage", "output_tokens").to_i }
+                end
+
+        { token: token, usage: usage }
+      end
     end
   end
 end

data/lib/active_harness/providers/base.rb

@@ -16,8 +16,8 @@ module ActiveHarness
         HTTP.post(url, headers: headers, body: body.to_json, timeout: timeout)
       end
 
-      def post_json_stream(url, headers:, body:, timeout: 60, on_token:)
-        STREAMING_HTTP.post(url, headers: headers, body: body.to_json, timeout: timeout, on_token: on_token)
+      def post_json_stream(url, headers:, body:, timeout: 60, on_token:, parse_chunk: nil)
+        STREAMING_HTTP.post(url, headers: headers, body: body.to_json, timeout: timeout, on_token: on_token, parse_chunk: parse_chunk)
       end
 
       # Normalize OpenAI-compatible usage object to a consistent hash.
@@ -45,6 +45,32 @@ module ActiveHarness
         }
       end
 
+      # Streaming call for OpenAI-compatible providers.
+      # Subclasses may override +prepare_streaming_body+ and +build_streaming_chunk+
+      # to support non-OpenAI SSE formats (e.g. Anthropic).
+      def call_streaming(url:, headers:, body:, stream:, provider:, model:)
+        body   = prepare_streaming_body(body)
+        result = post_json_stream(URI(url), headers: headers, body: body, on_token: stream, parse_chunk: method(:build_streaming_chunk))
+        u      = result[:usage] || {}
+        usage  = u.any? ? { input_tokens: u[:input_tokens].to_i, output_tokens: u[:output_tokens].to_i, total_tokens: u[:input_tokens].to_i + u[:output_tokens].to_i } : nil
+        { content: result[:content], provider: provider, model: model, usage: usage }
+      end
+
+      # Override in subclass to change streaming request body options.
+      def prepare_streaming_body(body)
+        body.merge(stream: true, stream_options: { include_usage: true })
+      end
+
+      # Override in subclass to parse provider-specific SSE chunks.
+      # Must return { token: String|nil, usage: Hash|nil } where usage keys
+      # are :input_tokens and :output_tokens.
+      def build_streaming_chunk(parsed)
+        token = parsed.dig("choices", 0, "delta", "content")
+        raw_u = parsed["usage"]
+        usage = raw_u ? { input_tokens: raw_u["prompt_tokens"].to_i, output_tokens: raw_u["completion_tokens"].to_i } : nil
+        { token: token, usage: usage }
+      end
+
       def parse!(raw)
         JSON.parse(raw)
       rescue JSON::ParserError => e

data/lib/active_harness/providers/deepseek.rb

@@ -5,14 +5,13 @@ module ActiveHarness
     # DeepSeek — OpenAI-compatible API.
     # https://platform.deepseek.com/api-docs
     class DeepSeek < Base
-      def call(model:, messages:, temperature: 0.7)
-        raw  = post_json(URI(config.deepseek_api_url),
-          headers: {
-            "Content-Type"  => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          },
-          body: { model: model, messages: messages, temperature: temperature }
-        )
+      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.deepseek_api_url, headers: headers, body: body, stream: stream, provider: :deepseek, model: model) if stream
+
+        raw  = post_json(URI(config.deepseek_api_url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 

data/lib/active_harness/providers/gemini.rb

@@ -5,23 +5,17 @@ module ActiveHarness
     # Google Gemini — OpenAI-compatible endpoint (beta).
     # https://ai.google.dev/gemini-api/docs/openai
     class Gemini < Base
-      def call(model:, messages:, temperature: 0.7)
-        raw  = post_json(URI(config.gemini_api_url),
-          headers: {
-            "Content-Type"  => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          },
-          body: { model: model, messages: messages, temperature: temperature }
-        )
+      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.gemini_api_url, headers: headers, body: body, stream: stream, provider: :gemini, model: model) if stream
+
+        raw  = post_json(URI(config.gemini_api_url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 
-        {
-          content:  data.dig("choices", 0, "message", "content").to_s.strip,
-          provider: :gemini,
-          model:    data["model"] || model,
-          usage:    extract_usage_openai(data)
-        }
+        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :gemini, model: data["model"] || model, usage: extract_usage_openai(data) }
       end
 
       private

data/lib/active_harness/providers/gpustack.rb

@@ -13,26 +13,20 @@ module ActiveHarness
     #     use provider: :gpustack, model: "Qwen/Qwen2.5-7B-Instruct-GGUF"
     #   end
     class GPUStack < Base
-      def call(model:, messages:, temperature: 0.7)
-        url = URI("#{api_base}/v1/chat/completions")
-
+      def call(model:, messages:, temperature: 0.7, stream: nil)
+        url     = "#{api_base}/v1/chat/completions"
         headers = { "Content-Type" => "application/json" }
         key     = api_key
         headers["Authorization"] = "Bearer #{key}" if key
+        body    = { model: model, messages: messages, temperature: temperature }
+
+        return call_streaming(url: url, headers: headers, body: body, stream: stream, provider: :gpustack, model: model) if stream
 
-        raw  = post_json(url,
-          headers: headers,
-          body:    { model: model, messages: messages, temperature: temperature }
-        )
+        raw  = post_json(URI(url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 
-        {
-          content:  data.dig("choices", 0, "message", "content").to_s.strip,
-          provider: :gpustack,
-          model:    data["model"] || model,
-          usage:    extract_usage_openai(data)
-        }
+        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :gpustack, model: data["model"] || model, usage: extract_usage_openai(data) }
       end
 
       private

data/lib/active_harness/providers/groq.rb

@@ -5,23 +5,17 @@ module ActiveHarness
     # Groq — OpenAI-compatible API with fast inference.
     # https://console.groq.com/docs/openai
     class Groq < Base
-      def call(model:, messages:, temperature: 0.7)
-        raw  = post_json(URI(config.groq_api_url),
-          headers: {
-            "Content-Type"  => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          },
-          body: { model: model, messages: messages, temperature: temperature }
-        )
+      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.groq_api_url, headers: headers, body: body, stream: stream, provider: :groq, model: model) if stream
+
+        raw  = post_json(URI(config.groq_api_url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 
-        {
-          content:  data.dig("choices", 0, "message", "content").to_s.strip,
-          provider: :groq,
-          model:    data["model"] || model,
-          usage:    extract_usage_openai(data)
-        }
+        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :groq, model: data["model"] || model, usage: extract_usage_openai(data) }
       end
 
       private

data/lib/active_harness/providers/mistral.rb

@@ -5,14 +5,13 @@ module ActiveHarness
     # Mistral AI — OpenAI-compatible API.
     # https://docs.mistral.ai/api
     class Mistral < Base
-      def call(model:, messages:, temperature: 0.7)
-        raw  = post_json(URI(config.mistral_api_url),
-          headers: {
-            "Content-Type"  => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          },
-          body: { model: model, messages: messages, temperature: temperature }
-        )
+      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.mistral_api_url, headers: headers, body: body, stream: stream, provider: :mistral, model: model) if stream
+
+        raw  = post_json(URI(config.mistral_api_url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 

data/lib/active_harness/providers/ollama.rb

@@ -13,26 +13,20 @@ module ActiveHarness
     #     use provider: :ollama, model: "llama3.2"
     #   end
     class Ollama < Base
-      def call(model:, messages:, temperature: 0.7)
-        url = URI("#{api_base}/v1/chat/completions")
-
+      def call(model:, messages:, temperature: 0.7, stream: nil)
+        url     = "#{api_base}/v1/chat/completions"
         headers = { "Content-Type" => "application/json" }
         key     = api_key
         headers["Authorization"] = "Bearer #{key}" if key
+        body    = { model: model, messages: messages, temperature: temperature }
+
+        return call_streaming(url: url, headers: headers, body: body, stream: stream, provider: :ollama, model: model) if stream
 
-        raw  = post_json(url,
-          headers: headers,
-          body:    { model: model, messages: messages, temperature: temperature }
-        )
+        raw  = post_json(URI(url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 
-        {
-          content:  data.dig("choices", 0, "message", "content").to_s.strip,
-          provider: :ollama,
-          model:    data["model"] || model,
-          usage:    extract_usage_openai(data)
-        }
+        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :ollama, model: data["model"] || model, usage: extract_usage_openai(data) }
       end
 
       private

data/lib/active_harness/providers/openai.rb

@@ -7,23 +7,17 @@ module ActiveHarness
       # @param messages [Array<Hash>]  [{role:, content:}, ...]
       # @param temperature [Float]
       # @return [Hash]  { content:, provider:, model: }
-      def call(model:, messages:, temperature: 0.7)
-        raw  = post_json(URI(config.openai_api_url),
-          headers: {
-            "Content-Type"  => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          },
-          body: { model: model, messages: messages, temperature: temperature }
-        )
+      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.openai_api_url, headers: headers, body: body, stream: stream, provider: :openai, model: model) if stream
+
+        raw  = post_json(URI(config.openai_api_url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 
-        {
-          content:  data.dig("choices", 0, "message", "content").to_s.strip,
-          provider: :openai,
-          model:    data["model"] || model,
-          usage:    extract_usage_openai(data)
-        }
+        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :openai, model: data["model"] || model, usage: extract_usage_openai(data) }
       end
 
       private

data/lib/active_harness/providers/openrouter.rb

@@ -17,11 +17,7 @@ module ActiveHarness
         }
         body = { model: model, messages: messages, temperature: temperature }
 
-        if stream
-          body[:stream] = true
-          content = post_json_stream(URI(config.openrouter_api_url), headers: headers, body: body, on_token: stream)
-          return { content: content, provider: :openrouter, model: model }
-        end
+        return call_streaming(url: config.openrouter_api_url, headers: headers, body: body, stream: stream, provider: :openrouter, model: model) if stream
 
         raw  = post_json(URI(config.openrouter_api_url), headers: headers, body: body)
         data = parse!(raw)

data/lib/active_harness/providers/perplexity.rb

@@ -5,14 +5,13 @@ module ActiveHarness
     # Perplexity — OpenAI-compatible API with web-search-augmented models.
     # https://docs.perplexity.ai/api-reference/chat-completions
     class Perplexity < Base
-      def call(model:, messages:, temperature: 0.7)
-        raw  = post_json(URI(config.perplexity_api_url),
-          headers: {
-            "Content-Type"  => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          },
-          body: { model: model, messages: messages, temperature: temperature }
-        )
+      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.perplexity_api_url, headers: headers, body: body, stream: stream, provider: :perplexity, model: model) if stream
+
+        raw  = post_json(URI(config.perplexity_api_url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 

data/lib/active_harness/providers/xai.rb

@@ -5,14 +5,13 @@ module ActiveHarness
     # xAI (Grok) — OpenAI-compatible API.
     # https://docs.x.ai/api
     class XAI < Base
-      def call(model:, messages:, temperature: 0.7)
-        raw  = post_json(URI(config.xai_api_url),
-          headers: {
-            "Content-Type"  => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          },
-          body: { model: model, messages: messages, temperature: temperature }
-        )
+      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.xai_api_url, headers: headers, body: body, stream: stream, provider: :xai, model: model) if stream
+
+        raw  = post_json(URI(config.xai_api_url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.11
 platform: ruby
 authors:
 - the-teacher