swarm_sdk 2.0.6 → 2.0.7

data/lib/swarm_sdk/swarm/agent_initializer.rb

@@ -15,14 +15,14 @@ module SwarmSDK
     # embedded in Swarm#initialize_agents.
     class AgentInitializer
       # rubocop:disable Metrics/ParameterLists
-      def initialize(swarm, agent_definitions, global_semaphore, hook_registry, scratchpad_storage, memory_storages, config_for_hooks: nil)
+      def initialize(swarm, agent_definitions, global_semaphore, hook_registry, scratchpad_storage, plugin_storages, config_for_hooks: nil)
         # rubocop:enable Metrics/ParameterLists
         @swarm = swarm
         @agent_definitions = agent_definitions
         @global_semaphore = global_semaphore
         @hook_registry = hook_registry
         @scratchpad_storage = scratchpad_storage
-        @memory_storages = memory_storages
+        @plugin_storages = plugin_storages
         @config_for_hooks = config_for_hooks
         @agents = {}
         @agent_contexts = {}
@@ -80,21 +80,17 @@ module SwarmSDK
       # This creates the Agent::Chat instances but doesn't wire them together yet.
       # Each agent gets its own chat instance with configured tools.
       def pass_1_create_agents
-        # Create memory storage for agents that have memory configured
-        @agent_definitions.each do |agent_name, agent_definition|
-          next unless agent_definition.memory_enabled?
-
-          # Use configured directory or default
-          memory_dir = agent_definition.memory.directory
-          memory_path = File.join(memory_dir, "memory.json")
-          @memory_storages[agent_name] = Tools::Stores::MemoryStorage.new(persist_to: memory_path)
-        end
+        # Create plugin storages for agents
+        create_plugin_storages
 
-        tool_configurator = ToolConfigurator.new(@swarm, @scratchpad_storage, @memory_storages)
+        tool_configurator = ToolConfigurator.new(@swarm, @scratchpad_storage, @plugin_storages)
 
         @agent_definitions.each do |name, agent_definition|
           chat = create_agent_chat(name, agent_definition, tool_configurator)
           @agents[name] = chat
+
+          # Notify plugins that agent was initialized
+          notify_plugins_agent_initialized(name, chat, agent_definition, tool_configurator)
         end
       end
 
@@ -207,6 +203,7 @@ module SwarmSDK
       def create_agent_chat(agent_name, agent_definition, tool_configurator)
         chat = Agent::Chat.new(
           definition: agent_definition.to_h,
+          agent_name: agent_name,
           global_semaphore: @global_semaphore,
         )
 
@@ -261,6 +258,77 @@ module SwarmSDK
           chat.with_tool(tool)
         end
       end
+
+      # Create plugin storages for all agents
+      #
+      # Iterates through all registered plugins and asks each to create
+      # storage for agents that need it.
+      #
+      # @return [void]
+      def create_plugin_storages
+        PluginRegistry.all.each do |plugin|
+          @agent_definitions.each do |agent_name, agent_definition|
+            # Check if this plugin needs storage for this agent
+            next unless plugin.storage_enabled?(agent_definition)
+
+            # Get plugin config for this agent
+            config = get_plugin_config(agent_definition, plugin.name)
+            next unless config
+
+            # Parse config through plugin
+            parsed_config = plugin.parse_config(config)
+
+            # Create plugin storage
+            storage = plugin.create_storage(agent_name: agent_name, config: parsed_config)
+
+            # Store in plugin_storages: { plugin_name => { agent_name => storage } }
+            @plugin_storages[plugin.name] ||= {}
+            @plugin_storages[plugin.name][agent_name] = storage
+          end
+        end
+      end
+
+      # Get plugin-specific config from agent definition
+      #
+      # Plugins can store their config in agent definition under their plugin name.
+      # E.g., memory plugin looks for `agent_definition.memory`
+      #
+      # @param agent_definition [Agent::Definition] Agent definition
+      # @param plugin_name [Symbol] Plugin name
+      # @return [Object, nil] Plugin config or nil
+      def get_plugin_config(agent_definition, plugin_name)
+        # Try to call method named after plugin (e.g., .memory for :memory plugin)
+        if agent_definition.respond_to?(plugin_name)
+          agent_definition.public_send(plugin_name)
+        end
+      end
+
+      # Notify all plugins that an agent was initialized
+      #
+      # Plugins can register additional tools, mark tools immutable, etc.
+      #
+      # @param agent_name [Symbol] Agent name
+      # @param chat [Agent::Chat] Chat instance
+      # @param agent_definition [Agent::Definition] Agent definition
+      # @param tool_configurator [ToolConfigurator] Tool configurator
+      # @return [void]
+      def notify_plugins_agent_initialized(agent_name, chat, agent_definition, tool_configurator)
+        PluginRegistry.all.each do |plugin|
+          # Get plugin storage for this agent (if any)
+          plugin_storages = @plugin_storages[plugin.name] || {}
+          storage = plugin_storages[agent_name]
+
+          # Build context for plugin
+          context = {
+            storage: storage,
+            agent_definition: agent_definition,
+            tool_configurator: tool_configurator,
+          }
+
+          # Notify plugin
+          plugin.on_agent_initialized(agent_name: agent_name, agent: chat, context: context)
+        end
+      end
     end
   end
 end

data/lib/swarm_sdk/swarm/tool_configurator.rb

@@ -20,6 +20,7 @@ module SwarmSDK
         :TodoWrite,
         :Think,
         :WebFetch,
+        :Clock,
       ].freeze
 
       # Scratchpad tools (added if scratchpad is enabled)
@@ -29,21 +30,12 @@ module SwarmSDK
         :ScratchpadList,
       ].freeze
 
-      # Memory tools (added if memory is configured for the agent)
-      MEMORY_TOOLS = [
-        :MemoryWrite,
-        :MemoryRead,
-        :MemoryEdit,
-        :MemoryMultiEdit,
-        :MemoryGlob,
-        :MemoryGrep,
-        :MemoryDelete,
-      ].freeze
-
-      def initialize(swarm, scratchpad_storage, memory_storages)
+      def initialize(swarm, scratchpad_storage, plugin_storages = {})
         @swarm = swarm
         @scratchpad_storage = scratchpad_storage
-        @memory_storages = memory_storages
+        # Plugin storages: { plugin_name => { agent_name => storage } }
+        # e.g., { memory: { agent1: storage1, agent2: storage2 } }
+        @plugin_storages = plugin_storages
       end
 
       # Register all tools for an agent (both explicit and default)
@@ -60,16 +52,24 @@ module SwarmSDK
       #
       # File tools and TodoWrite require agent context for tracking state.
       # Scratchpad tools require shared scratchpad instance.
+      # Plugin tools are delegated to their respective plugins.
       #
       # This method is public for testing delegation from Swarm.
       #
       # @param tool_name [Symbol, String] Tool name
       # @param agent_name [Symbol] Agent name for context
       # @param directory [String] Agent's working directory
+      # @param chat [Agent::Chat, nil] Optional chat instance for tools that need it
+      # @param agent_definition [Agent::Definition, nil] Optional agent definition
       # @return [RubyLLM::Tool] Tool instance
-      def create_tool_instance(tool_name, agent_name, directory)
+      def create_tool_instance(tool_name, agent_name, directory, chat: nil, agent_definition: nil)
         tool_name_sym = tool_name.to_sym
 
+        # Check if tool is provided by a plugin
+        if PluginRegistry.plugin_tool?(tool_name_sym)
+          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)
@@ -93,27 +93,22 @@ module SwarmSDK
           Tools::Scratchpad::ScratchpadRead.create_for_scratchpad(@scratchpad_storage)
         when :ScratchpadList
           Tools::Scratchpad::ScratchpadList.create_for_scratchpad(@scratchpad_storage)
-        when :MemoryWrite
-          Tools::Memory::MemoryWrite.create_for_memory(@memory_storages[agent_name])
-        when :MemoryRead
-          Tools::Memory::MemoryRead.create_for_memory(@memory_storages[agent_name], agent_name)
-        when :MemoryEdit
-          Tools::Memory::MemoryEdit.create_for_memory(@memory_storages[agent_name], agent_name)
-        when :MemoryMultiEdit
-          Tools::Memory::MemoryMultiEdit.create_for_memory(@memory_storages[agent_name], agent_name)
-        when :MemoryDelete
-          Tools::Memory::MemoryDelete.create_for_memory(@memory_storages[agent_name])
-        when :MemoryGlob
-          Tools::Memory::MemoryGlob.create_for_memory(@memory_storages[agent_name])
-        when :MemoryGrep
-          Tools::Memory::MemoryGrep.create_for_memory(@memory_storages[agent_name])
         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
+
           tool_class.new
         end
       end
@@ -169,34 +164,33 @@ module SwarmSDK
 
       # Register default tools for agents (unless disabled)
       #
+      # Note: Memory tools are registered separately and are NOT affected by
+      # disable_default_tools, since they're configured via memory {} block.
+      #
       # @param chat [AgentChat] The chat instance
       # @param agent_name [Symbol] Agent name
       # @param agent_definition [AgentDefinition] Agent definition
       def register_default_tools(chat, agent_name:, agent_definition:)
-        # If disable_default_tools is true, skip all default tools
-        return if agent_definition.disable_default_tools == true
-
         # Get explicit tool names to avoid duplicates
         explicit_tool_names = agent_definition.tools.map { |t| t[:name] }.to_set
 
-        # Register core default tools
-        DEFAULT_TOOLS.each do |tool_name|
-          register_tool_if_not_disabled(chat, tool_name, explicit_tool_names, agent_name, agent_definition)
-        end
-
-        # Register scratchpad tools if enabled
-        if @swarm.scratchpad_enabled?
-          SCRATCHPAD_TOOLS.each do |tool_name|
+        # Register core default tools (unless disabled)
+        if agent_definition.disable_default_tools != true
+          DEFAULT_TOOLS.each do |tool_name|
             register_tool_if_not_disabled(chat, tool_name, explicit_tool_names, agent_name, agent_definition)
           end
-        end
 
-        # Register memory tools if configured for this agent
-        if agent_definition.memory_enabled?
-          MEMORY_TOOLS.each do |tool_name|
-            register_tool_if_not_disabled(chat, tool_name, explicit_tool_names, agent_name, agent_definition)
+          # Register scratchpad tools if enabled
+          if @swarm.scratchpad_enabled?
+            SCRATCHPAD_TOOLS.each do |tool_name|
+              register_tool_if_not_disabled(chat, tool_name, explicit_tool_names, agent_name, agent_definition)
+            end
           end
         end
+
+        # Register plugin tools if plugin storage is enabled for this agent
+        # Plugin tools ARE affected by disable_default_tools (allows fine-grained control)
+        register_plugin_tools(chat, agent_name, agent_definition, explicit_tool_names)
       end
 
       # Register a tool if not already explicit or disabled
@@ -223,6 +217,84 @@ module SwarmSDK
         chat.with_tool(tool_instance)
       end
 
+      # Create a tool instance via plugin
+      #
+      # @param tool_name [Symbol] Tool name
+      # @param agent_name [Symbol] Agent name
+      # @param directory [String] Working directory
+      # @param chat [Agent::Chat, nil] Chat instance
+      # @param agent_definition [Agent::Definition, nil] Agent definition
+      # @return [RubyLLM::Tool] Tool instance
+      def create_plugin_tool(tool_name, agent_name, directory, chat, agent_definition)
+        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
+        plugin_storages = @plugin_storages[plugin.name] || {}
+        storage = plugin_storages[agent_name]
+
+        # Build context for tool creation
+        context = {
+          agent_name: agent_name,
+          directory: directory,
+          storage: storage,
+          agent_definition: agent_definition,
+          chat: chat,
+          tool_configurator: self,
+        }
+
+        plugin.create_tool(tool_name, context)
+      end
+
+      # Register plugin-provided tools for an agent
+      #
+      # Asks all plugins if they have tools to register for this agent.
+      #
+      # @param chat [Agent::Chat] Chat instance
+      # @param agent_name [Symbol] Agent name
+      # @param agent_definition [Agent::Definition] Agent definition
+      # @param explicit_tool_names [Set<Symbol>] Already-registered tool names
+      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]
+
+          # Register each tool provided by the plugin
+          plugin.tools.each do |tool_name|
+            # Skip if already registered explicitly
+            next if explicit_tool_names.include?(tool_name)
+
+            # Skip if tool is disabled via disable_default_tools
+            next if tool_disabled?(tool_name, agent_definition.disable_default_tools)
+
+            tool_instance = create_tool_instance(
+              tool_name,
+              agent_name,
+              agent_definition.directory,
+              chat: chat,
+              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,
+            )
+
+            chat.with_tool(tool_instance)
+          end
+        end
+      end
+
       # Check if a tool should be disabled based on disable_default_tools config
       #
       # @param tool_name [Symbol] Tool name to check

data/lib/swarm_sdk/swarm.rb

@@ -151,9 +151,10 @@ module SwarmSDK
       # Use provided scratchpad storage (for testing) or create volatile one
       @scratchpad_storage = scratchpad || Tools::Stores::ScratchpadStorage.new
 
-      # Per-agent memory storage (persistent)
+      # Per-agent plugin storages (persistent)
+      # Format: { plugin_name => { agent_name => storage } }
       # Will be populated when agents are initialized
-      @memory_storages = {}
+      @plugin_storages = {}
 
       # Hook registry for named hooks and swarm defaults
       @hook_registry = Hooks::Registry.new
@@ -551,7 +552,7 @@ module SwarmSDK
         @global_semaphore,
         @hook_registry,
         @scratchpad_storage,
-        @memory_storages,
+        @plugin_storages,
         config_for_hooks: @config_for_hooks,
       )
 
@@ -571,6 +572,18 @@ module SwarmSDK
       @agents.each do |agent_name, chat|
         agent_def = @agent_definitions[agent_name]
 
+        # Build plugin storage info for logging
+        plugin_storage_info = {}
+        @plugin_storages.each do |plugin_name, agent_storages|
+          next unless agent_storages.key?(agent_name)
+
+          plugin_storage_info[plugin_name] = {
+            enabled: true,
+            # Get additional info from agent definition if available
+            config: agent_def.respond_to?(plugin_name) ? extract_plugin_config_info(agent_def.public_send(plugin_name)) : nil,
+          }
+        end
+
         LogStream.emit(
           type: "agent_start",
           agent: agent_name,
@@ -581,8 +594,7 @@ module SwarmSDK
           system_prompt: agent_def.system_prompt,
           tools: chat.tools.keys,
           delegates_to: agent_def.delegates_to,
-          memory_enabled: agent_def.memory_enabled?,
-          memory_directory: agent_def.memory_enabled? ? agent_def.memory.directory : nil,
+          plugin_storages: plugin_storage_info,
           timestamp: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
         )
       end
@@ -620,12 +632,12 @@ module SwarmSDK
 
     # Create a tool instance (delegates to ToolConfigurator)
     def create_tool_instance(tool_name, agent_name, directory)
-      ToolConfigurator.new(self, @scratchpad_storage, @memory_storages).create_tool_instance(tool_name, agent_name, directory)
+      ToolConfigurator.new(self, @scratchpad_storage, @plugin_storages).create_tool_instance(tool_name, agent_name, directory)
     end
 
     # Wrap tool with permissions (delegates to ToolConfigurator)
     def wrap_tool_with_permissions(tool_instance, permissions_config, agent_definition)
-      ToolConfigurator.new(self, @scratchpad_storage, @memory_storages).wrap_tool_with_permissions(tool_instance, permissions_config, agent_definition)
+      ToolConfigurator.new(self, @scratchpad_storage, @plugin_storages).wrap_tool_with_permissions(tool_instance, permissions_config, agent_definition)
     end
 
     # Build MCP transport config (delegates to McpConfigurator)
@@ -635,10 +647,34 @@ module SwarmSDK
 
     # Create delegation tool (delegates to AgentInitializer)
     def create_delegation_tool(name:, description:, delegate_chat:, agent_name:)
-      AgentInitializer.new(self, @agent_definitions, @global_semaphore, @hook_registry, @scratchpad_storage, @memory_storages)
+      AgentInitializer.new(self, @agent_definitions, @global_semaphore, @hook_registry, @scratchpad_storage, @plugin_storages)
         .create_delegation_tool(name: name, description: description, delegate_chat: delegate_chat, agent_name: agent_name)
     end
 
+    # Extract loggable info from plugin config
+    #
+    # Attempts to extract useful information from plugin configuration
+    # for logging purposes. Handles MemoryConfig, Hashes, and other objects.
+    #
+    # @param config [Object] Plugin configuration object
+    # @return [Hash, nil] Extracted config info or nil
+    def extract_plugin_config_info(config)
+      return if config.nil?
+
+      # Handle MemoryConfig object (has directory method)
+      if config.respond_to?(:directory)
+        return { directory: config.directory }
+      end
+
+      # Handle Hash
+      if config.is_a?(Hash)
+        return config.slice(:directory, "directory", :adapter, "adapter")
+      end
+
+      # Unknown config type
+      nil
+    end
+
     # Register default logging hooks that emit LogStream events
     #
     # These hooks implement the standard SwarmSDK logging behavior.

data/lib/swarm_sdk/tools/clock.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SwarmSDK
+  module Tools
+    # Clock tool provides current date and time information
+    #
+    # Returns current temporal information in a consistent format.
+    # Agents use this when they need to know what day/time it is.
+    class Clock < RubyLLM::Tool
+      description <<~DESC
+        Get current date and time.
+
+        Returns:
+        - Current date (YYYY-MM-DD format)
+        - Current time (HH:MM:SS format)
+        - Day of week (Monday, Tuesday, etc.)
+        - ISO 8601 timestamp (full datetime)
+
+        Use this when you need to know what day it is, what time it is,
+        or to store temporal information (e.g., "As of 2025-10-20...").
+
+        No parameters needed - just call Clock() to get complete temporal information.
+      DESC
+
+      # No parameters needed
+
+      # Override name to return simple "Clock"
+      def name
+        "Clock"
+      end
+
+      def execute
+        now = Time.now
+
+        <<~RESULT.chomp
+          Current date: #{now.strftime("%Y-%m-%d")}
+          Current time: #{now.strftime("%H:%M:%S")}
+          Day of week: #{now.strftime("%A")}
+          ISO 8601: #{now.iso8601}
+        RESULT
+      end
+    end
+  end
+end

data/lib/swarm_sdk/tools/grep.rb

@@ -46,15 +46,15 @@ module SwarmSDK
 
       param :type,
         type: "string",
-        desc: "File type to search (rg --type). Common types: js, py, rust, go, java, etc.",
+        desc: "File type to search (rg --type). Common types: c, cpp, cs, csharp, css, dart, docker, dockercompose, elixir, erlang, go, graphql, haskell, html, java, js, json, kotlin, lua, make, markdown, md, php, py, python, ruby, rust, sass, scala, sh, sql, svelte, swift, tf, toml, ts, typescript, vim, vue, xml, yaml, zig",
         required: false
 
       param :output_mode,
         type: "string",
-        desc: "Output mode: \"content\" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), \"files_with_matches\" shows file paths (supports head_limit), \"count\" shows match counts (supports head_limit). Defaults to \"files_with_matches\".",
+        desc: "Output mode: \"content\" shows matching lines (supports context/line number options), \"files_with_matches\" shows file paths (default), \"count\" shows match counts. All modes support head_limit.",
         required: false
 
-      param :"-i",
+      param :case_insensitive,
         type: "boolean",
         desc: "Case insensitive search (rg -i)",
         required: false
@@ -64,22 +64,22 @@ module SwarmSDK
         desc: "Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall)",
         required: false
 
-      param :"-B",
+      param :context_before,
         type: "integer",
         desc: "Number of lines to show before each match (rg -B). Requires output_mode: \"content\", ignored otherwise.",
         required: false
 
-      param :"-A",
+      param :context_after,
         type: "integer",
         desc: "Number of lines to show after each match (rg -A). Requires output_mode: \"content\", ignored otherwise.",
         required: false
 
-      param :"-C",
+      param :context,
         type: "integer",
         desc: "Number of lines to show before and after each match (rg -C). Requires output_mode: \"content\", ignored otherwise.",
         required: false
 
-      param :"-n",
+      param :show_line_numbers,
         type: "boolean",
         desc: "Show line numbers in output (rg -n). Requires output_mode: \"content\", ignored otherwise.",
         required: false
@@ -95,7 +95,13 @@ module SwarmSDK
         glob: nil,
         type: nil,
         output_mode: "files_with_matches",
-        **options
+        case_insensitive: false,
+        multiline: false,
+        context_before: nil,
+        context_after: nil,
+        context: nil,
+        show_line_numbers: false,
+        head_limit: nil
       )
         # Validate inputs
         return validation_error("pattern is required") if pattern.nil? || pattern.empty?
@@ -108,15 +114,6 @@ module SwarmSDK
           resolve_path(path)
         end
 
-        # Extract options with their flag names
-        case_insensitive = options["-i"] || false
-        multiline = options[:multiline] || false
-        context_before = options["-B"]
-        context_after = options["-A"]
-        context = options["-C"]
-        line_numbers = options["-n"] || false
-        head_limit = options[:head_limit]
-
         # Validate output_mode
         valid_modes = ["content", "files_with_matches", "count"]
         unless valid_modes.include?(output_mode)
@@ -135,7 +132,7 @@ module SwarmSDK
         when "content"
           # Default mode, no special flag needed
           # Add line numbers if requested
-          cmd << "-n" if line_numbers
+          cmd << "-n" if show_line_numbers
 
           # Add context flags
           cmd << "-B" << context_before.to_s if context_before
@@ -222,7 +219,7 @@ module SwarmSDK
           <system-reminder>
           You used output_mode: '#{output_mode}' which only shows #{output_mode == "files_with_matches" ? "file paths" : "match counts"}.
           To see the actual matching lines and their content, use output_mode: 'content'.
-          You can also add -n: true and context lines (-B, -A, or -C) for better context.
+          You can also add show_line_numbers: true and context lines (context_before, context_after, or context) for better context.
           </system-reminder>
         REMINDER
       end

data/lib/swarm_sdk/tools/registry.rb

@@ -6,6 +6,9 @@ module SwarmSDK
     #
     # Maps tool names (symbols) to their RubyLLM::Tool classes.
     # Provides validation and lookup functionality for tool registration.
+    #
+    # 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
       BUILTIN_TOOLS = {
@@ -20,24 +23,22 @@ module SwarmSDK
         ScratchpadWrite: :special, # Requires scratchpad storage instance
         ScratchpadRead: :special, # Requires scratchpad storage instance
         ScratchpadList: :special, # Requires scratchpad storage instance
-        MemoryWrite: :special, # Requires memory storage instance
-        MemoryRead: :special, # Requires memory storage instance
-        MemoryEdit: :special, # Requires memory storage instance
-        MemoryMultiEdit: :special, # Requires memory storage instance
-        MemoryDelete: :special, # Requires memory storage instance
-        MemoryGlob: :special, # Requires memory storage instance
-        MemoryGrep: :special, # Requires memory storage instance
         Think: SwarmSDK::Tools::Think,
         WebFetch: SwarmSDK::Tools::WebFetch,
+        Clock: SwarmSDK::Tools::Clock,
       }.freeze
 
       class << self
         # Get tool class by name
         #
+        # Note: Plugin-provided tools are NOT returned by this method.
+        # They are managed by SwarmSDK::PluginRegistry instead.
+        #
         # @param name [Symbol, String] Tool name
-        # @return [Class, nil] Tool class or nil if not found
+        # @return [Class, Symbol, nil] Tool class, :special, or nil if not found
         def get(name)
-          BUILTIN_TOOLS[name.to_sym]
+          name_sym = name.to_sym
+          BUILTIN_TOOLS[name_sym]
         end
 
         # Get multiple tool classes by names
@@ -48,7 +49,10 @@ module SwarmSDK
         def get_many(names)
           names.map do |name|
             tool_class = get(name)
-            raise ConfigurationError, "Unknown tool: #{name}. Available tools: #{available_names.join(", ")}" unless tool_class
+            unless tool_class
+              raise ConfigurationError,
+                "Unknown tool: #{name}. Available tools: #{available_names.join(", ")}"
+            end
 
             tool_class
           end
@@ -56,13 +60,20 @@ module SwarmSDK
 
         # Check if a tool exists
         #
+        # Note: Only checks built-in tools. Plugin-provided tools are checked
+        # via SwarmSDK::PluginRegistry.plugin_tool?() instead.
+        #
         # @param name [Symbol, String] Tool name
         # @return [Boolean]
         def exists?(name)
-          BUILTIN_TOOLS.key?(name.to_sym)
+          name_sym = name.to_sym
+          BUILTIN_TOOLS.key?(name_sym)
         end
 
-        # Get all available tool names
+        # Get all available built-in tool names
+        #
+        # Note: Does NOT include plugin-provided tools. To get all available tools
+        # including plugins, combine with SwarmSDK::PluginRegistry.tools.
         #
         # @return [Array<Symbol>]
         def available_names