swarm_sdk 2.7.13 → 2.7.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 427d736e32c386d76df7481b50b95e272045b88eb93290353528fd48c2525d91
-  data.tar.gz: fc3cf69eaa253871f0db9f6332dd62669af2941082f622e266f65e035f6b2b21
+  metadata.gz: 22ea4e05517149f4cb6f6f18e896e9493e9ed75f69e82bd6891a9b0b471e314e
+  data.tar.gz: 94f2f1b7c28fe626889aa4f1fbb611bb36ac4d73ab7de778f76e553538589cbb
 SHA512:
-  metadata.gz: d08958fe437094ce91bdae63e6e20290158417270d1d39446fbb9cc45b2ea02bfbbae99dccfb36097fb053a2190f4cee1fd101c876eda1a388c19ba3ba4cdf4c
-  data.tar.gz: cf06e09fe354ca95035d27e5ee4d710be461757829c1448c5d178b9f8a9b9372419e27bc036101d9ad0add625459784fa766413695f3f030efcba8fa97ee8467
+  metadata.gz: 2360f50b71a7c2342f2301a8dc5362b0e92402f16bdaee19dc7932b395a33f37e12a385fe752b69411e481ed10418396b7245a5d61669f7d41d12b6f7d0c3f40
+  data.tar.gz: 076b1ca993b017aeabfe5e35daa08be81e4cd815e314b2e28b594f298ae2b5b430101a0c9ea01d5263689b21ad888e4fb17d06c4a59904aa38734308a21ad130

data/lib/swarm_sdk/agent/builder.rb

@@ -63,6 +63,7 @@ module SwarmSDK
         @shared_across_delegations = nil # nil = not set (will default to false in Definition)
         @streaming = nil # nil = not set (will use global config default)
         @thinking = nil # nil = not set (extended thinking disabled)
+        @disable_environment_info = nil # nil = not set (will default to false in Definition)
         @context_management_config = nil # Context management DSL hooks
       end
 
@@ -529,6 +530,29 @@ module SwarmSDK
         !@coding_agent.nil?
       end
 
+      # Disable environment info (date, platform, OS, working directory) in system prompt
+      #
+      # When true, omits the environment information section from the agent's system prompt.
+      # Defaults to false if not set.
+      #
+      # @param enabled [Boolean] Whether to disable environment info
+      # @return [void]
+      #
+      # @example
+      #   disable_environment_info true  # Omit environment info from prompt
+      def disable_environment_info(enabled)
+        @disable_environment_info = enabled
+      end
+
+      # Check if disable_environment_info has been explicitly set
+      #
+      # Used by Swarm::Builder to determine if all_agents disable_environment_info should apply.
+      #
+      # @return [Boolean] true if disable_environment_info was explicitly set
+      def disable_environment_info_set?
+        !@disable_environment_info.nil?
+      end
+
       # Check if parameters have been set
       #
       # Used by Swarm::Builder for merging all_agents parameters.
@@ -586,6 +610,7 @@ module SwarmSDK
         agent_config[:shared_across_delegations] = @shared_across_delegations unless @shared_across_delegations.nil?
         agent_config[:streaming] = @streaming unless @streaming.nil?
         agent_config[:thinking] = @thinking if @thinking
+        agent_config[:disable_environment_info] = @disable_environment_info unless @disable_environment_info.nil?
 
         # Convert DSL hooks to HookDefinition format
         agent_config[:hooks] = convert_hooks_to_definitions if @hooks.any?

data/lib/swarm_sdk/agent/chat.rb

@@ -658,57 +658,63 @@ module SwarmSDK
 
       # Execute ask without timeout (original ask implementation)
       def execute_ask(prompt, options)
-        is_first = first_message?
+        @hook_swarm&.mark_agent_active(@agent_name, self)
 
-        # Collect system reminders to inject as ephemeral content
-        reminders = collect_system_reminders(prompt, is_first)
-
-        # Trigger user_prompt hook (with clean prompt, not reminders)
-        source = options.delete(:source) || "user"
-        final_prompt = prompt
-        if @hook_executor
-          hook_result = trigger_user_prompt(prompt, source: source)
+        begin
+          is_first = first_message?
+
+          # Collect system reminders to inject as ephemeral content
+          reminders = collect_system_reminders(prompt, is_first)
+
+          # Trigger user_prompt hook (with clean prompt, not reminders)
+          source = options.delete(:source) || "user"
+          final_prompt = prompt
+          if @hook_executor
+            hook_result = trigger_user_prompt(prompt, source: source)
+
+            if hook_result[:halted]
+              return RubyLLM::Message.new(
+                role: :assistant,
+                content: hook_result[:halt_message],
+                model_id: model_id,
+              )
+            end
 
-          if hook_result[:halted]
-            return RubyLLM::Message.new(
-              role: :assistant,
-              content: hook_result[:halt_message],
-              model_id: model_id,
-            )
+            final_prompt = hook_result[:modified_prompt] if hook_result[:modified_prompt]
           end
 
-          final_prompt = hook_result[:modified_prompt] if hook_result[:modified_prompt]
-        end
-
-        # Add CLEAN user message to history (no reminders embedded)
-        @llm_chat.add_message(role: :user, content: final_prompt)
+          # Add CLEAN user message to history (no reminders embedded)
+          @llm_chat.add_message(role: :user, content: final_prompt)
 
-        # Track reminders as ephemeral content for this LLM call only
-        # They'll be injected by around_llm_request hook but not stored
-        reminders.each do |reminder|
-          @context_manager.add_ephemeral_reminder(reminder, messages_array: @llm_chat.messages)
-        end
-
-        # Execute complete() which handles tool loop and ephemeral injection
-        response = execute_with_global_semaphore do
-          catch(:finish_agent) do
-            catch(:finish_swarm) do
-              if @streaming_enabled
-                # Reset chunk type tracking for new streaming request
-                @last_chunk_type = nil
+          # Track reminders as ephemeral content for this LLM call only
+          # They'll be injected by around_llm_request hook but not stored
+          reminders.each do |reminder|
+            @context_manager.add_ephemeral_reminder(reminder, messages_array: @llm_chat.messages)
+          end
 
-                @llm_chat.complete(**options) do |chunk|
-                  emit_content_chunk(chunk)
+          # Execute complete() which handles tool loop and ephemeral injection
+          response = execute_with_global_semaphore do
+            catch(:finish_agent) do
+              catch(:finish_swarm) do
+                if @streaming_enabled
+                  # Reset chunk type tracking for new streaming request
+                  @last_chunk_type = nil
+
+                  @llm_chat.complete(**options) do |chunk|
+                    emit_content_chunk(chunk)
+                  end
+                else
+                  @llm_chat.complete(**options)
                 end
-              else
-                @llm_chat.complete(**options)
               end
             end
           end
-        end
 
-        # Handle finish markers from hooks
-        handle_finish_marker(response)
+          # Handle finish markers from hooks
+          handle_finish_marker(response)
+        ensure
+          @hook_swarm&.mark_agent_inactive(@agent_name)
+        end
       end
 
       # --- Tool Execution Hook ---

data/lib/swarm_sdk/agent/definition.rb

@@ -43,7 +43,8 @@ module SwarmSDK
         :plugin_configs,
         :shared_across_delegations,
         :streaming,
-        :thinking
+        :thinking,
+        :disable_environment_info
 
       attr_accessor :bypass_permissions, :max_concurrent_tools
 
@@ -118,6 +119,9 @@ module SwarmSDK
         # Extended thinking configuration (nil = disabled)
         @thinking = config[:thinking]
 
+        # When true, omits date/platform/OS/working directory from system prompts
+        @disable_environment_info = config.fetch(:disable_environment_info, false)
+
         # Build system prompt after directory and memory are set
         @system_prompt = build_full_system_prompt(config[:system_prompt])
 
@@ -201,6 +205,7 @@ module SwarmSDK
           hooks: @hooks,
           shared_across_delegations: @shared_across_delegations,
           streaming: @streaming,
+          disable_environment_info: @disable_environment_info,
           # Permissions are core SDK functionality (not plugin-specific)
           default_permissions: @default_permissions,
           permissions: @agent_permissions,
@@ -301,6 +306,7 @@ module SwarmSDK
           disable_default_tools: @disable_default_tools,
           directory: @directory,
           definition: self,
+          disable_environment_info: @disable_environment_info,
         )
       end
 
@@ -394,6 +400,7 @@ module SwarmSDK
           :shared_across_delegations,
           :streaming,
           :directories,
+          :disable_environment_info,
         ]
 
         config.reject { |k, _| standard_keys.include?(k.to_sym) }

data/lib/swarm_sdk/agent/system_prompt_builder.rb

@@ -28,24 +28,29 @@ module SwarmSDK
         # @param disable_default_tools [Boolean, Array, nil] Default tools disable configuration
         # @param directory [String] Agent's working directory
         # @param definition [Definition] Full definition for plugin contributions
+        # @param disable_environment_info [Boolean] Whether to omit environment info from prompt
         # @return [String] Complete system prompt
-        def build(custom_prompt:, coding_agent:, disable_default_tools:, directory:, definition:)
+        def build(custom_prompt:, coding_agent:, disable_default_tools:, directory:, definition:,
+          disable_environment_info: false)
           new(
             custom_prompt: custom_prompt,
             coding_agent: coding_agent,
             disable_default_tools: disable_default_tools,
             directory: directory,
             definition: definition,
+            disable_environment_info: disable_environment_info,
           ).build
         end
       end
 
-      def initialize(custom_prompt:, coding_agent:, disable_default_tools:, directory:, definition:)
+      def initialize(custom_prompt:, coding_agent:, disable_default_tools:, directory:, definition:,
+        disable_environment_info: false)
         @custom_prompt = custom_prompt
         @coding_agent = coding_agent
         @disable_default_tools = disable_default_tools
         @directory = directory
         @definition = definition
+        @disable_environment_info = disable_environment_info
       end
 
       def build
@@ -80,7 +85,11 @@ module SwarmSDK
         non_coding_base = render_non_coding_base_prompt
 
         if @custom_prompt && !@custom_prompt.strip.empty?
-          "#{non_coding_base}\n\n#{@custom_prompt}"
+          if non_coding_base.empty?
+            @custom_prompt.to_s
+          else
+            "#{non_coding_base}\n\n#{@custom_prompt}"
+          end
         else
           non_coding_base
         end
@@ -91,6 +100,7 @@ module SwarmSDK
       end
 
       def render_base_system_prompt
+        disable_environment_info = @disable_environment_info
         cwd = @directory || Dir.pwd
         platform = RUBY_PLATFORM
         os_version = begin
@@ -105,6 +115,8 @@ module SwarmSDK
       end
 
       def render_non_coding_base_prompt
+        return "" if @disable_environment_info
+
         cwd = @directory || Dir.pwd
         platform = RUBY_PLATFORM
         os_version = begin

data/lib/swarm_sdk/builders/base_builder.rb

@@ -265,6 +265,7 @@ module SwarmSDK
         builder.parameters(config[:parameters]) if config[:parameters]
         builder.headers(config[:headers]) if config[:headers]
         builder.coding_agent(config[:coding_agent]) unless config[:coding_agent].nil?
+        builder.disable_environment_info(config[:disable_environment_info]) unless config[:disable_environment_info].nil?
         builder.bypass_permissions(config[:bypass_permissions]) if config[:bypass_permissions]
         builder.disable_default_tools(config[:disable_default_tools]) unless config[:disable_default_tools].nil?
 
@@ -451,6 +452,10 @@ module SwarmSDK
           agent_builder.streaming(all_agents_hash[:streaming])
         end
 
+        if !all_agents_hash[:disable_environment_info].nil? && !agent_builder.disable_environment_info_set?
+          agent_builder.disable_environment_info(all_agents_hash[:disable_environment_info])
+        end
+
         if all_agents_hash[:thinking] && !agent_builder.thinking_set?
           agent_builder.thinking(**all_agents_hash[:thinking])
         end

data/lib/swarm_sdk/concerns/cleanupable.rb

@@ -31,6 +31,9 @@ module SwarmSDK
 
         @mcp_clients.clear
 
+        # Shutdown sub-swarms if registry exists
+        @swarm_registry&.shutdown_all
+
         # Clear delegation instances
         delegation_instances_hash&.clear
       end

data/lib/swarm_sdk/config.rb

@@ -105,6 +105,7 @@ module SwarmSDK
       allow_filesystem_tools: ["SWARM_SDK_ALLOW_FILESYSTEM_TOOLS", true],
       env_interpolation: ["SWARM_SDK_ENV_INTERPOLATION", true],
       streaming: ["SWARM_SDK_STREAMING", true],
+      mcp_ssl_verify: ["SWARM_SDK_MCP_SSL_VERIFY", true],
     }.freeze
 
     class << self
@@ -345,7 +346,7 @@ module SwarmSDK
     # @return [Integer, Float, Boolean, String] The parsed value
     def parse_env_value(value, key)
       case key
-      when :allow_filesystem_tools, :env_interpolation, :streaming
+      when :allow_filesystem_tools, :env_interpolation, :streaming, :mcp_ssl_verify
         # Convert string to boolean
         case value.to_s.downcase
         when "true", "yes", "1", "on", "enabled"

data/lib/swarm_sdk/configuration/translator.rb

@@ -100,6 +100,7 @@ module SwarmSDK
           coding_agent(all_agents_cfg[:coding_agent]) unless all_agents_cfg[:coding_agent].nil?
           disable_default_tools(all_agents_cfg[:disable_default_tools]) unless all_agents_cfg[:disable_default_tools].nil?
           streaming(all_agents_cfg[:streaming]) unless all_agents_cfg[:streaming].nil?
+          disable_environment_info(all_agents_cfg[:disable_environment_info]) unless all_agents_cfg[:disable_environment_info].nil?
           thinking(**all_agents_cfg[:thinking]) if all_agents_cfg[:thinking]
 
           if all_agents_hks.any?
@@ -165,6 +166,7 @@ module SwarmSDK
           disable_default_tools(config[:disable_default_tools]) unless config[:disable_default_tools].nil?
           shared_across_delegations(config[:shared_across_delegations]) unless config[:shared_across_delegations].nil?
           streaming(config[:streaming]) unless config[:streaming].nil?
+          disable_environment_info(config[:disable_environment_info]) unless config[:disable_environment_info].nil?
           thinking(**config[:thinking]) if config[:thinking]
 
           if config[:tools]&.any?

data/lib/swarm_sdk/observer/manager.rb

@@ -75,6 +75,18 @@ module SwarmSDK
         end
       end
 
+      # Stop all observer tasks immediately
+      #
+      # Interrupts in-flight observer LLM calls by stopping the barrier.
+      # Called during swarm interruption instead of wait_for_completion.
+      #
+      # @return [void]
+      def stop
+        @barrier&.stop
+      rescue StandardError => e
+        RubyLLM.logger.debug("SwarmSDK: Error stopping observer barrier: #{e.message}")
+      end
+
       # Cleanup all subscriptions
       #
       # Unsubscribes from LogCollector to prevent memory leaks.

data/lib/swarm_sdk/prompts/base_system_prompt.md.erb

@@ -90,6 +90,7 @@ NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTAN
 You MUST answer concisely with fewer than 4 lines of text (not including tool use or code generation), unless user asks for detail.
 
 
+<% unless disable_environment_info %>
 # Today's date
 
 <today-date>
@@ -104,6 +105,7 @@ Working directory: <%= cwd %>
 Platform: <%= platform %>
 OS Version: <%= os_version %>
 </env>
+<% end %>
 
 IMPORTANT: Assist with defensive security tasks only. Refuse to create, modify, or improve code that may be used maliciously. Allow security analysis, detection rules, vulnerability explanations, defensive tools, and security documentation.
 

data/lib/swarm_sdk/result.rb

@@ -23,6 +23,35 @@ module SwarmSDK
       !success?
     end
 
+    # Check if execution was interrupted via swarm.stop
+    #
+    # @return [Boolean] true if execution was interrupted
+    #
+    # @example
+    #   result = swarm.execute("Build auth")
+    #   result.interrupted?  # => false
+    #
+    #   # After calling swarm.stop during execution:
+    #   result.interrupted?  # => true
+    def interrupted?
+      @metadata[:interrupted] == true
+    end
+
+    # Get the reason execution finished
+    #
+    # Possible values:
+    # - "finished" - Normal completion
+    # - "interrupted" - Stopped via swarm.stop
+    # - "error" - Execution failed with an error
+    #
+    # @return [String] The finish reason
+    #
+    # @example
+    #   result.finish_reason  # => "finished"
+    def finish_reason
+      @metadata[:finish_reason] || (success? ? "finished" : "error")
+    end
+
     # Calculate total cost from logs
     #
     # Delegates to total_cost for consistency. This attribute is calculated

data/lib/swarm_sdk/ruby_llm_patches/chat_callbacks_patch.rb

@@ -153,30 +153,34 @@ 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
+
+            # Loop continues: next LLM call with zero stack growth
+          else
+            return response
+          end
         end
       end
 
@@ -238,8 +242,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 +264,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,6 @@ 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)
+require_relative "mcp_ssl_patch"

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)

data/lib/swarm_sdk/swarm/all_agents_builder.rb

@@ -37,6 +37,7 @@ module SwarmSDK
         @disable_default_tools = nil
         @streaming = nil
         @thinking = nil
+        @disable_environment_info = nil
       end
 
       # Set model for all agents
@@ -100,6 +101,13 @@ module SwarmSDK
         @streaming = value
       end
 
+      # Disable environment info for all agents
+      #
+      # @param enabled [Boolean] Whether to disable environment info in system prompts
+      def disable_environment_info(enabled)
+        @disable_environment_info = enabled
+      end
+
       # Configure extended thinking for all agents
       #
       # @param effort [Symbol, String, nil] Reasoning effort (:low, :medium, :high) — OpenAI
@@ -186,6 +194,7 @@ module SwarmSDK
           disable_default_tools: @disable_default_tools,
           streaming: @streaming,
           thinking: @thinking,
+          disable_environment_info: @disable_environment_info,
           tools: @tools_list,
           permissions: @permissions_config,
         }.compact

data/lib/swarm_sdk/swarm/executor.rb

@@ -6,9 +6,19 @@ module SwarmSDK
     #
     # Extracted from Swarm#execute to reduce complexity and eliminate code duplication.
     # The core execution loop, error handling, and cleanup logic are unified here.
+    #
+    # ## Stop Mechanism
+    #
+    # Supports hard-stop via `swarm.stop` using IO.pipe for thread-safe signaling:
+    # 1. `swarm.stop` writes to pipe and sets `@stop_requested`
+    # 2. A listener task reads from the pipe (async-aware I/O)
+    # 3. Listener calls `barrier.stop` within the Async reactor
+    # 4. All child tasks receive `Async::Stop` exception
+    # 5. `execute_in_task` catches `Async::Stop`, sets interrupted flag, emits events
     class Executor
       def initialize(swarm)
         @swarm = swarm
+        @interrupted_result = nil
       end
 
       # Execute the swarm with a prompt
@@ -18,7 +28,7 @@ module SwarmSDK
       # @param logs [Array] Log collection array
       # @param has_logging [Boolean] Whether logging is enabled
       # @param original_fiber_storage [Hash] Original Fiber storage values to restore
-      # @return [Async::Task] The execution task
+      # @return [Result, Async::Task] Result if wait: true, Async::Task if wait: false
       def run(prompt, wait:, logs:, has_logging:, original_fiber_storage:)
         @original_fiber_storage = original_fiber_storage
         if wait
@@ -31,19 +41,39 @@ module SwarmSDK
       private
 
       # Blocking execution using Sync
+      #
+      # Wraps execution in an Async::Barrier so `swarm.stop` can cancel all tasks.
+      # A stop listener task watches the IO.pipe for stop signals.
       def run_blocking(prompt, logs:, has_logging:)
         result = nil
+        start_time = Time.now
+        @swarm.prepare_for_execution
+
         Sync do |task|
-          start_time = Time.now
+          barrier = Async::Barrier.new
+          @swarm.register_execution_barrier(barrier)
+          stop_listener = setup_stop_listener(task, barrier)
+
+          begin
+            result = barrier.async do
+              if @swarm.execution_timeout
+                execute_with_execution_timeout(task, prompt, logs, has_logging, start_time)
+              else
+                execute_in_task(prompt, logs: logs, has_logging: has_logging) do |lead, current_prompt|
+                  lead.ask(current_prompt)
+                end
+              end
+            end.wait
 
-          result = if @swarm.execution_timeout
-            execute_with_execution_timeout(task, prompt, logs, has_logging, start_time)
-          else
-            execute_in_task(prompt, logs: logs, has_logging: has_logging) do |lead, current_prompt|
-              # Execute directly - no child task needed
-              # This keeps execution in same fiber context for better control
-              lead.ask(current_prompt)
-            end
+            # barrier child .wait returns nil when stopped
+            result = @interrupted_result if result.nil? && @swarm.stop_requested?
+          rescue Async::Stop
+            # Non-blocking path (rare - user called task.stop on Sync root)
+            result = @interrupted_result
+          ensure
+            barrier.stop unless barrier.empty?
+            stop_listener&.stop
+            @swarm.clear_execution_barrier
           end
         ensure
           # Always wait for observer tasks, even if main execution raises
@@ -53,32 +83,77 @@ module SwarmSDK
 
         result
       ensure
-        # Restore original fiber storage (preserves parent context for nested swarms)
+        @interrupted_result = nil
+        @swarm.cleanup_stop_signal
         restore_fiber_storage
       end
 
       # Non-blocking execution using parent async task
+      #
+      # Same barrier + stop listener pattern as run_blocking.
       def run_async(prompt, logs:, has_logging:)
         parent = Async::Task.current
         raise ConfigurationError, "wait: false requires an async context. Use Sync { swarm.execute(..., wait: false) }" unless parent
 
+        @swarm.prepare_for_execution
+
         # NOTE: The block receives |task| as the spawned Async::Task when arity > 0
         parent.async(finished: false) do |task|
           start_time = Time.now
+          barrier = Async::Barrier.new
+          @swarm.register_execution_barrier(barrier)
+          stop_listener = setup_stop_listener(task, barrier)
+
+          begin
+            result = barrier.async do
+              if @swarm.execution_timeout
+                execute_with_execution_timeout(task, prompt, logs, has_logging, start_time)
+              else
+                execute_in_task(prompt, logs: logs, has_logging: has_logging) do |lead, current_prompt|
+                  lead.ask(current_prompt)
+                end
+              end
+            end.wait
 
-          if @swarm.execution_timeout
-            execute_with_execution_timeout(task, prompt, logs, has_logging, start_time)
-          else
-            execute_in_task(prompt, logs: logs, has_logging: has_logging) do |lead, current_prompt|
-              # Execute directly - no child task needed
-              lead.ask(current_prompt)
-            end
+            result = @interrupted_result if result.nil? && @swarm.stop_requested?
+            result
+          rescue Async::Stop
+            @interrupted_result
+          ensure
+            barrier.stop unless barrier.empty?
+            stop_listener&.stop
+            @swarm.clear_execution_barrier
+            @interrupted_result = nil
+            @swarm.cleanup_stop_signal
+            @swarm.wait_for_observers
           end
         end
       end
 
+      # Setup a listener task that watches for stop signals via IO.pipe
+      #
+      # The listener reads from the pipe (async-aware I/O that yields to scheduler).
+      # When data arrives (from `swarm.stop`), it stops the barrier to cancel all tasks.
+      #
+      # @param task [Async::Task] Parent task to spawn listener under
+      # @param barrier [Async::Barrier] Execution barrier to stop
+      # @return [Async::Task, nil] The listener task, or nil if no pipe
+      def setup_stop_listener(task, barrier)
+        return unless @swarm.stop_signal_read
+
+        task.async do
+          @swarm.stop_signal_read.read(1) # Async-aware I/O, yields to scheduler
+          barrier.stop unless barrier.empty?
+        rescue IOError, Async::Stop
+          # Pipe closed or listener stopped - normal cleanup
+        end
+      end
+
       # Core execution logic (unified, no duplication)
       #
+      # Handles InterruptedError and Async::Stop to properly track interruption state.
+      # The interrupted flag drives cleanup behavior (event emission, result building).
+      #
       # @param prompt [String] Initial prompt
       # @param logs [Array] Log collection
       # @param has_logging [Boolean] Whether logging is enabled
@@ -89,6 +164,7 @@ module SwarmSDK
         result = nil
         swarm_stop_triggered = false
         current_prompt = prompt
+        interrupted = false
 
         begin
           # Notify plugins that swarm is starting
@@ -100,6 +176,12 @@ module SwarmSDK
           # Re-raise configuration errors and timeouts - these should not be caught here
           # Timeouts are handled by execute_with_execution_timeout wrapper
           raise
+        rescue InterruptedError
+          interrupted = true
+          raise
+        rescue Async::Stop
+          interrupted = true
+          raise # Must re-raise for Async task cleanup
         rescue TypeError => e
           result = handle_type_error(e, logs, start_time)
         rescue StandardError => e
@@ -108,17 +190,30 @@ module SwarmSDK
           # Notify plugins that swarm is stopping (called even on error)
           PluginRegistry.emit_event(:on_swarm_stopped, swarm: @swarm)
 
-          cleanup_after_execution(result, start_time, logs, swarm_stop_triggered, has_logging)
+          result = cleanup_after_execution(
+            result,
+            start_time,
+            logs,
+            swarm_stop_triggered,
+            has_logging,
+            interrupted: interrupted,
+          )
+          @interrupted_result = result if interrupted
         end
 
         result
       end
 
       # Main execution loop with reprompting support
+      #
+      # Checks for stop requests at the top of each iteration to prevent
+      # unnecessary LLM calls after stop is requested.
       def execution_loop(initial_prompt, logs, start_time)
         current_prompt = initial_prompt
 
         loop do
+          raise InterruptedError, "Swarm execution was interrupted" if @swarm.stop_requested?
+
           lead = @swarm.agents[@swarm.lead_agent]
           response = yield(lead, current_prompt)
 
@@ -197,7 +292,31 @@ module SwarmSDK
       end
 
       # Cleanup after execution (ensure block logic)
-      def cleanup_after_execution(result, start_time, logs, swarm_stop_triggered, has_logging)
+      #
+      # When interrupted, emits agent_stop events for active agents, builds
+      # an interrupted result, and triggers swarm_stop hook with interrupted context.
+      #
+      # @param result [Result, nil] Current execution result
+      # @param start_time [Time] Execution start time
+      # @param logs [Array] Collected logs
+      # @param swarm_stop_triggered [Boolean] Whether swarm_stop hook already fired
+      # @param has_logging [Boolean] Whether logging is enabled
+      # @param interrupted [Boolean] Whether execution was interrupted
+      # @return [Result] Final result (may be replaced with interrupted result)
+      def cleanup_after_execution(result, start_time, logs, swarm_stop_triggered, has_logging, interrupted: false)
+        if interrupted && !swarm_stop_triggered
+          emit_interrupted_agent_events
+          result = build_interrupted_result(logs, start_time)
+
+          # Trigger swarm_stop hook with interrupted result (emits swarm_stop event)
+          begin
+            @swarm.trigger_swarm_stop(result)
+          rescue StandardError => e
+            LogStream.emit_error(e, source: "executor", context: "interrupted_swarm_stop")
+          end
+          swarm_stop_triggered = true
+        end
+
         # Trigger swarm_stop if not already triggered (handles error cases)
         unless swarm_stop_triggered
           @swarm.trigger_swarm_stop_final(result, start_time, logs)
@@ -214,6 +333,43 @@ module SwarmSDK
 
         # Reset logging state for next execution if we set it up
         reset_logging if has_logging
+
+        result
+      end
+
+      # Emit agent_stop events for all agents that were actively executing when interrupted
+      #
+      # @return [void]
+      def emit_interrupted_agent_events
+        @swarm.active_agent_chats.each do |name, _chat|
+          LogStream.emit(
+            type: "agent_stop",
+            agent: name,
+            swarm_id: @swarm.swarm_id,
+            parent_swarm_id: @swarm.parent_swarm_id,
+            finish_reason: "interrupted",
+            content: nil,
+            tool_calls: [],
+            usage: {},
+            metadata: { interrupted: true },
+          )
+        end
+      end
+
+      # Build an interrupted result
+      #
+      # @param logs [Array] Collected logs
+      # @param start_time [Time] Execution start time
+      # @return [Result] Result marked as interrupted
+      def build_interrupted_result(logs, start_time)
+        Result.new(
+          content: nil,
+          agent: @swarm.lead_agent&.to_s || "unknown",
+          error: InterruptedError.new("Swarm execution was interrupted"),
+          logs: logs,
+          duration: Time.now - start_time,
+          metadata: { interrupted: true, finish_reason: "interrupted" },
+        )
       end
 
       # Restore Fiber-local storage to original values (preserves parent context)

data/lib/swarm_sdk/swarm/hook_triggers.rb

@@ -63,6 +63,16 @@ module SwarmSDK
       # @param result [Result] Execution result
       # @return [Hooks::Context] Hook context for swarm_stop event
       def build_swarm_stop_context(result)
+        finish_reason = if @stop_requested
+          "interrupted"
+        elsif result&.error.is_a?(ExecutionTimeoutError)
+          "timeout"
+        elsif result&.success?
+          "finished"
+        else
+          "error"
+        end
+
         Hooks::Context.new(
           event: :swarm_stop,
           agent_name: @lead_agent.to_s,
@@ -79,6 +89,7 @@ module SwarmSDK
             agents_involved: result.agents_involved,
             per_agent_usage: result.per_agent_usage,
             result: result,
+            finish_reason: finish_reason,
             timestamp: Time.now.utc.iso8601,
           },
         )

data/lib/swarm_sdk/swarm/logging_callbacks.rb

@@ -204,6 +204,7 @@ module SwarmSDK
           last_agent: context.metadata[:last_agent],
           content: context.metadata[:content],
           success: context.metadata[:success],
+          finish_reason: context.metadata[:finish_reason] || "finished",
           duration: context.metadata[:duration],
           total_cost: context.metadata[:total_cost],
           total_tokens: context.metadata[:total_tokens],

data/lib/swarm_sdk/swarm/mcp_configurator.rb

@@ -129,6 +129,9 @@ module SwarmSDK
       # @param config [Hash] MCP server configuration
       # @return [RubyLLM::MCP::Client] Initialized MCP client
       def initialize_mcp_client(config)
+        # Configure SSL before creating the client so HTTPX connections use the right options
+        configure_mcp_ssl(config)
+
         # Convert timeout from seconds to milliseconds
         # Use explicit config[:timeout] if provided, otherwise use global default
         timeout_seconds = config[:timeout] || SwarmSDK.config.mcp_request_timeout
@@ -230,6 +233,23 @@ module SwarmSDK
         }
       end
 
+      # Configure SSL options for MCP HTTPX connections
+      #
+      # Sets McpSslPatch.ssl_options based on per-server ssl_verify config
+      # or global SwarmSDK.config.mcp_ssl_verify. Resets the thread-local
+      # connection cache so build_connection picks up the new options.
+      #
+      # @param config [Hash] MCP server configuration
+      # @option config [Boolean] :ssl_verify Override global SSL verify setting
+      # @return [void]
+      def configure_mcp_ssl(config)
+        ssl_verify = config.fetch(:ssl_verify, SwarmSDK.config.mcp_ssl_verify)
+        verify_mode = ssl_verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+
+        McpSslPatch.ssl_options = { verify_mode: verify_mode }
+        McpSslPatch.reset_connection!
+      end
+
       # Emit MCP server initialization start event
       #
       # @param agent_name [Symbol] Agent name

data/lib/swarm_sdk/swarm.rb

@@ -72,7 +72,7 @@ module SwarmSDK
     # Default tools available to all agents
     DEFAULT_TOOLS = ToolConfigurator::DEFAULT_TOOLS
 
-    attr_reader :name, :agents, :lead_agent, :mcp_clients, :delegation_instances, :agent_definitions, :swarm_id, :parent_swarm_id, :swarm_registry, :scratchpad_storage, :allow_filesystem_tools, :hook_registry, :global_semaphore, :plugin_storages, :config_for_hooks, :observer_configs, :execution_timeout
+    attr_reader :name, :agents, :lead_agent, :mcp_clients, :delegation_instances, :agent_definitions, :swarm_id, :parent_swarm_id, :swarm_registry, :scratchpad_storage, :allow_filesystem_tools, :hook_registry, :global_semaphore, :plugin_storages, :config_for_hooks, :observer_configs, :execution_timeout, :stop_signal_read
 
     # Check if scratchpad tools are enabled
     #
@@ -217,6 +217,13 @@ module SwarmSDK
       # Observer agent configurations
       @observer_configs = []
       @observer_manager = nil
+
+      # Stop mechanism state
+      @stop_requested = false
+      @execution_barrier = nil
+      @stop_signal_read = nil
+      @stop_signal_write = nil
+      @active_agent_chats = {}
     end
 
     # Add an agent to the swarm
@@ -471,12 +478,17 @@ module SwarmSDK
 
     # Wait for all observer tasks to complete
     #
+    # If a stop was requested, stops observer tasks immediately instead of waiting.
     # Called by Executor to wait for observer agents before cleanup.
     # Safe to call even if no observers are configured.
     #
     # @return [void]
     def wait_for_observers
-      @observer_manager&.wait_for_completion
+      if @stop_requested
+        stop_observers
+      else
+        @observer_manager&.wait_for_completion
+      end
     end
 
     # Cleanup observer subscriptions
@@ -490,6 +502,124 @@ module SwarmSDK
       @observer_manager = nil
     end
 
+    # Stop all swarm execution immediately
+    #
+    # Thread-safe method that signals the execution to stop. Uses IO.pipe
+    # for cross-thread signaling, which wakes the Async scheduler from any
+    # thread. The stop listener task then calls barrier.stop within the
+    # reactor to cancel all executing tasks.
+    #
+    # Safe to call from event callbacks, other threads, or signal handlers.
+    # No-op if no execution is in progress or stop was already requested.
+    #
+    # @return [void]
+    #
+    # @example Stop from event callback
+    #   swarm.execute("Build auth") do |event|
+    #     swarm.stop if event[:type] == "tool_call" && event[:tool] == "Dangerous"
+    #   end
+    #
+    # @example Stop from another thread
+    #   Thread.new { swarm.execute("Build auth") }
+    #   sleep 10
+    #   swarm.stop
+    def stop
+      return if @stop_requested
+
+      @stop_requested = true
+      begin
+        @stop_signal_write&.write("x") unless @stop_signal_write&.closed?
+        @stop_signal_write&.close unless @stop_signal_write&.closed?
+      rescue IOError, Errno::EPIPE
+        # Pipe already closed - normal during cleanup
+      end
+    end
+
+    # Check if a stop has been requested
+    #
+    # @return [Boolean] true if stop was requested
+    def stop_requested?
+      @stop_requested
+    end
+
+    # Prepare stop signaling for a new execution
+    #
+    # Resets the stop flag and creates a new IO.pipe for signaling.
+    # Called by Executor at the start of each execution.
+    #
+    # @return [void]
+    def prepare_for_execution
+      @stop_requested = false
+      @stop_signal_read, @stop_signal_write = IO.pipe
+      @active_agent_chats = {}
+    end
+
+    # Close the stop signal pipe
+    #
+    # Called by Executor after execution completes.
+    #
+    # @return [void]
+    def cleanup_stop_signal
+      @stop_signal_read&.close unless @stop_signal_read&.closed?
+      @stop_signal_write&.close unless @stop_signal_write&.closed?
+      @stop_signal_read = nil
+      @stop_signal_write = nil
+    end
+
+    # Register the execution barrier for stop cancellation
+    #
+    # @param barrier [Async::Barrier] The barrier wrapping execution tasks
+    # @return [void]
+    def register_execution_barrier(barrier)
+      @execution_barrier = barrier
+    end
+
+    # Clear the execution barrier reference
+    #
+    # @return [void]
+    def clear_execution_barrier
+      @execution_barrier = nil
+    end
+
+    # Mark an agent as actively executing an LLM call
+    #
+    # Called by Agent::Chat#execute_ask to track which agents are mid-execution.
+    # Used during interruption to emit agent_stop events for active agents.
+    #
+    # @param name [Symbol] Agent name
+    # @param chat [Agent::Chat] Agent chat instance
+    # @return [void]
+    def mark_agent_active(name, chat)
+      @active_agent_chats[name] = chat
+    end
+
+    # Mark an agent as no longer actively executing
+    #
+    # @param name [Symbol] Agent name
+    # @return [void]
+    def mark_agent_inactive(name)
+      @active_agent_chats.delete(name)
+    end
+
+    # Get a snapshot of currently active agent chats
+    #
+    # Returns a copy to avoid concurrent modification issues.
+    #
+    # @return [Hash{Symbol => Agent::Chat}] Copy of active agent chats
+    def active_agent_chats
+      @active_agent_chats.dup
+    end
+
+    # Stop all observer tasks immediately
+    #
+    # Interrupts in-flight observer LLM calls.
+    # Called during swarm interruption instead of wait_for_completion.
+    #
+    # @return [void]
+    def stop_observers
+      @observer_manager&.stop
+    end
+
     # Create snapshot of current conversation state
     #
     # Returns a Snapshot object containing:

data/lib/swarm_sdk/version.rb

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

data/lib/swarm_sdk.rb

@@ -91,6 +91,9 @@ module SwarmSDK
   # Raised when agent turn exceeds turn_timeout
   class TurnTimeoutError < TimeoutError; end
 
+  # Raised when swarm execution is interrupted via swarm.stop
+  class InterruptedError < Error; end
+
   # Base class for MCP-related errors (provides context about server/tool)
   class MCPError < Error; end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: swarm_sdk
 version: !ruby/object:Gem::Version
-  version: 2.7.13
+  version: 2.7.14
 platform: ruby
 authors:
 - Paulo Arruda
@@ -181,6 +181,7 @@ files:
 - 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/mcp_ssl_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