boxcars 0.7.6 → 0.8.0

data/README.md

@@ -149,6 +149,311 @@ Also, if you set this flag: `Boxcars.configuration.log_prompts = true`
 The actual prompts handed to the connected Engine will be logged. This is off by default because it is very wordy, but handy if you are debugging prompts.
 
 Otherwise, we print to standard out.
+
+### Engine Factory (Engines)
+
+Boxcars provides a convenient factory class `Boxcars::Engines` that simplifies creating engine instances using model names and aliases instead of remembering full class names and model strings.
+
+#### Basic Usage
+
+```ruby
+# Using default model (gemini-2.5-flash-preview-05-20)
+engine = Boxcars::Engines.engine
+
+# Using specific models with convenient aliases
+gpt_engine = Boxcars::Engines.engine(model: "gpt-4o")
+claude_engine = Boxcars::Engines.engine(model: "sonnet")
+gemini_engine = Boxcars::Engines.engine(model: "flash")
+groq_engine = Boxcars::Engines.engine(model: "groq")
+```
+
+#### Supported Model Aliases
+
+**OpenAI Models:**
+- `"gpt-4o"`, `"gpt-3.5-turbo"`, `"o1-preview"` - Creates `Boxcars::Openai` engines
+
+**Anthropic Models:**
+- `"anthropic"`, `"sonnet"` - Creates `Boxcars::Anthropic` with Claude Sonnet
+- `"opus"` - Creates `Boxcars::Anthropic` with Claude Opus
+- `"claude-3-5-sonnet"`, etc. - Any model starting with "claude-"
+
+**Groq Models:**
+- `"groq"` - Creates `Boxcars::Groq` with Llama 3.3 70B
+- `"deepseek"` - Creates `Boxcars::Groq` with DeepSeek R1
+- `"mistral"` - Creates `Boxcars::Groq` with Mistral
+- Models starting with `"mistral-"`, `"meta-llama/"`, or `"deepseek-"`
+
+**Gemini Models:**
+- `"flash"`, `"gemini-flash"` - Creates `Boxcars::GeminiAi` with Gemini 2.5 Flash
+- `"gemini-pro"` - Creates `Boxcars::GeminiAi` with Gemini 2.5 Pro
+- Any model starting with `"gemini-"`
+
+**Perplexity Models:**
+- `"online"`, `"sonar"` - Creates `Boxcars::Perplexityai` with Sonar
+- `"sonar-pro"`, `"huge"` - Creates `Boxcars::Perplexityai` with Sonar Pro
+- Models containing `"-sonar-"`
+
+**Together AI Models:**
+- `"together-model-name"` - Creates `Boxcars::Together` (strips "together-" prefix)
+
+#### JSON-Optimized Engines
+
+For applications requiring JSON responses, use the `json_engine` method:
+
+```ruby
+# Creates engine optimized for JSON output
+json_engine = Boxcars::Engines.json_engine(model: "gpt-4o")
+
+# Automatically removes response_format for models that don't support it
+json_claude = Boxcars::Engines.json_engine(model: "sonnet")
+```
+
+#### Passing Additional Parameters
+
+```ruby
+# Pass any additional parameters to the underlying engine
+engine = Boxcars::Engines.engine(
+  model: "gpt-4o",
+  temperature: 0.7,
+  max_tokens: 1000,
+  top_p: 0.9
+)
+```
+
+#### Using with Boxcars
+
+```ruby
+# Use the factory with any Boxcar
+engine = Boxcars::Engines.engine(model: "sonnet")
+calc = Boxcars::Calculator.new(engine: engine)
+result = calc.run "What is 15 * 23?"
+
+# Or in a Train
+boxcars = [
+  Boxcars::Calculator.new(engine: Boxcars::Engines.engine(model: "gpt-4o")),
+  Boxcars::GoogleSearch.new(engine: Boxcars::Engines.engine(model: "flash"))
+]
+train = Boxcars.train.new(boxcars: boxcars)
+```
+
+### Overriding the Default Engine Model
+
+Boxcars provides several ways to override the default engine model used throughout your application. The default model is currently `"gemini-2.5-flash-preview-05-20"`, but you can customize this behavior.
+
+#### Global Configuration
+
+Set a global default model that will be used by `Boxcars::Engines.engine()` when no model is specified:
+
+```ruby
+# Set the default model globally
+Boxcars.configuration.default_model = "gpt-4o"
+
+# Now all engines created without specifying a model will use GPT-4o
+engine = Boxcars::Engines.engine  # Uses gpt-4o
+calc = Boxcars::Calculator.new    # Uses gpt-4o via default engine
+```
+
+#### Configuration Block
+
+Use a configuration block for more organized setup:
+
+```ruby
+Boxcars.configure do |config|
+  config.default_model = "sonnet"  # Use Claude Sonnet as default
+  config.logger = Rails.logger     # Set custom logger
+  config.log_prompts = true        # Enable prompt logging
+end
+```
+
+#### Per-Instance Override
+
+Override the model for specific engine instances:
+
+```ruby
+# Global default is gemini-flash, but use different models per boxcar
+default_engine = Boxcars::Engines.engine                    # Uses global default
+gpt_engine = Boxcars::Engines.engine(model: "gpt-4o")       # Uses GPT-4o
+claude_engine = Boxcars::Engines.engine(model: "sonnet")    # Uses Claude Sonnet
+
+# Use different engines for different boxcars
+calc = Boxcars::Calculator.new(engine: gpt_engine)
+search = Boxcars::GoogleSearch.new(engine: claude_engine)
+```
+
+#### Environment-Based Configuration
+
+Set the default model via environment variables or initialization:
+
+```ruby
+# In your application initialization (e.g., Rails initializer)
+if Rails.env.production?
+  Boxcars.configuration.default_model = "gpt-4o"      # Use GPT-4o in production
+elsif Rails.env.development?
+  Boxcars.configuration.default_model = "flash"       # Use faster Gemini Flash in development
+else
+  Boxcars.configuration.default_model = "groq"        # Use Groq for testing
+end
+```
+
+#### Model Resolution Priority
+
+The `Boxcars::Engines.engine()` method resolves the model in this order:
+
+1. **Explicit model parameter**: `Boxcars::Engines.engine(model: "gpt-4o")`
+2. **Global configuration**: `Boxcars.configuration.default_model`
+3. **Built-in default**: `"gemini-2.5-flash-preview-05-20"`
+
+#### Supported Model Aliases
+
+When setting `default_model`, you can use any of the supported model aliases:
+
+```ruby
+# These are all valid default_model values:
+Boxcars.configuration.default_model = "gpt-4o"        # OpenAI GPT-4o
+Boxcars.configuration.default_model = "sonnet"        # Claude Sonnet
+Boxcars.configuration.default_model = "flash"         # Gemini Flash
+Boxcars.configuration.default_model = "groq"          # Groq Llama
+Boxcars.configuration.default_model = "online"        # Perplexity Sonar
+```
+
+#### Legacy Engine Configuration
+
+You can also override the default engine class (though this is less common):
+
+```ruby
+# Override the default engine class entirely
+Boxcars.configuration.default_engine = Boxcars::Anthropic
+
+# Now Boxcars.engine returns Anthropic instead of OpenAI
+default_engine = Boxcars.engine  # Returns Boxcars::Anthropic instance
+```
+
+**Note**: When using `default_engine`, the `default_model` setting is ignored since you're specifying the engine class directly.
+
+### Observability
+
+Boxcars includes a comprehensive observability system that allows you to track and monitor AI operations across your application. The system provides insights into LLM calls, performance metrics, errors, and usage patterns.
+
+#### Core Components
+
+**Observability Class**: The central tracking interface that provides a simple `track` method for recording events.
+
+**ObservabilityBackend Module**: An interface that defines how tracking backends should be implemented. All backends must include this module and implement a `track` method.
+
+**Built-in Backends**:
+- **PosthogBackend**: Sends events to PostHog for analytics and user behavior tracking
+- **MultiBackend**: Allows sending events to multiple backends simultaneously
+
+#### Configuration
+
+Set up observability by configuring a backend:
+
+```ruby
+# Using PostHog backend
+require 'boxcars/observability_backends/posthog_backend'
+
+Boxcars.configure do |config|
+  config.observability_backend = Boxcars::PosthogBackend.new(
+    api_key: ENV['POSTHOG_API_KEY'] || 'your_posthog_api_key',
+    host: 'https://app.posthog.com' # or your self-hosted instance
+  )
+end
+
+# Using multiple backends
+require 'boxcars/observability_backends/multi_backend'
+backend1 = Boxcars::PosthogBackend.new(api_key: ENV['POSTHOG_API_KEY'])
+backend2 = YourCustomBackend.new
+
+Boxcars.configure do |config|
+  config.observability_backend = Boxcars::MultiBackend.new([backend1, backend2])
+end
+```
+
+#### Automatic Tracking
+
+Boxcars automatically tracks LLM calls with detailed metrics:
+
+```ruby
+# This automatically generates observability events
+engine = Boxcars::Openai.new
+calc = Boxcars::Calculator.new(engine: engine)
+result = calc.run "what is 2 + 2?"
+```
+
+**Tracked Properties Include**:
+- `provider`: The LLM provider (e.g., "openai", "anthropic")
+- `model_name`: The specific model used
+- `prompt_content`: The conversation messages sent to the LLM
+- `inputs`: Any template inputs provided
+- `duration_ms`: Request duration in milliseconds
+- `success`: Whether the call succeeded
+- `status_code`: HTTP response status
+- `error_message`: Error details if the call failed
+- `response_raw_body`: Raw API response
+- `api_call_parameters`: Parameters sent to the API
+
+#### Manual Tracking
+
+You can also track custom events:
+
+```ruby
+Boxcars::Observability.track(
+  event: 'custom_operation',
+  properties: {
+    user_id: 'user_123',
+    operation_type: 'data_processing',
+    duration_ms: 150,
+    success: true
+  }
+)
+```
+
+#### Creating Custom Backends
+
+Implement your own backend by including the `ObservabilityBackend` module:
+
+```ruby
+class CustomBackend
+  include Boxcars::ObservabilityBackend
+  
+  def track(event:, properties:)
+    # Your custom tracking logic here
+    puts "Event: #{event}, Properties: #{properties}"
+  end
+end
+
+Boxcars.configure do |config|
+  config.observability_backend = CustomBackend.new
+end
+```
+
+#### Error Handling
+
+The observability system is designed to fail silently to prevent tracking issues from disrupting your main application flow. If a backend raises an error, it will be caught and ignored, ensuring your AI operations continue uninterrupted.
+
+#### PostHog Integration
+
+The PostHog backend requires the `posthog-ruby` gem:
+
+```ruby
+# Add to your Gemfile
+gem 'posthog-ruby'
+
+# Configure the backend
+Boxcars.configure do |config|
+  config.observability_backend = Boxcars::PosthogBackend.new(
+    api_key: ENV['POSTHOG_API_KEY'],
+    host: 'https://app.posthog.com',
+    on_error: proc { |status, body| 
+      Rails.logger.warn "PostHog error: #{status} - #{body}" 
+    }
+  )
+end
+```
+
+Events are automatically associated with users when a `user_id` property is provided. Anonymous events use a default identifier.
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

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
@@ -36,7 +36,6 @@ Gem::Specification.new do |spec|
   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