active_harness 0.2.8 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7139860d4aa461b1d86eca144c4929d4bf362192099498eadf61401b85acf8d
-  data.tar.gz: 3f00f021d6fd660748767349fb6a00ba9187c6baf507d18b01ac668c52c67904
+  metadata.gz: 79db5ea3cf1416b2d9e8d3958d9a6e69c9ab65ea36ddf52bcdd8e41ff2e07b0c
+  data.tar.gz: 0fde20074cb5d215226fdac581b84220ae2d5462e14cae4bfc6e1216dff84164
 SHA512:
-  metadata.gz: 1c335d3ecce967dc10424ef0cbe15922561627539e7cbf5eb2a34ad7e672c964bd7fd796ed129229a41a7f32992c22241353e16b8e314aec7cd71878ea86148d
-  data.tar.gz: 930e5ad7ad85e5e269772e90c45453fb6672dc2f8752c3d546f9888d3d2c8cd2020a24190f7391f8217bf1c8e24cde67945788870c3b1d1ec60e01747c0d2698
+  metadata.gz: f6ccb47cc9f4c176d44503323ee642e879c66961521d69b102616ca92be8eeb8c0b38ce12e72bab1dbf67756c2d984edb8fb238d26778b4755f49370290a7861
+  data.tar.gz: 0c0478912520ed1a466a16dd4f453996c25f20878a6d1b10399faf89a7668fbfac58f0ef00d72c39b10db442f54366d0f886f1e70eb9908cc4bbbf6035412e0f

data/lib/active_harness/agent/providers.rb

@@ -47,7 +47,7 @@ module ActiveHarness
       messages = build_messages(system_prompt, @input)
       opts = { model: entry[:model], messages: messages }
       opts[:temperature] = entry[:temperature] if entry[:temperature]
-      opts[:stream]      = @stream             if @stream
+      opts[:stream]      = @token_stream       if @token_stream
       opts[:name]        = entry[:name]        if entry[:name]
       provider.call(**opts)
     end

data/lib/active_harness/agent/ruby_llm_backend.rb

@@ -54,8 +54,8 @@ module ActiveHarness
       chat = backend.call(params)
       chat.with_instructions(system_prompt) if system_prompt
 
-      if @stream
-        response = chat.ask(@input) { |chunk| @stream.call(chunk.content) if chunk.content }
+      if @token_stream
+        response = chat.ask(@input) { |chunk| @token_stream.call(chunk.content) if chunk.content }
       else
         response = chat.ask(@input)
       end

data/lib/active_harness/agent.rb

@@ -11,8 +11,8 @@ module ActiveHarness
       #   SupportAgent.call(input: "Hi")
       #   SupportAgent.call(input: "Hi", context: { user_id: 42 })
       #   SupportAgent.call(input: "Hi", memory: memory)
-      def call(input: nil, context: {}, models: nil, memory: nil, stream: nil)
-        new(input: input, context: context, models: models, memory: memory, stream: stream).call.result
+      def call(input: nil, context: {}, models: nil, memory: nil, stream: nil, token_stream: nil, event_stream: nil)
+        new(input: input, context: context, models: models, memory: memory, stream: stream, token_stream: token_stream, event_stream: event_stream).call
       end
 
       # Each subclass gets its own isolated config hash.
@@ -28,7 +28,7 @@ module ActiveHarness
     # -------------------------------------------------------------------------
     # Instance API
     # -------------------------------------------------------------------------
-    attr_accessor :input, :context
+    attr_accessor :input, :context, :stream, :token_stream, :event_stream
     attr_reader :result
 
     def models=(list)
@@ -36,12 +36,18 @@ module ActiveHarness
       @model_list_proxy = nil
     end
 
-    def initialize(input: nil, context: {}, models: nil, memory: nil, stream: nil)
+    def memory=(obj)
+      @memory = obj
+    end
+
+    def initialize(input: nil, context: {}, models: nil, memory: nil, stream: nil, token_stream: nil, event_stream: nil)
       @input           = input
       @context         = context
       @config          = self.class.agent_config
       @models_override = Array(models) if models
       @stream          = stream
+      @token_stream    = token_stream
+      @event_stream    = event_stream
       # memory: can be passed directly or via context[:memory]
       @memory = memory || @context[:memory]
       run_hook(:setup)
@@ -53,9 +59,9 @@ module ActiveHarness
     # Optionally accepts input and stream callback inline:
     #   agent.call("What is the capital of Japan?")
     #   agent.call("...", stream: ->(token) { print token })
-    def call(input = nil, stream: nil)
-      @input  = input  if input
-      @stream = stream if stream
+    def call(input = nil, token_stream: nil)
+      @input        = input        if input
+      @token_stream = token_stream if token_stream
       @memory&.load
       @system_prompt = resolve_system_prompt
       run_hook(:before_call)

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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.10
 platform: ruby
 authors:
 - the-teacher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-05-22 00:00:00.000000000 Z
+date: 2026-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby