FIX: make AI helper more robust

app/models/llm_model.rb

@@ -65,6 +65,8 @@ def self.provider_params
       google: {
         disable_native_tools: :checkbox,
         enable_thinking: :checkbox,
+        disable_temperature: :checkbox,
+        disable_top_p: :checkbox,
         thinking_tokens: :number,
       },
       azure: {

config/eval-llms.yml

@@ -1,4 +1,27 @@
 llms:
+  o3:
+    display_name: O3
+    name: o3
+    tokenizer: DiscourseAi::Tokenizer::OpenAiTokenizer
+    api_key_env: OPENAI_API_KEY
+    provider: open_ai
+    url: https://api.openai.com/v1/chat/completions
+    max_prompt_tokens: 131072
+    vision_enabled: true
+    provider_params:
+      disable_top_p: true
+      disable_temperature: true
+
+  gpt-41:
+    display_name: GPT-4.1
+    name: gpt-4.1
+    tokenizer: DiscourseAi::Tokenizer::OpenAiTokenizer
+    api_key_env: OPENAI_API_KEY
+    provider: open_ai
+    url: https://api.openai.com/v1/chat/completions
+    max_prompt_tokens: 131072
+    vision_enabled: true
+
   gpt-4o:
     display_name: GPT-4o
     name: gpt-4o
@@ -74,12 +97,25 @@ llms:
     max_prompt_tokens: 1000000
     vision_enabled: true
 
-  gemini-2.0-pro-exp:
+  gemini-2.5-flash:
+    display_name: Gemini 2.5 Flash
+    name: gemini-2-5-flash
+    tokenizer: DiscourseAi::Tokenizer::GeminiTokenizer
+    api_key_env: GEMINI_API_KEY
+    provider: google
+    url: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash
+    max_prompt_tokens: 1000000
+    vision_enabled: true
+    provider_params:
+      disable_top_p: true
+      disable_temperature: true
+
+  gemini-2.0-pro:
     display_name: Gemini 2.0 pro
-    name: gemini-2-0-pro-exp
+    name: gemini-2-0-pro
     tokenizer: DiscourseAi::Tokenizer::GeminiTokenizer
     api_key_env: GEMINI_API_KEY
     provider: google
-    url: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-pro-exp
+    url: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-pro
     max_prompt_tokens: 1000000
     vision_enabled: true

config/locales/client.en.yml

@@ -249,6 +249,7 @@ en:
           markdown_tables: "Generate Markdown table"
           custom_prompt: "Custom prompt"
           image_caption: "Caption images"
+          translator: "Translator"
 
         translation:
           name: "Translation"
@@ -257,7 +258,7 @@ en:
           post_raw_translator: "Post raw translator"
           topic_title_translator: "Topic title translator"
           short_text_translator: "Short text translator"
-        
+
         spam:
           name: "Spam"
           description: "Identifies potential spam using the selected LLM and flags it for site moderators to inspect in the review queue"

evals/lib/eval.rb

@@ -200,12 +200,7 @@ class << user
       user.admin = true
     end
     result =
-      helper.generate_and_send_prompt(
-        name,
-        input,
-        current_user = user,
-        _force_default_locale = false,
-      )
+      helper.generate_and_send_prompt(name, input, current_user = user, force_default_locale: false)
 
     result[:suggestions].first
   end

lib/ai_helper/assistant.rb

@@ -82,7 +82,7 @@ def attach_user_context(context, user = nil, force_default_locale: false)
         context.user_language = "#{locale_hash["name"]}"
 
         if user
-          timezone = user.user_option.timezone || "UTC"
+          timezone = user&.user_option&.timezone || "UTC"
           current_time = Time.now.in_time_zone(timezone)
 
           temporal_context = {
@@ -126,21 +126,32 @@ def generate_prompt(
           )
         context = attach_user_context(context, user, force_default_locale: force_default_locale)
 
-        helper_response = +""
+        bad_json = false
+        json_summary_schema_key = bot.persona.response_format&.first.to_h
+
+        schema_key = json_summary_schema_key["key"]&.to_sym
+        schema_type = json_summary_schema_key["type"]
+
+        if schema_type == "array"
+          helper_response = []
+        else
+          helper_response = +""
+        end
 
         buffer_blk =
           Proc.new do |partial, _, type|
-            json_summary_schema_key = bot.persona.response_format&.first.to_h
-            helper_response = [] if json_summary_schema_key["type"] == "array"
-            if type == :structured_output
-              helper_chunk = partial.read_buffered_property(json_summary_schema_key["key"]&.to_sym)
+            if type == :structured_output && schema_type
+              helper_chunk = partial.read_buffered_property(schema_key)
+              bad_json ||= partial.broken?
               if !helper_chunk.nil? && !helper_chunk.empty?
-                if json_summary_schema_key["type"] != "array"
-                  helper_response = helper_chunk
-                else
+                if bad_json || schema_type == "string" || schema_type == "array"
                   helper_response << helper_chunk
+                else
+                  # TODO this feels a bit odd
+                  # why is this allowed to throw away potential data?
+                  helper_response = helper_chunk
                 end
-                block.call(helper_chunk) if block
+                block.call(helper_chunk) if block && !bad_json
               end
             elsif type.blank?
               # Assume response is a regular completion.
@@ -151,6 +162,17 @@ def generate_prompt(
 
         bot.reply(context, &buffer_blk)
 
+        # handle edge cases where structured output is all over the place
+        if bad_json
+          helper_response = helper_response.join if helper_response.is_a?(Array)
+          helper_response =
+            DiscourseAi::Utils::BestEffortJsonParser.extract_key(
+              helper_response,
+              schema_type,
+              schema_key,
+            )
+          block.call(helper_response) if block
+        end
         helper_response
       end
 
@@ -255,7 +277,7 @@ def generate_image_caption(upload, user)
           Proc.new do |partial, _, type|
             if type == :structured_output
               structured_output = partial
-              json_summary_schema_key = bot.persona.response_format&.first.to_h
+              bot.persona.response_format&.first.to_h
             end
           end
 
@@ -287,6 +309,11 @@ def build_bot(helper_mode, user)
       end
 
       def find_ai_helper_model(helper_mode, persona_klass)
+        if helper_mode == IMAGE_CAPTION && @image_caption_llm.is_a?(LlmModel)
+          return @image_caption_llm
+        end
+
+        return @helper_llm if helper_mode != IMAGE_CAPTION && @helper_llm.is_a?(LlmModel)
         self.class.find_ai_helper_model(helper_mode, persona_klass)
       end
 
@@ -299,9 +326,9 @@ def self.find_ai_helper_model(helper_mode, persona_klass)
 
         if !model_id
           if helper_mode == IMAGE_CAPTION
-            model_id = @helper_llm || SiteSetting.ai_helper_image_caption_model&.split(":")&.last
+            model_id = SiteSetting.ai_helper_image_caption_model&.split(":")&.last
           else
-            model_id = @image_caption_llm || SiteSetting.ai_helper_model&.split(":")&.last
+            model_id = SiteSetting.ai_helper_model&.split(":")&.last
           end
         end
 

lib/completions/endpoints/gemini.rb

@@ -33,7 +33,8 @@ def normalize_model_params(model_params)
 
           model_params[:topP] = model_params.delete(:top_p) if model_params[:top_p]
 
-          # temperature already supported
+          model_params.delete(:temperature) if llm_model.lookup_custom_param("disable_temperature")
+          model_params.delete(:topP) if llm_model.lookup_custom_param("disable_top_p")
 
           model_params
         end

lib/completions/structured_output.rb

@@ -26,6 +26,10 @@ def <<(raw)
         @partial_json_tracker << raw
       end
 
+      def broken?
+        @partial_json_tracker.broken?
+      end
+
       def read_buffered_property(prop_name)
         # Safeguard: If the model is misbehaving and generating something that's not a JSON,
         # treat response as a normal string.

lib/configuration/feature.rb

@@ -103,6 +103,12 @@ def ai_helper_features
               DiscourseAi::Configuration::Module::AI_HELPER_ID,
               DiscourseAi::Configuration::Module::AI_HELPER,
             ),
+            new(
+              "translator",
+              "ai_helper_translator_persona",
+              DiscourseAi::Configuration::Module::AI_HELPER_ID,
+              DiscourseAi::Configuration::Module::AI_HELPER,
+            ),
             new(
               "custom_prompt",
               "ai_helper_custom_prompt_persona",

lib/personas/translator.rb

@@ -19,11 +19,12 @@ def system_prompt
 
           Format your response as a JSON object with a single key named "output", which has the translation as the value.
           Your output should be in the following format:
-            <output>
-              {"output": "xx"}
-            </output>
+
+          {"output": "xx"}
 
           Where "xx" is replaced by the translation.
+
+          reply with valid JSON only
         PROMPT
       end
 

lib/utils/best_effort_json_parser.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "json"
+
+module DiscourseAi
+  module Utils
+    class BestEffortJsonParser
+      class << self
+        def extract_key(helper_response, schema_type, schema_key)
+          return helper_response unless helper_response.is_a?(String)
+
+          schema_type = schema_type.to_sym
+          schema_key = schema_key&.to_sym
+          cleaned = remove_markdown_fences(helper_response.strip)
+
+          parsed =
+            try_parse(cleaned) || try_parse(fix_common_issues(cleaned)) ||
+              manual_extract(cleaned, schema_key, schema_type)
+
+          value = parsed.is_a?(Hash) ? parsed[schema_key.to_s] : parsed
+          parsed = cast_value(value, schema_type)
+        end
+
+        private
+
+        def remove_markdown_fences(text)
+          return text unless text.match?(/^```(?:json)?\s*\n/i)
+
+          text.gsub(/^```(?:json)?\s*\n/i, "").gsub(/\n```\s*$/, "")
+        end
+
+        def fix_common_issues(text)
+          text.gsub(/(\w+):/, '"\1":').gsub(/'/, "\"")
+        end
+
+        def try_parse(text)
+          JSON.parse(text)
+        rescue JSON::ParserError
+          nil
+        end
+
+        def manual_extract(text, key, schema_type)
+          return default_for(schema_type) unless key
+
+          case schema_type
+          when :object
+            extract_object(text, key.to_s)
+          when :array, :string
+            extract_scalar(text, key.to_s, schema_type)
+          else
+            default_for(schema_type)
+          end
+        end
+
+        def extract_scalar(text, key, schema_type)
+          patterns =
+            if schema_type == :array
+              [
+                /"#{key}"\s*:\s*\[([^\]]+)\]/,
+                /'#{key}'\s*:\s*\[([^\]]+)\]/,
+                /#{key}\s*:\s*\[([^\]]+)\]/,
+              ]
+            else
+              [
+                /"#{key}"\s*:\s*"([^"]+)"/,
+                /'#{key}'\s*:\s*'([^']+)'/,
+                /#{key}\s*:\s*"([^"]+)"/,
+                /#{key}\s*:\s*'([^']+)'/,
+              ]
+            end
+
+          patterns.each do |pattern|
+            match = text.match(pattern)
+            next unless match
+
+            value = match[1]
+            return schema_type == :array ? parse_array(value) : value
+          end
+
+          default_for(schema_type)
+        end
+
+        def parse_array(value)
+          JSON.parse("[#{value}]")
+        rescue JSON::ParserError
+          value.split(",").map { |item| item.strip.gsub(/^['"]|['"]$/, "") }
+        end
+
+        def extract_object(text, key)
+          pattern = /("#{key}"|'#{key}'|#{key})\s*:\s*\{/
+          match = text.match(pattern) or return {}
+
+          start = match.end(0) - 1
+          return {} unless text[start] == "{"
+
+          end_pos = find_matching_brace(text, start)
+          return {} unless end_pos
+
+          obj_str = text[start..end_pos]
+          try_parse(obj_str) || try_parse(fix_common_issues(obj_str)) || {}
+        end
+
+        def find_matching_brace(text, start_pos)
+          brace_count = 0
+
+          text[start_pos..-1].each_char.with_index do |char, idx|
+            brace_count += 1 if char == "{"
+            if char == "}"
+              brace_count -= 1
+              return start_pos + idx if brace_count.zero?
+            end
+          end
+          nil
+        end
+
+        def cast_value(value, schema_type)
+          case schema_type
+          when :array
+            value.is_a?(Array) ? value : []
+          when :object
+            value.is_a?(Hash) ? value : {}
+          else
+            value.to_s
+          end
+        end
+
+        def default_for(schema_type)
+          schema_type == :array ? [] : schema_type == :object ? {} : ""
+        end
+      end
+    end
+  end
+end