foobara-agent 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 121474f4e61c1b3a5eebc883794bef41159d48ecc05eba44165bd8d79111c426
-  data.tar.gz: 50bc4c4aea5bd447f17cf39712b7a86295e4f45708602398f72a61af2f221881
+  metadata.gz: 12e8facdeb95a000d81ec0ba8a133affa1ea66e470115e978bdc81f05bc51855
+  data.tar.gz: 294064df166d152c037db13263863b8ccfe32f064a78e77f6f5fe59af0be3829
 SHA512:
-  metadata.gz: e0cbf20f7fc287bd4a3be5caed0572de59475493ae4bed80d755b5284ead25fa697b455959ca323891bb20f0bfb57a5a01f1e62f335faacc6c99c220821920f3
-  data.tar.gz: cf85ac42b6ab4a9f8efddd35e533afd32f664b9a9ec8bba17f77abf424a5499e64ba6ad576b54bb24c03dadb5e6bc1c2fe54a502bd505f30caaeeb15e002d655
+  metadata.gz: 2c7fcaf044ba9bc821dcc42f9b0fb44b412fb42f9ef77dd4b7f3ed13cb8293cdb60d448d136e4e0567d104ecb022a00accfd05dbcf955e38185884d34e59668e
+  data.tar.gz: 380d9ae749b6a942b4e33b112f5aae35fd9600fa9ffcaf462fc0a35122354aae0658378190a4b9db3c0d65d2a12c9d49305b1d03a2881ce504d6d268cf039255

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.0.8] - 2025-06-27
+
+- Improve what is logged and its formatting when verbose
+- Improve/experiment with what is stored in the command log
+- Experiment with Atoms instead of Aggregates
+- Add max_llm_calls_per_minute option
+
+## [0.0.7] - 2025-06-23
+
+- Improvements to result type handling
+- Eliminate DescribeType command
+
 ## [0.0.6] - 2025-06-19
 
 - Do not run next command with pre-cast inputs

data/lib/foobara/agent.rb

@@ -12,7 +12,6 @@ module Foobara
       def reset_all
         [
           DetermineInputsForNextCommand,
-          DetermineNextCommand,
           NotifyUserThatCurrentGoalHasBeenAccomplished
         ].each do |command_class|
           command_class.clear_subclass_cache

data/src/foobara/agent/accomplish_goal.rb

@@ -3,21 +3,22 @@ require_relative "list_commands"
 module Foobara
   class Agent < CommandConnector
     class AccomplishGoal < Foobara::Command
+      # Using a const here so we can stub it in the test suite to speed things up
+      SECONDS_PER_MINUTE = 60
+
       possible_error :gave_up, context: { reason: :string }, message: "Gave up."
       possible_error :too_many_command_calls,
                      context: { maximum_command_calls: :integer }
 
       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 [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"
+        include_message_to_user_in_result :boolean, default: true
         verbose :boolean, default: false
         io_out :duck
         io_err :duck
-        existing_command_connector CommandConnector, :allow_nil,
-                                   "A connector containing already-connected commands for the agent to use"
+        agent Agent, :required
         current_context Context, :allow_nil, "The current context of the agent"
         maximum_command_calls :integer,
                               :allow_nil,
@@ -28,23 +29,17 @@ module Foobara
                   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."
+        max_llm_calls_per_minute :integer, :allow_nil
       end
 
       result do
-        message_to_user :string, :required, "Message to the user about successfully accomplishing the goal"
+        message_to_user :string, :allow_nil, "Message to the user about successfully accomplishing the goal"
         result_data :duck, "Optional result data to return to the user if final_result_type was given"
       end
 
@@ -53,24 +48,16 @@ module Foobara
       def execute
         build_initial_context_if_necessary
 
-        if command_connector_passed_in?
-          set_accomplished_goal_command
-        else
-          build_command_connector
-          connect_user_provided_commands
-        end
-
-        unless agent_commands_connected?
-          connect_agent_commands
-        end
-
+        simulate_describe_list_commands_command
         simulate_list_commands_run
-        simulate_describe_command_run_for_all_commands
+        # simulate_describe_command_run_for_all_commands
 
         until mission_accomplished or given_up
           increment_command_calls
           check_if_too_many_calls
 
+          throttle_llm_calls_if_necessary
+
           if choose_next_command_and_next_inputs_separately?
             determine_next_command_then_inputs_separately
           else
@@ -88,27 +75,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
-
-      def validate_either_command_classes_or_connector_given
-        # TODO: implement this!
-      end
-
-      attr_accessor :context, :next_command_name, :next_command_inputs, :mission_accomplished, :given_up,
-                    :next_command_class, :next_command, :command_outcome, :timed_out,
+      attr_accessor :context, :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
-      attr_writer :command_connector
-
-      def agent_name
-        @agent_name ||= inputs[:agent_name] || "Anon#{SecureRandom.hex(2)}"
-      end
 
       def build_initial_context_if_necessary
         # TODO: shouldn't have to pass command_log here since it has a default, debug that
@@ -116,9 +86,8 @@ module Foobara
       end
 
       def simulate_list_commands_run
-        return unless context.command_log.empty?
-
         self.next_command_name = ListCommands.full_command_name
+        self.next_command_raw_inputs = nil
         self.next_command_inputs = nil
         fetch_next_command_class
 
@@ -126,65 +95,46 @@ module Foobara
         log_last_command_outcome
       end
 
+      def simulate_describe_list_commands_command
+        self.next_command_name = DescribeCommand.full_command_name
+        self.next_command_inputs = { command_name: ListCommands.full_command_name }
+        self.next_command_raw_inputs = next_command_inputs
+        fetch_next_command_class
+
+        run_next_command
+        log_last_command_outcome
+      end
+
       def simulate_describe_command_run_for_all_commands
+        # TODO: currently not using this code path. Unclear if it is worth it.
+        # :nocov:
         return if context.command_log.size > 1
 
-        ListCommands.run!(command_connector:)[:user_provided_commands].each do |full_command_name|
+        ListCommands.run!(command_connector: agent)[:user_provided_commands].each do |full_command_name|
           next if described_commands.include?(full_command_name)
 
           self.next_command_name = DescribeCommand.full_command_name
           self.next_command_inputs = { command_name: full_command_name }
+          self.next_command_raw_inputs = next_command_inputs
           fetch_next_command_class
 
           run_next_command
           log_last_command_outcome
         end
-      end
-
-      def command_connector_passed_in?
-        existing_command_connector
-      end
-
-      def command_connector
-        @command_connector ||= existing_command_connector
-      end
-
-      # Do we really want to support calling AccomplishGoal outside the context of an Agent?
-      # If not, just delete this awkward coupling
-      def build_command_connector
-        self.command_connector ||= Agent.new(
-          current_accomplish_goal_command: self,
-          llm_model:,
-          verbose:,
-          io_out:
-        )
-      end
-
-      def set_accomplished_goal_command
-        command_connector.current_accomplish_goal_command = self
-      end
-
-      def connect_agent_commands
-        command_connector.connect_agent_commands(final_result_type:, agent_name:)
-      end
-
-      def connect_user_provided_commands
-        command_classes.each do |command_class|
-          command_connector.connect(command_class)
-        end
+        # :nocov:
       end
 
       def determine_next_command_and_inputs(retries = 2)
         inputs_for_determine = {
           goal:,
           context:,
-          llm_model:,
-          command_class_names: all_command_classes
+          llm_model:
         }
 
         determine_command = DetermineNextCommandNameAndInputs.new(inputs_for_determine)
 
         outcome = begin
+          record_llm_call_timestamp
           determine_command.run
         rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
           # :nocov:
@@ -195,6 +145,7 @@ module Foobara
         if outcome.success?
           self.next_command_name = outcome.result[:command_name]
           self.next_command_inputs = outcome.result[:inputs]
+          self.next_command_raw_inputs = next_command_inputs
 
           outcome = validate_next_command_name
 
@@ -204,32 +155,25 @@ module Foobara
             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
+              unless outcome.success?
                 log_command_outcome(
-                  command: determine_command,
-                  inputs: determine_command.inputs.except(:context),
-                  outcome:,
-                  result: outcome.result || determine_command.raw_result
+                  command_name: next_command_name,
+                  inputs: next_command_inputs,
+                  outcome:
                 )
 
                 determine_next_command_inputs
               end
             else
               self.next_command_inputs = {}
+              self.next_command_raw_inputs = next_command_inputs
             end
           else
             log_command_outcome(
-              command: determine_command,
-              inputs: determine_command.inputs&.except(:context),
+              command_name: next_command_name,
+              inputs: next_command_inputs,
               outcome:,
-              result: outcome.result || determine_command.raw_result
+              result: nil
             )
 
             if retries > 0
@@ -267,10 +211,23 @@ module Foobara
       end
 
       def validate_next_command_name
+        if next_command_name.is_a?(::String)
+          command_class = agent.transformed_command_from_name(next_command_name)
+
+          if command_class
+            self.next_command_name = command_class.full_command_name
+
+            return Outcome.success(next_command_name)
+          end
+        end
+
         outcome = command_name_type.process_value(next_command_name)
 
         if outcome.success?
+          # TODO: figure out a way to hit this path in the test suite
+          # :nocov:
           self.next_command_name = outcome.result
+          # :nocov:
         end
 
         outcome
@@ -294,17 +251,14 @@ module Foobara
                                    self.delayed_command_name = nil
                                    name
                                  else
-                                   command_class = DetermineNextCommand.for(
-                                     command_class_names: all_command_classes, agent_id: agent_name
-                                   )
-
                                    inputs = { goal:, context: }
                                    if llm_model
                                      inputs[:llm_model] = llm_model
                                    end
 
-                                   command = command_class.new(inputs)
+                                   command = DetermineNextCommand.new(inputs)
                                    outcome = begin
+                                     record_llm_call_timestamp
                                      command.run
                                    rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
                                      # :nocov:
@@ -313,12 +267,24 @@ module Foobara
                                    end
 
                                    if outcome.success?
-                                     if log_successful_determine_command_and_inputs_outcomes?
+                                     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:
+                                         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
@@ -348,11 +314,11 @@ module Foobara
       end
 
       def all_command_classes
-        @all_command_classes ||= run_subcommand!(ListCommands, command_connector:).values.flatten
+        @all_command_classes ||= run_subcommand!(ListCommands, command_connector: agent).values.flatten
       end
 
       def fetch_next_command_class
-        self.next_command_class = command_connector.transformed_command_from_name(next_command_name)
+        self.next_command_class = agent.transformed_command_from_name(next_command_name)
       end
 
       def determine_next_command_inputs(retries = 2)
@@ -366,6 +332,7 @@ module Foobara
 
                                      command = command_class.new(inputs)
                                      outcome = begin
+                                       record_llm_call_timestamp
                                        command.run
                                      rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
                                        # :nocov:
@@ -373,23 +340,15 @@ module Foobara
                                        # :nocov:
                                      end
 
-                                     if outcome.success?
-                                       if log_successful_determine_command_and_inputs_outcomes?
-                                         log_command_outcome(
-                                           command:,
-                                           inputs: command.inputs.except(:context),
-                                           outcome:
-                                         )
-                                       end
-                                     else
+                                     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:,
-                                         inputs: command.inputs.except(:context),
-                                         outcome:,
-                                         result: outcome.result || command.raw_result
+                                         command_name: next_command_name,
+                                         inputs: command.raw_result,
+                                         outcome:
                                        )
+
                                        if retries > 0
                                          return determine_next_command_inputs(retries - 1)
                                        end
@@ -414,10 +373,23 @@ module Foobara
 
       def run_next_command
         if verbose?
-          (io_out || $stdout).puts "Running #{next_command_name} with #{next_command_inputs}"
+          args = if next_command_inputs.nil? || next_command_inputs.empty?
+                   ""
+                 else
+                   s = next_command_inputs.to_s
+
+                   if s =~ /\A\{(.*)}\z/
+                     "(#{::Regexp.last_match(1)})"
+                   else
+                     # :nocov:
+                     raise "Unexpected next_command_inputs: #{next_command_inputs}"
+                     # :nocov:
+                   end
+                 end
+          (io_out || $stdout).puts "#{next_command_name}.run#{args}"
         end
 
-        self.command_response = command_connector.run(
+        self.command_response = agent.run(
           full_command_name: next_command_name,
           inputs: next_command_inputs,
           action: "run"
@@ -426,9 +398,7 @@ module Foobara
         self.command_outcome = command_response.outcome
 
         if verbose?
-          if command_outcome.success?
-            (io_out || $stdout).puts "Command #{command_response.command.class.full_command_name} succeeded"
-          else
+          unless command_outcome.success?
             # :nocov:
             (io_err || $stderr).puts(
               "Command #{command_response.command.class.full_command_name} failed #{command_outcome.errors_hash}"
@@ -461,8 +431,11 @@ module Foobara
       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
+          inputs ||= command.raw_inputs
           outcome ||= command.outcome
+        end
+
+        if outcome
           result ||= outcome.result
         end
 
@@ -520,17 +493,63 @@ module Foobara
         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
 
+      def agent_name
+        agent.agent_name
+      end
+
       def verbose?
         verbose
       end
+
+      def llm_call_timestamps
+        @llm_call_timestamps ||= []
+      end
+
+      attr_writer :llm_call_timestamps
+
+      def record_llm_call_timestamp
+        llm_call_timestamps.unshift(Time.now)
+      end
+
+      def llm_calls_in_last_minute
+        llm_call_timestamps.select { |t| t > (Time.now - 60) }
+      end
+
+      def llm_call_count_in_last_minute
+        llm_calls_in_last_minute.size
+      end
+
+      def time_until_llm_call_count_in_last_minute_changes
+        calls = llm_calls_in_last_minute
+
+        first_to_expire = calls.first
+
+        if first_to_expire
+          (first_to_expire + SECONDS_PER_MINUTE) - Time.now
+        else
+          # TODO: figure out how to test this code path
+          # :nocov:
+          0
+          # :nocov:
+        end
+      end
+
+      def throttle_llm_calls_if_necessary
+        return unless max_llm_calls_per_minute && max_llm_calls_per_minute > 0
+
+        if llm_call_count_in_last_minute >= max_llm_calls_per_minute
+          seconds = time_until_llm_call_count_in_last_minute_changes
+          if verbose?
+            (io_out || $stdout).puts "Sleeping for #{seconds} seconds to avoid LLM calls per minute limit"
+          end
+
+          sleep seconds
+        end
+      end
     end
   end
 end

data/src/foobara/agent/determine_inputs_for_next_command.rb

@@ -26,13 +26,20 @@ module Foobara
             end
 
             if command_class.inputs_type
-              klass.result 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

@@ -3,45 +3,30 @@ require "foobara/llm_backed_command"
 module Foobara
   class Agent < CommandConnector
     class DetermineNextCommand < Foobara::LlmBackedCommand
-      extend Concerns::SubclassCacheable
+      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."
 
-      class << self
-        # Allows us to give a more meaningful result type
-        def for(command_class_names:, agent_id:)
-          cached_subclass(agent_id) do
-            command_name = "Foobara::Agent::#{agent_id}::DetermineNextCommand"
-            klass = Util.make_class_p(command_name, self)
-
-            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, "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
-
-            klass.result :string,
-                         one_of: command_class_names,
-                         description: "Name of the next command to run to make progress " \
-                                      "towards accomplishing the mission"
-
-            klass
-          end
-        end
+      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
 
-      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."
+      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

data/src/foobara/agent/determine_next_command_name_and_inputs.rb

@@ -14,7 +14,6 @@ module Foobara
                                  "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",
@@ -25,6 +24,10 @@ module Foobara
         command_name :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

@@ -6,8 +6,10 @@ module Foobara
       class << self
         attr_accessor :command_class
 
-        def for(result_type:, agent_id:)
-          cached_subclass([result_type, agent_id]) do
+        def for(agent_id: nil, result_type: nil, include_message_to_user_in_result: true)
+          agent_id ||= "Anon#{SecureRandom.hex(2)}"
+
+          cached_subclass([result_type, agent_id, include_message_to_user_in_result]) do
             command_name = "Foobara::Agent::#{agent_id}::NotifyUserThatCurrentGoalHasBeenAccomplished"
             klass = Util.make_class_p(command_name, self)
 
@@ -16,32 +18,50 @@ module Foobara
                               "result schema and an optional message to the user. " \
                               "The user might issue a new goal."
 
-            inputs do
-              command_connector CommandConnector, :required, "Connector to notify user through"
-              message_to_user :string, :required, "Message to the user about what was done"
-            end
-
             if result_type
-              add_inputs do
-                result_data result_type, :required
+              if include_message_to_user_in_result
+                klass.add_inputs do
+                  result result_type, :required
+                  message_to_user :string, :required, "Message to the user about what was done"
+                end
+
+                klass.result do
+                  result result_type, :required
+                  message_to_user :string, :required, "Message to the user about what was done"
+                end
+
+                klass.description "Notifies the user that the current goal has been accomplished and returns a final " \
+                                  "result formatted according to the " \
+                                  "result schema and a message to the user. " \
+                                  "The user might issue a new goal."
+              else
+                klass.add_inputs do
+                  result result_type, :required
+                end
+
+                klass.result result_type
+
+                klass.description "Notifies the user that the current goal has been accomplished and returns a final " \
+                                  "result formatted according to the " \
+                                  "result schema. " \
+                                  "The user might issue a new goal."
+              end
+            elsif include_message_to_user_in_result
+              klass.add_inputs do
+                message_to_user :string, :required, "Message to the user about what was done"
               end
 
               klass.result do
-                message_to_user :string, :required
-                result_data result_type, :required
+                message_to_user :string, :required, "Message to the user about what was done"
               end
-              klass.description "Notifies the user that the current goal has been accomplished and 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 "Notifies the user that the current goal has been accomplished and results in a " \
+                                "message to the user. " \
+                                "The user might issue a new goal."
             else
-              # TODO: test this code path
+              # This should be unreachable actually
               # :nocov:
-              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. " \
+              klass.description "Notifies the user that the current goal has been accomplished. " \
                                 "The user might issue a new goal."
               # :nocov:
             end
@@ -55,10 +75,7 @@ module Foobara
                   "result schema if relevant and an optional message to the user."
 
       inputs do
-        # TODO: Are we still not able to uses classes as foobara types??
-        command_connector :duck, :required, "Connector to end"
-        message_to_user :string, :required, "Message to the user about what was done"
-        result_data :duck, "The final result of the work if relevant/expected"
+        command_connector CommandConnector, :required, "Connector to notify user through"
       end
 
       def execute
@@ -68,21 +85,18 @@ module Foobara
       end
 
       def mark_mission_accomplished
-        data = if result_type
-                 inputs[:result_data]
-               end
-
-        command_connector.mark_mission_accomplished(data, message_to_user)
+        command_connector.mark_mission_accomplished(inputs[:result], inputs[:message_to_user])
       end
 
       def parsed_result
-        h = { message_to_user: }
+        inputs_type = self.class.inputs_type
+        element_types = inputs_type.element_types
 
-        if inputs[:result_data] && result_type
-          h[:result_data] = result_data
+        if element_types.key?(:message_to_user)
+          inputs.slice(:result, :message_to_user)
+        elsif element_types.key?(:result)
+          inputs[:result]
         end
-
-        h
       end
     end
   end

data/src/foobara/agent.rb

@@ -18,10 +18,12 @@ module Foobara
                   :llm_model,
                   :current_accomplish_goal_command,
                   :result_type,
+                  :include_message_to_user_in_result,
                   :agent_commands_connected,
                   :verbose,
                   :io_out,
-                  :io_err
+                  :io_err,
+                  :max_llm_calls_per_minute
 
     def initialize(
       context: nil,
@@ -29,27 +31,35 @@ module Foobara
       command_classes: nil,
       llm_model: nil,
       result_type: nil,
-      current_accomplish_goal_command: nil,
+      include_message_to_user_in_result: true,
       verbose: false,
       io_out: nil,
       io_err: nil,
+      max_llm_calls_per_minute: nil,
       **opts
     )
       # TODO: shouldn't have to pass command_log here since it has a default, debug that
       self.context = context
-      self.agent_name = agent_name if agent_name
+      self.agent_name = agent_name || "Anon#{SecureRandom.hex(2)}"
       self.llm_model = llm_model
       self.result_type = result_type
-      self.current_accomplish_goal_command = current_accomplish_goal_command
+      self.include_message_to_user_in_result = include_message_to_user_in_result
       self.verbose = verbose
       self.io_out = io_out
       self.io_err = io_err
-
-      unless opts.key?(:default_serializers)
-        opts = opts.merge(default_serializers: [
-                            Foobara::CommandConnectors::Serializers::ErrorsSerializer,
-                            Foobara::CommandConnectors::Serializers::AggregateSerializer
-                          ])
+      self.max_llm_calls_per_minute = max_llm_calls_per_minute
+
+      # unless opts.key?(:default_serializers)
+      #   opts = opts.merge(default_serializers: [
+      #                       Foobara::CommandConnectors::Serializers::ErrorsSerializer,
+      #                       Foobara::CommandConnectors::Serializers::AggregateSerializer
+      #                     ])
+      # end
+
+      unless opts.key?(:default_pre_commit_transformers)
+        opts = opts.merge(
+          default_pre_commit_transformers: Foobara::CommandConnectors::Transformers::LoadAtomsPreCommitTransformer
+        )
       end
 
       super(**opts)
@@ -72,9 +82,9 @@ module Foobara
       inputs_transformers = Util.array(inputs_transformers)
       inputs_transformers << CommandConnectors::Transformers::EntityToPrimaryKeyInputsTransformer
 
-      unless opts.key?(:aggregate_entities)
-        opts = opts.merge(aggregate_entities: true)
-      end
+      # unless opts.key?(:aggregate_entities)
+      #   opts = opts.merge(aggregate_entities: true)
+      # end
 
       super(*args, **opts.merge(inputs_transformers:))
     end
@@ -107,7 +117,8 @@ module Foobara
       goal,
       result_type: nil,
       choose_next_command_and_next_inputs_separately: nil,
-      maximum_call_count: nil
+      maximum_call_count: nil,
+      llm_model: nil
     )
       if result_type && self.result_type != result_type
         if self.result_type
@@ -123,6 +134,10 @@ module Foobara
         end
       end
 
+      unless agent_commands_connected?
+        connect_agent_commands
+      end
+
       state_machine.perform_transition!(:accomplish_goal)
 
       begin
@@ -130,12 +145,10 @@ module Foobara
           goal:,
           final_result_type: self.result_type,
           current_context: context,
-          existing_command_connector: self
+          agent: self
         }
 
-        if agent_name
-          inputs[:agent_name] = agent_name
-        end
+        llm_model ||= self.llm_model
 
         if llm_model
           inputs[:llm_model] = llm_model
@@ -161,14 +174,24 @@ module Foobara
           inputs[:io_err] = io_err
         end
 
+        if include_message_to_user_in_result || include_message_to_user_in_result == false
+          inputs[:include_message_to_user_in_result] = include_message_to_user_in_result
+        end
+
+        if max_llm_calls_per_minute && max_llm_calls_per_minute > 0
+          inputs[:max_llm_calls_per_minute] = max_llm_calls_per_minute
+        end
+
         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
+          transition = if outcome.success?
+                         :goal_accomplished
+                       else
+                         :goal_errored
+                       end
+
+          state_machine.perform_transition!(transition)
         end
       rescue
         # :nocov:
@@ -197,19 +220,21 @@ module Foobara
       agent_commands_connected
     end
 
-    def connect_agent_commands(final_result_type: nil, agent_name: nil)
+    def connect_agent_commands
       command_classes = [
         DescribeCommand,
         DescribeType,
         GiveUp,
-        ListCommands,
-        ListTypes
+        ListCommands
       ]
 
-      command_classes << if final_result_type
+      command_classes << if result_type || include_message_to_user_in_result
+                           # TODO: Support changing the final result type when the goal changes
                            NotifyUserThatCurrentGoalHasBeenAccomplished.for(
-                             result_type: final_result_type,
-                             agent_id: agent_name
+                             result_type:,
+                             agent_id: agent_name,
+                             # TODO: Support changing this flag when the goal changes
+                             include_message_to_user_in_result:
                            )
                          else
                            NotifyUserThatCurrentGoalHasBeenAccomplished

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-agent
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Miles Georgi
@@ -59,7 +59,6 @@ files:
 - 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

data/src/foobara/agent/list_types.rb

@@ -1,23 +0,0 @@
-module Foobara
-  class Agent < CommandConnector
-    class ListTypes < Foobara::Command
-      inputs do
-        command_connector :duck, :required, "Connector to fetch types from"
-      end
-
-      result [:string]
-
-      def execute
-        construct_type_list
-
-        type_list
-      end
-
-      attr_accessor :type_list
-
-      def construct_type_list
-        self.type_list = command_connector.all_exposed_type_names
-      end
-    end
-  end
-end