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 } from './scripts/welcome-screen.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	if (textareaText && !selected_group && this_chid === undefined && name2 !== neutralCharacterName) {	2043	if (textareaText && !selected_group && this_chid === undefined && name2 !== neutralCharacterName) {
2044	await newAssistantChat();	2044	await newAssistantChat({ temporary: false });
2045	}	2045	}
2046		2046
2047	Generate(generateType);	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();
+                    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	await doNewChat({ deleteCurrentChat: deleteCurrentChat });	11153	await doNewChat({ deleteCurrentChat: deleteCurrentChat });
11125	}	11154	}
11126	if (!selected_group && this_chid === undefined && !is_send_press) {	11155	if (!selected_group && this_chid === undefined && !is_send_press) {
11127	await newAssistantChat();	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>
+    <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>
-    <div class="assistant_note_export menu_button menu_button_icon" data-i18n="[title]Export as JSONL" title="Export as JSONL">
+    <button class="assistant_note_import menu_button menu_button_icon margin0" data-i18n="[title]Import from JSONL" title="Import from 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');
+        const chatElement = document.getElementById('chat');
         if (!chatElement) {
             console.error('Chat element not found');
             return;

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

             });
         });
         fragment.querySelector('button.openTemporaryChat').addEventListener('click', () => {
-            void newAssistantChat();
+            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) => {
+    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: 10px;
+    gap: 5px;
-    padding: 0 2px;
+}
-.mes_text div[data-type="assistant_note"]:has(.assistant_note_export)>div:not(.assistant_note_export) {
+.mes_text div[data-type="assistant_note"]:has(.assistant_note_export) > div {
     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, 'creatorcomment', data.creator_notes || '');
     _.set(char, 'avatar', 'none');
     _.set(char, 'chat', data.ch_name + ' - ' + humanizedISO8601DateTime());
-    _.set(char, 'talkativeness', data.talkativeness);
+    _.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);
+    _.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 = getPngName(request.body.ch_name, 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);