DEV: Test if site setting can be added without translation

2024-07-10 13:55:19 +10:00
436 changed files with 10231 additions and 19482 deletions
@@ -1,7 +1,8 @@
-< 3.4.0.beta3-dev: decf1bb49d737ea15308400f22f89d1d1e71d13d
-< 3.4.0.beta1-dev: 9d887ad4ace8e33c3fe7dbb39237e882c08b4f0b
-< 3.3.0.beta5-dev: 4d8090002f6dcd8e34d41033606bf131fa221475
 < 3.3.0.beta2-dev: 61890b667c06299841ae88946f84a112f00060e1
-< 3.3.0.beta1-dev: d94234d89f50733678a5c62809445198a9fda74b
-3.2.999: d94234d89f50733678a5c62809445198a9fda74b
+< 3.3.0.beta1-dev: a65c4076a63104b61d213534db7f89aa3c8acd9e
+< 3.2.0.beta5-dev: c70f43f130fb98e4a1adb1afd9b621aaa49088e3
+< 3.2.0.beta4-dev: 493b48477a9288f2f1b6f021954088705a6673d6
+< 3.2.0.beta2-dev: 3bced1c6f525553fe2b5b79d29bd66c1cf2a47d5
 3.1.999: c0415bb7eb878b1b7abf112d65cba981030df8df
+< 3.2.0.beta1-dev: 3e7c99de894b03e9161d9481da118fe893991a1d
+3.1.0.beta3: 057fbe1ce6
@@ -1,4 +1,3 @@
 node_modules
 /gems
 /auto_generated
-.env
@@ -1,2 +0,0 @@
-engine-strict = true
-auto-install-peers = false
@@ -32,7 +32,8 @@ GEM
    rack (3.1.6)
    rainbow (3.1.1)
    regexp_parser (2.9.2)
-    rexml (3.3.9)
+    rexml (3.3.1)
+      strscan
    rubocop (1.64.1)
      json (~> 2.3)
      language_server-protocol (>= 3.17.0)
@@ -69,6 +70,7 @@ GEM
      rubocop (~> 1.61)
      rubocop-rspec (~> 3, >= 3.0.1)
    ruby-progressbar (1.13.0)
+    strscan (3.1.0)
    syntax_tree (6.2.0)
      prettier_print (>= 1.2.0)
    tzinfo (2.0.6)
@@ -1,13 +1,8 @@
 import DiscourseRoute from "discourse/routes/discourse";

 export default DiscourseRoute.extend({
-  queryParams: {
-    llmTemplate: { refreshModel: true },
-  },
-
  async model() {
    const record = this.store.createRecord("ai-llm");
-    record.provider_params = {};
    return record;
  },

@@ -17,9 +12,5 @@ export default DiscourseRoute.extend({
      "allLlms",
      this.modelFor("adminPlugins.show.discourse-ai-llms")
    );
-    controller.set(
-      "llmTemplate",
-      this.paramsFor(this.routeName).llmTemplate || null
-    );
  },
 });
@@ -4,9 +4,7 @@ export default DiscourseRoute.extend({
  async model(params) {
    const allLlms = this.modelFor("adminPlugins.show.discourse-ai-llms");
    const id = parseInt(params.id, 10);
-    const record = allLlms.findBy("id", id);
-    record.provider_params = record.provider_params || {};
-    return record;
+    return allLlms.findBy("id", id);
  },

  setupController(controller, model) {
@@ -10,8 +10,6 @@ export default DiscourseRoute.extend({
    record.set("rag_chunk_tokens", 374);
    record.set("rag_chunk_overlap_tokens", 10);
    record.set("rag_conversation_chunks", 10);
-    record.set("allow_personal_messages", true);
-    record.set("tool_details", false);
    return record;
  },

@@ -1,5 +1 @@
-<AiLlmsListEditor
-  @llms={{this.allLlms}}
-  @currentLlm={{this.model}}
-  @llmTemplate={{this.llmTemplate}}
-/>
+<AiLlmsListEditor @llms={{this.allLlms}} @currentLlm={{this.model}} />
@@ -14,9 +14,6 @@ module DiscourseAi
                     llms,
                     each_serializer: LlmModelSerializer,
                     root: false,
-                     scope: {
-                       llm_usage: DiscourseAi::Configuration::LlmEnumerator.global_usage,
-                     },
                   ).as_json,
                 meta: {
                   provider_params: LlmModel.provider_params,
@@ -39,34 +36,26 @@ module DiscourseAi
        llm_model = LlmModel.new(ai_llm_params)
        if llm_model.save
          llm_model.toggle_companion_user
-          render json: LlmModelSerializer.new(llm_model), status: :created
+          render json: { ai_persona: LlmModelSerializer.new(llm_model) }, status: :created
        else
-          render_json_error llm_model
+          render_json_error LlmModelSerializer.new(llm_model)
        end
      end

      def update
        llm_model = LlmModel.find(params[:id])

-        if llm_model.seeded?
-          return render_json_error(I18n.t("discourse_ai.llm.cannot_edit_builtin"), status: 403)
-        end
-
        if llm_model.update(ai_llm_params(updating: llm_model))
          llm_model.toggle_companion_user
          render json: LlmModelSerializer.new(llm_model)
        else
-          render_json_error llm_model
+          render_json_error LlmModelSerializer.new(llm_model)
        end
      end

      def destroy
        llm_model = LlmModel.find(params[:id])

-        if llm_model.seeded?
-          return render_json_error(I18n.t("discourse_ai.llm.cannot_delete_builtin"), status: 403)
-        end
-
        in_use_by = DiscourseAi::Configuration::LlmValidator.new.modules_using(llm_model)

        if !in_use_by.empty?
@@ -108,8 +97,6 @@ module DiscourseAi
      private

      def ai_llm_params(updating: nil)
-        return {} if params[:ai_llm].blank?
-
        permitted =
          params.require(:ai_llm).permit(
            :display_name,
@@ -119,30 +106,20 @@ module DiscourseAi
            :max_prompt_tokens,
            :api_key,
            :enabled_chat_bot,
-            :vision_enabled,
          )

        provider = updating ? updating.provider : permitted[:provider]
-        permit_url = provider != LlmModel::BEDROCK_PROVIDER_NAME
+        permit_url =
+          (updating && updating.url != LlmModel::RESERVED_VLLM_SRV_URL) ||
+            provider != LlmModel::BEDROCK_PROVIDER_NAME

-        new_url = params.dig(:ai_llm, :url)
-        permitted[:url] = new_url if permit_url && new_url
+        permitted[:url] = params.dig(:ai_llm, :url) if permit_url

-        extra_field_names = LlmModel.provider_params.dig(provider&.to_sym)
-        if extra_field_names.present?
-          received_prov_params =
-            params.dig(:ai_llm, :provider_params)&.slice(*extra_field_names.keys)
-
-          if received_prov_params.present?
-            received_prov_params.each do |pname, value|
-              if extra_field_names[pname.to_sym] == :checkbox
-                received_prov_params[pname] = ActiveModel::Type::Boolean.new.cast(value)
-              end
-            end
-
-            permitted[:provider_params] = received_prov_params.permit!
-          end
-        end
+        extra_field_names = LlmModel.provider_params.dig(provider&.to_sym, :fields).to_a
+        received_prov_params = params.dig(:ai_llm, :provider_params)
+        permitted[:provider_params] = received_prov_params.slice(
+          *extra_field_names,
+        ).permit! if !extra_field_names.empty? && received_prov_params.present?

        permitted
      end
@@ -5,7 +5,8 @@ module DiscourseAi
    class AiPersonasController < ::Admin::AdminController
      requires_plugin ::DiscourseAi::PLUGIN_NAME

-      before_action :find_ai_persona, only: %i[show update destroy create_user]
+      before_action :find_ai_persona,
+                    only: %i[show update destroy create_user indexing_status_check]

      def index
        ai_personas =
@@ -40,7 +41,7 @@ module DiscourseAi
      def create
        ai_persona = AiPersona.new(ai_persona_params.except(:rag_uploads))
        if ai_persona.save
-          RagDocumentFragment.link_target_and_uploads(ai_persona, attached_upload_ids)
+          RagDocumentFragment.link_persona_and_uploads(ai_persona, attached_upload_ids)

          render json: {
                   ai_persona: LocalizedAiPersonaSerializer.new(ai_persona, root: false),
@@ -58,11 +59,11 @@ module DiscourseAi

      def update
        if @ai_persona.update(ai_persona_params.except(:rag_uploads))
-          RagDocumentFragment.update_target_uploads(@ai_persona, attached_upload_ids)
+          RagDocumentFragment.update_persona_uploads(@ai_persona, attached_upload_ids)

          render json: LocalizedAiPersonaSerializer.new(@ai_persona, root: false)
        else
-          render_json_error @ai_persona
+          render_json_error LocalizedAiPersonaSerializer.new(@ai_persona, root: false)
        end
      end

@@ -70,97 +71,43 @@ module DiscourseAi
        if @ai_persona.destroy
          head :no_content
        else
-          render_json_error @ai_persona
+          render_json_error LocalizedAiPersonaSerializer.new(@ai_persona, root: false)
        end
      end

-      def stream_reply
-        persona =
-          AiPersona.find_by(name: params[:persona_name]) ||
-            AiPersona.find_by(id: params[:persona_id])
-        return render_json_error(I18n.t("discourse_ai.errors.persona_not_found")) if persona.nil?
+      def upload_file
+        file = params[:file] || params[:files].first

-        return render_json_error(I18n.t("discourse_ai.errors.persona_disabled")) if !persona.enabled
-
-        if persona.default_llm.blank?
-          return render_json_error(I18n.t("discourse_ai.errors.no_default_llm"))
+        if !SiteSetting.ai_embeddings_enabled?
+          raise Discourse::InvalidAccess.new("Embeddings not enabled")
        end

-        if params[:query].blank?
-          return render_json_error(I18n.t("discourse_ai.errors.no_query_specified"))
-        end
+        validate_extension!(file.original_filename)
+        validate_file_size!(file.tempfile.size)

-        if !persona.user_id
-          return render_json_error(I18n.t("discourse_ai.errors.no_user_for_persona"))
-        end
+        hijack do
+          upload =
+            UploadCreator.new(
+              file.tempfile,
+              file.original_filename,
+              type: "discourse_ai_rag_upload",
+              skip_validations: true,
+            ).create_for(current_user.id)

-        if !params[:username] && !params[:user_unique_id]
-          return render_json_error(I18n.t("discourse_ai.errors.no_user_specified"))
-        end
-
-        user = nil
-
-        if params[:username]
-          user = User.find_by_username(params[:username])
-          return render_json_error(I18n.t("discourse_ai.errors.user_not_found")) if user.nil?
-        elsif params[:user_unique_id]
-          user = stage_user
-        end
-
-        raise Discourse::NotFound if user.nil?
-
-        topic_id = params[:topic_id].to_i
-        topic = nil
-
-        if topic_id > 0
-          topic = Topic.find(topic_id)
-
-          if topic.topic_allowed_users.where(user_id: user.id).empty?
-            return render_json_error(I18n.t("discourse_ai.errors.user_not_allowed"))
+          if upload.persisted?
+            render json: UploadSerializer.new(upload)
+          else
+            render json: failed_json.merge(errors: upload.errors.full_messages), status: 422
          end
        end
+      end

-        hijack = request.env["rack.hijack"]
-        io = hijack.call
-
-        DiscourseAi::AiBot::ResponseHttpStreamer.queue_streamed_reply(
-          io: io,
-          persona: persona,
-          user: user,
-          topic: topic,
-          query: params[:query].to_s,
-          custom_instructions: params[:custom_instructions].to_s,
-          current_user: current_user,
-        )
+      def indexing_status_check
+        render json: RagDocumentFragment.indexing_status(@ai_persona, @ai_persona.uploads)
      end

      private

-      AI_STREAM_CONVERSATION_UNIQUE_ID = "ai-stream-conversation-unique-id"
-
-      def stage_user
-        unique_id = params[:user_unique_id].to_s
-        field = UserCustomField.find_by(name: AI_STREAM_CONVERSATION_UNIQUE_ID, value: unique_id)
-
-        if field
-          field.user
-        else
-          preferred_username = params[:preferred_username]
-          username = UserNameSuggester.suggest(preferred_username || unique_id)
-
-          user =
-            User.new(
-              username: username,
-              email: "#{SecureRandom.hex}@invalid.com",
-              staged: true,
-              active: false,
-            )
-          user.custom_fields[AI_STREAM_CONVERSATION_UNIQUE_ID] = unique_id
-          user.save!
-          user
-        end
-      end
-
      def find_ai_persona
        @ai_persona = AiPersona.find(params[:id])
      end
@@ -181,6 +128,7 @@ module DiscourseAi
            :temperature,
            :default_llm,
            :user_id,
+            :mentionable,
            :max_context_posts,
            :vision_enabled,
            :vision_max_pixels,
@@ -188,13 +136,8 @@ module DiscourseAi
            :rag_chunk_overlap_tokens,
            :rag_conversation_chunks,
            :question_consolidator_llm,
-            :allow_chat_channel_mentions,
-            :allow_chat_direct_messages,
-            :allow_topic_mentions,
-            :allow_personal_messages,
+            :allow_chat,
            :tool_details,
-            :forced_tool_count,
-            :force_default_llm,
            allowed_group_ids: [],
            rag_uploads: [:id],
          )
@@ -209,12 +152,40 @@ module DiscourseAi
      def permit_tools(tools)
        return [] if !tools.is_a?(Array)

-        tools.filter_map do |tool, options, force_tool|
+        tools.filter_map do |tool, options|
          break nil if !tool.is_a?(String)
          options&.permit! if options && options.is_a?(ActionController::Parameters)

-          # this is simpler from a storage perspective, 1 way to store tools
-          [tool, options, !!force_tool]
+          if options
+            [tool, options]
+          else
+            tool
+          end
+        end
+      end
+
+      def validate_extension!(filename)
+        extension = File.extname(filename)[1..-1] || ""
+        authorized_extensions = %w[txt md]
+        if !authorized_extensions.include?(extension)
+          raise Discourse::InvalidParameters.new(
+                  I18n.t(
+                    "upload.unauthorized",
+                    authorized_extensions: authorized_extensions.join(" "),
+                  ),
+                )
+        end
+      end
+
+      def validate_file_size!(filesize)
+        max_size_bytes = 20.megabytes
+        if filesize > max_size_bytes
+          raise Discourse::InvalidParameters.new(
+                  I18n.t(
+                    "upload.attachments.too_large_humanized",
+                    max_size: ActiveSupport::NumberHelper.number_to_human_size(max_size_bytes),
+                  ),
+                )
        end
      end
    end
@@ -5,7 +5,7 @@ module DiscourseAi
    class AiToolsController < ::Admin::AdminController
      requires_plugin ::DiscourseAi::PLUGIN_NAME

-      before_action :find_ai_tool, only: %i[test show update destroy]
+      before_action :find_ai_tool, only: %i[show update destroy]

      def index
        ai_tools = AiTool.all
@@ -21,7 +21,6 @@ module DiscourseAi
        ai_tool.created_by_id = current_user.id

        if ai_tool.save
-          RagDocumentFragment.link_target_and_uploads(ai_tool, attached_upload_ids)
          render_serialized(ai_tool, AiCustomToolSerializer, status: :created)
        else
          render_json_error ai_tool
@@ -30,7 +29,6 @@ module DiscourseAi

      def update
        if @ai_tool.update(ai_tool_params)
-          RagDocumentFragment.update_target_uploads(@ai_tool, attached_upload_ids)
          render_serialized(@ai_tool, AiCustomToolSerializer)
        else
          render_json_error @ai_tool
@@ -46,13 +44,18 @@ module DiscourseAi
      end

      def test
-        @ai_tool.assign_attributes(ai_tool_params) if params[:ai_tool]
+        if params[:id].present?
+          ai_tool = AiTool.find(params[:id])
+        else
+          ai_tool = AiTool.new(ai_tool_params)
+        end
+
        parameters = params[:parameters].to_unsafe_h

        # we need an llm so we have a tokenizer
        # but will do without if none is available
        llm = LlmModel.first&.to_llm
-        runner = @ai_tool.runner(parameters, llm: llm, bot_user: current_user, context: {})
+        runner = ai_tool.runner(parameters, llm: llm, bot_user: current_user, context: {})
        result = runner.invoke

        if result.is_a?(Hash) && result[:error]
@@ -68,28 +71,18 @@ module DiscourseAi

      private

-      def attached_upload_ids
-        params[:ai_tool][:rag_uploads].to_a.map { |h| h[:id] }
-      end
-
      def find_ai_tool
-        @ai_tool = AiTool.find(params[:id].to_i)
+        @ai_tool = AiTool.find(params[:id])
      end

      def ai_tool_params
-        params
-          .require(:ai_tool)
-          .permit(
-            :name,
-            :description,
-            :script,
-            :summary,
-            :rag_chunk_tokens,
-            :rag_chunk_overlap_tokens,
-            rag_uploads: [:id],
-            parameters: [:name, :type, :description, :required, enum: []],
-          )
-          .except(:rag_uploads)
+        params.require(:ai_tool).permit(
+          :name,
+          :description,
+          :script,
+          :summary,
+          parameters: [:name, :type, :description, :required, :enum, enum_values: []],
+        )
      end
    end
  end
@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module DiscourseAi
-  module Admin
-    class RagDocumentFragmentsController < ::Admin::AdminController
-      requires_plugin ::DiscourseAi::PLUGIN_NAME
-
-      def indexing_status_check
-        if params[:target_type] == "AiPersona"
-          @target = AiPersona.find(params[:target_id])
-        elsif params[:target_type] == "AiTool"
-          @target = AiTool.find(params[:target_id])
-        else
-          raise Discourse::InvalidParameters.new("Invalid target type")
-        end
-
-        render json: RagDocumentFragment.indexing_status(@target, @target.uploads)
-      end
-
-      def upload_file
-        file = params[:file] || params[:files].first
-
-        if !SiteSetting.ai_embeddings_enabled?
-          raise Discourse::InvalidAccess.new("Embeddings not enabled")
-        end
-
-        validate_extension!(file.original_filename)
-        validate_file_size!(file.tempfile.size)
-
-        hijack do
-          upload =
-            UploadCreator.new(
-              file.tempfile,
-              file.original_filename,
-              type: "discourse_ai_rag_upload",
-              skip_validations: true,
-            ).create_for(current_user.id)
-
-          if upload.persisted?
-            render json: UploadSerializer.new(upload)
-          else
-            render json: failed_json.merge(errors: upload.errors.full_messages), status: 422
-          end
-        end
-      end
-
-      private
-
-      def validate_extension!(filename)
-        extension = File.extname(filename)[1..-1] || ""
-        authorized_extensions = %w[txt md]
-        if !authorized_extensions.include?(extension)
-          raise Discourse::InvalidParameters.new(
-                  I18n.t(
-                    "upload.unauthorized",
-                    authorized_extensions: authorized_extensions.join(" "),
-                  ),
-                )
-        end
-      end
-
-      def validate_file_size!(filesize)
-        max_size_bytes = 20.megabytes
-        if filesize > max_size_bytes
-          raise Discourse::InvalidParameters.new(
-                  I18n.t(
-                    "upload.attachments.too_large_humanized",
-                    max_size: ActiveSupport::NumberHelper.number_to_human_size(max_size_bytes),
-                  ),
-                )
-        end
-      end
-    end
-  end
-end
@@ -6,21 +6,10 @@ module DiscourseAi
      requires_plugin ::DiscourseAi::PLUGIN_NAME
      requires_login
      before_action :ensure_can_request_suggestions
-      before_action :rate_limiter_performed!
+      before_action :rate_limiter_performed!, except: %i[prompts]

      include SecureUploadEndpointHelpers

-      RATE_LIMITS = {
-        "default" => {
-          amount: 6,
-          interval: 3.minutes,
-        },
-        "caption_image" => {
-          amount: 20,
-          interval: 1.minute,
-        },
-      }.freeze
-
      def suggest
        input = get_text_param!
        force_default_locale = params[:force_default_locale] || false
@@ -100,26 +89,18 @@ module DiscourseAi
        end
      end

-      def stream_suggestion
+      def explain
        post_id = get_post_param!
-        text = get_text_param!
+        term_to_explain = get_text_param!
        post = Post.includes(:topic).find_by(id: post_id)
-        prompt = CompletionPrompt.find_by(id: params[:mode])

-        raise Discourse::InvalidParameters.new(:mode) if !prompt || !prompt.enabled?
        raise Discourse::InvalidParameters.new(:post_id) unless post

-        if prompt.id == CompletionPrompt::CUSTOM_PROMPT
-          raise Discourse::InvalidParameters.new(:custom_prompt) if params[:custom_prompt].blank?
-        end
-
        Jobs.enqueue(
          :stream_post_helper,
          post_id: post.id,
          user_id: current_user.id,
-          text: text,
-          prompt: prompt.name,
-          custom_prompt: params[:custom_prompt],
+          term_to_explain: term_to_explain,
        )

        render json: { success: true }, status: 200
@@ -172,23 +153,13 @@ module DiscourseAi
      end

      def rate_limiter_performed!
-        action_rate_limit = RATE_LIMITS[action_name] || RATE_LIMITS["default"]
-        RateLimiter.new(
-          current_user,
-          "ai_assistant",
-          action_rate_limit[:amount],
-          action_rate_limit[:interval],
-        ).performed!
+        RateLimiter.new(current_user, "ai_assistant", 6, 3.minutes).performed!
      end

      def ensure_can_request_suggestions
-        allowed_groups =
-          (
-            SiteSetting.composer_ai_helper_allowed_groups_map |
-              SiteSetting.post_ai_helper_allowed_groups_map
-          )
-
-        raise Discourse::InvalidAccess if !current_user.in_any_groups?(allowed_groups)
+        if !current_user.in_any_groups?(SiteSetting.ai_helper_allowed_groups_map)
+          raise Discourse::InvalidAccess
+        end
      end
    end
  end
@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module DiscourseAi
-  module Discord
-    class BotController < ::ApplicationController
-      requires_plugin ::DiscourseAi::PLUGIN_NAME
-
-      skip_before_action :verify_authenticity_token
-
-      def interactions
-        # Request signature verification
-        begin
-          verify_request!
-        rescue Ed25519::VerifyError
-          return head :unauthorized
-        end
-
-        body = request.body.read
-        interaction = JSON.parse(body, object_class: OpenStruct)
-
-        if interaction.type == 1
-          # Respond to Discord PING request
-          render json: { type: 1 }
-        else
-          if !SiteSetting.ai_discord_allowed_guilds_map.include?(interaction.guild_id)
-            return head :forbidden
-          end
-
-          response = { type: 5, data: { content: "Searching..." } }
-          hijack { render json: response }
-
-          # Respond to Discord command
-          Jobs.enqueue(:stream_discord_reply, interaction: body)
-        end
-      end
-
-      private
-
-      def verify_request!
-        signature = request.headers["X-Signature-Ed25519"]
-        timestamp = request.headers["X-Signature-Timestamp"]
-        verify_key.verify([signature].pack("H*"), "#{timestamp}#{request.raw_post}")
-      end
-
-      def verify_key
-        Ed25519::VerifyKey.new([SiteSetting.ai_discord_app_public_key].pack("H*")).freeze
-      end
-    end
-  end
-end
@@ -7,12 +7,8 @@ module DiscourseAi

      SEMANTIC_SEARCH_TYPE = "semantic_search"

-      MAX_HYDE_SEARCHES_PER_MINUTE = 4
-      MAX_SEARCHES_PER_MINUTE = 100
-
      def search
        query = params[:q].to_s
-        skip_hyde = params[:hyde].to_s.downcase == "false" || params[:hyde].to_s == "0"

        if query.length < SiteSetting.min_search_term_length
          raise Discourse::InvalidParameters.new(:q)
@@ -29,25 +25,13 @@ module DiscourseAi

        semantic_search = DiscourseAi::Embeddings::SemanticSearch.new(guardian)

-        if !skip_hyde && !semantic_search.cached_query?(query)
-          RateLimiter.new(
-            current_user,
-            "semantic-search",
-            MAX_HYDE_SEARCHES_PER_MINUTE,
-            1.minutes,
-          ).performed!
-        else
-          RateLimiter.new(
-            current_user,
-            "semantic-search-non-hyde",
-            MAX_SEARCHES_PER_MINUTE,
-            1.minutes,
-          ).performed!
+        if !semantic_search.cached_query?(query)
+          RateLimiter.new(current_user, "semantic-search", 4, 1.minutes).performed!
        end

        hijack do
          semantic_search
-            .search_for_topics(query, _page = 1, hyde: !skip_hyde)
+            .search_for_topics(query)
            .each { |topic_post| grouped_results.add(topic_post) }

          render_serialized(grouped_results, GroupedSearchResultSerializer, result: grouped_results)
@@ -55,9 +39,6 @@ module DiscourseAi
      end

      def quick_search
-        # this search function searches posts (vs: topics)
-        # it requires post embeddings and a reranker
-        # it will not perform a hyde expantion
        query = params[:q].to_s

        if query.length < SiteSetting.min_search_term_length
@@ -15,21 +15,29 @@ module DiscourseAi
        channel = ::Chat::Channel.find(params[:channel_id])
        guardian.ensure_can_join_chat_channel!(channel)

-        summarizer = DiscourseAi::Summarization.chat_channel_summary(channel, since)
-        raise Discourse::NotFound.new unless summarizer
+        strategy = DiscourseAi::Summarization.default_strategy
+        raise Discourse::NotFound.new unless strategy

        guardian.ensure_can_request_summary!

        RateLimiter.new(current_user, "channel_summary", 6, 5.minutes).performed!

        hijack do
-          strategy = DiscourseAi::Summarization::Strategies::ChatMessages.new(channel, since)
+          content = { content_title: channel.name }
+
+          content[:contents] = channel
+            .chat_messages
+            .where("chat_messages.created_at > ?", since.hours.ago)
+            .includes(:user)
+            .order(created_at: :asc)
+            .pluck(:id, :username_lower, :message)
+            .map { { id: _1, poster: _2, text: _3 } }

          summarized_text =
-            if strategy.targets_data.empty?
+            if content[:contents].empty?
              I18n.t("discourse_ai.summarization.chat.no_targets")
            else
-              summarizer.summarize(current_user)&.summarized_text
+              strategy.summarize(content, current_user).dig(:summary)
            end

          render json: { summary: summarized_text }
@@ -14,29 +14,19 @@ module DiscourseAi
        RateLimiter.new(current_user, "summary", 6, 5.minutes).performed! if current_user

        opts = params.permit(:skip_age_check)
-        skip_age_check = opts[:skip_age_check] == "true"
-
-        summarization_service = DiscourseAi::TopicSummarization.for(topic, current_user)

        if params[:stream] && current_user
-          cached_summary = summarization_service.cached_summary
-
-          if cached_summary && !skip_age_check
-            render_serialized(cached_summary, AiTopicSummarySerializer)
-            return
-          end
-
          Jobs.enqueue(
            :stream_topic_ai_summary,
            topic_id: topic.id,
            user_id: current_user.id,
-            skip_age_check: skip_age_check,
+            opts: opts.as_json,
          )

          render json: success_json
        else
          hijack do
-            summary = summarization_service.summarize(skip_age_check: skip_age_check)
+            summary = DiscourseAi::TopicSummarization.summarize(topic, current_user, opts)
            render_serialized(summary, AiTopicSummarySerializer)
          end
        end
@@ -9,24 +9,17 @@ module ::Jobs
    # TODO(roman): Add a way to automatically recover from errors, resulting in unindexed uploads.
    def execute(args)
      return if (upload = Upload.find_by(id: args[:upload_id])).nil?
-
-      target_type = args[:target_type]
-      target_id = args[:target_id]
-
-      return if !target_type || !target_id
-
-      target = target_type.constantize.find_by(id: target_id)
-      return if !target
+      return if (ai_persona = AiPersona.find_by(id: args[:ai_persona_id])).nil?

      truncation = DiscourseAi::Embeddings::Strategies::Truncation.new
      vector_rep =
        DiscourseAi::Embeddings::VectorRepresentations::Base.current_representation(truncation)

      tokenizer = vector_rep.tokenizer
-      chunk_tokens = target.rag_chunk_tokens
-      overlap_tokens = target.rag_chunk_overlap_tokens
+      chunk_tokens = ai_persona.rag_chunk_tokens
+      overlap_tokens = ai_persona.rag_chunk_overlap_tokens

-      fragment_ids = RagDocumentFragment.where(target: target, upload: upload).pluck(:id)
+      fragment_ids = RagDocumentFragment.where(ai_persona: ai_persona, upload: upload).pluck(:id)

      # Check if this is the first time we process this upload.
      if fragment_ids.empty?
@@ -46,7 +39,7 @@ module ::Jobs
            overlap_tokens: overlap_tokens,
          ) do |chunk, metadata|
            fragment_ids << RagDocumentFragment.create!(
-              target: target,
+              ai_persona: ai_persona,
              fragment: chunk,
              fragment_number: idx + 1,
              upload: upload,
@@ -126,9 +119,7 @@ module ::Jobs

        while overlap_token_ids.present?
          begin
-            padding = split_char
-            padding = " " if padding.empty?
-            overlap = tokenizer.decode(overlap_token_ids) + padding
+            overlap = tokenizer.decode(overlap_token_ids) + split_char
            break if overlap.encoding == Encoding::UTF_8
          rescue StandardError
            # it is possible that we truncated mid char
@@ -137,7 +128,7 @@ module ::Jobs
        end

        # remove first word it is probably truncated
-        overlap = overlap.split(/\s/, 2).last.to_s.lstrip
+        overlap = overlap.split(" ", 2).last
      end
    end

@@ -17,10 +17,10 @@ module ::Jobs
      fragments.map { |fragment| vector_rep.generate_representation_from(fragment) }

      last_fragment = fragments.last
-      target = last_fragment.target
+      ai_persona = last_fragment.ai_persona
      upload = last_fragment.upload

-      indexing_status = RagDocumentFragment.indexing_status(target, [upload])[upload.id]
+      indexing_status = RagDocumentFragment.indexing_status(ai_persona, [upload])[upload.id]
      RagDocumentFragment.publish_status(upload, indexing_status)
    end
  end
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module ::Jobs
-  class HotTopicsGistBatch < ::Jobs::Base
-    def execute(_args)
-      return if !SiteSetting.discourse_ai_enabled
-      return if !SiteSetting.ai_summarization_enabled
-      return if SiteSetting.ai_summarize_max_hot_topics_gists_per_batch.zero?
-
-      Topic
-        .joins("JOIN topic_hot_scores on topics.id = topic_hot_scores.topic_id")
-        .order("topic_hot_scores.score DESC")
-        .limit(SiteSetting.ai_summarize_max_hot_topics_gists_per_batch)
-        .each do |topic|
-          summarizer = DiscourseAi::Summarization.topic_gist(topic)
-          gist = summarizer.existing_summary
-
-          summarizer.force_summarize(Discourse.system_user) if gist.blank? || gist.outdated
-        end
-    end
-  end
-end
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Jobs
-  class StreamDiscordReply < ::Jobs::Base
-    sidekiq_options retry: false
-
-    def execute(args)
-      interaction = args[:interaction]
-
-      if SiteSetting.ai_discord_search_mode == "persona"
-        DiscourseAi::Discord::Bot::PersonaReplier.new(interaction).handle_interaction!
-      else
-        DiscourseAi::Discord::Bot::Search.new(interaction).handle_interaction!
-      end
-    end
-  end
-end
@@ -7,35 +7,27 @@ module Jobs
    def execute(args)
      return unless post = Post.includes(:topic).find_by(id: args[:post_id])
      return unless user = User.find_by(id: args[:user_id])
-      return unless args[:text]
+      return unless args[:term_to_explain]

      topic = post.topic
      reply_to = post.reply_to_post

      return unless user.guardian.can_see?(post)

-      prompt = CompletionPrompt.enabled_by_name(args[:prompt])
+      prompt = CompletionPrompt.enabled_by_name("explain")

-      if prompt.id == CompletionPrompt::CUSTOM_PROMPT
-        prompt.custom_instruction = args[:custom_prompt]
-      end
-
-      if prompt.name == "explain"
-        input = <<~TEXT
-      <term>#{args[:text]}</term>
+      input = <<~TEXT
+      <term>#{args[:term_to_explain]}</term>
      <context>#{post.raw}</context>
          <topic>#{topic.title}</topic>
          #{reply_to ? "<replyTo>#{reply_to.raw}</replyTo>" : nil}
        TEXT
-      else
-        input = args[:text]
-      end

      DiscourseAi::AiHelper::Assistant.new.stream_prompt(
        prompt,
        input,
        user,
-        "/discourse-ai/ai-helper/stream_suggestion/#{post.id}",
+        "/discourse-ai/ai-helper/explain/#{post.id}",
      )
    end
  end
@@ -8,25 +8,25 @@ module Jobs
      return unless topic = Topic.find_by(id: args[:topic_id])
      return unless user = User.find_by(id: args[:user_id])

-      strategy = DiscourseAi::Summarization.topic_summary(topic)
+      strategy = DiscourseAi::Summarization.default_strategy
      return if strategy.nil? || !Guardian.new(user).can_see_summary?(topic)

      guardian = Guardian.new(user)
      return unless guardian.can_see?(topic)

-      skip_age_check = !!args[:skip_age_check]
+      opts = args[:opts] || {}

      streamed_summary = +""
      start = Time.now

      summary =
        DiscourseAi::TopicSummarization
-          .new(strategy, user)
-          .summarize(skip_age_check: skip_age_check) do |partial_summary|
+          .new(strategy)
+          .summarize(topic, user, opts) do |partial_summary|
            streamed_summary << partial_summary

            # Throttle updates.
-            if (Time.now - start > 0.3) || Rails.env.test?
+            if (Time.now - start > 0.5) || Rails.env.test?
              payload = { done: false, ai_topic_summary: { summarized_text: streamed_summary } }

              publish_update(topic, user, payload)
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ::Jobs
+  class UpdateAiBotPmTitle < ::Jobs::Base
+    sidekiq_options retry: false
+
+    def execute(args)
+      return unless bot_user = User.find_by(id: args[:bot_user_id])
+      return unless bot = DiscourseAi::AiBot::Bot.as(bot_user, model: args[:model])
+      return unless post = Post.includes(:topic).find_by(id: args[:post_id])
+
+      return unless post.topic.custom_fields[DiscourseAi::AiBot::EntryPoint::REQUIRE_TITLE_UPDATE]
+
+      DiscourseAi::AiBot::Playground.new(bot).title_playground(post)
+    end
+  end
+end
@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module ::Jobs
-  class UpdateHotTopicGist < ::Jobs::Base
-    sidekiq_options retry: false
-
-    def execute(args)
-      return if !SiteSetting.discourse_ai_enabled
-      return if !SiteSetting.ai_summarization_enabled
-      return if SiteSetting.ai_summarize_max_hot_topics_gists_per_batch.zero?
-
-      topic = Topic.find_by(id: args[:topic_id])
-      return if topic.blank?
-
-      return if !TopicHotScore.where(topic: topic).exists?
-
-      summarizer = DiscourseAi::Summarization.topic_gist(topic)
-      gist = summarizer.existing_summary
-      return if gist.blank?
-      return if !gist.outdated
-
-      summarizer.force_summarize(Discourse.system_user)
-    end
-  end
-end
@@ -35,6 +35,8 @@ module Jobs

      rebaked += populate_topic_embeddings(vector_rep, topics)

+      vector_rep.consider_indexing
+
      return if rebaked >= limit

      # Then, we'll try to backfill embeddings for topics that have outdated
@@ -52,12 +54,9 @@ module Jobs
      # Finally, we'll try to backfill embeddings for topics that have outdated
      # embeddings due to edits or new replies. Here we only do 10% of the limit
      relation =
-        topics
-          .where("#{table_name}.updated_at < ?", 6.hours.ago)
-          .where("#{table_name}.updated_at < topics.updated_at")
-          .limit((limit - rebaked) / 10)
+        topics.where("#{table_name}.updated_at < ?", 7.days.ago).limit((limit - rebaked) / 10)

-      populate_topic_embeddings(vector_rep, relation, force: true)
+      populate_topic_embeddings(vector_rep, relation)

      return if rebaked >= limit

@@ -80,6 +79,8 @@ module Jobs
          rebaked += 1
        end

+      vector_rep.consider_indexing
+
      return if rebaked >= limit

      # Then, we'll try to backfill embeddings for posts that have outdated
@@ -114,12 +115,9 @@ module Jobs

    private

-    def populate_topic_embeddings(vector_rep, topics, force: false)
+    def populate_topic_embeddings(vector_rep, topics)
      done = 0
-
-      topics = topics.where("#{vector_rep.topic_table_name}.topic_id IS NULL") if !force
-
-      ids = topics.pluck("topics.id")
+      ids = topics.where("#{vector_rep.topic_table_name}.topic_id IS NULL").pluck("topics.id")

      ids.each do |id|
        topic = Topic.find_by(id: id)
@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module ::Jobs
-  class SummariesBackfill < ::Jobs::Scheduled
-    every 5.minutes
-    cluster_concurrency 1
-
-    def execute(_args)
-      return if !SiteSetting.discourse_ai_enabled
-      return if !SiteSetting.ai_summarization_enabled
-      return if SiteSetting.ai_summary_backfill_maximum_topics_per_hour.zero?
-
-      system_user = Discourse.system_user
-
-      complete_t = AiSummary.summary_types[:complete]
-      backfill_candidates(complete_t)
-        .limit(current_budget(complete_t))
-        .each do |topic|
-          DiscourseAi::Summarization.topic_summary(topic).force_summarize(system_user)
-        end
-
-      gist_t = AiSummary.summary_types[:gist]
-      backfill_candidates(gist_t)
-        .limit(current_budget(gist_t))
-        .each { |topic| DiscourseAi::Summarization.topic_gist(topic).force_summarize(system_user) }
-    end
-
-    def backfill_candidates(summary_type)
-      Topic
-        .where("topics.word_count >= ?", SiteSetting.ai_summary_backfill_minimum_word_count)
-        .joins(<<~SQL)
-          LEFT OUTER JOIN ai_summaries ais ON 
-                          topics.id = ais.target_id AND 
-                          ais.target_type = 'Topic' AND 
-                          ais.summary_type = '#{summary_type}'
-        SQL
-        .where(
-          "ais.id IS NULL OR UPPER(ais.content_range) < topics.highest_post_number + 1",
-        ) # (1..1) gets stored ad (1..2).
-        .order("ais.created_at DESC NULLS FIRST, topics.last_posted_at DESC")
-    end
-
-    def current_budget(type)
-      # Split budget in 12 intervals, but make sure is at least one.
-      base_budget = SiteSetting.ai_summary_backfill_maximum_topics_per_hour
-      limit_per_job = [base_budget, 12].max / 12
-
-      used_budget =
-        AiSummary.system.where("created_at > ?", 1.hour.ago).where(summary_type: type).count
-
-      current_budget = [(base_budget - used_budget), limit_per_job].min
-      return 0 if current_budget < 0
-
-      current_budget
-    end
-  end
-end
@@ -12,7 +12,6 @@ class AiApiAuditLog < ActiveRecord::Base
    Vllm = 5
    Cohere = 6
    Ollama = 7
-    SambaNova = 8
  end
 end

@@ -33,4 +32,4 @@ end
 #  post_id              :integer
 #  feature_name         :string(255)
 #  language_model       :string(255)
-#  feature_context      :jsonb
+#
@@ -1,8 +1,8 @@
 # frozen_string_literal: true

 class AiPersona < ActiveRecord::Base
-  # TODO remove this line 01-1-2025
-  self.ignored_columns = %i[commands allow_chat mentionable]
+  # TODO remove this line 01-11-2024
+  self.ignored_columns = [:commands]

  # places a hard limit, so per site we cache a maximum of 500 classes
  MAX_PERSONAS_PER_SITE = 500
@@ -20,8 +20,6 @@ class AiPersona < ActiveRecord::Base
  validates :rag_chunk_tokens, numericality: { greater_than: 0, maximum: 50_000 }
  validates :rag_chunk_overlap_tokens, numericality: { greater_than: -1, maximum: 200 }
  validates :rag_conversation_chunks, numericality: { greater_than: 0, maximum: 1000 }
-  validates :forced_tool_count, numericality: { greater_than: -2, maximum: 100_000 }
-  has_many :rag_document_fragments, dependent: :destroy, as: :target

  belongs_to :created_by, class_name: "User"
  belongs_to :user
@@ -29,7 +27,12 @@ class AiPersona < ActiveRecord::Base
  has_many :upload_references, as: :target, dependent: :destroy
  has_many :uploads, through: :upload_references

+  has_many :rag_document_fragment, dependent: :destroy
+
+  has_many :rag_document_fragments, through: :ai_persona_rag_document_fragments
+
  before_destroy :ensure_not_system
+
  before_update :regenerate_rag_fragments

  def self.persona_cache
@@ -52,47 +55,30 @@ class AiPersona < ActiveRecord::Base
      persona_cache[:persona_users] ||= AiPersona
        .where(enabled: true)
        .joins(:user)
-        .map do |persona|
+        .pluck(
+          "ai_personas.id, users.id, users.username_lower, allowed_group_ids, default_llm, mentionable, allow_chat",
+        )
+        .map do |id, user_id, username, allowed_group_ids, default_llm, mentionable, allow_chat|
          {
-            id: persona.id,
-            user_id: persona.user_id,
-            username: persona.user.username_lower,
-            allowed_group_ids: persona.allowed_group_ids,
-            default_llm: persona.default_llm,
-            force_default_llm: persona.force_default_llm,
-            allow_chat_channel_mentions: persona.allow_chat_channel_mentions,
-            allow_chat_direct_messages: persona.allow_chat_direct_messages,
-            allow_topic_mentions: persona.allow_topic_mentions,
-            allow_personal_messages: persona.allow_personal_messages,
+            id: id,
+            user_id: user_id,
+            username: username,
+            allowed_group_ids: allowed_group_ids,
+            default_llm: default_llm,
+            mentionable: mentionable,
+            allow_chat: allow_chat,
          }
        end

    if user
-      persona_users.select { |persona_user| user.in_any_groups?(persona_user[:allowed_group_ids]) }
+      persona_users.select { |mentionable| user.in_any_groups?(mentionable[:allowed_group_ids]) }
    else
      persona_users
    end
  end

-  def self.allowed_modalities(
-    user: nil,
-    allow_chat_channel_mentions: false,
-    allow_chat_direct_messages: false,
-    allow_topic_mentions: false,
-    allow_personal_messages: false
-  )
-    index =
-      "modality-#{allow_chat_channel_mentions}-#{allow_chat_direct_messages}-#{allow_topic_mentions}-#{allow_personal_messages}"
-
-    personas =
-      persona_cache[index.to_sym] ||= persona_users.select do |persona|
-        next true if allow_chat_channel_mentions && persona[:allow_chat_channel_mentions]
-        next true if allow_chat_direct_messages && persona[:allow_chat_direct_messages]
-        next true if allow_topic_mentions && persona[:allow_topic_mentions]
-        next true if allow_personal_messages && persona[:allow_personal_messages]
-        false
-      end
-
+  def self.allowed_chat(user: nil)
+    personas = persona_cache[:allowed_chat] ||= persona_users.select { |u| u[:allow_chat] }
    if user
      personas.select { |u| user.in_any_groups?(u[:allowed_group_ids]) }
    else
@@ -100,6 +86,18 @@ class AiPersona < ActiveRecord::Base
    end
  end

+  def self.mentionables(user: nil)
+    all_mentionables =
+      persona_cache[:mentionables] ||= persona_users.select do |mentionable|
+        mentionable[:mentionable]
+      end
+    if user
+      all_mentionables.select { |mentionable| user.in_any_groups?(mentionable[:allowed_group_ids]) }
+    else
+      all_mentionables
+    end
+  end
+
  after_commit :bump_cache

  def bump_cache
@@ -118,11 +116,7 @@ class AiPersona < ActiveRecord::Base
      vision_max_pixels
      rag_conversation_chunks
      question_consolidator_llm
-      allow_chat_channel_mentions
-      allow_chat_direct_messages
-      allow_topic_mentions
-      allow_personal_messages
-      force_default_llm
+      allow_chat
      name
      description
      allowed_group_ids
@@ -137,8 +131,6 @@ class AiPersona < ActiveRecord::Base
      instance_attributes[attr] = value
    end

-    instance_attributes[:username] = user&.username_lower
-
    if persona_class
      instance_attributes.each do |key, value|
        # description/name are localized
@@ -148,23 +140,17 @@ class AiPersona < ActiveRecord::Base
    end

    options = {}
-    force_tool_use = []
-
    tools =
      self.tools.filter_map do |element|
        klass = nil

-        element = [element] if element.is_a?(String)
-
-        inner_name, current_options, should_force_tool_use =
-          element.is_a?(Array) ? element : [element, nil]
-
-        if inner_name.start_with?("custom-")
-          custom_tool_id = inner_name.split("-", 2).last.to_i
+        if element.is_a?(String) && element.start_with?("custom-")
+          custom_tool_id = element.split("-", 2).last.to_i
          if AiTool.exists?(id: custom_tool_id, enabled: true)
            klass = DiscourseAi::AiBot::Tools::Custom.class_instance(custom_tool_id)
          end
        else
+          inner_name, current_options = element.is_a?(Array) ? element : [element, nil]
          inner_name = inner_name.gsub("Tool", "")
          inner_name = "List#{inner_name}" if %w[Categories Tags].include?(inner_name)

@@ -173,10 +159,9 @@ class AiPersona < ActiveRecord::Base
            options[klass] = current_options if current_options
          rescue StandardError
          end
-        end

-        force_tool_use << klass if should_force_tool_use
-        klass
+          klass
+        end
      end

    ai_persona_id = self.id
@@ -196,8 +181,6 @@ class AiPersona < ActiveRecord::Base
      end

      define_method(:tools) { tools }
-      define_method(:force_tool_use) { force_tool_use }
-      define_method(:forced_tool_count) { @ai_persona&.forced_tool_count }
      define_method(:options) { options }
      define_method(:temperature) { @ai_persona&.temperature }
      define_method(:top_p) { @ai_persona&.top_p }
@@ -247,17 +230,14 @@ class AiPersona < ActiveRecord::Base

  def regenerate_rag_fragments
    if rag_chunk_tokens_changed? || rag_chunk_overlap_tokens_changed?
-      RagDocumentFragment.where(target: self).delete_all
+      RagDocumentFragment.where(ai_persona: self).delete_all
    end
  end

  private

  def chat_preconditions
-    if (
-         allow_chat_channel_mentions || allow_chat_direct_messages || allow_topic_mentions ||
-           force_default_llm
-       ) && !default_llm
+    if allow_chat && !default_llm
      errors.add(:default_llm, I18n.t("discourse_ai.ai_bot.personas.default_llm_required"))
    end
  end
@@ -281,36 +261,32 @@ end
 #
 # Table name: ai_personas
 #
-#  id                          :bigint           not null, primary key
-#  name                        :string(100)      not null
-#  description                 :string(2000)     not null
-#  system_prompt               :string(10000000) not null
-#  allowed_group_ids           :integer          default([]), not null, is an Array
-#  created_by_id               :integer
-#  enabled                     :boolean          default(TRUE), not null
-#  created_at                  :datetime         not null
-#  updated_at                  :datetime         not null
-#  system                      :boolean          default(FALSE), not null
-#  priority                    :boolean          default(FALSE), not null
-#  temperature                 :float
-#  top_p                       :float
-#  user_id                     :integer
-#  default_llm                 :text
-#  max_context_posts           :integer
-#  vision_enabled              :boolean          default(FALSE), not null
-#  vision_max_pixels           :integer          default(1048576), not null
-#  rag_chunk_tokens            :integer          default(374), not null
-#  rag_chunk_overlap_tokens    :integer          default(10), not null
-#  rag_conversation_chunks     :integer          default(10), not null
-#  question_consolidator_llm   :text
-#  tool_details                :boolean          default(TRUE), not null
-#  tools                       :json             not null
-#  forced_tool_count           :integer          default(-1), not null
-#  allow_chat_channel_mentions :boolean          default(FALSE), not null
-#  allow_chat_direct_messages  :boolean          default(FALSE), not null
-#  allow_topic_mentions        :boolean          default(FALSE), not null
-#  allow_personal_messages     :boolean          default(TRUE), not null
-#  force_default_llm           :boolean          default(FALSE), not null
+#  id                        :bigint           not null, primary key
+#  name                      :string(100)      not null
+#  description               :string(2000)     not null
+#  system_prompt             :string(10000000) not null
+#  allowed_group_ids         :integer          default([]), not null, is an Array
+#  created_by_id             :integer
+#  enabled                   :boolean          default(TRUE), not null
+#  created_at                :datetime         not null
+#  updated_at                :datetime         not null
+#  system                    :boolean          default(FALSE), not null
+#  priority                  :boolean          default(FALSE), not null
+#  temperature               :float
+#  top_p                     :float
+#  user_id                   :integer
+#  mentionable               :boolean          default(FALSE), not null
+#  default_llm               :text
+#  max_context_posts         :integer
+#  vision_enabled            :boolean          default(FALSE), not null
+#  vision_max_pixels         :integer          default(1048576), not null
+#  rag_chunk_tokens          :integer          default(374), not null
+#  rag_chunk_overlap_tokens  :integer          default(10), not null
+#  rag_conversation_chunks   :integer          default(10), not null
+#  question_consolidator_llm :text
+#  allow_chat                :boolean          default(FALSE), not null
+#  tool_details              :boolean          default(TRUE), not null
+#  tools                     :json             not null
 #
 # Indexes
 #
@@ -3,27 +3,6 @@
 class AiSummary < ActiveRecord::Base
  belongs_to :target, polymorphic: true

-  enum :summary_type, { complete: 0, gist: 1 }
-  enum :origin, { human: 0, system: 1 }
-
-  def self.store!(strategy, llm_model, summary, og_content, human:)
-    content_ids = og_content.map { |c| c[:id] }
-
-    AiSummary.create!(
-      target: strategy.target,
-      algorithm: llm_model.name,
-      content_range: (content_ids.first..content_ids.last),
-      summarized_text: summary,
-      original_content_sha: build_sha(content_ids.join),
-      summary_type: strategy.type,
-      origin: !!human ? origins[:human] : origins[:system],
-    )
-  end
-
-  def self.build_sha(joined_ids)
-    Digest::SHA256.hexdigest(joined_ids)
-  end
-
  def mark_as_outdated
    @outdated = true
  end
@@ -46,8 +25,6 @@ end
 #  algorithm            :string           not null
 #  created_at           :datetime         not null
 #  updated_at           :datetime         not null
-#  summary_type         :integer          default("complete"), not null
-#  origin               :integer
 #
 # Indexes
 #
--- a/Show More
+++ b/Show More