active_harness 0.2.9 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15017e6a42df89f5372596d3b75deb192117a680ad297196eda52111a8931a96
-  data.tar.gz: 135fdfb6b453c4c2bfaef6ff8ed7f022b2c3fb1b45923f2ed282701fd106864d
+  metadata.gz: 79db5ea3cf1416b2d9e8d3958d9a6e69c9ab65ea36ddf52bcdd8e41ff2e07b0c
+  data.tar.gz: 0fde20074cb5d215226fdac581b84220ae2d5462e14cae4bfc6e1216dff84164
 SHA512:
-  metadata.gz: 253c875d86e0d52535ba46ef206679a8cd5920e10b0cc0bcc82fad743e4a7bed1d1a3a28c8063db72400f17f057070ae0ac8cf61e14a3fe5708a766d9fa3b00f
-  data.tar.gz: f7f5a376c825d3ee9ace72f0512cb55f835dc7bad6b4dc419517d14b42f100b78b4bff1e6bf70cc6e7a137624d0ccf91fa71286805e3408560d3eb4fff54b904
+  metadata.gz: f6ccb47cc9f4c176d44503323ee642e879c66961521d69b102616ca92be8eeb8c0b38ce12e72bab1dbf67756c2d984edb8fb238d26778b4755f49370290a7861
+  data.tar.gz: 0c0478912520ed1a466a16dd4f453996c25f20878a6d1b10399faf89a7668fbfac58f0ef00d72c39b10db442f54366d0f886f1e70eb9908cc4bbbf6035412e0f

data/lib/active_harness/http/streaming_client.rb

@@ -25,6 +25,7 @@ module ActiveHarness
 
         buffer  = ""
         content = ""
+        usage   = nil
 
         http.request(req) do |response|
           response.read_body do |chunk|
@@ -42,11 +43,12 @@ module ActiveHarness
                 on_token.call(token)
                 content += token
               end
+              usage ||= parsed["usage"] if parsed.key?("usage")
             end
           end
         end
 
-        content
+        { content: content, raw_usage: usage }
       rescue Net::OpenTimeout, Net::ReadTimeout
         raise Errors::TimeoutError, "Request to #{url.host} timed out"
       rescue JSON::ParserError

data/lib/active_harness/providers/base.rb

@@ -45,6 +45,21 @@ module ActiveHarness
         }
       end
 
+      # Streaming call for OpenAI-compatible providers.
+      # Adds stream: true and stream_options to body, calls StreamingClient,
+      # and returns the same { content:, provider:, model:, usage: } shape
+      # as non-streaming calls so callers need no special handling.
+      def call_streaming(url:, headers:, body:, stream:, provider:, model:)
+        body = body.merge(stream: true, stream_options: { include_usage: true })
+        result = post_json_stream(URI(url), headers: headers, body: body, on_token: stream)
+        {
+          content:  result[:content],
+          provider: provider,
+          model:    model,
+          usage:    extract_usage_openai({ "usage" => result[:raw_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.10
 platform: ruby
 authors:
 - the-teacher