Merge branch 'main' into dev/glimmer-post-stream

Author: megothss

app/controllers/discourse_ai/ai_bot/conversations_controller.rb

@@ -15,8 +15,11 @@ def index
           Topic
             .private_messages_for_user(current_user)
             .where(user: current_user) # Only show PMs where the current user is the author
-            .joins(:topic_users)
-            .where(topic_users: { user_id: bot_user_ids })
+            .joins(
+              "INNER JOIN topic_custom_fields tcf ON tcf.topic_id = topics.id
+                   AND tcf.name = '#{DiscourseAi::AiBot::TOPIC_AI_BOT_PM_FIELD}'
+                   AND tcf.value = 't'",
+            )
             .distinct
 
         total = base_query.count

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

@@ -2,14 +2,17 @@ import Component from "@glimmer/component";
 import { action } from "@ember/object";
 import { service } from "@ember/service";
 import DButton from "discourse/components/d-button";
+import { defaultHomepage } from "discourse/lib/utilities";
 import { i18n } from "discourse-i18n";
 import { composeAiBotMessage } from "../lib/ai-bot-helper";
+import { AI_CONVERSATIONS_PANEL } from "../services/ai-conversations-sidebar-manager";
 
 export default class AiBotHeaderIcon extends Component {
-  @service currentUser;
-  @service siteSettings;
   @service composer;
+  @service currentUser;
   @service router;
+  @service sidebarState;
+  @service siteSettings;
 
   get bots() {
     const availableBots = this.currentUser.ai_enabled_chat_bots
@@ -23,20 +26,39 @@ export default class AiBotHeaderIcon extends Component {
     return this.bots.length > 0 && this.siteSettings.ai_bot_add_to_header;
   }
 
+  get icon() {
+    if (this.clickShouldRouteOutOfConversations) {
+      return "shuffle";
+    }
+    return "robot";
+  }
+
+  get clickShouldRouteOutOfConversations() {
+    return (
+      this.siteSettings.ai_enable_experimental_bot_ux &&
+      this.sidebarState.currentPanel?.key === AI_CONVERSATIONS_PANEL
+    );
+  }
+
   @action
-  compose() {
+  onClick() {
+    if (this.clickShouldRouteOutOfConversations) {
+      return this.router.transitionTo(`discovery.${defaultHomepage()}`);
+    }
+
     if (this.siteSettings.ai_enable_experimental_bot_ux) {
       return this.router.transitionTo("discourse-ai-bot-conversations");
     }
+
     composeAiBotMessage(this.bots[0], this.composer);
   }
 
   <template>
     {{#if this.showHeaderButton}}
       <li>
         <DButton
-          @action={{this.compose}}
-          @icon="robot"
+          @action={{this.onClick}}
+          @icon={{this.icon}}
           title={{i18n "discourse_ai.ai_bot.shortcut_title"}}
           class="ai-bot-button icon btn-flat"
         />

assets/javascripts/discourse/components/ai-bot-sidebar-new-conversation.gjs

@@ -1,4 +1,5 @@
 import Component from "@glimmer/component";
+import { action } from "@ember/object";
 import { service } from "@ember/service";
 import DButton from "discourse/components/d-button";
 import { AI_CONVERSATIONS_PANEL } from "../services/ai-conversations-sidebar-manager";
@@ -14,12 +15,18 @@ export default class AiBotSidebarNewConversation extends Component {
     );
   }
 
+  @action
+  routeTo() {
+    this.router.transitionTo("/discourse-ai/ai-bot/conversations");
+    this.args.outletArgs?.toggleNavigationMenu?.();
+  }
+
   <template>
     {{#if this.shouldRender}}
       <DButton
-        @route="/discourse-ai/ai-bot/conversations"
         @label="discourse_ai.ai_bot.conversations.new"
         @icon="plus"
+        @action={{this.routeTo}}
         class="ai-new-question-button btn-default"
       />
     {{/if}}

assets/javascripts/discourse/components/ai-llms-list-editor.gjs

@@ -116,6 +116,10 @@ export default class AiLlmsListEditor extends Component {
       return i18n("discourse_ai.llms.usage.ai_persona", {
         persona: usage.name,
       });
+    } else if (usage.type === "automation") {
+      return i18n("discourse_ai.llms.usage.automation", {
+        name: usage.name,
+      });
     } else {
       return i18n("discourse_ai.llms.usage." + usage.type);
     }

assets/javascripts/discourse/components/ai-persona-llm-selector.gjs

@@ -0,0 +1,202 @@
+import Component from "@glimmer/component";
+import { tracked } from "@glimmer/tracking";
+import { hash } from "@ember/helper";
+import { next } from "@ember/runloop";
+import { service } from "@ember/service";
+import { i18n } from "discourse-i18n";
+import DropdownSelectBox from "select-kit/components/dropdown-select-box";
+
+const PERSONA_SELECTOR_KEY = "ai_persona_selector_id";
+const LLM_SELECTOR_KEY = "ai_llm_selector_id";
+
+export default class AiPersonaLlmSelector extends Component {
+  @service currentUser;
+  @service keyValueStore;
+
+  @tracked llm;
+  @tracked allowLLMSelector = true;
+
+  constructor() {
+    super(...arguments);
+
+    if (this.botOptions?.length) {
+      this.#loadStoredPersona();
+      this.#loadStoredLlm();
+
+      next(() => {
+        this.resetTargetRecipients();
+      });
+    }
+  }
+
+  get composer() {
+    return this.args?.outletArgs?.model;
+  }
+
+  get hasLlmSelector() {
+    return this.currentUser.ai_enabled_chat_bots.any((bot) => !bot.is_persona);
+  }
+
+  get botOptions() {
+    if (!this.currentUser.ai_enabled_personas) {
+      return;
+    }
+
+    let enabledPersonas = this.currentUser.ai_enabled_personas;
+
+    if (!this.hasLlmSelector) {
+      enabledPersonas = enabledPersonas.filter((persona) => persona.username);
+    }
+
+    return enabledPersonas.map((persona) => {
+      return {
+        id: persona.id,
+        name: persona.name,
+        description: persona.description,
+      };
+    });
+  }
+
+  get filterable() {
+    return this.botOptions.length > 8;
+  }
+
+  get value() {
+    return this._value;
+  }
+
+  set value(newValue) {
+    this._value = newValue;
+    this.keyValueStore.setItem(PERSONA_SELECTOR_KEY, newValue);
+    this.args.setPersonaId(newValue);
+    this.setAllowLLMSelector();
+    this.resetTargetRecipients();
+  }
+
+  setAllowLLMSelector() {
+    if (!this.hasLlmSelector) {
+      this.allowLLMSelector = false;
+      return;
+    }
+
+    const persona = this.currentUser.ai_enabled_personas.find(
+      (innerPersona) => innerPersona.id === this._value
+    );
+
+    this.allowLLMSelector = !persona?.force_default_llm;
+  }
+
+  get currentLlm() {
+    return this.llm;
+  }
+
+  set currentLlm(newValue) {
+    this.llm = newValue;
+    this.keyValueStore.setItem(LLM_SELECTOR_KEY, newValue);
+
+    this.resetTargetRecipients();
+  }
+
+  resetTargetRecipients() {
+    if (this.allowLLMSelector) {
+      const botUsername = this.currentUser.ai_enabled_chat_bots.find(
+        (bot) => bot.id === this.llm
+      ).username;
+      this.args.setTargetRecipient(botUsername);
+    } else {
+      const persona = this.currentUser.ai_enabled_personas.find(
+        (innerPersona) => innerPersona.id === this._value
+      );
+      this.args.setTargetRecipient(persona.username || "");
+    }
+  }
+
+  get llmOptions() {
+    const availableBots = this.currentUser.ai_enabled_chat_bots
+      .filter((bot) => !bot.is_persona)
+      .filter(Boolean);
+
+    return availableBots
+      .map((bot) => {
+        return {
+          id: bot.id,
+          name: bot.display_name,
+        };
+      })
+      .sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  get showLLMSelector() {
+    return this.allowLLMSelector && this.llmOptions.length > 1;
+  }
+
+  #loadStoredPersona() {
+    let personaId = this.keyValueStore.getItem(PERSONA_SELECTOR_KEY);
+
+    this._value = this.botOptions[0].id;
+    if (personaId) {
+      personaId = parseInt(personaId, 10);
+      if (this.botOptions.any((bot) => bot.id === personaId)) {
+        this._value = personaId;
+      }
+    }
+
+    this.args.setPersonaId(this._value);
+  }
+
+  #loadStoredLlm() {
+    this.setAllowLLMSelector();
+
+    if (this.hasLlmSelector) {
+      let llm = this.keyValueStore.getItem(LLM_SELECTOR_KEY);
+
+      const llmOption =
+        this.llmOptions.find((innerLlmOption) => innerLlmOption.id === llm) ||
+        this.llmOptions[0];
+
+      if (llmOption) {
+        llm = llmOption.id;
+      } else {
+        llm = "";
+      }
+
+      if (llm) {
+        next(() => {
+          this.currentLlm = llm;
+        });
+      }
+    }
+  }
+
+  <template>
+    <div class="persona-llm-selector">
+      <div class="persona-llm-selector__selection-wrapper gpt-persona">
+        {{#if @showLabels}}
+          <label>{{i18n "discourse_ai.ai_bot.persona"}}</label>
+        {{/if}}
+        <DropdownSelectBox
+          class="persona-llm-selector__persona-dropdown"
+          @value={{this.value}}
+          @content={{this.botOptions}}
+          @options={{hash
+            icon=(if @showLabels "angle-down" "robot")
+            filterable=this.filterable
+          }}
+        />
+      </div>
+      {{#if this.showLLMSelector}}
+        <div class="persona-llm-selector__selection-wrapper llm-selector">
+          {{#if @showLabels}}
+            <label>{{i18n "discourse_ai.ai_bot.llm"}}</label>
+          {{/if}}
+          <DropdownSelectBox
+            class="persona-llm-selector__llm-dropdown"
+            @value={{this.currentLlm}}
+            @content={{this.llmOptions}}
+            @options={{hash icon=(if @showLabels "angle-down" "globe")}}
+          />
+        </div>
+      {{/if}}
+    </div>
+  </template>
+}