raif 1.0.0 → 1.2.0

data/app/controllers/raif/admin/stats/tasks_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Raif
+  module Admin
+    module Stats
+      class TasksController < Raif::Admin::ApplicationController
+        def index
+          @selected_period = params[:period] || "day"
+          @time_range = get_time_range(@selected_period)
+
+          @task_count = Raif::Task.where(created_at: @time_range).count
+
+          # Get task counts by type
+          @task_counts_by_type = Raif::Task.where(created_at: @time_range).group(:type).count
+
+          # Get costs by task type
+          @task_costs_by_type = Raif::Task.joins(:raif_model_completion)
+            .where(created_at: @time_range)
+            .group(:type)
+            .sum("raif_model_completions.total_cost")
+        end
+      end
+    end
+  end
+end

data/app/controllers/raif/admin/stats_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Raif
+  module Admin
+    class StatsController < Raif::Admin::ApplicationController
+      def index
+        @selected_period = params[:period] || "day"
+        @time_range = get_time_range(@selected_period)
+
+        @model_completion_count = Raif::ModelCompletion.where(created_at: @time_range).count
+        @model_completion_total_cost = Raif::ModelCompletion.where(created_at: @time_range).sum(:total_cost)
+        @task_count = Raif::Task.where(created_at: @time_range).count
+        @conversation_count = Raif::Conversation.where(created_at: @time_range).count
+        @conversation_entry_count = Raif::ConversationEntry.where(created_at: @time_range).count
+        @agent_count = Raif::Agent.where(created_at: @time_range).count
+      end
+    end
+  end
+end

data/app/controllers/raif/admin/tasks_controller.rb

@@ -7,10 +7,26 @@ module Raif
 
       def index
         @task_types = Raif::Task.distinct.pluck(:type)
-        @selected_types = params[:task_types] || []
+        @selected_type = params[:task_types].present? ? params[:task_types] : "all"
+
+        @task_statuses = [:all, :completed, :failed, :in_progress, :pending]
+        @selected_statuses = params[:task_statuses].present? ? params[:task_statuses].to_sym : :all
 
         tasks = Raif::Task.order(created_at: :desc)
-        tasks = tasks.where(type: @selected_types) if @selected_types.present?
+        tasks = tasks.where(type: @selected_type) if @selected_type.present? && @selected_type != "all"
+
+        if @selected_statuses.present? && @selected_statuses != :all
+          case @selected_statuses
+          when :completed
+            tasks = tasks.completed
+          when :failed
+            tasks = tasks.failed
+          when :in_progress
+            tasks = tasks.in_progress
+          when :pending
+            tasks = tasks.pending
+          end
+        end
 
         @pagy, @tasks = pagy(tasks)
       end

data/app/controllers/raif/conversations_controller.rb

@@ -34,7 +34,11 @@ private
   end
 
   def validate_conversation_type
-    head :bad_request unless Raif.config.conversation_types.include?(conversation_type_param)
+    unless Raif.config.conversation_types.include?(conversation_type_param)
+      logger.error("Invalid Raif conversation type - not in Raif.config.conversation_types: #{conversation_type_param}")
+      logger.debug("\n\n\e[33m!!! Make sure to add the conversation type in Raif.config.conversation_types\e[0m\n")
+      head :bad_request
+    end
   end
 
   def raif_conversation_type

data/app/models/raif/agent.rb

@@ -22,14 +22,12 @@ module Raif
     validates :task, presence: true
     validates :system_prompt, presence: true
     validates :max_iterations, presence: true, numericality: { greater_than: 0 }
-    validates :available_model_tools, length: {
-      minimum: 1,
-      message: ->(_object, _data) {
-        I18n.t("raif.agents.errors.available_model_tools.too_short")
-      }
-    }
 
-    before_validation -> { self.system_prompt ||= build_system_prompt }, on: :create
+    before_validation -> {
+      populate_default_model_tools
+      self.system_prompt ||= build_system_prompt
+    },
+      on: :create
 
     attr_accessor :on_conversation_history_entry
 
@@ -59,7 +57,6 @@ module Raif
     def run!(&block)
       self.on_conversation_history_entry = block_given? ? block : nil
       self.started_at = Time.current
-      self.available_model_tools += ["Raif::ModelTools::AgentFinalAnswer"] unless available_model_tools.include?("Raif::ModelTools::AgentFinalAnswer")
       save!
 
       logger.debug <<~DEBUG
@@ -111,8 +108,12 @@ module Raif
 
   private
 
+    def populate_default_model_tools
+      # no-op by default. Can be overridden by subclasses to add default model tools
+    end
+
     def process_iteration_model_completion(model_completion)
-      raise NotImplementedError, "#{self.class.name} must implement execute_agent_iteration"
+      raise NotImplementedError, "#{self.class.name} must implement process_iteration_model_completion"
     end
 
     def native_model_tools
@@ -122,6 +123,7 @@ module Raif
     def add_conversation_history_entry(entry)
       entry_stringified = entry.stringify_keys
       conversation_history << entry_stringified
+      save!
       on_conversation_history_entry.call(entry_stringified) if on_conversation_history_entry.present?
     end
 

data/app/models/raif/agents/native_tool_calling_agent.rb

@@ -4,6 +4,16 @@ module Raif
   module Agents
     class NativeToolCallingAgent < Raif::Agent
       validate :ensure_llm_supports_native_tool_use
+      validates :available_model_tools, length: {
+        minimum: 2,
+        message: ->(_object, _data) {
+          I18n.t("raif.agents.native_tool_calling_agent.errors.available_model_tools.too_short")
+        }
+      }
+
+      before_validation -> {
+        available_model_tools << "Raif::ModelTools::AgentFinalAnswer" unless available_model_tools.include?("Raif::ModelTools::AgentFinalAnswer")
+      }
 
       def build_system_prompt
         <<~PROMPT.strip
@@ -49,7 +59,7 @@ module Raif
         if model_completion.response_tool_calls.blank?
           add_conversation_history_entry({
             role: "assistant",
-            content: "<observation>Error: No tool call found. I need make a tool call at each step. Available tools: #{available_model_tools_map.keys.join(", ")}</observation>" # rubocop:disable Layout/LineLength
+            content: "<observation>Error: No tool call found. I need to make a tool call at each step. Available tools: #{available_model_tools_map.keys.join(", ")}</observation>" # rubocop:disable Layout/LineLength
           })
           return
         end

data/app/models/raif/agents/re_act_agent.rb

@@ -3,6 +3,12 @@
 module Raif
   module Agents
     class ReActAgent < Raif::Agent
+      validates :available_model_tools, length: {
+        minimum: 1,
+        message: ->(_object, _data) {
+          I18n.t("raif.agents.re_act_agent.errors.available_model_tools.too_short")
+        }
+      }
 
       def build_system_prompt
         <<~PROMPT.strip

data/app/models/raif/concerns/has_available_model_tools.rb

@@ -4,7 +4,7 @@ module Raif::Concerns::HasAvailableModelTools
   extend ActiveSupport::Concern
 
   def available_model_tools_map
-    @available_model_tools_map ||= available_model_tools&.map do |tool_name|
+    available_model_tools&.map do |tool_name|
       tool_klass = tool_name.is_a?(String) ? tool_name.constantize : tool_name
       [tool_klass.tool_name, tool_klass]
     end.to_h

data/app/models/raif/concerns/json_schema_definition.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Raif
+  module Concerns
+    module JsonSchemaDefinition
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def json_schema_definition(schema_name, &block)
+          raise ArgumentError, "A block must be provided to define the JSON schema" unless block_given?
+
+          @schemas ||= {}
+          @schemas[schema_name] = Raif::JsonSchemaBuilder.new
+          @schemas[schema_name].instance_eval(&block)
+          @schemas[schema_name]
+        end
+
+        def schema_defined?(schema_name)
+          @schemas&.dig(schema_name).present?
+        end
+
+        def schema_for(schema_name)
+          @schemas[schema_name].to_schema
+        end
+      end
+    end
+  end
+end

data/app/models/raif/concerns/llm_response_parsing.rb

@@ -3,12 +3,33 @@
 module Raif::Concerns::LlmResponseParsing
   extend ActiveSupport::Concern
 
+  ASCII_CONTROL_CHARS = /[\x00-\x1f\x7f]/
+
   included do
     normalizes :raw_response, with: ->(text){ text&.strip }
 
     enum :response_format, Raif::Llm.valid_response_formats, prefix: true
 
     validates :response_format, presence: true, inclusion: { in: response_formats.keys }
+
+    class_attribute :allowed_tags
+    class_attribute :allowed_attributes
+  end
+
+  class_methods do
+    def llm_response_format(format)
+      raise ArgumentError, "response_format must be one of: #{response_formats.keys.join(", ")}" unless response_formats.keys.include?(format.to_s)
+
+      after_initialize -> { self.response_format = format }, if: :new_record?
+    end
+
+    def llm_response_allowed_tags(tags)
+      self.allowed_tags = tags
+    end
+
+    def llm_response_allowed_attributes(attributes)
+      self.allowed_attributes = attributes
+    end
   end
 
   # Parses the response from the LLM into a structured format, based on the response_format.
@@ -16,29 +37,36 @@ module Raif::Concerns::LlmResponseParsing
   # If the response format is HTML, it will be sanitized via ActionController::Base.helpers.sanitize.
   #
   # @return [Object] The parsed response.
-  def parsed_response
+  def parsed_response(force_reparse: false)
     return if raw_response.blank?
+    return @parsed_response if @parsed_response.present? && !force_reparse
 
-    @parsed_response ||= if response_format_json?
-      json = raw_response.gsub("```json", "").gsub("```", "")
-      JSON.parse(json)
+    @parsed_response = if response_format_json?
+      parse_json_response
     elsif response_format_html?
-      html = raw_response.strip.gsub("```html", "").chomp("```")
-      clean_html_fragment(html)
+      parse_html_response
     else
       raw_response.strip
     end
   end
 
-  def clean_html_fragment(html)
-    fragment = Nokogiri::HTML.fragment(html)
+  def parse_json_response
+    json = raw_response.gsub(/#{ASCII_CONTROL_CHARS}|^```json|```$/, "").strip
 
-    fragment.traverse do |node|
-      if node.text? && node.text.strip.empty?
-        node.remove
-      end
-    end
+    raise JSON::ParserError, "Invalid JSON" if json.blank?
 
-    ActionController::Base.helpers.sanitize(fragment.to_html).strip
+    JSON.parse(json)
   end
+
+  def parse_html_response
+    html = raw_response.strip.gsub("```html", "").chomp("```")
+
+    html_with_converted_links = Raif::Utils::HtmlFragmentProcessor.convert_markdown_links_to_html(html)
+    Raif::Utils::HtmlFragmentProcessor.clean_html_fragment(
+      html_with_converted_links,
+      allowed_tags: allowed_tags,
+      allowed_attributes: allowed_attributes
+    )
+  end
+
 end

data/app/models/raif/concerns/llm_temperature.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::LlmTemperature
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :temperature, instance_writer: false
+  end
+
+  class_methods do
+    def llm_temperature(temperature)
+      raise ArgumentError, "temperature must be a number between 0 and 1" unless temperature.is_a?(Numeric) && temperature.between?(0, 1)
+
+      self.temperature = temperature
+    end
+  end
+end

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/anthropic/tool_formatting.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::Anthropic::ToolFormatting
+  extend ActiveSupport::Concern
+
+  def build_tools_parameter(model_completion)
+    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 << if tool.provider_managed?
+          format_provider_managed_tool(tool)
+        else
+          {
+            name: tool.tool_name,
+            description: tool.tool_description,
+            input_schema: tool.tool_arguments_schema
+          }
+        end
+      end
+    end
+
+    tools
+  end
+
+  def format_provider_managed_tool(tool)
+    validate_provider_managed_tool_support!(tool)
+
+    case tool.name
+    when "Raif::ModelTools::ProviderManaged::WebSearch"
+      {
+        type: "web_search_20250305",
+        name: "web_search",
+        max_uses: 5
+      }
+    when "Raif::ModelTools::ProviderManaged::CodeExecution"
+      {
+        type: "code_execution_20250522",
+        name: "code_execution"
+      }
+    else
+      raise Raif::Errors::UnsupportedFeatureError,
+        "Invalid provider-managed tool: #{tool.name} for #{key}"
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::Bedrock::MessageFormatting
+  extend ActiveSupport::Concern
+
+  def format_string_message(content, role: nil)
+    { "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::Bedrock#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::Bedrock#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/bedrock/tool_formatting.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::Bedrock::ToolFormatting
+  extend ActiveSupport::Concern
+
+  def build_tools_parameter(model_completion)
+    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
+
+    model_completion.available_model_tools_map.each do |_tool_name, tool|
+      tools << if tool.provider_managed?
+        raise Raif::Errors::UnsupportedFeatureError,
+          "Invalid provider-managed tool: #{tool.name} for #{key}"
+      else
+        {
+          name: tool.tool_name,
+          description: tool.tool_description,
+          input_schema: { json: tool.tool_arguments_schema }
+        }
+      end
+    end
+
+    return {} if tools.blank?
+
+    {
+      tools: tools.map{|tool| { tool_spec: tool } }
+    }
+  end
+end

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

@@ -0,0 +1,42 @@
+# 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]
+      {
+        "role" => role,
+        "content" => format_message_content(message["content"] || message[:content], role: role)
+      }
+    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, role: nil)
+    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, role: role)] 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, role: role)
+      else
+        item
+      end
+    end
+  end
+
+  def format_string_message(content, role: nil)
+    { "type" => "text", "text" => content }
+  end
+
+end