feat: legacy features to ruby llm (#12994)

enterprise/app/services/internal/account_analysis/content_evaluator_service.rb

@@ -1,48 +1,59 @@
-class Internal::AccountAnalysis::ContentEvaluatorService < Llm::LegacyBaseOpenAiService
-  def initialize
-    super()
+class Internal::AccountAnalysis::ContentEvaluatorService
+  include Integrations::LlmInstrumentation
 
-    @model = 'gpt-4o-mini'.freeze
+  def initialize
+    Llm::Config.initialize!
   end
 
   def evaluate(content)
     return default_evaluation if content.blank?
 
-    begin
-      response = send_to_llm(content)
-      evaluation = handle_response(response)
-      log_evaluation_results(evaluation)
-      evaluation
-    rescue StandardError => e
-      handle_evaluation_error(e)
+    moderation_result = instrument_moderation_call(instrumentation_params(content)) do
+      RubyLLM.moderate(content.to_s[0...10_000])
     end
+
+    build_evaluation(moderation_result)
+  rescue StandardError => e
+    handle_evaluation_error(e)
   end
 
   private
 
-  def send_to_llm(content)
-    Rails.logger.info('Sending content to LLM for security evaluation')
-    @client.chat(
-      parameters: {
-        model: @model,
-        messages: llm_messages(content),
-        response_format: { type: 'json_object' }
-      }
-    )
+  def instrumentation_params(content)
+    {
+      span_name: 'llm.internal.content_moderation',
+      model: 'text-moderation-latest',
+      input: content,
+      feature_name: 'content_evaluator'
+    }
   end
 
-  def handle_response(response)
-    return default_evaluation if response.nil?
+  def build_evaluation(result)
+    flagged = result.flagged?
+    categories = result.flagged_categories
 
-    parsed = JSON.parse(response.dig('choices', 0, 'message', 'content').strip)
-
-    {
-      'threat_level' => parsed['threat_level'] || 'unknown',
-      'threat_summary' => parsed['threat_summary'] || 'No threat summary provided',
-      'detected_threats' => parsed['detected_threats'] || [],
-      'illegal_activities_detected' => parsed['illegal_activities_detected'] || false,
-      'recommendation' => parsed['recommendation'] || 'review'
+    evaluation = {
+      'threat_level' => flagged ? determine_threat_level(result) : 'safe',
+      'threat_summary' => flagged ? "Content flagged for: #{categories.join(', ')}" : 'No threats detected',
+      'detected_threats' => categories,
+      'illegal_activities_detected' => categories.any? { |c| c.include?('violence') || c.include?('self-harm') },
+      'recommendation' => flagged ? 'review' : 'approve'
     }
+
+    log_evaluation_results(evaluation)
+    evaluation
+  end
+
+  def determine_threat_level(result)
+    scores = result.category_scores
+    max_score = scores.values.max || 0
+
+    case max_score
+    when 0.8.. then 'critical'
+    when 0.5..0.8 then 'high'
+    when 0.2..0.5 then 'medium'
+    else 'low'
+    end
   end
 
   def default_evaluation(error_type = nil)
@@ -56,18 +67,11 @@ class Internal::AccountAnalysis::ContentEvaluatorService < Llm::LegacyBaseOpenAi
   end
 
   def log_evaluation_results(evaluation)
-    Rails.logger.info("LLM evaluation - Level: #{evaluation['threat_level']}, Illegal activities: #{evaluation['illegal_activities_detected']}")
+    Rails.logger.info("Moderation evaluation - Level: #{evaluation['threat_level']}, Threats: #{evaluation['detected_threats'].join(', ')}")
   end
 
   def handle_evaluation_error(error)
     Rails.logger.error("Error evaluating content: #{error.message}")
     default_evaluation('evaluation_failure')
   end
-
-  def llm_messages(content)
-    [
-      { role: 'system', content: 'You are a security analysis system that evaluates content for potential threats and scams.' },
-      { role: 'user', content: Internal::AccountAnalysis::PromptsService.threat_analyser(content.to_s[0...10_000]) }
-    ]
-  end
 end