boxcars 0.2.16 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92af5ad71c16886afc760bcc1b98a1d050486f8cf7010e0f05ee5015aa767710
-  data.tar.gz: a0e5f39d40f79d4e4e5e337c00657764b5f9b329ec6bcc0f5a6e4ea62b0675b5
+  metadata.gz: 463f57f1436cfea29e0a60bbfce071afd355a5d0cadbe1d69f96adc7393eacd6
+  data.tar.gz: 282e528fb8cb8b532b621db5c2e7ce2b82c4607057c01f0feb1eaacfe98ba09b
 SHA512:
-  metadata.gz: 06123e9f6ea4cb294b258056b6e50af7654b2c4866b1585fb32e520eee4e64dcdecc7cf8dc4d019a42a3193b01be6a02fba8190ef52add4eb70ad7f1a79d492c
-  data.tar.gz: 3320ee8fdb68a4bf9601a6a584d64517242e0e80b14b812b6f04f3e0eaed05b5d520541e5547c72b7b3a8ebea044e7173163cafccc2cc8f9bb5c25b25a231ffe
+  metadata.gz: c76d2772db0925f71779c0bac1a2e92af20bcf398cc6e7cf943edeadb2014426554fba607b034fd68ac88bd26f2d42eef114de57332e83a4fe76558a9b2f0cea
+  data.tar.gz: '0489fffef87c32fbf6a7a9af4fbca77ef991437353211174617b6ea8e229e49accc85c39af93414ce1628a4472cc208d8075570abba5e8269b30cfb66000a40e'

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## [v0.3.1](https://github.com/BoxcarsAI/boxcars/tree/v0.3.1) (2023-07-01)
+
+[Full Changelog](https://github.com/BoxcarsAI/boxcars/compare/v0.2.16...v0.3.1)
+
+**Closed issues:**
+
+- Add a running log of prompts for debugging [\#99](https://github.com/BoxcarsAI/boxcars/issues/99)
+- Anyway to create conversation? [\#73](https://github.com/BoxcarsAI/boxcars/issues/73)
+
+**Merged pull requests:**
+
+- now, when you call run on a train multiple times, it remembers the ru… [\#101](https://github.com/BoxcarsAI/boxcars/pull/101) ([francis](https://github.com/francis))
+
+## [v0.2.16](https://github.com/BoxcarsAI/boxcars/tree/v0.2.16) (2023-06-26)
+
+[Full Changelog](https://github.com/BoxcarsAI/boxcars/compare/v0.2.15...v0.2.16)
+
+**Implemented enhancements:**
+
+- Support Sequel connection type [\#22](https://github.com/BoxcarsAI/boxcars/issues/22)
+
+**Closed issues:**
+
+- Using the SQL model This model's maximum context length is 4097 tokens [\#88](https://github.com/BoxcarsAI/boxcars/issues/88)
+
+**Merged pull requests:**
+
+- Add running logs [\#100](https://github.com/BoxcarsAI/boxcars/pull/100) ([francis](https://github.com/francis))
+- create new Sequel boxcar, and refactor Active Record SQL boxcar [\#98](https://github.com/BoxcarsAI/boxcars/pull/98) ([francis](https://github.com/francis))
+- Support for Sequel SQL connection types [\#97](https://github.com/BoxcarsAI/boxcars/pull/97) ([eltoob](https://github.com/eltoob))
+
 ## [v0.2.15](https://github.com/BoxcarsAI/boxcars/tree/v0.2.15) (2023-06-09)
 
 [Full Changelog](https://github.com/BoxcarsAI/boxcars/compare/v0.2.14...v0.2.15)

data/Gemfile.lock

@@ -1,10 +1,11 @@
 PATH
   remote: .
   specs:
-    boxcars (0.2.16)
+    boxcars (0.3.2)
       google_search_results (~> 2.2)
       gpt4all (~> 0.0.4)
       hnswlib (~> 0.8)
+      nokogiri (~> 1.15)
       pgvector (~> 0.2)
       ruby-openai (~> 4.1)
 
@@ -55,7 +56,7 @@ GEM
     domain_name (0.5.20190701)
       unf (>= 0.0.5, < 1.0.0)
     dotenv (2.8.1)
-    faraday (2.7.4)
+    faraday (2.7.9)
       faraday-net_http (>= 2.0, < 3.1)
       ruby2_keywords (>= 0.0.4)
     faraday-http-cache (2.5.0)
@@ -103,6 +104,14 @@ GEM
     netrc (0.11.0)
     nio4r (2.5.9)
     nio4r (2.5.9-java)
+    nokogiri (1.15.2-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.15.2-java)
+      racc (~> 1.4)
+    nokogiri (1.15.2-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.15.2-x86_64-linux)
+      racc (~> 1.4)
     octokit (4.25.1)
       faraday (>= 1, < 3)
       sawyer (~> 0.9)
@@ -120,6 +129,8 @@ GEM
       protocol-hpack (~> 1.4)
       protocol-http (~> 0.18)
     public_suffix (5.0.1)
+    racc (1.7.1)
+    racc (1.7.1-java)
     rainbow (3.1.1)
     rake (13.0.6)
     regexp_parser (2.8.0)

data/boxcars.gemspec

@@ -34,6 +34,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "google_search_results", "~> 2.2"
   spec.add_dependency "gpt4all", "~> 0.0.4"
   spec.add_dependency "hnswlib", "~> 0.8"
+  spec.add_dependency "nokogiri", "~> 1.15"
   spec.add_dependency "pgvector", "~> 0.2"
   spec.add_dependency "ruby-openai", "~> 4.1"
 

data/lib/boxcars/boxcar/active_record.rb

@@ -147,7 +147,7 @@ module Boxcars
     end
 
     def change_count(changes_code)
-      return 0 unless changes_code
+      return 0 if changes_code.nil? || changes_code.empty? || changes_code =~ %r{^(None|N/A)$}i
 
       rollback_after_running do
         Boxcars.debug "computing change count with: #{changes_code}", :yellow
@@ -200,7 +200,8 @@ module Boxcars
     def error_message(err, stage)
       msg = err.message
       msg = ::Regexp.last_match(1) if msg =~ /^(.+)' for #<Boxcars::ActiveRecord/
-      "#{stage} Error: #{msg} - please fix \"#{stage}:\" to not have this error"
+      msg.gsub!(/Boxcars::ActiveRecord::/, '')
+      "For the value you gave for #{stage}, fix this error: #{msg}"
     end
 
     def get_active_record_answer(text)

data/lib/boxcars/boxcar/calculator.rb

@@ -43,7 +43,7 @@ module Boxcars
     CTEMPLATE = [
       syst("You can do basic math, but for any hard calculations that a human could not do ",
            "in their head, use the following approach instead. ",
-           "Return code written in the Ruby programming language that prints the results. ",
+           "Return code written in the Ruby programming language that prints the results to the console. ",
            "If anyone gives you a hard math problem, just ",
            "use the following format and we’ll take care of the rest:\n",
            "${{Question with hard calculation.}}\n",

data/lib/boxcars/boxcar/url_text.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Boxcars
+  # A Boxcar that reads text from a URL.
+  class URLText < Boxcar
+    # the description of this boxcar
+    DESC = "useful when you want to get text from a URL."
+
+    # implements a boxcar that uses the Google SerpAPI to get answers to questions.
+    # @param name [String] The name of the boxcar. Defaults to classname.
+    # @param description [String] A description of the boxcar. Defaults to SERPDESC.
+    def initialize(name: "FetchURL", description: DESC)
+      super(name: name, description: description)
+    end
+
+    # Get text from a url.
+    # @param url [String] The url
+    # @return [String] The text for the url.
+    def run(url)
+      url = URI.parse(url)
+      get_answer(url)
+    end
+
+    private
+
+    def html_to_text(url, response)
+      Nokogiri::HTML(response.body).css(%w[h1 h2 h3 h4 h5 h6 p a].join(",")).map do |e|
+        itxt = e.inner_text.strip
+        itxt = itxt.gsub(/[[:space:]]+/, " ") # remove extra spaces
+        # next if itxt.nil? || itxt.empty?
+        if e.name == "a"
+          href = e.attributes["href"]&.value
+          href = URI.join(url, href).to_s if href =~ %r{^/}
+          "[#{itxt}](#{href})" # if e.attributes["href"]&.value =~ /^http/
+        else
+          itxt
+        end
+      end.compact.join("\n\n")
+    end
+
+    def get_answer(url)
+      response = Net::HTTP.get_response(url)
+      if response.is_a?(Net::HTTPSuccess)
+        return Result.from_text(response.body) if response.content_type == "text/plain"
+
+        if response.content_type == "text/html"
+          # return only the top level text
+          txt = html_to_text(url, response)
+          Result.from_text(txt)
+        else
+          Result.from_text(response.body)
+        end
+      else
+        Result.new(status: :error, explanation: "Error with url: #{response.code} #{response.message}")
+      end
+    end
+  end
+end

data/lib/boxcars/boxcar.rb

@@ -17,12 +17,12 @@ module Boxcars
 
     # Input keys this chain expects.
     def input_keys
-      raise NotImplementedError
+      [:question]
     end
 
     # Output keys this chain expects.
     def output_keys
-      raise NotImplementedError
+      [:answer]
     end
 
     # Check that all inputs are present.
@@ -63,7 +63,11 @@ module Boxcars
     # @return [String] The answer to the question.
     def run(*args, **kwargs)
       rv = conduct(*args, **kwargs)
-      rv.is_a?(Result) ? rv.to_answer : rv
+      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)
+
+      rv
     end
 
     # Get an extended answer from the boxcar.
@@ -74,6 +78,7 @@ module Boxcars
     def conduct(*args, **kwargs)
       Boxcars.info "> Entering #{name}#run", :gray, style: :bold
       rv = depart(*args, **kwargs)
+      remember_history(rv)
       Boxcars.info "< Exiting #{name}#run", :gray, style: :bold
       rv
     end
@@ -94,8 +99,65 @@ module Boxcars
       [:user, strs.join]
     end
 
+    # history entries
+    def self.hist
+      [:history, ""]
+    end
+
+    # save this boxcar to a file
+    def save(path:)
+      File.write(path, YAML.dump(self))
+    end
+
+    # load this boxcar from a file
+    # rubocop:disable Security/YAMLLoad
+    def load(path:)
+      YAML.load(File.read(path))
+    end
+    # rubocop:enable Security/YAMLLoad
+
+    def schema
+      params = input_keys.map do |key|
+        "<param name=\"#{key}\" data-type=\"String\" required=\"true\" description=\"#{key}\" />"
+      end.join("\n")
+      <<~SCHEMA.freeze
+        <tool>
+          <tool name="#{name}" version="0.1" description="#{description}">
+          <params>
+            #{params}
+          </params>
+        </tool>
+      SCHEMA
+    end
+
     private
 
+    # remember the history of this boxcar. Take the current intermediate steps and
+    # create a history that can be used on the next run.
+    # @param current_results [Array<Hash>] The current results.
+    def remember_history(current_results)
+      return unless current_results[:intermediate_steps] && is_a?(Train)
+
+      # insert conversation history into the prompt
+      history = []
+      history << Boxcar.user(key_and_value_text(question_prefix, current_results[:input]))
+      current_results[:intermediate_steps].each do |action, obs|
+        if action.is_a?(TrainAction)
+          obs = Observation.new(status: :ok, note: obs) if obs.is_a?(String)
+          next if obs.status != :ok
+
+          history << Boxcar.assi("#{thought_prefix}#{action.log}", "\n",
+                                 key_and_value_text(observation_prefix, obs.note))
+        else
+          Boxcars.error "Unknown action: #{action}", :red
+        end
+      end
+      final_answer = key_and_value_text(final_answer_prefix, current_results[:output])
+      history << Boxcar.assi(
+        key_and_value_text(thought_prefix, "I know the final answer\n#{final_answer}\n"))
+      prompt.add_history(history)
+    end
+
     # Get an answer from the boxcar.
     def run_boxcar(inputs:, return_only_outputs: false)
       inputs = our_inputs(inputs)
@@ -117,13 +179,11 @@ module Boxcars
       if kwargs.empty?
         raise Boxcars::ArgumentError, "run supports only one positional argument." if args.length != 1
 
-        return run_boxcar(inputs: args[0])[output_keys.first]
-      end
-      if args.empty?
-        ans = run_boxcar(inputs: kwargs)
-        return ans[output_keys.first]
+        return run_boxcar(inputs: args[0])
       end
 
+      return run_boxcar(inputs: kwargs) if args.empty?
+
       raise Boxcars::ArgumentError, "run supported with either positional or keyword arguments but not both. Got args" \
                                     ": #{args} and kwargs: #{kwargs}."
     end
@@ -148,10 +208,12 @@ module Boxcars
   end
 end
 
+require "boxcars/observation"
 require "boxcars/result"
 require "boxcars/boxcar/engine_boxcar"
 require "boxcars/boxcar/calculator"
 require "boxcars/boxcar/google_search"
+require "boxcars/boxcar/url_text"
 require "boxcars/boxcar/wikipedia_search"
 require "boxcars/boxcar/sql_base"
 require "boxcars/boxcar/sql_active_record"

data/lib/boxcars/conversation.rb

@@ -5,7 +5,7 @@ module Boxcars
   class Conversation
     attr_reader :lines, :show_roles
 
-    PEOPLE = %i[system user assistant].freeze
+    PEOPLE = %i[system user assistant history].freeze
 
     def initialize(lines: [], show_roles: false)
       @lines = lines
@@ -64,6 +64,23 @@ module Boxcars
       @lines += conversation.lines
     end
 
+    # insert converation above history line if it is present
+    # @param conversation [Conversation] The conversation to add
+    def add_history(conversation)
+      # find the history line
+      hi = lines.rindex { |ln| ln[0] == :history }
+      return unless hi
+
+      @lines = @lines.dup
+
+      # insert the conversation above the history line
+      @lines.insert(hi, *conversation.lines)
+    end
+
+    def no_history
+      @lines.reject { |ln| ln[0] == :history }
+    end
+
     # return just the messages for the conversation
     def message_text
       lines.map(&:last).join("\n")
@@ -73,7 +90,7 @@ module Boxcars
     # @param inputs [Hash] The inputs to use for the prompt.
     # @return [Hash] The formatted prompt { messages: ...}
     def as_messages(inputs = nil)
-      { messages: lines.map { |ln| { role: ln.first, content: ln.last % inputs } } }
+      { messages: no_history.map { |ln| { role: ln.first, content: ln.last % inputs } } }
     rescue ::KeyError => e
       first_line = e.message.to_s.split("\n").first
       Boxcars.error "Missing prompt input key: #{first_line}"
@@ -85,9 +102,9 @@ module Boxcars
     # @return [Hash] The formatted prompt { prompt: "..."}
     def as_prompt(inputs = nil)
       if show_roles
-        lines.map { |ln| format("#{ln.first}: #{ln.last}", inputs) }.join("\n\n")
+        no_history.map { |ln| format("#{ln.first}: #{ln.last}", inputs) }.compact.join("\n\n")
       else
-        lines.map { |ln| format(ln.last, inputs) }.join("\n\n")
+        no_history.map { |ln| format(ln.last, inputs) }.compact.join("\n\n")
       end
     rescue ::KeyError => e
       first_line = e.message.to_s.split("\n").first

data/lib/boxcars/conversation_prompt.rb

@@ -36,5 +36,16 @@ module Boxcars
       new_prompt.conversation.add_conversation(conversation)
       new_prompt
     end
+
+    # add conversation history to the prompt
+    # @param history [Hash] The history to add to the prompt.
+    def add_history(history)
+      conversation.add_history(Conversation.new(lines: history))
+    end
+
+    # print the prompt
+    def to_s
+      conversation.to_s
+    end
   end
 end

data/lib/boxcars/observation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Boxcars
+  # used by Boxcars to return structured result and additional context
+  class Observation
+    attr_reader :note, :status, :added_context
+
+    # @param note [String] The note to use for the result
+    # @param status [Symbol] :ok or :error
+    # @param added_context [Hash] Any additional context to add to the result
+    def initialize(note:, status: :ok, **added_context)
+      @note = note
+      @status = status
+      @added_context = added_context
+    end
+
+    # @return [Hash] The result as a hash
+    def to_h
+      {
+        note: note,
+        status: status
+      }.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
+      note
+    end
+
+    # create a new Observaton from a text string with a status of :ok
+    # @param note [String] The text to use for the observation
+    # @param added_context [Hash] Any additional context to add to the result
+    # @return [Boxcars::Observation] The observation
+    def self.ok(note, **kwargs)
+      new(note: note, status: :ok, **kwargs)
+    end
+
+    # create a new Observaton from a text string with a status of :error
+    # @param note [String] The text to use for the observation
+    # @param added_context [Hash] Any additional context to add to the result
+    # @return [Boxcars::Observation] The observation
+    def self.err(note, **kwargs)
+      new(note: note, status: :error, **kwargs)
+    end
+  end
+end

data/lib/boxcars/ruby_repl.rb

@@ -8,7 +8,7 @@ module Boxcars
     def call(code:)
       Boxcars.debug "RubyREPL: #{code}", :yellow
 
-      # wrap the code in an excption block so we can catch errors
+      # wrap the code in an exception 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|
@@ -19,6 +19,8 @@ module Boxcars
       if output =~ /^Error: /
         Boxcars.debug output, :red
         Result.from_error(output, code: code)
+      elsif output.blank?
+        Result.from_error("The code you gave me did not print a result", code: code)
       else
         output = ::Regexp.last_match(1) if output =~ /^\s*Answer:\s*(.*)$/m
         Boxcars.debug "Answer: #{output}", :yellow, style: :bold

data/lib/boxcars/train/xml_train.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+# base class for all XML trains
+module Boxcars
+  # A Train using XML for prompting and execution.
+  class XMLTrain < Train
+    # A Train will use a engine to run a series of boxcars.
+    # @param boxcars [Array<Boxcars::Boxcar>] The boxcars to run.
+    # @param prompt [Boxcars::Prompt] The prompt to use.
+    # @param engine [Boxcars::Engine] The engine to use for this train.
+    # @param kwargs [Hash] Additional arguments including: name, description, top_k, return_direct, and stop
+    # @abstract
+    def initialize(boxcars:, prompt:, engine: nil, **kwargs)
+      super
+    end
+
+    def init_prefixes
+      @thought_prefix ||= "<thought>"
+      @observation_prefix ||= "<observation>"
+      @final_answer_prefix ||= "<final_answer>"
+      @answer_prefix ||= "<answer>"
+      @question_prefix ||= "<question>"
+      @output_prefix ||= "<output>"
+    end
+
+    def close_tag(tag)
+      tag.to_s.sub("<", "</") if tag.to_s[0] == "<"
+    end
+
+    # the xml to describe the boxcars
+    def boxcars_xml
+      schema = boxcars.map(&:schema).join("\n")
+      "<boxcars>\n#{schema}</boxcars>"
+    end
+
+    # @return Hash The additional variables for this boxcar.
+    def prediction_additional(_inputs)
+      { boxcars_xml: boxcars_xml, next_actions: next_actions }.merge super
+    end
+
+    def build_output(text)
+      if text =~ /#{close_tag(thought_prefix)}/
+        "<data>#{engine_prefix}#{text}</data>"
+      else
+        "<data>#{text}</data>"
+      end
+    end
+
+    # Extract the boxcar and input from the engine output.
+    # @param text [String] The output from the engine.
+    # @return [Array<Boxcars::Boxcar, String>] The boxcar and input.
+    def extract_boxcar_and_input(text)
+      get_action_and_input(engine_output: build_output(text))
+    rescue StandardError => e
+      Boxcars.debug("Error: #{e.message}", :red)
+      [:error, e.message]
+    end
+
+    private
+
+    def parse_output(engine_output)
+      doc = Nokogiri::XML("<data>#{engine_prefix}#{engine_output}\n</data>")
+      keys = doc.element_children.first.element_children.map(&:name).map(&:to_sym)
+      keys.to_h do |key|
+        [key, doc.at_xpath("//#{key}")&.text]
+      end
+    end
+
+    def child_keys(xnode)
+      xnode.children.map(&:name).map(&:to_sym)
+    end
+
+    # get next action and input using an XNode
+    # @param xnode [XNode] The XNode to use.
+    # @return [Array<String, String>] The action and input.
+    def xn_get_action_and_input(xnode)
+      action = xnode.xtext("//action")
+      action_input = xnode.xtext("//action_input")
+      thought = xnode.xtext("//thought")
+      final_answer = xnode.xtext("//final_answer")
+
+      # the thought should be the frist line here if it doesn't start with "Action:"
+      Boxcars.debug("Thought: #{thought}", :yellow)
+
+      if final_answer.present?
+        Result.new(status: :ok, answer: final_answer, explanation: final_answer)
+      else
+        # we have an unexpected output from the engine
+        unless action.present? && action_input.present?
+          return [:error, "You gave me an improperly formatted answer or didn't use tags."]
+        end
+
+        Boxcars.debug("Action: #{action}\nAction Input: #{action_input}", :yellow)
+        [action, action_input]
+      end
+    end
+
+    # Parse out the action and input from the engine output.
+    # @param engine_output [String] The output from the engine.
+    # @return [Array<String>] The action and input.
+    def get_action_and_input(engine_output:)
+      xn_get_action_and_input(XNode.from_xml(engine_output))
+    end
+  end
+end

data/lib/boxcars/train/xml_zero_shot.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+# Agent for the MRKL chain
+module Boxcars
+  # A Train using the zero-shot react method and only XML in the prompt.
+  class XMLZeroShot < XMLTrain
+    attr_reader :boxcars
+    attr_accessor :wants_next_actions
+
+    # @param boxcars [Array<Boxcars::Boxcar>] The boxcars to run.
+    # @param engine [Boxcars::Engine] The engine to use for this train.
+    # @param name [String] The name of the train. Defaults to 'Zero Shot'.
+    # @param description [String] The description of the train. Defaults to 'Zero Shot Train'.
+    # @param prompt [Boxcars::Prompt] The prompt to use. Defaults to the built-in prompt.
+    # @param kwargs [Hash] Additional arguments to pass to the train. wants_next_actions: true
+    def initialize(boxcars:, engine: nil, name: 'Zero Shot XML', description: 'Zero Shot Train wiht XML', prompt: nil, **kwargs)
+      @engine_prefix = '<thought>'
+      @wants_next_actions = kwargs.fetch(:wants_next_actions, false)
+      prompt ||= my_prompt
+      super(engine: engine, boxcars: boxcars, prompt: prompt, name: name, description: description, **kwargs)
+    end
+
+    private
+
+    CTEMPLATE = [
+      syst("<training>Answer the following questions as best you can. You have access to the following tools for actions:\n",
+           "%<boxcars_xml>s",
+           "Use the following format making sure all open tags have closing tags:\n",
+           " <question>the input question you must answer</question>\n",
+           " <thought>you should always think about what to do</thought>\n",
+           " <action>the action to take, from this action list above</action>\n",
+           " <action_input>input to the action</action_input>\n",
+           " <observation>the result of the action</observation>\n",
+           " ... (this Thought/Action/Action Input/Observation sequence can repeat N times)\n",
+           " <thought>I know the final answer</thought>\n",
+           " <final_answer>the final answer to the original input question</final_answer>\n",
+           "-- FORMAT END -\n",
+           "Your answer should always have begin and end tags for each element.\n",
+           "Also make sure to specify a question for the action_input.\n",
+           "Finally, if you can deduct the answer from the question or observation, you can ",
+           "jump to final_answer and give me the answer.\n",
+           "</training>"),
+      hist, # insert thoughts here from previous runs
+      user("<question>%<input>s</question>"),
+      assi("<thought>%<agent_scratchpad>s")
+    ].freeze
+
+    # The prompt to use for the train.
+    def my_prompt
+      @conversation ||= Conversation.new(lines: CTEMPLATE)
+      @my_prompt ||= ConversationPrompt.new(
+        conversation: @conversation,
+        input_variables: [:input],
+        other_inputs: [:boxcars_xml, :next_actions, :agent_scratchpad],
+        output_variables: [:answer])
+    end
+  end
+end

data/lib/boxcars/train/zero_shot.rb

@@ -4,7 +4,7 @@
 module Boxcars
   # A Train using the zero-shot react method.
   class ZeroShot < Train
-    attr_reader :boxcars, :observation_prefix, :engine_prefix
+    attr_reader :boxcars, :observation_prefix
     attr_accessor :wants_next_actions
 
     # @param boxcars [Array<Boxcars::Boxcar>] The boxcars to run.
@@ -14,11 +14,9 @@ module Boxcars
     # @param prompt [Boxcars::Prompt] The prompt to use. Defaults to the built-in prompt.
     # @param kwargs [Hash] Additional arguments to pass to the train. wants_next_actions: true
     def initialize(boxcars:, engine: nil, name: 'Zero Shot', description: 'Zero Shot Train', prompt: nil, **kwargs)
-      @observation_prefix = 'Observation: '
-      @engine_prefix = 'Thought:'
       @wants_next_actions = kwargs.fetch(:wants_next_actions, false)
       prompt ||= my_prompt
-      super(engine: engine, boxcars: boxcars, prompt: prompt, name: name, description: description)
+      super(engine: engine, boxcars: boxcars, prompt: prompt, name: name, description: description, **kwargs)
     end
 
     # @return Hash The additional variables for this boxcar.
@@ -31,6 +29,8 @@ module Boxcars
     # @return [Array<Boxcars::Boxcar, String>] The boxcar and input.
     def extract_boxcar_and_input(text)
       get_action_and_input(engine_output: text)
+    rescue StandardError => e
+      [:error, e.message]
     end
 
     private
@@ -85,27 +85,15 @@ module Boxcars
            "%<next_actions>s\n",
            "Remember to start a line with \"Final Answer:\" to give me the final answer.\n",
            "Also make sure to specify a question for the Action Input.\n",
+           "Finally, if you can deduct the answer from the question or observation, you can ",
+           "start with \"Final Answer:\" and give me the answer.\n",
            "Begin!"),
+      # insert thoughts here from previous runs
+      hist,
       user("Question: %<input>s"),
       assi("Thought: %<agent_scratchpad>s")
     ].freeze
 
-    def boxcar_names
-      @boxcar_names ||= "[#{boxcars.map(&:name).join(', ')}]"
-    end
-
-    def boxcar_descriptions
-      @boxcar_descriptions ||= boxcars.map { |boxcar| "#{boxcar.name}: #{boxcar.description}" }.join("\n")
-    end
-
-    def next_actions
-      if wants_next_actions
-        "Next Actions: Up to 3 logical suggested next questions for the user to ask after getting this answer.\n"
-      else
-        ""
-      end
-    end
-
     # The prompt to use for the train.
     def my_prompt
       @conversation ||= Conversation.new(lines: CTEMPLATE)

data/lib/boxcars/train.rb

@@ -4,7 +4,8 @@ module Boxcars
   # @abstract
   class Train < EngineBoxcar
     attr_reader :boxcars, :return_values, :return_intermediate_steps,
-                :max_iterations, :early_stopping_method, :name_to_boxcar_map
+                :max_iterations, :early_stopping_method, :name_to_boxcar_map,
+                :observation_prefix, :thought_prefix, :final_answer_prefix, :answer_prefix, :question_prefix, :engine_prefix
 
     # A Train will use a engine to run a series of boxcars.
     # @param boxcars [Array<Boxcars::Boxcar>] The boxcars to run.
@@ -16,15 +17,25 @@ module Boxcars
       @boxcars = boxcars
       @name_to_boxcar_map = boxcars.to_h { |boxcar| [boxcar.name, boxcar] }
       @return_values = [:output]
-      @return_intermediate_steps = kwargs.delete(:return_intermediate_steps) || false
+      @return_intermediate_steps = kwargs.fetch(:return_intermediate_steps, true)
+      kwargs.delete(:return_intermediate_steps)
       @max_iterations = kwargs.delete(:max_iterations) || 25
       @early_stopping_method = kwargs.delete(:early_stopping_method) || "force"
-      kwargs[:stop] ||= ["\n#{observation_prefix}"]
+      init_prefixes
+      kwargs[:stop] = ["\n#{observation_prefix}"] unless kwargs.key?(:stop)
 
       super(prompt: prompt, engine: engine, **kwargs)
     end
 
-    # Extract the boxcar name and input from the text.
+    def init_prefixes
+      @thought_prefix ||= "Thought: "
+      @observation_prefix ||= "Observation: "
+      @final_answer_prefix ||= "Final Answer: "
+      @answer_prefix ||= "Answer:"
+      @question_prefix ||= "Question: "
+    end
+
+    # Callback to process the action/action input of a train.
     # @param text [String] The text to extract from.
     def extract_boxcar_and_input(text)
       Result.new(status: :ok, answer: text, explanation: engine_output)
@@ -37,7 +48,7 @@ module Boxcars
       thoughts = ""
       intermediate_steps.each do |action, observation|
         thoughts += action.is_a?(String) ? action : " #{action.log}"
-        thoughts += "\n#{observation_prefix}#{observation}\n#{engine_prefix}"
+        thoughts += "\n#{observation_text(observation)}\n#{engine_prefix}"
       end
       thoughts
     end
@@ -51,7 +62,7 @@ module Boxcars
       loop do
         full_inputs[:agent_scratchpad] += full_output
         output = predict(**full_inputs)
-        full_output += output
+        full_output += output.to_s
         parsed_output = extract_boxcar_and_input(full_output)
         break unless parsed_output.nil?
       end
@@ -88,14 +99,12 @@ module Boxcars
     # the input keys
     # @return [Array<Symbol>] The input keys.
     def input_keys
-      list = prompt.input_variables
-      list.delete(:agent_scratchpad)
-      list
+      prompt.input_variables - [:agent_scratchpad]
     end
 
     # the output keys
     def output_keys
-      return return_values + ["intermediate_steps"] if return_intermediate_steps
+      return return_values + [:intermediate_steps] if return_intermediate_steps
 
       return_values
     end
@@ -116,17 +125,10 @@ module Boxcars
     def pre_return(output, intermediate_steps)
       Boxcars.debug output.log, :yellow, style: :bold
       final_output = output.return_values
-      final_output["intermediate_steps"] = intermediate_steps if return_intermediate_steps
+      final_output[:intermediate_steps] = intermediate_steps if return_intermediate_steps
       final_output
     end
 
-    # the prefix for the engine
-    # @param return_direct [Boolean] Whether to return directly.
-    # @return [String] The prefix.
-    def engine_prefix(return_direct)
-      return_direct ? "" : engine_prefix
-    end
-
     # validate the prompt
     # @param values [Hash] The values to validate.
     # @return [Hash] The validated values.
@@ -159,7 +161,7 @@ module Boxcars
         thoughts = ""
         intermediate_steps.each do |action, observation|
           thoughts += action.log
-          thoughts += "\n#{observation_prefix}#{observation}\n#{engine_prefix}"
+          thoughts += "\n#{observation_text(observation)}\n#{engine_prefix}"
         end
         thoughts += "\n\nI now need to return a final answer based on the previous steps:"
         new_inputs = { agent_scratchpad: thoughts, stop: _stop }
@@ -170,6 +172,7 @@ module Boxcars
           TrainFinish.new({ output: full_output }, full_output)
         else
           boxcar, boxcar_input = parsed_output
+          Boxcars.debug "Got boxcar #{boxcar} and input #{boxcar_input}"
           if boxcar == finish_boxcar_name
             TrainFinish.new({ output: boxcar_input }, full_output)
           else
@@ -194,22 +197,24 @@ module Boxcars
 
         if (boxcar = name_to_boxcar_map[output.boxcar])
           begin
-            observation = boxcar.run(output.boxcar_input)
+            observation = Observation.ok(boxcar.run(output.boxcar_input))
             return_direct = boxcar.return_direct
           rescue Boxcars::ConfigurationError, Boxcars::SecurityError => e
             raise e
           rescue StandardError => e
             Boxcars.error "Error in #{boxcar.name} boxcar#call: #{e}\nbt:#{caller[0..5].join("\n   ")}", :red
-            observation = "Error - #{e}, correct and try again."
+            observation = Observation.err("Error - #{e}, correct and try again.")
           end
         elsif output.boxcar == :error
           observation = output.log
           return_direct = false
         else
-          observation = "#{output.boxcar} is not a valid boxcar, try another one."
+          observation = Observation.err("Error - #{output.boxcar} is not a valid action, try again.")
           return_direct = false
         end
-        Boxcars.debug "Observation: #{observation}", :green
+        # rubocop:disable Lint/RedundantStringCoercion
+        Boxcars.debug "Observation: #{observation.to_s}", :green
+        # rubocop:enable Lint/RedundantStringCoercion
         intermediate_steps.append([output, observation])
         if return_direct
           output = TrainFinish.new({ return_values[0] => observation }, "")
@@ -220,9 +225,46 @@ module Boxcars
       output = return_stopped_response(early_stopping_method, intermediate_steps, **inputs)
       pre_return(output, intermediate_steps)
     end
+
+    def key_and_value_text(key, value)
+      value = value.to_s
+      if key =~ /^<(?<tag_name>[[:word:]]+)>$/
+        # we need a close tag too
+        "#{key}#{value}</#{Regexp.last_match[:tag_name]}>"
+      else
+        "#{key}#{value}"
+      end
+    end
+
+    # this is for the scratchpad
+    def observation_text(observation)
+      key_and_value_text(observation_prefix, observation)
+    end
+
+    def question_text(question)
+      key_and_value_text(question_prefix, question)
+    end
+
+    def boxcar_names
+      @boxcar_names ||= boxcars.map(&:name).join(', ')
+    end
+
+    def boxcar_descriptions
+      @boxcar_descriptions ||= boxcars.map { |boxcar| "#{boxcar.name}: #{boxcar.description}" }.join("\n")
+    end
+
+    def next_actions
+      if wants_next_actions
+        "Next Actions: Up to 3 logical suggested next questions for the user to ask after getting this answer.\n"
+      else
+        ""
+      end
+    end
   end
 end
 
 require "boxcars/train/train_action"
 require "boxcars/train/train_finish"
 require "boxcars/train/zero_shot"
+require "boxcars/train/xml_train"
+require "boxcars/train/xml_zero_shot"

data/lib/boxcars/version.rb

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

data/lib/boxcars/x_node.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module Boxcars
+  class XNode
+    attr_accessor :node, :children, :attributes
+
+    def initialize(node)
+      @node = node
+      @valid_names = []
+      @children = {}
+      # @attributes = node.attributes.transform_values(&:value)
+      @attributes = node.attributes.values.to_h { |a| [a.name.to_sym, a.value] }
+
+      node.children.each do |child|
+        next if child.text?
+
+        child_node = XNode.new(child)
+        if @children[child.name].nil?
+          @valid_names << child.name.to_sym
+          @children[child.name] = child_node
+        elsif @children[child.name].is_a?(Array)
+          @children[child.name] << child_node
+        else
+          @children[child.name] = [@children[child.name], child_node]
+        end
+      end
+    end
+
+    def self.from_xml(xml)
+      doc = Nokogiri::XML.parse(xml)
+      raise XmlError, "XML is not valid: #{doc.errors.map { |e| "#{e.line}:#{e.column} #{e.message}" }}" if doc.errors.any?
+
+      XNode.new(doc.root)
+    end
+
+    def xml
+      @node.to_xml
+    end
+
+    def text
+      @node.text
+    end
+
+    def xpath(path)
+      @node.xpath(path)
+    end
+
+    def xtext(path)
+      rv = xpath(path)&.text&.gsub(/[[:space:]]+/, " ")&.strip
+      return nil if rv.empty?
+
+      rv
+    end
+
+    def stext
+      @stext ||= text.gsub(/[[:space:]]+/, " ").strip # remove extra spaces
+    end
+
+    def [](key)
+      @children[key.to_s]
+    end
+
+    def method_missing(name, *args)
+      return @children[name.to_s] if @children.key?(name.to_s)
+
+      super
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @valid_names.include?(method) || super
+    end
+  end
+end

data/lib/boxcars.rb

@@ -22,6 +22,9 @@ module Boxcars
   # Error class for all Boxcars key errors.
   class KeyError < Error; end
 
+  # Error class for all Boxcars XML errors.
+  class XmlError < Error; end
+
   # Configuration contains gem settings
   class Configuration
     attr_writer :openai_access_token, :serpapi_api_key
@@ -179,6 +182,7 @@ module Boxcars
 end
 
 require "boxcars/version"
+require "boxcars/x_node"
 require "boxcars/prompt"
 require "boxcars/conversation_prompt"
 require "boxcars/conversation"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boxcars
 version: !ruby/object:Gem::Version
-  version: 0.2.16
+  version: 0.3.2
 platform: ruby
 authors:
 - Francis Sullivan
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-26 00:00:00.000000000 Z
+date: 2023-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google_search_results
@@ -53,6 +53,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
 - !ruby/object:Gem::Dependency
   name: pgvector
   requirement: !ruby/object:Gem::Requirement
@@ -113,6 +127,7 @@ files:
 - lib/boxcars/boxcar/sql_base.rb
 - lib/boxcars/boxcar/sql_sequel.rb
 - lib/boxcars/boxcar/swagger.rb
+- lib/boxcars/boxcar/url_text.rb
 - lib/boxcars/boxcar/vector_answer.rb
 - lib/boxcars/boxcar/wikipedia_search.rb
 - lib/boxcars/conversation.rb
@@ -122,12 +137,15 @@ files:
 - lib/boxcars/engine/gpt4all_eng.rb
 - lib/boxcars/engine/openai.rb
 - lib/boxcars/generation.rb
+- lib/boxcars/observation.rb
 - lib/boxcars/prompt.rb
 - lib/boxcars/result.rb
 - lib/boxcars/ruby_repl.rb
 - lib/boxcars/train.rb
 - lib/boxcars/train/train_action.rb
 - lib/boxcars/train/train_finish.rb
+- lib/boxcars/train/xml_train.rb
+- lib/boxcars/train/xml_zero_shot.rb
 - lib/boxcars/train/zero_shot.rb
 - lib/boxcars/vector_search.rb
 - lib/boxcars/vector_store.rb
@@ -147,6 +165,7 @@ files:
 - lib/boxcars/vector_store/pgvector/search.rb
 - lib/boxcars/vector_store/split_text.rb
 - lib/boxcars/version.rb
+- lib/boxcars/x_node.rb
 homepage: https://github.com/BoxcarsAI/boxcars
 licenses:
 - MIT