dify_llm 1.6.4

data/lib/ruby_llm/aliases.json

@@ -0,0 +1,274 @@
+{
+  "chatgpt-4o": {
+    "openai": "chatgpt-4o-latest",
+    "openrouter": "openai/chatgpt-4o-latest"
+  },
+  "claude-3-5-haiku": {
+    "anthropic": "claude-3-5-haiku-20241022",
+    "openrouter": "anthropic/claude-3.5-haiku",
+    "bedrock": "anthropic.claude-3-5-haiku-20241022-v1:0"
+  },
+  "claude-3-5-sonnet": {
+    "anthropic": "claude-3-5-sonnet-20241022",
+    "openrouter": "anthropic/claude-3.5-sonnet",
+    "bedrock": "anthropic.claude-3-5-sonnet-20240620-v1:0:200k"
+  },
+  "claude-3-7-sonnet": {
+    "anthropic": "claude-3-7-sonnet-20250219",
+    "openrouter": "anthropic/claude-3.7-sonnet",
+    "bedrock": "us.anthropic.claude-3-7-sonnet-20250219-v1:0"
+  },
+  "claude-3-haiku": {
+    "anthropic": "claude-3-haiku-20240307",
+    "openrouter": "anthropic/claude-3-haiku",
+    "bedrock": "anthropic.claude-3-haiku-20240307-v1:0:200k"
+  },
+  "claude-3-opus": {
+    "anthropic": "claude-3-opus-20240229",
+    "openrouter": "anthropic/claude-3-opus",
+    "bedrock": "anthropic.claude-3-opus-20240229-v1:0:200k"
+  },
+  "claude-3-sonnet": {
+    "bedrock": "anthropic.claude-3-sonnet-20240229-v1:0"
+  },
+  "claude-opus-4": {
+    "anthropic": "claude-opus-4-20250514",
+    "openrouter": "anthropic/claude-opus-4",
+    "bedrock": "us.anthropic.claude-opus-4-1-20250805-v1:0"
+  },
+  "claude-opus-4-1": {
+    "anthropic": "claude-opus-4-1-20250805",
+    "openrouter": "anthropic/claude-opus-4.1",
+    "bedrock": "us.anthropic.claude-opus-4-1-20250805-v1:0"
+  },
+  "claude-sonnet-4": {
+    "anthropic": "claude-sonnet-4-20250514",
+    "openrouter": "anthropic/claude-sonnet-4",
+    "bedrock": "us.anthropic.claude-sonnet-4-20250514-v1:0"
+  },
+  "deepseek-chat": {
+    "deepseek": "deepseek-chat",
+    "openrouter": "deepseek/deepseek-chat"
+  },
+  "gemini-1.5-flash": {
+    "gemini": "gemini-1.5-flash",
+    "vertexai": "gemini-1.5-flash"
+  },
+  "gemini-1.5-flash-002": {
+    "gemini": "gemini-1.5-flash-002",
+    "vertexai": "gemini-1.5-flash-002"
+  },
+  "gemini-1.5-flash-8b": {
+    "gemini": "gemini-1.5-flash-8b",
+    "vertexai": "gemini-1.5-flash-8b"
+  },
+  "gemini-1.5-pro": {
+    "gemini": "gemini-1.5-pro",
+    "vertexai": "gemini-1.5-pro"
+  },
+  "gemini-1.5-pro-002": {
+    "gemini": "gemini-1.5-pro-002",
+    "vertexai": "gemini-1.5-pro-002"
+  },
+  "gemini-2.0-flash": {
+    "gemini": "gemini-2.0-flash",
+    "vertexai": "gemini-2.0-flash"
+  },
+  "gemini-2.0-flash-001": {
+    "gemini": "gemini-2.0-flash-001",
+    "openrouter": "google/gemini-2.0-flash-001",
+    "vertexai": "gemini-2.0-flash-001"
+  },
+  "gemini-2.0-flash-exp": {
+    "gemini": "gemini-2.0-flash-exp",
+    "vertexai": "gemini-2.0-flash-exp"
+  },
+  "gemini-2.0-flash-lite-001": {
+    "gemini": "gemini-2.0-flash-lite-001",
+    "openrouter": "google/gemini-2.0-flash-lite-001",
+    "vertexai": "gemini-2.0-flash-lite-001"
+  },
+  "gemini-2.5-flash": {
+    "gemini": "gemini-2.5-flash",
+    "openrouter": "google/gemini-2.5-flash",
+    "vertexai": "gemini-2.5-flash"
+  },
+  "gemini-2.5-flash-image-preview": {
+    "gemini": "gemini-2.5-flash-image-preview",
+    "openrouter": "google/gemini-2.5-flash-image-preview"
+  },
+  "gemini-2.5-flash-lite": {
+    "gemini": "gemini-2.5-flash-lite",
+    "openrouter": "google/gemini-2.5-flash-lite",
+    "vertexai": "gemini-2.5-flash-lite"
+  },
+  "gemini-2.5-flash-lite-preview-06-17": {
+    "gemini": "gemini-2.5-flash-lite-preview-06-17",
+    "openrouter": "google/gemini-2.5-flash-lite-preview-06-17"
+  },
+  "gemini-2.5-pro": {
+    "gemini": "gemini-2.5-pro",
+    "openrouter": "google/gemini-2.5-pro",
+    "vertexai": "gemini-2.5-pro"
+  },
+  "gemini-2.5-pro-preview-05-06": {
+    "gemini": "gemini-2.5-pro-preview-05-06",
+    "openrouter": "google/gemini-2.5-pro-preview-05-06"
+  },
+  "gemini-embedding-001": {
+    "gemini": "gemini-embedding-001",
+    "vertexai": "gemini-embedding-001"
+  },
+  "gemini-exp-1206": {
+    "gemini": "gemini-exp-1206",
+    "vertexai": "gemini-exp-1206"
+  },
+  "gemma-3-12b-it": {
+    "gemini": "gemma-3-12b-it",
+    "openrouter": "google/gemma-3-12b-it"
+  },
+  "gemma-3-27b-it": {
+    "gemini": "gemma-3-27b-it",
+    "openrouter": "google/gemma-3-27b-it"
+  },
+  "gemma-3-4b-it": {
+    "gemini": "gemma-3-4b-it",
+    "openrouter": "google/gemma-3-4b-it"
+  },
+  "gemma-3n-e4b-it": {
+    "gemini": "gemma-3n-e4b-it",
+    "openrouter": "google/gemma-3n-e4b-it"
+  },
+  "gpt-3.5-turbo": {
+    "openai": "gpt-3.5-turbo",
+    "openrouter": "openai/gpt-3.5-turbo"
+  },
+  "gpt-3.5-turbo-16k": {
+    "openai": "gpt-3.5-turbo-16k",
+    "openrouter": "openai/gpt-3.5-turbo-16k"
+  },
+  "gpt-3.5-turbo-instruct": {
+    "openai": "gpt-3.5-turbo-instruct",
+    "openrouter": "openai/gpt-3.5-turbo-instruct"
+  },
+  "gpt-4": {
+    "openai": "gpt-4",
+    "openrouter": "openai/gpt-4"
+  },
+  "gpt-4-1106-preview": {
+    "openai": "gpt-4-1106-preview",
+    "openrouter": "openai/gpt-4-1106-preview"
+  },
+  "gpt-4-turbo": {
+    "openai": "gpt-4-turbo",
+    "openrouter": "openai/gpt-4-turbo"
+  },
+  "gpt-4-turbo-preview": {
+    "openai": "gpt-4-turbo-preview",
+    "openrouter": "openai/gpt-4-turbo-preview"
+  },
+  "gpt-4.1": {
+    "openai": "gpt-4.1",
+    "openrouter": "openai/gpt-4.1"
+  },
+  "gpt-4.1-mini": {
+    "openai": "gpt-4.1-mini",
+    "openrouter": "openai/gpt-4.1-mini"
+  },
+  "gpt-4.1-nano": {
+    "openai": "gpt-4.1-nano",
+    "openrouter": "openai/gpt-4.1-nano"
+  },
+  "gpt-4o": {
+    "openai": "gpt-4o",
+    "openrouter": "openai/gpt-4o"
+  },
+  "gpt-4o-2024-05-13": {
+    "openai": "gpt-4o-2024-05-13",
+    "openrouter": "openai/gpt-4o-2024-05-13"
+  },
+  "gpt-4o-2024-08-06": {
+    "openai": "gpt-4o-2024-08-06",
+    "openrouter": "openai/gpt-4o-2024-08-06"
+  },
+  "gpt-4o-2024-11-20": {
+    "openai": "gpt-4o-2024-11-20",
+    "openrouter": "openai/gpt-4o-2024-11-20"
+  },
+  "gpt-4o-audio-preview": {
+    "openai": "gpt-4o-audio-preview",
+    "openrouter": "openai/gpt-4o-audio-preview"
+  },
+  "gpt-4o-mini": {
+    "openai": "gpt-4o-mini",
+    "openrouter": "openai/gpt-4o-mini"
+  },
+  "gpt-4o-mini-2024-07-18": {
+    "openai": "gpt-4o-mini-2024-07-18",
+    "openrouter": "openai/gpt-4o-mini-2024-07-18"
+  },
+  "gpt-4o-mini-search-preview": {
+    "openai": "gpt-4o-mini-search-preview",
+    "openrouter": "openai/gpt-4o-mini-search-preview"
+  },
+  "gpt-4o-search-preview": {
+    "openai": "gpt-4o-search-preview",
+    "openrouter": "openai/gpt-4o-search-preview"
+  },
+  "gpt-5": {
+    "openai": "gpt-5",
+    "openrouter": "openai/gpt-5"
+  },
+  "gpt-5-mini": {
+    "openai": "gpt-5-mini",
+    "openrouter": "openai/gpt-5-mini"
+  },
+  "gpt-5-nano": {
+    "openai": "gpt-5-nano",
+    "openrouter": "openai/gpt-5-nano"
+  },
+  "gpt-oss-120b": {
+    "openai": "gpt-oss-120b",
+    "openrouter": "openai/gpt-oss-120b"
+  },
+  "gpt-oss-20b": {
+    "openai": "gpt-oss-20b",
+    "openrouter": "openai/gpt-oss-20b"
+  },
+  "o1": {
+    "openai": "o1",
+    "openrouter": "openai/o1"
+  },
+  "o1-mini": {
+    "openai": "o1-mini",
+    "openrouter": "openai/o1-mini"
+  },
+  "o1-mini-2024-09-12": {
+    "openai": "o1-mini-2024-09-12",
+    "openrouter": "openai/o1-mini-2024-09-12"
+  },
+  "o1-pro": {
+    "openai": "o1-pro",
+    "openrouter": "openai/o1-pro"
+  },
+  "o3": {
+    "openai": "o3",
+    "openrouter": "openai/o3"
+  },
+  "o3-mini": {
+    "openai": "o3-mini",
+    "openrouter": "openai/o3-mini"
+  },
+  "o3-pro": {
+    "openai": "o3-pro",
+    "openrouter": "openai/o3-pro"
+  },
+  "o4-mini": {
+    "openai": "o4-mini",
+    "openrouter": "openai/o4-mini"
+  },
+  "text-embedding-004": {
+    "gemini": "text-embedding-004",
+    "vertexai": "text-embedding-004"
+  }
+}

data/lib/ruby_llm/aliases.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Manages model aliases for provider-specific versions
+  class Aliases
+    class << self
+      def resolve(model_id, provider = nil)
+        return model_id unless aliases[model_id]
+
+        if provider
+          aliases[model_id][provider.to_s] || model_id
+        else
+          aliases[model_id].values.first || model_id
+        end
+      end
+
+      def aliases
+        @aliases ||= load_aliases
+      end
+
+      def aliases_file
+        File.expand_path('aliases.json', __dir__)
+      end
+
+      def load_aliases
+        if File.exist?(aliases_file)
+          JSON.parse(File.read(aliases_file))
+        else
+          {}
+        end
+      end
+
+      def reload!
+        @aliases = load_aliases
+      end
+    end
+  end
+end

data/lib/ruby_llm/attachment.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # A class representing a file attachment.
+  class Attachment
+    attr_reader :source, :filename, :mime_type, :upload_file_id
+
+    def initialize(source, filename: nil)
+      @source = source
+      if url?
+        @source = URI source
+        @filename = filename || File.basename(@source.path).to_s
+      elsif uuid?
+        @upload_file_id = source
+      elsif path?
+        @source = Pathname.new source
+        @filename = filename || @source.basename.to_s
+      elsif active_storage?
+        @filename = filename || extract_filename_from_active_storage
+      else
+        @filename = filename
+      end
+
+      determine_mime_type if @upload_file_id.nil?
+    end
+
+    def url?
+      @source.is_a?(URI) || (@source.is_a?(String) && @source.match?(%r{^https?://}))
+    end
+
+    def path?
+      @source.is_a?(Pathname) || (@source.is_a?(String) && !url?)
+    end
+
+    def io_like?
+      @source.respond_to?(:read) && !path? && !active_storage?
+    end
+
+    def active_storage?
+      return false unless defined?(ActiveStorage)
+
+      @source.is_a?(ActiveStorage::Blob) ||
+        @source.is_a?(ActiveStorage::Attached::One) ||
+        @source.is_a?(ActiveStorage::Attached::Many)
+    end
+
+    def uuid?
+      @source.is_a?(String) && @source.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
+    end
+
+    def content
+      return @content if defined?(@content) && !@content.nil?
+
+      if url?
+        fetch_content
+      elsif path?
+        load_content_from_path
+      elsif active_storage?
+        load_content_from_active_storage
+      elsif io_like?
+        load_content_from_io
+      else
+        RubyLLM.logger.warn "Source is neither a URL, path, ActiveStorage, nor IO-like: #{@source.class}"
+        nil
+      end
+
+      @content
+    end
+
+    def encoded
+      Base64.strict_encode64(content)
+    end
+
+    def for_llm
+      case type
+      when :text
+        "<file name='#{filename}' mime_type='#{mime_type}'>#{content}</file>"
+      else
+        "data:#{mime_type};base64,#{encoded}"
+      end
+    end
+
+    def type
+      return :file_id unless @upload_file_id.nil?
+      return :image if image?
+      return :audio if audio?
+      return :pdf if pdf?
+      return :text if text?
+
+      :unknown
+    end
+
+    def image?
+      RubyLLM::MimeType.image? mime_type
+    end
+
+    def audio?
+      RubyLLM::MimeType.audio? mime_type
+    end
+
+    def format
+      case mime_type
+      when 'audio/mpeg'
+        'mp3'
+      when 'audio/wav', 'audio/wave', 'audio/x-wav'
+        'wav'
+      else
+        mime_type.split('/').last
+      end
+    end
+
+    def pdf?
+      RubyLLM::MimeType.pdf? mime_type
+    end
+
+    def text?
+      RubyLLM::MimeType.text? mime_type
+    end
+
+    def to_h
+      { type: type, source: @source }
+    end
+
+    private
+
+    def determine_mime_type
+      return @mime_type = active_storage_content_type if active_storage? && active_storage_content_type.present?
+
+      @mime_type = RubyLLM::MimeType.for(url? ? nil : @source, name: @filename)
+      @mime_type = RubyLLM::MimeType.for(content) if @mime_type == 'application/octet-stream'
+      @mime_type = 'audio/wav' if @mime_type == 'audio/x-wav' # Normalize WAV type
+    end
+
+    def fetch_content
+      response = Connection.basic.get @source.to_s
+      @content = response.body
+    end
+
+    def load_content_from_path
+      @content = File.read(@source)
+    end
+
+    def load_content_from_io
+      @source.rewind if @source.respond_to? :rewind
+      @content = @source.read
+    end
+
+    def load_content_from_active_storage
+      return unless defined?(ActiveStorage)
+
+      @content = case @source
+                 when ActiveStorage::Blob
+                   @source.download
+                 when ActiveStorage::Attached::One
+                   @source.blob&.download
+                 when ActiveStorage::Attached::Many
+                   # For multiple attachments, just take the first one
+                   # This maintains the single-attachment interface
+                   @source.blobs.first&.download
+                 end
+    end
+
+    def extract_filename_from_active_storage # rubocop:disable Metrics/PerceivedComplexity
+      return 'attachment' unless defined?(ActiveStorage)
+
+      case @source
+      when ActiveStorage::Blob
+        @source.filename.to_s
+      when ActiveStorage::Attached::One
+        @source.blob&.filename&.to_s || 'attachment'
+      when ActiveStorage::Attached::Many
+        @source.blobs.first&.filename&.to_s || 'attachment'
+      else
+        'attachment'
+      end
+    end
+
+    def active_storage_content_type
+      return unless defined?(ActiveStorage)
+
+      case @source
+      when ActiveStorage::Blob
+        @source.content_type
+      when ActiveStorage::Attached::One
+        @source.blob&.content_type
+      when ActiveStorage::Attached::Many
+        @source.blobs.first&.content_type
+      end
+    end
+  end
+end

data/lib/ruby_llm/chat.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Represents a conversation with an AI model
+  class Chat
+    include Enumerable
+
+    attr_reader :model, :messages, :tools, :params, :headers, :schema, :provider
+
+    def initialize(model: nil, provider: nil, assume_model_exists: false, context: nil)
+      if assume_model_exists && !provider
+        raise ArgumentError, 'Provider must be specified if assume_model_exists is true'
+      end
+
+      @context = context
+      @config = context&.config || RubyLLM.config
+      model_id = model || @config.default_model
+      with_model(model_id, provider: provider, assume_exists: assume_model_exists)
+      @temperature = nil
+      @messages = []
+      @tools = {}
+      @params = {}
+      @headers = {}
+      @schema = nil
+      @on = {
+        new_message: nil,
+        end_message: nil,
+        tool_call: nil,
+        tool_result: nil
+      }
+    end
+
+    def ask(message = nil, with: nil, &)
+      add_message role: :user, content: Content.new(message, with)
+      complete(&)
+    end
+
+    alias say ask
+
+    def with_instructions(instructions, replace: false)
+      @messages = @messages.reject { |msg| msg.role == :system } if replace
+
+      add_message role: :system, content: instructions
+      self
+    end
+
+    def with_tool(tool)
+      tool_instance = tool.is_a?(Class) ? tool.new : tool
+      @tools[tool_instance.name.to_sym] = tool_instance
+      self
+    end
+
+    def with_tools(*tools, replace: false)
+      @tools.clear if replace
+      tools.compact.each { |tool| with_tool tool }
+      self
+    end
+
+    def with_model(model_id, provider: nil, assume_exists: false)
+      @model, @provider = Models.resolve(model_id, provider:, assume_exists:, config: @config)
+      @connection = @provider.connection
+      self
+    end
+
+    def with_temperature(temperature)
+      @temperature = temperature
+      self
+    end
+
+    def with_context(context)
+      @context = context
+      @config = context.config
+      with_model(@model.id, provider: @provider.slug, assume_exists: true)
+      self
+    end
+
+    def with_params(**params)
+      @params = params
+      self
+    end
+
+    def with_headers(**headers)
+      @headers = headers
+      self
+    end
+
+    def with_schema(schema)
+      schema_instance = schema.is_a?(Class) ? schema.new : schema
+
+      # Accept both RubyLLM::Schema instances and plain JSON schemas
+      @schema = if schema_instance.respond_to?(:to_json_schema)
+                  schema_instance.to_json_schema[:schema]
+                else
+                  schema_instance
+                end
+
+      self
+    end
+
+    def on_new_message(&block)
+      @on[:new_message] = block
+      self
+    end
+
+    def on_end_message(&block)
+      @on[:end_message] = block
+      self
+    end
+
+    def on_tool_call(&block)
+      @on[:tool_call] = block
+      self
+    end
+
+    def on_tool_result(&block)
+      @on[:tool_result] = block
+      self
+    end
+
+    def each(&)
+      messages.each(&)
+    end
+
+    def complete(&) # rubocop:disable Metrics/PerceivedComplexity
+      response = @provider.complete(
+        messages,
+        tools: @tools,
+        temperature: @temperature,
+        model: @model,
+        params: @params,
+        headers: @headers,
+        schema: @schema,
+        &wrap_streaming_block(&)
+      )
+
+      @on[:new_message]&.call unless block_given?
+
+      if @schema && response.content.is_a?(String)
+        begin
+          response.content = JSON.parse(response.content)
+        rescue JSON::ParserError
+          # If parsing fails, keep content as string
+        end
+      end
+
+      add_message response
+      @on[:end_message]&.call(response)
+
+      if response.tool_call?
+        handle_tool_calls(response, &)
+      else
+        response
+      end
+    end
+
+    def add_message(message_or_attributes)
+      message = message_or_attributes.is_a?(Message) ? message_or_attributes : Message.new(message_or_attributes)
+      messages << message
+      message
+    end
+
+    def reset_messages!
+      @messages.clear
+    end
+
+    def instance_variables
+      super - %i[@connection @config]
+    end
+
+    private
+
+    def wrap_streaming_block(&block)
+      return nil unless block_given?
+
+      first_chunk_received = false
+
+      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
+
+    def handle_tool_calls(response, &) # rubocop:disable Metrics/PerceivedComplexity
+      halt_result = nil
+
+      response.tool_calls.each_value do |tool_call|
+        @on[:new_message]&.call
+        @on[:tool_call]&.call(tool_call)
+        result = execute_tool tool_call
+        @on[:tool_result]&.call(result)
+        content = result.is_a?(Content) ? result : result.to_s
+        message = add_message role: :tool, content:, tool_call_id: tool_call.id
+        @on[:end_message]&.call(message)
+
+        halt_result = result if result.is_a?(Tool::Halt)
+      end
+
+      halt_result || complete(&)
+    end
+
+    def execute_tool(tool_call)
+      tool = tools[tool_call.name.to_sym]
+      args = tool_call.arguments
+      tool.call(args)
+    end
+  end
+end