foobara-agent 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12e8facdeb95a000d81ec0ba8a133affa1ea66e470115e978bdc81f05bc51855
-  data.tar.gz: 294064df166d152c037db13263863b8ccfe32f064a78e77f6f5fe59af0be3829
+  metadata.gz: c086912a26df48a558f040a3b2e03138210674ec371f528437f08b007ba31783
+  data.tar.gz: 86315598bc4ca17d59cfc6e2d204561c2b387c0162a19601281f3825a7e68337
 SHA512:
-  metadata.gz: 2c7fcaf044ba9bc821dcc42f9b0fb44b412fb42f9ef77dd4b7f3ed13cb8293cdb60d448d136e4e0567d104ecb022a00accfd05dbcf955e38185884d34e59668e
-  data.tar.gz: 380d9ae749b6a942b4e33b112f5aae35fd9600fa9ffcaf462fc0a35122354aae0658378190a4b9db3c0d65d2a12c9d49305b1d03a2881ce504d6d268cf039255
+  metadata.gz: 2ce3b72dca0e4e111c8a68f61d9c80eeabbfcfd480d858ebeaa92b9e7cc4730fd4278654ce7b3ded885628297aa0eb8684ee73b7213559e9d9f93760a6c06086
+  data.tar.gz: 28c540d5663172ff9d15925f152357872576d96e275bb278edc5c6661c47dfbe9fc0832fec9268fe1b215dfaeb5d43d30eef422bc572dc4e9023e82cd77c3a79

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.0.9] - 2025-06-28
+
+- Relocate some common Determine* behavior into a DetermineBase
+- Move goal to Context and make use of LlmBackedCommand#messages
+- Simulating a DescribeCommand selection on failure
+- Compacting the command log
+
 ## [0.0.8] - 2025-06-27
 
 - Improve what is logged and its formatting when verbose

data/src/foobara/agent/accomplish_goal.rb

@@ -19,7 +19,7 @@ module Foobara
         io_out :duck
         io_err :duck
         agent Agent, :required
-        current_context Context, :allow_nil, "The current context of the agent"
+        context Context, :required, "The current context of the agent"
         maximum_command_calls :integer,
                               :allow_nil,
                               default: 25,
@@ -46,8 +46,6 @@ module Foobara
       depends_on ListCommands
 
       def execute
-        build_initial_context_if_necessary
-
         simulate_describe_list_commands_command
         simulate_list_commands_run
         # simulate_describe_command_run_for_all_commands
@@ -66,6 +64,7 @@ module Foobara
 
           run_next_command
           log_last_command_outcome
+          compact_command_log
         end
 
         if given_up
@@ -75,16 +74,11 @@ module Foobara
         build_result
       end
 
-      attr_accessor :context, :next_command_name, :next_command_inputs, :next_command_raw_inputs, :mission_accomplished,
+      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
 
-      def build_initial_context_if_necessary
-        # TODO: shouldn't have to pass command_log here since it has a default, debug that
-        self.context = current_context || Context.new(command_log: [])
-      end
-
       def simulate_list_commands_run
         self.next_command_name = ListCommands.full_command_name
         self.next_command_raw_inputs = nil
@@ -105,6 +99,26 @@ module Foobara
         log_last_command_outcome
       end
 
+      def simulate_describe_command(command_name = next_command_name)
+        old_next_command_name = next_command_name
+        old_next_command_inputs = next_command_inputs
+        old_next_command_raw_inputs = next_command_raw_inputs
+        old_next_command_class = next_command_class
+
+        self.next_command_name = DescribeCommand.full_command_name
+        self.next_command_inputs = { command_name: }
+        self.next_command_raw_inputs = next_command_inputs
+        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
+        self.next_command_raw_inputs = old_next_command_raw_inputs
+        self.next_command_class = old_next_command_class
+      end
+
       def simulate_describe_command_run_for_all_commands
         # TODO: currently not using this code path. Unclear if it is worth it.
         # :nocov:
@@ -126,7 +140,6 @@ module Foobara
 
       def determine_next_command_and_inputs(retries = 2)
         inputs_for_determine = {
-          goal:,
           context:,
           llm_model:
         }
@@ -162,6 +175,7 @@ module Foobara
                   outcome:
                 )
 
+                simulate_describe_command
                 determine_next_command_inputs
               end
             else
@@ -251,7 +265,7 @@ module Foobara
                                    self.delayed_command_name = nil
                                    name
                                  else
-                                   inputs = { goal:, context: }
+                                   inputs = { context: }
                                    if llm_model
                                      inputs[:llm_model] = llm_model
                                    end
@@ -291,7 +305,7 @@ module Foobara
                                      # :nocov:
                                      log_command_outcome(
                                        command:,
-                                       inputs: command.inputs.except(:context),
+                                       inputs: command.inputs&.except(:context),
                                        outcome:,
                                        result: outcome.result || command.raw_result
                                      )
@@ -325,7 +339,7 @@ module Foobara
         self.next_command_inputs = if next_command_has_inputs?
                                      command_class = command_class_for_determine_inputs_for_next_command
 
-                                     inputs = { goal:, context: }
+                                     inputs = { context: }
                                      if llm_model
                                        inputs[:llm_model] = llm_model
                                      end
@@ -349,6 +363,8 @@ module Foobara
                                          outcome:
                                        )
 
+                                       simulate_describe_command
+
                                        if retries > 0
                                          return determine_next_command_inputs(retries - 1)
                                        end
@@ -412,6 +428,57 @@ module Foobara
         log_command_outcome(command: command_response.command)
       end
 
+      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 = []
+        commands = {}
+
+        describe_command_name = DescribeCommand.full_command_name
+        context.command_log.each.with_index do |command_log_entry, index|
+          command_name = command_log_entry.command_name
+
+          if command_name == describe_command_name
+            describe_command_call_indexes << index
+          end
+
+          commands[command_name] ||= [[], []]
+          bucket_index = command_log_entry.outcome[:success] ? 0 : 1
+          commands[command_name][bucket_index] << index
+        end
+
+        indexes_to_delete = describe_command_call_indexes[0..-2]
+
+        commands.each_value do |(success_indexes, failure_indexes)|
+          last_success = success_indexes.last
+          next unless last_success
+
+          failure_indexes.each do |failure_index|
+            if failure_index < last_success
+              indexes_to_delete << failure_index
+            else
+              # :nocov:
+              break
+              # :nocov:
+            end
+          end
+        end
+
+        if indexes_to_delete.empty?
+          return
+        end
+
+        new_log = []
+        context.command_log = context.command_log.each.with_index do |entry, index|
+          unless indexes_to_delete.include?(index)
+            new_log << entry
+          end
+        end
+
+        context.command_log = new_log
+      end
+
       def increment_command_calls
         self.command_calls ||= -1
         self.command_calls += 1
@@ -435,7 +502,7 @@ module Foobara
           outcome ||= command.outcome
         end
 
-        if outcome
+        if outcome&.success?
           result ||= outcome.result
         end
 

data/src/foobara/agent/determine_base.rb

@@ -0,0 +1,82 @@
+require "foobara/llm_backed_command"
+
+module Foobara
+  class Agent < CommandConnector
+    class DetermineBase < Foobara::LlmBackedCommand
+      inputs do
+        context Context, :required, "Context of the progress towards the goal so far"
+        llm_model :string,
+                  one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
+                  default: "claude-3-7-sonnet-20250219",
+                  description: "The model to use for the LLM"
+      end
+
+      def association_depth
+        Foobara::JsonSchemaGenerator::AssociationDepth::ATOM
+      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 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."
+
+        @llm_instructions = instructions
+      end
+
+      def goal
+        context.current_goal
+      end
+    end
+  end
+end

data/src/foobara/agent/determine_inputs_for_next_command.rb

@@ -1,8 +1,6 @@
-require "foobara/llm_backed_command"
-
 module Foobara
   class Agent < CommandConnector
-    class DetermineInputsForNextCommand < Foobara::LlmBackedCommand
+    class DetermineInputsForNextCommand < DetermineBase
       extend Concerns::SubclassCacheable
 
       class << self
@@ -12,34 +10,24 @@ module Foobara
             class_name = "Foobara::Agent::#{agent_id}::DetermineInputsForNext#{command_short_name}Command"
             klass = Util.make_class_p(class_name, self)
 
-            klass.description "Accepts a goal and context of the work so far and returns the inputs for " \
-                              "the next #{command_short_name} command to run to make progress towards " \
-                              "accomplishing the goal."
+            klass.description "Returns the inputs for " \
+                              "the next #{command_class.full_command_name} command to run."
 
-            klass.inputs do
-              goal :string, :required, "The current (possibly already accomplished) goal"
-              context Context, :required, "Context of the progress towards the goal so far"
-              llm_model :string,
-                        one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
-                        default: "claude-3-7-sonnet-20250219",
-                        description: "The model to use for the LLM"
+            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
 
-            if command_class.inputs_type
-              transformer = CommandConnectors::Transformers::EntityToPrimaryKeyInputsTransformer.new(
-                to: command_class.inputs_type
-              )
-              klass.result transformer.from_type
-            end
+            transformer = CommandConnectors::Transformers::EntityToPrimaryKeyInputsTransformer.new(
+              to: command_class.inputs_type
+            )
+            klass.result transformer.from_type
 
             klass
           end
         end
       end
-
-      def association_depth
-        Foobara::JsonSchemaGenerator::AssociationDepth::ATOM
-      end
     end
   end
 end

data/src/foobara/agent/determine_next_command.rb

@@ -1,32 +1,13 @@
-require "foobara/llm_backed_command"
-
 module Foobara
   class Agent < CommandConnector
-    class DetermineNextCommand < Foobara::LlmBackedCommand
-      description "Accepts the current goal, which might already be accomplished, " \
-                  "and context of the work  " \
-                  "so far and returns the name of " \
-                  "the next command to run to make progress towards " \
-                  "accomplishing the goal. If the goal has already been accomplished then choose the " \
+    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."
 
-      inputs do
-        goal :string, :required, "The current goal to accomplish. If the goal has already been accomplished " \
-                                 "by the previous command runs then choose " \
-                                 "NotifyUserThatCurrentGoalHasBeenAccomplished to stop the loop."
-        context Context, :required, "Context of progress so far"
-        llm_model :string,
-                  one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
-                  default: "claude-3-7-sonnet-20250219",
-                  description: "The model to use for the LLM"
-      end
-
       result :string,
-             description: "Name of the next command to run to make progress " \
-                          "towards accomplishing the mission"
-      def association_depth
-        Foobara::JsonSchemaGenerator::AssociationDepth::ATOM
-      end
+             description: "Name of the next command to run"
     end
   end
 end

data/src/foobara/agent/determine_next_command_name_and_inputs.rb

@@ -1,33 +1,17 @@
-require "foobara/llm_backed_command"
+require_relative "determine_base"
 
 module Foobara
   class Agent < CommandConnector
-    class DetermineNextCommandNameAndInputs < Foobara::LlmBackedCommand
-      description "Accepts the current goal, which might already be accomplished, and context of the work  " \
-                  "so far and returns the inputs for " \
-                  "the next command to run to make progress towards " \
-                  "accomplishing the goal. If the goal has already been accomplished then choose the " \
+    class DetermineNextCommandNameAndInputs < DetermineBase
+      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."
 
-      inputs do
-        goal :string, :required, "The current goal to accomplish. If the goal has already been accomplished " \
-                                 "by the previous command runs then choose " \
-                                 "NotifyUserThatCurrentGoalHasBeenAccomplished to stop the loop."
-        context Context, :required, "Context of the progress towards the goal so far"
-        llm_model :string,
-                  one_of: Foobara::Ai::AnswerBot::Types::ModelEnum,
-                  default: "claude-3-7-sonnet-20250219",
-                  description: "The model to use for the LLM"
-      end
-
       result do
         command_name :string, :required
         inputs :attributes, :allow_nil
       end
-
-      def association_depth
-        Foobara::JsonSchemaGenerator::AssociationDepth::ATOM
-      end
     end
   end
 end

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

@@ -1,11 +1,25 @@
 module Foobara
   class Agent < CommandConnector
     class Context < Foobara::Model
+      class << self
+        def for(goal)
+          new(command_log: [], current_goal: goal)
+        end
+      end
+
       attributes do
+        current_goal :string, :required, "The current goal the agent needs to accomplish"
+        previous_goals [:string]
         # 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"
       end
+
+      def set_new_goal(goal)
+        self.previous_goals ||= []
+        previous_goals << current_goal
+        self.current_goal = goal
+      end
     end
   end
 end

data/src/foobara/agent.rb

@@ -67,8 +67,6 @@ module Foobara
       # TODO: this should work now, switch to this approach
       # add_default_inputs_transformer EntityToPrimaryKeyInputsTransformer
 
-      build_initial_context
-
       # TODO: push this convenience method up into base class?
       command_classes&.each do |command_class|
         connect(command_class)
@@ -120,6 +118,8 @@ module Foobara
       maximum_call_count: nil,
       llm_model: nil
     )
+      set_context_goal(goal)
+
       if result_type && self.result_type != result_type
         if self.result_type
           # :nocov:
@@ -144,7 +144,7 @@ module Foobara
         inputs = {
           goal:,
           final_result_type: self.result_type,
-          current_context: context,
+          context:,
           agent: self
         }
 
@@ -201,9 +201,12 @@ module Foobara
       end
     end
 
-    def build_initial_context
-      # TODO: shouldn't have to pass command_log here since it has a default, debug that
-      self.context ||= Context.new(command_log: [])
+    def set_context_goal(goal)
+      if context
+        context.set_new_goal(goal)
+      else
+        self.context = Context.for(goal)
+      end
     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.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Miles Georgi
@@ -54,6 +54,7 @@ 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_inputs_for_next_command.rb
 - src/foobara/agent/determine_next_command.rb
 - src/foobara/agent/determine_next_command_name_and_inputs.rb