anthropic 1.1.1 → 1.9.0

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

@@ -0,0 +1,278 @@
+# 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
+          parse_tool_uses!(@accumated_message_snapshot) if @tool_models.any?
+          @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
+        #
+        # Parse tool use blocks in the message using the provided tool models.
+        #
+        # @param message [Anthropic::Models::Message] The message to parse
+        #
+        # @return [Anthropic::Models::Message] The message with parsed tool uses
+        private def parse_tool_uses!(message)
+          return message unless message&.content
+
+          message.content.each_with_index do |content, index|
+            next unless content.type == :tool_use
+
+            next unless (model = @tool_models[content.name])
+
+            parsed =
+              begin
+                parsed_input = content.input.is_a?(String) ? JSON.parse(content.input) : content.input
+
+                Anthropic::Internal::Type::Converter.coerce(model, parsed_input)
+              rescue StandardError => e
+                e
+              end
+
+            message.content[index] = Anthropic::Models::ToolUseBlock.new(
+              id: content.id,
+              input: content.input,
+              name: content.name,
+              type: content.type,
+              parsed: parsed
+            )
+          end
+
+          message
+        end
+
+        # @api private
+        #
+        # @param raw_stream [Anthropic::Internal::Type::BaseStream]
+        # @param tool_models [Hash{String=>Class}] Mapping of tool names to model classes
+        def initialize(raw_stream:, tool_models: {})
+          # 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
+          # Mapping of tool names to model classes for parsing.
+          @tool_models = tool_models
+          # Lazy enumerable that transforms raw events into consumable events.
+          @iterator = iterator
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/streaming.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module Streaming
+      extend Anthropic::Internal::Util::SorbetRuntimeSupport
+
+      define_sorbet_constant!(:RawMessageEvent) do
+        T.type_alias do
+          T.any(
+            Anthropic::Models::RawMessageStartEvent,
+            Anthropic::Models::RawMessageDeltaEvent,
+            Anthropic::Models::RawMessageStopEvent,
+            Anthropic::Models::RawContentBlockStartEvent,
+            Anthropic::Models::RawContentBlockDeltaEvent,
+            Anthropic::Models::RawContentBlockStopEvent
+          )
+        end
+      end
+
+      define_sorbet_constant!(:StreamEvent) do
+        T.type_alias do
+          T.any(
+            Anthropic::Streaming::RawMessageEvent,
+            Anthropic::Streaming::TextEvent,
+            Anthropic::Streaming::CitationEvent,
+            Anthropic::Streaming::ThinkingEvent,
+            Anthropic::Streaming::SignatureEvent,
+            Anthropic::Streaming::InputJsonEvent,
+            Anthropic::Streaming::MessageStopEvent,
+            Anthropic::Streaming::ContentBlockStopEvent
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -82,7 +82,10 @@ module Anthropic
           end
           @project_id = project_id
 
-          base_url ||= ENV.fetch("ANTHROPIC_VERTEX_BASE_URL", "https://#{@region}-aiplatform.googleapis.com/v1")
+          base_url ||= ENV.fetch(
+            "ANTHROPIC_VERTEX_BASE_URL",
+            @region.to_s == "global" ? "https://aiplatform.googleapis.com/v1" : "https://#{@region}-aiplatform.googleapis.com/v1"
+          )
 
           super(
             base_url: base_url,

data/lib/anthropic/input_schema.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Anthropic
+  InputSchema = Anthropic::Helpers::InputSchema
+  ArrayOf = Anthropic::Helpers::InputSchema::ArrayOf
+  BaseModel = Anthropic::Helpers::InputSchema::BaseModel
+  Boolean = Anthropic::Helpers::InputSchema::Boolean
+  EnumOf = Anthropic::Helpers::InputSchema::EnumOf
+  UnionOf = Anthropic::Helpers::InputSchema::UnionOf
+end

data/lib/anthropic/internal/stream.rb

@@ -23,13 +23,15 @@ module Anthropic
             case msg
             in {event: "completion", data: String => data}
               decoded = JSON.parse(data, symbolize_names: true)
-              y << Anthropic::Internal::Type::Converter.coerce(@model, decoded)
+              unwrapped = Anthropic::Internal::Util.dig(decoded, @unwrap)
+              y << Anthropic::Internal::Type::Converter.coerce(@model, unwrapped)
             in {
               event: "message_start" | "message_delta" | "message_stop" | "content_block_start" | "content_block_delta" | "content_block_stop",
               data: String => data
             }
               decoded = JSON.parse(data, symbolize_names: true)
-              y << Anthropic::Internal::Type::Converter.coerce(@model, decoded)
+              unwrapped = Anthropic::Internal::Util.dig(decoded, @unwrap)
+              y << Anthropic::Internal::Type::Converter.coerce(@model, unwrapped)
             in {event: "ping"}
               next
             in {event: "error", data: String => data}
@@ -38,13 +40,14 @@ module Anthropic
               rescue JSON::ParserError
                 data
               end
-              Anthropic::Errors::APIStatusError.for(
+              err = Anthropic::Errors::APIStatusError.for(
                 url: @url,
                 status: @status,
                 body: decoded,
                 request: nil,
                 response: @response
               )
+              raise err
             else
             end
           end

data/lib/anthropic/internal/transport/base_client.rb

@@ -341,6 +341,23 @@ module Anthropic
           (@initial_retry_delay * scale * jitter).clamp(0, @max_retry_delay)
         end
 
+        # @api private
+        #
+        # Very private API, do not use
+        #
+        # @param request [Hash{Symbol=>Object}] .
+        #
+        #   @option request [Symbol] :method
+        #
+        #   @option request [URI::Generic] :url
+        #
+        #   @option request [Hash{String=>String}] :headers
+        #
+        #   @option request [Object] :body
+        #
+        # @return [Hash{Symbol, Object}]
+        private def transform_request(request) = request
+
         # @api private
         #
         # @param request [Hash{Symbol=>Object}] .
@@ -365,7 +382,8 @@ module Anthropic
         #
         # @raise [Anthropic::Errors::APIError]
         # @return [Array(Integer, Net::HTTPResponse, Enumerable<String>)]
-        private def send_request(request, redirect_count:, retry_count:, send_retry_header:)
+        def send_request(request, redirect_count:, retry_count:, send_retry_header:)
+          request = transform_request(request)
           url, headers, max_retries, timeout = request.fetch_values(:url, :headers, :max_retries, :timeout)
           input = {**request.except(:timeout), deadline: Anthropic::Internal::Util.monotonic_secs + timeout}
 
@@ -471,6 +489,7 @@ module Anthropic
           self.class.validate!(req)
           model = req.fetch(:model) { Anthropic::Internal::Type::Unknown }
           opts = req[:options].to_h
+          unwrap = req[:unwrap]
           Anthropic::RequestOptions.validate!(opts)
           request = build_request(req.except(:options), opts)
           url = request.fetch(:url)
@@ -487,11 +506,18 @@ module Anthropic
           decoded = Anthropic::Internal::Util.decode_content(response, stream: stream)
           case req
           in {stream: Class => st}
-            st.new(model: model, url: url, status: status, response: response, stream: decoded)
+            st.new(
+              model: model,
+              url: url,
+              status: status,
+              response: response,
+              unwrap: unwrap,
+              stream: decoded
+            )
           in {page: Class => page}
             page.new(client: self, req: req, headers: response, page_data: decoded)
           else
-            unwrapped = Anthropic::Internal::Util.dig(decoded, req[:unwrap])
+            unwrapped = Anthropic::Internal::Util.dig(decoded, unwrap)
             Anthropic::Internal::Type::Converter.coerce(model, unwrapped)
           end
         end
@@ -532,8 +558,7 @@ module Anthropic
               ),
               page: T.nilable(T::Class[Anthropic::Internal::Type::BasePage[Anthropic::Internal::Type::BaseModel]]),
               stream: T.nilable(
-                T::Class[Anthropic::Internal::Type::BaseStream[T.anything,
-                                                               Anthropic::Internal::Type::BaseModel]]
+                T::Class[Anthropic::Internal::Type::BaseStream[T.anything, Anthropic::Internal::Type::BaseModel]]
               ),
               model: T.nilable(Anthropic::Internal::Type::Converter::Input),
               options: T.nilable(Anthropic::RequestOptions::OrHash)

data/lib/anthropic/internal/transport/pooled_net_requester.rb

@@ -193,15 +193,7 @@ module Anthropic
         end
 
         define_sorbet_constant!(:Request) do
-          T.type_alias do
-            {
-              method: Symbol,
-              url: URI::Generic,
-              headers: T::Hash[String, String],
-              body: T.anything,
-              deadline: Float
-            }
-          end
+          T.type_alias { {method: Symbol, url: URI::Generic, headers: T::Hash[String, String], body: T.anything, deadline: Float} }
         end
       end
     end

data/lib/anthropic/internal/type/array_of.rb

@@ -62,10 +62,14 @@ module Anthropic
         #
         # @param state [Hash{Symbol=>Object}] .
         #
-        #   @option state [Boolean, :strong] :strictness
+        #   @option state [Boolean] :translate_names
+        #
+        #   @option state [Boolean] :strictness
         #
         #   @option state [Hash{Symbol=>Object}] :exactness
         #
+        #   @option state [Class<StandardError>] :error
+        #
         #   @option state [Integer] :branched
         #
         # @return [Array<Object>, Object]
@@ -74,6 +78,7 @@ module Anthropic
 
           unless value.is_a?(Array)
             exactness[:no] += 1
+            state[:error] = TypeError.new("#{value.class} can't be coerced into #{Array}")
             return value
           end
 
@@ -143,6 +148,7 @@ module Anthropic
         #   @option spec [Boolean] :"nil?"
         def initialize(type_info, spec = {})
           @item_type_fn = Anthropic::Internal::Type::Converter.type_info(type_info || spec)
+          @meta = Anthropic::Internal::Type::Converter.meta_info(type_info, spec)
           @nilable = spec.fetch(:nil?, false)
         end
 

data/lib/anthropic/internal/type/base_model.rb

@@ -59,18 +59,12 @@ module Anthropic
               in Hash
                 [Anthropic::Internal::Type::Converter.type_info(type_info), type_info]
               end
+            meta = Anthropic::Internal::Type::Converter.meta_info(type_info, spec)
 
-            setter = "#{name_sym}="
+            setter = :"#{name_sym}="
             api_name = info.fetch(:api_name, name_sym)
             nilable = info.fetch(:nil?, false)
-            const = if required && !nilable
-              info.fetch(
-                :const,
-                Anthropic::Internal::OMIT
-              )
-            else
-              Anthropic::Internal::OMIT
-            end
+            const = required && !nilable ? info.fetch(:const, Anthropic::Internal::OMIT) : Anthropic::Internal::OMIT
 
             [name_sym, setter].each { undef_method(_1) } if known_fields.key?(name_sym)
 
@@ -81,31 +75,65 @@ module Anthropic
                 required: required,
                 nilable: nilable,
                 const: const,
-                type_fn: type_fn
+                type_fn: type_fn,
+                meta: meta
               }
 
-            define_method(setter) { @data.store(name_sym, _1) }
+            define_method(setter) do |value|
+              target = type_fn.call
+              state = Anthropic::Internal::Type::Converter.new_coerce_state(translate_names: false)
+              coerced = Anthropic::Internal::Type::Converter.coerce(target, value, state: state)
+              status = @coerced.store(name_sym, state.fetch(:error) || true)
+              stored =
+                case [target, status]
+                in [Anthropic::Internal::Type::Converter | Symbol, true]
+                  coerced
+                else
+                  value
+                end
+              @data.store(name_sym, stored)
+            end
 
+            # rubocop:disable Style/CaseEquality
+            # rubocop:disable Metrics/BlockLength
             define_method(name_sym) do
               target = type_fn.call
-              value = @data.fetch(name_sym) { const == Anthropic::Internal::OMIT ? nil : const }
-              state = {strictness: :strong, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0}
-              if (nilable || !required) && value.nil?
-                nil
-              else
-                Anthropic::Internal::Type::Converter.coerce(
-                  target, value, state: state
+
+              case @coerced[name_sym]
+              in true | false if Anthropic::Internal::Type::Converter === target
+                @data.fetch(name_sym)
+              in ::StandardError => e
+                raise Anthropic::Errors::ConversionError.new(
+                  on: self.class,
+                  method: __method__,
+                  target: target,
+                  value: @data.fetch(name_sym),
+                  cause: e
                 )
+              else
+                Kernel.then do
+                  value = @data.fetch(name_sym) { const == Anthropic::Internal::OMIT ? nil : const }
+                  state = Anthropic::Internal::Type::Converter.new_coerce_state(translate_names: false)
+                  if (nilable || !required) && value.nil?
+                    nil
+                  else
+                    Anthropic::Internal::Type::Converter.coerce(
+                      target, value, state: state
+                    )
+                  end
+                rescue StandardError => e
+                  raise Anthropic::Errors::ConversionError.new(
+                    on: self.class,
+                    method: __method__,
+                    target: target,
+                    value: value,
+                    cause: e
+                  )
+                end
               end
-            rescue StandardError => e
-              cls = self.class.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: #{e.message}"
-              ].join(" ")
-              raise Anthropic::Errors::ConversionError.new(message)
             end
+            # rubocop:enable Metrics/BlockLength
+            # rubocop:enable Style/CaseEquality
           end
 
           # @api private
@@ -205,23 +233,28 @@ module Anthropic
           #
           # @param state [Hash{Symbol=>Object}] .
           #
-          #   @option state [Boolean, :strong] :strictness
+          #   @option state [Boolean] :translate_names
+          #
+          #   @option state [Boolean] :strictness
           #
           #   @option state [Hash{Symbol=>Object}] :exactness
           #
+          #   @option state [Class<StandardError>] :error
+          #
           #   @option state [Integer] :branched
           #
           # @return [self, Object]
           def coerce(value, state:)
             exactness = state.fetch(:exactness)
 
-            if value.is_a?(self.class)
+            if value.is_a?(self)
               exactness[:yes] += 1
               return value
             end
 
             unless (val = Anthropic::Internal::Util.coerce_hash(value)).is_a?(Hash)
               exactness[:no] += 1
+              state[:error] = TypeError.new("#{value.class} can't be coerced into #{Hash}")
               return value
             end
             exactness[:yes] += 1
@@ -229,13 +262,15 @@ module Anthropic
             keys = val.keys.to_set
             instance = new
             data = instance.to_h
+            status = instance.instance_variable_get(:@coerced)
 
             # rubocop:disable Metrics/BlockLength
             fields.each do |name, field|
               mode, required, target = field.fetch_values(:mode, :required, :type)
               api_name, nilable, const = field.fetch_values(:api_name, :nilable, :const)
+              src_name = state.fetch(:translate_names) ? api_name : name
 
-              unless val.key?(api_name)
+              unless val.key?(src_name)
                 if required && mode != :dump && const == Anthropic::Internal::OMIT
                   exactness[nilable ? :maybe : :no] += 1
                 else
@@ -244,9 +279,10 @@ module Anthropic
                 next
               end
 
-              item = val.fetch(api_name)
-              keys.delete(api_name)
+              item = val.fetch(src_name)
+              keys.delete(src_name)
 
+              state[:error] = nil
               converted =
                 if item.nil? && (nilable || !required)
                   exactness[nilable ? :yes : :maybe] += 1
@@ -260,6 +296,8 @@ module Anthropic
                     item
                   end
                 end
+
+              status.store(name, state.fetch(:error) || true)
               data.store(name, converted)
             end
             # rubocop:enable Metrics/BlockLength
@@ -434,7 +472,18 @@ module Anthropic
         # Create a new instance of a model.
         #
         # @param data [Hash{Symbol=>Object}, self]
-        def initialize(data = {}) = (@data = Anthropic::Internal::Util.coerce_hash!(data).to_h)
+        def initialize(data = {})
+          @data = {}
+          @coerced = {}
+          Anthropic::Internal::Util.coerce_hash!(data).each do
+            if self.class.known_fields.key?(_1)
+              public_send(:"#{_1}=", _2)
+            else
+              @data.store(_1, _2)
+              @coerced.store(_1, false)
+            end
+          end
+        end
 
         class << self
           # @api private