swarm_sdk 2.2.0 → 2.3.0

data/lib/swarm_sdk/tools/bash.rb

@@ -7,6 +7,13 @@ module SwarmSDK
     # Executes commands in a persistent shell session with timeout support.
     # Provides comprehensive guidance on proper usage patterns.
     class Bash < RubyLLM::Tool
+      # Factory pattern: declare what parameters this tool needs for instantiation
+      class << self
+        def creation_requirements
+          [:directory]
+        end
+      end
+
       def initialize(directory:)
         super()
         @directory = File.expand_path(directory)
@@ -78,9 +85,10 @@ module SwarmSDK
         desc: "Optional timeout in milliseconds (max 600000)",
         required: false
 
-      DEFAULT_TIMEOUT_MS = 120_000 # 2 minutes
-      MAX_TIMEOUT_MS = 600_000 # 10 minutes
-      MAX_OUTPUT_LENGTH = 30_000 # characters
+      # Backward compatibility aliases - use Defaults module for new code
+      DEFAULT_TIMEOUT_MS = Defaults::Timeouts::BASH_COMMAND_MS
+      MAX_TIMEOUT_MS = Defaults::Timeouts::BASH_COMMAND_MAX_MS
+      MAX_OUTPUT_LENGTH = Defaults::Limits::OUTPUT_CHARACTERS
 
       # Commands that are ALWAYS blocked for safety reasons
       # These cannot be overridden by permissions configuration

data/lib/swarm_sdk/tools/delegate.rb

@@ -2,12 +2,30 @@
 
 module SwarmSDK
   module Tools
-    # Delegate tool for delegating tasks to other agents in the swarm
+    # Delegate tool for working with other agents in the swarm
     #
-    # Creates agent-specific delegation tools (e.g., DelegateTaskToBackend)
-    # that allow one agent to delegate work to another agent.
+    # Creates agent-specific collaboration tools (e.g., WorkWithBackend)
+    # that allow one agent to work with another agent.
     # Supports pre/post delegation hooks for customization.
     class Delegate < RubyLLM::Tool
+      # Tool name prefix for delegation tools
+      # Change this to customize the tool naming pattern (e.g., "DelegateTaskTo", "AskAgent", etc.)
+      TOOL_NAME_PREFIX = "WorkWith"
+
+      class << self
+        # Generate tool name for a delegate agent
+        #
+        # This is the single source of truth for delegation tool naming.
+        # Used both when creating Delegate instances and when predicting tool names
+        # for agent context setup.
+        #
+        # @param delegate_name [String, Symbol] Name of the delegate agent
+        # @return [String] Tool name (e.g., "WorkWithBackend")
+        def tool_name_for(delegate_name)
+          "#{TOOL_NAME_PREFIX}#{delegate_name.to_s.capitalize}"
+        end
+      end
+
       attr_reader :delegate_name, :delegate_target, :tool_name
 
       # Initialize a delegation tool
@@ -16,10 +34,7 @@ module SwarmSDK
       # @param delegate_description [String] Description of the delegate agent
       # @param delegate_chat [AgentChat, nil] The chat instance for the delegate agent (nil if delegating to swarm)
       # @param agent_name [Symbol, String] Name of the agent using this tool
-      # @param swarm [Swarm] The swarm instance
-      # @param hook_registry [Hooks::Registry] Registry for callbacks
-      # @param call_stack [Array] Delegation call stack for circular dependency detection
-      # @param swarm_registry [SwarmRegistry, nil] Registry for sub-swarms (nil if not using composable swarms)
+      # @param swarm [Swarm] The swarm instance (provides hook_registry, delegation_call_stack, swarm_registry)
       # @param delegating_chat [Agent::Chat, nil] The chat instance of the agent doing the delegating (for accessing hooks)
       def initialize(
         delegate_name:,
@@ -27,9 +42,6 @@ module SwarmSDK
         delegate_chat:,
         agent_name:,
         swarm:,
-        hook_registry:,
-        call_stack:,
-        swarm_registry: nil,
         delegating_chat: nil
       )
         super()
@@ -39,24 +51,21 @@ module SwarmSDK
         @delegate_chat = delegate_chat
         @agent_name = agent_name
         @swarm = swarm
-        @hook_registry = hook_registry
-        @call_stack = call_stack
-        @swarm_registry = swarm_registry
         @delegating_chat = delegating_chat
 
-        # Generate tool name in the expected format: DelegateTaskTo[AgentName]
-        @tool_name = "DelegateTaskTo#{delegate_name.to_s.capitalize}"
+        # Generate tool name using canonical method
+        @tool_name = self.class.tool_name_for(delegate_name)
         @delegate_target = delegate_name.to_s
       end
 
       # Override description to return dynamic string based on delegate
       def description
-        "Delegate tasks to #{@delegate_name}. #{@delegate_description}"
+        "Work with #{@delegate_name} to delegate work, ask questions, or collaborate. #{@delegate_description}"
       end
 
-      param :task,
+      param :message,
         type: "string",
-        desc: "Task description for the agent",
+        desc: "Message to send to the agent - can be a work request, question, or collaboration message",
         required: true
 
       # Override name to return custom delegation tool name
@@ -66,13 +75,18 @@ module SwarmSDK
 
       # Execute delegation with pre/post hooks
       #
-      # @param task [String] Task to delegate
+      # @param message [String] Message to send to the agent
       # @return [String] Result from delegate agent or error message
-      def execute(task:)
+      def execute(message:)
+        # Access swarm infrastructure
+        call_stack = @swarm.delegation_call_stack
+        hook_registry = @swarm.hook_registry
+        swarm_registry = @swarm.swarm_registry
+
         # Check for circular dependency
-        if @call_stack.include?(@delegate_target)
-          emit_circular_warning
-          return "Error: Circular delegation detected: #{@call_stack.join(" -> ")} -> #{@delegate_target}. " \
+        if call_stack.include?(@delegate_target)
+          emit_circular_warning(call_stack)
+          return "Error: Circular delegation detected: #{call_stack.join(" -> ")} -> #{@delegate_target}. " \
             "Please restructure your delegation to avoid infinite loops."
         end
 
@@ -91,12 +105,12 @@ module SwarmSDK
           delegation_target: @delegate_target,
           metadata: {
             tool_name: @tool_name,
-            task: task,
+            message: message,
             timestamp: Time.now.utc.iso8601,
           },
         )
 
-        executor = Hooks::Executor.new(@hook_registry, logger: RubyLLM.logger)
+        executor = Hooks::Executor.new(hook_registry, logger: RubyLLM.logger)
         pre_agent_hooks = agent_hooks[:pre_delegation] || []
         result = executor.execute_safe(event: :pre_delegation, context: context, callbacks: pre_agent_hooks)
 
@@ -110,10 +124,10 @@ module SwarmSDK
         # Determine delegation type and proceed
         delegation_result = if @delegate_chat
           # Delegate to agent
-          delegate_to_agent(task)
-        elsif @swarm_registry&.registered?(@delegate_target)
+          delegate_to_agent(message, call_stack)
+        elsif swarm_registry&.registered?(@delegate_target)
           # Delegate to registered swarm
-          delegate_to_swarm(task)
+          delegate_to_swarm(message, call_stack, swarm_registry)
         else
           raise ConfigurationError, "Unknown delegation target: #{@delegate_target}"
         end
@@ -127,7 +141,7 @@ module SwarmSDK
           delegation_result: delegation_result,
           metadata: {
             tool_name: @tool_name,
-            task: task,
+            message: message,
             result: delegation_result,
             timestamp: Time.now.utc.iso8601,
           },
@@ -190,57 +204,61 @@ module SwarmSDK
 
       # Delegate to an agent
       #
-      # @param task [String] Task to delegate
+      # @param message [String] Message to send to the agent
+      # @param call_stack [Array] Delegation call stack for circular dependency detection
       # @return [String] Result from agent
-      def delegate_to_agent(task)
+      def delegate_to_agent(message, call_stack)
         # Push delegate target onto call stack to track delegation chain
-        @call_stack.push(@delegate_target)
+        call_stack.push(@delegate_target)
         begin
-          response = @delegate_chat.ask(task)
+          response = @delegate_chat.ask(message, source: "delegation")
           response.content
         ensure
           # Always pop from stack, even if delegation fails
-          @call_stack.pop
+          call_stack.pop
         end
       end
 
       # Delegate to a registered swarm
       #
-      # @param task [String] Task to delegate
+      # @param message [String] Message to send to the swarm
+      # @param call_stack [Array] Delegation call stack for circular dependency detection
+      # @param swarm_registry [SwarmRegistry] Registry for sub-swarms
       # @return [String] Result from swarm's lead agent
-      def delegate_to_swarm(task)
+      def delegate_to_swarm(message, call_stack, swarm_registry)
         # Load sub-swarm (lazy load + cache)
-        subswarm = @swarm_registry.load_swarm(@delegate_target)
+        subswarm = swarm_registry.load_swarm(@delegate_target)
 
         # Push delegate target onto call stack to track delegation chain
-        @call_stack.push(@delegate_target)
+        call_stack.push(@delegate_target)
         begin
           # Execute sub-swarm's lead agent
           lead_agent = subswarm.agents[subswarm.lead_agent]
-          response = lead_agent.ask(task)
+          response = lead_agent.ask(message, source: "delegation")
           result = response.content
 
           # Reset if keep_context: false
-          @swarm_registry.reset_if_needed(@delegate_target)
+          swarm_registry.reset_if_needed(@delegate_target)
 
           result
         ensure
           # Always pop from stack, even if delegation fails
-          @call_stack.pop
+          call_stack.pop
         end
       end
 
       # Emit circular dependency warning event
       #
+      # @param call_stack [Array] Current delegation call stack
       # @return [void]
-      def emit_circular_warning
+      def emit_circular_warning(call_stack)
         LogStream.emit(
           type: "delegation_circular_dependency",
           agent: @agent_name,
           swarm_id: @swarm.swarm_id,
           parent_swarm_id: @swarm.parent_swarm_id,
           target: @delegate_target,
-          call_stack: @call_stack,
+          call_stack: call_stack,
           timestamp: Time.now.utc.iso8601,
         )
       end

data/lib/swarm_sdk/tools/edit.rb

@@ -10,6 +10,13 @@ module SwarmSDK
     class Edit < RubyLLM::Tool
       include PathResolver
 
+      # Factory pattern: declare what parameters this tool needs for instantiation
+      class << self
+        def creation_requirements
+          [:agent_name, :directory]
+        end
+      end
+
       description <<~DESC
         Performs exact string replacements in files.
         You must use your Read tool at least once in the conversation before editing.
@@ -55,8 +62,7 @@ module SwarmSDK
       # @param directory [String] Agent's working directory
       def initialize(agent_name:, directory:)
         super()
-        @agent_name = agent_name.to_sym
-        @directory = File.expand_path(directory)
+        initialize_agent_context(agent_name: agent_name, directory: directory)
       end
 
       # Override name to return simple "Edit" instead of full class path
@@ -134,17 +140,6 @@ module SwarmSDK
       rescue StandardError => e
         error("Unexpected error editing file: #{e.class.name} - #{e.message}")
       end
-
-      private
-
-      # Helper methods
-      def validation_error(message)
-        "<tool_use_error>InputValidationError: #{message}</tool_use_error>"
-      end
-
-      def error(message)
-        "Error: #{message}"
-      end
     end
   end
 end

data/lib/swarm_sdk/tools/glob.rb

@@ -9,6 +9,13 @@ module SwarmSDK
     class Glob < RubyLLM::Tool
       include PathResolver
 
+      # Factory pattern: declare what parameters this tool needs for instantiation
+      class << self
+        def creation_requirements
+          [:directory]
+        end
+      end
+
       def initialize(directory:)
         super()
         @directory = File.expand_path(directory)
@@ -43,7 +50,8 @@ module SwarmSDK
         desc: "The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter \"undefined\" or \"null\" - simply omit it for the default behavior. Must be a valid directory path if provided.",
         required: false
 
-      MAX_RESULTS = 1000 # Limit results to prevent overwhelming output
+      # Backward compatibility alias - use Defaults module for new code
+      MAX_RESULTS = Defaults::Limits::GLOB_RESULTS
 
       def execute(pattern:, path: nil)
         # Validate inputs

data/lib/swarm_sdk/tools/grep.rb

@@ -9,6 +9,13 @@ module SwarmSDK
     class Grep < RubyLLM::Tool
       include PathResolver
 
+      # Factory pattern: declare what parameters this tool needs for instantiation
+      class << self
+        def creation_requirements
+          [:directory]
+        end
+      end
+
       def initialize(directory:)
         super()
         @directory = File.expand_path(directory)

data/lib/swarm_sdk/tools/multi_edit.rb

@@ -11,6 +11,13 @@ module SwarmSDK
     class MultiEdit < RubyLLM::Tool
       include PathResolver
 
+      # Factory pattern: declare what parameters this tool needs for instantiation
+      class << self
+        def creation_requirements
+          [:agent_name, :directory]
+        end
+      end
+
       description <<~DESC
         Performs multiple exact string replacements in a single file.
         Edits are applied sequentially, so later edits see the results of earlier ones.
@@ -53,8 +60,7 @@ module SwarmSDK
       # @param directory [String] Agent's working directory
       def initialize(agent_name:, directory:)
         super()
-        @agent_name = agent_name.to_sym
-        @directory = File.expand_path(directory)
+        initialize_agent_context(agent_name: agent_name, directory: directory)
       end
 
       # Override name to return simple "MultiEdit" instead of full class path
@@ -204,15 +210,13 @@ module SwarmSDK
 
       private
 
-      # Helper methods
-      def validation_error(message)
-        "<tool_use_error>InputValidationError: #{message}</tool_use_error>"
-      end
-
-      def error(message)
-        "Error: #{message}"
-      end
-
+      # Format an error that includes partial results
+      #
+      # Shows what edits succeeded before the error occurred.
+      #
+      # @param message [String] Error description
+      # @param results [Array<Hash>] Successful edit results before failure
+      # @return [String] Formatted error message with results summary
       def error_with_results(message, results)
         output = "<tool_use_error>InputValidationError: #{message}\n\n"
 

data/lib/swarm_sdk/tools/path_resolver.rb

@@ -2,7 +2,12 @@
 
 module SwarmSDK
   module Tools
-    # Shared path resolution logic for all file tools
+    # Shared path resolution and agent context logic for file tools
+    #
+    # This module provides:
+    # - Path resolution (relative to agent's working directory)
+    # - Agent context initialization (agent_name, directory expansion)
+    # - Standard error message formatting
     #
     # Tools resolve relative paths against the agent's directory.
     # Absolute paths are used as-is.
@@ -12,17 +17,41 @@ module SwarmSDK
     #     include PathResolver
     #
     #     def initialize(agent_name:, directory:)
-    #       @directory = File.expand_path(directory)
+    #       super()
+    #       initialize_agent_context(agent_name: agent_name, directory: directory)
     #     end
     #
     #     def execute(file_path:)
     #       resolved_path = resolve_path(file_path)
     #       File.read(resolved_path)
+    #     rescue StandardError => e
+    #       error("Failed to read: #{e.message}")
     #     end
     #   end
     module PathResolver
+      # Agent context attributes
+      # @return [Symbol] The agent identifier
+      attr_reader :agent_name
+
+      # @return [String] Absolute path to agent's working directory
+      attr_reader :directory
+
       private
 
+      # Initialize agent context for file tools
+      #
+      # Sets up the common agent context needed by file tools:
+      # - Normalizes agent_name to symbol
+      # - Expands directory to absolute path
+      #
+      # @param agent_name [Symbol, String] The agent identifier
+      # @param directory [String] Agent's working directory (will be expanded)
+      # @return [void]
+      def initialize_agent_context(agent_name:, directory:)
+        @agent_name = agent_name.to_sym
+        @directory = File.expand_path(directory)
+      end
+
       # Resolve a path relative to the agent's directory
       #
       # - Absolute paths (starting with /) are returned as-is
@@ -38,6 +67,26 @@ module SwarmSDK
 
         File.expand_path(path, @directory)
       end
+
+      # Format a validation error response
+      #
+      # Used for input validation failures (missing required params, invalid formats, etc.)
+      #
+      # @param message [String] Error description
+      # @return [String] Formatted error message wrapped in tool_use_error tags
+      def validation_error(message)
+        "<tool_use_error>InputValidationError: #{message}</tool_use_error>"
+      end
+
+      # Format a general error response
+      #
+      # Used for runtime errors (permission denied, file not found, etc.)
+      #
+      # @param message [String] Error description
+      # @return [String] Formatted error message prefixed with "Error:"
+      def error(message)
+        "Error: #{message}"
+      end
     end
   end
 end

data/lib/swarm_sdk/tools/read.rb

@@ -10,8 +10,9 @@ module SwarmSDK
     class Read < RubyLLM::Tool
       include PathResolver
 
-      MAX_LINE_LENGTH = 2000
-      DEFAULT_LIMIT = 2000
+      # Backward compatibility aliases - use Defaults module for new code
+      MAX_LINE_LENGTH = Defaults::Limits::LINE_CHARACTERS
+      DEFAULT_LIMIT = Defaults::Limits::READ_LINES
 
       # List of available document converters
       CONVERTERS = [
@@ -28,6 +29,13 @@ module SwarmSDK
         ""
       end
 
+      # Factory pattern: declare what parameters this tool needs for instantiation
+      class << self
+        def creation_requirements
+          [:agent_name, :directory]
+        end
+      end
+
       description <<~DESC
         Reads a file from the local filesystem. You can access any file directly by using this tool.
         Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid.
@@ -67,8 +75,7 @@ module SwarmSDK
       # @param directory [String] Agent's working directory
       def initialize(agent_name:, directory:)
         super()
-        @agent_name = agent_name.to_sym
-        @directory = File.expand_path(directory)
+        initialize_agent_context(agent_name: agent_name, directory: directory)
       end
 
       # Override name to return simple "Read" instead of full class path
@@ -182,15 +189,6 @@ module SwarmSDK
         CONVERTERS.find { |converter| converter.extensions.include?(ext) }
       end
 
-      # Helper methods
-      def validation_error(message)
-        "<tool_use_error>InputValidationError: #{message}</tool_use_error>"
-      end
-
-      def error(message)
-        "Error: #{message}"
-      end
-
       def format_with_reminder(content, reminder)
         return content if reminder.nil? || reminder.empty?
 

data/lib/swarm_sdk/tools/registry.rb

@@ -5,24 +5,51 @@ module SwarmSDK
     # Registry for built-in SwarmSDK tools
     #
     # Maps tool names (symbols) to their RubyLLM::Tool classes.
-    # Provides validation and lookup functionality for tool registration.
+    # Provides validation, lookup, and factory functionality for tool registration.
+    #
+    # ## Tool Creation Pattern
+    #
+    # Tools register themselves with their creation requirements via the `tool_factory` method.
+    # This eliminates the need for a giant case statement in ToolConfigurator.
+    #
+    # Tools fall into three categories:
+    # 1. **No params**: Simple tools with no initialization requirements (Think, Clock)
+    # 2. **Directory only**: Tools needing working directory (Bash, Grep, Glob)
+    # 3. **Agent context**: Tools needing agent tracking (Read, Write, Edit, MultiEdit)
+    # 4. **Scratchpad**: Tools needing scratchpad storage instance
+    #
+    # @example Adding a new tool with creation requirements
+    #   # In the tool class:
+    #   class MyTool < RubyLLM::Tool
+    #     def self.creation_requirements
+    #       [:agent_name, :directory]
+    #     end
+    #   end
+    #
+    #   # In registry:
+    #   BUILTIN_TOOLS = {
+    #     MyTool: SwarmSDK::Tools::MyTool,
+    #   }
     #
     # Note: Plugin-provided tools (e.g., memory tools) are NOT in this registry.
     # They are registered via SwarmSDK::PluginRegistry instead.
     class Registry
       # All available built-in tools
+      #
+      # Maps tool names to their classes. The class must respond to `creation_requirements`
+      # to specify what parameters are needed for instantiation.
       BUILTIN_TOOLS = {
-        Read: :special, # Requires agent context for read tracking
-        Write: :special, # Requires agent context for read-before-write enforcement
-        Edit: :special, # Requires agent context for read-before-edit enforcement
+        Read: SwarmSDK::Tools::Read,
+        Write: SwarmSDK::Tools::Write,
+        Edit: SwarmSDK::Tools::Edit,
+        MultiEdit: SwarmSDK::Tools::MultiEdit,
         Bash: SwarmSDK::Tools::Bash,
         Grep: SwarmSDK::Tools::Grep,
         Glob: SwarmSDK::Tools::Glob,
-        MultiEdit: :special, # Requires agent context for read-before-edit enforcement
-        TodoWrite: :special, # Requires agent context for todo tracking
-        ScratchpadWrite: :special, # Requires scratchpad storage instance
-        ScratchpadRead: :special, # Requires scratchpad storage instance
-        ScratchpadList: :special, # Requires scratchpad storage instance
+        TodoWrite: SwarmSDK::Tools::TodoWrite,
+        ScratchpadWrite: :scratchpad, # Requires scratchpad storage instance
+        ScratchpadRead: :scratchpad,  # Requires scratchpad storage instance
+        ScratchpadList: :scratchpad,  # Requires scratchpad storage instance
         Think: SwarmSDK::Tools::Think,
         WebFetch: SwarmSDK::Tools::WebFetch,
         Clock: SwarmSDK::Tools::Clock,
@@ -35,12 +62,49 @@ module SwarmSDK
         # They are managed by SwarmSDK::PluginRegistry instead.
         #
         # @param name [Symbol, String] Tool name
-        # @return [Class, Symbol, nil] Tool class, :special, or nil if not found
+        # @return [Class, Symbol, nil] Tool class, :scratchpad marker, or nil if not found
         def get(name)
           name_sym = name.to_sym
           BUILTIN_TOOLS[name_sym]
         end
 
+        # Create a tool instance using the Factory Pattern
+        #
+        # Uses the tool's `creation_requirements` class method to determine
+        # what parameters to pass to the constructor.
+        #
+        # @param name [Symbol, String] Tool name
+        # @param context [Hash] Available context for tool creation
+        # @option context [Symbol] :agent_name Agent identifier
+        # @option context [String] :directory Agent's working directory
+        # @option context [Object] :scratchpad_storage Scratchpad storage instance
+        # @return [RubyLLM::Tool] Instantiated tool
+        # @raise [ConfigurationError] If tool is unknown or has unmet requirements
+        def create(name, context = {})
+          name_sym = name.to_sym
+          tool_entry = BUILTIN_TOOLS[name_sym]
+
+          raise ConfigurationError, "Unknown tool: #{name}" unless tool_entry
+
+          # Handle scratchpad tools specially (they use factory methods)
+          if tool_entry == :scratchpad
+            return create_scratchpad_tool(name_sym, context[:scratchpad_storage])
+          end
+
+          # Get the tool class and its requirements
+          tool_class = tool_entry
+
+          # Check if tool defines creation requirements
+          if tool_class.respond_to?(:creation_requirements)
+            requirements = tool_class.creation_requirements
+            params = extract_params(requirements, context, name)
+            tool_class.new(**params)
+          else
+            # No requirements - simple instantiation
+            tool_class.new
+          end
+        end
+
         # Get multiple tool classes by names
         #
         # @param names [Array<Symbol, String>] Tool names
@@ -87,6 +151,54 @@ module SwarmSDK
         def validate(names)
           names.reject { |name| exists?(name) }
         end
+
+        private
+
+        # Extract required parameters from context
+        #
+        # @param requirements [Array<Symbol>] Required parameter names
+        # @param context [Hash] Available context
+        # @param tool_name [Symbol] Tool name for error messages
+        # @return [Hash] Parameters to pass to tool constructor
+        # @raise [ConfigurationError] If required parameter is missing
+        def extract_params(requirements, context, tool_name)
+          params = {}
+
+          requirements.each do |req|
+            unless context.key?(req)
+              raise ConfigurationError,
+                "Tool #{tool_name} requires #{req} but it was not provided in context"
+            end
+
+            params[req] = context[req]
+          end
+
+          params
+        end
+
+        # Create a scratchpad tool using its factory method
+        #
+        # @param name [Symbol] Scratchpad tool name
+        # @param storage [Object] Scratchpad storage instance
+        # @return [RubyLLM::Tool] Instantiated scratchpad tool
+        # @raise [ConfigurationError] If storage is not provided
+        def create_scratchpad_tool(name, storage)
+          unless storage
+            raise ConfigurationError,
+              "Scratchpad tool #{name} requires scratchpad_storage in context"
+          end
+
+          case name
+          when :ScratchpadWrite
+            Tools::Scratchpad::ScratchpadWrite.create_for_scratchpad(storage)
+          when :ScratchpadRead
+            Tools::Scratchpad::ScratchpadRead.create_for_scratchpad(storage)
+          when :ScratchpadList
+            Tools::Scratchpad::ScratchpadList.create_for_scratchpad(storage)
+          else
+            raise ConfigurationError, "Unknown scratchpad tool: #{name}"
+          end
+        end
       end
     end
   end