foobara-agent 0.0.8 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12e8facdeb95a000d81ec0ba8a133affa1ea66e470115e978bdc81f05bc51855
-  data.tar.gz: 294064df166d152c037db13263863b8ccfe32f064a78e77f6f5fe59af0be3829
+  metadata.gz: 4c8f095d06fb173bc816e83f19755cfe246f15bf2b8ef1f8f91bce08e5960e74
+  data.tar.gz: 15b48a59c43c909070f68bbc58c68ce02635d019f9d3af68f1c3aa4264cd4903
 SHA512:
-  metadata.gz: 2c7fcaf044ba9bc821dcc42f9b0fb44b412fb42f9ef77dd4b7f3ed13cb8293cdb60d448d136e4e0567d104ecb022a00accfd05dbcf955e38185884d34e59668e
-  data.tar.gz: 380d9ae749b6a942b4e33b112f5aae35fd9600fa9ffcaf462fc0a35122354aae0658378190a4b9db3c0d65d2a12c9d49305b1d03a2881ce504d6d268cf039255
+  metadata.gz: f558c74920f9759a98b2605fe2dcbbc52678ff5d90a0977182a75d0949cfd400b07d3d17d4dbfe162b37a3f463c3c55b4e25dee6382f2daeb3256b5df9615f73
+  data.tar.gz: f0588e94676e579c1fd5d7b3b603452d0c283b2b14217511b74a8d341d3126ff42cf7d0cb1cc881048d356525c7b9250f73c1a7631dae556a589f23b8627e1f8

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.0.10] - 2025-06-30
+
+- Allow more retries
+- Eliminate ability to select command and inputs separately
+
+## [0.0.9] - 2025-06-28
+
+- Relocate some common Determine* behavior into a DetermineBase
+- Move goal to Context and make use of LlmBackedCommand#messages
+- Simulating a DescribeCommand selection on failure
+- Compacting the command log
+
 ## [0.0.8] - 2025-06-27
 
 - Improve what is logged and its formatting when verbose

data/lib/foobara/agent.rb

@@ -11,7 +11,6 @@ module Foobara
     class << self
       def reset_all
         [
-          DetermineInputsForNextCommand,
           NotifyUserThatCurrentGoalHasBeenAccomplished
         ].each do |command_class|
           command_class.clear_subclass_cache

data/src/foobara/agent/accomplish_goal.rb

@@ -19,7 +19,7 @@ module Foobara
         io_out :duck
         io_err :duck
         agent Agent, :required
-        current_context Context, :allow_nil, "The current context of the agent"
+        context Context, :required, "The current context of the agent"
         maximum_command_calls :integer,
                               :allow_nil,
                               default: 25,
@@ -29,12 +29,6 @@ module Foobara
                   one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
                   default: "claude-3-7-sonnet-20250219",
                   description: "The model to use for the LLM"
-        choose_next_command_and_next_inputs_separately :boolean,
-                                                       default: false,
-                                                       description:
-                                                         "By default, asks for next command and inputs together. " \
-                                                         "You can experiment with getting the separately " \
-                                                         "with this flag if you wish."
         max_llm_calls_per_minute :integer, :allow_nil
       end
 
@@ -46,8 +40,6 @@ module Foobara
       depends_on ListCommands
 
       def execute
-        build_initial_context_if_necessary
-
         simulate_describe_list_commands_command
         simulate_list_commands_run
         # simulate_describe_command_run_for_all_commands
@@ -58,13 +50,9 @@ module Foobara
 
           throttle_llm_calls_if_necessary
 
-          if choose_next_command_and_next_inputs_separately?
-            determine_next_command_then_inputs_separately
-          else
-            determine_next_command_and_inputs
-          end
-
+          determine_next_command_and_inputs
           run_next_command
+
           log_last_command_outcome
         end
 
@@ -75,16 +63,11 @@ module Foobara
         build_result
       end
 
-      attr_accessor :context, :next_command_name, :next_command_inputs, :next_command_raw_inputs, :mission_accomplished,
+      attr_accessor :next_command_name, :next_command_inputs, :next_command_raw_inputs, :mission_accomplished,
                     :given_up, :next_command_class, :next_command, :command_outcome, :timed_out,
                     :final_result, :final_message, :command_response, :delayed_command_name,
                     :command_calls
 
-      def build_initial_context_if_necessary
-        # TODO: shouldn't have to pass command_log here since it has a default, debug that
-        self.context = current_context || Context.new(command_log: [])
-      end
-
       def simulate_list_commands_run
         self.next_command_name = ListCommands.full_command_name
         self.next_command_raw_inputs = nil
@@ -105,6 +88,26 @@ module Foobara
         log_last_command_outcome
       end
 
+      def simulate_describe_command(command_name = next_command_name)
+        old_next_command_name = next_command_name
+        old_next_command_inputs = next_command_inputs
+        old_next_command_raw_inputs = next_command_raw_inputs
+        old_next_command_class = next_command_class
+
+        self.next_command_name = DescribeCommand.full_command_name
+        self.next_command_inputs = { command_name: }
+        self.next_command_raw_inputs = next_command_inputs
+        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
+        self.next_command_raw_inputs = old_next_command_raw_inputs
+        self.next_command_class = old_next_command_class
+      end
+
       def simulate_describe_command_run_for_all_commands
         # TODO: currently not using this code path. Unclear if it is worth it.
         # :nocov:
@@ -124,9 +127,25 @@ module Foobara
         # :nocov:
       end
 
-      def determine_next_command_and_inputs(retries = 2)
+      def determine_next_command_and_inputs(retries = 3, error_outcome = nil)
+        if retries == 0
+          # TODO: test this path by irreparably breaking the needed commands
+          # :nocov:
+          self.next_command_name = GiveUp.full_command_name
+          self.next_command_inputs = {
+            message_to_user: "While trying to choose the next command and inputs, " \
+                             "I've ran into an error several times that I couldn't figure out how to get past. " \
+                             "The last error looked like this:\n#{error_outcome.errors_hash}"
+          }
+          self.next_command_raw_inputs = next_command_inputs
+
+          return
+          # :nocov:
+        end
+
+        compact_command_log
+
         inputs_for_determine = {
-          goal:,
           context:,
           llm_model:
         }
@@ -143,7 +162,7 @@ module Foobara
         end
 
         if outcome.success?
-          self.next_command_name = outcome.result[:command_name]
+          self.next_command_name = outcome.result[:command]
           self.next_command_inputs = outcome.result[:inputs]
           self.next_command_raw_inputs = next_command_inputs
 
@@ -162,7 +181,9 @@ module Foobara
                   outcome:
                 )
 
-                determine_next_command_inputs
+                simulate_describe_command
+
+                determine_next_command_and_inputs(retries - 1, outcome)
               end
             else
               self.next_command_inputs = {}
@@ -176,11 +197,7 @@ module Foobara
               result: nil
             )
 
-            if retries > 0
-              determine_next_command_and_inputs(retries - 1)
-            else
-              determine_next_command_then_inputs_separately
-            end
+            determine_next_command_and_inputs(retries - 1, outcome)
           end
         else
           log_command_outcome(
@@ -190,23 +207,7 @@ module Foobara
             result: outcome.result || determine_command.raw_result
           )
 
-          if retries > 0
-            determine_next_command_and_inputs(retries - 1)
-          else
-            determine_next_command_then_inputs_separately
-          end
-        end
-      end
-
-      def determine_next_command_then_inputs_separately
-        determine_next_command_name
-
-        if command_described?
-          fetch_next_command_class
-          determine_next_command_inputs
-        else
-          choose_describe_command_instead
-          fetch_next_command_class
+          determine_next_command_and_inputs(retries - 1, outcome)
         end
       end
 
@@ -245,74 +246,6 @@ module Foobara
         @command_name_type ||= Agent.foobara_type_from_declaration(:string, one_of: all_command_classes)
       end
 
-      def determine_next_command_name(retries = 2)
-        self.next_command_name = if delayed_command_name
-                                   name = delayed_command_name
-                                   self.delayed_command_name = nil
-                                   name
-                                 else
-                                   inputs = { goal:, context: }
-                                   if llm_model
-                                     inputs[:llm_model] = llm_model
-                                   end
-
-                                   command = DetermineNextCommand.new(inputs)
-                                   outcome = begin
-                                     record_llm_call_timestamp
-                                     command.run
-                                   rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
-                                     # :nocov:
-                                     Outcome.errors(e.errors)
-                                     # :nocov:
-                                   end
-
-                                   if outcome.success?
-                                     self.next_command_name = outcome.result
-
-                                     outcome = validate_next_command_name
-
-                                     unless outcome.success?
-                                       # TODO: figure out a way to hit this path in the test suite or delete it
-                                       # :nocov:
-                                       log_command_outcome(
-                                         command:,
-                                         inputs: command.inputs.except(:context),
-                                         outcome:,
-                                         result: outcome.result || command.raw_result
-                                       )
-
-                                       if retries > 0
-                                         return determine_next_command_name(retries - 1)
-                                       end
-                                       # :nocov:
-                                     end
-                                   else
-                                     # TODO: either figure out a way to hit this path in the test suite or delete it
-                                     # :nocov:
-                                     log_command_outcome(
-                                       command:,
-                                       inputs: command.inputs.except(:context),
-                                       outcome:,
-                                       result: outcome.result || command.raw_result
-                                     )
-
-                                     if retries > 0
-                                       return determine_next_command_name(retries - 1)
-                                     end
-                                     # :nocov:
-                                   end
-
-                                   outcome.raise!
-                                   outcome.result
-                                 end
-      end
-
-      def choose_describe_command_instead
-        self.delayed_command_name = next_command_name
-        self.next_command_inputs = { command_name: next_command_name }
-        self.next_command_name = DescribeCommand.full_command_name
-      end
-
       def all_command_classes
         @all_command_classes ||= run_subcommand!(ListCommands, command_connector: agent).values.flatten
       end
@@ -321,56 +254,11 @@ module Foobara
         self.next_command_class = agent.transformed_command_from_name(next_command_name)
       end
 
-      def determine_next_command_inputs(retries = 2)
-        self.next_command_inputs = if next_command_has_inputs?
-                                     command_class = command_class_for_determine_inputs_for_next_command
-
-                                     inputs = { goal:, context: }
-                                     if llm_model
-                                       inputs[:llm_model] = llm_model
-                                     end
-
-                                     command = command_class.new(inputs)
-                                     outcome = begin
-                                       record_llm_call_timestamp
-                                       command.run
-                                     rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
-                                       # :nocov:
-                                       Outcome.errors(e.errors)
-                                       # :nocov:
-                                     end
-
-                                     unless outcome.success?
-                                       # TODO: either figure out a way to hit this path in the test suite or delete it
-                                       # :nocov:
-                                       log_command_outcome(
-                                         command_name: next_command_name,
-                                         inputs: command.raw_result,
-                                         outcome:
-                                       )
-
-                                       if retries > 0
-                                         return determine_next_command_inputs(retries - 1)
-                                       end
-                                       # :nocov:
-                                     end
-
-                                     outcome.raise!
-                                     outcome.result
-                                   end
-      end
-
       def next_command_has_inputs?
         type = next_command_class.inputs_type
         type && !empty_attributes?(type)
       end
 
-      def command_class_for_determine_inputs_for_next_command
-        DetermineInputsForNextCommand.for(
-          command_class: next_command_class, agent_id: agent_name
-        )
-      end
-
       def run_next_command
         if verbose?
           args = if next_command_inputs.nil? || next_command_inputs.empty?
@@ -386,6 +274,7 @@ module Foobara
                      # :nocov:
                    end
                  end
+
           (io_out || $stdout).puts "#{next_command_name}.run#{args}"
         end
 
@@ -412,6 +301,66 @@ module Foobara
         log_command_outcome(command: command_response.command)
       end
 
+      def compact_command_log
+        # Rules:
+        # Delete errors for any command that has succeeded since
+        # Delete all but the last DescribeCommand call for a given
+        describe_command_call_indexes = {}
+        commands = {}
+
+        describe_command_name = DescribeCommand.full_command_name
+        context.command_log.each.with_index do |command_log_entry, index|
+          command_name = command_log_entry.command_name
+
+          if command_name == describe_command_name
+            described_command = command_log_entry.inputs[:command_name]
+
+            if command_log_entry.outcome[:success]
+              describe_command_call_indexes[described_command] ||= []
+              describe_command_call_indexes[described_command] << index
+            end
+          end
+
+          commands[command_name] ||= [[], []]
+          bucket_index = command_log_entry.outcome[:success] ? 0 : 1
+          commands[command_name][bucket_index] << index
+        end
+
+        indexes_to_delete = []
+
+        describe_command_call_indexes.each_value do |indexes|
+          indexes_to_delete += indexes[0..-2]
+        end
+
+        commands.each_value do |(success_indexes, failure_indexes)|
+          last_success = success_indexes.last
+          next unless last_success
+
+          failure_indexes.each do |failure_index|
+            if failure_index < last_success
+              indexes_to_delete << failure_index
+            else
+              # :nocov:
+              break
+              # :nocov:
+            end
+          end
+        end
+
+        if indexes_to_delete.empty?
+          return
+        end
+
+        new_log = []
+        context.command_log = context.command_log.each.with_index do |entry, index|
+          unless indexes_to_delete.include?(index)
+            new_log << entry
+          end
+        end
+
+        context.command_log = new_log
+      end
+
       def increment_command_calls
         self.command_calls ||= -1
         self.command_calls += 1
@@ -435,7 +384,7 @@ module Foobara
           outcome ||= command.outcome
         end
 
-        if outcome
+        if outcome&.success?
           result ||= outcome.result
         end
 
@@ -481,10 +430,6 @@ module Foobara
         }
       end
 
-      def command_described?
-        described_commands.include?(next_command_name)
-      end
-
       def described_commands
         @described_commands ||= Set.new
       end
@@ -493,14 +438,6 @@ module Foobara
         type.extends_type?(BuiltinTypes[:attributes]) && type.element_types.empty?
       end
 
-      def choose_next_command_and_next_inputs_separately?
-        choose_next_command_and_next_inputs_separately
-      end
-
-      def agent_name
-        agent.agent_name
-      end
-
       def verbose?
         verbose
       end
@@ -529,7 +466,7 @@ module Foobara
         first_to_expire = calls.first
 
         if first_to_expire
-          (first_to_expire + SECONDS_PER_MINUTE) - Time.now
+          [0, (first_to_expire + SECONDS_PER_MINUTE) - Time.now].max
         else
           # TODO: figure out how to test this code path
           # :nocov:

data/src/foobara/agent/concerns/subclass_cacheable.rb

@@ -13,7 +13,9 @@ module Foobara
 
         def cached_subclass(key)
           if subclass_cache.key?(key)
+            # :nocov:
             subclass_cache[key]
+            # :nocov:
           else
             subclass_cache[key] = yield
           end

data/src/foobara/agent/determine_base.rb

@@ -0,0 +1,82 @@
+require "foobara/llm_backed_command"
+
+module Foobara
+  class Agent < CommandConnector
+    class DetermineBase < Foobara::LlmBackedCommand
+      inputs do
+        context Context, :required, "Context of the progress towards the goal so far"
+        llm_model :string,
+                  one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
+                  default: "claude-3-7-sonnet-20250219",
+                  description: "The model to use for the LLM"
+      end
+
+      def association_depth
+        Foobara::JsonSchemaGenerator::AssociationDepth::ATOM
+      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 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
+    end
+  end
+end

data/src/foobara/agent/determine_next_command_name_and_inputs.rb

@@ -1,33 +1,17 @@
-require "foobara/llm_backed_command"
+require_relative "determine_base"
 
 module Foobara
   class Agent < CommandConnector
-    class DetermineNextCommandNameAndInputs < Foobara::LlmBackedCommand
-      description "Accepts the current goal, which might already be accomplished, and context of the work  " \
-                  "so far and returns the inputs for " \
-                  "the next command to run to make progress towards " \
-                  "accomplishing the goal. If the goal has already been accomplished then choose the " \
+    class DetermineNextCommandNameAndInputs < DetermineBase
+      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."
 
-      inputs do
-        goal :string, :required, "The current goal to accomplish. If the goal has already been accomplished " \
-                                 "by the previous command runs then choose " \
-                                 "NotifyUserThatCurrentGoalHasBeenAccomplished to stop the loop."
-        context Context, :required, "Context of the progress towards the goal so far"
-        llm_model :string,
-                  one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
-                  default: "claude-3-7-sonnet-20250219",
-                  description: "The model to use for the LLM"
-      end
-
       result do
-        command_name :string, :required
+        command :string, :required
         inputs :attributes, :allow_nil
       end
-
-      def association_depth
-        Foobara::JsonSchemaGenerator::AssociationDepth::ATOM
-      end
     end
   end
 end

data/src/foobara/agent/notify_user_that_current_goal_has_been_accomplished.rb

@@ -19,6 +19,8 @@ module Foobara
                               "The user might issue a new goal."
 
             if result_type
+              # 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.add_inputs do
                   result result_type, :required

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

@@ -1,11 +1,25 @@
 module Foobara
   class Agent < CommandConnector
     class Context < Foobara::Model
+      class << self
+        def for(goal)
+          new(command_log: [], current_goal: goal)
+        end
+      end
+
       attributes do
+        current_goal :string, :required, "The current goal the agent needs to accomplish"
+        previous_goals [:string]
         # TODO: why doesn't this default of [] work as expected on newly created models?
         command_log [CommandLogEntry], default: [],
                                        description: "Log of all commands run so far and their outcomes"
       end
+
+      def set_new_goal(goal)
+        self.previous_goals ||= []
+        previous_goals << current_goal
+        self.current_goal = goal
+      end
     end
   end
 end

data/src/foobara/agent.rb

@@ -67,8 +67,6 @@ module Foobara
       # TODO: this should work now, switch to this approach
       # add_default_inputs_transformer EntityToPrimaryKeyInputsTransformer
 
-      build_initial_context
-
       # TODO: push this convenience method up into base class?
       command_classes&.each do |command_class|
         connect(command_class)
@@ -116,10 +114,11 @@ module Foobara
     def accomplish_goal(
       goal,
       result_type: nil,
-      choose_next_command_and_next_inputs_separately: nil,
       maximum_call_count: nil,
       llm_model: nil
     )
+      set_context_goal(goal)
+
       if result_type && self.result_type != result_type
         if self.result_type
           # :nocov:
@@ -144,7 +143,7 @@ module Foobara
         inputs = {
           goal:,
           final_result_type: self.result_type,
-          current_context: context,
+          context:,
           agent: self
         }
 
@@ -154,10 +153,6 @@ module Foobara
           inputs[:llm_model] = llm_model
         end
 
-        unless choose_next_command_and_next_inputs_separately.nil?
-          inputs[:choose_next_command_and_next_inputs_separately] = choose_next_command_and_next_inputs_separately
-        end
-
         unless maximum_call_count.nil?
           inputs[:maximum_command_calls] = maximum_call_count
         end
@@ -201,9 +196,12 @@ module Foobara
       end
     end
 
-    def build_initial_context
-      # TODO: shouldn't have to pass command_log here since it has a default, debug that
-      self.context ||= Context.new(command_log: [])
+    def set_context_goal(goal)
+      if context
+        context.set_new_goal(goal)
+      else
+        self.context = Context.for(goal)
+      end
     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.8
+  version: 0.0.10
 platform: ruby
 authors:
 - Miles Georgi
@@ -54,8 +54,7 @@ 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_inputs_for_next_command.rb
-- src/foobara/agent/determine_next_command.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_inputs_for_next_command.rb

@@ -1,45 +0,0 @@
-require "foobara/llm_backed_command"
-
-module Foobara
-  class Agent < CommandConnector
-    class DetermineInputsForNextCommand < Foobara::LlmBackedCommand
-      extend Concerns::SubclassCacheable
-
-      class << self
-        def for(command_class:, agent_id:)
-          cached_subclass([command_class.full_command_name, agent_id]) do
-            command_short_name = Util.non_full_name(command_class.command_name)
-            class_name = "Foobara::Agent::#{agent_id}::DetermineInputsForNext#{command_short_name}Command"
-            klass = Util.make_class_p(class_name, self)
-
-            klass.description "Accepts a goal and context of the work so far and returns the inputs for " \
-                              "the next #{command_short_name} command to run to make progress towards " \
-                              "accomplishing the goal."
-
-            klass.inputs do
-              goal :string, :required, "The current (possibly already accomplished) goal"
-              context Context, :required, "Context of the progress towards the goal so far"
-              llm_model :string,
-                        one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
-                        default: "claude-3-7-sonnet-20250219",
-                        description: "The model to use for the LLM"
-            end
-
-            if command_class.inputs_type
-              transformer = CommandConnectors::Transformers::EntityToPrimaryKeyInputsTransformer.new(
-                to: command_class.inputs_type
-              )
-              klass.result transformer.from_type
-            end
-
-            klass
-          end
-        end
-      end
-
-      def association_depth
-        Foobara::JsonSchemaGenerator::AssociationDepth::ATOM
-      end
-    end
-  end
-end

data/src/foobara/agent/determine_next_command.rb

@@ -1,32 +0,0 @@
-require "foobara/llm_backed_command"
-
-module Foobara
-  class Agent < CommandConnector
-    class DetermineNextCommand < Foobara::LlmBackedCommand
-      description "Accepts the current goal, which might already be accomplished, " \
-                  "and context of the work  " \
-                  "so far and returns the name of " \
-                  "the next command to run to make progress towards " \
-                  "accomplishing the goal. If the goal has already been accomplished then choose the " \
-                  "NotifyUserThatCurrentGoalHasBeenAccomplished command."
-
-      inputs do
-        goal :string, :required, "The current goal to accomplish. If the goal has already been accomplished " \
-                                 "by the previous command runs then choose " \
-                                 "NotifyUserThatCurrentGoalHasBeenAccomplished to stop the loop."
-        context Context, :required, "Context of progress so far"
-        llm_model :string,
-                  one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
-                  default: "claude-3-7-sonnet-20250219",
-                  description: "The model to use for the LLM"
-      end
-
-      result :string,
-             description: "Name of the next command to run to make progress " \
-                          "towards accomplishing the mission"
-      def association_depth
-        Foobara::JsonSchemaGenerator::AssociationDepth::ATOM
-      end
-    end
-  end
-end