foobara-agent 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88347fd73d897f4a3f05eb2dcec999c5afddcec625cecc79a44a1a803394b352
-  data.tar.gz: '016936d6acc4e2497aa8e8853d058653d201d3d7d5c2c77090128b728f8833fe'
+  metadata.gz: 121474f4e61c1b3a5eebc883794bef41159d48ecc05eba44165bd8d79111c426
+  data.tar.gz: 50bc4c4aea5bd447f17cf39712b7a86295e4f45708602398f72a61af2f221881
 SHA512:
-  metadata.gz: 5672d6bd7930969b566d6dce04314062116593cd2df5c06d718916d83938deb91af64765a85752f7b5c8119d0fce32a56099907b252da636f0408fb3109bf38c
-  data.tar.gz: 71b2c350e024aca9d86c1f5f2bfd3d83726784ab028c6d7b6e0010a88512c1a06351cfbb298478fc1e5f6b5126367e9bca5d417040b9d493153fe7d142b20faa
+  metadata.gz: e0cbf20f7fc287bd4a3be5caed0572de59475493ae4bed80d755b5284ead25fa697b455959ca323891bb20f0bfb57a5a01f1e62f335faacc6c99c220821920f3
+  data.tar.gz: cf85ac42b6ab4a9f8efddd35e533afd32f664b9a9ec8bba17f77abf424a5499e64ba6ad576b54bb24c03dadb5e6bc1c2fe54a502bd505f30caaeeb15e002d655

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [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."
@@ -14,6 +13,9 @@ module Foobara
         # 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"
+        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"
         current_context Context, :allow_nil, "The current context of the agent"
@@ -62,8 +64,13 @@ module Foobara
           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
@@ -95,7 +102,8 @@ module Foobara
 
       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
+                    :final_result, :final_message, :command_response, :delayed_command_name,
+                    :command_calls
       attr_writer :command_connector
 
       def agent_name
@@ -107,6 +115,32 @@ module Foobara
         self.context = current_context || Context.new(command_log: [])
       end
 
+      def simulate_list_commands_run
+        return unless context.command_log.empty?
+
+        self.next_command_name = ListCommands.full_command_name
+        self.next_command_inputs = nil
+        fetch_next_command_class
+
+        run_next_command
+        log_last_command_outcome
+      end
+
+      def simulate_describe_command_run_for_all_commands
+        return if context.command_log.size > 1
+
+        ListCommands.run!(command_connector:)[: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
+
+          run_next_command
+          log_last_command_outcome
+        end
+      end
+
       def command_connector_passed_in?
         existing_command_connector
       end
@@ -120,7 +154,9 @@ module Foobara
       def build_command_connector
         self.command_connector ||= Agent.new(
           current_accomplish_goal_command: self,
-          llm_model:
+          llm_model:,
+          verbose:,
+          io_out:
         )
       end
 
@@ -139,13 +175,6 @@ module Foobara
       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 +279,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 +289,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
@@ -392,6 +413,10 @@ module Foobara
       end
 
       def run_next_command
+        if verbose?
+          (io_out || $stdout).puts "Running #{next_command_name} with #{next_command_inputs}"
+        end
+
         self.command_response = command_connector.run(
           full_command_name: next_command_name,
           inputs: next_command_inputs,
@@ -399,14 +424,31 @@ 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
+            # :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 +527,10 @@ module Foobara
       def choose_next_command_and_next_inputs_separately?
         choose_next_command_and_next_inputs_separately
       end
+
+      def verbose?
+        verbose
+      end
     end
   end
 end

data/src/foobara/agent/notify_user_that_current_goal_has_been_accomplished.rb

@@ -18,17 +18,17 @@ module Foobara
 
             inputs do
               command_connector CommandConnector, :required, "Connector to notify user through"
-              message_to_user :string, "Optional message to the user"
+              message_to_user :string, :required, "Message to the user about what was done"
             end
 
             if result_type
               add_inputs do
-                result_data result_type
+                result_data result_type, :required
               end
 
               klass.result do
-                message_to_user :string
-                result_data result_type
+                message_to_user :string, :required
+                result_data result_type, :required
               end
               klass.description "Notifies the user that the current goal has been accomplished and returns a final " \
                                 "result formatted according to the " \
@@ -57,7 +57,7 @@ module Foobara
       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"
+        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"
       end
 

data/src/foobara/agent.rb

@@ -18,7 +18,10 @@ module Foobara
                   :llm_model,
                   :current_accomplish_goal_command,
                   :result_type,
-                  :agent_commands_connected
+                  :agent_commands_connected,
+                  :verbose,
+                  :io_out,
+                  :io_err
 
     def initialize(
       context: nil,
@@ -27,6 +30,9 @@ module Foobara
       llm_model: nil,
       result_type: nil,
       current_accomplish_goal_command: nil,
+      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
@@ -35,16 +41,22 @@ module Foobara
       self.llm_model = llm_model
       self.result_type = result_type
       self.current_accomplish_goal_command = current_accomplish_goal_command
+      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 +65,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, **)
@@ -123,6 +149,18 @@ 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
+
         self.current_accomplish_goal_command = AccomplishGoal.new(inputs)
 
         current_accomplish_goal_command.run.tap do |outcome|

metadata

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