dify_llm 1.6.4

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Dify
+      # Media handling methods for the Gemini API integration
+      module Media
+        module_function
+
+        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)              
+            else
+              raise UnsupportedAttachmentError, attachment.class
+            end
+          end
+
+          parts
+        end
+
+        def format_document_type(attachment)
+          {
+            type: 'document',
+            transfer_method: 'local_file',
+            upload_file_id: attachment.upload_file_id
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Dify
+      # Streaming methods of the OpenAI API integration
+      module Streaming
+        module_function
+
+        def stream_url
+          completion_url
+        end
+
+        def build_chunk(data)
+          Chunk.new(
+            role: :assistant,
+            conversation_id: data['conversation_id'],
+            model_id: nil,
+            content: data['answer'],
+            tool_calls: nil,
+            input_tokens: data.dig('metadata', 'usage', 'prompt_tokens'),
+            output_tokens: data.dig('metadata', 'usage', 'completion_tokens')
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/dify.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Dify API integration.
+    class Dify < Provider
+      include Dify::Chat
+      include Dify::Media
+      include Dify::Streaming
+
+      def api_base
+        @config.dify_api_base
+      end
+
+      def parse_error(response)
+        return if response.body.empty?
+
+        body = try_parse_json(response.body)
+        case body
+        when Hash
+          body['message']
+        else
+          body
+        end
+      end
+
+      def headers
+        {
+          'Authorization' => "Bearer #{@config.dify_api_key}"
+        }
+      end
+
+      class << self
+        def capabilities
+          Dify::Capabilities
+        end
+
+        def local?
+          true
+        end
+
+        def configuration_requirements
+          %i[dify_api_base dify_api_key]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Gemini
+      # Determines capabilities and pricing for Google Gemini models
+      module Capabilities
+        module_function
+
+        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
+            1_048_576
+          when /gemini-1\.5-pro/ then 2_097_152
+          when /gemini-embedding-exp/ then 8_192
+          when /text-embedding-004/, /embedding-001/ then 2_048
+          when /aqa/ then 7_168
+          when /imagen-3/ then nil
+          else 32_768
+          end
+        end
+
+        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
+            8_192
+          when /gemini-embedding-exp/ then nil
+          when /text-embedding-004/, /embedding-001/ then 768
+          when /imagen-3/ then 4
+          else 4_096
+          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
+        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
+        end
+
+        def supports_vision?(model_id)
+          return false if model_id.match?(/text-embedding|embedding-001|aqa/)
+
+          model_id.match?(/gemini|flash|pro|imagen/)
+        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)
+          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
+
+          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
+          when /gemini-2\.0-flash-lite/ then :flash_lite_2 # rubocop:disable Naming/VariableNumber
+          when /gemini-2\.0-flash/ then :flash_2 # rubocop:disable Naming/VariableNumber
+          when /gemini-1\.5-flash-8b/ then :flash_8b
+          when /gemini-1\.5-flash/ then :flash
+          when /gemini-1\.5-pro/ then :pro
+          when /gemini-embedding-exp/ then :gemini_embedding
+          when /text-embedding|embedding/ then :embedding
+          when /imagen/ then :imagen
+          when /aqa/ then :aqa
+          else :base
+          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] << '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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Gemini
+      # Chat methods for the Gemini API implementation
+      module Chat
+        module_function
+
+        def completion_url
+          "models/#{@model}:generateContent"
+        end
+
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil) # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
+          @model = model.id
+          payload = {
+            contents: format_messages(messages),
+            generationConfig: {}
+          }
+
+          payload[:generationConfig][:temperature] = temperature unless temperature.nil?
+
+          if schema
+            payload[:generationConfig][:responseMimeType] = 'application/json'
+            payload[:generationConfig][:responseSchema] = convert_schema_to_gemini(schema)
+          end
+
+          payload[:tools] = format_tools(tools) if tools.any?
+          payload
+        end
+
+        private
+
+        def format_messages(messages)
+          messages.map do |msg|
+            {
+              role: format_role(msg.role),
+              parts: format_parts(msg)
+            }
+          end
+        end
+
+        def format_role(role)
+          case role
+          when :assistant then 'model'
+          when :system, :tool then 'user'
+          else role.to_s
+          end
+        end
+
+        def format_parts(msg)
+          if msg.tool_call?
+            [{
+              functionCall: {
+                name: msg.tool_calls.values.first.name,
+                args: msg.tool_calls.values.first.arguments
+              }
+            }]
+          elsif msg.tool_result?
+            [{
+              functionResponse: {
+                name: msg.tool_call_id,
+                response: {
+                  name: msg.tool_call_id,
+                  content: Media.format_content(msg.content)
+                }
+              }
+            }]
+          else
+            Media.format_content(msg.content)
+          end
+        end
+
+        def parse_completion_response(response)
+          data = response.body
+          tool_calls = extract_tool_calls(data)
+
+          Message.new(
+            role: :assistant,
+            content: extract_content(data),
+            tool_calls: tool_calls,
+            input_tokens: data.dig('usageMetadata', 'promptTokenCount'),
+            output_tokens: calculate_output_tokens(data),
+            model_id: data['modelVersion'] || response.env.url.path.split('/')[3].split(':')[0],
+            raw: response
+          )
+        end
+
+        def convert_schema_to_gemini(schema)
+          return nil unless schema
+
+          build_base_schema(schema).tap do |result|
+            result[:description] = schema[:description] if schema[:description]
+            apply_type_specific_attributes(result, schema)
+          end
+        end
+
+        def extract_content(data)
+          candidate = data.dig('candidates', 0)
+          return '' unless candidate
+
+          return '' if function_call?(candidate)
+
+          parts = candidate.dig('content', 'parts')
+          text_parts = parts&.select { |p| p['text'] }
+          return '' unless text_parts&.any?
+
+          text_parts.map { |p| p['text'] }.join
+        end
+
+        def function_call?(candidate)
+          parts = candidate.dig('content', 'parts')
+          parts&.any? { |p| p['functionCall'] }
+        end
+
+        def calculate_output_tokens(data)
+          candidates = data.dig('usageMetadata', 'candidatesTokenCount') || 0
+          thoughts = data.dig('usageMetadata', 'thoughtsTokenCount') || 0
+          candidates + thoughts
+        end
+
+        def build_base_schema(schema)
+          case schema[:type]
+          when 'object'
+            build_object_schema(schema)
+          when 'array'
+            { type: 'ARRAY', items: schema[:items] ? convert_schema_to_gemini(schema[:items]) : { type: 'STRING' } }
+          when 'number'
+            { type: 'NUMBER' }
+          when 'integer'
+            { type: 'INTEGER' }
+          when 'boolean'
+            { type: 'BOOLEAN' }
+          else
+            { type: 'STRING' }
+          end
+        end
+
+        def build_object_schema(schema)
+          {
+            type: 'OBJECT',
+            properties: (schema[:properties] || {}).transform_values { |prop| convert_schema_to_gemini(prop) },
+            required: schema[:required] || []
+          }.tap do |object|
+            object[:propertyOrdering] = schema[:propertyOrdering] if schema[:propertyOrdering]
+            object[:nullable] = schema[:nullable] if schema.key?(:nullable)
+          end
+        end
+
+        def apply_type_specific_attributes(result, schema)
+          case schema[:type]
+          when 'string'
+            copy_attributes(result, schema, :enum, :format, :nullable)
+          when 'number', 'integer'
+            copy_attributes(result, schema, :format, :minimum, :maximum, :enum, :nullable)
+          when 'array'
+            copy_attributes(result, schema, :minItems, :maxItems, :nullable)
+          when 'boolean'
+            copy_attributes(result, schema, :nullable)
+          end
+        end
+
+        def copy_attributes(target, source, *attributes)
+          attributes.each do |attr|
+            target[attr] = source[attr] if attr == :nullable ? source.key?(attr) : source[attr]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Gemini
+      # Embeddings methods for the Gemini API integration
+      module Embeddings
+        module_function
+
+        def embedding_url(model:)
+          "models/#{model}:batchEmbedContents"
+        end
+
+        def render_embedding_payload(text, model:, dimensions:)
+          { requests: [text].flatten.map { |t| single_embedding_payload(t, model:, dimensions:) } }
+        end
+
+        def parse_embedding_response(response, model:, text:)
+          vectors = response.body['embeddings']&.map { |e| e['values'] }
+          vectors = vectors.first if vectors&.length == 1 && !text.is_a?(Array)
+
+          Embedding.new(vectors:, model:, input_tokens: 0)
+        end
+
+        private
+
+        def single_embedding_payload(text, model:, dimensions:)
+          {
+            model: "models/#{model}",
+            content: { parts: [{ text: text.to_s }] },
+            outputDimensionality: dimensions
+          }.compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Gemini
+      # Image generation methods for the Gemini API implementation
+      module Images
+        def images_url
+          "models/#{@model}:predict"
+        end
+
+        def render_image_payload(prompt, model:, size:)
+          RubyLLM.logger.debug "Ignoring size #{size}. Gemini does not support image size customization."
+          @model = model
+          {
+            instances: [
+              {
+                prompt: prompt
+              }
+            ],
+            parameters: {
+              sampleCount: 1
+            }
+          }
+        end
+
+        def parse_image_response(response, model:)
+          data = response.body
+          image_data = data['predictions']&.first
+
+          unless image_data&.key?('bytesBase64Encoded')
+            raise Error, 'Unexpected response format from Gemini image generation API'
+          end
+
+          mime_type = image_data['mimeType'] || 'image/png'
+          base64_data = image_data['bytesBase64Encoded']
+
+          Image.new(
+            data: base64_data,
+            mime_type: mime_type,
+            model_id: model
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Gemini
+      # Media handling methods for the Gemini API integration
+      module Media
+        module_function
+
+        def format_content(content)
+          return [format_text(content.to_json)] if content.is_a?(Hash) || content.is_a?(Array)
+          return [format_text(content)] unless content.is_a?(Content)
+
+          parts = []
+          parts << format_text(content.text) if content.text
+
+          content.attachments.each do |attachment|
+            case attachment.type
+            when :text
+              parts << format_text_file(attachment)
+            when :unknown
+              raise UnsupportedAttachmentError, attachment.mime_type
+            else
+              parts << format_attachment(attachment)
+            end
+          end
+
+          parts
+        end
+
+        def format_attachment(attachment)
+          {
+            inline_data: {
+              mime_type: attachment.mime_type,
+              data: attachment.encoded
+            }
+          }
+        end
+
+        def format_text_file(text_file)
+          {
+            text: text_file.for_llm
+          }
+        end
+
+        def format_text(text)
+          {
+            text: text
+          }
+        end
+      end
+    end
+  end
+end