Character CRUD Slash Commands (#5306) * feat: add character CRUD slash commands (char-create, char-update, char-get, char-delete) Implement comprehensive character management commands allowing programmatic creation, modification, retrieval, and deletion of characters without UI interaction. All commands support named arguments with proper validation and error handling. * feat: enhance char CRUD commands with favorite, avatar, and improved defaults Add `favorite` and `avatar` named arguments to char-create and char-update commands. Make `char` argument optional in char-delete (defaults to current character). Improve documentation with clarifications on card tags vs ST tags, avatar URL sources, and usage examples. Add `fav` field to char-get output. * feat: add /tag-import slash command for programmatic character tag import Implement /tag-import command with `name` (defaults to {{char}}) and `mode` arguments (all/existing/none/ask). Command imports character card tags as ST tags for filtering/organizing. Returns 'true' if tags were imported, 'false' otherwise. Mode argument maps to existing tag_import_setting enum values. * feat: enhance char-create and char-update with avatar upload and tag parsing Add avatar resolution and upload support for char-create and char-update commands. Implement resolveAvatarData() to handle URLs, base64 data URLs, and local paths. Add uploadCharacterAvatar() to upload resolved images via /api/characters/edit-avatar. Parse tags argument as comma-separated array. Refresh side panel after char-update when modifying current character. Add char-get2 alias for testing. * feat: enhance avatar argument in char CRUD commands with file picker and local path support Add `prompt` value to avatar argument to open file picker dialog. Implement promptForAvatarFile() to handle image selection with validation. Add folderEnumMatchProvider() for autocomplete matching of folder paths. Update avatar enumList with common ST paths (characters/, backgrounds/, User Avatars/, assets/, user/images/). Remove external URL support from resolveAvatarData() - now only accepts "prompt", base * feat: add /char-duplicate slash command with avatar resize support and enhanced avatar upload handling Implement /char-duplicate command with `char` and `select` named arguments. Add `avatarPromptResize` argument to char-create and char-update for optional resize/crop dialog. Refactor duplicateCharacter() to accept avatar and silent parameters, returning the new avatar key. Enhance uploadCharacterAvatar() to handle resize prompts and return success status. Add cache busting and DOM refresh for avatar thumbnails * refactor: optimize avatar refresh after upload by using cache busting and DOM query Replace message-specific avatar refresh logic with generic image refresh targeting all thumbnails using the updated avatar URL. Remove unnecessary delay and character name matching. Add cache busting for both thumbnail and full character image. Use querySelectorAll to find and refresh all affected img elements in one pass. * refactor: rename char-get alias from char-get2 to char-data * refactor: move /dupe command to alias of /char-duplicate and fix characterIndex type Move standalone /dupe command to alias of /char-duplicate for consistency with character CRUD commands. Cast characterIndex to String in char-update to match expected type. * docs: clarify /imagine command integration with avatar argument in char CRUD commands Update avatar argument descriptions and examples to explicitly mention /imagine command return value support. Reorder piped /imagine example to show correct command flow (generate image first, then update character). * feat: add i18n support to char-create and char-update command error messages Wrap validation error toastr messages in t`` template literals for translation support in /char-create and /char-update commands. * feat: add group chat validation to /tag-import command Add early validation check to prevent tag import in group chats. Display warning toastr message and return 'false' when selected_group is not null. * Fix char update world property Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> * Fix help text documentation to match arg name Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> * fix: return empty string instead of throwing errors in char-create and char-update commands Replace `throw error` with `return ''` in error handlers for /char-create and /char-update commands to prevent unhandled promise rejections while still displaying error toastr messages. * refactor: make deleteCharacter return boolean success status and update char-delete command to use it Change deleteCharacter to return boolean indicating success/failure instead of void. Return false on user cancellation or failed chat close, true when character is successfully deleted. Update /char-delete command to use returned success value instead of always returning 'true'. * refactor: make description and firstMessage optional in /char-create command Remove description and firstMessage from required fields array, allowing character creation with only a name. Update help text to reflect that only name is required. * refactor: extract external URL check to utility function and add same-origin URL support for avatar resolution Extract external URL check into `isExternalUrl` utility function in utils.js. Update `resolveAvatarData` to use new utility and add support for same-origin URLs by converting them to pathname before fetching. --------- Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

f9c42a32dd97fc9b841f8e527ad8fb4acb56b7ef

Wolfsblvt <wolfsblvt@gmail.com>

Signed

Parents: bae4fd9f9843e86cc02a32155a8ce9a02d20ddf3

public/script.js+53 -26 Viewed

+    }
+}
-export async function duplicateCharacter() {
+/**
+ * Duplicates a character.
+ * @param {object} [options={}] - Options
+ * @param {string} [options.avatar] - Avatar key of the character to duplicate. Uses current character if not provided.
+ * @param {boolean} [options.silent=false] - Whether to skip the confirmation popup
+ * @returns {Promise<string>} The avatar key of the duplicated character, or empty string if cancelled/failed
+ */
+export async function duplicateCharacter({ avatar = null, silent = false } = {}) {
+    // Determine the character to duplicate
+    let targetAvatar;
+    if (avatar) {
+        const character = characters.find(c => c.avatar === avatar);
+        if (!character) {
+            toastr.warning(t`Character not found: ${avatar}`);
+            return '';
+        }
+        targetAvatar = avatar;
+    } else {
         if (this_chid === undefined || !characters[this_chid]) {
             toastr.warning(t`You must first select a character to duplicate!`);
             return '';
+        }
+        targetAvatar = characters[this_chid].avatar;
+    }
+    // Show confirmation unless silent
+    if (!silent) {
         const confirmMessage = $(await renderTemplateAsync('duplicateConfirm'));
         const confirm = await callGenericPopup(confirmMessage, POPUP_TYPE.CONFIRM);

             console.log('User cancelled duplication');
             return '';
+        }
+    }
-    const body = { avatar_url: characters[this_chid].avatar };
+    const body = { avatar_url: targetAvatar };
     const response = await fetch('/api/characters/duplicate', {
         method: 'POST',
         headers: getRequestHeaders(),
         body: JSON.stringify(body),
     });
-    if (response.ok) {
+    if (!response.ok) {
+        toastr.error(t`Failed to duplicate character`);
+        return '';
+    }
     toastr.success(t`Character Duplicated`);
     const data = await response.json();
-        await eventSource.emit(event_types.CHARACTER_DUPLICATED, { oldAvatar: body.avatar_url, newAvatar: data.path });
+    await eventSource.emit(event_types.CHARACTER_DUPLICATED, { oldAvatar: targetAvatar, newAvatar: data.path });
     await getCharacters();
-    }
-    return '';
+    return data.path;
+}
 function setInContextMessages(msgInContextCount, type) {

+        }
         await createOrEditCharacter();
-        await delay(DEFAULT_SAVE_EDIT_TIMEOUT);
         const formData = new FormData(/** @type {HTMLFormElement} */($('#form_create').get(0)));
-        await fetch(getThumbnailUrl('avatar', formData.get('avatar_url').toString()), {
+        const avatarKey = formData.get('avatar_url').toString();
-            method: 'GET',
-            cache: 'reload',
-        });
-        const messages = $('.mes').toArray();
+        // Bust cache for the avatar thumbnail and character image
-        for (const el of messages) {
+        const thumbnailUrl = getThumbnailUrl('avatar', avatarKey);
-            const $el = $(el);
+        await fetch(thumbnailUrl, { method: 'GET', cache: 'reload' });
-            const nameMatch = $el.attr('ch_name') == formData.get('ch_name');
+        await fetch(`/characters/${avatarKey}`, { method: 'GET', cache: 'reload' });
-            if ($el.attr('is_system') == 'true' && !nameMatch) continue;
-            if ($el.attr('is_user') == 'true') continue;
-            if (nameMatch) {
+        // Refresh all visible avatar images that use this thumbnail URL
-                const previewSrc = $('#avatar_load_preview').attr('src');
+        // This handles messages, character list, and any other place using the thumbnail
-                const avatar = $el.find('.avatar img');
+        const avatarImages = document.querySelectorAll(`img[src^="${thumbnailUrl}"]`);
-                avatar.attr('src', default_avatar);
+        for (const img of avatarImages) {
-                await delay(1);
+            if (img instanceof HTMLImageElement) {
-                avatar.attr('src', previewSrc);
+                const originalSrc = img.src;
+                img.src = '';
+                img.src = originalSrc;
+            }
+        }
+        console.debug(`Refreshed ${avatarImages.length} avatar images for ${avatarKey}`);
         console.log('Avatar refreshed');
+    }

  * @param {string|string[]} characterKey - The key (avatar) of the character to be deleted
  * @param {Object} [options] - Optional parameters for the deletion
  * @param {boolean} [options.deleteChats=true] - Whether to delete associated chats or not
- * @return {Promise<void>} - A promise that resolves when the character is successfully deleted
+ * @return {Promise<boolean>} - A promise that resolves when the character is successfully deleted
  */
 export async function deleteCharacter(characterKey, { deleteChats = true } = {}) {
     if (!Array.isArray(characterKey)) {

@@ -10577,15 +10600,17 @@ export async function deleteCharacter(characterKey, { deleteChats = true } = {})
10577	t`Deleting this character will close the chat and you will lose any unsaved messages. Do you want to proceed?`,	10600	t`Deleting this character will close the chat and you will lose any unsaved messages. Do you want to proceed?`,
10578	);	10601	);
10579	if (!confirmClose) {	10602	if (!confirmClose) {
10580	return;	10603	return false;
10581	}	10604	}
10582	}	10605	}
10583		10606
10584	const closeChatResult = await closeCurrentChat();	10607	const closeChatResult = await closeCurrentChat();
10585	if (!closeChatResult) {	10608	if (!closeChatResult) {
10586	return;	10609	return false;
10587	}	10610	}
10588		10611
		10612	let deleted = false;
		10613
10589	for (const key of characterKey) {	10614	for (const key of characterKey) {
10590	const character = characters.find(x => x.avatar == key);	10615	const character = characters.find(x => x.avatar == key);
10591	if (!character) {	10616	if (!character) {

@@ -10624,9 +10649,11 @@ export async function deleteCharacter(characterKey, { deleteChats = true } = {})
10624	}	10649	}
10625		10650
10626	await eventSource.emit(event_types.CHARACTER_DELETED, { id: chid, character: character });	10651	await eventSource.emit(event_types.CHARACTER_DELETED, { id: chid, character: character });
		10652	deleted = true;
10627	}	10653	}
10628		10654
10629	await removeCharacterFromUI();	10655	await removeCharacterFromUI();
		10656	return deleted;
10630	}	10657	}
10631		10658
10632	/**	10659	/**

public/scripts/slash-commands.js+1015 -6 Viewed

 import { Fuse, DOMPurify } from '../lib.js';
-import { canUseNegativeLookbehind, copyText, findPersona, flashHighlight } from './utils.js';
+import { canUseNegativeLookbehind, copyText, findPersona, flashHighlight, getBase64Async, ensureImageFormatSupported, supportedImageMimeTypes, isExternalUrl } from './utils.js';
 import {
     Generate,

     comment_avatar,
     deactivateSendButtons,
     default_avatar,
+    deleteCharacter,
     deleteSwipe,
     displayPastChats,
     duplicateCharacter,

     extractMessageBias,
     generateQuietPrompt,
     generateRaw,
+    getCharacters,
     getCurrentChatDetails,
     getCurrentChatId,
     getFirstDisplayedMessageId,
+    getOneCharacter,
+    getRequestHeaders,
     getThumbnailUrl,
     is_send_press,
     main_api,

     saveChatConditional,
     saveSettings,
     saveSettingsDebounced,
+    selectCharacterById,
+    select_selected_character,
     sendMessageAsUser,
     sendSystemMessage,
     setActiveCharacter,

+    }
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
-        name: 'dupe',
-        callback: duplicateCharacter,
-        helpString: t`Duplicates the currently selected character.`,
-    }));
-    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'api',
         callback: async function (args, text) {
             if (!text?.toString()?.trim()) {

         </div>
         `,
     }));
+    /**
+     * Provides autocomplete matching for folder names.
+     * Matches if the input starts with the check or vice versa (case-insensitive).
+     * @param {string} input - The input string to match against
+     * @param {string} check - The check string to match with
+     * @param {object} [options={}] - Options
+     * @param {boolean} [options.trueOnEmpty=true] - Whether to return true when input is empty
+     * @returns {boolean} - True if the strings match according to the folder matching rules
+     */
+    function folderEnumMatchProvider(input, check, { trueOnEmpty = true } = {}) {
+        if (!check) return false;
+        if (!input) return trueOnEmpty;
+        const inputLower = input.toLowerCase();
+        const checkLower = check.toLowerCase();
+        return inputLower.startsWith(checkLower) || checkLower.startsWith(inputLower);
+    }
+    // Shared character field definitions for char CRUD commands
+    const getCharacterFieldArgs = ({ requiredFields = [] } = {}) => [
+        SlashCommandNamedArgument.fromProps({
+            name: 'name',
+            description: t`The name of the character`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('name'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'description',
+            description: t`The character's description/personality definition`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('description'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'firstMessage',
+            description: t`The character's first message/greeting`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('firstMessage'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'personality',
+            description: t`A brief description of the personality`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('personality'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'scenario',
+            description: t`The scenario or circumstances for the conversation`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('scenario'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'messageExamples',
+            description: t`Example messages for the character`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('messageExamples'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'creatorNotes',
+            description: t`Notes from the character creator`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('creatorNotes'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'systemPrompt',
+            description: t`The character's system prompt`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('systemPrompt'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'postHistoryInstructions',
+            description: t`Post-history instructions (jailbreak)`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('postHistoryInstructions'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'creator',
+            description: t`The creator of the character`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('creator'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'characterVersion',
+            description: t`The version of the character`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('characterVersion'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'tags',
+            description: t`Comma-separated list of character card tags (embedded in the card, not ST's folder/filter tags). Use /tag-add for ST tags or /tag-import to import card tags as ST tags.`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('tags'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'favorite',
+            description: t`Whether this character is a favorite`,
+            typeList: [ARGUMENT_TYPE.BOOLEAN],
+            enumProvider: commonEnumProviders.boolean('trueFalse'),
+            isRequired: requiredFields.includes('favorite'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'avatar',
+            description: t`Avatar image. Use "prompt" to open file picker, or provide a local ST file path (e.g., characters/Name.png, backgrounds/image.png). This can also be the return value from the /imagine command. External URLs are not supported.`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('avatar'),
+            enumList: [
+                new SlashCommandEnumValue('prompt', 'Open file picker to select an image', 'enum', '📁'),
+                new SlashCommandEnumValue('characters/...', 'Character avatars path (e.g., characters/Name.png)', 'enum', '📄', (input) => folderEnumMatchProvider(input, 'characters/'), () => 'characters/'),
+                new SlashCommandEnumValue('backgrounds/...', 'Background image path', 'enum', '📄', (input) => folderEnumMatchProvider(input, 'backgrounds/'), () => 'backgrounds/'),
+                new SlashCommandEnumValue('User Avatars/...', 'User avatar path', 'enum', '📄', (input) => folderEnumMatchProvider(input, 'User Avatars/'), () => 'User Avatars/'),
+                new SlashCommandEnumValue('assets/...', 'Asset file path', 'enum', '📄', (input) => folderEnumMatchProvider(input, 'assets/'), () => 'assets/'),
+                new SlashCommandEnumValue('user/images/...', 'User image path', 'enum', '📄', (input) => folderEnumMatchProvider(input, 'user/images/'), () => 'user/images/'),
+            ],
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'avatarPromptResize',
+            description: t`Whether to show the avatar resize/crop dialog when uploading (default: true). Ignored if "Never resize avatars" is enabled in settings.`,
+            typeList: [ARGUMENT_TYPE.BOOLEAN],
+            defaultValue: 'true',
+            enumProvider: commonEnumProviders.boolean('trueFalse'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'talkativeness',
+            description: t`How often the character speaks in group chats (0.0 to 1.0)`,
+            typeList: [ARGUMENT_TYPE.NUMBER],
+            isRequired: requiredFields.includes('talkativeness'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'world',
+            description: t`The name of the lorebook to attach`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            enumProvider: commonEnumProviders.worlds,
+            isRequired: requiredFields.includes('world'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'depthPrompt',
+            description: t`Character-specific depth prompt content`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            isRequired: requiredFields.includes('depthPrompt'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'depthPromptDepth',
+            description: t`Depth for the character-specific depth prompt`,
+            typeList: [ARGUMENT_TYPE.NUMBER],
+            isRequired: requiredFields.includes('depthPromptDepth'),
+        }),
+        SlashCommandNamedArgument.fromProps({
+            name: 'depthPromptRole',
+            description: t`Role for the depth prompt`,
+            typeList: [ARGUMENT_TYPE.STRING],
+            enumList: commonEnumProviders.messageRoles(),
+            isRequired: requiredFields.includes('depthPromptRole'),
+        }),
+    ];
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'char-create',
+        callback: createCharacterCallback,
+        returns: t`the avatar key (unique identifier) of the created character`,
+        namedArgumentList: [
+            ...getCharacterFieldArgs({ requiredFields: ['name'] }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'select',
+                description: t`Whether to select/open the character after creation (default: true)`,
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'true',
+                enumProvider: commonEnumProviders.boolean('trueFalse'),
+            }),
+        ],
+        helpString: `
+        <div>
+            ${t`Creates a new character with the specified attributes. Returns the avatar key of the created character.`}
+        </div>
+        <div>
+            <strong>${t`Required arguments:`}</strong>
+            <ul>
+                <li><code>name</code> - ${t`The character's name`}</li>
+            </ul>
+        </div>
+        <div>
+            <strong>${t`Note on tags:`}</strong> ${t`The <code>tags</code> argument sets character card tags (embedded in the character file), not SillyTavern's folder/filter tags. To add ST tags after creation, use <code>/tag-add</code>. To import card tags as ST tags, use <code>/tag-import</code>.`}
+        </div>
+        <div>
+            <strong>${t`Note on avatar:`}</strong> ${t`The <code>avatar</code> argument accepts <code>prompt</code> to open a file picker, or a local ST file path. Supported paths include: <code>characters/Name.png</code>, <code>backgrounds/image.png</code>, <code>User Avatars/avatar.png</code>, <code>assets/category/file.png</code>. This can also be the return value from the /imagine command. External URLs are not supported.`}
+        </div>
+        <div>
+            <strong>${t`Example:`}</strong>
+            <ul>
+                <li>
+                    <pre><code>/char-create name="Alice" description="A friendly AI assistant" firstMessage="Hello! How can I help you today?"</code></pre>
+                </li>
+                <li>
+                    <pre><code>/char-create name="Bob" description="A wise wizard" firstMessage="Greetings, traveler." personality="Wise, patient" scenario="A magical library" favorite=true</code></pre>
+                </li>
+                <li>
+                    <pre><code>/char-create name="Clone" description="A clone" firstMessage="Hi!" avatar=prompt</code></pre>
+                    <span>${t`(opens file picker for avatar)`}</span>
+                </li>
+            </ul>
+        </div>
+        `,
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'char-update',
+        callback: updateCharacterCallback,
+        returns: t`the avatar key of the updated character`,
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'char',
+                description: t`Character name or avatar key. If not provided, uses the currently selected character.`,
+                typeList: [ARGUMENT_TYPE.STRING],
+                enumProvider: commonEnumProviders.characters('character'),
+            }),
+            ...getCharacterFieldArgs(),
+        ],
+        helpString: `
+        <div>
+            ${t`Updates an existing character's attributes. The character does not need to be currently selected.`}
+        </div>
+        <div>
+            ${t`If no <code>char</code> argument is provided, updates the currently selected character.`}
+        </div>
+        <div>
+            <strong>${t`Note on tags:`}</strong> ${t`The <code>tags</code> argument sets character card tags (embedded in the PNG), not SillyTavern's folder/filter tags. To add ST tags, use <code>/tag-add</code>. To import card tags as ST tags, use <code>/tag-import</code>.`}
+        </div>
+        <div>
+            <strong>${t`Note on avatar:`}</strong> ${t`The <code>avatar</code> argument accepts <code>prompt</code> to open a file picker, or a local ST file path. Supported paths: <code>characters/Name.png</code>, <code>backgrounds/image.png</code>, <code>User Avatars/avatar.png</code>, <code>assets/category/file.png</code>. This can also be the return value from the /imagine command. External URLs are not supported.`}
+        </div>
+        <div>
+            <strong>${t`Example:`}</strong>
+            <ul>
+                <li>
+                    <pre><code>/char-update description="An updated description for this character"</code></pre>
+                    ${t`Updates the currently selected character's description.`}
+                </li>
+                <li>
+                    <pre><code>/char-update char="Alice" personality="Cheerful and energetic" favorite=true</code></pre>
+                    ${t`Updates Alice's personality and marks her as a favorite.`}
+                </li>
+                <li>
+                    <pre><code>/imagine you | /char-update avatar="{{pipe}}"</code></pre>
+                    ${t`Generates an image and sets it as the current character's avatar.`}
+                </li>
+            </ul>
+        </div>
+        `,
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'char-duplicate',
+        aliases: ['dupe'],
+        callback: duplicateCharacterCallback,
+        returns: t`the avatar key (unique identifier) of the duplicated character`,
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'char',
+                description: t`Character name or avatar key to duplicate. If not provided, uses the currently selected character.`,
+                typeList: [ARGUMENT_TYPE.STRING],
+                enumProvider: commonEnumProviders.characters('character'),
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'select',
+                description: t`Whether to select/open the duplicated character after creation (default: false)`,
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'false',
+                enumProvider: commonEnumProviders.boolean('trueFalse'),
+            }),
+        ],
+        helpString: `
+        <div>
+            ${t`Duplicates a character. Returns the avatar key of the duplicated character.`}
+        </div>
+        <div>
+            ${t`Use <code>/char-update</code> afterwards to modify the duplicated character's fields.`}
+        </div>
+        <div>
+            <strong>${t`Example:`}</strong>
+            <ul>
+                <li>
+                    <pre><code>/char-duplicate</code></pre>
+                    ${t`Duplicates the currently selected character.`}
+                </li>
+                <li>
+                    <pre><code>/char-duplicate char="Alice" select=true</code></pre>
+                    ${t`Duplicates Alice and selects the new character.`}
+                </li>
+                <li>
+                    <pre><code>/char-duplicate | /setvar key=newChar | /char-update char="{{getvar::newChar}}" name="Clone"</code></pre>
+                    ${t`Duplicates the current character and renames the clone.`}
+                </li>
+            </ul>
+        </div>
+        `,
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'char-get',
+        aliases: ['char-data'],
+        callback: getCharacterDataCallback,
+        returns: t`character data as JSON or a specific field value`,
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'char',
+                description: t`Character name or avatar key. If not provided, uses the currently selected character.`,
+                typeList: [ARGUMENT_TYPE.STRING],
+                enumProvider: commonEnumProviders.characters('character'),
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'field',
+                description: t`Specific field to retrieve. If not provided, returns the entire character data.`,
+                typeList: [ARGUMENT_TYPE.STRING],
+                enumList: [
+                    new SlashCommandEnumValue('name', t`Character name`, enumTypes.enum),
+                    new SlashCommandEnumValue('description', t`Character description`, enumTypes.enum),
+                    new SlashCommandEnumValue('personality', t`Character personality`, enumTypes.enum),
+                    new SlashCommandEnumValue('scenario', t`Character scenario`, enumTypes.enum),
+                    new SlashCommandEnumValue('first_mes', t`First message`, enumTypes.enum),
+                    new SlashCommandEnumValue('mes_example', t`Message examples`, enumTypes.enum),
+                    new SlashCommandEnumValue('creator_notes', t`Creator notes`, enumTypes.enum),
+                    new SlashCommandEnumValue('system_prompt', t`System prompt`, enumTypes.enum),
+                    new SlashCommandEnumValue('post_history_instructions', t`Post-history instructions`, enumTypes.enum),
+                    new SlashCommandEnumValue('creator', t`Creator name`, enumTypes.enum),
+                    new SlashCommandEnumValue('character_version', t`Character version`, enumTypes.enum),
+                    new SlashCommandEnumValue('tags', t`Character tags`, enumTypes.enum),
+                    new SlashCommandEnumValue('talkativeness', t`Talkativeness`, enumTypes.enum),
+                    new SlashCommandEnumValue('avatar', t`Avatar filename`, enumTypes.enum),
+                    new SlashCommandEnumValue('fav', t`Favorite status`, enumTypes.enum),
+                ],
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'return',
+                description: t`The way to return the result`,
+                typeList: [ARGUMENT_TYPE.STRING],
+                defaultValue: 'pipe',
+                enumList: slashCommandReturnHelper.enumList({ allowPipe: true, allowObject: true, allowChat: false, allowPopup: true, allowTextVersion: false }),
+            }),
+        ],
+        helpString: `
+        <div>
+            ${t`Retrieves character data. Can get all data or a specific field.`}
+        </div>
+        <div>
+            <strong>${t`Example:`}</strong>
+            <ul>
+                <li>
+                    <pre><code>/char-get field=description | /echo</code></pre>
+                    ${t`Outputs the current character's description.`}
+                </li>
+                <li>
+                    <pre><code>/char-get char="Alice" field=personality</code></pre>
+                    ${t`Returns Alice's personality field.`}
+                </li>
+                <li>
+                    <pre><code>/char-get char="Bob" return=object</code></pre>
+                    ${t`Returns Bob's entire character data as an object.`}
+                </li>
+            </ul>
+        </div>
+        `,
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'char-delete',
+        callback: deleteCharacterCallback,
+        returns: t`true if the character was deleted, false otherwise`,
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'char',
+                description: t`Character name or avatar key. If not provided, uses the currently selected character.`,
+                typeList: [ARGUMENT_TYPE.STRING],
+                enumProvider: commonEnumProviders.characters('character'),
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'deleteChats',
+                description: t`Whether to also delete all chats with this character`,
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'false',
+                enumProvider: commonEnumProviders.boolean('trueFalse'),
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'silent',
+                description: t`Skip the confirmation popup`,
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'false',
+                enumProvider: commonEnumProviders.boolean('trueFalse'),
+            }),
+        ],
+        helpString: `
+        <div>
+            ${t`Deletes a character from the system.`}
+        </div>
+        <div>
+            ${t`If no <code>char</code> argument is provided, deletes the currently selected character.`}
+        </div>
+        <div>
+            <strong>${t`Warning:`}</strong> ${t`This action is irreversible!`}
+        </div>
+        <div>
+            <strong>${t`Example:`}</strong>
+            <ul>
+                <li>
+                    <pre><code>/char-delete</code></pre>
+                    ${t`Deletes the currently selected character (will show confirmation popup).`}
+                </li>
+                <li>
+                    <pre><code>/char-delete char="Bob" deleteChats=true silent=true</code></pre>
+                    ${t`Deletes Bob and all associated chats without confirmation.`}
+                </li>
+            </ul>
+        </div>
+        `,
+    }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'message-role',
         callback: messageRoleCallback,

     await reloadCurrentChat();
+}
+/**
+ * Opens a file picker dialog for selecting an image.
+ * @returns {Promise<string|null>} Base64 data URL of selected image, or null if cancelled
+ */
+async function promptForAvatarFile() {
+    return new Promise(resolve => {
+        const input = document.createElement('input');
+        input.type = 'file';
+        input.accept = supportedImageMimeTypes.join(',');
+        input.onchange = async (e) => {
+            if (!(e.target instanceof HTMLInputElement)) {
+                return '';
+            }
+            const file = e.target?.files?.[0];
+            if (!file) {
+                resolve(null);
+                return;
+            }
+            try {
+                const converted = await ensureImageFormatSupported(file);
+                const base64 = await getBase64Async(converted);
+                resolve(base64);
+            } catch (error) {
+                console.error('Error processing selected image:', error);
+                toastr.error(t`Failed to process selected image: ${error.message}`);
+                resolve(null);
+            }
+        };
+        input.oncancel = () => resolve(null);
+        input.click();
+    });
+}
+/**
+ * Resolves avatar data from various input formats (base64, local path, or prompt).
+ * @param {string} input - "prompt" to open file picker, base64 data URL, or local file path
+ * @returns {Promise<string|null>} Base64 data URL or null if invalid/cancelled
+ */
+async function resolveAvatarData(input) {
+    if (!input || typeof input !== 'string') {
+        return null;
+    }
+    const trimmed = input.trim();
+    // Special value "prompt" opens file picker
+    if (trimmed.toLowerCase() === 'prompt') {
+        return await promptForAvatarFile();
+    }
+    // Already a base64 data URL
+    if (trimmed.startsWith('data:image/')) {
+        return trimmed;
+    }
+    // External URLs are not supported
+    if (isExternalUrl(trimmed)) {
+        toastr.warning(t`External URLs are not supported for avatars. Use a local file path or "prompt" to select a file.`);
+        return null;
+    }
+    // Local path or URL (e.g., characters/name.png) - fetch from ST server or same origin
+    // Supported paths: /characters/*, /backgrounds/*, /User Avatars/*, /assets/*, /user/images/*
+    // Also supports same-origin URLs (e.g., https://localhost:8000/characters/name.png)
+    if (trimmed.includes('/') || trimmed.endsWith('.png')) {
+        try {
+            // Construct the URL to fetch the local file
+            let url = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+            // Handle same-origin URLs
+            if (trimmed.startsWith(window.location.origin)) {
+                url = new URL(trimmed).pathname;
+            }
+            // If there is no subfolder, we guess this should be a character image
+            if (!url.includes('/', 1)) {
+                url = '/characters/' + trimmed;
+            }
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`File not found or inaccessible: ${response.status}`);
+            }
+            const blob = await response.blob();
+            if (!blob.type.startsWith('image/')) {
+                throw new Error('File is not an image');
+            }
+            const converted = await ensureImageFormatSupported(new File([blob], 'avatar.png', { type: blob.type }));
+            return await getBase64Async(converted);
+        } catch (error) {
+            console.error('Error fetching local avatar:', error);
+            toastr.warning(t`Failed to load avatar from path: ${error.message}`);
+            return null;
+        }
+    }
+    // Unknown format
+    console.warn('Unknown avatar format:', trimmed.substring(0, 50));
+    toastr.warning(t`Unknown avatar format. Use "prompt" to select a file, or provide a local file path.`);
+    return null;
+}
+/**
+ * Uploads an avatar image to a character.
+ * @param {string} avatarKey - The character's avatar filename (e.g., "name.png")
+ * @param {string} base64Data - Base64 data URL of the image
+ * @param {object} [options={}] - Options
+ * @param {boolean} [options.resizePrompt=false] - Whether to show the resize/crop prompt
+ * @returns {Promise<boolean>} True if upload was successful, false if cancelled or failed
+ */
+async function uploadCharacterAvatar(avatarKey, base64Data, { resizePrompt = false } = {}) {
+    if (!base64Data || !avatarKey) {
+        return false;
+    }
+    let finalImageData = base64Data;
+    // Handle resize prompt
+    if (resizePrompt) {
+        if (power_user.never_resize_avatars) {
+            toastr.warning(t`Avatar resizing is disabled in settings. The image will be uploaded as-is.`);
+        } else {
+            const dlg = new Popup(t`Set the crop position of the avatar image`, POPUP_TYPE.CROP, '', { cropImage: base64Data });
+            const croppedImage = await dlg.show();
+            if (!croppedImage) {
+                // User cancelled the crop dialog
+                return false;
+            }
+            // The dialog returns the already-cropped image
+            finalImageData = String(croppedImage);
+        }
+    }
+    try {
+        // Convert base64 to blob
+        const response = await fetch(finalImageData);
+        const blob = await response.blob();
+        // Create form data for upload
+        const formData = new FormData();
+        formData.append('avatar', blob, 'avatar.png');
+        formData.append('avatar_url', avatarKey);
+        const uploadResponse = await fetch('/api/characters/edit-avatar', {
+            method: 'POST',
+            headers: getRequestHeaders({ omitContentType: true }),
+            body: formData,
+        });
+        if (!uploadResponse.ok) {
+            const errorText = await uploadResponse.text();
+            throw new Error(errorText); // Will be caught and logged below
+        }
+        // Bust cache for the avatar thumbnail and character image
+        const thumbnailUrl = getThumbnailUrl('avatar', avatarKey);
+        await fetch(thumbnailUrl, { method: 'GET', cache: 'reload' });
+        await fetch(`/characters/${avatarKey}`, { method: 'GET', cache: 'reload' });
+        // Refresh all visible avatar images that use this thumbnail URL
+        // This handles messages, character list, and any other place using the thumbnail
+        const avatarImages = document.querySelectorAll(`img[src^="${thumbnailUrl}"]`);
+        for (const img of avatarImages) {
+            if (img instanceof HTMLImageElement) {
+                const originalSrc = img.src;
+                img.src = '';
+                img.src = originalSrc;
+            }
+        }
+        console.debug(`Refreshed ${avatarImages.length} avatar images for ${avatarKey}`);
+        return true;
+    } catch (error) {
+        console.error('Error uploading character avatar:', error);
+        toastr.warning(t`Failed to upload avatar: ${error.message}`);
+        return false;
+    }
+}
+/**
+ * Creates a new character via the API.
+ * @param {object} args Named arguments
+ * @returns {Promise<string>} The avatar key of the created character
+ */
+async function createCharacterCallback(args) {
+    const name = args.name;
+    const description = args.description;
+    const firstMessage = args.firstMessage;
+    if (!name || typeof name !== 'string' || !name.trim()) {
+        toastr.warning(t`Character name is required`);
+        return '';
+    }
+    if (!description || typeof description !== 'string') {
+        toastr.warning(t`Character description is required`);
+        return '';
+    }
+    if (!firstMessage || typeof firstMessage !== 'string') {
+        toastr.warning(t`Character first message is required`);
+        return '';
+    }
+    // Build the character data object matching the server's expected format
+    const characterData = {
+        ch_name: name.trim(),
+        description: description,
+        first_mes: firstMessage,
+        personality: args.personality ?? '',
+        scenario: args.scenario ?? '',
+        mes_example: args.messageExamples ?? '',
+        creator_notes: args.creatorNotes ?? '',
+        system_prompt: args.systemPrompt ?? '',
+        post_history_instructions: args.postHistoryInstructions ?? '',
+        creator: args.creator ?? '',
+        character_version: args.characterVersion ?? '',
+        tags: args.tags ? args.tags.split(',').map(t => t.trim()).filter(t => t) : [],
+        talkativeness: args.talkativeness ?? '0.5',
+        world: args.world ?? '',
+        depth_prompt_prompt: args.depthPrompt ?? '',
+        depth_prompt_depth: args.depthPromptDepth ?? '4',
+        depth_prompt_role: args.depthPromptRole ?? 'system',
+        fav: isTrueBoolean(args.favorite) ? 'true' : 'false',
+        alternate_greetings: [],
+        extensions: '{}',
+    };
+    // Handle avatar if provided (URL or base64)
+    const avatarData = args.avatar ? await resolveAvatarData(args.avatar) : null;
+    try {
+        const response = await fetch('/api/characters/create', {
+            method: 'POST',
+            headers: getRequestHeaders(),
+            body: JSON.stringify(characterData),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(errorText); // Will be caught and logged below
+        }
+        const avatarKey = await response.text();
+        // Upload avatar if provided
+        if (avatarData) {
+            const resizePrompt = !isFalseBoolean(args.avatarPromptResize);
+            const uploaded = await uploadCharacterAvatar(avatarKey, avatarData, { resizePrompt });
+            if (!uploaded && resizePrompt) {
+                // User cancelled the resize dialog, but character was still created
+                toastr.info(t`Character created without avatar (resize cancelled)`);
+            }
+        }
+        // Refresh the character list
+        await getCharacters();
+        // Select the character if requested (default: true)
+        const shouldSelect = !isFalseBoolean(args.select);
+        if (shouldSelect) {
+            const characterIndex = characters.findIndex(c => c.avatar === avatarKey);
+            if (characterIndex !== -1) {
+                // selectCharacterById handles group reset and active character setting
+                await selectCharacterById(characterIndex);
+            }
+        }
+        toastr.success(t`Character "${name}" created successfully`);
+        return avatarKey;
+    } catch (error) {
+        console.error('Error creating character:', error);
+        toastr.error(t`Failed to create character: ${error.message}`);
+        return '';
+    }
+}
+/**
+ * Updates an existing character via the merge-attributes API.
+ * @param {object} args Named arguments
+ * @returns {Promise<string>} The avatar key of the updated character
+ */
+async function updateCharacterCallback(args) {
+    // Find the target character
+    let character;
+    let characterIndex;
+    if (args.char) {
+        character = findChar({ name: args.char });
+        if (!character) {
+            toastr.warning(t`Character "${args.char}" not found`);
+            return '';
+        }
+        characterIndex = String(characters.indexOf(character));
+    } else {
+        // Use currently selected character
+        if (this_chid === undefined || !characters[this_chid]) {
+            toastr.warning(t`No character selected and no char argument provided`);
+            return '';
+        }
+        character = characters[this_chid];
+        characterIndex = this_chid;
+    }
+    // Build the update object with only provided fields
+    const updateData = {
+        avatar: character.avatar,
+    };
+    // Map argument names to character data field names
+    const fieldMappings = {
+        name: 'name',
+        description: 'description',
+        firstMessage: 'first_mes',
+        personality: 'personality',
+        scenario: 'scenario',
+        messageExamples: 'mes_example',
+        creatorNotes: 'creator_notes',
+        systemPrompt: 'system_prompt',
+        postHistoryInstructions: 'post_history_instructions',
+        creator: 'creator',
+        characterVersion: 'character_version',
+        tags: 'tags',
+    };
+    // Add provided fields to update data
+    let hasUpdates = false;
+    for (const [argName, fieldName] of Object.entries(fieldMappings)) {
+        if (args[argName] !== undefined) {
+            let value = args[argName];
+            // Handle tags as comma-separated array
+            if (fieldName === 'tags' && typeof value === 'string') {
+                value = value.split(',').map(t => t.trim()).filter(t => t);
+            }
+            updateData[fieldName] = value;
+            // Also set in data object for V2 spec compliance
+            if (!updateData.data) updateData.data = {};
+            updateData.data[fieldName] = value;
+            hasUpdates = true;
+        }
+    }
+    // Special handling for world / lorebook: store under data.extensions.world
+    if (args.world !== undefined) {
+        const value = args.world;
+        if (!updateData.data) {
+            updateData.data = {};
+        }
+        if (!updateData.data.extensions) {
+            updateData.data.extensions = {};
+        }
+        updateData.data.extensions.world = value;
+        hasUpdates = true;
+    }
+    // Handle talkativeness (stored in extensions)
+    if (args.talkativeness !== undefined) {
+        const talkValue = parseFloat(args.talkativeness);
+        if (!isNaN(talkValue)) {
+            updateData.talkativeness = talkValue;
+            if (!updateData.data) updateData.data = {};
+            if (!updateData.data.extensions) updateData.data.extensions = {};
+            updateData.data.extensions.talkativeness = talkValue;
+            hasUpdates = true;
+        }
+    }
+    // Handle favorite
+    if (args.favorite !== undefined) {
+        const favValue = isTrueBoolean(args.favorite);
+        updateData.fav = favValue;
+        if (!updateData.data) updateData.data = {};
+        if (!updateData.data.extensions) updateData.data.extensions = {};
+        updateData.data.extensions.fav = favValue;
+        hasUpdates = true;
+    }
+    // Handle avatar (resolve URL/base64, upload separately after merge)
+    const avatarData = args.avatar ? await resolveAvatarData(args.avatar) : null;
+    if (avatarData) {
+        hasUpdates = true;
+    }
+    // Handle depth prompt fields
+    if (args.depthPrompt !== undefined || args.depthPromptDepth !== undefined || args.depthPromptRole !== undefined) {
+        if (!updateData.data) updateData.data = {};
+        if (!updateData.data.extensions) updateData.data.extensions = {};
+        if (!updateData.data.extensions.depth_prompt) updateData.data.extensions.depth_prompt = {};
+        if (args.depthPrompt !== undefined) {
+            updateData.data.extensions.depth_prompt.prompt = args.depthPrompt;
+            hasUpdates = true;
+        }
+        if (args.depthPromptDepth !== undefined) {
+            updateData.data.extensions.depth_prompt.depth = parseInt(args.depthPromptDepth);
+            hasUpdates = true;
+        }
+        if (args.depthPromptRole !== undefined) {
+            updateData.data.extensions.depth_prompt.role = args.depthPromptRole;
+            hasUpdates = true;
+        }
+    }
+    if (!hasUpdates) {
+        toastr.warning(t`No fields provided to update`);
+        return character.avatar;
+    }
+    try {
+        const response = await fetch('/api/characters/merge-attributes', {
+            method: 'POST',
+            headers: getRequestHeaders(),
+            body: JSON.stringify(updateData),
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(errorData.message || `Server returned ${response.status}`); // Will be caught and logged below
+        }
+        // Upload avatar if provided
+        if (avatarData) {
+            const resizePrompt = !isFalseBoolean(args.avatarPromptResize);
+            const uploaded = await uploadCharacterAvatar(character.avatar, avatarData, { resizePrompt });
+            if (!uploaded && resizePrompt) {
+                // User cancelled the resize dialog
+                toastr.warning(t`Avatar update cancelled`);
+            }
+        }
+        // Refresh the character data
+        await getOneCharacter(character.avatar);
+        await eventSource.emit(event_types.CHARACTER_EDITED, { detail: { id: characterIndex, character: characters[characterIndex] } });
+        // Update the side panel if this is the currently selected character
+        if (characterIndex === this_chid) {
+            select_selected_character(this_chid, { switchMenu: false });
+        }
+        toastr.success(t`Character "${character.name}" updated successfully`);
+        return character.avatar;
+    } catch (error) {
+        console.error('Error updating character:', error);
+        toastr.error(t`Failed to update character: ${error.message}`);
+        return '';
+    }
+}
+/**
+ * Duplicates a character via the slash command.
+ * @param {object} args Named arguments
+ * @returns {Promise<string>} The avatar key of the duplicated character
+ */
+async function duplicateCharacterCallback(args) {
+    // Find the target character if specified
+    let targetAvatar = null;
+    if (args.char) {
+        const character = findChar({ name: args.char });
+        if (!character) {
+            toastr.warning(t`Character "${args.char}" not found`);
+            return '';
+        }
+        targetAvatar = character.avatar;
+    }
+    // Call the duplicateCharacter utility with silent mode (no popup)
+    const newAvatarKey = await duplicateCharacter({ avatar: targetAvatar, silent: true });
+    if (!newAvatarKey) {
+        toastr.error(t`Failed to duplicate character`);
+        return '';
+    }
+    // Select the character if requested (default: false)
+    const shouldSelect = isTrueBoolean(args.select);
+    if (shouldSelect) {
+        const characterIndex = characters.findIndex(c => c.avatar === newAvatarKey);
+        if (characterIndex !== -1) {
+            await selectCharacterById(characterIndex);
+        }
+    }
+    return newAvatarKey;
+}
+/**
+ * Gets character data or a specific field.
+ * @param {object} args Named arguments
+ * @returns {Promise<string>} Character data or field value
+ */
+async function getCharacterDataCallback(args) {
+    // Find the target character
+    let character;
+    if (args.char) {
+        character = findChar({ name: args.char });
+        if (!character) {
+            toastr.warning(t`Character "${args.char}" not found`);
+            return '';
+        }
+    } else {
+        // Use currently selected character
+        if (this_chid === undefined || !characters[this_chid]) {
+            toastr.warning(t`No character selected and no char argument provided`);
+            return '';
+        }
+        character = characters[this_chid];
+    }
+    // If a specific field is requested
+    if (args.field) {
+        const fieldName = args.field;
+        // Try to get from data object first (V2 spec), then fall back to root
+        let value = character.data?.[fieldName] ?? character[fieldName];
+        // Handle special cases for nested fields
+        if (fieldName === 'talkativeness') {
+            value = character.data?.extensions?.talkativeness ?? character.talkativeness ?? 0.5;
+        }
+        if (fieldName === 'tags') {
+            value = character.data?.tags ?? character.tags ?? [];
+            if (Array.isArray(value)) {
+                value = value.join(', ');
+            }
+        }
+        if (value === undefined) {
+            return '';
+        }
+        return await slashCommandReturnHelper.doReturn(args.return ?? 'pipe', value, { objectToStringFunc: x => String(x) });
+    }
+    // Return entire character data
+    const charData = {
+        avatar: character.avatar,
+        name: character.name,
+        description: character.description ?? character.data?.description ?? '',
+        personality: character.personality ?? character.data?.personality ?? '',
+        scenario: character.scenario ?? character.data?.scenario ?? '',
+        first_mes: character.first_mes ?? character.data?.first_mes ?? '',
+        mes_example: character.mes_example ?? character.data?.mes_example ?? '',
+        creator_notes: character.data?.creator_notes ?? '',
+        system_prompt: character.data?.system_prompt ?? '',
+        post_history_instructions: character.data?.post_history_instructions ?? '',
+        creator: character.data?.creator ?? '',
+        character_version: character.data?.character_version ?? '',
+        tags: character.data?.tags ?? character.tags ?? [],
+        talkativeness: character.data?.extensions?.talkativeness ?? character.talkativeness ?? 0.5,
+        fav: character.fav ?? character.data?.extensions?.fav ?? false,
+        chat: character.chat,
+        create_date: character.create_date,
+    };
+    return await slashCommandReturnHelper.doReturn(args.return ?? 'pipe', charData, { objectToStringFunc: x => JSON.stringify(x, null, 2) });
+}
+/**
+ * Deletes a character using the core deleteCharacter function.
+ * @param {object} args Named arguments
+ * @returns {Promise<string>} 'true' if deleted, 'false' otherwise
+ */
+async function deleteCharacterCallback(args) {
+    // Find the target character
+    let character;
+    if (args.char) {
+        character = findChar({ name: args.char });
+        if (!character) {
+            toastr.warning(t`Character "${args.char}" not found`);
+            return 'false';
+        }
+    } else {
+        // Use currently selected character
+        if (this_chid === undefined || !characters[this_chid]) {
+            toastr.warning(t`No character selected and no char argument provided`);
+            return 'false';
+        }
+        character = characters[this_chid];
+    }
+    const deleteChats = isTrueBoolean(args.deleteChats);
+    const silent = isTrueBoolean(args.silent);
+    // Show confirmation popup unless silent mode
+    if (!silent) {
+        const confirmMessage = deleteChats
+            ? t`Are you sure you want to delete "${character.name}" and all associated chats? This action cannot be undone.`
+            : t`Are you sure you want to delete "${character.name}"? This action cannot be undone.`;
+        const result = await callGenericPopup(confirmMessage, POPUP_TYPE.CONFIRM);
+        if (result !== POPUP_RESULT.AFFIRMATIVE) {
+            return 'false';
+        }
+    }
+    try {
+        // Use the core deleteCharacter function which handles all cleanup and events
+        const success = await deleteCharacter(character.avatar, { deleteChats });
+        return success ? 'true' : 'false';
+    } catch (error) {
+        console.error('Error deleting character:', error);
+        toastr.error(t`Failed to delete character: ${error.message}`);
+        return 'false';
+    }
+}
 async function continueChatCallback(args, prompt) {
     const shouldAwait = isTrueBoolean(args?.await);

public/scripts/tags.js+77 -0 Viewed

 import { renderTemplateAsync } from './templates.js';
 import { t, translate } from './i18n.js';
 import { accountStorage } from './util/AccountStorage.js';
+import { enumTypes, SlashCommandEnumValue } from './slash-commands/SlashCommandEnumValue.js';
 export {
     TAG_FOLDER_TYPES,

         </div>
     `,
     }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'tag-import',
+        /** @param {{name: string, mode: 'all'|'existing'|'none'|'ask'}} namedArgs @returns {Promise<string>} */
+        callback: async ({ name, mode }) => {
+            if (selected_group !== null) {
+                toastr.warning(t`Tag import does not support group chats.`);
+                return 'false';
+            }
+            const key = searchCharByName(name);
+            if (!key) return 'false';
+            // Map mode argument to tag_import_setting
+            const modeMap = {
+                'all': tag_import_setting.ALL,
+                'existing': tag_import_setting.ONLY_EXISTING,
+                'none': tag_import_setting.NONE,
+                'ask': tag_import_setting.ASK,
+            };
+            if (mode && !modeMap[mode]) {
+                toastr.warning(`Invalid tag import mode: ${mode}. Valid modes are: ${Object.keys(modeMap).join(', ')}`);
+                return 'false';
+            }
+            const importSetting = mode ? modeMap[mode] : null;
+            const character = findChar({ name: key });
+            const result = await importTags(character, { importSetting });
+            return result ? 'true' : 'false';
+        },
+        returns: t`true if any tags were imported, false otherwise`,
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'name',
+                description: 'Character name - or unique character identifier (avatar key)',
+                typeList: [ARGUMENT_TYPE.STRING],
+                defaultValue: '{{char}}',
+                enumProvider: commonEnumProviders.characters(),
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'mode',
+                description: t`Import mode: "all" imports all tags, "existing" imports only existing ST tags, "none" skips import, "ask" shows the import popup (default: uses your saved setting)`,
+                typeList: [ARGUMENT_TYPE.STRING],
+                enumList: [
+                    new SlashCommandEnumValue('all', t`Import all tags (create new ones if needed)`, enumTypes.enum),
+                    new SlashCommandEnumValue('existing', t`Import only existing ST tags`, enumTypes.enum),
+                    new SlashCommandEnumValue('none', t`Skip import`, enumTypes.enum),
+                    new SlashCommandEnumValue('ask', t`Show the import popup`, enumTypes.enum),
+                ],
+            }),
+        ],
+        helpString: `
+        <div>
+            ${t`Imports character card tags as SillyTavern tags for folder/filter use.`}
+        </div>
+        <div>
+            ${t`Character cards can have embedded tags (set via <code>tags</code> argument in <code>/char-create</code> or <code>/char-update</code>). This command imports those embedded tags as ST tags that can be used for filtering and organizing characters.`}
+        </div>
+        <div>
+            ${t`If no mode is specified, uses your saved tag import setting from preferences.`}
+        </div>
+        <div>
+            <strong>${t`Example:`}</strong>
+            <ul>
+                <li>
+                    <pre><code>/tag-import</code></pre>
+                    ${t`Imports tags for the current character using your default setting.`}
+                </li>
+                <li>
+                    <pre><code>/tag-import name="Alice" mode=all</code></pre>
+                    ${t`Imports all of Alice's card tags, creating new ST tags if needed.`}
+                </li>
+            </ul>
+        </div>
+        `,
+    }));
+}
 /**

public/scripts/utils.js+19 -7 Viewed

+}
 /**
+ * Checks if a URL is external to the current domain.
+ * @param {string} url URL to check
+ * @returns {boolean} True if the URL is external, false otherwise
+ */
+export function isExternalUrl(url) {
+    return (url.indexOf('://') > 0 || url.indexOf('//') === 0) && !url.startsWith(window.location.origin);
+}
+/**
  * Checks if a string is a valid UUID (version 1-5).
  * @param {string} value String to check
  * @returns {boolean} True if the string is a valid UUID, false otherwise.

+}
 /**
- * Ensure that we can import war crime image formats like WEBP and AVIF.
+ *  An array of all supported image MIME types.
- * @param {File} file Input file
- * @returns {Promise<File>} A promise that resolves to the supported file.
  */
-export async function ensureImageFormatSupported(file) {
+export const supportedImageMimeTypes = Object.freeze([
-    const supportedTypes = [
     'image/jpeg',
     'image/png',
     'image/bmp',

     'image/apng',
     'image/webp',
     'image/avif',
-    ];
+]);
-    if (supportedTypes.includes(file.type) || !file.type.startsWith('image/')) {
+/**
+ * Ensure that we can import war crime image formats like WEBP and AVIF.
+ * @param {File} file Input file
+ * @returns {Promise<File>} A promise that resolves to the supported file.
+ */
+export async function ensureImageFormatSupported(file) {
+    if (supportedImageMimeTypes.includes(file.type) || !file.type.startsWith('image/')) {
         return file;
+    }