boxcars 0.7.7 → 0.8.1

data/boxcars.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description = "You simply set an OpenAI key, give a number of Boxcars to a Train, and magic ensues when you run it."
   spec.homepage = "https://github.com/BoxcarsAI/boxcars"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.0"
+  spec.required_ruby_version = ">= 3.2.0"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
@@ -31,12 +31,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # runtime dependencies
+  spec.add_dependency "faraday-retry", "~> 2.0"
   spec.add_dependency "google_search_results", "~> 2.2"
   spec.add_dependency "gpt4all", "~> 0.0.5"
   spec.add_dependency "hnswlib", "~> 0.9"
   spec.add_dependency "intelligence", ">= 0.8"
   spec.add_dependency "nokogiri", "~> 1.18"
-  spec.add_dependency "pgvector", "~> 0.2"
   spec.add_dependency "ruby-anthropic", "~> 0.4"
   spec.add_dependency "ruby-openai", ">= 7.3"
 

data/lib/boxcars/boxcar/active_record.rb

@@ -23,14 +23,14 @@ module Boxcars
       @read_only = read_only.nil? ? !approval_callback : read_only
       @code_only = kwargs.delete(:code_only) || false
       kwargs[:name] ||= get_name
-      kwargs[:description] ||= format(ARDESC, name: name)
+      kwargs[:description] ||= format(ARDESC, name:)
       kwargs[:prompt] ||= my_prompt
       super(**kwargs)
     end
 
     # @return Hash The additional variables for this boxcar.
     def prediction_additional(_inputs)
-      { model_info: model_info }.merge super
+      { model_info: }.merge super
     end
 
     CTEMPLATE = [
@@ -150,16 +150,15 @@ module Boxcars
     # run the code in a safe environment
     # @param code [String] The code to run
     # @return [Object] The result of the code
-    def eval_safe_wrapper(code)
+    def eval_safe_wrapper(code, binding = TOPLEVEL_BINDING)
       # if the code used ActiveRecord, we need to add :: in front of it to escape the module
       new_code = code.gsub(/\b(ActiveRecord::)/, '::\1')
-
       # sometimes the code will have a puts or print in it, which will miss. Remove them.
       new_code = new_code.gsub(/\b(puts|print)\b/, '')
+
       proc do
-        $SAFE = 4
         # rubocop:disable Security/Eval
-        eval new_code
+        eval(new_code, binding)
         # rubocop:enable Security/Eval
       end.call
     end
@@ -231,24 +230,24 @@ module Boxcars
     def get_active_record_answer(text)
       changes_code = extract_code text.split('ARCode:').first.split('ARChanges:').last.strip if text =~ /^ARChanges:/
       code = extract_code text.split('ARCode:').last.strip
-      return Result.new(status: :ok, explanation: "code to run", code: code, changes_code: changes_code) if code_only?
+      return Result.new(status: :ok, explanation: "code to run", code:, changes_code:) if code_only?
 
       have_approval = false
       begin
         have_approval = approved?(changes_code, code)
       rescue NameError, Error => e
-        return Result.new(status: :error, explanation: error_message(e, "ARChanges"), changes_code: changes_code)
+        return Result.new(status: :error, explanation: error_message(e, "ARChanges"), changes_code:)
       end
 
       raise SecurityError, "Permission to run code that makes changes denied" unless have_approval
 
       begin
         output = clean_up_output(run_active_record_code(code))
-        Result.new(status: :ok, answer: output, explanation: "Answer: #{output.to_json}", code: code)
+        Result.new(status: :ok, answer: output, explanation: "Answer: #{output.to_json}", code:)
       rescue SecurityError => e
         raise e
       rescue ::StandardError => e
-        Result.new(status: :error, answer: nil, explanation: error_message(e, "ARCode"), code: code)
+        Result.new(status: :error, answer: nil, explanation: error_message(e, "ARCode"), code:)
       end
     end
 

data/lib/boxcars/boxcar/calculator.rb

@@ -15,7 +15,7 @@ module Boxcars
       kwargs[:stop] ||= ["```output"]
       kwargs[:name] ||= "Calculator"
       kwargs[:description] ||= CALCDESC
-      super(engine: engine, prompt: the_prompt, **kwargs)
+      super(engine:, prompt: the_prompt, **kwargs)
     end
 
     # our template
@@ -47,7 +47,7 @@ module Boxcars
       code = text.split("```ruby\n").last.split("```").first.strip
       # code = text[8..-4].split("```").first.strip
       ruby_executor = Boxcars::RubyREPL.new
-      ruby_executor.call(code: code)
+      ruby_executor.call(code:)
     end
 
     def get_answer(text)

data/lib/boxcars/boxcar/engine_boxcar.rb

@@ -46,7 +46,7 @@ module Boxcars
       stop = input_list[0][:stop]
       the_prompt = current_conversation ? prompt.with_conversation(current_conversation) : prompt
       prompts = input_list.map { |inputs| [the_prompt, inputs] }
-      engine.generate(prompts: prompts, stop: stop)
+      engine.generate(prompts:, stop:)
     end
 
     # apply a response from the engine
@@ -54,7 +54,7 @@ module Boxcars
     # @param current_conversation [Boxcars::Conversation] Optional ongoing conversation to use for the prompt.
     # @return [Hash] A hash of the output key and the output value.
     def apply(input_list:, current_conversation: nil)
-      response = generate(input_list: input_list, current_conversation: current_conversation)
+      response = generate(input_list:, current_conversation:)
       response.generations.to_h do |generation|
         [output_key, generation[0].text]
       end
@@ -65,7 +65,7 @@ module Boxcars
     # @param kwargs [Hash] A hash of input values to use for the prompt.
     # @return [String] The output value.
     def predict(current_conversation: nil, **kwargs)
-      prediction = apply(current_conversation: current_conversation, input_list: [kwargs])[output_key]
+      prediction = apply(current_conversation:, input_list: [kwargs])[output_key]
       Boxcars.debug(prediction, :white) if Boxcars.configuration.log_generated
       prediction
     end
@@ -115,7 +115,7 @@ module Boxcars
 
     # @return Hash The additional variables for this boxcar.
     def prediction_additional(_inputs)
-      { stop: stop, top_k: top_k }
+      { stop:, top_k: }
     end
 
     # @param inputs [Hash] The inputs to the boxcar.

data/lib/boxcars/boxcar/google_search.rb

@@ -14,8 +14,8 @@ module Boxcars
     # @param description [String] A description of the boxcar. Defaults to SERPDESC.
     # @param serpapi_api_key [String] The API key to use for the SerpAPI. Defaults to Boxcars.configuration.serpapi_api_key.
     def initialize(name: "Search", description: SERPDESC, serpapi_api_key: nil)
-      super(name: name, description: description)
-      api_key = Boxcars.configuration.serpapi_api_key(serpapi_api_key: serpapi_api_key)
+      super(name:, description:)
+      api_key = Boxcars.configuration.serpapi_api_key(serpapi_api_key:)
       ::GoogleSearch.api_key = api_key
     end
 

data/lib/boxcars/boxcar/json_engine_boxcar.rb

@@ -37,7 +37,7 @@ module Boxcars
       SYSPR
       stock_prompt += "\n\nImportant:\n#{important}\n" unless important.to_s.empty?
 
-      sprompt = format(stock_prompt, wanted_data: wanted_data, data_description: data_description)
+      sprompt = format(stock_prompt, wanted_data:, data_description:)
       ctemplate = [
         Boxcar.syst(sprompt),
         Boxcar.user("%<input>s")

data/lib/boxcars/boxcar/ruby_calculator.rb

@@ -30,7 +30,7 @@ module Boxcars
     def run(question)
       code = "puts(#{question})"
       ruby_executor = Boxcars::RubyREPL.new
-      rv = ruby_executor.call(code: code)
+      rv = ruby_executor.call(code:)
       puts "Question: #{question}"
       puts "Answer: #{rv}"
       rv

data/lib/boxcars/boxcar/sql_base.rb

@@ -20,7 +20,7 @@ module Boxcars
       @connection = connection
       check_tables(tables, except_tables)
       kwargs[:name] ||= "Database"
-      kwargs[:description] ||= format(SQLDESC, name: name)
+      kwargs[:description] ||= format(SQLDESC, name:)
       kwargs[:prompt] ||= my_prompt
       kwargs[:stop] ||= ["SQLResult:"]
 
@@ -29,7 +29,7 @@ module Boxcars
 
     # @return Hash The additional variables for this boxcar.
     def prediction_additional(_inputs)
-      { schema: schema, dialect: dialect }.merge super
+      { schema:, dialect: }.merge super
     end
 
     CTEMPLATE = [
@@ -107,9 +107,9 @@ module Boxcars
       code = extract_code text.split('SQLQuery:').last.strip
       Boxcars.debug code, :yellow
       output = clean_up_output(code)
-      Result.new(status: :ok, answer: output, explanation: "Answer: #{output.to_json}", code: code)
+      Result.new(status: :ok, answer: output, explanation: "Answer: #{output.to_json}", code:)
     rescue StandardError => e
-      Result.new(status: :error, answer: nil, explanation: "Error: #{e.message}", code: code)
+      Result.new(status: :error, answer: nil, explanation: "Error: #{e.message}", code:)
     end
 
     def get_answer(text)

data/lib/boxcars/boxcar/swagger.rb

@@ -21,12 +21,12 @@ module Boxcars
       kwargs[:stop] ||= ["```output"]
       kwargs[:name] ||= "Swagger API"
       kwargs[:description] ||= DESC
-      super(engine: engine, prompt: the_prompt, **kwargs)
+      super(engine:, prompt: the_prompt, **kwargs)
     end
 
     # @return Hash The additional variables for this boxcar.
     def prediction_additional(_inputs)
-      { swagger_url: swagger_url, context: context }.merge super
+      { swagger_url:, context: }.merge super
     end
 
     # our template
@@ -52,7 +52,7 @@ module Boxcars
     def get_embedded_ruby_answer(text)
       code = text.split("```ruby\n").last.split("```").first.strip
       ruby_executor = Boxcars::RubyREPL.new
-      ruby_executor.call(code: code)
+      ruby_executor.call(code:)
     end
 
     def get_answer(text)

data/lib/boxcars/boxcar/vector_answer.rb

@@ -21,7 +21,7 @@ module Boxcars
       kwargs[:stop] ||= ["```output"]
       kwargs[:name] ||= "VectorAnswer"
       kwargs[:description] ||= DESC
-      super(engine: engine, prompt: the_prompt, **kwargs)
+      super(engine:, prompt: the_prompt, **kwargs)
     end
 
     # @param inputs [Hash] The inputs to use for the prediction.
@@ -53,8 +53,8 @@ module Boxcars
     # @params count [Integer] The number of results to return.
     # @return [String] The content of the search results.
     def get_search_content(question, count: 1)
-      search = Boxcars::VectorSearch.new(embeddings: embeddings, vector_documents: vector_documents)
-      results = search.call query: question, count: count
+      search = Boxcars::VectorSearch.new(embeddings:, vector_documents:)
+      results = search.call(query: question, count:)
       @search_content = get_results_content(results)
     end
 

data/lib/boxcars/boxcar/xml_engine_boxcar.rb

@@ -21,7 +21,7 @@ module Boxcars
     def xn_get_answer(xnode)
       reply = xnode.xtext("//reply")
 
-      if reply.present?
+      if reply && !reply.to_s.strip.empty?
         Result.new(status: :ok, answer: reply, explanation: reply)
       else
         # we have an unexpected output from the engine

data/lib/boxcars/boxcar.rb

@@ -63,8 +63,8 @@ module Boxcars
     # @param kwargs [Hash] The keyword arguments to pass to the boxcar.
     # you can pass one or the other, but not both.
     # @return [String] The answer to the question.
-    def run(*args, **kwargs)
-      rv = conduct(*args, **kwargs)
+    def run(*, **)
+      rv = conduct(*, **)
       rv = rv[:answer] if rv.is_a?(Hash) && rv.key?(:answer)
       return rv.answer if rv.is_a?(Result)
       return rv[output_keys[0]] if rv.is_a?(Hash)
@@ -77,9 +77,9 @@ module Boxcars
     # @param kwargs [Hash] The keyword arguments to pass to the boxcar.
     # you can pass one or the other, but not both.
     # @return [Boxcars::Result] The answer to the question.
-    def conduct(*args, **kwargs)
+    def conduct(*, **)
       Boxcars.info "> Entering #{name}#run", :gray, style: :bold
-      rv = depart(*args, **kwargs)
+      rv = depart(*, **)
       remember_history(rv)
       Boxcars.info "< Exiting #{name}#run", :gray, style: :bold
       rv
@@ -163,7 +163,7 @@ module Boxcars
       inputs = our_inputs(inputs)
       output = nil
       begin
-        output = call(inputs: inputs)
+        output = call(inputs:)
       rescue StandardError => e
         Boxcars.error "Error in #{name} boxcar#call: #{e}\nbt:#{e.backtrace[0..5].join("\n   ")}", :red
         Boxcars.error("Response Body: #{e.response[:body]}", :red) if e.respond_to?(:response) && !e.response.nil?
@@ -199,7 +199,7 @@ module Boxcars
         end
         inputs = { input_keys.first => inputs }
       end
-      validate_inputs(inputs: inputs)
+      validate_inputs(inputs:)
     end
 
     # the default answer is the text passed in

data/lib/boxcars/conversation_prompt.rb

@@ -11,7 +11,7 @@ module Boxcars
     # @param output_variables [Array<Symbol>] The output vars to use for the prompt. Defaults to [:output]
     def initialize(conversation:, input_variables: nil, other_inputs: nil, output_variables: nil)
       @conversation = conversation
-      super(template: template, input_variables: input_variables, other_inputs: other_inputs, output_variables: output_variables)
+      super(template:, input_variables:, other_inputs:, output_variables:)
     end
 
     # prompt for chatGPT params
@@ -25,7 +25,7 @@ module Boxcars
     # @param inputs [Hash] The inputs to use for the prompt.
     # @return [Hash] The formatted prompt.
     def as_prompt(inputs:, prefixes: default_prefixes, show_roles: false)
-      { prompt: conversation.as_prompt(inputs: inputs, prefixes: prefixes, show_roles: show_roles) }
+      { prompt: conversation.as_prompt(inputs:, prefixes:, show_roles:) }
     end
 
     # tack on the ongoing conversation if present to the prompt
@@ -56,7 +56,7 @@ module Boxcars
     # @param inputs [Hash] The inputs to use for the prompt
     # @return [Intelligence::Conversation] The converted conversation
     def as_intelligence_conversation(inputs: nil)
-      conversation.as_intelligence_conversation(inputs: inputs)
+      conversation.as_intelligence_conversation(inputs:)
     end
   end
 end

data/lib/boxcars/engine/anthropic.rb

@@ -4,7 +4,9 @@ require 'anthropic'
 # Boxcars is a framework for running a series of tools to get an answer to a question.
 module Boxcars
   # A engine that uses OpenAI's API.
+  # rubocop:disable Metrics/ClassLength
   class Anthropic < Engine
+    include UnifiedObservability
     attr_reader :prompts, :llm_params, :model_kwargs, :batch_size
 
     # The default parameters to use when asking the engine.
@@ -29,7 +31,7 @@ module Boxcars
       @llm_params = DEFAULT_PARAMS.merge(kwargs)
       @prompts = prompts
       @batch_size = 20
-      super(description: description, name: name)
+      super(description:, name:)
     end
 
     def conversation_model?(_model)
@@ -46,33 +48,50 @@ module Boxcars
     #   Defaults to Boxcars.configuration.anthropic_api_key.
     # @param kwargs [Hash] Additional parameters to pass to the engine if wanted.
     def client(prompt:, inputs: {}, **kwargs)
-      model_params = llm_params.merge(kwargs)
-      api_key = Boxcars.configuration.anthropic_api_key(**kwargs)
-      aclient = anthropic_client(anthropic_api_key: api_key)
-      prompt = prompt.first if prompt.is_a?(Array)
-      params = convert_to_anthropic(prompt.as_messages(inputs).merge(model_params))
-      if Boxcars.configuration.log_prompts
-        if params[:messages].length < 2 && params[:system].present?
-          Boxcars.debug(">>>>>> Role: system <<<<<<\n#{params[:system]}")
+      start_time = Time.now
+      response_data = { response_obj: nil, parsed_json: nil, success: false, error: nil, status_code: nil }
+      current_params = llm_params.merge(kwargs)
+      current_prompt_object = prompt.is_a?(Array) ? prompt.first : prompt
+      api_request_params = nil
+
+      begin
+        api_key = Boxcars.configuration.anthropic_api_key(**kwargs)
+        aclient = anthropic_client(anthropic_api_key: api_key)
+        api_request_params = convert_to_anthropic(current_prompt_object.as_messages(inputs).merge(current_params))
+
+        if Boxcars.configuration.log_prompts
+          if api_request_params[:messages].length < 2 && api_request_params[:system] && !api_request_params[:system].empty?
+            Boxcars.debug(">>>>>> Role: system <<<<<<\n#{api_request_params[:system]}")
+          end
+          Boxcars.debug(api_request_params[:messages].last(2).map do |p|
+            ">>>>>> Role: #{p[:role]} <<<<<<\n#{p[:content]}"
+          end.join("\n"), :cyan)
         end
-        Boxcars.debug(params[:messages].last(2).map { |p| ">>>>>> Role: #{p[:role]} <<<<<<\n#{p[:content]}" }.join("\n"), :cyan)
+
+        raw_response = aclient.messages(parameters: api_request_params)
+        _process_anthropic_response(raw_response, response_data)
+      rescue StandardError => e
+        _handle_anthropic_error(e, response_data)
+      ensure
+        call_context = {
+          start_time:,
+          prompt_object: current_prompt_object,
+          inputs:,
+          api_request_params:,
+          current_params:
+        }
+        _track_anthropic_observability(call_context, response_data)
       end
-      response = aclient.messages(parameters: params)
-      response['completion'] = response.dig('content', 0, 'text')
-      response.delete('content')
-      response
-    rescue StandardError => e
-      err = e.respond_to?(:response) ? e.response[:body] : e
-      Boxcars.warn("Anthropic Error #{e.class.name}: #{err}", :red)
-      raise
+
+      _anthropic_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)
+      response = client(prompt:, **)
 
       raise Error, "Anthropic: No response from API" unless response
       raise Error, "Anthropic: #{response['error']}" if response['error']
@@ -134,7 +153,7 @@ module Boxcars
       # Includes prompt, completion, and total tokens used.
       prompts.each_slice(batch_size) do |sub_prompts|
         sub_prompts.each do |sprompts, inputs|
-          response = client(prompt: sprompts, inputs: inputs, **params)
+          response = client(prompt: sprompts, inputs:, **params)
           check_response(response)
           choices << response
         end
@@ -146,7 +165,7 @@ module Boxcars
         sub_choices = choices[i * n, (i + 1) * n]
         generations.push(generation_info(sub_choices))
       end
-      EngineResult.new(generations: generations, engine_output: { token_usage: {} })
+      EngineResult.new(generations:, engine_output: { token_usage: {} })
     end
     # rubocop:enable Metrics/AbcSize
 
@@ -191,12 +210,14 @@ module Boxcars
     end
 
     # convert generic parameters to Anthopic specific ones
+    # rubocop:disable Metrics/AbcSize
     def convert_to_anthropic(params)
       params[:stop_sequences] = params.delete(:stop) if params.key?(:stop)
       params[:system] = params[:messages].shift[:content] if params.dig(:messages, 0, :role) == :system
-      params[:messages].pop if params[:messages].last[:content].blank?
+      params[:messages].pop if params[:messages].last[:content].nil? || params[:messages].last[:content].strip.empty?
       combine_assistant(params)
     end
+    # rubocop:enable Metrics/AbcSize
 
     def combine_assistant(params)
       params[:messages] = combine_assistant_entries(params[:messages])
@@ -220,5 +241,82 @@ module Boxcars
     def default_prefixes
       { system: "Human: ", user: "Human: ", assistant: "Assistant: ", history: :history }
     end
+
+    private
+
+    # Process the raw response from Anthropic API
+    # rubocop:disable Metrics/AbcSize
+    def _process_anthropic_response(raw_response, response_data)
+      response_data[:response_obj] = raw_response
+      response_data[:parsed_json] = raw_response # Already parsed by Anthropic gem
+
+      if raw_response && !raw_response["error"]
+        response_data[:success] = true
+        response_data[:status_code] = 200 # Inferred
+        # Transform response to match expected format
+        raw_response['completion'] = raw_response.dig('content', 0, 'text')
+        raw_response.delete('content')
+      else
+        response_data[:success] = false
+        err_details = raw_response["error"] if raw_response
+        msg = err_details ? "#{err_details['type']}: #{err_details['message']}" : "Unknown Anthropic API Error"
+        response_data[:error] ||= StandardError.new(msg)
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # Handle errors from Anthropic API calls
+    def _handle_anthropic_error(error, response_data)
+      response_data[:error] = error
+      response_data[:success] = false
+      response_data[:status_code] = error.respond_to?(:http_status) ? error.http_status : nil
+    end
+
+    # Track observability using the unified system
+    def _track_anthropic_observability(call_context, response_data)
+      duration_ms = ((Time.now - call_context[:start_time]) * 1000).round
+      request_context = {
+        prompt: call_context[:prompt_object],
+        inputs: call_context[:inputs],
+        conversation_for_api: call_context[:api_request_params]
+      }
+
+      track_ai_generation(
+        duration_ms:,
+        current_params: call_context[:current_params],
+        request_context:,
+        response_data:,
+        provider: :anthropic
+      )
+    end
+
+    # Handle the final outcome of the API call
+    def _anthropic_handle_call_outcome(response_data:)
+      if response_data[:error]
+        _handle_anthropic_error_outcome(response_data[:error])
+      elsif !response_data[:success]
+        _handle_anthropic_response_body_error(response_data[:response_obj])
+      else
+        response_data[:parsed_json] # Return the raw parsed JSON
+      end
+    end
+
+    # Handle error outcomes
+    def _handle_anthropic_error_outcome(error_data)
+      detailed_error_message = error_data.message
+      if error_data.respond_to?(:response) && error_data.response
+        detailed_error_message += " - Details: #{error_data.response[:body]}"
+      end
+      Boxcars.error("Anthropic Error: #{detailed_error_message} (#{error_data.class.name})", :red)
+      raise error_data
+    end
+
+    # Handle response body errors
+    def _handle_anthropic_response_body_error(response_obj)
+      err_details = response_obj&.dig("error")
+      msg = err_details ? "#{err_details['type']}: #{err_details['message']}" : "Unknown error from Anthropic API"
+      raise Error, msg
+    end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/boxcars/engine/cerebras.rb

@@ -21,8 +21,8 @@ module Boxcars
     # @param prompts [Array<Prompt>] The prompts to use for the Engine.
     # @param batch_size [Integer] The number of prompts to send to the Engine at a time.
     # @param kwargs [Hash] Additional parameters to pass to the Engine.
-    def initialize(name: DEFAULT_NAME, description: DEFAULT_DESCRIPTION, prompts: [], batch_size: 20, **kwargs)
-      super(provider: :cerebras, description: description, name: name, prompts: prompts, batch_size: batch_size, **kwargs)
+    def initialize(name: DEFAULT_NAME, description: DEFAULT_DESCRIPTION, prompts: [], batch_size: 20, **)
+      super(provider: :cerebras, description:, name:, prompts:, batch_size:, **)
     end
 
     def default_model_params