ConverseStream never delivers ContentBlockStopEvent for tool_use content blocks — stream hangs until timeout. Help needed.

[ady88]

Describe the bug

Summary

When calling BedrockRuntimeAsyncClient.converseStream() with a tool configuration, the SDK never delivers a ContentBlockStopEvent for tool_use content blocks. After the last ContentBlockDeltaEvent for the tool input, the stream goes completely silent — MessageStopEvent also never arrives. The
connection holds open until the HTTP read/SSE timeout fires.

Text content blocks (type=text) receive their ContentBlockStopEvent correctly. Only tool_use blocks are affected.

SDK version

software.amazon.awssdk:bedrockruntime:2.47.4

Region / Model

• Region: eu-central-1
• Model: eu.anthropic.claude-sonnet-4-6

Observed event sequence

  MessageStartEvent
  ContentBlockDeltaEvent   (text, index 0)   ← multiple tokens
  ContentBlockDeltaEvent   (text, index 0)
  ContentBlockStopEvent    (index 0)          ← text block closes correctly ✓
  ContentBlockStartEvent   (index 1, tool_use)
  ContentBlockDeltaEvent   (index 1, tool_use, partial_json="")
                                              ← SILENCE — no ContentBlockStopEvent
                                              ← no MessageStopEvent
                                              ← stream holds open until timeout

Expected event sequence

  MessageStartEvent
  ContentBlockDeltaEvent   (text, index 0)
  ...
  ContentBlockStopEvent    (index 0)
  ContentBlockStartEvent   (index 1, tool_use)
  ContentBlockDeltaEvent   (index 1, tool_use)
  ContentBlockStopEvent    (index 1)          ← never arrives
  MessageStopEvent                            ← never arrives
  ConverseStreamMetadataEvent

Minimal reproduction

var request = ConverseStreamRequest.builder()
     .modelId("eu.anthropic.claude-sonnet-4-6")
     .messages(Message.builder()
         .role(ConversationRole.USER)
         .content(ContentBlock.builder()
             .text("Please analyse my company benefit data and give me a short summary.")
             .build())
         .build())
     .toolConfig(ToolConfiguration.builder()
         .tools(Tool.builder()
             .toolSpec(ts -> ts
                 .name("CompanyBenefitData")
                 .description("Return benefit health data for a company.")
                 .inputSchema(is -> is.json(Document.fromMap(Map.of(
                     "type", Document.fromString("object"),
                     "properties", Document.fromMap(Map.of()),
                     "required", Document.fromList(List.of()))))))
             .build())
         .build())
     .build();

 asyncClient.converseStream(request, ConverseStreamResponseHandler.builder()
     .subscriber(event -> System.out.println("Event: " + event.getClass().getSimpleName()))
     .onComplete(() -> System.out.println("Complete"))
     .onError(t -> System.out.println("Error: " + t))
     .build())
     .get(90, TimeUnit.SECONDS);
 // Never prints "Complete" or "Error" within 90s on a tool_use turn
 // ContentBlockStopEvent for index 1 never appears in subscriber

Additional observations

• The ConverseStream raw HTTP/2 connection does receive DATA frames from Bedrock after the last tool_use_delta (observed via Netty's DefaultHttp2ConnectionDecoder logging). Those frames are not translated into ContentBlockStopEvent by the SDK.
• The synchronous converse() API correctly returns the complete response including tool_use blocks — only the streaming path is affected.
• This appears to be an SDK-level translation issue: the raw Bedrock response contains the stop events but they are not surfaced to the ConverseStreamResponseHandler subscriber.

---

Regression Issue

• Select this option if this issue appears to be a regression.

Expected Behavior

MessageStartEvent
ContentBlockDeltaEvent (text, index 0)
...
ContentBlockStopEvent (index 0)
ContentBlockStartEvent (index 1, tool_use)
ContentBlockDeltaEvent (index 1, tool_use)
ContentBlockStopEvent (index 1) ← never arrives
MessageStopEvent ← never arrives
ConverseStreamMetadataEvent

Current Behavior

After the last ContentBlockDeltaEvent for the tool_use block, the stream goes completely silent. ContentBlockStopEvent for index=1 never arrives. MessageStopEvent never arrives. onComplete is never called. The CompletableFuture returned by converseStream() hangs until the caller's timeout fires.

Observed SDK event log (INFO-level instrumentation on the ConverseStreamResponseHandler subscriber):

[bedrock-stream] event received: DefaultMessageStart
[bedrock-stream] event received: DefaultContentBlockDelta
[bedrock-stream] event received: DefaultContentBlockDelta
[bedrock-stream] event received: DefaultContentBlockDelta
[bedrock-stream] event received: DefaultContentBlockDelta
[bedrock-stream] event received: DefaultContentBlockDelta
[bedrock-stream] event received: DefaultContentBlockStop ← index 0 (text), correct
[bedrock-stream] ContentBlockStopEvent index=0
[bedrock-stream] event received: DefaultContentBlockStart
[bedrock-stream] ContentBlockStartEvent index=1 type=tool_use
[bedrock-stream] event received: DefaultContentBlockDelta ← tool input delta
← SILENCE from this point
← no ContentBlockStopEvent
← no MessageStopEvent
← onComplete never called
← onError never called

After a 60 s wall-clock wait:
java.util.concurrent.TimeoutException
at java.base/java.util.concurrent.CompletableFuture.timedGet(CompletableFuture.java:1957)
at java.base/java.util.concurrent.CompletableFuture.get(CompletableFuture.java:2031)
at ConverseStreamToolUseBug.main(ConverseStreamToolUseBug.java:XX)

Reproduction Steps

---

  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.TimeUnit;

  import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
  import software.amazon.awssdk.core.document.Document;
  import software.amazon.awssdk.regions.Region;
  import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
  import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
  import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
  import software.amazon.awssdk.services.bedrockruntime.model.ConverseStreamRequest;
  import software.amazon.awssdk.services.bedrockruntime.model.ConverseStreamResponseHandler;
  import software.amazon.awssdk.services.bedrockruntime.model.Message;
  import software.amazon.awssdk.services.bedrockruntime.model.Tool;
  import software.amazon.awssdk.services.bedrockruntime.model.ToolConfiguration;

  /**
   * Reproduces: ContentBlockStopEvent never delivered for tool_use blocks in ConverseStream.
   *
   * Dependencies (Gradle):
   *   implementation platform("software.amazon.awssdk:bom:2.47.4")
   *   implementation "software.amazon.awssdk:bedrockruntime"
   *   implementation "software.amazon.awssdk:netty-nio-client"
   *
   * Prerequisites:
   *   AWS credentials available via the default credentials chain
   *   (env vars, ~/.aws/credentials, or IAM role).
   *
   * Expected: subscriber prints ContentBlockStopEvent for index 1, then MessageStopEvent, then "onComplete".
   * Actual:   subscriber stops after ContentBlockDeltaEvent for index 1 — no ContentBlockStopEvent,
   *           no MessageStopEvent, no "onComplete" within the 60s timeout.
   */
  public class ConverseStreamToolUseBug {

      public static void main(String[] args) throws Exception {
          var client = BedrockRuntimeAsyncClient.builder()
                  .region(Region.EU_CENTRAL_1)
                  .credentialsProvider(DefaultCredentialsProvider.create())
                  .build();

          var request = ConverseStreamRequest.builder()
                  .modelId("eu.anthropic.claude-sonnet-4-6")
                  .messages(Message.builder()
                          .role(ConversationRole.USER)
                          .content(ContentBlock.builder()
                                  .build())
                          .build())
                  .toolConfig(ToolConfiguration.builder()
                          .tools(Tool.builder()
                                  .toolSpec(ts -> ts
                                          .name("CompanyBenefitData")
                                          .description("Returns benefit data for the user's company.")
                                          .inputSchema(is -> is.json(
                                                  Document.fromMap(Map.of(
                                                          "type", Document.fromString("object"),
                                                          "properties", Document.fromMap(Map.of()),
                                                          "required", Document.fromList(List.of()))))))
                                  .build())               
                          .build())
                  .build();
                  
          var handler = ConverseStreamResponseHandler.builder()
                  .subscriber(event -> System.out.println(
                          "[" + System.currentTimeMillis() + "] event: " + event.getClass().getSimpleName()))
                  .onComplete(() -> System.out.println("onComplete — stream finished normally"))
                  .onError(t -> System.out.println("onError — " + t.getClass().getSimpleName() + ": " + t.getMessage()))
                  .build();
                  
          System.out.println("Starting converseStream...");
          client.converseStream(request, handler).get(60, TimeUnit.SECONDS);
          client.close();
      }
  }

Observed output (actual):
Starting converseStream...
[..] event: DefaultMessageStart
[..] event: DefaultContentBlockDelta
[..] event: DefaultContentBlockDelta
[..] event: DefaultContentBlockStop ← index 0 (text) closes correctly
[..] event: DefaultContentBlockStart ← index 1 (tool_use) opens
[..] event: DefaultContentBlockDelta ← tool input delta
← silence until TimeoutException after 60s
← no DefaultContentBlockStop for index 1
← no DefaultMessageStop
← onComplete never called

Expected output:
[..] event: DefaultContentBlockStop ← index 1 (tool_use) should close here
[..] event: DefaultMessageStop
[..] event: DefaultConverseStreamMetadata
onComplete — stream finished normally

---

Possible Solution

I have done workarounds by implementing watchdog solution but it has downsides, don't have an ideea how could this be fixed.

Additional Information/Context

The synchronous BedrockRuntimeClient.converse() API with the identical request payload completes successfully and returns the full response including the tool_use content block — only the converseStream() path is affected.

AWS Java SDK version used

software.amazon.awssdk:bedrockruntime:2.47.4

JDK version used

java 25.0.1 Oracle

Operating System and version

MacOs 15.7.4

[rpelevin]

One diagnostic split seems important here: observing more HTTP/2 DATA frames does not yet establish that complete AWS event-stream messages reached the generated union unmarshaller. I would instrument this at separate boundaries so the fix lands at the owning layer without inferring completion from transport activity:

• transport/event-stream decoder: message event type, content-block index, sequence, and decode outcome, without logging tool input;
• generated Bedrock union unmarshaller: which modeled event was produced or which decode failure occurred;
• response subscriber and returned future: callback order and exactly one terminal result.

The contract I would keep is:

1. Every started content block follows start -> delta* -> stop; MessageStop cannot complete while a block remains open.
2. Every converseStream attempt reaches exactly one observable terminal outcome: completed, failed, cancelled, or timed out. A decode or unmarshal failure must reach onError and complete the future exceptionally rather than becoming silence.
3. A tool_use block whose stop event was not observed remains incomplete. Its partial JSON must not be promoted into an executable tool request.
4. Cancellation and caller timeout close the subscription and retain the last observed boundary, block index, and event type for diagnosis, without retaining the private tool payload.

Regression coverage I would add at three layers:

• a recorded AWS event-stream fixture containing text events followed by fragmented tool-input deltas, tool block stop, message stop, and metadata;
• decoder/unmarshaller tests that deliver each modeled event once and in order across arbitrary frame fragmentation;
• subscriber tests for success, malformed event, truncated stream, cancellation, duplicate terminal event, and no-progress timeout, asserting both callback order and future state.

That separates a service-emission gap from an SDK decode/delivery gap and gives downstream agent runtimes a safe terminal result instead of an ambiguous partial tool call.

Boundary: architecture and regression-test feedback only. I did not reproduce the report or validate Amazon Bedrock, the AWS SDK for Java, the reported model or region, HTTP/2 frame contents, AWS event-stream decoding, generated unmarshalling, subscriber behavior, future completion, root cause, implementation correctness, safety, security, production readiness, official alignment, adoption, partnership, integration, customer interest, or Neura usage.

[ady88]

Update — unable to reproduce, closing

Ran the exact reproduction from this report against both SDK 2.31.1 and 2.47.4 (region eu-central-1, model eu.anthropic.claude-sonnet-4-6). Both now deliver the complete event chain:

  [0]  MessageStartEvent
  [1]–[4] ContentBlockDeltaEvent  index=0  (text)
  [5]  ContentBlockStopEvent      index=0
  [6]  ContentBlockStartEvent     index=1  type=tool_use
  [7]  ContentBlockDeltaEvent     index=1
  [8]  ContentBlockStopEvent      index=1   ← arrives correctly
  [9]  MessageStopEvent           stopReason=tool_use
  [10] ConverseStreamMetadataEvent

onComplete fired — CompletableFuture resolved normally

All three layers (event-stream decoder, unmarshaller, subscriber) show ContentBlockStopEvent for the tool_use block arriving correctly.. Closing as not reproducible — leaving a note here in case anyone else can still
reproduce it.

---

Update — root cause identified: OpenTelemetry Java agent 2.28.1

The earlier "unable to reproduce" conclusion was incorrect. The issue was reproducible but only inside a Spring Boot application running with the OpenTelemetry Java agent v2.28.1 (-javaagent:opentelemetry-javaagent.jar). The standalone JBang script had no OTel agent, which is why it always completed
successfully.

Root cause: the OTel agent v2.28.1's AWS SDK v2 instrumentation (aws-sdk-2.2 module) interferes with converseStream() event delivery. Specifically, ContentBlockStopEvent for tool_use blocks never arrives — the stream silently hangs until the Netty read timeout fires (~60 s).

Fix: upgrade the OTel Java agent to v2.30.0. The bug does not reproduce on 2.30.0 with the same request, same model, same guardrail config, and full AWS SDK instrumentation enabled.

Workaround if upgrade is not immediately possible: suppress the AWS SDK instrumentation via OTEL_INSTRUMENTATION_AWS_SDK_2_2_ENABLED=false. This keeps the rest of OTel telemetry intact.

[github-actions]

This issue is now closed. Comments on closed issues are hard for our team to see.
If you need more assistance, please open a new issue that references this one.