active_harness 0.1.0 → 0.2.1

data/lib/active_harness/providers/anthropic.rb

@@ -1,10 +1,82 @@
+require "uri"
+
 module ActiveHarness
   module Providers
-    # Phase 2 — Anthropic (Claude) adapter
+    # Anthropic Claude — native Messages API (not OpenAI-compatible).
+    # https://docs.anthropic.com/en/api/messages
     class Anthropic < Base
-      def call(_request)
-        # TODO: implement Anthropic Messages API
-        raise NotImplementedError, "Anthropic adapter is planned for phase 2"
+      API_URL         = URI("https://api.anthropic.com/v1/messages")
+      ANTHROPIC_VERSION = "2023-06-01"
+      DEFAULT_MAX_TOKENS = 1024
+
+      def call(model:, messages:, temperature: 0.7)
+        system_msg, chat_messages = extract_system(messages)
+
+        body = {
+          model:      model,
+          max_tokens: DEFAULT_MAX_TOKENS,
+          temperature: temperature,
+          messages:   chat_messages
+        }
+        body[:system] = system_msg if system_msg
+
+        raw  = post_json(API_URL,
+          headers: {
+            "Content-Type"      => "application/json",
+            "x-api-key"         => api_key,
+            "anthropic-version" => ANTHROPIC_VERSION
+          },
+          body: body
+        )
+        data = parse!(raw)
+        handle_error!(data)
+
+        {
+          content:  data.dig("content", 0, "text").to_s.strip,
+          provider: :anthropic,
+          model:    data["model"] || model,
+          usage:    extract_usage_anthropic(data)
+        }
+      end
+
+      private
+
+      # Anthropic keeps system prompt separate from the messages array.
+      def extract_system(messages)
+        system = messages.find { |m| m[:role] == "system" || m["role"] == "system" }
+        chat   = messages.reject { |m| m[:role] == "system" || m["role"] == "system" }
+                         .map { |m| { role: m[:role] || m["role"], content: m[:content] || m["content"] } }
+
+        system_text = system && (system[:content] || system["content"])
+        [system_text, chat]
+      end
+
+      def api_key
+        key = ENV["ANTHROPIC_API_KEY"].to_s
+        raise Errors::InvalidApiKeyError, "ANTHROPIC_API_KEY is not set" if key.empty?
+        key
+      end
+
+      def handle_error!(data)
+        return unless data["error"]
+
+        msg      = data.dig("error", "message").to_s
+        type     = data.dig("error", "type").to_s
+        metadata = data["error"].reject { |k, _| %w[message type].include?(k) }
+        metadata = nil if metadata.empty?
+
+        case type
+        when "authentication_error"
+          raise Errors::InvalidApiKeyError.new(msg,       error_code: type, metadata: metadata)
+        when "rate_limit_error"
+          raise Errors::RateLimitError.new(msg,           error_code: type, metadata: metadata)
+        when "overloaded_error"
+          raise Errors::ProviderUnavailableError.new(msg, error_code: type, metadata: metadata)
+        when "api_error"
+          raise Errors::ServerError.new(msg,              error_code: type, metadata: metadata)
+        else
+          raise Errors::InvalidRequestError.new(msg,      error_code: type, metadata: metadata)
+        end
       end
     end
   end

data/lib/active_harness/providers/base.rb

@@ -1,22 +1,50 @@
+require "json"
+
 module ActiveHarness
   module Providers
     class Base
-      # @param request [ModelRequest]
-      # @return [ModelResponse]
-      def call(request)
-        raise NotImplementedError, "#{self.class}#call not implemented"
-      end
+      HTTP            = ActiveHarness::Http::Client.new
+      STREAMING_HTTP  = ActiveHarness::Http::StreamingClient.new
 
       private
 
-      def build_response(content:, provider:, model:, usage: {}, raw: nil)
-        ModelResponse.new(
-          content:  content,
-          provider: provider,
-          model:    model,
-          usage:    usage,
-          raw:      raw
-        )
+      def post_json(url, headers:, body:, timeout: 30)
+        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)
+      end
+
+      # Normalize OpenAI-compatible usage object to a consistent hash.
+      # Returns nil if the response contains no usage data.
+      def extract_usage_openai(data)
+        u = data["usage"]
+        return nil unless u
+        {
+          input_tokens:  u["prompt_tokens"].to_i,
+          output_tokens: u["completion_tokens"].to_i,
+          total_tokens:  u["total_tokens"].to_i
+        }
+      end
+
+      # Normalize Anthropic usage object.
+      def extract_usage_anthropic(data)
+        u = data["usage"]
+        return nil unless u
+        input  = u["input_tokens"].to_i
+        output = u["output_tokens"].to_i
+        {
+          input_tokens:  input,
+          output_tokens: output,
+          total_tokens:  input + output
+        }
+      end
+
+      def parse!(raw)
+        JSON.parse(raw)
+      rescue JSON::ParserError => e
+        raise Errors::ProviderError, "Invalid JSON response: #{e.message}"
       end
     end
   end

data/lib/active_harness/providers/gemini.rb

@@ -0,0 +1,61 @@
+require "uri"
+
+module ActiveHarness
+  module Providers
+    # Google Gemini — OpenAI-compatible endpoint (beta).
+    # https://ai.google.dev/gemini-api/docs/openai
+    class Gemini < Base
+      API_URL = URI("https://generativelanguage.googleapis.com/v1beta/openai/chat/completions")
+
+      def call(model:, messages:, temperature: 0.7)
+        raw  = post_json(API_URL,
+          headers: {
+            "Content-Type"  => "application/json",
+            "Authorization" => "Bearer #{api_key}"
+          },
+          body: { model: model, messages: messages, temperature: temperature }
+        )
+        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)
+        }
+      end
+
+      private
+
+      def api_key
+        key = ENV["GEMINI_API_KEY"].to_s
+        raise Errors::InvalidApiKeyError, "GEMINI_API_KEY is not set" if key.empty?
+        key
+      end
+
+      def handle_error!(data)
+        return unless data["error"]
+
+        msg      = data.dig("error", "message").to_s
+        code     = data.dig("error", "code").to_s
+        status   = data.dig("error", "status").to_s
+        metadata = data["error"].reject { |k, _| %w[message code status].include?(k) }
+        metadata = nil if metadata.empty?
+
+        case status
+        when "UNAUTHENTICATED"
+          raise Errors::InvalidApiKeyError.new(msg,       error_code: code, metadata: metadata)
+        when "RESOURCE_EXHAUSTED"
+          raise Errors::RateLimitError.new(msg,           error_code: code, metadata: metadata)
+        when "UNAVAILABLE"
+          raise Errors::ProviderUnavailableError.new(msg, error_code: code, metadata: metadata)
+        when "INTERNAL"
+          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

data/lib/active_harness/providers/groq.rb

@@ -0,0 +1,64 @@
+require "uri"
+
+module ActiveHarness
+  module Providers
+    # Groq — OpenAI-compatible API with fast inference.
+    # https://console.groq.com/docs/openai
+    class Groq < Base
+      API_URL = URI("https://api.groq.com/openai/v1/chat/completions")
+
+      def call(model:, messages:, temperature: 0.7)
+        raw  = post_json(API_URL,
+          headers: {
+            "Content-Type"  => "application/json",
+            "Authorization" => "Bearer #{api_key}"
+          },
+          body: { model: model, messages: messages, temperature: temperature }
+        )
+        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)
+        }
+      end
+
+      private
+
+      def api_key
+        key = ENV["GROQ_API_KEY"].to_s
+        raise Errors::InvalidApiKeyError, "GROQ_API_KEY is not set" if key.empty?
+        key
+      end
+
+      def handle_error!(data)
+        return unless data["error"]
+
+        msg      = data.dig("error", "message").to_s
+        code     = data.dig("error", "code").to_s
+        type     = data.dig("error", "type").to_s
+        metadata = data["error"].reject { |k, _| %w[message code type].include?(k) }
+        metadata = nil if metadata.empty?
+
+        case code
+        when "invalid_api_key", "unauthorized"
+          raise Errors::InvalidApiKeyError.new(msg,       error_code: code, metadata: metadata)
+        when "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
+          case type
+          when "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/openai.rb

@@ -1,76 +1,68 @@
-require "json"
+require "uri"
 
 module ActiveHarness
   module Providers
     class OpenAI < Base
       API_URL = URI("https://api.openai.com/v1/chat/completions")
 
-      def call(request)
-        body     = build_body(request)
-        raw      = post(body, request.timeout)
-        data     = JSON.parse(raw)
-
+      # @param model    [String]
+      # @param messages [Array<Hash>]  [{role:, content:}, ...]
+      # @param temperature [Float]
+      # @return [Hash]  { content:, provider:, model: }
+      def call(model:, messages:, temperature: 0.7)
+        raw  = post_json(API_URL,
+          headers: {
+            "Content-Type"  => "application/json",
+            "Authorization" => "Bearer #{api_key}"
+          },
+          body: { model: model, messages: messages, temperature: temperature }
+        )
+        data = parse!(raw)
         handle_error!(data)
 
-        content = data.dig("choices", 0, "message", "content").to_s.strip
-        usage   = data["usage"] || {}
-
-        build_response(
-          content:  content,
+        {
+          content:  data.dig("choices", 0, "message", "content").to_s.strip,
           provider: :openai,
-          model:    data["model"] || request.model,
-          usage:    { prompt: usage["prompt_tokens"], completion: usage["completion_tokens"] },
-          raw:      raw
-        )
+          model:    data["model"] || model,
+          usage:    extract_usage_openai(data)
+        }
       end
 
       private
 
-      def build_body(request)
-        body = {
-          model:       request.model,
-          messages:    request.messages,
-          temperature: request.temperature
-        }
-        body[:response_format] = { type: "json_object" } if request.response_format == :json
-        body.to_json
-      end
-
-      def post(body, timeout)
-        ActiveHarness.config.http_client.post(
-          API_URL,
-          headers: {
-            "Content-Type"  => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          },
-          body:    body,
-          timeout: timeout
-        )
+      def api_key
+        key = ENV["OPENAI_API_KEY"].to_s
+        raise Errors::InvalidApiKeyError, "OPENAI_API_KEY is not set" if key.empty?
+        key
       end
 
       def handle_error!(data)
         return unless data["error"]
 
-        message = data.dig("error", "message").to_s
-        code    = data.dig("error", "code").to_s
+        msg      = data.dig("error", "message").to_s
+        code     = data.dig("error", "code").to_s
+        type     = data.dig("error", "type").to_s
+        metadata = data["error"].reject { |k, _| %w[message code type].include?(k) }
+        metadata = nil if metadata.empty?
 
         case code
         when "invalid_api_key", "unauthorized"
-          raise Errors::InvalidApiKeyError, message
+          raise Errors::InvalidApiKeyError.new(msg,  error_code: code, metadata: metadata)
         when "rate_limit_exceeded"
-          raise Errors::RateLimitError, message
+          raise Errors::RateLimitError.new(msg,      error_code: code, metadata: metadata)
         when "content_filter"
-          raise Errors::SafetyBlockedError, message
+          raise Errors::SafetyBlockedError.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, message
+          case type
+          when "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
-
-      def api_key
-        key = ActiveHarness.config.openai_api_key
-        raise Errors::InvalidApiKeyError, "OPENAI_API_KEY not configured" if key.nil? || key.empty?
-        key
-      end
     end
   end
 end

data/lib/active_harness/providers/openrouter.rb

@@ -1,80 +1,66 @@
-require "json"
+require "uri"
 
 module ActiveHarness
   module Providers
-    # OpenRouter proxies many models (OpenAI, Anthropic, etc.) through a single API.
-    # API is OpenAI-compatible with an extra "HTTP-Referer" header.
+    # OpenRouter — OpenAI-compatible API that proxies many models.
     class OpenRouter < Base
       API_URL = URI("https://openrouter.ai/api/v1/chat/completions")
 
-      def call(request)
-        body = build_body(request)
-        raw  = post(body, request.timeout)
-        data = JSON.parse(raw)
+      # @param model    [String]
+      # @param messages [Array<Hash>]  [{role:, content:}, ...]
+      # @param temperature [Float]
+      # @param stream   [Proc, nil]  if given, called with each token as it arrives
+      # @return [Hash]  { content:, provider:, model: }
+      def call(model:, messages:, temperature: 0.7, stream: nil)
+        headers = {
+          "Content-Type"  => "application/json",
+          "Authorization" => "Bearer #{api_key}",
+          "HTTP-Referer"  => "https://github.com/the-teacher/ActiveHarness"
+        }
+        body = { model: model, messages: messages, temperature: temperature }
 
-        handle_error!(data)
+        if stream
+          body[:stream] = true
+          content = post_json_stream(API_URL, headers: headers, body: body, on_token: stream)
+          return { content: content, provider: :openrouter, model: model }
+        end
 
-        content = data.dig("choices", 0, "message", "content").to_s.strip
-        usage   = data["usage"] || {}
+        raw  = post_json(API_URL, headers: headers, body: body)
+        data = parse!(raw)
+        handle_error!(data)
 
-        build_response(
-          content:  content,
+        {
+          content:  data.dig("choices", 0, "message", "content").to_s.strip,
           provider: :openrouter,
-          model:    data["model"] || request.model,
-          usage:    { prompt: usage["prompt_tokens"], completion: usage["completion_tokens"] },
-          raw:      raw
-        )
+          model:    data["model"] || model,
+          usage:    extract_usage_openai(data)
+        }
       end
 
       private
 
-      def build_body(request)
-        body = {
-          model:       request.model,
-          messages:    request.messages,
-          temperature: request.temperature
-        }
-        body[:response_format] = { type: "json_object" } if request.response_format == :json
-        body.to_json
-      end
-
-      def post(body, timeout)
-        ActiveHarness.config.http_client.post(
-          API_URL,
-          headers: {
-            "Content-Type"  => "application/json",
-            "Authorization" => "Bearer #{api_key}",
-            "HTTP-Referer"  => "https://github.com/the-teacher/ActiveHarness"
-          },
-          body:    body,
-          timeout: timeout
-        )
+      def api_key
+        key = ENV["OPENROUTER_API_KEY"].to_s
+        raise Errors::InvalidApiKeyError, "OPENROUTER_API_KEY is not set" if key.empty?
+        key
       end
 
       def handle_error!(data)
         return unless data["error"]
 
-        error   = data["error"]
-        message = error["message"].to_s
-        code    = error["code"].to_s
-        meta    = error.reject { |k, _| k == "message" }
-        full    = meta.empty? ? message : "#{message} | #{meta.inspect}"
+        msg      = data.dig("error", "message").to_s
+        code     = data.dig("error", "code").to_s
+        metadata = data.dig("error", "metadata")
 
         case code
-        when "401"
-          raise Errors::InvalidApiKeyError, full
-        when "429"
-          raise Errors::RateLimitError, full
-        else
-          raise Errors::InvalidRequestError, full
+        when "401"        then raise Errors::InvalidApiKeyError.new(msg,       error_code: code, metadata: metadata)
+        when "402"        then raise Errors::RateLimitError.new(msg,           error_code: code, metadata: metadata)
+        when "429"        then raise Errors::RateLimitError.new(msg,           error_code: code, metadata: metadata)
+        when "500", "502",
+             "503", "504" then raise Errors::ProviderUnavailableError.new(msg, error_code: code, metadata: metadata)
+        else                   raise Errors::InvalidRequestError.new(msg,      error_code: code, metadata: metadata)
         end
       end
-
-      def api_key
-        key = ActiveHarness.config.openrouter_api_key
-        raise Errors::InvalidApiKeyError, "OPENROUTER_API_KEY not configured" if key.nil? || key.empty?
-        key
-      end
     end
   end
 end

data/lib/active_harness/railtie.rb

@@ -0,0 +1,12 @@
+module ActiveHarness
+  class Railtie < Rails::Railtie
+    APP_AI_DIRS = %w[agents prompts tribunals pipelines memory].freeze
+
+    initializer "active_harness.autoload_paths" do |app|
+      APP_AI_DIRS.each do |dir|
+        path = Rails.root.join("app", "ai", dir)
+        app.config.autoload_paths << path.to_s if path.exist?
+      end
+    end
+  end
+end

data/lib/active_harness/result.rb

@@ -0,0 +1,10 @@
+require "json"
+
+module ActiveHarness
+  # Minimal result wrapper returned by Agent#call.
+  #
+  # output — raw string from the provider
+  # parsed — for format :json: a Ruby Hash/Array; for format :text: same as output
+  # usage  — token counts: { input_tokens:, output_tokens:, total_tokens: } or nil for streaming
+  Result = Struct.new(:input, :output, :parsed, :system_prompt, :provider, :model, :temperature, :model_list, :attempts, :execution_time, :usage, keyword_init: true)
+end