ruby_llm 1.9.1 → 1.10.0

data/lib/ruby_llm/providers/openai/chat.rb

@@ -11,7 +11,7 @@ module RubyLLM
 
         module_function
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil) # rubocop:disable Metrics/ParameterLists
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil, thinking: nil) # rubocop:disable Metrics/ParameterLists
           payload = {
             model: model.id,
             messages: format_messages(messages),
@@ -34,6 +34,9 @@ module RubyLLM
             }
           end
 
+          effort = resolve_effort(thinking)
+          payload[:reasoning_effort] = effort if effort
+
           payload[:stream_options] = { include_usage: true } if stream
           payload
         end
@@ -49,15 +52,21 @@ module RubyLLM
 
           usage = data['usage'] || {}
           cached_tokens = usage.dig('prompt_tokens_details', 'cached_tokens')
+          thinking_tokens = usage.dig('completion_tokens_details', 'reasoning_tokens')
+          content, thinking_from_blocks = extract_content_and_thinking(message_data['content'])
+          thinking_text = thinking_from_blocks || extract_thinking_text(message_data)
+          thinking_signature = extract_thinking_signature(message_data)
 
           Message.new(
             role: :assistant,
-            content: message_data['content'],
+            content: content,
+            thinking: Thinking.build(text: thinking_text, signature: thinking_signature),
             tool_calls: parse_tool_calls(message_data['tool_calls']),
             input_tokens: usage['prompt_tokens'],
             output_tokens: usage['completion_tokens'],
             cached_tokens: cached_tokens,
             cache_creation_tokens: 0,
+            thinking_tokens: thinking_tokens,
             model_id: data['model'],
             raw: response
           )
@@ -70,7 +79,7 @@ module RubyLLM
               content: Media.format_content(msg.content),
               tool_calls: format_tool_calls(msg.tool_calls),
               tool_call_id: msg.tool_call_id
-            }.compact
+            }.compact.merge(format_thinking(msg))
           end
         end
 
@@ -82,6 +91,81 @@ module RubyLLM
             role.to_s
           end
         end
+
+        def resolve_effort(thinking)
+          return nil unless thinking
+
+          thinking.respond_to?(:effort) ? thinking.effort : thinking
+        end
+
+        def format_thinking(msg)
+          return {} unless msg.role == :assistant
+
+          thinking = msg.thinking
+          return {} unless thinking
+
+          payload = {}
+          if thinking.text
+            payload[:reasoning] = thinking.text
+            payload[:reasoning_content] = thinking.text
+          end
+          payload[:reasoning_signature] = thinking.signature if thinking.signature
+          payload
+        end
+
+        def extract_thinking_text(message_data)
+          candidate = message_data['reasoning_content'] || message_data['reasoning'] || message_data['thinking']
+          candidate.is_a?(String) ? candidate : nil
+        end
+
+        def extract_thinking_signature(message_data)
+          candidate = message_data['reasoning_signature'] || message_data['signature']
+          candidate.is_a?(String) ? candidate : nil
+        end
+
+        def extract_content_and_thinking(content)
+          return extract_think_tag_content(content) if content.is_a?(String)
+          return [content, nil] unless content.is_a?(Array)
+
+          text = extract_text_from_blocks(content)
+          thinking = extract_thinking_from_blocks(content)
+
+          [text.empty? ? nil : text, thinking.empty? ? nil : thinking]
+        end
+
+        def extract_text_from_blocks(blocks)
+          blocks.filter_map do |block|
+            block['text'] if block['type'] == 'text' && block['text'].is_a?(String)
+          end.join
+        end
+
+        def extract_thinking_from_blocks(blocks)
+          blocks.filter_map do |block|
+            next unless block['type'] == 'thinking'
+
+            extract_thinking_text_from_block(block)
+          end.join
+        end
+
+        def extract_thinking_text_from_block(block)
+          thinking_block = block['thinking']
+          return thinking_block if thinking_block.is_a?(String)
+
+          if thinking_block.is_a?(Array)
+            return thinking_block.filter_map { |item| item['text'] if item['type'] == 'text' }.join
+          end
+
+          block['text'] if block['text'].is_a?(String)
+        end
+
+        def extract_think_tag_content(text)
+          return [text, nil] unless text.include?('<think>')
+
+          thinking = text.scan(%r{<think>(.*?)</think>}m).join
+          content = text.gsub(%r{<think>.*?</think>}m, '').strip
+
+          [content.empty? ? nil : content, thinking.empty? ? nil : thinking]
+        end
       end
     end
   end

data/lib/ruby_llm/providers/openai/streaming.rb

@@ -14,16 +14,24 @@ module RubyLLM
         def build_chunk(data)
           usage = data['usage'] || {}
           cached_tokens = usage.dig('prompt_tokens_details', 'cached_tokens')
+          delta = data.dig('choices', 0, 'delta') || {}
+          content_source = delta['content'] || data.dig('choices', 0, 'message', 'content')
+          content, thinking_from_blocks = OpenAI::Chat.extract_content_and_thinking(content_source)
 
           Chunk.new(
             role: :assistant,
             model_id: data['model'],
-            content: data.dig('choices', 0, 'delta', 'content'),
-            tool_calls: parse_tool_calls(data.dig('choices', 0, 'delta', 'tool_calls'), parse_arguments: false),
+            content: content,
+            thinking: Thinking.build(
+              text: thinking_from_blocks || delta['reasoning_content'] || delta['reasoning'],
+              signature: delta['reasoning_signature']
+            ),
+            tool_calls: parse_tool_calls(delta['tool_calls'], parse_arguments: false),
             input_tokens: usage['prompt_tokens'],
             output_tokens: usage['completion_tokens'],
             cached_tokens: cached_tokens,
-            cache_creation_tokens: 0
+            cache_creation_tokens: 0,
+            thinking_tokens: usage.dig('completion_tokens_details', 'reasoning_tokens')
           )
         end
 

data/lib/ruby_llm/providers/openai/temperature.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class OpenAI
+      # Normalizes temperature for OpenAI models with provider-specific requirements.
+      module Temperature
+        module_function
+
+        def normalize(temperature, model_id)
+          if model_id.match?(/^(o\d|gpt-5)/) && !temperature.nil? && !temperature_close_to_one?(temperature)
+            RubyLLM.logger.debug "Model #{model_id} requires temperature=1.0, setting that instead."
+            1.0
+          elsif model_id.include?('-search')
+            RubyLLM.logger.debug "Model #{model_id} does not accept temperature parameter, removing"
+            nil
+          else
+            temperature
+          end
+        end
+
+        def temperature_close_to_one?(temperature)
+          (temperature.to_f - 1.0).abs <= Float::EPSILON
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/openai.rb

@@ -27,7 +27,7 @@ module RubyLLM
       end
 
       def maybe_normalize_temperature(temperature, model)
-        OpenAI::Capabilities.normalize_temperature(temperature, model.id)
+        OpenAI::Temperature.normalize(temperature, model.id)
       end
 
       class << self

data/lib/ruby_llm/providers/openrouter/chat.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class OpenRouter
+      # Chat methods of the OpenRouter API integration
+      module Chat
+        module_function
+
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil, thinking: nil) # rubocop:disable Metrics/ParameterLists
+          payload = {
+            model: model.id,
+            messages: format_messages(messages),
+            stream: stream
+          }
+
+          payload[:temperature] = temperature unless temperature.nil?
+          payload[:tools] = tools.map { |_, tool| OpenAI::Tools.tool_for(tool) } if tools.any?
+
+          if schema
+            strict = schema[:strict] != false
+            payload[:response_format] = {
+              type: 'json_schema',
+              json_schema: {
+                name: 'response',
+                schema: schema,
+                strict: strict
+              }
+            }
+          end
+
+          reasoning = build_reasoning(thinking)
+          payload[:reasoning] = reasoning if reasoning
+
+          payload[:stream_options] = { include_usage: true } if stream
+          payload
+        end
+
+        def parse_completion_response(response)
+          data = response.body
+          return if data.empty?
+
+          raise Error.new(response, data.dig('error', 'message')) if data.dig('error', 'message')
+
+          message_data = data.dig('choices', 0, 'message')
+          return unless message_data
+
+          usage = data['usage'] || {}
+          cached_tokens = usage.dig('prompt_tokens_details', 'cached_tokens')
+          thinking_tokens = usage.dig('completion_tokens_details', 'reasoning_tokens')
+          thinking_text = extract_thinking_text(message_data)
+          thinking_signature = extract_thinking_signature(message_data)
+
+          Message.new(
+            role: :assistant,
+            content: message_data['content'],
+            thinking: Thinking.build(text: thinking_text, signature: thinking_signature),
+            tool_calls: OpenAI::Tools.parse_tool_calls(message_data['tool_calls']),
+            input_tokens: usage['prompt_tokens'],
+            output_tokens: usage['completion_tokens'],
+            cached_tokens: cached_tokens,
+            cache_creation_tokens: 0,
+            thinking_tokens: thinking_tokens,
+            model_id: data['model'],
+            raw: response
+          )
+        end
+
+        def format_messages(messages)
+          messages.map do |msg|
+            {
+              role: format_role(msg.role),
+              content: OpenAI::Media.format_content(msg.content),
+              tool_calls: OpenAI::Tools.format_tool_calls(msg.tool_calls),
+              tool_call_id: msg.tool_call_id
+            }.compact.merge(format_thinking(msg))
+          end
+        end
+
+        def format_role(role)
+          case role
+          when :system
+            @config.openai_use_system_role ? 'system' : 'developer'
+          else
+            role.to_s
+          end
+        end
+
+        def build_reasoning(thinking)
+          return nil unless thinking&.enabled?
+
+          reasoning = {}
+          reasoning[:effort] = thinking.effort if thinking.respond_to?(:effort) && thinking.effort
+          reasoning[:max_tokens] = thinking.budget if thinking.respond_to?(:budget) && thinking.budget
+          reasoning[:enabled] = true if reasoning.empty?
+          reasoning
+        end
+
+        def format_thinking(msg)
+          thinking = msg.thinking
+          return {} unless thinking && msg.role == :assistant
+
+          details = []
+          if thinking.text
+            details << {
+              type: 'reasoning.text',
+              text: thinking.text,
+              signature: thinking.signature
+            }.compact
+          elsif thinking.signature
+            details << {
+              type: 'reasoning.encrypted',
+              data: thinking.signature
+            }
+          end
+
+          details.empty? ? {} : { reasoning_details: details }
+        end
+
+        def extract_thinking_text(message_data)
+          candidate = message_data['reasoning']
+          return candidate if candidate.is_a?(String)
+
+          details = message_data['reasoning_details']
+          return nil unless details.is_a?(Array)
+
+          text = details.filter_map do |detail|
+            case detail['type']
+            when 'reasoning.text'
+              detail['text']
+            when 'reasoning.summary'
+              detail['summary']
+            end
+          end.join
+
+          text.empty? ? nil : text
+        end
+
+        def extract_thinking_signature(message_data)
+          details = message_data['reasoning_details']
+          return nil unless details.is_a?(Array)
+
+          signature = details.filter_map do |detail|
+            detail['signature'] if detail['signature'].is_a?(String)
+          end.first
+          return signature if signature
+
+          encrypted = details.find { |detail| detail['type'] == 'reasoning.encrypted' && detail['data'].is_a?(String) }
+          encrypted&.dig('data')
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/openrouter/streaming.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class OpenRouter
+      # Streaming methods of the OpenRouter API integration
+      module Streaming
+        module_function
+
+        def stream_url
+          completion_url
+        end
+
+        def build_chunk(data)
+          usage = data['usage'] || {}
+          cached_tokens = usage.dig('prompt_tokens_details', 'cached_tokens')
+          delta = data.dig('choices', 0, 'delta') || {}
+
+          Chunk.new(
+            role: :assistant,
+            model_id: data['model'],
+            content: delta['content'],
+            thinking: Thinking.build(
+              text: extract_thinking_text(delta),
+              signature: extract_thinking_signature(delta)
+            ),
+            tool_calls: OpenAI::Tools.parse_tool_calls(delta['tool_calls'], parse_arguments: false),
+            input_tokens: usage['prompt_tokens'],
+            output_tokens: usage['completion_tokens'],
+            cached_tokens: cached_tokens,
+            cache_creation_tokens: 0,
+            thinking_tokens: usage.dig('completion_tokens_details', 'reasoning_tokens')
+          )
+        end
+
+        def parse_streaming_error(data)
+          OpenAI::Streaming.parse_streaming_error(data)
+        end
+
+        def extract_thinking_text(delta)
+          candidate = delta['reasoning']
+          return candidate if candidate.is_a?(String)
+
+          details = delta['reasoning_details']
+          return nil unless details.is_a?(Array)
+
+          text = details.filter_map do |detail|
+            case detail['type']
+            when 'reasoning.text'
+              detail['text']
+            when 'reasoning.summary'
+              detail['summary']
+            end
+          end.join
+
+          text.empty? ? nil : text
+        end
+
+        def extract_thinking_signature(delta)
+          details = delta['reasoning_details']
+          return nil unless details.is_a?(Array)
+
+          signature = details.filter_map do |detail|
+            detail['signature'] if detail['signature'].is_a?(String)
+          end.first
+          return signature if signature
+
+          encrypted = details.find { |detail| detail['type'] == 'reasoning.encrypted' && detail['data'].is_a?(String) }
+          encrypted&.dig('data')
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/openrouter.rb

@@ -4,7 +4,9 @@ module RubyLLM
   module Providers
     # OpenRouter API integration.
     class OpenRouter < OpenAI
+      include OpenRouter::Chat
       include OpenRouter::Models
+      include OpenRouter::Streaming
 
       def api_base
         'https://openrouter.ai/api/v1'

data/lib/ruby_llm/providers/vertexai.rb

@@ -16,7 +16,11 @@ module RubyLLM
       end
 
       def api_base
-        "https://#{@config.vertexai_location}-aiplatform.googleapis.com/v1beta1"
+        if @config.vertexai_location.to_s == 'global'
+          'https://aiplatform.googleapis.com/v1beta1'
+        else
+          "https://#{@config.vertexai_location}-aiplatform.googleapis.com/v1beta1"
+        end
       end
 
       def headers

data/lib/ruby_llm/stream_accumulator.rb

@@ -7,11 +7,16 @@ module RubyLLM
 
     def initialize
       @content = +''
+      @thinking_text = +''
+      @thinking_signature = nil
       @tool_calls = {}
       @input_tokens = nil
       @output_tokens = nil
       @cached_tokens = nil
       @cache_creation_tokens = nil
+      @thinking_tokens = nil
+      @inside_think_tag = false
+      @pending_think_tag = +''
       @latest_tool_call_id = nil
     end
 
@@ -19,12 +24,8 @@ module RubyLLM
       RubyLLM.logger.debug chunk.inspect if RubyLLM.config.log_stream_debug
       @model_id ||= chunk.model_id
 
-      if chunk.tool_call?
-        accumulate_tool_calls chunk.tool_calls
-      else
-        @content << (chunk.content || '')
-      end
-
+      handle_chunk_content(chunk)
+      append_thinking_from_chunk(chunk)
       count_tokens chunk
       RubyLLM.logger.debug inspect if RubyLLM.config.log_stream_debug
     end
@@ -33,12 +34,19 @@ module RubyLLM
       Message.new(
         role: :assistant,
         content: content.empty? ? nil : content,
+        thinking: Thinking.build(
+          text: @thinking_text.empty? ? nil : @thinking_text,
+          signature: @thinking_signature
+        ),
+        tokens: Tokens.build(
+          input: @input_tokens,
+          output: @output_tokens,
+          cached: @cached_tokens,
+          cache_creation: @cache_creation_tokens,
+          thinking: @thinking_tokens
+        ),
         model_id: model_id,
         tool_calls: tool_calls_from_stream,
-        input_tokens: @input_tokens,
-        output_tokens: @output_tokens,
-        cached_tokens: @cached_tokens,
-        cache_creation_tokens: @cache_creation_tokens,
         raw: response
       )
     end
@@ -58,12 +66,13 @@ module RubyLLM
         ToolCall.new(
           id: tc.id,
           name: tc.name,
-          arguments: arguments
+          arguments: arguments,
+          thought_signature: tc.thought_signature
         )
       end
     end
 
-    def accumulate_tool_calls(new_tool_calls)
+    def accumulate_tool_calls(new_tool_calls) # rubocop:disable Metrics/PerceivedComplexity
       RubyLLM.logger.debug "Accumulating tool calls: #{new_tool_calls}" if RubyLLM.config.log_stream_debug
       new_tool_calls.each_value do |tool_call|
         if tool_call.id
@@ -72,12 +81,18 @@ module RubyLLM
           @tool_calls[tool_call.id] = ToolCall.new(
             id: tool_call_id,
             name: tool_call.name,
-            arguments: tool_call_arguments
+            arguments: tool_call_arguments,
+            thought_signature: tool_call.thought_signature
           )
           @latest_tool_call_id = tool_call.id
         else
           existing = @tool_calls[@latest_tool_call_id]
-          existing.arguments << tool_call.arguments if existing
+          if existing
+            existing.arguments << tool_call.arguments
+            if tool_call.thought_signature && existing.thought_signature.nil?
+              existing.thought_signature = tool_call.thought_signature
+            end
+          end
         end
       end
     end
@@ -96,6 +111,88 @@ module RubyLLM
       @output_tokens = chunk.output_tokens if chunk.output_tokens
       @cached_tokens = chunk.cached_tokens if chunk.cached_tokens
       @cache_creation_tokens = chunk.cache_creation_tokens if chunk.cache_creation_tokens
+      @thinking_tokens = chunk.thinking_tokens if chunk.thinking_tokens
+    end
+
+    def handle_chunk_content(chunk)
+      return accumulate_tool_calls(chunk.tool_calls) if chunk.tool_call?
+
+      content_text = chunk.content || ''
+      if content_text.is_a?(String)
+        append_text_with_thinking(content_text)
+      else
+        @content << content_text.to_s
+      end
+    end
+
+    def append_text_with_thinking(text)
+      content_chunk, thinking_chunk = extract_think_tags(text)
+      @content << content_chunk
+      @thinking_text << thinking_chunk if thinking_chunk
+    end
+
+    def append_thinking_from_chunk(chunk)
+      thinking = chunk.thinking
+      return unless thinking
+
+      @thinking_text << thinking.text.to_s if thinking.text
+      @thinking_signature ||= thinking.signature # rubocop:disable Naming/MemoizedInstanceVariableName
+    end
+
+    def extract_think_tags(text)
+      start_tag = '<think>'
+      end_tag = '</think>'
+      remaining = @pending_think_tag + text
+      @pending_think_tag = +''
+
+      output = +''
+      thinking = +''
+
+      until remaining.empty?
+        remaining = if @inside_think_tag
+                      consume_think_content(remaining, end_tag, thinking)
+                    else
+                      consume_non_think_content(remaining, start_tag, output)
+                    end
+      end
+
+      [output, thinking.empty? ? nil : thinking]
+    end
+
+    def consume_think_content(remaining, end_tag, thinking)
+      end_index = remaining.index(end_tag)
+      if end_index
+        thinking << remaining.slice(0, end_index)
+        @inside_think_tag = false
+        remaining.slice((end_index + end_tag.length)..) || +''
+      else
+        suffix_len = longest_suffix_prefix(remaining, end_tag)
+        thinking << remaining.slice(0, remaining.length - suffix_len)
+        @pending_think_tag = remaining.slice(-suffix_len, suffix_len)
+        +''
+      end
+    end
+
+    def consume_non_think_content(remaining, start_tag, output)
+      start_index = remaining.index(start_tag)
+      if start_index
+        output << remaining.slice(0, start_index)
+        @inside_think_tag = true
+        remaining.slice((start_index + start_tag.length)..) || +''
+      else
+        suffix_len = longest_suffix_prefix(remaining, start_tag)
+        output << remaining.slice(0, remaining.length - suffix_len)
+        @pending_think_tag = remaining.slice(-suffix_len, suffix_len)
+        +''
+      end
+    end
+
+    def longest_suffix_prefix(text, tag)
+      max = [text.length, tag.length - 1].min
+      max.downto(1) do |len|
+        return len if text.end_with?(tag[0, len])
+      end
+      0
     end
   end
 end