foobara-agent 0.0.9 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c086912a26df48a558f040a3b2e03138210674ec371f528437f08b007ba31783
-  data.tar.gz: 86315598bc4ca17d59cfc6e2d204561c2b387c0162a19601281f3825a7e68337
+  metadata.gz: 0e0f6302247bbcc56ed93f61ec3a5d39e5041029e03b20cadea2d1dd0ebd04b6
+  data.tar.gz: baca677e1ea555bcdc908fd2b37dc2d8b016df9888f8f7a69c8cff73774756b2
 SHA512:
-  metadata.gz: 2ce3b72dca0e4e111c8a68f61d9c80eeabbfcfd480d858ebeaa92b9e7cc4730fd4278654ce7b3ded885628297aa0eb8684ee73b7213559e9d9f93760a6c06086
-  data.tar.gz: 28c540d5663172ff9d15925f152357872576d96e275bb278edc5c6661c47dfbe9fc0832fec9268fe1b215dfaeb5d43d30eef422bc572dc4e9023e82cd77c3a79
+  metadata.gz: 350feb6d9058009889a342a5dcc4f44befed8a25be71ebc7673bf75b7ceb1f95adcec3a52d2eb53ba9301d0ef2312919a4496a53f2146423dd36c17b122856af
+  data.tar.gz: a91ec6608bc3001f06d3c17562321d2c1a52a537372347593293d57d9d6312126f5116853c8b32b649d7c65a050bbb67bd03b2dbc50247cdc7260013b6d8f3ec

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.0.11] - 2025-07-01
+
+- Fix some bugs with result type/value mismatches
+- Eliminate ability to select command and inputs separately
+
+## [0.0.10] - 2025-06-30
+
+- Allow more retries
+- Eliminate ability to select command and inputs separately
+
 ## [0.0.9] - 2025-06-28
 
 - Relocate some common Determine* behavior into a DetermineBase

data/lib/foobara/agent.rb

@@ -11,7 +11,6 @@ module Foobara
     class << self
       def reset_all
         [
-          DetermineInputsForNextCommand,
           NotifyUserThatCurrentGoalHasBeenAccomplished
         ].each do |command_class|
           command_class.clear_subclass_cache
@@ -23,4 +22,4 @@ module Foobara
 end
 
 Foobara::Util.require_directory "#{__dir__}/../../src"
-Foobara::Monorepo.project "agent", project_path: "#{__dir__}/../../"
+Foobara.project "agent", project_path: "#{__dir__}/../../"

data/src/foobara/agent/accomplish_goal.rb

@@ -29,12 +29,6 @@ module Foobara
                   one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
                   default: "claude-3-7-sonnet-20250219",
                   description: "The model to use for the LLM"
-        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
 
@@ -56,15 +50,10 @@ module Foobara
 
           throttle_llm_calls_if_necessary
 
-          if choose_next_command_and_next_inputs_separately?
-            determine_next_command_then_inputs_separately
-          else
-            determine_next_command_and_inputs
-          end
-
+          determine_next_command_and_inputs
           run_next_command
+
           log_last_command_outcome
-          compact_command_log
         end
 
         if given_up
@@ -138,7 +127,24 @@ module Foobara
         # :nocov:
       end
 
-      def determine_next_command_and_inputs(retries = 2)
+      def determine_next_command_and_inputs(retries = 3, error_outcome = nil)
+        if retries == 0
+          # TODO: test this path by irreparably breaking the needed commands
+          # :nocov:
+          self.next_command_name = GiveUp.full_command_name
+          self.next_command_inputs = {
+            message_to_user: "While trying to choose the next command and inputs, " \
+                             "I've ran into an error several times that I couldn't figure out how to get past. " \
+                             "The last error looked like this:\n#{error_outcome.errors_hash}"
+          }
+          self.next_command_raw_inputs = next_command_inputs
+
+          return
+          # :nocov:
+        end
+
+        compact_command_log
+
         inputs_for_determine = {
           context:,
           llm_model:
@@ -156,7 +162,7 @@ module Foobara
         end
 
         if outcome.success?
-          self.next_command_name = outcome.result[:command_name]
+          self.next_command_name = outcome.result[:command]
           self.next_command_inputs = outcome.result[:inputs]
           self.next_command_raw_inputs = next_command_inputs
 
@@ -176,7 +182,8 @@ module Foobara
                 )
 
                 simulate_describe_command
-                determine_next_command_inputs
+
+                determine_next_command_and_inputs(retries - 1, outcome)
               end
             else
               self.next_command_inputs = {}
@@ -190,11 +197,7 @@ module Foobara
               result: nil
             )
 
-            if retries > 0
-              determine_next_command_and_inputs(retries - 1)
-            else
-              determine_next_command_then_inputs_separately
-            end
+            determine_next_command_and_inputs(retries - 1, outcome)
           end
         else
           log_command_outcome(
@@ -204,23 +207,7 @@ module Foobara
             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
+          determine_next_command_and_inputs(retries - 1, outcome)
         end
       end
 
@@ -259,74 +246,6 @@ module Foobara
         @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 delayed_command_name
-                                   name = delayed_command_name
-                                   self.delayed_command_name = nil
-                                   name
-                                 else
-                                   inputs = { context: }
-                                   if llm_model
-                                     inputs[:llm_model] = llm_model
-                                   end
-
-                                   command = DetermineNextCommand.new(inputs)
-                                   outcome = begin
-                                     record_llm_call_timestamp
-                                     command.run
-                                   rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
-                                     # :nocov:
-                                     Outcome.errors(e.errors)
-                                     # :nocov:
-                                   end
-
-                                   if outcome.success?
-                                     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:,
-                                         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
-                                     # :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
-
-      def choose_describe_command_instead
-        self.delayed_command_name = next_command_name
-        self.next_command_inputs = { command_name: next_command_name }
-        self.next_command_name = DescribeCommand.full_command_name
-      end
-
       def all_command_classes
         @all_command_classes ||= run_subcommand!(ListCommands, command_connector: agent).values.flatten
       end
@@ -335,58 +254,11 @@ module Foobara
         self.next_command_class = agent.transformed_command_from_name(next_command_name)
       end
 
-      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 = { context: }
-                                     if llm_model
-                                       inputs[:llm_model] = llm_model
-                                     end
-
-                                     command = command_class.new(inputs)
-                                     outcome = begin
-                                       record_llm_call_timestamp
-                                       command.run
-                                     rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
-                                       # :nocov:
-                                       Outcome.errors(e.errors)
-                                       # :nocov:
-                                     end
-
-                                     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_name: next_command_name,
-                                         inputs: command.raw_result,
-                                         outcome:
-                                       )
-
-                                       simulate_describe_command
-
-                                       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
         if verbose?
           args = if next_command_inputs.nil? || next_command_inputs.empty?
@@ -402,6 +274,7 @@ module Foobara
                      # :nocov:
                    end
                  end
+
           (io_out || $stdout).puts "#{next_command_name}.run#{args}"
         end
 
@@ -431,8 +304,8 @@ module Foobara
       def compact_command_log
         # Rules:
         # Delete errors for any command that has succeeded since
-        # Delete all but the last DescribeCommand call
-        describe_command_call_indexes = []
+        # Delete all but the last DescribeCommand call for a given
+        describe_command_call_indexes = {}
         commands = {}
 
         describe_command_name = DescribeCommand.full_command_name
@@ -440,7 +313,12 @@ module Foobara
           command_name = command_log_entry.command_name
 
           if command_name == describe_command_name
-            describe_command_call_indexes << index
+            described_command = command_log_entry.inputs[:command_name]
+
+            if command_log_entry.outcome[:success]
+              describe_command_call_indexes[described_command] ||= []
+              describe_command_call_indexes[described_command] << index
+            end
           end
 
           commands[command_name] ||= [[], []]
@@ -448,7 +326,11 @@ module Foobara
           commands[command_name][bucket_index] << index
         end
 
-        indexes_to_delete = describe_command_call_indexes[0..-2]
+        indexes_to_delete = []
+
+        describe_command_call_indexes.each_value do |indexes|
+          indexes_to_delete += indexes[0..-2]
+        end
 
         commands.each_value do |(success_indexes, failure_indexes)|
           last_success = success_indexes.last
@@ -548,10 +430,6 @@ module Foobara
         }
       end
 
-      def command_described?
-        described_commands.include?(next_command_name)
-      end
-
       def described_commands
         @described_commands ||= Set.new
       end
@@ -560,14 +438,6 @@ module Foobara
         type.extends_type?(BuiltinTypes[:attributes]) && type.element_types.empty?
       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
@@ -596,7 +466,7 @@ module Foobara
         first_to_expire = calls.first
 
         if first_to_expire
-          (first_to_expire + SECONDS_PER_MINUTE) - Time.now
+          [0, (first_to_expire + SECONDS_PER_MINUTE) - Time.now].max
         else
           # TODO: figure out how to test this code path
           # :nocov:

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

@@ -13,7 +13,9 @@ module Foobara
 
         def cached_subclass(key)
           if subclass_cache.key?(key)
+            # :nocov:
             subclass_cache[key]
+            # :nocov:
           else
             subclass_cache[key] = yield
           end

data/src/foobara/agent/determine_next_command_name_and_inputs.rb

@@ -9,7 +9,7 @@ module Foobara
                   "NotifyUserThatCurrentGoalHasBeenAccomplished command."
 
       result do
-        command_name :string, :required
+        command :string, :required
         inputs :attributes, :allow_nil
       end
     end

data/src/foobara/agent/notify_user_that_current_goal_has_been_accomplished.rb

@@ -4,7 +4,7 @@ module Foobara
       extend Concerns::SubclassCacheable
 
       class << self
-        attr_accessor :command_class
+        attr_accessor :command_class, :returns_message_to_user, :returns_result_data, :result_is_attributes
 
         def for(agent_id: nil, result_type: nil, include_message_to_user_in_result: true)
           agent_id ||= "Anon#{SecureRandom.hex(2)}"
@@ -19,24 +19,36 @@ module Foobara
                               "The user might issue a new goal."
 
             if result_type
+              klass.returns_result_data = true
+
+              # TODO: fix this... agent backed command sets these via its own result type.
+              # check if message_to_user is already here and also search/fix result_data to be result for consistency.
               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.returns_message_to_user = true
 
                 klass.result do
                   result result_type, :required
                   message_to_user :string, :required, "Message to the user about what was done"
                 end
 
+                klass.add_inputs klass.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 and a message to the user. " \
                                   "The user might issue a new goal."
               else
-                klass.add_inputs do
-                  result result_type, :required
+                unless result_type.is_a?(Types::Type)
+                  result_type = Domain.current.foobara_type_from_declaration(result_type)
+                end
+
+                if result_type.extends?(BuiltinTypes[:attributes])
+                  klass.result_is_attributes = true
+                  klass.add_inputs result_type
+                else
+                  klass.add_inputs do
+                    result result_type, :required
+                  end
                 end
 
                 klass.result result_type
@@ -47,6 +59,8 @@ module Foobara
                                   "The user might issue a new goal."
               end
             elsif include_message_to_user_in_result
+              klass.returns_message_to_user = true
+
               klass.add_inputs do
                 message_to_user :string, :required, "Message to the user about what was done"
               end
@@ -79,24 +93,46 @@ module Foobara
       end
 
       def execute
+        build_result
         mark_mission_accomplished
 
-        parsed_result
+        built_result
       end
 
+      attr_accessor :built_result
+
       def mark_mission_accomplished
-        command_connector.mark_mission_accomplished(inputs[:result], inputs[:message_to_user])
+        result, message_to_user = if returns_message_to_user?
+                                    [built_result[:result], built_result[:message_to_user]]
+                                  elsif returns_result_data?
+                                    [built_result, nil]
+                                  end
+
+        command_connector.mark_mission_accomplished(result, message_to_user)
       end
 
-      def parsed_result
-        inputs_type = self.class.inputs_type
-        element_types = inputs_type.element_types
+      def build_result
+        self.built_result = if returns_message_to_user?
+                              inputs.slice(:result, :message_to_user)
+                            elsif returns_result_data?
+                              if result_is_attributes?
+                                inputs.slice(*self.class.result_type.element_types.keys)
+                              else
+                                inputs[:result]
+                              end
+                            end
+      end
 
-        if element_types.key?(:message_to_user)
-          inputs.slice(:result, :message_to_user)
-        elsif element_types.key?(:result)
-          inputs[:result]
-        end
+      def returns_message_to_user?
+        self.class.returns_message_to_user
+      end
+
+      def returns_result_data?
+        self.class.returns_result_data
+      end
+
+      def result_is_attributes?
+        self.class.result_is_attributes
       end
     end
   end

data/src/foobara/agent.rb

@@ -41,7 +41,7 @@ module Foobara
       # TODO: shouldn't have to pass command_log here since it has a default, debug that
       self.context = context
       self.agent_name = agent_name || "Anon#{SecureRandom.hex(2)}"
-      self.llm_model = llm_model
+      self.llm_model = llm_model || "claude-opus-4-20250514"
       self.result_type = result_type
       self.include_message_to_user_in_result = include_message_to_user_in_result
       self.verbose = verbose
@@ -114,7 +114,6 @@ module Foobara
     def accomplish_goal(
       goal,
       result_type: nil,
-      choose_next_command_and_next_inputs_separately: nil,
       maximum_call_count: nil,
       llm_model: nil
     )
@@ -154,10 +153,6 @@ module Foobara
           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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-agent
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.11
 platform: ruby
 authors:
 - Miles Georgi
@@ -55,8 +55,6 @@ files:
 - src/foobara/agent/describe_command.rb
 - src/foobara/agent/describe_type.rb
 - src/foobara/agent/determine_base.rb
-- src/foobara/agent/determine_inputs_for_next_command.rb
-- src/foobara/agent/determine_next_command.rb
 - src/foobara/agent/determine_next_command_name_and_inputs.rb
 - src/foobara/agent/give_up.rb
 - src/foobara/agent/list_commands.rb

data/src/foobara/agent/determine_inputs_for_next_command.rb

@@ -1,33 +0,0 @@
-module Foobara
-  class Agent < CommandConnector
-    class DetermineInputsForNextCommand < DetermineBase
-      extend Concerns::SubclassCacheable
-
-      class << self
-        def for(command_class:, agent_id:)
-          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.description "Returns the inputs for " \
-                              "the next #{command_class.full_command_name} command to run."
-
-            if command_class.inputs_type.nil? || command_class.inputs_type.element_types.empty?
-              # :nocov:
-              raise ArgumentError, "command #{command_class.full_command_name} has no inputs"
-              # :nocov:
-            end
-
-            transformer = CommandConnectors::Transformers::EntityToPrimaryKeyInputsTransformer.new(
-              to: command_class.inputs_type
-            )
-            klass.result transformer.from_type
-
-            klass
-          end
-        end
-      end
-    end
-  end
-end

data/src/foobara/agent/determine_next_command.rb

@@ -1,13 +0,0 @@
-module Foobara
-  class Agent < CommandConnector
-    class DetermineNextCommand < DetermineBase
-      description "Returns the name of the next command to run given the progress  " \
-                  "towards accomplishing the current goal. " \
-                  "If the goal has been accomplished it will choose the " \
-                  "NotifyUserThatCurrentGoalHasBeenAccomplished command."
-
-      result :string,
-             description: "Name of the next command to run"
-    end
-  end
-end