swarm_sdk 2.7.12 → 2.7.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 700ee5f9b81c58e030024d664a7c3e27db84c705c876493678c89371f803158a
-  data.tar.gz: b2a4e2d7dc72208bff64b9c8d5f72dbe9d2772ae5f2f61d8abf3973d5855867c
+  metadata.gz: 427d736e32c386d76df7481b50b95e272045b88eb93290353528fd48c2525d91
+  data.tar.gz: fc3cf69eaa253871f0db9f6332dd62669af2941082f622e266f65e035f6b2b21
 SHA512:
-  metadata.gz: 7e375f31f8419422c3b93065f0fa525d63ae063865b2dd62032ac42ff4e9f827111f5cf1dc13cc18e27e215e9e1a0924965791155f553d5af9261f53580680e4
-  data.tar.gz: f44a0e73852254048fe7219efed8db620bc41f4d274bfd938997ac5281a79c6cfa575e3be7631e404bbd84acfc3dd25649130a06fa10b85d4cac6a0099007d11
+  metadata.gz: d08958fe437094ce91bdae63e6e20290158417270d1d39446fbb9cc45b2ea02bfbbae99dccfb36097fb053a2190f4cee1fd101c876eda1a388c19ba3ba4cdf4c
+  data.tar.gz: cf06e09fe354ca95035d27e5ee4d710be461757829c1448c5d178b9f8a9b9372419e27bc036101d9ad0add625459784fa766413695f3f030efcba8fa97ee8467

data/lib/swarm_sdk/agent/chat.rb

@@ -526,17 +526,24 @@ module SwarmSDK
       #
       # This method:
       # 1. Serializes concurrent asks via @ask_semaphore
-      # 2. Adds CLEAN user message to history (no reminders)
-      # 3. Injects system reminders as ephemeral content (sent to LLM but not stored)
-      # 4. Triggers user_prompt hooks
-      # 5. Acquires global semaphore for LLM call
-      # 6. Delegates to RubyLLM::Chat for actual execution
+      # 2. Optionally clears conversation context (inside semaphore for safety)
+      # 3. Adds CLEAN user message to history (no reminders)
+      # 4. Injects system reminders as ephemeral content (sent to LLM but not stored)
+      # 5. Triggers user_prompt hooks
+      # 6. Acquires global semaphore for LLM call
+      # 7. Delegates to RubyLLM::Chat for actual execution
       #
       # @param prompt [String] User prompt
+      # @param clear_context [Boolean] When true, clears conversation history before
+      #   processing. Clearing happens inside the ask_semaphore, making it safe for
+      #   concurrent callers (e.g., parallel delegations to the same agent).
       # @param options [Hash] Additional options (source: for hooks)
       # @return [RubyLLM::Message] LLM response
-      def ask(prompt, **options)
+      def ask(prompt, clear_context: false, **options)
         @ask_semaphore.acquire do
+          # Clear inside semaphore so concurrent callers don't corrupt each other's messages
+          clear_conversation if clear_context
+
           if @turn_timeout
             execute_with_turn_timeout(prompt, options)
           else

data/lib/swarm_sdk/agent/llm_instrumentation_middleware.rb

@@ -82,6 +82,7 @@ module SwarmSDK
       def emit_request_event(env, timestamp)
         request_data = {
           provider: @provider_name,
+          url: env.url.to_s,
           body: parse_body(env.body),
           timestamp: timestamp.utc.iso8601,
         }

data/lib/swarm_sdk/ruby_llm_patches/configuration_patch.rb

@@ -3,6 +3,7 @@
 # Extends RubyLLM::Configuration with additional options:
 # - anthropic_api_base: Configurable Anthropic API base URL
 # - read_timeout, open_timeout, write_timeout: Granular timeout configuration
+# - Fixes Anthropic completion_url leading slash that breaks proxy base URLs
 #
 # Fork Reference: Commits da6144b, 3daa4fb
 
@@ -29,13 +30,25 @@ module RubyLLM
     end
   end
 
-  # Patch Anthropic provider to use configurable base URL
+  # Patch Anthropic provider to use configurable base URL and fix completion_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
+
+      # Fix completion_url to use relative path (no leading slash).
+      # The leading slash causes Faraday to discard the base URL path component,
+      # breaking proxy configurations where api_base includes a path segment
+      # (e.g., https://proxy.dev/apis/anthropic/v1/messages → https://proxy.dev/v1/messages).
+      # stream_url delegates to completion_url, so this fixes both sync and streaming.
+      # Can be removed once RubyLLM releases a version including upstream fix (commit da6144b).
+      module Chat
+        def completion_url
+          "v1/messages"
+        end
+      end
     end
   end
 end

data/lib/swarm_sdk/ruby_llm_patches/tool_concurrency_patch.rb

@@ -88,11 +88,15 @@ module RubyLLM
               "Add `gem 'async'` to your Gemfile. Original error: #{e.message}"
         end
 
-        def run_with_sync(&)
-          if defined?(Sync)
-            Sync(&)
+        def run_with_sync(&block)
+          if Async::Task.current?
+            # Already inside an async reactor (SwarmSDK always runs in one).
+            # Just yield — no Sync, no nested reactor, no Promise mutex issues.
+            yield
           else
-            Async(&).wait
+            # Outside async context (e.g., standalone RubyLLM usage).
+            # Sync handles reactor creation and cleanup.
+            Sync(&block)
           end
         end
 

data/lib/swarm_sdk/swarm.rb

@@ -73,7 +73,6 @@ module SwarmSDK
     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_accessor :delegation_call_stack
 
     # Check if scratchpad tools are enabled
     #
@@ -174,9 +173,6 @@ module SwarmSDK
       # Swarm registry for managing sub-swarms (initialized later if needed)
       @swarm_registry = nil
 
-      # Delegation call stack for circular dependency detection
-      @delegation_call_stack = []
-
       # Shared semaphore for all agents
       @global_semaphore = Async::Semaphore.new(@global_concurrency)
 

data/lib/swarm_sdk/tools/delegate.rb

@@ -45,7 +45,7 @@ module SwarmSDK
       # @param delegate_description [String] Description of the delegate agent
       # @param delegate_chat [AgentChat, nil] The chat instance for the delegate agent (nil if delegating to swarm)
       # @param agent_name [Symbol, String] Name of the agent using this tool
-      # @param swarm [Swarm] The swarm instance (provides hook_registry, delegation_call_stack, swarm_registry)
+      # @param swarm [Swarm] The swarm instance (provides hook_registry, swarm_registry)
       # @param delegating_chat [Agent::Chat, nil] The chat instance of the agent doing the delegating (for accessing hooks)
       # @param custom_tool_name [String, nil] Optional custom tool name (overrides auto-generated name)
       # @param preserve_context [Boolean] Whether to preserve conversation context between delegations (default: true)
@@ -72,6 +72,16 @@ module SwarmSDK
         # Use custom tool name if provided, otherwise generate using canonical method
         @tool_name = custom_tool_name || self.class.tool_name_for(delegate_name)
         @delegate_target = delegate_name.to_s
+
+        # Track concurrent delegations to this target.
+        # When multiple parallel tool calls target the same delegate, only the first
+        # preserves context; subsequent concurrent calls always clear context to
+        # prevent cross-contamination between independent parallel work.
+        #
+        # No Mutex needed: Async Fibers run on a single thread and only switch at
+        # explicit yield points (IO, sleep, semaphore.acquire). Integer increment
+        # and decrement never yield, so they are inherently atomic.
+        @active_count = 0
       end
 
       # Override description to return dynamic string based on delegate
@@ -122,19 +132,32 @@ module SwarmSDK
 
       # Execute delegation with pre/post hooks
       #
+      # Uses Fiber-local path tracking for circular dependency detection.
+      # Each concurrent delegation runs in its own Fiber (via Async), so the path
+      # is isolated per execution path. This correctly distinguishes parallel fan-out
+      # (A→B, A→B) from true circular dependencies (A→B→A).
+      #
       # @param message [String] Message to send to the agent
       # @param reset_context [Boolean] Whether to reset the agent's conversation history before delegation
       # @return [String] Result from delegate agent or error message
       def execute(message:, reset_context: false)
+        # Save the current delegation path so we can restore it after execution.
+        # The extended path (with our target) is only needed during chat.ask() so
+        # child Fibers (nested delegations) inherit it. After delegation returns,
+        # this Fiber's path should be unchanged.
+        saved_delegation_path = Fiber[:delegation_path]
+
         # Access swarm infrastructure
-        call_stack = @swarm.delegation_call_stack
         hook_registry = @swarm.hook_registry
         swarm_registry = @swarm.swarm_registry
 
-        # Check for circular dependency
-        if call_stack.include?(@delegate_target)
-          emit_circular_warning(call_stack)
-          return "Error: Circular delegation detected: #{call_stack.join(" -> ")} -> #{@delegate_target}. " \
+        # Check for circular dependency using Fiber-local path
+        # Each Fiber inherits the parent's path, so nested delegations
+        # accumulate the full chain while parallel siblings remain isolated
+        delegation_path = saved_delegation_path || []
+        if delegation_path.include?(@delegate_target)
+          emit_circular_warning(delegation_path)
+          return "Error: Circular delegation detected: #{delegation_path.join(" -> ")} -> #{@delegate_target}. " \
             "Please restructure your delegation to avoid infinite loops."
         end
 
@@ -172,10 +195,10 @@ module SwarmSDK
         # Determine delegation type and proceed
         delegation_result = if @delegate_chat
           # Delegate to agent
-          delegate_to_agent(message, call_stack, reset_context: reset_context)
+          delegate_to_agent(message, reset_context: reset_context)
         elsif swarm_registry&.registered?(@delegate_target)
           # Delegate to registered swarm
-          delegate_to_swarm(message, call_stack, swarm_registry, reset_context: reset_context)
+          delegate_to_swarm(message, swarm_registry, reset_context: reset_context)
         else
           raise ConfigurationError, "Unknown delegation target: #{@delegate_target}"
         end
@@ -246,6 +269,11 @@ module SwarmSDK
         # Return error string for LLM
         backtrace_str = backtrace_array.join("\n  ")
         "Error: #{@tool_name} encountered an error: #{e.class.name}: #{e.message}\nBacktrace:\n  #{backtrace_str}"
+      ensure
+        # Restore the calling Fiber's delegation path.
+        # The extended path was only needed during chat.ask() so child Fibers
+        # (spawned for nested tool calls) could inherit it for circular detection.
+        Fiber[:delegation_path] = saved_delegation_path
       end
 
       private
@@ -254,28 +282,41 @@ module SwarmSDK
       #
       # Handles both eager Agent::Chat instances and lazy-loaded delegates.
       # LazyDelegateChat instances are initialized on first access.
+      # Sets Fiber-local delegation path so child Fibers (nested delegations)
+      # inherit the full chain for circular dependency detection.
+      #
+      # Tracks concurrent delegations to this target. When multiple parallel
+      # tool calls target the same delegate (fan-out), only the first call
+      # preserves context; subsequent concurrent calls always clear context
+      # to prevent cross-contamination between independent parallel work.
+      # Context clearing happens inside Agent::Chat's ask_semaphore for safety.
       #
       # @param message [String] Message to send to the agent
-      # @param call_stack [Array] Delegation call stack for circular dependency detection
       # @param reset_context [Boolean] Whether to reset the agent's conversation history before delegation
       # @return [String] Result from agent
-      def delegate_to_agent(message, call_stack, reset_context: false)
-        # Push delegate target onto call stack to track delegation chain
-        call_stack.push(@delegate_target)
-        begin
-          # Resolve the chat instance (handles lazy loading)
-          chat = resolve_delegate_chat
-
-          # Clear conversation if reset_context is true OR if preserve_context is false
-          # reset_context takes precedence as it's an explicit request
-          chat.clear_conversation if reset_context || !@preserve_context
-
-          response = chat.ask(message, source: "delegation")
-          response.content
-        ensure
-          # Always pop from stack, even if delegation fails
-          call_stack.pop
-        end
+      def delegate_to_agent(message, reset_context: false)
+        @active_count += 1
+        concurrent = @active_count > 1
+
+        # Set Fiber-local delegation path for this execution path
+        # Child Fibers (from nested delegations) inherit this path automatically
+        # We create a new array to avoid mutating the parent Fiber's reference
+        Fiber[:delegation_path] = (Fiber[:delegation_path] || []) + [@delegate_target]
+
+        # Resolve the chat instance (handles lazy loading)
+        chat = resolve_delegate_chat
+
+        # Determine if context should be cleared:
+        # - reset_context: explicit caller request
+        # - !preserve_context: agent configuration
+        # - concurrent: parallel fan-out to same delegate (always isolate)
+        # Clearing is done inside chat.ask's semaphore to avoid race conditions
+        should_clear = reset_context || !@preserve_context || concurrent
+
+        response = chat.ask(message, source: "delegation", clear_context: should_clear)
+        response.content
+      ensure
+        @active_count -= 1
       end
 
       # Resolve the delegate chat instance
@@ -294,48 +335,52 @@ module SwarmSDK
 
       # Delegate to a registered swarm
       #
+      # Sets Fiber-local delegation path so child Fibers (nested delegations)
+      # inherit the full chain for circular dependency detection.
+      # Tracks concurrent delegations the same way as delegate_to_agent.
+      #
       # @param message [String] Message to send to the swarm
-      # @param call_stack [Array] Delegation call stack for circular dependency detection
       # @param swarm_registry [SwarmRegistry] Registry for sub-swarms
       # @param reset_context [Boolean] Whether to reset the swarm's conversation history before delegation
       # @return [String] Result from swarm's lead agent
-      def delegate_to_swarm(message, call_stack, swarm_registry, reset_context: false)
+      def delegate_to_swarm(message, swarm_registry, reset_context: false)
+        @active_count += 1
+        concurrent = @active_count > 1
+
+        # Set Fiber-local delegation path for this execution path
+        Fiber[:delegation_path] = (Fiber[:delegation_path] || []) + [@delegate_target]
+
         # Load sub-swarm (lazy load + cache)
         subswarm = swarm_registry.load_swarm(@delegate_target)
 
-        # Push delegate target onto call stack to track delegation chain
-        call_stack.push(@delegate_target)
-        begin
-          # Reset swarm if reset_context is true
-          swarm_registry.reset(@delegate_target) if reset_context
+        # Reset swarm context if explicitly requested or concurrent fan-out
+        swarm_registry.reset(@delegate_target) if reset_context || concurrent
 
-          # Execute sub-swarm's lead agent (uses agent() to trigger lazy initialization)
-          lead_agent = subswarm.agent(subswarm.lead_agent)
-          response = lead_agent.ask(message, source: "delegation")
-          result = response.content
+        # Execute sub-swarm's lead agent (uses agent() to trigger lazy initialization)
+        lead_agent = subswarm.agent(subswarm.lead_agent)
+        response = lead_agent.ask(message, source: "delegation")
+        result = response.content
 
-          # Reset if keep_context: false (standard behavior)
-          swarm_registry.reset_if_needed(@delegate_target)
+        # Reset if keep_context: false (standard behavior)
+        swarm_registry.reset_if_needed(@delegate_target)
 
-          result
-        ensure
-          # Always pop from stack, even if delegation fails
-          call_stack.pop
-        end
+        result
+      ensure
+        @active_count -= 1
       end
 
       # Emit circular dependency warning event
       #
-      # @param call_stack [Array] Current delegation call stack
+      # @param delegation_path [Array<String>] Current Fiber-local delegation path
       # @return [void]
-      def emit_circular_warning(call_stack)
+      def emit_circular_warning(delegation_path)
         LogStream.emit(
           type: "delegation_circular_dependency",
           agent: @agent_name,
           swarm_id: @swarm.swarm_id,
           parent_swarm_id: @swarm.parent_swarm_id,
           target: @delegate_target,
-          call_stack: call_stack,
+          delegation_path: delegation_path,
           timestamp: Time.now.utc.iso8601,
         )
       end

data/lib/swarm_sdk/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: swarm_sdk
 version: !ruby/object:Gem::Version
-  version: 2.7.12
+  version: 2.7.13
 platform: ruby
 authors:
 - Paulo Arruda