foobara-agent 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db38ddbbaba0842ca16f3155372979cae6ed6d2807c5dd2a62dcaf7f9b93941b
-  data.tar.gz: 0415660f250abc75647efc61ed27635fd82c7cd2ceadb4d9ac93e1cf5bb4c3bf
+  metadata.gz: 7288308d62332addbe98233f7652d718b16f496b02a632426c418642959c5aa4
+  data.tar.gz: 2da140d10bf62e8858de3d5f77c732a0295a4179dfa22e3ddb2c3becf7421029
 SHA512:
-  metadata.gz: a9c2401005ddc1f5cb03ed562a5a811b01d575234713d9d6c0cd4b720fc6a776637bb3195b0a96b38945a4b1c4bdeb862a2de12bb83d2fb7267e8fbd6f30903c
-  data.tar.gz: abf74b0929795f22d434a813794b0f99516d1e817b57dfd9de31cd50833096c384c423deae386c68d91d9692e7b5eebad0739cd38d2e122dc8990c6c6fdb3822
+  metadata.gz: 830b3932828ccb30587c64214425f7b4eea862f5deec5c6a9a8d2a8d80733720b66e0d73f936444d91f5dffa6b7f27d8736638c000e17d2caa37cbff477fe6d2
+  data.tar.gz: cd9e89b6dc3dc81f2bd71ed5d6269f7dc8268d950bb120508c8295d1b89b64cd345d79fec8aa2f85cba0945e534e5fc62305ca070f78490f5c3f0303bf72f011

data/lib/foobara/agent.rb

@@ -13,10 +13,10 @@ module Foobara
         [
           DetermineInputsForNextCommand,
           DetermineNextCommand,
-          EndSessionBecauseGoalHasBeenAccomplished
+          NotifyUserThatCurrentGoalHasBeenAccomplished
         ].each do |command_class|
-          command_class.clear_cache
-          Util.descendants(command_class).each(&:clear_cache)
+          command_class.clear_subclass_cache
+          Util.descendants(command_class).each(&:clear_subclass_cache)
         end
       end
     end

data/src/foobara/agent/accomplish_goal.rb

@@ -5,20 +5,40 @@ module Foobara
   class Agent
     class AccomplishGoal < Foobara::Command
       possible_error :gave_up, context: { reason: :string }, message: "Gave up."
+      possible_error :too_many_command_calls,
+                     context: { maximum_command_calls: :integer }
 
       inputs do
         agent_name :string, "Name of the agent"
         goal :string, :required, "What do you want the agent to attempt to accomplish?"
         # TODO: we should be able to specify a subclass as a type
-        command_classes [:duck], "Commands that can be ran to accomplish the goal"
+        command_classes [Class], "Commands that can be ran to accomplish the goal"
         final_result_type :duck, "Specifies how the result of the goal is to be structured"
-        existing_command_connector :duck, "A connector containing already-connected commands for the agent to use"
-        current_context :duck, "The current context of the agent"
+        existing_command_connector CommandConnector, :allow_nil,
+                                   "A connector containing already-connected commands for the agent to use"
+        current_context Context, :allow_nil, "The current context of the agent"
+        maximum_command_calls :integer,
+                              :allow_nil,
+                              default: 25,
+                              description: "Maximum number of commands to run before giving up"
         llm_model :string,
                   :allow_nil,
                   one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
                   default: "claude-3-7-sonnet-20250219",
                   description: "The model to use for the LLM"
+        log_successful_determine_command_and_inputs_outcomes(
+          :boolean,
+          default: true,
+          description: "You can experiment with turning this off " \
+                       "if you want to see what happens if we don't log " \
+                       "successful command/input selection outcomes"
+        )
+        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."
       end
 
       result do
@@ -36,26 +56,22 @@ module Foobara
         else
           build_command_connector
           connect_user_provided_commands
-          connect_agent_commands
         end
 
-        unless command_connector.agent_commands_connected?
+        unless agent_commands_connected?
           connect_agent_commands
         end
 
         until mission_accomplished or given_up or timed_out
-          determine_next_command_name
-
-          if command_described?
-            fetch_next_command_class
-            determine_next_command_inputs
+          if choose_next_command_and_next_inputs_separately?
+            determine_next_command_then_inputs_separately
           else
-            choose_describe_command_instead
-            fetch_next_command_class
+            determine_next_command_and_inputs
           end
 
           run_next_command
-          log_command_outcome
+          log_last_command_outcome
+          check_if_too_many_calls
         end
 
         if given_up
@@ -65,6 +81,10 @@ module Foobara
         build_result
       end
 
+      def agent_commands_connected?
+        command_connector.agent_commands_connected?
+      end
+
       def validate
         validate_either_command_classes_or_connector_given
       end
@@ -100,8 +120,7 @@ module Foobara
           accomplish_goal_command: self,
           default_serializers: [
             Foobara::CommandConnectors::Serializers::ErrorsSerializer,
-            Foobara::CommandConnectors::Serializers::AtomicSerializer,
-            Foobara::CommandConnectors::Serializers::JsonSerializer
+            Foobara::CommandConnectors::Serializers::AtomicSerializer
           ],
           llm_model:
         )
@@ -121,7 +140,125 @@ module Foobara
         end
       end
 
-      def determine_next_command_name
+      def determine_next_command_and_inputs(retries = 1)
+        if context.command_log.empty?
+          self.next_command_name = ListCommands.full_command_name
+          self.next_command_inputs = nil
+          fetch_next_command_class
+          return
+        end
+
+        inputs_for_determine = {
+          goal:,
+          context:,
+          llm_model:,
+          command_class_names: all_command_classes
+        }
+
+        determine_command = DetermineNextCommandNameAndInputs.new(inputs_for_determine)
+
+        outcome = determine_command.run
+
+        if outcome.success?
+          self.next_command_name = outcome.result[:command_name]
+          self.next_command_inputs = outcome.result[:inputs]
+
+          outcome = validate_next_command_name
+
+          if outcome.success?
+            fetch_next_command_class
+
+            if next_command_has_inputs?
+              outcome = validate_next_command_inputs
+
+              if outcome.success?
+                if log_successful_determine_command_and_inputs_outcomes?
+                  log_command_outcome(
+                    command: determine_command,
+                    inputs: determine_command.inputs.except(:context)
+                  )
+                end
+              else
+                log_command_outcome(
+                  command: determine_command,
+                  inputs: determine_command.inputs.except(:context),
+                  outcome:
+                )
+
+                determine_next_command_inputs
+              end
+            else
+              self.next_command_inputs = {}
+            end
+          else
+            log_command_outcome(
+              command: determine_command,
+              inputs: determine_command.inputs&.except(:context),
+              outcome:
+            )
+
+            if retries > 0
+              determine_next_command_and_inputs(retries - 1)
+            else
+              determine_next_command_then_inputs_separately
+            end
+          end
+        else
+          log_command_outcome(
+            command_name: determine_command.class.full_command_name,
+            inputs: determine_command.inputs&.except(:context),
+            outcome:
+          )
+
+          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
+        end
+      end
+
+      def validate_next_command_name
+        outcome = command_name_type.process_value(next_command_name)
+
+        if outcome.success?
+          self.next_command_name = outcome.result
+        end
+
+        outcome
+      end
+
+      def validate_next_command_inputs
+        inputs_type = next_command_class.inputs_type
+
+        outcome = NestedTransactionable.with_needed_transactions_for_type(inputs_type) do
+          inputs_type.process_value(next_command_inputs)
+        end
+
+        if outcome.success?
+          self.next_command_inputs = outcome.result
+        end
+
+        outcome
+      end
+
+      def command_name_type
+        @command_name_type ||= Agent.foobara_type_from_declaration(:string, one_of: all_command_classes)
+      end
+
+      def determine_next_command_name(retries = 1)
         self.next_command_name = if context.command_log.empty?
                                    ListCommands.full_command_name
                                  elsif delayed_command_name
@@ -138,7 +275,32 @@ module Foobara
                                      inputs[:llm_model] = llm_model
                                    end
 
-                                   command_class.run!(inputs)
+                                   command = command_class.new(inputs)
+                                   outcome = command.run
+
+                                   if outcome.success?
+                                     if log_successful_determine_command_and_inputs_outcomes?
+                                       log_command_outcome(
+                                         command:,
+                                         inputs: command.inputs.except(:context)
+                                       )
+                                     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)
+                                     )
+
+                                     if retries > 0
+                                       return determine_next_command_name(retries - 1)
+                                     end
+                                     # :nocov:
+                                   end
+
+                                   outcome.raise!
+                                   outcome.result
                                  end
       end
 
@@ -156,23 +318,54 @@ module Foobara
         self.next_command_class = command_connector.transformed_command_from_name(next_command_name)
       end
 
-      def determine_next_command_inputs
-        type = next_command_class.inputs_type
-
-        self.next_command_inputs = if type && !empty_attributes?(type)
-                                     command_class = DetermineInputsForNextCommand.for(
-                                       command_class: next_command_class, agent_id: agent_name
-                                     )
+      def determine_next_command_inputs(retries = 1)
+        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_class.run!(inputs)
+                                     command = command_class.new(inputs)
+                                     outcome = command.run
+
+                                     if outcome.success?
+                                       if log_successful_determine_command_and_inputs_outcomes?
+                                         log_command_outcome(
+                                           command:,
+                                           inputs: command.inputs.except(:context)
+                                         )
+                                       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)
+                                       )
+                                       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
         self.command_response = command_connector.run(
           full_command_name: next_command_name,
@@ -183,20 +376,42 @@ module Foobara
         self.command_outcome = command_response.outcome
       end
 
-      def log_command_outcome
-        outcome_hash = { success: command_outcome.success? }
+      def log_last_command_outcome
+        log_command_outcome(command: command_response.command)
+      end
+
+      def check_if_too_many_calls
+        if context.command_log.size > maximum_command_calls
+          add_runtime_error(
+            :too_many_command_calls,
+            "Too many command calls. " \
+            "Stopping. Increase maximum_command_calls if #{maximum_command_calls} is not enough.",
+            maximum_command_calls:
+          )
+        end
+      end
 
-        if command_outcome.success?
-          outcome_hash[:result] = command_response.body
-        else
-          # :nocov:
-          outcome_hash[:errors_hash] = command_response.body
-          # :nocov:
+      def log_command_outcome(command: nil, command_name: nil, inputs: nil, outcome: nil, result: nil)
+        if command
+          command_name ||= command.class.full_command_name
+          inputs ||= command.inputs
+          outcome ||= command.outcome
+          result ||= outcome.result
+        end
+
+        outcome_hash = { success: outcome.success? }
+
+        if outcome.success? || result
+          outcome_hash[:result] = result
+        end
+
+        unless outcome.success?
+          outcome_hash[:errors_hash] = outcome.errors_hash
         end
 
         context.command_log << CommandLogEntry.new(
-          command_name: next_command_name,
-          inputs: next_command_inputs,
+          command_name:,
+          inputs:,
           outcome: outcome_hash
         )
       end
@@ -235,6 +450,14 @@ module Foobara
       def empty_attributes?(type)
         type.extends_type?(BuiltinTypes[:attributes]) && type.element_types.empty?
       end
+
+      def log_successful_determine_command_and_inputs_outcomes?
+        log_successful_determine_command_and_inputs_outcomes
+      end
+
+      def choose_next_command_and_next_inputs_separately?
+        choose_next_command_and_next_inputs_separately
+      end
     end
   end
 end

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

@@ -0,0 +1,24 @@
+module Foobara
+  class Agent
+    module Concerns
+      # There's nothing really subclass-specific about this concern, maybe rename it...
+      module SubclassCacheable
+        def subclass_cache
+          @subclass_cache ||= {}
+        end
+
+        def clear_subclass_cache
+          @subclass_cache = nil
+        end
+
+        def cached_subclass(key)
+          if subclass_cache.key?(key)
+            subclass_cache[key]
+          else
+            subclass_cache[key] = yield
+          end
+        end
+      end
+    end
+  end
+end

data/src/foobara/agent/connector/connector.rb

@@ -36,12 +36,12 @@ module Foobara
         ]
 
         command_classes << if final_result_type
-                             EndSessionBecauseGoalHasBeenAccomplished.for(
+                             NotifyUserThatCurrentGoalHasBeenAccomplished.for(
                                result_type: final_result_type,
                                agent_id: agent_name
                              )
                            else
-                             EndSessionBecauseGoalHasBeenAccomplished
+                             NotifyUserThatCurrentGoalHasBeenAccomplished
                            end
 
         command_classes.each do |command_class|

data/src/foobara/agent/describe_command.rb

@@ -41,13 +41,13 @@ module Foobara
 
       def set_inputs_type
         if command_class.inputs_type
-          command_description[:inputs_type] = JsonSchemaGenerator.to_json_schema(command_class.inputs_type)
+          command_description[:inputs_type] = JSON.parse(JsonSchemaGenerator.to_json_schema(command_class.inputs_type))
         end
       end
 
       def set_result_type
         if command_class.result_type
-          command_description[:result_type] = JsonSchemaGenerator.to_json_schema(command_class.result_type)
+          command_description[:result_type] = JSON.parse(JsonSchemaGenerator.to_json_schema(command_class.result_type))
         end
       end
 

data/src/foobara/agent/determine_inputs_for_next_command.rb

@@ -3,35 +3,15 @@ require "foobara/llm_backed_command"
 module Foobara
   class Agent
     class DetermineInputsForNextCommand < Foobara::LlmBackedCommand
-      class << self
-        attr_accessor :command_class
-
-        def command_cache
-          @command_cache ||= {}
-        end
-
-        def clear_cache
-          @command_cache = nil
-        end
-
-        def cached_command(agent_id, full_command_name)
-          key = [agent_id, full_command_name]
-
-          if command_cache.key?(key)
-            command_cache[key]
-          else
-            command_cache[key] = yield
-          end
-        end
+      extend Concerns::SubclassCacheable
 
+      class << self
         def for(command_class:, agent_id:)
-          cached_command(agent_id, command_class.full_command_name) do
+          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.command_class = command_class
-
             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."
@@ -53,23 +33,6 @@ module Foobara
           end
         end
       end
-
-      description "Accepts a goal and context of the work so far and returns the inputs for the next command to " \
-                  "run to make progress towards accomplishing the mission."
-
-      inputs do
-        goal :string, :required, "What do you want the agent to attempt to accomplish?"
-        context Context, :required, "Context of the current mission so far"
-        command_class :duck, :required, "Command to run to accomplish the goal"
-        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 :duck,
-             description: "Inputs to pass to the next command to run to make progress " \
-                          "towards accomplishing the mission."
     end
   end
 end

data/src/foobara/agent/determine_next_command.rb

@@ -3,35 +3,18 @@ require "foobara/llm_backed_command"
 module Foobara
   class Agent
     class DetermineNextCommand < Foobara::LlmBackedCommand
-      class << self
-        attr_accessor :command_class_names
-
-        def command_cache
-          @command_cache ||= {}
-        end
-
-        def clear_cache
-          @command_cache = nil
-        end
-
-        def cached_command(agent_id)
-          if command_cache.key?(agent_id)
-            command_cache[agent_id]
-          else
-            command_cache[agent_id] = yield
-          end
-        end
+      extend Concerns::SubclassCacheable
 
+      class << self
+        # Allows us to give a more meaningful result type
         def for(command_class_names:, agent_id:)
-          cached_command(agent_id) do
+          cached_subclass(agent_id) do
             command_name = "Foobara::Agent::#{agent_id}::DetermineNextCommand"
             klass = Util.make_class_p(command_name, self)
 
-            klass.command_class_names = command_class_names
-
             klass.inputs do
               goal :string, :required, "What do you want the agent to attempt to accomplish?"
-              context Context, :required, "Context of the current mission so far"
+              context Context, :required, "Context of progress so far"
               llm_model :string,
                         one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
                         default: "claude-3-7-sonnet-20250219",
@@ -49,19 +32,7 @@ module Foobara
       end
 
       description "Accepts a goal and context of the work so far and returns the name of the next command to run to " \
-                  "make progress towards accomplishing the mission. Make sure you have called DescribeCommand the" \
-                  "command first so that you will know how to construct its inputs in the next step."
-
-      inputs do
-        goal :string, :required, "What do you want the agent to attempt to accomplish?"
-        context Context, :required, "Context of the current mission 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."
+                  "make progress towards accomplishing the mission."
     end
   end
 end

data/src/foobara/agent/determine_next_command_name_and_inputs.rb

@@ -0,0 +1,26 @@
+require "foobara/llm_backed_command"
+
+module Foobara
+  class Agent
+    class DetermineNextCommandNameAndInputs < Foobara::LlmBackedCommand
+      description "Accepts a goal and context of the work so far and returns the inputs for " \
+                  "the next command to run to make progress towards " \
+                  "accomplishing the goal."
+
+      inputs do
+        goal :string, :required, "What do you want the agent to attempt to accomplish?"
+        context Context, :required, "Context of the progress towards the goal so far"
+        command_class_names [:string], :required
+        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
+        inputs :attributes, :allow_nil
+      end
+    end
+  end
+end

data/src/foobara/agent/give_up.rb

@@ -2,7 +2,7 @@ module Foobara
   class Agent
     class GiveUp < Foobara::Command
       inputs do
-        command_connector :duck, :required, "Connector to end"
+        command_connector CommandConnector, :required, "Connector to end"
         message_to_user :string, "Optional message to the user explaining why you decided to give up"
       end
 

data/src/foobara/agent/{end_session_because_goal_has_been_accomplished.rb → notify_user_that_current_goal_has_been_accomplished.rb}

@@ -1,59 +1,48 @@
 module Foobara
   class Agent
-    class EndSessionBecauseGoalHasBeenAccomplished < Foobara::Command
+    class NotifyUserThatCurrentGoalHasBeenAccomplished < Foobara::Command
+      extend Concerns::SubclassCacheable
+
       class << self
         attr_accessor :command_class
 
-        def command_cache
-          @command_cache ||= {}
-        end
-
-        def clear_cache
-          @command_cache = nil
-        end
-
-        def cached_command(agent_id, result_type)
-          key = [agent_id, result_type]
-
-          if command_cache.key?(key)
-            # :nocov:
-            command_cache[key]
-            # :nocov:
-          else
-            command_cache[key] = yield
-          end
-        end
-
         def for(result_type:, agent_id:)
-          cached_command(agent_id, result_type) do
-            command_name = "Foobara::Agent::#{agent_id}::EndSessionBecauseGoalHasBeenAccomplished"
+          cached_subclass([result_type, agent_id]) do
+            command_name = "Foobara::Agent::#{agent_id}::NotifyUserThatCurrentGoalHasBeenAccomplished"
             klass = Util.make_class_p(command_name, self)
 
-            klass.description "Ends the session giving a final result formatted according to the " \
-                              "result schema if relevant and an optional message to the user."
+            klass.description "Notifies the user that the current goal has been accomplished and returns a final " \
+                              "result formatted according to the " \
+                              "result schema and an optional message to the user. " \
+                              "The user might issue a new goal."
 
             inputs do
-              # TODO: Are we still not able to uses classes as foobara types??
-              command_connector :duck, :required, "Connector to end"
+              command_connector CommandConnector, :required, "Connector to notify user through"
               message_to_user :string, "Optional message to the user"
             end
 
             if result_type
               add_inputs do
-                result_data(*result_type)
+                result_data result_type
               end
 
               klass.result do
                 message_to_user :string
-                result_data(*result_type)
+                result_data 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 if relevant and an optional message to the user. " \
+                                "The user might issue a new goal."
 
-              klass.description "Ends the session giving a final result formatted according to the " \
-                                "result schema and an optional message to the user."
             else
               # TODO: test this code path
               # :nocov:
-              klass.description "Ends the session giving an optional message to the user."
+              klass.description "Notifies the user that the current goal has been accomplished and, if relevant,  " \
+                                "returns a final " \
+                                "result formatted according to the " \
+                                "result schema and an optional message to the user. " \
+                                "The user might issue a new goal."
               # :nocov:
             end
 

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

@@ -3,12 +3,12 @@ module Foobara
     class CommandLogEntry < Foobara::Model
       attributes do
         command_name :string, :required, "Name of the command that was run"
-        inputs :duck, :required, "Inputs to the command" # TODO: Allow :attributes to be used as a type succesfully
+        inputs :attributes, :allow_nil, "Inputs to the command"
         outcome :required do
           success :boolean, :required, "Whether the command succeeded or not"
-          result :duck, :allow_nil, "Result of the command"
+          result :duck, "Result of the command"
           # TODO: create a type for error hash structure
-          errors_hash :duck, :allow_nil, "Errors that occurred during the command"
+          errors_hash :duck, "Errors that occurred during the command"
         end
       end
     end

data/src/foobara/agent.rb

@@ -1,5 +1,3 @@
-require "io/wait"
-
 module Foobara
   class Agent
     attr_accessor :context, :agent_command_connector, :agent_name, :llm_model
@@ -25,19 +23,33 @@ module Foobara
       end
     end
 
-    def accomplish_goal(goal, result_type: nil)
+    def accomplish_goal(
+      goal,
+      result_type: nil,
+      choose_next_command_and_next_inputs_separately: nil,
+      maximum_call_count: nil
+    )
       inputs = {
         goal:,
         final_result_type: result_type,
         current_context: context,
         existing_command_connector: agent_command_connector,
         agent_name:
+
       }
 
       if llm_model
         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
+
       AccomplishGoal.run(inputs)
     end
 
@@ -52,8 +64,7 @@ module Foobara
         llm_model:,
         default_serializers: [
           Foobara::CommandConnectors::Serializers::ErrorsSerializer,
-          Foobara::CommandConnectors::Serializers::AtomicSerializer,
-          Foobara::CommandConnectors::Serializers::JsonSerializer
+          Foobara::CommandConnectors::Serializers::AtomicSerializer
         ]
       )
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-agent
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Miles Georgi
@@ -50,16 +50,18 @@ files:
 - lib/foobara/agent.rb
 - src/foobara/agent.rb
 - src/foobara/agent/accomplish_goal.rb
+- src/foobara/agent/concerns/subclass_cacheable.rb
 - src/foobara/agent/connector/connector.rb
 - 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/end_session_because_goal_has_been_accomplished.rb
+- src/foobara/agent/determine_next_command_name_and_inputs.rb
 - src/foobara/agent/give_up.rb
 - src/foobara/agent/list_commands.rb
 - src/foobara/agent/list_types.rb
+- src/foobara/agent/notify_user_that_current_goal_has_been_accomplished.rb
 - src/foobara/agent/types/command_log_entry.rb
 - src/foobara/agent/types/context.rb
 homepage: https://github.com/foobara/agent