dify_llm 1.9.1 → 1.14.1

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

@@ -3,127 +3,17 @@
 module RubyLLM
   module Providers
     class DeepSeek
-      # Determines capabilities and pricing for DeepSeek models
+      # Provider-level capability checks used outside the model registry.
       module Capabilities
         module_function
 
-        def context_window_for(model_id)
-          case model_id
-          when /deepseek-(?:chat|reasoner)/ then 64_000
-          else 32_768
-          end
+        def supports_tool_choice?(_model_id)
+          true
         end
 
-        def max_tokens_for(model_id)
-          case model_id
-          when /deepseek-(?:chat|reasoner)/ then 8_192
-          else 4_096
-          end
-        end
-
-        def input_price_for(model_id)
-          PRICES.dig(model_family(model_id), :input_miss) || default_input_price
-        end
-
-        def output_price_for(model_id)
-          PRICES.dig(model_family(model_id), :output) || default_output_price
-        end
-
-        def cache_hit_price_for(model_id)
-          PRICES.dig(model_family(model_id), :input_hit) || default_cache_hit_price
-        end
-
-        def supports_vision?(_model_id)
+        def supports_tool_parallel_control?(_model_id)
           false
         end
-
-        def supports_functions?(model_id)
-          model_id.match?(/deepseek-chat/)
-        end
-
-        def supports_json_mode?(_model_id)
-          false
-        end
-
-        def format_display_name(model_id)
-          case model_id
-          when 'deepseek-chat' then 'DeepSeek V3'
-          when 'deepseek-reasoner' then 'DeepSeek R1'
-          else
-            model_id.split('-')
-                    .map(&:capitalize)
-                    .join(' ')
-          end
-        end
-
-        def model_type(_model_id)
-          'chat'
-        end
-
-        def model_family(model_id)
-          case model_id
-          when /deepseek-reasoner/ then :reasoner
-          else :chat
-          end
-        end
-
-        PRICES = {
-          chat: {
-            input_hit: 0.07,
-            input_miss: 0.27,
-            output: 1.10
-          },
-          reasoner: {
-            input_hit: 0.14,
-            input_miss: 0.55,
-            output: 2.19
-          }
-        }.freeze
-
-        def default_input_price
-          0.27
-        end
-
-        def default_output_price
-          1.10
-        end
-
-        def default_cache_hit_price
-          0.07
-        end
-
-        def modalities_for(_model_id)
-          {
-            input: ['text'],
-            output: ['text']
-          }
-        end
-
-        def capabilities_for(model_id)
-          capabilities = ['streaming']
-
-          capabilities << 'function_calling' if model_id.match?(/deepseek-chat/)
-
-          capabilities
-        end
-
-        def pricing_for(model_id)
-          family = model_family(model_id)
-          prices = PRICES.fetch(family, { input_miss: default_input_price, output: default_output_price })
-
-          standard_pricing = {
-            input_per_million: prices[:input_miss],
-            output_per_million: prices[:output]
-          }
-
-          standard_pricing[:cached_input_per_million] = prices[:input_hit] if prices[:input_hit]
-
-          {
-            text_tokens: {
-              standard: standard_pricing
-            }
-          }
-        end
       end
     end
   end

data/lib/ruby_llm/providers/deepseek.rb

@@ -7,7 +7,7 @@ module RubyLLM
       include DeepSeek::Chat
 
       def api_base
-        'https://api.deepseek.com'
+        @config.deepseek_api_base || 'https://api.deepseek.com'
       end
 
       def headers
@@ -21,6 +21,10 @@ module RubyLLM
           DeepSeek::Capabilities
         end
 
+        def configuration_options
+          %i[deepseek_api_key deepseek_api_base]
+        end
+
         def configuration_requirements
           %i[deepseek_api_key]
         end

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

@@ -26,21 +26,23 @@ module RubyLLM
           }
           @connection.upload('v1/files/upload', payload)
         end
-        
+
         module_function
 
         def completion_url
           'v1/chat-messages'
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil) # rubocop:disable Lint/UnusedMethodArgument
+        # rubocop:disable Lint/UnusedMethodArgument
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil, thinking: nil,
+                           tool_prefs: nil)
           current_message = messages[-1]
           current_message_content = current_message.content # dify using conversation_id to trace message history
 
           # Find the latest non-nil conversation_id from all messages
           latest_conversation_id = messages.reverse.find { |msg| msg.conversation_id }&.conversation_id
 
-          {
+          payload = {
             inputs: {},
             query: current_message_content.is_a?(Content) ? current_message_content.text : current_message_content,
             response_mode: (stream ? 'streaming' : 'blocking'),
@@ -48,22 +50,95 @@ module RubyLLM
             user: (@config&.dify_user || 'dify-user'),
             files: format_files(current_message_content)
           }
+
+          payload[:thinking] = { type: 'enabled' } if thinking&.enabled?
+          payload
         end
+        # rubocop:enable Lint/UnusedMethodArgument
 
         def parse_completion_response(response)
           data = response.body
+          message_data = data.dig('choices', 0, 'message')
+          usage = data['usage'] || {}
+
+          if message_data
+            content, thinking_from_tags = extract_content_and_thinking(message_data['content'])
+            thinking_text = thinking_from_tags || extract_thinking_text(message_data)
+            thinking_signature = extract_thinking_signature(message_data)
+            thinking_tokens = extract_thinking_tokens(data)
+          else
+            answer = data['answer']
+            content, thinking_from_tags = extract_content_and_thinking(answer)
+            thinking_text = thinking_from_tags || extract_thinking_text(data)
+            thinking_signature = extract_thinking_signature(data)
+            thinking_tokens = extract_thinking_tokens(data)
+          end
 
           Message.new(
             role: :assistant,
-            content: data['answer'],
+            content: content,
+            thinking: Thinking.build(text: thinking_text, signature: thinking_signature),
             tool_calls: nil,
-            input_tokens: data.dig('metadata', 'usage', 'prompt_tokens'),
-            output_tokens: data.dig('metadata', 'usage', 'completion_tokens'),
+            input_tokens: usage['prompt_tokens'] || data.dig('metadata', 'usage', 'prompt_tokens'),
+            output_tokens: usage['completion_tokens'] || data.dig('metadata', 'usage', 'completion_tokens'),
+            thinking_tokens: thinking_tokens,
             conversation_id: data['conversation_id'],
-            model_id: 'dify-model',
+            model_id: data['model'] || 'dify-model',
             raw: response
           )
         end
+
+        def extract_content_and_thinking(answer)
+          return [answer, nil] unless answer.is_a?(String)
+          return [answer, nil] unless answer.include?('<think>')
+
+          thinking = answer.scan(%r{<think>(.*?)</think>}m).join
+          content = answer.gsub(%r{<think>.*?</think>}m, '').strip
+
+          [content.empty? ? nil : content, thinking.empty? ? nil : thinking]
+        end
+
+        def extract_thinking_text(data)
+          candidate = data['reasoning_content'] || data['reasoning'] || data['thinking'] || data['thought']
+          return candidate if candidate.is_a?(String)
+
+          metadata = data['metadata']
+          candidate = metadata&.dig('reasoning_content') ||
+                      metadata&.dig('reasoning') ||
+                      metadata&.dig('thinking') ||
+                      metadata&.dig('thought')
+          return candidate if candidate.is_a?(String)
+
+          thoughts = data['thoughts'] || metadata&.dig('thoughts')
+          return nil unless thoughts.is_a?(Array)
+
+          text = thoughts.filter_map do |thought|
+            next thought if thought.is_a?(String)
+
+            thought['thought'] || thought['thinking'] || thought['content'] || thought['text']
+          end.join
+
+          text.empty? ? nil : text
+        end
+
+        def extract_thinking_signature(data)
+          candidate = data['thinking_signature'] || data['reasoning_signature'] || data['signature']
+          return candidate if candidate.is_a?(String)
+
+          metadata = data['metadata']
+          candidate = metadata&.dig('thinking_signature') ||
+                      metadata&.dig('reasoning_signature') ||
+                      metadata&.dig('signature')
+          candidate if candidate.is_a?(String)
+        end
+
+        def extract_thinking_tokens(data)
+          usage = data['usage'] || data.dig('metadata', 'usage') || {}
+          usage['thinking_tokens'] ||
+            usage['reasoning_tokens'] ||
+            usage.dig('completion_tokens_details', 'reasoning_tokens') ||
+            usage.dig('output_tokens_details', 'thinking_tokens')
+        end
       end
     end
   end

data/lib/ruby_llm/providers/dify/media.rb

@@ -9,13 +9,13 @@ module RubyLLM
 
         def format_files(content)
           return nil unless content.is_a?(Content)
-          
+
           parts = []
 
           content.attachments.each do |attachment|
             case attachment.type
             when :file_id
-              parts << format_document_type(attachment)              
+              parts << format_document_type(attachment)
             else
               raise UnsupportedAttachmentError, attachment.class
             end

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

@@ -12,14 +12,36 @@ module RubyLLM
         end
 
         def build_chunk(data)
+          if data['choices'].is_a?(Array)
+            delta = data.dig('choices', 0, 'delta') || {}
+            usage = data['usage'] || {}
+            content = delta['content']
+            thinking_text = delta['reasoning_content'] || delta['reasoning'] || delta['thinking']
+            thinking_signature = delta['reasoning_signature'] || delta['signature']
+            thinking_tokens = Chat.extract_thinking_tokens(data)
+            input_tokens = usage['prompt_tokens'] || data.dig('metadata', 'usage', 'prompt_tokens')
+            output_tokens = usage['completion_tokens'] || data.dig('metadata', 'usage', 'completion_tokens')
+            model_id = data['model']
+          else
+            content = data['answer']
+            thinking_text = Chat.extract_thinking_text(data)
+            thinking_signature = Chat.extract_thinking_signature(data)
+            thinking_tokens = Chat.extract_thinking_tokens(data)
+            input_tokens = data.dig('metadata', 'usage', 'prompt_tokens') || data.dig('usage', 'prompt_tokens')
+            output_tokens = data.dig('metadata', 'usage', 'completion_tokens') || data.dig('usage', 'completion_tokens')
+            model_id = nil
+          end
+
           Chunk.new(
             role: :assistant,
             conversation_id: data['conversation_id'],
-            model_id: nil,
-            content: data['answer'],
+            model_id: model_id,
+            content: content,
+            thinking: Thinking.build(text: thinking_text, signature: thinking_signature),
             tool_calls: nil,
-            input_tokens: data.dig('metadata', 'usage', 'prompt_tokens'),
-            output_tokens: data.dig('metadata', 'usage', 'completion_tokens')
+            input_tokens: input_tokens,
+            output_tokens: output_tokens,
+            thinking_tokens: thinking_tokens
           )
         end
       end

data/lib/ruby_llm/providers/dify.rb

@@ -35,6 +35,10 @@ module RubyLLM
           Dify::Capabilities
         end
 
+        def configuration_options
+          %i[dify_api_base dify_api_key dify_user]
+        end
+
         def local?
           true
         end

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

@@ -3,13 +3,35 @@
 module RubyLLM
   module Providers
     class Gemini
-      # Determines capabilities and pricing for Google Gemini models
+      # Provider-level capability checks and narrow registry fallbacks.
       module Capabilities
         module_function
 
+        PRICES = {
+          flash_2: { input: 0.10, output: 0.40 }, # rubocop:disable Naming/VariableNumber
+          flash_lite_2: { input: 0.075, output: 0.30 }, # rubocop:disable Naming/VariableNumber
+          flash: { input: 0.075, output: 0.30 },
+          flash_8b: { input: 0.0375, output: 0.15 },
+          pro: { input: 1.25, output: 5.0 },
+          pro_2_5: { input: 0.12, output: 0.50 }, # rubocop:disable Naming/VariableNumber
+          gemini_embedding: { input: 0.002, output: 0.004 },
+          embedding: { input: 0.00, output: 0.00 },
+          imagen: { price: 0.03 },
+          aqa: { input: 0.00, output: 0.00 }
+        }.freeze
+
+        def supports_tool_choice?(_model_id)
+          true
+        end
+
+        def supports_tool_parallel_control?(_model_id)
+          false
+        end
+
         def context_window_for(model_id)
           case model_id
-          when /gemini-2\.5-pro-exp-03-25/, /gemini-2\.0-flash/, /gemini-2\.0-flash-lite/, /gemini-1\.5-flash/, /gemini-1\.5-flash-8b/ # rubocop:disable Layout/LineLength
+          when /gemini-2\.5-pro-exp-03-25/, /gemini-2\.0-flash/, /gemini-2\.0-flash-lite/, /gemini-1\.5-flash/,
+               /gemini-1\.5-flash-8b/
             1_048_576
           when /gemini-1\.5-pro/ then 2_097_152
           when /gemini-embedding-exp/ then 8_192
@@ -23,7 +45,8 @@ module RubyLLM
         def max_tokens_for(model_id)
           case model_id
           when /gemini-2\.5-pro-exp-03-25/ then 64_000
-          when /gemini-2\.0-flash/, /gemini-2\.0-flash-lite/, /gemini-1\.5-flash/, /gemini-1\.5-flash-8b/, /gemini-1\.5-pro/ # rubocop:disable Layout/LineLength
+          when /gemini-2\.0-flash/, /gemini-2\.0-flash-lite/, /gemini-1\.5-flash/, /gemini-1\.5-flash-8b/,
+               /gemini-1\.5-pro/
             8_192
           when /gemini-embedding-exp/ then nil
           when /text-embedding-004/, /embedding-001/ then 768
@@ -32,18 +55,24 @@ module RubyLLM
           end
         end
 
-        def input_price_for(model_id)
-          base_price = PRICES.dig(pricing_family(model_id), :input) || default_input_price
-          return base_price unless long_context_model?(model_id)
-
-          context_window_for(model_id) > 128_000 ? base_price * 2 : base_price
+        def critical_capabilities_for(model_id)
+          capabilities = []
+          capabilities << 'function_calling' if supports_functions?(model_id)
+          capabilities << 'structured_output' if supports_structured_output?(model_id)
+          capabilities << 'vision' if supports_vision?(model_id)
+          capabilities
         end
 
-        def output_price_for(model_id)
-          base_price = PRICES.dig(pricing_family(model_id), :output) || default_output_price
-          return base_price unless long_context_model?(model_id)
-
-          context_window_for(model_id) > 128_000 ? base_price * 2 : base_price
+        def pricing_for(model_id)
+          prices = PRICES.fetch(pricing_family(model_id), { input: 0.075, output: 0.30 })
+          {
+            text_tokens: {
+              standard: {
+                input_per_million: prices[:input] || prices[:price] || 0.075,
+                output_per_million: prices[:output] || prices[:price] || 0.30
+              }
+            }
+          }
         end
 
         def supports_vision?(model_id)
@@ -52,17 +81,13 @@ module RubyLLM
           model_id.match?(/gemini|flash|pro|imagen/)
         end
 
-        def supports_video?(model_id)
-          model_id.match?(/gemini/)
-        end
-
         def supports_functions?(model_id)
           return false if model_id.match?(/text-embedding|embedding-001|aqa|flash-lite|imagen|gemini-2\.0-flash-lite/)
 
           model_id.match?(/gemini|pro|flash/)
         end
 
-        def supports_json_mode?(model_id)
+        def supports_structured_output?(model_id)
           if model_id.match?(/text-embedding|embedding-001|aqa|imagen|gemini-2\.0-flash-lite|gemini-2\.5-pro-exp-03-25/)
             return false
           end
@@ -70,59 +95,6 @@ module RubyLLM
           model_id.match?(/gemini|pro|flash/)
         end
 
-        def format_display_name(model_id)
-          model_id
-            .delete_prefix('models/')
-            .split('-')
-            .map(&:capitalize)
-            .join(' ')
-            .gsub(/(\d+\.\d+)/, ' \1')
-            .gsub(/\s+/, ' ')
-            .gsub('Aqa', 'AQA')
-            .strip
-        end
-
-        def supports_caching?(model_id)
-          if model_id.match?(/flash-lite|gemini-2\.5-pro-exp-03-25|aqa|imagen|text-embedding|embedding-001/)
-            return false
-          end
-
-          model_id.match?(/gemini|pro|flash/)
-        end
-
-        def supports_tuning?(model_id)
-          model_id.match?(/gemini-1\.5-flash|gemini-1\.5-flash-8b/)
-        end
-
-        def supports_audio?(model_id)
-          model_id.match?(/gemini|pro|flash/)
-        end
-
-        def model_type(model_id)
-          case model_id
-          when /text-embedding|embedding|gemini-embedding/ then 'embedding'
-          when /imagen/ then 'image'
-          else 'chat'
-          end
-        end
-
-        def model_family(model_id)
-          case model_id
-          when /gemini-2\.5-pro-exp-03-25/ then 'gemini25_pro_exp'
-          when /gemini-2\.0-flash-lite/ then 'gemini20_flash_lite'
-          when /gemini-2\.0-flash/ then 'gemini20_flash'
-          when /gemini-1\.5-flash-8b/ then 'gemini15_flash_8b'
-          when /gemini-1\.5-flash/ then 'gemini15_flash'
-          when /gemini-1\.5-pro/ then 'gemini15_pro'
-          when /gemini-embedding-exp/ then 'gemini_embedding_exp'
-          when /text-embedding-004/ then 'embedding4'
-          when /embedding-001/ then 'embedding1'
-          when /aqa/ then 'aqa'
-          when /imagen-3/ then 'imagen3'
-          else 'other'
-          end
-        end
-
         def pricing_family(model_id)
           case model_id
           when /gemini-2\.5-pro-exp-03-25/ then :pro_2_5 # rubocop:disable Naming/VariableNumber
@@ -139,142 +111,8 @@ module RubyLLM
           end
         end
 
-        def long_context_model?(model_id)
-          model_id.match?(/gemini-1\.5-(?:pro|flash)|gemini-1\.5-flash-8b/)
-        end
-
-        def context_length(model_id)
-          context_window_for(model_id)
-        end
-
-        PRICES = {
-          flash_2: { # rubocop:disable Naming/VariableNumber
-            input: 0.10,
-            output: 0.40,
-            audio_input: 0.70,
-            cache: 0.025,
-            cache_storage: 1.00,
-            grounding_search: 35.00
-          },
-          flash_lite_2: { # rubocop:disable Naming/VariableNumber
-            input: 0.075,
-            output: 0.30
-          },
-          flash: {
-            input: 0.075,
-            output: 0.30,
-            cache: 0.01875,
-            cache_storage: 1.00,
-            grounding_search: 35.00
-          },
-          flash_8b: {
-            input: 0.0375,
-            output: 0.15,
-            cache: 0.01,
-            cache_storage: 0.25,
-            grounding_search: 35.00
-          },
-          pro: {
-            input: 1.25,
-            output: 5.0,
-            cache: 0.3125,
-            cache_storage: 4.50,
-            grounding_search: 35.00
-          },
-          pro_2_5: { # rubocop:disable Naming/VariableNumber
-            input: 0.12,
-            output: 0.50
-          },
-          gemini_embedding: {
-            input: 0.002,
-            output: 0.004
-          },
-          embedding: {
-            input: 0.00,
-            output: 0.00
-          },
-          imagen: {
-            price: 0.03
-          },
-          aqa: {
-            input: 0.00,
-            output: 0.00
-          }
-        }.freeze
-
-        def default_input_price
-          0.075
-        end
-
-        def default_output_price
-          0.30
-        end
-
-        def modalities_for(model_id)
-          modalities = {
-            input: ['text'],
-            output: ['text']
-          }
-
-          if supports_vision?(model_id)
-            modalities[:input] << 'image'
-            modalities[:input] << 'pdf'
-          end
-
-          modalities[:input] << 'video' if supports_video?(model_id)
-          modalities[:input] << 'audio' if model_id.match?(/audio/)
-          modalities[:output] << 'embeddings' if model_id.match?(/embedding|gemini-embedding/)
-          modalities[:output] = ['image'] if model_id.match?(/imagen/)
-
-          modalities
-        end
-
-        def capabilities_for(model_id)
-          capabilities = ['streaming']
-
-          capabilities << 'function_calling' if supports_functions?(model_id)
-          capabilities << 'structured_output' if supports_json_mode?(model_id)
-          capabilities << 'batch' if model_id.match?(/embedding|flash/)
-          capabilities << 'caching' if supports_caching?(model_id)
-          capabilities << 'fine_tuning' if supports_tuning?(model_id)
-          capabilities
-        end
-
-        def pricing_for(model_id)
-          family = pricing_family(model_id)
-          prices = PRICES.fetch(family, { input: default_input_price, output: default_output_price })
-
-          standard_pricing = {
-            input_per_million: prices[:input],
-            output_per_million: prices[:output]
-          }
-
-          standard_pricing[:cached_input_per_million] = prices[:input_hit] if prices[:input_hit]
-
-          batch_pricing = {
-            input_per_million: (standard_pricing[:input_per_million] || 0) * 0.5,
-            output_per_million: (standard_pricing[:output_per_million] || 0) * 0.5
-          }
-
-          if standard_pricing[:cached_input_per_million]
-            batch_pricing[:cached_input_per_million] = standard_pricing[:cached_input_per_million] * 0.5
-          end
-
-          pricing = {
-            text_tokens: {
-              standard: standard_pricing,
-              batch: batch_pricing
-            }
-          }
-
-          if model_id.match?(/embedding|gemini-embedding/)
-            pricing[:embeddings] = {
-              standard: { input_per_million: prices[:price] || 0.002 }
-            }
-          end
-
-          pricing
-        end
+        module_function :context_window_for, :max_tokens_for, :critical_capabilities_for, :pricing_for,
+                        :supports_vision?, :supports_functions?, :supports_structured_output?, :pricing_family
       end
     end
   end