claude_swarm 1.0.10 → 1.0.11

data/lib/swarm_memory/dsl/memory_config.rb

@@ -84,6 +84,43 @@ module SwarmMemory
         @mode = value.to_sym
       end
 
+      # DSL method to set/get semantic weight for hybrid search
+      #
+      # Controls how much semantic (embedding) similarity affects search results.
+      # Default is 0.5 (50%). Set to 1.0 for pure semantic search.
+      #
+      # @param value [Float, nil] Weight between 0.0 and 1.0
+      # @return [Float, nil] Current semantic weight
+      #
+      # @example Pure semantic search (no keyword penalty)
+      #   semantic_weight 1.0
+      #   keyword_weight 0.0
+      def semantic_weight(value = nil)
+        if value.nil?
+          @adapter_options[:semantic_weight]
+        else
+          @adapter_options[:semantic_weight] = value.to_f
+        end
+      end
+
+      # DSL method to set/get keyword weight for hybrid search
+      #
+      # Controls how much keyword (tag) matching affects search results.
+      # Default is 0.5 (50%). Set to 0.0 to disable keyword matching.
+      #
+      # @param value [Float, nil] Weight between 0.0 and 1.0
+      # @return [Float, nil] Current keyword weight
+      #
+      # @example Disable keyword matching
+      #   keyword_weight 0.0
+      def keyword_weight(value = nil)
+        if value.nil?
+          @adapter_options[:keyword_weight]
+        else
+          @adapter_options[:keyword_weight] = value.to_f
+        end
+      end
+
       # Check if memory is enabled
       #
       # @return [Boolean] True if adapter is configured with required options

data/lib/swarm_memory/integration/sdk_plugin.rb

@@ -22,6 +22,9 @@ module SwarmMemory
         # Track memory mode for each agent: { agent_name => mode }
         # Modes: :assistant (default), :retrieval, :researcher
         @modes = {}
+        # Track threshold configuration for each agent: { agent_name => config }
+        # Enables per-adapter threshold tuning with ENV fallback
+        @threshold_configs = {}
       end
 
       # Plugin identifier
@@ -49,7 +52,6 @@ module SwarmMemory
           :MemoryGrep,
           :MemoryWrite,
           :MemoryEdit,
-          :MemoryMultiEdit,
           :MemoryDelete,
           :MemoryDefrag,
         ]
@@ -75,7 +77,6 @@ module SwarmMemory
             :MemoryGrep,
             :MemoryWrite,
             :MemoryEdit,
-            :MemoryMultiEdit,
             :MemoryDelete,
             :MemoryDefrag,
           ]
@@ -109,10 +110,12 @@ module SwarmMemory
           # MemoryConfig object (from DSL)
           [config.adapter_type, config.adapter_options]
         elsif config.is_a?(Hash)
-          # Hash (from YAML)
+          # Hash (from YAML) - symbolize keys for adapter compatibility
           adapter = (config[:adapter] || config["adapter"] || :filesystem).to_sym
-          options = config.reject { |k, _v| k == :adapter || k == "adapter" || k == :mode || k == "mode" }
-          [adapter, options]
+          options = config.reject { |k, _v| [:adapter, "adapter", :mode, "mode"].include?(k) }
+          # Symbolize keys so adapter receives keyword arguments correctly
+          symbolized_options = options.transform_keys { |k| k.to_s.to_sym }
+          [adapter, symbolized_options]
         else
           raise SwarmSDK::ConfigurationError, "Invalid memory configuration for #{agent_name}"
         end
@@ -124,7 +127,17 @@ module SwarmMemory
           raise SwarmSDK::ConfigurationError, "#{e.message} for agent #{agent_name}"
         end
 
-        # Instantiate adapter with options
+        # Extract hybrid search weights and other SDK-level config (before passing to adapter)
+        # Keys are already symbolized at this point
+        semantic_weight = adapter_options.delete(:semantic_weight)
+        keyword_weight = adapter_options.delete(:keyword_weight)
+
+        # Remove other SDK-level threshold configs that shouldn't go to adapter
+        adapter_options.delete(:discovery_threshold)
+        adapter_options.delete(:discovery_threshold_short)
+        adapter_options.delete(:adaptive_word_cutoff)
+
+        # Instantiate adapter with options (weights removed, adapter doesn't need them)
         # Note: Adapter is responsible for validating its own requirements
         begin
           adapter = adapter_class.new(**adapter_options)
@@ -136,8 +149,13 @@ module SwarmMemory
         # Create embedder for semantic search
         embedder = Embeddings::InformersEmbedder.new
 
-        # Create storage with embedder (enables semantic features)
-        Core::Storage.new(adapter: adapter, embedder: embedder)
+        # Create storage with embedder and hybrid search weights
+        Core::Storage.new(
+          adapter: adapter,
+          embedder: embedder,
+          semantic_weight: semantic_weight,
+          keyword_weight: keyword_weight,
+        )
       end
 
       # Parse memory configuration
@@ -199,24 +217,36 @@ module SwarmMemory
         end
       end
 
-      # Check if storage should be created for this agent
+      # Check if memory is configured for this agent
+      #
+      # Delegates adapter-specific validation to the adapter itself.
+      # Filesystem adapter requires 'directory', custom adapters may use other keys.
       #
       # @param agent_definition [Agent::Definition] Agent definition
-      # @return [Boolean] True if agent has memory configuration
-      def storage_enabled?(agent_definition)
+      # @return [Boolean] True if agent has valid memory configuration
+      def memory_configured?(agent_definition)
         memory_config = agent_definition.plugin_config(:memory)
         return false if memory_config.nil?
 
-        # MemoryConfig object (from DSL)
+        # MemoryConfig object (from DSL) - delegates to its enabled? method
         return memory_config.enabled? if memory_config.respond_to?(:enabled?)
 
-        # Hash (from YAML) - check for directory key
-        if memory_config.is_a?(Hash)
+        # Hash (from YAML)
+        return false unless memory_config.is_a?(Hash)
+        return false if memory_config.empty?
+
+        adapter = (memory_config[:adapter] || memory_config["adapter"] || :filesystem).to_sym
+
+        case adapter
+        when :filesystem
+          # Filesystem adapter requires directory
           directory = memory_config[:directory] || memory_config["directory"]
-          return !directory.nil? && !directory.to_s.strip.empty?
+          !directory.nil? && !directory.to_s.strip.empty?
+        else
+          # Custom adapters: presence of config is sufficient
+          # Adapter will validate its own requirements during initialization
+          true
         end
-
-        false
       end
 
       # Contribute to agent serialization
@@ -293,9 +323,18 @@ module SwarmMemory
 
         builder.instance_eval do
           memory do
+            # Standard options
             directory(memory_config[:directory]) if memory_config[:directory]
             adapter(memory_config[:adapter]) if memory_config[:adapter]
             mode(memory_config[:mode]) if memory_config[:mode]
+
+            # Pass through all custom adapter options
+            # Handle both symbol and string keys (YAML may have either)
+            standard_keys = [:directory, :adapter, :mode, "directory", "adapter", "mode"]
+            custom_keys = memory_config.keys - standard_keys
+            custom_keys.each do |key|
+              option(key.to_sym, memory_config[key]) # Normalize to symbol
+            end
           end
         end
       end
@@ -336,6 +375,7 @@ module SwarmMemory
         # Store storage and mode using BASE NAME
         @storages[base_name] = storage # ← Changed from agent_name to base_name
         @modes[base_name] = mode # ← Changed from agent_name to base_name
+        @threshold_configs[base_name] = extract_threshold_config(memory_config)
 
         # Get mode-specific tools
         allowed_tools = tools_for_mode(mode)
@@ -384,20 +424,27 @@ module SwarmMemory
         # V7.0: Extract base name for storage lookup (delegation instances share storage)
         base_name = agent_name.to_s.split("@").first.to_sym
         storage = @storages[base_name] # ← Changed from agent_name to base_name
+        config = @threshold_configs[base_name] || {}
 
         return [] unless storage&.semantic_index
         return [] if prompt.nil? || prompt.empty?
 
         # Adaptive threshold based on query length
         # Short queries use lower threshold as they have less semantic richness
-        # Optimal: cutoff=10 words, short=0.25, normal=0.35 (discovered via systematic evaluation)
+        # Fallback chain: config → ENV → default
         word_count = prompt.split.size
-        word_cutoff = (ENV["SWARM_MEMORY_ADAPTIVE_WORD_CUTOFF"] || "10").to_i
+        word_cutoff = config[:adaptive_word_cutoff] ||
+          ENV["SWARM_MEMORY_ADAPTIVE_WORD_CUTOFF"]&.to_i ||
+          10
 
         threshold = if word_count < word_cutoff
-          (ENV["SWARM_MEMORY_DISCOVERY_THRESHOLD_SHORT"] || "0.25").to_f
+          config[:discovery_threshold_short] ||
+            ENV["SWARM_MEMORY_DISCOVERY_THRESHOLD_SHORT"]&.to_f ||
+            0.25
         else
-          (ENV["SWARM_MEMORY_DISCOVERY_THRESHOLD"] || "0.35").to_f
+          config[:discovery_threshold] ||
+            ENV["SWARM_MEMORY_DISCOVERY_THRESHOLD"]&.to_f ||
+            0.35
         end
         reminders = []
 
@@ -482,9 +529,15 @@ module SwarmMemory
           }
         end
 
-        # Get actual weights being used (from ENV or defaults)
-        semantic_weight = (ENV["SWARM_MEMORY_SEMANTIC_WEIGHT"] || "0.5").to_f
-        keyword_weight = (ENV["SWARM_MEMORY_KEYWORD_WEIGHT"] || "0.5").to_f
+        # Get actual weights being used (fallback chain: config → ENV → defaults)
+        base_name = agent_name.to_s.split("@").first.to_sym
+        config = @threshold_configs[base_name] || {}
+        semantic_weight = config[:semantic_weight] ||
+          ENV["SWARM_MEMORY_SEMANTIC_WEIGHT"]&.to_f ||
+          0.5
+        keyword_weight = config[:keyword_weight] ||
+          ENV["SWARM_MEMORY_KEYWORD_WEIGHT"]&.to_f ||
+          0.5
 
         SwarmSDK::LogStream.emit(
           type: "semantic_skill_search",
@@ -545,9 +598,15 @@ module SwarmMemory
           }
         end
 
-        # Get actual weights being used (from ENV or defaults)
-        semantic_weight = (ENV["SWARM_MEMORY_SEMANTIC_WEIGHT"] || "0.5").to_f
-        keyword_weight = (ENV["SWARM_MEMORY_KEYWORD_WEIGHT"] || "0.5").to_f
+        # Get actual weights being used (fallback chain: config → ENV → defaults)
+        base_name = agent_name.to_s.split("@").first.to_sym
+        config = @threshold_configs[base_name] || {}
+        semantic_weight = config[:semantic_weight] ||
+          ENV["SWARM_MEMORY_SEMANTIC_WEIGHT"]&.to_f ||
+          0.5
+        keyword_weight = config[:keyword_weight] ||
+          ENV["SWARM_MEMORY_KEYWORD_WEIGHT"]&.to_f ||
+          0.5
 
         SwarmSDK::LogStream.emit(
           type: "semantic_memory_search",
@@ -626,6 +685,40 @@ module SwarmMemory
 
         reminder
       end
+
+      # Extract threshold configuration from memory config
+      #
+      # Supports both MemoryConfig objects (from DSL) and Hash configs (from YAML).
+      # Extracts semantic search thresholds and hybrid search weights.
+      #
+      # @param memory_config [MemoryConfig, Hash, nil] Memory configuration
+      # @return [Hash] Threshold config with symbol keys
+      def extract_threshold_config(memory_config)
+        return {} unless memory_config
+
+        threshold_keys = [
+          :discovery_threshold,
+          :discovery_threshold_short,
+          :adaptive_word_cutoff,
+          :semantic_weight,
+          :keyword_weight,
+        ]
+
+        if memory_config.respond_to?(:adapter_options)
+          # MemoryConfig object (from DSL)
+          memory_config.adapter_options.slice(*threshold_keys)
+        elsif memory_config.is_a?(Hash)
+          # Hash (from YAML) - handle both symbol and string keys
+          result = {}
+          threshold_keys.each do |key|
+            value = memory_config[key] || memory_config[key.to_s]
+            result[key] = value if value
+          end
+          result
+        else
+          {}
+        end
+      end
     end
   end
 end

data/lib/swarm_memory/optimization/defragmenter.rb

@@ -191,7 +191,7 @@ module SwarmMemory
             "  Semantic similarity: N/A (no embeddings)"
           end
           report << ""
-          report << "  **Suggestion:** Review both entries and consider merging with MemoryMultiEdit"
+          report << "  **Suggestion:** Review both entries and consider merging with MemoryEdit"
           report << ""
         end
 

data/lib/swarm_memory/prompts/memory_researcher.md.erb

@@ -28,7 +28,6 @@ You have persistent memory that learns from conversations and helps you answer q
 - `MemoryGlob` - Browse memory by path pattern
 - `MemoryWrite` - Create new memory
 - `MemoryEdit` - Update existing memory
-- `MemoryMultiEdit` - Update multiple memories at once
 - `MemoryDelete` - Delete a memory
 - `MemoryDefrag` - Optimize memory storage
 - `LoadSkill` - Load a skill and swap tools

data/lib/swarm_memory/tools/load_skill.rb

@@ -148,7 +148,6 @@ module SwarmMemory
           "MemoryWrite",
           "MemoryRead",
           "MemoryEdit",
-          "MemoryMultiEdit",
           "MemoryDelete",
           "MemoryGlob",
           "MemoryGrep",

data/lib/swarm_memory/tools/memory_edit.rb

@@ -162,11 +162,12 @@ module SwarmMemory
         # Get existing entry metadata
         entry = @storage.read_entry(file_path: file_path)
 
-        # Write updated content back (preserving the title)
+        # Write updated content back (preserving the title and metadata)
         @storage.write(
           file_path: file_path,
           content: new_content,
           title: entry.title,
+          metadata: entry.metadata,
         )
 
         # Build success message

data/lib/swarm_memory/tools/memory_read.rb

@@ -35,7 +35,7 @@ module SwarmMemory
         - MemoryRead(file_path: "skill/debugging/api-errors.md") - Read a skill before loading it
 
         **Important:**
-        - Always read entries before editing them with MemoryEdit or MemoryMultiEdit
+        - Always read entries before editing them with MemoryEdit
         - Line numbers in output are for reference only - don't include them when editing
         - Each read is tracked to enforce read-before-edit patterns
       DESC

data/lib/swarm_memory/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SwarmMemory
-  VERSION = "2.1.4"
+  VERSION = "2.2.3"
 end

data/lib/swarm_memory.rb

@@ -21,8 +21,8 @@ rescue LoadError
   warn("Warning: informers gem not found. Semantic search will be unavailable. Run: gem install informers")
 end
 
-# Load errors and version first
-require_relative "swarm_memory/errors"
+# Load error classes and version first (before Zeitwerk)
+require_relative "swarm_memory/error"
 require_relative "swarm_memory/version"
 
 # Setup Zeitwerk loader
@@ -36,6 +36,11 @@ loader.inflector.inflect(
   "dsl" => "DSL",
   "sdk_plugin" => "SDKPlugin",
 )
+
+# Ignore files that are manually loaded above
+loader.ignore("#{__dir__}/swarm_memory/error.rb")
+loader.ignore("#{__dir__}/swarm_memory/version.rb")
+
 loader.setup
 
 # Explicitly load DSL components and extensions to inject into SwarmSDK
@@ -118,8 +123,6 @@ module SwarmMemory
         Tools::MemoryRead.new(storage: storage, agent_name: agent_name)
       when :MemoryEdit
         Tools::MemoryEdit.new(storage: storage, agent_name: agent_name)
-      when :MemoryMultiEdit
-        Tools::MemoryMultiEdit.new(storage: storage, agent_name: agent_name)
       when :MemoryDelete
         Tools::MemoryDelete.new(storage: storage)
       when :MemoryGlob
@@ -153,7 +156,6 @@ module SwarmMemory
         Tools::MemoryWrite.new(storage: storage, agent_name: agent_name),
         Tools::MemoryRead.new(storage: storage, agent_name: agent_name),
         Tools::MemoryEdit.new(storage: storage, agent_name: agent_name),
-        Tools::MemoryMultiEdit.new(storage: storage, agent_name: agent_name),
         Tools::MemoryDelete.new(storage: storage),
         Tools::MemoryGlob.new(storage: storage),
         Tools::MemoryGrep.new(storage: storage),

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

@@ -55,10 +55,14 @@ module SwarmSDK
         #
         # Registers RubyLLM callbacks to collect data and emit log events.
         # Should only be called when LogStream.emitter is set.
+        # This method is idempotent - calling it multiple times has no effect.
         #
         # @return [void]
         def setup_logging
+          return if @logging_setup
+
           register_logging_callbacks
+          @logging_setup = true
         end
 
         # Extract agent name from delegation tool name

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,29 +123,63 @@ 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
         #
+        # Uses SwarmSDK::Models for model lookup (reads from models.json).
+        # Falls back to RubyLLM.models if not found in SwarmSDK.
+        #
         # @param model_id [String] Model ID to lookup
         def fetch_real_model_info(model_id)
           @model_lookup_error = nil
           @real_model_info = begin
-            RubyLLM.models.find(model_id)
+            # Try SwarmSDK::Models first (reads from local models.json)
+            # Returns ModelInfo object with method access (context_window, etc.)
+            SwarmSDK::Models.find(model_id) || RubyLLM.models.find(model_id)
           rescue StandardError => e
             suggestions = suggest_similar_models(model_id)
             @model_lookup_error = {

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

@@ -74,8 +74,8 @@ module SwarmSDK
           model_info = SwarmSDK::Models.find(message.model_id)
           return zero_cost unless model_info
 
-          # Extract pricing from SwarmSDK's models.json structure
-          pricing = model_info["pricing"] || model_info[:pricing]
+          # Extract pricing from SwarmSDK's ModelInfo (method access for top-level, Hash for nested)
+          pricing = model_info.pricing
           return zero_cost unless pricing
 
           text_pricing = pricing["text_tokens"] || pricing[:text_tokens]

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/chat_helpers/token_tracking.rb

@@ -84,6 +84,35 @@ module SwarmSDK
           limit - cumulative_total_tokens
         end
 
+        # Calculate cumulative input cost based on tokens and model pricing
+        #
+        # @return [Float] Total input cost in dollars
+        def cumulative_input_cost
+          pricing = model_pricing
+          return 0.0 unless pricing
+
+          input_price = pricing["input_per_million"] || pricing[:input_per_million] || 0.0
+          (cumulative_input_tokens / 1_000_000.0) * input_price
+        end
+
+        # Calculate cumulative output cost based on tokens and model pricing
+        #
+        # @return [Float] Total output cost in dollars
+        def cumulative_output_cost
+          pricing = model_pricing
+          return 0.0 unless pricing
+
+          output_price = pricing["output_per_million"] || pricing[:output_per_million] || 0.0
+          (cumulative_output_tokens / 1_000_000.0) * output_price
+        end
+
+        # Calculate cumulative total cost (input + output)
+        #
+        # @return [Float] Total cost in dollars
+        def cumulative_total_cost
+          cumulative_input_cost + cumulative_output_cost
+        end
+
         # Compact the conversation history to reduce token usage
         #
         # @param options [Hash] Compression options
@@ -92,6 +121,25 @@ module SwarmSDK
           compactor = ContextCompactor.new(self, options)
           compactor.compact
         end
+
+        private
+
+        # Get pricing info for the current model
+        #
+        # Extracts standard text token pricing from model info.
+        #
+        # @return [Hash, nil] Pricing hash with input_per_million and output_per_million
+        def model_pricing
+          return unless @real_model_info&.pricing
+
+          pricing = @real_model_info.pricing
+          text_pricing = pricing["text_tokens"] || pricing[:text_tokens]
+          return unless text_pricing
+
+          text_pricing["standard"] || text_pricing[:standard]
+        rescue StandardError
+          nil
+        end
       end
     end
   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/agent/system_prompt_builder.rb

@@ -148,7 +148,7 @@ module SwarmSDK
         contributions = []
 
         PluginRegistry.all.each do |plugin|
-          next unless plugin.storage_enabled?(@definition)
+          next unless plugin.memory_configured?(@definition)
 
           contribution = plugin.system_prompt_contribution(agent_definition: @definition, storage: nil)
           contributions << contribution if contribution && !contribution.strip.empty?