Fix lib directory

- adds `lib/` autoloading (and removes the plugin.rb workaround)
- adds eager loading of scheduled jobs in development (otherwise they don't work at all)

.discourse-compatibility

@@ -1,3 +1,4 @@
+< 3.3.0.beta1-dev: a65c4076a63104b61d213534db7f89aa3c8acd9e
 < 3.2.0.beta5-dev: c70f43f130fb98e4a1adb1afd9b621aaa49088e3
 < 3.2.0.beta4-dev: 493b48477a9288f2f1b6f021954088705a6673d6
 < 3.2.0.beta2-dev: 3bced1c6f525553fe2b5b79d29bd66c1cf2a47d5

Gemfile.lock

@@ -1,11 +1,30 @@
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (7.1.3.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
     ast (2.4.2)
+    base64 (0.2.0)
+    bigdecimal (3.1.6)
+    concurrent-ruby (1.2.3)
+    connection_pool (2.4.1)
+    drb (2.2.1)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
     json (2.7.1)
     language_server-protocol (3.17.0.3)
+    minitest (5.22.2)
+    mutex_m (0.2.0)
     parallel (1.24.0)
-    parser (3.3.0.3)
+    parser (3.3.0.5)
       ast (~> 2.4.1)
       racc
     prettier_print (1.2.1)
@@ -13,33 +32,38 @@ GEM
     rainbow (3.1.1)
     regexp_parser (2.9.0)
     rexml (3.2.6)
-    rubocop (1.59.0)
+    rubocop (1.61.0)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
-      parser (>= 3.2.2.4)
+      parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
       rubocop-ast (>= 1.30.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.30.0)
-      parser (>= 3.2.1.0)
+    rubocop-ast (1.31.1)
+      parser (>= 3.3.0.4)
     rubocop-capybara (2.20.0)
       rubocop (~> 1.41)
-    rubocop-discourse (3.6.0)
+    rubocop-discourse (3.7.1)
+      activesupport (>= 6.1)
       rubocop (>= 1.59.0)
+      rubocop-capybara (>= 2.0.0)
+      rubocop-factory_bot (>= 2.0.0)
       rubocop-rspec (>= 2.25.0)
     rubocop-factory_bot (2.25.1)
       rubocop (~> 1.41)
-    rubocop-rspec (2.26.1)
+    rubocop-rspec (2.27.1)
       rubocop (~> 1.40)
       rubocop-capybara (~> 2.17)
       rubocop-factory_bot (~> 2.22)
     ruby-progressbar (1.13.0)
     syntax_tree (6.2.0)
       prettier_print (>= 1.2.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
     unicode-display_width (2.5.0)
 
 PLATFORMS

admin/assets/javascripts/discourse/routes/admin-plugins-show-discourse-ai-personas-new.js

@@ -0,0 +1,23 @@
+import { AUTO_GROUPS } from "discourse/lib/constants";
+import DiscourseRoute from "discourse/routes/discourse";
+
+export default DiscourseRoute.extend({
+  async model() {
+    const record = this.store.createRecord("ai-persona");
+    record.set("allowed_group_ids", [AUTO_GROUPS.trust_level_0.id]);
+    record.set("rag_uploads", []);
+    // these match the defaults on the table
+    record.set("rag_chunk_tokens", 374);
+    record.set("rag_chunk_overlap_tokens", 10);
+    record.set("rag_conversation_chunks", 10);
+    return record;
+  },
+
+  setupController(controller, model) {
+    this._super(controller, model);
+    controller.set(
+      "allPersonas",
+      this.modelFor("adminPlugins.show.discourse-ai-personas")
+    );
+  },
+});

admin/assets/javascripts/discourse/routes/admin-plugins-show-discourse-ai-personas-show.js

@@ -2,7 +2,9 @@ import DiscourseRoute from "discourse/routes/discourse";
 
 export default DiscourseRoute.extend({
   async model(params) {
-    const allPersonas = this.modelFor("adminPlugins.discourse-ai.ai-personas");
+    const allPersonas = this.modelFor(
+      "adminPlugins.show.discourse-ai-personas"
+    );
     const id = parseInt(params.id, 10);
     return allPersonas.findBy("id", id);
   },
@@ -11,7 +13,7 @@ export default DiscourseRoute.extend({
     this._super(controller, model);
     controller.set(
       "allPersonas",
-      this.modelFor("adminPlugins.discourse-ai.ai-personas")
+      this.modelFor("adminPlugins.show.discourse-ai-personas")
     );
   },
 });

admin/assets/javascripts/discourse/routes/admin-plugins-show-discourse-ai-personas.js

@@ -1,7 +1,7 @@
 import DiscourseRoute from "discourse/routes/discourse";
 
-export default DiscourseRoute.extend({
-  async model() {
+export default class DiscourseAiAiPersonasRoute extends DiscourseRoute {
+  model() {
     return this.store.findAll("ai-persona");
-  },
-});
+  }
+}

app/controllers/discourse_ai/admin/ai_personas_controller.rb

@@ -3,7 +3,10 @@
 module DiscourseAi
   module Admin
     class AiPersonasController < ::Admin::AdminController
-      before_action :find_ai_persona, only: %i[show update destroy create_user]
+      requires_plugin ::DiscourseAi::PLUGIN_NAME
+
+      before_action :find_ai_persona,
+                    only: %i[show update destroy create_user indexing_status_check]
 
       def index
         ai_personas =
@@ -28,8 +31,10 @@ module DiscourseAi
       end
 
       def create
-        ai_persona = AiPersona.new(ai_persona_params)
+        ai_persona = AiPersona.new(ai_persona_params.except(:rag_uploads))
         if ai_persona.save
+          RagDocumentFragment.link_persona_and_uploads(ai_persona, attached_upload_ids)
+
           render json: { ai_persona: ai_persona }, status: :created
         else
           render_json_error ai_persona
@@ -42,7 +47,9 @@ module DiscourseAi
       end
 
       def update
-        if @ai_persona.update(ai_persona_params)
+        if @ai_persona.update(ai_persona_params.except(:rag_uploads))
+          RagDocumentFragment.update_persona_uploads(@ai_persona, attached_upload_ids)
+
           render json: @ai_persona
         else
           render_json_error @ai_persona
@@ -57,12 +64,47 @@ module DiscourseAi
         end
       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
+
+      def indexing_status_check
+        render json: RagDocumentFragment.indexing_status(@ai_persona, @ai_persona.uploads)
+      end
+
       private
 
       def find_ai_persona
         @ai_persona = AiPersona.find(params[:id])
       end
 
+      def attached_upload_ids
+        ai_persona_params[:rag_uploads].to_a.map { |h| h[:id] }
+      end
+
       def ai_persona_params
         permitted =
           params.require(:ai_persona).permit(
@@ -77,7 +119,14 @@ module DiscourseAi
             :user_id,
             :mentionable,
             :max_context_posts,
+            :vision_enabled,
+            :vision_max_pixels,
+            :rag_chunk_tokens,
+            :rag_chunk_overlap_tokens,
+            :rag_conversation_chunks,
+            :question_consolidator_llm,
             allowed_group_ids: [],
+            rag_uploads: [:id],
           )
 
         if commands = params.dig(:ai_persona, :commands)
@@ -101,6 +150,31 @@ module DiscourseAi
           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
   end
 end

app/controllers/discourse_ai/ai_bot/bot_controller.rb

@@ -6,6 +6,21 @@ module DiscourseAi
       requires_plugin ::DiscourseAi::PLUGIN_NAME
       requires_login
 
+      def show_debug_info
+        post = Post.find(params[:post_id])
+        guardian.ensure_can_debug_ai_bot_conversation!(post)
+
+        posts =
+          Post
+            .where("post_number <= ?", post.post_number)
+            .where(topic_id: post.topic_id)
+            .order("post_number DESC")
+
+        debug_info = AiApiAuditLog.where(post: posts).order(created_at: :desc).first
+
+        render json: debug_info, status: 200
+      end
+
       def stop_streaming_response
         post = Post.find(params[:post_id])
         guardian.ensure_can_see!(post)

app/controllers/discourse_ai/ai_bot/shared_ai_conversations_controller.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module DiscourseAi
+  module AiBot
+    class SharedAiConversationsController < ::ApplicationController
+      requires_plugin ::DiscourseAi::PLUGIN_NAME
+      requires_login only: %i[create update destroy]
+      before_action :require_site_settings!
+
+      skip_before_action :preload_json, :check_xhr, :redirect_to_login_if_required, only: %i[show]
+
+      def create
+        ensure_allowed_create!
+
+        RateLimiter.new(current_user, "share-ai-conversation", 10, 1.minute).performed!
+
+        shared_conversation = SharedAiConversation.share_conversation(current_user, @topic)
+
+        if shared_conversation.persisted?
+          render json: success_json.merge(share_key: shared_conversation.share_key)
+        else
+          render json: failed_json.merge(error: I18n.t("discourse_ai.share_ai.failed_to_share")),
+                 status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        ensure_allowed_destroy!
+
+        SharedAiConversation.destroy_conversation(@shared_conversation)
+
+        render json:
+                 success_json.merge(message: I18n.t("discourse_ai.share_ai.conversation_deleted"))
+      end
+
+      def show
+        @shared_conversation = SharedAiConversation.find_by(share_key: params[:share_key])
+        raise Discourse::NotFound if @shared_conversation.blank?
+
+        expires_in 1.minute, public: true
+        response.headers["X-Robots-Tag"] = "noindex"
+
+        if request.format.json?
+          render json: success_json.merge(@shared_conversation.to_json)
+        else
+          render "show", layout: false
+        end
+      end
+
+      def preview
+        ensure_allowed_preview!
+        data = SharedAiConversation.build_conversation_data(@topic, include_usernames: true)
+        data[:error] = @error if @error
+        data[:share_key] = @shared_conversation.share_key if @shared_conversation
+        data[:topic_id] = @topic.id
+        render json: data
+      end
+
+      private
+
+      def require_site_settings!
+        if !SiteSetting.discourse_ai_enabled ||
+             !SiteSetting.ai_bot_public_sharing_allowed_groups_map.any? ||
+             !SiteSetting.ai_bot_enabled
+          raise Discourse::NotFound
+        end
+      end
+
+      def ensure_allowed_preview!
+        @topic = Topic.find_by(id: params[:topic_id])
+        raise Discourse::NotFound if !@topic
+
+        @shared_conversation = SharedAiConversation.find_by(target: @topic)
+
+        @error = DiscourseAi::AiBot::EntryPoint.ai_share_error(@topic, guardian)
+        if @error == :not_allowed
+          raise Discourse::InvalidAccess.new(
+                  nil,
+                  nil,
+                  custom_message: "discourse_ai.share_ai.errors.#{@error}",
+                )
+        end
+      end
+
+      def ensure_allowed_destroy!
+        @shared_conversation = SharedAiConversation.find_by(share_key: params[:share_key])
+
+        raise Discourse::InvalidAccess if @shared_conversation.blank?
+
+        guardian.ensure_can_destroy_shared_ai_bot_conversation!(@shared_conversation)
+      end
+
+      def ensure_allowed_create!
+        @topic = Topic.find_by(id: params[:topic_id])
+        raise Discourse::NotFound if !@topic
+
+        error = DiscourseAi::AiBot::EntryPoint.ai_share_error(@topic, guardian)
+        if error
+          raise Discourse::InvalidAccess.new(
+                  nil,
+                  nil,
+                  custom_message: "discourse_ai.share_ai.errors.#{error}",
+                )
+        end
+      end
+    end
+  end
+end

app/controllers/discourse_ai/ai_helper/assistant_controller.rb

@@ -8,6 +8,8 @@ module DiscourseAi
       before_action :ensure_can_request_suggestions
       before_action :rate_limiter_performed!, except: %i[prompts]
 
+      include SecureUploadEndpointHelpers
+
       def suggest
         input = get_text_param!
 
@@ -105,6 +107,31 @@ module DiscourseAi
                           status: 502
       end
 
+      def caption_image
+        image_url = params[:image_url]
+        raise Discourse::InvalidParameters.new(:image_url) if !image_url
+
+        image = upload_from_full_url(image_url)
+        raise Discourse::NotFound if image.blank?
+        final_image_url = get_caption_url(image, image_url)
+
+        hijack do
+          caption =
+            DiscourseAi::AiHelper::Assistant.new.generate_image_caption(
+              final_image_url,
+              current_user,
+            )
+          render json: {
+                   caption:
+                     "#{caption} (#{I18n.t("discourse_ai.ai_helper.image_caption.attribution")})",
+                 },
+                 status: 200
+        end
+      rescue DiscourseAi::Completions::Endpoints::Base::CompletionFailed, Net::HTTPBadResponse
+        render_json_error I18n.t("discourse_ai.ai_helper.errors.completion_request_failed"),
+                          status: 502
+      end
+
       private
 
       def get_text_param!
@@ -120,14 +147,18 @@ module DiscourseAi
       end
 
       def ensure_can_request_suggestions
-        user_group_ids = current_user.group_ids
+        if !current_user.in_any_groups?(SiteSetting.ai_helper_allowed_groups_map)
+          raise Discourse::InvalidAccess
+        end
+      end
 
-        allowed =
-          SiteSetting.ai_helper_allowed_groups_map.any? do |group_id|
-            user_group_ids.include?(group_id)
-          end
+      def get_caption_url(image_upload, image_url)
+        if image_upload.secure?
+          check_secure_upload_permission(image_upload)
+          return Discourse.store.url_for(image_upload)
+        end
 
-        raise Discourse::InvalidAccess if !allowed
+        UrlHelper.absolute(image_url)
       end
     end
   end

app/controllers/discourse_ai/embeddings/embeddings_controller.rb

@@ -36,6 +36,34 @@ module DiscourseAi
           render_serialized(grouped_results, GroupedSearchResultSerializer, result: grouped_results)
         end
       end
+
+      def quick_search
+        query = params[:q].to_s
+
+        if query.length < SiteSetting.min_search_term_length
+          raise Discourse::InvalidParameters.new(:q)
+        end
+
+        grouped_results =
+          Search::GroupedSearchResults.new(
+            type_filter: SEMANTIC_SEARCH_TYPE,
+            term: query,
+            search_context: guardian,
+            use_pg_headlines_for_excerpt: false,
+          )
+
+        semantic_search = DiscourseAi::Embeddings::SemanticSearch.new(guardian)
+
+        if !semantic_search.cached_query?(query)
+          RateLimiter.new(current_user, "semantic-search", 60, 1.minutes).performed!
+        end
+
+        hijack do
+          semantic_search.quick_search(query).each { |topic_post| grouped_results.add(topic_post) }
+
+          render_serialized(grouped_results, GroupedSearchResultSerializer, result: grouped_results)
+        end
+      end
     end
   end
 end

app/helpers/discourse_ai/ai_bot/shared_ai_conversations_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module DiscourseAi
+  module AiBot
+    module SharedAiConversationsHelper
+      # bump up version when assets change
+      # long term we may want to change this cause it is hard to remember
+      # to bump versions, but for now this does the job
+      VERSION = "1"
+
+      def share_asset_url(short_path)
+        ::UrlHelper.local_cdn_url("/plugins/discourse-ai/ai-share/#{short_path}?#{VERSION}")
+      end
+    end
+  end
+end

app/jobs/regular/digest_rag_upload.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module ::Jobs
+  class DigestRagUpload < ::Jobs::Base
+    CHUNK_SIZE = 1024
+    CHUNK_OVERLAP = 64
+    MAX_FRAGMENTS = 100_000
+
+    # 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?
+      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 = ai_persona.rag_chunk_tokens
+      overlap_tokens = ai_persona.rag_chunk_overlap_tokens
+
+      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?
+        document = get_uploaded_file(upload)
+        return if document.nil?
+
+        RagDocumentFragment.publish_status(upload, { total: 0, indexed: 0, left: 0 })
+
+        fragment_ids = []
+        idx = 0
+
+        ActiveRecord::Base.transaction do
+          chunk_document(
+            file: document,
+            tokenizer: tokenizer,
+            chunk_tokens: chunk_tokens,
+            overlap_tokens: overlap_tokens,
+          ) do |chunk, metadata|
+            fragment_ids << RagDocumentFragment.create!(
+              ai_persona: ai_persona,
+              fragment: chunk,
+              fragment_number: idx + 1,
+              upload: upload,
+              metadata: metadata,
+            ).id
+
+            idx += 1
+
+            if idx > MAX_FRAGMENTS
+              Rails.logger.warn("Upload #{upload.id} has too many fragments, truncating.")
+              break
+            end
+          end
+        end
+      end
+
+      fragment_ids.each_slice(50) do |slice|
+        Jobs.enqueue(:generate_rag_embeddings, fragment_ids: slice)
+      end
+    end
+
+    private
+
+    def chunk_document(file:, tokenizer:, chunk_tokens:, overlap_tokens:)
+      buffer = +""
+      current_metadata = nil
+      done = false
+      overlap = ""
+
+      # generally this will be plenty
+      read_size = chunk_tokens * 10
+
+      while buffer.present? || !done
+        if buffer.length < read_size
+          read = file.read(read_size)
+          done = true if read.nil?
+
+          read = Encodings.to_utf8(read) if read
+
+          buffer << (read || "")
+        end
+
+        # at this point we unconditionally have 2x CHUNK_SIZE worth of data in the buffer
+        metadata_regex = /\[\[metadata (.*?)\]\]/m
+
+        before_metadata, new_metadata, after_metadata = buffer.split(metadata_regex)
+        to_chunk = nil
+
+        if before_metadata.present?
+          to_chunk = before_metadata
+        elsif after_metadata.present?
+          current_metadata = new_metadata
+          to_chunk = after_metadata
+          buffer = buffer.split(metadata_regex, 2).last
+          overlap = ""
+        else
+          current_metadata = new_metadata
+          buffer = buffer.split(metadata_regex, 2).last
+          overlap = ""
+          next
+        end
+
+        chunk, split_char = first_chunk(to_chunk, tokenizer: tokenizer, chunk_tokens: chunk_tokens)
+        buffer = buffer[chunk.length..-1]
+
+        processed_chunk = overlap + chunk
+
+        processed_chunk.strip!
+        processed_chunk.gsub!(/\n[\n]+/, "\n\n")
+
+        yield processed_chunk, current_metadata
+
+        current_chunk_tokens = tokenizer.encode(chunk)
+        overlap_token_ids = current_chunk_tokens[-overlap_tokens..-1] || current_chunk_tokens
+
+        overlap = ""
+
+        while overlap_token_ids.present?
+          begin
+            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
+          end
+          overlap_token_ids.shift
+        end
+
+        # remove first word it is probably truncated
+        overlap = overlap.split(" ", 2).last
+      end
+    end
+
+    def first_chunk(text, chunk_tokens:, tokenizer:, splitters: ["\n\n", "\n", ".", ""])
+      return text, " " if tokenizer.tokenize(text).length <= chunk_tokens
+
+      splitters = splitters.find_all { |s| text.include?(s) }.compact
+
+      buffer = +""
+      split_char = nil
+
+      splitters.each do |splitter|
+        split_char = splitter
+
+        text
+          .split(split_char)
+          .each do |part|
+            break if tokenizer.tokenize(buffer + split_char + part).length > chunk_tokens
+            buffer << split_char
+            buffer << part
+          end
+        break if buffer.length > 0
+      end
+
+      [buffer, split_char]
+    end
+
+    def get_uploaded_file(upload)
+      store = Discourse.store
+      @file ||=
+        if store.external?
+          # Upload#filesize could be approximate.
+          # add two extra Mbs to make sure that we'll be able to download the upload.
+          max_filesize = upload.filesize + 2.megabytes
+          store.download(upload, max_file_size_kb: max_filesize)
+        else
+          File.open(store.path_for(upload))
+        end
+    end
+  end
+end

app/jobs/regular/generate_rag_embeddings.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ::Jobs
+  class GenerateRagEmbeddings < ::Jobs::Base
+    sidekiq_options queue: "ultra_low"
+    # we could also restrict concurrency but this takes so long if it is not concurrent
+
+    def execute(args)
+      return if (fragments = RagDocumentFragment.where(id: args[:fragment_ids].to_a)).empty?
+
+      truncation = DiscourseAi::Embeddings::Strategies::Truncation.new
+      vector_rep =
+        DiscourseAi::Embeddings::VectorRepresentations::Base.current_representation(truncation)
+
+      # generate_representation_from checks compares the digest value to make sure
+      # the embedding is only generated once per fragment unless something changes.
+      fragments.map { |fragment| vector_rep.generate_representation_from(fragment) }
+
+      last_fragment = fragments.last
+      ai_persona = last_fragment.ai_persona
+      upload = last_fragment.upload
+
+      indexing_status = RagDocumentFragment.indexing_status(ai_persona, [upload])[upload.id]
+      RagDocumentFragment.publish_status(upload, indexing_status)
+    end
+  end
+end

app/jobs/regular/shared_conversation_adjust_upload_security.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ::Jobs
+  class SharedConversationAdjustUploadSecurity < ::Jobs::Base
+    def execute(args)
+      if args[:conversation_id].present?
+        # The conversation context includes post cooked content so this
+        # must be updated when target uploads security changes.
+        update_conversation(args[:conversation_id])
+      elsif args[:target_id].present? && args[:target_type].present?
+        # If we deleted the conversation then we just need to update the target's
+        # uploads security, no need to update the conversation.
+        update_target(args[:target_id], args[:target_type])
+      end
+    end
+
+    private
+
+    def update_conversation(conversation_id)
+      conversation = SharedAiConversation.find_by(id: conversation_id)
+      return if conversation.blank?
+
+      # NOTE: Only Topics are supported for now, in future we will need a more flexible
+      # way of doing this.
+      if conversation.target_type == "Topic"
+        rebaked_posts = TopicUploadSecurityManager.new(conversation.target).run
+
+        if rebaked_posts.any?
+          new_context =
+            conversation.context.map do |context_post|
+              rebaked_post = rebaked_posts.find { |p| p.id == context_post["id"] }
+              context_post["cooked"] = rebaked_post.cooked if rebaked_post
+              context_post
+            end
+
+          conversation.update(context: new_context)
+        end
+      end
+    end
+
+    def update_target(target_id, target_type)
+      # NOTE: Only Topics are supported for now, in future we will need a more flexible
+      # way of doing this.
+      if target_type == "Topic"
+        topic = target_type.constantize.find_by(id: target_id)
+        return if topic.blank?
+        TopicUploadSecurityManager.new(topic).run
+      end
+    end
+  end
+end

app/jobs/regular/stream_post_helper.rb

@@ -12,8 +12,7 @@ module Jobs
       topic = post.topic
       reply_to = post.reply_to_post
 
-      guardian = Guardian.new(user)
-      return unless guardian.can_see?(post)
+      return unless user.guardian.can_see?(post)
 
       prompt = CompletionPrompt.enabled_by_name("explain")
 

app/jobs/regular/update_ai_bot_pm_title.rb

@@ -6,7 +6,7 @@ module ::Jobs
 
     def execute(args)
       return unless bot_user = User.find_by(id: args[:bot_user_id])
-      return unless bot = DiscourseAi::AiBot::Bot.as(bot_user)
+      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]

app/models/ai_api_audit_log.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 class AiApiAuditLog < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :topic
+
   module Provider
     OpenAI = 1
     Anthropic = 2
     HuggingFaceTextGeneration = 3
     Gemini = 4
     Vllm = 5
+    Cohere = 6
   end
 end
 

app/models/ai_persona.rb

@@ -9,44 +9,30 @@ class AiPersona < ActiveRecord::Base
   validates :system_prompt, presence: true, length: { maximum: 10_000_000 }
   validate :system_persona_unchangeable, on: :update, if: :system
   validates :max_context_posts, numericality: { greater_than: 0 }, allow_nil: true
+  # leaves some room for growth but sets a maximum to avoid memory issues
+  # we may want to revisit this in the future
+  validates :vision_max_pixels, numericality: { greater_than: 0, maximum: 4_000_000 }
+
+  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 }
 
   belongs_to :created_by, class_name: "User"
   belongs_to :user
 
+  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
 
-  class MultisiteHash
-    def initialize(id)
-      @hash = Hash.new { |h, k| h[k] = {} }
-      @id = id
-
-      MessageBus.subscribe(channel_name) { |message| @hash[message.data] = {} }
-    end
-
-    def channel_name
-      "/multisite-hash-#{@id}"
-    end
-
-    def current_db
-      RailsMultisite::ConnectionManagement.current_db
-    end
-
-    def [](key)
-      @hash.dig(current_db, key)
-    end
-
-    def []=(key, val)
-      @hash[current_db][key] = val
-    end
-
-    def flush!
-      @hash[current_db] = {}
-      MessageBus.publish(channel_name, current_db)
-    end
-  end
+  before_update :regenerate_rag_fragments
 
   def self.persona_cache
-    @persona_cache ||= MultisiteHash.new("persona_cache")
+    @persona_cache ||= ::DiscourseAi::MultisiteHash.new("persona_cache")
   end
 
   scope :ordered, -> { order("priority DESC, lower(name) ASC") }
@@ -60,21 +46,54 @@ class AiPersona < ActiveRecord::Base
       .map(&:class_instance)
   end
 
-  def self.mentionables
-    persona_cache[:mentionable_usernames] ||= AiPersona
-      .where(mentionable: true)
-      .where(enabled: true)
-      .joins(:user)
-      .pluck("ai_personas.id, users.id, users.username_lower, allowed_group_ids, default_llm")
-      .map do |id, user_id, username, allowed_group_ids, default_llm|
-        {
-          id: id,
-          user_id: user_id,
-          username: username,
-          allowed_group_ids: allowed_group_ids,
-          default_llm: default_llm,
-        }
-      end
+  def self.persona_users(user: nil)
+    persona_users =
+      persona_cache[:persona_users] ||= AiPersona
+        .where(enabled: true)
+        .joins(:user)
+        .pluck(
+          "ai_personas.id, users.id, users.username_lower, allowed_group_ids, default_llm, mentionable",
+        )
+        .map do |id, user_id, username, allowed_group_ids, default_llm, mentionable|
+          {
+            id: id,
+            user_id: user_id,
+            username: username,
+            allowed_group_ids: allowed_group_ids,
+            default_llm: default_llm,
+            mentionable: mentionable,
+          }
+        end
+
+    if user
+      persona_users.select { |mentionable| user.in_any_groups?(mentionable[:allowed_group_ids]) }
+    else
+      persona_users
+    end
+  end
+
+  def self.mentionables(user: nil)
+    all_mentionables =
+      persona_cache[:mentionable_usernames] ||= AiPersona
+        .where(mentionable: true)
+        .where(enabled: true)
+        .joins(:user)
+        .pluck("ai_personas.id, users.id, users.username_lower, allowed_group_ids, default_llm")
+        .map do |id, user_id, username, allowed_group_ids, default_llm|
+          {
+            id: id,
+            user_id: user_id,
+            username: username,
+            allowed_group_ids: allowed_group_ids,
+            default_llm: default_llm,
+          }
+        end
+
+    if user
+      all_mentionables.select { |mentionable| user.in_any_groups?(mentionable[:allowed_group_ids]) }
+    else
+      all_mentionables
+    end
   end
 
   after_commit :bump_cache
@@ -91,6 +110,10 @@ class AiPersona < ActiveRecord::Base
     mentionable = self.mentionable
     default_llm = self.default_llm
     max_context_posts = self.max_context_posts
+    vision_enabled = self.vision_enabled
+    vision_max_pixels = self.vision_max_pixels
+    rag_conversation_chunks = self.rag_conversation_chunks
+    question_consolidator_llm = self.question_consolidator_llm
 
     persona_class = DiscourseAi::AiBot::Personas::Persona.system_personas_by_id[self.id]
     if persona_class
@@ -122,6 +145,22 @@ class AiPersona < ActiveRecord::Base
         max_context_posts
       end
 
+      persona_class.define_singleton_method :vision_enabled do
+        vision_enabled
+      end
+
+      persona_class.define_singleton_method :vision_max_pixels do
+        vision_max_pixels
+      end
+
+      persona_class.define_singleton_method :question_consolidator_llm do
+        question_consolidator_llm
+      end
+
+      persona_class.define_singleton_method :rag_conversation_chunks do
+        rag_conversation_chunks
+      end
+
       return persona_class
     end
 
@@ -197,6 +236,22 @@ class AiPersona < ActiveRecord::Base
         max_context_posts
       end
 
+      define_singleton_method :vision_enabled do
+        vision_enabled
+      end
+
+      define_singleton_method :vision_max_pixels do
+        vision_max_pixels
+      end
+
+      define_singleton_method :rag_conversation_chunks do
+        rag_conversation_chunks
+      end
+
+      define_singleton_method :question_consolidator_llm do
+        question_consolidator_llm
+      end
+
       define_singleton_method :to_s do
         "#<DiscourseAi::AiBot::Personas::Persona::Custom @name=#{self.name} @allowed_group_ids=#{self.allowed_group_ids.join(",")}>"
       end
@@ -210,6 +265,10 @@ class AiPersona < ActiveRecord::Base
         super(*args, **kwargs)
       end
 
+      define_method :persona_id do
+        @ai_persona&.id
+      end
+
       define_method :tools do
         tools
       end
@@ -229,6 +288,10 @@ class AiPersona < ActiveRecord::Base
       define_method :system_prompt do
         @ai_persona&.system_prompt || "You are a helpful bot."
       end
+
+      define_method :uploads do
+        @ai_persona&.uploads
+      end
     end
   end
 
@@ -271,6 +334,12 @@ class AiPersona < ActiveRecord::Base
     user
   end
 
+  def regenerate_rag_fragments
+    if rag_chunk_tokens_changed? || rag_chunk_overlap_tokens_changed?
+      RagDocumentFragment.where(ai_persona: self).delete_all
+    end
+  end
+
   private
 
   def system_persona_unchangeable
@@ -292,26 +361,32 @@ end
 #
 # Table name: ai_personas
 #
-#  id                      :bigint           not null, primary key
-#  name                    :string(100)      not null
-#  description             :string(2000)     not null
-#  commands                :json             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
-#  max_post_context_tokens :integer
-#  max_context_tokens      :integer
+#  id                          :bigint           not null, primary key
+#  name                        :string(100)      not null
+#  description                 :string(2000)     not null
+#  commands                    :json             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
+#  max_post_context_tokens     :integer
+#  max_context_tokens          :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
 #
 # Indexes
 #

app/models/post_custom_prompt.rb

@@ -7,3 +7,18 @@ end
 class ::Post
   has_one :post_custom_prompt, dependent: :destroy
 end
+
+# == Schema Information
+#
+# Table name: post_custom_prompts
+#
+#  id            :bigint           not null, primary key
+#  post_id       :integer          not null
+#  custom_prompt :json             not null
+#  created_at    :datetime         not null
+#  updated_at    :datetime         not null
+#
+# Indexes
+#
+#  index_post_custom_prompts_on_post_id  (post_id) UNIQUE
+#

app/models/rag_document_fragment.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+class RagDocumentFragment < ActiveRecord::Base
+  belongs_to :upload
+  belongs_to :ai_persona
+
+  class << self
+    def link_persona_and_uploads(persona, upload_ids)
+      return if persona.blank?
+      return if upload_ids.blank?
+      return if !SiteSetting.ai_embeddings_enabled?
+
+      UploadReference.ensure_exist!(upload_ids: upload_ids, target: persona)
+
+      upload_ids.each do |upload_id|
+        Jobs.enqueue(:digest_rag_upload, ai_persona_id: persona.id, upload_id: upload_id)
+      end
+    end
+
+    def update_persona_uploads(persona, upload_ids)
+      return if persona.blank?
+      return if !SiteSetting.ai_embeddings_enabled?
+
+      if upload_ids.blank?
+        RagDocumentFragment.where(ai_persona: persona).destroy_all
+        UploadReference.where(target: persona).destroy_all
+      else
+        RagDocumentFragment.where(ai_persona: persona).where.not(upload_id: upload_ids).destroy_all
+        link_persona_and_uploads(persona, upload_ids)
+      end
+    end
+
+    def indexing_status(persona, uploads)
+      truncation = DiscourseAi::Embeddings::Strategies::Truncation.new
+      vector_rep =
+        DiscourseAi::Embeddings::VectorRepresentations::Base.current_representation(truncation)
+
+      embeddings_table = vector_rep.rag_fragments_table_name
+
+      results = DB.query(<<~SQL, persona_id: persona.id, upload_ids: uploads.map(&:id))
+        SELECT
+          uploads.id,
+          SUM(CASE WHEN (rdf.upload_id IS NOT NULL) THEN 1 ELSE 0 END) AS total,
+          SUM(CASE WHEN (eft.rag_document_fragment_id IS NOT NULL) THEN 1 ELSE 0 END) as indexed,
+          SUM(CASE WHEN (rdf.upload_id IS NOT NULL AND eft.rag_document_fragment_id IS NULL) THEN 1 ELSE 0 END) as left
+        FROM uploads
+        LEFT OUTER JOIN rag_document_fragments rdf ON uploads.id = rdf.upload_id AND rdf.ai_persona_id = :persona_id
+        LEFT OUTER JOIN #{embeddings_table} eft ON rdf.id = eft.rag_document_fragment_id
+        WHERE uploads.id IN (:upload_ids)
+        GROUP BY uploads.id
+      SQL
+
+      results.reduce({}) do |acc, r|
+        acc[r.id] = { total: r.total, indexed: r.indexed, left: r.left }
+        acc
+      end
+    end
+
+    def publish_status(upload, status)
+      MessageBus.publish(
+        "/discourse-ai/ai-persona-rag/#{upload.id}",
+        status,
+        user_ids: [upload.user_id],
+      )
+    end
+  end
+end
+
+# == Schema Information
+#
+# Table name: rag_document_fragments
+#
+#  id              :bigint           not null, primary key
+#  fragment        :text             not null
+#  upload_id       :integer          not null
+#  ai_persona_id   :integer          not null
+#  fragment_number :integer          not null
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#  metadata        :text
+#

app/models/shared_ai_conversation.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+class SharedAiConversation < ActiveRecord::Base
+  DEFAULT_MAX_POSTS = 100
+
+  belongs_to :user
+  belongs_to :target, polymorphic: true
+
+  validates :user_id, presence: true
+  validates :target, presence: true
+  validates :context, presence: true
+  validates :share_key, presence: true, uniqueness: true
+
+  before_validation :generate_share_key, on: :create
+
+  def self.share_conversation(user, target, max_posts: DEFAULT_MAX_POSTS)
+    raise "Target must be a topic for now" if !target.is_a?(Topic)
+
+    conversation = find_by(user: user, target: target)
+    conversation_data = build_conversation_data(target, max_posts: max_posts)
+
+    conversation =
+      if conversation
+        conversation.update(**conversation_data)
+        conversation
+      else
+        create(user_id: user.id, target: target, **conversation_data)
+      end
+
+    ::Jobs.enqueue(:shared_conversation_adjust_upload_security, conversation_id: conversation.id)
+
+    conversation
+  end
+
+  def self.destroy_conversation(conversation)
+    conversation.destroy
+    ::Jobs.enqueue(
+      :shared_conversation_adjust_upload_security,
+      target_id: conversation.target_id,
+      target_type: conversation.target_type,
+    )
+  end
+
+  # Technically this may end up being a chat message
+  # but this name works
+  class SharedPost
+    attr_accessor :user
+    attr_reader :id, :user_id, :created_at, :cooked, :persona
+    def initialize(post)
+      @id = post[:id]
+      @user_id = post[:user_id]
+      @created_at = DateTime.parse(post[:created_at])
+      @cooked = post[:cooked]
+      @persona = post[:persona]
+    end
+  end
+
+  def populated_context
+    return @populated_context if @populated_context
+    @populated_context = context.map { |post| SharedPost.new(post.symbolize_keys) }
+    populate_user_info!(@populated_context)
+    @populated_context
+  end
+
+  def to_json
+    posts =
+      self.populated_context.map do |post|
+        {
+          id: post.id,
+          cooked: post.cooked,
+          username: post.user.username,
+          created_at: post.created_at,
+        }
+      end
+    { llm_name: self.llm_name, share_key: self.share_key, title: self.title, posts: posts }
+  end
+
+  def url
+    "#{Discourse.base_uri}/discourse-ai/ai-bot/shared-ai-conversations/#{share_key}"
+  end
+
+  def html_excerpt
+    html = +""
+    populated_context.each do |post|
+      text =
+        PrettyText.excerpt(
+          post.cooked,
+          400,
+          text_entities: true,
+          strip_links: true,
+          strip_details: true,
+        )
+
+      html << "<p><b>#{post.user.username}</b>: #{text}</p>"
+      if html.length > 1000
+        html << "<p>...</p>"
+        break
+      end
+    end
+    html << "<a href='#{url}'>#{I18n.t("discourse_ai.share_ai.read_more")}<a>"
+    html
+  end
+
+  def onebox
+    <<~HTML
+    <div>
+      <aside class="onebox allowlistedgeneric" data-onebox-src="#{url}">
+      <header class="source">
+        <span class="onebox-ai-llm-title">#{I18n.t("discourse_ai.share_ai.onebox_title", llm_name: llm_name)}</span>
+        <a href="#{url}" target="_blank" rel="nofollow ugc noopener" tabindex="-1">#{Discourse.base_uri}</a>
+      </header>
+      <article class="onebox-body">
+      <h3><a href="#{url}" rel="nofollow ugc noopener" tabindex="-1">#{title}</a></h3>
+    #{html_excerpt}
+    </article>
+    <div style="clear: both"></div>
+    </aside>
+    </div>
+    HTML
+  end
+
+  def self.excerpt(posts)
+    excerpt = +""
+    posts.each do |post|
+      excerpt << "#{post.user.display_name}: #{post.excerpt(100)} "
+      break if excerpt.length > 1000
+    end
+    excerpt
+  end
+
+  def formatted_excerpt
+    I18n.t("discourse_ai.share_ai.formatted_excerpt", llm_name: llm_name, excerpt: excerpt)
+  end
+
+  def self.build_conversation_data(topic, max_posts: DEFAULT_MAX_POSTS, include_usernames: false)
+    llm_name = nil
+    topic.topic_allowed_users.each do |tu|
+      if DiscourseAi::AiBot::EntryPoint::BOT_USER_IDS.include?(tu.user_id)
+        llm_name = DiscourseAi::AiBot::EntryPoint.find_bot_by_id(tu.user_id)&.llm
+      end
+    end
+
+    llm_name = ActiveSupport::Inflector.humanize(llm_name) if llm_name
+    llm_name ||= I18n.t("discourse_ai.unknown_model")
+
+    persona = nil
+    if persona_id = topic.custom_fields["ai_persona_id"]
+      persona = AiPersona.find_by(id: persona_id.to_i)&.name
+    end
+
+    posts =
+      topic
+        .posts
+        .by_post_number
+        .where(post_type: Post.types[:regular])
+        .where.not(cooked: nil)
+        .where(deleted_at: nil)
+        .limit(max_posts)
+
+    {
+      llm_name: llm_name,
+      title: topic.title,
+      excerpt: excerpt(posts),
+      context:
+        posts.map do |post|
+          mapped = {
+            id: post.id,
+            user_id: post.user_id,
+            created_at: post.created_at,
+            cooked: post.cooked,
+          }
+
+          mapped[:persona] = persona if ::DiscourseAi::AiBot::EntryPoint::BOT_USER_IDS.include?(
+            post.user_id,
+          )
+          mapped[:username] = post.user&.username if include_usernames
+          mapped
+        end,
+    }
+  end
+
+  private
+
+  def populate_user_info!(posts)
+    users = User.where(id: posts.map(&:user_id).uniq).map { |u| [u.id, u] }.to_h
+    posts.each { |post| post.user = users[post.user_id] }
+  end
+
+  def generate_share_key
+    self.share_key = SecureRandom.urlsafe_base64(16)
+  end
+end
+
+# == Schema Information
+#
+# Table name: shared_ai_conversations
+#
+#  id          :bigint           not null, primary key
+#  user_id     :integer          not null
+#  target_id   :integer          not null
+#  target_type :string           not null
+#  title       :string           not null
+#  llm_name    :string           not null
+#  context     :jsonb            not null
+#  share_key   :string           not null
+#  excerpt     :string           not null
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#
+# Indexes
+#
+#  idx_shared_ai_conversations_user_target                     (user_id,target_id,target_type) UNIQUE
+#  index_shared_ai_conversations_on_share_key                  (share_key) UNIQUE
+#  index_shared_ai_conversations_on_target_id_and_target_type  (target_id,target_type) UNIQUE
+#

app/serializers/localized_ai_persona_serializer.rb

@@ -17,9 +17,20 @@ class LocalizedAiPersonaSerializer < ApplicationSerializer
              :mentionable,
              :default_llm,
              :user_id,
-             :max_context_posts
+             :max_context_posts,
+             :vision_enabled,
+             :vision_max_pixels,
+             :rag_chunk_tokens,
+             :rag_chunk_overlap_tokens,
+             :rag_conversation_chunks,
+             :question_consolidator_llm
 
   has_one :user, serializer: BasicUserSerializer, embed: :object
+  has_many :rag_uploads, serializer: UploadSerializer, embed: :object
+
+  def rag_uploads
+    object.uploads
+  end
 
   def name
     object.class_instance.name

assets/javascripts/discourse/admin-discourse-ai-personas-route-map.js

@@ -1,14 +0,0 @@
-export default {
-  resource: "admin.adminPlugins",
-
-  path: "/plugins",
-
-  map() {
-    this.route("discourse-ai", function () {
-      this.route("ai-personas", function () {
-        this.route("new");
-        this.route("show", { path: "/:id" });
-      });
-    });
-  },
-};

assets/javascripts/discourse/admin-discourse-ai-plugin-route-map.js

@@ -0,0 +1,12 @@
+export default {
+  resource: "admin.adminPlugins.show",
+
+  path: "/plugins",
+
+  map() {
+    this.route("discourse-ai-personas", { path: "ai-personas" }, function () {
+      this.route("new");
+      this.route("show", { path: "/:id" });
+    });
+  },
+};

assets/javascripts/discourse/admin/models/ai-persona.js

@@ -2,7 +2,8 @@ import { tracked } from "@glimmer/tracking";
 import { ajax } from "discourse/lib/ajax";
 import RestModel from "discourse/models/rest";
 
-const ATTRIBUTES = [
+const CREATE_ATTRIBUTES = [
+  "id",
   "name",
   "description",
   "commands",
@@ -18,6 +19,33 @@ const ATTRIBUTES = [
   "default_llm",
   "user",
   "max_context_posts",
+  "vision_enabled",
+  "vision_max_pixels",
+  "rag_uploads",
+  "rag_chunk_tokens",
+  "rag_chunk_overlap_tokens",
+  "rag_conversation_chunks",
+  "question_consolidator_llm",
+];
+
+const SYSTEM_ATTRIBUTES = [
+  "id",
+  "allowed_group_ids",
+  "enabled",
+  "system",
+  "priority",
+  "user_id",
+  "mentionable",
+  "default_llm",
+  "user",
+  "max_context_posts",
+  "vision_enabled",
+  "vision_max_pixels",
+  "rag_uploads",
+  "rag_chunk_tokens",
+  "rag_chunk_overlap_tokens",
+  "rag_conversation_chunks",
+  "question_consolidator_llm",
 ];
 
 class CommandOption {
@@ -97,19 +125,24 @@ export default class AiPersona extends RestModel {
   }
 
   updateProperties() {
-    let attrs = this.getProperties(ATTRIBUTES);
+    let attrs = this.system
+      ? this.getProperties(SYSTEM_ATTRIBUTES)
+      : this.getProperties(CREATE_ATTRIBUTES);
     attrs.id = this.id;
     this.populateCommandOptions(attrs);
+
     return attrs;
   }
 
   createProperties() {
-    let attrs = this.getProperties(ATTRIBUTES);
+    let attrs = this.getProperties(CREATE_ATTRIBUTES);
     this.populateCommandOptions(attrs);
     return attrs;
   }
 
   workingCopy() {
-    return AiPersona.create(this.createProperties());
+    let attrs = this.getProperties(CREATE_ATTRIBUTES);
+    this.populateCommandOptions(attrs);
+    return AiPersona.create(attrs);
   }
 }

assets/javascripts/discourse/components/ai-bot-header-icon.gjs

@@ -0,0 +1,50 @@
+import Component from "@glimmer/component";
+import { action } from "@ember/object";
+import { service } from "@ember/service";
+import { gt } from "truth-helpers";
+import DButton from "discourse/components/d-button";
+import i18n from "discourse-common/helpers/i18n";
+import DMenu from "float-kit/components/d-menu";
+import { composeAiBotMessage } from "../lib/ai-bot-helper";
+import AiBotHeaderPanel from "./ai-bot-header-panel";
+
+export default class AiBotHeaderIcon extends Component {
+  @service siteSettings;
+  @service composer;
+
+  get bots() {
+    return this.siteSettings.ai_bot_add_to_header
+      ? this.siteSettings.ai_bot_enabled_chat_bots.split("|").filter(Boolean)
+      : [];
+  }
+
+  @action
+  compose() {
+    composeAiBotMessage(this.bots[0], this.composer);
+  }
+
+  <template>
+    {{#if (gt this.bots.length 0)}}
+      <li>
+        {{#if (gt this.bots.length 1)}}
+          <DMenu
+            @icon="robot"
+            @title={{i18n "discourse_ai.ai_bot.shortcut_title"}}
+            class="ai-bot-button icon btn-flat"
+          >
+            <:content as |args|>
+              <AiBotHeaderPanel @closePanel={{args.close}} />
+            </:content>
+          </DMenu>
+        {{else}}
+          <DButton
+            @icon="robot"
+            @title={{i18n "discourse_ai.ai_bot.shortcut_title"}}
+            class="ai-bot-button icon btn-flat"
+            @action={{this.compose}}
+          />
+        {{/if}}
+      </li>
+    {{/if}}
+  </template>
+}