foobara-agent 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 121474f4e61c1b3a5eebc883794bef41159d48ecc05eba44165bd8d79111c426
-  data.tar.gz: 50bc4c4aea5bd447f17cf39712b7a86295e4f45708602398f72a61af2f221881
+  metadata.gz: 968399c2d338c8f069712d0ad9437b928fe48bc7356e88fd86b9ff6fb7ae235f
+  data.tar.gz: 8483b856faf2f559985550cc631764121797f88963c0baf428b7f16646bd8b59
 SHA512:
-  metadata.gz: e0cbf20f7fc287bd4a3be5caed0572de59475493ae4bed80d755b5284ead25fa697b455959ca323891bb20f0bfb57a5a01f1e62f335faacc6c99c220821920f3
-  data.tar.gz: cf85ac42b6ab4a9f8efddd35e533afd32f664b9a9ec8bba17f77abf424a5499e64ba6ad576b54bb24c03dadb5e6bc1c2fe54a502bd505f30caaeeb15e002d655
+  metadata.gz: 79be2912847cb407d1ad65166313c8b799b981a2b0da6f8c8e3f8132049c1eb67ec56a9307fdf887f8e659299883f0da4517762abc885fdf8b69949f869f54de
+  data.tar.gz: 169c02a8070d5feb4d307b41ff757294ca5a2e3b810ac0766cece386a357db2cf85075ae9ecb1f5ee2e0b1ec92c855eb202ee4166102a88341b8e5b4268eeb92

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [0.0.7] - 2025-06-23
+
+- 
+
 ## [0.0.6] - 2025-06-19
 
 - Do not run next command with pre-cast inputs

data/src/foobara/agent/accomplish_goal.rb

@@ -8,16 +8,14 @@ module Foobara
                      context: { maximum_command_calls: :integer }
 
       inputs do
-        agent_name :string, "Name of the agent"
         goal :string, :required, "What do you want the agent to attempt to accomplish?"
         # TODO: we should be able to specify a subclass as a type
-        command_classes [Class], "Commands that can be ran to accomplish the goal"
         final_result_type :duck, "Specifies how the result of the goal is to be structured"
+        include_message_to_user_in_result :boolean, default: true
         verbose :boolean, default: false
         io_out :duck
         io_err :duck
-        existing_command_connector CommandConnector, :allow_nil,
-                                   "A connector containing already-connected commands for the agent to use"
+        agent Agent, :required
         current_context Context, :allow_nil, "The current context of the agent"
         maximum_command_calls :integer,
                               :allow_nil,
@@ -44,7 +42,7 @@ module Foobara
       end
 
       result do
-        message_to_user :string, :required, "Message to the user about successfully accomplishing the goal"
+        message_to_user :string, :allow_nil, "Message to the user about successfully accomplishing the goal"
         result_data :duck, "Optional result data to return to the user if final_result_type was given"
       end
 
@@ -53,17 +51,6 @@ module Foobara
       def execute
         build_initial_context_if_necessary
 
-        if command_connector_passed_in?
-          set_accomplished_goal_command
-        else
-          build_command_connector
-          connect_user_provided_commands
-        end
-
-        unless agent_commands_connected?
-          connect_agent_commands
-        end
-
         simulate_list_commands_run
         simulate_describe_command_run_for_all_commands
 
@@ -88,27 +75,10 @@ module Foobara
         build_result
       end
 
-      def agent_commands_connected?
-        command_connector.agent_commands_connected?
-      end
-
-      def validate
-        validate_either_command_classes_or_connector_given
-      end
-
-      def validate_either_command_classes_or_connector_given
-        # TODO: implement this!
-      end
-
       attr_accessor :context, :next_command_name, :next_command_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
-      attr_writer :command_connector
-
-      def agent_name
-        @agent_name ||= inputs[:agent_name] || "Anon#{SecureRandom.hex(2)}"
-      end
 
       def build_initial_context_if_necessary
         # TODO: shouldn't have to pass command_log here since it has a default, debug that
@@ -129,7 +99,7 @@ module Foobara
       def simulate_describe_command_run_for_all_commands
         return if context.command_log.size > 1
 
-        ListCommands.run!(command_connector:)[:user_provided_commands].each do |full_command_name|
+        ListCommands.run!(command_connector: agent)[:user_provided_commands].each do |full_command_name|
           next if described_commands.include?(full_command_name)
 
           self.next_command_name = DescribeCommand.full_command_name
@@ -141,39 +111,6 @@ module Foobara
         end
       end
 
-      def command_connector_passed_in?
-        existing_command_connector
-      end
-
-      def command_connector
-        @command_connector ||= existing_command_connector
-      end
-
-      # Do we really want to support calling AccomplishGoal outside the context of an Agent?
-      # If not, just delete this awkward coupling
-      def build_command_connector
-        self.command_connector ||= Agent.new(
-          current_accomplish_goal_command: self,
-          llm_model:,
-          verbose:,
-          io_out:
-        )
-      end
-
-      def set_accomplished_goal_command
-        command_connector.current_accomplish_goal_command = self
-      end
-
-      def connect_agent_commands
-        command_connector.connect_agent_commands(final_result_type:, agent_name:)
-      end
-
-      def connect_user_provided_commands
-        command_classes.each do |command_class|
-          command_connector.connect(command_class)
-        end
-      end
-
       def determine_next_command_and_inputs(retries = 2)
         inputs_for_determine = {
           goal:,
@@ -348,11 +285,11 @@ module Foobara
       end
 
       def all_command_classes
-        @all_command_classes ||= run_subcommand!(ListCommands, command_connector:).values.flatten
+        @all_command_classes ||= run_subcommand!(ListCommands, command_connector: agent).values.flatten
       end
 
       def fetch_next_command_class
-        self.next_command_class = command_connector.transformed_command_from_name(next_command_name)
+        self.next_command_class = agent.transformed_command_from_name(next_command_name)
       end
 
       def determine_next_command_inputs(retries = 2)
@@ -417,7 +354,7 @@ module Foobara
           (io_out || $stdout).puts "Running #{next_command_name} with #{next_command_inputs}"
         end
 
-        self.command_response = command_connector.run(
+        self.command_response = agent.run(
           full_command_name: next_command_name,
           inputs: next_command_inputs,
           action: "run"
@@ -528,6 +465,10 @@ module Foobara
         choose_next_command_and_next_inputs_separately
       end
 
+      def agent_name
+        agent.agent_name
+      end
+
       def verbose?
         verbose
       end

data/src/foobara/agent/notify_user_that_current_goal_has_been_accomplished.rb

@@ -6,8 +6,10 @@ module Foobara
       class << self
         attr_accessor :command_class
 
-        def for(result_type:, agent_id:)
-          cached_subclass([result_type, agent_id]) do
+        def for(agent_id: nil, result_type: nil, include_message_to_user_in_result: true)
+          agent_id ||= "Anon#{SecureRandom.hex(2)}"
+
+          cached_subclass([result_type, agent_id, include_message_to_user_in_result]) do
             command_name = "Foobara::Agent::#{agent_id}::NotifyUserThatCurrentGoalHasBeenAccomplished"
             klass = Util.make_class_p(command_name, self)
 
@@ -16,32 +18,50 @@ module Foobara
                               "result schema and an optional message to the user. " \
                               "The user might issue a new goal."
 
-            inputs do
-              command_connector CommandConnector, :required, "Connector to notify user through"
-              message_to_user :string, :required, "Message to the user about what was done"
-            end
-
             if result_type
-              add_inputs do
-                result_data result_type, :required
+              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.result do
+                  result result_type, :required
+                  message_to_user :string, :required, "Message to the user about what was done"
+                end
+
+                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
+                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.result do
-                message_to_user :string, :required
-                result_data result_type, :required
+                message_to_user :string, :required, "Message to the user about what was done"
               end
-              klass.description "Notifies the user that the current goal has been accomplished and returns a final " \
-                                "result formatted according to the " \
-                                "result schema if relevant and an optional message to the user. " \
-                                "The user might issue a new goal."
 
+              klass.description "Notifies the user that the current goal has been accomplished and results in a " \
+                                "message to the user. " \
+                                "The user might issue a new goal."
             else
-              # TODO: test this code path
+              # This should be unreachable actually
               # :nocov:
-              klass.description "Notifies the user that the current goal has been accomplished and, if relevant,  " \
-                                "returns a final " \
-                                "result formatted according to the " \
-                                "result schema and an optional message to the user. " \
+              klass.description "Notifies the user that the current goal has been accomplished. " \
                                 "The user might issue a new goal."
               # :nocov:
             end
@@ -55,10 +75,7 @@ module Foobara
                   "result schema if relevant and an optional message to the user."
 
       inputs do
-        # TODO: Are we still not able to uses classes as foobara types??
-        command_connector :duck, :required, "Connector to end"
-        message_to_user :string, :required, "Message to the user about what was done"
-        result_data :duck, "The final result of the work if relevant/expected"
+        command_connector CommandConnector, :required, "Connector to notify user through"
       end
 
       def execute
@@ -68,21 +85,18 @@ module Foobara
       end
 
       def mark_mission_accomplished
-        data = if result_type
-                 inputs[:result_data]
-               end
-
-        command_connector.mark_mission_accomplished(data, message_to_user)
+        command_connector.mark_mission_accomplished(inputs[:result], inputs[:message_to_user])
       end
 
       def parsed_result
-        h = { message_to_user: }
+        inputs_type = self.class.inputs_type
+        element_types = inputs_type.element_types
 
-        if inputs[:result_data] && result_type
-          h[:result_data] = result_data
+        if element_types.key?(:message_to_user)
+          inputs.slice(:result, :message_to_user)
+        elsif element_types.key?(:result)
+          inputs[:result]
         end
-
-        h
       end
     end
   end

data/src/foobara/agent.rb

@@ -18,6 +18,7 @@ module Foobara
                   :llm_model,
                   :current_accomplish_goal_command,
                   :result_type,
+                  :include_message_to_user_in_result,
                   :agent_commands_connected,
                   :verbose,
                   :io_out,
@@ -29,7 +30,7 @@ module Foobara
       command_classes: nil,
       llm_model: nil,
       result_type: nil,
-      current_accomplish_goal_command: nil,
+      include_message_to_user_in_result: true,
       verbose: false,
       io_out: nil,
       io_err: nil,
@@ -37,10 +38,10 @@ module Foobara
     )
       # TODO: shouldn't have to pass command_log here since it has a default, debug that
       self.context = context
-      self.agent_name = agent_name if agent_name
+      self.agent_name = agent_name || "Anon#{SecureRandom.hex(2)}"
       self.llm_model = llm_model
       self.result_type = result_type
-      self.current_accomplish_goal_command = current_accomplish_goal_command
+      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
@@ -107,7 +108,8 @@ module Foobara
       goal,
       result_type: nil,
       choose_next_command_and_next_inputs_separately: nil,
-      maximum_call_count: nil
+      maximum_call_count: nil,
+      llm_model: nil
     )
       if result_type && self.result_type != result_type
         if self.result_type
@@ -123,6 +125,10 @@ module Foobara
         end
       end
 
+      unless agent_commands_connected?
+        connect_agent_commands
+      end
+
       state_machine.perform_transition!(:accomplish_goal)
 
       begin
@@ -130,12 +136,10 @@ module Foobara
           goal:,
           final_result_type: self.result_type,
           current_context: context,
-          existing_command_connector: self
+          agent: self
         }
 
-        if agent_name
-          inputs[:agent_name] = agent_name
-        end
+        llm_model ||= self.llm_model
 
         if llm_model
           inputs[:llm_model] = llm_model
@@ -161,14 +165,20 @@ module Foobara
           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
+
         self.current_accomplish_goal_command = AccomplishGoal.new(inputs)
 
         current_accomplish_goal_command.run.tap do |outcome|
-          if outcome.success?
-            state_machine.perform_transition!(:goal_accomplished)
-          else
-            state_machine.perform_transition!(:goal_errored)
-          end
+          transition = if outcome.success?
+                         :goal_accomplished
+                       else
+                         :goal_errored
+                       end
+
+          state_machine.perform_transition!(transition)
         end
       rescue
         # :nocov:
@@ -197,19 +207,21 @@ module Foobara
       agent_commands_connected
     end
 
-    def connect_agent_commands(final_result_type: nil, agent_name: nil)
+    def connect_agent_commands
       command_classes = [
         DescribeCommand,
         DescribeType,
         GiveUp,
-        ListCommands,
-        ListTypes
+        ListCommands
       ]
 
-      command_classes << if final_result_type
+      command_classes << if result_type || include_message_to_user_in_result
+                           # TODO: Support changing the final result type when the goal changes
                            NotifyUserThatCurrentGoalHasBeenAccomplished.for(
-                             result_type: final_result_type,
-                             agent_id: agent_name
+                             result_type:,
+                             agent_id: agent_name,
+                             # TODO: Support changing this flag when the goal changes
+                             include_message_to_user_in_result:
                            )
                          else
                            NotifyUserThatCurrentGoalHasBeenAccomplished

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-agent
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Miles Georgi
@@ -59,7 +59,6 @@ files:
 - src/foobara/agent/determine_next_command_name_and_inputs.rb
 - src/foobara/agent/give_up.rb
 - src/foobara/agent/list_commands.rb
-- src/foobara/agent/list_types.rb
 - 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

data/src/foobara/agent/list_types.rb

@@ -1,23 +0,0 @@
-module Foobara
-  class Agent < CommandConnector
-    class ListTypes < Foobara::Command
-      inputs do
-        command_connector :duck, :required, "Connector to fetch types from"
-      end
-
-      result [:string]
-
-      def execute
-        construct_type_list
-
-        type_list
-      end
-
-      attr_accessor :type_list
-
-      def construct_type_list
-        self.type_list = command_connector.all_exposed_type_names
-      end
-    end
-  end
-end