dify_llm 1.9.1 → 1.14.1

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

@@ -3,22 +3,26 @@
 module RubyLLM
   module Providers
     class Anthropic
-      # Chat methods of the OpenAI API integration
+      # Chat methods for the Anthropic API implementation
       module Chat
         module_function
 
         def completion_url
-          '/v1/messages'
+          'v1/messages'
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil) # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
+        # rubocop:disable Metrics/ParameterLists
+        def render_payload(messages, tools:, temperature:, model:, stream: false,
+                           schema: nil, thinking: nil, tool_prefs: nil)
+          tool_prefs ||= {}
           system_messages, chat_messages = separate_messages(messages)
           system_content = build_system_content(system_messages)
 
-          build_base_payload(chat_messages, model, stream).tap do |payload|
-            add_optional_fields(payload, system_content:, tools:, temperature:)
+          build_base_payload(chat_messages, model, stream, thinking).tap do |payload|
+            add_optional_fields(payload, system_content:, tools:, tool_prefs:, temperature:, schema:)
           end
         end
+        # rubocop:enable Metrics/ParameterLists
 
         def separate_messages(messages)
           messages.partition { |msg| msg.role == :system }
@@ -45,19 +49,37 @@ module RubyLLM
           end
         end
 
-        def build_base_payload(chat_messages, model, stream)
-          {
+        def build_base_payload(chat_messages, model, stream, thinking)
+          payload = {
             model: model.id,
-            messages: chat_messages.map { |msg| format_message(msg) },
+            messages: chat_messages.map { |msg| format_message(msg, thinking: thinking) },
             stream: stream,
             max_tokens: model.max_tokens || 4096
           }
+
+          thinking_payload = build_thinking_payload(thinking)
+          payload[:thinking] = thinking_payload if thinking_payload
+
+          payload
         end
 
-        def add_optional_fields(payload, system_content:, tools:, temperature:)
-          payload[:tools] = tools.values.map { |t| Tools.function_for(t) } if tools.any?
+        def add_optional_fields(payload, system_content:, tools:, tool_prefs:, temperature:, schema: nil) # rubocop:disable Metrics/ParameterLists
+          if tools.any?
+            payload[:tools] = tools.values.map { |t| Tools.function_for(t) }
+            unless tool_prefs[:choice].nil? && tool_prefs[:calls].nil?
+              payload[:tool_choice] = Tools.build_tool_choice(tool_prefs)
+            end
+          end
           payload[:system] = system_content unless system_content.empty?
           payload[:temperature] = temperature unless temperature.nil?
+          payload[:output_config] = build_output_config(schema) if schema
+        end
+
+        def build_output_config(schema)
+          normalized = RubyLLM::Utils.deep_dup(schema[:schema])
+          normalized.delete(:strict)
+          normalized.delete('strict')
+          { format: { type: 'json_schema', schema: normalized } }
         end
 
         def parse_completion_response(response)
@@ -65,9 +87,11 @@ module RubyLLM
           content_blocks = data['content'] || []
 
           text_content = extract_text_content(content_blocks)
+          thinking_content = extract_thinking_content(content_blocks)
+          thinking_signature = extract_thinking_signature(content_blocks)
           tool_use_blocks = Tools.find_tool_uses(content_blocks)
 
-          build_message(data, text_content, tool_use_blocks, response)
+          build_message(data, text_content, thinking_content, thinking_signature, tool_use_blocks, response)
         end
 
         def extract_text_content(blocks)
@@ -75,50 +99,158 @@ module RubyLLM
           text_blocks.map { |c| c['text'] }.join
         end
 
-        def build_message(data, content, tool_use_blocks, response)
+        def extract_thinking_content(blocks)
+          thinking_blocks = blocks.select { |c| c['type'] == 'thinking' }
+          thoughts = thinking_blocks.map { |c| c['thinking'] || c['text'] }.join
+          thoughts.empty? ? nil : thoughts
+        end
+
+        def extract_thinking_signature(blocks)
+          thinking_block = blocks.find { |c| c['type'] == 'thinking' } ||
+                           blocks.find { |c| c['type'] == 'redacted_thinking' }
+          thinking_block&.dig('signature') || thinking_block&.dig('data')
+        end
+
+        def build_message(data, content, thinking, thinking_signature, tool_use_blocks, response) # rubocop:disable Metrics/ParameterLists
           usage = data['usage'] || {}
           cached_tokens = usage['cache_read_input_tokens']
           cache_creation_tokens = usage['cache_creation_input_tokens']
           if cache_creation_tokens.nil? && usage['cache_creation'].is_a?(Hash)
             cache_creation_tokens = usage['cache_creation'].values.compact.sum
           end
+          thinking_tokens = usage.dig('output_tokens_details', 'thinking_tokens') ||
+                            usage.dig('output_tokens_details', 'reasoning_tokens') ||
+                            usage['thinking_tokens'] ||
+                            usage['reasoning_tokens']
 
           Message.new(
             role: :assistant,
             content: content,
+            thinking: Thinking.build(text: thinking, signature: thinking_signature),
             tool_calls: Tools.parse_tool_calls(tool_use_blocks),
             input_tokens: usage['input_tokens'],
             output_tokens: usage['output_tokens'],
             cached_tokens: cached_tokens,
             cache_creation_tokens: cache_creation_tokens,
+            thinking_tokens: thinking_tokens,
             model_id: data['model'],
             raw: response
           )
         end
 
-        def format_message(msg)
+        def format_message(msg, thinking: nil)
+          thinking_enabled = thinking&.enabled?
+
           if msg.tool_call?
-            Tools.format_tool_call(msg)
+            format_tool_call_with_thinking(msg, thinking_enabled)
           elsif msg.tool_result?
             Tools.format_tool_result(msg)
           else
-            format_basic_message(msg)
+            format_basic_message_with_thinking(msg, thinking_enabled)
           end
         end
 
-        def format_basic_message(msg)
+        def format_basic_message_with_thinking(msg, thinking_enabled)
+          content_blocks = []
+
+          if msg.role == :assistant && thinking_enabled
+            thinking_block = build_thinking_block(msg.thinking)
+            content_blocks << thinking_block if thinking_block
+          end
+
+          append_formatted_content(content_blocks, msg.content)
+
           {
             role: convert_role(msg.role),
-            content: Media.format_content(msg.content)
+            content: content_blocks
+          }
+        end
+
+        def format_tool_call_with_thinking(msg, thinking_enabled)
+          if msg.content.is_a?(RubyLLM::Content::Raw)
+            content_blocks = msg.content.value
+            content_blocks = [content_blocks] unless content_blocks.is_a?(Array)
+            content_blocks = prepend_thinking_block(content_blocks, msg, thinking_enabled)
+
+            return { role: 'assistant', content: content_blocks }
+          end
+
+          content_blocks = prepend_thinking_block([], msg, thinking_enabled)
+          content_blocks << Media.format_text(msg.content) unless msg.content.nil? || msg.content.empty?
+
+          msg.tool_calls.each_value do |tool_call|
+            content_blocks << {
+              type: 'tool_use',
+              id: tool_call.id,
+              name: tool_call.name,
+              input: tool_call.arguments
+            }
+          end
+
+          {
+            role: 'assistant',
+            content: content_blocks
           }
         end
 
+        def prepend_thinking_block(content_blocks, msg, thinking_enabled)
+          return content_blocks unless thinking_enabled
+
+          thinking_block = build_thinking_block(msg.thinking)
+          content_blocks.unshift(thinking_block) if thinking_block
+
+          content_blocks
+        end
+
+        def build_thinking_block(thinking)
+          return nil unless thinking
+
+          if thinking.text
+            {
+              type: 'thinking',
+              thinking: thinking.text,
+              signature: thinking.signature
+            }.compact
+          elsif thinking.signature
+            {
+              type: 'redacted_thinking',
+              data: thinking.signature
+            }
+          end
+        end
+
+        def append_formatted_content(content_blocks, content)
+          formatted_content = Media.format_content(content)
+          if formatted_content.is_a?(Array)
+            content_blocks.concat(formatted_content)
+          else
+            content_blocks << formatted_content
+          end
+        end
+
         def convert_role(role)
           case role
           when :tool, :user then 'user'
           else 'assistant'
           end
         end
+
+        def build_thinking_payload(thinking)
+          return nil unless thinking&.enabled?
+
+          budget = resolve_budget(thinking)
+          raise ArgumentError, 'Anthropic thinking requires a budget' if budget.nil?
+
+          {
+            type: 'enabled',
+            budget_tokens: budget
+          }
+        end
+
+        def resolve_budget(thinking)
+          budget = thinking.respond_to?(:budget) ? thinking.budget : thinking
+          budget.is_a?(Integer) ? budget : nil
+        end
       end
     end
   end

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

@@ -44,7 +44,7 @@ module RubyLLM
               type: 'image',
               source: {
                 type: 'url',
-                url: image.source
+                url: image.source.to_s
               }
             }
           else
@@ -65,7 +65,7 @@ module RubyLLM
               type: 'document',
               source: {
                 type: 'url',
-                url: pdf.source
+                url: pdf.source.to_s
               }
             }
           else

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

@@ -8,24 +8,18 @@ module RubyLLM
         module_function
 
         def models_url
-          '/v1/models'
+          'v1/models'
         end
 
-        def parse_list_models_response(response, slug, capabilities)
+        def parse_list_models_response(response, slug, _capabilities)
           Array(response.body['data']).map do |model_data|
             model_id = model_data['id']
 
             Model::Info.new(
               id: model_id,
-              name: model_data['display_name'],
+              name: model_data['display_name'] || model_id,
               provider: slug,
-              family: capabilities.model_family(model_id),
               created_at: Time.parse(model_data['created_at']),
-              context_window: capabilities.determine_context_window(model_id),
-              max_output_tokens: capabilities.determine_max_tokens(model_id),
-              modalities: capabilities.modalities_for(model_id),
-              capabilities: capabilities.capabilities_for(model_id),
-              pricing: capabilities.pricing_for(model_id),
               metadata: {}
             )
           end

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

@@ -12,10 +12,16 @@ module RubyLLM
         end
 
         def build_chunk(data)
+          delta_type = data.dig('delta', 'type')
+
           Chunk.new(
             role: :assistant,
             model_id: extract_model_id(data),
-            content: data.dig('delta', 'text'),
+            content: extract_content_delta(data, delta_type),
+            thinking: Thinking.build(
+              text: extract_thinking_delta(data, delta_type),
+              signature: extract_signature_delta(data, delta_type)
+            ),
             input_tokens: extract_input_tokens(data),
             output_tokens: extract_output_tokens(data),
             cached_tokens: extract_cached_tokens(data),
@@ -24,6 +30,24 @@ module RubyLLM
           )
         end
 
+        def extract_content_delta(data, delta_type)
+          return data.dig('delta', 'text') if delta_type == 'text_delta'
+
+          nil
+        end
+
+        def extract_thinking_delta(data, delta_type)
+          return data.dig('delta', 'thinking') if delta_type == 'thinking_delta'
+
+          nil
+        end
+
+        def extract_signature_delta(data, delta_type)
+          return data.dig('delta', 'signature') if delta_type == 'signature_delta'
+
+          nil
+        end
+
         def json_delta?(data)
           data['type'] == 'content_block_delta' && data.dig('delta', 'type') == 'input_json_delta'
         end

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

@@ -103,6 +103,26 @@ module RubyLLM
             'strict' => true
           }
         end
+
+        def build_tool_choice(tool_prefs)
+          tool_choice = tool_prefs[:choice]
+          calls_in_response = tool_prefs[:calls]
+          tool_choice = :auto if tool_choice.nil?
+
+          {
+            type: case tool_choice
+                  when :auto, :none
+                    tool_choice
+                  when :required
+                    :any
+                  else
+                    :tool
+                  end
+          }.tap do |tc|
+            tc[:name] = tool_choice if tc[:type] == :tool
+            tc[:disable_parallel_tool_use] = calls_in_response == :one if tc[:type] != :none && !calls_in_response.nil?
+          end
+        end
       end
     end
   end

data/lib/ruby_llm/providers/anthropic.rb

@@ -12,7 +12,7 @@ module RubyLLM
       include Anthropic::Tools
 
       def api_base
-        'https://api.anthropic.com'
+        @config.anthropic_api_base || 'https://api.anthropic.com'
       end
 
       def headers
@@ -27,6 +27,10 @@ module RubyLLM
           Anthropic::Capabilities
         end
 
+        def configuration_options
+          %i[anthropic_api_key anthropic_api_base]
+        end
+
         def configuration_requirements
           %i[anthropic_api_key]
         end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Azure
+      # Chat methods of the Azure AI Foundry API integration
+      module Chat
+        def completion_url
+          azure_endpoint(:chat)
+        end
+
+        def format_messages(messages)
+          messages.map do |msg|
+            {
+              role: format_role(msg.role),
+              content: Media.format_content(msg.content),
+              tool_calls: format_tool_calls(msg.tool_calls),
+              tool_call_id: msg.tool_call_id
+            }.compact.merge(format_thinking(msg))
+          end
+        end
+
+        def format_role(role)
+          role.to_s
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/azure/embeddings.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Azure
+      # Embeddings methods of the Azure AI Foundry API integration
+      module Embeddings
+        module_function
+
+        def embedding_url(...)
+          azure_endpoint(:embeddings)
+        end
+
+        def render_embedding_payload(text, model:, dimensions:)
+          {
+            model: model,
+            input: [text].flatten,
+            dimensions: dimensions
+          }.compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Azure
+      # Handles formatting of media content (images, audio) for Azure OpenAI-compatible APIs.
+      module Media
+        module_function
+
+        def format_content(content) # rubocop:disable Metrics/PerceivedComplexity
+          return content.value if content.is_a?(RubyLLM::Content::Raw)
+          return content.to_json if content.is_a?(Hash) || content.is_a?(Array)
+          return content unless content.is_a?(Content)
+
+          parts = []
+          parts << OpenAI::Media.format_text(content.text) if content.text
+
+          content.attachments.each do |attachment|
+            case attachment.type
+            when :image
+              parts << format_image(attachment)
+            when :audio
+              parts << OpenAI::Media.format_audio(attachment)
+            when :text
+              parts << OpenAI::Media.format_text_file(attachment)
+            else
+              raise UnsupportedAttachmentError, attachment.type
+            end
+          end
+
+          parts
+        end
+
+        def format_image(image)
+          {
+            type: 'image_url',
+            image_url: {
+              url: image.for_llm
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Azure
+      # Models methods of the Azure AI Foundry API integration
+      module Models
+        def models_url
+          azure_endpoint(:models)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/azure.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Azure AI Foundry / OpenAI-compatible API integration.
+    class Azure < OpenAI
+      AZURE_DEFAULT_CHAT_API_VERSION = '2024-05-01-preview'
+      AZURE_DEFAULT_MODELS_API_VERSION = 'preview'
+
+      include Azure::Chat
+      include Azure::Embeddings
+      include Azure::Media
+      include Azure::Models
+
+      def api_base
+        @config.azure_api_base
+      end
+
+      def headers
+        if @config.azure_api_key
+          { 'api-key' => @config.azure_api_key }
+        else
+          { 'Authorization' => "Bearer #{@config.azure_ai_auth_token}" }
+        end
+      end
+
+      def configured?
+        self.class.configured?(@config)
+      end
+
+      def azure_endpoint(kind)
+        parts = azure_base_parts
+
+        case kind
+        when :chat
+          chat_endpoint(parts)
+        when :embeddings
+          embeddings_endpoint(parts)
+        when :models
+          models_endpoint(parts)
+        else
+          raise ArgumentError, "Unknown Azure endpoint kind: #{kind.inspect}"
+        end
+      end
+
+      class << self
+        def configuration_options
+          %i[azure_api_base azure_api_key azure_ai_auth_token]
+        end
+
+        def configuration_requirements
+          %i[azure_api_base]
+        end
+
+        def configured?(config)
+          config.azure_api_base && (config.azure_api_key || config.azure_ai_auth_token)
+        end
+
+        # Azure works with deployment names, instead of model names
+        def assume_models_exist?
+          true
+        end
+      end
+
+      def ensure_configured!
+        missing = []
+        missing << :azure_api_base unless @config.azure_api_base
+        if @config.azure_api_key.nil? && @config.azure_ai_auth_token.nil?
+          missing << 'azure_api_key or azure_ai_auth_token'
+        end
+        return if missing.empty?
+
+        raise ConfigurationError,
+              "Missing configuration for Azure: #{missing.join(', ')}"
+      end
+
+      private
+
+      def azure_base_parts
+        @azure_base_parts ||= begin
+          raw_base = api_base.to_s.sub(%r{/+\z}, '')
+          version = raw_base[/[?&]api-version=([^&]+)/i, 1]
+          path_base = raw_base.sub(/\?.*\z/, '')
+
+          mode = if path_base.include?('/chat/completions')
+                   :chat_endpoint
+                 elsif path_base.include?('/openai/deployments/')
+                   :deployment_base
+                 elsif path_base.include?('/openai/v1')
+                   :openai_v1_base
+                 else
+                   :resource_base
+                 end
+
+          {
+            raw_base: raw_base,
+            path_base: path_base,
+            root: azure_host_root(path_base),
+            mode: mode,
+            version: version
+          }
+        end
+      end
+
+      def chat_endpoint(parts)
+        case parts[:mode]
+        when :chat_endpoint
+          ''
+        when :deployment_base
+          with_api_version('chat/completions', parts[:version] || AZURE_DEFAULT_CHAT_API_VERSION)
+        when :openai_v1_base
+          with_api_version('chat/completions', parts[:version])
+        else
+          with_api_version('models/chat/completions', parts[:version] || AZURE_DEFAULT_CHAT_API_VERSION)
+        end
+      end
+
+      def embeddings_endpoint(parts)
+        case parts[:mode]
+        when :deployment_base, :openai_v1_base
+          with_api_version('embeddings', parts[:version])
+        else
+          "#{parts[:root]}/openai/v1/embeddings"
+        end
+      end
+
+      def models_endpoint(parts)
+        case parts[:mode]
+        when :openai_v1_base
+          with_api_version('models', parts[:version] || AZURE_DEFAULT_MODELS_API_VERSION)
+        else
+          "#{parts[:root]}/openai/v1/models?api-version=#{parts[:version] || AZURE_DEFAULT_MODELS_API_VERSION}"
+        end
+      end
+
+      def with_api_version(path, version)
+        return path unless version
+
+        separator = path.include?('?') ? '&' : '?'
+        "#{path}#{separator}api-version=#{version}"
+      end
+
+      def azure_host_root(base_without_query)
+        base_without_query.sub(%r{/(models|openai)/.*\z}, '').sub(%r{/+\z}, '')
+      end
+    end
+  end
+end