raif 1.0.0 → 1.2.0

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::OpenAi::JsonSchemaValidation
+  extend ActiveSupport::Concern
+
+  def validate_json_schema!(schema)
+    return if schema.blank?
+
+    errors = []
+
+    # Check if schema is present
+    if schema.blank?
+      errors << "JSON schema must include a 'schema' property"
+    else
+      # Check root object type
+      if schema[:type] != "object" && !schema.key?(:properties)
+        errors << "Root schema must be of type 'object' with 'properties'"
+      end
+
+      # Check all objects in the schema recursively
+      validate_object_properties(schema, errors)
+
+      # Check properties count (max 100 total)
+      validate_properties_count(schema, errors)
+
+      # Check nesting depth (max 5 levels)
+      validate_nesting_depth(schema, errors)
+
+      # Check for unsupported anyOf at root level
+      if schema[:anyOf].present? && schema[:properties].blank?
+        errors << "Root objects cannot be of type 'anyOf'"
+      end
+    end
+
+    # Raise error if any validation issues found
+    if errors.any?
+      error_message = "Invalid JSON schema for OpenAI structured outputs: #{errors.join("; ")}\nSchema was: #{schema.inspect}"
+      raise Raif::Errors::OpenAi::JsonSchemaError, error_message
+    else
+      true
+    end
+  end
+
+private
+
+  def validate_object_properties(schema, errors)
+    return unless schema.is_a?(Hash)
+
+    # Check if the current schema is an object and validate additionalProperties and required fields
+    if schema[:type] == "object"
+      if schema[:additionalProperties] != false
+        errors << "All objects must have 'additionalProperties' set to false"
+      end
+
+      # Check that all properties are required
+      if schema[:properties].is_a?(Hash) && schema[:properties].any?
+        property_keys = schema[:properties].keys
+        required_fields = schema[:required] || []
+
+        if required_fields.sort != property_keys.map(&:to_s).sort
+          errors << "All object properties must be listed in the 'required' array"
+        end
+      end
+    end
+
+    # Check if the current schema is an object and validate additionalProperties
+    if schema[:type] == "object"
+      if schema[:additionalProperties] != false
+        errors << "All objects must have 'additionalProperties' set to false"
+      end
+
+      # Check properties of the object recursively
+      if schema[:properties].is_a?(Hash)
+        schema[:properties].each_value do |property|
+          validate_object_properties(property, errors)
+        end
+      end
+    end
+
+    # Check array items
+    if schema[:type] == "array" && schema[:items].is_a?(Hash)
+      validate_object_properties(schema[:items], errors)
+    end
+
+    # Check anyOf
+    if schema[:anyOf].is_a?(Array)
+      schema[:anyOf].each do |option|
+        validate_object_properties(option, errors)
+      end
+    end
+  end
+
+  def validate_properties_count(schema, errors, count = 0)
+    return count unless schema.is_a?(Hash)
+
+    if schema[:properties].is_a?(Hash)
+      count += schema[:properties].size
+
+      if count > 100
+        errors << "Schema exceeds maximum of 100 total object properties"
+        return count
+      end
+
+      # Check nested properties
+      schema[:properties].each_value do |property|
+        count = validate_properties_count(property, errors, count)
+      end
+    end
+
+    # Check array items
+    if schema[:type] == "array" && schema[:items].is_a?(Hash)
+      count = validate_properties_count(schema[:items], errors, count)
+    end
+
+    count
+  end
+
+  def validate_nesting_depth(schema, errors, depth = 1)
+    return unless schema.is_a?(Hash)
+
+    if depth > 5
+      errors << "Schema exceeds maximum nesting depth of 5 levels"
+      return
+    end
+
+    if schema[:properties].is_a?(Hash)
+      schema[:properties].each_value do |property|
+        validate_nesting_depth(property, errors, depth + 1)
+      end
+    end
+
+    # Check array items
+    if schema[:type] == "array" && schema[:items].is_a?(Hash)
+      validate_nesting_depth(schema[:items], errors, depth + 1)
+    end
+  end
+
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::OpenAiCompletions::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/concerns/llms/open_ai_completions/tool_formatting.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::OpenAiCompletions::ToolFormatting
+  extend ActiveSupport::Concern
+
+  def build_tools_parameter(model_completion)
+    model_completion.available_model_tools_map.map do |_tool_name, tool|
+      if tool.provider_managed?
+        raise Raif::Errors::UnsupportedFeatureError,
+          "Raif doesn't yet support provider-managed tools for the OpenAI Completions API. Consider using the OpenAI Responses API instead."
+      else
+        # It's a developer-managed tool
+        validate_json_schema!(tool.tool_arguments_schema)
+
+        {
+          type: "function",
+          function: {
+            name: tool.tool_name,
+            description: tool.tool_description,
+            parameters: tool.tool_arguments_schema
+          }
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::OpenAiResponses::MessageFormatting
+  extend ActiveSupport::Concern
+
+  def format_string_message(content, role: nil)
+    if role == "assistant"
+      { "type" => "output_text", "text" => content }
+    else
+      { "type" => "input_text", "text" => content }
+    end
+  end
+
+  def format_model_image_input_message(image_input)
+    if image_input.source_type == :url
+      {
+        "type" => "input_image",
+        "image_url" => image_input.url
+      }
+    elsif image_input.source_type == :file_content
+      {
+        "type" => "input_image",
+        "image_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
+      {
+        "type" => "input_file",
+        "filename" => file_input.filename,
+        "file_data" => "data:#{file_input.content_type};base64,#{file_input.base64_data}"
+      }
+    else
+      raise Raif::Errors::InvalidModelFileInputError, "Invalid model image input source type: #{file_input.source_type}"
+    end
+  end
+end

data/app/models/raif/concerns/llms/open_ai_responses/tool_formatting.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::OpenAiResponses::ToolFormatting
+  extend ActiveSupport::Concern
+
+  def build_tools_parameter(model_completion)
+    model_completion.available_model_tools_map.map do |_tool_name, tool|
+      if tool.provider_managed?
+        format_provider_managed_tool(tool)
+      else
+        # It's a developer-managed tool
+        validate_json_schema!(tool.tool_arguments_schema)
+
+        {
+          type: "function",
+          name: tool.tool_name,
+          description: tool.tool_description,
+          parameters: tool.tool_arguments_schema
+        }
+      end
+    end
+  end
+
+  def format_provider_managed_tool(tool)
+    validate_provider_managed_tool_support!(tool)
+
+    case tool.name
+    when "Raif::ModelTools::ProviderManaged::WebSearch"
+      { type: "web_search_preview" }
+    when "Raif::ModelTools::ProviderManaged::CodeExecution"
+      {
+        type: "code_interpreter",
+        container: { "type": "auto" }
+      }
+    when "Raif::ModelTools::ProviderManaged::ImageGeneration"
+      { type: "image_generation" }
+    else
+      raise Raif::Errors::UnsupportedFeatureError,
+        "Invalid provider-managed tool: #{tool.name} for #{key}"
+    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
 
@@ -15,17 +16,17 @@ class Raif::Conversation < Raif::ApplicationRecord
   after_initialize -> { self.available_user_tools ||= [] }
 
   before_validation ->{ self.type ||= "Raif::Conversation" }, on: :create
-  before_validation -> { self.system_prompt ||= build_system_prompt }, on: :create
 
   def build_system_prompt
-    <<~PROMPT
+    <<~PROMPT.strip
       #{system_prompt_intro}
       #{system_prompt_language_preference}
     PROMPT
   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')
@@ -33,21 +34,41 @@ class Raif::Conversation < Raif::ApplicationRecord
     I18n.t("#{self.class.name.underscore.gsub("/", ".")}.initial_chat_message")
   end
 
-  def prompt_model_for_entry_response(entry:)
+  def prompt_model_for_entry_response(entry:, &block)
+    update(system_prompt: build_system_prompt)
+
     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
+      available_model_tools: available_model_tools,
+      &block
     )
+  rescue StandardError => e
+    Rails.logger.error("Error processing conversation entry ##{entry.id}. #{e.message}")
+    entry.failed!
+
+    if defined?(Airbrake)
+      notice = Airbrake.build_notice(e)
+      notice[:context][:component] = "raif_conversation"
+      notice[:context][:action] = "prompt_model_for_entry_response"
+
+      Airbrake.notify(notice)
+    end
+  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

@@ -16,7 +16,7 @@ class Raif::ConversationEntry < Raif::ApplicationRecord
   has_one :raif_model_completion, as: :source, dependent: :destroy, class_name: "Raif::ModelCompletion"
 
   delegate :available_model_tools, to: :raif_conversation
-  delegate :system_prompt, :llm_model_key, to: :raif_model_completion, allow_nil: true
+  delegate :system_prompt, :llm_model_key, :citations, to: :raif_model_completion, allow_nil: true
   delegate :json_response_schema, to: :class
 
   accepts_nested_attributes_for :raif_user_tool_invocation
@@ -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?
@@ -45,10 +46,27 @@ class Raif::ConversationEntry < Raif::ApplicationRecord
   end
 
   def process_entry!
-    self.raif_model_completion = raif_conversation.prompt_model_for_entry_response(entry: self)
+    self.model_response_message = ""
+
+    self.raif_model_completion = raif_conversation.prompt_model_for_entry_response(entry: self) do |model_completion, _delta, _sse_event|
+      self.raw_response = model_completion.raw_response
+      self.model_response_message = raif_conversation.process_model_response_message(
+        message: model_completion.parsed_response(force_reparse: true),
+        entry: self
+      )
+
+      update_columns(
+        model_response_message: model_response_message,
+        raw_response: raw_response,
+        updated_at: Time.current
+      )
+
+      broadcast_replace_to raif_conversation
+    end
 
     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 +75,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.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Raif::EmbeddingModels::Bedrock < Raif::EmbeddingModel
+
+  def generate_embedding!(input, dimensions: nil)
+    unless input.is_a?(String)
+      raise ArgumentError, "Raif::EmbeddingModels::Bedrock#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