foobara-agent 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88666f0c9353fd88d386752d774b3a5abac7bf035b9349769049a1e633fb6a4e
-  data.tar.gz: 60a09c5cd82d3c4b580ab3224875bc78b3086f04d91e3c28da6708483d4b3806
+  metadata.gz: 88347fd73d897f4a3f05eb2dcec999c5afddcec625cecc79a44a1a803394b352
+  data.tar.gz: '016936d6acc4e2497aa8e8853d058653d201d3d7d5c2c77090128b728f8833fe'
 SHA512:
-  metadata.gz: 5590b86e0dbb6baf8feac06ed1dce7a95a066acf3d684203dff92b86adb1fc329a217ec702affa332d9b6b6c2d6d187b5e3c960ee4b22a7263c0412760fd30c2
-  data.tar.gz: 13e01dd7118c05188ffd6a58ba51923eec81b14b227506a6fdeaf0c731dfef4bc41a14a052f2c17c2e46e3d32438a181ff906a082bf7f123ee7210fca1efc959
+  metadata.gz: 5672d6bd7930969b566d6dce04314062116593cd2df5c06d718916d83938deb91af64765a85752f7b5c8119d0fce32a56099907b252da636f0408fb3109bf38c
+  data.tar.gz: 71b2c350e024aca9d86c1f5f2bfd3d83726784ab028c6d7b6e0010a88512c1a06351cfbb298478fc1e5f6b5126367e9bca5d417040b9d493153fe7d142b20faa

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.0.5] - 2025-05-30
+
+- Don't require agents to have a name
+
+## [0.0.4] - 2025-05-30
+
+- Refactor agent to be a command connector
+
 ## [0.0.3] - 2025-05-30
 
 - Increase the retries, attempt to improve command descriptions,

data/lib/foobara/agent.rb

@@ -3,7 +3,7 @@ require "foobara/ai"
 require "foobara/command_connectors"
 
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     foobara_domain!
 
     foobara_depends_on Foobara::Ai::AnswerBot

data/src/foobara/agent/accomplish_goal.rb

@@ -2,7 +2,7 @@ require_relative "list_commands"
 
 module Foobara
   # TODO: should agent maybe be a command connector? It feels a bit more like a command connector.
-  class Agent
+  class Agent < CommandConnector
     class AccomplishGoal < Foobara::Command
       possible_error :gave_up, context: { reason: :string }, message: "Gave up."
       possible_error :too_many_command_calls,
@@ -115,19 +115,17 @@ module Foobara
         @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 ||= Connector.new(
-          accomplish_goal_command: self,
-          default_serializers: [
-            Foobara::CommandConnectors::Serializers::ErrorsSerializer,
-            Foobara::CommandConnectors::Serializers::AtomicSerializer
-          ],
+        self.command_connector ||= Agent.new(
+          current_accomplish_goal_command: self,
           llm_model:
         )
       end
 
       def set_accomplished_goal_command
-        command_connector.accomplish_goal_command = self
+        command_connector.current_accomplish_goal_command = self
       end
 
       def connect_agent_commands
@@ -160,7 +158,9 @@ module Foobara
         outcome = begin
           determine_command.run
         rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
+          # :nocov:
           Outcome.errors(e.errors)
+          # :nocov:
         end
 
         if outcome.success?
@@ -286,7 +286,9 @@ module Foobara
                                    outcome = begin
                                      command.run
                                    rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
+                                     # :nocov:
                                      Outcome.errors(e.errors)
+                                     # :nocov:
                                    end
 
                                    if outcome.success?
@@ -345,7 +347,9 @@ module Foobara
                                      outcome = begin
                                        command.run
                                      rescue CommandPatternImplementation::Concerns::Result::CouldNotProcessResult => e
+                                       # :nocov:
                                        Outcome.errors(e.errors)
+                                       # :nocov:
                                      end
 
                                      if outcome.success?

data/src/foobara/agent/concerns/subclass_cacheable.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     module Concerns
       # There's nothing really subclass-specific about this concern, maybe rename it...
       module SubclassCacheable

data/src/foobara/agent/connector/set_command_connector_inputs_transformer.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     class SetCommandConnectorInputsTransformer < TypeDeclarations::TypedTransformer
       class << self
         attr_accessor :command_connector

data/src/foobara/agent/describe_command.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     class DescribeCommand < Foobara::Command
       inputs do
         command_connector :duck, :required, "Connector to find relevant command in"
@@ -52,7 +52,7 @@ module Foobara
       end
 
       def mark_command_as_described
-        command_connector.accomplish_goal_command.described_commands << command_class.full_command_name
+        command_connector.current_accomplish_goal_command.described_commands << command_class.full_command_name
       end
     end
   end

data/src/foobara/agent/describe_type.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     class DescribeType < Foobara::Command
       inputs do
         command_connector :duck, :required, "Connector to find relevant type in"

data/src/foobara/agent/determine_inputs_for_next_command.rb

@@ -1,7 +1,7 @@
 require "foobara/llm_backed_command"
 
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     class DetermineInputsForNextCommand < Foobara::LlmBackedCommand
       extend Concerns::SubclassCacheable
 

data/src/foobara/agent/determine_next_command.rb

@@ -1,7 +1,7 @@
 require "foobara/llm_backed_command"
 
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     class DetermineNextCommand < Foobara::LlmBackedCommand
       extend Concerns::SubclassCacheable
 

data/src/foobara/agent/determine_next_command_name_and_inputs.rb

@@ -1,7 +1,7 @@
 require "foobara/llm_backed_command"
 
 module Foobara
-  class Agent
+  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 " \

data/src/foobara/agent/give_up.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     class GiveUp < Foobara::Command
       inputs do
         command_connector CommandConnector, :required, "Connector to end"

data/src/foobara/agent/list_commands.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     class ListCommands < Foobara::Command
       inputs do
         command_connector :duck, :required, "Connector to end"

data/src/foobara/agent/list_types.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     class ListTypes < Foobara::Command
       inputs do
         command_connector :duck, :required, "Connector to fetch types from"

data/src/foobara/agent/notify_user_that_current_goal_has_been_accomplished.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     class NotifyUserThatCurrentGoalHasBeenAccomplished < Foobara::Command
       extend Concerns::SubclassCacheable
 
@@ -71,6 +71,7 @@ module Foobara
         data = if result_type
                  inputs[:result_data]
                end
+
         command_connector.mark_mission_accomplished(data, message_to_user)
       end
 

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

@@ -1,5 +1,5 @@
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     class CommandLogEntry < Foobara::Model
       attributes do
         command_name :string, :required, "Name of the command that was run"

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

@@ -1,5 +1,5 @@
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     class Context < Foobara::Model
       attributes do
         # TODO: why doesn't this default of [] work as expected on newly created models?

data/src/foobara/agent.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Agent
+  class Agent < CommandConnector
     StateMachine = Foobara::StateMachine.for(
       [:initialized, :idle, :error, :failure] => {
         kill: :killed,
@@ -14,32 +14,54 @@ module Foobara
     )
 
     attr_accessor :context,
-                  :agent_command_connector,
                   :agent_name,
                   :llm_model,
                   :current_accomplish_goal_command,
-                  :result_type
+                  :result_type,
+                  :agent_commands_connected
 
     def initialize(
       context: nil,
       agent_name: nil,
       command_classes: nil,
-      agent_command_connector: nil,
       llm_model: nil,
-      result_type: nil
+      result_type: nil,
+      current_accomplish_goal_command: nil,
+      **opts
     )
       # TODO: shouldn't have to pass command_log here since it has a default, debug that
       self.context = context
-      self.agent_command_connector = agent_command_connector
       self.agent_name = agent_name if agent_name
       self.llm_model = llm_model
       self.result_type = result_type
+      self.current_accomplish_goal_command = current_accomplish_goal_command
+
+      unless opts.key?(:default_serializers)
+        opts = opts.merge(default_serializers: [
+                            Foobara::CommandConnectors::Serializers::ErrorsSerializer,
+                            Foobara::CommandConnectors::Serializers::AtomicSerializer
+                          ])
+      end
+
+      super(**opts)
 
       build_initial_context
-      build_agent_command_connector
 
+      # TODO: push this convenience method up into base class?
       command_classes&.each do |command_class|
-        self.agent_command_connector.connect(command_class)
+        connect(command_class)
+      end
+    end
+
+    def run(*args, **)
+      if args.first.is_a?(::String)
+        accomplish_goal(*args, **)
+      else
+        unless agent_commands_connected?
+          connect_agent_commands
+        end
+
+        super
       end
     end
 
@@ -66,7 +88,7 @@ module Foobara
           # :nocov:
           raise ArgumentError, "You can only specify a result type once"
           # :nocov:
-        elsif agent_command_connector.agent_commands_connected?
+        elsif agent_commands_connected?
           # :nocov:
           raise ArgumentError, "You can't specify a result type this late in the process"
           # :nocov:
@@ -82,10 +104,13 @@ module Foobara
           goal:,
           final_result_type: self.result_type,
           current_context: context,
-          existing_command_connector: agent_command_connector,
-          agent_name:
+          existing_command_connector: self
         }
 
+        if agent_name
+          inputs[:agent_name] = agent_name
+        end
+
         if llm_model
           inputs[:llm_model] = llm_model
         end
@@ -120,15 +145,45 @@ module Foobara
       self.context ||= Context.new(command_log: [])
     end
 
-    def build_agent_command_connector
-      self.agent_command_connector ||= Connector.new(
-        accomplish_goal_command: self,
-        llm_model:,
-        default_serializers: [
-          Foobara::CommandConnectors::Serializers::ErrorsSerializer,
-          Foobara::CommandConnectors::Serializers::AtomicSerializer
-        ]
-      )
+    def mark_mission_accomplished(final_result, message_to_user)
+      # TODO: this is a pretty awkward way to communicate between commands hmmm...
+      # maybe see if there's a less hacky way to pull this off.
+      current_accomplish_goal_command.mission_accomplished!(final_result, message_to_user)
+    end
+
+    def give_up(reason)
+      current_accomplish_goal_command.give_up!(reason)
+    end
+
+    def agent_commands_connected?
+      agent_commands_connected
+    end
+
+    def connect_agent_commands(final_result_type: nil, agent_name: nil)
+      command_classes = [
+        DescribeCommand,
+        DescribeType,
+        GiveUp,
+        ListCommands,
+        ListTypes
+      ]
+
+      command_classes << if final_result_type
+                           NotifyUserThatCurrentGoalHasBeenAccomplished.for(
+                             result_type: final_result_type,
+                             agent_id: agent_name
+                           )
+                         else
+                           NotifyUserThatCurrentGoalHasBeenAccomplished
+                         end
+
+      set_command_connector_transformer = SetCommandConnectorInputsTransformer.for(self)
+
+      command_classes.each do |command_class|
+        connect(command_class, inputs: set_command_connector_transformer)
+      end
+
+      self.agent_commands_connected = true
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-agent
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Miles Georgi
@@ -51,7 +51,6 @@ files:
 - src/foobara/agent.rb
 - src/foobara/agent/accomplish_goal.rb
 - src/foobara/agent/concerns/subclass_cacheable.rb
-- src/foobara/agent/connector/connector.rb
 - src/foobara/agent/connector/set_command_connector_inputs_transformer.rb
 - src/foobara/agent/describe_command.rb
 - src/foobara/agent/describe_type.rb

data/src/foobara/agent/connector/connector.rb

@@ -1,59 +0,0 @@
-require "foobara/command_connectors"
-
-module Foobara
-  class Agent
-    class Connector < Foobara::CommandConnector
-      attr_accessor :accomplish_goal_command, :agent_commands_connected, :llm_model
-
-      def initialize(*, accomplish_goal_command:, llm_model: nil, **)
-        self.accomplish_goal_command = accomplish_goal_command
-        self.llm_model = llm_model
-
-        super(*, **)
-      end
-
-      def mark_mission_accomplished(final_result, message_to_user)
-        # TODO: this is a pretty awkward way to communicate between commands hmmm...
-        # maybe see if there's a less hacky way to pull this off.
-        accomplish_goal_command.mission_accomplished!(final_result, message_to_user)
-      end
-
-      def give_up(reason)
-        accomplish_goal_command.give_up!(reason)
-      end
-
-      def agent_commands_connected?
-        agent_commands_connected
-      end
-
-      def connect_agent_commands(final_result_type: nil, agent_name: nil)
-        command_classes = [
-          DescribeCommand,
-          DescribeType,
-          GiveUp,
-          ListCommands,
-          ListTypes
-        ]
-
-        command_classes << if final_result_type
-                             NotifyUserThatCurrentGoalHasBeenAccomplished.for(
-                               result_type: final_result_type,
-                               agent_id: agent_name
-                             )
-                           else
-                             NotifyUserThatCurrentGoalHasBeenAccomplished
-                           end
-
-        command_classes.each do |command_class|
-          connect(command_class, inputs: set_command_connector_transformer)
-        end
-
-        self.agent_commands_connected = true
-      end
-
-      def set_command_connector_transformer
-        @set_command_connector_transformer ||= SetCommandConnectorInputsTransformer.for(self)
-      end
-    end
-  end
-end