foobara-agent 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db38ddbbaba0842ca16f3155372979cae6ed6d2807c5dd2a62dcaf7f9b93941b
-  data.tar.gz: 0415660f250abc75647efc61ed27635fd82c7cd2ceadb4d9ac93e1cf5bb4c3bf
+  metadata.gz: 88666f0c9353fd88d386752d774b3a5abac7bf035b9349769049a1e633fb6a4e
+  data.tar.gz: 60a09c5cd82d3c4b580ab3224875bc78b3086f04d91e3c28da6708483d4b3806
 SHA512:
-  metadata.gz: a9c2401005ddc1f5cb03ed562a5a811b01d575234713d9d6c0cd4b720fc6a776637bb3195b0a96b38945a4b1c4bdeb862a2de12bb83d2fb7267e8fbd6f30903c
-  data.tar.gz: abf74b0929795f22d434a813794b0f99516d1e817b57dfd9de31cd50833096c384c423deae386c68d91d9692e7b5eebad0739cd38d2e122dc8990c6c6fdb3822
+  metadata.gz: 5590b86e0dbb6baf8feac06ed1dce7a95a066acf3d684203dff92b86adb1fc329a217ec702affa332d9b6b6c2d6d187b5e3c960ee4b22a7263c0412760fd30c2
+  data.tar.gz: 13e01dd7118c05188ffd6a58ba51923eec81b14b227506a6fdeaf0c731dfef4bc41a14a052f2c17c2e46e3d32438a181ff906a082bf7f123ee7210fca1efc959

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [0.0.3] - 2025-05-30
+
+- Increase the retries, attempt to improve command descriptions,
+  and attempt to improve the information stored in the context/command log
+- Add some safeguards around changing the result type too late in the process
+- Add an agent state machine and a kill! method
+
+## [0.0.2] - 2025-05-27
+
+- Add maximum_call_count option
+- Try getting the command and inputs together to reduce calls
+- Tweaks to algorithms and improvements to what is stored in context/command_log
+
 ## [0.0.1] - 2025-05-21
 
 - Initial release

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
+        until mission_accomplished or given_up
+          check_if_too_many_calls
+          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
         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,132 @@ module Foobara
         end
       end
 
-      def determine_next_command_name
+      def determine_next_command_and_inputs(retries = 2)
+        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 = begin
+          determine_command.run
+        rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
+          Outcome.errors(e.errors)
+        end
+
+        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:,
+                  result: outcome.result || determine_command.raw_result
+                )
+
+                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:,
+              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
+        else
+          log_command_outcome(
+            command_name: determine_command.class.full_command_name,
+            inputs: determine_command.inputs&.except(:context),
+            outcome:,
+            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
+        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 = 2)
         self.next_command_name = if context.command_log.empty?
                                    ListCommands.full_command_name
                                  elsif delayed_command_name
@@ -138,7 +282,39 @@ module Foobara
                                      inputs[:llm_model] = llm_model
                                    end
 
-                                   command_class.run!(inputs)
+                                   command = command_class.new(inputs)
+                                   outcome = begin
+                                     command.run
+                                   rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
+                                     Outcome.errors(e.errors)
+                                   end
+
+                                   if outcome.success?
+                                     if log_successful_determine_command_and_inputs_outcomes?
+                                       log_command_outcome(
+                                         command:,
+                                         inputs: command.inputs.except(:context),
+                                         outcome:
+                                       )
+                                     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
 
@@ -156,23 +332,61 @@ 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 = 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_class.run!(inputs)
+                                     command = command_class.new(inputs)
+                                     outcome = begin
+                                       command.run
+                                     rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
+                                       Outcome.errors(e.errors)
+                                     end
+
+                                     if outcome.success?
+                                       if log_successful_determine_command_and_inputs_outcomes?
+                                         log_command_outcome(
+                                           command:,
+                                           inputs: command.inputs.except(:context),
+                                           outcome:
+                                         )
+                                       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_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,22 +397,46 @@ 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
 
-        context.command_log << CommandLogEntry.new(
-          command_name: next_command_name,
-          inputs: next_command_inputs,
+        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
+
+        log_entry = CommandLogEntry.new(
+          command_name:,
+          inputs:,
           outcome: outcome_hash
         )
+
+        context.command_log << log_entry
       end
 
       # TODO: these are awkwardly called from outside. Come up with a better solution.
@@ -235,6 +473,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,41 +3,21 @@ 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."
 
             klass.inputs do
-              goal :string, :required, "What do you want the agent to attempt to accomplish?"
+              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,
@@ -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,27 @@ 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.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."
 
             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"
+              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",
@@ -49,19 +41,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,30 @@
+require "foobara/llm_backed_command"
+
+module Foobara
+  class Agent
+    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 " \
+                  "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"
+        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,21 +1,39 @@
-require "io/wait"
-
 module Foobara
   class Agent
-    attr_accessor :context, :agent_command_connector, :agent_name, :llm_model
+    StateMachine = Foobara::StateMachine.for(
+      [:initialized, :idle, :error, :failure] => {
+        kill: :killed,
+        accomplish_goal: :accomplishing_goal
+      },
+      accomplishing_goal: {
+        goal_accomplished: :idle,
+        goal_errored: :error,
+        goal_failed: :failure,
+        kill: :killed
+      }
+    )
+
+    attr_accessor :context,
+                  :agent_command_connector,
+                  :agent_name,
+                  :llm_model,
+                  :current_accomplish_goal_command,
+                  :result_type
 
     def initialize(
       context: nil,
       agent_name: nil,
       command_classes: nil,
       agent_command_connector: nil,
-      llm_model: nil
+      llm_model: nil,
+      result_type: nil
     )
       # TODO: shouldn't have to pass command_log here since it has a default, debug that
       self.context = context
       self.agent_command_connector = agent_command_connector
       self.agent_name = agent_name if agent_name
       self.llm_model = llm_model
+      self.result_type = result_type
 
       build_initial_context
       build_agent_command_connector
@@ -25,20 +43,76 @@ module Foobara
       end
     end
 
-    def accomplish_goal(goal, result_type: nil)
-      inputs = {
-        goal:,
-        final_result_type: result_type,
-        current_context: context,
-        existing_command_connector: agent_command_connector,
-        agent_name:
-      }
+    def state_machine
+      @state_machine ||= StateMachine.new
+    end
+
+    def kill!
+      state_machine.perform_transition!(:kill)
+    end
+
+    def killed?
+      state_machine.current_state == :killed
+    end
 
-      if llm_model
-        inputs[:llm_model] = llm_model
+    def accomplish_goal(
+      goal,
+      result_type: nil,
+      choose_next_command_and_next_inputs_separately: nil,
+      maximum_call_count: nil
+    )
+      if result_type && self.result_type != result_type
+        if self.result_type
+          # :nocov:
+          raise ArgumentError, "You can only specify a result type once"
+          # :nocov:
+        elsif agent_command_connector.agent_commands_connected?
+          # :nocov:
+          raise ArgumentError, "You can't specify a result type this late in the process"
+          # :nocov:
+        else
+          self.result_type = result_type
+        end
       end
 
-      AccomplishGoal.run(inputs)
+      state_machine.perform_transition!(:accomplish_goal)
+
+      begin
+        inputs = {
+          goal:,
+          final_result_type: self.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
+
+        self.current_accomplish_goal_command = AccomplishGoal.new(inputs)
+
+        current_accomplish_goal_command.run.tap do |outcome|
+          if outcome.success?
+            state_machine.perform_transition!(:goal_accomplished)
+          else
+            state_machine.perform_transition!(:goal_errored)
+          end
+        end
+      rescue
+        # :nocov:
+        state_machine.perform_transition!(:goal_failed)
+        raise
+        # :nocov:
+      end
     end
 
     def build_initial_context
@@ -52,8 +126,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.3
 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