claude_swarm 1.0.10 → 1.0.11

data/lib/swarm_sdk/models.rb

@@ -18,16 +18,57 @@ module SwarmSDK
     MODELS_JSON_PATH = File.expand_path("models.json", __dir__)
     ALIASES_JSON_PATH = File.expand_path("model_aliases.json", __dir__)
 
+    # Model information wrapper providing method access to model data
+    #
+    # Wraps the raw Hash from models.json to provide RubyLLM::Model::Info-like
+    # interface for compatibility with code expecting method access.
+    #
+    # @example
+    #   model = SwarmSDK::Models.find("claude-sonnet-4-5-20250929")
+    #   model.context_window  #=> 200000
+    #   model.id              #=> "claude-sonnet-4-5-20250929"
+    class ModelInfo
+      attr_reader :id,
+        :name,
+        :provider,
+        :family,
+        :context_window,
+        :max_output_tokens,
+        :knowledge_cutoff,
+        :modalities,
+        :capabilities,
+        :pricing,
+        :metadata
+
+      # Create a ModelInfo from a Hash
+      #
+      # @param data [Hash] Model data from models.json
+      def initialize(data)
+        @id = data["id"] || data[:id]
+        @name = data["name"] || data[:name]
+        @provider = data["provider"] || data[:provider]
+        @family = data["family"] || data[:family]
+        @context_window = data["context_window"] || data[:context_window]
+        @max_output_tokens = data["max_output_tokens"] || data[:max_output_tokens]
+        @knowledge_cutoff = data["knowledge_cutoff"] || data[:knowledge_cutoff]
+        @modalities = data["modalities"] || data[:modalities]
+        @capabilities = data["capabilities"] || data[:capabilities]
+        @pricing = data["pricing"] || data[:pricing]
+        @metadata = data["metadata"] || data[:metadata]
+      end
+    end
+
     class << self
       # Find a model by ID or alias
       #
       # @param model_id [String] Model ID or alias to find
-      # @return [Hash, nil] Model data or nil if not found
+      # @return [ModelInfo, nil] Model info or nil if not found
       def find(model_id)
         # Check if it's an alias first
         resolved_id = resolve_alias(model_id)
 
-        all.find { |m| m["id"] == resolved_id || m[:id] == resolved_id }
+        model_hash = all.find { |m| m["id"] == resolved_id || m[:id] == resolved_id }
+        model_hash ? ModelInfo.new(model_hash) : nil
       end
 
       # Resolve a model alias to full model ID

data/lib/swarm_sdk/plugin.rb

@@ -139,11 +139,11 @@ module SwarmSDK
       []
     end
 
-    # Agent storage enabled for this agent? (optional)
+    # Check if memory is configured for this agent (optional)
     #
     # @param agent_definition [Agent::Definition] Agent definition
     # @return [Boolean] True if storage should be created
-    def storage_enabled?(agent_definition)
+    def memory_configured?(agent_definition)
       false
     end
 

data/lib/swarm_sdk/result.rb

@@ -109,6 +109,58 @@ module SwarmSDK
       @logs.map { |entry| entry[:agent] }.compact.uniq.map(&:to_sym)
     end
 
+    # Get per-agent usage breakdown from logs
+    #
+    # Aggregates context usage, tokens, and cost for each agent from their
+    # final agent_stop or agent_step events. Each agent's entry includes:
+    # - input_tokens, output_tokens, total_tokens
+    # - context_limit, usage_percentage, tokens_remaining
+    # - input_cost, output_cost, total_cost
+    #
+    # @return [Hash{Symbol => Hash}] Per-agent usage breakdown
+    #
+    # @example
+    #   result.per_agent_usage[:backend]
+    #   # => {
+    #   #   input_tokens: 15000,
+    #   #   output_tokens: 5000,
+    #   #   total_tokens: 20000,
+    #   #   context_limit: 200000,
+    #   #   usage_percentage: "10.0%",
+    #   #   tokens_remaining: 180000,
+    #   #   input_cost: 0.045,
+    #   #   output_cost: 0.075,
+    #   #   total_cost: 0.12
+    #   # }
+    def per_agent_usage
+      # Find the last usage entry for each agent
+      agent_entries = {}
+
+      @logs.each do |entry|
+        next unless entry[:usage] && entry[:agent]
+        next unless entry[:type] == "agent_step" || entry[:type] == "agent_stop"
+
+        agent_name = entry[:agent].to_sym
+        agent_entries[agent_name] = entry[:usage]
+      end
+
+      # Build breakdown from final usage entries
+      agent_entries.transform_values do |usage|
+        {
+          input_tokens: usage[:cumulative_input_tokens] || 0,
+          output_tokens: usage[:cumulative_output_tokens] || 0,
+          total_tokens: usage[:cumulative_total_tokens] || 0,
+          cached_tokens: usage[:cumulative_cached_tokens] || 0,
+          context_limit: usage[:context_limit],
+          usage_percentage: usage[:tokens_used_percentage],
+          tokens_remaining: usage[:tokens_remaining],
+          input_cost: usage[:input_cost] || 0.0,
+          output_cost: usage[:output_cost] || 0.0,
+          total_cost: usage[:total_cost] || 0.0,
+        }
+      end
+    end
+
     # Count total LLM requests made
     # Each LLM API call produces either agent_step (tool calls) or agent_stop (final answer)
     def llm_requests

data/lib/swarm_sdk/swarm/agent_initializer.rb

@@ -569,7 +569,7 @@ module SwarmSDK
         PluginRegistry.all.each do |plugin|
           @swarm.agent_definitions.each do |agent_name, agent_definition|
             # Check if this plugin needs storage for this agent
-            next unless plugin.storage_enabled?(agent_definition)
+            next unless plugin.memory_configured?(agent_definition)
 
             # Get plugin config for this agent
             config = get_plugin_config(agent_definition, plugin.name)

data/lib/swarm_sdk/swarm/hook_triggers.rb

@@ -77,6 +77,7 @@ module SwarmSDK
             total_cost: result.total_cost,
             total_tokens: result.total_tokens,
             agents_involved: result.agents_involved,
+            per_agent_usage: result.per_agent_usage,
             result: result,
             timestamp: Time.now.utc.iso8601,
           },

data/lib/swarm_sdk/swarm/logging_callbacks.rb

@@ -208,6 +208,7 @@ module SwarmSDK
           total_cost: context.metadata[:total_cost],
           total_tokens: context.metadata[:total_tokens],
           agents_involved: context.metadata[:agents_involved],
+          per_agent_usage: context.metadata[:per_agent_usage],
           timestamp: context.metadata[:timestamp],
         )
       end

data/lib/swarm_sdk/swarm/tool_configurator.rb

@@ -60,6 +60,11 @@ module SwarmSDK
       # 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.
@@ -80,7 +85,16 @@ module SwarmSDK
           return create_plugin_tool(tool_name_sym, agent_name, directory, chat, agent_definition)
         end
 
-        # Use Registry factory pattern - tools declare their own requirements
+        # 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
+
+        # Use Registry factory pattern for built-in tools
         context = {
           agent_name: agent_name,
           directory: directory,
@@ -127,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
 
@@ -267,7 +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)
+          next unless plugin.memory_configured?(agent_definition)
 
           # Register each tool provided by the plugin
           plugin.tools.each do |tool_name|

data/lib/swarm_sdk/swarm.rb

@@ -67,8 +67,7 @@ module SwarmSDK
     include LoggingCallbacks
     include HookTriggers
 
-    # Backward compatibility aliases - use Defaults module for new code
-    DEFAULT_MCP_LOG_LEVEL = Defaults::Logging::MCP_LOG_LEVEL
+    # NOTE: MCP log level now accessed via SwarmSDK.config.mcp_log_level
 
     # Default tools available to all agents
     DEFAULT_TOOLS = ToolConfigurator::DEFAULT_TOOLS
@@ -98,7 +97,7 @@ module SwarmSDK
     attr_writer :first_message_sent
 
     # Class-level MCP log level configuration
-    @mcp_log_level = DEFAULT_MCP_LOG_LEVEL
+    @mcp_log_level = nil
     @mcp_logging_configured = false
 
     class << self
@@ -111,8 +110,8 @@ module SwarmSDK
       #
       # @param level [Integer] Log level (Logger::DEBUG, Logger::INFO, Logger::WARN, Logger::ERROR, Logger::FATAL)
       # @return [void]
-      def configure_mcp_logging(level = DEFAULT_MCP_LOG_LEVEL)
-        @mcp_log_level = level
+      def configure_mcp_logging(level = nil)
+        @mcp_log_level = level || SwarmSDK.config.mcp_log_level
         apply_mcp_logging_configuration
       end
 
@@ -123,7 +122,7 @@ module SwarmSDK
         return if @mcp_logging_configured
 
         RubyLLM::MCP.configure do |config|
-          config.log_level = @mcp_log_level
+          config.log_level = @mcp_log_level || SwarmSDK.config.mcp_log_level
         end
 
         @mcp_logging_configured = true
@@ -135,17 +134,17 @@ module SwarmSDK
     # @param name [String] Human-readable swarm name
     # @param swarm_id [String, nil] Optional swarm ID (auto-generated if not provided)
     # @param parent_swarm_id [String, nil] Optional parent swarm ID (nil for root swarms)
-    # @param global_concurrency [Integer] Max concurrent LLM calls across entire swarm
-    # @param default_local_concurrency [Integer] Default max concurrent tool calls per agent
+    # @param global_concurrency [Integer, nil] Max concurrent LLM calls across entire swarm (nil uses config default)
+    # @param default_local_concurrency [Integer, nil] Default max concurrent tool calls per agent (nil uses config default)
     # @param scratchpad [Tools::Stores::Scratchpad, nil] Optional scratchpad instance (for testing/internal use)
     # @param scratchpad_mode [Symbol, String] Scratchpad mode (:enabled or :disabled). :per_node not allowed for non-node swarms.
     # @param allow_filesystem_tools [Boolean, nil] Whether to allow filesystem tools (nil uses global setting)
-    def initialize(name:, swarm_id: nil, parent_swarm_id: nil, global_concurrency: Defaults::Concurrency::GLOBAL_LIMIT, default_local_concurrency: Defaults::Concurrency::LOCAL_LIMIT, scratchpad: nil, scratchpad_mode: :enabled, allow_filesystem_tools: nil)
+    def initialize(name:, swarm_id: nil, parent_swarm_id: nil, global_concurrency: nil, default_local_concurrency: nil, scratchpad: nil, scratchpad_mode: :enabled, allow_filesystem_tools: nil)
       @name = name
       @swarm_id = swarm_id || generate_swarm_id(name)
       @parent_swarm_id = parent_swarm_id
-      @global_concurrency = global_concurrency
-      @default_local_concurrency = default_local_concurrency
+      @global_concurrency = global_concurrency || SwarmSDK.config.global_concurrency_limit
+      @default_local_concurrency = default_local_concurrency || SwarmSDK.config.local_concurrency_limit
 
       # Handle scratchpad_mode parameter
       # For Swarm: :enabled or :disabled (not :per_node - that's for nodes)
@@ -153,9 +152,9 @@ module SwarmSDK
 
       # Resolve allow_filesystem_tools with priority:
       # 1. Explicit parameter (if not nil)
-      # 2. Global settings
+      # 2. Global config
       @allow_filesystem_tools = if allow_filesystem_tools.nil?
-        SwarmSDK.settings.allow_filesystem_tools
+        SwarmSDK.config.allow_filesystem_tools
       else
         allow_filesystem_tools
       end
@@ -367,6 +366,47 @@ module SwarmSDK
       @agent_definitions.keys
     end
 
+    # Get context usage breakdown for all agents
+    #
+    # Returns per-agent context statistics including tokens used, context limit,
+    # usage percentage, and cost. Useful for monitoring context window consumption
+    # across the swarm.
+    #
+    # @return [Hash{Symbol => Hash}] Per-agent context breakdown
+    #
+    # @example
+    #   breakdown = swarm.context_breakdown
+    #   breakdown[:backend]
+    #   # => {
+    #   #   input_tokens: 15000,
+    #   #   output_tokens: 5000,
+    #   #   total_tokens: 20000,
+    #   #   cached_tokens: 2000,
+    #   #   context_limit: 200000,
+    #   #   usage_percentage: 10.0,
+    #   #   tokens_remaining: 180000,
+    #   #   input_cost: 0.045,
+    #   #   output_cost: 0.075,
+    #   #   total_cost: 0.12
+    #   # }
+    def context_breakdown
+      initialize_agents unless @agents_initialized
+
+      breakdown = {}
+
+      # Include primary agents
+      @agents.each do |name, chat|
+        breakdown[name] = build_agent_context_info(chat)
+      end
+
+      # Include delegation instances
+      @delegation_instances.each do |instance_name, chat|
+        breakdown[instance_name.to_sym] = build_agent_context_info(chat)
+      end
+
+      breakdown
+    end
+
     # Implement Snapshotable interface
     def primary_agents
       @agents
@@ -547,6 +587,29 @@ module SwarmSDK
       end
     end
 
+    # Build context info hash for an agent chat instance
+    #
+    # @param chat [Agent::Chat] Agent chat instance with TokenTracking
+    # @return [Hash] Context usage information
+    def build_agent_context_info(chat)
+      return {} unless chat.respond_to?(:cumulative_input_tokens)
+
+      {
+        input_tokens: chat.cumulative_input_tokens,
+        output_tokens: chat.cumulative_output_tokens,
+        total_tokens: chat.cumulative_total_tokens,
+        cached_tokens: chat.cumulative_cached_tokens,
+        cache_creation_tokens: chat.cumulative_cache_creation_tokens,
+        effective_input_tokens: chat.effective_input_tokens,
+        context_limit: chat.context_limit,
+        usage_percentage: chat.context_usage_percentage,
+        tokens_remaining: chat.tokens_remaining,
+        input_cost: chat.cumulative_input_cost,
+        output_cost: chat.cumulative_output_cost,
+        total_cost: chat.cumulative_total_cost,
+      }
+    end
+
     # Validate that observer agent exists
     #
     # @param agent_name [Symbol] Name of the observer agent

data/lib/swarm_sdk/tools/bash.rb

@@ -85,10 +85,7 @@ module SwarmSDK
         desc: "Optional timeout in milliseconds (max 600000)",
         required: false
 
-      # 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
+      # NOTE: Timeout and output limits now accessed via SwarmSDK.config
 
       # Commands that are ALWAYS blocked for safety reasons
       # These cannot be overridden by permissions configuration
@@ -107,8 +104,8 @@ module SwarmSDK
         end
 
         # Validate and set timeout
-        timeout_ms = timeout || DEFAULT_TIMEOUT_MS
-        timeout_ms = [timeout_ms, MAX_TIMEOUT_MS].min
+        timeout_ms = timeout || SwarmSDK.config.bash_command_timeout
+        timeout_ms = [timeout_ms, SwarmSDK.config.bash_command_max_timeout].min
         timeout_seconds = timeout_ms / 1000.0
 
         # Execute command with timeout
@@ -149,9 +146,10 @@ module SwarmSDK
         output = format_command_output(command, description, stdout, stderr, exit_status)
 
         # Truncate if too long
-        if output.length > MAX_OUTPUT_LENGTH
-          truncated = output[0...MAX_OUTPUT_LENGTH]
-          truncated += "\n\n<system-reminder>Output truncated at #{MAX_OUTPUT_LENGTH} characters. The full output was #{output.length} characters.</system-reminder>"
+        max_output = SwarmSDK.config.output_character_limit
+        if output.length > max_output
+          truncated = output[0...max_output]
+          truncated += "\n\n<system-reminder>Output truncated at #{max_output} characters. The full output was #{output.length} characters.</system-reminder>"
           output = truncated
         end
 

data/lib/swarm_sdk/tools/glob.rb

@@ -50,8 +50,7 @@ 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
 
-      # Backward compatibility alias - use Defaults module for new code
-      MAX_RESULTS = Defaults::Limits::GLOB_RESULTS
+      # NOTE: Result limit now accessed via SwarmSDK.config.glob_result_limit
 
       def execute(pattern:, path: nil)
         # Validate inputs
@@ -108,8 +107,9 @@ module SwarmSDK
           matches.sort_by! { |f| -File.mtime(f).to_i }
 
           # Limit results
-          if matches.count > MAX_RESULTS
-            matches = matches.take(MAX_RESULTS)
+          max_results = SwarmSDK.config.glob_result_limit
+          if matches.count > max_results
+            matches = matches.take(max_results)
             truncated = true
           else
             truncated = false
@@ -123,7 +123,7 @@ module SwarmSDK
             output += <<~REMINDER
 
               <system-reminder>
-              Results limited to first #{MAX_RESULTS} matches (sorted by most recently modified).
+              Results limited to first #{max_results} matches (sorted by most recently modified).
               Consider using a more specific pattern to narrow your search.
               </system-reminder>
             REMINDER

data/lib/swarm_sdk/tools/read.rb

@@ -10,9 +10,7 @@ module SwarmSDK
     class Read < RubyLLM::Tool
       include PathResolver
 
-      # Backward compatibility aliases - use Defaults module for new code
-      MAX_LINE_LENGTH = Defaults::Limits::LINE_CHARACTERS
-      DEFAULT_LIMIT = Defaults::Limits::READ_LINES
+      # NOTE: Line length and limit now accessed via SwarmSDK.config
 
       # List of available document converters
       CONVERTERS = [
@@ -153,18 +151,20 @@ module SwarmSDK
         lines = lines.drop(start_line)
 
         # Apply limit if specified, otherwise use default
-        effective_limit = limit || DEFAULT_LIMIT
+        default_limit = SwarmSDK.config.read_line_limit
+        effective_limit = limit || default_limit
         lines = lines.take(effective_limit)
-        truncated = limit.nil? && total_lines > DEFAULT_LIMIT
+        truncated = limit.nil? && total_lines > default_limit
 
         # Format with line numbers (cat -n style)
+        max_line_length = SwarmSDK.config.line_character_limit
         output_lines = lines.each_with_index.map do |line, idx|
           line_number = start_line + idx + 1
           display_line = line.chomp
 
           # Truncate long lines
-          if display_line.length > MAX_LINE_LENGTH
-            display_line = display_line[0...MAX_LINE_LENGTH]
+          if display_line.length > max_line_length
+            display_line = display_line[0...max_line_length]
             display_line += "... (line truncated)"
           end
 
@@ -203,7 +203,7 @@ module SwarmSDK
 
         if truncated
           reminders << ""
-          reminders << "Note: This file has #{total_lines} lines but only the first #{DEFAULT_LIMIT} lines are shown. Use the offset and limit parameters to read additional sections if needed."
+          reminders << "Note: This file has #{total_lines} lines but only the first #{SwarmSDK.config.read_line_limit} lines are shown. Use the offset and limit parameters to read additional sections if needed."
         end
 
         reminders << "</system-reminder>"

data/lib/swarm_sdk/tools/stores/scratchpad_storage.rb

@@ -21,7 +21,7 @@ module SwarmSDK
           super() # Initialize parent Storage class
           @entries = {}
           @total_size = 0
-          @total_size_limit = total_size_limit || Defaults::Storage::TOTAL_SIZE_BYTES
+          @total_size_limit = total_size_limit || SwarmSDK.config.scratchpad_total_size_limit
           @mutex = Mutex.new
         end
 
@@ -41,8 +41,9 @@ module SwarmSDK
             content_size = content.bytesize
 
             # Check entry size limit
-            if content_size > Defaults::Storage::ENTRY_SIZE_BYTES
-              raise ArgumentError, "Content exceeds maximum size (#{format_bytes(Defaults::Storage::ENTRY_SIZE_BYTES)}). " \
+            entry_size_limit = SwarmSDK.config.scratchpad_entry_size_limit
+            if content_size > entry_size_limit
+              raise ArgumentError, "Content exceeds maximum size (#{format_bytes(entry_size_limit)}). " \
                 "Current: #{format_bytes(content_size)}"
             end
 

data/lib/swarm_sdk/tools/web_fetch.rb

@@ -11,7 +11,6 @@ module SwarmSDK
         super()
         @cache = {}
         @cache_ttl = 900 # 15 minutes in seconds
-        @llm_enabled = SwarmSDK.settings.webfetch_llm_enabled?
       end
 
       def name
@@ -51,17 +50,18 @@ module SwarmSDK
         desc: "The prompt to run on the fetched content. Required when SwarmSDK is configured with webfetch_provider and webfetch_model. Optional otherwise (ignored if LLM processing not configured).",
         required: false
 
-      # Backward compatibility aliases - use Defaults module for new code
-      MAX_CONTENT_LENGTH = Defaults::Limits::WEB_FETCH_CHARACTERS
+      # NOTE: Content length and timeout now accessed via SwarmSDK.config
       USER_AGENT = "SwarmSDK WebFetch Tool (https://github.com/parruda/claude-swarm)"
-      TIMEOUT = Defaults::Timeouts::WEB_FETCH_SECONDS
 
       def execute(url:, prompt: nil)
         # Validate inputs
         return validation_error("url is required") if url.nil? || url.empty?
 
+        # Check if LLM processing is enabled (lazy check)
+        llm_enabled = SwarmSDK.config.webfetch_llm_enabled?
+
         # Validate prompt when LLM processing is enabled
-        if @llm_enabled && (prompt.nil? || prompt.empty?)
+        if llm_enabled && (prompt.nil? || prompt.empty?)
           return validation_error("prompt is required when LLM processing is configured")
         end
 
@@ -70,7 +70,7 @@ module SwarmSDK
         return validation_error("Invalid URL format: #{url}") unless normalized_url
 
         # Check cache first (cache key includes prompt if LLM is enabled)
-        cache_key = @llm_enabled ? "#{normalized_url}:#{prompt}" : normalized_url
+        cache_key = llm_enabled ? "#{normalized_url}:#{prompt}" : normalized_url
         cached = get_from_cache(cache_key)
         return cached if cached
 
@@ -87,13 +87,14 @@ module SwarmSDK
         markdown_content = html_to_markdown(fetch_result[:body])
 
         # Truncate if too long
-        if markdown_content.length > MAX_CONTENT_LENGTH
-          markdown_content = markdown_content[0...MAX_CONTENT_LENGTH]
+        max_content = SwarmSDK.config.web_fetch_character_limit
+        if markdown_content.length > max_content
+          markdown_content = markdown_content[0...max_content]
           markdown_content += "\n\n[Content truncated due to length]"
         end
 
         # Process with AI model if LLM is enabled, otherwise return markdown
-        result = if @llm_enabled
+        result = if llm_enabled
           process_with_llm(markdown_content, prompt, normalized_url)
         else
           markdown_content
@@ -143,12 +144,13 @@ module SwarmSDK
         require "faraday"
         require "faraday/follow_redirects"
 
+        timeout = SwarmSDK.config.web_fetch_timeout
         response = Faraday.new(url: url) do |conn|
           conn.request(:url_encoded)
           conn.response(:follow_redirects, limit: 5)
           conn.adapter(Faraday.default_adapter)
-          conn.options.timeout = TIMEOUT
-          conn.options.open_timeout = TIMEOUT
+          conn.options.timeout = timeout
+          conn.options.open_timeout = timeout
         end.get do |req|
           req.headers["User-Agent"] = USER_AGENT
           req.headers["Accept"] = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
@@ -167,7 +169,7 @@ module SwarmSDK
           redirect_url: redirect_url,
         }
       rescue Faraday::TimeoutError
-        error("Request timed out after #{TIMEOUT} seconds")
+        error("Request timed out after #{SwarmSDK.config.web_fetch_timeout} seconds")
       rescue Faraday::ConnectionFailed => e
         error("Connection failed: #{e.message}")
       rescue StandardError => e
@@ -194,17 +196,17 @@ module SwarmSDK
           Please respond to the user's request based on the content above.
         PROMPT
 
-        # Get settings
-        config = SwarmSDK.settings
+        # Get config
+        sdk_config = SwarmSDK.config
 
         # Build chat with configured provider and model
         chat_params = {
-          model: config.webfetch_model,
-          provider: config.webfetch_provider.to_sym,
+          model: sdk_config.webfetch_model,
+          provider: sdk_config.webfetch_provider.to_sym,
         }
-        chat_params[:base_url] = config.webfetch_base_url if config.webfetch_base_url
+        chat_params[:base_url] = sdk_config.webfetch_base_url if sdk_config.webfetch_base_url
 
-        chat = RubyLLM.chat(**chat_params).with_params(max_tokens: config.webfetch_max_tokens)
+        chat = RubyLLM.chat(**chat_params).with_params(max_tokens: sdk_config.webfetch_max_tokens)
 
         response = chat.ask(full_prompt)
 

data/lib/swarm_sdk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SwarmSDK
-  VERSION = "2.3.0"
+  VERSION = "2.5.1"
 end