@windward/core 0.21.0 → 0.22.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## Release [0.22.0] - 2025-08-25
+
+* Merged in bugfix/LE-2075-the-panel-of-the-text-block-isnt (pull request #427)
+* Merged in bug-fix/LE-2060/llm-character-limit-validation (pull request #421)
+* Merged in bugfix/LE-2031-open-response-download-collate-q (pull request #422)
+* Merged in bugfix/LE-1960-video-using-urls-as-a-source (pull request #423)
+* Merged release/0.22.0 into bugfix/LE-1960-video-using-urls-as-a-source
+* Merged in bugfix/LE-2057-save-button-disappeared-again-on (pull request #419)
+* Merged release/0.22.0 into bugfix/LE-1960-video-using-urls-as-a-source
+* Merged in feature/LE-2036/word-jumble-gen (pull request #420)
+* Merged in feature/LE-1997/scenario-gen (pull request #416)
+* Merged in bugfix/LE-1928-user-upload-allowed-file-types (pull request #415)
+* Merged release/0.21.0 into bugfix/LE-1960-video-using-urls-as-a-source
+* Merged release/0.21.0 into bugfix/LE-1928-user-upload-allowed-file-types
+
+## Hotfix [0.21.1] created - 2025-08-20
+
+
 ## Release [0.21.0] - 2025-08-01
 
 * Merged in feature/LE-2045/lableing-fixes (pull request #414)

package/components/Content/Blocks/OpenResponseCollate.vue

@@ -82,10 +82,9 @@ export default {
                     .get()
 
                 let collated = ''
-                // sort by order on the page
-                const sortedStates = userState.sort((a, b) =>
-                    a.content_block.order < b.content_block.order ? -1 : 1
-                )
+
+                // sort by states by page order in course then by order on the page
+                const sortedStates = this.sortStates(userState)
 
                 sortedStates.forEach((state) => {
                     // Prepend the prompt from the state if include prompts is enabled
@@ -150,6 +149,30 @@ export default {
                 )
             }
         },
+        sortStates(states) {
+            // order by appearance on page
+            states = states.sort((a, b) =>
+                a.content_block.order < b.content_block.order ? -1 : 1
+            )
+            const contentBlocksByPage = []
+            // get page order in course
+            const contentBlockTree = this.$ContentService.getFlatTree()
+            // get homepage and add to front
+            const homePage = this.$ContentService.getHomepage()
+            if (homePage !== null) {
+                contentBlockTree.unshift(homePage)
+            }
+            // order states by page in the course
+            contentBlockTree.forEach((block) => {
+                states.forEach((state) => {
+                    if (state.content_block?.content_id === block.content?.id) {
+                        contentBlocksByPage.push(state)
+                    }
+                })
+            })
+
+            return contentBlocksByPage
+        },
         generateDocument(htmlBody, filename = '') {
             // Specify file name. If one isn't supplied then a default name of `exported_document_YYYY-MM-DD.doc` is used
             filename = filename

package/components/Content/Blocks/Video.vue

@@ -55,24 +55,24 @@
                 @seeking="onSeeking"
                 @timeupdate="onTimeupdate"
             >
-            <template #no-source>
-                <v-card>
-                    <v-card-title class="justify-center">
-                        <v-icon class="mr-2">mdi-cloud-question</v-icon>
-                        {{
+                <template #no-source>
+                    <v-card>
+                        <v-card-title class="justify-center">
+                            <v-icon class="mr-2">mdi-cloud-question</v-icon>
+                            {{
+                                $t(
+                                    'windward.core.components.content.blocks.video.not_configured_title'
+                                )
+                            }}
+                        </v-card-title>
+                        <v-card-text>{{
                             $t(
-                                'windward.core.components.content.blocks.video.not_configured_title'
+                                'windward.core.components.content.blocks.video.edit_prompt'
                             )
-                        }}
-                    </v-card-title>
-                    <v-card-text>{{
-                        $t(
-                            'windward.core.components.content.blocks.video.edit_prompt'
-                        )
-                    }}</v-card-text>
-                </v-card>
-            </template>
-        </VuetifyPlayer>
+                        }}</v-card-text>
+                    </v-card>
+                </template>
+            </VuetifyPlayer>
         </div>
         <!--    display first note in the playlist for now    -->
         <v-alert
@@ -103,6 +103,45 @@ export default {
         VuetifyPlayer,
     },
     extends: BaseContentBlock,
+    data() {
+        return {
+            fileTab: null,
+            // Default config settings
+            defaultConfig: {
+                title: '',
+                instructions: '',
+                // Default settings for new blocks
+                // This will be overridden in beforeMount()
+                type: 'auto', // Allowed auto|video|audio. In audio mode the player has a max-height of 40px. Auto will switch between the other types when needed
+                attributes: {
+                    autoplay: false, // Autoplay on load. It's in the spec but DON'T USE THIS
+                    autopictureinpicture: false, // Start with picture in picture mode
+                    controls: true, // Show video controls. When false only play/pause allowed but clicking on the video itself
+                    controlslist: 'nodownload noremoteplayback', // Space separated string per <video>. Allowed 'nodownload nofullscreen noremoteplayback'
+                    crossorigin: 'anonymous',
+                    disablepictureinpicture: true, // Shows the picture in picture button
+                    disableremoteplayback: true, // Shows the remote playback button but functionality does not exist when clicked
+                    height: 'auto',
+                    width: '100%',
+                    rewind: true, // Enabled the rewind 10s button
+                    loop: false, // Loop the video on completion
+                    muted: false, // Start the video muted
+                    playsinline: false, // Force inline & disable fullscreen
+                    poster: '', // Overridden with the playlist.poster if one is set there
+                    preload: '',
+                    captionsmenu: true, // Show the captions below the video
+                    playlistmenu: true, // Show the playlist menu if there's multiple videos
+                    playlistautoadvance: true, // Play the next source group
+                    playbackrates: [0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2], // Default playback speeds
+                },
+                playlist: [],
+            },
+            tracking: {
+                hasSkipped: false,
+                percentComplete: 0,
+            },
+        }
+    },
     computed: {
         hasSource() {
             // __isDirty is used to communicate from the settings panel that a source / caption
@@ -312,83 +351,6 @@ export default {
             },
         },
     },
-    data() {
-        return {
-            fileTab: null,
-            // Default config settings
-            defaultConfig: {
-                title: '',
-                instructions: '',
-                // Default settings for new blocks
-                // This will be overridden in beforeMount()
-                type: 'auto', // Allowed auto|video|audio. In audio mode the player has a max-height of 40px. Auto will switch between the other types when needed
-                attributes: {
-                    autoplay: false, // Autoplay on load. It's in the spec but DON'T USE THIS
-                    autopictureinpicture: false, // Start with picture in picture mode
-                    controls: true, // Show video controls. When false only play/pause allowed but clicking on the video itself
-                    controlslist: 'nodownload noremoteplayback', // Space separated string per <video>. Allowed 'nodownload nofullscreen noremoteplayback'
-                    crossorigin: 'anonymous',
-                    disablepictureinpicture: true, // Shows the picture in picture button
-                    disableremoteplayback: true, // Shows the remote playback button but functionality does not exist when clicked
-                    height: 'auto',
-                    width: '100%',
-                    rewind: true, // Enabled the rewind 10s button
-                    loop: false, // Loop the video on completion
-                    muted: false, // Start the video muted
-                    playsinline: false, // Force inline & disable fullscreen
-                    poster: '', // Overridden with the playlist.poster if one is set there
-                    preload: '',
-                    captionsmenu: true, // Show the captions below the video
-                    playlistmenu: true, // Show the playlist menu if there's multiple videos
-                    playlistautoadvance: true, // Play the next source group
-                    playbackrates: [0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2], // Default playback speeds
-                },
-                playlist: [
-                    /*{
-                        name: '', // The video name to appear on playlists
-                        poster: '', // A video specific poster in the playlist
-                        ads: [
-                            {
-                            play_at_percent: 0,
-                            sources: [
-                                {
-                                    src: "https://domain.test/ad_example.mp4",
-                                    type: "video/mp4",
-                                },
-                            ],
-                            tracks: [
-                                {
-                                    src: "https://domain.test/ad_example-US.vtt",
-                                    kind: "captions",
-                                    srclang: "en-US",
-                                    default: true,
-                                },
-                            ],
-                        },
-                        ],
-                        sources: [
-                            {
-                                src: "https://domain.test/example.mp4",
-                                type: "video/mp4",
-                            },
-                        ],
-                        tracks: [
-                            {
-                                src: "https://domain.test/example_en-US.vtt",
-                                kind: "captions",
-                                srclang: "en-US",
-                                default: true,
-                            },
-                        ],
-                    },*/
-                ],
-            },
-            tracking: {
-                hasSkipped: false,
-                percentComplete: 0,
-            },
-        }
-    },
     beforeMount() {
         // Apply the default config
         if (_.isEmpty(this.block.metadata.config)) {

package/components/Settings/ScenarioChoiceSettings.vue

@@ -129,6 +129,20 @@
                 </v-btn>
             </v-row>
         </v-container>
+        
+        <v-container class="pa-4 mb-6">
+            <v-row>
+                <v-col cols="12">
+                    <GenerateAIQuestionButton
+                        :course="course"
+                        :content="currentContent"
+                        :block="block"
+                        question-type="scenario_game"
+                        @click:generate="onGeneratedScenarioGame"
+                    ></GenerateAIQuestionButton>
+                </v-col>
+            </v-row>
+        </v-container>
 
         <DialogBox
             v-model="showLinkDialog"
@@ -196,6 +210,7 @@ import SortableExpansionPanel from '~/components/Core/SortableExpansionPanel.vue
 import DialogBox from '~/components/Core/DialogBox.vue'
 import Uuid from '~/helpers/Uuid'
 import TextEditor from '~/components/Text/TextEditor'
+import GenerateAIQuestionButton from '../utils/GenerateAIQuestionButton.vue'
 
 export default {
     name: 'ScenarioChoiceSettings',
@@ -204,6 +219,7 @@ export default {
         TextEditor,
         DialogBox,
         BaseContentBlockSettings,
+        GenerateAIQuestionButton,
     },
     extends: BaseContentSettings,
     data() {
@@ -240,6 +256,8 @@ export default {
     computed: {
         ...mapGetters({
             contentTree: 'content/getTree',
+            course: 'course/get',
+            currentContent: 'content/get',
         }),
     },
     beforeMount() {
@@ -351,6 +369,45 @@ export default {
                 !_.isEmpty(this.block.metadata.config.link_content_id) &&
                 !_.isEmpty(this.block.metadata.config.link_text)
         },
+        onGeneratedScenarioGame(activityData) {
+            // Process the activity data
+            if (activityData && activityData.metadata && 
+                activityData.metadata.config &&
+                activityData.metadata.config.items &&
+                Array.isArray(activityData.metadata.config.items)) {
+
+                // Clear existing items and replace with generated ones
+                this.block.metadata.config.items.splice(0, this.block.metadata.config.items.length)
+
+                // Add all new choices
+                activityData.metadata.config.items.forEach(item => {
+                    this.block.metadata.config.items.push({
+                        title: item.title || '',
+                        body: item.body || '<p></p>',
+                        correct: item.correct || false
+                    })
+                })
+
+                // Update title and instructions if provided
+                if (activityData.metadata.config.title) {
+                    this.block.metadata.config.title = activityData.metadata.config.title
+                }
+
+                if (activityData.metadata.config.instructions) {
+                    this.block.metadata.config.instructions = activityData.metadata.config.instructions
+                }
+
+                this.$toast.success(
+                    this.$t('windward.core.components.settings.scenario_choice.generated_successfully'),
+                    { duration: 3000 }
+                )
+            } else {
+                this.$toast.error(
+                    this.$t('windward.core.components.settings.scenario_choice.invalid_response'),
+                    { duration: 5000 }
+                )
+            }
+        },
     },
 }
 </script>

package/components/Settings/UserUploadSettings.vue

@@ -139,7 +139,7 @@ export default {
                     name: this.$t(
                         'windward.core.components.settings.user_upload.types.all_zip'
                     ),
-                    value: 'application/zip,application/gzip,application/x-gzip,application/x-tar,application/rar,application/x-rar-compressed,application/x-7z-compressed,application/x-bzip2,application/x-xz',
+                    value: 'application/zip,application/gzip,application/x-gzip,application/x-tar,application/rar,application/x-rar-compressed,application/x-7z-compressed,application/x-bzip2,application/x-xz,application/x-zip-compressed',
                 },
             ]
         },

package/components/Settings/VideoSettings/SourcePicker.vue

@@ -32,7 +32,7 @@
                 $PermissionService.userHasAccessTo(
                     'windward.global.file',
                     'writable'
-                )
+                ) && !isFromUrl
             "
             top
             color="primary"
@@ -63,7 +63,10 @@
             }}</span>
         </v-tooltip>
 
-        <v-alert v-if="sourceInherit && !hasLinkedCaptions" type="warning">
+        <v-alert
+            v-if="sourceInherit && !hasLinkedCaptions && !isFromUrl"
+            type="warning"
+        >
             {{
                 $t(
                     'windward.core.components.settings.video.inherit_missing_captions'
@@ -180,6 +183,18 @@ export default {
                 _.get(this.linkedCaptions, 'asset.public_url', '???')
             )
         },
+        isFromUrl() {
+            if (
+                this.source &&
+                _.isEmpty(this.source.id) &&
+                _.isEmpty(this.source.asset.id) &&
+                _.isEmpty(this.source.asset.name) &&
+                !_.isEmpty(this.source.asset.public_url)
+            ) {
+                return true
+            }
+            return false
+        },
     },
     watch: {},
     beforeMount() {},

package/components/Settings/VideoSettings.vue

@@ -197,7 +197,6 @@
                         <template #activator="{ on, attrs }">
                             <v-btn
                                 v-bind="attrs"
-                                v-on="on"
                                 text
                                 elevation="0"
                                 color="error"
@@ -205,6 +204,7 @@
                                     render ||
                                     block.metadata.config.playlist.length <= 1
                                 "
+                                v-on="on"
                                 @click="onRemovePlaylistItem"
                             >
                                 <v-icon>mdi-delete</v-icon>
@@ -334,16 +334,6 @@
                                     "
                                     :disabled="render"
                                 ></v-switch>
-                                <!--
-                                            <v-switch
-                                            v-model="block.metadata.config.attributes.playlistmenu"
-                                            :label="$t('windward.core.components.settings.video.video.attributes.playlistmenu')"
-                                        ></v-switch>
-                                        <v-switch
-                                            v-model="block.metadata.config.attributes.playlistautoadvance"
-                                            :label="$t('windward.core.components.settings.video.video.attributes.playlistautoadvance')"
-                                        ></v-switch>
-                                        -->
                             </v-col>
                             <v-col cols="6">
                                 <v-switch
@@ -392,8 +382,8 @@
 import _ from 'lodash'
 import BaseContentSettings from '~/components/Content/Settings/BaseContentSettings.js'
 import ContentBlockAsset from '~/components/Content/ContentBlockAsset.vue'
-import SourcePicker from './VideoSettings/SourcePicker.vue'
 import BaseContentBlockSettings from '~/components/Content/Settings/BaseContentBlockSettings.vue'
+import SourcePicker from './VideoSettings/SourcePicker.vue'
 
 export default {
     name: 'VideoSettings',
@@ -602,7 +592,10 @@ export default {
                 this.$set(
                     this.block.metadata.config.playlist[this.playlistIndex].ads,
                     adIndex,
-                    { sources: [], tracks: [] }
+                    {
+                        sources: [],
+                        tracks: [],
+                    }
                 )
             }
 

package/components/utils/GenerateAIQuestionButton.vue

@@ -44,7 +44,7 @@
                 </div>
             </v-col>
             <v-col
-                v-if="isFlashcardType || isMatchingGameType || isSortingGameType"
+                v-if="isFlashcardType || isMatchingGameType || isSortingGameType || isWordJumbleType"
                 cols="auto"
                 class="d-flex align-center"
             >
@@ -111,7 +111,7 @@ export default {
                     'windward.core.components.content.blocks.generate_questions.blooms.none'
                 ),
             },
-            replaceExisting: this.questionType === 'bucket_game' ? true : this.replaceExistingMode,
+            replaceExisting: this.questionType === 'bucket_game' || this.questionType === 'word_jumble' ? true : this.replaceExistingMode,
         }
     },
     computed: {
@@ -125,11 +125,18 @@ export default {
             return this.questionType === 'bucket_game'
         },
         isMatchingGameType() {
+            
             return this.questionType === 'matching_game'
         },
         isSortingGameType() {
             return this.questionType === 'sorting_game'
         },
+        isScenarioGameType() {
+            return this.questionType === 'scenario_game'
+        },
+        isWordJumbleType() {
+            return this.questionType === 'word_jumble'
+        },
         replaceExistingLabel() {
             if (this.isBucketGameType) {
                 return this.$t(
@@ -147,6 +154,10 @@ export default {
                 return this.$t(
                 'windward.games.components.settings.sorting_game.form.replace_existing')
             }
+            if (this.isWordJumbleType) {
+                return this.$t(
+                'windward.games.components.settings.word_jumble.form.replace_existing')
+            }
             return this.$t(
                 'windward.games.components.settings.flashcard.form.replace_existing'
             
@@ -181,6 +192,66 @@ export default {
             return fullTree
         },
         taxonomyLevels() {
+            // For word jumble games, only show None, Remember, Understand, Apply
+            if (this.isWordJumbleType) {
+                return [
+                    {
+                        value: 'None',
+                        text: this.$t(
+                            'windward.core.components.content.blocks.generate_questions.blooms.none'
+                        ),
+                    },
+                    {
+                        value: 'Remember',
+                        text: this.$t(
+                            'windward.core.components.content.blocks.generate_questions.blooms.remember'
+                        ),
+                    },
+                    {
+                        value: 'Understand',
+                        text: this.$t(
+                            'windward.core.components.content.blocks.generate_questions.blooms.understand'
+                        ),
+                    },
+                    {
+                        value: 'Apply',
+                        text: this.$t(
+                            'windward.core.components.content.blocks.generate_questions.blooms.apply'
+                        ),
+                    },
+                ]
+            }
+            
+            // For scenario games, only show None, Apply, Analyze, Evaluate
+            if (this.isScenarioGameType) {
+                return [
+                    {
+                        value: 'None',
+                        text: this.$t(
+                            'windward.core.components.content.blocks.generate_questions.blooms.none'
+                        ),
+                    },
+                    {
+                        value: 'Apply',
+                        text: this.$t(
+                            'windward.core.components.content.blocks.generate_questions.blooms.apply'
+                        ),
+                    },
+                    {
+                        value: 'Analyze',
+                        text: this.$t(
+                            'windward.core.components.content.blocks.generate_questions.blooms.analyze'
+                        ),
+                    },
+                    {
+                        value: 'Evaluate',
+                        text: this.$t(
+                            'windward.core.components.content.blocks.generate_questions.blooms.evaluate'
+                        ),
+                    },
+                ]
+            }
+            
             // Basic Bloom's taxonomy levels available to all question types
             let basicBloomTaxonomy = [
                 {
@@ -212,6 +283,7 @@ export default {
             // Only add higher-level Bloom's taxonomy for supported question types
             const supportsAdvancedTaxonomy = 
                 this.isSortingGameType ||
+                this.isScenarioGameType ||
                 ([
                     'multi_choice_single_answer',
                     'multi_choice_multi_answer',
@@ -257,6 +329,14 @@ export default {
                 return this.$t(
                     'windward.core.components.content.blocks.generate_questions.button_label_sorting_game'
                 )
+            } else if (this.questionType === 'scenario_game') {
+                return this.$t(
+                    'windward.core.components.content.blocks.generate_questions.button_label_scenario_game'
+                )
+            } else if (this.questionType === 'word_jumble') {
+                return this.$t(
+                    'windward.core.components.content.blocks.generate_questions.button_label_word_jumble'
+                )
             } else {
                 return this.$t(
                     'windward.core.components.content.blocks.generate_questions.button_label'
@@ -466,6 +546,96 @@ export default {
                             'Invalid response from sorting game generation'
                         )
                     }
+                } else if (this.questionType === 'scenario_game') {
+                    // SCENARIO GAME GENERATION
+                    const activity = new Activity()
+
+                    const endpoint = `suggest/scenario_game${bloomsRequest}`;
+
+                    response = await Activity.custom(
+                        course,
+                        content,
+                        activity,
+                        endpoint
+                    ).get()
+
+                    let activityData = null
+
+                    if (response && response.activity) {
+                        activityData = response.activity
+                    } else if (
+                        response &&
+                        response.length > 0 &&
+                        response[0] &&
+                        response[0].activity
+                    ) {
+                        activityData = response[0].activity
+                    } else if (Array.isArray(response) && response.length > 0) {
+                        activityData = response[0]
+                    } else if (response) {
+                        activityData = response
+                    }
+
+                    if (activityData && activityData.metadata &&
+                        activityData.metadata.config &&
+                        activityData.metadata.config.items &&
+                        Array.isArray(activityData.metadata.config.items)
+                    ) {
+                        // For scenario games, always replace existing content
+                        this.$emit(
+                            'click:generate',
+                            activityData,
+                            true
+                        )
+                    } else {
+                        throw new Error('activity.error.content_mismatch')
+                    }
+                } else if (this.questionType === 'word_jumble') {
+                    // WORD JUMBLE GENERATION
+                    const activity = new Activity()
+
+                    const endpoint = `suggest/word_jumble${bloomsRequest}`
+
+                    response = await Activity.custom(
+                        course,
+                        content,
+                        activity,
+                        endpoint
+                    ).get()
+
+                    let activityData = null
+
+                    if (response && response.activity) {
+                        activityData = response.activity
+                    } else if (
+                        response &&
+                        response.length > 0 &&
+                        response[0] &&
+                        response[0].activity
+                    ) {
+                        activityData = response[0].activity
+                    } else if (Array.isArray(response) && response.length > 0) {
+                        activityData = response[0]
+                    }
+
+                    if (
+                        activityData &&
+                        activityData.metadata &&
+                        activityData.metadata.config &&
+                        activityData.metadata.config.words &&
+                        Array.isArray(activityData.metadata.config.words)
+                    ) {
+                        // We pass the activity data and the replace flag to the parent component
+                        this.$emit(
+                            'click:generate',
+                            activityData,
+                            this.replaceExisting
+                        )
+                    } else {
+                        throw new Error(
+                            'Invalid response from word jumble generation'
+                        )
+                    }
                 } else {
                     // ASSESSMENT QUESTION GENERATION
                     const assessment = new Assessment({ id: this.block.id })
@@ -499,8 +669,29 @@ export default {
 
                 let errorText = ''
 
-                // Check for content mismatch error specifically for bucket games
-                if (
+                // Check for character limit error by structured data first
+                const errorSubtype = error.response?.data?.error?.details?.error_subtype
+                const errorDetails = error.response?.data?.error?.details
+                
+                if (errorSubtype === 'CHARACTER_LIMIT_EXCEEDED') {
+                    // Use structured data if available
+                    const field = errorDetails?.field || 'content'
+                    const limit = errorDetails?.limit
+                    const actual = errorDetails?.actual
+                    
+                    // Use parameterized message if we have the data
+                    if (limit && actual) {
+                        errorText = this.$t(`${basePath}.character_limit_detailed`, { field, limit, actual })
+                    } else {
+                        // Fallback to generic message
+                        errorText = this.$t(`${basePath}.character_limit`)
+                    }
+                }
+                // Keep backward compatibility - check for old message pattern
+                else if (errorDetails?.message === 'An error occurred while generating content. Try generating again.') {
+                    errorText = this.$t(`${basePath}.character_limit`)
+                } else if (
+                    // Check for content mismatch error specifically for bucket games
                     (errorMessage === 'activity.error.content_mismatch' ||
                         errorType === 'content_mismatch') &&
                     this.questionType === 'bucket_game'
@@ -533,11 +724,73 @@ export default {
                         this.$t(
                             `${basePath}.content_mismatch_sorting_game_support`
                         )
-                } else {
+                } else if (
+                    (errorMessage === 'activity.error.content_mismatch' ||
+                        errorType === 'content_mismatch') &&
+                    this.questionType === 'scenario_game'
+                ) {
                     errorText =
-                        this.$t(`${basePath}.${errorType}`) +
+                        this.$t(`${basePath}.content_mismatch_scenario_game`) +
                         '\n\n' +
-                        this.$t(`${basePath}.${errorType}_support`)
+                        this.$t(
+                            `${basePath}.content_mismatch_scenario_game_support`
+                        )
+                } else if (
+                    (errorMessage === 'activity.error.content_mismatch' ||
+                        errorType === 'content_mismatch') &&
+                    this.questionType === 'word_jumble'
+                ) {
+                    errorText =
+                        this.$t(`${basePath}.content_mismatch_word_jumble`) +
+                        '\n\n' +
+                        this.$t(
+                            `${basePath}.content_mismatch_word_jumble_support`
+                        )
+                } else if (errorType === 'insufficient_content' && error.response?.data?.error?.details) {
+                    // Handle dynamic Bloom's taxonomy insufficient content errors
+                    const details = error.response.data.error.details
+                    const bloomsLevel = details.blooms_level
+                    const minimumRequired = details.minimum_required
+                    
+                    if (bloomsLevel && bloomsLevel !== 'None') {
+                        // Message with Bloom's level
+                        errorText =
+                            this.$t(`${basePath}.insufficient_content_blooms`, { bloomsLevel }) +
+                            '\n\n' +
+                            this.$t(`${basePath}.insufficient_content_blooms_support`, { minimumRequired })
+                    } else if (minimumRequired) {
+                        // Message without Bloom's level but with word count
+                        errorText =
+                            this.$t(`${basePath}.insufficient_content_dynamic`) +
+                            '\n\n' +
+                            this.$t(`${basePath}.insufficient_content_dynamic_support`, { minimumRequired })
+                    } else {
+                        // Fallback to static translation
+                        errorText =
+                            this.$t(`${basePath}.${errorType}`) +
+                            '\n\n' +
+                            this.$t(`${basePath}.${errorType}_support`)
+                    }
+                } else {
+                    // Check if the error type is a valid i18n key
+                    const errorKey = `${basePath}.${errorType}`
+                    const supportKey = `${basePath}.${errorType}_support`
+                    
+                    // Try to get the translation, fall back to default error if not found
+                    const hasTranslation = this.$te(errorKey)
+                    
+                    if (hasTranslation) {
+                        errorText =
+                            this.$t(errorKey) +
+                            '\n\n' +
+                            this.$t(supportKey)
+                    } else {
+                        // Fall back to default error message
+                        errorText =
+                            this.$t(`${basePath}.default`) +
+                            '\n\n' +
+                            this.$t(`${basePath}.default_support`)
+                    }
 
                     if (errorType === 'technical') {
                         const errorCode =

package/components/utils/TinyMCEWrapper.vue

@@ -37,14 +37,14 @@
             </slot>
         </div>
         <v-btn-toggle
-            v-if="allowRead && !render"
+            v-if="hasActions"
             dense
             multiple
             class="pt-1 d-flex justify-end"
         >
             <slot name="actions-prepend" :render="render"></slot>
             <slot name="actions" :render="render">
-                <v-btn-toggle dense>
+                <v-btn-toggle v-if="allowRead && !render" dense>
                     <v-btn color="primary" outlined @click="read">
                         <v-icon> mdi-play</v-icon>
                     </v-btn>
@@ -164,6 +164,21 @@ export default {
     },
 
     computed: {
+        hasActions() {
+            if (this.allowRead && !this.render) {
+                return true
+            }
+            // reach into parent text editor to see if a slot has been used.
+            // Cant access this.$slots when daisy chained like we're doing with texteditor
+            if (_.isEmpty(this.$parent) || _.isEmpty(this.$parent.$slots)) {
+                return false
+            }
+            return (
+                typeof this.$parent.$slots['actions-prepend'] !== 'undefined' ||
+                typeof this.$parent.$slots['actions'] !== 'undefined' ||
+                typeof this.$parent.$slots['actions-append'] !== 'undefined'
+            )
+        },
         dataCy() {
             return (
                 this.dataKey ||

package/i18n/en-US/components/content/blocks/generate_questions.ts

@@ -7,6 +7,14 @@ export default {
         insufficient_content: 'More content needed to generate questions.',
         insufficient_content_support:
             'Please add more text, examples, or explanations to this section. We recommend at least 50 words of relevant content to generate appropriate questions.',
+        
+        insufficient_content_blooms: 'Insufficient content to generate quality questions at the {bloomsLevel} level.',
+        insufficient_content_blooms_support:
+            'Please add more detailed text, examples, or explanations to this section. We recommend at least {minimumRequired} words of relevant content to generate appropriate questions at this level.',
+        
+        insufficient_content_dynamic: 'Insufficient content to generate quality questions.',
+        insufficient_content_dynamic_support:
+            'Please add more detailed text, examples, or explanations to this section. We recommend at least {minimumRequired} words of relevant content to generate appropriate questions.',
 
         content_mismatch: "Content doesn't match question type.",
         content_mismatch_support:
@@ -24,6 +32,17 @@ export default {
         content_mismatch_sorting_game_support:
             "Consider adding content with sequential steps, chronological events, or items that have a clear logical order for students to arrange.",
 
+        content_mismatch_scenario_game: "Content not suitable for scenario games.",
+        content_mismatch_scenario_game_support:
+            "Consider adding content that describes concepts, processes, or principles that can be applied in real-world scenarios.",
+
+        content_mismatch_word_jumble: "Content not suitable for word jumble games.",
+        content_mismatch_word_jumble_support:
+            "Consider adding content with clear vocabulary terms, glossary words, or key concepts that can be unscrambled.",
+
+        character_limit: 'An error occurred while generating content. Try generating again.',
+        character_limit_detailed: 'The {field} exceeds the {limit} character limit (currently {actual} characters). Try generating again with shorter content.',
+
         llm_unavailable: 'Question generation temporarily unavailable.',
         llm_unavailable_support:
             "We're unable to connect to our AI service at the moment. Please try again in a few minutes or contact support if the issue persists.",
@@ -37,6 +56,8 @@ export default {
     button_label_bucket_game: 'Generate Buckets',
     button_label_matching_game: 'Generate Matches',
     button_label_sorting_game: 'Generate Items',
+    button_label_scenario_game: 'Generate Scenarios',
+    button_label_word_jumble: 'Generate Items',
     selected_pages: 'Selected Page',
     ai_assistance: 'AI Assistance',
     blooms: {

package/i18n/en-US/components/settings/scenario_choice.ts

@@ -17,4 +17,6 @@ export default {
         number: 'Numbers',
     },
     add_choice: 'Add Choice',
+    generated_successfully: 'Scenarios generated successfully',
+    invalid_response: 'Invalid response from scenario generation',
 }

package/i18n/es-ES/components/content/blocks/generate_questions.ts

@@ -9,6 +9,14 @@ export default {
             'Se necesita más contenido para generar preguntas.',
         insufficient_content_support:
             'Agregue más texto, ejemplos o explicaciones a esta sección. Recomendamos al menos 2 o 3 párrafos de contenido.',
+        
+        insufficient_content_blooms: 'Contenido insuficiente para generar preguntas de calidad en el nivel de {bloomsLevel}.',
+        insufficient_content_blooms_support:
+            'Por favor, agregue texto más detallado, ejemplos o explicaciones a esta sección. Recomendamos al menos {minimumRequired} palabras de contenido relevante para generar preguntas apropiadas en este nivel.',
+        
+        insufficient_content_dynamic: 'Contenido insuficiente para generar preguntas de calidad.',
+        insufficient_content_dynamic_support:
+            'Por favor, agregue texto más detallado, ejemplos o explicaciones a esta sección. Recomendamos al menos {minimumRequired} palabras de contenido relevante para generar preguntas apropiadas.',
 
         content_mismatch: 'El contenido no coincide con el tipo de pregunta.',
         content_mismatch_support:
@@ -26,6 +34,17 @@ export default {
         content_mismatch_sorting_game_support:
             'Considera agregar contenido con pasos secuenciales, eventos cronológicos o elementos que tengan un orden lógico claro para que los estudiantes los organicen.',
 
+        content_mismatch_scenario_game: 'El contenido no es adecuado para juegos de escenarios.',
+        content_mismatch_scenario_game_support:
+            'Considera agregar contenido que describa conceptos, procesos o principios que se puedan aplicar en escenarios del mundo real.',
+
+        content_mismatch_word_jumble: 'El contenido no es adecuado para juegos de revoltijo de palabras.',
+        content_mismatch_word_jumble_support:
+            'Considera agregar contenido con términos de vocabulario claros, palabras de glosario o conceptos clave que puedan ser desordenados.',
+
+        character_limit: 'Se produjo un error al generar el contenido. Intenta generar de nuevo.',
+        character_limit_detailed: 'El campo {field} excede el límite de {limit} caracteres (actualmente {actual} caracteres). Intenta generar de nuevo con contenido más corto.',
+
         llm_unavailable:
             'La generación de preguntas no está disponible temporalmente.',
         llm_unavailable_support:
@@ -40,6 +59,8 @@ export default {
     button_label_bucket_game: 'Generar categorías',
     button_label_matching_game: 'Generar coincidencias',
     button_label_sorting_game: 'Generar elementos',
+    button_label_scenario_game: 'Generar escenarios',
+    button_label_word_jumble: 'Generar elementos',
     selected_pages: 'Página seleccionada',
     ai_assistance: 'Asistencia de IA',
     blooms: {

package/i18n/es-ES/components/settings/scenario_choice.ts

@@ -17,4 +17,6 @@ export default {
         number: 'Números',
     },
     add_choice: 'Agregar opción',
+    generated_successfully: 'Escenarios generados con éxito',
+    invalid_response: 'Respuesta inválida de la generación de escenarios',
 }

package/i18n/sv-SE/components/content/blocks/generate_questions.ts

@@ -7,6 +7,14 @@ export default {
         insufficient_content: 'Mer innehåll behövs för att generera frågor.',
         insufficient_content_support:
             'Vänligen lägg till mer text, exempel eller förklaringar till det här avsnittet. Vi rekommenderar minst 2-3 stycken innehåll.',
+        
+        insufficient_content_blooms: 'Otillräckligt innehåll för att generera kvalitetsfrågor på {bloomsLevel}-nivån.',
+        insufficient_content_blooms_support:
+            'Vänligen lägg till mer detaljerad text, exempel eller förklaringar till detta avsnitt. Vi rekommenderar minst {minimumRequired} ord av relevant innehåll för att generera lämpliga frågor på denna nivå.',
+        
+        insufficient_content_dynamic: 'Otillräckligt innehåll för att generera kvalitetsfrågor.',
+        insufficient_content_dynamic_support:
+            'Vänligen lägg till mer detaljerad text, exempel eller förklaringar till detta avsnitt. Vi rekommenderar minst {minimumRequired} ord av relevant innehåll för att generera lämpliga frågor.',
 
         content_mismatch: 'Innehållet matchar inte frågetyp.',
         content_mismatch_support:
@@ -24,6 +32,17 @@ export default {
         content_mismatch_sorting_game_support:
             'Överväg att lägga till innehåll med sekventiella steg, kronologiska händelser eller objekt som har en tydlig logisk ordning för elever att arrangera.',
 
+        content_mismatch_scenario_game: 'Innehållet är inte lämpligt för scenariospel.',
+        content_mismatch_scenario_game_support:
+            'Överväg att lägga till innehåll som beskriver koncept, processer eller principer som kan tillämpas i verkliga scenarier.',
+
+        content_mismatch_word_jumble: 'Innehållet är inte lämpligt för ordvirrvarr-spel.',
+        content_mismatch_word_jumble_support:
+            'Överväg att lägga till innehåll med tydliga vokabulärtermer, ordlistor eller nyckelkoncept som kan blandas.',
+
+        character_limit: 'Ett fel uppstod när innehållet genererades. Försök generera igen.',
+        character_limit_detailed: 'Fältet {field} överskrider gränsen på {limit} tecken (för närvarande {actual} tecken). Försök generera igen med kortare innehåll.',
+
         llm_unavailable: 'Frågegenerering tillfälligt otillgänglig.',
         llm_unavailable_support:
             'Vi kan inte ansluta till vår AI-tjänst för tillfället. Försök igen om några minuter.',
@@ -37,6 +56,8 @@ export default {
     button_label_bucket_game: 'Generera kategorier',
     button_label_matching_game: 'Generera matchningar',
     button_label_sorting_game: 'Generera objekt',
+    button_label_scenario_game: 'Generera scenarier',
+    button_label_word_jumble: 'Generera objekt',
     selected_pages: 'Vald sida',
     ai_assistance: 'AI-hjälp',
     blooms: {

package/i18n/sv-SE/components/settings/scenario_choice.ts

@@ -17,4 +17,6 @@ export default {
         number: 'Nummer',
     },
     add_choice: 'Lägg till val',
+    generated_successfully: 'Scenarier genererades framgångsrikt',
+    invalid_response: 'Ogiltigt svar från scenariogenereringen',
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@windward/core",
-    "version": "0.21.0",
+    "version": "0.22.0",
     "description": "Windward UI Core Plugins",
     "main": "plugin.js",
     "scripts": {