boxcars 0.7.7 → 0.8.1

data/lib/boxcars/engine/groq.rb

@@ -1,119 +1,170 @@
 # frozen_string_literal: true
 
-# Boxcars is a framework for running a series of tools to get an answer to a question.
+require 'openai' # Groq uses the OpenAI gem with a custom URI base
+require 'json'
+
 module Boxcars
   # A engine that uses Groq's API.
   class Groq < Engine
-    attr_reader :prompts, :groq_parmas, :model_kwargs, :batch_size
+    include UnifiedObservability
+    attr_reader :prompts, :groq_params, :model_kwargs, :batch_size
 
-    # The default parameters to use when asking the engine.
     DEFAULT_PARAMS = {
       model: "llama3-70b-8192",
       temperature: 0.1,
-      max_tokens: 4096
+      max_tokens: 4096 # Groq API might have specific limits or naming for this
     }.freeze
-
-    # the default name of the engine
     DEFAULT_NAME = "Groq engine"
-    # the default description of the engine
-    DEFAULT_DESCRIPTION = "useful for when you need to use AI to answer questions. " \
+    DEFAULT_DESCRIPTION = "useful for when you need to use Groq AI to answer questions. " \
                           "You should ask targeted questions"
 
-    # A engine is a container for a single tool to run.
-    # @param name [String] The name of the engine. Defaults to "Groq engine".
-    # @param description [String] A description of the engine. Defaults to:
-    #        useful for when you need to use AI to answer questions. You should ask targeted questions".
-    # @param prompts [Array<String>] The prompts to use when asking the engine. Defaults to [].
-    # @param batch_size [Integer] The number of prompts to send to the engine at once. Defaults to 20.
     def initialize(name: DEFAULT_NAME, description: DEFAULT_DESCRIPTION, prompts: [], batch_size: 20, **kwargs)
-      @groq_parmas = DEFAULT_PARAMS.merge(kwargs)
+      @groq_params = DEFAULT_PARAMS.merge(kwargs) # Corrected typo here
       @prompts = prompts
       @batch_size = batch_size
-      super(description: description, name: name)
+      super(description:, name:)
     end
 
-    # Get the OpenAI API client
-    # @param groq_api_key [String] The access token to use when asking the engine.
-    #   Defaults to Boxcars.configuration.groq_api_key
-    # @return [OpenAI::Client] The OpenAI API gem client.
-    def self.open_ai_client(groq_api_key: nil)
-      access_token = Boxcars.configuration.groq_api_key(groq_api_key: groq_api_key)
-      ::OpenAI::Client.new(access_token: access_token, uri_base: "https://api.groq.com/openai")
+    # Renamed from open_ai_client to groq_client for clarity
+    def self.groq_client(groq_api_key: nil)
+      access_token = Boxcars.configuration.groq_api_key(groq_api_key:)
+      ::OpenAI::Client.new(access_token:, uri_base: "https://api.groq.com/openai/v1")
+      # Adjusted uri_base to include /v1 as is common for OpenAI-compatible APIs
     end
 
-    def conversation_model?(_model)
+    # Groq models are typically conversational.
+    def conversation_model?(_model_name)
       true
     end
 
-    # Get an answer from the engine.
-    # @param prompt [String] The prompt to use when asking the engine.
-    # @param groq_api_key [String] The access token to use when asking the engine.
-    #   Defaults to Boxcars.configuration.groq_api_key.
-    # @param kwargs [Hash] Additional parameters to pass to the engine if wanted.
     def client(prompt:, inputs: {}, groq_api_key: nil, **kwargs)
-      clnt = Groq.open_ai_client(groq_api_key: groq_api_key)
-      params = groq_parmas.merge(kwargs)
-      prompt = prompt.first if prompt.is_a?(Array)
-      params = prompt.as_messages(inputs).merge(params)
-      if Boxcars.configuration.log_prompts
-        Boxcars.debug(params[:messages].last(2).map { |p| ">>>>>> Role: #{p[:role]} <<<<<<\n#{p[:content]}" }.join("\n"), :cyan)
+      start_time = Time.now
+      response_data = { response_obj: nil, parsed_json: nil, success: false, error: nil, status_code: nil }
+      current_params = @groq_params.merge(kwargs)
+      current_prompt_object = prompt.is_a?(Array) ? prompt.first : prompt
+      api_request_params = nil # Initialize
+
+      begin
+        clnt = Groq.groq_client(groq_api_key:)
+        api_request_params = _prepare_groq_request_params(current_prompt_object, inputs, current_params)
+
+        log_messages_debug(api_request_params[:messages]) if Boxcars.configuration.log_prompts && api_request_params[:messages]
+
+        _execute_and_process_groq_call(clnt, api_request_params, response_data)
+      rescue ::OpenAI::Error => e
+        _handle_openai_error_for_groq(e, response_data)
+      rescue StandardError => e
+        _handle_standard_error_for_groq(e, response_data)
+      ensure
+        duration_ms = ((Time.now - start_time) * 1000).round
+        request_context = {
+          prompt: current_prompt_object,
+          inputs:,
+          conversation_for_api: api_request_params&.dig(:messages)
+        }
+        track_ai_generation(
+          duration_ms:,
+          current_params:,
+          request_context:,
+          response_data:,
+          provider: :groq
+        )
       end
-      clnt.chat(parameters: params)
-    rescue => e
-      Boxcars.error(e, :red)
-      raise
+
+      _groq_handle_call_outcome(response_data:)
     end
 
-    # get an answer from the engine for a question.
-    # @param question [String] The question to ask the engine.
-    # @param kwargs [Hash] Additional parameters to pass to the engine if wanted.
-    def run(question, **kwargs)
+    def run(question, **)
       prompt = Prompt.new(template: question)
-      response = client(prompt: prompt, **kwargs)
-      raise Error, "Groq: No response from API" unless response
-
-      check_response(response)
-      response["choices"].map { |c| c.dig("message", "content") || c["text"] }.join("\n").strip
+      answer = client(prompt:, inputs: {}, **)
+      Boxcars.debug("Answer: #{answer}", :cyan)
+      answer
     end
 
-    # Get the default parameters for the engine.
     def default_params
-      groq_parmas
+      @groq_params # Use instance variable
+    end
+
+    private
+
+    # Helper methods for the client method
+    def _prepare_groq_request_params(prompt_object, inputs, current_params)
+      messages_hash_from_prompt = prompt_object.as_messages(inputs)
+      actual_messages_for_api = messages_hash_from_prompt[:messages]
+      { messages: actual_messages_for_api }.merge(current_params)
     end
 
-    # make sure we got a valid response
-    # @param response [Hash] The response to check.
-    # @param must_haves [Array<String>] The keys that must be in the response. Defaults to %w[choices].
-    # @raise [KeyError] if there is an issue with the access token.
-    # @raise [ValueError] if the response is not valid.
+    def _execute_and_process_groq_call(clnt, api_request_params, response_data)
+      raw_response = clnt.chat(parameters: api_request_params)
+      response_data[:response_obj] = raw_response
+      response_data[:parsed_json] = raw_response # OpenAI gem returns Hash
+
+      if raw_response && !raw_response["error"] && raw_response["choices"]
+        response_data[:success] = true
+        response_data[:status_code] = 200 # Inferred
+      else
+        response_data[:success] = false
+        err_details = raw_response["error"] if raw_response
+        msg = if err_details
+                (err_details.is_a?(Hash) ? err_details['message'] : err_details).to_s
+              else
+                "Unknown Groq API Error"
+              end
+        response_data[:error] ||= StandardError.new(msg) # Use ||= to not overwrite existing exception
+      end
+    end
+
+    def _handle_openai_error_for_groq(error, response_data)
+      response_data[:error] = error
+      response_data[:success] = false
+      response_data[:status_code] = error.http_status if error.respond_to?(:http_status)
+    end
+
+    def _handle_standard_error_for_groq(error, response_data)
+      response_data[:error] = error
+      response_data[:success] = false
+    end
+
+    def log_messages_debug(messages)
+      return unless messages.is_a?(Array)
+
+      Boxcars.debug(messages.last(2).map { |p| ">>>>>> Role: #{p[:role]} <<<<<<\n#{p[:content]}" }.join("\n"), :cyan)
+    end
+
+    def _groq_handle_call_outcome(response_data:)
+      if response_data[:error]
+        Boxcars.error("Groq Error: #{response_data[:error].message} (#{response_data[:error].class.name})", :red)
+        raise response_data[:error]
+      elsif !response_data[:success]
+        err_details = response_data.dig(:response_obj, "error")
+        msg = if err_details
+                err_details.is_a?(Hash) ? "#{err_details['type']}: #{err_details['message']}" : err_details.to_s
+              else
+                "Unknown error from Groq API"
+              end
+        raise Error, msg
+      else
+        choices = response_data.dig(:parsed_json, "choices")
+        raise Error, "Groq: No choices found in response" unless choices.is_a?(Array) && !choices.empty?
+
+        choices.map { |c| c.dig("message", "content") || c["text"] }.join("\n").strip
+      end
+    end
+
+    # Retaining check_response if run method or other parts still use it.
     def check_response(response, must_haves: %w[choices])
       if response['error'].is_a?(Hash)
         code = response.dig('error', 'code')
         msg = response.dig('error', 'message') || 'unknown error'
-        raise KeyError, "GROQ_API_TOKEN not valid" if code == 'invalid_api_key'
+        # GROQ_API_TOKEN is not standard, usually it's an API key.
+        raise KeyError, "Groq API Key not valid or permission issue" if ['invalid_api_key', 'permission_denied'].include?(code)
 
         raise ValueError, "Groq error: #{msg}"
       end
 
       must_haves.each do |key|
-        raise ValueError, "Expecting key #{key} in response" unless response.key?(key)
+        raise ValueError, "Expecting key #{key} in response" unless response.key?(key) && !response[key].empty?
       end
     end
-
-    # the engine type
-    def engine_type
-      "groq"
-    end
-
-    # Calculate the maximum number of tokens possible to generate for a prompt.
-    # @param prompt_text [String] The prompt text to use.
-    # @return [Integer] the number of tokens possible to generate.
-    def max_tokens_for_prompt(prompt_text)
-      num_tokens = get_num_tokens(prompt_text)
-
-      # get max context size for model by name
-      max_size = 8096
-      max_size - num_tokens
-    end
   end
 end

data/lib/boxcars/engine/intelligence_base.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 require 'intelligence'
+require_relative 'unified_observability'
 
 module Boxcars
   # A Base class for all Intelligence Engines
   class IntelligenceBase < Engine
+    include Boxcars::UnifiedObservability
     attr_reader :provider, :all_params
 
     # The base Intelligence Engine is used by other engines to generate output from prompts
@@ -16,8 +18,9 @@ module Boxcars
     # @param kwargs [Hash] Additional parameters to pass to the Engine.
     def initialize(provider:, description:, name:, prompts: [], batch_size: 20, **kwargs)
       @provider = provider
+      # Start with defaults, merge other kwargs, then explicitly set model if provided in initialize
       @all_params = default_model_params.merge(kwargs)
-      super(description: description, name: name, prompts: prompts, batch_size: batch_size)
+      super(description:, name:, prompts:, batch_size:)
     end
 
     # can be overridden by provider subclass
@@ -30,9 +33,10 @@ module Boxcars
     end
 
     def adapter(params:, api_key:)
-      Intelligence::Adapter[provider].new(
-        { key: api_key, chat_options: params }
-      )
+      Intelligence::Adapter.build! @provider do |config|
+        config.key api_key
+        config.chat_options params
+      end
     end
 
     # Process different content types
@@ -59,25 +63,56 @@ module Boxcars
     # Get an answer from the engine
     def client(prompt:, inputs: {}, api_key: nil, **kwargs)
       params = all_params.merge(kwargs)
-      api_key ||= lookup_provider_api_key(params: params)
+      api_key ||= lookup_provider_api_key(params:)
       raise Error, "No API key found for #{provider}" unless api_key
 
-      adapter = adapter(api_key: api_key, params: params)
-      convo = prompt.as_intelligence_conversation(inputs: inputs)
-      request = Intelligence::ChatRequest.new(adapter: adapter)
-      response = request.chat(convo)
-      return JSON.parse(response.body) if response.success?
-
-      raise Error, (response&.reason_phrase || "No response from API #{provider}")
-    rescue StandardError => e
-      Boxcars.error("#{provider} Error: #{e.message}", :red)
-      raise
+      adapter = adapter(api_key:, params:)
+      convo = prompt.as_intelligence_conversation(inputs:)
+      request_context = { prompt: prompt&.as_prompt(inputs:)&.[](:prompt), inputs:, conversation_for_api: convo.to_h }
+      request = Intelligence::ChatRequest.new(adapter:)
+
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      response_obj = nil
+
+      begin
+        response_obj = request.chat(convo)
+        duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000
+
+        if response_obj.success?
+          success = true
+          parsed_json_response = JSON.parse(response_obj.body)
+          response_data = { success:, parsed_json: parsed_json_response, response_obj:,
+                            status_code: response_obj.status }
+          track_ai_generation(duration_ms:, current_params: params, request_context:, response_data:, provider:)
+          parsed_json_response
+        else
+          success = false
+          error_message = response_obj&.reason_phrase || "No response from API #{provider}"
+          response_data = { success:, error: StandardError.new(error_message), response_obj:,
+                            status_code: response_obj.status }
+          track_ai_generation(duration_ms:, current_params: params, request_context:, response_data:, provider:)
+          raise Error, error_message
+        end
+      rescue Error => e
+        # Re-raise Error exceptions (like the one above) without additional tracking
+        # since they were already tracked in the else branch
+        Boxcars.error("#{provider} Error: #{e.message}", :red)
+        raise
+      rescue StandardError => e
+        duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000
+        success = false
+        error_obj = e
+        response_data = { success:, error: error_obj, response_obj:, status_code: response_obj&.status }
+        track_ai_generation(duration_ms:, current_params: params, request_context:, response_data:, provider:)
+        Boxcars.error("#{provider} Error: #{e.message}", :red)
+        raise
+      end
     end
 
     # Run the engine with a question
-    def run(question, **kwargs)
+    def run(question, **)
       prompt = Prompt.new(template: question)
-      response = client(prompt: prompt, **kwargs)
+      response = client(prompt:, **)
       extract_answer(response)
     end
 

data/lib/boxcars/engine/ollama.rb

@@ -1,80 +1,160 @@
 # frozen_string_literal: true
 
-# Boxcars is a framework for running a series of tools to get an answer to a question.
+require 'openai' # Ollama uses the OpenAI gem with a custom URI base
+require 'json'
+
 module Boxcars
-  # A engine that uses local GPT4All API.
+  # A engine that uses a local Ollama API (OpenAI-compatible).
   class Ollama < Engine
+    include UnifiedObservability
     attr_reader :prompts, :model_kwargs, :batch_size, :ollama_params
 
-    # The default parameters to use when asking the engine.
     DEFAULT_PARAMS = {
-      model: "llama3",
+      model: "llama3", # Default model for Ollama
       temperature: 0.1,
-      max_tokens: 4096
+      max_tokens: 4096 # Check if Ollama respects this or has its own limits
     }.freeze
-
-    # the default name of the engine
     DEFAULT_NAME = "Ollama engine"
-    # the default description of the engine
     DEFAULT_DESCRIPTION = "useful for when you need to use local AI to answer questions. " \
                           "You should ask targeted questions"
 
-    # A engine is a container for a single tool to run.
-    # @param name [String] The name of the engine. Defaults to "OpenAI engine".
-    # @param description [String] A description of the engine. Defaults to:
-    #        useful for when you need to use AI to answer questions. You should ask targeted questions".
-    # @param prompts [Array<String>] The prompts to use when asking the engine. Defaults to [].
-    # @param batch_size [Integer] The number of prompts to send to the engine at once. Defaults to 2.
     def initialize(name: DEFAULT_NAME, description: DEFAULT_DESCRIPTION, prompts: [], batch_size: 2, **kwargs)
       @ollama_params = DEFAULT_PARAMS.merge(kwargs)
       @prompts = prompts
-      @batch_size = batch_size
-      super(description: description, name: name)
+      @batch_size = batch_size # Retain if used by other methods
+      super(description:, name:)
     end
 
-    # Get the OpenAI API client
-    # @param groq_api_key [String] The access token to use when asking the engine.
-    #   Defaults to Boxcars.configuration.groq_api_key
-    # @return [OpenAI::Client] The OpenAI API gem client.
-    def self.open_ai_client
-      ::OpenAI::Client.new(uri_base: "http://localhost:11434")
+    # Renamed from open_ai_client to ollama_client for clarity
+    # Ollama doesn't use an API key by default.
+    def self.ollama_client
+      # The OpenAI gem requires an access_token, even if the local service doesn't.
+      # Provide a dummy one if not needed, or allow configuration if Ollama setup requires one.
+      ::OpenAI::Client.new(access_token: "ollama-dummy-key", uri_base: "http://localhost:11434/v1")
+      # Added /v1 to uri_base, as OpenAI-compatible endpoints often version this way.
+      # Verify Ollama's actual OpenAI-compatible endpoint path.
     end
 
-    def conversation_model?(_model)
+    # Ollama models are typically conversational.
+    def conversation_model?(_model_name)
       true
     end
 
-    # Get an answer from the engine.
-    # @param prompt [String] The prompt to use when asking the engine.
-    # @param groq_api_key [String] The access token to use when asking the engine.
-    #   Defaults to Boxcars.configuration.groq_api_key.
-    # @param kwargs [Hash] Additional parameters to pass to the engine if wanted.
     def client(prompt:, inputs: {}, **kwargs)
-      clnt = Ollama.open_ai_client
-      params = ollama_params.merge(kwargs)
-      prompt = prompt.first if prompt.is_a?(Array)
-      params = prompt.as_messages(inputs).merge(params)
-      if Boxcars.configuration.log_prompts
-        Boxcars.debug(params[:messages].last(2).map { |p| ">>>>>> Role: #{p[:role]} <<<<<<\n#{p[:content]}" }.join("\n"), :cyan)
+      start_time = Time.now
+      response_data = { response_obj: nil, parsed_json: nil, success: false, error: nil, status_code: nil }
+      current_params = @ollama_params.merge(kwargs)
+      current_prompt_object = prompt.is_a?(Array) ? prompt.first : prompt
+      api_request_params = nil # Initialize
+
+      begin
+        clnt = Ollama.ollama_client
+        api_request_params = _prepare_ollama_request_params(current_prompt_object, inputs, current_params)
+
+        log_messages_debug(api_request_params[:messages]) if Boxcars.configuration.log_prompts && api_request_params[:messages]
+
+        _execute_and_process_ollama_call(clnt, api_request_params, response_data)
+      rescue ::OpenAI::Error => e
+        _handle_openai_error_for_ollama(e, response_data)
+      rescue StandardError => e
+        _handle_standard_error_for_ollama(e, response_data)
+      ensure
+        duration_ms = ((Time.now - start_time) * 1000).round
+        request_context = {
+          prompt: current_prompt_object,
+          inputs:,
+          conversation_for_api: api_request_params&.dig(:messages)
+        }
+        track_ai_generation(
+          duration_ms:,
+          current_params:,
+          request_context:,
+          response_data:,
+          provider: :ollama
+        )
       end
-      ans = clnt.chat(parameters: params)
-      ans['choices'].pluck('message').pluck('content').join("\n")
-    rescue => e
-      Boxcars.error(e, :red)
-      raise
+
+      _ollama_handle_call_outcome(response_data:)
     end
 
-    # get an answer from the engine for a question.
-    # @param question [String] The question to ask the engine.
-    # @param kwargs [Hash] Additional parameters to pass to the engine if wanted.
-    def run(question, **kwargs)
+    def run(question, **)
       prompt = Prompt.new(template: question)
-      answer = client(prompt: prompt, **kwargs)
-      raise Error, "Ollama: No response from API" unless answer
-
-      # raise Error, "Ollama: #{response['error']}" if response["error"]
+      answer = client(prompt:, inputs: {}, **) # Pass empty inputs hash
       Boxcars.debug("Answer: #{answer}", :cyan)
       answer
     end
+
+    def default_params
+      @ollama_params
+    end
+
+    private
+
+    # Helper methods for the client method
+    def _prepare_ollama_request_params(prompt_object, inputs, current_params)
+      # prompt_object.as_messages(inputs) returns a hash like { messages: [...] }
+      # We need to extract the array of messages for the API call.
+      actual_messages_array = prompt_object.as_messages(inputs)[:messages]
+      { messages: actual_messages_array }.merge(current_params)
+    end
+
+    def _execute_and_process_ollama_call(clnt, api_request_params, response_data)
+      raw_response = clnt.chat(parameters: api_request_params)
+      response_data[:response_obj] = raw_response
+      response_data[:parsed_json] = raw_response # OpenAI gem returns Hash
+
+      if raw_response && !raw_response["error"] && raw_response["choices"]
+        response_data[:success] = true
+        response_data[:status_code] = 200 # Inferred for local success
+      else
+        response_data[:success] = false
+        err_details = raw_response["error"] if raw_response
+        msg = if err_details
+                (err_details.is_a?(Hash) ? err_details['message'] : err_details).to_s
+              else
+                "Unknown Ollama API Error"
+              end
+        response_data[:error] ||= Error.new(msg) # Use ||= to not overwrite existing exception
+      end
+    end
+
+    def _handle_openai_error_for_ollama(error, response_data)
+      response_data[:error] = error
+      response_data[:success] = false
+      response_data[:status_code] = error.http_status if error.respond_to?(:http_status)
+    end
+
+    def _handle_standard_error_for_ollama(error, response_data)
+      response_data[:error] = error
+      response_data[:success] = false
+    end
+
+    def log_messages_debug(messages)
+      return unless messages.is_a?(Array)
+
+      Boxcars.debug(messages.last(2).map { |p| ">>>>>> Role: #{p[:role]} <<<<<<\n#{p[:content]}" }.join("\n"), :cyan)
+    end
+
+    def _ollama_handle_call_outcome(response_data:)
+      if response_data[:error]
+        Boxcars.error("Ollama Error: #{response_data[:error].message} (#{response_data[:error].class.name})", :red)
+        raise response_data[:error] # Re-raise the original error
+      elsif !response_data[:success]
+        # This case handles errors returned in the response body but not raised as OpenAI::Error
+        err_details = response_data.dig(:response_obj, "error")
+        msg = if err_details
+                err_details.is_a?(Hash) ? err_details['message'] : err_details.to_s
+              else
+                "Unknown error from Ollama API"
+              end
+        raise Error, msg
+      else
+        # Extract answer from successful response (assuming OpenAI-like structure)
+        choices = response_data.dig(:parsed_json, "choices")
+        raise Error, "Ollama: No choices found in response" unless choices.is_a?(Array) && !choices.empty?
+
+        choices.map { |c| c.dig("message", "content") }.join("\n").strip
+      end
+    end
   end
 end