foobara-agent 0.0.11 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e0f6302247bbcc56ed93f61ec3a5d39e5041029e03b20cadea2d1dd0ebd04b6
-  data.tar.gz: baca677e1ea555bcdc908fd2b37dc2d8b016df9888f8f7a69c8cff73774756b2
+  metadata.gz: dc32aeaa66ec947920e085944f7948d22d97b4fa3b39d1a4b4fbf58755ca4321
+  data.tar.gz: 0dc7b3d02061bf0a615ab6299ea5f607fff1d703804d5368b57a9157d4edf64a
 SHA512:
-  metadata.gz: 350feb6d9058009889a342a5dcc4f44befed8a25be71ebc7673bf75b7ceb1f95adcec3a52d2eb53ba9301d0ef2312919a4496a53f2146423dd36c17b122856af
-  data.tar.gz: a91ec6608bc3001f06d3c17562321d2c1a52a537372347593293d57d9d6312126f5116853c8b32b649d7c65a050bbb67bd03b2dbc50247cdc7260013b6d8f3ec
+  metadata.gz: e1a1d3780d7a3112cff93e7e626ec677ad558ce605e65c60f00ec3b8213b604e248ca4428311303b1902451f2bcc7d2a5f17f3725dde77bbb4725aeb10b9898d
+  data.tar.gz: f6113517024dc34e999fafcb3bc5ee0ec98fb63628f61725b5631e454d6edd4714933a745232e57f2a1c8f686f0d2544b481b1726cfff3e4dbbc47666bdd74c4

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.0.14] - 2025-07-08
+
+- Better handle serialization/pre-commit loading for various entity-depth scenarios
+
+## [0.0.13] - 2025-07-06
+
+- Eliminate NotifyUser... result_type to save tokens/improve accuracy
+- Choose DescribeCommand for commands with inputs that haven't been described
+- Log failure output when trying to determine commands/inputs
+
+## [0.0.12] - 2025-07-05
+
+- Choose DescribeCommand for commands that have inputs and haven't been described
+- Log determine command/input failures when verbose
+
 ## [0.0.11] - 2025-07-01
 
 - Fix some bugs with result type/value mismatches

data/src/foobara/agent/accomplish_goal.rb

@@ -19,7 +19,6 @@ module Foobara
         io_out :duck
         io_err :duck
         agent Agent, :required
-        context Context, :required, "The current context of the agent"
         maximum_command_calls :integer,
                               :allow_nil,
                               default: 25,
@@ -30,6 +29,9 @@ module Foobara
                   default: "claude-3-7-sonnet-20250219",
                   description: "The model to use for the LLM"
         max_llm_calls_per_minute :integer, :allow_nil
+        user_association_depth :symbol, :allow_nil, one_of: Foobara::AssociationDepth
+        result_entity_depth :symbol, :allow_nil, one_of: Foobara::AssociationDepth
+        pass_aggregates_to_llm :boolean, :allow_nil
       end
 
       result do
@@ -40,8 +42,10 @@ module Foobara
       depends_on ListCommands
 
       def execute
-        simulate_describe_list_commands_command
-        simulate_list_commands_run
+        unless list_commands_already_ran?
+          simulate_describe_list_commands_command
+          simulate_list_commands_run
+        end
         # simulate_describe_command_run_for_all_commands
 
         until mission_accomplished or given_up
@@ -51,9 +55,8 @@ module Foobara
           throttle_llm_calls_if_necessary
 
           determine_next_command_and_inputs
-          run_next_command
 
-          log_last_command_outcome
+          run_next_command
         end
 
         if given_up
@@ -68,6 +71,10 @@ module Foobara
                     :final_result, :final_message, :command_response, :delayed_command_name,
                     :command_calls
 
+      def list_commands_already_ran?
+        context.command_log.any? { |log_entry| log_entry.command_name =~ /\bListCommands\z/ }
+      end
+
       def simulate_list_commands_run
         self.next_command_name = ListCommands.full_command_name
         self.next_command_raw_inputs = nil
@@ -75,7 +82,6 @@ module Foobara
         fetch_next_command_class
 
         run_next_command
-        log_last_command_outcome
       end
 
       def simulate_describe_list_commands_command
@@ -85,7 +91,6 @@ module Foobara
         fetch_next_command_class
 
         run_next_command
-        log_last_command_outcome
       end
 
       def simulate_describe_command(command_name = next_command_name)
@@ -100,7 +105,6 @@ module Foobara
         fetch_next_command_class
 
         run_next_command
-        log_last_command_outcome
 
         self.next_command_name = old_next_command_name
         self.next_command_inputs = old_next_command_inputs
@@ -114,7 +118,7 @@ module Foobara
         return if context.command_log.size > 1
 
         ListCommands.run!(command_connector: agent)[:user_provided_commands].each do |full_command_name|
-          next if described_commands.include?(full_command_name)
+          next if command_described?(full_command_name)
 
           self.next_command_name = DescribeCommand.full_command_name
           self.next_command_inputs = { command_name: full_command_name }
@@ -122,7 +126,6 @@ module Foobara
           fetch_next_command_class
 
           run_next_command
-          log_last_command_outcome
         end
         # :nocov:
       end
@@ -145,11 +148,10 @@ module Foobara
 
         compact_command_log
 
-        inputs_for_determine = {
-          context:,
-          llm_model:
-        }
-
+        inputs_for_determine = { agent:, llm_model: }
+        unless pass_aggregates_to_llm.nil?
+          inputs_for_determine[:pass_aggregates_to_llm] = pass_aggregates_to_llm
+        end
         determine_command = DetermineNextCommandNameAndInputs.new(inputs_for_determine)
 
         outcome = begin
@@ -171,10 +173,17 @@ module Foobara
           if outcome.success?
             fetch_next_command_class
 
+            if need_to_describe_next_command?
+              simulate_describe_command
+              return determine_next_command_and_inputs(retries, outcome)
+            end
+
             if next_command_has_inputs?
               outcome = validate_next_command_inputs
 
               unless outcome.success?
+                # TODO: test this path
+                # :nocov:
                 log_command_outcome(
                   command_name: next_command_name,
                   inputs: next_command_inputs,
@@ -184,6 +193,7 @@ module Foobara
                 simulate_describe_command
 
                 determine_next_command_and_inputs(retries - 1, outcome)
+                # :nocov:
               end
             else
               self.next_command_inputs = {}
@@ -260,23 +270,7 @@ module Foobara
       end
 
       def run_next_command
-        if verbose?
-          args = if next_command_inputs.nil? || next_command_inputs.empty?
-                   ""
-                 else
-                   s = next_command_inputs.to_s
-
-                   if s =~ /\A\{(.*)}\z/
-                     "(#{::Regexp.last_match(1)})"
-                   else
-                     # :nocov:
-                     raise "Unexpected next_command_inputs: #{next_command_inputs}"
-                     # :nocov:
-                   end
-                 end
-
-          (io_out || $stdout).puts "#{next_command_name}.run#{args}"
-        end
+        log_command_code(command_name: next_command_name, inputs: next_command_inputs)
 
         self.command_response = agent.run(
           full_command_name: next_command_name,
@@ -286,19 +280,7 @@ module Foobara
 
         self.command_outcome = command_response.outcome
 
-        if verbose?
-          unless command_outcome.success?
-            # :nocov:
-            (io_err || $stderr).puts(
-              "Command #{command_response.command.class.full_command_name} failed #{command_outcome.errors_hash}"
-            )
-            # :nocov:
-          end
-        end
-      end
-
-      def log_last_command_outcome
-        log_command_outcome(command: command_response.command)
+        log_command_outcome(command: command_response.command, log_command_code: false)
       end
 
       def compact_command_log
@@ -337,13 +319,14 @@ module Foobara
           next unless last_success
 
           failure_indexes.each do |failure_index|
+            # TODO: test this path
+            # :nocov:
             if failure_index < last_success
               indexes_to_delete << failure_index
             else
-              # :nocov:
               break
-              # :nocov:
             end
+            # :nocov:
           end
         end
 
@@ -377,7 +360,12 @@ module Foobara
         end
       end
 
-      def log_command_outcome(command: nil, command_name: nil, inputs: nil, outcome: nil, result: nil)
+      def log_command_outcome(command: nil,
+                              command_name: nil,
+                              inputs: nil,
+                              outcome: nil,
+                              result: nil,
+                              log_command_code: true)
         if command
           command_name ||= command.class.full_command_name
           inputs ||= command.raw_inputs
@@ -405,6 +393,43 @@ module Foobara
         )
 
         context.command_log << log_entry
+
+        if verbose?
+          if log_command_code
+            # TODO: test this code path hmmm
+            # :nocov:
+            self.log_command_code(command_name:, inputs:)
+            # :nocov:
+          end
+
+          unless log_entry.success?
+            # :nocov:
+            (io_err || $stderr).puts(
+              "Command #{log_entry.command_name} failed:\n#{log_entry.errors_hash}"
+            )
+            # :nocov:
+          end
+        end
+      end
+
+      def log_command_code(command_name:, inputs:)
+        if verbose?
+          args = if next_command_inputs.nil? || next_command_inputs.empty?
+                   ""
+                 else
+                   s = next_command_inputs.to_s
+
+                   if s =~ /\A\{(.*)}\z/
+                     "(#{::Regexp.last_match(1)})"
+                   else
+                     # :nocov:
+                     raise "Unexpected next_command_inputs: #{next_command_inputs}"
+                     # :nocov:
+                   end
+                 end
+
+          (io_out || $stdout).puts "#{next_command_name}.run#{args}"
+        end
       end
 
       # TODO: these are awkwardly called from outside. Come up with a better solution.
@@ -442,6 +467,20 @@ module Foobara
         verbose
       end
 
+      def need_to_describe_next_command?
+        return false if command_described?(next_command_name)
+        return false if next_command_name == DescribeCommand.full_command_name
+        return true if next_command_has_inputs?
+
+        # check if inputs were unexpectedly given for a command that doesn't need them,
+        # in which case we should describe it
+        next_command_inputs && !next_command_inputs.empty?
+      end
+
+      def command_described?(command_name)
+        described_commands.include?(command_name)
+      end
+
       def llm_call_timestamps
         @llm_call_timestamps ||= []
       end
@@ -487,6 +526,10 @@ module Foobara
           sleep seconds
         end
       end
+
+      def context
+        agent.context
+      end
     end
   end
 end

data/src/foobara/agent/determine_base.rb

@@ -2,9 +2,12 @@ require "foobara/llm_backed_command"
 
 module Foobara
   class Agent < CommandConnector
+    # TODO: just move this back to DetermineNextCommandAndInputs since it's now the only base class
     class DetermineBase < Foobara::LlmBackedCommand
       inputs do
-        context Context, :required, "Context of the progress towards the goal so far"
+        pass_aggregates_to_llm :boolean, :allow_nil, "Should we send aggregates to the LLM or " \
+                                                     "require it to fetch what it needs?"
+        agent Agent, :required
         llm_model :string,
                   one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
                   default: "claude-3-7-sonnet-20250219",
@@ -12,7 +15,11 @@ module Foobara
       end
 
       def association_depth
-        Foobara::JsonSchemaGenerator::AssociationDepth::ATOM
+        if pass_aggregates_to_llm
+          Foobara::AssociationDepth::AGGREGATE
+        else
+          Foobara::AssociationDepth::ATOM
+        end
       end
 
       def build_messages
@@ -49,34 +56,13 @@ module Foobara
         p
       end
 
-      def llm_instructions
-        return @llm_instructions if defined?(@llm_instructions)
-
-        description = self.class.description
-
-        instructions = "You are the implementation of a command called #{self.class.scoped_full_name}"
-
-        instructions += if description && !description.empty?
-                          " which has the following description:\n\n#{self.class.description}\n\n"
-                        else
-                          # :nocov:
-                          ". "
-                          # :nocov:
-                        end
-
-        instructions += "You are working towards accomplishing the following goal:\n\n#{goal}\n\n"
-        instructions += "Your response should match the following JSON schema: \n\n#{self.class.result_json_schema}\n\n"
-        instructions += "You can get more details about the result schema for a specific command by " \
-                        "choosing the DescribeCommand command. " \
-                        "You will reply with nothing more than the JSON you've generated so that the calling code " \
-                        "can successfully parse your answer."
-
-        @llm_instructions = instructions
-      end
-
       def goal
         context.current_goal
       end
+
+      def context
+        agent.context
+      end
     end
   end
 end

data/src/foobara/agent/determine_next_command_name_and_inputs.rb

@@ -3,6 +3,44 @@ require_relative "determine_base"
 module Foobara
   class Agent < CommandConnector
     class DetermineNextCommandNameAndInputs < DetermineBase
+      class << self
+        def llm_instructions(assistant_association_depth, goal)
+          key = [assistant_association_depth, goal]
+
+          @llm_instructions_cache ||= {}
+
+          if @llm_instructions_cache.key?(key)
+            @llm_instructions_cache[key]
+          else
+            @llm_instructions_cache[key] = build_llm_instructions(assistant_association_depth, goal)
+          end
+        end
+
+        def build_llm_instructions(assistant_association_depth, goal)
+          instructions = "You are the implementation of a command called #{scoped_full_name}"
+
+          instructions += if description && !description.empty?
+                            " which has the following description:\n\n#{description}\n\n"
+                          else
+                            # :nocov:
+                            ". "
+                            # :nocov:
+                          end
+
+          result_schema = result_json_schema(assistant_association_depth)
+
+          instructions += "You are working towards accomplishing the following goal:\n\n#{goal}\n\n"
+          instructions += "Your response of which command to run next should match the following JSON schema:"
+          instructions += "\n\n#{result_schema}\n\n"
+          instructions += "You can get more details about the inputs and result schemas for a specific command by " \
+                          "choosing the DescribeCommand command. " \
+                          "You will reply with nothing more than the JSON you've generated so that the calling code " \
+                          "can successfully parse your answer."
+
+          instructions
+        end
+      end
+
       description "Returns the name of the next command to run and its inputs given the progress  " \
                   "towards accomplishing the current goal. " \
                   "If the goal has been accomplished it will choose the " \
@@ -12,6 +50,10 @@ module Foobara
         command :string, :required
         inputs :attributes, :allow_nil
       end
+
+      def determine_llm_instructions
+        self.llm_instructions = self.class.llm_instructions(computed_user_association_depth, goal)
+      end
     end
   end
 end

data/src/foobara/agent/notify_user_that_current_goal_has_been_accomplished.rb

@@ -1,15 +1,18 @@
 module Foobara
   class Agent < CommandConnector
+    # NOTE: we intentionally don't use a result type here
+    # to reduce tokens the LLM has to deal with when this command is described
     class NotifyUserThatCurrentGoalHasBeenAccomplished < Foobara::Command
       extend Concerns::SubclassCacheable
 
       class << self
-        attr_accessor :command_class, :returns_message_to_user, :returns_result_data, :result_is_attributes
+        attr_accessor :command_class, :returns_message_to_user, :returns_result_data, :result_is_attributes,
+                      :built_result_type
 
-        def for(agent_id: nil, result_type: nil, include_message_to_user_in_result: true)
+        def for(agent_id: nil, result_type: nil, include_message_to_user_in_result: true, result_entity_depth: nil)
           agent_id ||= "Anon#{SecureRandom.hex(2)}"
 
-          cached_subclass([result_type, agent_id, include_message_to_user_in_result]) do
+          cached_subclass([agent_id]) do
             command_name = "Foobara::Agent::#{agent_id}::NotifyUserThatCurrentGoalHasBeenAccomplished"
             klass = Util.make_class_p(command_name, self)
 
@@ -20,39 +23,40 @@ module Foobara
 
             if result_type
               klass.returns_result_data = true
+              unless result_type.is_a?(Types::Type)
+                result_type = Domain.current.foobara_type_from_declaration(result_type)
+              end
+
+              domain = result_type.created_in_namespace.foobara_domain
 
               # TODO: fix this... agent backed command sets these via its own result type.
               # check if message_to_user is already here and also search/fix result_data to be result for consistency.
               if include_message_to_user_in_result
                 klass.returns_message_to_user = true
 
-                klass.result do
+                klass.built_result_type = domain.foobara_type_from_declaration do
                   result result_type, :required
                   message_to_user :string, :required, "Message to the user about what was done"
                 end
 
-                klass.add_inputs klass.result_type
+                klass.add_inputs klass.built_result_type
 
                 klass.description "Notifies the user that the current goal has been accomplished and returns a final " \
                                   "result formatted according to the " \
                                   "result schema and a message to the user. " \
                                   "The user might issue a new goal."
               else
-                unless result_type.is_a?(Types::Type)
-                  result_type = Domain.current.foobara_type_from_declaration(result_type)
-                end
-
                 if result_type.extends?(BuiltinTypes[:attributes])
+                  klass.built_result_type = result_type
                   klass.result_is_attributes = true
                   klass.add_inputs result_type
                 else
-                  klass.add_inputs do
+                  klass.built_result_type = domain.foobara_type_from_declaration do
                     result result_type, :required
                   end
+                  klass.add_inputs klass.built_result_type
                 end
 
-                klass.result result_type
-
                 klass.description "Notifies the user that the current goal has been accomplished and returns a final " \
                                   "result formatted according to the " \
                                   "result schema. " \
@@ -65,10 +69,6 @@ module Foobara
                 message_to_user :string, :required, "Message to the user about what was done"
               end
 
-              klass.result do
-                message_to_user :string, :required, "Message to the user about what was done"
-              end
-
               klass.description "Notifies the user that the current goal has been accomplished and results in a " \
                                 "message to the user. " \
                                 "The user might issue a new goal."
@@ -80,9 +80,46 @@ module Foobara
               # :nocov:
             end
 
+            apply_result_data_transformer(klass, result_entity_depth)
+
             klass
           end
         end
+
+        def result_data_transformer(result_entity_depth)
+          if result_entity_depth
+            case result_entity_depth
+            when AssociationDepth::AGGREGATE
+              CommandConnectors::Transformers::LoadAggregatesTransformer
+            when AssociationDepth::ATOM
+              CommandConnectors::Transformers::LoadAtomsTransformer
+            else
+              # :nocov:
+              raise "Unsupported result entity depth: #{result_entity_depth}"
+              # :nocov:
+            end&.instance
+          end
+        end
+
+        def apply_result_data_transformer(command_klass, result_entity_depth)
+          transformer = result_data_transformer(result_entity_depth)
+          return unless transformer
+
+          inputs_type = command_klass.inputs_type
+          return unless inputs_type
+
+          if inputs_type.extends?(BuiltinTypes[:detached_entity]) ||
+             DetachedEntity.contains_associations?(inputs_type)
+            command_klass.before_commit_transaction do |command:, **|
+              # TODO: why can't we just pass in the command??
+              built_result = command.built_result
+
+              if built_result
+                transformer.process_value!(built_result)
+              end
+            end
+          end
+        end
       end
 
       description "Ends the session giving a final result formatted according to the " \
@@ -96,7 +133,7 @@ module Foobara
         build_result
         mark_mission_accomplished
 
-        built_result
+        nil
       end
 
       attr_accessor :built_result
@@ -116,7 +153,7 @@ module Foobara
                               inputs.slice(:result, :message_to_user)
                             elsif returns_result_data?
                               if result_is_attributes?
-                                inputs.slice(*self.class.result_type.element_types.keys)
+                                inputs.slice(*self.class.built_result_type.element_types.keys)
                               else
                                 inputs[:result]
                               end

data/src/foobara/agent/types/command_log_entry.rb

@@ -11,6 +11,17 @@ module Foobara
           errors_hash :duck, "Errors that occurred during the command"
         end
       end
+
+      def success?
+        outcome[:success]
+      end
+
+      def errors_hash
+        # TODO: test this path
+        # :nocov:
+        outcome[:errors_hash]
+        # :nocov:
+      end
     end
   end
 end

data/src/foobara/agent.rb

@@ -23,7 +23,9 @@ module Foobara
                   :verbose,
                   :io_out,
                   :io_err,
-                  :max_llm_calls_per_minute
+                  :max_llm_calls_per_minute,
+                  :pass_aggregates_to_llm,
+                  :result_entity_depth
 
     def initialize(
       context: nil,
@@ -36,6 +38,8 @@ module Foobara
       io_out: nil,
       io_err: nil,
       max_llm_calls_per_minute: nil,
+      result_entity_depth: AssociationDepth::AGGREGATE,
+      pass_aggregates_to_llm: nil,
       **opts
     )
       # TODO: shouldn't have to pass command_log here since it has a default, debug that
@@ -48,25 +52,22 @@ module Foobara
       self.io_out = io_out
       self.io_err = io_err
       self.max_llm_calls_per_minute = max_llm_calls_per_minute
+      self.result_entity_depth = result_entity_depth
+      self.pass_aggregates_to_llm = pass_aggregates_to_llm
 
-      # unless opts.key?(:default_serializers)
-      #   opts = opts.merge(default_serializers: [
-      #                       Foobara::CommandConnectors::Serializers::ErrorsSerializer,
-      #                       Foobara::CommandConnectors::Serializers::AggregateSerializer
-      #                     ])
-      # end
+      pre_commit_transformer = if pass_aggregates_to_llm
+                                 CommandConnectors::Transformers::LoadAggregatesPreCommitTransformer
+                               else
+                                 CommandConnectors::Transformers::LoadAtomsPreCommitTransformer
+                               end
 
-      unless opts.key?(:default_pre_commit_transformers)
-        opts = opts.merge(
-          default_pre_commit_transformers: Foobara::CommandConnectors::Transformers::LoadAtomsPreCommitTransformer
-        )
-      end
+      opts = opts.merge(default_pre_commit_transformers: [
+        *opts[:default_pre_commit_transformers],
+        pre_commit_transformer
+      ].uniq)
 
       super(**opts)
 
-      # TODO: this should work now, switch to this approach
-      # add_default_inputs_transformer EntityToPrimaryKeyInputsTransformer
-
       # TODO: push this convenience method up into base class?
       command_classes&.each do |command_class|
         connect(command_class)
@@ -140,42 +141,7 @@ module Foobara
       state_machine.perform_transition!(:accomplish_goal)
 
       begin
-        inputs = {
-          goal:,
-          final_result_type: self.result_type,
-          context:,
-          agent: self
-        }
-
-        llm_model ||= self.llm_model
-
-        if llm_model
-          inputs[:llm_model] = llm_model
-        end
-
-        unless maximum_call_count.nil?
-          inputs[:maximum_command_calls] = maximum_call_count
-        end
-
-        if verbose
-          inputs[:verbose] = verbose
-        end
-
-        if io_out
-          inputs[:io_out] = io_out
-        end
-
-        if io_err
-          inputs[:io_err] = io_err
-        end
-
-        if include_message_to_user_in_result || include_message_to_user_in_result == false
-          inputs[:include_message_to_user_in_result] = include_message_to_user_in_result
-        end
-
-        if max_llm_calls_per_minute && max_llm_calls_per_minute > 0
-          inputs[:max_llm_calls_per_minute] = max_llm_calls_per_minute
-        end
+        inputs = accomplish_goal_inputs(goal, result_type:, maximum_call_count:, llm_model:)
 
         self.current_accomplish_goal_command = AccomplishGoal.new(inputs)
 
@@ -196,6 +162,57 @@ module Foobara
       end
     end
 
+    def accomplish_goal_inputs(goal,
+                               result_type: nil,
+                               maximum_call_count: nil,
+                               llm_model: nil)
+      inputs = {
+        goal:,
+        final_result_type: self.result_type,
+        agent: self
+      }
+
+      llm_model ||= self.llm_model
+
+      if llm_model
+        inputs[:llm_model] = llm_model
+      end
+
+      unless maximum_call_count.nil?
+        inputs[:maximum_command_calls] = maximum_call_count
+      end
+
+      if verbose
+        inputs[:verbose] = verbose
+      end
+
+      if io_out
+        inputs[:io_out] = io_out
+      end
+
+      if io_err
+        inputs[:io_err] = io_err
+      end
+
+      if include_message_to_user_in_result || include_message_to_user_in_result == false
+        inputs[:include_message_to_user_in_result] = include_message_to_user_in_result
+      end
+
+      if max_llm_calls_per_minute && max_llm_calls_per_minute > 0
+        inputs[:max_llm_calls_per_minute] = max_llm_calls_per_minute
+      end
+
+      if result_entity_depth
+        inputs[:result_entity_depth] = result_entity_depth
+      end
+
+      unless pass_aggregates_to_llm.nil?
+        inputs[:pass_aggregates_to_llm] = pass_aggregates_to_llm
+      end
+
+      inputs
+    end
+
     def set_context_goal(goal)
       if context
         context.set_new_goal(goal)
@@ -232,7 +249,8 @@ module Foobara
                              result_type:,
                              agent_id: agent_name,
                              # TODO: Support changing this flag when the goal changes
-                             include_message_to_user_in_result:
+                             include_message_to_user_in_result:,
+                             result_entity_depth:
                            )
                          else
                            NotifyUserThatCurrentGoalHasBeenAccomplished

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-agent
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.14
 platform: ruby
 authors:
 - Miles Georgi
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.1
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.1
+        version: 1.0.0
 email:
 - azimux@gmail.com
 executables: []