ruby_llm 2.0.0 → 2.1.0

data/lib/ruby_llm/protocols/converse/request_shapes.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Protocols
+    class Converse
+      # Describes Converse requests, and the token counting requests that
+      # wrap them, as RequestShape objects. A content block is a union keyed
+      # by its kind, and media names a format instead of a MIME type.
+      # Converse wants user and assistant messages to alternate, pairs tool
+      # results with uses by id, and takes reasoning back only with its
+      # signature.
+      module RequestShapes
+        MEDIA_KINDS = { 'image' => :image, 'audio' => :audio, 'video' => :video, 'document' => :document }.freeze
+
+        def parse_request_shape(payload)
+          request = shape_hash(shape_hash(payload['input'])['converse'])
+          request = payload if request.empty?
+          messages = request['messages']
+          return unless messages.is_a?(Array)
+
+          turns = messages.each_with_index.map { |message, index| shape_converse_turn(shape_hash(message), index) }
+          tools = shape_list(shape_hash(request['toolConfig'])['tools'])
+          shape_request(turns, payload:, rules: %i[alternating_roles signed_thinking],
+                               instructions: shape_converse_blocks(request['system']),
+                               tool_names: tools.map { |tool| shape_converse_tool_name(shape_hash(tool)) },
+                               thinking_settings: shape_converse_thinking(request))
+        end
+
+        private
+
+        def shape_converse_turn(message, index)
+          parts = shape_converse_blocks(message['content'])
+          shape_turn(index, message['role'], message['role'] == 'assistant' ? :model : shape_answer(parts), parts)
+        end
+
+        def shape_converse_blocks(blocks)
+          shape_list(blocks).flat_map { |block| shape_converse_block(shape_hash(block)) }
+        end
+
+        def shape_converse_block(block)
+          type, value = block.first
+          return shape_text(value) if %w[text json].include?(type)
+
+          value = shape_hash(value)
+          case type
+          when 'toolUse' then shape_tool_call(value['name'], value['input'], id: value['toolUseId'])
+          when 'toolResult'
+            shape_tool_result(value['content'], id: value['toolUseId']) { |inner| shape_converse_block(inner) }
+          when 'reasoningContent' then shape_converse_reasoning(value)
+          when *MEDIA_KINDS.keys then shape_converse_media(MEDIA_KINDS[type], value)
+          else shape_other(type)
+          end
+        end
+
+        def shape_converse_reasoning(reasoning)
+          unless reasoning.key?('reasoningText')
+            return shape_text(nil, kind: :thinking, signed: shape_signature?(reasoning['redactedContent']))
+          end
+
+          text = shape_hash(reasoning['reasoningText'])
+          shape_text(text['text'], kind: :thinking, signed: shape_signature?(text['signature']))
+        end
+
+        def shape_converse_media(kind, media)
+          source = shape_hash(media['source'])
+          mime_type = shape_converse_mime_type(kind, media['format'])
+          return shape_inline(source['bytes'], kind:, mime_type:) if source.key?('bytes')
+          return shape_file(kind:, mime_type:) unless source.key?('text')
+
+          shape_media(kind, source: :inline, size: shape_length(source['text']), mime_type:)
+        end
+
+        # A format can name a container that holds either sound or video,
+        # such as mp4, so its MIME type counts only when it agrees.
+        def shape_converse_mime_type(kind, format)
+          return unless format.is_a?(String)
+
+          mime_type = RubyLLM::Files::MimeType.for(name: "file.#{format}")
+          mime_type if mime_type != 'application/octet-stream' && shape_media_kind(mime_type) == kind
+        end
+
+        def shape_converse_tool_name(tool)
+          shape_hash(tool['toolSpec'])['name'] || shape_hash(tool['systemTool'])['name']
+        end
+
+        # Each model family takes its reasoning settings in a field of its
+        # own, and some name an effort with a bare reasoning_config.
+        def shape_converse_thinking(request)
+          fields = shape_hash(request['additionalModelRequestFields'])
+          shape_settings(fields, 'reasoning_config', 'reasoning_effort')
+            .merge(shape_settings(fields['reasoning_config'], 'type', 'budget_tokens'))
+            .merge(shape_settings(fields['reasoningConfig'], 'type', 'maxReasoningEffort'))
+            .merge(shape_settings(fields['thinking'], 'type'))
+            .merge(shape_settings(fields['output_config'], 'effort'))
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/protocols/converse/streaming.rb

@@ -31,8 +31,7 @@ module RubyLLM
             on_failed_response: ->(chunk, env) { handle_failed_stream(chunk, env) }
           )
 
-          response = @connection.post(stream_url, payload, usage: @usage_tracker) do |req|
-            req.headers.merge!(@provider.sign_headers('POST', stream_url, body))
+          response = @connection.post(stream_url, body, usage: @usage_tracker, stream: true) do |req|
             req.headers.merge!(additional_headers) unless additional_headers.empty?
             req.headers['Accept'] = 'application/vnd.amazon.eventstream'
             (req.options.context ||= {})[RubyLLM::Transport::Connection::STREAM_PROGRESS_KEY] = progress
@@ -203,6 +202,7 @@ module RubyLLM
             output_tokens: extract_output_tokens(metadata_usage, usage),
             cache_read_tokens: extract_cache_read_tokens(metadata_usage, usage),
             cache_write_tokens: extract_cache_write_tokens(metadata_usage, usage),
+            cache_write_tokens_by_ttl: Chat.cache_write_by_ttl(metadata_usage) || Chat.cache_write_by_ttl(usage),
             thinking_tokens: extract_reasoning_tokens(metadata_usage, usage),
             finish_reason: extract_finish_reason(event)
           )

data/lib/ruby_llm/protocols/converse/thinking_stream.rb

@@ -37,7 +37,8 @@ module RubyLLM
           else
             text = (block['reasoningText'] ||= { 'text' => '' })
             (delta['reasoningText'] || delta).slice('text', 'signature').each do |key, value|
-              text[key] = text[key].to_s + value.to_s
+              text[key] = +text[key].to_s
+              text[key] << value.to_s
             end
           end
         end

data/lib/ruby_llm/protocols/converse.rb

@@ -4,10 +4,11 @@ module RubyLLM
   module Protocols
     # The AWS Bedrock Converse API. Requests are SigV4-signed by the provider.
     class Converse < Protocol
-      REGION_PREFIXES = %w[global us-gov us eu apac ap sa ca me af il au jp].freeze
+      REGION_PREFIXES = %w[global us-gov us eu apac ap sa ca me af il au jp in].freeze
 
       include Converse::Chat
       include Converse::Media
+      include Converse::RequestShapes
       include Converse::Streaming
 
       # Nova 2 models execute built-in tools server-side when the request
@@ -42,10 +43,7 @@ module RubyLLM
       end
 
       def signed_post(url, payload, additional_headers = {})
-        body = JSON.generate(payload)
-
-        @connection.post(url, payload, usage: @usage_tracker) do |req|
-          req.headers.merge!(@provider.sign_headers('POST', url, body))
+        @connection.post(url, JSON.generate(payload), usage: @usage_tracker) do |req|
           req.headers.merge!(additional_headers) unless additional_headers.empty?
         end
       end

data/lib/ruby_llm/protocols/deepseek/files.rb

@@ -5,21 +5,14 @@ module RubyLLM
     module DeepSeek
       # DeepSeek stores image files for reuse by vision models.
       class Files < Protocols::OpenAI::Files
-        IMAGE_TYPES = %w[image/jpeg image/png image/gif image/webp].freeze
-        MAX_FILE_SIZE = 64 * 1024 * 1024
-
         def download(_file_id)
           raise Error, 'DeepSeek does not support downloading uploaded files'
         end
 
         private
 
-        def render_upload_payload(attachment, purpose: nil, **options)
-          raise UnsupportedAttachmentError, attachment.mime_type unless IMAGE_TYPES.include?(attachment.mime_type)
-          raise ArgumentError, 'DeepSeek image uploads cannot exceed 64 MiB' if file_size(attachment) > MAX_FILE_SIZE
-          raise ArgumentError, 'DeepSeek file uploads require purpose: user_data' if purpose && purpose != 'user_data'
-
-          super(attachment, purpose: 'user_data', **options)
+        def render_upload_payload(attachment, purpose: nil, **)
+          super(attachment, purpose: purpose || 'user_data', **)
         end
 
         def uploaded_file(data, **attributes)

data/lib/ruby_llm/protocols/elevenlabs/flows/images.rb

@@ -5,8 +5,6 @@ module RubyLLM
     class ElevenLabs
       class Flows
         module Images # :nodoc: all
-          MASK_MODELS = %w[gpt-image-1 gpt-image-1.5 gpt-image-2].freeze
-
           def images_url(**)
             'v1/flows/image'
           end
@@ -20,11 +18,7 @@ module RubyLLM
             payload = { model_id: model, prompt: }
             payload[:images] = images.map { |image| render_media_reference(image) } if images.any?
             payload[:aspect_ratio] = image_aspect_ratio(size) if size && size != 'auto'
-            if mask
-              raise ArgumentError, 'ElevenLabs image masks require a GPT Image model' unless MASK_MODELS.include?(model)
-
-              payload[:mask] = render_media_reference(Attachment.wrap(mask, config: @config).first)
-            end
+            payload[:mask] = render_media_reference(Attachment.wrap(mask, config: @config).first) if mask
             Support::Utils.deep_merge(payload, provider_options)
           end
 

data/lib/ruby_llm/protocols/elevenlabs/flows/videos.rb

@@ -5,10 +5,6 @@ module RubyLLM
     class ElevenLabs
       class Flows
         module Videos # :nodoc: all
-          REFERENCE_VIDEO_MODELS = %w[
-            bytedance-seedance-v2 bytedance-seedance-v2-fast bytedance-seedance-v2-mini bytedance-seedance-v2.5
-          ].freeze
-
           def video_url
             'v1/flows/video'
           end
@@ -17,22 +13,20 @@ module RubyLLM
             payload = if model == 'creatify-aurora'
                         render_character_animation(prompt, with:)
                       else
-                        render_video_inputs(prompt, model:, with:)
+                        render_video_inputs(prompt, with:)
                       end
             Support::Utils.deep_merge({ model_id: model }.merge(payload), provider_options)
           end
 
-          def render_video_inputs(prompt, model:, with:)
-            raise ArgumentError, 'This ElevenLabs video model requires a prompt' if prompt.to_s.empty?
-
-            payload = { prompt: }
+          def render_video_inputs(prompt, with:)
+            payload = { prompt: }.compact
             if with.all?(&:image?)
               raise ArgumentError, 'Video generation accepts at most two frame images' if with.size > 2
 
               payload[:start_frame] = render_media_reference(with[0]) if with[0]
               payload[:end_frame] = render_media_reference(with[1]) if with[1]
             else
-              render_video_references(payload, with, model:)
+              render_video_references(payload, with)
             end
             payload
           end
@@ -51,19 +45,19 @@ module RubyLLM
             { image: render_media_reference(image.first), audio: render_media_reference(audio.first) }
           end
 
-          def render_video_references(payload, attachments, model:)
-            unless REFERENCE_VIDEO_MODELS.include?(model)
-              raise ArgumentError, 'This ElevenLabs video model only accepts image attachments'
-            end
-
+          def render_video_references(payload, attachments)
             { images: :image?, audios: :audio?, videos: :video? }.each do |field, predicate|
               references = attachments.select { |attachment| attachment.public_send(predicate) }
               payload[field] = references.map { |attachment| render_media_reference(attachment) } if references.any?
             end
           end
 
-          def parse_video_job(response, model:)
-            VideoJob.new(id: response.body.fetch('id'), protocol: self, model:, raw: response.body)
+          def parse_video_job(response, model:, **request)
+            VideoJob.new(id: response.body.fetch('id'), protocol: self, model:, raw: response.body, **request)
+          end
+
+          def video_request_settings(request)
+            { duration: request[:duration_secs], resolution: request[:resolution] }
           end
 
           def video_job_url(job)

data/lib/ruby_llm/protocols/elevenlabs/streaming_transcription.rb

@@ -4,8 +4,6 @@ module RubyLLM
   module Protocols
     class ElevenLabs
       module StreamingTranscription # :nodoc: all
-        SAMPLE_RATES = [8000, 16_000, 22_050, 24_000, 44_100, 48_000].freeze
-
         def stream_transcription(payload, model:, &block)
           validate_streaming_transcription(payload)
           audio = RubyLLM::Transcription::WavAudio.new(payload.fetch(:file).io.read)
@@ -74,8 +72,7 @@ module RubyLLM
         end
 
         def pcm_audio?(audio)
-          [audio.channels, audio.encoding, audio.bits_per_sample] == [1, 1, 16] &&
-            SAMPLE_RATES.include?(audio.sample_rate)
+          [audio.channels, audio.encoding, audio.bits_per_sample] == [1, 1, 16]
         end
 
         def streaming_transcription_url(payload, audio_format:)

data/lib/ruby_llm/protocols/gemini/chat.rb

@@ -15,7 +15,6 @@ module RubyLLM
 
         GEMINI_INLINE_FILE_THRESHOLD = 20 * 1024 * 1024
         VERTEX_INLINE_FILE_THRESHOLD = 7 * 1024 * 1024
-        GEMINI_FILE_UPLOAD_LIMIT = 2 * 1024 * 1024 * 1024
 
         module_function
 
@@ -84,8 +83,8 @@ module RubyLLM
           "models/#{@model.id}:countTokens"
         end
 
-        def render_count_tokens_payload(messages, model:, **options)
-          request = count_tokens_request(messages, model: model, **options)
+        def render_count_tokens_payload(messages, model:, **)
+          request = count_tokens_request(messages, model: model, **)
           { generateContentRequest: request.merge(model: "models/#{model.id}") }
         end
 
@@ -128,10 +127,6 @@ module RubyLLM
           @provider.slug == 'vertexai' ? VERTEX_INLINE_FILE_THRESHOLD : GEMINI_INLINE_FILE_THRESHOLD
         end
 
-        def provider_file_upload_limit
-          GEMINI_FILE_UPLOAD_LIMIT
-        end
-
         def provider_file_attachable?(attachment)
           attachment.image? || attachment.video? || attachment.audio? || attachment.pdf? || attachment.text?
         end
@@ -160,7 +155,7 @@ module RubyLLM
         end
 
         def format_parts(msg)
-          if msg.role == :assistant && msg.raw_content
+          if msg.role == :assistant && msg.raw_content.is_a?(Array)
             msg.raw_content
           elsif msg.tool_call?
             format_tool_call(msg)
@@ -172,19 +167,20 @@ module RubyLLM
         end
 
         def format_message_parts(msg)
-          parts = []
+          parts = Media.format_content(msg.content, msg.attachments)
+          thinking = msg.thinking if msg.role == :assistant
+          return parts unless thinking
 
-          parts << build_thought_part(msg.thinking) if msg.role == :assistant && msg.thinking
-
-          parts.concat(Media.format_content(msg.content, msg.attachments))
-          parts
+          signature = own_signature(msg)
+          parts = sign_last_part(parts, signature) if signature
+          thinking.text ? [{ thought: true, text: thinking.text }, *parts] : parts
         end
 
-        def build_thought_part(thinking)
-          part = { thought: true }
-          part[:text] = thinking.text if thinking.text
-          part[:thoughtSignature] = thinking.signature if thinking.signature
-          part
+        # Gemini signs the last part of an answer. An answer without parts gets
+        # the empty text part a stream ends with: Gemini refuses a part without data.
+        def sign_last_part(parts, signature)
+          parts = [Media.format_text('')] if parts.empty?
+          [*parts[...-1], parts.last.merge(thoughtSignature: signature)]
         end
 
         def parse_completion_body(data, raw:)
@@ -203,11 +199,12 @@ module RubyLLM
             ),
             tool_calls: tool_calls,
             server_tool_calls: extract_server_tool_calls(data, parts),
-            raw_content: parts.any? { |part| server_tool_part?(part) } ? parts : nil,
+            raw_content: parts.any? { |part| server_tool_part?(part) } ? without_search_suggestions(parts) : nil,
             input_tokens: input_tokens(data),
             output_tokens: calculate_output_tokens(data),
             cache_read_tokens: data.dig('usageMetadata', 'cachedContentTokenCount'),
             thinking_tokens: data.dig('usageMetadata', 'thoughtsTokenCount'),
+            server_tool_use: parse_server_tool_use(data),
             finish_reason: normalize_finish_reason(
               data.dig('candidates', 0, 'finishReason') || data.dig('promptFeedback', 'blockReason')
             ),
@@ -216,6 +213,14 @@ module RubyLLM
           )
         end
 
+        # Gemini 3 bills each distinct, non-empty query a grounding ran.
+        def parse_server_tool_use(data)
+          searches = Array(data['candidates']).sum do |candidate|
+            Array(candidate.dig('groundingMetadata', 'webSearchQueries')).reject(&:empty?).uniq.size
+          end
+          { 'web_search_requests' => searches }
+        end
+
         def input_tokens(data)
           prompt_tokens = data.dig('usageMetadata', 'promptTokenCount')
           return unless prompt_tokens
@@ -243,6 +248,18 @@ module RubyLLM
           part.key?('executableCode') || part.key?('codeExecutionResult')
         end
 
+        # Google's terms forbid storing search suggestions, and Gemini takes
+        # a replayed search result without them.
+        def without_search_suggestions(parts)
+          parts.map do |part|
+            tool_response = part['toolResponse']
+            response = tool_response&.dig('response')
+            next part unless response.is_a?(Hash) && response.key?('search_suggestions')
+
+            part.merge('toolResponse' => tool_response.merge('response' => response.except('search_suggestions')))
+          end
+        end
+
         def extract_server_tool_calls(data, parts)
           calls = parts.select { |part| server_tool_part?(part) }.map do |part|
             ServerToolCall.new(
@@ -263,7 +280,9 @@ module RubyLLM
           queries = candidate.dig('groundingMetadata', 'webSearchQueries')
           if queries&.any?
             calls << ServerToolCall.new(type: 'google_search', input: { 'queries' => queries },
-                                        raw: { 'webSearchQueries' => queries })
+                                        raw: { 'webSearchQueries' => queries },
+                                        search_suggestions: candidate.dig('groundingMetadata', 'searchEntryPoint',
+                                                                          'renderedContent'))
           end
 
           url_metadata = candidate['urlContextMetadata']
@@ -370,6 +389,7 @@ module RubyLLM
             @messages = messages
             @index = 0
             @tool_call_names = {}
+            @turn_start = messages.rindex { |message| message.role == :user }
           end
 
           def format
@@ -437,12 +457,21 @@ module RubyLLM
           end
 
           def build_standard_message(message)
+            parts = @provider.send(:format_parts, message)
+            parts = @provider.send(:sign_step, parts) if message.tool_call? && current_turn?
+
             {
               role: @provider.send(:format_role, message.role),
-              parts: @provider.send(:format_parts, message)
+              parts: parts
             }
           end
 
+          # Gemini checks signatures only in the current turn, which starts at
+          # the last user message.
+          def current_turn?
+            @turn_start.nil? || @index > @turn_start
+          end
+
           def format_tool_result(message, tool_name)
             @provider.send(:format_tool_result, message, tool_name)
           end

data/lib/ruby_llm/protocols/gemini/embeddings.rb

@@ -30,8 +30,8 @@ module RubyLLM
           true
         end
 
-        def render_embedding(text, dimensions: nil, **options)
-          payload = render_embedding_payload(text, dimensions:, **options)
+        def render_embedding(text, dimensions: nil, **)
+          payload = render_embedding_payload(text, dimensions:, **)
           return payload if text.is_a?(Array) || !payload.key?(:requests)
 
           payload.fetch(:requests).first

data/lib/ruby_llm/protocols/gemini/files.rb

@@ -102,7 +102,7 @@ module RubyLLM
         def gemini_connection(request_json:, response_json:)
           connection = Transport::Connection.basic(@config) do |connection|
             connection.request :json if request_json
-            connection.response :json if response_json
+            connection.use Transport::JsonResponse if response_json
             connection.adapter @config.faraday_adapter
             connection.use :llm_errors, provider: @provider
           end

data/lib/ruby_llm/protocols/gemini/images.rb

@@ -125,7 +125,11 @@ module RubyLLM
 
         def parse_gemini_image_responses(data, model:)
           parts = gemini_image_parts(data)
-          raise Error, 'Unexpected response format from Gemini image generation API' if parts.empty?
+          if parts.empty?
+            usage = gemini_image_usage(data)
+            @usage_tracker&.observe_tokens(Tokens.new(input: usage['input_tokens'], output: usage['output_tokens']))
+            raise Error, 'Unexpected response format from Gemini image generation API'
+          end
 
           parts.map.with_index do |image_data, index|
             Image.new(

data/lib/ruby_llm/protocols/gemini/media.rb

@@ -10,23 +10,27 @@ module RubyLLM
       module Media
         module_function
 
+        def supported_attachment?(attachment)
+          %i[image audio video pdf text].include?(attachment.type)
+        end
+
         def format_content(content, attachments = [])
           parts = []
           parts << format_text(content) if content
 
           attachments.each do |attachment|
-            parts << format_content_attachment(attachment)
+            parts << with_media_resolution(format_content_attachment(attachment), attachment)
           end
 
           parts
         end
 
         def format_content_attachment(attachment)
+          raise UnsupportedAttachmentError, attachment.mime_type unless supported_attachment?(attachment)
+
           case attachment.type
           when :text
             format_text_file(attachment)
-          when :document, :unknown
-            raise UnsupportedAttachmentError, attachment.mime_type
           else
             format_attachment(attachment)
           end
@@ -43,6 +47,14 @@ module RubyLLM
           }
         end
 
+        def with_media_resolution(part, attachment)
+          return part unless attachment.resolution && %i[image video pdf].include?(attachment.type)
+
+          level = attachment.resolution == :original ? :ultra_high : attachment.resolution
+          level = :high if level == :ultra_high && attachment.type != :image
+          part.merge(media_resolution: { level: "MEDIA_RESOLUTION_#{level.upcase}" })
+        end
+
         def format_file_data(attachment)
           uri = attachment.provider_file_uri || attachment.provider_file_id
           {

data/lib/ruby_llm/protocols/gemini/request_shapes.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Protocols
+    class Gemini
+      # Describes generateContent requests, and the countTokens requests that
+      # wrap them, as RequestShape objects. RubyLLM writes media parts in
+      # snake case, and a model's own parts replay in camel case. Gemini pairs
+      # function responses with calls by position and name, wants data in
+      # every part, and from Gemini 3 needs a signature on the first call of
+      # each step in the current turn.
+      module RequestShapes
+        PART_MODIFIERS = %w[thought thoughtSignature thought_signature mediaResolution media_resolution
+                            videoMetadata video_metadata partMetadata part_metadata].freeze
+        DATA_FIELDS = %w[text inlineData inline_data fileData file_data functionCall function_call functionResponse
+                         function_response executableCode executable_code codeExecutionResult code_execution_result
+                         toolCall tool_call toolResponse tool_response].freeze
+        FUNCTION_DECLARATIONS = %w[functionDeclarations function_declarations].freeze
+        THINKING_SETTINGS = %w[includeThoughts include_thoughts thinkingBudget thinking_budget thinkingLevel
+                               thinking_level].freeze
+
+        def parse_request_shape(payload)
+          request = shape_hash(payload['generateContentRequest'])
+          request = payload if request.empty?
+          contents = request['contents']
+          return unless contents.is_a?(Array)
+
+          turns = contents.each_with_index.map { |content, index| shape_gemini_turn(shape_hash(content), index) }
+          shape_request(turns, payload:, pairing: :position, rules: %i[signed_steps],
+                               instructions: shape_gemini_parts(request['systemInstruction'] ||
+                                                                request['system_instruction']),
+                               tool_names: shape_list(request['tools']).flat_map { |tool| shape_gemini_tools(tool) },
+                               thinking_settings: shape_gemini_thinking(request))
+        end
+
+        private
+
+        def shape_gemini_turn(content, index)
+          parts = shape_gemini_parts(content)
+          shape_turn(index, content['role'], content['role'] == 'model' ? :model : shape_answer(parts), parts)
+        end
+
+        def shape_gemini_parts(content)
+          shape_list(shape_hash(content)['parts']).flat_map { |part| shape_gemini_part(shape_hash(part)) }
+        end
+
+        def shape_gemini_part(part)
+          signed = shape_signature?(part['thoughtSignature'] || part['thought_signature'])
+          call = shape_gemini_field(part, 'functionCall', 'function_call')
+          response = shape_gemini_field(part, 'functionResponse', 'function_response')
+
+          if call
+            shape_tool_call(call['name'], call['args'], id: call['id'], signed:)
+          elsif response
+            shape_gemini_tool_result(response)
+          elsif part.key?('text')
+            shape_text(part['text'], kind: part['thought'] ? :thinking : :text, signed:)
+          else
+            shape_gemini_data(part, signed)
+          end
+        end
+
+        # RubyLLM wraps a result's text in content parts, and Gemini 3 sends
+        # a result's media in parts beside it.
+        def shape_gemini_tool_result(response)
+          result = response['response']
+          content = shape_hash(result)['content']
+          content = result unless content.is_a?(Array)
+          shape_tool_result(content, name: response['name']) { |part| shape_gemini_part(part) } +
+            shape_gemini_parts(response)
+        end
+
+        # A thought or a signature alone is a part with no data, which
+        # Gemini refuses.
+        def shape_gemini_data(part, signed)
+          if (data = shape_gemini_field(part, 'inlineData', 'inline_data'))
+            return shape_inline(data['data'], mime_type: data['mimeType'] || data['mime_type'], signed:)
+          end
+          if (file = shape_gemini_field(part, 'fileData', 'file_data'))
+            return shape_file(mime_type: file['mimeType'] || file['mime_type'])
+          end
+
+          spec = if part['thought']
+                   shape_text(nil, kind: :thinking, signed:)
+                 else
+                   shape_other(part.keys.find { |key| !PART_MODIFIERS.include?(key) }, signed:)
+                 end
+          spec.without_data = !part.keys.intersect?(DATA_FIELDS)
+          spec
+        end
+
+        def shape_gemini_field(part, *keys)
+          keys.map { |key| part[key] }.find { |value| value.is_a?(Hash) }
+        end
+
+        def shape_gemini_tools(tool)
+          shape_hash(tool).flat_map do |key, value|
+            next [key] unless FUNCTION_DECLARATIONS.include?(key)
+
+            shape_list(value).map { |declaration| shape_hash(declaration)['name'] }
+          end
+        end
+
+        def shape_gemini_thinking(request)
+          config = shape_hash(request['generationConfig'] || request['generation_config'])
+          shape_settings(config['thinkingConfig'] || config['thinking_config'], *THINKING_SETTINGS)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/protocols/gemini/streaming.rb

@@ -28,6 +28,7 @@ module RubyLLM
             output_tokens: extract_output_tokens(data),
             cache_read_tokens: data.dig('usageMetadata', 'cachedContentTokenCount'),
             thinking_tokens: data.dig('usageMetadata', 'thoughtsTokenCount'),
+            server_tool_use: parse_server_tool_use(data),
             finish_reason: normalize_finish_reason(
               data.dig('candidates', 0, 'finishReason') || data.dig('promptFeedback', 'blockReason')
             ),
@@ -63,7 +64,7 @@ module RubyLLM
 
           {
             server_tool_calls: calls,
-            raw_content: @saw_server_part ? @stream_parts : nil
+            raw_content: @saw_server_part ? without_search_suggestions(@stream_parts) : nil
           }
         end