raif 1.0.0

data/app/models/raif/conversation_entry.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+class Raif::ConversationEntry < Raif::ApplicationRecord
+  include Raif::Concerns::InvokesModelTools
+  include Raif::Concerns::HasAvailableModelTools
+
+  belongs_to :raif_conversation, counter_cache: true, class_name: "Raif::Conversation"
+  belongs_to :creator, polymorphic: true
+
+  has_one :raif_user_tool_invocation,
+    class_name: "Raif::UserToolInvocation",
+    dependent: :destroy,
+    foreign_key: :raif_conversation_entry_id,
+    inverse_of: :raif_conversation_entry
+
+  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 :json_response_schema, to: :class
+
+  accepts_nested_attributes_for :raif_user_tool_invocation
+
+  boolean_timestamp :started_at
+  boolean_timestamp :completed_at
+  boolean_timestamp :failed_at
+
+  before_validation :add_user_tool_invocation_to_user_message, on: :create
+
+  normalizes :model_response_message, with: ->(value) { value&.strip }
+  normalizes :user_message, with: ->(value) { value&.strip }
+
+  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}
+
+      #{user_message}
+    MESSAGE
+  end
+
+  def generating_response?
+    started? && !completed? && !failed?
+  end
+
+  def process_entry!
+    self.raif_model_completion = raif_conversation.prompt_model_for_entry_response(entry: self)
+
+    if raif_model_completion.parsed_response.present? || raif_model_completion.response_tool_calls.present?
+      extract_message_and_invoke_tools!
+    else
+      logger.error "Error processing conversation entry ##{id}. No model response found."
+      failed!
+    end
+
+    self
+  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
+      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)
+        end
+      end
+
+      completed!
+    end
+  rescue StandardError => e
+    logger.error "Error processing conversation entry ##{id}. Error: #{e.message}"
+    logger.error e.backtrace.join("\n")
+    failed!
+
+    raise e
+  end
+
+end

data/app/models/raif/llm.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Raif
+  class Llm
+    include ActiveModel::Model
+
+    attr_accessor :key,
+      :api_name,
+      :default_temperature,
+      :default_max_completion_tokens,
+      :supports_native_tool_use,
+      :provider_settings
+
+    validates :key, presence: true
+    validates :api_name, presence: true
+
+    VALID_RESPONSE_FORMATS = [:text, :json, :html].freeze
+
+    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)
+      @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
+    end
+
+    def name
+      I18n.t("raif.model_names.#{key}")
+    end
+
+    def chat(message: nil, messages: nil, response_format: :text, available_model_tools: [], source: nil, system_prompt: nil, temperature: nil,
+      max_completion_tokens: nil)
+      unless response_format.is_a?(Symbol)
+        raise ArgumentError,
+          "Raif::Llm#chat - Invalid response format: #{response_format}. Must be a symbol (you passed #{response_format.class}) and be one of: #{VALID_RESPONSE_FORMATS.join(", ")}" # rubocop:disable Layout/LineLength
+      end
+
+      unless VALID_RESPONSE_FORMATS.include?(response_format)
+        raise ArgumentError, "Raif::Llm#chat - Invalid response format: #{response_format}. Must be one of: #{VALID_RESPONSE_FORMATS.join(", ")}"
+      end
+
+      unless message.present? || messages.present?
+        raise ArgumentError, "Raif::Llm#chat - You must provide either a message: or messages: argument"
+      end
+
+      if message.present? && messages.present?
+        raise ArgumentError, "Raif::Llm#chat - You must provide either a message: or messages: argument, not both"
+      end
+
+      unless Raif.config.llm_api_requests_enabled
+        Raif.logger.warn("LLM API requests are disabled. Skipping request to #{api_name}.")
+        return
+      end
+
+      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,
+        system_prompt: system_prompt,
+        response_format: response_format,
+        source: source,
+        llm_model_key: key.to_s,
+        model_api_name: api_name,
+        temperature: temperature,
+        max_completion_tokens: max_completion_tokens,
+        available_model_tools: available_model_tools
+      )
+
+      perform_model_completion!(model_completion)
+      model_completion
+    end
+
+    def perform_model_completion!(model_completion)
+      raise NotImplementedError, "Raif::Llm subclasses must implement #perform_model_completion!"
+    end
+
+    def self.valid_response_formats
+      VALID_RESPONSE_FORMATS
+    end
+
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+class Raif::Llms::Anthropic < Raif::Llm
+
+  def perform_model_completion!(model_completion)
+    params = build_api_parameters(model_completion)
+
+    response = connection.post("messages") do |req|
+      req.body = params.to_json
+    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
+
+    model_completion.raw_response = if model_completion.response_format_json?
+      extract_json_response(resp)
+    else
+      extract_text_response(resp)
+    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.save!
+
+    model_completion
+  end
+
+  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"
+    end
+  end
+
+protected
+
+  def build_api_parameters(model_completion)
+    params = {
+      model: model_completion.model_api_name,
+      messages: model_completion.messages,
+      temperature: (model_completion.temperature || default_temperature).to_f,
+      max_tokens: model_completion.max_completion_tokens || default_max_completion_tokens
+    }
+
+    params[:system] = model_completion.system_prompt if model_completion.system_prompt.present?
+
+    # Add tools to the request if needed
+    tools = []
+
+    # If we're looking for a JSON response, add a tool to the request that the model can use to provide a JSON response
+    if model_completion.response_format_json? && model_completion.json_response_schema.present?
+      tools << {
+        name: "json_response",
+        description: "Generate a structured JSON response based on the provided schema.",
+        input_schema: model_completion.json_response_schema
+      }
+    end
+
+    # If we support native tool use and have tools available, add them to the request
+    if supports_native_tool_use? && model_completion.available_model_tools.any?
+      model_completion.available_model_tools_map.each do |_tool_name, tool|
+        tools << {
+          name: tool.tool_name,
+          description: tool.tool_description,
+          input_schema: tool.tool_arguments_schema
+        }
+      end
+    end
+
+    params[:tools] = tools if tools.any?
+
+    params
+  end
+
+  def extract_text_response(resp)
+    resp&.dig(:content)&.first&.dig(:text)
+  end
+
+  def extract_json_response(resp)
+    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
+    end
+
+    if tool_response
+      JSON.generate(tool_response[:input])
+    else
+      extract_text_response(resp)
+    end
+  end
+
+  def extract_response_tool_calls(resp)
+    return if resp&.dig(:content).nil?
+
+    # Find any tool_use content blocks
+    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]
+      }
+    end
+  end
+
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+class Raif::Llms::BedrockClaude < Raif::Llm
+
+  def perform_model_completion!(model_completion)
+    if Raif.config.aws_bedrock_model_name_prefix.present?
+      model_completion.model_api_name = "#{Raif.config.aws_bedrock_model_name_prefix}.#{model_completion.model_api_name}"
+    end
+
+    params = build_api_parameters(model_completion)
+    resp = bedrock_client.converse(params)
+
+    model_completion.raw_response = if model_completion.response_format_json?
+      extract_json_response(resp)
+    else
+      extract_text_response(resp)
+    end
+
+    model_completion.completion_tokens = resp.usage.output_tokens
+    model_completion.prompt_tokens = resp.usage.input_tokens
+    model_completion.total_tokens = resp.usage.total_tokens
+    model_completion.save!
+
+    model_completion
+  end
+
+protected
+
+  def bedrock_client
+    @bedrock_client ||= Aws::BedrockRuntime::Client.new(region: Raif.config.aws_bedrock_region)
+  end
+
+  def format_messages(messages)
+    messages.map(&:symbolize_keys).map do |message|
+      {
+        role: message[:role],
+        content: [{ text: message[:content] }]
+      }
+    end
+  end
+
+  def build_api_parameters(model_completion)
+    params = {
+      model_id: model_completion.model_api_name,
+      inference_config: { max_tokens: model_completion.max_completion_tokens || 8192 },
+      messages: format_messages(model_completion.messages)
+    }
+
+    params[:system] = [{ text: model_completion.system_prompt }] if model_completion.system_prompt.present?
+
+    # Prepare tools configuration if needed
+    tools = []
+
+    # If we're looking for a JSON response, add a tool to the request that the model can use to provide a JSON response
+    if model_completion.response_format_json? && model_completion.json_response_schema.present?
+      tools << {
+        name: "json_response",
+        description: "Generate a structured JSON response based on the provided schema.",
+        input_schema: { json: model_completion.json_response_schema }
+      }
+    end
+
+    # If we support native tool use and have tools available, add them to the request
+    if supports_native_tool_use? && model_completion.available_model_tools.any?
+      model_completion.available_model_tools_map.each do |_tool_name, tool|
+        tools << {
+          name: tool.tool_name,
+          description: tool.tool_description,
+          input_schema: { json: tool.tool_arguments_schema }
+        }
+      end
+    end
+
+    # Add tool configuration if any tools are available
+    if tools.any?
+      params[:tool_config] = {
+        tools: tools.map { |tool| { tool_spec: tool } }
+      }
+    end
+
+    params
+  end
+
+  def extract_text_response(resp)
+    # Get the message from the response object
+    message = resp.output.message
+
+    # Find the first text content block
+    text_block = message.content&.find do |content|
+      content.respond_to?(:text) && content.text.present?
+    end
+
+    text_block&.text
+  end
+
+  def extract_json_response(resp)
+    # Get the message from the response object
+    message = resp.output.message
+
+    return extract_text_response(resp) if message.content.nil?
+
+    # Look for tool_use blocks in the content array
+    tool_response = message.content.find do |content|
+      content.respond_to?(:tool_use) && content.tool_use.present? && content.tool_use.name == "json_response"
+    end
+
+    if tool_response&.tool_use
+      JSON.generate(tool_response.tool_use.input)
+    else
+      extract_text_response(resp)
+    end
+  end
+
+  def extract_response_tool_calls(resp)
+    # Get the message from the response object
+    message = resp.output.message
+    return if message.content.nil?
+
+    # Find any tool_use blocks in the content array
+    tool_uses = message.content.select do |content|
+      content.respond_to?(:tool_use) && content.tool_use.present?
+    end
+
+    return if tool_uses.blank?
+
+    tool_uses.map do |content|
+      {
+        "name" => content.tool_use.name,
+        "arguments" => content.tool_use.input
+      }
+    end
+  end
+
+end

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

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+class Raif::Llms::OpenAi < Raif::Llm
+
+  def perform_model_completion!(model_completion)
+    model_completion.temperature ||= default_temperature
+    parameters = build_chat_parameters(model_completion)
+
+    response = connection.post("chat/completions") do |req|
+      req.body = parameters.to_json
+    end
+
+    resp = JSON.parse(response.body)
+
+    # Handle API errors
+    unless response.success?
+      error_message = resp["error"]&.dig("message") || "OpenAI API error: #{response.status}"
+      raise Raif::Errors::OpenAi::ApiError, error_message
+    end
+
+    model_completion.update!(
+      response_tool_calls: extract_response_tool_calls(resp),
+      raw_response: resp.dig("choices", 0, "message", "content"),
+      completion_tokens: resp["usage"]["completion_tokens"],
+      prompt_tokens: resp["usage"]["prompt_tokens"],
+      total_tokens: resp["usage"]["total_tokens"],
+      response_format_parameter: parameters.dig(:response_format, :type)
+    )
+
+    model_completion
+  end
+
+  def connection
+    @connection ||= Faraday.new(url: "https://api.openai.com/v1") do |f|
+      f.headers["Content-Type"] = "application/json"
+      f.headers["Authorization"] = "Bearer #{Raif.config.open_ai_api_key}"
+    end
+  end
+
+  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 extract_response_tool_calls(resp)
+    return if resp.dig("choices", 0, "message", "tool_calls").blank?
+
+    resp.dig("choices", 0, "message", "tool_calls").map do |tool_call|
+      {
+        "name" => tool_call["function"]["name"],
+        "arguments" => JSON.parse(tool_call["function"]["arguments"])
+      }
+    end
+  end
+
+  def build_chat_parameters(model_completion)
+    formatted_system_prompt = model_completion.system_prompt.to_s.strip
+
+    # If the response format is JSON, we need to include "as json" in the system prompt.
+    # OpenAI requires this and will throw an error if it's not included.
+    if model_completion.response_format_json?
+      # Ensure system prompt ends with a period if not empty
+      if formatted_system_prompt.present? && !formatted_system_prompt.end_with?(".", "?", "!")
+        formatted_system_prompt += "."
+      end
+      formatted_system_prompt += " Return your response as JSON."
+      formatted_system_prompt.strip!
+    end
+
+    messages = model_completion.messages
+    messages_with_system = if !formatted_system_prompt.empty?
+      [{ "role" => "system", "content" => formatted_system_prompt }] + messages
+    else
+      messages
+    end
+
+    parameters = {
+      model: api_name,
+      messages: messages_with_system,
+      temperature: model_completion.temperature.to_f
+    }
+
+    # If the LLM supports native tool use and there are available tools, add them to the parameters
+    if supports_native_tool_use? && model_completion.available_model_tools.any?
+      parameters[:tools] = model_completion.available_model_tools_map.map do |_tool_name, 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
+
+    # Add response format if needed
+    response_format = determine_response_format(model_completion)
+    parameters[:response_format] = response_format if response_format
+
+    parameters
+  end
+
+  def determine_response_format(model_completion)
+    # Only configure response format for JSON outputs
+    return unless model_completion.response_format_json?
+
+    if model_completion.json_response_schema.present? && supports_structured_outputs?
+      validate_json_schema!(model_completion.json_response_schema)
+
+      {
+        type: "json_schema",
+        json_schema: {
+          name: "json_response_schema",
+          strict: true,
+          schema: model_completion.json_response_schema
+        }
+      }
+    else
+      # Default JSON mode for OpenAI models that don't support structured outputs or no schema is provided
+      { type: "json_object" }
+    end
+  end
+
+  def supports_structured_outputs?
+    # Not all OpenAI models support structured outputs:
+    # https://platform.openai.com/docs/guides/structured-outputs?api-mode=chat#supported-models
+    provider_settings[:supports_structured_outputs]
+  end
+
+  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