foobara-agent 0.0.10 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c8f095d06fb173bc816e83f19755cfe246f15bf2b8ef1f8f91bce08e5960e74
-  data.tar.gz: 15b48a59c43c909070f68bbc58c68ce02635d019f9d3af68f1c3aa4264cd4903
+  metadata.gz: dc4b3804b5930b121fdc679ecf203b9e8b4d11122d24da967cfbfd10a1e6562d
+  data.tar.gz: '0739391b9b59d453783756a8efed38ec3d559ce7636873776ee71a14027059b5'
 SHA512:
-  metadata.gz: f558c74920f9759a98b2605fe2dcbbc52678ff5d90a0977182a75d0949cfd400b07d3d17d4dbfe162b37a3f463c3c55b4e25dee6382f2daeb3256b5df9615f73
-  data.tar.gz: f0588e94676e579c1fd5d7b3b603452d0c283b2b14217511b74a8d341d3126ff42cf7d0cb1cc881048d356525c7b9250f73c1a7631dae556a589f23b8627e1f8
+  metadata.gz: 0ff04dba39a3edae5a80a98234cd7708c2f90d30bded9f12a0e2b665ea640c302e1ed14c607d61533daa5a0b3d7712684d92de740a3f3e085a1704286f95b837
+  data.tar.gz: 252b0f1a1c298bd984a856f4e63e57808b63cace046d58cf82f8c55f391c6d21fb3d98b8dda869582aa995eb6438a2fe998bae3952c5f6791eca00d25c5d181c

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [0.0.13] - 2025-07-06
+
+- Eliminate NotifyUser... result_type to save tokens/improve accuracy
+- Choose DescribeCommand for commands with inputs that haven't been described
+- Log failure output when trying to determine commands/inputs
+
+## [0.0.12] - 2025-07-05
+
+- Choose DescribeCommand for commands that have inputs and haven't been described
+- Log determine command/input failures when verbose
+
+## [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

data/lib/foobara/agent.rb

@@ -22,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

@@ -30,6 +30,7 @@ module Foobara
                   default: "claude-3-7-sonnet-20250219",
                   description: "The model to use for the LLM"
         max_llm_calls_per_minute :integer, :allow_nil
+        result_entity_depth :symbol, :allow_nil, one_of: [:atom, :aggregate]
       end
 
       result do
@@ -51,9 +52,8 @@ module Foobara
           throttle_llm_calls_if_necessary
 
           determine_next_command_and_inputs
-          run_next_command
 
-          log_last_command_outcome
+          run_next_command
         end
 
         if given_up
@@ -75,7 +75,6 @@ module Foobara
         fetch_next_command_class
 
         run_next_command
-        log_last_command_outcome
       end
 
       def simulate_describe_list_commands_command
@@ -85,7 +84,6 @@ module Foobara
         fetch_next_command_class
 
         run_next_command
-        log_last_command_outcome
       end
 
       def simulate_describe_command(command_name = next_command_name)
@@ -100,7 +98,6 @@ module Foobara
         fetch_next_command_class
 
         run_next_command
-        log_last_command_outcome
 
         self.next_command_name = old_next_command_name
         self.next_command_inputs = old_next_command_inputs
@@ -114,7 +111,7 @@ module Foobara
         return if context.command_log.size > 1
 
         ListCommands.run!(command_connector: agent)[:user_provided_commands].each do |full_command_name|
-          next if described_commands.include?(full_command_name)
+          next if command_described?(full_command_name)
 
           self.next_command_name = DescribeCommand.full_command_name
           self.next_command_inputs = { command_name: full_command_name }
@@ -122,7 +119,6 @@ module Foobara
           fetch_next_command_class
 
           run_next_command
-          log_last_command_outcome
         end
         # :nocov:
       end
@@ -145,11 +141,7 @@ module Foobara
 
         compact_command_log
 
-        inputs_for_determine = {
-          context:,
-          llm_model:
-        }
-
+        inputs_for_determine = { context:, llm_model: }
         determine_command = DetermineNextCommandNameAndInputs.new(inputs_for_determine)
 
         outcome = begin
@@ -171,10 +163,17 @@ module Foobara
           if outcome.success?
             fetch_next_command_class
 
+            if need_to_describe_next_command?
+              simulate_describe_command
+              return determine_next_command_and_inputs(retries, outcome)
+            end
+
             if next_command_has_inputs?
               outcome = validate_next_command_inputs
 
               unless outcome.success?
+                # TODO: test this path
+                # :nocov:
                 log_command_outcome(
                   command_name: next_command_name,
                   inputs: next_command_inputs,
@@ -184,6 +183,7 @@ module Foobara
                 simulate_describe_command
 
                 determine_next_command_and_inputs(retries - 1, outcome)
+                # :nocov:
               end
             else
               self.next_command_inputs = {}
@@ -260,23 +260,7 @@ module Foobara
       end
 
       def run_next_command
-        if verbose?
-          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
+        log_command_code(command_name: next_command_name, inputs: next_command_inputs)
 
         self.command_response = agent.run(
           full_command_name: next_command_name,
@@ -286,19 +270,7 @@ module Foobara
 
         self.command_outcome = command_response.outcome
 
-        if verbose?
-          unless command_outcome.success?
-            # :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)
+        log_command_outcome(command: command_response.command, log_command_code: false)
       end
 
       def compact_command_log
@@ -337,13 +309,14 @@ module Foobara
           next unless last_success
 
           failure_indexes.each do |failure_index|
+            # TODO: test this path
+            # :nocov:
             if failure_index < last_success
               indexes_to_delete << failure_index
             else
-              # :nocov:
               break
-              # :nocov:
             end
+            # :nocov:
           end
         end
 
@@ -377,7 +350,12 @@ module Foobara
         end
       end
 
-      def log_command_outcome(command: nil, command_name: nil, inputs: nil, outcome: nil, result: nil)
+      def log_command_outcome(command: nil,
+                              command_name: nil,
+                              inputs: nil,
+                              outcome: nil,
+                              result: nil,
+                              log_command_code: true)
         if command
           command_name ||= command.class.full_command_name
           inputs ||= command.raw_inputs
@@ -405,6 +383,43 @@ module Foobara
         )
 
         context.command_log << log_entry
+
+        if verbose?
+          if log_command_code
+            # TODO: test this code path hmmm
+            # :nocov:
+            self.log_command_code(command_name:, inputs:)
+            # :nocov:
+          end
+
+          unless log_entry.success?
+            # :nocov:
+            (io_err || $stderr).puts(
+              "Command #{log_entry.command_name} failed:\n#{log_entry.errors_hash}"
+            )
+            # :nocov:
+          end
+        end
+      end
+
+      def log_command_code(command_name:, inputs:)
+        if verbose?
+          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
       end
 
       # TODO: these are awkwardly called from outside. Come up with a better solution.
@@ -442,6 +457,20 @@ module Foobara
         verbose
       end
 
+      def need_to_describe_next_command?
+        return false if command_described?(next_command_name)
+        return false if next_command_name == DescribeCommand.full_command_name
+        return true if next_command_has_inputs?
+
+        # check if inputs were unexpectedly given for a command that doesn't need them,
+        # in which case we should describe it
+        next_command_inputs && !next_command_inputs.empty?
+      end
+
+      def command_described?(command_name)
+        described_commands.include?(command_name)
+      end
+
       def llm_call_timestamps
         @llm_call_timestamps ||= []
       end

data/src/foobara/agent/notify_user_that_current_goal_has_been_accomplished.rb

@@ -1,15 +1,18 @@
 module Foobara
   class Agent < CommandConnector
+    # NOTE: we intentionally don't use a result type here
+    # to reduce tokens the LLM has to deal with when this command is described
     class NotifyUserThatCurrentGoalHasBeenAccomplished < Foobara::Command
       extend Concerns::SubclassCacheable
 
       class << self
-        attr_accessor :command_class
+        attr_accessor :command_class, :returns_message_to_user, :returns_result_data, :result_is_attributes,
+                      :built_result_type
 
-        def for(agent_id: nil, result_type: nil, include_message_to_user_in_result: true)
+        def for(agent_id: nil, result_type: nil, include_message_to_user_in_result: true, result_entity_depth: nil)
           agent_id ||= "Anon#{SecureRandom.hex(2)}"
 
-          cached_subclass([result_type, agent_id, include_message_to_user_in_result]) do
+          cached_subclass([agent_id]) do
             command_name = "Foobara::Agent::#{agent_id}::NotifyUserThatCurrentGoalHasBeenAccomplished"
             klass = Util.make_class_p(command_name, self)
 
@@ -19,41 +22,50 @@ module Foobara
                               "The user might issue a new goal."
 
             if result_type
+              klass.returns_result_data = true
+              unless result_type.is_a?(Types::Type)
+                result_type = Domain.current.foobara_type_from_declaration(result_type)
+              end
+
+              domain = result_type.created_in_namespace.foobara_domain
+
               # 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
+                klass.built_result_type = domain.foobara_type_from_declaration do
                   result result_type, :required
                   message_to_user :string, :required, "Message to the user about what was done"
                 end
 
+                klass.add_inputs klass.built_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
+                if result_type.extends?(BuiltinTypes[:attributes])
+                  klass.built_result_type = result_type
+                  klass.result_is_attributes = true
+                  klass.add_inputs result_type
+                else
+                  klass.built_result_type = domain.foobara_type_from_declaration do
+                    result result_type, :required
+                  end
+                  klass.add_inputs klass.built_result_type
                 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.returns_message_to_user = true
 
-              klass.result do
+              klass.add_inputs do
                 message_to_user :string, :required, "Message to the user about what was done"
               end
 
@@ -68,9 +80,46 @@ module Foobara
               # :nocov:
             end
 
+            apply_result_data_transformer(klass, result_entity_depth)
+
             klass
           end
         end
+
+        def result_data_transformer(result_entity_depth)
+          if result_entity_depth
+            case result_entity_depth
+            when AssociationDepth::AGGREGATE
+              CommandConnectors::Transformers::LoadAggregatesTransformer
+            when AssociationDepth::ATOM
+              CommandConnectors::Transformers::LoadAtomsTransformer
+            else
+              # :nocov:
+              raise "Unsupported result entity depth: #{result_entity_depth}"
+              # :nocov:
+            end&.instance
+          end
+        end
+
+        def apply_result_data_transformer(command_klass, result_entity_depth)
+          transformer = result_data_transformer(result_entity_depth)
+          return unless transformer
+
+          inputs_type = command_klass.inputs_type
+          return unless inputs_type
+
+          if inputs_type.extends?(BuiltinTypes[:detached_entity]) ||
+             DetachedEntity.contains_associations?(inputs_type)
+            command_klass.before_commit_transaction do |command:, **|
+              # TODO: why can't we just pass in the command??
+              built_result = command.built_result
+
+              if built_result
+                transformer.process_value!(built_result)
+              end
+            end
+          end
+        end
       end
 
       description "Ends the session giving a final result formatted according to the " \
@@ -81,24 +130,46 @@ module Foobara
       end
 
       def execute
+        build_result
         mark_mission_accomplished
 
-        parsed_result
+        nil
       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.built_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/types/command_log_entry.rb

@@ -11,6 +11,17 @@ module Foobara
           errors_hash :duck, "Errors that occurred during the command"
         end
       end
+
+      def success?
+        outcome[:success]
+      end
+
+      def errors_hash
+        # TODO: test this path
+        # :nocov:
+        outcome[:errors_hash]
+        # :nocov:
+      end
     end
   end
 end

data/src/foobara/agent.rb

@@ -23,7 +23,8 @@ module Foobara
                   :verbose,
                   :io_out,
                   :io_err,
-                  :max_llm_calls_per_minute
+                  :max_llm_calls_per_minute,
+                  :result_entity_depth
 
     def initialize(
       context: nil,
@@ -36,18 +37,20 @@ module Foobara
       io_out: nil,
       io_err: nil,
       max_llm_calls_per_minute: nil,
+      result_entity_depth: AssociationDepth::AGGREGATE,
       **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 || "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
       self.io_out = io_out
       self.io_err = io_err
       self.max_llm_calls_per_minute = max_llm_calls_per_minute
+      self.result_entity_depth = result_entity_depth
 
       # unless opts.key?(:default_serializers)
       #   opts = opts.merge(default_serializers: [
@@ -140,42 +143,7 @@ module Foobara
       state_machine.perform_transition!(:accomplish_goal)
 
       begin
-        inputs = {
-          goal:,
-          final_result_type: self.result_type,
-          context:,
-          agent: self
-        }
-
-        llm_model ||= self.llm_model
-
-        if llm_model
-          inputs[:llm_model] = llm_model
-        end
-
-        unless maximum_call_count.nil?
-          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
-
-        if max_llm_calls_per_minute && max_llm_calls_per_minute > 0
-          inputs[:max_llm_calls_per_minute] = max_llm_calls_per_minute
-        end
+        inputs = accomplish_goal_inputs(goal, result_type:, maximum_call_count:, llm_model:)
 
         self.current_accomplish_goal_command = AccomplishGoal.new(inputs)
 
@@ -196,6 +164,54 @@ module Foobara
       end
     end
 
+    def accomplish_goal_inputs(goal,
+                               result_type: nil,
+                               maximum_call_count: nil,
+                               llm_model: nil)
+      inputs = {
+        goal:,
+        final_result_type: self.result_type,
+        context:,
+        agent: self
+      }
+
+      llm_model ||= self.llm_model
+
+      if llm_model
+        inputs[:llm_model] = llm_model
+      end
+
+      unless maximum_call_count.nil?
+        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
+
+      if max_llm_calls_per_minute && max_llm_calls_per_minute > 0
+        inputs[:max_llm_calls_per_minute] = max_llm_calls_per_minute
+      end
+
+      if result_entity_depth
+        inputs[:result_entity_depth] = result_entity_depth
+      end
+
+      inputs
+    end
+
     def set_context_goal(goal)
       if context
         context.set_new_goal(goal)
@@ -232,7 +248,8 @@ module Foobara
                              result_type:,
                              agent_id: agent_name,
                              # TODO: Support changing this flag when the goal changes
-                             include_message_to_user_in_result:
+                             include_message_to_user_in_result:,
+                             result_entity_depth:
                            )
                          else
                            NotifyUserThatCurrentGoalHasBeenAccomplished

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-agent
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.13
 platform: ruby
 authors:
 - Miles Georgi