foobara-agent 0.0.18 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff591852377b5821eabf7ff4b49c4cc4bcacbebfdceaed539af14b831aa9cea3
-  data.tar.gz: 35de585c33d57e7f52f91baf95efaccd685e42fb342a0ac407875c8eb1790dad
+  metadata.gz: 17773b8b47ace046d920b37565e0b5327fad2bba050f867c9a951ee89b780a93
+  data.tar.gz: 861120d98c2c9cce6f5194403cc950d7ff6c096061be4ebd8cd7a3f93f43c78f
 SHA512:
-  metadata.gz: 3ba055dccfe9e32a9ec6a9397a47707de6804d43c1e0e99a23f798951f246ea158b08048b939b51278cf0f552d16268cd83fe22a46bc2915f3434de693a1040e
-  data.tar.gz: '091f144c40b376ee7431c9ba4e906258f6d68704ebee1b568383bb66f7708cb40abeb4fab0650aeafd9bc2a9bb2b69f0428014566783f966d2545e07cfd0eb6e'
+  metadata.gz: be3168705a2ef7bfcc7a9ab2cde4713c91451857fbb762f121ada60d48cf590d5b0c184ca514221c58fb2b2bdbef08e20f95b7783ba54e83cb9f55fa37546350
+  data.tar.gz: c02c9a0b4dd95b228a8d723ed84af909040f50c8bb2694aea0b30e30a1ab7356f5f074d6a8e64a1ba47b5a113b69e013ad1db0f5fb98ded799ffcc8d5e89760d

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.0.20] - 2025-07-23
+
+- Fix bug with result type being an array without any message to the user
+
+## [0.0.19] - 2025-07-23
+
+- Skip result: input if result is a Model and properly cast result
+- Add include_message_to_user_in_result option to #accomplish_goal
+- Include the llm_model in the verbose output
+- Print out info about retries if verbose
+- Change the language of the instructions to see what happens
+
 ## [0.0.18] - 2025-07-21
 
 - Add maximum_command_calls option to Agent#initialize

data/src/foobara/agent/accomplish_goal.rb

@@ -42,9 +42,8 @@ module Foobara
           simulate_describe_list_commands_command
           simulate_list_commands_run
         end
-        # simulate_describe_command_run_for_all_commands
 
-        until mission_accomplished or given_up or killed
+        until mission_accomplished? or given_up? or killed?
           increment_command_calls
           check_if_too_many_calls
 
@@ -53,7 +52,7 @@ module Foobara
           run_next_command
         end
 
-        if given_up
+        if given_up?
           add_given_up_error
         end
 
@@ -124,9 +123,17 @@ module Foobara
         # :nocov:
       end
 
-      def determine_next_command_and_inputs(retries = 3, error_outcome = nil)
+      RETRY_COUNT = 3
+
+      def determine_next_command_and_inputs(retries = RETRY_COUNT, error_outcome = nil)
         return if killed
 
+        if verbose? && retries != RETRY_COUNT
+          # :nocov:
+          (io_err || $stderr).puts " !!! Retrying to determine next command and inputs. Retries left: #{retries}"
+          # :nocov:
+        end
+
         if retries == 0
           # TODO: test this path by irreparably breaking the needed commands
           # :nocov:
@@ -244,7 +251,8 @@ module Foobara
         inputs_type = next_command_class.inputs_type
 
         NestedTransactionable.with_needed_transactions_for_type(inputs_type) do
-          inputs_type.process_value(next_command_inputs)
+          inputs = next_command_inputs.nil? ? {} : next_command_inputs
+          inputs_type.process_value(inputs)
         end
       end
 
@@ -425,7 +433,16 @@ module Foobara
                  end
 
           agent_name = agent.agent_name
-          prefix = agent_name && !agent_name.empty? ? "#{agent_name}: " : ""
+          prefix = if agent_name && !agent_name.empty?
+                     "#{agent_name}<#{llm_model}>: "
+                   else
+                     # Not setting an agent_name results in non-determinism in NotifyUser... command
+                     # namespace. This results in problems in the test suite making this code path a little
+                     # harder to test indirectly.
+                     # :nocov:
+                     ""
+                     # :nocov:
+                   end
 
           (io_out || $stdout).puts "#{prefix}#{next_command_name}.run#{args}"
         end
@@ -451,10 +468,40 @@ module Foobara
         add_runtime_error(:gave_up, reason: final_message)
       end
 
+      def final_result_type_from_declaration
+        return @final_result_type_from_declaration if defined?(@final_result_type_from_declaration)
+
+        @final_result_type_from_declaration = if final_result_type
+                                                if final_result_type.is_a?(Types::Type)
+                                                  final_result_type
+                                                else
+                                                  domain = result_type.created_in_namespace.foobara_domain
+                                                  domain.foobara_type_from_declaration(final_result_type)
+                                                end
+                                              end
+      end
+
       def build_result
+        result_data = if final_result_type_from_declaration
+                        outcome = final_result_type_from_declaration.process_value(final_result)
+
+                        if outcome.success?
+                          outcome.result
+                        elsif given_up? || killed?
+                          final_result
+                        else
+                          # :nocov:
+                          raise CommandPatternImplementation::Concerns::Result::CouldNotProcessResult,
+                                outcome.errors
+                          # :nocov:
+                        end
+                      else
+                        final_result
+                      end
+
         {
           message_to_user: final_message,
-          result_data: final_result
+          result_data:
         }
       end
 
@@ -497,6 +544,18 @@ module Foobara
       def context
         agent.context
       end
+
+      def mission_accomplished?
+        mission_accomplished
+      end
+
+      def given_up?
+        given_up
+      end
+
+      def killed?
+        killed
+      end
     end
   end
 end

data/src/foobara/agent/determine_next_command_name_and_inputs.rb

@@ -17,15 +17,8 @@ module Foobara
         end
 
         def build_llm_instructions(assistant_association_depth, goal, previous_goals)
-          instructions = "You are the implementation of a command called #{scoped_full_name}"
-
-          instructions += if description && !description.empty?
-                            " which has the following description:\n\n#{description}\n\n"
-                          else
-                            # :nocov:
-                            ". "
-                            # :nocov:
-                          end
+          instructions = "You are part of an agent implementation. " \
+                         "Your task is to decide which command to run next.\n\n"
 
           result_schema = result_json_schema(assistant_association_depth)
 
@@ -38,13 +31,25 @@ module Foobara
             end
           end
 
-          instructions += "You are working towards accomplishing the following goal:\n\n#{goal}\n\n"
+          instructions += "You are working towards accomplishing the following goal: #{goal}\n\n"
+
+          instructions += "You will answer with the name of the next command to run and, if needed, its inputs. " \
+                          "Choose whichever command is best to make progress towards accomplishing the current goal " \
+                          "based on the progress made so far. " \
+                          "If the goal has been accomplished then choose the " \
+                          "NotifyUserThatCurrentGoalHasBeenAccomplished command. " \
+                          "If you are stuck either due to errors " \
+                          "or because you do not have the command you need to accomplish the " \
+                          "goal, then choose GiveUp.\n\n"
 
-          instructions += "Your response of which command to run next should match the following JSON schema:"
-          instructions += "\n\n#{result_schema}\n\n"
           instructions += "You can get more details about the inputs and result schemas for a specific command by " \
-                          "choosing the DescribeCommand command. " \
-                          "You will reply with nothing more than the JSON you've generated so that the calling code " \
+                          "choosing the DescribeCommand command.\n\n"
+
+          instructions += "Your result type is described by the following JSON schema:" \
+                          "\n\n#{result_schema}\n\n" \
+                          "You will reply with nothing more than the JSON that you've " \
+                          "generated that adheres to this result type schema " \
+                          "so that the calling code " \
                           "can successfully parse your answer."
 
           instructions
@@ -54,7 +59,8 @@ module Foobara
       description "Returns the name of the next command to run and its inputs given the progress  " \
                   "towards accomplishing the current goal. " \
                   "If the goal has been accomplished it will choose the " \
-                  "NotifyUserThatCurrentGoalHasBeenAccomplished command."
+                  "NotifyUserThatCurrentGoalHasBeenAccomplished command. It will choose GiveUp if it runs into an " \
+                  "error it cannot get around or does not believe it has the proper commands to accomplish its goal."
 
       result do
         command :string, :required

data/src/foobara/agent/notify_user_that_current_goal_has_been_accomplished.rb

@@ -7,7 +7,7 @@ module Foobara
 
       class << self
         attr_accessor :command_class, :returns_message_to_user, :returns_result_data, :result_is_attributes,
-                      :built_result_type
+                      :built_result_type, :result_is_model
 
         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)}"
@@ -46,20 +46,38 @@ module Foobara
                                   "result schema and a message to the user. " \
                                   "The user might issue a new goal."
               else
-                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
+                if result_type.extends?(BuiltinTypes[:model]) &&
+                   !result_type.extends?(BuiltinTypes[:detached_entity]) && result_type != BuiltinTypes[:model]
+                  # TODO: Create a ModelToAttributesInputsTransformer in foobara gem and move this logic there
+                  model_declaration = result_type.declaration_data
+
+                  # Distinguishing between nil and no inputs might be tricky so if :allow_nil then
+                  # we will prefer `result: nil` over `nil`
+                  # if there's a description we'll also prefer result: so that the description will
+                  # make it through to the LLM on that input.
+                  # TODO: handle the model's description via the command's description instead.
+                  if !model_declaration.key?(:allow_nil) && !model_declaration.key?(:description)
+                    klass.built_result_type = result_type
+                    klass.result_is_model = true
+                    klass.add_inputs result_type.target_class.attributes_type
                   end
-                  klass.add_inputs klass.built_result_type
                 end
 
-                klass.description "Notifies the user that the current goal has been accomplished and returns a final " \
-                                  "result formatted according to the " \
-                                  "result schema. " \
+                unless klass.result_is_model
+                  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
+                end
+
+                klass.description "Notifies the user that the current goal has been accomplished and accepts a final " \
+                                  "result value as inputs. " \
                                   "The user might issue a new goal."
               end
             elsif include_message_to_user_in_result
@@ -112,7 +130,7 @@ module Foobara
              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
+              built_result = command.final_result_data
 
               if built_result
                 transformer.process_value!(built_result)
@@ -130,34 +148,35 @@ module Foobara
       end
 
       def execute
-        build_result
+        extract_result_data_and_message_to_user
         mark_mission_accomplished
 
         nil
       end
 
-      attr_accessor :built_result
-
-      def mark_mission_accomplished
-        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
+      attr_accessor :final_result_data, :final_message_to_user
+
+      def extract_result_data_and_message_to_user
+        result, message = if returns_message_to_user?
+                            inputs.values_at(:result, :message_to_user)
+                          elsif returns_result_data?
+                            if result_is_attributes?
+                              inputs.slice(*self.class.built_result_type.element_types.keys)
+                            elsif result_is_model?
+                              inputs.slice(
+                                *self.class.built_result_type.target_class.attributes_type.element_types.keys
+                              )
+                            else
+                              [inputs[:result], nil]
+                            end
+                          end
 
-        command_connector.mark_mission_accomplished(result, message_to_user)
+        self.final_result_data = result
+        self.final_message_to_user = message
       end
 
-      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
+      def mark_mission_accomplished
+        command_connector.mark_mission_accomplished(final_result_data, final_message_to_user)
       end
 
       def returns_message_to_user?
@@ -171,6 +190,10 @@ module Foobara
       def result_is_attributes?
         self.class.result_is_attributes
       end
+
+      def result_is_model?
+        self.class.result_is_model
+      end
     end
   end
 end

data/src/foobara/agent/types/context.rb

@@ -3,12 +3,6 @@ require_relative "goal"
 module Foobara
   class Agent < CommandConnector
     class Context < Foobara::Model
-      class << self
-        def for(goal)
-          new(command_log: [], current_goal: Goal.new(text: goal))
-        end
-      end
-
       attributes do
         current_goal Goal, :required, "The current goal the agent needs to accomplish"
         previous_goals [Goal]
@@ -19,7 +13,11 @@ module Foobara
 
       def set_new_goal(goal)
         self.previous_goals ||= []
-        previous_goals << current_goal
+
+        if current_goal
+          previous_goals << current_goal
+        end
+
         self.current_goal = Goal.new(text: goal)
       end
     end

data/src/foobara/agent.rb

@@ -44,7 +44,8 @@ module Foobara
       **opts
     )
       # TODO: shouldn't have to pass command_log here since it has a default, debug that
-      self.context = context
+      self.context = context || Context.new(command_log: [])
+
       if agent_name
         self.agent_name = agent_name
       end
@@ -125,8 +126,13 @@ module Foobara
       goal,
       result_type: nil,
       maximum_command_calls: nil,
+      include_message_to_user_in_result: nil,
       llm_model: nil
     )
+      unless include_message_to_user_in_result.nil?
+        self.include_message_to_user_in_result = include_message_to_user_in_result
+      end
+
       set_context_goal(goal)
 
       if result_type && self.result_type != result_type
@@ -150,7 +156,10 @@ module Foobara
       state_machine.perform_transition!(:accomplish_goal)
 
       begin
-        inputs = accomplish_goal_inputs(goal, result_type:, maximum_command_calls:, llm_model:)
+        inputs = accomplish_goal_inputs(goal,
+                                        result_type:,
+                                        maximum_command_calls:,
+                                        llm_model:)
 
         self.current_accomplish_goal_command = AccomplishGoal.new(inputs)
 
@@ -236,11 +245,7 @@ module Foobara
     end
 
     def set_context_goal(goal)
-      if context
-        context.set_new_goal(goal)
-      else
-        self.context = Context.for(goal)
-      end
+      context.set_new_goal(goal)
     end
 
     def mark_mission_accomplished(final_result, message_to_user)

metadata

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