Merge branch 'staging' of https://github.com/Cohee1207/SillyTavern into staging

d772d24052674993efa53bd9c04057ec537eebff

RossAscends <124905043+RossAscends@users.noreply.github.com>

Parents: cdb271e6ec3533cda8f92e98cc9da2a79471e087 ac50cec02f72ffe70757fc55d4bc9371368d8068

public/scripts/extensions/stable-diffusion/index.js+2 -4 Viewed

     str = str.replaceAll('"', '');
     str = str.replaceAll('“', '');
-    str = str.replaceAll('.', ',');
     str = str.replaceAll('\n', ', ');
     str = str.normalize('NFD');
-    str = str.replace(/[^a-zA-Z0-9,:_(){}<>[\]\-']+/g, ' ');
+    str = str.replace(/[^a-zA-Z0-9\.,:_(){}<>[\]\-']+/g, ' ');
     str = str.replace(/\s+/g, ' '); // Collapse multiple whitespaces into one
     str = str.trim();

     });
     if (result.ok) {
-        const data = await result.json();
+        return await result.json();
-        return { format: 'jpg', data: data?.output?.choices?.[0]?.image_base64 };
     } else {
         const text = await result.text();
         throw new Error(text);

public/scripts/variables.js+2 -1 Viewed

             return '';
+        }
-        const operandNumber = Number(operand);
+        // parseFloat will return NaN for spaces.
+        const operandNumber = parseFloat(operand);
         if (!isNaN(operandNumber)) {
             return operandNumber;

public/scripts/world-info.js+31 -25 Viewed

  */
 class WorldInfoBuffer {
     /**
-     * @type {object[]} Array of entries that need to be activated no matter what
+     * @type {Map<string, object>} Map of entries that need to be activated no matter what
      */
-    static externalActivations = [];
+    static externalActivations = new Map();
     /**
      * @type {string[]} Array of messages sorted by ascending depth

+    }
     /**
-     * Check if the current entry is externally activated.
+     * Get the externally activated version of the entry, if there is one.
      * @param {object} entry WI entry to check
-     * @returns {boolean} True if the entry is forcefully activated
+     * @returns {object|undefined} the external version if the entry is forcefully activated, undefined otherwise
      */
-    isExternallyActivated(entry) {
+    getExternallyActivated(entry) {
-        // Entries could be copied with structuredClone, so we need to compare them by string representation
+        return WorldInfoBuffer.externalActivations.get(`${entry.world}.${entry.uid}`);
-        return WorldInfoBuffer.externalActivations.some(x => JSON.stringify(x) === JSON.stringify(entry));
+    }
     /**
      * Clean-up the external effects for entries.
      */
     resetExternalEffects() {
-        WorldInfoBuffer.externalActivations.splice(0, WorldInfoBuffer.externalActivations.length);
+        WorldInfoBuffer.externalActivations = new Map();
+    }
     /**

     worldInfoString = worldInfoBefore + worldInfoAfter;
     if (!isDryRun && activatedWorldInfo.allActivatedEntries && activatedWorldInfo.allActivatedEntries.size > 0) {
-        const arg = Array.from(activatedWorldInfo.allActivatedEntries);
+        const arg = Array.from(activatedWorldInfo.allActivatedEntries.values());
         await eventSource.emit(event_types.WORLD_INFO_ACTIVATED, arg);
+    }

     });
     eventSource.on(event_types.WORLDINFO_FORCE_ACTIVATE, (entries) => {
-        WorldInfoBuffer.externalActivations.push(...entries);
+        for (const entry of entries) {
+            if (!Object.hasOwn(entry, 'world') || !Object.hasOwn(entry, 'uid')) {
+                console.error('[WI] WORLDINFO_FORCE_ACTIVATE requires all entries to have both world and uid fields, entry IGNORED', entry);
+            } else {
+                WorldInfoBuffer.externalActivations.set(`${entry.world}.${entry.uid}`, entry);
+                console.log('[WI] WORLDINFO_FORCE_ACTIVATE added entry', entry);
+            }
+        }
     });
     // Add slash commands

     let scanState = scan_state.INITIAL;
     let token_budget_overflowed = false;
     let count = 0;
-    let allActivatedEntries = new Set();
+    let allActivatedEntries = new Map();
     let failedProbabilityChecks = new Set();
     let allActivatedText = '';

@@ -3789,7 +3795,7 @@ export async function checkWorldInfo(chat, maxContext, isDryRun) {
3789	}	3795	}
3790		3796
3791	// Already processed, considered and then skipped entries should still be skipped	3797	// Already processed, considered and then skipped entries should still be skipped
3792	if (failedProbabilityChecks.has(entry) \|\| allActivatedEntries.has(entry)) {	3798	if (failedProbabilityChecks.has(entry) \|\| allActivatedEntries.has(`${entry.world}.${entry.uid}`)) {
3793	continue;	3799	continue;
3794	}	3800	}
3795		3801

@@ -3869,15 +3875,15 @@ export async function checkWorldInfo(chat, maxContext, isDryRun) {
3869	continue;	3875	continue;
3870	}	3876	}
3871		3877
3872	// Now do checks for immediate activations	3878	if (buffer.getExternallyActivated(entry)) {
3873	if (entry.constant) {	3879	log('externally activated');
3874	log('activated because of constant');	3880	activatedNow.add(buffer.getExternallyActivated(entry));
3875	activatedNow.add(entry);
3876	continue;	3881	continue;
3877	}	3882	}
3878		3883
3879	if (buffer.isExternallyActivated(entry)) {	3884	// Now do checks for immediate activations
3880	log('externally activated');	3885	if (entry.constant) {
		3886	log('activated because of constant');
3881	activatedNow.add(entry);	3887	activatedNow.add(entry);
3882	continue;	3888	continue;
3883	}	3889	}

@@ -4039,7 +4045,7 @@ export async function checkWorldInfo(chat, maxContext, isDryRun) {
4039	break;	4045	break;
4040	}	4046	}
4041		4047
4042	allActivatedEntries.add(entry);	4048	allActivatedEntries.set(`${entry.world}.${entry.uid}`, entry);
4043	console.debug(`[WI] Entry ${entry.uid} activation successful, adding to prompt`, entry);	4049	console.debug(`[WI] Entry ${entry.uid} activation successful, adding to prompt`, entry);
4044	}	4050	}
4045		4051

     // Appends from insertion order 999 to 1. Use unshift for this purpose
     // TODO (kingbri): Change to use WI Anchor positioning instead of separate top/bottom arrays
-    [...allActivatedEntries].sort(sortFn).forEach((entry) => {
+    [...allActivatedEntries.values()].sort(sortFn).forEach((entry) => {
         const regexDepth = entry.position === world_info_position.atDepth ? (entry.depth ?? DEFAULT_DEPTH) : null;
         const content = getRegexedString(entry.content, regex_placement.WORLD_INFO, { depth: regexDepth, isMarkdown: false, isPrompt: true });

         context.setExtensionPrompt(NOTE_MODULE_NAME, ANWithWI, chat_metadata[metadata_keys.position], chat_metadata[metadata_keys.depth], extension_settings.note.allowWIScan, chat_metadata[metadata_keys.role]);
+    }
-    !isDryRun && timedEffects.setTimedEffects(Array.from(allActivatedEntries));
+    !isDryRun && timedEffects.setTimedEffects(Array.from(allActivatedEntries.values()));
     buffer.resetExternalEffects();
     timedEffects.cleanUp();
-    console.log(`[WI] Adding ${allActivatedEntries.size} entries to prompt`, Array.from(allActivatedEntries));
+    console.log(`[WI] Adding ${allActivatedEntries.size} entries to prompt`, Array.from(allActivatedEntries.values()));
     console.debug('[WI] --- DONE ---');
-    return { worldInfoBefore, worldInfoAfter, EMEntries, WIDepthEntries, allActivatedEntries };
+    return { worldInfoBefore, worldInfoAfter, EMEntries, WIDepthEntries, allActivatedEntries: new Set(allActivatedEntries.values()) };
+}
 /**

 /**
  * Filters entries by inclusion groups.
  * @param {object[]} newEntries Entries activated on current recursion level
- * @param {Set<object>} allActivatedEntries Set of all activated entries
+ * @param {Map<string, object>} allActivatedEntries Map of all activated entries
  * @param {WorldInfoBuffer} buffer The buffer to use for scanning
  * @param {number} scanState The current scan state
  * @param {WorldInfoTimedEffects} timedEffects The timed effects currently active

             continue;
+        }
-        if (Array.from(allActivatedEntries).some(x => x.group === key)) {
+        if (Array.from(allActivatedEntries.values()).some(x => x.group === key)) {
             console.debug(`[WI] Skipping inclusion group check, group '${key}' was already activated`);
             // We need to forcefully deactivate all other entries in the group
             removeAllBut(group, null, false);

src/endpoints/stable-diffusion.js+9 -9 Viewed

         console.log('TogetherAI request:', request.body);
-        const result = await fetch('https://api.together.xyz/api/inference', {
+        const result = await fetch('https://api.together.xyz/v1/images/generations', {
             method: 'POST',
             body: JSON.stringify({
-                request_type: 'image-model-inference',
                 prompt: request.body.prompt,
                 negative_prompt: request.body.negative_prompt,
                 height: request.body.height,

                 n: 1,
                 // Limited to 10000 on playground, works fine with more.
                 seed: request.body.seed >= 0 ? request.body.seed : Math.floor(Math.random() * 10_000_000),
-                // Don't know if that's supposed to be random or not. It works either way.
-                sessionKey: getHexString(40),
             }),
             headers: {
                 'Content-Type': 'application/json',

         });
         if (!result.ok) {
-            console.log('TogetherAI returned an error.');
+            console.log('TogetherAI returned an error.', { body: await result.text() });
             return response.sendStatus(500);
+        }
         const data = await result.json();
         console.log('TogetherAI response:', data);
-        if (data.status !== 'finished') {
+        const choice = data?.data?.[0];
-            console.log('TogetherAI job failed.');
+        let b64_json = choice.b64_json;
-            return response.sendStatus(500);
+        if (!b64_json) {
+            const buffer = await (await fetch(choice.url)).buffer();
+            b64_json = buffer.toString('base64');
+        }
-        return response.send(data);
+        return response.send({ format: 'jpg', data: b64_json });
     } catch (error) {
         console.log(error);
         return response.sendStatus(500);