Permanent assistant autocreation and temporary chat restore

31e2cf714a43fef67f4ee2ab02a2f3b9eae14568

Cohee <18619528+Cohee1207@users.noreply.github.com>

Parents: 61f69aa674ab237d8d02fb96636595e8c09984d7

public/script.js+35 -6 Viewed

 import { getContext } from './scripts/st-context.js';
 import { extractReasoningFromData, initReasoning, parseReasoningInSwipes, PromptReasoning, ReasoningHandler, removeReasoningFromString, updateReasoningUI } from './scripts/reasoning.js';
 import { accountStorage } from './scripts/util/AccountStorage.js';
 import { initWelcomeScreen, openPermanentAssistantChat, openPermanentAssistantCard } from './scripts/welcome-screen.js';
 // API OBJECT FOR EXTERNAL WIRING
 globalThis.SillyTavern = {

@@ -2041,7 +2041,7 @@ export async function sendTextareaMessage() {
2041	2041	}
2042	2042
2043	2043	if (textareaText && !selected_group && this_chid === undefined && name2 !== neutralCharacterName) {
2044	2044	await newAssistantChat({ temporary: false });
2045	2045	}
2046	2046
2047	2047	Generate(generateType);

     return true;
+}
 -export function sendSystemMessage(type, text, extra = {}) {
 +/**
 + * Gets a system message by type.
 + * @param {string} type Type of system message
 + * @param {string} [text] Text to be sent
 + * @param {object} [extra] Additional data to be added to the message
 + * @returns {object} System message object
 + */
 +export function getSystemMessageByType(type, text, extra = {}) {
     const systemMessage = system_messages[type];
     if (!systemMessage) {

     newMessage.extra = Object.assign(newMessage.extra, extra);
     newMessage.extra.type = type;
 +    return newMessage;
 +}
 +/**
 + * Sends a system message to the chat.
 + * @param {string} type Type of system message
 + * @param {string} [text] Text to be sent
 + * @param {object} [extra] Additional data to be added to the message
 + */
 +export function sendSystemMessage(type, text, extra = {}) {
 +    const newMessage = getSystemMessageByType(type, text, extra);
     chat.push(newMessage);
     addOneMessage(newMessage);
     is_send_press = false;

     saveSettingsDebounced();
+}
 -export async function newAssistantChat() {
 +/**
 + * Creates a new assistant chat.
 + * @param {object} params - Parameters for the new assistant chat
 + * @param {boolean} [params.temporary=false] I need a temporary secretary
 + * @returns {Promise<void>} - A promise that resolves when the new assistant chat is created
 + */
 +export async function newAssistantChat({ temporary = false } = {}) {
     await clearChat();
 +    if (!temporary) {
 +        return openPermanentAssistantChat();
 +    }
     chat.splice(0, chat.length);
     chat_metadata = {};
     setCharacterName(neutralCharacterName);

                     if (chatId) {
                         return reject('Not in a temporary chat');
+                    }
                     await newAssistantChat({ temporary: true });
                     return resolve('');
                 };
                 eventSource.once(event_types.CHAT_CHANGED, eventCallback);

         });
         if (id == 'option_select_chat') {
 +            if (this_chid === undefined && !is_send_press) {
 +                await openPermanentAssistantCard();
 +            }
             if ((selected_group && !is_group_generating) || (this_chid !== undefined && !is_send_press) || fromSlashCommand) {
                 await displayPastChats();
                 //this is just to avoid the shadow for past chat view when using /delchat

@@ -11124,7 +11153,7 @@ jQuery(async function () {
11124	11153	await doNewChat({ deleteCurrentChat: deleteCurrentChat });
11125	11154	}
11126	11155	if (!selected_group && this_chid === undefined && !is_send_press) {
11127	11156	await newAssistantChat({ temporary: true });
11128	11157	}
11129	11158	}
11130	11159

public/scripts/chats.js+33 -0 Viewed

     neutralCharacterName,
     updateChatMetadata,
     system_message_types,
 +    getSystemMessageByType,
 +    printMessages,
 +    clearChat,
 } from '../script.js';
 import { selected_group } from './group-chats.js';
 import { power_user } from './power-user.js';

     saveBase64AsFile,
     extractTextFromOffice,
     download,
 +    getFileText,
 } from './utils.js';
 import { extension_settings, renderExtensionTemplateAsync, saveMetadataDebounced } from './extensions.js';
 import { POPUP_RESULT, POPUP_TYPE, Popup, callGenericPopup } from './popup.js';

         download(chatToSave.map((m) => JSON.stringify(m)).join('\n'), `Assistant - ${humanizedDateTime()}.jsonl`, 'application/json');
     });
 +    $(document).on('click', '.assistant_note_import', async function () {
 +        const importFile = async () => {
 +            const file = fileInput.files[0];
 +            if (!file) {
 +                return;
 +            }
++
 +            try {
 +                const text = await getFileText(file);
 +                const lines = text.split('\n').filter(line => line.trim() !== '');
 +                const messages = lines.map(line => JSON.parse(line));
 +                const metadata = messages.shift()?.chat_metadata || {};
 +                messages.unshift(getSystemMessageByType(system_message_types.ASSISTANT_NOTE));
 +                await clearChat();
 +                chat.splice(0, chat.length, ...messages);
 +                updateChatMetadata(metadata, true);
 +                await printMessages();
 +            } catch (error) {
 +                console.error('Error importing assistant chat:', error);
 +                toastr.error(t`It's either corrupted or not a valid JSONL file.`, t`Failed to import chat`);
 +            }
 +        };
 +        const fileInput = document.createElement('input');
 +        fileInput.type = 'file';
 +        fileInput.accept = '.jsonl';
 +        fileInput.addEventListener('change', importFile);
 +        fileInput.click();
 +    });
++
     // Do not change. #attachFile is added by extension.
     $(document).on('click', '#attachFile', function () {
         $('#file_form_input').trigger('click');

public/scripts/templates/assistantNote.html+8 -4 Viewed

 <div data-type="assistant_note">
     <div class="assistant_note_title">
         <b data-i18n="Note:">Note:</b> <span data-i18n="this chat is temporary and will be deleted as soon as you leave it.">this chat is temporary and will be deleted as soon as you leave it.</span>
 -        <span data-i18n="Click the button to save it as a file.">Click the button to save it as a file.</span>
     </div>
     <divbutton class="assistant_note_exportassistant_note_import menu_button menu_button_icon margin0" data-i18n="[title]ExportImport asfrom JSONL" title="ExportImport asfrom JSONL">
 +        <i class="fa-solid fa-file-import"></i>
 +        <span data-i18n="Load">Load</span>
 +    </button>
 +    <button class="assistant_note_export menu_button menu_button_icon margin0" data-i18n="[title]Export as JSONL" title="Export as JSONL">
         <i class="fa-solid fa-file-export"></i>
 -    </div>
 +        <span data-i18n="Save">Save</span>
 +    </button>
 </div>

public/scripts/welcome-screen.js+77 -4 Viewed

 import {
     characters,
     displayVersion,
 +    doNewChat,
     event_types,
     eventSource,
 +    getCharacters,
     getCurrentChatId,
     getRequestHeaders,
     getThumbnailUrl,
 +    is_send_press,
 +    neutralCharacterName,
     newAssistantChat,
     openCharacterChat,
     selectCharacterById,
     sendSystemMessage,
     system_message_types,
 } from '../script.js';
 +import { is_group_generating } from './group-chats.js';
 import { t } from './i18n.js';
 import { renderTemplateAsync } from './templates.js';
 import { timestampToMoment } from './utils.js';
 +const permanentAssistantAvatar = 'default_Assistant.png';
++
 export async function openWelcomeScreen() {
     const currentChatId = getCurrentChatId();
     if (currentChatId !== undefined) {

 async function sendWelcomePanel() {
     try {
         const chatElement =   document.getElementById('chat');
         if (!chatElement) {
             console.error('Chat element not found');
             return;

         const chats = await getRecentChats();
         const templateData = {
             chats,
             empty: !chats.length ,
             version: displayVersion,
         };
         const template = await renderTemplateAsync('welcomePanel', templateData);

             });
         });
         fragment.querySelector('button.openTemporaryChat').addEventListener('click', () => {
             void newAssistantChat({ temporary: true });
         });
         chatElement.append(fragment.firstChild);
     } catch (error) {

     /** @type {RecentChat[]} */
     const data = await response.json();
     data.sort((a, b) =>   b.last_mes - a.last_mes).forEach((chat, index) => {
         const character = characters.find(x => x.avatar === chat.avatar);
         if (!character) {
             console.warn(`Character not found for chat: ${chat.file_name}`);

     return data;
+}
 +export async function openPermanentAssistantChat({ tryCreate = true } = {}) {
 +    const characterId = characters.findIndex(x => x.avatar === permanentAssistantAvatar);
 +    if (characterId === -1) {
 +        if (!tryCreate) {
 +            console.error(`Character not found for avatar ID: ${permanentAssistantAvatar}. Cannot create.`);
 +            return;
 +        }
++
 +        try {
 +            console.log(`Character not found for avatar ID: ${permanentAssistantAvatar}. Creating new assistant.`);
 +            await createPermanentAssistant();
 +            return openPermanentAssistantChat({ tryCreate: false });
 +        }
 +        catch (error) {
 +            console.error('Error creating permanent assistant:', error);
 +            toastr.error(t`Failed to create ${neutralCharacterName}. See console for details.`);
 +            return;
 +        }
 +    }
++
 +    try {
 +        await selectCharacterById(characterId);
 +        await doNewChat({ deleteCurrentChat: false });
 +        console.log(`Opened permanent assistant chat for ${neutralCharacterName}.`, getCurrentChatId());
 +    } catch (error) {
 +        console.error('Error opening permanent assistant chat:', error);
 +        toastr.error(t`Failed to open permanent assistant chat. See console for details.`);
 +    }
 +}
++
 +async function createPermanentAssistant() {
 +    if (is_group_generating || is_send_press) {
 +        throw new Error(t`Cannot create while generating.`);
 +    }
++
 +    const formData = new FormData();
 +    formData.append('ch_name', neutralCharacterName);
 +    formData.append('file_name', permanentAssistantAvatar.replace('.png', ''));
++
 +    const headers = getRequestHeaders();
 +    delete headers['Content-Type'];
++
 +    const fetchResult = await fetch('/api/characters/create', {
 +        method: 'POST',
 +        headers: headers,
 +        body: formData,
 +        cache: 'no-cache',
 +    });
++
 +    if (!fetchResult.ok) {
 +        throw new Error(t`Creation request did not succeed.`);
 +    }
++
 +    await getCharacters();
 +}
++
 +export async function openPermanentAssistantCard() {
 +    const characterId = characters.findIndex(x => x.avatar === permanentAssistantAvatar);
 +    if (characterId === -1) {
 +        toastr.info(t`Assistant not found. Try sending a chat message.`);
 +        return;
 +    }
++
 +    await selectCharacterById(characterId);
 +}
++
 export function initWelcomeScreen() {
     const events = [event_types.CHAT_CHANGED, event_types.APP_READY];
     for (const event of events) {

public/style.css+3 -3 Viewed

     flex-wrap: nowrap;
     justify-content: space-between;
     align-items: center;
     gap: 10px5px;
 -    padding: 0 2px;
+}
 .mes_text div[data-type="assistant_note"]:has(.assistant_note_export) > div:not(.assistant_note_export) {
     flex: 1;
 +    text-align: left;
+}
 .oneline-dropdown label {

src/endpoints/characters.js+4 -4 Viewed

     _.set(char, 'mes_example', data.mes_example || '');
     // Old ST extension fields (for backward compatibility, will be deprecated)
     _.set(char, 'creatorcomment', data.creator_notes || '');
     _.set(char, 'avatar', 'none');
     _.set(char, 'chat', data.ch_name + ' - ' + humanizedISO8601DateTime());
     _.set(char, 'talkativeness', data.talkativeness || 0.5);
     _.set(char, 'fav', data.fav == 'true');
     _.set(char, 'tags', typeof data.tags == 'string' ? (data.tags.split(',').map(x => x.trim()).filter(x => x)) : data.tags || []);

     _.set(char, 'data.alternate_greetings', getAlternateGreetings(data));
     // ST extension fields to V2 object
     _.set(char, 'data.extensions.talkativeness', data.talkativeness || 0.5);
     _.set(char, 'data.extensions.fav', data.fav == 'true');
     _.set(char, 'data.extensions.world', data.world || '');

         request.body.ch_name = sanitize(request.body.ch_name);
         const char = JSON.stringify(charaFormatData(request.body, request.user.directories));
         const internalName = request.body.file_name || getPngName(request.body.ch_name, request.user.directories);
         const avatarName = `${internalName}.png`;
         const chatsPath = path.join(request.user.directories.chats, internalName);