ruby_llm 1.9.2 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3767ec948dc2525f68824d04df633fb65bdb6dc5ea87464e059bee1559d6751e
-  data.tar.gz: de82f54d7ebca42419671df2233c4a935eb17f17a8edd9095361f7a6107d8f71
+  metadata.gz: 5c88c057a541d5c27c5ab61a9bcf6db9e20c702fdb34b5b26d2d3154128f8dbd
+  data.tar.gz: d425e78899c69aa798838f0f3bf6e6f99f3e3ddc9c9057ded3bd7360b482acd1
 SHA512:
-  metadata.gz: 5cce23683b7712a9d670f8ad7cf78c72a69663e788767ed2eddc36f4bde53c4d78a95801a59632dff702bd6b32e352d42e555564965709c6b19b4102160e3894
-  data.tar.gz: 2456901875eda20c8593ce9bb6627bf4436b434c534c65e31b8241b99d2a253e651fedfd07df1eca1e38da32dffed8353d339b100047ecfac5118430e2e018f4
+  metadata.gz: 4545a9ef9254ec489924172c3f82fec9fd59986517e61b0e6ab24465dd5e4cd44f35296f14da3e3416c71bea05a1147ac80bf206fde68e071ae525c5e6effd27
+  data.tar.gz: 9be86b4db70aba3d4684dc81bac6949895c9232a0783f3b1f13758356565de682c4d8b9a1ff1aac70ceedcde9fd363b0a5b4e941516d26aafbc783d0e7692dd2

data/README.md

@@ -7,7 +7,7 @@
 
 <strong>One *beautiful* Ruby API for GPT, Claude, Gemini, and more.</strong>
 
-Battle tested at [<picture><source media="(prefers-color-scheme: dark)" srcset="https://chatwithwork.com/logotype-dark.svg"><img src="https://chatwithwork.com/logotype.svg" alt="Chat with Work" height="30" align="absmiddle"></picture>](https://chatwithwork.com) — *Claude Code for your documents*
+Battle tested at [<picture><source media="(prefers-color-scheme: dark)" srcset="https://chatwithwork.com/logotype-dark.svg"><img src="https://chatwithwork.com/logotype.svg" alt="Chat with Work" height="30" align="absmiddle"></picture>](https://chatwithwork.com) — *Your AI coworker*
 
 [![Gem Version](https://badge.fury.io/rb/ruby_llm.svg?a=10)](https://badge.fury.io/rb/ruby_llm)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop)
@@ -122,7 +122,8 @@ response = chat.with_schema(ProductSchema).ask "Analyze this product", with: "pr
 * **Streaming:** Real-time responses with blocks
 * **Rails:** ActiveRecord integration with `acts_as_chat`
 * **Async:** Fiber-based concurrency
-* **Model registry:** 500+ models with capability detection and pricing
+* **Model registry:** 800+ models with capability detection and pricing
+* **Extended thinking:** Control, view, and persist model deliberation
 * **Providers:** OpenAI, Anthropic, Gemini, VertexAI, Bedrock, DeepSeek, Mistral, Ollama, OpenRouter, Perplexity, GPUStack, and any OpenAI-compatible API
 
 ## Installation

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

@@ -4,6 +4,9 @@ class Create<%= message_model_name.gsub('::', '').pluralize %> < ActiveRecord::M
       t.string :role, null: false
       t.text :content
       t.json :content_raw
+      t.text :thinking_text
+      t.text :thinking_signature
+      t.integer :thinking_tokens
       t.integer :input_tokens
       t.integer :output_tokens
       t.integer :cached_tokens

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

@@ -4,6 +4,7 @@ class Create<%= tool_call_model_name.gsub('::', '').pluralize %> < ActiveRecord:
     create_table :<%= tool_call_table_name %> do |t|
       t.string :tool_call_id, null: false
       t.string :name, null: false
+      t.string :thought_signature
 <% if postgresql? %>
       t.jsonb :arguments, default: {}
 <% elsif mysql? %>

data/lib/generators/ruby_llm/upgrade_to_v1_10/templates/add_v1_10_message_columns.rb.tt

@@ -0,0 +1,19 @@
+class AddRubyLlmV110Columns < ActiveRecord::Migration<%= migration_version %>
+  def change
+    unless column_exists?(:<%= message_table_name %>, :thinking_text)
+      add_column :<%= message_table_name %>, :thinking_text, :text
+    end
+
+    unless column_exists?(:<%= message_table_name %>, :thinking_signature)
+      add_column :<%= message_table_name %>, :thinking_signature, :text
+    end
+
+    unless column_exists?(:<%= message_table_name %>, :thinking_tokens)
+      add_column :<%= message_table_name %>, :thinking_tokens, :integer
+    end
+
+    unless column_exists?(:<%= tool_call_table_name %>, :thought_signature)
+      add_column :<%= tool_call_table_name %>, :thought_signature, :string
+    end
+  end
+end

data/lib/generators/ruby_llm/upgrade_to_v1_10/upgrade_to_v1_10_generator.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+require_relative '../generator_helpers'
+
+module RubyLLM
+  module Generators
+    # Generator to add v1.10 columns (thinking output + thinking tokens) to existing apps.
+    class UpgradeToV110Generator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      include RubyLLM::Generators::GeneratorHelpers
+
+      namespace 'ruby_llm:upgrade_to_v1_10'
+      source_root File.expand_path('templates', __dir__)
+
+      argument :model_mappings, type: :array, default: [], banner: 'message:MessageName'
+
+      desc 'Adds thinking output columns and thinking token tracking introduced in v1.10.0'
+
+      def self.next_migration_number(dirname)
+        ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def create_migration_file
+        parse_model_mappings
+
+        migration_template 'add_v1_10_message_columns.rb.tt',
+                           'db/migrate/add_ruby_llm_v1_10_columns.rb',
+                           migration_version: migration_version,
+                           message_table_name: message_table_name,
+                           tool_call_table_name: tool_call_table_name
+      end
+
+      def show_next_steps
+        say_status :success, 'Upgrade prepared!', :green
+        say <<~INSTRUCTIONS
+
+          Next steps:
+          1. Review the generated migration
+          2. Run: rails db:migrate
+          3. Restart your application server
+
+          📚 See the v1.10.0 release notes for details on extended thinking support.
+
+        INSTRUCTIONS
+      end
+    end
+  end
+end

data/lib/ruby_llm/active_record/acts_as_legacy.rb

@@ -279,8 +279,11 @@ module RubyLLM
       end
 
       def persist_tool_calls(tool_calls)
+        supports_thought_signature = tool_calls.klass.column_names.include?('thought_signature')
+
         tool_calls.each_value do |tool_call|
           attributes = tool_call.to_h
+          attributes.delete(:thought_signature) unless supports_thought_signature
           attributes[:tool_call_id] = attributes.delete(:id)
           @message.tool_calls.create!(**attributes)
         end
@@ -357,7 +360,8 @@ module RubyLLM
             RubyLLM::ToolCall.new(
               id: tool_call.tool_call_id,
               name: tool_call.name,
-              arguments: tool_call.arguments
+              arguments: tool_call.arguments,
+              thought_signature: tool_call.try(:thought_signature)
             )
           ]
         end

data/lib/ruby_llm/active_record/chat_methods.rb

@@ -124,6 +124,11 @@ module RubyLLM
         self
       end
 
+      def with_thinking(...)
+        to_llm.with_thinking(...)
+        self
+      end
+
       def with_params(...)
         to_llm.with_params(...)
         self
@@ -262,6 +267,9 @@ module RubyLLM
           if @message.has_attribute?(:cache_creation_tokens)
             attrs[:cache_creation_tokens] = message.cache_creation_tokens
           end
+          attrs[:thinking_text] = message.thinking&.text if @message.has_attribute?(:thinking_text)
+          attrs[:thinking_signature] = message.thinking&.signature if @message.has_attribute?(:thinking_signature)
+          attrs[:thinking_tokens] = message.thinking_tokens if @message.has_attribute?(:thinking_tokens)
 
           # Add model association dynamically
           attrs[self.class.model_association_name] = model_association
@@ -282,8 +290,12 @@ module RubyLLM
       # rubocop:enable Metrics/PerceivedComplexity
 
       def persist_tool_calls(tool_calls)
+        tool_call_klass = @message.tool_calls_association.klass
+        supports_thought_signature = tool_call_klass.column_names.include?('thought_signature')
+
         tool_calls.each_value do |tool_call|
           attributes = tool_call.to_h
+          attributes.delete(:thought_signature) unless supports_thought_signature
           attributes[:tool_call_id] = attributes.delete(:id)
           @message.tool_calls_association.create!(**attributes)
         end

data/lib/ruby_llm/active_record/message_methods.rb

@@ -11,24 +11,56 @@ module RubyLLM
       end
 
       def to_llm
-        cached = has_attribute?(:cached_tokens) ? self[:cached_tokens] : nil
-        cache_creation = has_attribute?(:cache_creation_tokens) ? self[:cache_creation_tokens] : nil
-
         RubyLLM::Message.new(
           role: role.to_sym,
           content: extract_content,
+          thinking: thinking,
+          tokens: tokens,
           tool_calls: extract_tool_calls,
           tool_call_id: extract_tool_call_id,
-          input_tokens: input_tokens,
-          output_tokens: output_tokens,
-          cached_tokens: cached,
-          cache_creation_tokens: cache_creation,
           model_id: model_association&.model_id
         )
       end
 
+      def thinking
+        RubyLLM::Thinking.build(
+          text: thinking_text_value,
+          signature: thinking_signature_value
+        )
+      end
+
+      def tokens
+        RubyLLM::Tokens.build(
+          input: input_tokens,
+          output: output_tokens,
+          cached: cached_value,
+          cache_creation: cache_creation_value,
+          thinking: thinking_tokens_value
+        )
+      end
+
       private
 
+      def thinking_text_value
+        has_attribute?(:thinking_text) ? self[:thinking_text] : nil
+      end
+
+      def thinking_signature_value
+        has_attribute?(:thinking_signature) ? self[:thinking_signature] : nil
+      end
+
+      def cached_value
+        has_attribute?(:cached_tokens) ? self[:cached_tokens] : nil
+      end
+
+      def cache_creation_value
+        has_attribute?(:cache_creation_tokens) ? self[:cache_creation_tokens] : nil
+      end
+
+      def thinking_tokens_value
+        has_attribute?(:thinking_tokens) ? self[:thinking_tokens] : nil
+      end
+
       def extract_tool_calls
         tool_calls_association.to_h do |tool_call|
           [
@@ -36,7 +68,8 @@ module RubyLLM
             RubyLLM::ToolCall.new(
               id: tool_call.tool_call_id,
               name: tool_call.name,
-              arguments: tool_call.arguments
+              arguments: tool_call.arguments,
+              thought_signature: tool_call.try(:thought_signature)
             )
           ]
         end

data/lib/ruby_llm/aliases.json

@@ -336,18 +336,6 @@
     "openai": "gpt-5.2-pro",
     "openrouter": "openai/gpt-5.2-pro"
   },
-  "imagen-4.0-fast-generate-001": {
-    "gemini": "imagen-4.0-fast-generate-001",
-    "vertexai": "imagen-4.0-fast-generate-001"
-  },
-  "imagen-4.0-generate-001": {
-    "gemini": "imagen-4.0-generate-001",
-    "vertexai": "imagen-4.0-generate-001"
-  },
-  "imagen-4.0-ultra-generate-001": {
-    "gemini": "imagen-4.0-ultra-generate-001",
-    "vertexai": "imagen-4.0-ultra-generate-001"
-  },
   "o1": {
     "openai": "o1",
     "openrouter": "openai/o1"

data/lib/ruby_llm/chat.rb

@@ -22,6 +22,7 @@ module RubyLLM
       @params = {}
       @headers = {}
       @schema = nil
+      @thinking = nil
       @on = {
         new_message: nil,
         end_message: nil,
@@ -67,6 +68,13 @@ module RubyLLM
       self
     end
 
+    def with_thinking(effort: nil, budget: nil)
+      raise ArgumentError, 'with_thinking requires :effort or :budget' if effort.nil? && budget.nil?
+
+      @thinking = Thinking::Config.new(effort: effort, budget: budget)
+      self
+    end
+
     def with_context(context)
       @context = context
       @config = context.config
@@ -130,6 +138,7 @@ module RubyLLM
         params: @params,
         headers: @headers,
         schema: @schema,
+        thinking: @thinking,
         &wrap_streaming_block(&)
       )
 
@@ -172,15 +181,9 @@ module RubyLLM
     def wrap_streaming_block(&block)
       return nil unless block_given?
 
-      first_chunk_received = false
+      @on[:new_message]&.call
 
       proc do |chunk|
-        # Create message on first content chunk
-        unless first_chunk_received
-          first_chunk_received = true
-          @on[:new_message]&.call
-        end
-
         block.call chunk
       end
     end

data/lib/ruby_llm/configuration.rb

@@ -56,7 +56,7 @@ module RubyLLM
       @retry_interval_randomness = 0.5
       @http_proxy = nil
 
-      @default_model = 'gpt-4.1-nano'
+      @default_model = 'gpt-5-nano'
       @default_embedding_model = 'text-embedding-3-small'
       @default_moderation_model = 'omni-moderation-latest'
       @default_image_model = 'gpt-image-1'

data/lib/ruby_llm/message.rb

@@ -5,8 +5,7 @@ module RubyLLM
   class Message
     ROLES = %i[system user assistant tool].freeze
 
-    attr_reader :role, :model_id, :tool_calls, :tool_call_id, :input_tokens, :output_tokens,
-                :cached_tokens, :cache_creation_tokens, :raw
+    attr_reader :role, :model_id, :tool_calls, :tool_call_id, :raw, :thinking, :tokens
     attr_writer :content
 
     def initialize(options = {})
@@ -15,11 +14,16 @@ module RubyLLM
       @model_id = options[:model_id]
       @tool_calls = options[:tool_calls]
       @tool_call_id = options[:tool_call_id]
-      @input_tokens = options[:input_tokens]
-      @output_tokens = options[:output_tokens]
-      @cached_tokens = options[:cached_tokens]
-      @cache_creation_tokens = options[:cache_creation_tokens]
+      @tokens = options[:tokens] || Tokens.build(
+        input: options[:input_tokens],
+        output: options[:output_tokens],
+        cached: options[:cached_tokens],
+        cache_creation: options[:cache_creation_tokens],
+        thinking: options[:thinking_tokens],
+        reasoning: options[:reasoning_tokens]
+      )
       @raw = options[:raw]
+      @thinking = options[:thinking]
 
       ensure_valid_role
     end
@@ -44,6 +48,30 @@ module RubyLLM
       content if tool_result?
     end
 
+    def input_tokens
+      tokens&.input
+    end
+
+    def output_tokens
+      tokens&.output
+    end
+
+    def cached_tokens
+      tokens&.cached
+    end
+
+    def cache_creation_tokens
+      tokens&.cache_creation
+    end
+
+    def thinking_tokens
+      tokens&.thinking
+    end
+
+    def reasoning_tokens
+      tokens&.thinking
+    end
+
     def to_h
       {
         role: role,
@@ -51,11 +79,9 @@ module RubyLLM
         model_id: model_id,
         tool_calls: tool_calls,
         tool_call_id: tool_call_id,
-        input_tokens: input_tokens,
-        output_tokens: output_tokens,
-        cached_tokens: cached_tokens,
-        cache_creation_tokens: cache_creation_tokens
-      }.compact
+        thinking: thinking&.text,
+        thinking_signature: thinking&.signature
+      }.merge(tokens ? tokens.to_h : {}).compact
     end
 
     def instance_variables