swarm_sdk 2.7.10 → 2.7.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7863f2b6c3b7c74c13ca47957713e5588167a09a2c95acfebb3c53bab571af7f
-  data.tar.gz: edf4cc3e12b13327909b8c21a5b0b40dafde5707ff82883762d980b267330e8b
+  metadata.gz: 700ee5f9b81c58e030024d664a7c3e27db84c705c876493678c89371f803158a
+  data.tar.gz: b2a4e2d7dc72208bff64b9c8d5f72dbe9d2772ae5f2f61d8abf3973d5855867c
 SHA512:
-  metadata.gz: df8234592d637315378d078c211b98b61bf3411d11ac49b2c2d82954314cf985686deb927d9d8f41855a341675fb216814415a7be0b7e5e0297fd593b83fc95f
-  data.tar.gz: 360d76065cbc15d6968d13616cb5e2c29d5a6b3771aa58a7490fca5cf360fc6b0a2bd3b3c7c90b98d89388205ad927ea998b2804fb1076bed5d91aff0d982596
+  metadata.gz: 7e375f31f8419422c3b93065f0fa525d63ae063865b2dd62032ac42ff4e9f827111f5cf1dc13cc18e27e215e9e1a0924965791155f553d5af9261f53580680e4
+  data.tar.gz: f44a0e73852254048fe7219efed8db620bc41f4d274bfd938997ac5281a79c6cfa575e3be7631e404bbd84acfc3dd25649130a06fa10b85d4cac6a0099007d11

data/lib/swarm_sdk/agent/builder.rb

@@ -62,6 +62,7 @@ module SwarmSDK
         @memory_config = nil
         @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)
         @context_management_config = nil # Context management DSL hooks
       end
 
@@ -372,6 +373,38 @@ module SwarmSDK
         !@streaming.nil?
       end
 
+      # Configure extended thinking for this agent
+      #
+      # Extended thinking allows models to reason through complex problems before responding.
+      # For Anthropic models, specify a budget (token count). For OpenAI models, specify effort.
+      # Both can be specified for cross-provider compatibility.
+      #
+      # @param effort [Symbol, String, nil] Reasoning effort level (:low, :medium, :high) — used by OpenAI
+      # @param budget [Integer, nil] Token budget for thinking — used by Anthropic
+      # @return [self] Returns self for method chaining
+      #
+      # @example Anthropic thinking with budget
+      #   thinking budget: 10_000
+      #
+      # @example OpenAI reasoning effort
+      #   thinking effort: :high
+      #
+      # @example Cross-provider (both)
+      #   thinking effort: :high, budget: 10_000
+      def thinking(effort: nil, budget: nil)
+        raise ArgumentError, "thinking requires :effort or :budget" if effort.nil? && budget.nil?
+
+        @thinking = { effort: effort, budget: budget }.compact
+        self
+      end
+
+      # Check if thinking has been explicitly set
+      #
+      # @return [Boolean] true if thinking was explicitly configured
+      def thinking_set?
+        !@thinking.nil?
+      end
+
       # Configure context management handlers
       #
       # Define custom handlers for context warning thresholds (60%, 80%, 90%).
@@ -552,6 +585,7 @@ module SwarmSDK
         agent_config[:memory] = @memory_config if @memory_config
         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
 
         # Convert DSL hooks to HookDefinition format
         agent_config[:hooks] = convert_hooks_to_definitions if @hooks.any?

data/lib/swarm_sdk/agent/chat.rb

@@ -189,10 +189,11 @@ module SwarmSDK
         # Try to fetch real model info for accurate context tracking
         fetch_real_model_info(model_id)
 
-        # Configure system prompt, parameters, and headers
+        # Configure system prompt, parameters, headers, and thinking
         configure_system_prompt(system_prompt) if system_prompt
         configure_parameters(parameters)
         configure_headers(custom_headers)
+        configure_thinking(definition[:thinking])
 
         # Setup around_tool_execution hook for SwarmSDK orchestration
         setup_tool_execution_hook
@@ -986,6 +987,12 @@ module SwarmSDK
             emit_non_retryable_error(e, "UnknownAPIError")
             return build_error_message(e)
 
+          # === CATEGORY A (CONTINUED): PROGRAMMING ERRORS ===
+          rescue ArgumentError, TypeError, NameError => e
+            # Programming errors (wrong keywords, type mismatches) - won't fix by retrying
+            emit_non_retryable_error(e, e.class.name)
+            return build_error_message(e)
+
           # === CATEGORY C: NETWORK/OTHER ERRORS ===
           rescue StandardError => e
             # Network errors, timeouts, unknown errors - retry with delays

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

@@ -224,6 +224,22 @@ module SwarmSDK
           RubyLLM.logger.debug("SwarmSDK: Enabled native Responses API support")
         end
 
+        # Configure extended thinking on the RubyLLM chat instance
+        #
+        # @param thinking_config [Hash, nil] Thinking configuration with :effort and/or :budget
+        # @return [self]
+        #
+        # @example
+        #   configure_thinking(budget: 10_000)
+        #   configure_thinking(effort: :high)
+        #   configure_thinking(effort: :high, budget: 10_000)
+        def configure_thinking(thinking_config)
+          return self unless thinking_config
+
+          @llm_chat.with_thinking(**thinking_config)
+          self
+        end
+
         # Configure LLM parameters with proper temperature normalization
         #
         # @param params [Hash] Parameter hash

data/lib/swarm_sdk/agent/definition.rb

@@ -42,7 +42,8 @@ module SwarmSDK
         :hooks,
         :plugin_configs,
         :shared_across_delegations,
-        :streaming
+        :streaming,
+        :thinking
 
       attr_accessor :bypass_permissions, :max_concurrent_tools
 
@@ -114,6 +115,9 @@ module SwarmSDK
         # Streaming configuration (default: true from global config)
         @streaming = config.fetch(:streaming, SwarmSDK.config.streaming)
 
+        # Extended thinking configuration (nil = disabled)
+        @thinking = config[:thinking]
+
         # Build system prompt after directory and memory are set
         @system_prompt = build_full_system_prompt(config[:system_prompt])
 

data/lib/swarm_sdk/builders/base_builder.rb

@@ -450,6 +450,10 @@ module SwarmSDK
         if !all_agents_hash[:streaming].nil? && !agent_builder.streaming_set?
           agent_builder.streaming(all_agents_hash[:streaming])
         end
+
+        if all_agents_hash[:thinking] && !agent_builder.thinking_set?
+          agent_builder.thinking(**all_agents_hash[:thinking])
+        end
       end
 
       # Validate all_agents filesystem tools

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?
+          thinking(**all_agents_cfg[:thinking]) if all_agents_cfg[:thinking]
 
           if all_agents_hks.any?
             all_agents_hks.each do |event, hook_specs|
@@ -164,6 +165,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?
+          thinking(**config[:thinking]) if config[:thinking]
 
           if config[:tools]&.any?
             tool_names = config[:tools].map { |t| t.is_a?(Hash) ? t[:name] : t }

data/lib/swarm_sdk/ruby_llm_patches/chat_callbacks_patch.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+# Extends RubyLLM::Chat with:
+# - Multi-subscriber callbacks (allows multiple callbacks per event)
+# - Subscription objects for unsubscribing
+# - around_tool_execution hook for wrapping tool execution
+# - around_llm_request hook for wrapping LLM API requests
+# - Changed on_tool_result signature to pass (tool_call, result)
+#
+# Fork Reference: Commits d0912c7, a2a028d, 61cd510, 162189f
+
+module RubyLLM
+  class Chat
+    # Represents an active subscription to a callback event
+    class Subscription
+      attr_reader :tag
+
+      def initialize(callback_list, callback, monitor:, tag: nil)
+        @callback_list = callback_list
+        @callback = callback
+        @monitor = monitor
+        @tag = tag
+        @active = true
+      end
+
+      def unsubscribe # rubocop:disable Naming/PredicateMethod
+        @monitor.synchronize do
+          return false unless @active
+
+          @callback_list.delete(@callback)
+          @active = false
+        end
+        true
+      end
+
+      def active?
+        @monitor.synchronize do
+          @active && @callback_list.include?(@callback)
+        end
+      end
+
+      def inspect
+        "#<#{self.class.name} tag=#{@tag.inspect} active=#{active?}>"
+      end
+    end
+
+    # Module to prepend for multi-subscriber callbacks
+    module MultiSubscriberCallbacks
+      def initialize(**kwargs)
+        super(**kwargs)
+
+        # Replace single callback hash with multi-subscriber arrays
+        @callbacks = {
+          new_message: [],
+          end_message: [],
+          tool_call: [],
+          tool_result: [],
+        }
+        @callback_monitor = Monitor.new
+
+        # Initialize around hooks
+        @around_tool_execution_hook = nil
+        @around_llm_request_hook = nil
+
+        # Keep @on for backward compatibility (read-only)
+        @on = nil
+      end
+
+      # Subscribe to an event with the given block
+      # Returns a Subscription that can be used to unsubscribe
+      def subscribe(event, tag: nil, &block)
+        @callback_monitor.synchronize do
+          unless @callbacks.key?(event)
+            raise ArgumentError, "Unknown event: #{event}. Valid events: #{@callbacks.keys.join(", ")}"
+          end
+
+          @callbacks[event] << block
+          Subscription.new(@callbacks[event], block, monitor: @callback_monitor, tag: tag)
+        end
+      end
+
+      # Subscribe to an event that automatically unsubscribes after firing once
+      def once(event, tag: nil, &block)
+        subscription = nil
+        wrapper = lambda do |*args|
+          subscription&.unsubscribe
+          block.call(*args)
+        end
+        subscription = subscribe(event, tag: tag, &wrapper)
+      end
+
+      # Override callback registration methods to support multi-subscriber
+      def on_new_message(&block)
+        subscribe(:new_message, &block)
+        self
+      end
+
+      def on_end_message(&block)
+        subscribe(:end_message, &block)
+        self
+      end
+
+      def on_tool_call(&block)
+        subscribe(:tool_call, &block)
+        self
+      end
+
+      def on_tool_result(&block)
+        subscribe(:tool_result, &block)
+        self
+      end
+
+      # Sets a hook to wrap tool execution with custom behavior
+      #
+      # @yield [ToolCall, Tool, Proc] Block called for each tool execution
+      # @return [self] for chaining
+      def around_tool_execution(&block)
+        @around_tool_execution_hook = block
+        self
+      end
+
+      # Sets a hook to wrap LLM API requests with custom behavior
+      #
+      # @yield [Array<Message>, Proc] Block called before each LLM request
+      # @return [self] for chaining
+      def around_llm_request(&block)
+        @around_llm_request_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
+          if event
+            @callbacks[event]&.clear
+          else
+            @callbacks.each_value(&:clear)
+          end
+        end
+        self
+      end
+
+      # Returns the number of callbacks registered for the specified event
+      def callback_count(event = nil)
+        @callback_monitor.synchronize do
+          if event
+            @callbacks[event]&.size || 0
+          else
+            @callbacks.transform_values(&:size)
+          end
+        end
+      end
+
+      # Override complete to use emit() and support around_llm_request hook
+      # Follows fork pattern: tool call handling wraps message addition
+      def complete(&block)
+        # Execute LLM request (potentially wrapped by around_llm_request hook)
+        response = execute_llm_request(&block)
+
+        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
+          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
+        end
+      end
+
+      private
+
+      # Emit an event to all registered callbacks
+      # Callbacks are called in FIFO order, errors are isolated
+      def emit(event, *args)
+        callbacks = @callback_monitor.synchronize { @callbacks[event]&.dup || [] }
+
+        callbacks.each do |callback|
+          callback.call(*args)
+        rescue StandardError => e
+          RubyLLM.logger.error("[RubyLLM] Callback error for #{event}: #{e.message}")
+        end
+      end
+
+      # Execute LLM request, potentially wrapped by around_llm_request hook
+      def execute_llm_request(&block)
+        if @around_llm_request_hook
+          @around_llm_request_hook.call(messages) do |prepared_messages = messages|
+            perform_llm_request(prepared_messages, &block)
+          end
+        else
+          perform_llm_request(messages, &block)
+        end
+      end
+
+      # Perform the actual LLM request
+      def perform_llm_request(messages_to_send, &block)
+        kwargs = {
+          tools: @tools,
+          temperature: @temperature,
+          model: @model,
+          params: @params,
+          headers: @headers,
+          schema: @schema,
+        }
+        # Only pass thinking when explicitly configured via with_thinking
+        # to maintain compatibility with providers that don't support this keyword
+        kwargs[:thinking] = @thinking if @thinking
+
+        @provider.complete(messages_to_send, **kwargs, &wrap_streaming_block(&block))
+      rescue ArgumentError => e
+        raise ArgumentError,
+          "#{e.message} — provider #{@provider.class.name} does not support this parameter " \
+            "(model: #{@model&.id || "unknown"})",
+          e.backtrace
+      end
+
+      # Override wrap_streaming_block to use emit
+      def wrap_streaming_block(&block)
+        return unless block_given?
+
+        emit(:new_message)
+
+        proc do |chunk|
+          block.call(chunk)
+        end
+      end
+
+      # Override handle_tool_calls to use emit and support around_tool_execution hook
+      def handle_tool_calls(response, &block)
+        halt_result = nil
+
+        response.tool_calls.each_value do |tool_call|
+          emit(:new_message)
+          emit(:tool_call, tool_call)
+
+          result = execute_tool_with_hook(tool_call)
+
+          # Emit tool_result with both tool_call and result (fork signature)
+          emit(:tool_result, tool_call, result)
+
+          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)
+          emit(:end_message, message)
+
+          halt_result = result if result.is_a?(Tool::Halt)
+        end
+
+        halt_result || complete(&block)
+      end
+
+      # Execute tool with around_tool_execution hook if set
+      # Fork signature: hook receives (tool_call, tool_instance, execute_proc)
+      # Note: tool_instance may be nil if tool is not found - the hook/execute_proc
+      # should handle this case (will raise NoMethodError, caught by rescue)
+      def execute_tool_with_hook(tool_call)
+        tool_instance = tools[tool_call.name.to_sym]
+        execute_proc = -> { tool_instance.call(tool_call.arguments) }
+
+        if @around_tool_execution_hook
+          @around_tool_execution_hook.call(tool_call, tool_instance, execute_proc)
+        else
+          execute_proc.call
+        end
+      rescue StandardError => e
+        "Error: #{e.class}: #{e.message}"
+      end
+    end
+
+    # Prepend the module to override methods
+    prepend MultiSubscriberCallbacks
+  end
+end

data/lib/swarm_sdk/ruby_llm_patches/configuration_patch.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Extends RubyLLM::Configuration with additional options:
+# - anthropic_api_base: Configurable Anthropic API base URL
+# - read_timeout, open_timeout, write_timeout: Granular timeout configuration
+#
+# Fork Reference: Commits da6144b, 3daa4fb
+
+module RubyLLM
+  class Configuration
+    # Add new configuration accessors
+    attr_accessor :anthropic_api_base,
+      :read_timeout,
+      :open_timeout,
+      :write_timeout
+
+    # Store original initialize for chaining
+    alias_method :original_initialize_without_patches, :initialize
+
+    # Override initialize to set default values for new options
+    def initialize
+      original_initialize_without_patches
+
+      # Add new configuration options with defaults
+      @anthropic_api_base = nil # Uses default 'https://api.anthropic.com' if not set
+      @read_timeout = nil       # Defaults to request_timeout if not set
+      @open_timeout = 30
+      @write_timeout = 30
+    end
+  end
+
+  # Patch Anthropic provider to use configurable base URL
+  module Providers
+    class Anthropic
+      # Override api_base to use configurable base URL
+      def api_base
+        @config.anthropic_api_base || "https://api.anthropic.com"
+      end
+    end
+  end
+end

data/lib/swarm_sdk/ruby_llm_patches/connection_patch.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Extends RubyLLM::Connection with:
+# - Connection.basic uses net_http adapter for SSL/IPv6 compatibility
+# - Granular timeout support (read_timeout, open_timeout, write_timeout)
+#
+# Fork Reference: Commits cdc6067, 3daa4fb
+
+module RubyLLM
+  class Connection
+    class << self
+      # Override basic to use net_http adapter
+      # This avoids async-http SSL/IPv6 issues for simple API calls
+      def basic(&)
+        Faraday.new do |f|
+          f.response(
+            :logger,
+            RubyLLM.logger,
+            bodies: false,
+            response: false,
+            errors: true,
+            headers: false,
+            log_level: :debug,
+          )
+          f.response(:raise_error)
+          yield f if block_given?
+          # Use net_http for simple API calls to avoid async-http SSL/IPv6 issues
+          f.adapter(:net_http)
+        end
+      end
+    end
+
+    private
+
+    # Override setup_timeout to support granular timeouts
+    def setup_timeout(faraday)
+      faraday.options.timeout = @config.request_timeout
+      faraday.options.open_timeout = @config.open_timeout if @config.respond_to?(:open_timeout) && @config.open_timeout
+      faraday.options.write_timeout = @config.write_timeout if @config.respond_to?(:write_timeout) && @config.write_timeout
+
+      # read_timeout defaults to request_timeout for streaming support
+      if @config.respond_to?(:read_timeout)
+        faraday.options.read_timeout = @config.read_timeout || @config.request_timeout
+      end
+    end
+  end
+end

data/lib/swarm_sdk/ruby_llm_patches/init.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# RubyLLM Compatibility Patches
+#
+# These patches extend upstream ruby_llm to match fork functionality used by SwarmSDK.
+# Load order is important - patches are loaded in dependency order.
+#
+# Features provided by these patches:
+# - Multi-subscriber callbacks with Subscription objects
+# - around_tool_execution and around_llm_request hooks
+# - Concurrent tool execution (async/threads)
+# - preserve_system_prompt option in reset_messages!
+# - Configurable Anthropic API base URL
+# - Granular timeout configuration (read_timeout, open_timeout, write_timeout)
+# - OpenAI Responses API support
+# - IPv6 fallback fix for io-endpoint
+#
+# Once upstream ruby_llm adds these features, patches can be disabled.
+
+# Load patches in dependency order
+
+# 1. io-endpoint patch (infrastructure fix, no RubyLLM dependencies)
+require_relative "io_endpoint_patch"
+
+# 2. Configuration patch (must be loaded before connection/providers)
+require_relative "configuration_patch"
+
+# 3. Connection patch (depends on configuration patch)
+require_relative "connection_patch"
+
+# 4. Chat callbacks patch (core callback system)
+require_relative "chat_callbacks_patch"
+
+# 5. Tool concurrency patch (depends on chat callbacks patch)
+require_relative "tool_concurrency_patch"
+
+# 6. Message management patch (simple, no dependencies)
+require_relative "message_management_patch"
+
+# 7. Responses API patch (depends on configuration, uses error classes)
+require_relative "responses_api_patch"

data/lib/swarm_sdk/ruby_llm_patches/io_endpoint_patch.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Monkey-patch io-endpoint to handle EHOSTUNREACH (IPv6 unreachable)
+# This fixes an issue where the async adapter fails on IPv6 without trying IPv4
+#
+# Fork Reference: Commit cdc6067
+
+begin
+  require "io/endpoint"
+  require "io/endpoint/host_endpoint"
+
+  # rubocop:disable Style/ClassAndModuleChildren
+  # Reopen the existing class (no superclass specified)
+  class IO::Endpoint::HostEndpoint
+    # Override connect to add EHOSTUNREACH to the rescue list
+    # This allows the connection to fall back to IPv4 when IPv6 is unavailable
+    def connect(wrapper = self.wrapper, &block)
+      last_error = nil
+
+      Addrinfo.foreach(*@specification) do |address|
+        socket = wrapper.connect(address, **@options)
+      rescue Errno::ECONNREFUSED, Errno::ENETUNREACH, Errno::EHOSTUNREACH, Errno::EAGAIN => last_error
+        # Try next address (IPv4 fallback)
+      else
+        return socket unless block_given?
+
+        begin
+          return yield(socket)
+        ensure
+          socket.close
+        end
+      end
+
+      raise last_error if last_error
+    end
+  end
+  # rubocop:enable Style/ClassAndModuleChildren
+rescue LoadError
+  # io-endpoint gem not available, skip this patch
+end

data/lib/swarm_sdk/ruby_llm_patches/message_management_patch.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Extends RubyLLM::Chat with enhanced message management:
+# - reset_messages! with preserve_system_prompt option
+#
+# Fork Reference: Commit e6a34b5
+
+module RubyLLM
+  class Chat
+    # Override reset_messages! to support preserve_system_prompt option
+    #
+    # @param preserve_system_prompt [Boolean] If true (default), keeps system messages
+    # @return [self] for chaining
+    def reset_messages!(preserve_system_prompt: true)
+      if preserve_system_prompt
+        @messages.select! { |m| m.role == :system }
+      else
+        @messages.clear
+      end
+      self
+    end
+  end
+end