swarm_memory 2.1.2 → 2.1.4

data/lib/swarm_sdk/swarm/mcp_configurator.rb

@@ -40,7 +40,7 @@ module SwarmSDK
           # Fetch tools from MCP server and register with chat
           # Tools are already in RubyLLM::Tool format
           tools = client.tools
-          tools.each { |tool| chat.with_tool(tool) }
+          tools.each { |tool| chat.add_tool(tool) }
 
           RubyLLM.logger.debug("SwarmSDK: Registered #{tools.size} tools from MCP server '#{server_config[:name]}' for agent #{agent_name}")
         rescue StandardError => e
@@ -138,13 +138,16 @@ module SwarmSDK
       # @param config [Hash] MCP server configuration
       # @return [Hash] Streamable configuration
       def build_streamable_config(config)
-        {
+        streamable_config = {
           url: config[:url],
           headers: config[:headers] || {},
           version: config[:version]&.to_sym || :http2,
-          oauth: config[:oauth],
-          rate_limit: config[:rate_limit],
         }
+
+        # Only include rate_limit if present
+        streamable_config[:rate_limit] = config[:rate_limit] if config[:rate_limit]
+
+        streamable_config
       end
     end
   end

data/lib/swarm_sdk/swarm/swarm_registry_builder.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module SwarmSDK
+  class Swarm
+    # Builder for swarm registry in DSL
+    #
+    # Supports registering external swarms for composable swarms pattern.
+    #
+    # @example
+    #   swarms do
+    #     register "code_review", file: "./swarms/code_review.rb"
+    #     register "testing", file: "./swarms/testing.yml", keep_context: false
+    #   end
+    #
+    # @example Inline swarm definition
+    #   swarms do
+    #     register "tester" do
+    #       lead :tester
+    #       agent :tester do
+    #         model "gpt-4o-mini"
+    #         system "You test code"
+    #       end
+    #     end
+    #   end
+    #
+    class SwarmRegistryBuilder
+      attr_reader :registrations
+
+      def initialize
+        @registrations = []
+      end
+
+      # Register a swarm from file, YAML string, or inline block
+      #
+      # @param name [String, Symbol] Registration name
+      # @param file [String, nil] Path to swarm file (.rb or .yml)
+      # @param yaml [String, nil] YAML content string
+      # @param keep_context [Boolean] Whether to preserve conversation state (default: true)
+      # @yield Optional block for inline swarm definition
+      # @raise [ArgumentError] If neither file, yaml, nor block provided
+      def register(name, file: nil, yaml: nil, keep_context: true, &block)
+        # Validate that exactly one source is provided
+        sources = [file, yaml, block].compact
+        if sources.empty?
+          raise ArgumentError, "register '#{name}' requires either file:, yaml:, or a block"
+        elsif sources.size > 1
+          raise ArgumentError, "register '#{name}' accepts only one of: file:, yaml:, or block (got #{sources.size})"
+        end
+
+        # Determine source type and store
+        source = if file
+          { type: :file, value: file }
+        elsif yaml
+          { type: :yaml, value: yaml }
+        else
+          { type: :block, value: block }
+        end
+
+        @registrations << {
+          name: name.to_s,
+          source: source,
+          keep_context: keep_context,
+        }
+      end
+    end
+  end
+end

data/lib/swarm_sdk/swarm/tool_configurator.rb

@@ -17,10 +17,6 @@ module SwarmSDK
         :Read,
         :Grep,
         :Glob,
-        :TodoWrite,
-        :Think,
-        :WebFetch,
-        :Clock,
       ].freeze
 
       # Scratchpad tools (added if scratchpad is enabled)
@@ -30,6 +26,17 @@ module SwarmSDK
         :ScratchpadList,
       ].freeze
 
+      # Filesystem tools that can be globally disabled for security
+      FILESYSTEM_TOOLS = [
+        :Read,
+        :Write,
+        :Edit,
+        :MultiEdit,
+        :Grep,
+        :Glob,
+        :Bash,
+      ].freeze
+
       def initialize(swarm, scratchpad_storage, plugin_storages = {})
         @swarm = swarm
         @scratchpad_storage = scratchpad_storage
@@ -50,6 +57,9 @@ module SwarmSDK
 
       # Create a tool instance by name
       #
+      # Uses the Registry factory pattern to instantiate tools based on their
+      # declared requirements. This eliminates the need for a giant case statement.
+      #
       # File tools and TodoWrite require agent context for tracking state.
       # Scratchpad tools require shared scratchpad instance.
       # Plugin tools are delegated to their respective plugins.
@@ -70,47 +80,14 @@ module SwarmSDK
           return create_plugin_tool(tool_name_sym, agent_name, directory, chat, agent_definition)
         end
 
-        case tool_name_sym
-        when :Read
-          Tools::Read.new(agent_name: agent_name, directory: directory)
-        when :Write
-          Tools::Write.new(agent_name: agent_name, directory: directory)
-        when :Edit
-          Tools::Edit.new(agent_name: agent_name, directory: directory)
-        when :MultiEdit
-          Tools::MultiEdit.new(agent_name: agent_name, directory: directory)
-        when :Bash
-          Tools::Bash.new(directory: directory)
-        when :Glob
-          Tools::Glob.new(directory: directory)
-        when :Grep
-          Tools::Grep.new(directory: directory)
-        when :TodoWrite
-          Tools::TodoWrite.new(agent_name: agent_name) # TodoWrite doesn't need directory
-        when :ScratchpadWrite
-          Tools::Scratchpad::ScratchpadWrite.create_for_scratchpad(@scratchpad_storage)
-        when :ScratchpadRead
-          Tools::Scratchpad::ScratchpadRead.create_for_scratchpad(@scratchpad_storage)
-        when :ScratchpadList
-          Tools::Scratchpad::ScratchpadList.create_for_scratchpad(@scratchpad_storage)
-        when :Think
-          Tools::Think.new
-        when :Clock
-          Tools::Clock.new
-        else
-          # Regular tools - get class from registry and instantiate
-          tool_class = Tools::Registry.get(tool_name_sym)
-          raise ConfigurationError, "Unknown tool: #{tool_name}" unless tool_class
-
-          # Check if tool is marked as :special but not handled in case statement
-          if tool_class == :special
-            raise ConfigurationError,
-              "Tool '#{tool_name}' requires special initialization but is not handled in create_tool_instance. " \
-                "This is a bug - #{tool_name} should be added to the case statement above."
-          end
+        # Use Registry factory pattern - tools declare their own requirements
+        context = {
+          agent_name: agent_name,
+          directory: directory,
+          scratchpad_storage: @scratchpad_storage,
+        }
 
-          tool_class.new
-        end
+        Tools::Registry.create(tool_name_sym, context)
       end
 
       # Wrap a tool instance with permissions validator if configured
@@ -144,6 +121,19 @@ module SwarmSDK
       # @param agent_name [Symbol] Agent name
       # @param agent_definition [AgentDefinition] Agent definition
       def register_explicit_tools(chat, tool_configs, agent_name:, agent_definition:)
+        # Validate filesystem tools if globally disabled
+        unless @swarm.allow_filesystem_tools
+          # Extract tool names from hashes and convert to symbols for comparison
+          forbidden = tool_configs.map { |tc| tc[:name].to_sym }.select { |name| FILESYSTEM_TOOLS.include?(name) }
+          unless forbidden.empty?
+            raise ConfigurationError,
+              "Filesystem tools are globally disabled (SwarmSDK.settings.allow_filesystem_tools = false) " \
+                "but agent '#{agent_name}' attempts to use: #{forbidden.join(", ")}.\n\n" \
+                "This is a system-wide security setting that cannot be overridden by swarm configuration.\n" \
+                "To use filesystem tools, set SwarmSDK.settings.allow_filesystem_tools = true before loading the swarm."
+          end
+        end
+
         tool_configs.each do |tool_config|
           tool_name = tool_config[:name]
           permissions_config = tool_config[:permissions]
@@ -151,14 +141,8 @@ module SwarmSDK
           # Create tool instance
           tool_instance = create_tool_instance(tool_name, agent_name, agent_definition.directory)
 
-          # Wrap with permissions validator if configured
-          tool_instance = wrap_tool_with_permissions(
-            tool_instance,
-            permissions_config,
-            agent_definition,
-          )
-
-          chat.with_tool(tool_instance)
+          # Wrap with permissions and add to chat
+          wrap_and_add_tool(chat, tool_instance, permissions_config, agent_definition)
         end
       end
 
@@ -177,6 +161,9 @@ module SwarmSDK
         # Register core default tools (unless disabled)
         if agent_definition.disable_default_tools != true
           DEFAULT_TOOLS.each do |tool_name|
+            # Skip filesystem tools if globally disabled
+            next if !@swarm.allow_filesystem_tools && FILESYSTEM_TOOLS.include?(tool_name)
+
             register_tool_if_not_disabled(chat, tool_name, explicit_tool_names, agent_name, agent_definition)
           end
 
@@ -202,19 +189,36 @@ module SwarmSDK
         return if tool_disabled?(tool_name, agent_definition.disable_default_tools)
 
         tool_instance = create_tool_instance(tool_name, agent_name, agent_definition.directory)
+        permissions_config = resolve_default_permissions(tool_name, agent_definition)
 
-        # Resolve permissions for default tool
-        permissions_config = agent_definition.agent_permissions[tool_name] ||
-          agent_definition.default_permissions[tool_name]
+        wrap_and_add_tool(chat, tool_instance, permissions_config, agent_definition)
+      end
 
-        # Wrap with permissions validator if configured
-        tool_instance = wrap_tool_with_permissions(
-          tool_instance,
-          permissions_config,
-          agent_definition,
-        )
+      # Wrap tool with permissions and add to chat
+      #
+      # This is the common pattern for registering tools:
+      # 1. Wrap with permissions validator (if configured)
+      # 2. Add to chat
+      #
+      # @param chat [Agent::Chat] The chat instance
+      # @param tool_instance [RubyLLM::Tool] Tool instance
+      # @param permissions_config [Hash, nil] Permissions configuration
+      # @param agent_definition [Agent::Definition] Agent definition
+      # @return [void]
+      def wrap_and_add_tool(chat, tool_instance, permissions_config, agent_definition)
+        tool_instance = wrap_tool_with_permissions(tool_instance, permissions_config, agent_definition)
+        chat.add_tool(tool_instance)
+      end
 
-        chat.with_tool(tool_instance)
+      # Resolve permissions for a default/plugin tool
+      #
+      # Looks up permissions in agent-specific config first, falls back to global defaults.
+      #
+      # @param tool_name [Symbol] Tool name
+      # @param agent_definition [Agent::Definition] Agent definition
+      # @return [Hash, nil] Permissions configuration or nil
+      def resolve_default_permissions(tool_name, agent_definition)
+        agent_definition.agent_permissions[tool_name] || agent_definition.default_permissions[tool_name]
       end
 
       # Create a tool instance via plugin
@@ -229,15 +233,21 @@ module SwarmSDK
         plugin = PluginRegistry.plugin_for_tool(tool_name)
         raise ConfigurationError, "Tool #{tool_name} is not provided by any plugin" unless plugin
 
-        # Get plugin storage for this agent
+        # V7.0: Extract base name for storage lookup (handles delegation instances)
+        # For primary agents: :tester → :tester (no change)
+        # For delegation instances: "tester@frontend" → :tester (extracts base)
+        base_name = agent_name.to_s.split("@").first.to_sym
+
+        # Get plugin storage using BASE NAME (shared across instances)
         plugin_storages = @plugin_storages[plugin.name] || {}
-        storage = plugin_storages[agent_name]
+        storage = plugin_storages[base_name] # ← Changed from agent_name to base_name
 
         # Build context for tool creation
+        # Pass full agent_name for tool state tracking (TodoWrite, ReadTracker, etc.)
         context = {
-          agent_name: agent_name,
+          agent_name: agent_name, # Full instance name for tool's use
           directory: directory,
-          storage: storage,
+          storage: storage, # Shared storage by base name
           agent_definition: agent_definition,
           chat: chat,
           tool_configurator: self,
@@ -259,10 +269,6 @@ module SwarmSDK
           # Check if plugin has storage enabled for this agent
           next unless plugin.storage_enabled?(agent_definition)
 
-          # Get plugin storage for this agent
-          plugin_storages = @plugin_storages[plugin.name] || {}
-          plugin_storages[agent_name]
-
           # Register each tool provided by the plugin
           plugin.tools.each do |tool_name|
             # Skip if already registered explicitly
@@ -279,18 +285,9 @@ module SwarmSDK
               agent_definition: agent_definition,
             )
 
-            # Resolve permissions for plugin tool
-            permissions_config = agent_definition.agent_permissions[tool_name] ||
-              agent_definition.default_permissions[tool_name]
+            permissions_config = resolve_default_permissions(tool_name, agent_definition)
 
-            # Wrap with permissions validator if configured
-            tool_instance = wrap_tool_with_permissions(
-              tool_instance,
-              permissions_config,
-              agent_definition,
-            )
-
-            chat.with_tool(tool_instance)
+            wrap_and_add_tool(chat, tool_instance, permissions_config, agent_definition)
           end
         end
       end
@@ -303,15 +300,21 @@ module SwarmSDK
       def tool_disabled?(tool_name, disable_config)
         return false if disable_config.nil?
 
+        # Normalize tool_name to symbol for comparison
+        tool_name_sym = tool_name.to_sym
+
         if disable_config == true
           # Disable all default tools
           true
         elsif disable_config.is_a?(Symbol)
           # Single tool name
-          disable_config == tool_name
+          disable_config == tool_name_sym
+        elsif disable_config.is_a?(String)
+          # Single tool name as string (from YAML)
+          disable_config.to_sym == tool_name_sym
         elsif disable_config.is_a?(Array)
-          # Disable only tools in the array
-          disable_config.include?(tool_name)
+          # Disable only tools in the array - normalize to symbols for comparison
+          disable_config.map(&:to_sym).include?(tool_name_sym)
         else
           false
         end
@@ -344,76 +347,12 @@ module SwarmSDK
             delegate_chat: delegate_agent,
             agent_name: agent_name,
             swarm: @swarm,
-            hook_registry: @hook_registry,
             delegating_chat: chat,
           )
 
-          chat.with_tool(tool)
-        end
-      end
-
-      # Pass 4: Configure hook system
-      #
-      # Setup the callback system for each agent.
-      def pass_4_configure_hooks
-        @agents.each do |agent_name, chat|
-          agent_definition = @agent_definitions[agent_name]
-
-          chat.setup_hooks(
-            registry: @hook_registry,
-            agent_definition: agent_definition,
-            swarm: @swarm,
-          ) if chat.respond_to?(:setup_hooks)
-        end
-      end
-
-      # Pass 5: Apply YAML hooks if present
-      #
-      # If loaded from YAML, apply agent-specific hooks.
-      def pass_5_apply_yaml_hooks
-        return unless @config_for_hooks
-
-        @agents.each do |agent_name, chat|
-          agent_def = @config_for_hooks.agents[agent_name]
-          next unless agent_def&.hooks
-
-          HooksAdapter.apply_agent_hooks(chat, agent_name, agent_def.hooks, @swarm.name)
+          chat.add_tool(tool)
         end
       end
-
-      # Create an AgentChat instance
-      #
-      # NOTE: This is dead code, left over from refactoring. AgentInitializer
-      # now handles agent creation. This should be removed in a cleanup pass.
-      #
-      # @param agent_name [Symbol] Agent name
-      # @param agent_definition [AgentDefinition] Agent definition
-      # @param tool_configurator [ToolConfigurator] Tool configurator
-      # @return [AgentChat] Configured chat instance
-      def create_agent_chat(agent_name, agent_definition, tool_configurator)
-        chat = AgentChat.new(
-          definition: agent_definition.to_h,
-          global_semaphore: @global_semaphore,
-        )
-
-        # Set agent name on provider for logging (if provider supports it)
-        chat.provider.agent_name = agent_name if chat.provider.respond_to?(:agent_name=)
-
-        # Register tools
-        tool_configurator.register_all_tools(
-          chat: chat,
-          agent_name: agent_name,
-          agent_definition: agent_definition,
-        )
-
-        # Register MCP servers if any
-        if agent_definition.mcp_servers.any?
-          mcp_configurator = McpConfigurator.new(@swarm)
-          mcp_configurator.register_mcp_servers(chat, agent_definition.mcp_servers, agent_name: agent_name)
-        end
-
-        chat
-      end
     end
   end
 end