swarm_sdk 2.7.9 → 2.7.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6af3c1d2b4f71135747902e3d94b4541904bf1877c02064cb928cccc742cf9b
-  data.tar.gz: a829be669e85d25c1fa85cc05410b44bb3d9785ad0a72bfe238ae92f1859c828
+  metadata.gz: bcabd24d5d88debcf61b86803b61996a60a8d56dac5ca56c1952478df8725079
+  data.tar.gz: 1c661fd7c839822ce4cddcfbb499ed8700b3311b45d6f791e94e3b4fb9965dd3
 SHA512:
-  metadata.gz: af53d4fa1e8a4ae2ace5297e90743ddd219e3015f3ffa62e89dedb607f73e9641d3cb3d44b506a76e2a70a72074aa3f504229cb4a7d02b056af6b0b555c59bdd
-  data.tar.gz: 333359fe2c10fbb772675ae035fa00de4eb1a1cf9d3f5ee7e7b4440d8d6bd25cfc96d1efbadf8621e5bf3c6ef53f8e790a8d31db3c682c1ac7f47d61507c4843
+  metadata.gz: eec76f06fd85bbfe4bfc124473760ef9a3a84dd69aae3abb3de018b18b817882b5b1d23e1708cd9dce7f04abff433bec60eb436d7e5939a8925ef84f44a88005
+  data.tar.gz: 5b71b6839d87d0010525a5dcf708424a8a585ed59472a384af0d13b5e2992e760f9ee15e9707c63ce0023e3aef3e19c373e333fa1d6dfd3bcb87dc59b9dd76c3

data/lib/swarm_sdk/ruby_llm_patches/chat_callbacks_patch.rb

@@ -0,0 +1,284 @@
+# 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)
+        @provider.complete(
+          messages_to_send,
+          tools: @tools,
+          temperature: @temperature,
+          model: @model,
+          params: @params,
+          headers: @headers,
+          schema: @schema,
+          thinking: @thinking,
+          &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