foobara-agent 0.0.16 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 240c7fa690a890cd583288e9ed1ae2fb7fe5c70a5322778eccf29ac4bc6554f9
-  data.tar.gz: 1d41b1f61ef8126fda960b91231558cf3911fc91a806e005d6c1d36db17d16d6
+  metadata.gz: ff591852377b5821eabf7ff4b49c4cc4bcacbebfdceaed539af14b831aa9cea3
+  data.tar.gz: 35de585c33d57e7f52f91baf95efaccd685e42fb342a0ac407875c8eb1790dad
 SHA512:
-  metadata.gz: c02671a8ad44659aa2c5aed14bf57f71d3bf14252757302d040e4e2b6060b89c3cbccbc54e35e647cd2c5433a03ef15b12c7dcb97c602fcf4d5edb153d7b2c01
-  data.tar.gz: 7b250f7059fb4fda74fff80c4b7c886219abe44b234b48e41a54b954df20a7f549b161cada201b9215d259f17ace85c2ad174f3c95631f45c1ce7c6e965bffa1
+  metadata.gz: 3ba055dccfe9e32a9ec6a9397a47707de6804d43c1e0e99a23f798951f246ea158b08048b939b51278cf0f552d16268cd83fe22a46bc2915f3434de693a1040e
+  data.tar.gz: '091f144c40b376ee7431c9ba4e906258f6d68704ebee1b568383bb66f7708cb40abeb4fab0650aeafd9bc2a9bb2b69f0428014566783f966d2545e07cfd0eb6e'

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.0.18] - 2025-07-21
+
+- Add maximum_command_calls option to Agent#initialize
+
+## [0.0.17] - 2025-07-10
+
+- Prefix verbose output with the agent name if there is one
+
 ## [0.0.16] - 2025-07-09
 
 - Tell the llm about previous goals

data/lib/foobara/agent.rb

@@ -10,12 +10,8 @@ module Foobara
 
     class << self
       def reset_all
-        [
-          NotifyUserThatCurrentGoalHasBeenAccomplished
-        ].each do |command_class|
-          command_class.clear_subclass_cache
-          Util.descendants(command_class).each(&:clear_subclass_cache)
-        end
+        NotifyUserThatCurrentGoalHasBeenAccomplished.clear_subclass_cache
+        Util.descendants(NotifyUserThatCurrentGoalHasBeenAccomplished).each(&:clear_subclass_cache)
       end
     end
   end

data/src/foobara/agent/accomplish_goal.rb

@@ -3,9 +3,6 @@ require_relative "list_commands"
 module Foobara
   class Agent < CommandConnector
     class AccomplishGoal < Foobara::Command
-      # Using a const here so we can stub it in the test suite to speed things up
-      SECONDS_PER_MINUTE = 60
-
       possible_error :gave_up, context: { reason: :string }, message: "Gave up."
       possible_error :too_many_command_calls,
                      context: { maximum_command_calls: :integer }
@@ -28,7 +25,6 @@ module Foobara
                   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
         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
@@ -52,8 +48,6 @@ module Foobara
           increment_command_calls
           check_if_too_many_calls
 
-          throttle_llm_calls_if_necessary
-
           determine_next_command_and_inputs
 
           run_next_command
@@ -430,7 +424,10 @@ module Foobara
                    end
                  end
 
-          (io_out || $stdout).puts "#{next_command_name}.run#{args}"
+          agent_name = agent.agent_name
+          prefix = agent_name && !agent_name.empty? ? "#{agent_name}: " : ""
+
+          (io_out || $stdout).puts "#{prefix}#{next_command_name}.run#{args}"
         end
       end
 
@@ -497,42 +494,6 @@ module Foobara
         llm_call_timestamps.unshift(Time.now)
       end
 
-      def llm_calls_in_last_minute
-        llm_call_timestamps.select { |t| t > (Time.now - 60) }
-      end
-
-      def llm_call_count_in_last_minute
-        llm_calls_in_last_minute.size
-      end
-
-      def time_until_llm_call_count_in_last_minute_changes
-        calls = llm_calls_in_last_minute
-
-        first_to_expire = calls.first
-
-        if first_to_expire
-          [0, (first_to_expire + SECONDS_PER_MINUTE) - Time.now].max
-        else
-          # TODO: figure out how to test this code path
-          # :nocov:
-          0
-          # :nocov:
-        end
-      end
-
-      def throttle_llm_calls_if_necessary
-        return unless max_llm_calls_per_minute && max_llm_calls_per_minute > 0
-
-        if llm_call_count_in_last_minute >= max_llm_calls_per_minute
-          seconds = time_until_llm_call_count_in_last_minute_changes
-          if verbose?
-            (io_out || $stdout).puts "Sleeping for #{seconds} seconds to avoid LLM calls per minute limit"
-          end
-
-          sleep seconds
-        end
-      end
-
       def context
         agent.context
       end

data/src/foobara/agent/determine_next_command_name_and_inputs.rb

@@ -1,8 +1,8 @@
-require_relative "determine_base"
+require "foobara/llm_backed_command"
 
 module Foobara
   class Agent < CommandConnector
-    class DetermineNextCommandNameAndInputs < DetermineBase
+    class DetermineNextCommandNameAndInputs < Foobara::LlmBackedCommand
       class << self
         def llm_instructions(assistant_association_depth, goal, previous_goals = nil)
           key = [assistant_association_depth, goal, previous_goals]
@@ -61,6 +61,16 @@ module Foobara
         inputs :attributes, :allow_nil
       end
 
+      inputs do
+        agent Agent, :required
+        pass_aggregates_to_llm :boolean, :allow_nil, "Should we send aggregates to the LLM or " \
+                                                     "require it to fetch what it needs?"
+        llm_model :string,
+                  one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
+                  default: Ai.default_llm_model,
+                  description: "The model to use for the LLM"
+      end
+
       def determine_llm_instructions
         self.llm_instructions = self.class.llm_instructions(
           computed_user_association_depth,
@@ -68,6 +78,64 @@ module Foobara
           previous_goal_and_status_pairs
         )
       end
+
+      def association_depth
+        if pass_aggregates_to_llm
+          Foobara::AssociationDepth::AGGREGATE
+        else
+          Foobara::AssociationDepth::ATOM
+        end
+      end
+
+      def build_messages
+        p = [
+          {
+            content: llm_instructions,
+            role: :system
+          }
+        ]
+
+        context.command_log.each do |command_log_entry|
+          agent_entry = {
+            command: command_log_entry.command_name
+          }
+
+          inputs = command_log_entry.inputs
+
+          if inputs && !inputs.empty?
+            agent_entry[:inputs] = inputs
+          end
+
+          outcome_entry = command_log_entry.outcome
+
+          p << {
+            content: agent_entry,
+            role: :assistant
+          }
+          p << {
+            content: outcome_entry,
+            role: :user
+          }
+        end
+
+        p
+      end
+
+      def goal
+        context.current_goal.text
+      end
+
+      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 context
+        agent.context
+      end
     end
   end
 end

data/src/foobara/agent.rb

@@ -24,9 +24,9 @@ module Foobara
                   :verbose,
                   :io_out,
                   :io_err,
-                  :max_llm_calls_per_minute,
                   :pass_aggregates_to_llm,
-                  :result_entity_depth
+                  :result_entity_depth,
+                  :maximum_command_calls
 
     def initialize(
       context: nil,
@@ -38,9 +38,9 @@ module Foobara
       verbose: false,
       io_out: nil,
       io_err: nil,
-      max_llm_calls_per_minute: nil,
       result_entity_depth: AssociationDepth::AGGREGATE,
       pass_aggregates_to_llm: nil,
+      maximum_command_calls: nil,
       **opts
     )
       # TODO: shouldn't have to pass command_log here since it has a default, debug that
@@ -55,9 +55,9 @@ module Foobara
       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
       self.pass_aggregates_to_llm = pass_aggregates_to_llm
+      self.maximum_command_calls = maximum_command_calls
 
       pre_commit_transformer = if pass_aggregates_to_llm
                                  CommandConnectors::Transformers::LoadAggregatesPreCommitTransformer
@@ -124,7 +124,7 @@ module Foobara
     def accomplish_goal(
       goal,
       result_type: nil,
-      maximum_call_count: nil,
+      maximum_command_calls: nil,
       llm_model: nil
     )
       set_context_goal(goal)
@@ -150,7 +150,7 @@ module Foobara
       state_machine.perform_transition!(:accomplish_goal)
 
       begin
-        inputs = accomplish_goal_inputs(goal, result_type:, maximum_call_count:, llm_model:)
+        inputs = accomplish_goal_inputs(goal, result_type:, maximum_command_calls:, llm_model:)
 
         self.current_accomplish_goal_command = AccomplishGoal.new(inputs)
 
@@ -186,7 +186,7 @@ module Foobara
 
     def accomplish_goal_inputs(goal,
                                result_type: nil,
-                               maximum_call_count: nil,
+                               maximum_command_calls: nil,
                                llm_model: nil)
       inputs = {
         goal:,
@@ -200,8 +200,12 @@ module Foobara
         inputs[:llm_model] = llm_model
       end
 
-      unless maximum_call_count.nil?
-        inputs[:maximum_command_calls] = maximum_call_count
+      if maximum_command_calls.nil?
+        maximum_command_calls = self.maximum_command_calls
+      end
+
+      unless maximum_command_calls.nil?
+        inputs[:maximum_command_calls] = maximum_command_calls
       end
 
       if verbose
@@ -220,10 +224,6 @@ module Foobara
         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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-agent
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.18
 platform: ruby
 authors:
 - Miles Georgi
@@ -66,7 +66,6 @@ files:
 - src/foobara/agent/connector/set_command_connector_inputs_transformer.rb
 - src/foobara/agent/describe_command.rb
 - src/foobara/agent/describe_type.rb
-- src/foobara/agent/determine_base.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_base.rb

@@ -1,76 +0,0 @@
-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
-        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: Ai.default_llm_model,
-                  description: "The model to use for the LLM"
-      end
-
-      def association_depth
-        if pass_aggregates_to_llm
-          Foobara::AssociationDepth::AGGREGATE
-        else
-          Foobara::AssociationDepth::ATOM
-        end
-      end
-
-      def build_messages
-        p = [
-          {
-            content: llm_instructions,
-            role: :system
-          }
-        ]
-
-        context.command_log.each do |command_log_entry|
-          agent_entry = {
-            command: command_log_entry.command_name
-          }
-
-          inputs = command_log_entry.inputs
-
-          if inputs && !inputs.empty?
-            agent_entry[:inputs] = inputs
-          end
-
-          outcome_entry = command_log_entry.outcome
-
-          p << {
-            content: agent_entry,
-            role: :assistant
-          }
-          p << {
-            content: outcome_entry,
-            role: :user
-          }
-        end
-
-        p
-      end
-
-      def goal
-        context.current_goal.text
-      end
-
-      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 context
-        agent.context
-      end
-    end
-  end
-end