swarm_sdk 2.7.11 → 2.7.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcabd24d5d88debcf61b86803b61996a60a8d56dac5ca56c1952478df8725079
-  data.tar.gz: 1c661fd7c839822ce4cddcfbb499ed8700b3311b45d6f791e94e3b4fb9965dd3
+  metadata.gz: 427d736e32c386d76df7481b50b95e272045b88eb93290353528fd48c2525d91
+  data.tar.gz: fc3cf69eaa253871f0db9f6332dd62669af2941082f622e266f65e035f6b2b21
 SHA512:
-  metadata.gz: eec76f06fd85bbfe4bfc124473760ef9a3a84dd69aae3abb3de018b18b817882b5b1d23e1708cd9dce7f04abff433bec60eb436d7e5939a8925ef84f44a88005
-  data.tar.gz: 5b71b6839d87d0010525a5dcf708424a8a585ed59472a384af0d13b5e2992e760f9ee15e9707c63ce0023e3aef3e19c373e333fa1d6dfd3bcb87dc59b9dd76c3
+  metadata.gz: d08958fe437094ce91bdae63e6e20290158417270d1d39446fbb9cc45b2ea02bfbbae99dccfb36097fb053a2190f4cee1fd101c876eda1a388c19ba3ba4cdf4c
+  data.tar.gz: cf06e09fe354ca95035d27e5ee4d710be461757829c1448c5d178b9f8a9b9372419e27bc036101d9ad0add625459784fa766413695f3f030efcba8fa97ee8467

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
@@ -525,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
@@ -986,6 +994,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/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/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

@@ -207,17 +207,19 @@ module RubyLLM
 
       # Perform the actual LLM request
       def perform_llm_request(messages_to_send, &block)
-        @provider.complete(
-          messages_to_send,
+        kwargs = {
           tools: @tools,
           temperature: @temperature,
           model: @model,
           params: @params,
           headers: @headers,
           schema: @schema,
-          thinking: @thinking,
-          &wrap_streaming_block(&block)
-        )
+        }
+        # 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 " \

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/all_agents_builder.rb

@@ -36,6 +36,7 @@ module SwarmSDK
         @coding_agent = nil
         @disable_default_tools = nil
         @streaming = nil
+        @thinking = nil
       end
 
       # Set model for all agents
@@ -99,6 +100,16 @@ module SwarmSDK
         @streaming = value
       end
 
+      # Configure extended thinking for all agents
+      #
+      # @param effort [Symbol, String, nil] Reasoning effort (:low, :medium, :high) — OpenAI
+      # @param budget [Integer, nil] Token budget for thinking — Anthropic
+      def thinking(effort: nil, budget: nil)
+        raise ArgumentError, "thinking requires :effort or :budget" if effort.nil? && budget.nil?
+
+        @thinking = { effort: effort, budget: budget }.compact
+      end
+
       # Add tools that all agents will have
       def tools(*tool_names)
         @tools_list.concat(tool_names)
@@ -174,6 +185,7 @@ module SwarmSDK
           coding_agent: @coding_agent,
           disable_default_tools: @disable_default_tools,
           streaming: @streaming,
+          thinking: @thinking,
           tools: @tools_list,
           permissions: @permissions_config,
         }.compact

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.11"
+  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.11
+  version: 2.7.13
 platform: ruby
 authors:
 - Paulo Arruda