claude-agent-sdk 0.16.3 → 0.16.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2c37eb821ab8e4fe91cc69b4d0d683b364617b321d74e642f330c7c560850dd
-  data.tar.gz: 62c00c3973e9bfabda1ebf5f95b4ce4ca79bd6dc4c36e8f0bcf0038ede7c588f
+  metadata.gz: f2fe7bf072c2a3b8448b23bf82c95e7f0a896b347bd43039145458b72e21f301
+  data.tar.gz: 1a58f5e31ef7a872aeaf75a3aada1c8e60a264d9ad5e93615b62c42d96179d99
 SHA512:
-  metadata.gz: af171dc45b39c86eee1dacd829f062e230b3369225ef394df0df43b9a05d2ecec087a6566dd00cb7a4a01d1af1f3a5677f08f9ae04ecaa9c46d9490c75acaf46
-  data.tar.gz: f96ce5a7ee822ef161a541e29fa6677fb28c77c5e316965aa15477a782e087a60b15ea706665488e09f102356f91fa43491be82f526910c2d4afa4f08b3256fd
+  metadata.gz: e76c6cfe62c7b01320edf7a3d659e44fce46921f764132da7ab0f8223bb1d5a4a2b4457f5406b7bc68a1dde91f7af29fd0d4ff565334ed2cae8ad120339bac83
+  data.tar.gz: 9e1920a7254f5e27dab4ae88cc5ba6d8ac7430a7ec32e8c9157d80c792a65bee8c258096f52ac20ce69d5bedfd1a629a2c8ef852341c9b03e4aaa631c491d912

data/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.16.5] - 2026-04-24
+
+### Added
+- `display:` option on `ThinkingConfigAdaptive` and `ThinkingConfigEnabled`, forwarded to the CLI as `--thinking-display <summarized|omitted>`. Opus 4.7 defaults thinking display to `"omitted"` (empty `thinking` field, signature only), so pass `ThinkingConfigAdaptive.new(display: "summarized")` to receive plaintext summarized thinking text. Invalid values raise `ArgumentError` at construction. See [adaptive thinking docs](https://docs.claude.com/en/docs/build-with-claude/adaptive-thinking).
+
+### Internal
+- Extracted private `writeln`/`write` helpers in `Client` and `Query` to consolidate the `@transport.write(json + "\n")` pattern across five call sites. Pure refactor; same bytes on the wire.
+
+## [0.16.4] - 2026-04-23
+
+### Fixed
+- `Client#receive_response` no longer hangs in interactive Client mode. The 0.16.1 flag-based fix relied on the loop draining via the transport's `:end` sentinel, which only arrives when the CLI subprocess exits — true for one-shot `query()` but never for a `Client` whose CLI stays alive between turns. `receive_response` now drives `QueryHandler#receive_messages` directly so its `break` runs on the same fiber as the underlying `Async::Queue#dequeue` loop and unwinds it. The 0.16.1 regression spec passed only because its stub iterated a finite array; replaced with a real `Async::Queue` driven from a sibling task so a hang now fails the test.
+
+### Internal
+- `FiberBoundary` doc-comment now warns that `break`/`return`/`next` cannot cross the thread hop, so SDK-internal loops yielding user callbacks must keep loop control on the outer side of the boundary.
+
 ## [0.16.3] - 2026-04-23
 
 ### Changed

data/README.md

@@ -108,7 +108,7 @@ Add this line to your application's Gemfile:
 gem 'claude-agent-sdk', github: 'ya-luotao/claude-agent-sdk-ruby'
 
 # Or use a stable version from RubyGems
-gem 'claude-agent-sdk', '~> 0.16.3'
+gem 'claude-agent-sdk', '~> 0.16.5'
 ```
 
 And then execute:

data/lib/claude_agent_sdk/command_builder.rb

@@ -158,8 +158,10 @@ module ClaudeAgentSDK
         case @options.thinking
         when ThinkingConfigAdaptive
           cmd.push("--thinking", "adaptive")
+          append_thinking_display(cmd, @options.thinking.display)
         when ThinkingConfigEnabled
           cmd.push("--max-thinking-tokens", @options.thinking.budget_tokens.to_s)
+          append_thinking_display(cmd, @options.thinking.display)
         when ThinkingConfigDisabled
           cmd.push("--thinking", "disabled")
         end
@@ -168,6 +170,15 @@ module ClaudeAgentSDK
       end
     end
 
+    # `--thinking-display` toggles between `"summarized"` (visible thinking
+    # text) and `"omitted"` (empty thinking, signature only). Opus 4.7 defaults
+    # to `"omitted"`, so pass `display: "summarized"` to see reasoning.
+    def append_thinking_display(cmd, display)
+      return if display.nil?
+
+      cmd.push("--thinking-display", display.to_s)
+    end
+
     # The set of supported levels is model-dependent; the CLI falls back to
     # the highest supported level at or below the one requested
     # (e.g. `xhigh` → `high` on Opus 4.6).

data/lib/claude_agent_sdk/fiber_boundary.rb

@@ -23,6 +23,10 @@ module ClaudeAgentSDK
   # user's app makes.
   #
   # No-op when no scheduler is active, so it's cheap to use unconditionally.
+  #
+  # The thread hop severs `break`/`return`/`next` from the surrounding method,
+  # so SDK loops yielding user callbacks must keep loop control outside the
+  # invoked block (see `Client#receive_response`).
   module FiberBoundary
     module_function
 

data/lib/claude_agent_sdk/query.rb

@@ -261,7 +261,7 @@ module ClaudeAgentSDK
           response: response_data
         }
       }
-      @transport.write(JSON.generate(success_response) + "\n")
+      writeln(JSON.generate(success_response))
     rescue Async::Stop
       # Cancellation requested; respond with an error so the CLI can unblock.
       cancelled_response = {
@@ -273,7 +273,7 @@ module ClaudeAgentSDK
           error: 'Cancelled'
         }
       }
-      @transport.write(JSON.generate(cancelled_response) + "\n")
+      writeln(JSON.generate(cancelled_response))
     rescue StandardError => e
       # Send error response
       error_response = {
@@ -285,7 +285,7 @@ module ClaudeAgentSDK
           error: e.message
         }
       }
-      @transport.write(JSON.generate(error_response) + "\n")
+      writeln(JSON.generate(error_response))
     end
 
     def handle_permission_request(request_data)
@@ -642,7 +642,7 @@ module ClaudeAgentSDK
         request: request
       }
 
-      @transport.write(JSON.generate(control_request) + "\n")
+      writeln(JSON.generate(control_request))
 
       # Wait for response with timeout (default 1200s to handle slow CLI startup)
       Async do |task|
@@ -913,13 +913,8 @@ module ClaudeAgentSDK
     def stream_input(stream)
       stream.each do |message|
         break if @closed
-        serialized = if message.is_a?(Hash)
-                       JSON.generate(message) + "\n"
-                     else
-                       message.to_s
-                     end
-        serialized += "\n" unless serialized.end_with?("\n")
-        @transport.write(serialized)
+        serialized = message.is_a?(Hash) ? JSON.generate(message) : message.to_s
+        writeln(serialized)
       end
     rescue StandardError => e
       # Log error but don't raise
@@ -928,6 +923,14 @@ module ClaudeAgentSDK
       wait_for_result_and_end_input
     end
 
+    def writeln(string)
+      write string.end_with?("\n") ? string : "#{string}\n"
+    end
+
+    def write(string)
+      @transport.write(string)
+    end
+
     # Receive SDK messages (not control messages)
     def receive_messages(&block)
       return enum_for(:receive_messages) unless block

data/lib/claude_agent_sdk/types.rb

@@ -599,23 +599,53 @@ module ClaudeAgentSDK
   end
 
   # Thinking configuration types
+  #
+  # `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
+  # visible thinking text. Not supported with `ThinkingConfigDisabled`.
+  THINKING_DISPLAY_VALUES = %w[summarized omitted].freeze
 
   # Adaptive thinking: uses a default budget of 32000 tokens
   class ThinkingConfigAdaptive
-    attr_accessor :type
+    attr_accessor :type, :display
 
-    def initialize
+    def initialize(display: nil)
       @type = 'adaptive'
+      @display = validate_display(display)
+    end
+
+    private
+
+    def validate_display(value)
+      return nil if value.nil?
+      return value if THINKING_DISPLAY_VALUES.include?(value.to_s)
+
+      raise ArgumentError,
+            "invalid thinking display #{value.inspect}; expected one of #{THINKING_DISPLAY_VALUES.inspect}"
     end
   end
 
   # Enabled thinking: uses a user-specified budget
   class ThinkingConfigEnabled
-    attr_accessor :type, :budget_tokens
+    attr_accessor :type, :budget_tokens, :display
 
-    def initialize(budget_tokens:)
+    def initialize(budget_tokens:, display: nil)
       @type = 'enabled'
       @budget_tokens = budget_tokens
+      @display = validate_display(display)
+    end
+
+    private
+
+    def validate_display(value)
+      return nil if value.nil?
+      return value if THINKING_DISPLAY_VALUES.include?(value.to_s)
+
+      raise ArgumentError,
+            "invalid thinking display #{value.inspect}; expected one of #{THINKING_DISPLAY_VALUES.inspect}"
     end
   end
 

data/lib/claude_agent_sdk/version.rb

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

data/lib/claude_agent_sdk.rb

@@ -374,9 +374,7 @@ module ClaudeAgentSDK
         query(prompt)
       else
         prompt.each do |message_json|
-          message_json = message_json.to_s
-          message_json += "\n" unless message_json.end_with?("\n")
-          @transport.write(message_json)
+          writeln(message_json.to_s)
         end
       end
     end
@@ -394,7 +392,7 @@ module ClaudeAgentSDK
         parent_tool_use_id: nil,
         session_id: session_id
       }
-      @transport.write(JSON.generate(message) + "\n")
+      writeln(JSON.generate(message))
     end
 
     # Receive all messages from Claude
@@ -418,15 +416,18 @@ module ClaudeAgentSDK
     def receive_response(&block)
       return enum_for(:receive_response) unless block
 
-      # Flag-based rather than `break`: `receive_messages` hops this
-      # block onto a plain thread via `FiberBoundary.invoke`, which
-      # severs break's unwind target.
-      result_seen = false
-      receive_messages do |message|
-        next if result_seen
+      raise CLIConnectionError, 'Not connected. Call connect() first' unless @connected
+
+      # Keep `break` on the same fiber as the underlying dequeue. Going through
+      # Client#receive_messages would put the FiberBoundary hop above the break
+      # and hang in Client mode — the CLI keeps stdin open and never emits `:end`.
+      @query_handler.receive_messages do |data|
+        message = MessageParser.parse(data)
+        next unless message
 
-        block.call(message)
-        result_seen = true if message.is_a?(ResultMessage)
+        ClaudeAgentSDK.notify_observers(@resolved_observers, :on_message, message)
+        FiberBoundary.invoke { block.call(message) }
+        break if message.is_a?(ResultMessage)
       end
     end
 
@@ -554,5 +555,13 @@ module ClaudeAgentSDK
       end
       nil
     end
+
+    def writeln(string)
+      write string.end_with?("\n") ? string : "#{string}\n"
+    end
+
+    def write(string)
+      @transport.write(string)
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: claude-agent-sdk
 version: !ruby/object:Gem::Version
-  version: 0.16.3
+  version: 0.16.5
 platform: ruby
 authors:
 - Community Contributors
 bindir: bin
 cert_chain: []
-date: 2026-04-23 00:00:00.000000000 Z
+date: 2026-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async