dify_llm 1.9.2 → 1.14.1

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

@@ -14,7 +14,10 @@ module RubyLLM
           "models/#{@model}:generateContent"
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil) # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
+        # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil,
+                           thinking: nil, tool_prefs: nil)
+          tool_prefs ||= {}
           @model = model.id
           payload = {
             contents: format_messages(messages),
@@ -24,10 +27,35 @@ module RubyLLM
           payload[:generationConfig][:temperature] = temperature unless temperature.nil?
 
           payload[:generationConfig].merge!(structured_output_config(schema, model)) if schema
+          payload[:generationConfig][:thinkingConfig] = build_thinking_config(model, thinking) if thinking&.enabled?
+
+          if tools.any?
+            payload[:tools] = format_tools(tools)
+            # Gemini doesn't support controlling parallel tool calls
+            payload[:toolConfig] = build_tool_config(tool_prefs[:choice]) unless tool_prefs[:choice].nil?
+          end
 
-          payload[:tools] = format_tools(tools) if tools.any?
           payload
         end
+        # rubocop:enable Metrics/ParameterLists,Lint/UnusedMethodArgument
+
+        def build_thinking_config(_model, thinking)
+          config = { includeThoughts: true }
+
+          config[:thinkingLevel] = resolve_effort_level(thinking) if thinking&.effort
+          config[:thinkingBudget] = resolve_budget(thinking) if thinking&.budget
+
+          config
+        end
+
+        def resolve_effort_level(thinking)
+          thinking.respond_to?(:effort) ? thinking.effort : thinking
+        end
+
+        def resolve_budget(thinking)
+          budget = thinking.respond_to?(:budget) ? thinking.budget : thinking
+          budget.is_a?(Integer) ? budget : nil
+        end
 
         private
 
@@ -56,20 +84,44 @@ module RubyLLM
           elsif msg.tool_result?
             format_tool_result(msg)
           else
-            Media.format_content(msg.content)
+            format_message_parts(msg)
           end
         end
 
+        def format_message_parts(msg)
+          parts = []
+
+          parts << build_thought_part(msg.thinking) if msg.role == :assistant && msg.thinking
+
+          content_parts = Media.format_content(msg.content)
+          parts.concat(content_parts.is_a?(Array) ? content_parts : [content_parts])
+          parts
+        end
+
+        def build_thought_part(thinking)
+          part = { thought: true }
+          part[:text] = thinking.text if thinking.text
+          part[:thoughtSignature] = thinking.signature if thinking.signature
+          part
+        end
+
         def parse_completion_response(response)
           data = response.body
+          parts = data.dig('candidates', 0, 'content', 'parts') || []
           tool_calls = extract_tool_calls(data)
 
           Message.new(
             role: :assistant,
-            content: parse_content(data),
+            content: extract_text_parts(parts) || parse_content(data),
+            thinking: Thinking.build(
+              text: extract_thought_parts(parts),
+              signature: extract_thought_signature(parts)
+            ),
             tool_calls: tool_calls,
             input_tokens: data.dig('usageMetadata', 'promptTokenCount'),
             output_tokens: calculate_output_tokens(data),
+            cached_tokens: data.dig('usageMetadata', 'cachedContentTokenCount'),
+            thinking_tokens: data.dig('usageMetadata', 'thoughtsTokenCount'),
             model_id: data['modelVersion'] || response.env.url.path.split('/')[3].split(':')[0],
             raw: response
           )
@@ -78,6 +130,9 @@ module RubyLLM
         def convert_schema_to_gemini(schema)
           return nil unless schema
 
+          # Extract inner schema if wrapper format (e.g., from RubyLLM::Schema.to_json_schema)
+          schema = schema[:schema] || schema
+
           GeminiSchema.new(schema).to_h
         end
 
@@ -90,7 +145,34 @@ module RubyLLM
           parts = candidate.dig('content', 'parts')
           return '' unless parts&.any?
 
-          build_response_content(parts)
+          non_thought_parts = parts.reject { |part| part['thought'] }
+          return '' unless non_thought_parts.any?
+
+          build_response_content(non_thought_parts)
+        end
+
+        def extract_text_parts(parts)
+          text_parts = parts.reject { |p| p['thought'] }
+          content = text_parts.filter_map { |p| p['text'] }.join
+          content.empty? ? nil : content
+        end
+
+        def extract_thought_parts(parts)
+          thought_parts = parts.select { |p| p['thought'] }
+          thoughts = thought_parts.filter_map { |p| p['text'] }.join
+          thoughts.empty? ? nil : thoughts
+        end
+
+        def extract_thought_signature(parts)
+          parts.each do |part|
+            signature = part['thoughtSignature'] ||
+                        part['thought_signature'] ||
+                        part.dig('functionCall', 'thoughtSignature') ||
+                        part.dig('functionCall', 'thought_signature')
+            return signature if signature
+          end
+
+          nil
         end
 
         def function_call?(candidate)
@@ -110,7 +192,7 @@ module RubyLLM
         end
 
         def build_json_schema(schema)
-          normalized = RubyLLM::Utils.deep_dup(schema)
+          normalized = RubyLLM::Utils.deep_dup(schema[:schema])
           normalized.delete(:strict)
           normalized.delete('strict')
           RubyLLM::Utils.deep_stringify_keys(normalized)

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

@@ -10,7 +10,7 @@ module RubyLLM
         end
 
         def render_image_payload(prompt, model:, size:)
-          RubyLLM.logger.debug "Ignoring size #{size}. Gemini does not support image size customization."
+          RubyLLM.logger.debug { "Ignoring size #{size}. Gemini does not support image size customization." }
           @model = model
           {
             instances: [

data/lib/ruby_llm/providers/gemini/models.rb

@@ -17,14 +17,12 @@ module RubyLLM
 
             Model::Info.new(
               id: model_id,
-              name: model_data['displayName'],
+              name: model_data['displayName'] || model_id,
               provider: slug,
-              family: capabilities.model_family(model_id),
               created_at: nil,
               context_window: model_data['inputTokenLimit'] || capabilities.context_window_for(model_id),
               max_output_tokens: model_data['outputTokenLimit'] || capabilities.max_tokens_for(model_id),
-              modalities: capabilities.modalities_for(model_id),
-              capabilities: capabilities.capabilities_for(model_id),
+              capabilities: capabilities.critical_capabilities_for(model_id),
               pricing: capabilities.pricing_for(model_id),
               metadata: {
                 version: model_data['version'],

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

@@ -10,12 +10,20 @@ module RubyLLM
         end
 
         def build_chunk(data)
+          parts = data.dig('candidates', 0, 'content', 'parts') || []
+
           Chunk.new(
             role: :assistant,
             model_id: extract_model_id(data),
-            content: extract_content(data),
+            content: extract_text_content(parts),
+            thinking: Thinking.build(
+              text: extract_thought_content(parts),
+              signature: extract_thought_signature(parts)
+            ),
             input_tokens: extract_input_tokens(data),
             output_tokens: extract_output_tokens(data),
+            cached_tokens: data.dig('usageMetadata', 'cachedContentTokenCount'),
+            thinking_tokens: data.dig('usageMetadata', 'thoughtsTokenCount'),
             tool_calls: extract_tool_calls(data)
           )
         end
@@ -26,6 +34,30 @@ module RubyLLM
           data['modelVersion']
         end
 
+        def extract_text_content(parts)
+          text_parts = parts.reject { |p| p['thought'] }
+          text = text_parts.filter_map { |p| p['text'] }.join
+          text.empty? ? nil : text
+        end
+
+        def extract_thought_content(parts)
+          thought_parts = parts.select { |p| p['thought'] }
+          thoughts = thought_parts.filter_map { |p| p['text'] }.join
+          thoughts.empty? ? nil : thoughts
+        end
+
+        def extract_thought_signature(parts)
+          parts.each do |part|
+            signature = part['thoughtSignature'] ||
+                        part['thought_signature'] ||
+                        part.dig('functionCall', 'thoughtSignature') ||
+                        part.dig('functionCall', 'thought_signature')
+            return signature if signature
+          end
+
+          nil
+        end
+
         def extract_content(data)
           return nil unless data['candidates']&.any?
 
@@ -52,7 +84,7 @@ module RubyLLM
           error_data = JSON.parse(data)
           [error_data['error']['code'], error_data['error']['message']]
         rescue JSON::ParserError => e
-          RubyLLM.logger.debug "Failed to parse streaming error: #{e.message}"
+          RubyLLM.logger.debug { "Failed to parse streaming error: #{e.message}" }
           [500, "Failed to parse error: #{data}"]
         end
       end

data/lib/ruby_llm/providers/gemini/tools.rb

@@ -13,7 +13,7 @@ module RubyLLM
           }]
         end
 
-        def format_tool_call(msg)
+        def format_tool_call(msg) # rubocop:disable Metrics/PerceivedComplexity
           parts = []
 
           if msg.content && !(msg.content.respond_to?(:empty?) && msg.content.empty?)
@@ -21,13 +21,24 @@ module RubyLLM
             parts.concat(formatted_content.is_a?(Array) ? formatted_content : [formatted_content])
           end
 
+          fallback_signature = msg.thinking&.signature
+          used_fallback = false
+
           msg.tool_calls.each_value do |tool_call|
-            parts << {
+            part = {
               functionCall: {
                 name: tool_call.name,
                 args: tool_call.arguments
               }
             }
+
+            signature = tool_call.thought_signature
+            if signature.nil? && fallback_signature && !used_fallback
+              signature = fallback_signature
+              used_fallback = true
+            end
+            part[:thoughtSignature] = signature if signature
+            parts << part
           end
 
           parts
@@ -61,11 +72,13 @@ module RubyLLM
             next unless function_data
 
             id = SecureRandom.uuid
+            thought_signature = part['thoughtSignature'] || part['thought_signature']
 
             result[id] = ToolCall.new(
               id:,
               name: function_data['name'],
-              arguments: function_data['args'] || {}
+              arguments: function_data['args'] || {},
+              thought_signature: thought_signature
             )
           end
 
@@ -192,6 +205,25 @@ module RubyLLM
           else 'STRING'
           end
         end
+
+        def build_tool_config(tool_choice)
+          {
+            functionCallingConfig: {
+              mode: forced_tool_choice?(tool_choice) ? 'any' : tool_choice
+            }.tap do |config|
+              # Use allowedFunctionNames to simulate specific tool choice
+              config[:allowedFunctionNames] = [tool_choice] if specific_tool_choice?(tool_choice)
+            end
+          }
+        end
+
+        def forced_tool_choice?(tool_choice)
+          tool_choice == :required || specific_tool_choice?(tool_choice)
+        end
+
+        def specific_tool_choice?(tool_choice)
+          !%i[auto none required].include?(tool_choice)
+        end
       end
     end
   end

data/lib/ruby_llm/providers/gemini.rb

@@ -28,6 +28,10 @@ module RubyLLM
           Gemini::Capabilities
         end
 
+        def configuration_options
+          %i[gemini_api_key gemini_api_base]
+        end
+
         def configuration_requirements
           %i[gemini_api_key]
         end

data/lib/ruby_llm/providers/gpustack/capabilities.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class GPUStack
+      # Determines capabilities for GPUStack models
+      module Capabilities
+        module_function
+
+        def supports_tool_choice?(_model_id)
+          false
+        end
+
+        def supports_tool_parallel_control?(_model_id)
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -14,7 +14,7 @@ module RubyLLM
               content: GPUStack::Media.format_content(msg.content),
               tool_calls: format_tool_calls(msg.tool_calls),
               tool_call_id: msg.tool_call_id
-            }.compact
+            }.compact.merge(OpenAI::Chat.format_thinking(msg))
           end
         end
 

data/lib/ruby_llm/providers/gpustack.rb

@@ -21,6 +21,10 @@ module RubyLLM
       end
 
       class << self
+        def configuration_options
+          %i[gpustack_api_base gpustack_api_key]
+        end
+
         def local?
           true
         end
@@ -28,6 +32,10 @@ module RubyLLM
         def configuration_requirements
           %i[gpustack_api_base]
         end
+
+        def capabilities
+          GPUStack::Capabilities
+        end
       end
     end
   end

data/lib/ruby_llm/providers/mistral/capabilities.rb

@@ -15,6 +15,14 @@ module RubyLLM
           !model_id.match?(/embed|moderation|ocr|voxtral|transcriptions|mistral-(tiny|small)-(2312|2402)/)
         end
 
+        def supports_tool_choice?(_model_id)
+          true
+        end
+
+        def supports_tool_parallel_control?(_model_id)
+          true
+        end
+
         def supports_vision?(model_id)
           model_id.match?(/pixtral|mistral-small-(2503|2506)|mistral-medium/)
         end

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

@@ -11,13 +11,71 @@ module RubyLLM
           role.to_s
         end
 
+        def format_messages(messages)
+          messages.map do |msg|
+            {
+              role: format_role(msg.role),
+              content: format_content_with_thinking(msg),
+              tool_calls: OpenAI::Tools.format_tool_calls(msg.tool_calls),
+              tool_call_id: msg.tool_call_id
+            }.compact
+          end
+        end
+
         # rubocop:disable Metrics/ParameterLists
-        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil)
+        def render_payload(messages, tools:, temperature:, model:, stream: false,
+                           schema: nil, thinking: nil, tool_prefs: nil)
           payload = super
           payload.delete(:stream_options)
+          payload.delete(:reasoning_effort)
+          warn_on_unsupported_thinking(model, thinking)
           payload
         end
         # rubocop:enable Metrics/ParameterLists
+
+        def format_content_with_thinking(msg)
+          formatted_content = OpenAI::Media.format_content(msg.content)
+          return formatted_content unless msg.role == :assistant && msg.thinking
+
+          content_blocks = build_thinking_blocks(msg.thinking)
+          append_formatted_content(content_blocks, formatted_content)
+
+          content_blocks
+        end
+
+        def warn_on_unsupported_thinking(model, thinking)
+          return unless thinking&.enabled?
+          return if model.id.to_s.include?('magistral')
+
+          RubyLLM.logger.warn(
+            'Mistral thinking is only supported on Magistral models. ' \
+            "Ignoring thinking settings for #{model.id}."
+          )
+        end
+
+        def build_thinking_blocks(thinking)
+          return [] unless thinking
+
+          if thinking.text
+            [{
+              type: 'thinking',
+              thinking: [{ type: 'text', text: thinking.text }],
+              signature: thinking.signature
+            }.compact]
+          elsif thinking.signature
+            [{ type: 'thinking', signature: thinking.signature }]
+          else
+            []
+          end
+        end
+
+        def append_formatted_content(content_blocks, formatted_content)
+          if formatted_content.is_a?(Array)
+            content_blocks.concat(formatted_content)
+          elsif formatted_content
+            content_blocks << { type: 'text', text: formatted_content }
+          end
+        end
       end
     end
   end

data/lib/ruby_llm/providers/mistral.rb

@@ -23,6 +23,10 @@ module RubyLLM
           Mistral::Capabilities
         end
 
+        def configuration_options
+          %i[mistral_api_key]
+        end
+
         def configuration_requirements
           %i[mistral_api_key]
         end

data/lib/ruby_llm/providers/ollama/capabilities.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Ollama
+      # Determines capabilities for Ollama models
+      module Capabilities
+        module_function
+
+        def supports_tool_choice?(_model_id)
+          false
+        end
+
+        def supports_tool_parallel_control?(_model_id)
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -14,7 +14,7 @@ module RubyLLM
               content: Ollama::Media.format_content(msg.content),
               tool_calls: format_tool_calls(msg.tool_calls),
               tool_call_id: msg.tool_call_id
-            }.compact
+            }.compact.merge(OpenAI::Chat.format_thinking(msg))
           end
         end
 

data/lib/ruby_llm/providers/ollama.rb

@@ -13,10 +13,16 @@ module RubyLLM
       end
 
       def headers
-        {}
+        return {} unless @config.ollama_api_key
+
+        { 'Authorization' => "Bearer #{@config.ollama_api_key}" }
       end
 
       class << self
+        def configuration_options
+          %i[ollama_api_base ollama_api_key]
+        end
+
         def configuration_requirements
           %i[ollama_api_base]
         end
@@ -24,6 +30,10 @@ module RubyLLM
         def local?
           true
         end
+
+        def capabilities
+          Ollama::Capabilities
+        end
       end
     end
   end