swarm_sdk 2.7.7 → 2.7.9

data/lib/swarm_sdk/swarm/agent_initializer.rb

@@ -117,38 +117,92 @@ module SwarmSDK
       #
       # Agents that are ONLY delegates with shared_across_delegations: false
       # are NOT created here - they'll be created as delegation instances in pass 2a.
+      #
+      # Agent creation is parallelized using Async::Barrier for faster initialization.
       def pass_1_create_agents
         # Create plugin storages for agents
         create_plugin_storages
 
         tool_configurator = ToolConfigurator.new(@swarm, @swarm.scratchpad_storage, @swarm.plugin_storages)
 
-        @swarm.agent_definitions.each do |name, agent_definition|
-          # Skip if this agent will only exist as delegation instances
-          next if should_skip_primary_creation?(name, agent_definition)
+        # Filter agents that need primary creation
+        agents_to_create = @swarm.agent_definitions.reject do |name, agent_definition|
+          should_skip_primary_creation?(name, agent_definition)
+        end
+
+        # Create agents in parallel using Async::Barrier
+        results = create_agents_in_parallel(agents_to_create, tool_configurator)
 
-          chat = create_agent_chat(name, agent_definition, tool_configurator)
+        # Store results and notify plugins (sequential for safety)
+        results.each do |name, chat, agent_definition|
           @agents[name] = chat
-
-          # Notify plugins that agent was initialized
           notify_plugins_agent_initialized(name, chat, agent_definition, tool_configurator)
         end
       end
 
-      # Pass 2: Create delegation instances and wire delegation tools
+      # Create multiple agents in parallel using Async fibers
       #
-      # This pass has three sub-steps that must happen in order:
-      # 2a. Create delegation instances (ONLY for agents with shared_across_delegations: false)
-      # 2b. Wire primary agents to delegation instances OR shared primaries
-      # 2c. Wire delegation instances to their delegates (nested delegation support)
-      def pass_2_register_delegation_tools
-        tool_configurator = ToolConfigurator.new(@swarm, @swarm.scratchpad_storage, @swarm.plugin_storages)
+      # @param agents_to_create [Hash] Hash of { name => agent_definition }
+      # @param tool_configurator [ToolConfigurator] Shared tool configurator
+      # @return [Array<Array>] Array of [name, chat, agent_definition] tuples
+      def create_agents_in_parallel(agents_to_create, tool_configurator)
+        return [] if agents_to_create.empty?
+
+        results = []
+        errors = []
+        mutex = Mutex.new
+
+        Sync do
+          barrier = Async::Barrier.new
+
+          agents_to_create.each do |name, agent_definition|
+            barrier.async do
+              chat = create_agent_chat(name, agent_definition, tool_configurator)
+              mutex.synchronize { results << [name, chat, agent_definition] }
+            rescue StandardError => e
+              # Catch errors to avoid Async warning logs (which fail in tests with StringIO)
+              mutex.synchronize { errors << [name, e] }
+            end
+          end
+
+          barrier.wait
+        end
+
+        # Re-raise first error if any occurred
+        unless errors.empty?
+          # Emit events for all errors (not just the first)
+          errors.each do |agent_name, err|
+            LogStream.emit(
+              type: "agent_initialization_error",
+              agent: agent_name,
+              error_class: err.class.name,
+              error_message: err.message,
+              timestamp: Time.now.utc.iso8601,
+            )
+          end
+
+          # Re-raise first error with context
+          name, error = errors.first
+          raise error.class, "Agent '#{name}' initialization failed: #{error.message}", error.backtrace
+        end
+
+        results
+      end
+
+      # Collect all delegation instances that need to be created
+      #
+      # Validates delegation configs and returns a list of instances to create.
+      # This is done sequentially to fail fast on configuration errors.
+      #
+      # @return [Array<Hash>] Array of { instance_name:, base_name:, definition: }
+      def collect_delegation_instances_to_create
+        instances = []
 
-        # Sub-pass 2a: Create delegation instances for isolated agents
         @swarm.agent_definitions.each do |delegator_name, delegator_def|
           delegator_def.delegation_configs.each do |delegation_config|
             delegate_base_name = delegation_config[:agent]
 
+            # Validate delegate exists
             unless @swarm.agent_definitions.key?(delegate_base_name)
               raise ConfigurationError,
                 "Agent '#{delegator_name}' delegates to unknown agent '#{delegate_base_name}'"
@@ -156,24 +210,95 @@ module SwarmSDK
 
             delegate_definition = @swarm.agent_definitions[delegate_base_name]
 
-            # Check isolation mode of the DELEGATE agent
-            # If delegate wants to be shared, skip instance creation (use primary)
+            # Skip if delegate wants to be shared (use primary instead)
             next if delegate_definition.shared_across_delegations
 
-            # Create unique delegation instance (isolated mode)
             instance_name = "#{delegate_base_name}@#{delegator_name}"
 
-            # V7.0: Use existing register_all_tools (no new method needed!)
-            delegation_chat = create_agent_chat_for_delegation(
+            instances << {
               instance_name: instance_name,
               base_name: delegate_base_name,
-              agent_definition: delegate_definition,
-              tool_configurator: tool_configurator,
-            )
+              definition: delegate_definition,
+            }
+          end
+        end
+
+        instances
+      end
+
+      # Create multiple delegation instances in parallel using Async fibers
+      #
+      # @param instances_to_create [Array<Hash>] Array of instance configs
+      # @param tool_configurator [ToolConfigurator] Shared tool configurator
+      # @return [Array<Array>] Array of [instance_name, chat] tuples
+      def create_delegation_instances_in_parallel(instances_to_create, tool_configurator)
+        return [] if instances_to_create.empty?
+
+        results = []
+        errors = []
+        mutex = Mutex.new
+
+        Sync do
+          barrier = Async::Barrier.new
+
+          instances_to_create.each do |config|
+            barrier.async do
+              delegation_chat = create_agent_chat_for_delegation(
+                instance_name: config[:instance_name],
+                base_name: config[:base_name],
+                agent_definition: config[:definition],
+                tool_configurator: tool_configurator,
+              )
+              mutex.synchronize { results << [config[:instance_name], delegation_chat] }
+            rescue StandardError => e
+              # Catch errors to avoid Async warning logs (which fail in tests with StringIO)
+              mutex.synchronize { errors << [config[:instance_name], e] }
+            end
+          end
+
+          barrier.wait
+        end
 
-            # Store in delegation_instances hash
-            @swarm.delegation_instances[instance_name] = delegation_chat
+        # Re-raise first error if any occurred
+        unless errors.empty?
+          # Emit events for all errors (not just the first)
+          errors.each do |inst_name, err|
+            LogStream.emit(
+              type: "delegation_instance_initialization_error",
+              instance_name: inst_name,
+              error_class: err.class.name,
+              error_message: err.message,
+              timestamp: Time.now.utc.iso8601,
+            )
           end
+
+          # Re-raise first error with context
+          instance_name, error = errors.first
+          raise error.class, "Delegation instance '#{instance_name}' initialization failed: #{error.message}", error.backtrace
+        end
+
+        results
+      end
+
+      # Pass 2: Create delegation instances and wire delegation tools
+      #
+      # This pass has three sub-steps that must happen in order:
+      # 2a. Create delegation instances (ONLY for agents with shared_across_delegations: false)
+      # 2b. Wire primary agents to delegation instances OR shared primaries
+      # 2c. Wire delegation instances to their delegates (nested delegation support)
+      #
+      # Sub-pass 2a is parallelized using Async::Barrier for faster initialization.
+      def pass_2_register_delegation_tools
+        tool_configurator = ToolConfigurator.new(@swarm, @swarm.scratchpad_storage, @swarm.plugin_storages)
+
+        # Sub-pass 2a: Create delegation instances for isolated agents (parallelized)
+        delegation_instances_to_create = collect_delegation_instances_to_create
+
+        results = create_delegation_instances_in_parallel(delegation_instances_to_create, tool_configurator)
+
+        # Store results after all parallel creation completes
+        results.each do |instance_name, delegation_chat|
+          @swarm.delegation_instances[instance_name] = delegation_chat
         end
 
         # Sub-pass 2b: Wire primary agents to delegation instances OR shared primaries OR registered swarms

data/lib/swarm_sdk/swarm/mcp_configurator.rb

@@ -130,7 +130,8 @@ module SwarmSDK
       # @return [RubyLLM::MCP::Client] Initialized MCP client
       def initialize_mcp_client(config)
         # Convert timeout from seconds to milliseconds
-        timeout_seconds = config[:timeout] || 30
+        # Use explicit config[:timeout] if provided, otherwise use global default
+        timeout_seconds = config[:timeout] || SwarmSDK.config.mcp_request_timeout
         timeout_ms = timeout_seconds * 1000
 
         # Determine transport type
@@ -179,11 +180,16 @@ module SwarmSDK
       # @param config [Hash] MCP server configuration
       # @return [Hash] SSE configuration
       def build_sse_config(config)
-        {
+        sse_config = {
           url: config[:url],
           headers: config[:headers] || {},
           version: config[:version]&.to_sym || :http2,
         }
+
+        # Add reconnection options for resilient SSE connections
+        sse_config[:reconnection] = build_reconnection_options(config)
+
+        sse_config
       end
 
       # Build streamable (HTTP) transport configuration
@@ -200,9 +206,30 @@ module SwarmSDK
         # Only include rate_limit if present
         streamable_config[:rate_limit] = config[:rate_limit] if config[:rate_limit]
 
+        # Add reconnection options for resilient streamable connections
+        streamable_config[:reconnection] = build_reconnection_options(config)
+
         streamable_config
       end
 
+      # Build reconnection options from config or defaults
+      #
+      # Provides exponential backoff reconnection for SSE/streamable transports.
+      # Can be customized per-server or uses global defaults.
+      #
+      # @param config [Hash] MCP server configuration
+      # @return [Hash] Reconnection options
+      def build_reconnection_options(config)
+        reconnection_config = config[:reconnection] || {}
+
+        {
+          max_retries: reconnection_config[:max_retries] || Defaults::McpReconnection::MAX_RETRIES,
+          initial_reconnection_delay: reconnection_config[:initial_delay] || Defaults::McpReconnection::INITIAL_DELAY_MS,
+          reconnection_delay_grow_factor: reconnection_config[:delay_grow_factor] || Defaults::McpReconnection::DELAY_GROW_FACTOR,
+          max_reconnection_delay: reconnection_config[:max_delay] || Defaults::McpReconnection::MAX_DELAY_MS,
+        }
+      end
+
       # Emit MCP server initialization start event
       #
       # @param agent_name [Symbol] Agent name

data/lib/swarm_sdk/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: swarm_sdk
 version: !ruby/object:Gem::Version
-  version: 2.7.7
+  version: 2.7.9
 platform: ruby
 authors:
 - Paulo Arruda