raif 1.0.0 → 1.1.0

data/app/models/raif/concerns/llms/anthropic/message_formatting.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::Anthropic::MessageFormatting
+  extend ActiveSupport::Concern
+
+  def format_model_image_input_message(image_input)
+    if image_input.source_type == :url
+      {
+        "type" => "image",
+        "source" => {
+          "type" => "url",
+          "url" => image_input.url
+        }
+      }
+    elsif image_input.source_type == :file_content
+      {
+        "type" => "image",
+        "source" => {
+          "type" => "base64",
+          "media_type" => image_input.content_type,
+          "data" => image_input.base64_data
+        }
+      }
+    else
+      raise Raif::Errors::InvalidModelImageInputError, "Invalid model image input source type: #{image_input.source_type}"
+    end
+  end
+
+  def format_model_file_input_message(file_input)
+    if file_input.source_type == :url
+      {
+        "type" => "document",
+        "source" => {
+          "type" => "url",
+          "url" => file_input.url
+        }
+      }
+    elsif file_input.source_type == :file_content
+      {
+        "type" => "document",
+        "source" => {
+          "type" => "base64",
+          "media_type" => file_input.content_type,
+          "data" => file_input.base64_data
+        }
+      }
+    else
+      raise Raif::Errors::InvalidModelFileInputError, "Invalid model file input source type: #{file_input.source_type}"
+    end
+  end
+end

data/app/models/raif/concerns/llms/bedrock_claude/message_formatting.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::BedrockClaude::MessageFormatting
+  extend ActiveSupport::Concern
+
+  def format_string_message(content)
+    { "text" => content }
+  end
+
+  def format_model_image_input_message(image_input)
+    if image_input.source_type == :url
+      raise Raif::Errors::UnsupportedFeatureError, "AWS Bedrock does not support providing an image by URL"
+    elsif image_input.source_type == :file_content
+      # The AWS Bedrock SDK requires data sent as bytes (and doesn't support base64 like everyone else)
+      # The ModelCompletion stores the messages as JSON though, so it can't be raw bytes (it will throw an encoding error).
+      # We store the image data as base64 and then it will get converted to bytes in Raif::Llms::BedrockClaude#perform_model_completion!
+      # before sending to AWS.
+      {
+        "image" => {
+          "format" => format_for_content_type(image_input.content_type),
+          "source" => {
+            "tmp_base64_data" => image_input.base64_data
+          }
+        }
+      }
+    else
+      raise Raif::Errors::InvalidModelImageInputError, "Invalid model image input source type: #{image_input.source_type}"
+    end
+  end
+
+  def format_model_file_input_message(file_input)
+    if file_input.source_type == :url
+      raise Raif::Errors::UnsupportedFeatureError, "AWS Bedrock does not support providing a file by URL"
+    elsif file_input.source_type == :file_content
+      # The AWS Bedrock SDK requires data sent as bytes (and doesn't support base64 like everyone else)
+      # The ModelCompletion stores the messages as JSON though, so it can't be raw bytes (it will throw an encoding error).
+      # We store the image data as base64 and then it will get converted to bytes in Raif::Llms::BedrockClaude#perform_model_completion!
+      # before sending to AWS.
+      {
+        "document" => {
+          "format" => format_for_content_type(file_input.content_type),
+          "name" => File.basename(file_input.filename, File.extname(file_input.filename)), # AWS requires a filename and it cannot include dots from the extension # rubocop:disable Layout/LineLength
+          "source" => {
+            "tmp_base64_data" => file_input.base64_data
+          }
+        }
+      }
+    else
+      raise Raif::Errors::InvalidModelFileInputError, "Invalid model file input source type: #{file_input.source_type}"
+    end
+  end
+
+  def format_for_content_type(content_type)
+    {
+      "image/png" => "png",
+      "image/jpeg" => "jpeg",
+      "image/gif" => "gif",
+      "image/webp" => "webp",
+      "application/pdf" => "pdf",
+      "text/csv" => "csv",
+      "application/msword" => "doc",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document" => "docx",
+      "application/vnd.ms-excel" => "xls",
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" => "xlsx",
+      "text/html" => "html",
+      "text/plain" => "txt",
+      "text/markdown" => "md"
+    }[content_type]
+  end
+end

data/app/models/raif/concerns/llms/message_formatting.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::MessageFormatting
+  extend ActiveSupport::Concern
+
+  def format_messages(messages)
+    messages.map do |message|
+      {
+        "role" => message["role"] || message[:role],
+        "content" => format_message_content(message["content"] || message[:content])
+      }
+    end
+  end
+
+  # Content could be a string or an array.
+  # If it's an array, it could contain Raif::ModelImageInput or Raif::ModelFileInput objects,
+  # which need to be formatted according to each model provider's API.
+  def format_message_content(content)
+    raise ArgumentError,
+      "Message content must be an array or a string. Content was: #{content.inspect}" unless content.is_a?(Array) || content.is_a?(String)
+
+    return [format_string_message(content)] if content.is_a?(String)
+
+    content.map do |item|
+      if item.is_a?(Raif::ModelImageInput)
+        format_model_image_input_message(item)
+      elsif item.is_a?(Raif::ModelFileInput)
+        format_model_file_input_message(item)
+      elsif item.is_a?(String)
+        format_string_message(item)
+      else
+        item
+      end
+    end
+  end
+
+  def format_string_message(content)
+    { "type" => "text", "text" => content }
+  end
+
+end

data/app/models/raif/concerns/llms/open_ai/message_formatting.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::OpenAi::MessageFormatting
+  extend ActiveSupport::Concern
+
+  def format_model_image_input_message(image_input)
+    if image_input.source_type == :url
+      {
+        "type" => "image_url",
+        "image_url" => { "url" => image_input.url }
+      }
+    elsif image_input.source_type == :file_content
+      {
+        "type" => "image_url",
+        "image_url" => {
+          "url" => "data:#{image_input.content_type};base64,#{image_input.base64_data}"
+        }
+      }
+    else
+      raise Raif::Errors::InvalidModelImageInputError, "Invalid model image input source type: #{image_input.source_type}"
+    end
+  end
+
+  def format_model_file_input_message(file_input)
+    if file_input.source_type == :url
+      raise Raif::Errors::UnsupportedFeatureError, "#{self.class.name} does not support providing a file by URL"
+    elsif file_input.source_type == :file_content
+      file_params = {
+        "filename" => file_input.filename,
+        "file_data" => "data:#{file_input.content_type};base64,#{file_input.base64_data}"
+      }.compact
+
+      {
+        "type" => "file",
+        "file" => file_params
+      }
+    else
+      raise Raif::Errors::InvalidModelFileInputError, "Invalid model image input source type: #{file_input.source_type}"
+    end
+  end
+end

data/app/models/raif/conversation.rb

@@ -4,6 +4,7 @@ class Raif::Conversation < Raif::ApplicationRecord
   include Raif::Concerns::HasLlm
   include Raif::Concerns::HasRequestedLanguage
   include Raif::Concerns::HasAvailableModelTools
+  include Raif::Concerns::LlmResponseParsing
 
   belongs_to :creator, polymorphic: true
 
@@ -25,7 +26,8 @@ class Raif::Conversation < Raif::ApplicationRecord
   end
 
   def system_prompt_intro
-    Raif.config.conversation_system_prompt_intro
+    sp = Raif.config.conversation_system_prompt_intro
+    sp.respond_to?(:call) ? sp.call(self) : sp
   end
 
   # i18n-tasks-use t('raif.conversation.initial_chat_message')
@@ -37,17 +39,23 @@ class Raif::Conversation < Raif::ApplicationRecord
     llm.chat(
       messages: llm_messages,
       source: entry,
-      response_format: :text,
+      response_format: response_format.to_sym,
       system_prompt: system_prompt,
       available_model_tools: available_model_tools
     )
   end
 
+  def process_model_response_message(message:, entry:)
+    # no-op by default.
+    # Override in subclasses for type-specific processing of the model response message
+    message
+  end
+
   def llm_messages
     messages = []
 
     entries.oldest_first.includes(:raif_model_tool_invocations).each do |entry|
-      messages << { "role" => "user", "content" => entry.user_message }
+      messages << { "role" => "user", "content" => entry.user_message } unless entry.user_message.blank?
       next unless entry.completed?
 
       messages << { "role" => "assistant", "content" => entry.model_response_message } unless entry.model_response_message.blank?

data/app/models/raif/conversation_entry.rb

@@ -33,11 +33,12 @@ class Raif::ConversationEntry < Raif::ApplicationRecord
   def add_user_tool_invocation_to_user_message
     return unless raif_user_tool_invocation.present?
 
-    self.user_message = <<~MESSAGE.strip
-      #{raif_user_tool_invocation.as_user_message}
+    separator = response_format == "html" ? "<br>" : "\n\n"
+    self.user_message = [user_message, raif_user_tool_invocation.as_user_message].join(separator)
+  end
 
-      #{user_message}
-    MESSAGE
+  def response_format
+    raif_model_completion&.response_format.presence || raif_conversation.response_format
   end
 
   def generating_response?
@@ -49,6 +50,7 @@ class Raif::ConversationEntry < Raif::ApplicationRecord
 
     if raif_model_completion.parsed_response.present? || raif_model_completion.response_tool_calls.present?
       extract_message_and_invoke_tools!
+      create_entry_for_observation! if triggers_observation_to_model?
     else
       logger.error "Error processing conversation entry ##{id}. No model response found."
       failed!
@@ -57,18 +59,32 @@ class Raif::ConversationEntry < Raif::ApplicationRecord
     self
   end
 
+  def triggers_observation_to_model?
+    return false unless completed?
+
+    raif_model_tool_invocations.any?(&:triggers_observation_to_model?)
+  end
+
+  def create_entry_for_observation!
+    follow_up_entry = raif_conversation.entries.create!(creator: creator)
+    Raif::ConversationEntryJob.perform_later(conversation_entry: follow_up_entry)
+    follow_up_entry.broadcast_append_to raif_conversation, target: dom_id(raif_conversation, :entries)
+  end
+
 private
 
   def extract_message_and_invoke_tools!
     transaction do
       self.raw_response = raif_model_completion.raw_response
-      self.model_response_message = raif_model_completion.parsed_response
+      self.model_response_message = raif_conversation.process_model_response_message(message: raif_model_completion.parsed_response, entry: self)
       save!
 
       if raif_model_completion.response_tool_calls.present?
         raif_model_completion.response_tool_calls.each do |tool_call|
           tool_klass = available_model_tools_map[tool_call["name"]]
-          tool_klass&.invoke_tool(tool_arguments: tool_call["arguments"], source: self)
+          next if tool_klass.nil?
+
+          tool_klass.invoke_tool(tool_arguments: tool_call["arguments"], source: self)
         end
       end
 

data/app/models/raif/embedding_model.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Raif::EmbeddingModel
+  include ActiveModel::Model
+
+  attr_accessor :key,
+    :api_name,
+    :input_token_cost,
+    :default_output_vector_size
+
+  validates :default_output_vector_size, presence: true, numericality: { only_integer: true, greater_than: 0 }
+  validates :api_name, presence: true
+  validates :key, presence: true
+
+  def name
+    I18n.t("raif.embedding_model_names.#{key}")
+  end
+
+  def generate_embedding!(input, dimensions: nil)
+    raise NotImplementedError, "#{self.class.name} must implement #generate_embedding!"
+  end
+end

data/app/models/raif/embedding_models/bedrock_titan.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Raif::EmbeddingModels::BedrockTitan < Raif::EmbeddingModel
+
+  def generate_embedding!(input, dimensions: nil)
+    unless input.is_a?(String)
+      raise ArgumentError, "Raif::EmbeddingModels::BedrockTitan#generate_embedding! input must be a string"
+    end
+
+    params = build_request_parameters(input, dimensions:)
+    response = bedrock_client.invoke_model(params)
+
+    response_body = JSON.parse(response.body.read)
+    response_body["embedding"]
+  rescue Aws::BedrockRuntime::Errors::ServiceError => e
+    raise "Bedrock API error: #{e.message}"
+  end
+
+private
+
+  def build_request_parameters(input, dimensions: nil)
+    body_params = { inputText: input }
+    body_params[:dimensions] = dimensions if dimensions.present?
+
+    {
+      model_id: api_name,
+      body: body_params.to_json
+    }
+  end
+
+  def bedrock_client
+    @bedrock_client ||= Aws::BedrockRuntime::Client.new(region: Raif.config.aws_bedrock_region)
+  end
+end

data/app/models/raif/embedding_models/open_ai.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Raif::EmbeddingModels::OpenAi < Raif::EmbeddingModel
+  def generate_embedding!(input, dimensions: nil)
+    unless input.is_a?(String) || input.is_a?(Array)
+      raise ArgumentError, "Raif::EmbeddingModels::OpenAi#generate_embedding! input must be a string or an array of strings"
+    end
+
+    response = connection.post("embeddings") do |req|
+      req.body = build_request_parameters(input, dimensions:)
+    end
+
+    if input.is_a?(String)
+      response.body["data"][0]["embedding"]
+    else
+      response.body["data"].map{|v| v["embedding"] }
+    end
+  end
+
+private
+
+  def build_request_parameters(input, dimensions: nil)
+    params = {
+      model: api_name,
+      input: input
+    }
+
+    params[:dimensions] = dimensions if dimensions.present?
+    params
+  end
+
+  def connection
+    @connection ||= Faraday.new(url: "https://api.openai.com/v1") do |f|
+      f.headers["Authorization"] = "Bearer #{Raif.config.open_ai_api_key}"
+      f.request :json
+      f.response :json
+      f.response :raise_error
+    end
+  end
+end

data/app/models/raif/llm.rb

@@ -3,13 +3,16 @@
 module Raif
   class Llm
     include ActiveModel::Model
+    include Raif::Concerns::Llms::MessageFormatting
 
     attr_accessor :key,
       :api_name,
       :default_temperature,
       :default_max_completion_tokens,
       :supports_native_tool_use,
-      :provider_settings
+      :provider_settings,
+      :input_token_cost,
+      :output_token_cost
 
     validates :key, presence: true
     validates :api_name, presence: true
@@ -18,13 +21,16 @@ module Raif
 
     alias_method :supports_native_tool_use?, :supports_native_tool_use
 
-    def initialize(key:, api_name:, model_provider_settings: {}, supports_native_tool_use: true, temperature: nil, max_completion_tokens: nil)
+    def initialize(key:, api_name:, model_provider_settings: {}, supports_native_tool_use: true, temperature: nil, max_completion_tokens: nil,
+      input_token_cost: nil, output_token_cost: nil)
       @key = key
       @api_name = api_name
       @provider_settings = model_provider_settings
       @supports_native_tool_use = supports_native_tool_use
       @default_temperature = temperature || 0.7
       @default_max_completion_tokens = max_completion_tokens
+      @input_token_cost = input_token_cost
+      @output_token_cost = output_token_cost
     end
 
     def name
@@ -55,13 +61,13 @@ module Raif
         return
       end
 
-      messages = [{ role: "user", content: message }] if message.present?
+      messages = [{ "role" => "user", "content" => message }] if message.present?
 
       temperature ||= default_temperature
       max_completion_tokens ||= default_max_completion_tokens
 
       model_completion = Raif::ModelCompletion.new(
-        messages: messages,
+        messages: format_messages(messages),
         system_prompt: system_prompt,
         response_format: response_format,
         source: source,
@@ -72,17 +78,44 @@ module Raif
         available_model_tools: available_model_tools
       )
 
-      perform_model_completion!(model_completion)
+      retry_with_backoff(model_completion) do
+        perform_model_completion!(model_completion)
+      end
+
       model_completion
     end
 
     def perform_model_completion!(model_completion)
-      raise NotImplementedError, "Raif::Llm subclasses must implement #perform_model_completion!"
+      raise NotImplementedError, "#{self.class.name} must implement #perform_model_completion!"
     end
 
     def self.valid_response_formats
       VALID_RESPONSE_FORMATS
     end
 
+  private
+
+    def retry_with_backoff(model_completion)
+      retries = 0
+      max_retries = Raif.config.llm_request_max_retries
+      base_delay = 3
+      max_delay = 30
+
+      begin
+        yield
+      rescue *Raif.config.llm_request_retriable_exceptions => e
+        retries += 1
+        if retries <= max_retries
+          delay = [base_delay * (2**(retries - 1)), max_delay].min
+          Raif.logger.warn("Retrying LLM API request after error: #{e.message}. Attempt #{retries}/#{max_retries}. Waiting #{delay} seconds...")
+          model_completion.increment!(:retry_count)
+          sleep delay
+          retry
+        else
+          Raif.logger.error("LLM API request failed after #{max_retries} retries. Last error: #{e.message}")
+          raise
+        end
+      end
+    end
   end
 end

data/app/models/raif/llms/anthropic.rb

@@ -1,31 +1,25 @@
 # frozen_string_literal: true
 
 class Raif::Llms::Anthropic < Raif::Llm
+  include Raif::Concerns::Llms::Anthropic::MessageFormatting
 
   def perform_model_completion!(model_completion)
-    params = build_api_parameters(model_completion)
-
+    params = build_request_parameters(model_completion)
     response = connection.post("messages") do |req|
-      req.body = params.to_json
+      req.body = params
     end
 
-    resp = JSON.parse(response.body, symbolize_names: true)
-
-    # Handle API errors
-    unless response.success?
-      error_message = resp[:error]&.dig(:message) || "Anthropic API error: #{response.status}"
-      raise Raif::Errors::Anthropic::ApiError, error_message
-    end
+    response_json = response.body
 
     model_completion.raw_response = if model_completion.response_format_json?
-      extract_json_response(resp)
+      extract_json_response(response_json)
     else
-      extract_text_response(resp)
+      extract_text_response(response_json)
     end
 
-    model_completion.response_tool_calls = extract_response_tool_calls(resp)
-    model_completion.completion_tokens = resp&.dig(:usage, :output_tokens)
-    model_completion.prompt_tokens = resp&.dig(:usage, :input_tokens)
+    model_completion.response_tool_calls = extract_response_tool_calls(response_json)
+    model_completion.completion_tokens = response_json&.dig("usage", "output_tokens")
+    model_completion.prompt_tokens = response_json&.dig("usage", "input_tokens")
     model_completion.save!
 
     model_completion
@@ -33,15 +27,17 @@ class Raif::Llms::Anthropic < Raif::Llm
 
   def connection
     @connection ||= Faraday.new(url: "https://api.anthropic.com/v1") do |f|
-      f.headers["Content-Type"] = "application/json"
       f.headers["x-api-key"] = Raif.config.anthropic_api_key
       f.headers["anthropic-version"] = "2023-06-01"
+      f.request :json
+      f.response :json
+      f.response :raise_error
     end
   end
 
 protected
 
-  def build_api_parameters(model_completion)
+  def build_request_parameters(model_completion)
     params = {
       model: model_completion.model_api_name,
       messages: model_completion.messages,
@@ -80,39 +76,38 @@ protected
   end
 
   def extract_text_response(resp)
-    resp&.dig(:content)&.first&.dig(:text)
+    resp&.dig("content")&.first&.dig("text")
   end
 
   def extract_json_response(resp)
-    return extract_text_response(resp) if resp&.dig(:content).nil?
+    return extract_text_response(resp) if resp&.dig("content").nil?
 
     # Look for tool_use blocks in the content array
-    tool_name = "json_response"
-    tool_response = resp&.dig(:content)&.find do |content|
-      content[:type] == "tool_use" && content[:name] == tool_name
+    tool_response = resp&.dig("content")&.find do |content|
+      content["type"] == "tool_use" && content["name"] == "json_response"
     end
 
     if tool_response
-      JSON.generate(tool_response[:input])
+      JSON.generate(tool_response["input"])
     else
       extract_text_response(resp)
     end
   end
 
   def extract_response_tool_calls(resp)
-    return if resp&.dig(:content).nil?
+    return if resp&.dig("content").nil?
 
     # Find any tool_use content blocks
-    tool_uses = resp&.dig(:content)&.select do |content|
-      content[:type] == "tool_use"
+    tool_uses = resp&.dig("content")&.select do |content|
+      content["type"] == "tool_use"
     end
 
     return if tool_uses.blank?
 
     tool_uses.map do |tool_use|
       {
-        "name" => tool_use[:name],
-        "arguments" => tool_use[:input]
+        "name" => tool_use["name"],
+        "arguments" => tool_use["input"]
       }
     end
   end