active_harness 0.2.10 → 0.2.12

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,7 +28,7 @@ module ActiveHarness
 
         buffer  = ""
         content = ""
-        usage   = nil
+        usage   = {}
 
         http.request(req) do |response|
           response.read_body do |chunk|
@@ -37,26 +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 ||= parsed["usage"] if parsed.key?("usage")
+              usage = usage.merge(info[:usage]) if info[:usage]
             end
           end
         end
 
-        { content: content, raw_usage: usage }
+        { 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.
@@ -46,18 +46,29 @@ 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.
+      # 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 = 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] })
-        }
+        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)

data/lib/active_harness.rb

@@ -20,6 +20,7 @@ require_relative "active_harness/providers/azure"
 require_relative "active_harness/providers/bedrock"
 require_relative "active_harness/providers/vertexai"
 require_relative "active_harness/providers/custom"
+require_relative "active_harness/costs"
 require_relative "active_harness/memory"
 require_relative "active_harness/agent"
 require_relative "active_harness/tribunal"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.12
 platform: ruby
 authors:
 - the-teacher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-05-24 00:00:00.000000000 Z
+date: 2026-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -41,6 +41,8 @@ files:
 - lib/active_harness/agent/ruby_llm_backend.rb
 - lib/active_harness/configuration.rb
 - lib/active_harness/core/errors.rb
+- lib/active_harness/costs.rb
+- lib/active_harness/data/models.json
 - lib/active_harness/http/client.rb
 - lib/active_harness/http/retry_policy.rb
 - lib/active_harness/http/streaming_client.rb