foobara-agent 0.0.13 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc4b3804b5930b121fdc679ecf203b9e8b4d11122d24da967cfbfd10a1e6562d
-  data.tar.gz: '0739391b9b59d453783756a8efed38ec3d559ce7636873776ee71a14027059b5'
+  metadata.gz: 240c7fa690a890cd583288e9ed1ae2fb7fe5c70a5322778eccf29ac4bc6554f9
+  data.tar.gz: 1d41b1f61ef8126fda960b91231558cf3911fc91a806e005d6c1d36db17d16d6
 SHA512:
-  metadata.gz: 0ff04dba39a3edae5a80a98234cd7708c2f90d30bded9f12a0e2b665ea640c302e1ed14c607d61533daa5a0b3d7712684d92de740a3f3e085a1704286f95b837
-  data.tar.gz: 252b0f1a1c298bd984a856f4e63e57808b63cace046d58cf82f8c55f391c6d21fb3d98b8dda869582aa995eb6438a2fe998bae3952c5f6791eca00d25c5d181c
+  metadata.gz: c02671a8ad44659aa2c5aed14bf57f71d3bf14252757302d040e4e2b6060b89c3cbccbc54e35e647cd2c5433a03ef15b12c7dcb97c602fcf4d5edb153d7b2c01
+  data.tar.gz: 7b250f7059fb4fda74fff80c4b7c886219abe44b234b48e41a54b954df20a7f549b161cada201b9215d259f17ace85c2ad174f3c95631f45c1ce7c6e965bffa1

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.0.16] - 2025-07-09
+
+- Tell the llm about previous goals
+- Allow agents to be nameless
+- Improve support for killing a running agent
+
+## [0.0.15] - 2025-07-09
+
+- Make use of Ai.default_llm_model
+
+## [0.0.14] - 2025-07-08
+
+- Better handle serialization/pre-commit loading for various entity-depth scenarios
+
 ## [0.0.13] - 2025-07-06
 
 - Eliminate NotifyUser... result_type to save tokens/improve accuracy

data/src/foobara/agent/accomplish_goal.rb

@@ -19,18 +19,19 @@ module Foobara
         io_out :duck
         io_err :duck
         agent Agent, :required
-        context Context, :required, "The current context of the agent"
         maximum_command_calls :integer,
                               :allow_nil,
                               default: 25,
                               description: "Maximum number of commands to run before giving up"
         llm_model :string,
                   :allow_nil,
-                  one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
-                  default: "claude-3-7-sonnet-20250219",
+                  one_of: Ai::AnswerBot::Types::ModelEnum,
+                  default: Ai.default_llm_model,
                   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]
+        user_association_depth :symbol, :allow_nil, one_of: Foobara::AssociationDepth
+        result_entity_depth :symbol, :allow_nil, one_of: Foobara::AssociationDepth
+        pass_aggregates_to_llm :boolean, :allow_nil
       end
 
       result do
@@ -41,11 +42,13 @@ module Foobara
       depends_on ListCommands
 
       def execute
-        simulate_describe_list_commands_command
-        simulate_list_commands_run
+        unless list_commands_already_ran?
+          simulate_describe_list_commands_command
+          simulate_list_commands_run
+        end
         # simulate_describe_command_run_for_all_commands
 
-        until mission_accomplished or given_up
+        until mission_accomplished or given_up or killed
           increment_command_calls
           check_if_too_many_calls
 
@@ -66,7 +69,11 @@ module Foobara
       attr_accessor :next_command_name, :next_command_inputs, :next_command_raw_inputs, :mission_accomplished,
                     :given_up, :next_command_class, :next_command, :command_outcome, :timed_out,
                     :final_result, :final_message, :command_response, :delayed_command_name,
-                    :command_calls
+                    :command_calls, :killed
+
+      def list_commands_already_ran?
+        context.command_log.any? { |log_entry| log_entry.command_name =~ /\bListCommands\z/ }
+      end
 
       def simulate_list_commands_run
         self.next_command_name = ListCommands.full_command_name
@@ -124,6 +131,8 @@ module Foobara
       end
 
       def determine_next_command_and_inputs(retries = 3, error_outcome = nil)
+        return if killed
+
         if retries == 0
           # TODO: test this path by irreparably breaking the needed commands
           # :nocov:
@@ -141,7 +150,10 @@ module Foobara
 
         compact_command_log
 
-        inputs_for_determine = { context:, llm_model: }
+        inputs_for_determine = { agent:, llm_model: }
+        unless pass_aggregates_to_llm.nil?
+          inputs_for_determine[:pass_aggregates_to_llm] = pass_aggregates_to_llm
+        end
         determine_command = DetermineNextCommandNameAndInputs.new(inputs_for_determine)
 
         outcome = begin
@@ -429,6 +441,10 @@ module Foobara
         self.final_message = message
       end
 
+      def kill!
+        self.killed = true
+      end
+
       def give_up!(message)
         self.given_up = true
         self.final_message = message
@@ -516,6 +532,10 @@ module Foobara
           sleep seconds
         end
       end
+
+      def context
+        agent.context
+      end
     end
   end
 end

data/src/foobara/agent/determine_base.rb

@@ -2,17 +2,24 @@ require "foobara/llm_backed_command"
 
 module Foobara
   class Agent < CommandConnector
+    # TODO: just move this back to DetermineNextCommandAndInputs since it's now the only base class
     class DetermineBase < Foobara::LlmBackedCommand
       inputs do
-        context Context, :required, "Context of the progress towards the goal so far"
+        pass_aggregates_to_llm :boolean, :allow_nil, "Should we send aggregates to the LLM or " \
+                                                     "require it to fetch what it needs?"
+        agent Agent, :required
         llm_model :string,
                   one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
-                  default: "claude-3-7-sonnet-20250219",
+                  default: Ai.default_llm_model,
                   description: "The model to use for the LLM"
       end
 
       def association_depth
-        Foobara::JsonSchemaGenerator::AssociationDepth::ATOM
+        if pass_aggregates_to_llm
+          Foobara::AssociationDepth::AGGREGATE
+        else
+          Foobara::AssociationDepth::ATOM
+        end
       end
 
       def build_messages
@@ -49,33 +56,20 @@ module Foobara
         p
       end
 
-      def llm_instructions
-        return @llm_instructions if defined?(@llm_instructions)
-
-        description = self.class.description
-
-        instructions = "You are the implementation of a command called #{self.class.scoped_full_name}"
-
-        instructions += if description && !description.empty?
-                          " which has the following description:\n\n#{self.class.description}\n\n"
-                        else
-                          # :nocov:
-                          ". "
-                          # :nocov:
-                        end
-
-        instructions += "You are working towards accomplishing the following goal:\n\n#{goal}\n\n"
-        instructions += "Your response should match the following JSON schema: \n\n#{self.class.result_json_schema}\n\n"
-        instructions += "You can get more details about the result schema 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 " \
-                        "can successfully parse your answer."
+      def goal
+        context.current_goal.text
+      end
 
-        @llm_instructions = instructions
+      def previous_goal_and_status_pairs
+        if context.previous_goals && !context.previous_goals.empty?
+          context.previous_goals.map do |previous_goal|
+            [previous_goal.text, previous_goal.state]
+          end
+        end
       end
 
-      def goal
-        context.current_goal
+      def context
+        agent.context
       end
     end
   end

data/src/foobara/agent/determine_next_command_name_and_inputs.rb

@@ -3,6 +3,54 @@ require_relative "determine_base"
 module Foobara
   class Agent < CommandConnector
     class DetermineNextCommandNameAndInputs < DetermineBase
+      class << self
+        def llm_instructions(assistant_association_depth, goal, previous_goals = nil)
+          key = [assistant_association_depth, goal, previous_goals]
+
+          @llm_instructions_cache ||= {}
+
+          if @llm_instructions_cache.key?(key)
+            @llm_instructions_cache[key]
+          else
+            @llm_instructions_cache[key] = build_llm_instructions(assistant_association_depth, goal, previous_goals)
+          end
+        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
+
+          result_schema = result_json_schema(assistant_association_depth)
+
+          if previous_goals && !previous_goals.empty?
+            instructions += "You have previously accomplished the following goals:\n\n"
+
+            previous_goals.each.with_index do |(previous_goal, state), index|
+              instructions += "previous goal #{index + 1}: #{previous_goal}\n"
+              instructions += "status of goal #{index + 1}: #{state}\n\n"
+            end
+          end
+
+          instructions += "You are working towards accomplishing the following goal:\n\n#{goal}\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 " \
+                          "can successfully parse your answer."
+
+          instructions
+        end
+      end
+
       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 " \
@@ -12,6 +60,14 @@ module Foobara
         command :string, :required
         inputs :attributes, :allow_nil
       end
+
+      def determine_llm_instructions
+        self.llm_instructions = self.class.llm_instructions(
+          computed_user_association_depth,
+          goal,
+          previous_goal_and_status_pairs
+        )
+      end
     end
   end
 end

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

@@ -1,15 +1,17 @@
+require_relative "goal"
+
 module Foobara
   class Agent < CommandConnector
     class Context < Foobara::Model
       class << self
         def for(goal)
-          new(command_log: [], current_goal: goal)
+          new(command_log: [], current_goal: Goal.new(text: goal))
         end
       end
 
       attributes do
-        current_goal :string, :required, "The current goal the agent needs to accomplish"
-        previous_goals [:string]
+        current_goal Goal, :required, "The current goal the agent needs to accomplish"
+        previous_goals [Goal]
         # TODO: why doesn't this default of [] work as expected on newly created models?
         command_log [CommandLogEntry], default: [],
                                        description: "Log of all commands run so far and their outcomes"
@@ -18,7 +20,7 @@ module Foobara
       def set_new_goal(goal)
         self.previous_goals ||= []
         previous_goals << current_goal
-        self.current_goal = goal
+        self.current_goal = Goal.new(text: goal)
       end
     end
   end

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

@@ -0,0 +1,18 @@
+module Foobara
+  class Agent < CommandConnector
+    class Goal < Foobara::Model
+      module States
+        ACCOMPLISHED = :accomplished
+        KILLED = :killed
+        FAILED = :failed
+        ERROR = :error
+        GAVE_UP = :gave_up
+      end
+
+      attributes do
+        text :string, :required
+        state :symbol, :allow_nil, one_of: States
+      end
+    end
+  end
+end

data/src/foobara/agent.rb

@@ -15,6 +15,7 @@ module Foobara
 
     attr_accessor :context,
                   :agent_name,
+                  :agent_id,
                   :llm_model,
                   :current_accomplish_goal_command,
                   :result_type,
@@ -24,6 +25,7 @@ module Foobara
                   :io_out,
                   :io_err,
                   :max_llm_calls_per_minute,
+                  :pass_aggregates_to_llm,
                   :result_entity_depth
 
     def initialize(
@@ -38,12 +40,16 @@ module Foobara
       io_err: nil,
       max_llm_calls_per_minute: nil,
       result_entity_depth: AssociationDepth::AGGREGATE,
+      pass_aggregates_to_llm: 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 || "Anon#{SecureRandom.hex(2)}"
-      self.llm_model = llm_model || "claude-opus-4-20250514"
+      if agent_name
+        self.agent_name = agent_name
+      end
+      self.agent_id = agent_name || "Anon#{SecureRandom.hex(2)}"
+      self.llm_model = llm_model || Ai.default_llm_model
       self.result_type = result_type
       self.include_message_to_user_in_result = include_message_to_user_in_result
       self.verbose = verbose
@@ -51,25 +57,21 @@ module Foobara
       self.io_err = io_err
       self.max_llm_calls_per_minute = max_llm_calls_per_minute
       self.result_entity_depth = result_entity_depth
+      self.pass_aggregates_to_llm = pass_aggregates_to_llm
 
-      # unless opts.key?(:default_serializers)
-      #   opts = opts.merge(default_serializers: [
-      #                       Foobara::CommandConnectors::Serializers::ErrorsSerializer,
-      #                       Foobara::CommandConnectors::Serializers::AggregateSerializer
-      #                     ])
-      # end
+      pre_commit_transformer = if pass_aggregates_to_llm
+                                 CommandConnectors::Transformers::LoadAggregatesPreCommitTransformer
+                               else
+                                 CommandConnectors::Transformers::LoadAtomsPreCommitTransformer
+                               end
 
-      unless opts.key?(:default_pre_commit_transformers)
-        opts = opts.merge(
-          default_pre_commit_transformers: Foobara::CommandConnectors::Transformers::LoadAtomsPreCommitTransformer
-        )
-      end
+      opts = opts.merge(default_pre_commit_transformers: [
+        *opts[:default_pre_commit_transformers],
+        pre_commit_transformer
+      ].uniq)
 
       super(**opts)
 
-      # TODO: this should work now, switch to this approach
-      # add_default_inputs_transformer EntityToPrimaryKeyInputsTransformer
-
       # TODO: push this convenience method up into base class?
       command_classes&.each do |command_class|
         connect(command_class)
@@ -107,11 +109,16 @@ module Foobara
     end
 
     def kill!
-      state_machine.perform_transition!(:kill)
+      current_accomplish_goal_command&.kill!
+      state_machine.perform_transition!(:kill) do
+        if context
+          context.current_goal.state = Goal::States::KILLED
+        end
+      end
     end
 
     def killed?
-      state_machine.current_state == :killed
+      state_machine.current_state == Goal::States::KILLED
     end
 
     def accomplish_goal(
@@ -151,14 +158,27 @@ module Foobara
           transition = if outcome.success?
                          :goal_accomplished
                        else
-                         :goal_errored
+                         :goal_failed
                        end
 
-          state_machine.perform_transition!(transition)
+          unless killed?
+            state_machine.perform_transition!(transition) do
+              context.current_goal.state = if outcome.success?
+                                             Goal::States::ACCOMPLISHED
+                                           else
+                                             Goal::States::FAILED
+                                           end
+            end
+          end
         end
       rescue
         # :nocov:
-        state_machine.perform_transition!(:goal_failed)
+        unless killed?
+          state_machine.perform_transition!(:goal_errored) do
+            context.current_goal.state = Goal::States::ERROR
+          end
+        end
+
         raise
         # :nocov:
       end
@@ -171,7 +191,6 @@ module Foobara
       inputs = {
         goal:,
         final_result_type: self.result_type,
-        context:,
         agent: self
       }
 
@@ -209,6 +228,10 @@ module Foobara
         inputs[:result_entity_depth] = result_entity_depth
       end
 
+      unless pass_aggregates_to_llm.nil?
+        inputs[:pass_aggregates_to_llm] = pass_aggregates_to_llm
+      end
+
       inputs
     end
 
@@ -246,7 +269,7 @@ module Foobara
                            # TODO: Support changing the final result type when the goal changes
                            NotifyUserThatCurrentGoalHasBeenAccomplished.for(
                              result_type:,
-                             agent_id: agent_name,
+                             agent_id:,
                              # TODO: Support changing this flag when the goal changes
                              include_message_to_user_in_result:,
                              result_entity_depth:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-agent
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.16
 platform: ruby
 authors:
 - Miles Georgi
@@ -13,30 +13,42 @@ dependencies:
   name: foobara
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.126
+        version: 0.0.136
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.136
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.0.126
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: foobara-llm-backed-command
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.1
+        version: 1.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.0.1
+        version: 2.0.0
 email:
 - azimux@gmail.com
 executables: []
@@ -61,6 +73,7 @@ files:
 - 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
+- src/foobara/agent/types/goal.rb
 homepage: https://github.com/foobara/agent
 licenses:
 - MPL-2.0