From 6a726c61793af4102704cd4c31327aac2c49e1d8 Mon Sep 17 00:00:00 2001
From: Christian Beeznest <christian.fasanando@beeznest.com>
Date: Fri, 16 Jan 2026 01:22:10 -0500
Subject: [PATCH] Glossary: Add AI glossary term generator - refs #7309

---
 assets/vue/router/glossary.js                 |   9 +-
 assets/vue/services/glossaryService.js        |  60 +-
 .../views/glossary/GlossaryGenerateTerms.vue  | 526 ++++++++++++++++++
 assets/vue/views/glossary/GlossaryList.vue    |  77 ++-
 src/CoreBundle/Controller/AiController.php    | 357 ++++++++----
 .../PlatformConfigurationController.php       |   1 +
 .../Repository/CGlossaryRepository.php        |  53 ++
 7 files changed, 938 insertions(+), 145 deletions(-)
 create mode 100644 assets/vue/views/glossary/GlossaryGenerateTerms.vue

diff --git a/assets/vue/router/glossary.js b/assets/vue/router/glossary.js
index 1093470a9d6..7b16a6cacc1 100644
--- a/assets/vue/router/glossary.js
+++ b/assets/vue/router/glossary.js
@@ -23,13 +23,18 @@ export default {
     },
     {
       name: "ImportGlossary",
-      path: "",
+      path: "import",
       component: () => import("../views/glossary/GlossaryImport.vue"),
     },
     {
       name: "ExportGlossary",
-      path: "",
+      path: "export",
       component: () => import("../views/glossary/GlossaryExport.vue"),
     },
+    {
+      name: "GenerateGlossaryTerms",
+      path: "generate",
+      component: () => import("../views/glossary/GlossaryGenerateTerms.vue"),
+    },
   ],
 }
diff --git a/assets/vue/services/glossaryService.js b/assets/vue/services/glossaryService.js
index cdec7dca1c0..7a3e0790133 100644
--- a/assets/vue/services/glossaryService.js
+++ b/assets/vue/services/glossaryService.js
@@ -2,84 +2,70 @@ import { ENTRYPOINT } from "../config/entrypoint"
 import axios from "axios"
 
 export default {
-  /**
-   * @param {Object} params
-   */
+  // ---------------------------
+  // Glossary CRUD (API entrypoint)
+  // ---------------------------
   getGlossaryTerms: async (params) => {
     const response = await axios.get(ENTRYPOINT + "glossaries", { params })
-
     return response.data
   },
 
-  /**
-   * @param {String|Number} termId
-   */
   getGlossaryTerm: async (termId) => {
     const response = await axios.get(ENTRYPOINT + `glossaries/${termId}`)
-
     return response.data
   },
 
-  /**
-   * @param {Object} data
-   */
   createGlossaryTerm: async (data) => {
-    const response = await axios.post(ENTRYPOINT + `glossaries`, data)
-
+    const response = await axios.post(ENTRYPOINT + "glossaries", data)
     return response.data
   },
 
-  /**
-   * @param {String|Number} termId
-   * @param {Object} data
-   */
   updateGlossaryTerm: async (termId, data) => {
     const response = await axios.put(ENTRYPOINT + `glossaries/${termId}`, data)
-
     return response.data
   },
 
-  /**
-   * @param {FormData} formData
-   */
   export: async (formData) => {
     const endpoint = `${ENTRYPOINT}glossaries/export`
-    const response = await axios.post(endpoint, formData, { responsetype: "blob" })
-
+    const response = await axios.post(endpoint, formData, { responseType: "blob" })
     return response.data
   },
 
-  /**
-   * @param {FormData} formData
-   */
   import: async (formData) => {
     const endpoint = `${ENTRYPOINT}glossaries/import`
     const response = await axios.post(endpoint, formData, {
-      headers: {
-        "Content-Type": "multipart/form-data",
-      },
+      headers: { "Content-Type": "multipart/form-data" },
     })
-
     return response.data
   },
 
-  /**
-   * @param {Object} data
-   */
   exportToDocuments: async (data) => {
     const endpoint = `${ENTRYPOINT}glossaries/export_to_documents`
     const response = await axios.post(endpoint, data)
-
     return response.data
   },
 
-  /**
-   * @param {String|Number} termId
-   */
   deleteTerm: async (termId) => {
     const endpoint = `${ENTRYPOINT}glossaries/${termId}`
     const response = await axios.delete(endpoint)
+    return response.data
+  },
+
+  // ---------------------------
+  // AI helpers (non-API entrypoint)
+  // ---------------------------
+  getTextProviders: async () => {
+    const response = await axios.get("/ai/text_providers")
+    return response.data
+  },
+
+  getDefaultPrompt: async (params) => {
+    const response = await axios.get("/ai/glossary_default_prompt", { params })
+    return response.data
+  },
 
+  generateGlossaryTerms: async (data) => {
+    const response = await axios.post("/ai/generate_glossary_terms", data)
     return response.data
   },
 }
diff --git a/assets/vue/views/glossary/GlossaryGenerateTerms.vue b/assets/vue/views/glossary/GlossaryGenerateTerms.vue
new file mode 100644
index 00000000000..e47f0d0f661
--- /dev/null
+++ b/assets/vue/views/glossary/GlossaryGenerateTerms.vue
@@ -0,0 +1,526 @@
+<template>
+  <LayoutFormGeneric>
+    <template #header>
+      <BaseIcon icon="robot" />
+      {{ t("Generate glossary terms") }}
+    </template>
+
+    <div class="space-y-5">
+      <!-- Permission / helper -->
+      <div class="rounded-2xl border border-gray-25 bg-white p-4 text-sm">
+        <div
+          v-if="!canEditGlossary"
+          class="text-danger"
+        >
+          {{ t("You do not have permission to generate glossary terms.") }}
+        </div>
+
+        <div
+          v-else
+          class="space-y-2"
+        >
+          <div class="flex flex-wrap items-center gap-2">
+            <span
+              class="inline-flex items-center gap-2 rounded-full border border-gray-25 bg-gray-15 px-3 py-1 text-xs"
+            >
+              <span class="font-semibold">1</span> {{ t("Generate") }}
+            </span>
+            <i
+              class="mdi mdi-arrow-right text-gray-40 text-base"
+              aria-hidden="true"
+            ></i>
+            <span
+              class="inline-flex items-center gap-2 rounded-full border border-gray-25 bg-gray-15 px-3 py-1 text-xs"
+            >
+              <span class="font-semibold">2</span> {{ t("Import") }}
+            </span>
+          </div>
+
+          <p class="text-gray-60 text-xs">
+            Generate glossary suggestions with AI, review/edit the result, then import it into the course glossary.
+          </p>
+        </div>
+      </div>
+
+      <!-- Settings -->
+      <div class="rounded-2xl border border-gray-25 bg-white p-4">
+        <div class="grid grid-cols-1 gap-4 md:grid-cols-3">
+          <div class="md:col-span-1">
+            <label class="block text-sm font-medium mb-1">
+              {{ t("Generate") }}
+            </label>
+
+            <div class="flex items-center gap-2">
+              <input
+                v-model.number="n"
+                type="number"
+                min="1"
+                max="200"
+                class="w-full rounded-xl border border-gray-25 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-gray-25"
+                :disabled="isBusy || !canEditGlossary"
+              />
+              <button
+                type="button"
+                class="shrink-0 rounded-xl border border-gray-25 px-3 py-2 text-sm hover:bg-gray-15 disabled:opacity-50 disabled:cursor-not-allowed"
+                :disabled="isBusy || !canEditGlossary"
+                @click="resetToDefaults"
+                title="Reset prompt to default"
+              >
+                <i
+                  class="mdi mdi-refresh"
+                  aria-hidden="true"
+                ></i>
+              </button>
+            </div>
+
+            <p class="text-xs text-gray-60 mt-1">1–200</p>
+          </div>
+
+          <div class="md:col-span-2">
+            <label class="block text-sm font-medium mb-1">AI provider</label>
+
+            <select
+              v-model="aiProvider"
+              class="w-full rounded-xl border border-gray-25 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-gray-25 disabled:opacity-50 disabled:cursor-not-allowed"
+              :disabled="isBusy || !canEditGlossary || providers.length === 0"
+            >
+              <option
+                v-for="p in providers"
+                :key="p"
+                :value="p"
+              >
+                {{ p }}
+              </option>
+            </select>
+
+            <p
+              v-if="providers.length === 0"
+              class="text-xs text-danger mt-1"
+            >
+              No text AI providers available.
+            </p>
+          </div>
+        </div>
+      </div>
+
+      <!-- Prompt -->
+      <div class="rounded-2xl border border-gray-25 bg-white p-4">
+        <div class="flex items-center justify-between gap-3 mb-2">
+          <label class="block text-sm font-medium">Prompt</label>
+
+          <div class="flex items-center gap-2">
+            <button
+              type="button"
+              class="rounded-xl border border-gray-25 px-3 py-2 text-xs hover:bg-gray-15 disabled:opacity-50 disabled:cursor-not-allowed"
+              :disabled="isBusy || !canEditGlossary"
+              @click="applyDefaultPrompt(true)"
+              title="Restore default prompt"
+            >
+              Restore default
+            </button>
+          </div>
+        </div>
+
+        <textarea
+          v-model="prompt"
+          rows="6"
+          class="w-full rounded-xl border border-gray-25 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-gray-25 disabled:opacity-50 disabled:cursor-not-allowed"
+          :disabled="isBusy || !canEditGlossary"
+          @input="promptDirty = true"
+        />
+        <p class="text-xs text-gray-60 mt-2">
+          Tip: keep the requested format (term line, definition next line, blank line between items) for best imports.
+        </p>
+
+        <div class="mt-4 flex flex-wrap gap-2">
+          <BaseButton
+            :label="t('Back')"
+            icon="back"
+            type="black"
+            :disabled="isBusy"
+            @click="goBack"
+          />
+          <BaseButton
+            :label="t('Generate')"
+            icon="send"
+            type="success"
+            :disabled="!canGenerate"
+            @click="runGeneration"
+          />
+        </div>
+      </div>
+
+      <!-- Result -->
+      <div
+        v-if="generatedText !== null"
+        class="rounded-2xl border border-gray-25 bg-white p-4"
+      >
+        <div class="flex items-center justify-between gap-3 mb-2">
+          <label class="block text-sm font-medium"> Result (edit before import) </label>
+
+          <span class="text-xs text-gray-60"> Detected terms: {{ detectedCount }} </span>
+        </div>
+
+        <textarea
+          v-model="generatedText"
+          rows="12"
+          class="w-full rounded-xl border border-gray-25 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-gray-25 disabled:opacity-50 disabled:cursor-not-allowed"
+          :disabled="isBusy || !canEditGlossary"
+        />
+
+        <div class="mt-4 flex flex-wrap items-center gap-2">
+          <BaseButton
+            :label="t('Import')"
+            icon="import"
+            type="success"
+            :disabled="!canImport"
+            @click="importTerms"
+          />
+
+          <span
+            v-if="importProgress"
+            class="text-xs text-gray-60"
+          >
+            Importing {{ importProgress.current }}/{{ importProgress.total }}…
+          </span>
+        </div>
+
+        <div
+          v-if="importReport"
+          class="mt-4 rounded-2xl border border-gray-25 bg-gray-15 p-4 text-sm"
+        >
+          <div class="grid grid-cols-1 gap-2 md:grid-cols-3">
+            <div><b>Created:</b> {{ importReport.created }}</div>
+            <div><b>Skipped:</b> {{ importReport.skipped }}</div>
+            <div><b>Errors:</b> {{ importReport.errors.length }}</div>
+          </div>
+
+          <div
+            v-if="importReport.errors.length"
+            class="mt-3"
+          >
+            <ul class="list-disc ml-5 space-y-1">
+              <li
+                v-for="(e, idx) in importReport.errors"
+                :key="idx"
+              >
+                {{ e }}
+              </li>
+            </ul>
+          </div>
+        </div>
+      </div>
+    </div>
+  </LayoutFormGeneric>
+</template>
+<script setup>
+import { computed, onMounted, ref, watch } from "vue"
+import { useRoute, useRouter } from "vue-router"
+import { useI18n } from "vue-i18n"
+import LayoutFormGeneric from "../../components/layout/LayoutFormGeneric.vue"
+import BaseIcon from "../../components/basecomponents/BaseIcon.vue"
+import BaseButton from "../../components/basecomponents/BaseButton.vue"
+import { useCidReq } from "../../composables/cidReq"
+import { RESOURCE_LINK_PUBLISHED } from "../../constants/entity/resourcelink"
+import glossaryService from "../../services/glossaryService"
+import { useNotification } from "../../composables/notification"
+import { useSecurityStore } from "../../store/securityStore"
+import { checkIsAllowedToEdit } from "../../composables/userPermissions"
+import { usePlatformConfig } from "../../store/platformConfig"
+import { useCidReqStore } from "../../store/cidReq"
+import { storeToRefs } from "pinia"
+
+const route = useRoute()
+const router = useRouter()
+const { t, locale } = useI18n()
+const notification = useNotification()
+const securityStore = useSecurityStore()
+const platform = usePlatformConfig()
+
+const cidReqStore = useCidReqStore()
+const { course, session } = storeToRefs(cidReqStore)
+
+const { cid, sid } = useCidReq()
+
+const isAllowedToEdit = ref(false)
+
+const canEditGlossary = computed(() => {
+  const inSession = !!route.query.sid
+  const basePermission = isAllowedToEdit.value || (securityStore.isCurrentTeacher && !inSession)
+  return basePermission && !platform.isStudentViewActive
+})
+
+const n = ref(15)
+const providers = ref([])
+const aiProvider = ref("")
+const prompt = ref("")
+const promptDirty = ref(false)
+
+const generatedText = ref(null)
+const importReport = ref(null)
+const importProgress = ref(null)
+const isBusy = ref(false)
+
+const parentResourceNodeId = ref(Number(route.params.node))
+
+const resourceLinkList = ref(
+  JSON.stringify([
+    {
+      sid,
+      cid,
+      visibility: RESOURCE_LINK_PUBLISHED,
+    },
+  ]),
+)
+
+const canGenerate = computed(() => {
+  return canEditGlossary.value && providers.value.length > 0 && prompt.value.trim().length > 0 && !isBusy.value
+})
+
+const detectedCount = computed(() => {
+  const terms = parseGlossaryTerms(generatedText.value || "")
+  return terms.length
+})
+
+const canImport = computed(() => {
+  return canEditGlossary.value && !!generatedText.value && generatedText.value.trim().length > 0 && !isBusy.value
+})
+
+function goBack() {
+  router.push({ name: "GlossaryList", query: route.query })
+}
+
+function escapeHtml(str) {
+  return (str ?? "")
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#039;")
+}
+
+/**
+ * Remove common markdown wrappers and surrounding quotes for titles.
+ * Keeps the actual text only (no **bold**, no quotes).
+ */
+function normalizeTermTitle(input) {
+  let s = String(input ?? "").trim()
+
+  // Remove leading list markers like "-", "*", "•", "1.", "1)"
+  s = s.replace(/^\s*(?:[-*•]+|\d+[.)])\s+/, "")
+
+  // Remove surrounding quotes (straight + smart quotes)
+  s = s.replace(/^[\s"'“”‘’]+/, "").replace(/[\s"'“”‘’]+$/, "")
+
+  // Remove surrounding markdown wrappers (**term**, __term__, `term`)
+  // Repeat a couple of times to handle nested wrappers.
+  for (let k = 0; k < 2; k++) {
+    s = s.replace(/^\*\*(.+)\*\*$/, "$1").trim()
+    s = s.replace(/^__(.+)__$/, "$1").trim()
+    s = s.replace(/^`(.+)`$/, "$1").trim()
+    s = s.replace(/^[\s"'“”‘’]+/, "").replace(/[\s"'“”‘’]+$/, "")
+  }
+
+  // Collapse whitespace
+  s = s.replace(/\s+/g, " ").trim()
+
+  return s
+}
+
+/**
+ * Conservative inline markdown cleanup for definitions (remove **bold** / __bold__ / `code`)
+ * while keeping most punctuation intact.
+ */
+function cleanupDefinitionText(input) {
+  let s = String(input ?? "")
+
+  s = s.replace(/\*\*(.+?)\*\*/g, "$1")
+  s = s.replace(/__(.+?)__/g, "$1")
+  s = s.replace(/`(.+?)`/g, "$1")
+
+  return s.trim()
+}
+
+/**
+ * Parse:
+ * Term line
+ * Definition lines...
+ * blank line between items
+ */
+function parseGlossaryTerms(text) {
+  const lines = String(text ?? "").split(/\r?\n/)
+  const items = []
+  const seen = new Set()
+
+  let i = 0
+  while (i < lines.length) {
+    while (i < lines.length && lines[i].trim() === "") i++
+    if (i >= lines.length) break
+
+    const rawTerm = lines[i].trim()
+    i++
+
+    const defLines = []
+    while (i < lines.length && lines[i].trim() !== "") {
+      defLines.push(lines[i])
+      i++
+    }
+
+    const term = normalizeTermTitle(rawTerm)
+    const definitionRaw = cleanupDefinitionText(defLines.join("\n").trim())
+
+    if (term && definitionRaw) {
+      const key = term.toLowerCase()
+      if (seen.has(key)) {
+        continue
+      }
+      seen.add(key)
+
+      // Store definition as safe HTML, preserve line breaks
+      const safe = escapeHtml(definitionRaw).replace(/\n/g, "<br>")
+      items.push({ title: term, description: safe })
+    }
+  }
+
+  return items
+}
+
+async function loadProviders() {
+  try {
+    const res = await glossaryService.getTextProviders()
+    providers.value = res.providers || []
+    aiProvider.value = providers.value[0] || ""
+  } catch (e) {
+    console.error("[GlossaryGenerateTerms] Error loading AI providers:", e)
+    providers.value = []
+  }
+}
+
+async function applyDefaultPrompt(force = false) {
+  try {
+    const res = await glossaryService.getDefaultPrompt({
+      cid: route.query.cid,
+      sid: route.query.sid,
+      n: n.value,
+      language: locale.value || "en",
+    })
+
+    if ((force || !promptDirty.value) && res?.prompt) {
+      prompt.value = res.prompt
+      if (force) {
+        promptDirty.value = false
+      }
+    }
+  } catch (e) {
+    console.error("[GlossaryGenerateTerms] Error loading default prompt:", e)
+
+    if (force || !promptDirty.value) {
+      const title = course.value?.title || course.value?.name || ""
+      prompt.value = `Generate ${n.value} glossary terms for a course on '${title}', each term on a single line, with its definition on the next line and one blank line between each term.`
+      if (force) {
+        promptDirty.value = false
+      }
+    }
+  }
+}
+
+function resetToDefaults() {
+  // Reset number and prompt to default suggestion (best effort)
+  n.value = 15
+  promptDirty.value = false
+  applyDefaultPrompt(true)
+}
+
+async function runGeneration() {
+  if (!canGenerate.value) return
+
+  isBusy.value = true
+  importReport.value = null
+  importProgress.value = null
+
+  try {
+    const res = await glossaryService.generateGlossaryTerms({
+      n: n.value,
+      language: locale.value || "en",
+      prompt: prompt.value,
+      cid: route.query.cid,
+      sid: route.query.sid,
+      ai_provider: aiProvider.value,
+      tool: "glossary",
+    })
+
+    generatedText.value = res.text || ""
+    notification.showSuccessNotification(t("Generate glossary terms"))
+  } catch (e) {
+    console.error("[GlossaryGenerateTerms] Error generating glossary terms:", e)
+    notification.showErrorNotification("AI glossary generation failed.")
+  } finally {
+    isBusy.value = false
+  }
+}
+
+async function importTerms() {
+  if (!canImport.value) return
+
+  isBusy.value = true
+  importReport.value = null
+
+  const terms = parseGlossaryTerms(generatedText.value)
+  if (terms.length === 0) {
+    notification.showErrorNotification("No valid terms detected. Ensure each term is followed by its definition.")
+    isBusy.value = false
+    return
+  }
+
+  let created = 0
+  let skipped = 0
+  const errors = []
+
+  importProgress.value = { current: 0, total: terms.length }
+
+  for (const item of terms) {
+    importProgress.value.current++
+
+    const postData = {
+      title: item.title,
+      description: item.description,
+      parentResourceNodeId: parentResourceNodeId.value,
+      resourceLinkList: resourceLinkList.value,
+      sid: route.query.sid,
+      cid: route.query.cid,
+    }
+
+    try {
+      await glossaryService.createGlossaryTerm(postData)
+      created++
+    } catch (e) {
+      skipped++
+      const msg = e?.response?.data?.message || e?.message || "Unknown error"
+      errors.push(`${item.title}: ${msg}`)
+    }
+  }
+
+  importReport.value = { created, skipped, errors }
+  importProgress.value = null
+
+  if (created > 0) {
+    notification.showSuccessNotification("Glossary terms imported.")
+  } else {
+    notification.showErrorNotification("No terms were imported.")
+  }
+
+  isBusy.value = false
+}
+
+watch(n, async () => {
+  // Refresh default prompt when N changes (only if the user didn't customize prompt)
+  await applyDefaultPrompt(false)
+})
+
+onMounted(async () => {
+  isAllowedToEdit.value = await checkIsAllowedToEdit(true, true, true)
+
+  await loadProviders()
+  await applyDefaultPrompt(false)
+})
+</script>
diff --git a/assets/vue/views/glossary/GlossaryList.vue b/assets/vue/views/glossary/GlossaryList.vue
index 08a1628f84c..f85e7a3ee1c 100644
--- a/assets/vue/views/glossary/GlossaryList.vue
+++ b/assets/vue/views/glossary/GlossaryList.vue
@@ -16,6 +16,13 @@
           type="black"
           @click="addNewTerm"
         />
+        <BaseButton
+          v-if="canUseAiGlossaryGenerator"
+          :label="t('Generate glossary terms')"
+          icon="robot"
+          type="black"
+          @click="generateGlossaryTerms"
+        />
         <BaseButton
           :label="t('Import glossary')"
           icon="import"
@@ -67,7 +74,6 @@
     </div>
 
     <div v-if="glossaries.length === 0 && !searchBoxTouched && !isLoading">
-      <!-- Render the image and create button -->
       <EmptyState
         icon="glossary"
         summary="Add your first term glossary to this course"
@@ -135,6 +141,7 @@ import { checkIsAllowedToEdit } from "../../composables/userPermissions"
 import { useCidReqStore } from "../../store/cidReq"
 import { storeToRefs } from "pinia"
 import { usePlatformConfig } from "../../store/platformConfig"
+import { useCourseSettings } from "../../store/courseSettingStore"
 import SectionHeader from "../../components/layout/SectionHeader.vue"
 import StudentViewButton from "../../components/StudentViewButton.vue"
 
@@ -143,12 +150,12 @@ const router = useRouter()
 const securityStore = useSecurityStore()
 const notifications = useNotification()
 const platform = usePlatformConfig()
+const courseSettingsStore = useCourseSettings()
 
 const { t } = useI18n()
 
 const cidReqStore = useCidReqStore()
-
-const { course } = storeToRefs(cidReqStore)
+const { course, session } = storeToRefs(cidReqStore)
 
 const isLoading = ref(true)
 const isSearchLoading = ref(false)
@@ -161,22 +168,19 @@ const resourceLinkList = ref(
     {
       sid: route.query.sid,
       cid: route.query.cid,
-      visibility: RESOURCE_LINK_PUBLISHED, // visible by default
+      visibility: RESOURCE_LINK_PUBLISHED,
     },
   ]),
 )
 
-const isCurrentTeacher = securityStore.isCurrentTeacher
-
 const glossaries = ref([])
 const view = ref("list")
 
 const isDeleteItemDialogVisible = ref(false)
 const termToDelete = ref(null)
+
 const termToDeleteString = computed(() => {
-  if (termToDelete.value === null) {
-    return ""
-  }
+  if (termToDelete.value === null) return ""
   return termToDelete.value.title
 })
 
@@ -188,14 +192,36 @@ const canEditGlossary = computed(() => {
   return basePermission && !platform.isStudentViewActive
 })
 
-const isAdminOrTeacher = computed(() => securityStore.isAdmin || securityStore.isTeacher)
+async function loadCourseSettingsIfPossible() {
+  const courseId = course.value?.id
+  const sessionId = session.value?.id
+
+  if (!courseId) {
+    return
+  }
+
+  try {
+    await courseSettingsStore.loadCourseSettings(courseId, sessionId)
+  } catch (err) {
+    console.error("[Glossary] loadCourseSettings FAILED:", err)
+  }
+}
 
 onMounted(async () => {
   isLoading.value = true
+
+  await loadCourseSettingsIfPossible()
   await fetchGlossaries()
   await onStudentViewChange()
 })
 
+watch(
+  () => [course.value?.id, session.value?.id],
+  async () => {
+    await loadCourseSettingsIfPossible()
+  },
+)
+
 watch(
   () => platform.isStudentViewActive,
   async () => {
@@ -215,6 +241,31 @@ const debouncedSearch = debounce(() => {
   fetchGlossaries()
 }, 500)
 
+const aiHelpersEnabled = computed(() => {
+  const v = String(platform.getSetting("ai_helpers.enable_ai_helpers"))
+  return v === "true"
+})
+
+const glossaryGeneratorEnabled = computed(() => {
+  const v =
+    courseSettingsStore?.getSetting?.("glossary_terms_generator") ??
+    courseSettingsStore?.getSetting?.("glossary_terms_generators")
+
+  return String(v) === "true"
+})
+
+const canUseAiGlossaryGenerator = computed(() => {
+  return !!(canEditGlossary.value && aiHelpersEnabled.value && glossaryGeneratorEnabled.value)
+})
+
+function generateGlossaryTerms() {
+  if (!canEditGlossary.value) return
+  router.push({
+    name: "GenerateGlossaryTerms",
+    query: route.query,
+  })
+}
+
 function addNewTerm() {
   if (!canEditGlossary.value) return
   router.push({
@@ -247,7 +298,7 @@ async function deleteTerm() {
     isDeleteItemDialogVisible.value = false
     await fetchGlossaries()
   } catch (error) {
-    console.error("Error deleting term:", error)
+    console.error("[Glossary] Error deleting term:", error)
     notifications.showErrorNotification(t("Could not delete term"))
   }
 }
@@ -283,7 +334,7 @@ async function exportToDocuments() {
     await glossaryService.exportToDocuments(postData)
     notifications.showSuccessNotification(t("Exported to documents"))
   } catch (error) {
-    console.error("Error fetching links:", error)
+    console.error("[Glossary] Error exporting to documents:", error)
     notifications.showErrorNotification(t("Could not export to documents"))
   }
 }
@@ -301,7 +352,7 @@ async function fetchGlossaries() {
   try {
     glossaries.value = await glossaryService.getGlossaryTerms(params)
   } catch (error) {
-    console.error("Error fetching links:", error)
+    console.error("[Glossary] Error fetching glossary terms:", error)
     notifications.showErrorNotification(t("Could not fetch glossary terms"))
   } finally {
     isLoading.value = false
diff --git a/src/CoreBundle/Controller/AiController.php b/src/CoreBundle/Controller/AiController.php
index 19badccf47c..02ead206ffe 100644
--- a/src/CoreBundle/Controller/AiController.php
+++ b/src/CoreBundle/Controller/AiController.php
@@ -9,10 +9,13 @@
 use Chamilo\CoreBundle\AiProvider\AiImageProviderInterface;
 use Chamilo\CoreBundle\AiProvider\AiProviderFactory;
 use Chamilo\CoreBundle\AiProvider\AiVideoProviderInterface;
+use Chamilo\CoreBundle\Entity\Course;
 use Chamilo\CoreBundle\Entity\TrackEDefault;
 use Chamilo\CoreBundle\Entity\TrackEExercise;
 use Chamilo\CoreBundle\Repository\TrackEAttemptRepository;
+use Chamilo\CourseBundle\Entity\CGlossary;
 use Chamilo\CourseBundle\Entity\CQuizAnswer;
+use Chamilo\CourseBundle\Repository\CGlossaryRepository;
 use DateTime;
 use Doctrine\ORM\EntityManagerInterface;
 use Exception;
@@ -23,8 +26,10 @@
 use Symfony\Component\Routing\Attribute\Route;
 use Symfony\Component\Security\Core\Exception\AccessDeniedException;
 use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\Translation\TranslatorInterface;
 
 use const FILTER_SANITIZE_NUMBER_INT;
+use const FILTER_VALIDATE_URL;
 
 #[Route('/ai')]
 class AiController extends AbstractController
@@ -34,8 +39,175 @@ public function __construct(
         private readonly TrackEAttemptRepository $attemptRepo,
         private readonly EntityManagerInterface $em,
         private readonly HttpClientInterface $httpClient,
+        private readonly TranslatorInterface $translator,
     ) {}
 
+    #[Route('/text_providers', name: 'chamilo_core_ai_text_providers', methods: ['GET'])]
+    public function textProviders(): JsonResponse
+    {
+        try {
+            $this->denyIfNotTeacher();
+        } catch (AccessDeniedException $e) {
+            return new JsonResponse(['providers' => []], 403);
+        }
+
+        return new JsonResponse([
+            'providers' => array_values($this->aiProviderFactory->getProvidersForType('text')),
+        ]);
+    }
+
+    #[Route('/glossary_default_prompt', name: 'chamilo_core_ai_glossary_default_prompt', methods: ['GET'])]
+    public function glossaryDefaultPrompt(Request $request): JsonResponse
+    {
+        try {
+            $this->denyIfNotTeacher();
+        } catch (AccessDeniedException $e) {
+            return new JsonResponse(['prompt' => ''], 403);
+        }
+
+        $cid = (int) $request->query->get('cid', 0);
+        $sid = (int) $request->query->get('sid', 0);
+        $n = (int) $request->query->get('n', 15);
+
+        if ($n < 1) {
+            $n = 1;
+        }
+        if ($n > 200) {
+            $n = 200;
+        }
+
+        if (0 === $cid) {
+            return new JsonResponse(['prompt' => ''], 400);
+        }
+
+        /** @var Course|null $course */
+        $course = $this->em->getRepository(Course::class)->find($cid);
+        if (null === $course) {
+            return new JsonResponse(['prompt' => ''], 404);
+        }
+
+        $courseTitle = (string) $course->getTitle();
+        $desc = $this->getGenericCourseDescription($cid, $sid);
+
+        $base = $this->translator->trans(
+            "Generate %d glossary terms for a course on '%s', each term on a single line, with its definition on the next line and one blank line between each term."
+        );
+
+        $prompt = sprintf($base, $n, $courseTitle);
+
+        if ('' !== $desc) {
+            $descPrefix = $this->translator->trans(
+                "This is a short description of the course '%s'."
+            );
+            $prompt .= ' '.sprintf($descPrefix, $courseTitle).' '.$desc;
+        }
+
+        return new JsonResponse(['prompt' => $prompt]);
+    }
+
+    #[Route('/generate_glossary_terms', name: 'chamilo_core_ai_generate_glossary_terms', methods: ['POST'])]
+    public function generateGlossaryTerms(Request $request): JsonResponse
+    {
+        try {
+            $this->denyIfNotTeacher();
+        } catch (AccessDeniedException $e) {
+            return new JsonResponse([
+                'success' => false,
+                'text' => 'Access denied.',
+            ], 403);
+        }
+
+        $data = json_decode($request->getContent(), true);
+        if (!is_array($data)) {
+            return new JsonResponse([
+                'success' => false,
+                'text' => 'Invalid JSON payload.',
+            ], 400);
+        }
+
+        $n = (int) ($data['n'] ?? 15);
+        $language = (string) ($data['language'] ?? 'en');
+        $prompt = trim((string) ($data['prompt'] ?? ''));
+        $providerName = isset($data['ai_provider']) ? (string) $data['ai_provider'] : null;
+        $cid = (int) ($data['cid'] ?? 0);
+        $toolName = trim((string) ($data['tool'] ?? 'glossary'));
+
+        if ($n < 1) {
+            $n = 1;
+        }
+        if ($n > 200) {
+            $n = 200;
+        }
+
+        if (0 === $cid || '' === $prompt) {
+            return new JsonResponse([
+                'success' => false,
+                'text' => 'Invalid request parameters.',
+            ], 400);
+        }
+
+        /** @var Course|null $course */
+        $course = $this->em->getRepository(Course::class)->find($cid);
+        if (null === $course) {
+            return new JsonResponse([
+                'success' => false,
+                'text' => 'Course not found.',
+            ], 404);
+        }
+
+        try {
+            $provider = $this->aiProviderFactory->getProvider($providerName, 'text');
+
+            if (!is_object($provider) || !method_exists($provider, 'generateText')) {
+                return new JsonResponse([
+                    'success' => false,
+                    'text' => 'Selected AI provider does not support text generation.',
+                ], 400);
+            }
+
+            // Preferred signature: generateText(string $prompt, array $options = []): string
+            try {
+                $raw = (string) $provider->generateText($prompt, [
+                    'language' => $language,
+                    'n' => $n,
+                    'tool' => $toolName,
+                ]);
+            } catch (\TypeError $e) {
+                // Backward compatibility: generateText(string $prompt, string $language): string
+                $raw = (string) $provider->generateText($prompt, $language);
+            }
+
+            $raw = trim($raw);
+
+            if ('' === $raw) {
+                return new JsonResponse([
+                    'success' => false,
+                    'text' => 'AI request returned an empty response.',
+                ], 500);
+            }
+
+            if (str_starts_with($raw, 'Error:')) {
+                $msg = trim((string) preg_replace('/^Error:\s*/', '', $raw));
+                return new JsonResponse([
+                    'success' => false,
+                    'text' => $msg !== '' ? $msg : $raw,
+                ], 500);
+            }
+
+            return new JsonResponse([
+                'success' => true,
+                'text' => $raw,
+            ]);
+        } catch (\Throwable $e) {
+            error_log('[AI][glossary] Generation failed: '.$e->getMessage());
+
+            return new JsonResponse([
+                'success' => false,
+                'text' => 'An error occurred while generating glossary terms.',
+            ], 500);
+        }
+    }
+
     #[Route('/capabilities', name: 'chamilo_core_ai_capabilities', methods: ['GET'])]
     public function capabilities(): JsonResponse
     {
@@ -332,26 +504,15 @@ public function generateImage(Request $request): JsonResponse
                 ]);
             }
 
-            $content = isset($result['content']) && \is_string($result['content']) ? trim($result['content']) : '';
             $url = isset($result['url']) && \is_string($result['url']) ? trim($result['url']) : '';
-            $isBase64 = (bool) ($result['is_base64'] ?? false);
-            $contentType = (string) ($result['content_type'] ?? 'image/png');
-
-            if (!$isBase64 && '' === $content && '' !== $url) {
-                try {
-                    $fetched = $this->fetchUrlAsBase64($url, 10 * 1024 * 1024);
-                    $result['content'] = $fetched['content'];
-                    $result['content_type'] = $fetched['content_type'];
-                    $result['is_base64'] = true;
-                    $result['url'] = null;
-                } catch (\Throwable $e) {
-                    error_log('[AI][image] Failed to fetch image URL as base64: '.$e->getMessage());
+            $content = isset($result['content']) && \is_string($result['content']) ? trim($result['content']) : '';
 
-                    return new JsonResponse([
-                        'success' => false,
-                        'text' => 'Image was generated, but could not be converted to base64 for preview.',
-                    ], 500);
-                }
+            if ('' === $content && '' !== $url && false === (bool) ($result['is_base64'] ?? false)) {
+                $fetched = $this->fetchUrlAsBase64($url, 10 * 1024 * 1024);
+                $result['content'] = $fetched['content'];
+                $result['content_type'] = $fetched['content_type'];
+                $result['is_base64'] = true;
+                $result['url'] = null;
             }
 
             $text = '';
@@ -404,7 +565,6 @@ public function generateVideo(Request $request): JsonResponse
             $toolName = trim((string) ($data['tool'] ?? 'document'));
             $aiProvider = $data['ai_provider'] ?? null;
 
-            // Optional overrides
             $seconds = isset($data['seconds']) ? trim((string) $data['seconds']) : null;
             $size = isset($data['size']) ? trim((string) $data['size']) : null;
 
@@ -455,7 +615,7 @@ public function generateVideo(Request $request): JsonResponse
                     ];
 
                     if (null !== $seconds && $seconds !== '') {
-                        $options['seconds'] = $seconds; // must be string: "4"|"8"|"12"
+                        $options['seconds'] = $seconds;
                     }
                     if (null !== $size && $size !== '') {
                         $options['size'] = $size;
@@ -501,11 +661,11 @@ public function generateVideo(Request $request): JsonResponse
                     : 'All video providers failed.'
                 );
 
-                $statusCode = $this->mapVideoErrorToHttpStatus($message);
+                $statusCode = $this->mapVideoErrorToHttpStatus((string) $message);
 
                 return new JsonResponse([
                     'success' => false,
-                    'text' => $message,
+                    'text' => (string) $message,
                     'providers_tried' => $providersToTry,
                     'errors' => $errors,
                 ], $statusCode);
@@ -557,7 +717,7 @@ public function generateVideo(Request $request): JsonResponse
             $url = isset($result['url']) && \is_string($result['url']) ? trim($result['url']) : '';
             $content = isset($result['content']) && \is_string($result['content']) ? trim($result['content']) : '';
 
-            if (empty($content) && !empty($url) && false === (bool) ($result['is_base64'] ?? false)) {
+            if ('' === $content && '' !== $url && false === (bool) ($result['is_base64'] ?? false)) {
                 try {
                     $fetched = $this->fetchUrlAsBase64($url, 15 * 1024 * 1024);
                     $result['content'] = $fetched['content'];
@@ -596,73 +756,6 @@ public function generateVideo(Request $request): JsonResponse
         }
     }
 
-    /**
-     * Returns a reasonable HTTP status code for known provider errors.
-     */
-    private function mapVideoErrorToHttpStatus(string $message): int
-    {
-        $m = strtolower(trim($message));
-
-        if ($m === '') {
-            return 500;
-        }
-
-        // OpenAI typical cases
-        if (str_contains($m, 'invalid api key') || str_contains($m, 'incorrect api key') || str_contains($m, 'unauthorized')) {
-            return 401;
-        }
-
-        if (str_contains($m, 'must be verified') || str_contains($m, 'verify organization') || str_contains($m, 'organization must be verified')) {
-            return 403;
-        }
-
-        if (str_contains($m, 'does not have access') || str_contains($m, 'not authorized') || str_contains($m, 'permission')) {
-            return 403;
-        }
-
-        if (str_contains($m, 'rate limit') || str_contains($m, 'too many requests')) {
-            return 429;
-        }
-
-        if (str_contains($m, 'insufficient_quota') || str_contains($m, 'quota')) {
-            return 402;
-        }
-
-        return 500;
-    }
-
-    private function looksLikeUrl(string $s): bool
-    {
-        $s = trim($s);
-        if ($s === '') {
-            return false;
-        }
-
-        return (bool) filter_var($s, FILTER_VALIDATE_URL);
-    }
-
-    private function looksLikeBase64(string $s): bool
-    {
-        $s = trim($s);
-        if ($s === '' || strlen($s) < 64) {
-            return false;
-        }
-
-        // Basic base64 charset check
-        if (!preg_match('/^[A-Za-z0-9+\/=\r\n]+$/', $s)) {
-            return false;
-        }
-
-        // Validate decode (strict)
-        $decoded = base64_decode($s, true);
-        if ($decoded === false) {
-            return false;
-        }
-
-        // Video will likely be binary; just ensure not empty
-        return $decoded !== '';
-    }
-
     #[Route('/video_job/{id}', name: 'chamilo_core_ai_video_job', methods: ['GET'])]
     public function videoJobStatus(string $id, Request $request): JsonResponse
     {
@@ -756,13 +849,77 @@ public function videoJobStatus(string $id, Request $request): JsonResponse
         }
     }
 
+    /**
+     * Returns a reasonable HTTP status code for known provider errors.
+     */
+    private function mapVideoErrorToHttpStatus(string $message): int
+    {
+        $m = strtolower(trim($message));
+
+        if ('' === $m) {
+            return 500;
+        }
+
+        if (str_contains($m, 'invalid api key') || str_contains($m, 'incorrect api key') || str_contains($m, 'unauthorized')) {
+            return 401;
+        }
+
+        if (str_contains($m, 'must be verified') || str_contains($m, 'verify organization') || str_contains($m, 'organization must be verified')) {
+            return 403;
+        }
+
+        if (str_contains($m, 'does not have access') || str_contains($m, 'not authorized') || str_contains($m, 'permission')) {
+            return 403;
+        }
+
+        if (str_contains($m, 'rate limit') || str_contains($m, 'too many requests')) {
+            return 429;
+        }
+
+        if (str_contains($m, 'insufficient_quota') || str_contains($m, 'quota')) {
+            return 402;
+        }
+
+        return 500;
+    }
+
+    private function looksLikeUrl(string $s): bool
+    {
+        $s = trim($s);
+        if ('' === $s) {
+            return false;
+        }
+
+        return (bool) filter_var($s, FILTER_VALIDATE_URL);
+    }
+
+    private function looksLikeBase64(string $s): bool
+    {
+        $s = trim($s);
+        if ('' === $s || strlen($s) < 64) {
+            return false;
+        }
+
+        if (!preg_match('/^[A-Za-z0-9+\/=\r\n]+$/', $s)) {
+            return false;
+        }
+
+        $decoded = base64_decode($s, true);
+        if (false === $decoded) {
+            return false;
+        }
+
+        return '' !== $decoded;
+    }
+
     private function denyIfNotTeacher(): void
     {
-        if (!$this->isGranted('ROLE_CURRENT_COURSE_TEACHER')
+        if (
+            !$this->isGranted('ROLE_CURRENT_COURSE_TEACHER')
             && !$this->isGranted('ROLE_CURRENT_COURSE_SESSION_TEACHER')
             && !$this->isGranted('ROLE_TEACHER')
         ) {
-            throw new \RuntimeException('Access denied.');
+            throw new AccessDeniedException('Access denied.');
         }
     }
 
@@ -823,7 +980,6 @@ private function isSafeRemoteUrl(string $url): bool
 
         $ip = gethostbyname($host);
         if (filter_var($ip, FILTER_VALIDATE_IP)) {
-            // Block private/reserved ranges (basic SSRF hardening).
             if (!filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE)) {
                 return false;
             }
@@ -831,4 +987,19 @@ private function isSafeRemoteUrl(string $url): bool
 
         return true;
     }
+
+    private function getGenericCourseDescription(int $cid, int $sid): string
+    {
+        try {
+            $repo = $this->em->getRepository(CGlossary::class);
+
+            if ($repo instanceof CGlossaryRepository) {
+                return $repo->getGenericCourseDescription($cid, $sid);
+            }
+        } catch (\Throwable) {
+            // Ignore repository instantiation differences.
+        }
+
+        return '';
+    }
 }
diff --git a/src/CoreBundle/Controller/PlatformConfigurationController.php b/src/CoreBundle/Controller/PlatformConfigurationController.php
index 9886d57619d..360a5dc8863 100644
--- a/src/CoreBundle/Controller/PlatformConfigurationController.php
+++ b/src/CoreBundle/Controller/PlatformConfigurationController.php
@@ -228,6 +228,7 @@ public function courseSettingsList(
             'learning_path_generator' => $courseSettingsManager->getCourseSettingValue('learning_path_generator'),
             'image_generator' => $courseSettingsManager->getCourseSettingValue('image_generator'),
             'video_generator' => $courseSettingsManager->getCourseSettingValue('video_generator'),
+            'glossary_terms_generator' => $courseSettingsManager->getCourseSettingValue('glossary_terms_generator'),
             'display_info_advance_inside_homecourse' => $courseSettingsManager->getCourseSettingValue('display_info_advance_inside_homecourse'),
         ];
 
diff --git a/src/CourseBundle/Repository/CGlossaryRepository.php b/src/CourseBundle/Repository/CGlossaryRepository.php
index 45a72c2e1ff..9abbfd79c61 100644
--- a/src/CourseBundle/Repository/CGlossaryRepository.php
+++ b/src/CourseBundle/Repository/CGlossaryRepository.php
@@ -15,15 +15,20 @@
 use Chamilo\CoreBundle\Repository\ResourceWithLinkInterface;
 use Chamilo\CourseBundle\Entity\CGlossary;
 use Chamilo\CourseBundle\Entity\CGroup;
+use Doctrine\DBAL\Connection;
 use Doctrine\ORM\QueryBuilder;
 use Doctrine\Persistence\ManagerRegistry;
 use Symfony\Component\Routing\RouterInterface;
 
 final class CGlossaryRepository extends ResourceRepository implements ResourceWithLinkInterface
 {
+    private Connection $connection;
+
     public function __construct(ManagerRegistry $registry)
     {
         parent::__construct($registry, CGlossary::class);
+
+        $this->connection = $this->getEntityManager()->getConnection();
     }
 
     /*public function getResources(User $user, ResourceNode $parentNode, Course $course = null, Session $session = null, CGroup $group = null): QueryBuilder
@@ -42,4 +47,52 @@ public function getLink(ResourceInterface $resource, RouterInterface $router, ar
 
         return '/main/glossary/index.php?'.http_build_query($params);
     }
+
+    /**
+     * Best-effort extraction from Chamilo "course description" tool table.
+     * Tries the session-specific record first (if sid>0), then session_id=0.
+     *
+     * Returns plain text (HTML stripped, whitespace normalized).
+     */
+    public function getGenericCourseDescription(int $cid, int $sid = 0): string
+    {
+        if ($cid <= 0) {
+            return '';
+        }
+
+        $candidates = [];
+        if ($sid > 0) {
+            $candidates[] = $sid;
+        }
+        $candidates[] = 0;
+
+        foreach ($candidates as $sessionId) {
+            try {
+                $row = $this->connection->fetchAssociative(
+                    "SELECT content
+                     FROM c_course_description
+                     WHERE c_id = :cid
+                       AND session_id = :sid
+                     ORDER BY id DESC
+                     LIMIT 1",
+                    [
+                        'cid' => $cid,
+                        'sid' => (int) $sessionId,
+                    ]
+                );
+
+                if (!empty($row['content'])) {
+                    $txt = strip_tags((string) $row['content']);
+                    $txt = preg_replace('/\s+/', ' ', $txt ?? '') ?? '';
+
+                    return trim($txt);
+                }
+            } catch (\Throwable) {
+                // Some installs may not have this table or may differ; ignore.
+                continue;
+            }
+        }
+
+        return '';
+    }
 }