swarm_sdk 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8643441321fcf3c24d637134d75697f61670ffa4129608c1c4d0e98571805a5
-  data.tar.gz: cb105cd387671e16eea9ebf52fbcf31a11f9ec0d6a03b7f2e45cad7721434dab
+  metadata.gz: 9921bd8cfa2073d8a470b7c9f39ec925f07a4d4c3a38ea03fd1e5bc5e83fd2a7
+  data.tar.gz: e7a77f34453d3d3521eea2c3461563050b5057b340f54e7544ad3d9efecbda5a
 SHA512:
-  metadata.gz: f613f1d8be2c5fd00ebaaa896b54bdeb34f6537b56638706c5655d8b0ceeb942c87702be5d07be748dd194ec90c48c5e7b24d180ca6bea58714f43cd55afaf86
-  data.tar.gz: b608df1ef8b5368c4f1e84a057591103943df755706bdaba521fa56075805d6281d434968eadb4cb35edb6a4d9987e710e9b1450fde09c9ed23ed1bebe5af075
+  metadata.gz: 7a37d856b2989058fa3a62fb9847de0fe810d03140fb4fee10f88af2f5995c3a79cd2f6443e233403499619c8a9b99c825f64a68386d411a35eb92accc11a225
+  data.tar.gz: 42e1849a8b7d9660627b0b1477cf558829e0b7afd46f4087c1a5204a1dd0dd7ae76a09be2c963884fc61f926c3b8c93fd17331cc5d8d1fa5b025c5c44fc71740

data/lib/swarm_sdk/agent/chat.rb

@@ -122,7 +122,7 @@ module SwarmSDK
         max_concurrent_tools = definition[:max_concurrent_tools]
         base_url = definition[:base_url]
         api_version = definition[:api_version]
-        timeout = definition[:timeout] || Defaults::Timeouts::AGENT_REQUEST_SECONDS
+        timeout = definition[:timeout] || SwarmSDK.config.agent_request_timeout
         assume_model_exists = definition[:assume_model_exists]
         system_prompt = definition[:system_prompt]
         parameters = definition[:parameters]

data/lib/swarm_sdk/agent/chat_helpers/hook_integration.rb

@@ -117,7 +117,7 @@ module SwarmSDK
 
             # Trigger automatic compression at 60% ONLY if no custom handler
             compression_triggered = false
-            if threshold == Context::COMPRESSION_THRESHOLD && !has_custom_handler
+            if threshold == SwarmSDK.config.context_compression_threshold && !has_custom_handler
               compressed_count = apply_automatic_compression
               compression_triggered = compressed_count > 0
             end

data/lib/swarm_sdk/agent/chat_helpers/llm_configuration.rb

@@ -47,7 +47,7 @@ module SwarmSDK
         #
         # @return [RubyLLM::Chat] Chat instance
         def instantiate_chat(model_id:, provider_name:, base_url:, timeout:, assume_model_exists:, chat_options:)
-          if base_url || timeout != Defaults::Timeouts::AGENT_REQUEST_SECONDS
+          if base_url || timeout != SwarmSDK.config.agent_request_timeout
             instantiate_with_custom_context(
               model_id: model_id,
               provider_name: provider_name,
@@ -123,22 +123,51 @@ module SwarmSDK
         end
 
         # Configure provider-specific base URL
+        #
+        # @param config [RubyLLM::Config] RubyLLM configuration context
+        # @param provider [String] Provider name
+        # @param base_url [String] Custom base URL
+        # @raise [ConfigurationError] If API key is required but not configured
+        # @raise [ArgumentError] If provider doesn't support custom base_url
         def configure_provider_base_url(config, provider, base_url)
           case provider.to_s
           when "openai", "deepseek", "perplexity", "mistral", "openrouter"
             config.openai_api_base = base_url
-            config.openai_api_key = ENV["OPENAI_API_KEY"] || "dummy-key-for-local"
+            api_key = SwarmSDK.config.openai_api_key
+
+            # For local endpoints, API key is optional
+            # For cloud endpoints, require API key
+            unless api_key || local_endpoint?(base_url)
+              raise ConfigurationError,
+                "OpenAI API key required for '#{provider}' with base_url '#{base_url}'. " \
+                  "Configure with: SwarmSDK.configure { |c| c.openai_api_key = '...' }"
+            end
+
+            config.openai_api_key = api_key if api_key
             config.openai_use_system_role = true
           when "ollama"
             config.ollama_api_base = base_url
+            # Ollama doesn't need an API key
           when "gpustack"
             config.gpustack_api_base = base_url
-            config.gpustack_api_key = ENV["GPUSTACK_API_KEY"] || "dummy-key"
+            api_key = SwarmSDK.config.gpustack_api_key
+            config.gpustack_api_key = api_key if api_key
           else
             raise ArgumentError, "Provider '#{provider}' doesn't support custom base_url."
           end
         end
 
+        # Check if a URL points to a local endpoint
+        #
+        # @param url [String] URL to check
+        # @return [Boolean] true if URL is a local endpoint
+        def local_endpoint?(url)
+          uri = URI.parse(url)
+          ["localhost", "127.0.0.1", "0.0.0.0"].include?(uri.host)
+        rescue URI::InvalidURIError
+          false
+        end
+
         # Fetch real model info for accurate context tracking
         #
         # @param model_id [String] Model ID to lookup

data/lib/swarm_sdk/agent/chat_helpers/system_reminder_injector.rb

@@ -22,9 +22,6 @@ module SwarmSDK
           <system-reminder>The TodoWrite tool hasn't been used recently. If you're working on tasks that would benefit from tracking progress, consider using the TodoWrite tool to track progress. Also consider cleaning up the todo list if has become stale and no longer matches what you are working on. Only use it if it's relevant to the current work. This is just a gentle reminder - ignore if not applicable.</system-reminder>
         REMINDER
 
-        # Backward compatibility alias - use Defaults module for new code
-        TODOWRITE_REMINDER_INTERVAL = Defaults::Context::TODOWRITE_REMINDER_INTERVAL
-
         class << self
           # Check if this is the first user message in the conversation
           #
@@ -106,15 +103,16 @@ module SwarmSDK
             end
 
             # Check if enough messages have passed since last TodoWrite
+            reminder_interval = SwarmSDK.config.todowrite_reminder_interval
             if last_todo_index.nil? && last_todowrite_index.nil?
               # Never used TodoWrite - check if we've exceeded interval
-              chat.message_count >= TODOWRITE_REMINDER_INTERVAL
+              chat.message_count >= reminder_interval
             elsif last_todo_index
               # Recently used - don't remind
               false
             elsif last_todowrite_index
               # Used before - check if interval has passed
-              chat.message_count - last_todowrite_index >= TODOWRITE_REMINDER_INTERVAL
+              chat.message_count - last_todowrite_index >= reminder_interval
             else
               false
             end

data/lib/swarm_sdk/agent/context.rb

@@ -30,8 +30,7 @@ module SwarmSDK
       # 60% triggers automatic compression, 80%/90% are informational warnings
       CONTEXT_WARNING_THRESHOLDS = [60, 80, 90].freeze
 
-      # Backward compatibility alias - use Defaults module for new code
-      COMPRESSION_THRESHOLD = Defaults::Context::COMPRESSION_THRESHOLD_PERCENT
+      # NOTE: Compression threshold now accessed via SwarmSDK.config.context_compression_threshold
 
       attr_reader :name, :delegation_tools, :metadata, :warning_thresholds_hit, :swarm_id, :parent_swarm_id
 

data/lib/swarm_sdk/agent/definition.rb

@@ -67,14 +67,14 @@ module SwarmSDK
         end
 
         @description = config[:description]
-        @model = config[:model] || Defaults::Agent::MODEL
-        @provider = config[:provider] || Defaults::Agent::PROVIDER
+        @model = config[:model] || SwarmSDK.config.default_model
+        @provider = config[:provider] || SwarmSDK.config.default_provider
         @base_url = config[:base_url]
         @api_version = config[:api_version]
         @context_window = config[:context_window] # Explicit context window override
         @parameters = config[:parameters] || {}
         @headers = Utils.stringify_keys(config[:headers] || {})
-        @timeout = config[:timeout] || Defaults::Timeouts::AGENT_REQUEST_SECONDS
+        @timeout = config[:timeout] || SwarmSDK.config.agent_request_timeout
         @bypass_permissions = config[:bypass_permissions] || false
         @max_concurrent_tools = config[:max_concurrent_tools]
         # Always assume model exists - SwarmSDK validates models separately using models.json

data/lib/swarm_sdk/builders/base_builder.rb

@@ -318,7 +318,7 @@ module SwarmSDK
       # @return [void]
       def validate_all_agents_filesystem_tools
         resolved_setting = if @allow_filesystem_tools.nil?
-          SwarmSDK.settings.allow_filesystem_tools
+          SwarmSDK.config.allow_filesystem_tools
         else
           @allow_filesystem_tools
         end
@@ -333,10 +333,10 @@ module SwarmSDK
         return if 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 all_agents configuration includes: #{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
 
       # Validate individual agent filesystem tools
@@ -345,7 +345,7 @@ module SwarmSDK
       # @return [void]
       def validate_agent_filesystem_tools
         resolved_setting = if @allow_filesystem_tools.nil?
-          SwarmSDK.settings.allow_filesystem_tools
+          SwarmSDK.config.allow_filesystem_tools
         else
           @allow_filesystem_tools
         end
@@ -373,10 +373,10 @@ module SwarmSDK
           next if 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
 

data/lib/swarm_sdk/config.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+module SwarmSDK
+  # Centralized configuration for SwarmSDK
+  #
+  # Config provides a single entry point for all SwarmSDK configuration,
+  # including API keys (proxied to RubyLLM), defaults override, and
+  # WebFetch settings.
+  #
+  # ## Priority Order
+  #
+  # Configuration values are resolved in this order:
+  # 1. Explicit value (set via SwarmSDK.configure)
+  # 2. Environment variable
+  # 3. Module default (from SwarmSDK::Defaults)
+  #
+  # ## API Key Proxying
+  #
+  # API keys are automatically proxied to RubyLLM.config when set,
+  # ensuring RubyLLM always has the correct credentials.
+  #
+  # @example Basic configuration
+  #   SwarmSDK.configure do |config|
+  #     config.openai_api_key = "sk-..."
+  #     config.default_model = "claude-sonnet-4"
+  #     config.agent_request_timeout = 600
+  #   end
+  #
+  # @example Testing setup
+  #   def setup
+  #     SwarmSDK.reset_config!
+  #   end
+  class Config
+    # API keys that proxy to RubyLLM.config
+    # Maps SwarmSDK config key => [RubyLLM config key, ENV variable]
+    API_KEY_MAPPINGS = {
+      openai_api_key: [:openai_api_key, "OPENAI_API_KEY"],
+      openai_api_base: [:openai_api_base, "OPENAI_API_BASE"],
+      openai_organization_id: [:openai_organization_id, "OPENAI_ORG_ID"],
+      openai_project_id: [:openai_project_id, "OPENAI_PROJECT_ID"],
+      anthropic_api_key: [:anthropic_api_key, "ANTHROPIC_API_KEY"],
+      gemini_api_key: [:gemini_api_key, "GEMINI_API_KEY"],
+      gemini_api_base: [:gemini_api_base, "GEMINI_API_BASE"],
+      vertexai_project_id: [:vertexai_project_id, "GOOGLE_CLOUD_PROJECT"],
+      vertexai_location: [:vertexai_location, "GOOGLE_CLOUD_LOCATION"],
+      deepseek_api_key: [:deepseek_api_key, "DEEPSEEK_API_KEY"],
+      mistral_api_key: [:mistral_api_key, "MISTRAL_API_KEY"],
+      perplexity_api_key: [:perplexity_api_key, "PERPLEXITY_API_KEY"],
+      openrouter_api_key: [:openrouter_api_key, "OPENROUTER_API_KEY"],
+      bedrock_api_key: [:bedrock_api_key, "AWS_ACCESS_KEY_ID"],
+      bedrock_secret_key: [:bedrock_secret_key, "AWS_SECRET_ACCESS_KEY"],
+      bedrock_region: [:bedrock_region, "AWS_REGION"],
+      bedrock_session_token: [:bedrock_session_token, "AWS_SESSION_TOKEN"],
+      ollama_api_base: [:ollama_api_base, "OLLAMA_API_BASE"],
+      gpustack_api_base: [:gpustack_api_base, "GPUSTACK_API_BASE"],
+      gpustack_api_key: [:gpustack_api_key, "GPUSTACK_API_KEY"],
+    }.freeze
+
+    # SwarmSDK defaults that can be overridden
+    # Maps config key => [ENV variable, default proc]
+    DEFAULTS_MAPPINGS = {
+      default_model: ["SWARM_SDK_DEFAULT_MODEL", -> { Defaults::Agent::MODEL }],
+      default_provider: ["SWARM_SDK_DEFAULT_PROVIDER", -> { Defaults::Agent::PROVIDER }],
+      agent_request_timeout: ["SWARM_SDK_AGENT_REQUEST_TIMEOUT", -> { Defaults::Timeouts::AGENT_REQUEST_SECONDS }],
+      bash_command_timeout: ["SWARM_SDK_BASH_COMMAND_TIMEOUT", -> { Defaults::Timeouts::BASH_COMMAND_MS }],
+      bash_command_max_timeout: ["SWARM_SDK_BASH_COMMAND_MAX_TIMEOUT", -> { Defaults::Timeouts::BASH_COMMAND_MAX_MS }],
+      web_fetch_timeout: ["SWARM_SDK_WEB_FETCH_TIMEOUT", -> { Defaults::Timeouts::WEB_FETCH_SECONDS }],
+      hook_shell_timeout: ["SWARM_SDK_HOOK_SHELL_TIMEOUT", -> { Defaults::Timeouts::HOOK_SHELL_SECONDS }],
+      transformer_command_timeout: ["SWARM_SDK_TRANSFORMER_COMMAND_TIMEOUT", -> { Defaults::Timeouts::TRANSFORMER_COMMAND_SECONDS }],
+      global_concurrency_limit: ["SWARM_SDK_GLOBAL_CONCURRENCY_LIMIT", -> { Defaults::Concurrency::GLOBAL_LIMIT }],
+      local_concurrency_limit: ["SWARM_SDK_LOCAL_CONCURRENCY_LIMIT", -> { Defaults::Concurrency::LOCAL_LIMIT }],
+      output_character_limit: ["SWARM_SDK_OUTPUT_CHARACTER_LIMIT", -> { Defaults::Limits::OUTPUT_CHARACTERS }],
+      read_line_limit: ["SWARM_SDK_READ_LINE_LIMIT", -> { Defaults::Limits::READ_LINES }],
+      line_character_limit: ["SWARM_SDK_LINE_CHARACTER_LIMIT", -> { Defaults::Limits::LINE_CHARACTERS }],
+      web_fetch_character_limit: ["SWARM_SDK_WEB_FETCH_CHARACTER_LIMIT", -> { Defaults::Limits::WEB_FETCH_CHARACTERS }],
+      glob_result_limit: ["SWARM_SDK_GLOB_RESULT_LIMIT", -> { Defaults::Limits::GLOB_RESULTS }],
+      scratchpad_entry_size_limit: ["SWARM_SDK_SCRATCHPAD_ENTRY_SIZE_LIMIT", -> { Defaults::Storage::ENTRY_SIZE_BYTES }],
+      scratchpad_total_size_limit: ["SWARM_SDK_SCRATCHPAD_TOTAL_SIZE_LIMIT", -> { Defaults::Storage::TOTAL_SIZE_BYTES }],
+      context_compression_threshold: ["SWARM_SDK_CONTEXT_COMPRESSION_THRESHOLD", -> { Defaults::Context::COMPRESSION_THRESHOLD_PERCENT }],
+      todowrite_reminder_interval: ["SWARM_SDK_TODOWRITE_REMINDER_INTERVAL", -> { Defaults::Context::TODOWRITE_REMINDER_INTERVAL }],
+      chars_per_token_prose: ["SWARM_SDK_CHARS_PER_TOKEN_PROSE", -> { Defaults::TokenEstimation::CHARS_PER_TOKEN_PROSE }],
+      chars_per_token_code: ["SWARM_SDK_CHARS_PER_TOKEN_CODE", -> { Defaults::TokenEstimation::CHARS_PER_TOKEN_CODE }],
+      mcp_log_level: ["SWARM_SDK_MCP_LOG_LEVEL", -> { Defaults::Logging::MCP_LOG_LEVEL }],
+    }.freeze
+
+    # WebFetch and control settings
+    # Maps config key => [ENV variable, default value]
+    SETTINGS_MAPPINGS = {
+      webfetch_provider: ["SWARM_SDK_WEBFETCH_PROVIDER", nil],
+      webfetch_model: ["SWARM_SDK_WEBFETCH_MODEL", nil],
+      webfetch_base_url: ["SWARM_SDK_WEBFETCH_BASE_URL", nil],
+      webfetch_max_tokens: ["SWARM_SDK_WEBFETCH_MAX_TOKENS", 4096],
+      allow_filesystem_tools: ["SWARM_SDK_ALLOW_FILESYSTEM_TOOLS", true],
+    }.freeze
+
+    class << self
+      # Get the singleton Config instance
+      #
+      # @return [Config] The singleton instance
+      def instance
+        @instance ||= new
+      end
+
+      # Reset the Config instance
+      #
+      # Clears all configuration including explicit values and cached ENV values.
+      # Use in tests to ensure clean state.
+      #
+      # @return [void]
+      def reset!
+        @instance = nil
+      end
+    end
+
+    # Initialize a new Config instance
+    #
+    # @note Use Config.instance instead of new for the singleton pattern
+    def initialize
+      @explicit_values = {}
+      @env_values = {}
+      @env_loaded = false
+      @env_mutex = Mutex.new
+    end
+
+    # ========== API Key Accessors (with RubyLLM proxying) ==========
+
+    # @!method openai_api_key
+    #   Get the OpenAI API key
+    #   @return [String, nil] The API key
+    #
+    # @!method openai_api_key=(value)
+    #   Set the OpenAI API key (proxied to RubyLLM)
+    #   @param value [String] The API key
+
+    API_KEY_MAPPINGS.each_key do |config_key|
+      ruby_llm_key, _ = API_KEY_MAPPINGS[config_key]
+
+      # Getter
+      define_method(config_key) do
+        ensure_env_loaded!
+        @explicit_values[config_key] || @env_values[config_key]
+      end
+
+      # Setter with RubyLLM proxying
+      define_method("#{config_key}=") do |value|
+        @explicit_values[config_key] = value
+        RubyLLM.config.public_send("#{ruby_llm_key}=", value) if value
+      end
+    end
+
+    # ========== Defaults Accessors (with module constant fallback) ==========
+
+    # @!method default_model
+    #   Get the default model
+    #   @return [String] The default model (falls back to Defaults::Agent::MODEL)
+    #
+    # @!method default_model=(value)
+    #   Set the default model
+    #   @param value [String] The default model
+
+    DEFAULTS_MAPPINGS.each_key do |config_key|
+      _env_key, default_proc = DEFAULTS_MAPPINGS[config_key]
+
+      # Getter with default fallback
+      define_method(config_key) do
+        ensure_env_loaded!
+        @explicit_values[config_key] || @env_values[config_key] || default_proc.call
+      end
+
+      # Setter
+      define_method("#{config_key}=") do |value|
+        @explicit_values[config_key] = value
+      end
+    end
+
+    # ========== Settings Accessors (WebFetch and control) ==========
+
+    # @!method webfetch_provider
+    #   Get the WebFetch LLM provider
+    #   @return [String, nil] The provider
+    #
+    # @!method allow_filesystem_tools
+    #   Get whether filesystem tools are allowed
+    #   @return [Boolean] true if allowed
+
+    SETTINGS_MAPPINGS.each_key do |config_key|
+      _env_key, default_value = SETTINGS_MAPPINGS[config_key]
+
+      # Getter with default fallback
+      define_method(config_key) do
+        ensure_env_loaded!
+        if @explicit_values.key?(config_key)
+          @explicit_values[config_key]
+        elsif @env_values.key?(config_key)
+          @env_values[config_key]
+        else
+          default_value
+        end
+      end
+
+      # Setter
+      define_method("#{config_key}=") do |value|
+        @explicit_values[config_key] = value
+      end
+    end
+
+    # ========== Convenience Methods ==========
+
+    # Check if WebFetch LLM processing is enabled
+    #
+    # WebFetch uses LLM processing when both provider and model are configured.
+    #
+    # @return [Boolean] true if WebFetch LLM is configured
+    def webfetch_llm_enabled?
+      !webfetch_provider.nil? && !webfetch_model.nil?
+    end
+
+    private
+
+    # Ensure ENV values are loaded (lazy loading with double-check locking)
+    #
+    # Thread-safe lazy loading of ENV values. Only loads once per Config instance.
+    #
+    # @return [void]
+    def ensure_env_loaded!
+      return if @env_loaded
+
+      @env_mutex.synchronize do
+        return if @env_loaded
+
+        load_env_values!
+        @env_loaded = true
+      end
+    end
+
+    # Load environment variable values
+    #
+    # Loads API keys (with RubyLLM proxying), defaults, and settings from ENV.
+    # Only loads values that haven't been explicitly set.
+    #
+    # @return [void]
+    def load_env_values!
+      # Load API keys and proxy to RubyLLM
+      API_KEY_MAPPINGS.each do |config_key, (ruby_llm_key, env_key)|
+        next if @explicit_values.key?(config_key)
+        next unless ENV.key?(env_key)
+
+        value = ENV[env_key]
+        @env_values[config_key] = value
+
+        # Proxy to RubyLLM
+        RubyLLM.config.public_send("#{ruby_llm_key}=", value)
+      end
+
+      # Load defaults (no RubyLLM proxy)
+      DEFAULTS_MAPPINGS.each do |config_key, (env_key, _default_proc)|
+        next if @explicit_values.key?(config_key)
+        next unless ENV.key?(env_key)
+
+        @env_values[config_key] = parse_env_value(ENV[env_key], config_key)
+      end
+
+      # Load settings (no RubyLLM proxy)
+      SETTINGS_MAPPINGS.each do |config_key, (env_key, _default_value)|
+        next if @explicit_values.key?(config_key)
+        next unless ENV.key?(env_key)
+
+        @env_values[config_key] = parse_env_value(ENV[env_key], config_key)
+      end
+    end
+
+    # Parse environment variable value to appropriate type
+    #
+    # Converts string ENV values to integers, floats, or booleans based on
+    # the configuration key pattern.
+    #
+    # @param value [String] The ENV value string
+    # @param key [Symbol] The configuration key
+    # @return [Integer, Float, Boolean, String] The parsed value
+    def parse_env_value(value, key)
+      case key
+      when :allow_filesystem_tools
+        # Convert string to boolean
+        case value.to_s.downcase
+        when "true", "yes", "1", "on", "enabled"
+          true
+        when "false", "no", "0", "off", "disabled"
+          false
+        else
+          true # Default to true if unrecognized
+        end
+      when /_timeout$/, /_limit$/, /_interval$/, /_threshold$/, :mcp_log_level, :webfetch_max_tokens
+        value.to_i
+      when /^chars_per_token/
+        value.to_f
+      else
+        value
+      end
+    end
+  end
+end

data/lib/swarm_sdk/context_compactor/token_counter.rb

@@ -17,10 +17,6 @@ module SwarmSDK
     #   total_tokens = TokenCounter.estimate_messages(messages)
     #
     class TokenCounter
-      # Backward compatibility aliases - use Defaults module for new code
-      CHARS_PER_TOKEN_PROSE = Defaults::TokenEstimation::CHARS_PER_TOKEN_PROSE
-      CHARS_PER_TOKEN_CODE = Defaults::TokenEstimation::CHARS_PER_TOKEN_CODE
-
       class << self
         # Estimate tokens for a single message
         #
@@ -78,9 +74,9 @@ module SwarmSDK
 
           # Choose characters per token based on content type
           chars_per_token = if code_ratio > 0.1
-            CHARS_PER_TOKEN_CODE # Code
+            SwarmSDK.config.chars_per_token_code # Code
           else
-            CHARS_PER_TOKEN_PROSE # Prose
+            SwarmSDK.config.chars_per_token_prose # Prose
           end
 
           (text.length / chars_per_token).ceil

data/lib/swarm_sdk/hooks/adapter.rb

@@ -167,7 +167,7 @@ module SwarmSDK
         def create_hook_callback(hook_def, event_symbol, agent_name, swarm_name)
           # Support both string and symbol keys (YAML may be symbolized)
           command = hook_def[:command] || hook_def["command"]
-          timeout = hook_def[:timeout] || hook_def["timeout"] || ShellExecutor::DEFAULT_TIMEOUT
+          timeout = hook_def[:timeout] || hook_def["timeout"] || SwarmSDK.config.hook_shell_timeout
 
           lambda do |context|
             input_json = build_input_json(context, event_symbol, agent_name)
@@ -191,7 +191,7 @@ module SwarmSDK
         def create_all_agents_hook_callback(hook_def, event_symbol, swarm_name)
           # Support both string and symbol keys (YAML may be symbolized)
           command = hook_def[:command] || hook_def["command"]
-          timeout = hook_def[:timeout] || hook_def["timeout"] || ShellExecutor::DEFAULT_TIMEOUT
+          timeout = hook_def[:timeout] || hook_def["timeout"] || SwarmSDK.config.hook_shell_timeout
 
           lambda do |context|
             # Agent name comes from context
@@ -217,7 +217,7 @@ module SwarmSDK
         def create_swarm_hook_callback(hook_def, event_symbol, swarm_name)
           # Support both string and symbol keys (YAML may be symbolized)
           command = hook_def[:command] || hook_def["command"]
-          timeout = hook_def[:timeout] || hook_def["timeout"] || ShellExecutor::DEFAULT_TIMEOUT
+          timeout = hook_def[:timeout] || hook_def["timeout"] || SwarmSDK.config.hook_shell_timeout
 
           lambda do |context|
             input_json = build_swarm_input_json(context, event_symbol, swarm_name)

data/lib/swarm_sdk/hooks/shell_executor.rb

@@ -47,8 +47,7 @@ module SwarmSDK
     #   )
     #   # => Result (continue or halt based on exit code)
     class ShellExecutor
-      # Backward compatibility alias - use Defaults module for new code
-      DEFAULT_TIMEOUT = Defaults::Timeouts::HOOK_SHELL_SECONDS
+      # NOTE: Timeout now accessed via SwarmSDK.config.hook_shell_timeout
 
       class << self
         # Execute a shell command hook
@@ -60,7 +59,9 @@ module SwarmSDK
         # @param swarm_name [String, nil] Swarm name for environment variables
         # @param event [Symbol] Event type for context-aware behavior
         # @return [Result] Result based on exit code (continue or halt)
-        def execute(command:, input_json:, timeout: DEFAULT_TIMEOUT, agent_name: nil, swarm_name: nil, event: nil)
+        def execute(command:, input_json:, timeout: nil, agent_name: nil, swarm_name: nil, event: nil)
+          timeout ||= SwarmSDK.config.hook_shell_timeout
+
           # Build environment variables
           env = build_environment(agent_name: agent_name, swarm_name: swarm_name)