ruby_llm 2.0.0.rc4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c047801a2b7a5a642296f0ae84e81ab29b641353ffe8618b3ece44db0b0a3849
-  data.tar.gz: 05e4624f14a8e2045408dd21007758612f0644522bae4e250902fd60d66955e1
+  metadata.gz: 42dd9dfdb910f8e5df4eb6114ed59586a13e4a51797173d3f3bdb13b6d59c28b
+  data.tar.gz: fa4e0aa374c915ab5e97146bcacb438fc2c3fca0c029ed51c1aea6c934769da8
 SHA512:
-  metadata.gz: 6e73e5f6818e70c607c3cabfc6e0dfb19f9271491375b71279e0a205f2ecff8fe0051c691c51230644d32f7ad8f377b8f8bddfcae919e33ff64015ccd9a942e7
-  data.tar.gz: fd4285734764621dc2cab77579b8c713aaff907930c1b6849472c470839b2a75e6975832baf4e43adeedd1d3326b92af816af4a63242bdfa2585fab2b72fdc58
+  metadata.gz: 3e5489b6fdd071de5c4281c9cc8eff9d345dd10876cb6773144873d2e58c3ec400109d208706d4c04c12d93328f5864f839907521fd751accc29aa9a5a753602
+  data.tar.gz: 19c33af936f0626262ad3e469c955b98aee8599b15fe088ba745e31584f91ebbf166cabc981bef4bef526f6e6c96800aebe07dc133ca732313ca58598aa6273f

data/README.md

@@ -34,7 +34,7 @@ Build with the models you want. Move between hosted and local providers without
 
 ## Start with one line. Add files, tools, and agents
 
-These examples use **2.0.0.rc4 (prerelease)**. Follow [Getting Started](https://rubyllm.com/getting-started/) to install it and configure the providers you want to try. For 1.x, use the [stable-version docs](https://rubyllm.com/v1/).
+These examples use **2.0.0**. Follow [Getting Started](https://rubyllm.com/getting-started/) to install it and configure the providers you want to try. For 1.x, use the [1.x docs](https://rubyllm.com/v1/).
 
 ```ruby
 # Just ask
@@ -167,7 +167,7 @@ Agents, workflows, RAG, images, audio, and video. Built in, with usage tracking
 * **Tools:** Let AI call your Ruby methods
 * **Tool approval:** Park a run until a human approves with `requires_approval`
 * **The agentic loop:** Drive it yourself with `ask_later`, `step`, and `complete?`
-* **Server tools:** Web search, code execution, and MCP connectors with `with_server_tools`
+* **Provider tools:** Web search, code execution, and MCP connectors with `with_provider_tools`
 * **Agents:** Reusable assistants with `RubyLLM::Agent`
 * **Prompt templates:** ERB prompts in `app/prompts`, rendered with `RubyLLM.render_prompt`
 * **Workflows:** Correlate multi-agent runs in your telemetry with `RubyLLM.workflow`
@@ -189,10 +189,10 @@ Agents, workflows, RAG, images, audio, and video. Built in, with usage tracking
 
 ## Installation
 
-Install the 2.0 release candidate:
+Install RubyLLM 2.0:
 
 ```bash
-bundle add ruby_llm --version 2.0.0.rc4
+bundle add ruby_llm --version 2.0.0
 ```
 
 Configure a provider in your script, or in `config/initializers/ruby_llm.rb` in Rails:

data/lib/generators/ruby_llm/generator_helpers.rb

@@ -138,7 +138,10 @@ module RubyLLM
       end
 
       def reference_type
-        Rails.application.config.generators.options.dig(:active_record, :primary_key_type) || :bigint
+        application = Rails.application if Rails.respond_to?(:application)
+        return :bigint unless application
+
+        application.config.generators.options.dig(:active_record, :primary_key_type) || :bigint
       end
 
       def create_migration_class_name(table_name)

data/lib/generators/ruby_llm/install/templates/create_chats_migration.rb.tt

@@ -1,6 +1,6 @@
 class <%= create_migration_class_name(chat_table_name) %> < ActiveRecord::Migration<%= migration_version %>
   def change
-    create_table :<%= chat_table_name %> do |t|
+    create_table :<%= chat_table_name %>, id: :<%= reference_type %> do |t|
       t.references :ruby_llm_model, null: false, foreign_key: { to_table: :ruby_llm_models }, type: :<%= reference_type %>
       t.boolean :cancelled, null: false, default: false
       t.timestamps

data/lib/generators/ruby_llm/install/templates/create_messages_migration.rb.tt

@@ -1,6 +1,6 @@
 class <%= create_migration_class_name(message_table_name) %> < ActiveRecord::Migration<%= migration_version %>
   def change
-    create_table :<%= message_table_name %> do |t|
+    create_table :<%= message_table_name %>, id: :<%= reference_type %> do |t|
       t.references :<%= chat_table_name.singularize %>, null: false, foreign_key: { to_table: :<%= chat_table_name %> }, type: :<%= reference_type %>
       t.string :role, null: false
       t.text :content

data/lib/generators/ruby_llm/install/templates/create_ruby_llm_records_migration.rb.tt

@@ -1,6 +1,6 @@
-class CreateRubyLlmRecords < ActiveRecord::Migration<%= migration_version %>
+class <%= create_migration_class_name('ruby_llm_records') %> < ActiveRecord::Migration<%= migration_version %>
   def change
-    create_table :ruby_llm_models do |t|
+    create_table :ruby_llm_models, id: :<%= reference_type %> do |t|
       t.string :model_id, null: false
       t.string :name, null: false
       t.string :provider, null: false
@@ -37,7 +37,7 @@ class CreateRubyLlmRecords < ActiveRecord::Migration<%= migration_version %>
 <% end -%>
     end
 
-    create_table :ruby_llm_tool_calls do |t|
+    create_table :ruby_llm_tool_calls, id: :<%= reference_type %> do |t|
       t.references :message, polymorphic: true, null: false, type: :<%= reference_type %>, index: false
       t.references :result, polymorphic: true, type: :<%= reference_type %>, index: false
       t.string :tool_call_id, null: false
@@ -60,7 +60,7 @@ class CreateRubyLlmRecords < ActiveRecord::Migration<%= migration_version %>
       t.index :name
     end
 
-    create_table :ruby_llm_usages do |t|
+    create_table :ruby_llm_usages, id: :<%= reference_type %> do |t|
       t.references :chat, polymorphic: true, null: false, type: :<%= reference_type %>, index: false
       t.references :message, polymorphic: true, type: :<%= reference_type %>, index: false
       t.string :operation, null: false
@@ -87,7 +87,7 @@ class CreateRubyLlmRecords < ActiveRecord::Migration<%= migration_version %>
       t.check_constraint "status IN (<%= usage_statuses_sql %>)"
     end
 
-    create_table :ruby_llm_batches do |t|
+    create_table :ruby_llm_batches, id: :<%= reference_type %> do |t|
       t.string :provider_batch_id, null: false
       t.string :provider, null: false
       t.string :status, null: false

data/lib/generators/ruby_llm/upgrade/templates/prepare_v2_upgrade.rb.tt

@@ -382,7 +382,7 @@ class <%= prepare_migration_class_name %> < ActiveRecord::Migration<%= migration
 
   def create_usages
     unless table_exists?(:ruby_llm_usages)
-      create_table :ruby_llm_usages do |table|
+      create_table :ruby_llm_usages, id: :<%= reference_type %> do |table|
         table.references :chat, polymorphic: true, null: false,
                                 type: reference_type_for(:<%= chat_table_name %>), index: false
         table.references :message, polymorphic: true,
@@ -417,7 +417,7 @@ class <%= prepare_migration_class_name %> < ActiveRecord::Migration<%= migration
 
   def create_batches
     unless table_exists?(:ruby_llm_batches)
-      create_table :ruby_llm_batches do |table|
+      create_table :ruby_llm_batches, id: :<%= reference_type %> do |table|
         table.string :provider_batch_id, null: false
         table.string :provider, null: false
         table.string :status, null: false

data/lib/ruby_llm/active_record/attachment_helpers.rb

@@ -58,18 +58,96 @@ module RubyLLM
       end
 
       def plain_text_content(content_value)
+        return action_text_plain_text(content_value) if action_text_content?(content_value)
         return content_value.to_plain_text if content_value.respond_to?(:to_plain_text)
 
         content_value
       end
 
       def action_text_attachment_sources(content_value)
-        return [] unless content_value.respond_to?(:body)
+        return [] unless action_text_content?(content_value)
 
+        action_text_attachables(content_value).flat_map do |attachable|
+          action_text_attachable_sources(attachable)
+        end.compact
+      end
+
+      def action_text_content?(content_value)
+        content_value.respond_to?(:body) && action_text_body?(content_value.body)
+      end
+
+      def preload_action_text_embeds(messages)
+        return unless defined?(ActionText::Attachment)
+
+        rich_texts = messages.filter_map do |message|
+          rich_text = message.rich_text_content
+          body = rich_text&.body
+          rich_text if action_text_body?(body) && action_text_embeds?(body)
+        end
+        return if rich_texts.empty?
+
+        ::ActiveRecord::Associations::Preloader.new(
+          records: rich_texts,
+          associations: { embeds_attachments: :blob }
+        ).call
+      end
+
+      def action_text_embeds?(body)
+        body.fragment.find_all(ActionText::Attachment.tag_name).any? { |node| action_text_blob_id(node) }
+      end
+
+      def action_text_body?(body)
+        defined?(ActionText::Attachment) && body.respond_to?(:fragment) && body.respond_to?(:attachables) &&
+          body.respond_to?(:sanitize_content_attachment)
+      end
+
+      def action_text_plain_text(content_value)
+        body = content_value.body
+        preloaded_blobs = action_text_preloaded_blobs(content_value).index_by { |blob| blob.id.to_s }
+        rendered = body.fragment.replace(ActionText::Attachment.tag_name) do |node|
+          if node.key?('content')
+            sanitized_content = body.sanitize_content_attachment(node.remove_attribute('content').to_s)
+            node['content'] = sanitized_content if sanitized_content.present?
+          end
+
+          attachable = action_text_attachable_for_node(node, preloaded_blobs)
+          ActionText::Attachment.from_node(node, attachable).to_plain_text
+        end
+
+        ActionText::Content.new(rendered, canonicalize: false).fragment.to_plain_text
+      end
+
+      def action_text_attachables(content_value)
         body = content_value.body
-        return [] unless body.respond_to?(:attachables)
+        preloaded_blobs = action_text_preloaded_blobs(content_value).index_by { |blob| blob.id.to_s }
+        body.fragment.find_all(ActionText::Attachment.tag_name).map do |node|
+          action_text_attachable_for_node(node, preloaded_blobs)
+        end
+      end
 
-        body.attachables.flat_map { |attachable| action_text_attachable_sources(attachable) }.compact
+      def action_text_attachable_for_node(node, preloaded_blobs)
+        preloaded_blobs[action_text_blob_id(node)] || ActionText::Attachable.from_node(node)
+      end
+
+      def action_text_blob_id(node)
+        sgid = node['sgid']
+        gid = SignedGlobalID.parse(sgid, for: ActionText::Attachable::LOCATOR_NAME) if sgid
+        return unless gid && gid.app == GlobalID.app && gid.model_name == ActiveStorage::Blob.name
+
+        gid.model_id.to_s
+      end
+
+      def action_text_preloaded_blobs(content_value)
+        return [] unless content_value.class.respond_to?(:reflect_on_association) &&
+                         content_value.class.reflect_on_association(:embeds_attachments)
+
+        association = content_value.association(:embeds_attachments)
+        return [] unless association.loaded?
+
+        content_value.embeds_attachments.filter_map do |attachment|
+          blob_association = attachment.association(:blob)
+          blob_association.target if blob_association.loaded?
+        end
       end
 
       def action_text_attachable_sources(attachable)

data/lib/ruby_llm/active_record/chat_methods.rb

@@ -212,7 +212,7 @@ module RubyLLM
       # RubyLLM::Chat. Each behaves exactly as documented on RubyLLM::Chat,
       # then returns the record so calls chain.
       CHAINABLE_CHAT_DELEGATES = %i[
-        with_tools with_tool_options with_server_tools with_fallbacks with_temperature
+        with_tools with_tool_options with_provider_tools with_fallbacks with_temperature
         with_max_output_tokens with_thinking with_citations with_caching
         with_end_user with_compaction
         with_provider_options with_headers with_schema
@@ -233,10 +233,10 @@ module RubyLLM
       # Applies Chat#with_tool_options and returns this record.
 
       ##
-      # :method: with_server_tools
-      # :call-seq: with_server_tools(*tools, **tools_with_options)
+      # :method: with_provider_tools
+      # :call-seq: with_provider_tools(*tools, **tools_with_options)
       #
-      # Applies Chat#with_server_tools and returns this record.
+      # Applies Chat#with_provider_tools and returns this record.
 
       ##
       # :method: with_fallbacks
@@ -407,10 +407,10 @@ module RubyLLM
       # Delegates to Chat#schema. See that method for arguments and return values.
 
       ##
-      # :method: server_tools
-      # :call-seq: server_tools
+      # :method: provider_tools
+      # :call-seq: provider_tools
       #
-      # Delegates to Chat#server_tools. See that method for arguments and return values.
+      # Delegates to Chat#provider_tools. See that method for arguments and return values.
 
       ##
       # :method: temperature
@@ -449,7 +449,7 @@ module RubyLLM
 
       PASSTHROUGH_CHAT_DELEGATES = %i[
         caching citations compaction concurrency end_user fallbacks headers max_output_tokens provider_options
-        schema server_tools temperature thinking tool_options tools
+        schema provider_tools temperature thinking tool_options tools
         add_completion count_tokens each render
       ].freeze
 
@@ -778,8 +778,11 @@ module RubyLLM
 
         associations = %i[ruby_llm_tool_calls ruby_llm_parent_tool_call ruby_llm_usages]
         associations << { attachments_attachments: :blob } if attachment_association?(assoc.klass)
+        rich_text_reflection = assoc.klass.reflect_on_association(:rich_text_content)
+        associations << :rich_text_content if rich_text_reflection
 
         ::ActiveRecord::Associations::Preloader.new(records: messages, associations: associations).call
+        preload_action_text_embeds(messages) if rich_text_reflection
         messages
       end
 

data/lib/ruby_llm/agent.rb

@@ -44,7 +44,7 @@ module RubyLLM
     DUPED_INHERITED_CONFIG = {
       :@chat_kwargs => {},
       :@tools => [],
-      :@server_tools => [],
+      :@provider_tools => [],
       :@tool_options => {},
       :@caching => nil,
       :@compaction => nil,
@@ -66,7 +66,7 @@ module RubyLLM
 
     # Chat methods that return the wrapped chat so calls can be chained there.
     CHAINABLE_CHAT_DELEGATES = %i[
-      with_instructions with_tools with_server_tools with_tool_options with_model
+      with_instructions with_tools with_provider_tools with_tool_options with_model
       with_temperature with_max_output_tokens with_thinking with_citations
       with_end_user with_compaction with_caching with_context with_provider_options
       with_headers with_schema with_fallbacks
@@ -77,7 +77,7 @@ module RubyLLM
 
     # Chat values and operations whose return values pass through unchanged.
     PASSTHROUGH_CHAT_DELEGATES = %i[
-      model provider messages tools server_tools tool_options provider_options headers schema concurrency
+      model provider messages tools provider_tools tool_options provider_options headers schema concurrency
       caching citations compaction context end_user fallbacks thinking temperature max_output_tokens
       each complete? cancelled? awaiting_approval? pending_approvals
       add_message add_completion tokens cost render
@@ -150,17 +150,17 @@ module RubyLLM
       end
 
       # Enables provider-executed tools for chats this agent builds, applied
-      # via Chat#with_server_tools. Accepts the same aliases, options, and
+      # via Chat#with_provider_tools. Accepts the same aliases, options, and
       # raw Hashes; a block defers evaluation until the chat is built.
       # Called with no arguments, returns the declared entries.
       #
-      #   server_tools :web_search
-      #   server_tools web_search: { allowed_domains: ["ruby-lang.org"] }
+      #   provider_tools :web_search
+      #   provider_tools web_search: { allowed_domains: ["ruby-lang.org"] }
       #
-      def server_tools(*tools, **tools_with_options, &block)
-        return @server_tools || [] if tools.empty? && tools_with_options.empty? && !block_given?
+      def provider_tools(*tools, **tools_with_options, &block)
+        return @provider_tools || [] if tools.empty? && tools_with_options.empty? && !block_given?
 
-        @server_tools = block_given? ? block : RubyLLM::Tools::ServerTools.normalize(tools, tools_with_options)
+        @provider_tools = block_given? ? block : RubyLLM::Tools::ProviderTools.normalize(tools, tools_with_options)
       end
 
       # Adds system instructions for chats this agent builds. Accepts a string,
@@ -667,8 +667,8 @@ module RubyLLM
         options = evaluate(tool_options, runtime)
         chat.with_tool_options(**options) if options && !options.empty?
 
-        server_tools_to_apply = Array(evaluate(server_tools, runtime)).compact
-        chat.with_server_tools(*server_tools_to_apply) if server_tools_to_apply.any?
+        provider_tools_to_apply = Array(evaluate(provider_tools, runtime)).compact
+        chat.with_provider_tools(*provider_tools_to_apply) if provider_tools_to_apply.any?
       end
 
       def apply_passthrough_options(chat)
@@ -873,10 +873,10 @@ module RubyLLM
     # Delegates to Chat#with_tools. See that method for arguments and return values.
 
     ##
-    # :method: with_server_tools
-    # :call-seq: with_server_tools(*tools, **tools_with_options)
+    # :method: with_provider_tools
+    # :call-seq: with_provider_tools(*tools, **tools_with_options)
     #
-    # Delegates to Chat#with_server_tools. See that method for arguments and return values.
+    # Delegates to Chat#with_provider_tools. See that method for arguments and return values.
 
     ##
     # :method: with_tool_options
@@ -1053,10 +1053,10 @@ module RubyLLM
     # Delegates to Chat#tools. See that method for arguments and return values.
 
     ##
-    # :method: server_tools
-    # :call-seq: server_tools
+    # :method: provider_tools
+    # :call-seq: provider_tools
     #
-    # Delegates to Chat#server_tools. See that method for arguments and return values.
+    # Delegates to Chat#provider_tools. See that method for arguments and return values.
 
     ##
     # :method: tool_options

data/lib/ruby_llm/chat.rb

@@ -42,9 +42,9 @@ module RubyLLM
     # The registered tools, as a Hash of tool name Symbols to Tool instances.
     attr_reader :tools
 
-    # The server tools enabled with #with_server_tools, as an array of
+    # The provider tools enabled with #with_provider_tools, as an array of
     # normalized entry Hashes.
-    attr_reader :server_tools
+    attr_reader :provider_tools
 
     # Extra request options set with #with_provider_options, expressed in
     # the provider's request vocabulary.
@@ -119,7 +119,7 @@ module RubyLLM
       @messages = []
       @usage_entries = []
       @tools = {}
-      @server_tools = []
+      @provider_tools = []
       @tool_prefs = { choice: nil, calls: nil }
       @concurrency = normalize_tool_concurrency(@config.tool_concurrency)
       @provider_options = {}
@@ -354,10 +354,10 @@ module RubyLLM
     # no alias for yet work without a gem update. Entries add to any tools
     # enabled earlier; pass +nil+ to clear them all. Returns +self+.
     #
-    #   chat.with_server_tools(:web_search)
-    #   chat.with_server_tools(:web_search, :code_execution)
-    #   chat.with_server_tools(web_search: { allowed_domains: ["ruby-lang.org"] })
-    #   chat.with_server_tools({ type: "web_search_20260318", name: "web_search" })
+    #   chat.with_provider_tools(:web_search)
+    #   chat.with_provider_tools(:web_search, :code_execution)
+    #   chat.with_provider_tools(web_search: { allowed_domains: ["ruby-lang.org"] })
+    #   chat.with_provider_tools({ type: "web_search_20260318", name: "web_search" })
     #
     # The tool steps the model ran come back on
     # Message#server_tool_calls, citations from search tools on
@@ -365,14 +365,14 @@ module RubyLLM
     # <tt>message.tokens.server_tool_use</tt>.
     #
     # Raises UnsupportedServerToolError at request time when the provider
-    # has no server-tool support or does not define a requested alias.
-    def with_server_tools(*tools, **tools_with_options)
+    # has no provider-tool support or does not define a requested alias.
+    def with_provider_tools(*tools, **tools_with_options)
       if tools == [nil] && tools_with_options.empty?
-        @server_tools = []
+        @provider_tools = []
         return self
       end
 
-      @server_tools += RubyLLM::Tools::ServerTools.normalize(tools, tools_with_options)
+      @provider_tools += RubyLLM::Tools::ProviderTools.normalize(tools, tools_with_options)
       self
     end
 
@@ -742,7 +742,7 @@ module RubyLLM
     #   chat.with_instructions("Be terse.").with_tools(Weather)
     #   chat.count_tokens("What's the weather in Berlin?")
     #
-    # Server tools, provider_options, compaction, and before_request hooks
+    # Provider tools, provider_options, compaction, and before_request hooks
     # are not included. Raises Error when the provider has no token counting
     # endpoint.
     def count_tokens(message = nil)
@@ -849,7 +849,7 @@ module RubyLLM
       @provider.render(
         preprocessed_messages,
         tools: @tools,
-        server_tools: @server_tools,
+        provider_tools: @provider_tools,
         tool_prefs: @tool_prefs,
         temperature: @temperature,
         max_output_tokens: @max_output_tokens,
@@ -1009,7 +1009,7 @@ module RubyLLM
         input_messages: messages.dup,
         message_count: messages.size,
         tools: tools.keys,
-        server_tools: server_tools,
+        provider_tools: provider_tools,
         tool_choice: tool_prefs[:choice],
         tool_call_limit: tool_prefs[:calls],
         temperature: @temperature,
@@ -1147,7 +1147,7 @@ module RubyLLM
       @provider.complete(
         preprocessed_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/error.rb

@@ -83,7 +83,7 @@ module RubyLLM
     end
   end
 
-  # Raised when Chat#with_server_tools is used with a provider RubyLLM has
+  # Raised when Chat#with_provider_tools is used with a provider RubyLLM has
   # no server-tool support for, or with an alias the provider's protocol
   # does not define.
   class UnsupportedServerToolError < Error; end

data/lib/ruby_llm/message.rb

@@ -64,7 +64,7 @@ module RubyLLM
 
     # The provider-executed tool steps in this response, as an array of
     # ServerToolCall objects. Empty unless the chat enabled tools with
-    # Chat#with_server_tools and the model used one.
+    # Chat#with_provider_tools and the model used one.
     attr_reader :server_tool_calls
 
     # The provider-shaped content blocks of this assistant message, kept
@@ -129,6 +129,14 @@ module RubyLLM
       dup.tap { |message| message.instance_variable_set(:@attachments, wrapped) }
     end
 
+    def without_thinking # :nodoc:
+      dup.tap do |message|
+        message.instance_variable_set(:@thinking, nil)
+        message.instance_variable_set(:@raw_reasoning, nil)
+        message.instance_variable_set(:@tool_calls, tool_calls_without_thought_signatures)
+      end
+    end
+
     # Returns +true+ if the assistant requested one or more tool calls,
     # +false+ otherwise.
     def tool_call?
@@ -276,6 +284,12 @@ module RubyLLM
       end
     end
 
+    def tool_calls_without_thought_signatures
+      tool_calls&.transform_values do |call|
+        call.dup.tap { |copy| copy.thought_signature = nil }
+      end
+    end
+
     def coerce_thinking(thinking, signature)
       case thinking
       when nil, Thinking then thinking

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/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,6 +44,10 @@ 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

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/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/version.rb

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

data/lib/ruby_llm.rb

@@ -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.rc4
+  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
@@ -617,7 +617,7 @@ metadata:
   funding_uri: https://github.com/sponsors/crmne
   rubygems_mfa_required: 'true'
 post_install_message: |
-  RubyLLM 2.0.0.rc4
+  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: