raif 1.3.0 → 1.5.0

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Raif
+  module Admin
+    class ConfigsController < Raif::Admin::ApplicationController
+
+      def show
+        @config = Raif.config
+        @config_settings = build_config_settings
+      end
+
+    private
+
+      def build_config_settings
+        [
+          { key: "agent_types", value: format_array(@config.agent_types.to_a) },
+          { key: "anthropic_api_key", value: mask_sensitive_value(@config.anthropic_api_key) },
+          { key: "anthropic_models_enabled", value: @config.anthropic_models_enabled },
+          { key: "authorize_admin_controller_action", value: format_proc(@config.authorize_admin_controller_action) },
+          { key: "authorize_controller_action", value: format_proc(@config.authorize_controller_action) },
+          { key: "aws_bedrock_model_name_prefix", value: @config.aws_bedrock_model_name_prefix },
+          { key: "aws_bedrock_region", value: @config.aws_bedrock_region },
+          { key: "bedrock_embedding_models_enabled", value: @config.bedrock_embedding_models_enabled },
+          { key: "bedrock_models_enabled", value: @config.bedrock_models_enabled },
+          { key: "conversation_entries_controller", value: @config.conversation_entries_controller },
+          { key: "conversation_llm_messages_max_length_default", value: @config.conversation_llm_messages_max_length_default },
+          { key: "conversation_system_prompt_intro", value: truncate_text(@config.conversation_system_prompt_intro, 100) },
+          { key: "conversation_types", value: format_array(@config.conversation_types.to_a) },
+          { key: "conversations_controller", value: @config.conversations_controller },
+          { key: "current_user_method", value: @config.current_user_method },
+          { key: "default_embedding_model_key", value: @config.default_embedding_model_key },
+          { key: "default_llm_model_key", value: @config.default_llm_model_key },
+          { key: "evals_default_llm_judge_model_key", value: @config.evals_default_llm_judge_model_key },
+          { key: "evals_verbose_output", value: @config.evals_verbose_output },
+          { key: "google_api_key", value: mask_sensitive_value(@config.google_api_key) },
+          { key: "google_embedding_models_enabled", value: @config.google_embedding_models_enabled },
+          { key: "google_models_enabled", value: @config.google_models_enabled },
+          { key: "llm_api_requests_enabled", value: @config.llm_api_requests_enabled },
+          { key: "llm_request_max_retries", value: @config.llm_request_max_retries },
+          { key: "llm_request_retriable_exceptions", value: @config.llm_request_retriable_exceptions.map(&:name).join(", ") },
+          { key: "model_superclass", value: @config.model_superclass },
+          { key: "open_ai_api_key", value: mask_sensitive_value(@config.open_ai_api_key) },
+          { key: "open_ai_api_version", value: @config.open_ai_api_version },
+          { key: "open_ai_auth_header_style", value: @config.open_ai_auth_header_style },
+          { key: "open_ai_base_url", value: @config.open_ai_base_url },
+          { key: "open_ai_embedding_base_url", value: @config.open_ai_embedding_base_url },
+          { key: "open_ai_embedding_models_enabled", value: @config.open_ai_embedding_models_enabled },
+          { key: "open_ai_models_enabled", value: @config.open_ai_models_enabled },
+          { key: "open_router_api_key", value: mask_sensitive_value(@config.open_router_api_key) },
+          { key: "open_router_app_name", value: @config.open_router_app_name },
+          { key: "open_router_models_enabled", value: @config.open_router_models_enabled },
+          { key: "open_router_site_url", value: @config.open_router_site_url },
+          { key: "request_open_timeout", value: @config.request_open_timeout },
+          { key: "request_read_timeout", value: @config.request_read_timeout },
+          { key: "request_write_timeout", value: @config.request_write_timeout },
+          { key: "streaming_update_chunk_size_threshold", value: @config.streaming_update_chunk_size_threshold },
+          { key: "task_creator_optional", value: @config.task_creator_optional },
+          { key: "task_system_prompt_intro", value: truncate_text(@config.task_system_prompt_intro, 100) },
+          { key: "user_tool_types", value: format_array(@config.user_tool_types) }
+        ]
+      end
+
+      def mask_sensitive_value(value)
+        return "Not set" if value.blank?
+        return "Not set" if value.include?("placeholder")
+
+        "#{value[0...5]}#{"*" * 20}"
+      end
+
+      def format_proc(value)
+        return "Not set" unless value.respond_to?(:call)
+
+        source = value.source_location
+        if source
+          "Lambda/Proc defined at #{source[0]}:#{source[1]}"
+        else
+          "Lambda/Proc (source unavailable)"
+        end
+      end
+
+      def truncate_text(text, length)
+        return "Not set" if text.blank?
+        return format_proc(text) if text.respond_to?(:call)
+
+        text.length > length ? "#{text[0...length]}..." : text
+      end
+
+      def format_array(array)
+        return "None" if array.blank?
+
+        array.join(", ")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Raif
+  module Admin
+    class LlmsController < Raif::Admin::ApplicationController
+
+      def index
+        @llms = Raif.llm_registry.map do |_key, config|
+          llm_class = config[:llm_class]
+          llm_class.new(**config.except(:llm_class))
+        end
+
+        @llms.sort_by!(&:name)
+
+        @provider_names = @llms.map { |llm| llm.class.name.demodulize }.uniq.sort
+        @llm_names = @llms.map(&:name).sort
+
+        @selected_providers = Array(params[:providers]).reject(&:blank?)
+        @selected_names = Array(params[:names]).reject(&:blank?)
+
+        @llms = @llms.select { |llm| @selected_providers.include?(llm.class.name.demodulize) } if @selected_providers.present?
+        @llms = @llms.select { |llm| @selected_names.include?(llm.name) } if @selected_names.present?
+      end
+
+    end
+  end
+end

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

@@ -6,7 +6,30 @@ module Raif
       include Pagy::Backend
 
       def index
-        @pagy, @model_completions = pagy(Raif::ModelCompletion.order(created_at: :desc))
+        @selected_status = params[:status].present? ? params[:status].to_sym : :all
+        @selected_llm_model_key = params[:llm_model_key].presence
+        @llm_model_keys = Raif::ModelCompletion.distinct.order(:llm_model_key).pluck(:llm_model_key)
+
+        model_completions = Raif::ModelCompletion.order(created_at: :desc)
+
+        if @selected_status.present? && @selected_status != :all
+          case @selected_status
+          when :completed
+            model_completions = model_completions.completed
+          when :failed
+            model_completions = model_completions.failed
+          when :started
+            model_completions = model_completions.started.where(completed_at: nil, failed_at: nil)
+          when :pending
+            model_completions = model_completions.where(started_at: nil)
+          end
+        end
+
+        if @selected_llm_model_key.present?
+          model_completions = model_completions.where(llm_model_key: @selected_llm_model_key)
+        end
+
+        @pagy, @model_completions = pagy(model_completions)
       end
 
       def show

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

@@ -6,7 +6,13 @@ module Raif
       include Pagy::Backend
 
       def index
-        @pagy, @model_tool_invocations = pagy(Raif::ModelToolInvocation.order(created_at: :desc))
+        @tool_types = Raif::ModelToolInvocation.distinct.pluck(:tool_type)
+        @selected_type = params[:tool_types].present? && @tool_types.include?(params[:tool_types]) ? params[:tool_types] : "all"
+
+        model_tool_invocations = Raif::ModelToolInvocation.newest_first
+        model_tool_invocations = model_tool_invocations.where(tool_type: @selected_type) if @selected_type.present? && @selected_type != "all"
+
+        @pagy, @model_tool_invocations = pagy(model_tool_invocations)
       end
 
       def show

data/app/controllers/raif/admin/prompt_studio/agents_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Raif
+  module Admin
+    module PromptStudio
+      class AgentsController < BaseController
+        def index
+          @agent_types = Raif::Agent.distinct.pluck(:type).sort
+          @selected_type = params[:agent_type] if params[:agent_type].present?
+          @llm_model_keys = Raif::Agent.where(type: @selected_type).distinct.pluck(:llm_model_key).compact.sort if @selected_type.present?
+
+          if @selected_type.present?
+            agents = apply_filters(Raif::Agent.where(type: @selected_type)).order(created_at: :desc)
+            @pagy, @agents = pagy(agents)
+          end
+        end
+
+        def show
+          @agent = Raif::Agent.find(params[:id])
+          @comparison = build_prompt_comparison(@agent)
+        end
+      end
+    end
+  end
+end

data/app/controllers/raif/admin/prompt_studio/base_controller.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Raif
+  module Admin
+    module PromptStudio
+      class BaseController < Raif::Admin::ApplicationController
+        include Pagy::Backend
+
+      private
+
+        def build_prompt_comparison(record)
+          Raif::PromptStudioComparisonBuilder.build(record)
+        end
+
+        def apply_filters(scope)
+          scope = scope.where("#{scope.table_name}.created_at >= ?", Time.zone.parse(params[:created_after])) if params[:created_after].present?
+          scope = scope.where(
+            "#{scope.table_name}.created_at <= ?",
+            Time.zone.parse(params[:created_before]).end_of_day
+          ) if params[:created_before].present?
+          scope = scope.where(llm_model_key: params[:llm_model_key]) if params[:llm_model_key].present?
+          scope
+        end
+
+        helper_method :prompt_studio_runs_enabled?
+        def prompt_studio_runs_enabled?
+          Raif.config.prompt_studio_runs_enabled
+        end
+      end
+    end
+  end
+end

data/app/controllers/raif/admin/prompt_studio/batch_runs_controller.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Raif
+  module Admin
+    module PromptStudio
+      class BatchRunsController < BaseController
+        def create
+          unless prompt_studio_runs_enabled?
+            redirect_to raif.admin_prompt_studio_tasks_path, alert: t("raif.admin.prompt_studio.common.runs_disabled")
+            return
+          end
+
+          source_tasks = resolve_source_tasks
+          if source_tasks.empty?
+            redirect_to raif.admin_prompt_studio_tasks_path(task_type: params[:task_type]),
+              alert: t("raif.admin.prompt_studio.batch_runs.create.no_tasks_selected")
+            return
+          end
+
+          available_keys = Raif.available_llm_keys.map(&:to_s)
+
+          unless params[:llm_model_key].present? && available_keys.include?(params[:llm_model_key])
+            redirect_to raif.admin_prompt_studio_tasks_path(task_type: params[:task_type]),
+              alert: t("raif.admin.prompt_studio.tasks.rerun.invalid_model")
+            return
+          end
+
+          if params[:judge_type].present? && params[:judge_llm_model_key].present? && !available_keys.include?(params[:judge_llm_model_key])
+            redirect_to raif.admin_prompt_studio_tasks_path(task_type: params[:task_type]),
+              alert: t("raif.admin.prompt_studio.tasks.rerun.invalid_model")
+            return
+          end
+
+          batch_run = Raif::PromptStudioBatchRun.new(
+            task_type: params[:task_type],
+            llm_model_key: params[:llm_model_key],
+            judge_type: params[:judge_type].presence,
+            judge_llm_model_key: params[:judge_llm_model_key].presence,
+            judge_config: build_judge_config,
+            total_count: source_tasks.size
+          )
+
+          batch_run.save!
+
+          source_tasks.each do |task|
+            batch_run.items.create!(source_task: task)
+          end
+
+          Raif::PromptStudioBatchRunJob.perform_later(batch_run: batch_run)
+
+          redirect_to raif.admin_prompt_studio_batch_run_path(batch_run)
+        rescue StandardError => e
+          redirect_to raif.admin_prompt_studio_tasks_path(task_type: params[:task_type]),
+            alert: t("raif.admin.prompt_studio.batch_runs.create.error", message: e.message)
+        end
+
+        def show
+          @batch_run = Raif::PromptStudioBatchRun.find(params[:id])
+          items = @batch_run.items.includes(:source_task, :result_task, :judge_task).order(:id)
+          @pagy, @items = pagy(items)
+        end
+
+      private
+
+        def resolve_source_tasks
+          ids = Array(params[:source_task_ids]).map(&:to_i).reject(&:zero?)
+          scope = Raif::Task.where(id: ids).completed
+          scope = scope.where(type: params[:task_type]) if params[:task_type].present?
+          scope
+        end
+
+        def build_judge_config
+          config = case params[:judge_type]
+          when "Raif::Evals::LlmJudges::Binary"
+            {
+              "criteria" => params[:judge_criteria].presence || "",
+              "strict_mode" => params[:judge_strict_mode] == "1"
+            }
+          when "Raif::Evals::LlmJudges::Scored"
+            {
+              "scoring_rubric" => params[:judge_scoring_rubric].presence || "accuracy"
+            }
+          when "Raif::Evals::LlmJudges::Comparative"
+            {
+              "comparison_criteria" => params[:judge_comparison_criteria].presence || ""
+            }
+          when "Raif::Evals::LlmJudges::Summarization"
+            {}
+          else
+            {}
+          end
+
+          if params[:judge_type].present?
+            config["include_original_prompt_as_context"] = params[:judge_include_original_prompt_as_context] == "1"
+          end
+
+          config
+        end
+      end
+    end
+  end
+end

data/app/controllers/raif/admin/prompt_studio/conversations_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Raif
+  module Admin
+    module PromptStudio
+      class ConversationsController < BaseController
+        def index
+          @conversation_types = Raif::Conversation.distinct.pluck(:type).sort
+          @selected_type = params[:conversation_type] if params[:conversation_type].present?
+          @llm_model_keys = Raif::Conversation.where(type: @selected_type).distinct.pluck(:llm_model_key).compact.sort if @selected_type.present?
+
+          if @selected_type.present?
+            conversations = apply_filters(Raif::Conversation.where(type: @selected_type)).order(created_at: :desc)
+            @pagy, @conversations = pagy(conversations)
+          end
+        end
+
+        def show
+          @conversation = Raif::Conversation.find(params[:id])
+          @comparison = build_prompt_comparison(@conversation)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Raif
+  module Admin
+    module PromptStudio
+      class TasksController < BaseController
+        def index
+          @task_types = Raif::Task.distinct.pluck(:type).sort
+          @selected_type = params[:task_type] if params[:task_type].present?
+          @llm_model_keys = Raif::Task.where(type: @selected_type).distinct.pluck(:llm_model_key).compact.sort if @selected_type.present?
+
+          if @selected_type.present?
+            tasks = apply_filters(Raif::Task.where(type: @selected_type).completed).includes(:raif_model_completion).order(created_at: :desc)
+            @pagy, @tasks = pagy(tasks)
+          end
+
+          @show_batch_runs = prompt_studio_runs_enabled? && @selected_type.present? && @tasks.present?
+        end
+
+        def show
+          @task = Raif::Task.find(params[:id])
+          @comparison = build_prompt_comparison(@task)
+          @original_task = @task.source if @task.prompt_studio_run? && @task.source.is_a?(Raif::Task)
+          @available_llm_keys = Raif.available_llm_keys.map(&:to_s).sort
+        end
+
+        def create
+          original_task = Raif::Task.find(params[:source_task_id])
+
+          unless prompt_studio_runs_enabled?
+            redirect_to raif.admin_prompt_studio_task_path(original_task), alert: t("raif.admin.prompt_studio.common.runs_disabled")
+            return
+          end
+
+          llm_model_key = params[:llm_model_key]
+
+          unless llm_model_key.present? && Raif.available_llm_keys.map(&:to_s).include?(llm_model_key)
+            redirect_to raif.admin_prompt_studio_task_path(original_task), alert: t("raif.admin.prompt_studio.tasks.rerun.invalid_model")
+            return
+          end
+
+          new_task = original_task.class.new(
+            creator: original_task.creator,
+            source: original_task,
+            llm_model_key: llm_model_key,
+            available_model_tools: original_task.available_model_tools,
+            run_with: original_task.run_with,
+            prompt_studio_run: true,
+            started_at: Time.current
+          )
+          new_task.assign_attributes(original_task.prompt_studio_task_attributes)
+          new_task.save!
+          Raif::PromptStudioTaskRunJob.perform_later(task: new_task)
+
+          redirect_to raif.admin_prompt_studio_task_path(new_task)
+        rescue StandardError => e
+          new_task&.update(failed_at: Time.current) unless new_task&.failed_at?
+          redirect_to raif.admin_prompt_studio_task_path(original_task || params[:source_task_id]),
+            alert: t("raif.admin.prompt_studio.tasks.rerun.error", message: e.message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Raif
+  module Admin
+    module Stats
+      class ModelToolInvocationsController < Raif::Admin::ApplicationController
+        def index
+          @selected_period = params[:period] || "day"
+          @time_range = get_time_range(@selected_period)
+
+          @model_tool_invocation_count = Raif::ModelToolInvocation.where(created_at: @time_range).count
+
+          @model_tool_invocation_stats_by_type = Raif::ModelToolInvocation
+            .where(created_at: @time_range)
+            .group(:tool_type)
+            .count
+        end
+      end
+    end
+  end
+end

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

@@ -7,17 +7,26 @@ module Raif
         def index
           @selected_period = params[:period] || "day"
           @time_range = get_time_range(@selected_period)
+          @show_model_breakdown = params[:show_model_breakdown] == "1"
 
           @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
+          group_columns = @show_model_breakdown ? [:type, :llm_model_key] : [:type]
+          select_columns = ["raif_tasks.type"]
+          select_columns << "raif_tasks.llm_model_key" if @show_model_breakdown
+          select_columns << "COUNT(raif_tasks.id)"
+          select_columns << "SUM(raif_model_completions.prompt_token_cost)"
+          select_columns << "SUM(raif_model_completions.output_token_cost)"
+          select_columns << "SUM(raif_model_completions.total_cost)"
 
-          # Get costs by task type
-          @task_costs_by_type = Raif::Task.joins(:raif_model_completion)
+          @task_stats_by_type = Raif::Task.joins(:raif_model_completion)
             .where(created_at: @time_range)
-            .group(:type)
-            .sum("raif_model_completions.total_cost")
+            .group(*group_columns)
+            .pluck(*select_columns)
+            .map do |type, *rest|
+              llm_model_key = @show_model_breakdown ? rest.shift : nil
+              Raif::Admin::TaskStat.new(type, llm_model_key, *rest)
+            end
         end
       end
     end

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

@@ -7,12 +7,41 @@ module Raif
         @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
+        model_completions = Raif::ModelCompletion.where(created_at: @time_range)
+
+        @model_completion_count = model_completions.count
+        @model_completion_total_cost = model_completions.sum(:total_cost)
+        @model_completion_input_token_cost = model_completions.sum(:prompt_token_cost)
+        @model_completion_output_token_cost = model_completions.sum(:output_token_cost)
+
+        tasks = Raif::Task.where(created_at: @time_range)
+        @task_count = tasks.count
+        @task_total_cost = Raif::ModelCompletion.where(source_type: "Raif::Task", created_at: @time_range).sum(:total_cost)
+        @task_input_token_cost = Raif::ModelCompletion.where(source_type: "Raif::Task", created_at: @time_range).sum(:prompt_token_cost)
+        @task_output_token_cost = Raif::ModelCompletion.where(source_type: "Raif::Task", created_at: @time_range).sum(:output_token_cost)
+
         @conversation_count = Raif::Conversation.where(created_at: @time_range).count
+
         @conversation_entry_count = Raif::ConversationEntry.where(created_at: @time_range).count
+        @conversation_entry_total_cost = Raif::ModelCompletion.where(
+          source_type: "Raif::ConversationEntry",
+          created_at: @time_range,
+        ).sum(:total_cost)
+        @conversation_entry_input_token_cost = Raif::ModelCompletion.where(
+          source_type: "Raif::ConversationEntry",
+          created_at: @time_range,
+        ).sum(:prompt_token_cost)
+        @conversation_entry_output_token_cost = Raif::ModelCompletion.where(
+          source_type: "Raif::ConversationEntry",
+          created_at: @time_range,
+        ).sum(:output_token_cost)
+
         @agent_count = Raif::Agent.where(created_at: @time_range).count
+        @agent_total_cost = Raif::ModelCompletion.where(source_type: "Raif::Agent", created_at: @time_range).sum(:total_cost)
+        @agent_input_token_cost = Raif::ModelCompletion.where(source_type: "Raif::Agent", created_at: @time_range).sum(:prompt_token_cost)
+        @agent_output_token_cost = Raif::ModelCompletion.where(source_type: "Raif::Agent", created_at: @time_range).sum(:output_token_cost)
+
+        @model_tool_invocation_count = Raif::ModelToolInvocation.where(created_at: @time_range).count
       end
     end
   end

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

@@ -12,6 +12,9 @@ module Raif
         @task_statuses = [:all, :completed, :failed, :in_progress, :pending]
         @selected_statuses = params[:task_statuses].present? ? params[:task_statuses].to_sym : :all
 
+        @selected_llm_model_key = params[:llm_model_key].presence
+        @llm_model_keys = Raif::Task.distinct.order(:llm_model_key).pluck(:llm_model_key)
+
         tasks = Raif::Task.order(created_at: :desc)
         tasks = tasks.where(type: @selected_type) if @selected_type.present? && @selected_type != "all"
 
@@ -28,6 +31,8 @@ module Raif
           end
         end
 
+        tasks = tasks.where(llm_model_key: @selected_llm_model_key) if @selected_llm_model_key.present?
+
         @pagy, @tasks = pagy(tasks)
       end
 

data/app/controllers/raif/conversation_entries_controller.rb

@@ -25,6 +25,7 @@ class Raif::ConversationEntriesController < Raif::ApplicationController
     @conversation_entry.creator = current_user
 
     if @conversation_entry.save
+      @conversation.update_columns(generating_entry_response: true)
       Raif::ConversationEntryJob.perform_later(conversation_entry: @conversation_entry)
     end
   end

data/app/controllers/raif/conversations_controller.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
 class Raif::ConversationsController < Raif::ApplicationController
-  before_action :validate_conversation_type
+  before_action :validate_conversation_type, unless: ->{ params[:action] == "index" && params[:conversation_type].blank? }
+
+  def index
+    @conversations = conversations_scope
+  end
 
   def show
     @conversations = conversations_scope
@@ -26,7 +30,11 @@ private
   end
 
   def conversations_scope
-    raif_conversation_type.newest_first.where(creator: raif_current_user)
+    if params[:conversation_type].present?
+      raif_conversation_type
+    else
+      Raif::Conversation
+    end.newest_first.where(creator: raif_current_user)
   end
 
   def conversation_type_param

data/app/helpers/raif/application_helper.rb

@@ -3,5 +3,45 @@
 module Raif
   module ApplicationHelper
     include Pagy::Frontend
+
+    def format_task_response(task)
+      if task.response_format_json? && task.raw_response.present?
+        JSON.pretty_generate(JSON.parse(task.raw_response))
+      else
+        task.raw_response
+      end
+    rescue JSON::ParserError
+      task.raw_response
+    end
+
+    def pretty_json(value)
+      JSON.pretty_generate(JSON.parse(value))
+    rescue StandardError
+      value
+    end
+
+    def llm_model_options(selected: nil)
+      options = Raif.available_llm_keys.map do |key|
+        label = I18n.t("raif.model_names.#{key}", default: key.to_s)
+        [label, key.to_s]
+      end.sort_by(&:first)
+
+      options_for_select(options, selected&.to_s)
+    end
+
+    def llm_pricing_json
+      pricing = {}
+      Raif.available_llm_keys.each do |key|
+        config = Raif.llm_config(key)
+        next unless config
+
+        pricing[key.to_s] = {
+          input: config[:input_token_cost] || 0,
+          output: config[:output_token_cost] || 0
+        }
+      end
+
+      pricing.to_json
+    end
   end
 end

data/app/jobs/raif/conversation_entry_job.rb

@@ -6,22 +6,24 @@ module Raif
     before_enqueue do |job|
       conversation_entry = job.arguments.first[:conversation_entry]
       conversation_entry.update_columns(started_at: Time.current)
+
+      unless conversation_entry.raif_conversation.generating_entry_response?
+        conversation_entry.raif_conversation.update_columns(generating_entry_response: true)
+      end
     end
 
     def perform(conversation_entry:)
       conversation = conversation_entry.raif_conversation
       conversation_entry.process_entry!
-      conversation_entry.broadcast_replace_to conversation
 
-      Turbo::StreamsChannel.broadcast_action_to(
-        conversation,
-        action: :raif_scroll_to_bottom,
-        target: ActionView::RecordIdentifier.dom_id(conversation, :entries)
-      )
+      Turbo::StreamsChannel.broadcast_render_to conversation,
+        partial: "raif/conversations/entry_processed",
+        locals: { conversation: conversation, conversation_entry: conversation_entry }
     rescue StandardError => e
       logger.error "Error processing conversation entry: #{e.message}"
       logger.error e.backtrace.join("\n")
 
+      conversation_entry.raif_conversation.update_columns(generating_entry_response: false)
       conversation_entry.failed!
       conversation_entry.broadcast_replace_to conversation
     end

data/app/jobs/raif/prompt_studio_batch_run_item_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Raif
+  class PromptStudioBatchRunItemJob < ApplicationJob
+
+    def perform(item:)
+      item.execute!
+    end
+
+  end
+end