claude-agent-sdk 0.33.1 → 0.35.0

data/lib/claude_agent_sdk/types.rb

@@ -9,7 +9,7 @@ module ClaudeAgentSDK
 
   # Effort levels for `ClaudeAgentOptions#effort`. The CLI (Claude Code 2.1.111+)
   # accepts these values; the set of *supported* levels is model-dependent
-  # (e.g. `xhigh` is only supported on Opus 4.7 and falls back to `high` on
+  # (e.g. `xhigh` arrived with Opus 4.7 and falls back to `high` on
   # Opus 4.6 / Sonnet 4.6). An Integer is also accepted and forwarded verbatim.
   EFFORT_LEVELS = %w[low medium high xhigh max].freeze
 
@@ -90,8 +90,245 @@ module ClaudeAgentSDK
       {}
     end
 
+    # The copy hook used wherever ClaudeAgentOptions are copied (dup_with and
+    # the configured-defaults merge). Identity by default: most Type instances
+    # are messages or callback payloads that never live inside options, and a
+    # user-supplied object that does (an observer, a store adapter) must stay
+    # the same object. Option VALUE types include OptionValue to opt in to
+    # copying, so a per-session change to e.g. sandbox rules can never reach
+    # another session or the configured defaults.
+    def dup_for_options
+      self
+    end
+
+    # Mixed into the mutable value types that ClaudeAgentOptions holds
+    # (SandboxSettings, SystemPromptPreset, AgentDefinition, ...). The copy
+    # recurses into the value's own state with Type.deep_dup_for_options, so
+    # nested containers and nested value types (SandboxSettings#network) are
+    # copied too while identity leaves (McpSdkServerConfig#instance, the
+    # callables in HookMatcher#hooks) stay shared. #dup never copies frozen
+    # state, so a copy of a frozen value (the configured-defaults snapshot) is
+    # mutable.
+    module OptionValue
+      def dup_for_options
+        copy = dup
+        copy.instance_variables.each do |ivar|
+          copy.instance_variable_set(ivar, Type.deep_dup_for_options(copy.instance_variable_get(ivar)))
+        end
+        copy
+      end
+    end
+
+    # Recurse into Hash/Array containers and option value types, and copy
+    # mutable (unfrozen) Strings — a caller-built prompt, model or
+    # allowed_tools entry is as much shared state as an Array, and `str <<
+    # 'x'` on one copy would otherwise change every other. A frozen String
+    # (any literal under frozen_string_literal) is immutable and keeps
+    # identity. Every other leaf keeps object identity (observer factories,
+    # callbacks, SDK MCP server instances must not be duped). Rebuild
+    # containers via dup.clear (never Hash#to_h / Array#map) to preserve
+    # container SUBCLASSES: to_h flattens e.g. Rails'
+    # HashWithIndifferentAccess into a plain Hash, silently breaking symbol
+    # lookups on the copy (config[:type] == 'sdk' → nil). Hash keys: Ruby
+    # already stores a dup'd, frozen copy of an unfrozen plain String key, but
+    # not of a String SUBCLASS key, so those are copied (and frozen, as keys
+    # should be) here. A compare_by_identity Hash is left keyed by the
+    # caller's objects: copying a key would break the caller's own lookups.
+    def self.deep_dup_for_options(value)
+      case value
+      when Hash
+        copy = value.dup.clear
+        value.each { |k, v| copy[option_hash_key(k, value)] = deep_dup_for_options(v) }
+        copy
+      when Array
+        copy = value.dup.clear
+        value.each { |v| copy << deep_dup_for_options(v) }
+        copy
+      when Type then value.dup_for_options
+      when String then value.frozen? ? value : value.dup # #dup keeps subclass and encoding
+      else value
+      end
+    end
+
+    def self.option_hash_key(key, hash)
+      return key unless key.is_a?(String) && !key.frozen? && !hash.compare_by_identity?
+
+      key.dup.freeze
+    end
+    private_class_method :option_hash_key
+
+    # Bounded, human-oriented #inspect listing the non-nil instance variables
+    # in definition order:
+    #
+    #   #<ClaudeAgentSDK::ResultMessage subtype="success" num_turns=3 ...>
+    #
+    # Messages carry whole transcripts, tool payloads and usage maps, so the
+    # output is bounded rather than faithful: long Strings are truncated,
+    # long Arrays/Hashes abbreviated, and nesting past INSPECT_MAX_DEPTH (or
+    # a reference cycle) collapses to a placeholder. Other objects keep their
+    # own #inspect (truncated) unless they only have Kernel#inspect, which
+    # dumps every ivar recursively — those (SDK MCP server instances, store
+    # adapters, observers) show as `#<ClassName>`. For display only: nothing
+    # sent to the CLI goes through #inspect or #to_s (wire output uses #to_h).
+    def inspect
+      inspect_with(0, {}.compare_by_identity)
+    end
+
+    # Object#to_s ignores instance variables, so `puts message` would print
+    # only a class name and an address. Types with a natural textual form
+    # (UserMessage, AssistantMessage, TextBlock, ResultMessage, SystemMessage)
+    # override this.
+    def to_s
+      inspect
+    end
+
+    # Declares attributes that carry credentials (env vars, auth headers).
+    # Objects get logged, so #inspect shows them filtered; #to_h and
+    # everything sent to the CLI are unaffected. Inherited by subclasses.
+    def self.inspect_filtered(*names)
+      @inspect_filtered_attributes = (inspect_filtered_attributes + names.map(&:to_s)).uniq.freeze
+    end
+
+    def self.inspect_filtered_attributes
+      @inspect_filtered_attributes || (superclass <= Type ? superclass.inspect_filtered_attributes : [].freeze)
+    end
+
+    INSPECT_MAX_STRING = 80
+    INSPECT_MAX_ITEMS = 5
+    INSPECT_MAX_DEPTH = 2
+    private_constant :INSPECT_MAX_STRING, :INSPECT_MAX_ITEMS, :INSPECT_MAX_DEPTH
+
+    protected
+
+    # `seen` holds the Types/containers on the current rendering path (not
+    # every one rendered so far), so a shared-but-acyclic value still renders
+    # in full wherever it appears.
+    def inspect_with(depth, seen)
+      return "#<#{inspect_class_name} …>" if depth > INSPECT_MAX_DEPTH || seen.key?(self)
+
+      seen[self] = true
+      begin
+        attributes = inspect_attributes.map do |name, value|
+          " #{name}=#{inspect_bounded(value, depth + 1, seen)}"
+        end
+        "#<#{inspect_class_name}#{attributes.join}>"
+      ensure
+        seen.delete(self)
+      end
+    end
+
     private
 
+    # [name, value] pairs rendered by #inspect. Subclasses override to hide
+    # redundant state or redact secrets — never by mutating the object.
+    def inspect_attributes
+      filtered = self.class.inspect_filtered_attributes
+      instance_variables.filter_map do |ivar|
+        value = instance_variable_get(ivar)
+        next if value.nil?
+
+        name = ivar.to_s.delete_prefix('@')
+        [name, filtered.include?(name) ? inspect_filter(value) : value]
+      end
+    end
+
+    # A credential-bearing Hash keeps its keys (useful when debugging which
+    # variables are set) with every value replaced; anything else is replaced
+    # outright. Builds a new Hash; the object itself is never touched.
+    def inspect_filter(value)
+      value.respond_to?(:each_key) ? value.each_key.to_h { |key| [key, '[FILTERED]'] } : '[FILTERED]'
+    end
+
+    def inspect_class_name
+      self.class.name || self.class.inspect
+    end
+
+    def inspect_bounded(value, depth, seen)
+      case value
+      when Type then value.inspect_with(depth, seen)
+      when String then inspect_truncated(value)
+      when Array then inspect_container(value, '[', ']', depth, seen) { |item| inspect_bounded(item, depth + 1, seen) }
+      when Hash
+        inspect_container(value, '{', '}', depth, seen) do |key, item|
+          "#{inspect_hash_key(key, depth + 1, seen)}#{inspect_bounded(item, depth + 1, seen)}"
+        end
+      when Proc, Method, UnboundMethod then inspect_callable(value)
+      else inspect_leaf(value)
+      end
+    end
+
+    def inspect_container(value, open, close, depth, seen, &render)
+      return "#{open}#{close}" if value.empty?
+      return "#{open}…(#{value.size})#{close}" if depth > INSPECT_MAX_DEPTH || seen.key?(value)
+
+      seen[value] = true
+      begin
+        parts = value.first(INSPECT_MAX_ITEMS).map(&render)
+        parts << "…(+#{value.size - INSPECT_MAX_ITEMS} more)" if value.size > INSPECT_MAX_ITEMS
+        "#{open}#{parts.join(', ')}#{close}"
+      ensure
+        seen.delete(value)
+      end
+    end
+
+    # Rendered by hand rather than via Hash#inspect, whose format differs
+    # between Ruby 3.3 (`{:a=>1}`) and 3.4 (`{a: 1}`).
+    def inspect_hash_key(key, depth, seen)
+      return "#{key.name}: " if key.is_a?(Symbol) && key.inspect.match?(/\A:\w+[?!]?\z/)
+
+      "#{inspect_bounded(key, depth, seen)} => "
+    end
+
+    def inspect_truncated(string)
+      return string.inspect if string.length <= INSPECT_MAX_STRING
+
+      "#{string[0, INSPECT_MAX_STRING].inspect}…(+#{string.length - INSPECT_MAX_STRING} chars)"
+    end
+
+    # Callbacks (can_use_tool, hooks, callback_wrapper, ...) are user-supplied:
+    # render them from source_location rather than their own #inspect, which
+    # a subclass may override (and raise from) and which embeds an absolute
+    # path — `#<Proc(lambda) permissions.rb:17>`, `#<Method Policy#call>`.
+    def inspect_callable(value)
+      label = if value.is_a?(Proc)
+                value.lambda? ? 'Proc(lambda)' : 'Proc'
+              else
+                "#{value.class.name} #{value.owner.name || value.owner.inspect}##{value.name}"
+              end
+      file, line = value.source_location
+      rendered = file ? "#<#{label} #{File.basename(file)}:#{line}>" : "#<#{label}>"
+      inspect_truncated_text(rendered)
+    rescue StandardError
+      inspect_leaf(value)
+    end
+
+    def inspect_truncated_text(rendered)
+      return rendered if rendered.length <= INSPECT_MAX_STRING
+
+      "#{rendered[0, INSPECT_MAX_STRING]}…(+#{rendered.length - INSPECT_MAX_STRING} chars)"
+    end
+
+    # Printing must never raise (it runs inside loggers and `puts`), so an
+    # object whose #inspect raises, or a BasicObject without one, falls back
+    # to a placeholder.
+    def inspect_leaf(value)
+      return "#<#{value.class}>" if kernel_inspect_only?(value)
+
+      inspect_truncated_text(value.inspect)
+    rescue StandardError
+      begin
+        "#<#{value.class}>"
+      rescue StandardError
+        '#<?>'
+      end
+    end
+
+    def kernel_inspect_only?(value)
+      Kernel.instance_method(:method).bind_call(value, :inspect).owner == Kernel
+    rescue TypeError # not a Kernel object: BasicObject, Delegator
+      false
+    end
+
     # Allow camelCase attribute access
     def method_missing(method_name, ...)
       normalized = normalize_name(method_name)
@@ -163,6 +400,10 @@ module ClaudeAgentSDK
   # Text content block
   class TextBlock < Type
     attr_accessor :text
+
+    def to_s
+      text.to_s
+    end
   end
 
   # Thinking content block
@@ -308,6 +549,22 @@ module ClaudeAgentSDK
       super
       @data ||= attributes if attributes.is_a?(Hash)
     end
+
+    def to_s
+      subtype.nil? ? '[system]' : "[system: #{subtype}]"
+    end
+
+    private
+
+    # A typed subclass (InitMessage, TaskStartedMessage, ...) already exposes
+    # the fields of its raw frame as attributes; repeating @data would double
+    # the output. A bare SystemMessage (unrecognized subtype) keeps it, since
+    # @data is the only place its payload lives.
+    def inspect_attributes
+      return super if instance_of?(SystemMessage)
+
+      super.reject { |pair| pair.first == 'data' }
+    end
   end
 
   # Init system message (emitted at session start and after /clear)
@@ -688,6 +945,19 @@ module ClaudeAgentSDK
     # @return [Hash{Symbol => Object}, nil]
     # @see UserMessage#origin
     attr_accessor :origin
+
+    # One human-readable line, e.g. `[result: success, 3 turns, 4.2s, $0.0120]`
+    # (parts the CLI did not report are left out). An error result appends its
+    # `errors`. Use #inspect for every field.
+    def to_s
+      parts = [subtype].compact
+      parts << "#{num_turns} #{num_turns == 1 ? 'turn' : 'turns'}" unless num_turns.nil?
+      parts << format('%.1fs', duration_ms / 1000.0) if duration_ms.is_a?(Numeric)
+      parts << format('$%.4f', total_cost_usd) if total_cost_usd.is_a?(Numeric)
+      line = parts.empty? ? '[result]' : "[result: #{parts.join(', ')}]"
+      line += " - #{Array(errors).join('; ')}" if is_error && !Array(errors).empty?
+      line
+    end
   end
 
   # Stream event for partial message updates
@@ -785,13 +1055,16 @@ module ClaudeAgentSDK
   # `display` controls how thinking content appears in responses. Valid values
   # are `"summarized"` (plaintext summary) and `"omitted"` (empty thinking
   # field, signature only). Defaults are model-dependent: Opus 4.6/Sonnet 4.6
-  # default to `"summarized"`; Opus 4.7 and Mythos Preview default to
-  # `"omitted"`. Pass `display: "summarized"` explicitly on Opus 4.7 to get
+  # default to `"summarized"`; Opus 4.7 and every later model default to
+  # `"omitted"`. Pass `display: "summarized"` explicitly on those to get
   # visible thinking text. Not supported with `ThinkingConfigDisabled`.
   THINKING_DISPLAY_VALUES = %w[summarized omitted].freeze
 
-  # Adaptive thinking: uses a default budget of 32000 tokens
+  # Adaptive thinking: the model decides when and how much to think
+  # (sent as `--thinking adaptive`, no budget); control depth with `effort`.
   class ThinkingConfigAdaptive < Type
+    include Type::OptionValue
+
     attr_reader :type, :display
 
     def initialize(attributes = {})
@@ -816,6 +1089,8 @@ module ClaudeAgentSDK
 
   # Enabled thinking: uses a user-specified budget
   class ThinkingConfigEnabled < Type
+    include Type::OptionValue
+
     attr_accessor :budget_tokens
     attr_reader :type, :display
 
@@ -841,6 +1116,8 @@ module ClaudeAgentSDK
 
   # Disabled thinking: sets thinking tokens to 0
   class ThinkingConfigDisabled < Type
+    include Type::OptionValue
+
     attr_reader :type
 
     def initialize(attributes = {})
@@ -851,6 +1128,8 @@ module ClaudeAgentSDK
 
   # Agent definition configuration
   class AgentDefinition < Type
+    include Type::OptionValue
+
     attr_accessor :description, :prompt, :tools, :disallowed_tools, :model, :skills, :memory, :mcp_servers,
                   :initial_prompt, :max_turns, :background, :effort, :permission_mode
   end
@@ -942,6 +1221,8 @@ module ClaudeAgentSDK
 
   # Hook matcher configuration
   class HookMatcher < Type
+    include Type::OptionValue
+
     attr_accessor :matcher, :hooks, :timeout
 
     def initialize(attributes = {})
@@ -1640,9 +1921,13 @@ module ClaudeAgentSDK
 
   # MCP Server configurations
   class McpStdioServerConfig < Type
+    include Type::OptionValue
+
     attr_accessor :command, :args, :env
     attr_reader :type
 
+    inspect_filtered :env
+
     def initialize(attributes = {})
       super
       @type = 'stdio'
@@ -1657,9 +1942,13 @@ module ClaudeAgentSDK
   end
 
   class McpSSEServerConfig < Type
+    include Type::OptionValue
+
     attr_accessor :url, :headers
     attr_reader :type
 
+    inspect_filtered :headers
+
     def initialize(attributes = {})
       super
       @type = 'sse'
@@ -1673,9 +1962,13 @@ module ClaudeAgentSDK
   end
 
   class McpHttpServerConfig < Type
+    include Type::OptionValue
+
     attr_accessor :url, :headers
     attr_reader :type
 
+    inspect_filtered :headers
+
     def initialize(attributes = {})
       super
       @type = 'http'
@@ -1689,6 +1982,8 @@ module ClaudeAgentSDK
   end
 
   class McpSdkServerConfig < Type
+    include Type::OptionValue
+
     attr_accessor :name, :instance
     attr_reader :type
 
@@ -1704,6 +1999,8 @@ module ClaudeAgentSDK
 
   # SDK Plugin configuration
   class SdkPluginConfig < Type
+    include Type::OptionValue
+
     attr_accessor :path
     attr_reader :type
 
@@ -1719,6 +2016,8 @@ module ClaudeAgentSDK
 
   # Sandbox network configuration
   class SandboxNetworkConfig < Type
+    include Type::OptionValue
+
     attr_accessor :allowed_domains, :denied_domains, :allow_managed_domains_only,
                   :allow_unix_sockets, :allow_all_unix_sockets, :allow_local_binding,
                   :allow_mach_lookup, :http_proxy_port, :socks_proxy_port
@@ -1740,6 +2039,8 @@ module ClaudeAgentSDK
 
   # Sandbox filesystem configuration
   class SandboxFilesystemConfig < Type
+    include Type::OptionValue
+
     attr_accessor :allow_write, :deny_write, :deny_read, :allow_read, :allow_managed_read_paths_only
 
     def to_h
@@ -1755,6 +2056,8 @@ module ClaudeAgentSDK
 
   # Sandbox settings for isolated command execution
   class SandboxSettings < Type
+    include Type::OptionValue
+
     attr_accessor :enabled, :fail_if_unavailable, :auto_allow_bash_if_sandboxed,
                   :excluded_commands, :allow_unsandboxed_commands, :network, :filesystem,
                   :ignore_violations, :enable_weaker_nested_sandbox,
@@ -1786,6 +2089,8 @@ module ClaudeAgentSDK
   # When set, the model is made aware of its remaining token budget so it can
   # pace tool use and wrap up before the limit.
   class TaskBudget < Type
+    include Type::OptionValue
+
     attr_accessor :total
 
     def to_h
@@ -1795,6 +2100,8 @@ module ClaudeAgentSDK
 
   # System prompt file configuration — loads system prompt from a file path
   class SystemPromptFile < Type
+    include Type::OptionValue
+
     attr_accessor :path
     attr_reader :type
 
@@ -1822,6 +2129,8 @@ module ClaudeAgentSDK
   # before 2.1.265 a session with an +append+ prompt recorded it only when
   # +snapshot+ was true. Older CLIs silently ignore it.
   class SystemPromptPreset < Type
+    include Type::OptionValue
+
     attr_reader :type
     attr_accessor :preset, :append, :exclude_dynamic_sections, :snapshot
 
@@ -1844,6 +2153,8 @@ module ClaudeAgentSDK
   # (+--system-prompt <prompt>+); the object form exists so +snapshot+ can be
   # set alongside it (see SystemPromptPreset#snapshot for its semantics).
   class SystemPromptCustom < Type
+    include Type::OptionValue
+
     attr_reader :type
     attr_accessor :prompt, :snapshot
 
@@ -1861,6 +2172,8 @@ module ClaudeAgentSDK
 
   # Tools preset configuration
   class ToolsPreset < Type
+    include Type::OptionValue
+
     attr_reader :type
     attr_accessor :preset
 
@@ -1876,6 +2189,9 @@ module ClaudeAgentSDK
 
   # Claude Agent Options for configuring queries
   class ClaudeAgentOptions < Type
+    # `env` routinely carries credentials (ANTHROPIC_API_KEY, ...).
+    inspect_filtered :env
+
     attr_accessor :allowed_tools, :system_prompt, :mcp_servers, :permission_mode,
                   :resume, :resume_session_at, :session_id, :max_turns, :disallowed_tools,
                   :model, :permission_prompt_tool_name, :cwd, :cli_path, :settings,
@@ -1955,14 +2271,16 @@ module ClaudeAgentSDK
 
     def dup_with(**changes)
       new_options = self.dup
-      # A shallow #dup shares nested containers, so mutating a derived copy
-      # (e.g. `variant.allowed_tools << 'Bash'`) would bleed into the base and
-      # every sibling — including the security-relevant allow/deny lists.
-      # Deep-dup Hash/Array containers only; non-container values (procs,
-      # SDK MCP server instances, store adapters) must keep their identity.
+      # A shallow #dup shares nested containers and typed option values, so
+      # mutating a derived copy (e.g. `variant.allowed_tools << 'Bash'` or
+      # `variant.sandbox.enabled = false`) would bleed into the base and every
+      # sibling — including the security-relevant allow/deny lists and sandbox
+      # rules. Deep-dup Hash/Array containers and option value types (Type#
+      # dup_for_options, including those nested inside containers such as
+      # agents[:x]); every other leaf (procs, SDK MCP server instances, store
+      # adapters) keeps its identity.
       new_options.instance_variables.each do |ivar|
-        value = new_options.instance_variable_get(ivar)
-        new_options.instance_variable_set(ivar, deep_dup_containers(value)) if value.is_a?(Hash) || value.is_a?(Array)
+        new_options.instance_variable_set(ivar, Type.deep_dup_for_options(new_options.instance_variable_get(ivar)))
       end
       changes.each { |key, value| new_options[key] = value }
       new_options
@@ -2120,13 +2438,17 @@ module ClaudeAgentSDK
     # A callable receiving a zero-arg invocation; it MUST call it and
     # return its value:
     #
-    #   callback_wrapper: ->(invocation) { Rails.application.executor.wrap { invocation.call } }
+    #   callback_wrapper: ->(invocation) { MyApm.trace('agent.callback') { invocation.call } }
     #
     # The wrapper runs on the same execution context as the callback —
-    # inside the worker thread in :thread mode (so executor.wrap checks AR
-    # connections back in when the callback ends), in place on the reactor
+    # inside the worker thread in :thread mode, in place on the reactor
     # fiber in :inline mode. Exceptions propagate through it unchanged; it
     # must not swallow them. Default nil (no wrapping).
+    #
+    # Rails apps: use ClaudeAgentSDK::Railtie.callback_wrapper, which runs
+    # callbacks in the Rails executor (AR connections check back in when the
+    # callback ends). A bare `Rails.application.executor.wrap` deadlocks
+    # under development code reloading in :thread mode.
     def callback_wrapper=(value)
       raise ArgumentError, "callback_wrapper must be a callable or nil (got #{value.inspect})" unless value.nil? || value.respond_to?(:call)
 
@@ -2160,12 +2482,20 @@ module ClaudeAgentSDK
       defaults = ClaudeAgentSDK.default_options
       return attributes unless defaults.any?
 
-      # Start from configured defaults. Container values are recursively
-      # duped so per-instance mutation (options.allowed_tools << 'Bash')
-      # can never corrupt the global defaults; non-container leaves
-      # (Strings, Procs, SdkMcpServer instances) intentionally keep identity.
+      # Start from configured defaults. Container values, typed option
+      # values (SandboxSettings, SystemPromptPreset, AgentDefinition, ...)
+      # and mutable Strings are recursively copied (Type.deep_dup_for_options)
+      # so per-instance mutation (options.allowed_tools << 'Bash',
+      # options.sandbox.enabled = false) can never corrupt the global
+      # defaults or reach another session; other leaves (frozen Strings,
+      # Procs, SdkMcpServer instances, store adapters) intentionally keep
+      # identity. The stored defaults are a frozen snapshot
+      # (Configuration#default_options=), and the copy is what makes each
+      # session's containers and values mutable again — its Strings stay the
+      # snapshot's frozen ones, so `options.model << 'x'` fails loudly rather
+      # than reaching other sessions; reassign instead.
       result = {}
-      defaults.each { |key, value| result[option_key(key)] = deep_dup_containers(value) }
+      defaults.each { |key, value| result[option_key(key)] = Type.deep_dup_for_options(value) }
       attributes.each do |key, value|
         key = option_key(key)
         default_val = result[key]
@@ -2187,26 +2517,6 @@ module ClaudeAgentSDK
       normalized = normalize_name(name)
       respond_to?(:"#{normalized}=") ? normalized.to_sym : name
     end
-
-    # Recurse ONLY into Hash/Array; leaves keep object identity (observer
-    # factories, callbacks, SDK MCP server instances must not be duped).
-    # Rebuild via dup.clear (never Hash#to_h / Array#map) to preserve
-    # container SUBCLASSES: to_h flattens e.g. Rails'
-    # HashWithIndifferentAccess into a plain Hash, silently breaking symbol
-    # lookups on the copy (config[:type] == 'sdk' → nil).
-    def deep_dup_containers(value)
-      case value
-      when Hash
-        copy = value.dup.clear
-        value.each { |k, v| copy[k] = deep_dup_containers(v) }
-        copy
-      when Array
-        copy = value.dup.clear
-        value.each { |v| copy << deep_dup_containers(v) }
-        copy
-      else value
-      end
-    end
   end
 
   # SDK MCP Tool definition

data/lib/claude_agent_sdk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClaudeAgentSDK
-  VERSION = '0.33.1'
+  VERSION = '0.35.0'
 end