foobara-agent 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88347fd73d897f4a3f05eb2dcec999c5afddcec625cecc79a44a1a803394b352
-  data.tar.gz: '016936d6acc4e2497aa8e8853d058653d201d3d7d5c2c77090128b728f8833fe'
+  metadata.gz: 968399c2d338c8f069712d0ad9437b928fe48bc7356e88fd86b9ff6fb7ae235f
+  data.tar.gz: 8483b856faf2f559985550cc631764121797f88963c0baf428b7f16646bd8b59
 SHA512:
-  metadata.gz: 5672d6bd7930969b566d6dce04314062116593cd2df5c06d718916d83938deb91af64765a85752f7b5c8119d0fce32a56099907b252da636f0408fb3109bf38c
-  data.tar.gz: 71b2c350e024aca9d86c1f5f2bfd3d83726784ab028c6d7b6e0010a88512c1a06351cfbb298478fc1e5f6b5126367e9bca5d417040b9d493153fe7d142b20faa
+  metadata.gz: 79be2912847cb407d1ad65166313c8b799b981a2b0da6f8c8e3f8132049c1eb67ec56a9307fdf887f8e659299883f0da4517762abc885fdf8b69949f869f54de
+  data.tar.gz: 169c02a8070d5feb4d307b41ff757294ca5a2e3b810ac0766cece386a357db2cf85075ae9ecb1f5ee2e0b1ec92c855eb202ee4166102a88341b8e5b4268eeb92

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [0.0.7] - 2025-06-23
+
+- 
+
+## [0.0.6] - 2025-06-19
+
+- Do not run next command with pre-cast inputs
+- Make result_data and message_to_user required (probably unwise for message_to_user?)
+- Simulate ListCommands and DescribeCommand being at start
+- Add a verbose flag for debugging help
+- Give each AccomplishGoal its own command call count
+- Convert entities to their aggregates as input and primary keys as output
+
 ## [0.0.5] - 2025-05-30
 
 - Don't require agents to have a name

data/src/foobara/agent/accomplish_goal.rb

@@ -1,7 +1,6 @@
 require_relative "list_commands"
 
 module Foobara
-  # TODO: should agent maybe be a command connector? It feels a bit more like a command connector.
   class Agent < CommandConnector
     class AccomplishGoal < Foobara::Command
       possible_error :gave_up, context: { reason: :string }, message: "Gave up."
@@ -9,13 +8,14 @@ module Foobara
                      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"
-        existing_command_connector CommandConnector, :allow_nil,
-                                   "A connector containing already-connected commands for the agent to use"
+        include_message_to_user_in_result :boolean, default: true
+        verbose :boolean, default: false
+        io_out :duck
+        io_err :duck
+        agent Agent, :required
         current_context Context, :allow_nil, "The current context of the agent"
         maximum_command_calls :integer,
                               :allow_nil,
@@ -42,7 +42,7 @@ module Foobara
       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
 
@@ -51,19 +51,13 @@ 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_list_commands_run
+        simulate_describe_command_run_for_all_commands
 
         until mission_accomplished or given_up
+          increment_command_calls
           check_if_too_many_calls
+
           if choose_next_command_and_next_inputs_separately?
             determine_next_command_then_inputs_separately
           else
@@ -81,71 +75,43 @@ 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,
-                    :final_result, :final_message, :command_response, :delayed_command_name
-      attr_writer :command_connector
-
-      def agent_name
-        @agent_name ||= inputs[:agent_name] || "Anon#{SecureRandom.hex(2)}"
-      end
+                    :final_result, :final_message, :command_response, :delayed_command_name,
+                    :command_calls
 
       def build_initial_context_if_necessary
         # TODO: shouldn't have to pass command_log here since it has a default, debug that
         self.context = current_context || Context.new(command_log: [])
       end
 
-      def command_connector_passed_in?
-        existing_command_connector
-      end
+      def simulate_list_commands_run
+        return unless context.command_log.empty?
 
-      def command_connector
-        @command_connector ||= existing_command_connector
-      end
+        self.next_command_name = ListCommands.full_command_name
+        self.next_command_inputs = nil
+        fetch_next_command_class
 
-      # 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:
-        )
+        run_next_command
+        log_last_command_outcome
       end
 
-      def set_accomplished_goal_command
-        command_connector.current_accomplish_goal_command = self
-      end
+      def simulate_describe_command_run_for_all_commands
+        return if context.command_log.size > 1
 
-      def connect_agent_commands
-        command_connector.connect_agent_commands(final_result_type:, agent_name:)
-      end
+        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 }
+          fetch_next_command_class
 
-      def connect_user_provided_commands
-        command_classes.each do |command_class|
-          command_connector.connect(command_class)
+          run_next_command
+          log_last_command_outcome
         end
       end
 
       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:,
@@ -250,15 +216,9 @@ module Foobara
       def validate_next_command_inputs
         inputs_type = next_command_class.inputs_type
 
-        outcome = NestedTransactionable.with_needed_transactions_for_type(inputs_type) do
+        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
@@ -266,9 +226,7 @@ module Foobara
       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
+        self.next_command_name = if delayed_command_name
                                    name = delayed_command_name
                                    self.delayed_command_name = nil
                                    name
@@ -327,11 +285,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)
@@ -392,21 +350,42 @@ module Foobara
       end
 
       def run_next_command
-        self.command_response = command_connector.run(
+        if verbose?
+          (io_out || $stdout).puts "Running #{next_command_name} with #{next_command_inputs}"
+        end
+
+        self.command_response = agent.run(
           full_command_name: next_command_name,
           inputs: next_command_inputs,
           action: "run"
         )
 
         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
+            # :nocov:
+            (io_err || $stderr).puts(
+              "Command #{command_response.command.class.full_command_name} failed #{command_outcome.errors_hash}"
+            )
+            # :nocov:
+          end
+        end
       end
 
       def log_last_command_outcome
         log_command_outcome(command: command_response.command)
       end
 
+      def increment_command_calls
+        self.command_calls ||= -1
+        self.command_calls += 1
+      end
+
       def check_if_too_many_calls
-        if context.command_log.size > maximum_command_calls
+        if command_calls > maximum_command_calls
           add_runtime_error(
             :too_many_command_calls,
             "Too many command calls. " \
@@ -485,6 +464,14 @@ module Foobara
       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
     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, "Optional message to the user"
-            end
-
             if result_type
-              add_inputs do
-                result_data result_type
+              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
-                result_data result_type
+                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, "Optional message to the user"
-        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,7 +18,11 @@ module Foobara
                   :llm_model,
                   :current_accomplish_goal_command,
                   :result_type,
-                  :agent_commands_connected
+                  :include_message_to_user_in_result,
+                  :agent_commands_connected,
+                  :verbose,
+                  :io_out,
+                  :io_err
 
     def initialize(
       context: nil,
@@ -26,25 +30,34 @@ 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,
       **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::AtomicSerializer
+                            Foobara::CommandConnectors::Serializers::AggregateSerializer
                           ])
       end
 
       super(**opts)
 
+      # TODO: this should work now, switch to this approach
+      # add_default_inputs_transformer EntityToPrimaryKeyInputsTransformer
+
       build_initial_context
 
       # TODO: push this convenience method up into base class?
@@ -53,6 +66,20 @@ module Foobara
       end
     end
 
+    def connect(*args, **opts)
+      args, opts = desugarize_connect_args(args, opts)
+
+      inputs_transformers = opts[:inputs_transformers] || []
+      inputs_transformers = Util.array(inputs_transformers)
+      inputs_transformers << CommandConnectors::Transformers::EntityToPrimaryKeyInputsTransformer
+
+      unless opts.key?(:aggregate_entities)
+        opts = opts.merge(aggregate_entities: true)
+      end
+
+      super(*args, **opts.merge(inputs_transformers:))
+    end
+
     def run(*args, **)
       if args.first.is_a?(::String)
         accomplish_goal(*args, **)
@@ -81,7 +108,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
@@ -97,6 +125,10 @@ module Foobara
         end
       end
 
+      unless agent_commands_connected?
+        connect_agent_commands
+      end
+
       state_machine.perform_transition!(:accomplish_goal)
 
       begin
@@ -104,12 +136,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
@@ -123,14 +153,32 @@ module Foobara
           inputs[:maximum_command_calls] = maximum_call_count
         end
 
+        if verbose
+          inputs[:verbose] = verbose
+        end
+
+        if io_out
+          inputs[:io_out] = io_out
+        end
+
+        if io_err
+          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
+
         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:
@@ -159,19 +207,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.5
+  version: 0.0.7
 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
@@ -85,7 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: An agent that uses whatever Foobara commands you wish to accomplish goals
   of your choosing!

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