ruby_llm 2.0.0.rc3 → 2.0.0

data/lib/ruby_llm/moderation.rb

@@ -104,7 +104,7 @@ module RubyLLM
       empty_tokens = Tokens.new
       payload = {
         provider: provider_instance.slug,
-        provider_class: provider_instance.class.display_name,
+        provider_class: provider_instance.name,
         model: model&.id,
         model_info: model,
         input: input,

data/lib/ruby_llm/ocr.rb

@@ -62,7 +62,7 @@ module RubyLLM
                                                        config: config)
       payload = {
         provider: provider_instance.slug,
-        provider_class: provider_instance.class.display_name,
+        provider_class: provider_instance.name,
         model: model.id,
         model_info: model,
         pages: pages,

data/lib/ruby_llm/protocol.rb

@@ -96,13 +96,13 @@ module RubyLLM
 
     def complete(messages, tools:, temperature:, provider_options: {}, headers: {}, schema: nil, thinking: nil,
                  max_output_tokens: nil, citations: false, caching: nil, tool_prefs: nil, before_request: [],
-                 usage_recorder: nil, server_tools: [], compaction: nil, end_user: nil, &)
-      resolution = resolve_server_tools_for_request(server_tools)
+                 usage_recorder: nil, provider_tools: [], compaction: nil, end_user: nil, &)
+      resolution = resolve_provider_tools_for_request(provider_tools)
       headers = resolution.headers.merge(headers) if resolution
       headers = apply_compaction_headers(headers, compaction) if compaction
       payload = render(
         messages, tools:, tool_prefs:, temperature:, max_output_tokens:, provider_options:, schema:, thinking:,
-                  citations:, caching:, compaction:, end_user:, before_request:, server_tools:,
+                  citations:, caching:, compaction:, end_user:, before_request:, provider_tools:,
                   stream: block_given?
       )
 
@@ -122,7 +122,7 @@ module RubyLLM
 
     def render(messages, tools:, temperature:, provider_options: {}, schema: nil, thinking: nil,
                max_output_tokens: nil, citations: false, caching: nil, tool_prefs: nil, before_request: [],
-               stream: false, server_tools: [], compaction: nil, end_user: nil)
+               stream: false, provider_tools: [], compaction: nil, end_user: nil)
       payload = render_payload(
         messages,
         tools: tools,
@@ -139,7 +139,7 @@ module RubyLLM
       payload = apply_end_user(payload, end_user) if end_user
       payload = apply_compaction(payload, compaction) if compaction
       payload = Support::Utils.deep_merge(payload, provider_options)
-      payload = apply_server_tools(payload, server_tools)
+      payload = apply_provider_tools(payload, provider_tools)
       apply_before_request_hooks(payload, before_request)
     rescue NotImplementedError
       raise Error, "#{@provider.name} doesn't support chat"
@@ -188,8 +188,8 @@ module RubyLLM
     end
 
     # The alias table mapping portable server tool names to this protocol's
-    # wire format. Protocols with server-tool support override this;
-    # +nil+ means the protocol has no server-tool support at all.
+    # wire format. Protocols with provider-tool support override this;
+    # +nil+ means the protocol has no provider-tool support at all.
     def server_tool_aliases
       nil
     end
@@ -471,6 +471,7 @@ module RubyLLM
     end
 
     def preprocess_message(message)
+      return message.without_thinking if foreign_thinking?(message)
       return message unless auto_upload_large_files?
       return message unless message.role == :user
       return message if message.attachments.empty?
@@ -483,21 +484,43 @@ module RubyLLM
 
     private
 
-    def resolve_server_tools_for_request(entries)
+    # A thinking signature is opaque to every provider but the one that
+    # issued it, so a message another provider produced replays without
+    # its thinking. A message with no known producer replays as it is.
+    def foreign_thinking?(message)
+      return false unless message.role == :assistant && carries_thinking?(message)
+
+      producer = producer_slug(message)
+      !producer.nil? && producer != @provider.slug
+    end
+
+    def carries_thinking?(message)
+      return true if message.thinking || message.raw_reasoning
+
+      message.tool_call? && message.tool_calls.each_value.any?(&:thought_signature)
+    end
+
+    # Only a usage entry names the producer: a model id alone can belong
+    # to several providers.
+    def producer_slug(message)
+      message.ruby_llm_usage_entries.reverse.find(&:succeeded?)&.provider
+    end
+
+    def resolve_provider_tools_for_request(entries)
       return nil if entries.nil? || entries.empty?
 
       aliases = server_tool_aliases
       unless aliases
         raise UnsupportedServerToolError,
-              "#{@provider.name} has no server-tool support through RubyLLM yet. " \
+              "#{@provider.name} has no provider-tool support through RubyLLM yet. " \
               'Request options in the provider vocabulary can be set with with_provider_options.'
       end
 
-      RubyLLM::Tools::ServerTools.resolve(entries, aliases: aliases, owner: @provider.name)
+      RubyLLM::Tools::ProviderTools.resolve(entries, aliases: aliases, owner: @provider.name)
     end
 
-    def apply_server_tools(payload, entries)
-      resolution = resolve_server_tools_for_request(entries)
+    def apply_provider_tools(payload, entries)
+      resolution = resolve_provider_tools_for_request(entries)
       return payload unless resolution
 
       payload = Support::Utils.deep_merge(payload, resolution.payload) unless resolution.payload.empty?
@@ -505,7 +528,7 @@ module RubyLLM
       payload
     end
 
-    # Server tools join function tools in the payload's tools array. The
+    # Provider tools join function tools in the payload's tools array. The
     # entry shape comes from the alias table or the caller's raw Hash.
     def merge_server_tool_entries(payload, entries)
       payload[:tools] = Array(payload[:tools]) + entries

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

@@ -39,13 +39,12 @@ module RubyLLM
           warn_unsupported_citations(model) if citations && !model.supports?(:citations)
           tool_prefs ||= {}
           system_messages, chat_messages = separate_messages(messages)
-          explicit_boundaries = cache_boundaries?(messages, caching:)
           system_content = build_system_content(system_messages, caching:)
 
           build_base_payload(chat_messages, model, stream, thinking, citations: citations, caching:,
                                                                      max_output_tokens:).tap do |payload|
             add_optional_fields(payload, system_content:, tools:, tool_prefs:, temperature:, schema:)
-            payload[:cache_control] = prompt_cache_control(caching) if caching && !explicit_boundaries
+            payload[:cache_control] = prompt_cache_control(caching) if caching
           end
         end
 
@@ -429,10 +428,6 @@ module RubyLLM
           content_blocks.concat(Media.format_content(msg.content, msg.attachments, citations: citations))
         end
 
-        def cache_boundaries?(messages, caching: nil)
-          caching != false && messages.any?(&:cache_until_here?)
-        end
-
         def cache_boundary?(message, caching: nil)
           caching != false && message.cache_until_here?
         end

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

@@ -87,7 +87,7 @@ module RubyLLM
           payload[:reasoning_effort] = effort if effort
 
           payload[:stream_options] = { include_usage: true } if stream
-          apply_prompt_cache_params(payload, messages, caching)
+          apply_prompt_cache_params(payload, caching)
           payload
         end
 
@@ -250,11 +250,10 @@ module RubyLLM
           end
         end
 
-        def apply_prompt_cache_params(payload, messages, caching)
+        def apply_prompt_cache_params(payload, caching)
           return unless openai_prompt_caching?
 
           payload.merge!(prompt_cache_params(caching)) if caching
-          force_explicit_cache_mode(payload) if caching != false && cache_boundaries?(messages)
         end
 
         def openai_prompt_caching?
@@ -290,14 +289,6 @@ module RubyLLM
           retention
         end
 
-        def force_explicit_cache_mode(payload)
-          payload[:prompt_cache_options] = { mode: 'explicit' }.merge(payload[:prompt_cache_options] || {})
-        end
-
-        def cache_boundaries?(messages)
-          messages.any?(&:cache_until_here?)
-        end
-
         def prompt_cache_options(caching)
           options = caching.to_h.transform_keys(&:to_sym)
           unsupported = options.keys - PROMPT_CACHE_OPTIONS

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

@@ -266,7 +266,6 @@ module RubyLLM
 
         def automatic_cache_target(system_messages, chat_messages, caching)
           return unless caching
-          return if (system_messages + chat_messages).any?(&:cache_until_here?)
 
           (chat_messages.reverse + system_messages.reverse).find { |msg| cacheable_message?(msg) }
         end

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

@@ -12,7 +12,6 @@ module RubyLLM
         OPENAI_INLINE_FILE_LIMIT = 50 * 1024 * 1024
         OPENAI_FILE_UPLOAD_LIMIT = 512 * 1024 * 1024
         PROMPT_CACHE_OPTIONS = %i[key ttl mode retention].freeze
-        CACHE_BREAKPOINT_ROLES = %i[user system].freeze
 
         module_function
 
@@ -47,7 +46,6 @@ module RubyLLM
           payload[:reasoning] = { effort: effort } if effort
           payload[:reasoning] = (payload[:reasoning] || {}).merge(summary: 'auto') if thinking&.display == :summarized
           payload.merge!(prompt_cache_params(caching)) if caching
-          force_explicit_cache_mode(payload) if caching != false && cache_boundaries?(messages)
 
           payload
         end
@@ -225,14 +223,6 @@ module RubyLLM
           retention
         end
 
-        def force_explicit_cache_mode(payload)
-          payload[:prompt_cache_options] = { mode: 'explicit' }.merge(payload[:prompt_cache_options] || {})
-        end
-
-        def cache_boundaries?(messages)
-          messages.any? { |msg| msg.cache_until_here? && CACHE_BREAKPOINT_ROLES.include?(msg.role) }
-        end
-
         def prompt_cache_options(caching)
           options = caching.to_h.transform_keys(&:to_sym)
           unsupported = options.keys - PROMPT_CACHE_OPTIONS

data/lib/ruby_llm/protocols/vertexai/research.rb

@@ -21,9 +21,9 @@ module RubyLLM
 
         def server_tool_aliases = SERVER_TOOL_ALIASES
 
-        def create_research_job(prompt, agent:, with: nil, server_tools: nil, provider_options: {})
+        def create_research_job(prompt, agent:, with: nil, provider_tools: nil, provider_options: {})
           validate_research_agent(agent)
-          payload = render_research_payload(prompt, agent:, with:, server_tools:, provider_options:)
+          payload = render_research_payload(prompt, agent:, with:, provider_tools:, provider_options:)
           response = @connection.post(research_url, payload, idempotent: false)
           parse_research_job(response, agent:)
         end
@@ -71,20 +71,20 @@ module RubyLLM
           raise ArgumentError, 'Vertex AI research requires the supported Deep Research agent ID'
         end
 
-        def render_research_payload(prompt, agent:, with:, server_tools:, provider_options:)
+        def render_research_payload(prompt, agent:, with:, provider_tools:, provider_options:)
           raise ArgumentError, 'Research requires a nonempty prompt' unless prompt.is_a?(String) && !prompt.empty?
 
           attachments = Attachment.wrap(with, config: @config)
           validate_research_attachments(attachments)
           payload = { agent:, input: render_interaction_content(prompt, attachments), background: true, stream: false }
-          payload[:tools] = [] unless server_tools.nil?
+          payload[:tools] = [] unless provider_tools.nil?
           options = render_research_options(provider_options)
-          entries = if server_tools.is_a?(Hash)
-                      RubyLLM::Tools::ServerTools.normalize([], server_tools)
+          entries = if provider_tools.is_a?(Hash)
+                      RubyLLM::Tools::ProviderTools.normalize([], provider_tools)
                     else
-                      RubyLLM::Tools::ServerTools.normalize(Array(server_tools), {})
+                      RubyLLM::Tools::ProviderTools.normalize(Array(provider_tools), {})
                     end
-          apply_server_tools(payload, entries).merge(options)
+          apply_provider_tools(payload, entries).merge(options)
         end
 
         def validate_research_attachments(attachments)

data/lib/ruby_llm/provider.rb

@@ -130,13 +130,13 @@ module RubyLLM
 
     def complete(messages, tools:, temperature:, model:, provider_options: {}, headers: {}, schema: nil, # :nodoc:
                  max_output_tokens: nil, thinking: nil, citations: false, caching: nil, tool_prefs: nil,
-                 protocol: nil, before_request: [], usage_recorder: nil, server_tools: [],
+                 protocol: nil, before_request: [], usage_recorder: nil, provider_tools: [],
                  compaction: nil, end_user: nil, &)
       protocol_class = resolve_protocol(protocol, model, tools:, schema:, thinking:, tool_prefs:, citations:)
       protocol_class.new(self, model).complete(
         messages,
         tools: tools,
-        server_tools: server_tools,
+        provider_tools: provider_tools,
         tool_prefs: tool_prefs,
         temperature: temperature,
         max_output_tokens: max_output_tokens,
@@ -166,12 +166,12 @@ module RubyLLM
 
     def render(messages, tools:, temperature:, model:, provider_options: {}, schema: nil, thinking: nil, # :nodoc:
                max_output_tokens: nil, citations: false, caching: nil, tool_prefs: nil, protocol: nil,
-               before_request: [], server_tools: [], compaction: nil, end_user: nil)
+               before_request: [], provider_tools: [], compaction: nil, end_user: nil)
       protocol_class = resolve_protocol(protocol, model, tools:, schema:, thinking:, tool_prefs:, citations:)
       protocol_class.new(self, model).render(
         messages,
         tools: tools,
-        server_tools: server_tools,
+        provider_tools: provider_tools,
         tool_prefs: tool_prefs,
         temperature: temperature,
         max_output_tokens: max_output_tokens,

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

@@ -44,10 +44,14 @@ module RubyLLM
           payload = super
           payload.delete(:reasoning_effort)
           strip_schema_strict(payload)
+          if tool_prefs&.dig(:choice) == :none
+            payload.delete(:tools)
+            payload.delete(:parallel_tool_calls)
+          end
 
           reasoning = build_reasoning(thinking)
           payload[:reasoning] = reasoning if reasoning
-          payload[:cache_control] = prompt_cache_control(caching) if caching && !cache_boundaries?(messages)
+          payload[:cache_control] = prompt_cache_control(caching) if caching
           payload
         end
 
@@ -142,10 +146,6 @@ module RubyLLM
           keys.map { |key| ":#{key}" }.join(', ')
         end
 
-        def cache_boundaries?(messages)
-          messages.any?(&:cache_until_here?)
-        end
-
         def openai_prompt_caching?
           false
         end

data/lib/ruby_llm/rerank.rb

@@ -81,7 +81,7 @@ module RubyLLM
       empty_tokens = Tokens.new
       payload = {
         provider: provider_instance.slug,
-        provider_class: provider_instance.class.display_name,
+        provider_class: provider_instance.name,
         model: model.id,
         model_info: model,
         query: query,

data/lib/ruby_llm/research_job.rb

@@ -67,15 +67,15 @@ module RubyLLM
 
     # Submits one research task without waiting. +provider:+ and +agent:+
     # are required; +with:+ attaches documents or images where supported.
-    # +server_tools:+ accepts an array of aliases or a Hash of aliases
-    # and their options, as on Chat#with_server_tools.
-    def self.research_later(prompt, provider:, agent:, with: nil, server_tools: nil,
+    # +provider_tools:+ accepts an array of aliases or a Hash of aliases
+    # and their options, as on Chat#with_provider_tools.
+    def self.research_later(prompt, provider:, agent:, with: nil, provider_tools: nil,
                             context: nil, provider_options: {}, metadata: nil)
       config = context&.config || RubyLLM.config
       instance = Provider.resolve!(provider).new(config)
       payload = { provider: instance.slug, agent:, prompt:, metadata: }
       RubyLLM.instrument('research_job.ruby_llm', payload, config:) do |event|
-        job = instance.research_later(prompt, agent:, with:, server_tools:, provider_options:)
+        job = instance.research_later(prompt, agent:, with:, provider_tools:, provider_options:)
         event[:job_id] = job.id
         event[:status] = job.status
         job

data/lib/ruby_llm/server_tool_call.rb

@@ -5,9 +5,9 @@ module RubyLLM
   # response: a web search the model ran, a code execution, or the results
   # block a provider returned for one. They appear on
   # Message#server_tool_calls when a chat enables tools with
-  # Chat#with_server_tools.
+  # Chat#with_provider_tools.
   #
-  #   response = chat.with_server_tools(:web_search).ask "What changed in Ruby 3.5?"
+  #   response = chat.with_provider_tools(:web_search).ask "What changed in Ruby 3.5?"
   #   response.server_tool_calls.map(&:type) # => ["server_tool_use", "web_search_tool_result"]
   #
   # RubyLLM does not model each tool's result schema. #raw always holds the

data/lib/ruby_llm/speech.rb

@@ -91,7 +91,7 @@ module RubyLLM
 
       payload = {
         provider: provider_instance.slug,
-        provider_class: provider_instance.class.display_name,
+        provider_class: provider_instance.name,
         model: model.id,
         model_info: model,
         input: input,

data/lib/ruby_llm/tools/{server_tools.rb → provider_tools.rb}

@@ -2,12 +2,12 @@
 
 module RubyLLM
   module Tools # :nodoc:
-    # Normalizes and resolves the server tools a chat enabled with
-    # Chat#with_server_tools. Protocols declare an alias table mapping portable
+    # Normalizes and resolves the provider tools a chat enabled with
+    # Chat#with_provider_tools. Protocols declare an alias table mapping portable
     # names such as +:web_search+ to their wire format; raw Hashes pass through
     # verbatim so new provider tools work without a gem update. :nodoc:
-    module ServerTools # :nodoc: all
-      # The result of resolving a chat's server tools against a protocol's
+    module ProviderTools # :nodoc: all
+      # The result of resolving a chat's provider tools against a protocol's
       # alias table: tool entries for the payload's tools slot, extra payload
       # fields to merge, and request headers to add.
       class Resolution
@@ -61,7 +61,7 @@ module RubyLLM
 
       module_function
 
-      # Normalizes with_server_tools arguments into entry hashes:
+      # Normalizes with_provider_tools arguments into entry hashes:
       # {name:, options:} for aliases and {raw:} for verbatim tool specs.
       def normalize(tools, tools_with_options)
         entries = tools.compact.map { |tool| normalize_positional(tool) }
@@ -74,13 +74,13 @@ module RubyLLM
         when Hash then normalized_entry?(tool) ? tool : { raw: tool }
         else
           raise ArgumentError,
-                "Server tools must be Symbols or Hashes, got #{tool.class}. " \
+                "Provider tools must be Symbols or Hashes, got #{tool.class}. " \
                 'Pass :web_search for a portable alias or the provider\'s tool definition as a Hash.'
         end
       end
 
       # Entries that already went through normalize (an Agent's declared
-      # server_tools, for example) pass through unchanged.
+      # provider_tools, for example) pass through unchanged.
       def normalized_entry?(hash)
         hash.key?(:raw) ? hash.size == 1 : hash.size == 2 && hash.key?(:name) && hash.key?(:options)
       end

data/lib/ruby_llm/transcription.rb

@@ -132,7 +132,7 @@ module RubyLLM
       empty_tokens = Tokens.new
       payload = {
         provider: provider_instance.slug,
-        provider_class: provider_instance.class.display_name,
+        provider_class: provider_instance.name,
         model: model.id,
         model_info: model,
         language: language,

data/lib/ruby_llm/version.rb

@@ -2,5 +2,5 @@
 
 module RubyLLM
   # The version of the ruby_llm gem, as a string.
-  VERSION = '2.0.0.rc3'
+  VERSION = '2.0.0'
 end

data/lib/ruby_llm/video_job.rb

@@ -50,7 +50,7 @@ module RubyLLM
                                                        config: config)
       payload = {
         provider: provider_instance.slug,
-        provider_class: provider_instance.class.display_name,
+        provider_class: provider_instance.name,
         model: model.id,
         model_info: model,
         prompt: prompt,

data/lib/ruby_llm.rb

@@ -44,7 +44,7 @@ loader.setup
 
 # RubyLLM is an AI framework for Ruby and Rails. Build conversations and
 # agents, generate media, process documents, and work with model providers
-# through one Ruby API. The guides at https://rubyllm.com/next/ introduce
+# through one Ruby API. The guides at https://rubyllm.com/ introduce
 # each feature; this reference documents its classes, arguments, and results.
 #
 #   RubyLLM.configure do |config|
@@ -75,7 +75,7 @@ loader.setup
 #
 # Subclass Tool and implement +execute+ to give the model an application
 # action. Tool.requires_approval pauses execution for a human decision;
-# Chat#approve and Chat#deny record it. Chat#with_server_tools enables
+# Chat#approve and Chat#deny record it. Chat#with_provider_tools enables
 # provider-executed tools such as web search, code execution, and remote MCP.
 # Their calls appear as ServerToolCall values, with Citation values for sources.
 #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc3
+  version: 2.0.0
 platform: ruby
 authors:
 - Carmine Paolino
@@ -589,7 +589,7 @@ files:
 - lib/ruby_llm/tokens.rb
 - lib/ruby_llm/tool.rb
 - lib/ruby_llm/tool_call.rb
-- lib/ruby_llm/tools/server_tools.rb
+- lib/ruby_llm/tools/provider_tools.rb
 - lib/ruby_llm/transcription.rb
 - lib/ruby_llm/transcription/wav_audio.rb
 - lib/ruby_llm/transcription_chunk.rb
@@ -612,24 +612,24 @@ metadata:
   homepage_uri: https://rubyllm.com
   source_code_uri: https://github.com/crmne/ruby_llm
   changelog_uri: https://github.com/crmne/ruby_llm/releases
-  documentation_uri: https://rubyllm.com/next/
+  documentation_uri: https://rubyllm.com/
   bug_tracker_uri: https://github.com/crmne/ruby_llm/issues
   funding_uri: https://github.com/sponsors/crmne
   rubygems_mfa_required: 'true'
 post_install_message: |
-  RubyLLM 2.0.0.rc3
+  RubyLLM 2.0.0
 
     2.0 renames several APIs and changes what message content returns. Coming
     from 1.x? Read the upgrade guide before you boot:
 
-      https://rubyllm.com/next/upgrading/
+      https://rubyllm.com/upgrading/
 
     The Rails upgrade uses forward-only preparation, backfill, and finish
     phases, with cleanup later. Rename mode is the default; optional copy
     mode supports a controlled return to 1.16. Read its requirements in the
     upgrade guide and rehearse on a recent production snapshot.
 
-    Agent skill: https://rubyllm.com/next/ai-coding-assistants/
+    Agent skill: https://rubyllm.com/ai-coding-assistants/
 rdoc_options: []
 require_paths:
 - lib
@@ -644,7 +644,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: 'Build AI features the Ruby way: a delightful Ruby AI framework for every
   major AI provider.'