swarm_sdk 2.7.13 → 3.0.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 427d736e32c386d76df7481b50b95e272045b88eb93290353528fd48c2525d91
-  data.tar.gz: fc3cf69eaa253871f0db9f6332dd62669af2941082f622e266f65e035f6b2b21
+  metadata.gz: 373c4df61931acf2a3ed260a6686068dc918f9d3ad6f3eea746f81a38711e2b5
+  data.tar.gz: 2b5414dd35362e4e58616092717b47b2207dcf54a886c10e74f5408f07686192
 SHA512:
-  metadata.gz: d08958fe437094ce91bdae63e6e20290158417270d1d39446fbb9cc45b2ea02bfbbae99dccfb36097fb053a2190f4cee1fd101c876eda1a388c19ba3ba4cdf4c
-  data.tar.gz: cf06e09fe354ca95035d27e5ee4d710be461757829c1448c5d178b9f8a9b9372419e27bc036101d9ad0add625459784fa766413695f3f030efcba8fa97ee8467
+  metadata.gz: 46a0bba9e559d4acc92dbb5bf68776471bf2409a2aa0cee9b3ed458e0d9028b24b69534b6963a9a1b57de23ff305c9d69c7a927828f80de4de7750561311bb4f
+  data.tar.gz: add457e2f8a04cca43f0fd9f169207695cad562a7f7c0b98a217a002560d335e693cca5ef0a39ad0438a7d0ff818246f97d43a0155d103f9d3944e73cb9e3027

data/lib/swarm_sdk/ruby_llm_patches/chat_callbacks_patch.rb

@@ -63,6 +63,7 @@ module RubyLLM
         # Initialize around hooks
         @around_tool_execution_hook = nil
         @around_llm_request_hook = nil
+        @after_tool_calls_hook = nil
 
         # Keep @on for backward compatibility (read-only)
         @on = nil
@@ -130,6 +131,19 @@ module RubyLLM
         self
       end
 
+      # Sets a hook that fires once per tool-call round, after all tool
+      # results are committed to chat history and before the next LLM call
+      #
+      # Skipped when a tool returns {Tool::Halt} — pending work stays
+      # queued for the next {#ask} call.
+      #
+      # @yield Block called after tool results are added to history
+      # @return [self] for chaining
+      def after_tool_calls(&block)
+        @after_tool_calls_hook = block
+        self
+      end
+
       # Clears all callbacks for the specified event, or all events if none specified
       def clear_callbacks(event = nil)
         @callback_monitor.synchronize do
@@ -153,30 +167,36 @@ module RubyLLM
         end
       end
 
-      # Override complete to use emit() and support around_llm_request hook
-      # Follows fork pattern: tool call handling wraps message addition
+      # Override complete to use emit() and support around_llm_request hook.
+      # Uses a trampoline loop instead of mutual recursion with handle_tool_calls
+      # to avoid stack growth during multi-round tool-call conversations.
       def complete(&block)
-        # Execute LLM request (potentially wrapped by around_llm_request hook)
-        response = execute_llm_request(&block)
+        loop do
+          response = execute_llm_request(&block)
 
-        emit(:new_message) unless block_given?
+          emit(:new_message) unless block_given?
 
-        if @schema && response.content.is_a?(String)
-          begin
-            response.content = JSON.parse(response.content)
-          rescue JSON::ParserError
-            # If parsing fails, keep content as string
+          if @schema && response.content.is_a?(String)
+            begin
+              response.content = JSON.parse(response.content)
+            rescue JSON::ParserError
+              # If parsing fails, keep content as string
+            end
           end
-        end
 
-        add_message(response)
-        emit(:end_message, response)
-        if response.tool_call?
-          # For tool calls: add message, emit end_message, then handle tools
-          handle_tool_calls(response, &block)
-        else
-          # For final responses: add message and emit end_message
-          response
+          add_message(response)
+          emit(:end_message, response)
+
+          if response.tool_call?
+            halt_result = handle_tool_calls(response, &block)
+            return halt_result if halt_result
+
+            @after_tool_calls_hook&.call
+
+            # Loop continues: next LLM call with zero stack growth
+          else
+            return response
+          end
         end
       end
 
@@ -238,8 +258,9 @@ module RubyLLM
         end
       end
 
-      # Override handle_tool_calls to use emit and support around_tool_execution hook
-      def handle_tool_calls(response, &block)
+      # Execute tool calls and return halt result (or nil to continue the loop).
+      # Does NOT recurse back into complete() — the trampoline loop handles that.
+      def handle_tool_calls(response, &_block)
         halt_result = nil
 
         response.tool_calls.each_value do |tool_call|
@@ -259,7 +280,7 @@ module RubyLLM
           halt_result = result if result.is_a?(Tool::Halt)
         end
 
-        halt_result || complete(&block)
+        halt_result
       end
 
       # Execute tool with around_tool_execution hook if set

data/lib/swarm_sdk/ruby_llm_patches/init.rb

@@ -39,3 +39,9 @@ require_relative "message_management_patch"
 
 # 7. Responses API patch (depends on configuration, uses error classes)
 require_relative "responses_api_patch"
+
+# 8. MCP SSL patch (configures SSL for HTTPX connections in ruby_llm-mcp)
+# Only load if RubyLLM::MCP is available
+if defined?(RubyLLM::MCP)
+  require_relative "mcp_ssl_patch"
+end

data/lib/swarm_sdk/ruby_llm_patches/mcp_ssl_patch.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+# Patches ruby_llm-mcp HTTPX connections to configure SSL verification
+#
+# OpenSSL 3.6 enforces CRL (Certificate Revocation List) checking by default.
+# Most certificates don't provide accessible CRL endpoints (industry moved to OCSP),
+# which breaks HTTPS MCP connections with:
+#   "certificate verify failed (unable to get certificate CRL)"
+#
+# This patch injects SSL options into all 5 HTTPX connection creation paths:
+#
+# Via HTTPClient.build_connection (paths 1-3):
+#   1. StreamableHTTP#create_connection
+#   2. StreamableHTTP#create_connection_with_streaming_callbacks
+#   3. SSE#send_request
+#
+# Direct HTTPX.plugin calls (paths 4-5):
+#   4. StreamableHTTP#create_connection_with_sse_callbacks
+#   5. SSE#create_sse_client
+#
+# Default: VERIFY_PEER (validates cert chain without CRL checking)
+# Configurable: VERIFY_NONE for local development via SwarmSDK.config.mcp_ssl_verify
+
+require "openssl"
+
+module SwarmSDK
+  # Module-level SSL configuration for MCP HTTPX connections
+  #
+  # Set ssl_options before creating MCP clients. The patched HTTPX methods
+  # read from this accessor to configure SSL on every connection.
+  #
+  # @example Default (validates cert chain, skips CRL)
+  #   McpSslPatch.ssl_options #=> { verify_mode: OpenSSL::SSL::VERIFY_PEER }
+  #
+  # @example Disable SSL verification (local dev only)
+  #   McpSslPatch.ssl_options = { verify_mode: OpenSSL::SSL::VERIFY_NONE }
+  module McpSslPatch
+    @ssl_options = { verify_mode: OpenSSL::SSL::VERIFY_PEER }
+
+    class << self
+      # @return [Hash] SSL options hash passed to HTTPX .with(ssl: ...)
+      attr_accessor :ssl_options
+
+      # Clear the thread-local HTTPX connection cache
+      #
+      # Must be called after changing ssl_options so that HTTPClient.build_connection
+      # runs again with the updated options.
+      #
+      # @return [void]
+      def reset_connection!
+        Thread.current[:ruby_llm_mcp_client_connection] = nil
+      end
+    end
+  end
+end
+
+# Patch 1: HTTPClient.build_connection
+#
+# Covers paths 1-3: StreamableHTTP#create_connection,
+# StreamableHTTP#create_connection_with_streaming_callbacks, SSE#send_request
+#
+# These all chain from HTTPClient.connection which calls build_connection.
+module RubyLLM
+  module MCP
+    module Transports
+      module Support
+        class HTTPClient
+          class << self
+            def build_connection
+              HTTPX.with(
+                pool_options: {
+                  max_connections: RubyLLM::MCP.config.max_connections,
+                  pool_timeout: RubyLLM::MCP.config.pool_timeout,
+                },
+                ssl: SwarmSDK::McpSslPatch.ssl_options,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# Patch 2: StreamableHTTP#create_connection_with_sse_callbacks
+#
+# This method calls HTTPX.plugin(:callbacks) directly, bypassing HTTPClient.
+# Merges SSL options with ALPN protocol when version is :http1.
+module SwarmSDK
+  module McpSslPatch
+    module StreamableHttpSslPatch
+      private
+
+      def create_connection_with_sse_callbacks(options, headers)
+        client = HTTPX.plugin(:callbacks)
+        client = add_on_response_body_chunk_callback(client, options)
+
+        ssl = SwarmSDK::McpSslPatch.ssl_options.dup
+        ssl[:alpn_protocols] = ["http/1.1"] if @version == :http1
+
+        client = client.with(
+          timeout: {
+            connect_timeout: 10,
+            read_timeout: @request_timeout / 1000,
+            write_timeout: @request_timeout / 1000,
+            operation_timeout: @request_timeout / 1000,
+          },
+          headers: headers,
+          ssl: ssl,
+        )
+
+        register_client(client)
+      end
+    end
+  end
+end
+
+# Patch 3: SSE#create_sse_client
+#
+# This method calls HTTPX.plugin(:stream) directly, bypassing HTTPClient.
+# Merges SSL options with ALPN protocol when version is :http1.
+module SwarmSDK
+  module McpSslPatch
+    module SseSslPatch
+      private
+
+      def create_sse_client
+        stream_headers = build_request_headers
+
+        ssl = SwarmSDK::McpSslPatch.ssl_options.dup
+        ssl[:alpn_protocols] = ["http/1.1"] if @version == :http1
+
+        HTTPX.plugin(:stream).with(
+          headers: stream_headers,
+          ssl: ssl,
+        )
+      end
+    end
+  end
+end
+
+# Apply prepend patches for direct HTTPX.plugin calls
+RubyLLM::MCP::Transports::StreamableHTTP.prepend(SwarmSDK::McpSslPatch::StreamableHttpSslPatch)
+RubyLLM::MCP::Transports::SSE.prepend(SwarmSDK::McpSslPatch::SseSslPatch)

data/lib/swarm_sdk/ruby_llm_patches/tool_concurrency_patch.rb

@@ -149,14 +149,13 @@ module RubyLLM
 
       private
 
-      # Override handle_tool_calls to support concurrent execution
-      # This method is called when tool_concurrency is set
+      # Override handle_tool_calls to support concurrent execution.
+      # Returns halt result or nil — the trampoline loop in complete() handles the next iteration.
       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)
+        execute_tools_concurrently(tool_calls)
       end
 
       def execute_tools_concurrently(tool_calls)