foobara-agent 0.0.17 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 786fe4f10e3355da241847e573ff5d80abfb174d5afdedc0cb936d0a08b583ab
-  data.tar.gz: f6ae8472f81c4a7ba98f8daa6dd9998118d3d0dbf0728d5710b0d1b0575264ab
+  metadata.gz: a8033849f6ba2e137ede7ef837ba585f2e6705149e1a65c1282c971b524efbc7
+  data.tar.gz: 59bfa9001aa1badda383fc35a73dafa7fbf3d5adfec50bba217c291e74e25751
 SHA512:
-  metadata.gz: d4f150fb79b86ea3e02413bbd2d08e186f08888dd462fd722037d7741d65f7ccfc04d080ac751abcf04cbd2ba3455c240a3a0695699b3b01fd9e3d5ffba96948
-  data.tar.gz: 759813642a132a0f874506af6d5692f820fc62893e76e14bc759b33ebd353541917ad72b8589efa74141dee0fa8866638dd188e8860d7af4a9a412c69c344571
+  metadata.gz: 5625b3b2d52a6193b387c1031ca4950273a81eb872f349ccd43f2c63607e9f15615f17a26b1852d2d4a2d86585ffbb0ada7a816e23303babe2fc05bc86e4df41
+  data.tar.gz: ba10c928d42bce2d8cd20e5a98d6652ec8241b3e1a10cda7625e2b299307a1aa08561c36185733c65b2795ec08aa61024e6b7f87097d3bf08ff73d90d181746b

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.0.19] - 2025-07-23
+
+- Skip result: input if result is a Model and properly cast result
+- Add include_message_to_user_in_result option to #accomplish_goal
+- Include the llm_model in the verbose output
+- Print out info about retries if verbose
+- Change the language of the instructions to see what happens
+
+## [0.0.18] - 2025-07-21
+
+- Add maximum_command_calls option to Agent#initialize
+
 ## [0.0.17] - 2025-07-10
 
 - Prefix verbose output with the agent name if there is one

data/lib/foobara/agent.rb

@@ -10,12 +10,8 @@ module Foobara
 
     class << self
       def reset_all
-        [
-          NotifyUserThatCurrentGoalHasBeenAccomplished
-        ].each do |command_class|
-          command_class.clear_subclass_cache
-          Util.descendants(command_class).each(&:clear_subclass_cache)
-        end
+        NotifyUserThatCurrentGoalHasBeenAccomplished.clear_subclass_cache
+        Util.descendants(NotifyUserThatCurrentGoalHasBeenAccomplished).each(&:clear_subclass_cache)
       end
     end
   end

data/src/foobara/agent/accomplish_goal.rb

@@ -3,9 +3,6 @@ require_relative "list_commands"
 module Foobara
   class Agent < CommandConnector
     class AccomplishGoal < Foobara::Command
-      # Using a const here so we can stub it in the test suite to speed things up
-      SECONDS_PER_MINUTE = 60
-
       possible_error :gave_up, context: { reason: :string }, message: "Gave up."
       possible_error :too_many_command_calls,
                      context: { maximum_command_calls: :integer }
@@ -28,7 +25,6 @@ module Foobara
                   one_of: Ai::AnswerBot::Types::ModelEnum,
                   default: Ai.default_llm_model,
                   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
@@ -46,20 +42,17 @@ module Foobara
           simulate_describe_list_commands_command
           simulate_list_commands_run
         end
-        # simulate_describe_command_run_for_all_commands
 
-        until mission_accomplished or given_up or killed
+        until mission_accomplished? or given_up? or killed?
           increment_command_calls
           check_if_too_many_calls
 
-          throttle_llm_calls_if_necessary
-
           determine_next_command_and_inputs
 
           run_next_command
         end
 
-        if given_up
+        if given_up?
           add_given_up_error
         end
 
@@ -130,9 +123,17 @@ module Foobara
         # :nocov:
       end
 
-      def determine_next_command_and_inputs(retries = 3, error_outcome = nil)
+      RETRY_COUNT = 3
+
+      def determine_next_command_and_inputs(retries = RETRY_COUNT, error_outcome = nil)
         return if killed
 
+        if verbose? && retries != RETRY_COUNT
+          # :nocov:
+          (io_err || $stderr).puts " !!! Retrying to determine next command and inputs. Retries left: #{retries}"
+          # :nocov:
+        end
+
         if retries == 0
           # TODO: test this path by irreparably breaking the needed commands
           # :nocov:
@@ -250,7 +251,8 @@ module Foobara
         inputs_type = next_command_class.inputs_type
 
         NestedTransactionable.with_needed_transactions_for_type(inputs_type) do
-          inputs_type.process_value(next_command_inputs)
+          inputs = next_command_inputs.nil? ? {} : next_command_inputs
+          inputs_type.process_value(inputs)
         end
       end
 
@@ -431,7 +433,16 @@ module Foobara
                  end
 
           agent_name = agent.agent_name
-          prefix = agent_name && !agent_name.empty? ? "#{agent_name}: " : ""
+          prefix = if agent_name && !agent_name.empty?
+                     "#{agent_name}<#{llm_model}>: "
+                   else
+                     # Not setting an agent_name results in non-determinism in NotifyUser... command
+                     # namespace. This results in problems in the test suite making this code path a little
+                     # harder to test indirectly.
+                     # :nocov:
+                     ""
+                     # :nocov:
+                   end
 
           (io_out || $stdout).puts "#{prefix}#{next_command_name}.run#{args}"
         end
@@ -457,10 +468,40 @@ module Foobara
         add_runtime_error(:gave_up, reason: final_message)
       end
 
+      def final_result_type_from_declaration
+        return @final_result_type_from_declaration if defined?(@final_result_type_from_declaration)
+
+        @final_result_type_from_declaration = if final_result_type
+                                                if final_result_type.is_a?(Types::Type)
+                                                  final_result_type
+                                                else
+                                                  domain = result_type.created_in_namespace.foobara_domain
+                                                  domain.foobara_type_from_declaration(final_result_type)
+                                                end
+                                              end
+      end
+
       def build_result
+        result_data = if final_result_type_from_declaration
+                        outcome = final_result_type_from_declaration.process_value(final_result)
+
+                        if outcome.success?
+                          outcome.result
+                        elsif given_up? || killed?
+                          final_result
+                        else
+                          # :nocov:
+                          raise CommandPatternImplementation::Concerns::Result::CouldNotProcessResult,
+                                outcome.errors
+                          # :nocov:
+                        end
+                      else
+                        final_result
+                      end
+
         {
           message_to_user: final_message,
-          result_data: final_result
+          result_data:
         }
       end
 
@@ -500,44 +541,20 @@ module Foobara
         llm_call_timestamps.unshift(Time.now)
       end
 
-      def llm_calls_in_last_minute
-        llm_call_timestamps.select { |t| t > (Time.now - 60) }
-      end
-
-      def llm_call_count_in_last_minute
-        llm_calls_in_last_minute.size
+      def context
+        agent.context
       end
 
-      def time_until_llm_call_count_in_last_minute_changes
-        calls = llm_calls_in_last_minute
-
-        first_to_expire = calls.first
-
-        if first_to_expire
-          [0, (first_to_expire + SECONDS_PER_MINUTE) - Time.now].max
-        else
-          # TODO: figure out how to test this code path
-          # :nocov:
-          0
-          # :nocov:
-        end
+      def mission_accomplished?
+        mission_accomplished
       end
 
-      def throttle_llm_calls_if_necessary
-        return unless max_llm_calls_per_minute && max_llm_calls_per_minute > 0
-
-        if llm_call_count_in_last_minute >= max_llm_calls_per_minute
-          seconds = time_until_llm_call_count_in_last_minute_changes
-          if verbose?
-            (io_out || $stdout).puts "Sleeping for #{seconds} seconds to avoid LLM calls per minute limit"
-          end
-
-          sleep seconds
-        end
+      def given_up?
+        given_up
       end
 
-      def context
-        agent.context
+      def killed?
+        killed
       end
     end
   end

data/src/foobara/agent/determine_next_command_name_and_inputs.rb

@@ -1,8 +1,8 @@
-require_relative "determine_base"
+require "foobara/llm_backed_command"
 
 module Foobara
   class Agent < CommandConnector
-    class DetermineNextCommandNameAndInputs < DetermineBase
+    class DetermineNextCommandNameAndInputs < Foobara::LlmBackedCommand
       class << self
         def llm_instructions(assistant_association_depth, goal, previous_goals = nil)
           key = [assistant_association_depth, goal, previous_goals]
@@ -17,15 +17,8 @@ module Foobara
         end
 
         def build_llm_instructions(assistant_association_depth, goal, previous_goals)
-          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
+          instructions = "You are part of an agent implementation. " \
+                         "Your task is to decide which command to run next.\n\n"
 
           result_schema = result_json_schema(assistant_association_depth)
 
@@ -38,13 +31,25 @@ module Foobara
             end
           end
 
-          instructions += "You are working towards accomplishing the following goal:\n\n#{goal}\n\n"
+          instructions += "You are working towards accomplishing the following goal: #{goal}\n\n"
+
+          instructions += "You will answer with the name of the next command to run and, if needed, its inputs. " \
+                          "Choose whichever command is best to make progress towards accomplishing the current goal " \
+                          "based on the progress made so far. " \
+                          "If the goal has been accomplished then choose the " \
+                          "NotifyUserThatCurrentGoalHasBeenAccomplished command. " \
+                          "If you are stuck either due to errors " \
+                          "or because you do not have the command you need to accomplish the " \
+                          "goal, then choose GiveUp.\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 " \
+                          "choosing the DescribeCommand command.\n\n"
+
+          instructions += "Your result type is described by the following JSON schema:" \
+                          "\n\n#{result_schema}\n\n" \
+                          "You will reply with nothing more than the JSON that you've " \
+                          "generated that adheres to this result type schema " \
+                          "so that the calling code " \
                           "can successfully parse your answer."
 
           instructions
@@ -54,13 +59,24 @@ module Foobara
       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 " \
-                  "NotifyUserThatCurrentGoalHasBeenAccomplished command."
+                  "NotifyUserThatCurrentGoalHasBeenAccomplished command. It will choose GiveUp if it runs into an " \
+                  "error it cannot get around or does not believe it has the proper commands to accomplish its goal."
 
       result do
         command :string, :required
         inputs :attributes, :allow_nil
       end
 
+      inputs do
+        agent Agent, :required
+        pass_aggregates_to_llm :boolean, :allow_nil, "Should we send aggregates to the LLM or " \
+                                                     "require it to fetch what it needs?"
+        llm_model :string,
+                  one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
+                  default: Ai.default_llm_model,
+                  description: "The model to use for the LLM"
+      end
+
       def determine_llm_instructions
         self.llm_instructions = self.class.llm_instructions(
           computed_user_association_depth,
@@ -68,6 +84,64 @@ module Foobara
           previous_goal_and_status_pairs
         )
       end
+
+      def association_depth
+        if pass_aggregates_to_llm
+          Foobara::AssociationDepth::AGGREGATE
+        else
+          Foobara::AssociationDepth::ATOM
+        end
+      end
+
+      def build_messages
+        p = [
+          {
+            content: llm_instructions,
+            role: :system
+          }
+        ]
+
+        context.command_log.each do |command_log_entry|
+          agent_entry = {
+            command: command_log_entry.command_name
+          }
+
+          inputs = command_log_entry.inputs
+
+          if inputs && !inputs.empty?
+            agent_entry[:inputs] = inputs
+          end
+
+          outcome_entry = command_log_entry.outcome
+
+          p << {
+            content: agent_entry,
+            role: :assistant
+          }
+          p << {
+            content: outcome_entry,
+            role: :user
+          }
+        end
+
+        p
+      end
+
+      def goal
+        context.current_goal.text
+      end
+
+      def previous_goal_and_status_pairs
+        if context.previous_goals && !context.previous_goals.empty?
+          context.previous_goals.map do |previous_goal|
+            [previous_goal.text, previous_goal.state]
+          end
+        end
+      end
+
+      def context
+        agent.context
+      end
     end
   end
 end

data/src/foobara/agent/notify_user_that_current_goal_has_been_accomplished.rb

@@ -7,7 +7,7 @@ module Foobara
 
       class << self
         attr_accessor :command_class, :returns_message_to_user, :returns_result_data, :result_is_attributes,
-                      :built_result_type
+                      :built_result_type, :result_is_model
 
         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)}"
@@ -46,20 +46,38 @@ module Foobara
                                   "result schema and a message to the user. " \
                                   "The user might issue a new goal."
               else
-                if result_type.extends?(BuiltinTypes[:attributes])
-                  klass.built_result_type = result_type
-                  klass.result_is_attributes = true
-                  klass.add_inputs result_type
-                else
-                  klass.built_result_type = domain.foobara_type_from_declaration do
-                    result result_type, :required
+                if result_type.extends?(BuiltinTypes[:model]) &&
+                   !result_type.extends?(BuiltinTypes[:detached_entity]) && result_type != BuiltinTypes[:model]
+                  # TODO: Create a ModelToAttributesInputsTransformer in foobara gem and move this logic there
+                  model_declaration = result_type.declaration_data
+
+                  # Distinguishing between nil and no inputs might be tricky so if :allow_nil then
+                  # we will prefer `result: nil` over `nil`
+                  # if there's a description we'll also prefer result: so that the description will
+                  # make it through to the LLM on that input.
+                  # TODO: handle the model's description via the command's description instead.
+                  if !model_declaration.key?(:allow_nil) && !model_declaration.key?(:description)
+                    klass.built_result_type = result_type
+                    klass.result_is_model = true
+                    klass.add_inputs result_type.target_class.attributes_type
                   end
-                  klass.add_inputs klass.built_result_type
                 end
 
-                klass.description "Notifies the user that the current goal has been accomplished and returns a final " \
-                                  "result formatted according to the " \
-                                  "result schema. " \
+                unless klass.result_is_model
+                  if result_type.extends?(BuiltinTypes[:attributes])
+                    klass.built_result_type = result_type
+                    klass.result_is_attributes = true
+                    klass.add_inputs result_type
+                  else
+                    klass.built_result_type = domain.foobara_type_from_declaration do
+                      result result_type, :required
+                    end
+                    klass.add_inputs klass.built_result_type
+                  end
+                end
+
+                klass.description "Notifies the user that the current goal has been accomplished and accepts a final " \
+                                  "result value as inputs. " \
                                   "The user might issue a new goal."
               end
             elsif include_message_to_user_in_result
@@ -112,7 +130,7 @@ module Foobara
              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
+              built_result = command.final_result_data
 
               if built_result
                 transformer.process_value!(built_result)
@@ -130,34 +148,35 @@ module Foobara
       end
 
       def execute
-        build_result
+        extract_result_data_and_message_to_user
         mark_mission_accomplished
 
         nil
       end
 
-      attr_accessor :built_result
-
-      def mark_mission_accomplished
-        result, message_to_user = if returns_message_to_user?
-                                    [built_result[:result], built_result[:message_to_user]]
-                                  elsif returns_result_data?
-                                    [built_result, nil]
-                                  end
+      attr_accessor :final_result_data, :final_message_to_user
+
+      def extract_result_data_and_message_to_user
+        result, message = if returns_message_to_user?
+                            inputs.values_at(:result, :message_to_user)
+                          elsif returns_result_data?
+                            if result_is_attributes?
+                              inputs.slice(*self.class.built_result_type.element_types.keys)
+                            elsif result_is_model?
+                              inputs.slice(
+                                *self.class.built_result_type.target_class.attributes_type.element_types.keys
+                              )
+                            else
+                              inputs[:result]
+                            end
+                          end
 
-        command_connector.mark_mission_accomplished(result, message_to_user)
+        self.final_result_data = result
+        self.final_message_to_user = message
       end
 
-      def build_result
-        self.built_result = if returns_message_to_user?
-                              inputs.slice(:result, :message_to_user)
-                            elsif returns_result_data?
-                              if result_is_attributes?
-                                inputs.slice(*self.class.built_result_type.element_types.keys)
-                              else
-                                inputs[:result]
-                              end
-                            end
+      def mark_mission_accomplished
+        command_connector.mark_mission_accomplished(final_result_data, final_message_to_user)
       end
 
       def returns_message_to_user?
@@ -171,6 +190,10 @@ module Foobara
       def result_is_attributes?
         self.class.result_is_attributes
       end
+
+      def result_is_model?
+        self.class.result_is_model
+      end
     end
   end
 end

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

@@ -3,12 +3,6 @@ require_relative "goal"
 module Foobara
   class Agent < CommandConnector
     class Context < Foobara::Model
-      class << self
-        def for(goal)
-          new(command_log: [], current_goal: Goal.new(text: goal))
-        end
-      end
-
       attributes do
         current_goal Goal, :required, "The current goal the agent needs to accomplish"
         previous_goals [Goal]
@@ -19,7 +13,11 @@ module Foobara
 
       def set_new_goal(goal)
         self.previous_goals ||= []
-        previous_goals << current_goal
+
+        if current_goal
+          previous_goals << current_goal
+        end
+
         self.current_goal = Goal.new(text: goal)
       end
     end

data/src/foobara/agent.rb

@@ -24,9 +24,9 @@ module Foobara
                   :verbose,
                   :io_out,
                   :io_err,
-                  :max_llm_calls_per_minute,
                   :pass_aggregates_to_llm,
-                  :result_entity_depth
+                  :result_entity_depth,
+                  :maximum_command_calls
 
     def initialize(
       context: nil,
@@ -38,13 +38,14 @@ module Foobara
       verbose: false,
       io_out: nil,
       io_err: nil,
-      max_llm_calls_per_minute: nil,
       result_entity_depth: AssociationDepth::AGGREGATE,
       pass_aggregates_to_llm: nil,
+      maximum_command_calls: nil,
       **opts
     )
       # TODO: shouldn't have to pass command_log here since it has a default, debug that
-      self.context = context
+      self.context = context || Context.new(command_log: [])
+
       if agent_name
         self.agent_name = agent_name
       end
@@ -55,9 +56,9 @@ module Foobara
       self.verbose = verbose
       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
+      self.maximum_command_calls = maximum_command_calls
 
       pre_commit_transformer = if pass_aggregates_to_llm
                                  CommandConnectors::Transformers::LoadAggregatesPreCommitTransformer
@@ -124,9 +125,14 @@ module Foobara
     def accomplish_goal(
       goal,
       result_type: nil,
-      maximum_call_count: nil,
+      maximum_command_calls: nil,
+      include_message_to_user_in_result: nil,
       llm_model: nil
     )
+      unless include_message_to_user_in_result.nil?
+        self.include_message_to_user_in_result = include_message_to_user_in_result
+      end
+
       set_context_goal(goal)
 
       if result_type && self.result_type != result_type
@@ -150,7 +156,10 @@ module Foobara
       state_machine.perform_transition!(:accomplish_goal)
 
       begin
-        inputs = accomplish_goal_inputs(goal, result_type:, maximum_call_count:, llm_model:)
+        inputs = accomplish_goal_inputs(goal,
+                                        result_type:,
+                                        maximum_command_calls:,
+                                        llm_model:)
 
         self.current_accomplish_goal_command = AccomplishGoal.new(inputs)
 
@@ -186,7 +195,7 @@ module Foobara
 
     def accomplish_goal_inputs(goal,
                                result_type: nil,
-                               maximum_call_count: nil,
+                               maximum_command_calls: nil,
                                llm_model: nil)
       inputs = {
         goal:,
@@ -200,8 +209,12 @@ module Foobara
         inputs[:llm_model] = llm_model
       end
 
-      unless maximum_call_count.nil?
-        inputs[:maximum_command_calls] = maximum_call_count
+      if maximum_command_calls.nil?
+        maximum_command_calls = self.maximum_command_calls
+      end
+
+      unless maximum_command_calls.nil?
+        inputs[:maximum_command_calls] = maximum_command_calls
       end
 
       if verbose
@@ -220,10 +233,6 @@ module Foobara
         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
@@ -236,11 +245,7 @@ module Foobara
     end
 
     def set_context_goal(goal)
-      if context
-        context.set_new_goal(goal)
-      else
-        self.context = Context.for(goal)
-      end
+      context.set_new_goal(goal)
     end
 
     def mark_mission_accomplished(final_result, message_to_user)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-agent
 version: !ruby/object:Gem::Version
-  version: 0.0.17
+  version: 0.0.19
 platform: ruby
 authors:
 - Miles Georgi
@@ -66,7 +66,6 @@ files:
 - src/foobara/agent/connector/set_command_connector_inputs_transformer.rb
 - src/foobara/agent/describe_command.rb
 - src/foobara/agent/describe_type.rb
-- src/foobara/agent/determine_base.rb
 - src/foobara/agent/determine_next_command_name_and_inputs.rb
 - src/foobara/agent/give_up.rb
 - src/foobara/agent/list_commands.rb

data/src/foobara/agent/determine_base.rb

@@ -1,76 +0,0 @@
-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
-        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: Ai.default_llm_model,
-                  description: "The model to use for the LLM"
-      end
-
-      def association_depth
-        if pass_aggregates_to_llm
-          Foobara::AssociationDepth::AGGREGATE
-        else
-          Foobara::AssociationDepth::ATOM
-        end
-      end
-
-      def build_messages
-        p = [
-          {
-            content: llm_instructions,
-            role: :system
-          }
-        ]
-
-        context.command_log.each do |command_log_entry|
-          agent_entry = {
-            command: command_log_entry.command_name
-          }
-
-          inputs = command_log_entry.inputs
-
-          if inputs && !inputs.empty?
-            agent_entry[:inputs] = inputs
-          end
-
-          outcome_entry = command_log_entry.outcome
-
-          p << {
-            content: agent_entry,
-            role: :assistant
-          }
-          p << {
-            content: outcome_entry,
-            role: :user
-          }
-        end
-
-        p
-      end
-
-      def goal
-        context.current_goal.text
-      end
-
-      def previous_goal_and_status_pairs
-        if context.previous_goals && !context.previous_goals.empty?
-          context.previous_goals.map do |previous_goal|
-            [previous_goal.text, previous_goal.state]
-          end
-        end
-      end
-
-      def context
-        agent.context
-      end
-    end
-  end
-end