prescient 0.6.0 → 0.8.0

data/lib/prescient/provider/openai.rb

@@ -1,192 +1,195 @@
 # frozen_string_literal: true
 
-require 'httparty'
+require "httparty"
+
+module Prescient
+  module Provider
+    # OpenAI API provider adapter.
+    class OpenAI < Prescient::Base
+      include HTTParty
+
+      base_uri "https://api.openai.com"
+
+      # Known embedding dimensions for OpenAI embedding models.
+      EMBEDDING_DIMENSIONS = {
+        "text-embedding-3-small" => 1536,
+        "text-embedding-3-large" => 3072,
+        "text-embedding-ada-002" => 1536
+      }.freeze
+
+      def initialize(**options)
+        super
+        @provider_name = "OpenAI"
+        self.class.default_timeout(@options[:timeout] || 60)
+      end
 
-# OpenAI API provider adapter.
-class Prescient::Provider::OpenAI < Prescient::Base
-  include HTTParty
+      # Generate an embedding through the OpenAI embeddings API.
+      # @param text [String] Text to embed
+      # @return [Array<Float>] Embedding vector
+      def generate_embedding(text, **options)
+        handle_errors do
+          clean_text_input = clean_text(text)
+
+          embedding_model = options[:model] || @options[:embedding_model]
+          response = self.class.post("/v1/embeddings",
+                                     headers: {
+                                       "Content-Type" => "application/json",
+                                       "Authorization" => "Bearer #{@options[:api_key]}"
+                                     },
+                                     body: {
+                                       model: embedding_model,
+                                       input: clean_text_input,
+                                       encoding_format: "float"
+                                     }.to_json)
 
-  base_uri 'https://api.openai.com'
+          validate_response!(response, "embedding generation")
 
-  # Known embedding dimensions for OpenAI embedding models.
-  EMBEDDING_DIMENSIONS = {
-    'text-embedding-3-small' => 1536,
-    'text-embedding-3-large' => 3072,
-    'text-embedding-ada-002' => 1536,
-  }.freeze
+          embedding_data = response.parsed_response.dig("data", 0, "embedding")
+          raise Prescient::InvalidResponseError, "No embedding returned" unless embedding_data
 
-  def initialize(**options)
-    super
-    @provider_name = 'OpenAI'
-    self.class.default_timeout(@options[:timeout] || 60)
-  end
+          expected_dimensions = EMBEDDING_DIMENSIONS[embedding_model] || @options[:embedding_dimensions]
+          unless expected_dimensions
+            raise Prescient::Error,
+                  "Embedding dimensions are required for model #{embedding_model}"
+          end
 
-  # Generate an embedding through the OpenAI embeddings API.
-  # @param text [String] Text to embed
-  # @return [Array<Float>] Embedding vector
-  def generate_embedding(text, **options)
-    handle_errors do
-      clean_text_input = clean_text(text)
-
-      embedding_model = options[:model] || @options[:embedding_model]
-      response = self.class.post('/v1/embeddings',
-                                 headers: {
-                                   'Content-Type'  => 'application/json',
-                                   'Authorization' => "Bearer #{@options[:api_key]}",
-                                 },
-                                 body:    {
-                                   model:           embedding_model,
-                                   input:           clean_text_input,
-                                   encoding_format: 'float',
-                                 }.to_json)
-
-      validate_response!(response, 'embedding generation')
-
-      embedding_data = response.parsed_response.dig('data', 0, 'embedding')
-      raise Prescient::InvalidResponseError, 'No embedding returned' unless embedding_data
-
-      expected_dimensions = EMBEDDING_DIMENSIONS[embedding_model] || @options[:embedding_dimensions]
-      unless expected_dimensions
-        raise Prescient::Error,
-              "Embedding dimensions are required for model #{embedding_model}"
+          validate_embedding_dimensions(embedding_data, expected_dimensions)
+        end
       end
 
-      validate_embedding_dimensions(embedding_data, expected_dimensions)
-    end
-  end
-
-  # Generate a response through the OpenAI chat completions API.
-  # @param prompt [String] Prompt to send
-  # @param context_items [Array<Hash, String>] Optional context items
-  # @return [Hash] Normalized response data
-  def generate_response(prompt, context_items = [], **options)
-    handle_errors do
-      formatted_prompt = build_prompt(prompt, context_items)
-
-      response = self.class.post('/v1/chat/completions',
-                                 headers: {
-                                   'Content-Type'  => 'application/json',
-                                   'Authorization' => "Bearer #{@options[:api_key]}",
-                                 },
-                                 body:    {
-                                   model:       options[:model] || @options[:chat_model],
-                                   messages:    [
-                                     {
-                                       role:    'user',
-                                       content: formatted_prompt,
+      # Generate a response through the OpenAI chat completions API.
+      # @param prompt [String] Prompt to send
+      # @param context_items [Array<Hash, String>] Optional context items
+      # @return [Hash] Normalized response data
+      def generate_response(prompt, context_items = [], **options)
+        handle_errors do
+          formatted_prompt = build_prompt(prompt, context_items)
+
+          response = self.class.post("/v1/chat/completions",
+                                     headers: {
+                                       "Content-Type" => "application/json",
+                                       "Authorization" => "Bearer #{@options[:api_key]}"
                                      },
-                                   ],
-                                   max_tokens:  options[:max_tokens] || 2000,
-                                   temperature: options[:temperature] || 0.7,
-                                   top_p:       options[:top_p] || 0.9,
-                                 }.to_json)
-
-      validate_response!(response, 'text generation')
-
-      puts "response.parsed_response: #{response.parsed_response.inspect}"
-
-      content = response.parsed_response.dig('choices', 0, 'message', 'content')
-      raise Prescient::InvalidResponseError, 'No response generated' unless content
-
-      {
-        response:        content.strip,
-        model:           options[:model] || @options[:chat_model],
-        provider:        'openai',
-        processing_time: nil,
-        metadata:        {
-          usage:         response.parsed_response['usage'],
-          finish_reason: response.parsed_response.dig('choices', 0, 'finish_reason'),
-        },
-      }
-    end
-  end
-
-  # Check OpenAI model availability via `/v1/models`.
-  #
-  # `reachable` indicates the API answered successfully. `ready` indicates that
-  # both configured models appear in the returned model list.
-  #
-  # @return [Hash] Provider health information
-  def health_check
-    handle_errors do
-      response = self.class.get('/v1/models',
-                                headers: {
-                                  'Authorization' => "Bearer #{@options[:api_key]}",
-                                })
-
-      if response.success?
-        models = response.parsed_response['data'] || []
-        embedding_available = models.any? { |m| m['id'] == @options[:embedding_model] }
-        chat_available = models.any? { |m| m['id'] == @options[:chat_model] }
-
-        {
-          status:           'healthy',
-          provider:         'openai',
-          reachable:        true,
-          models_available: models.map { |m| m['id'] },
-          embedding_model:  {
-            name:      @options[:embedding_model],
-            available: embedding_available,
-          },
-          chat_model:       {
-            name:      @options[:chat_model],
-            available: chat_available,
-          },
-          ready:            embedding_available && chat_available,
-        }
-      else
-        {
-          status:    'unhealthy',
-          provider:  'openai',
-          reachable: true,
-          error:     "HTTP #{response.code}",
-          message:   response.message,
-          ready:     false,
-        }
+                                     body: {
+                                       model: options[:model] || @options[:chat_model],
+                                       messages: [
+                                         {
+                                           role: "user",
+                                           content: formatted_prompt
+                                         }
+                                       ],
+                                       max_tokens: options[:max_tokens] || 2000,
+                                       temperature: options[:temperature] || 0.7,
+                                       top_p: options[:top_p] || 0.9
+                                     }.to_json)
+
+          validate_response!(response, "text generation")
+
+          content = response.parsed_response.dig("choices", 0, "message", "content")
+          raise Prescient::InvalidResponseError, "No response generated" unless content
+
+          {
+            response: content.strip,
+            model: options[:model] || @options[:chat_model],
+            provider: "openai",
+            processing_time: nil,
+            metadata: {
+              usage: response.parsed_response["usage"],
+              finish_reason: response.parsed_response.dig("choices", 0, "finish_reason")
+            }
+          }
+        end
       end
-    end
-  rescue Prescient::Error => e
-    {
-      status:    'unavailable',
-      provider:  'openai',
-      reachable: false,
-      error:     e.class.name,
-      message:   e.message,
-      ready:     false,
-    }
-  end
 
-  # List models available to the configured OpenAI account.
-  #
-  # @return [Array<Hash>] Model descriptors
-  def list_models
-    handle_errors do
-      response = self.class.get('/v1/models',
-                                headers: {
-                                  'Authorization' => "Bearer #{@options[:api_key]}",
-                                })
-      validate_response!(response, 'model listing')
-
-      models = response.parsed_response['data'] || []
-      models.map do |model|
+      # Check OpenAI model availability via `/v1/models`.
+      #
+      # `reachable` indicates the API answered successfully. `ready` indicates that
+      # both configured models appear in the returned model list.
+      #
+      # @return [Hash] Provider health information
+      # rubocop:disable Metrics/MethodLength
+      def health_check
+        handle_errors do
+          response = self.class.get("/v1/models",
+                                    headers: {
+                                      "Authorization" => "Bearer #{@options[:api_key]}"
+                                    })
+
+          if response.success?
+            models = response.parsed_response["data"] || []
+            embedding_available = models.any? { |m| m["id"] == @options[:embedding_model] }
+            chat_available = models.any? { |m| m["id"] == @options[:chat_model] }
+
+            {
+              status: "healthy",
+              provider: "openai",
+              reachable: true,
+              models_available: models.map { |m| m["id"] },
+              embedding_model: {
+                name: @options[:embedding_model],
+                available: embedding_available
+              },
+              chat_model: {
+                name: @options[:chat_model],
+                available: chat_available
+              },
+              ready: embedding_available && chat_available
+            }
+          else
+            {
+              status: "unhealthy",
+              provider: "openai",
+              reachable: true,
+              error: "HTTP #{response.code}",
+              message: response.message,
+              ready: false
+            }
+          end
+        end
+      rescue Prescient::Error => e
         {
-          name:     model['id'],
-          created:  model['created'],
-          owned_by: model['owned_by'],
+          status: "unavailable",
+          provider: "openai",
+          reachable: false,
+          error: e.class.name,
+          message: e.message,
+          ready: false
         }
       end
-    end
-  end
+      # rubocop:enable Metrics/MethodLength
+
+      # List models available to the configured OpenAI account.
+      #
+      # @return [Array<Hash>] Model descriptors
+      def list_models
+        handle_errors do
+          response = self.class.get("/v1/models",
+                                    headers: {
+                                      "Authorization" => "Bearer #{@options[:api_key]}"
+                                    })
+          validate_response!(response, "model listing")
+
+          models = response.parsed_response["data"] || []
+          models.map do |model|
+            {
+              name: model["id"],
+              created: model["created"],
+              owned_by: model["owned_by"]
+            }
+          end
+        end
+      end
 
-  protected
+      protected
 
-  def validate_configuration!
-    required_options = [:api_key, :embedding_model, :chat_model]
-    missing_options = required_options.select { |opt| @options[opt].nil? }
+      def validate_configuration!
+        required_options = %i[api_key embedding_model chat_model]
+        missing_options = required_options.select { |opt| @options[opt].nil? }
 
-    return unless missing_options.any?
+        return unless missing_options.any?
 
-    raise Prescient::Error, "Missing required options: #{missing_options.join(', ')}"
+        raise Prescient::Error, "Missing required options: #{missing_options.join(", ")}"
+      end
+    end
   end
-
 end

data/lib/prescient/provider/xai.rb

@@ -1,139 +1,143 @@
 # frozen_string_literal: true
 
-require 'httparty'
+require "httparty"
 
-# xAI API provider adapter.
-class Prescient::Provider::XAI < Prescient::Base
-  include HTTParty
+module Prescient
+  module Provider
+    # xAI API provider adapter.
+    class XAI < Prescient::Base
+      include HTTParty
 
-  base_uri 'https://api.x.ai'
+      base_uri "https://api.x.ai"
 
-  def initialize(**options)
-    super
-    @provider_name = 'xAI'
-    self.class.default_timeout(@options[:timeout] || 60)
-  end
-
-  # xAI does not expose a standard embeddings API for this adapter.
-  # @raise [Prescient::Error] Always, because embeddings are unsupported
-  def generate_embedding(_text, **_options)
-    raise Prescient::Error, 'xAI provider does not support embeddings.'
-  end
-
-  # Generate a response through xAI's OpenAI-compatible chat API.
-  # @param prompt [String] Prompt to send
-  # @param context_items [Array<Hash, String>] Optional context items
-  # @return [Hash] Normalized response data
-  def generate_response(prompt, context_items = [], **options)
-    handle_errors do
-      model = options[:model] || @options[:chat_model]
-      response = self.class.post(
-        '/v1/chat/completions',
-        headers: api_headers,
-        body:    {
-          model:       model,
-          messages:    [{ role: 'user', content: build_prompt(prompt, context_items) }],
-          max_tokens:  options[:max_tokens] || 2000,
-          temperature: options[:temperature] || 0.7,
-          top_p:       options[:top_p] || 0.9,
-        }.to_json,
-      )
-
-      validate_response!(response, 'text generation')
-
-      parsed_response = response.parsed_response
-      content = parsed_response.dig('choices', 0, 'message', 'content')
-      raise Prescient::InvalidResponseError, 'No response generated' unless content.is_a?(String) && !content.empty?
-
-      {
-        response:        content.strip,
-        model:           model,
-        provider:        'xai',
-        processing_time: nil,
-        metadata:        {
-          usage:         parsed_response['usage'],
-          finish_reason: parsed_response.dig('choices', 0, 'finish_reason'),
-        },
-      }
-    end
-  end
+      def initialize(**options)
+        super
+        @provider_name = "xAI"
+        self.class.default_timeout(@options[:timeout] || 60)
+      end
 
-  # Check whether the configured xAI model is available.
-  # @return [Hash] Provider health information
-  def health_check
-    handle_errors do
-      response = self.class.get('/v1/models', headers: api_headers)
+      # xAI does not expose a standard embeddings API for this adapter.
+      # @raise [Prescient::Error] Always, because embeddings are unsupported
+      def generate_embedding(_text, **_options)
+        raise Prescient::Error, "xAI provider does not support embeddings."
+      end
 
-      if response.success?
-        models = response.parsed_response['data'] || []
-        model_available = models.any? { |model| model['id'] == @options[:chat_model] }
+      # Generate a response through xAI's OpenAI-compatible chat API.
+      # @param prompt [String] Prompt to send
+      # @param context_items [Array<Hash, String>] Optional context items
+      # @return [Hash] Normalized response data
+      def generate_response(prompt, context_items = [], **options)
+        handle_errors do
+          model = options[:model] || @options[:chat_model]
+          response = self.class.post(
+            "/v1/chat/completions",
+            headers: api_headers,
+            body: {
+              model: model,
+              messages: [{ role: "user", content: build_prompt(prompt, context_items) }],
+              max_tokens: options[:max_tokens] || 2000,
+              temperature: options[:temperature] || 0.7,
+              top_p: options[:top_p] || 0.9
+            }.to_json
+          )
+
+          validate_response!(response, "text generation")
+
+          parsed_response = response.parsed_response
+          content = parsed_response.dig("choices", 0, "message", "content")
+          raise Prescient::InvalidResponseError, "No response generated" unless content.is_a?(String) && !content.empty?
+
+          {
+            response: content.strip,
+            model: model,
+            provider: "xai",
+            processing_time: nil,
+            metadata: {
+              usage: parsed_response["usage"],
+              finish_reason: parsed_response.dig("choices", 0, "finish_reason")
+            }
+          }
+        end
+      end
 
+      # Check whether the configured xAI model is available.
+      # @return [Hash] Provider health information
+      def health_check
+        handle_errors do
+          response = self.class.get("/v1/models", headers: api_headers)
+
+          if response.success?
+            models = response.parsed_response["data"] || []
+            model_available = models.any? { |model| model["id"] == @options[:chat_model] }
+
+            {
+              status: "healthy",
+              provider: "xai",
+              reachable: true,
+              models_available: models.map { |model| model["id"] },
+              chat_model: { name: @options[:chat_model], available: model_available },
+              ready: model_available
+            }
+          else
+            {
+              status: "unhealthy",
+              provider: "xai",
+              reachable: true,
+              error: "HTTP #{response.code}",
+              message: response.message,
+              ready: false
+            }
+          end
+        end
+      rescue Prescient::Error => e
         {
-          status:           'healthy',
-          provider:         'xai',
-          reachable:        true,
-          models_available: models.map { |model| model['id'] },
-          chat_model:       { name: @options[:chat_model], available: model_available },
-          ready:            model_available,
-        }
-      else
-        {
-          status:    'unhealthy',
-          provider:  'xai',
-          reachable: true,
-          error:     "HTTP #{response.code}",
-          message:   response.message,
-          ready:     false,
+          status: "unavailable",
+          provider: "xai",
+          reachable: false,
+          error: e.class.name,
+          message: e.message,
+          ready: false
         }
       end
-    end
-  rescue Prescient::Error => e
-    {
-      status:    'unavailable',
-      provider:  'xai',
-      reachable: false,
-      error:     e.class.name,
-      message:   e.message,
-      ready:     false,
-    }
-  end
-
-  # List models available to the configured xAI API key.
-  # @return [Array<Hash>] Model descriptors
-  def list_models
-    handle_errors do
-      response = self.class.get('/v1/models', headers: api_headers)
-      validate_response!(response, 'model listing')
 
-      (response.parsed_response['data'] || []).map do |model|
-        {
-          name:           model['id'],
-          object:         model['object'],
-          created:        model['created'],
-          owned_by:       model['owned_by'],
-          context_length: model['context_length'],
-        }.compact
+      # List models available to the configured xAI API key.
+      # @return [Array<Hash>] Model descriptors
+      def list_models
+        handle_errors do
+          response = self.class.get("/v1/models", headers: api_headers)
+          validate_response!(response, "model listing")
+
+          (response.parsed_response["data"] || []).map do |model|
+            {
+              name: model["id"],
+              object: model["object"],
+              created: model["created"],
+              owned_by: model["owned_by"],
+              context_length: model["context_length"]
+            }.compact
+          end
+        end
       end
-    end
-  end
 
-  protected
+      protected
 
-  def validate_configuration!
-    required_options = [:api_key, :chat_model]
-    missing_options = required_options.select { |option| @options[option].nil? }
+      def validate_configuration!
+        required_options = %i[api_key chat_model]
+        missing_options = required_options.select { |option| @options[option].nil? }
 
-    return unless missing_options.any?
+        return unless missing_options.any?
 
-    raise Prescient::Error, "Missing required options: #{missing_options.join(', ')}"
-  end
+        raise Prescient::Error, "Missing required options: #{missing_options.join(", ")}"
+      end
 
-  private
+      private
 
-  def api_headers
-    {
-      'Content-Type'  => 'application/json',
-      'Authorization' => "Bearer #{@options[:api_key]}",
-    }
+      def api_headers
+        {
+          "Content-Type" => "application/json",
+          "Authorization" => "Bearer #{@options[:api_key]}"
+        }
+      end
+    end
   end
 end