boxcars 0.1.8 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3de375ad403bb62fb6af1045aff6a6115cbb598c3747fe48f882fb40483289e0
-  data.tar.gz: 343a3077d72ce21a56d8045701a8a3bd681c5fe91fd8ffbca2cc14270b92f3bb
+  metadata.gz: 50a47cf449c063e7ca02cb36ad315008fa6a5813063a24d92ed4c0f94743c12e
+  data.tar.gz: fad47ad6fefc7d580251edf1675ae575a9f4eebf28fb903a1c82ba2868310bc4
 SHA512:
-  metadata.gz: efc72210fb52599b7c6278502a5b4143d995e671c62c7f6c090cbddf2a8926b231b0d7ab0aa28fa1325324ded1ebac5cac4e10e608ae59077a431a20f9d62f23
-  data.tar.gz: eeb00a993d7bbf64ac5c7461a1e31f241407c58a19a919c0853ade7e4a3bf717ab4f69331c5bc5d8c0049a89c53353d311d41616352131379b7e87b8ec3e491d
+  metadata.gz: '073919902e84d95158573400ebe593d1e5aa72cc1ab6efb0c4cfccaf9806a91a0c55913d9d9ec47dd8b56f7fb81660fdfd81753092e2a3bd590e4ef782c51ba8'
+  data.tar.gz: 87f1ec995889c7ca107ccf187f1b01874f136787861e5116abc13da5f204f4f3e7e8cf101692fed7285ac875f405e1f8e08701f3785e0c5e83f25d0e5a0b9b15

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [v0.2.0](https://github.com/BoxcarsAI/boxcars/tree/v0.2.0) (2023-03-07)
+
+[Full Changelog](https://github.com/BoxcarsAI/boxcars/compare/v0.1.8...v0.2.0)
+
+**Merged pull requests:**
+
+- Default to chatgpt [\#35](https://github.com/BoxcarsAI/boxcars/pull/35) ([francis](https://github.com/francis))
+
+## [v0.1.8](https://github.com/BoxcarsAI/boxcars/tree/v0.1.8) (2023-03-02)
+
+[Full Changelog](https://github.com/BoxcarsAI/boxcars/compare/v0.1.7...v0.1.8)
+
+**Merged pull requests:**
+
+- return JSON from the Active Record boxcar [\#34](https://github.com/BoxcarsAI/boxcars/pull/34) ([francis](https://github.com/francis))
+- validate return values from Open AI API [\#33](https://github.com/BoxcarsAI/boxcars/pull/33) ([francis](https://github.com/francis))
+- simplify prompting and parameters used. refs \#29 [\#30](https://github.com/BoxcarsAI/boxcars/pull/30) ([francis](https://github.com/francis))
+- \[infra\] Added sample .env file and updated the lookup to save the key [\#27](https://github.com/BoxcarsAI/boxcars/pull/27) ([AKovtunov](https://github.com/AKovtunov))
+
 ## [v0.1.7](https://github.com/BoxcarsAI/boxcars/tree/v0.1.7) (2023-02-27)
 
 [Full Changelog](https://github.com/BoxcarsAI/boxcars/compare/v0.1.6...v0.1.7)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    boxcars (0.1.8)
+    boxcars (0.2.1)
       google_search_results (~> 2.2)
       ruby-openai (~> 3.0)
 
@@ -140,7 +140,7 @@ GEM
     rubocop-rspec (2.18.1)
       rubocop (~> 1.33)
       rubocop-capybara (~> 2.17)
-    ruby-openai (3.3.0)
+    ruby-openai (3.5.0)
       httparty (>= 0.18.1)
     ruby-progressbar (1.11.0)
     ruby2_keywords (0.0.5)

data/lib/boxcars/boxcar/active_record.rb

@@ -7,28 +7,24 @@ module Boxcars
     # the description of this engine boxcar
     ARDESC = "useful for when you need to query a database for an application named %<name>s."
     LOCKED_OUT_MODELS = %w[ActiveRecord::SchemaMigration ActiveRecord::InternalMetadata ApplicationRecord].freeze
-    attr_accessor :connection, :requested_models, :read_only, :approval_callback
+    attr_accessor :connection, :requested_models, :read_only, :approval_callback, :code_only
     attr_reader :except_models
 
-    # @param engine [Boxcars::Engine] The engine to user for this boxcar. Can be inherited from a train if nil.
     # @param models [Array<ActiveRecord::Model>] The models to use for this boxcar. Will use all if nil.
+    # @param except_models [Array<ActiveRecord::Model>] The models to exclude from this boxcar. Will exclude none if nil.
     # @param read_only [Boolean] Whether to use read only models. Defaults to true unless you pass an approval function.
     # @param approval_callback [Proc] A function to call to approve changes. Defaults to nil.
     # @param kwargs [Hash] Any other keyword arguments. These can include:
-    #   :name, :description, :prompt, :except_models, :top_k, and :stop
-    def initialize(engine: nil, models: nil, read_only: nil, approval_callback: nil, **kwargs)
-      check_models(models)
-      @except_models = LOCKED_OUT_MODELS + kwargs[:except_models].to_a
+    #   :name, :description, :prompt, :except_models, :top_k, :stop, :code_only and :engine
+    def initialize(models: nil, except_models: nil, read_only: nil, approval_callback: nil, **kwargs)
+      check_models(models, except_models)
       @approval_callback = approval_callback
       @read_only = read_only.nil? ? !approval_callback : read_only
-      the_prompt = kwargs[prompt] || my_prompt
-      name = kwargs[:name] || "Data"
-      kwargs[:stop] ||= ["Answer:"]
-      super(name: name,
-            description: kwargs[:description] || format(ARDESC, name: name),
-            engine: engine,
-            prompt: the_prompt,
-            **kwargs)
+      @code_only = kwargs.delete(:code_only) || false
+      kwargs[:name] ||= "Data"
+      kwargs[:description] ||= format(ARDESC, name: name)
+      kwargs[:prompt] ||= my_prompt
+      super(**kwargs)
     end
 
     # @return Hash The additional variables for this boxcar.
@@ -42,7 +38,11 @@ module Boxcars
       read_only
     end
 
-    def check_models(models)
+    def code_only?
+      code_only
+    end
+
+    def check_models(models, exceptions)
       if models.is_a?(Array) && models.length.positive?
         @requested_models = models
         models.each do |m|
@@ -51,6 +51,7 @@ module Boxcars
       elsif models
         raise ArgumentError, "models needs to be an array of Active Record models"
       end
+      @except_models = LOCKED_OUT_MODELS + exceptions.to_a
     end
 
     def wanted_models
@@ -120,7 +121,7 @@ module Boxcars
       changes = change_count(changes_code)
       return true unless changes&.positive?
 
-      Boxcars.debug "Pending Changes: #{changes}", :yellow, style: :bold
+      Boxcars.debug "#{name}(Pending Changes): #{changes}", :yellow
       change_str = "#{changes} change#{'s' if changes.to_i > 1}"
       raise SecurityError, "Can not run code that makes #{change_str} in read-only mode" if read_only?
 
@@ -140,18 +141,26 @@ module Boxcars
       end
     end
 
+    def clean_up_output(output)
+      output = output.as_json if output.is_a?(::ActiveRecord::Result)
+      output = 0 if output.is_a?(Array) && output.empty?
+      output = output.first if output.is_a?(Array) && output.length == 1
+      output = output[output.keys.first] if output.is_a?(Hash) && output.length == 1
+      output = output.as_json if output.is_a?(::ActiveRecord::Relation)
+      output
+    end
+
     def get_active_record_answer(text)
       code = text[/^ARCode: (.*)/, 1]
       changes_code = text[/^ARChanges: (.*)/, 1]
+      return Result.new(status: :ok, explanation: "code to run", code: code, changes_code: changes_code) if code_only?
+
       raise SecurityError, "Permission to run code that makes changes denied" unless approved?(changes_code, code)
 
-      output = run_active_record_code(code)
-      output = 0 if output.is_a?(Array) && output.empty?
-      output = output.first if output.is_a?(Array) && output.length == 1
-      output = output[output.keys.first] if output.is_a?(Hash) && output.length == 1
-      "Answer: #{output.to_json}"
+      output = clean_up_output(run_active_record_code(code))
+      Result.new(status: :ok, answer: output, explanation: "Answer: #{output.to_json}", code: code)
     rescue StandardError => e
-      "Error: #{e.message}"
+      Result.new(status: :error, answer: nil, explanation: "Error: #{e.message}", code: code)
     end
 
     def get_answer(text)
@@ -159,9 +168,9 @@ module Boxcars
       when /^ARCode:/
         get_active_record_answer(text)
       when /^Answer:/
-        text
+        Result.from_text(text)
       else
-        raise Boxcars::Error "Unknown format from engine: #{text}"
+        Result.from_error("Unknown format from engine: #{text}")
       end
     end
 

data/lib/boxcars/boxcar/calculator.rb

@@ -11,14 +11,11 @@ module Boxcars
     # @param prompt [Boxcars::Prompt] The prompt to use for this boxcar. Defaults to built-in prompt.
     # @param kwargs [Hash] Any other keyword arguments to pass to the parent class.
     def initialize(engine: nil, prompt: nil, **kwargs)
-      # def initialize(engine:, prompt: my_prompt, output_key: :answer, **kwargs)
       the_prompt = prompt || my_prompt
       kwargs[:stop] ||= ["```output"]
-      super(name: kwargs[:name] || "Calculator",
-            description: kwargs[:description] || CALCDESC,
-            engine: engine,
-            prompt: the_prompt,
-            **kwargs)
+      kwargs[:name] ||= "Calculator"
+      kwargs[:description] ||= CALCDESC
+      super(engine: engine, prompt: the_prompt, **kwargs)
     end
 
     private
@@ -26,7 +23,7 @@ module Boxcars
     def get_embedded_ruby_answer(text)
       code = text[8..-4].split("```").first.strip
       ruby_executor = Boxcars::RubyREPL.new
-      ruby_executor.call(code: code).strip
+      ruby_executor.call(code: code)
     end
 
     def get_answer(text)
@@ -34,9 +31,9 @@ module Boxcars
       when /^```ruby/
         get_embedded_ruby_answer(text)
       when /^Answer:/
-        text
+        Result.from_text(text)
       else
-        raise Boxcars::Error "Unknown format from engine: #{text}"
+        Result.new(status: :error, explanation: "Unknown format from engine: #{text}")
       end
     end
 
@@ -45,7 +42,7 @@ module Boxcars
     TEMPLATE = <<~'IPT'
       You are GPT-3, and you can't do math.
       You can do basic math, and your memorization abilities are impressive, but you can't do any complex calculations that a human could not do in their head. You also have an annoying tendency to just make up highly specific, but wrong, answers.
-      So we hooked you up to a Ruby 3 kernel, and now you can execute ruby code. If anyone gives you a hard math problem, just use this format and we’ll take care of the rest:
+      So we hooked you up to a Ruby 3 kernel, and now you can execute code written in the Ruby programming language. If anyone gives you a hard math problem, just use this format and we’ll take care of the rest:
 
       Question: ${{Question with hard calculation.}}
       ```ruby

data/lib/boxcars/boxcar/engine_boxcar.rb

@@ -16,7 +16,7 @@ module Boxcars
       @engine = engine || Boxcars.engine.new
       @top_k = kwargs[:top_k] || 5
       @stop = kwargs[:stop] || ["Answer:"]
-      super(name: name, description: description)
+      super(name: name, description: description, return_direct: kwargs[:return_direct])
     end
 
     # input keys for the prompt
@@ -95,7 +95,7 @@ module Boxcars
     def check_output_keys
       return unless output_keys.length != 1
 
-      raise Boxcars::ArgumentError, "run not supported when there is not exactly one output key. Got #{output_keys}."
+      raise Boxcars::ArgumentError, "not supported when there is not exactly one output key. Got #{output_keys}."
     end
 
     # call the boxcar
@@ -104,7 +104,7 @@ module Boxcars
     def call(inputs:)
       t = predict(**prediction_variables(inputs)).strip
       answer = get_answer(t)
-      Boxcars.debug answer, :magenta
+      Boxcars.debug answer.to_json, :magenta
       { output_keys.first => answer }
     end
 

data/lib/boxcars/boxcar/sql.rb

@@ -6,21 +6,21 @@ module Boxcars
   class SQL < EngineBoxcar
     # the description of this engine boxcar
     SQLDESC = "useful for when you need to query a database for %<name>s."
+    LOCKED_OUT_TABLES = %w[schema_migrations ar_internal_metadata].freeze
     attr_accessor :connection
 
     # @param connection [ActiveRecord::Connection] The SQL connection to use for this boxcar.
-    # @param engine [Boxcars::Engine] The engine to user for this boxcar. Can be inherited from a train if nil.
+    # @param tables [Array<String>] The tables to use for this boxcar. Will use all if nil.
+    # @param except_tables [Array<String>] The tables to exclude from this boxcar. Will exclude none if nil.
     # @param kwargs [Hash] Any other keyword arguments to pass to the parent class. This can include
-    #   :name, :description, :prompt and :top_k
-    def initialize(connection: nil, engine: nil, **kwargs)
+    #   :name, :description, :prompt, :top_k, :stop, and :engine
+    def initialize(connection: nil, tables: nil, except_tables: nil, **kwargs)
       @connection = connection || ::ActiveRecord::Base.connection
-      the_prompt = kwargs[prompt] || my_prompt
-      kwargs[:stop] ||= ["Answer:"]
-      name = kwargs[:name] || "database"
-      super(name: name,
-            description: kwargs[:description] || format(SQLDESC, name: name),
-            engine: engine,
-            prompt: the_prompt)
+      check_tables(tables, except_tables)
+      kwargs[:name] ||= "Database"
+      kwargs[:description] ||= format(SQLDESC, name: name)
+      kwargs[:prompt] ||= my_prompt
+      super(**kwargs)
     end
 
     # @return Hash The additional variables for this boxcar.
@@ -30,6 +30,19 @@ module Boxcars
 
     private
 
+    def check_tables(rtables, exceptions)
+      if rtables.is_a?(Array) && tables.length.positive?
+        @requested_tables = rtables
+        all_tables = tables
+        rtables.each do |t|
+          raise ArgumentError, "table #{t} needs to be an Active Record model" unless all_tables.include?(t)
+        end
+      elsif rtables
+        raise ArgumentError, "tables needs to be an array of Strings"
+      end
+      @except_models = LOCKED_OUT_TABLES + exceptions.to_a
+    end
+
     def tables
       connection&.tables
     end
@@ -49,11 +62,22 @@ module Boxcars
       connection.class.name.split("::").last.sub("Adapter", "")
     end
 
+    def clean_up_output(output)
+      output = output.as_json if output.is_a?(::ActiveRecord::Result)
+      output = 0 if output.is_a?(Array) && output.empty?
+      output = output.first if output.is_a?(Array) && output.length == 1
+      output = output[output.keys.first] if output.is_a?(Hash) && output.length == 1
+      output = output.as_json if output.is_a?(::ActiveRecord::Relation)
+      output
+    end
+
     def get_embedded_sql_answer(text)
       code = text[/^SQLQuery: (.*)/, 1]
       Boxcars.debug code, :yellow
-      output = connection.exec_query(code).to_a
-      "Answer: #{output}"
+      output = clean_up_output(connection.exec_query(code))
+      Result.new(status: :ok, answer: output, explanation: "Answer: #{output.to_json}", code: code)
+    rescue StandardError => e
+      Result.new(status: :error, answer: nil, explanation: "Error: #{e.message}", code: code)
     end
 
     def get_answer(text)
@@ -61,14 +85,14 @@ module Boxcars
       when /^SQLQuery:/
         get_embedded_sql_answer(text)
       when /^Answer:/
-        text
+        Result.from_text(text)
       else
-        raise Boxcars::Error "Unknown format from engine: #{text}"
+        Result.from_error("Unknown format from engine: #{text}")
       end
     end
 
     TEMPLATE = <<~IPT
-      Given an input question, first create a syntactically correct %<dialect>s query to run,
+      Given an input question, first create a syntactically correct %<dialect>s SQL query to run,
       then look at the results of the query and return the answer. Unless the user specifies
       in his question a specific number of examples he wishes to obtain, always limit your query
       to at most %<top_k>s results using a LIMIT clause. You can order the results by a relevant column

data/lib/boxcars/boxcar.rb

@@ -62,8 +62,18 @@ module Boxcars
     # 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)
+      rv.is_a?(Result) ? rv.to_answer : rv
+    end
+
+    # Get an extended answer from the boxcar.
+    # @param args [Array] The positional arguments to pass to the boxcar.
+    # @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)
       Boxcars.info "> Entering #{name}#run", :gray, style: :bold
-      rv = do_run(*args, **kwargs)
+      rv = depart(*args, **kwargs)
       Boxcars.info "< Exiting #{name}#run", :gray, style: :bold
       rv
     end
@@ -71,7 +81,7 @@ module Boxcars
     private
 
     # Get an answer from the boxcar.
-    def do_call(inputs:, return_only_outputs: false)
+    def run_boxcar(inputs:, return_only_outputs: false)
       inputs = our_inputs(inputs)
       output = nil
       begin
@@ -81,19 +91,19 @@ module Boxcars
         raise e
       end
       validate_outputs(outputs: output.keys)
-      # memory&.save_convext(inputs: inputs, outputs: outputs)
       return output if return_only_outputs
 
       inputs.merge(output)
     end
 
-    def do_run(*args, **kwargs)
+    # line up parameters and run boxcar
+    def depart(*args, **kwargs)
       if kwargs.empty?
         raise Boxcars::ArgumentError, "run supports only one positional argument." if args.length != 1
 
-        return do_call(inputs: args[0])[output_keys.first]
+        return run_boxcar(inputs: args[0])[output_keys.first]
       end
-      return do_call(**kwargs)[output_keys].first if args.empty?
+      return run_boxcar(**kwargs)[output_keys].first if args.empty?
 
       raise Boxcars::ArgumentError, "run supported with either positional or keyword arguments but not both. Got args" \
                                     ": #{args} and kwargs: #{kwargs}."
@@ -111,9 +121,15 @@ module Boxcars
       end
       validate_inputs(inputs: inputs)
     end
+
+    # the default answer is the text passed in
+    def get_answer(text)
+      Result.from_text(text)
+    end
   end
 end
 
+require "boxcars/result"
 require "boxcars/boxcar/engine_boxcar"
 require "boxcars/boxcar/calculator"
 require "boxcars/boxcar/google_search"

data/lib/boxcars/engine/openai.rb

@@ -9,9 +9,9 @@ module Boxcars
 
     # The default parameters to use when asking the engine.
     DEFAULT_PARAMS = {
-      model: "text-davinci-003",
+      model: "gpt-3.5-turbo",
       temperature: 0.7,
-      max_tokens: 256
+      max_tokens: 512
     }.freeze
 
     # the default name of the engine
@@ -43,7 +43,13 @@ module Boxcars
       organization_id = Boxcars.configuration.organization_id
       clnt = ::OpenAI::Client.new(access_token: access_token, organization_id: organization_id)
       the_params = { prompt: prompt }.merge(open_ai_params).merge(kwargs)
-      clnt.completions(parameters: the_params)
+      if the_params[:model] == "gpt-3.5-turbo"
+        prompt = prompt.first if prompt.is_a?(Array)
+        the_params = { messages: [{ role: "user", content: prompt }] }.merge(open_ai_params).merge(kwargs)
+        clnt.chat(parameters: the_params)
+      else
+        clnt.completions(parameters: the_params)
+      end
     end
 
     # get an answer from the engine for a question.
@@ -51,7 +57,7 @@ module Boxcars
     # @param kwargs [Hash] Additional parameters to pass to the engine if wanted.
     def run(question, **kwargs)
       response = client(prompt: question, **kwargs)
-      answer = response["choices"].map { |c| c["text"] }.join("\n").strip
+      answer = response["choices"].map { |c| c.dig("message", "content") || c["text"] }.join("\n").strip
       puts answer
       answer
     end
@@ -74,7 +80,7 @@ module Boxcars
     def generation_info(sub_choices)
       sub_choices.map do |choice|
         Generation.new(
-          text: choice["text"],
+          text: choice.dig("message", "content") || choice["text"],
           generation_info: {
             finish_reason: choice.fetch("finish_reason", nil),
             logprobs: choice.fetch("logprobs", nil)
@@ -160,7 +166,8 @@ module Boxcars
       'text-babbage-001': 2048,
       'text-ada-001': 2048,
       'code-davinci-002': 8000,
-      'code-cushman-001': 2048
+      'code-cushman-001': 2048,
+      'gpt-3.5-turbo-1': 4096
     }.freeze
     model_lookup[modelname] || 4097
   end

data/lib/boxcars/result.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Boxcars
+  # used by Boxcars to return structured result and additional context
+  class Result
+    attr_reader :status, :answer, :explanation, :suggestions, :added_context
+
+    # @param status [Symbol] :ok or :error
+    # @param answer [String] The answer to the question
+    # @param explanation [String] The explanation of the answer
+    # @param suggestions [Array<String>] The next suggestions for the user
+    # @param added_context [Hash] Any additional context to add to the result
+    def initialize(status:, answer: nil, explanation: nil, suggestions: nil, **added_context)
+      @status = status
+      @answer = answer || explanation
+      @explanation = explanation
+      @suggestions = suggestions
+      @added_context = added_context
+    end
+
+    # @return [Hash] The result as a hash
+    def to_h
+      {
+        status: status,
+        answer: answer,
+        explanation: explanation,
+        suggestions: suggestions
+      }.merge(added_context).compact
+    end
+
+    # @return [String] The result as a json string
+    def to_json(*args)
+      JSON.generate(to_h, *args)
+    end
+
+    # @return [String] An explanation of the result
+    def to_s
+      explanation
+    end
+
+    # @return [String] The answer data to the question
+    def to_answer
+      answer
+    end
+
+    # create a new Result from a text string
+    # @param text [String] The text to use for the result
+    # @param kwargs [Hash] Any additional kwargs to pass to the result
+    # @return [Boxcars::Result] The result
+    def self.from_text(text, **kwargs)
+      answer = text.delete_prefix('"').delete_suffix('"').strip
+      answer = Regexp.last_match(:answer) if answer =~ /^Answer:\s*(?<answer>.*)$/
+      explanation = "Answer: #{answer}"
+      new(status: :ok, answer: answer, explanation: explanation, **kwargs)
+    end
+
+    # create a new Result from an error string
+    # @param error [String] The error to use for the result
+    # @param kwargs [Hash] Any additional kwargs to pass to the result
+    # @return [Boxcars::Result] The error result
+    def self.from_error(error, **kwargs)
+      answer = error
+      answer = Regexp.last_match(:answer) if answer =~ /^Error:\s*(?<answer>.*)$/
+      explanation = "Error: #{answer}"
+      new(status: :error, answer: answer, explanation: explanation, **kwargs)
+    end
+  end
+end

data/lib/boxcars/ruby_repl.rb

@@ -7,14 +7,22 @@ module Boxcars
     # @param code [String] The code to run
     def call(code:)
       Boxcars.debug "RubyREPL: #{code}", :yellow
+
+      # wrap the code in an excption block so we can catch errors
+      wrapped = "begin\n#{code}\nrescue Exception => e\n  puts 'Error: ' + e.message\nend"
       output = ""
       IO.popen("ruby", "r+") do |io|
-        io.puts code
+        io.puts wrapped
         io.close_write
         output = io.read
       end
-      Boxcars.debug "Answer: #{output}", :yellow, style: :bold
-      output
+      if output =~ /^Error: /
+        Boxcars.debug output, :red
+        Result.from_error(output, code: code)
+      else
+        Boxcars.debug "Answer: #{output}", :yellow, style: :bold
+        Result.from_text(output, code: code)
+      end
     end
 
     # Execute ruby code

data/lib/boxcars/train/train_action.rb

@@ -5,10 +5,24 @@ module Boxcars
   class TrainAction
     attr_accessor :boxcar, :boxcar_input, :log
 
-    def initialize(boxcar: nil, boxcar_input: nil, log: nil)
-      @boxcar = boxcar
+    # record for a train action
+    # @param boxcar [String] The boxcar to run.
+    # @param log [String] The log of the action.
+    # @param boxcar_input [String] The input to the boxcar.
+    # @return [Boxcars::TrainAction] The train action.
+    def initialize(boxcar:, log:, boxcar_input: nil)
       @boxcar_input = boxcar_input
+      @boxcar = boxcar
       @log = log
     end
+
+    # build a train action from a result
+    # @param result [Boxcars::Result] The result to build from.
+    # @param boxcar [String] The boxcar to run.
+    # @param log [String] The log of the action.
+    # @return [Boxcars::TrainAction] The train action.
+    def self.from_result(result:, boxcar:, log:)
+      new(boxcar: boxcar, boxcar_input: result.to_answer, log: log)
+    end
   end
 end

data/lib/boxcars/train/zero_shot.rb

@@ -19,7 +19,7 @@ module Boxcars
       ... (this Thought/Action/Action Input/Observation sequence can repeat N times)
       Thought: I now know the final answer
       Final Answer: the final answer to the original input question
-      Next Actions: up to three suggested actions for the user to take next
+      Next Actions: If you have them, up to three suggested actions for the user to take after getting this answer.
     FINPUT
 
     # default prompt suffix
@@ -69,15 +69,18 @@ module Boxcars
       #   with "Action Input:" should be separated by a newline.
       if engine_output.include?(FINAL_ANSWER_ACTION)
         answer = engine_output.split(FINAL_ANSWER_ACTION).last.strip
-        ['Final Answer', answer]
+        Result.new(status: :ok, answer: answer, explanation: engine_output)
+        # ['Final Answer', answer]
       else
+        # the thought should be the frist line here if it doesn't start with "Action:"
+        thought = engine_output.split(/\n+/).reject(&:empty?).first
+        Boxcars.debug("Though: #{thought}", :cyan)
         regex = /Action: (?<action>.*)\nAction Input: (?<action_input>.*)/
         match = regex.match(engine_output)
         raise ValueError, "Could not parse engine output: #{engine_output}" unless match
 
         action = match[:action].strip
-        action_input = match[:action_input].strip
-        # [action, action_input.strip(" ").strip('"')]
+        action_input = match[:action_input].strip.delete_prefix('"').delete_suffix('"')
         [action, action_input]
       end
     end

data/lib/boxcars/train.rb

@@ -38,7 +38,7 @@ module Boxcars
     def construct_scratchpad(intermediate_steps)
       thoughts = ""
       intermediate_steps.each do |action, observation|
-        thoughts += action.is_a?(String) ? action : action.log
+        thoughts += action.is_a?(String) ? action : " #{action.log}"
         thoughts += "\n#{observation_prefix}#{observation}\n#{engine_prefix}"
       end
       thoughts
@@ -51,13 +51,16 @@ module Boxcars
       full_output = predict(**full_inputs)
       parsed_output = extract_boxcar_and_input(full_output)
       while parsed_output.nil?
-        full_output = _fix_text(full_output)
         full_inputs[:agent_scratchpad] += full_output
         output = predict(**full_inputs)
         full_output += output
         parsed_output = extract_boxcar_and_input(full_output)
       end
-      TrainAction.new(boxcar: parsed_output[0], boxcar_input: parsed_output[1], log: full_output)
+      if parsed_output.is_a?(Result)
+        TrainAction.from_result(boxcar: "Final Answer", result: parsed_output, log: full_output)
+      else
+        TrainAction.new(boxcar: parsed_output[0], boxcar_input: parsed_output[1], log: full_output)
+      end
     end
 
     # Given input, decided what to do.
@@ -196,7 +199,7 @@ module Boxcars
             observation = boxcar.run(output.boxcar_input)
             return_direct = boxcar.return_direct
           rescue StandardError => e
-            error "Error in #{boxcar.name} boxcar#call: #{e}", :red
+            Boxcars.error "Error in #{boxcar.name} boxcar#call: #{e}", :red
             observation = "Error - #{e}, correct and try again."
           end
         else

data/lib/boxcars/version.rb

@@ -2,5 +2,5 @@
 
 module Boxcars
   # The current version of the gem.
-  VERSION = "0.1.8"
+  VERSION = "0.2.1"
 end

data/lib/boxcars.rb

@@ -30,7 +30,7 @@ module Boxcars
     def initialize
       @organization_id = nil
       @logger = Rails.logger if defined?(Rails)
-      @log_prompts = false
+      @log_prompts = ENV.fetch("LOG_PROMPTS", false)
     end
 
     # @return [String] The OpenAI Access Token either from arg or env.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boxcars
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.1
 platform: ruby
 authors:
 - Francis Sullivan
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-02 00:00:00.000000000 Z
+date: 2023-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: debug
@@ -114,6 +114,7 @@ files:
 - lib/boxcars/engine/openai.rb
 - lib/boxcars/generation.rb
 - lib/boxcars/prompt.rb
+- lib/boxcars/result.rb
 - lib/boxcars/ruby_repl.rb
 - lib/boxcars/train.rb
 - lib/boxcars/train/train_action.rb