anthropic 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40c9c7c712197e8666740804eca676d573e5214f541cf983e0427f76b8eaefe3
-  data.tar.gz: 2423170ab39925e637cb77782db3883645d0064d4582a87afcd50bd6fec6e7af
+  metadata.gz: 4d36e1f15e69568a09c53f6050d60cf715dd92adf8df94877f9ea59693a58f16
+  data.tar.gz: 862a093342067fecddb4c2cc2c9365c2a0a69ffd6d93661c7ee5c70056606bba
 SHA512:
-  metadata.gz: 503e09fa3681d40df1045b3cc57c29e7e81594f44011e837dd8ea41f0c6c0b7fbe35c4659d9e5d1803f7ec0dc73bfea0c8ebb70249820e8d1854c4a9b8b127d8
-  data.tar.gz: 810826a076fbc6614429d4ed0ae073e90487a9fb17521375ed174d087c9b1ec865c7d12470ab5c4b77bc3d62cec2016a356a0a5c3e26b4fcce31c5101ba90366
+  metadata.gz: 4ce2b4e8c467b715b86b3e2756ffaa3a7b7df6b37eff492c8d0b552adaaa5b1c6efb3172308d0b61f9abecdfa2f392c70a3ac850678b1c92806865eaad1851c5
+  data.tar.gz: 80fc591eac84e7d9e95cae8b7d5ed51a7a68ae19f3c66c1a27442f3f46838050e50d939132e019452218766eec3fc6d7d40db5092fbedfdaec25c970c3ccceed

data/CHANGELOG.md

@@ -1,5 +1,67 @@
 # Changelog
 
+## 1.2.0 (2025-07-18)
+
+Full Changelog: [v1.1.1...v1.2.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.1.1...v1.2.0)
+
+### Features
+
+* **api:** add support for Search Result Content Blocks ([158a7ce](https://github.com/anthropics/anthropic-sdk-ruby/commit/158a7ced1013c3af956554caf41ee08ec5d1db3c))
+* **api:** api update ([cd22765](https://github.com/anthropics/anthropic-sdk-ruby/commit/cd2276536c7960a4f7276ceb9baba8ba5aec196e))
+* **api:** manual updates ([7f51b33](https://github.com/anthropics/anthropic-sdk-ruby/commit/7f51b336943422d230d8704583f42dc6f8a3ac62))
+* **client:** add breaking change detection to CI ([52e342f](https://github.com/anthropics/anthropic-sdk-ruby/commit/52e342fe8c8231ad6b6b6ff68ed522033cd503c7))
+* **client:** add support for new text_editor_20250429 tool ([9049af2](https://github.com/anthropics/anthropic-sdk-ruby/commit/9049af2f634f88d867104f2dc0ddc6396f5f8031))
+* streaming helpers ([#627](https://github.com/anthropics/anthropic-sdk-ruby/issues/627)) ([43fbbf8](https://github.com/anthropics/anthropic-sdk-ruby/commit/43fbbf8a39ac1d99920845ba19da43d7419a5e73))
+* **vertex:** support global region endpoint ([da8c452](https://github.com/anthropics/anthropic-sdk-ruby/commit/da8c452a22c56780f311f4f1ab3477a48ac46891))
+
+
+### Bug Fixes
+
+* `to_sorbet_type` should not return branded types ([2658903](https://github.com/anthropics/anthropic-sdk-ruby/commit/2658903f13178a133ca679f4b87615e9cddcd813))
+* **ci:** release-doctor — report correct token name ([e30183e](https://github.com/anthropics/anthropic-sdk-ruby/commit/e30183e5561070dfd3dfe041f48e76765975cb3b))
+* **client:** deprecate BetaBase64PDFBlock in favor of BetaRequestDocumentBlock ([f75705b](https://github.com/anthropics/anthropic-sdk-ruby/commit/f75705bfb4af3160b2fa7208adfad10719cd17a7))
+* default content-type for text in multi-part formdata uploads should be text/plain ([0a91592](https://github.com/anthropics/anthropic-sdk-ruby/commit/0a915925fc93ca7ad191bab33dba8c72b6c48a2a))
+* **internal:** fix: should publish to ruby gems when a release is created ([cc88c6c](https://github.com/anthropics/anthropic-sdk-ruby/commit/cc88c6c7c164c5bb1937e12cefb4d91f05fec157))
+* issue where we cannot mutate arrays on base model derivatives ([446c8be](https://github.com/anthropics/anthropic-sdk-ruby/commit/446c8be0eb77a29641d472ea36cbaf6f786f7e3a))
+
+
+### Chores
+
+* add `license` to the gemspec ([#101](https://github.com/anthropics/anthropic-sdk-ruby/issues/101)) ([af509a7](https://github.com/anthropics/anthropic-sdk-ruby/commit/af509a735c0e985e615f9279bc070dc090874df8))
+* add RBS types for helpers/streaming ([#631](https://github.com/anthropics/anthropic-sdk-ruby/issues/631)) ([0d7941d](https://github.com/anthropics/anthropic-sdk-ruby/commit/0d7941df6628b1500f7e7e8def88f613d7bcf2fa))
+* **api:** mark claude-3-opus-20240229 as deprecated ([1edd9bd](https://github.com/anthropics/anthropic-sdk-ruby/commit/1edd9bdf0bf508f5467daf92c4b1db11128d70ea))
+* **api:** update BetaCitationSearchResultLocation ([b294f7e](https://github.com/anthropics/anthropic-sdk-ruby/commit/b294f7e2bfd44d01504eeb7e30b37926ca7200e2))
+* **ci:** enable for pull requests ([31bbb43](https://github.com/anthropics/anthropic-sdk-ruby/commit/31bbb43d02cc56505ad5ec8d737801b73f9f5fd8))
+* **ci:** link to correct github repo ([37b5902](https://github.com/anthropics/anthropic-sdk-ruby/commit/37b59027a26268ad5bb20ee6530c7f0c630bc5b5))
+* **ci:** only run for pushes and fork pull requests ([8d3c942](https://github.com/anthropics/anthropic-sdk-ruby/commit/8d3c9425afe873a49e403c7a8a36f14642191a89))
+* **internal:** allow streams to also be unwrapped on a per-row basis ([a271d21](https://github.com/anthropics/anthropic-sdk-ruby/commit/a271d21d2f01a9f7c9c2d126b1f3d9b0611dd8cd))
+* **internal:** codegen related update ([8b12fd6](https://github.com/anthropics/anthropic-sdk-ruby/commit/8b12fd6e8ec1c06d3cbf7d20c63c6933538d0983))
+* remove workaround for updating arrays in place in streaming ([#643](https://github.com/anthropics/anthropic-sdk-ruby/issues/643)) ([e0a30b8](https://github.com/anthropics/anthropic-sdk-ruby/commit/e0a30b8128624566f673ac77f97c305953b11c63))
+
+
+### Documentation
+
+* model in examples ([18ba0b6](https://github.com/anthropics/anthropic-sdk-ruby/commit/18ba0b62bd8f87b84766265726090ca2265a64b7))
+* update documentation in MessageStream ([#630](https://github.com/anthropics/anthropic-sdk-ruby/issues/630)) ([4795c73](https://github.com/anthropics/anthropic-sdk-ruby/commit/4795c73f0628d2bc710f77bd0868be18c53ec31a))
+* update models and non-beta ([a4ea04e](https://github.com/anthropics/anthropic-sdk-ruby/commit/a4ea04eaf88e608612512d39d07051842beaf500))
+
+## 1.1.1 (2025-05-28)
+
+Full Changelog: [v1.1.0...v1.1.1](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.1.0...v1.1.1)
+
+### Bug Fixes
+
+* prevent rubocop from mangling `===` to `is_a?` check ([303ad55](https://github.com/anthropics/anthropic-sdk-ruby/commit/303ad550c542c726b2ce8bc3d53e01108af634d5))
+* sorbet types for enums, and make tapioca detection ignore `tapioca dsl` ([fb289a1](https://github.com/anthropics/anthropic-sdk-ruby/commit/fb289a1be37379cea207b024e0fb4503ea174639))
+
+
+### Chores
+
+* add more examples ([e14665e](https://github.com/anthropics/anthropic-sdk-ruby/commit/e14665e4e236cce4a17de06507d1b855d1d153d2))
+* image example ([#621](https://github.com/anthropics/anthropic-sdk-ruby/issues/621)) ([9bdc648](https://github.com/anthropics/anthropic-sdk-ruby/commit/9bdc6487d77d856c87d658917f53faa6f12bc38f))
+* **internal:** fix release workflows ([fffb4b8](https://github.com/anthropics/anthropic-sdk-ruby/commit/fffb4b8eeff759ac98e9cfb5d778b014336e2956))
+* more examples ([#619](https://github.com/anthropics/anthropic-sdk-ruby/issues/619)) ([e14665e](https://github.com/anthropics/anthropic-sdk-ruby/commit/e14665e4e236cce4a17de06507d1b855d1d153d2))
+
 ## 1.1.0 (2025-05-22)
 
 Full Changelog: [v1.0.0...v1.1.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.0.0...v1.1.0)

data/README.md

@@ -15,7 +15,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "anthropic", "~> 1.1.0"
+gem "anthropic", "~> 1.2.0"
 ```
 
 <!-- x-release-please-end -->
@@ -39,7 +39,7 @@ anthropic = Anthropic::Client.new(
 message = anthropic.messages.create(
   max_tokens: 1024,
   messages: [{role: "user", content: "Hello, Claude"}],
-  model: :"claude-3-7-sonnet-latest"
+  model: :"claude-sonnet-4-20250514"
 )
 
 puts(message.content)
@@ -49,13 +49,11 @@ puts(message.content)
 
 We provide support for streaming responses using Server-Sent Events (SSE).
 
-**coming soon**: `anthropic.messages.stream` will have [Python SDK](https://github.com/anthropics/anthropic-sdk-python?tab=readme-ov-file#streaming-helpers) style streaming response helpers.
-
 ```ruby
-stream = anthropic.messages.stream_raw(
+stream = anthropic.messages.stream(
   max_tokens: 1024,
   messages: [{role: "user", content: "Hello, Claude"}],
-  model: :"claude-3-7-sonnet-latest"
+  model: :"claude-sonnet-4-20250514"
 )
 
 stream.each do |message|
@@ -63,6 +61,24 @@ stream.each do |message|
 end
 ```
 
+### Streaming Helpers
+
+This library provides several conveniences for streaming messages, for example:
+
+```ruby
+stream = anthropic.messages.stream(
+  max_tokens: 1024,
+  messages: [{role: :user, content: "Say hello there!"}],
+  model: :"claude-sonnet-4-20250514"
+)
+
+stream.text.each do |text|
+  print(text)
+end
+```
+
+Streaming with `anthropic.messages.stream(...)` exposes [various helpers for your convenience](helpers.md) including accumulation & SDK-specific events.
+
 ### Pagination
 
 List methods in the Anthropic API are paginated.
@@ -70,7 +86,7 @@ List methods in the Anthropic API are paginated.
 This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:
 
 ```ruby
-page = anthropic.beta.messages.batches.list(limit: 20)
+page = anthropic.messages.batches.list(limit: 20)
 
 # Fetch single item from page.
 batch = page.data[0]
@@ -122,7 +138,7 @@ begin
   message = anthropic.messages.create(
     max_tokens: 1024,
     messages: [{role: "user", content: "Hello, Claude"}],
-    model: :"claude-3-7-sonnet-latest"
+    model: :"claude-sonnet-4-20250514"
   )
 rescue Anthropic::Errors::APIConnectionError => e
   puts("The server could not be reached")
@@ -169,7 +185,7 @@ anthropic = Anthropic::Client.new(
 anthropic.messages.create(
   max_tokens: 1024,
   messages: [{role: "user", content: "Hello, Claude"}],
-  model: :"claude-3-7-sonnet-latest",
+  model: :"claude-sonnet-4-20250514",
   request_options: {max_retries: 5}
 )
 ```
@@ -188,7 +204,7 @@ anthropic = Anthropic::Client.new(
 anthropic.messages.create(
   max_tokens: 1024,
   messages: [{role: "user", content: "Hello, Claude"}],
-  model: :"claude-3-7-sonnet-latest",
+  model: :"claude-sonnet-4-20250514",
   request_options: {timeout: 5}
 )
 ```
@@ -219,7 +235,7 @@ message = anthropic.messages.create(
       content: "Hello, Claude"
     }
   ],
-  model: "anthropic.claude-3-5-sonnet-20241022-v2:0"
+  model: "anthropic.claude-sonnet-4-20250514-v2:0"
 )
 
 puts(message)
@@ -247,7 +263,7 @@ message = anthropic.messages.create(
       content: "Hello, Claude"
     }
   ],
-  model: "claude-3-7-sonnet@20250219"
+  model: "claude-sonnet-4@20250514"
 )
 
 puts(message)
@@ -284,7 +300,7 @@ message =
   anthropic.messages.create(
     max_tokens: 1024,
     messages: [{role: "user", content: "Hello, Claude"}],
-    model: :"claude-3-7-sonnet-latest",
+    model: :"claude-sonnet-4-20250514",
     request_options: {
       extra_query: {my_query_parameter: value},
       extra_body: {my_body_parameter: value},
@@ -333,7 +349,7 @@ You can provide typesafe request parameters like so:
 anthropic.messages.create(
   max_tokens: 1024,
   messages: [Anthropic::MessageParam.new(role: "user", content: "Hello, Claude")],
-  model: :"claude-3-7-sonnet-latest"
+  model: :"claude-sonnet-4-20250514"
 )
 ```
 
@@ -344,14 +360,14 @@ Or, equivalently:
 anthropic.messages.create(
   max_tokens: 1024,
   messages: [{role: "user", content: "Hello, Claude"}],
-  model: :"claude-3-7-sonnet-latest"
+  model: :"claude-sonnet-4-20250514"
 )
 
 # You can also splat a full Params class:
 params = Anthropic::MessageCreateParams.new(
   max_tokens: 1024,
   messages: [Anthropic::MessageParam.new(role: "user", content: "Hello, Claude")],
-  model: :"claude-3-7-sonnet-latest"
+  model: :"claude-sonnet-4-20250514"
 )
 anthropic.messages.create(**params)
 ```

data/lib/anthropic/errors.rb

@@ -9,6 +9,28 @@ module Anthropic
     end
 
     class ConversionError < Anthropic::Errors::Error
+      # @return [StandardError, nil]
+      def cause = @cause.nil? ? super : @cause
+
+      # @api private
+      #
+      # @param on [Class<StandardError>]
+      # @param method [Symbol]
+      # @param target [Object]
+      # @param value [Object]
+      # @param cause [StandardError, nil]
+      def initialize(on:, method:, target:, value:, cause: nil)
+        cls = on.name.split("::").last
+
+        message = [
+          "Failed to parse #{cls}.#{method} from #{value.class} to #{target.inspect}.",
+          "To get the unparsed API response, use #{cls}[#{method.inspect}].",
+          cause && "Cause: #{cause.message}"
+        ].filter(&:itself).join(" ")
+
+        @cause = cause
+        super(message)
+      end
     end
 
     class APIError < Anthropic::Errors::Error

data/lib/anthropic/helpers/bedrock/client.rb

@@ -62,7 +62,7 @@ module Anthropic
           begin
             require("aws-sdk-bedrockruntime")
           rescue LoadError
-            raise <<~MSG
+            message = <<~MSG
 
               In order to access Anthropic models on Bedrock you must require the `aws-sdk-bedrockruntime` gem.
               You can install it by adding the following to your Gemfile:
@@ -75,6 +75,8 @@ module Anthropic
 
                   gem install aws-sdk-bedrockruntime
             MSG
+
+            raise RuntimeError.new(message)
           end
 
           @aws_region, @aws_credentials = resolve_region_and_credentials(

data/lib/anthropic/helpers/streaming/events.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module Streaming
+      class TextEvent < Anthropic::Internal::Type::BaseModel
+        # @!attribute type
+        #
+        #   @return [Symbol, :text]
+        required :type, const: :text
+
+        # @!attribute text
+        #   The text delta received in this streaming event.
+        #
+        #   @return [String]
+        required :text, String
+
+        # @!attribute snapshot
+        #   The entire accumulated text up to this point in the stream.
+        #
+        #   @return [String]
+        required :snapshot, String
+      end
+
+      class CitationEvent < Anthropic::Internal::Type::BaseModel
+        # @!attribute type
+        #
+        #   @return [Symbol, :citation]
+        required :type, const: :citation
+
+        # @!attribute citation
+        #   The new citation received in this streaming event.
+        #
+        #   @return [Anthropic::Models::CitationCharLocation, Anthropic::Models::CitationPageLocation, Anthropic::Models::CitationContentBlockLocation, Anthropic::Models::CitationsWebSearchResultLocation]
+        required :citation, union: -> { Anthropic::CitationsDelta::Citation }
+
+        # @!attribute snapshot
+        #   All of the accumulated citations up to this point in the stream.
+        #
+        #   @return [Array<Anthropic::Models::CitationCharLocation, Anthropic::Models::CitationPageLocation, Anthropic::Models::CitationContentBlockLocation, Anthropic::Models::CitationsWebSearchResultLocation>]
+        required :snapshot,
+                 -> {
+                   Anthropic::Internal::Type::ArrayOf[union: Anthropic::CitationsDelta::Citation]
+                 }
+      end
+
+      class ThinkingEvent < Anthropic::Internal::Type::BaseModel
+        # @!attribute type
+        #
+        #   @return [Symbol, :thinking]
+        required :type, const: :thinking
+
+        # @!attribute thinking
+        #   The thinking delta received in this streaming event.
+        #
+        #   @return [String]
+        required :thinking, String
+
+        # @!attribute snapshot
+        #   The accumulated thinking content up to this point in the stream.
+        #
+        #   @return [String]
+        required :snapshot, String
+      end
+
+      class SignatureEvent < Anthropic::Internal::Type::BaseModel
+        # @!attribute type
+        #
+        #   @return [Symbol, :signature]
+        required :type, const: :signature
+
+        # @!attribute signature
+        #   The signature of the thinking block.
+        #
+        #   @return [String]
+        required :signature, String
+      end
+
+      class InputJsonEvent < Anthropic::Internal::Type::BaseModel
+        # @!attribute type
+        #
+        #   @return [Symbol, :input_json]
+        required :type, const: :input_json
+
+        # @!attribute partial_json
+        #   A partial JSON string delta received in this streaming event.
+        #
+        #   Example:
+        #   ```
+        #   "{'location':,"
+        #   ```
+        #
+        #   @return [String]
+        required :partial_json, String
+
+        # @!attribute snapshot
+        #   The currently accumulated parsed object up to this point in the stream.
+        #
+        #   Example:
+        #   ```
+        #   {'location': 'San Francisco, CA'}
+        #   ```
+        #
+        #   @return [Object]
+        required :snapshot, Anthropic::Internal::Type::Unknown
+      end
+
+      class MessageStopEvent < Anthropic::Models::RawMessageStopEvent
+        # @!attribute type
+        #
+        #   @return [Symbol, :message_stop]
+        required :type, const: :message_stop
+
+        # @!attribute message
+        #   The completed message when streaming ends.
+        #
+        #   @return [Anthropic::Models::Message]
+        required :message, Anthropic::Models::Message
+      end
+
+      class ContentBlockStopEvent < Anthropic::Models::RawContentBlockStopEvent
+        # @!attribute index
+        #   The index of the content block that has stopped streaming.
+        #
+        #   @return [Integer]
+        required :index, Integer
+
+        # @!attribute type
+        #
+        #   @return [Symbol, :content_block_stop]
+        required :type, const: :content_block_stop
+
+        # @!attribute content_block
+        #   The completed content block when streaming for this block ends.
+        #
+        #   @return [Anthropic::Models::TextBlock, Anthropic::Models::ToolUseBlock]
+        required :content_block, Anthropic::Models::ContentBlock
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/streaming/message_stream.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module Streaming
+      # @api private
+      #
+      # MessageStream provides a Ruby Enumerable interface over Server-Sent Events from
+      # the Anthropic API, yielding a mix of raw streaming events and higher-level typed
+      # events while maintaining accumulated message state throughout the stream lifecycle.
+      #
+      #
+      # @generic Elem
+      class MessageStream
+        include Anthropic::Internal::Type::BaseStream
+
+        # @api private
+        #
+        # Consumes raw stream events and yields a mix of raw and higher-level typed events while
+        # maintaining accumulated message state. This is what's called when you run `each` on the
+        # stream.
+        #
+        # @return [Enumerable<generic<Elem>>]
+        private def iterator
+          @iterator ||= Anthropic::Internal::Util.chain_fused(@stream) do |y|
+            @raw_stream.each do |raw_event|
+              @accumated_message_snapshot = accumulate_event(
+                event: raw_event,
+                current_snapshot: @accumated_message_snapshot
+              )
+              events_to_yield = build_events(event: raw_event, message_snapshot: @accumated_message_snapshot)
+              events_to_yield.each(&y)
+            end
+          end
+        end
+
+        # @api public
+        #
+        # Blocks until the stream has been consumed
+        #
+        # @return [void]
+        def until_done = each {} # rubocop:disable Lint/EmptyBlock
+
+        # @api public
+        #
+        # Returns an enumerable of text deltas from the streaming response.
+        #
+        # @return [Enumerable<String>]
+        def text
+          Anthropic::Internal::Util.chain_fused(@iterator) do |y|
+            @iterator.each do |event|
+              if event.type == :content_block_delta && event.delta.type == :text_delta
+                y << event.delta.text
+              end
+            end
+          end
+        end
+
+        # @api public
+        #
+        # Returns the complete accumulated Message object after stream completion.
+        #
+        # @return [Anthropic::Models::Message]
+        def accumulated_message
+          until_done
+          @accumated_message_snapshot
+        end
+
+        # @api public
+        #
+        # Returns all text content blocks concatenated into a single string.
+        # NOTE: Currently the API will only respond with a single content block.
+        #
+        # Will raise an error if no `text` content blocks were returned.
+        # @return [String]
+        def accumulated_text
+          message = accumulated_message
+          text_blocks = []
+          message.content.each do |block|
+            if block.type == :text
+              text_blocks << block.text
+            end
+          end
+
+          if text_blocks.empty?
+            raise RuntimeError.new("Expected to have received at least 1 text block")
+          end
+
+          text_blocks.join
+        end
+
+        # @api private
+        #
+        # Builds up a complete Message object as streaming events arrive.
+        #
+        # @param event [Anthropic::Models::RawMessageStreamEvent] the raw streaming event to process
+        # @param current_snapshot [Anthropic::Models::Message, nil] current accumulated message state
+        #
+        # @return [Anthropic::Models::Message] updated message snapshot with event applied
+        private def accumulate_event(event:, current_snapshot:)
+          unless event in Anthropic::Models::RawMessageStreamEvent
+            message = "Expected event to be a variant of RawMessageStreamEvent, got #{event.class}"
+            raise ArgumentError.new(message)
+          end
+
+          if current_snapshot.nil?
+            return event.message if event.type == :message_start
+
+            message = "Unexpected event order, got \"#{event.type}\" before \":message_start\""
+            raise RuntimeError.new(message)
+          end
+
+          case event
+          in Anthropic::Models::RawMessageStartEvent
+            # Use the converter to create a new, isolated copy of the message object.
+            # This ensures proper type validation and prevents shared object references
+            # that could lead to unintended mutations during streaming accumulation.
+            # Matches the Python SDK's approach of explicitly constructing Message objects.
+            return Anthropic::Internal::Type::Converter.coerce(Anthropic::Models::Message, event.message)
+          in Anthropic::Models::RawContentBlockStartEvent
+            current_snapshot.content = (current_snapshot.content || []) + [event.content_block]
+          in Anthropic::Models::RawContentBlockDeltaEvent
+            content = current_snapshot.content[event.index]
+
+            case (delta = event.delta)
+            in Anthropic::Models::TextDelta if content.type == :text
+              content.text += delta.text
+            in Anthropic::Models::InputJSONDelta if content.type == :tool_use
+              json_buf = content.json_buf.to_s
+              json_buf += delta.partial_json
+
+              content.input = json_buf
+              content.json_buf = json_buf
+            in Anthropic::Models::CitationsDelta if content.type == :text
+              content.citations ||= []
+              content.citations << delta.citation
+            in Anthropic::Models::ThinkingDelta if content.type == :thinking
+              content.thinking += delta.thinking
+            in Anthropic::Models::SignatureDelta if content.type == :thinking
+              content.signature = delta.signature
+            else
+            end
+          in Anthropic::Models::RawMessageDeltaEvent
+            current_snapshot.stop_reason = event.delta.stop_reason
+            current_snapshot.stop_sequence = event.delta.stop_sequence
+            current_snapshot.usage.output_tokens = event.usage.output_tokens
+          else
+          end
+
+          current_snapshot
+        end
+
+        # @api private
+        #
+        # Determines which events to yield for a given raw streaming event.
+        #
+        # May transform events into higher-level types (TextEvent, InputJsonEvent),
+        # pass through raw events unchanged, or produce multiple events.
+        #
+        # @param event [Anthropic::Models::RawMessageStreamEvent] the raw event to process
+        # @param message_snapshot [Anthropic::Models::Message] current accumulated message state
+        #
+        # @return [Array<Object>] events to yield (mix of raw and typed events)
+        private def build_events(event:, message_snapshot:)
+          events_to_yield = []
+
+          case event
+          in Anthropic::Models::RawMessageStopEvent
+            events_to_yield << MessageStopEvent.new(
+              type: :message_stop,
+              message: message_snapshot
+            )
+          in Anthropic::Models::RawContentBlockDeltaEvent
+            events_to_yield << event
+            content_block = message_snapshot.content[event.index]
+
+            case (delta = event.delta)
+            in Anthropic::Models::TextDelta if content_block.type == :text
+              events_to_yield << Anthropic::Streaming::TextEvent.new(
+                type: :text,
+                text: delta.text,
+                snapshot: content_block.text
+              )
+            in Anthropic::Models::InputJSONDelta if content_block.type == :tool_use
+              events_to_yield << Anthropic::Streaming::InputJsonEvent.new(
+                type: :input_json,
+                partial_json: delta.partial_json,
+                snapshot: content_block.input
+              )
+            in Anthropic::Models::CitationsDelta if content_block.type == :text
+              events_to_yield << Anthropic::Streaming::CitationEvent.new(
+                type: :citation,
+                citation: delta.citation,
+                snapshot: content_block.citations || []
+              )
+            in Anthropic::Models::ThinkingDelta if content_block.type == :thinking
+              events_to_yield << Anthropic::Streaming::ThinkingEvent.new(
+                type: :thinking,
+                thinking: delta.thinking,
+                snapshot: content_block.thinking
+              )
+            in Anthropic::Models::SignatureDelta if content_block.type == :thinking
+              events_to_yield << Anthropic::Streaming::SignatureEvent.new(
+                type: :signature,
+                signature: content_block.signature
+              )
+            else
+            end
+          in Anthropic::Models::RawContentBlockStopEvent
+            content_block = message_snapshot.content[event.index]
+
+            events_to_yield << ContentBlockStopEvent.new(
+              type: :content_block_stop,
+              index: event.index,
+              content_block: content_block
+            )
+          else
+            events_to_yield << event
+          end
+
+          events_to_yield
+        end
+
+        # @api private
+        #
+        # @param raw_stream [Anthropic::Internal::Type::BaseStream]
+        def initialize(raw_stream:)
+          # The underlying Server-Sent Event stream from the Anthropic API.
+          @raw_stream = raw_stream
+          # Accumulated message state that builds up as events are processed.
+          @accumated_message_snapshot = nil
+          # Lazy enumerable that transforms raw events into consumable events.
+          @iterator = iterator
+        end
+      end
+    end
+  end
+end