swarm_sdk 2.7.10 → 2.7.11

data/lib/swarm_sdk/ruby_llm_patches/tool_concurrency_patch.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+# Adds concurrent tool execution support to RubyLLM::Chat
+# Supports :async and :threads executors with configurable concurrency limits
+#
+# Fork Reference: Commit d0912c7, file lib/ruby_llm/tool_executors.rb
+
+module RubyLLM
+  # Tool executor registry
+  class << self
+    def tool_executors
+      @tool_executors ||= {}
+    end
+
+    def register_tool_executor(name, &block)
+      tool_executors[name] = block
+    end
+
+    def get_tool_executor(name)
+      tool_executors[name] || raise(ArgumentError, "Unknown tool executor: #{name}")
+    end
+  end
+
+  # Built-in tool executors
+  module ToolExecutors
+    class << self
+      def register_defaults
+        register_threads_executor
+        register_async_executor
+      end
+
+      private
+
+      def register_threads_executor
+        RubyLLM.register_tool_executor(:threads) do |tool_calls, max_concurrency:, &execute|
+          results = {}
+          mutex = Mutex.new
+          semaphore = max_concurrency ? Thread::SizedQueue.new(max_concurrency) : nil
+
+          # Fill semaphore with permits
+          max_concurrency&.times { semaphore << :permit }
+
+          threads = tool_calls.map do |tool_call|
+            Thread.new do
+              permit = semaphore&.pop
+
+              begin
+                result = execute.call(tool_call)
+                mutex.synchronize { results[tool_call.id] = result }
+              rescue StandardError => e
+                error_result = "Error: #{e.class}: #{e.message}"
+                mutex.synchronize { results[tool_call.id] = error_result }
+                RubyLLM.logger.warn("[RubyLLM] Tool #{tool_call.id} failed: #{e.message}")
+              ensure
+                semaphore&.push(permit) if permit
+              end
+            end
+          end
+
+          threads.each(&:join)
+          results
+        end
+      end
+
+      def register_async_executor
+        RubyLLM.register_tool_executor(:async) do |tool_calls, max_concurrency:, &execute|
+          AsyncExecutor.execute(tool_calls, max_concurrency: max_concurrency, &execute)
+        end
+      end
+    end
+
+    module AsyncExecutor
+      class << self
+        def execute(tool_calls, max_concurrency:, &block)
+          load_async_gem
+          run_with_sync { execute_tools(tool_calls, max_concurrency, &block) }
+        end
+
+        private
+
+        def load_async_gem
+          require "async"
+          require "async/barrier"
+          require "async/semaphore"
+        rescue LoadError => e
+          raise LoadError,
+            "The async gem is required for :async tool executor. " \
+              "Add `gem 'async'` to your Gemfile. Original error: #{e.message}"
+        end
+
+        def run_with_sync(&)
+          if defined?(Sync)
+            Sync(&)
+          else
+            Async(&).wait
+          end
+        end
+
+        def execute_tools(tool_calls, max_concurrency)
+          semaphore = max_concurrency ? Async::Semaphore.new(max_concurrency) : nil
+          barrier = Async::Barrier.new
+          results = {}
+
+          tool_calls.each do |tool_call|
+            barrier.async do
+              results[tool_call.id] = execute_single_tool(tool_call, semaphore) { yield tool_call }
+            rescue StandardError => e
+              results[tool_call.id] = "Error: #{e.class}: #{e.message}"
+              RubyLLM.logger.warn("[RubyLLM] Tool #{tool_call.id} failed: #{e.message}")
+            end
+          end
+
+          barrier.wait
+          results
+        end
+
+        def execute_single_tool(_tool_call, semaphore, &)
+          if semaphore
+            semaphore.acquire(&)
+          else
+            yield
+          end
+        end
+      end
+    end
+  end
+
+  class Chat
+    attr_reader :tool_concurrency, :max_concurrency
+
+    # Module to prepend for concurrent tool execution
+    module ConcurrentToolExecution
+      def initialize(tool_concurrency: nil, max_concurrency: nil, **kwargs)
+        @tool_concurrency = tool_concurrency
+        @max_concurrency = max_concurrency
+        super(**kwargs)
+      end
+
+      # Configure tool concurrency
+      def with_tool_concurrency(executor, max: nil)
+        @tool_concurrency = executor
+        @max_concurrency = max
+        self
+      end
+
+      private
+
+      # Override handle_tool_calls to support concurrent execution
+      # This method is called when tool_concurrency is set
+      def handle_tool_calls(response, &block)
+        return super unless @tool_concurrency
+
+        tool_calls = response.tool_calls
+        halt_result = execute_tools_concurrently(tool_calls)
+        halt_result || complete(&block)
+      end
+
+      def execute_tools_concurrently(tool_calls)
+        executor = RubyLLM.get_tool_executor(@tool_concurrency)
+        tool_calls_array = tool_calls.values
+
+        # Execute tools concurrently, emitting events per-tool
+        results = executor.call(tool_calls_array, max_concurrency: @max_concurrency) do |tool_call|
+          execute_single_tool_with_events(tool_call)
+        end
+
+        # Add all tool result messages atomically
+        add_tool_results_atomically(tool_calls, results)
+
+        # Find first halt result by original order
+        find_first_halt(tool_calls, results)
+      end
+
+      # Execute a single tool with events (for concurrent execution)
+      # Emits new_message, tool_call, and tool_result events per-tool
+      def execute_single_tool_with_events(tool_call)
+        emit(:new_message)
+        emit(:tool_call, tool_call)
+        result = execute_tool_with_hook(tool_call)
+        emit(:tool_result, tool_call, result)
+        result
+      end
+
+      # Add all tool result messages atomically to ensure consistent state
+      def add_tool_results_atomically(tool_calls, results)
+        messages = []
+
+        tool_calls.each_key do |id|
+          tool_call = tool_calls[id]
+          result = results[id]
+
+          tool_payload = result.is_a?(Tool::Halt) ? result.content : result
+          content = content_like?(tool_payload) ? tool_payload : tool_payload.to_s
+          message = add_message(role: :tool, content: content, tool_call_id: tool_call.id)
+          messages << message
+        end
+
+        # Fire end_message events for all messages
+        messages.each { |msg| emit(:end_message, msg) }
+      end
+
+      # Find the first halt result by request order
+      def find_first_halt(tool_calls, results)
+        tool_calls.each_key do |id|
+          result = results[id]
+          return result if result.is_a?(Tool::Halt)
+        end
+        nil
+      end
+    end
+
+    # Prepend after MultiSubscriberCallbacks so we can call its methods
+    prepend ConcurrentToolExecution
+  end
+end
+
+# Register built-in executors
+RubyLLM::ToolExecutors.register_defaults

data/lib/swarm_sdk/tools/delegate.rb

@@ -309,8 +309,8 @@ module SwarmSDK
           # Reset swarm if reset_context is true
           swarm_registry.reset(@delegate_target) if reset_context
 
-          # Execute sub-swarm's lead agent
-          lead_agent = subswarm.agents[subswarm.lead_agent]
+          # Execute sub-swarm's lead agent (uses agent() to trigger lazy initialization)
+          lead_agent = subswarm.agent(subswarm.lead_agent)
           response = lead_agent.ask(message, source: "delegation")
           result = response.content
 

data/lib/swarm_sdk/version.rb

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

data/lib/swarm_sdk.rb

@@ -18,14 +18,32 @@ require "async/semaphore"
 require "ruby_llm"
 require "ruby_llm/mcp"
 
-# Patch ruby_llm_swarm-mcp's Zeitwerk loader to ignore railtie.rb when Rails is not present
+# Load ruby_llm compatibility patches
+# These patches extend upstream ruby_llm to match fork functionality used by SwarmSDK
+require_relative "swarm_sdk/ruby_llm_patches/init"
+
+# Patch Zeitwerk loaders to ignore Rails-dependent files when Rails is not present
 # This prevents NameError when eager loading outside of Rails applications
 unless defined?(Rails)
   require "zeitwerk"
+
+  # Ignore ruby_llm's ActiveRecord integration (requires ActiveSupport)
+  ruby_llm_loader = nil
+  Zeitwerk::Registry.loaders.each { |l| ruby_llm_loader = l if l.tag == "ruby_llm" }
+  if ruby_llm_loader
+    ruby_llm_gem_dir = Gem.loaded_specs["ruby_llm"]&.gem_dir
+    if ruby_llm_gem_dir
+      active_record_dir = File.join(ruby_llm_gem_dir, "lib", "ruby_llm", "active_record")
+      ruby_llm_loader.ignore(active_record_dir)
+    end
+  end
+
+  # Ignore ruby_llm-mcp's railtie
   mcp_loader = nil
   Zeitwerk::Registry.loaders.each { |l| mcp_loader = l if l.tag == "RubyLLM-mcp" }
   if mcp_loader
-    mcp_gem_dir = Gem.loaded_specs["ruby_llm_swarm-mcp"]&.gem_dir
+    mcp_gem_dir = Gem.loaded_specs["ruby_llm-mcp"]&.gem_dir ||
+      Gem.loaded_specs["ruby_llm_swarm-mcp"]&.gem_dir
     if mcp_gem_dir
       railtie_path = File.join(mcp_gem_dir, "lib", "ruby_llm", "mcp", "railtie.rb")
       mcp_loader.ignore(railtie_path)
@@ -51,6 +69,8 @@ loader.inflector.inflect(
   "mcp" => "MCP",
   "openai_with_responses" => "OpenAIWithResponses",
 )
+# Ignore ruby_llm_patches - these are manually required monkey patches, not autoloaded modules
+loader.ignore("#{__dir__}/swarm_sdk/ruby_llm_patches")
 loader.setup
 
 module SwarmSDK

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: swarm_sdk
 version: !ruby/object:Gem::Version
-  version: 2.7.10
+  version: 2.7.11
 platform: ruby
 authors:
 - Paulo Arruda
@@ -52,33 +52,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.4'
 - !ruby/object:Gem::Dependency
-  name: openssl
+  name: ruby_llm
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.3.2
+        version: '1.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.3.2
-- !ruby/object:Gem::Dependency
-  name: ruby_llm_swarm
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.9.7
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.9.7
+        version: '1.11'
 - !ruby/object:Gem::Dependency
   name: ruby_llm_swarm-mcp
   requirement: !ruby/object:Gem::Requirement
@@ -190,6 +176,14 @@ files:
 - lib/swarm_sdk/prompts/base_system_prompt.md.erb
 - lib/swarm_sdk/restore_result.rb
 - lib/swarm_sdk/result.rb
+- lib/swarm_sdk/ruby_llm_patches/chat_callbacks_patch.rb
+- lib/swarm_sdk/ruby_llm_patches/configuration_patch.rb
+- lib/swarm_sdk/ruby_llm_patches/connection_patch.rb
+- lib/swarm_sdk/ruby_llm_patches/init.rb
+- lib/swarm_sdk/ruby_llm_patches/io_endpoint_patch.rb
+- lib/swarm_sdk/ruby_llm_patches/message_management_patch.rb
+- lib/swarm_sdk/ruby_llm_patches/responses_api_patch.rb
+- lib/swarm_sdk/ruby_llm_patches/tool_concurrency_patch.rb
 - lib/swarm_sdk/snapshot.rb
 - lib/swarm_sdk/snapshot_from_events.rb
 - lib/swarm_sdk/state_restorer.rb