917a994c · permissionBRICK/SillyTavern

package-lock.json+5 -4 Viewed

                 "sanitize-filename": "^1.6.3",
                 "sillytavern-transformers": "2.14.6",
                 "simple-git": "^3.19.1",
-                "tiktoken": "^1.0.15",
+                "tiktoken": "^1.0.16",
                 "vectra": "^0.2.2",
                 "wavefile": "^11.0.0",
                 "write-file-atomic": "^5.0.1",

             "license": "MIT"
         },
         "node_modules/tiktoken": {
-            "version": "1.0.15",
+            "version": "1.0.16",
-            "resolved": "https://registry.npmjs.org/tiktoken/-/tiktoken-1.0.15.tgz",
+            "resolved": "https://registry.npmjs.org/tiktoken/-/tiktoken-1.0.16.tgz",
-            "integrity": "sha512-sCsrq/vMWUSEW29CJLNmPvWxlVp7yh2tlkAjpJltIKqp5CKf98ZNpdeHRmAlPVFlGEbswDc6SmI8vz64W/qErw=="
+            "integrity": "sha512-hRcORIGF2YlAgWx3nzrGJOrKSJwLoc81HpXmMQk89632XAgURc7IeV2FgQ2iXo9z/J96fCvpsHg2kWoHcbj9fg==",
+            "license": "MIT"
         },
         "node_modules/timm": {
             "version": "1.7.1",

package.json+1 -1 Viewed

         "sanitize-filename": "^1.6.3",
         "sillytavern-transformers": "2.14.6",
         "simple-git": "^3.19.1",
-        "tiktoken": "^1.0.15",
+        "tiktoken": "^1.0.16",
         "vectra": "^0.2.2",
         "wavefile": "^11.0.0",
         "write-file-atomic": "^5.0.1",

public/index.html+5 -1 Viewed

                                         Max Response Length (tokens)
                                     </div>
                                     <div class="wide100p">
-                                        <input type="number" id="openai_max_tokens" name="openai_max_tokens" class="text_pole" min="1" max="16384">
+                                        <input type="number" id="openai_max_tokens" name="openai_max_tokens" class="text_pole" min="1" max="65536">
                                     </div>
                                 </div>
                                 <div class="range-block" data-source="openai,custom">

                                         <option value="gpt-4-0125-preview">gpt-4-0125-preview (2024)</option>
                                         <option value="gpt-4-1106-preview">gpt-4-1106-preview (2023)</option>
                                     </optgroup>
+                                    <optgroup label="o1">
+                                        <option value="o1-preview">o1-preview</option>
+                                        <option value="o1-mini">o1-mini</option>
+                                    </optgroup>
                                     <optgroup label="Other">
                                         <option value="text-davinci-003">text-davinci-003</option>
                                         <option value="text-davinci-002">text-davinci-002</option>

public/script.js+32 -56 Viewed

 //css
 var css_send_form_display = $('<div id=send_form></div>').css('display');
-const MAX_GENERATION_LOOPS = 5;
 var kobold_horde_model = '';

 export function isStreamingEnabled() {
     const noStreamSources = [chat_completion_sources.SCALE];
-    return ((main_api == 'openai' && oai_settings.stream_openai && !noStreamSources.includes(oai_settings.chat_completion_source) && !(oai_settings.chat_completion_source == chat_completion_sources.MAKERSUITE && oai_settings.google_model.includes('bison')))
+    return (
+        (main_api == 'openai' &&
+            oai_settings.stream_openai &&
+            !noStreamSources.includes(oai_settings.chat_completion_source) &&
+            !(oai_settings.chat_completion_source == chat_completion_sources.OPENAI && oai_settings.openai_model.startsWith('o1-')) &&
+            !(oai_settings.chat_completion_source == chat_completion_sources.MAKERSUITE && oai_settings.google_model.includes('bison')))
         || (main_api == 'kobold' && kai_settings.streaming_kobold && kai_flags.can_use_streaming)
         || (main_api == 'novel' && nai_settings.streaming_novel)
         || (main_api == 'textgenerationwebui' && textgen_settings.streaming));

@@ -3251,7 +3255,7 @@ export async function generateRaw(prompt, api, instructOverride, quietToLoud, sy
3251	}	3255	}
3252		3256
3253	if (data.error) {	3257	if (data.error) {
3254	throw new Error(data.error);	3258	throw new Error(data.response);
3255	}	3259	}
3256		3260
3257	const message = cleanUpMessage(extractMessageFromData(data), false, false, true);	3261	const message = cleanUpMessage(extractMessageFromData(data), false, false, true);

  * @param {GenerateOptions} options Generation options
  * @param {boolean} dryRun Whether to actually generate a message or just assemble the prompt
  * @returns {Promise<any>} Returns a promise that resolves when the text is done generating.
- * @typedef {{automatic_trigger?: boolean, force_name2?: boolean, quiet_prompt?: string, quietToLoud?: boolean, skipWIAN?: boolean, force_chid?: number, signal?: AbortSignal, quietImage?: string, maxLoops?: number, quietName?: string }} GenerateOptions
+ * @typedef {{automatic_trigger?: boolean, force_name2?: boolean, quiet_prompt?: string, quietToLoud?: boolean, skipWIAN?: boolean, force_chid?: number, signal?: AbortSignal, quietImage?: string, quietName?: string }} GenerateOptions
  */
-export async function Generate(type, { automatic_trigger, force_name2, quiet_prompt, quietToLoud, skipWIAN, force_chid, signal, quietImage, maxLoops, quietName } = {}, dryRun = false) {
+export async function Generate(type, { automatic_trigger, force_name2, quiet_prompt, quietToLoud, skipWIAN, force_chid, signal, quietImage, quietName } = {}, dryRun = false) {
     console.log('Generate entered');
-    await eventSource.emit(event_types.GENERATION_STARTED, type, { automatic_trigger, force_name2, quiet_prompt, quietToLoud, skipWIAN, force_chid, signal, quietImage, maxLoops }, dryRun);
+    await eventSource.emit(event_types.GENERATION_STARTED, type, { automatic_trigger, force_name2, quiet_prompt, quietToLoud, skipWIAN, force_chid, signal, quietImage }, dryRun);
     setGenerationProgress(0);
     generation_started = new Date();

     if (selected_group && !is_group_generating) {
         if (!dryRun) {
             // Returns the promise that generateGroupWrapper returns; resolves when generation is done
-            return generateGroupWrapper(false, type, { quiet_prompt, force_chid, signal: abortController.signal, quietImage, maxLoops });
+            return generateGroupWrapper(false, type, { quiet_prompt, force_chid, signal: abortController.signal, quietImage });
+        }
         const characterIndexMap = new Map(characters.map((char, index) => [char.avatar, index]));

@@ -4399,9 +4403,9 @@ export async function Generate(type, { automatic_trigger, force_name2, quiet_pro
4399	generatedPromptCache = '';	4403	generatedPromptCache = '';
4400		4404
4401	if (data?.response) {	4405	if (data?.response) {
4402	toastr.error(data.response, 'API Error');	4406	toastr.error(data.response, 'API Error', { preventDuplicates: true });
4403	}	4407	}
4404	throw data?.response;	4408	throw new Error(data?.response);
4405	}	4409	}
4406		4410
4407	//const getData = await response.json();	4411	//const getData = await response.json();

         const displayIncomplete = type === 'quiet' && !quietToLoud;
         getMessage = cleanUpMessage(getMessage, isImpersonate, isContinue, displayIncomplete);
-        if (getMessage.length > 0 || data.allowEmptyResponse) {
+        if (isImpersonate) {
-            if (isImpersonate) {
+            $('#send_textarea').val(getMessage)[0].dispatchEvent(new Event('input', { bubbles: true }));
-                $('#send_textarea').val(getMessage)[0].dispatchEvent(new Event('input', { bubbles: true }));
+            generatedPromptCache = '';
-                generatedPromptCache = '';
+            await eventSource.emit(event_types.IMPERSONATE_READY, getMessage);
-                await eventSource.emit(event_types.IMPERSONATE_READY, getMessage);
+        }
-            }
+        else if (type == 'quiet') {
-            else if (type == 'quiet') {
+            unblockGeneration(type);
-                unblockGeneration(type);
+            return getMessage;
-                return getMessage;
+        }
+        else {
+            // Without streaming we'll be having a full message on continuation. Treat it as a last chunk.
+            if (originalType !== 'continue') {
+                ({ type, getMessage } = await saveReply(type, getMessage, false, title, swipes));
+            }
             else {
-                // Without streaming we'll be having a full message on continuation. Treat it as a last chunk.
+                ({ type, getMessage } = await saveReply('appendFinal', getMessage, false, title, swipes));
-                if (originalType !== 'continue') {
-                    ({ type, getMessage } = await saveReply(type, getMessage, false, title, swipes));
-                }
-                else {
-                    ({ type, getMessage } = await saveReply('appendFinal', getMessage, false, title, swipes));
-                }
-                // This relies on `saveReply` having been called to add the message to the chat, so it must be last.
-                parseAndSaveLogprobs(data, continue_mag);
+            }
-            if (type !== 'quiet') {
+            // This relies on `saveReply` having been called to add the message to the chat, so it must be last.
-                playMessageSound();
+            parseAndSaveLogprobs(data, continue_mag);
-            }
+        }
-        } else {
-            // If maxLoops is not passed in (e.g. first time generating), set it to MAX_GENERATION_LOOPS
-            maxLoops ??= MAX_GENERATION_LOOPS;
-            if (maxLoops === 0) {
-                if (type !== 'quiet') {
-                    throwCircuitBreakerError();
-                }
-                throw new Error('Generate circuit breaker interruption');
-            }
-            // regenerate with character speech reenforced
+        if (type !== 'quiet') {
-            // to make sure we leave on swipe type while also adding the name2 appendage
+            playMessageSound();
-            await delay(1000);
-            // A message was already deleted on regeneration, so instead treat is as a normal gen
-            if (type === 'regenerate') {
-                type = 'normal';
-            }
-            // The first await is for waiting for the generate to start. The second one is waiting for it to finish
-            const result = await await Generate(type, { automatic_trigger, force_name2: true, quiet_prompt, quietToLoud, skipWIAN, force_chid, signal, quietImage, quietName, maxLoops: maxLoops - 1 });
-            return result;
+        }
         if (power_user.auto_swipe) {

@@ -5240,11 +5221,6 @@ function getGenerateUrl(api) {
5240	}	5221	}
5241	}	5222	}
5242		5223
5243	function throwCircuitBreakerError() {
5244	callPopup(`Could not extract reply in ${MAX_GENERATION_LOOPS} attempts. Try generating again`, 'text');
5245	unblockGeneration();
5246	}
5247
5248	function extractTitleFromData(data) {	5224	function extractTitleFromData(data) {
5249	if (main_api == 'koboldhorde') {	5225	if (main_api == 'koboldhorde') {
5250	return data.workerName;	5226	return data.workerName;

public/scripts/openai.js+29 -6 Viewed

     const isQuiet = type === 'quiet';
     const isImpersonate = type === 'impersonate';
     const isContinue = type === 'continue';
-    const stream = oai_settings.stream_openai && !isQuiet && !isScale && !(isGoogle && oai_settings.google_model.includes('bison'));
+    const stream = oai_settings.stream_openai && !isQuiet && !isScale && !(isGoogle && oai_settings.google_model.includes('bison')) && !(isOAI && oai_settings.openai_model.startsWith('o1-'));
     const useLogprobs = !!power_user.request_token_probabilities;
     const canMultiSwipe = oai_settings.n > 1 && !isContinue && !isImpersonate && !isQuiet && (isOAI || isCustom);

         generate_data['seed'] = oai_settings.seed;
+    }
-    await eventSource.emit(event_types.CHAT_COMPLETION_SETTINGS_READY, generate_data);
     if (isFunctionCallingSupported() && !stream) {
         await registerFunctionTools(type, generate_data);
+    }
+    if (isOAI && oai_settings.openai_model.startsWith('o1-')) {
+        generate_data.messages.forEach((msg) => {
+            if (msg.role === 'system') {
+                msg.role = 'user';
+            }
+        });
+        generate_data.max_completion_tokens = generate_data.max_tokens;
+        delete generate_data.max_tokens;
+        delete generate_data.stream;
+        delete generate_data.logprobs;
+        delete generate_data.top_logprobs;
+        delete generate_data.n;
+        delete generate_data.temperature;
+        delete generate_data.top_p;
+        delete generate_data.frequency_penalty;
+        delete generate_data.presence_penalty;
+        delete generate_data.tools;
+        delete generate_data.tool_choice;
+        delete generate_data.stop;
+        // It does support logit_bias, but the tokenizer used and its effect is yet unknown.
+        // delete generate_data.logit_bias;
+    }
+    await eventSource.emit(event_types.CHAT_COMPLETION_SETTINGS_READY, generate_data);
     const generate_url = '/api/backends/chat-completions/generate';
     const response = await fetch(generate_url, {
         method: 'POST',

@@ -2111,7 +2134,6 @@ async function checkFunctionToolCalls(data) {
2111	const args = toolCall.function;	2134	const args = toolCall.function;
2112	console.log('Function tool call:', toolCall);	2135	console.log('Function tool call:', toolCall);
2113	await eventSource.emit(event_types.LLM_FUNCTION_TOOL_CALL, args);	2136	await eventSource.emit(event_types.LLM_FUNCTION_TOOL_CALL, args);
2114	data.allowEmptyResponse = true;
2115	}	2137	}
2116	}	2138	}
2117		2139

@@ -2125,7 +2147,6 @@ async function checkFunctionToolCalls(data) {
2125	/** @type {FunctionToolCall} */	2147	/** @type {FunctionToolCall} */
2126	const args = { name: content.name, arguments: JSON.stringify(content.input) };	2148	const args = { name: content.name, arguments: JSON.stringify(content.input) };
2127	await eventSource.emit(event_types.LLM_FUNCTION_TOOL_CALL, args);	2149	await eventSource.emit(event_types.LLM_FUNCTION_TOOL_CALL, args);
2128	data.allowEmptyResponse = true;
2129	}	2150	}
2130	}	2151	}
2131	}	2152	}

@@ -2140,7 +2161,6 @@ async function checkFunctionToolCalls(data) {
2140	const args = { name: toolCall.name, arguments: JSON.stringify(toolCall.parameters) };	2161	const args = { name: toolCall.name, arguments: JSON.stringify(toolCall.parameters) };
2141	console.log('Function tool call:', toolCall);	2162	console.log('Function tool call:', toolCall);
2142	await eventSource.emit(event_types.LLM_FUNCTION_TOOL_CALL, args);	2163	await eventSource.emit(event_types.LLM_FUNCTION_TOOL_CALL, args);
2143	data.allowEmptyResponse = true;
2144	}	2164	}
2145	}	2165	}
2146	}	2166	}

@@ -3905,6 +3925,9 @@ function getMaxContextOpenAI(value) {
3905	if (oai_settings.max_context_unlocked) {	3925	if (oai_settings.max_context_unlocked) {
3906	return unlocked_max;	3926	return unlocked_max;
3907	}	3927	}
		3928	else if (value.startsWith('o1-')) {
		3929	return max_128k;
		3930	}
3908	else if (value.includes('chatgpt-4o-latest') \|\| value.includes('gpt-4-turbo') \|\| value.includes('gpt-4o') \|\| value.includes('gpt-4-1106') \|\| value.includes('gpt-4-0125') \|\| value.includes('gpt-4-vision')) {	3931	else if (value.includes('chatgpt-4o-latest') \|\| value.includes('gpt-4-turbo') \|\| value.includes('gpt-4o') \|\| value.includes('gpt-4-1106') \|\| value.includes('gpt-4-0125') \|\| value.includes('gpt-4-vision')) {
3909	return max_128k;	3932	return max_128k;
3910	}	3933	}

public/scripts/slash-commands.js+9 -1 Viewed

 async function generateRawCallback(args, value) {
     if (!value) {
         console.warn('WARN: No argument provided for /genraw command');
-        return;
+        return '';
+    }
     // Prevent generate recursion

         setEphemeralStopStrings(resolveVariable(args?.stop));
         const result = await generateRaw(value, '', isFalseBoolean(args?.instruct), quietToLoud, systemPrompt, length);
         return result;
+    } catch (err) {
+        console.error('Error on /genraw generation', err);
+        toastr.error(err.message, 'API Error', { preventDuplicates: true });
     } finally {
         if (lock) {
             activateSendButtons();
+        }
         flushEphemeralStoppingStrings();
+    }
+    return '';
+}
 /**

         const name = args?.name;
         const result = await generateQuietPrompt(value, quietToLoud, false, '', name, length);
         return result;
+    } catch (err) {
+        console.error('Error on /gen generation', err);
+        toastr.error(err.message, 'API Error', { preventDuplicates: true });
     } finally {
         if (lock) {
             activateSendButtons();
+        }
         flushEphemeralStoppingStrings();
+    }
+    return '';
+}
 /**

public/scripts/world-info.js+6 -14 Viewed

  * @property {number} [cooldown] The cooldown of the entry
  * @property {number} [delay] The delay of the entry
  * @property {string[]} [decorators] Array of decorators for the entry
+ * @property {number} [hash] The hash of the entry
  */
 /**

  */
 class WorldInfoTimedEffects {
     /**
-     * Cache for entry hashes. Uses weak map to avoid memory leaks.
-     * @type {WeakMap<WIScanEntry, number>}
-     */
-    #entryHashCache = new WeakMap();
-    /**
      * Array of chat messages.
      * @type {string[]}
      */

     * @returns {number} String hash
     */
     #getEntryHash(entry) {
-        if (this.#entryHashCache.has(entry)) {
+        return entry.hash;
-            return this.#entryHashCache.get(entry);
-        }
-        const hash = getStringHash(JSON.stringify(entry));
-        this.#entryHashCache.set(entry, hash);
-        return hash;
+    }
     /**

         // Chat lore always goes first
         entries = [...chatLore.sort(sortFn), ...entries];
-        // Parse decorators
+        // Calculate hash and parse decorators. Split maps to preserve old hashes.
         entries = entries.map((entry) => {
             const [decorators, content] = parseDecorators(entry.content || '');
             return { ...entry, decorators, content };
+        }).map((entry) => {
+            const hash = getStringHash(JSON.stringify(entry));
+            return { ...entry, hash };
         });
         console.debug(`[WI] Found ${entries.length} world lore entries. Sorted by strategy`, Object.entries(world_info_insertion_strategy).find((x) => x[1] === world_info_character_strategy));

src/endpoints/backends/chat-completions.js+1 -0 Viewed

         'model': request.body.model,
         'temperature': request.body.temperature,
         'max_tokens': request.body.max_tokens,
+        'max_completion_tokens': request.body.max_completion_tokens,
         'stream': request.body.stream,
         'presence_penalty': request.body.presence_penalty,
         'frequency_penalty': request.body.frequency_penalty,

src/endpoints/backends/text-completions.js+3 -1 Viewed

@@ -375,7 +375,9 @@ router.post('/generate', jsonParser, async function (request, response) {
375	}	375	}
376	}	376	}
377	} catch (error) {	377	} catch (error) {
378	let value = { error: true, status: error?.status, response: error?.statusText };	378	const status = error?.status ?? error?.code ?? 'UNKNOWN';
		379	const text = error?.error ?? error?.statusText ?? error?.message ?? 'Unknown error on /generate endpoint';
		380	let value = { error: true, status: status, response: text };
379	console.log('Endpoint error:', error);	381	console.log('Endpoint error:', error);
380		382
381	if (!response.headersSent) {	383	if (!response.headersSent) {

src/endpoints/tokenizers.js+4 -0 Viewed

  * @returns {string} Tokenizer model to use
  */
 function getTokenizerModel(requestModel) {
+    if (requestModel.includes('o1-preview') || requestModel.includes('o1-mini')) {
+        return 'gpt-4o';
+    }
     if (requestModel.includes('gpt-4o')) {
         return 'gpt-4o';
+    }

Merge branch 'staging' into small-bookmark-updates