claude_swarm 1.0.9 → 1.0.11

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/tool_configurator.rb

@@ -57,6 +57,14 @@ 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.
+      #
+      # Tool lookup order:
+      # 1. Plugin tools (registered via SwarmSDK::PluginRegistry)
+      # 2. Custom tools (registered via SwarmSDK.register_tool)
+      # 3. Built-in tools (SwarmSDK::Tools::Registry)
+      #
       # File tools and TodoWrite require agent context for tracking state.
       # Scratchpad tools require shared scratchpad instance.
       # Plugin tools are delegated to their respective plugins.
@@ -77,47 +85,23 @@ 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 a custom registered tool
+        if CustomToolRegistry.registered?(tool_name_sym)
+          context = {
+            agent_name: agent_name,
+            directory: directory,
+          }
+          return CustomToolRegistry.create(tool_name_sym, context)
+        end
 
-          # 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 for built-in tools
+        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
@@ -157,10 +141,10 @@ module SwarmSDK
           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) " \
+              "Filesystem tools are globally disabled (SwarmSDK.config.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."
+                "To use filesystem tools, set SwarmSDK.config.allow_filesystem_tools = true before loading the swarm."
           end
         end
 
@@ -171,14 +155,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
 
@@ -225,19 +203,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
@@ -286,11 +281,7 @@ module SwarmSDK
       def register_plugin_tools(chat, agent_name, agent_definition, explicit_tool_names)
         PluginRegistry.all.each do |plugin|
           # 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]
+          next unless plugin.memory_configured?(agent_definition)
 
           # Register each tool provided by the plugin
           plugin.tools.each do |tool_name|
@@ -308,18 +299,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]
-
-            # Wrap with permissions validator if configured
-            tool_instance = wrap_tool_with_permissions(
-              tool_instance,
-              permissions_config,
-              agent_definition,
-            )
+            permissions_config = resolve_default_permissions(tool_name, agent_definition)
 
-            chat.with_tool(tool_instance)
+            wrap_and_add_tool(chat, tool_instance, permissions_config, agent_definition)
           end
         end
       end
@@ -379,76 +361,12 @@ module SwarmSDK
             delegate_chat: delegate_agent,
             agent_name: agent_name,
             swarm: @swarm,
-            hook_registry: @hook_registry,
             delegating_chat: chat,
           )
 
-          chat.with_tool(tool)
+          chat.add_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)
-        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