Merge branch 'SillyTavern:staging' into staging

17fb9815b3e3bc27f8000ce5da622d5744ae7188

Yokayo <52032299+Yokayo@users.noreply.github.com>

Signed

Parents: c98e3fd57d56527bd4ae81295f226bb70437f8ac 23639ce1fe7339605065d67f8c6cb4c026c51988

.github/readme-de_de.md+383 -0 Viewed

 +> [!IMPORTANT]
 +> Die hier veröffentlichten Informationen sind möglicherweise veraltet oder unvollständig. Für aktuelle Informationen nutzen Sie bitte die englische Version.
 +> Letztes Update dieser README: 28.9.2024
++
 +<a name="readme-top"></a>
++
 +![][cover]
++
 +<div align="center">
++
 +[English](readme.md) | German | [中文](readme-zh_cn.md) | [日本語](readme-ja_jp.md) | [Русский](readme-ru_ru.md)
++
 +[![GitHub Stars](https://img.shields.io/github/stars/SillyTavern/SillyTavern.svg)](https://github.com/SillyTavern/SillyTavern/stargazers)
 +[![GitHub Forks](https://img.shields.io/github/forks/SillyTavern/SillyTavern.svg)](https://github.com/SillyTavern/SillyTavern/network)
 +[![GitHub Issues](https://img.shields.io/github/issues/SillyTavern/SillyTavern.svg)](https://github.com/SillyTavern/SillyTavern/issues)
 +[![GitHub Pull Requests](https://img.shields.io/github/issues-pr/SillyTavern/SillyTavern.svg)](https://github.com/SillyTavern/SillyTavern/pulls)
++
 +</div>
++
 +---
++
 +SillyTavern bietet eine einheitliche Benutzeroberfläche für viele LLM-APIs (KoboldAI/CPP, Horde, NovelAI, Ooba, Tabby, OpenAI, OpenRouter, Claude, Mistral und mehr), ein mobilfreundliches Layout, einen Visual-Novel-Modus, die Integration von Automatic1111 & ComfyUI API zur Bilderzeugung, TTS, WorldInfo (Lorebooks), anpassbare UI, automatische Übersetzung, mehr Eingabeaufforderungsoptionen, als du jemals wolltest oder brauchst, und unendliches Wachstumspotenzial durch Drittanbietererweiterungen.
++
 +Wir haben eine [Dokumentationswebsite](https://docs.sillytavern.app/), um die meisten deiner Fragen zu beantworten und dir den Einstieg zu erleichtern.
++
 +## Was ist SillyTavern?
++
 +SillyTavern (oder ST abgekürtz) ist eine lokal installierte Benutzeroberfläche, die es dir ermöglicht, mit Textgenerations-LLMs, Bildgenerierungsmaschinen und TTS-Sprachmodellen zu interagieren.
++
 +Angefangen im Februar 2023 als Fork von TavernAI 1.2.8 hat SillyTavern nun über 100 Mitwirkende und 2 Jahre unabhängiger Entwicklung hinter sich und dient weiterhin als führende Software für versierte KI-Hobbyisten.
++
 +## Unsere Vision
++
 +1. Wir möchten die Nutzer mit so viel Nutzen und Kontrolle über ihre LLM-Prompts wie möglich ausstatten. Die steile Lernkurve ist Teil des Spaßes!
 +2. Wir bieten weder Online- oder gehosteten Dienste an, noch verfolgen wir programmgesteuert Benutzerdaten.
 +3. SillyTavern ist ein Herzensprojekt, das von einer engagierten Community von LLM-Enthusiasten unterstützt wird, und wird immer kostenlos und Open Source sein.
++
 +## Branches
++
 +SillyTavern wird mit einem Branchsystem entwickelt, um ein reibungsloses Erlebnis für alle Nutzer zu gewährleisten.
++
 +* `release` -🌟 **Empfohlen für die meisten Nutzer.** Dies ist der stabilste und empfohlene Branch, der nur aktualisiert wird, wenn wichtige Versionen veröffentlicht werden. Er ist für die Mehrheit der Nutzer geeignet. Typischerweise einmal im Monat aktualisiert.
 +* `staging` - ⚠️ **Nicht für den gelegentlichen Gebrauch empfohlen.** Dieser Branch enthält die neuesten Funktionen, kann jedoch jederzeit instabil sein. Nur für Power-User und Enthusiasten. Mehrmals täglich aktualisiert.
++
 +Wenn du nicht vertraut mit der Verwendung der git CLI bist oder nicht verstehst, was ein Branch ist, mach dir keine Sorgen! Der Release-Branch ist immer die bevorzugte Option für dich.
++
 +## Was brauche ich zusätzlich zu SillyTavern?
++
 +Da SillyTavern nur eine Benutzeroberfläche ist, benötigst du Zugriff auf ein LLM-Backend, um Inferenz bereitzustellen. Du kannst AI Horde für sofortiges Chatten ohne weitere Einrichtung verwenden. Darüber hinaus unterstützen wir viele andere lokale und cloudbasierte LLM-Backends: OpenAI-kompatible API, KoboldAI, Tabby und viele mehr. Du kannst mehr über unsere unterstützten APIs in [der FAQ](https://docs.sillytavern.app/usage/api-connections/) lesen.
++
 +### Brauche ich einen leistungsstarken PC, um SillyTavern auszuführen?
++
 +Die Hardwareanforderungen sind minimal: Es läuft auf allem, was NodeJS 18 oder höher ausführen kann. Wenn du LLM-Inferenz auf deinem lokalen Rechner durchführen möchtest, empfehlen wir eine NVIDIA-Grafikkarte der 3000er-Serie mit mindestens 6 GB VRAM. Überprüfe die Dokumentation deines Backends für weitere Einzelheiten.
++
 +### Vorgeschlagene Backends (keine Partnerschaft oder Werbebeziehung)
++
 +* [AI Horde](https://aihorde.net/) - verwende Modelle, die von Freiwilligen gehostet werden. Erfordert keine weitere Einrichtung
 +* [KoboldCpp](https://github.com/LostRuins/koboldcpp) - ein Favorit der Community, um GGUF-Modelle lokal auszuführen
 +* [tabbyAPI](https://github.com/theroyallab/tabbyAPI) - eine beliebte, portable, speicherplatzoptimierte und lokal gehostete exl2 Inferenz-API
 +* [OpenRouter](https://openrouter.ai) - eine einzige API für viele Cloud-Anbieter (OpenAI, Claude, Meta Llama usw.) sowie beliebte Community-Modelle.
++
 +## Fragen oder Vorschläge?
++
 +### Discord-Server
++
 +| [![][discord-shield-badge]][discord-link] | [Tritt unserer Discord-Community bei!](https://discord.gg/sillytavern) Erhalte Unterstützung, teile deine Lieblingscharaktere und Prompts. |
 +| :---------------------------------------- | :----------------------------------------------------------------------------------------------------------------- |
++
 +Oder nimm direkt Kontakt mit den Entwicklern auf:
++
 +* Discord: cohee, rossascends, wolfsblvt
 +* Reddit: [/u/RossAscends](https://www.reddit.com/user/RossAscends/), [/u/sillylossy](https://www.reddit.com/user/sillylossy/), [u/Wolfsblvt](https://www.reddit.com/user/Wolfsblvt/)
 +* [Erstelle ein GitHub-Issue](https://github.com/SillyTavern/SillyTavern/issues)
++
 +### Ich mag dieses Projekt! Wie kann ich beitragen?
++
 +1. Sende Pull-Requests. Lerne, wie du beitragen kannst: [CONTRIBUTING.md](../CONTRIBUTING.md)
 +2. Sende Feature Requests und Issues unter Verwendung der bereitgestellten Vorlagen.
 +3. Lies diese gesamte README-Datei und überprüfe zuerst die Dokumentationswebsite, um doppelte Issues zu vermeiden.
++
 +## Screenshots
++
 +<img width="500" alt="image" src="https://github.com/user-attachments/assets/9b5f32f0-c3b3-4102-b3f5-0e9213c0f50f">
 +<img width="500" alt="image" src="https://github.com/user-attachments/assets/913fdbaa-7d33-42f1-ae2c-89dca41c53d1">
++
 +## Charakterkarten
++
 +SillyTavern basiert auf dem Konzept der "Charakterkarten". Eine Charakterkarte ist eine Sammlung von Prompts, die das Verhalten des LLM festlegen und erforderlich sind, um persistente Gespräche in SillyTavern zu führen. Sie funktionieren ähnlich wie ChatGPT's GPTs oder Poe's Bots. Der Inhalt einer Charakterkarte kann alles sein: ein abstraktes Szenario, ein Assistent, der für eine bestimmte Aufgabe maßgeschneidert ist, eine berühmte Persönlichkeit oder ein fiktiver Charakter.
++
 +Das Namensfeld ist der einzige erforderliche Eingabewert für die Charakterkarte. Um ein neutrales Gespräch mit dem LLM zu beginnen, erstelle eine neue Karte, die einfach "Assistent" genannt wird, und lasse die restlichen Felder leer. Für einen thematischeren Chat kannst du dem LLM verschiedene Hintergrundinformationen, Verhaltensweisen und Schreibmuster sowie ein Szenario geben, um das Gespräch zu beginnen.
++
 +Um ein schnelles Gespräch zu führen, ohne eine Charakterkarte auszuwählen, oder um einfach die LLM-Verbindung zu testen, gib einfach dein Prompt in die Eingabezeile auf dem Willkommensbildschirm ein, nachdem du SillyTavern geöffnet hast. Bitte beachte, dass solche Chats vorübergehend sind und nicht gespeichert werden.
++
 +Um eine allgemeine Vorstellung davon zu bekommen, wie man Charakterkarten definiert, sieh dir die mitgelieferte Charakterkarte (Seraphina) an oder lade ausgewählte von der Community erstellte Karten im Menü "Erweiterungen & Assets herunterladen" herunter.
++
 +## Wichtigste Features
++
 +* Erweiterte Text-Generierungs-Einstellungen mit vielen von der Community erstellten mitgelieferten Einstellungen (Presets)
 +* Unterstützung für World Info: Erstelle reichhaltige Lore oder reduziere die Tokens in deiner Charakterkarte
 +* Gruppenchats: Multi-Bot-Räume für Charaktere, die mit dir und/oder untereinander sprechen
 +* Reichhaltige UI-Anpassungsoptionen: Themes zur Farbenwahl, Hintergrundbilder, benutzerdefiniertes CSS und mehr
 +* Benutzer-Personas: Lass die KI ein wenig über dich wissen, um die Immersion zu erhöhen
 +* Eingebaute RAG-Unterstützung: Füge Dokumente zu deinen Chats hinzu, auf die die KI verweisen kann
 +* Umfangreiches "Chat-Befehle"-System und eigene [Scripting-Engine](https://docs.sillytavern.app/usage/st-script/)
++
 +## Erweiterungen
++
 +SillyTavern unterstützt Erweiterungen.
++
 +* Emotionale Ausdrucksformen von Charakteren (Sprites)
 +* Automatische Zusammenfassung des Chatverlaufs
 +* Automatische UI- und Chat-Übersetzung
 +* Bildgenerierung mit Stable Diffusion/FLUX/DALL-E
 +* Text-to-Speech für KI-Antwortnachrichten (über ElevenLabs, Silero oder die TTS-Funktion des Betriebssystems)
 +* Websuchfunktionen zum Hinzufügen zusätzlicher realer Kontexte zu deinen Eingabeaufforderungen
 +* Viele weitere sind im Menü "Erweiterungen & Assets herunterladen" verfügbar.
++
 +Tutorials zur Nutzung findest du in der [Dokumentation](https://docs.sillytavern.app/).
++
 +# ⌛ Installation
++
 +> \[!WARNING]
 +>
 +> * INSTALLIERE NICHT IN EINEM VON WINDOWS KONTROLLIERTEN ORDNER (Programme, System32 usw.).
 +> * FÜHRE START.BAT NICHT MIT ADMIN-BERECHTIGUNGEN AUS.
 +> * DIE INSTALLATION AUF WINDOWS 7 IST UNMÖGLICH, DA ES NODEJS 18.16 NICHT AUSFÜHREN KANN.
++
 +## 🪟 Windows
++
 +### Installation über Git
++
 +1. Installiere [NodeJS](https://nodejs.org/en) (die neueste LTS-Version wird empfohlen).
 +2. Installiere [Git für Windows](https://gitforwindows.org/).
 +3. Öffne den Windows-Explorer (`Win+E`).
 +4. Gehe zu oder erstelle einen Ordner, der nicht von Windows kontrolliert oder überwacht wird. (z.B.: C:\MySpecialFolder\)
 +5. Öffne ein Eingabeaufforderungsfenster in diesem Ordner, indem du in die 'Adressleiste' oben klickst, `cmd` eingibst und Enter drückst.
 +6. Sobald das schwarze Fenster (Eingabeaufforderung) erscheint, gib EINE der folgenden Optionen ein und drücke Enter:
++
 +* für den Release-Branch: `git clone https://github.com/SillyTavern/SillyTavern -b release`
 +* für den Staging-Branch: `git clone https://github.com/SillyTavern/SillyTavern -b staging`
++
 +7. Sobald alles geklont ist, doppelklicke auf `Start.bat`, damit NodeJS seine Anforderungen installiert.
 +8. Der Server wird dann gestartet, und SillyTavern wird in deinem Browser geöffnet.
++
 +### Installation über GitHub Desktop
++
 +(Dies ermöglicht die Nutzung von git **nur** in GitHub Desktop. Wenn du `git` auch in der Eingabeaufforderung verwenden möchtest, musst du auch [Git für Windows](https://gitforwindows.org/) installieren.)
++
 +1. Installiere [NodeJS](https://nodejs.org/en) (die neueste LTS-Version wird empfohlen).
 +2. Installiere [GitHub Desktop](https://central.github.com/deployments/desktop/desktop/latest/win32).
 +3. Klicke nach der Installation von GitHub Desktop auf `Ein Repository aus dem Internet klonen....` (Hinweis: Du **musst kein** GitHub-Konto für diesen Schritt erstellen).
 +4. Klicke im Menü auf den Tab URL, gib diese URL ein `https://github.com/SillyTavern/SillyTavern` und klicke auf Klonen. Du kannst den lokalen Pfad ändern, um festzulegen, wohin SillyTavern heruntergeladen werden soll.
 +5. Um SillyTavern zu öffnen, durchsuche mit dem Windows-Explorer den Ordner, in den du das Repository geklont hast. Standardmäßig wird das Repository hier hin geklont: `C:\Users\[Dein Windows-Benutzername]\Documents\GitHub\SillyTavern`.
 +6. Doppelklicke auf die Datei `start.bat`. (Hinweis: Der Teil `.bat` des Dateinamens könnte von deinem Betriebssystem verborgen sein. In diesem Fall sieht es aus wie eine Datei namens "`Start`". Dies ist die Datei, auf die du doppelklickst, um SillyTavern auszuführen.)
 +7. Nach dem Doppelklicken sollte ein großes schwarzes Konsolenfenster erscheinen, und SillyTavern beginnt, das zu installieren, was es zum Betrieb benötigt.
 +8. Nach dem Installationsprozess sollte das Konsolenfenster so aussehen, und ein SillyTavern-Tab sollte in deinem Browser geöffnet sein.
 +9. Verbinde dich mit einer der [unterstützten APIs](https://docs.sillytavern.app/usage/api-connections/) und beginne zu chatten!
++
 +## 🐧 Linux & 🍎 MacOS
++
 +Für MacOS/Linux werden all diese Schritte in einem Terminal durchgeführt.
++
 +1. Installiere git und nodeJS (die Methode zur Durchführung hängt von deinem Betriebssystem ab).
 +2. Klone das Repository.
++
 +* für den Release-Branch: `git clone https://github.com/SillyTavern/SillyTavern -b release`
 +* für den Staging-Branch: `git clone https://github.com/SillyTavern/SillyTavern -b staging`
++
 +3. `cd SillyTavern`, um in den Installationsordner zu navigieren.
 +4. Führe das Skript `start.sh` mit einem dieser Befehle aus:
++
 +* `./start.sh`
 +* `bash start.sh`
++
 +## ⚡ Installation über SillyTavern Launcher
++
 +Der SillyTavern Launcher ist ein Installationsassistent, der dir bei der Einrichtung mit vielen Optionen helfen wird, einschließlich der Installation eines Backends für lokale Inferenz.
++
 +### Für Windows-Nutzer
++
 +1. Drücke auf deiner Tastatur **`WINDOWS + R`**, um das Ausführen-Dialogfeld zu öffnen. Führe dann den folgenden Befehl aus, um git zu installieren:
++
 +```shell
 +cmd /c winget install -e --id Git.Git
 +```
++
 +2. Drücke auf deiner Tastatur **`WINDOWS + E`**, um den Datei-Explorer zu öffnen, und navigiere dann zu dem Ordner, in dem du den Launcher installieren möchtest. Gib im gewünschten Ordner in die Adressleiste `cmd` ein und drücke Enter. Führe dann den folgenden Befehl aus:
++
 +```shell
 +git clone https://github.com/SillyTavern/SillyTavern-Launcher.git && cd SillyTavern-Launcher && start installer.bat
 +```
++
 +### Für Linux-Nutzer
++
 +1. Öffne dein bevorzugtes Terminal und installiere git.
 +2. Klone den SillyTavern-Launcher mit:
++
 +```shell
 +git clone https://github.com/SillyTavern/SillyTavern-Launcher.git && cd SillyTavern-Launcher
 +```
++
 +3. Starte die installer.sh mit:
++
 +```shell
 +chmod +x install.sh && ./install.sh
 +```
++
 +4. Nach der Installation starte die launcher.sh mit:
++
 +```shell
 +chmod +x launcher.sh && ./launcher.sh
 +```
++
 +### Für Mac-Nutzer
++
 +1. Öffne ein Terminal und installiere brew mit:
++
 +```shell
 +/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
 +```
++
 +2. Installiere git mit:
++
 +```shell
 +brew install git
 +```
++
 +3. Klone den SillyTavern-Launcher mit:
++
 +```shell
 +git clone https://github.com/SillyTavern/SillyTavern-Launcher.git && cd SillyTavern-Launcher
 +```
++
 +4. Starte die installer.sh mit:
++
 +```shell
 +chmod +x install.sh && ./install.sh
 +```
++
 +5. Nach der Installation starte die launcher.sh mit:
++
 +```shell
 +chmod +x launcher.sh && ./launcher.sh
 +```
++
 +## 🐋 Installation über Docker
++
 +Diese Anweisungen setzen voraus, dass du Docker installiert hast, auf deine Befehlszeile für die Installation von Containern zugreifen kannst und mit deren allgemeiner Funktionsweise vertraut bist.
++
 +### Image selbst bauen
++
 +Wir haben einen umfassenden Leitfaden zur Nutzung von SillyTavern in Docker [hier](http://docs.sillytavern.app/installation/docker/) der die Installationen auf Windows, macOS und Linux abdeckt! Lies ihn, wenn du das Image selbst bauen möchtest.
++
 +### Verwendung der GitHub Container Registry (am einfachsten)
++
 +Du benötigst zwei zwingende Verzeichniszuordnungen und eine Portzuordnung, um SillyTavern funktionsfähig zu machen. Ersetze in dem Befehl deine Auswahl an den folgenden Stellen:
++
 +#### Container-Variablen
++
 +##### Volumen-Zuordnungen
++
 +* [config] - Das Verzeichnis, in dem die SillyTavern-Konfigurationsdateien auf deinem Host-Computer gespeichert werden
 +* [data] - Das Verzeichnis, in dem die Benutzerdaten von SillyTavern (einschließlich Charaktere) auf deinem Host-Computer gespeichert werden
 +* [plugins] - (optional) Das Verzeichnis, in dem die SillyTavern-Server-Plugins auf deinem Host-Computer gespeichert werden
++
 +##### Port-Zuordnungen
++
 +* [PublicPort] - Der Port, über den der Datenverkehr ausgegeben werden soll. Dies ist zwingend erforderlich, da du auf die Instanz von außerhalb des virtuellen Maschinencontainers zugreifst. EXPOSIERE DIES NICHT IM INTERNET, OHNE EINEN GETRENNTEN SERVICE FÜR DIE SICHERHEIT ZU IMPLEMENTIEREN.
++
 +##### Zusätzliche Einstellungen
++
 +* [DockerNet] - Das Docker-Netzwerk, mit dem der Container erstellt werden soll. Wenn du nicht weißt, was das ist, sieh dir die [offizielle Docker-Dokumentation](https://docs.docker.com/reference/cli/docker/network/) an.
 +* [version] - Auf der rechten Seite dieser GitHub-Seite siehst du "Packages". Wähle das Paket "sillytavern" und du siehst die Imageversionen. Das Image-Tag "latest" hält dich auf dem Laufenden mit dem aktuellen Release. Du kannst auch "staging" und "release" Tags nutzen, die auf die nightly images der jeweiligen Branche verweisen, aber das könnte unangemessen sein, wenn du Erweiterungen verwendest, die möglicherweise kaputt sind und Zeit benötigen, um aktualisiert zu werden.
++
 +#### Installationsbefehl
++
 +1. Öffne deine Befehlszeile.
 +2. Führe den folgenden Befehl aus:
++
 +`docker create --name='sillytavern' --net='[DockerNet]' -p '8000:8000/tcp' -v '[plugins]':'/home/node/app/plugins':'rw' -v '[config]':'/home/node/app/config':'rw' -v '[data]':'/home/node/app/data':'rw' 'ghcr.io/sillytavern/sillytavern:[version]'`
++
 +> Beachte, dass 8000 ein Standard-Listening-Port ist. Vergiss nicht, einen geeigneten Port zu verwenden, wenn du ihn in der Konfiguration änderst.
++
 +## 📱 Installation über Termux auf Android OS
++
 +> \[!HINWEIS]
 +> **SillyTavern kann nativ auf Android-Geräten über Termux ausgeführt werden, aber wir bieten keine offizielle Unterstützung für diesen Anwendungsfall.**
 +>
 +> **Bitte beziehe dich auf diesen Leitfaden von ArroganceComplex#2659:**
 +>
 +> * <https://rentry.org/STAI-Termux>
++
 +**Nicht unterstützte Plattform: android arm LEtime-web.** 32-Bit-Android benötigt eine externe Abhängigkeit, die nicht mit npm installiert werden kann. Verwende den folgenden Befehl, um sie zu installieren: `pkg install esbuild`. Führe dann die üblichen Installationsschritte aus.
++
 +## API-Schlüsselverwaltung
++
 +SillyTavern speichert deine API-Schlüssel in einer Datei `secrets.json` im Benutzerdatenverzeichnis (`/data/default-user/secrets.json` ist der Standardpfad).
++
 +Standardmäßig sind API-Schlüssel nach dem Speichern und Aktualisieren der Seite nicht mehr über die Benutzeroberfläche sichtbar.
++
 +Um die Ansicht deiner Schlüssel zu aktivieren:
++
 +1. Setze den Wert von `allowKeysExposure` auf `true` in der Datei `config.yaml`.
 +2. Starte den SillyTavern-Server neu.
 +3. Klicke auf den Link 'Verborgene API-Schlüssel anzeigen' in der unteren rechten Ecke des API-Verbindungsfeldes.
++
 +## Befehlszeilenargumente
++
 +Sie können Befehlszeilenargumente an den Start des SillyTavern-Servers übergeben, um einige Einstellungen in `config.yaml` zu überschreiben.
++
 +### Beispiele
++
 +```shell
 +node server.js --port 8000 --listen false
 +# oder
 +npm run start -- --port 8000 --listen false
 +# oder (nur Windows)
 +Start.bat --port 8000 --listen false
 +```
++
 +### Unterstützte Argumente
++
 +| Option | Beschreibung | Typ |
 +|-------------------------|----------------------------------------------------------------------------------------------------|----------|
 +| `--version` | Versionsnummer anzeigen | boolean |
 +| `--enableIPv6` | Aktiviert IPv6. | boolean |
 +| `--enableIPv4` | Aktiviert IPv4. | boolean |
 +| `--port` | Legt den Port fest, unter dem SillyTavern ausgeführt wird. Wenn nicht angegeben, wird auf YAML-Konfiguration „Port“ zurückgegriffen. | number |
 +| „--dnsPreferIPv6“ | Bevorzugt IPv6 für DNS. Wenn nicht angegeben, wird auf YAML-Konfiguration „preferIPv6“ zurückgegriffen. | boolean |
 +| „--autorun“ | Startet SillyTavern automatisch im Browser. Wenn nicht angegeben, wird auf YAML-Konfiguration „autorun“ zurückgegriffen.| boolean |
 +| „--autorunHostname“ | Der Autorun-Hostname, am besten auf „auto“ belassen. | string |
 +| „--autorunPortOverride“ | Überschreibt den Port für Autorun. | string |
 +| „--listen“ | SillyTavern lauscht auf allen Netzwerkschnittstellen. Wenn nicht angegeben, wird auf YAML-Konfiguration „listen“ zurückgegriffen.| boolean |
 +| „--corsProxy“ | Aktiviert CORS-Proxy. Wenn nicht angegeben, wird auf YAML-Konfiguration „enableCorsProxy“ zurückgegriffen. | boolean |
 +| `--disableCsrf` | Deaktiviert CSRF-Schutz | boolean |
 +| `--ssl` | Aktiviert SSL | boolean |
 +| `--certPath` | Pfad zu Ihrer Zertifikatsdatei. | string |
 +| `--keyPath` | Pfad zu Ihrer privaten Schlüsseldatei. | string |
 +| `--whitelist` | Aktiviert den Whitelist-Modus | boolean |
 +| `--dataRoot` | Stammverzeichnis für Datenspeicherung | string |
 +| `--avoidLocalhost` | Vermeidet die Verwendung von „localhost“ für Autorun im Auto-Modus. | boolean |
 +| `--basicAuthMode` | Aktiviert die grundlegende Authentifizierung | boolean |
 +| `--requestProxyEnabled` | Aktiviert die Verwendung eines Proxys für ausgehende Anfragen | boolean |
 +| `--requestProxyUrl` | Proxy-URL anfordern (HTTP- oder SOCKS-Protokolle) | string |
 +| `--requestProxyBypass` | Proxy-Bypass-Liste anfordern (durch Leerzeichen getrennte Liste von Hosts) | Array |
++
 +## Remoteverbindungen
++
 +Dies ist in den meisten Fällen für Personen gedacht, die SillyTavern auf ihren Mobiltelefonen verwenden möchten, während ihr PC den ST-Server im selben WLAN-Netzwerk betreibt. Es kann jedoch auch verwendet werden, um Remoteverbindungen von überall her zu ermöglichen.
++
 +Lies die ausführliche Anleitung zum Einrichten von Remoteverbindungen in den [Docs](https://docs.sillytavern.app/usage/remoteconnections/).
++
 +Möglicherweise möchtest du SillyTavern-Benutzerprofile auch mit (optionalem) Kennwortschutz konfigurieren: [Benutzer](https://docs.sillytavern.app/installation/st-1.12.0-migration-guide/#users).
++
 +## Leistungsprobleme?
++
 +1. Deaktiviere den Unschärfeeffekt und aktiviere "Verringerte Bewegung" im Bedienfeld "Benutzereinstellungen" (UI-Design schaltet Kategorie um).
 +2. Wenn du Response Streaming verwendest, stelle die Streaming-FPS auf einen niedrigeren Wert ein (10-15 FPS werden empfohlen).
 +3. Stelle sicher, dass der Browser die GPU-Beschleunigung zum Rendern verwenden kann.
++
 +## Lizenz und Danksagungen
++
 +**Dieses Programm wird in der Hoffnung verbreitet, dass es nützlich ist,
 +aber OHNE JEGLICHE GARANTIE; nicht einmal die stillschweigende Garantie der
 +MARKTFÄHIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK. Siehe die
 +GNU Affero General Public License für weitere Details.**
++
 +* [TavernAI](https://github.com/TavernAI/TavernAI) 1.2.8 von Humi: MIT-Lizenz
 +* Teile von CncAnons TavernAITurbo-Mod werden mit Genehmigung verwendet
 +* Visual Novel-Modus inspiriert von der Arbeit von PepperTaco (<https://github.com/peppertaco/Tavern/>)
 +* Noto Sans-Schriftart von Google (OFL-Lizenz)
 +* Symboldesign von Font Awesome <https://fontawesome.com> (Symbole: CC BY 4.0, Schriftarten: SIL OFL 1.1, Code: MIT-Lizenz)
 +* Standardinhalt von @OtisAlejandro (Seraphina-Charakter und Lorebook) und @kallmeflocc (10.000 Discord-Benutzer-Feierhintergrund)
 +* Docker-Anleitung von [@mrguymiah](https://github.com/mrguymiah) und [@Bronya-Rand](https://github.com/Bronya-Rand)
++
 +## Top Contributors
++
 +[![Contributors](https://contrib.rocks/image?repo=SillyTavern/SillyTavern)](https://github.com/SillyTavern/SillyTavern/graphs/contributors)
++
 +<!-- LINK GROUP -->
 +[cover]: https://github.com/user-attachments/assets/01a6ae9a-16aa-45f2-8bff-32b5dc587e44
 +[discord-link]: https://discord.gg/sillytavern
 +[discord-shield-badge]: https://img.shields.io/discord/1100685673633153084?color=5865F2&label=discord&labelColor=black&logo=discord&logoColor=white&style=for-the-badge

.github/readme-ja_jp.md+1 -1 Viewed

 <div align="center">
 [English](readme.md) | [German](readme-de_de.md) | [中文](readme-zh_cn.md) | 日本語 | [Русский](readme-ru_ru.md)
 [![GitHub Stars](https://img.shields.io/github/stars/SillyTavern/SillyTavern.svg)](https://github.com/SillyTavern/SillyTavern/stargazers)
 [![GitHub Forks](https://img.shields.io/github/forks/SillyTavern/SillyTavern.svg)](https://github.com/SillyTavern/SillyTavern/network)

.github/readme-ru_ru.md+1 -1 Viewed

 <div align="center">
 [English](readme.md) | [German](readme-de_de.md) | [中文](readme-zh_cn.md) | [日本語](readme-ja_jp.md) | Русский
 [![GitHub Stars](https://img.shields.io/github/stars/SillyTavern/SillyTavern.svg)](https://github.com/SillyTavern/SillyTavern/stargazers)
 [![GitHub Forks](https://img.shields.io/github/forks/SillyTavern/SillyTavern.svg)](https://github.com/SillyTavern/SillyTavern/network)

.github/readme-zh_cn.md+1 -1 Viewed

 <div align="center">
 [English](readme.md) | [German](readme-de_de.md) | 中文 | [日本語](readme-ja_jp.md) | [Русский](readme-ru_ru.md)
 [![GitHub Stars](https://img.shields.io/github/stars/SillyTavern/SillyTavern.svg)](https://github.com/SillyTavern/SillyTavern/stargazers)
 [![GitHub Forks](https://img.shields.io/github/forks/SillyTavern/SillyTavern.svg)](https://github.com/SillyTavern/SillyTavern/network)

.github/readme.md+1 -1 Viewed

 <div align="center">
 English | [German](readme-de_de.md) | [中文](readme-zh_cn.md) | [日本語](readme-ja_jp.md) | [Русский](readme-ru_ru.md)
 [![GitHub Stars](https://img.shields.io/github/stars/SillyTavern/SillyTavern.svg)](https://github.com/SillyTavern/SillyTavern/stargazers)
 [![GitHub Forks](https://img.shields.io/github/forks/SillyTavern/SillyTavern.svg)](https://github.com/SillyTavern/SillyTavern/network)

public/css/popup.css+2 -1 Viewed

 +@import url('/lib/dialog-polyfill.css');
 @import url('./popup-safari-fix.css');
 dialog {

     display: flex;
     flex-direction: column;
     overflow: hidden;
     width: min(100%, 100vw);
     height: 100%;
     padding: 1px;
+}

public/index.html+36 -18 Viewed

                                 <div class="">
                                     <div class="inline-drawer wide100p flexFlowColumn">
                                         <div class="inline-drawer-toggle inline-drawer-header">
                                             <div class="flex-container alignItemsCenter flexNoGap">
                                                 <b data-i18n="Character Names Behavior">Character Names Behavior</b>
                                                 <span title="Helps the model to associate messages with characters." data-i18n="[title]Helps the model to associate messages with characters." class="note-link-spanopacity50p fa-solid fa-circle-questioninfo"></span>
                                                 <small class="flexBasis100p">(<span id="character_names_display"></span>)</small>
                                             </div>
                                             <div class="fa-solid fa-circle-chevron-down inline-drawer-icon down"></div>

                                             <label class="checkbox_label flexWrap alignItemsCenter" for="character_names_none">
                                                 <input type="radio" id="character_names_none" name="character_names" value="-1">
                                                 <span data-i18n="None">None</span>
 -                                                <i class="right_menu_button fa-solid fa-circle-exclamation" title="Never add character name prefixes. May behave poorly in groups, choose with caution." data-i18n="[title]character_names_none"></i>
 +                                                <small class="flexBasis100p" data-i18n="character_names_none">
 -                                                <small class="flexBasis100p" data-i18n="Never add character names.">
 +                                                    Never add character name prefixes. May behave poorly in groups, choose with caution.
 -                                                    Never add character names.
                                                 </small>
                                             </label>
                                             <label class="checkbox_label flexWrap alignItemsCenter" for="character_names_default">
                                                 <input type="radio" id="character_names_default" name="character_names" value="0">
                                                 <span data-i18n="Default">Default</span>
 -                                                <i class="right_menu_button fa-solid fa-circle-exclamation" title="Add prefixes for groups and past personas. Otherwise, make sure you provide names in the prompt." data-i18n="[title]character_names_default"></i>
 +                                                <small class="flexBasis100p" data-i18n="character_names_default">
 -                                                <small class="flexBasis100p" data-i18n="Don't add character names unless necessary.">
 +                                                    Add prefixes for groups and past personas. Otherwise, make sure you provide names in the prompt.
 -                                                    Don't add character names unless necessary.
                                                 </small>
                                             </label>
                                             <label class="checkbox_label flexWrap alignItemsCenter" for="character_names_completion">
                                                 <input type="radio" id="character_names_completion" name="character_names" value="1">
                                                 <span data-i18n="Completion Object">Completion Object</span>
 -                                                <i class="right_menu_button fa-solid fa-circle-exclamation" title="Restrictions apply: only Latin alphanumerics and underscores. Doesn't work for all sources, notably: Claude, MistralAI, Google." data-i18n="[title]character_names_completion"></i>
 +                                                <small class="flexBasis100p" data-i18n="character_names_completion">
 -                                                <small class="flexBasis100p" data-i18n="Add character names to completion objects.">
 +                                                    Add character names to completion objects. Restrictions apply: only Latin alphanumerics and underscores.
 -                                                    Add character names to completion objects.
                                                 </small>
                                             </label>
                                             <label class="checkbox_label flexWrap alignItemsCenter" for="character_names_content">

                                     </div>
                                     <div class="inline-drawer wide100p flexFlowColumn marginBot10">
                                         <div class="inline-drawer-toggle inline-drawer-header">
                                             <div class="flex-container alignItemsCenter flexNoGap">
                                                 <b data-i18n="Continue Postfix">Continue Postfix</b>
                                                 <span data-i18n="[title]The next chunk of the continued message will be appended using this as a separator." title="The next chunk of the continued message will be appended using this as a separator." class="note-link-spanopacity50p fa-solid fa-circle-questioninfo"></span>
                                                 <small class="flexBasis100p">(<span id="continue_postfix_display"></span>)</small>
                                             </div>
                                             <div class="fa-solid fa-circle-chevron-down inline-drawer-icon down"></div>

                                         <option value="gemini-1.5-pro-latest">Gemini 1.5 Pro [latest]</option>
                                         <option value="gemini-1.5-pro-001">Gemini 1.5 Pro [001]</option>
                                         <option value="gemini-1.5-pro-002">Gemini 1.5 Pro [002]</option>
 +                                        <option value="gemini-1.5-flash-8b">Gemini 1.5 Flash 8B</option>
                                         <option value="gemini-1.5-flash-exp-0827">Gemini 1.5 Flash Experiment 2024-08-27</option>
                                         <option value="gemini-1.5-flash-8b-exp-0827">Gemini 1.5 Flash 8B Experiment 2024-08-27</option>
                                         <option value="gemini-1.5-flash-8b-exp-0924">Gemini 1.5 Flash 8B Experiment 2024-09-24</option>

                             </div>
                             <h4 data-i18n="Groq Model">Groq Model</h4>
                             <select id="model_groq_select">
 -                                <option value="llama-3.1-405b-reasoning">llama-3.1-405b-reasoning</option>
 +                                <optgroup label="Llama 3.2">
                                                                     <option value="llama-3.12-70b1b-versatilepreview">llama-3.12-70b1b-versatilepreview</option>
 +                                    <option value="llama-3.2-3b-preview">llama-3.2-3b-preview</option>
 +                                    <option value="llama-3.2-11b-vision-preview">llama-3.2-11b-vision-preview</option>
 +                                    <option value="llama-3.2-90b-vision-preview">llama-3.2-90b-vision-preview</option>
 +                                </optgroup>
 +                                <optgroup label="Llama 3.1">
                                     <option value="llama-3.1-8b-instant">llama-3.1-8b-instant</option>
                                                                     <option value="llama3llama-groq3.1-70b-8192-tool-use-previewversatile">llama3llama-groq3.1-70b-8192-tool-use-previewversatile</option>
 +                                    <option value="llama-3.1-405b-reasoning">llama-3.1-405b-reasoning</option>
 +                                </optgroup>
 +                                <optgroup label="Llama 3">
                                     <option value="llama3-groq-8b-8192-tool-use-preview">llama3-groq-8b-8192-tool-use-preview</option>
 +                                    <option value="llama3-groq-70b-8192-tool-use-preview">llama3-groq-70b-8192-tool-use-preview</option>
                                     <option value="llama3-8b-8192">llama3-8b-8192</option>
                                     <option value="llama3-70b-8192">llama3-70b-8192</option>
 -                                <option value="mixtral-8x7b-32768">mixtral-8x7b-32768</option>
 +                                </optgroup>
 +                                <optgroup label="Gemma">
                                     <option value="gemma-7b-it">gemma-7b-it</option>
                                     <option value="gemma2-9b-it">gemma2-9b-it</option>
 +                                </optgroup>
 +                                <optgroup label="Other">
 +                                    <option value="mixtral-8x7b-32768">mixtral-8x7b-32768</option>
 +                                    <option value="llava-v1.5-7b-4096-preview">llava-v1.5-7b-4096-preview</option>
 +                                </optgroup>
                             </select>
                         </div>
                         <div id="perplexity_form" data-source="perplexity">

                                     <input id="compact_input_area" type="checkbox" />
                                     <small data-i18n="Compact Input Area (Mobile)">Compact Input Area</small><i class="fa-solid fa-mobile-screen-button"></i>
                                 </label>
 +                                <label for="show_swipe_num_all_messages" class="checkbox_label" title="Display swipe numbers for all messages, not just the last." data-i18n="[title]Display swipe numbers for all messages, not just the last.">
 +                                    <input id="show_swipe_num_all_messages" type="checkbox" />
 +                                    <small data-i18n="Swipe # for All Messages">Swipe # for All Messages</small><i class="fa-solid fa-mobile-screen-button"></i>
 +                                </label>
                                 <label for="hotswapEnabled" class="checkbox_label" title="In the Character Management panel, show quick selection buttons for favorited characters." data-i18n="[title]In the Character Management panel, show quick selection buttons for favorited characters">
                                     <input id="hotswapEnabled" type="checkbox" />
                                     <small data-i18n="Characters Hotswap">Characters Hotswap</small>

                     </div>
                     <div class="mes_bias"></div>
                 </div>
                                     <div class="swipe_right faflex-solidcontainer fa-chevron-right"swipeRightBlock style="display:flexFlowColumn none;flexNoGap">
 +                    <div class="swipe_right fa-solid fa-chevron-right" style="display: none;"></div>
                     <div class="swipes-counter"></div>
                 </div>
             </div>

public/lib/dialog-polyfill.css+37 -0 Viewed

 +.poly_dialog {
 +  position: absolute;
 +  left: 0; right: 0;
 +  width: -moz-fit-content;
 +  width: -webkit-fit-content;
 +  width: fit-content;
 +  height: -moz-fit-content;
 +  height: -webkit-fit-content;
 +  height: fit-content;
 +  margin: auto;
 +  border: solid;
 +  padding: 1em;
 +  background: white;
 +  color: black;
 +  display: block;
 +}
++
 +.poly_dialog:not([open]) {
 +  display: none;
 +}
++
 +.poly_dialog + .backdrop {
 +  position: fixed;
 +  top: 0; right: 0; bottom: 0; left: 0;
 +  background: rgba(0,0,0,0.1);
 +}
++
 +._poly_dialog_overlay {
 +  position: fixed;
 +  top: 0; right: 0; bottom: 0; left: 0;
 +}
++
 +.poly_dialog.fixed {
 +  position: fixed;
 +  top: 50%;
 +  transform: translate(0, -50%);
 +}
 \ No newline at end of file

public/lib/dialog-polyfill.esm.js+858 -0 Viewed

 +// nb. This is for IE10 and lower _only_.
 +var supportCustomEvent = window.CustomEvent;
 +if (!supportCustomEvent || typeof supportCustomEvent === 'object') {
 +  supportCustomEvent = function CustomEvent(event, x) {
 +    x = x || {};
 +    var ev = document.createEvent('CustomEvent');
 +    ev.initCustomEvent(event, !!x.bubbles, !!x.cancelable, x.detail || null);
 +    return ev;
 +  };
 +  supportCustomEvent.prototype = window.Event.prototype;
 +}
++
 +/**
 + * Dispatches the passed event to both an "on<type>" handler as well as via the
 + * normal dispatch operation. Does not bubble.
 + *
 + * @param {!EventTarget} target
 + * @param {!Event} event
 + * @return {boolean}
 + */
 +function safeDispatchEvent(target, event) {
 +  var check = 'on' + event.type.toLowerCase();
 +  if (typeof target[check] === 'function') {
 +    target[check](event);
 +  }
 +  return target.dispatchEvent(event);
 +}
++
 +/**
 + * @param {Element} el to check for stacking context
 + * @return {boolean} whether this el or its parents creates a stacking context
 + */
 +function createsStackingContext(el) {
 +  while (el && el !== document.body) {
 +    var s = window.getComputedStyle(el);
 +    var invalid = function(k, ok) {
 +      return !(s[k] === undefined || s[k] === ok);
 +    };
++
 +    if (s.opacity < 1 ||
 +        invalid('zIndex', 'auto') ||
 +        invalid('transform', 'none') ||
 +        invalid('mixBlendMode', 'normal') ||
 +        invalid('filter', 'none') ||
 +        invalid('perspective', 'none') ||
 +        s['isolation'] === 'isolate' ||
 +        s.position === 'fixed' ||
 +        s.webkitOverflowScrolling === 'touch') {
 +      return true;
 +    }
 +    el = el.parentElement;
 +  }
 +  return false;
 +}
++
 +/**
 + * Finds the nearest <dialog> from the passed element.
 + *
 + * @param {Element} el to search from
 + * @return {HTMLDialogElement} dialog found
 + */
 +function findNearestDialog(el) {
 +  while (el) {
 +    if (el.localName === 'dialog') {
 +      return /** @type {HTMLDialogElement} */ (el);
 +    }
 +    if (el.parentElement) {
 +      el = el.parentElement;
 +    } else if (el.parentNode) {
 +      el = el.parentNode.host;
 +    } else {
 +      el = null;
 +    }
 +  }
 +  return null;
 +}
++
 +/**
 + * Blur the specified element, as long as it's not the HTML body element.
 + * This works around an IE9/10 bug - blurring the body causes Windows to
 + * blur the whole application.
 + *
 + * @param {Element} el to blur
 + */
 +function safeBlur(el) {
 +  // Find the actual focused element when the active element is inside a shadow root
 +  while (el && el.shadowRoot && el.shadowRoot.activeElement) {
 +    el = el.shadowRoot.activeElement;
 +  }
++
 +  if (el && el.blur && el !== document.body) {
 +    el.blur();
 +  }
 +}
++
 +/**
 + * @param {!NodeList} nodeList to search
 + * @param {Node} node to find
 + * @return {boolean} whether node is inside nodeList
 + */
 +function inNodeList(nodeList, node) {
 +  for (var i = 0; i < nodeList.length; ++i) {
 +    if (nodeList[i] === node) {
 +      return true;
 +    }
 +  }
 +  return false;
 +}
++
 +/**
 + * @param {HTMLFormElement} el to check
 + * @return {boolean} whether this form has method="dialog"
 + */
 +function isFormMethodDialog(el) {
 +  if (!el || !el.hasAttribute('method')) {
 +    return false;
 +  }
 +  return el.getAttribute('method').toLowerCase() === 'dialog';
 +}
++
 +/**
 + * @param {!DocumentFragment|!Element} hostElement
 + * @return {?Element}
 + */
 +function findFocusableElementWithin(hostElement) {
 +  // Note that this is 'any focusable area'. This list is probably not exhaustive, but the
 +  // alternative involves stepping through and trying to focus everything.
 +  var opts = ['button', 'input', 'keygen', 'select', 'textarea'];
 +  var query = opts.map(function(el) {
 +    return el + ':not([disabled])';
 +  });
 +  // TODO(samthor): tabindex values that are not numeric are not focusable.
 +  query.push('[tabindex]:not([disabled]):not([tabindex=""])');  // tabindex != "", not disabled
 +  var target = hostElement.querySelector(query.join(', '));
++
 +  if (!target && 'attachShadow' in Element.prototype) {
 +    // If we haven't found a focusable target, see if the host element contains an element
 +    // which has a shadowRoot.
 +    // Recursively search for the first focusable item in shadow roots.
 +    var elems = hostElement.querySelectorAll('*');
 +    for (var i = 0; i < elems.length; i++) {
 +      if (elems[i].tagName && elems[i].shadowRoot) {
 +        target = findFocusableElementWithin(elems[i].shadowRoot);
 +        if (target) {
 +          break;
 +        }
 +      }
 +    }
 +  }
 +  return target;
 +}
++
 +/**
 + * Determines if an element is attached to the DOM.
 + * @param {Element} element to check
 + * @return {boolean} whether the element is in DOM
 + */
 +function isConnected(element) {
 +  return element.isConnected || document.body.contains(element);
 +}
++
 +/**
 + * @param {!Event} event
 + * @return {?Element}
 + */
 +function findFormSubmitter(event) {
 +  if (event.submitter) {
 +    return event.submitter;
 +  }
++
 +  var form = event.target;
 +  if (!(form instanceof HTMLFormElement)) {
 +    return null;
 +  }
++
 +  var submitter = dialogPolyfill.formSubmitter;
 +  if (!submitter) {
 +    var target = event.target;
 +    var root = ('getRootNode' in target && target.getRootNode() || document);
 +    submitter = root.activeElement;
 +  }
++
 +  if (!submitter || submitter.form !== form) {
 +    return null;
 +  }
 +  return submitter;
 +}
++
 +/**
 + * @param {!Event} event
 + */
 +function maybeHandleSubmit(event) {
 +  if (event.defaultPrevented) {
 +    return;
 +  }
 +  var form = /** @type {!HTMLFormElement} */ (event.target);
++
 +  // We'd have a value if we clicked on an imagemap.
 +  var value = dialogPolyfill.imagemapUseValue;
 +  var submitter = findFormSubmitter(event);
 +  if (value === null && submitter) {
 +    value = submitter.value;
 +  }
++
 +  // There should always be a dialog as this handler is added specifically on them, but check just
 +  // in case.
 +  var dialog = findNearestDialog(form);
 +  if (!dialog) {
 +    return;
 +  }
++
 +  // Prefer formmethod on the button.
 +  var formmethod = submitter && submitter.getAttribute('formmethod') || form.getAttribute('method');
 +  if (formmethod !== 'dialog') {
 +    return;
 +  }
 +  event.preventDefault();
++
 +  if (value != null) {
 +    // nb. we explicitly check against null/undefined
 +    dialog.close(value);
 +  } else {
 +    dialog.close();
 +  }
 +}
++
 +/**
 + * @param {!HTMLDialogElement} dialog to upgrade
 + * @constructor
 + */
 +function dialogPolyfillInfo(dialog) {
 +  this.dialog_ = dialog;
 +  this.replacedStyleTop_ = false;
 +  this.openAsModal_ = false;
++
 +  // Set a11y role. Browsers that support dialog implicitly know this already.
 +  if (!dialog.hasAttribute('role')) {
 +    dialog.setAttribute('role', 'dialog');
 +  }
++
 +  dialog.show = this.show.bind(this);
 +  dialog.showModal = this.showModal.bind(this);
 +  dialog.close = this.close.bind(this);
++
 +  dialog.addEventListener('submit', maybeHandleSubmit, false);
++
 +  if (!('returnValue' in dialog)) {
 +    dialog.returnValue = '';
 +  }
++
 +  if ('MutationObserver' in window) {
 +    var mo = new MutationObserver(this.maybeHideModal.bind(this));
 +    mo.observe(dialog, {attributes: true, attributeFilter: ['open']});
 +  } else {
 +    // IE10 and below support. Note that DOMNodeRemoved etc fire _before_ removal. They also
 +    // seem to fire even if the element was removed as part of a parent removal. Use the removed
 +    // events to force downgrade (useful if removed/immediately added).
 +    var removed = false;
 +    var cb = function() {
 +      removed ? this.downgradeModal() : this.maybeHideModal();
 +      removed = false;
 +    }.bind(this);
 +    var timeout;
 +    var delayModel = function(ev) {
 +      if (ev.target !== dialog) { return; }  // not for a child element
 +      var cand = 'DOMNodeRemoved';
 +      removed |= (ev.type.substr(0, cand.length) === cand);
 +      window.clearTimeout(timeout);
 +      timeout = window.setTimeout(cb, 0);
 +    };
 +    ['DOMAttrModified', 'DOMNodeRemoved', 'DOMNodeRemovedFromDocument'].forEach(function(name) {
 +      dialog.addEventListener(name, delayModel);
 +    });
 +  }
 +  // Note that the DOM is observed inside DialogManager while any dialog
 +  // is being displayed as a modal, to catch modal removal from the DOM.
++
 +  Object.defineProperty(dialog, 'open', {
 +    set: this.setOpen.bind(this),
 +    get: dialog.hasAttribute.bind(dialog, 'open')
 +  });
++
 +  this.backdrop_ = document.createElement('div');
 +  this.backdrop_.className = 'backdrop';
 +  this.backdrop_.addEventListener('mouseup'  , this.backdropMouseEvent_.bind(this));
 +  this.backdrop_.addEventListener('mousedown', this.backdropMouseEvent_.bind(this));
 +  this.backdrop_.addEventListener('click'    , this.backdropMouseEvent_.bind(this));
 +}
++
 +dialogPolyfillInfo.prototype = /** @type {HTMLDialogElement.prototype} */ ({
++
 +  get dialog() {
 +    return this.dialog_;
 +  },
++
 +  /**
 +   * Maybe remove this dialog from the modal top layer. This is called when
 +   * a modal dialog may no longer be tenable, e.g., when the dialog is no
 +   * longer open or is no longer part of the DOM.
 +   */
 +  maybeHideModal: function() {
 +    if (this.dialog_.hasAttribute('open') && isConnected(this.dialog_)) { return; }
 +    this.downgradeModal();
 +  },
++
 +  /**
 +   * Remove this dialog from the modal top layer, leaving it as a non-modal.
 +   */
 +  downgradeModal: function() {
 +    if (!this.openAsModal_) { return; }
 +    this.openAsModal_ = false;
 +    this.dialog_.style.zIndex = '';
++
 +    // This won't match the native <dialog> exactly because if the user set top on a centered
 +    // polyfill dialog, that top gets thrown away when the dialog is closed. Not sure it's
 +    // possible to polyfill this perfectly.
 +    if (this.replacedStyleTop_) {
 +      this.dialog_.style.top = '';
 +      this.replacedStyleTop_ = false;
 +    }
++
 +    // Clear the backdrop and remove from the manager.
 +    this.backdrop_.parentNode && this.backdrop_.parentNode.removeChild(this.backdrop_);
 +    dialogPolyfill.dm.removeDialog(this);
 +  },
++
 +  /**
 +   * @param {boolean} value whether to open or close this dialog
 +   */
 +  setOpen: function(value) {
 +    if (value) {
 +      this.dialog_.hasAttribute('open') || this.dialog_.setAttribute('open', '');
 +    } else {
 +      this.dialog_.removeAttribute('open');
 +      this.maybeHideModal();  // nb. redundant with MutationObserver
 +    }
 +  },
++
 +  /**
 +   * Handles mouse events ('mouseup', 'mousedown', 'click') on the fake .backdrop element, redirecting them as if
 +   * they were on the dialog itself.
 +   *
 +   * @param {!Event} e to redirect
 +   */
 +  backdropMouseEvent_: function(e) {
 +    if (!this.dialog_.hasAttribute('tabindex')) {
 +      // Clicking on the backdrop should move the implicit cursor, even if dialog cannot be
 +      // focused. Create a fake thing to focus on. If the backdrop was _before_ the dialog, this
 +      // would not be needed - clicks would move the implicit cursor there.
 +      var fake = document.createElement('div');
 +      this.dialog_.insertBefore(fake, this.dialog_.firstChild);
 +      fake.tabIndex = -1;
 +      fake.focus();
 +      this.dialog_.removeChild(fake);
 +    } else {
 +      this.dialog_.focus();
 +    }
++
 +    var redirectedEvent = document.createEvent('MouseEvents');
 +    redirectedEvent.initMouseEvent(e.type, e.bubbles, e.cancelable, window,
 +        e.detail, e.screenX, e.screenY, e.clientX, e.clientY, e.ctrlKey,
 +        e.altKey, e.shiftKey, e.metaKey, e.button, e.relatedTarget);
 +    this.dialog_.dispatchEvent(redirectedEvent);
 +    e.stopPropagation();
 +  },
++
 +  /**
 +   * Focuses on the first focusable element within the dialog. This will always blur the current
 +   * focus, even if nothing within the dialog is found.
 +   */
 +  focus_: function() {
 +    // Find element with `autofocus` attribute, or fall back to the first form/tabindex control.
 +    var target = this.dialog_.querySelector('[autofocus]:not([disabled])');
 +    if (!target && this.dialog_.tabIndex >= 0) {
 +      target = this.dialog_;
 +    }
 +    if (!target) {
 +      target = findFocusableElementWithin(this.dialog_);
 +    }
 +    safeBlur(document.activeElement);
 +    target && target.focus();
 +  },
++
 +  /**
 +   * Sets the zIndex for the backdrop and dialog.
 +   *
 +   * @param {number} dialogZ
 +   * @param {number} backdropZ
 +   */
 +  updateZIndex: function(dialogZ, backdropZ) {
 +    if (dialogZ < backdropZ) {
 +      throw new Error('dialogZ should never be < backdropZ');
 +    }
 +    this.dialog_.style.zIndex = dialogZ;
 +    this.backdrop_.style.zIndex = backdropZ;
 +  },
++
 +  /**
 +   * Shows the dialog. If the dialog is already open, this does nothing.
 +   */
 +  show: function() {
 +    if (!this.dialog_.open) {
 +      this.setOpen(true);
 +      this.focus_();
 +    }
 +  },
++
 +  /**
 +   * Show this dialog modally.
 +   */
 +  showModal: function() {
 +    if (this.dialog_.hasAttribute('open')) {
 +      throw new Error('Failed to execute \'showModal\' on dialog: The element is already open, and therefore cannot be opened modally.');
 +    }
 +    if (!isConnected(this.dialog_)) {
 +      throw new Error('Failed to execute \'showModal\' on dialog: The element is not in a Document.');
 +    }
 +    if (!dialogPolyfill.dm.pushDialog(this)) {
 +      throw new Error('Failed to execute \'showModal\' on dialog: There are too many open modal dialogs.');
 +    }
++
 +    if (createsStackingContext(this.dialog_.parentElement)) {
 +      console.warn('A dialog is being shown inside a stacking context. ' +
 +          'This may cause it to be unusable. For more information, see this link: ' +
 +          'https://github.com/GoogleChrome/dialog-polyfill/#stacking-context');
 +    }
++
 +    this.setOpen(true);
 +    this.openAsModal_ = true;
++
 +    // Optionally center vertically, relative to the current viewport.
 +    if (dialogPolyfill.needsCentering(this.dialog_)) {
 +      dialogPolyfill.reposition(this.dialog_);
 +      this.replacedStyleTop_ = true;
 +    } else {
 +      this.replacedStyleTop_ = false;
 +    }
++
 +    // Insert backdrop.
 +    this.dialog_.parentNode.insertBefore(this.backdrop_, this.dialog_.nextSibling);
++
 +    // Focus on whatever inside the dialog.
 +    this.focus_();
 +  },
++
 +  /**
 +   * Closes this HTMLDialogElement. This is optional vs clearing the open
 +   * attribute, however this fires a 'close' event.
 +   *
 +   * @param {string=} opt_returnValue to use as the returnValue
 +   */
 +  close: function(opt_returnValue) {
 +    if (!this.dialog_.hasAttribute('open')) {
 +      throw new Error('Failed to execute \'close\' on dialog: The element does not have an \'open\' attribute, and therefore cannot be closed.');
 +    }
 +    this.setOpen(false);
++
 +    // Leave returnValue untouched in case it was set directly on the element
 +    if (opt_returnValue !== undefined) {
 +      this.dialog_.returnValue = opt_returnValue;
 +    }
++
 +    // Triggering "close" event for any attached listeners on the <dialog>.
 +    var closeEvent = new supportCustomEvent('close', {
 +      bubbles: false,
 +      cancelable: false
 +    });
 +    safeDispatchEvent(this.dialog_, closeEvent);
 +  }
++
 +});
++
 +var dialogPolyfill = {};
++
 +dialogPolyfill.reposition = function(element) {
 +  var scrollTop = document.body.scrollTop || document.documentElement.scrollTop;
 +  var topValue = scrollTop + (window.innerHeight - element.offsetHeight) / 2;
 +  element.style.top = Math.max(scrollTop, topValue) + 'px';
 +};
++
 +dialogPolyfill.isInlinePositionSetByStylesheet = function(element) {
 +  for (var i = 0; i < document.styleSheets.length; ++i) {
 +    var styleSheet = document.styleSheets[i];
 +    var cssRules = null;
 +    // Some browsers throw on cssRules.
 +    try {
 +      cssRules = styleSheet.cssRules;
 +    } catch (e) {}
 +    if (!cssRules) { continue; }
 +    for (var j = 0; j < cssRules.length; ++j) {
 +      var rule = cssRules[j];
 +      var selectedNodes = null;
 +      // Ignore errors on invalid selector texts.
 +      try {
 +        selectedNodes = document.querySelectorAll(rule.selectorText);
 +      } catch(e) {}
 +      if (!selectedNodes || !inNodeList(selectedNodes, element)) {
 +        continue;
 +      }
 +      var cssTop = rule.style.getPropertyValue('top');
 +      var cssBottom = rule.style.getPropertyValue('bottom');
 +      if ((cssTop && cssTop !== 'auto') || (cssBottom && cssBottom !== 'auto')) {
 +        return true;
 +      }
 +    }
 +  }
 +  return false;
 +};
++
 +dialogPolyfill.needsCentering = function(dialog) {
 +  var computedStyle = window.getComputedStyle(dialog);
 +  if (computedStyle.position !== 'absolute') {
 +    return false;
 +  }
++
 +  // We must determine whether the top/bottom specified value is non-auto.  In
 +  // WebKit/Blink, checking computedStyle.top == 'auto' is sufficient, but
 +  // Firefox returns the used value. So we do this crazy thing instead: check
 +  // the inline style and then go through CSS rules.
 +  if ((dialog.style.top !== 'auto' && dialog.style.top !== '') ||
 +      (dialog.style.bottom !== 'auto' && dialog.style.bottom !== '')) {
 +    return false;
 +  }
 +  return !dialogPolyfill.isInlinePositionSetByStylesheet(dialog);
 +};
++
 +/**
 + * @param {!Element} element to force upgrade
 + */
 +dialogPolyfill.forceRegisterDialog = function(element) {
 +  if (window.HTMLDialogElement || element.showModal) {
 +    console.warn('This browser already supports <dialog>, the polyfill ' +
 +        'may not work correctly', element);
 +  }
 +  if (element.localName !== 'dialog') {
 +    throw new Error('Failed to register dialog: The element is not a dialog.');
 +  }
 +  new dialogPolyfillInfo(/** @type {!HTMLDialogElement} */ (element));
 +};
++
 +/**
 + * @param {!Element} element to upgrade, if necessary
 + */
 +dialogPolyfill.registerDialog = function(element) {
 +  if (!element.showModal) {
 +    dialogPolyfill.forceRegisterDialog(element);
 +  }
 +};
++
 +/**
 + * @constructor
 + */
 +dialogPolyfill.DialogManager = function() {
 +  /** @type {!Array<!dialogPolyfillInfo>} */
 +  this.pendingDialogStack = [];
++
 +  var checkDOM = this.checkDOM_.bind(this);
++
 +  // The overlay is used to simulate how a modal dialog blocks the document.
 +  // The blocking dialog is positioned on top of the overlay, and the rest of
 +  // the dialogs on the pending dialog stack are positioned below it. In the
 +  // actual implementation, the modal dialog stacking is controlled by the
 +  // top layer, where z-index has no effect.
 +  this.overlay = document.createElement('div');
 +  this.overlay.className = '_poly_dialog_overlay';
 +  this.overlay.addEventListener('click', function(e) {
 +    this.forwardTab_ = undefined;
 +    e.stopPropagation();
 +    checkDOM([]);  // sanity-check DOM
 +  }.bind(this));
++
 +  this.handleKey_ = this.handleKey_.bind(this);
 +  this.handleFocus_ = this.handleFocus_.bind(this);
++
 +  this.zIndexLow_ = 100000;
 +  this.zIndexHigh_ = 100000 + 150;
++
 +  this.forwardTab_ = undefined;
++
 +  if ('MutationObserver' in window) {
 +    this.mo_ = new MutationObserver(function(records) {
 +      var removed = [];
 +      records.forEach(function(rec) {
 +        for (var i = 0, c; c = rec.removedNodes[i]; ++i) {
 +          if (!(c instanceof Element)) {
 +            continue;
 +          } else if (c.localName === 'dialog') {
 +            removed.push(c);
 +          }
 +          removed = removed.concat(c.querySelectorAll('dialog'));
 +        }
 +      });
 +      removed.length && checkDOM(removed);
 +    });
 +  }
 +};
++
 +/**
 + * Called on the first modal dialog being shown. Adds the overlay and related
 + * handlers.
 + */
 +dialogPolyfill.DialogManager.prototype.blockDocument = function() {
 +  document.documentElement.addEventListener('focus', this.handleFocus_, true);
 +  document.addEventListener('keydown', this.handleKey_);
 +  this.mo_ && this.mo_.observe(document, {childList: true, subtree: true});
 +};
++
 +/**
 + * Called on the first modal dialog being removed, i.e., when no more modal
 + * dialogs are visible.
 + */
 +dialogPolyfill.DialogManager.prototype.unblockDocument = function() {
 +  document.documentElement.removeEventListener('focus', this.handleFocus_, true);
 +  document.removeEventListener('keydown', this.handleKey_);
 +  this.mo_ && this.mo_.disconnect();
 +};
++
 +/**
 + * Updates the stacking of all known dialogs.
 + */
 +dialogPolyfill.DialogManager.prototype.updateStacking = function() {
 +  var zIndex = this.zIndexHigh_;
++
 +  for (var i = 0, dpi; dpi = this.pendingDialogStack[i]; ++i) {
 +    dpi.updateZIndex(--zIndex, --zIndex);
 +    if (i === 0) {
 +      this.overlay.style.zIndex = --zIndex;
 +    }
 +  }
++
 +  // Make the overlay a sibling of the dialog itself.
 +  var last = this.pendingDialogStack[0];
 +  if (last) {
 +    var p = last.dialog.parentNode || document.body;
 +    p.appendChild(this.overlay);
 +  } else if (this.overlay.parentNode) {
 +    this.overlay.parentNode.removeChild(this.overlay);
 +  }
 +};
++
 +/**
 + * @param {Element} candidate to check if contained or is the top-most modal dialog
 + * @return {boolean} whether candidate is contained in top dialog
 + */
 +dialogPolyfill.DialogManager.prototype.containedByTopDialog_ = function(candidate) {
 +  while (candidate = findNearestDialog(candidate)) {
 +    for (var i = 0, dpi; dpi = this.pendingDialogStack[i]; ++i) {
 +      if (dpi.dialog === candidate) {
 +        return i === 0;  // only valid if top-most
 +      }
 +    }
 +    candidate = candidate.parentElement;
 +  }
 +  return false;
 +};
++
 +dialogPolyfill.DialogManager.prototype.handleFocus_ = function(event) {
 +  var target = event.composedPath ? event.composedPath()[0] : event.target;
++
 +  if (this.containedByTopDialog_(target)) { return; }
++
 +  if (document.activeElement === document.documentElement) { return; }
++
 +  event.preventDefault();
 +  event.stopPropagation();
 +  safeBlur(/** @type {Element} */ (target));
++
 +  if (this.forwardTab_ === undefined) { return; }  // move focus only from a tab key
++
 +  var dpi = this.pendingDialogStack[0];
 +  var dialog = dpi.dialog;
 +  var position = dialog.compareDocumentPosition(target);
 +  if (position & Node.DOCUMENT_POSITION_PRECEDING) {
 +    if (this.forwardTab_) {
 +      // forward
 +      dpi.focus_();
 +    } else if (target !== document.documentElement) {
 +      // backwards if we're not already focused on <html>
 +      document.documentElement.focus();
 +    }
 +  }
++
 +  return false;
 +};
++
 +dialogPolyfill.DialogManager.prototype.handleKey_ = function(event) {
 +  this.forwardTab_ = undefined;
 +  if (event.keyCode === 27) {
 +    event.preventDefault();
 +    event.stopPropagation();
 +    var cancelEvent = new supportCustomEvent('cancel', {
 +      bubbles: false,
 +      cancelable: true
 +    });
 +    var dpi = this.pendingDialogStack[0];
 +    if (dpi && safeDispatchEvent(dpi.dialog, cancelEvent)) {
 +      dpi.dialog.close();
 +    }
 +  } else if (event.keyCode === 9) {
 +    this.forwardTab_ = !event.shiftKey;
 +  }
 +};
++
 +/**
 + * Finds and downgrades any known modal dialogs that are no longer displayed. Dialogs that are
 + * removed and immediately readded don't stay modal, they become normal.
 + *
 + * @param {!Array<!HTMLDialogElement>} removed that have definitely been removed
 + */
 +dialogPolyfill.DialogManager.prototype.checkDOM_ = function(removed) {
 +  // This operates on a clone because it may cause it to change. Each change also calls
 +  // updateStacking, which only actually needs to happen once. But who removes many modal dialogs
 +  // at a time?!
 +  var clone = this.pendingDialogStack.slice();
 +  clone.forEach(function(dpi) {
 +    if (removed.indexOf(dpi.dialog) !== -1) {
 +      dpi.downgradeModal();
 +    } else {
 +      dpi.maybeHideModal();
 +    }
 +  });
 +};
++
 +/**
 + * @param {!dialogPolyfillInfo} dpi
 + * @return {boolean} whether the dialog was allowed
 + */
 +dialogPolyfill.DialogManager.prototype.pushDialog = function(dpi) {
 +  var allowed = (this.zIndexHigh_ - this.zIndexLow_) / 2 - 1;
 +  if (this.pendingDialogStack.length >= allowed) {
 +    return false;
 +  }
 +  if (this.pendingDialogStack.unshift(dpi) === 1) {
 +    this.blockDocument();
 +  }
 +  this.updateStacking();
 +  return true;
 +};
++
 +/**
 + * @param {!dialogPolyfillInfo} dpi
 + */
 +dialogPolyfill.DialogManager.prototype.removeDialog = function(dpi) {
 +  var index = this.pendingDialogStack.indexOf(dpi);
 +  if (index === -1) { return; }
++
 +  this.pendingDialogStack.splice(index, 1);
 +  if (this.pendingDialogStack.length === 0) {
 +    this.unblockDocument();
 +  }
 +  this.updateStacking();
 +};
++
 +dialogPolyfill.dm = new dialogPolyfill.DialogManager();
 +dialogPolyfill.formSubmitter = null;
 +dialogPolyfill.imagemapUseValue = null;
++
 +/**
 + * Installs global handlers, such as click listers and native method overrides. These are needed
 + * even if a no dialog is registered, as they deal with <form method="dialog">.
 + */
 +if (window.HTMLDialogElement === undefined) {
++
 +  /**
 +   * If HTMLFormElement translates method="DIALOG" into 'get', then replace the descriptor with
 +   * one that returns the correct value.
 +   */
 +  var testForm = document.createElement('form');
 +  testForm.setAttribute('method', 'dialog');
 +  if (testForm.method !== 'dialog') {
 +    var methodDescriptor = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, 'method');
 +    if (methodDescriptor) {
 +      // nb. Some older iOS and older PhantomJS fail to return the descriptor. Don't do anything
 +      // and don't bother to update the element.
 +      var realGet = methodDescriptor.get;
 +      methodDescriptor.get = function() {
 +        if (isFormMethodDialog(this)) {
 +          return 'dialog';
 +        }
 +        return realGet.call(this);
 +      };
 +      var realSet = methodDescriptor.set;
 +      /** @this {HTMLElement} */
 +      methodDescriptor.set = function(v) {
 +        if (typeof v === 'string' && v.toLowerCase() === 'dialog') {
 +          return this.setAttribute('method', v);
 +        }
 +        return realSet.call(this, v);
 +      };
 +      Object.defineProperty(HTMLFormElement.prototype, 'method', methodDescriptor);
 +    }
 +  }
++
 +  /**
 +   * Global 'click' handler, to capture the <input type="submit"> or <button> element which has
 +   * submitted a <form method="dialog">. Needed as Safari and others don't report this inside
 +   * document.activeElement.
 +   */
 +  document.addEventListener('click', function(ev) {
 +    dialogPolyfill.formSubmitter = null;
 +    dialogPolyfill.imagemapUseValue = null;
 +    if (ev.defaultPrevented) { return; }  // e.g. a submit which prevents default submission
++
 +    var target = /** @type {Element} */ (ev.target);
 +    if ('composedPath' in ev) {
 +      var path = ev.composedPath();
 +      target = path.shift() || target;
 +    }
 +    if (!target || !isFormMethodDialog(target.form)) { return; }
++
 +    var valid = (target.type === 'submit' && ['button', 'input'].indexOf(target.localName) > -1);
 +    if (!valid) {
 +      if (!(target.localName === 'input' && target.type === 'image')) { return; }
 +      // this is a <input type="image">, which can submit forms
 +      dialogPolyfill.imagemapUseValue = ev.offsetX + ',' + ev.offsetY;
 +    }
++
 +    var dialog = findNearestDialog(target);
 +    if (!dialog) { return; }
++
 +    dialogPolyfill.formSubmitter = target;
++
 +  }, false);
++
 +  /**
 +   * Global 'submit' handler. This handles submits of `method="dialog"` which are invalid, i.e.,
 +   * outside a dialog. They get prevented.
 +   */
 +  document.addEventListener('submit', function(ev) {
 +    var form = ev.target;
 +    var dialog = findNearestDialog(form);
 +    if (dialog) {
 +      return;  // ignore, handle there
 +    }
++
 +    var submitter = findFormSubmitter(ev);
 +    var formmethod = submitter && submitter.getAttribute('formmethod') || form.getAttribute('method');
 +    if (formmethod === 'dialog') {
 +      ev.preventDefault();
 +    }
 +  });
++
 +  /**
 +   * Replace the native HTMLFormElement.submit() method, as it won't fire the
 +   * submit event and give us a chance to respond.
 +   */
 +  var nativeFormSubmit = HTMLFormElement.prototype.submit;
 +  var replacementFormSubmit = function () {
 +    if (!isFormMethodDialog(this)) {
 +      return nativeFormSubmit.call(this);
 +    }
 +    var dialog = findNearestDialog(this);
 +    dialog && dialog.close();
 +  };
 +  HTMLFormElement.prototype.submit = replacementFormSubmit;
 +}
++
 +export default dialogPolyfill;

public/script.js+54 -24 Viewed

     resetMovableStyles,
     forceCharacterEditorTokenize,
     applyPowerUserSettings,
 +    switchSwipeNumAllMessages,
 } from './scripts/power-user.js';
 import {

 export async function sendTextareaMessage() {
     if (is_send_press) return;
     if (isExecutingCommandsFromChatInput) return;
 +    if (this_edit_mes_id) return; // don't proceed if editing a message
     let generateType;
     // "Continue on send" is activated when the user hits "send" (or presses enter) on an empty chat box, and the last

     addCopyToCodeBlocks(newMessage);
 +    // Set the swipes counter for past messages, only visible if 'Show Swipes on All Message' is enabled
 +    if (!params.isUser && newMessageId !== 0 && newMessageId !== chat.length - 1) {
 +        const swipesNum = chat[newMessageId].swipes?.length;
 +        const swipeId = chat[newMessageId].swipe_id + 1;
 +        newMessage.find('.swipes-counter').text(formatSwipeCounter(swipeId, swipesNum));
 +    }
++
     if (showSwipes) {
         $('#chat .mes').last().addClass('last_mes');
         $('#chat .mes').eq(-2).removeClass('last_mes');

  * @param {boolean} [compact] Send as a compact display message.
  * @param {string} [name] Name of the user sending the message. Defaults to name1.
  * @param {string} [avatar] Avatar of the user sending the message. Defaults to user_avatar.
  * @returns {Promise<voidany>} A promise that resolves whento the message when it is inserted.
  */
 export async function sendMessageAsUser(messageText, messageBias, insertAt = null, compact = false, name = name1, avatar = user_avatar) {
     messageText = getRegexedString(messageText, regex_placement.USER_INPUT);

@@ -4832,6 +4841,8 @@ export async function sendMessageAsUser(messageText, messageBias, insertAt = nul
4832	4841	await eventSource.emit(event_types.USER_MESSAGE_RENDERED, chat_id);
4833	4842	await saveChatConditional();
4834	4843	}
	4844	+
	4845	+ return message;
4835	4846	}
4836	4847
4837	4848	/**

     //had to add this to make the swipe counter work
     //(copied from the onclick functions for swipe buttons..
     //don't know why the array isn't set for non-swipe messsages in Generate or addOneMessage..)
+-
     if (chat[chat.length - 1]['swipe_id'] === undefined) {              // if there is no swipe-message in the last spot of the chat array
         chat[chat.length - 1]['swipe_id'] = 0;                        // set it to id 0
         chat[chat.length - 1]['swipes'] = [];                         // empty the array

     const currentMessage = $('#chat').children().filter(`[mesid="${chat.length - 1}"]`);
     const swipeId = chat[chat.length - 1].swipe_id;
     const swipeCounterText = formatSwipeCounter(`${(swipeId + 1)}\u200B/\u200b${(, chat[chat.length - 1].swipes.length)}`);
 +    const swipeRight = currentMessage.find('.swipe_right');
 +    const swipeLeft = currentMessage.find('.swipe_left');
 +    const swipeCounter = currentMessage.find('.swipes-counter');
     if (swipeId !== undefined && (chat[chat.length - 1].swipes.length > 1 || swipeId > 0)) {
         currentMessage.children('.swipe_left')swipeLeft.css('display', 'flex');
+    }
     //only show right when generate is off, or when next right swipe would not make a generate happen
     if (is_send_press === false || chat[chat.length - 1].swipes.length >= swipeId) {
         currentMessageswipeRight.childrencss('.swipe_rightdisplay', 'flex').css('displayopacity', 'flex0.3');
         currentMessage.children('.swipe_right')swipeCounter.css('opacity', '0.3');
+    }
 -    //console.log((chat[chat.length - 1]));
     if ((chat[chat.length - 1].swipes.length - swipeId) === 1) {
 -        //console.log('highlighting R swipe');
 +        //chevron was moved out of hardcode in HTML to class toggle dependent on last_mes or not
 -        currentMessage.children('.swipe_right').css('opacity', '0.7');
 +        //necessary for 'swipe_right' div in past messages to have no chevron if 'show swipes for all messages' is turned on
 +        swipeRight.css('opacity', '0.7');
 +        swipeCounter.css('opacity', '0.7');
+    }
 -    //console.log(swipesCounterHTML);
 -    $('.swipes-counter').text(swipeCounterText);
 +    //allows for writing individual swipe counters for past messages
 +    const lastSwipeCounter = $('.last_mes .swipes-counter');
 +    lastSwipeCounter.text(swipeCounterText).show();
     //console.logswitchSwipeNumAllMessages(swipeId);
 -    //console.log(chat[chat.length - 1].swipes.length);
+}
 export function hideSwipeButtons() {
 -    //console.log('hideswipebuttons entered');
 +    $('#chat').find('.swipe_right').hide();
     $('#chat').find('.swipe_rightlast_mes .swipes-counter').csshide('display', 'none');
     $('#chat').find('.swipe_left').csshide('display', 'none');
+}
 /**

     };
 };
 +/**
 + * Formats a counter for a swipe view.
 + * @param {number} current The current number of items.
 + * @param {number} total The total number of items.
 + * @returns {string} The formatted counter.
 + */
 +function formatSwipeCounter(current, total) {
 +    if (isNaN(current) || isNaN(total)) {
 +        return '';
 +    }
++
 +    return `${current}\u200b/\u200b${total}`;
 +}
++
 function swipe_left() {      // when we swipe left..but no generation.
     if (chat.length - 1 === Number(this_edit_mes_id)) {
         closeMessageEditor();

+    }
     const currentMessage = $('#chat').children().filter(`[mesid="${chat.length - 1}"]`);
     let this_div = currentMessage.childrenfind('.swipe_right');
     let this_mes_div = this_div.parent().parent();
     if (chat[chat.length - 1]['swipe_id'] > chat[chat.length - 1]['swipes'].length) { //if we swipe right while generating (the swipe ID is greater than what we are viewing now)
         chat[chat.length - 1]['swipe_id'] = chat[chat.length - 1]['swipes'].length; //show that message slot (will be '...' while generating)

+    }
     // handles animated transitions when swipe right, specifically height transitions between messages
     if (run_generate || run_swipe_right) {
         let this_mes_block = this_mes_div.childrenfind('.mes_block').children(' .mes_text');
         const this_mes_div_height = this_mes_div[0].scrollHeight;
         const this_mes_block_height = this_mes_block[0].scrollHeight;

     ///// SWIPE BUTTON CLICKS ///////
 -    $(document).on('click', '.swipe_right', swipe_right);
 +    //limit swiping to only last message clicks
+-
 +    $(document).on('click', '.last_mes .swipe_right', swipe_right);
     $(document).on('click', '.last_mes .swipe_left', swipe_left);
     const debouncedCharacterSearch = debounce((searchQuery) => {
         entitiesFilter.setFilterData(FILTER_TYPES.SEARCH, searchQuery);

+        }
         else if (id == 'option_continue') {
 +            if (this_edit_mes_id) return; // don't proceed if editing a message
++
             if (is_send_press == false || fromSlashCommand) {
                 is_send_press = true;
                 Generate('continue', buildOrFillAdditionalArgs());

             $('.openDrawer').not('.pinnedOpen').addClass('resizing').slideToggle(200, 'swing', async function () {
                 await delay(50); $(this).closest('.drawer-content').removeClass('resizing');
             });
             $('.openIcon').not('.drawerPinnedOpen').toggleClass('closedIcon openIcon');
             $('.openDrawer').not('.pinnedOpen').toggleClass('closedDrawer openDrawer');
             icon.toggleClass('openIcon closedIcon');
             drawer.toggleClass('openDrawer closedDrawer');

                     $('.openDrawer').not('.pinnedOpen').addClass('resizing').slideToggle(200, 'swing', function () {
                         $(this).closest('.drawer-content').removeClass('resizing');
                     });
                     $('.openIcon').not('.drawerPinnedOpen').toggleClass('closedIcon openIcon');
                     $('.openDrawer').not('.pinnedOpen').toggleClass('closedDrawer openDrawer');
+                }

public/scripts/RossAscends-mods.js+19 -3 Viewed

 var WIPanelPin = document.getElementById('WI_panel_pin');
 var RightNavPanel = document.getElementById('right-nav-panel');
 +var RightNavDrawerIcon = document.getElementById('rightNavDrawerIcon');
 var LeftNavPanel = document.getElementById('left-nav-panel');
 +var LeftNavDrawerIcon = document.getElementById('leftNavDrawerIcon');
 var WorldInfo = document.getElementById('WorldInfo');
 +var WIDrawerIcon = document.getElementById('WIDrawerIcon');
 var SelectedCharacterTab = document.getElementById('rm_button_selected_ch');

         if ($(RPanelPin).prop('checked') == true) {
             //console.log('adding pin class to right nav');
             $(RightNavPanel).addClass('pinnedOpen');
 +            $(RightNavDrawerIcon).addClass('drawerPinnedOpen');
         } else {
             //console.log('removing pin class from right nav');
             $(RightNavPanel).removeClass('pinnedOpen');
 +            $(RightNavDrawerIcon).removeClass('drawerPinnedOpen');
             if ($(RightNavPanel).hasClass('openDrawer') && $('.openDrawer').length > 1) {
                 $(RightNavPanel).slideToggle(200, 'swing');
                 //$(rightNavDrawerIconRightNavDrawerIcon).toggleClass('openIcon closedIcon');
                 $(RightNavPanel).toggleClass('openDrawer closedDrawer');
+            }
+        }

         if ($(LPanelPin).prop('checked') == true) {
             //console.log('adding pin class to Left nav');
             $(LeftNavPanel).addClass('pinnedOpen');
 +            $(LeftNavDrawerIcon).addClass('drawerPinnedOpen');
         } else {
             //console.log('removing pin class from Left nav');
             $(LeftNavPanel).removeClass('pinnedOpen');
 +            $(LeftNavDrawerIcon).removeClass('drawerPinnedOpen');
             if ($(LeftNavPanel).hasClass('openDrawer') && $('.openDrawer').length > 1) {
                 $(LeftNavPanel).slideToggle(200, 'swing');
                 //$(leftNavDrawerIconLeftNavDrawerIcon).toggleClass('openIcon closedIcon');
                 $(LeftNavPanel).toggleClass('openDrawer closedDrawer');
+            }
+        }

         if ($(WIPanelPin).prop('checked') == true) {
             console.debug('adding pin class to WI');
             $(WorldInfo).addClass('pinnedOpen');
 +            $(WIDrawerIcon).addClass('drawerPinnedOpen');
         } else {
             console.debug('removing pin class from WI');
             $(WorldInfo).removeClass('pinnedOpen');
 +            $(WIDrawerIcon).removeClass('drawerPinnedOpen');
             if ($(WorldInfo).hasClass('openDrawer') && $('.openDrawer').length > 1) {
                 console.debug('closing WI after lock removal');
                 $(WorldInfo).slideToggle(200, 'swing');
                 //$(WorldInfoDrawerIconWIDrawerIcon).toggleClass('openIcon closedIcon');
                 $(WorldInfo).toggleClass('openDrawer closedDrawer');
+            }
+        }

     if (LoadLocalBool('NavLockOn') == true) {
         //console.log('setting pin class via local var');
         $(RightNavPanel).addClass('pinnedOpen');
 +        $(RightNavDrawerIcon).addClass('drawerPinnedOpen');
+    }
     if ($(RPanelPin).prop('checked')) {
         console.debug('setting pin class via checkbox state');
         $(RightNavPanel).addClass('pinnedOpen');
 +        $(RightNavDrawerIcon).addClass('drawerPinnedOpen');
+    }
     // read the state of left Nav Lock and apply to leftnav classlist
     $(LPanelPin).prop('checked', LoadLocalBool('LNavLockOn'));
     if (LoadLocalBool('LNavLockOn') == true) {
         //console.log('setting pin class via local var');
         $(LeftNavPanel).addClass('pinnedOpen');
 +        $(LeftNavDrawerIcon).addClass('drawerPinnedOpen');
+    }
     if ($(LPanelPin).prop('checked')) {
         console.debug('setting pin class via checkbox state');
         $(LeftNavPanel).addClass('pinnedOpen');
 +        $(LeftNavDrawerIcon).addClass('drawerPinnedOpen');
+    }
     // read the state of left Nav Lock and apply to leftnav classlist

     if (LoadLocalBool('WINavLockOn') == true) {
         //console.log('setting pin class via local var');
         $(WorldInfo).addClass('pinnedOpen');
 +        $(WIDrawerIcon).addClass('drawerPinnedOpen');
+    }
     if ($(WIPanelPin).prop('checked')) {
         console.debug('setting pin class via checkbox state');
         $(WorldInfo).addClass('pinnedOpen');
 +        $(WIDrawerIcon).addClass('drawerPinnedOpen');
+    }
     //save state of Right nav being open or closed

             const editMesDone = $('.mes_edit_done:visible');
             if (editMesDone.length > 0) {
                 console.debug('Accepting edits with Ctrl+Enter');
 +                $('#send_textarea').focus();
                 editMesDone.trigger('click');
                 return;
             } else if (is_send_press == false) {

public/scripts/extensions/attachments/index.js+21 -0 Viewed

 +import { event_types, eventSource, saveSettingsDebounced } from '../../../script.js';
 import { deleteAttachment, getDataBankAttachments, getDataBankAttachmentsForSource, getFileAttachment, uploadFileAttachmentToServer } from '../../chats.js';
 import { extension_settings, renderExtensionTemplateAsync } from '../../extensions.js';
 import { SlashCommand } from '../../slash-commands/SlashCommand.js';

     return '';
+}
 +function cleanUpAttachments() {
 +    let shouldSaveSettings = false;
 +    if (extension_settings.character_attachments) {
 +        Object.values(extension_settings.character_attachments).flat().filter(a => a.text).forEach(a => {
 +            shouldSaveSettings = true;
 +            delete a.text;
 +        });
 +    }
 +    if (Array.isArray(extension_settings.attachments)) {
 +        extension_settings.attachments.filter(a => a.text).forEach(a => {
 +            shouldSaveSettings = true;
 +            delete a.text;
 +        });
 +    }
 +    if (shouldSaveSettings) {
 +        saveSettingsDebounced();
 +    }
 +}
++
 jQuery(async () => {
 +    eventSource.on(event_types.APP_READY, cleanUpAttachments);
     const manageButton = await renderExtensionTemplateAsync('attachments', 'manage-button', {});
     const attachButton = await renderExtensionTemplateAsync('attachments', 'attach-button', {});
     $('#data_bank_wand_container').append(manageButton);

public/scripts/extensions/caption/index.js+1 -0 Viewed

                 (extension_settings.caption.source === 'multimodal' && extension_settings.caption.multimodal_api === 'openai' && (secret_state[SECRET_KEYS.OPENAI] || extension_settings.caption.allow_reverse_proxy)) ||
                 (extension_settings.caption.source === 'multimodal' && extension_settings.caption.multimodal_api === 'openrouter' && secret_state[SECRET_KEYS.OPENROUTER]) ||
                 (extension_settings.caption.source === 'multimodal' && extension_settings.caption.multimodal_api === 'zerooneai' && secret_state[SECRET_KEYS.ZEROONEAI]) ||
 +                (extension_settings.caption.source === 'multimodal' && extension_settings.caption.multimodal_api === 'groq' && secret_state[SECRET_KEYS.GROQ]) ||
                 (extension_settings.caption.source === 'multimodal' && extension_settings.caption.multimodal_api === 'mistral' && (secret_state[SECRET_KEYS.MISTRALAI] || extension_settings.caption.allow_reverse_proxy)) ||
                 (extension_settings.caption.source === 'multimodal' && extension_settings.caption.multimodal_api === 'google' && (secret_state[SECRET_KEYS.MAKERSUITE] || extension_settings.caption.allow_reverse_proxy)) ||
                 (extension_settings.caption.source === 'multimodal' && extension_settings.caption.multimodal_api === 'anthropic' && (secret_state[SECRET_KEYS.CLAUDE] || extension_settings.caption.allow_reverse_proxy)) ||

public/scripts/extensions/caption/settings.html+4 -0 Viewed

                         <option value="anthropic">Anthropic</option>
                         <option value="custom" data-i18n="Custom (OpenAI-compatible)">Custom (OpenAI-compatible)</option>
                         <option value="google">Google AI Studio</option>
 +                        <option value="groq">Groq</option>
                         <option value="koboldcpp">KoboldCpp</option>
                         <option value="llamacpp">llama.cpp</option>
                         <option value="mistral">MistralAI</option>

                         <option data-type="google" value="gemini-1.5-pro-exp-0801">gemini-1.5-pro-exp-0801</option>
                         <option data-type="google" value="gemini-1.5-pro-exp-0827">gemini-1.5-pro-exp-0827</option>
                         <option data-type="google" value="gemini-pro-vision">gemini-pro-vision</option>
 +                        <option data-type="groq" value="llama-3.2-11b-vision-preview">llama-3.2-11b-vision-preview</option>
 +                        <option data-type="groq" value="llama-3.2-90b-vision-preview">llama-3.2-90b-vision-preview</option>
 +                        <option data-type="groq" value="llava-v1.5-7b-4096-preview">llava-v1.5-7b-4096-preview</option>
                         <option data-type="openrouter" value="openai/gpt-4-vision-preview">openai/gpt-4-vision-preview</option>
                         <option data-type="openrouter" value="openai/gpt-4o">openai/gpt-4o</option>
                         <option data-type="openrouter" value="openai/gpt-4o-2024-05-13">openai/gpt-4o-2024-05-13</option>

public/scripts/extensions/expressions/index.js+31 -5 Viewed

 import { isFunctionCallingSupported } from '../../openai.js';
 import { SlashCommandEnumValue, enumTypes } from '../../slash-commands/SlashCommandEnumValue.js';
 import { commonEnumProviders } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
 +import { slashCommandReturnHelper } from '../../slash-commands/SlashCommandReturnHelper.js';
 +import { SlashCommandClosure } from '../../slash-commands/SlashCommandClosure.js';
 export { MODULE_NAME };
 const MODULE_NAME = 'expressions';

         name: 'classify-expressions',
         aliases: ['expressions'],
         callback: async (args) => {
 -            const list = await getExpressionsList();
 +            /** @type {import('../../slash-commands/SlashCommandReturnHelper.js').SlashCommandReturnType} */
 -            switch (String(args.format).toLowerCase()) {
 +            // @ts-ignore
 +            let returnType = args.return;
++
 +            // Old legacy return type handling
 +            if (args.format) {
 +                toastr.warning(`Legacy argument 'format' with value '${args.format}' is deprecated. Please use 'return' instead. Routing to the correct return type...`, 'Deprecation warning');
 +                const type = String(args?.format).toLowerCase().trim();
 +                switch (type) {
                     case 'json':
 -                    return JSON.stringify(list);
 +                        returnType = 'object';
 +                        break;
                     default:
 -                    return list.join(', ');
 +                        returnType = 'pipe';
 +                        break;
 +                }
+            }
++
 +            // Now the actual new return type handling
 +            const list = await getExpressionsList();
++
 +            return await slashCommandReturnHelper.doReturn(returnType ?? 'pipe', list, { objectToStringFunc: list => list.join(', ') });
         },
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'pipe',
 +                enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
 +                forceEnum: true,
 +            }),
 +            // TODO remove some day
 +            SlashCommandNamedArgument.fromProps({
                 name: 'format',
                 description: '!!! DEPRECATED - use "return" instead !!! The format to return the list in: comma-separated plain text or JSON array. Default is plain text.',
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumList: [
                     new SlashCommandEnumValue('plain', null, enumTypes.enum, ', '),

public/scripts/extensions/shared.js+5 -1 Viewed

     const isVllm = extension_settings.caption.multimodal_api === 'vllm';
     const base64Bytes = base64Img.length * 0.75;
     const compressionLimit = 2 * 1024 * 1024;
     if ((['google', 'openrouter', 'mistral', 'groq'].includes(extension_settings.caption.multimodal_api) && base64Bytes > compressionLimit) || isOoba || isKoboldCpp) {
         const maxSide = 1024;
         base64Img = await createThumbnail(base64Img, maxSide, maxSide, 'image/jpeg');
+    }

@@ -135,6 +135,10 @@ function throwIfInvalidModel(useReverseProxy) {
135	135	throw new Error('01.AI API key is not set.');
136	136	}
137	137
	138	+ if (extension_settings.caption.multimodal_api === 'groq' && !secret_state[SECRET_KEYS.GROQ]) {
	139	+ throw new Error('Groq API key is not set.');
	140	+ }
	141	+
138	142	if (extension_settings.caption.multimodal_api === 'google' && !secret_state[SECRET_KEYS.MAKERSUITE] && !useReverseProxy) {
139	143	throw new Error('Google AI Studio API key is not set.');
140	144	}

public/scripts/extensions/vectors/index.js+2 -2 Viewed

+        }
         // Download and process the file
         file.textconst fileText = await getFileAttachment(file.url);
         console.log(`Vectors: Retrieved file ${file.name} from Data Bank`);
         // Convert kilobytes to string length
         const thresholdLength = settings.size_threshold_db * 1024;
         // Use chunk size from settings if file is larger than threshold
         const chunkSize = file.size > thresholdLength ? settings.chunk_size_db : -1;
         await vectorizeFile(file.textfileText, file.name, collectionId, chunkSize, settings.overlap_percent_db);
+    }
     return dataBankCollectionIds;

public/scripts/openai.js+13 -5 Viewed

         if (chatCompletion.canAfford(chatMessage)) {
             if (type === 'continue' && oai_settings.continue_prefill && chatPrompt === firstNonInjected) {
 +                // in case we are using continue_prefill and the latest message is an assistant message, we want to prepend the users assistant prefill on the message
 +                if (chatPrompt.role === 'assistant') {
 +                    const collection = new MessageCollection('continuePrefill', new Message(chatMessage.role, substituteParams(oai_settings.assistant_prefill + '\n\n') + chatMessage.content, chatMessage.identifier));
 +                    chatCompletion.add(collection, -1);
 +                    continue;
 +                }
                 const collection = new MessageCollection('continuePrefill', chatMessage);
                 chatCompletion.add(collection, -1);
                 continue;

@@ -1767,8 +1773,8 @@ async function sendOpenAIRequest(type, messages, signal) {
1767	1773	generate_data['claude_use_sysprompt'] = oai_settings.claude_use_sysprompt;
1768	1774	generate_data['stop'] = getCustomStoppingStrings(); // Claude shouldn't have limits on stop strings.
1769	1775	generate_data['human_sysprompt_message'] = substituteParams(oai_settings.human_sysprompt_message);
1770	1776	// Don't add a prefill on quiet gens (summarization) and when using continue prefill.
1771	1777	if (!isQuiet && !(isContinue && oai_settings.continue_prefill)) {
1772	1778	generate_data['assistant_prefill'] = isImpersonate ? substituteParams(oai_settings.assistant_impersonation) : substituteParams(oai_settings.assistant_prefill);
1773	1779	}
1774	1780	}

             $('#openai_max_context').attr('max', max_2mil);
         } else if (value.includes('gemini-1.5-pro')) {
             $('#openai_max_context').attr('max', max_2mil);
 -        } else if (value.match('gemini-1.5-flash-002')) {
 -            $('#openai_max_context').attr('max', max_2mil);
         } else if (value.includes('gemini-1.5-flash')) {
             $('#openai_max_context').attr('max', max_1mil);
         } else if (value.includes('gemini-1.0-pro-vision') || value === 'gemini-pro-vision') {

         if (oai_settings.max_context_unlocked) {
             $('#openai_max_context').attr('max', unlocked_max);
+        }
         else if (oai_settings.groq_model.includes('llama-3.12') && oai_settings.groq_model.includes('-preview')) {
 +            $('#openai_max_context').attr('max', max_8k);
 +        }
 +        else if (oai_settings.groq_model.includes('llama-3.2') || oai_settings.groq_model.includes('llama-3.1')) {
             $('#openai_max_context').attr('max', max_128k);
+        }
         else if (oai_settings.groq_model.includes('llama3-groq')) {

         'gemini-1.5-flash-001',
         'gemini-1.5-flash-002',
         'gemini-1.5-flash-exp-0827',
 +        'gemini-1.5-flash-8b',
         'gemini-1.5-flash-8b-exp-0827',
         'gemini-1.5-flash-8b-exp-0924',
         'gemini-1.0-pro-vision-latest',

public/scripts/popup.js+5 -0 Viewed

 +import dialogPolyfill from '../lib/dialog-polyfill.esm.js';
 import { shouldSendOnEnter } from './RossAscends-mods.js';
 import { power_user } from './power-user.js';
 import { removeFromArray, runAfterAnimation, uuidv4 } from './utils.js';

         const template = document.querySelector('#popup_template');
         // @ts-ignore
         this.dlg = template.content.cloneNode(true).querySelector('.popup');
 +        if (!this.dlg.showModal) {
 +            this.dlg.classList.add('poly_dialog');
 +            dialogPolyfill.registerDialog(this.dlg);
 +        }
         this.body = this.dlg.querySelector('.popup-body');
         this.content = this.dlg.querySelector('.popup-content');
         this.mainInput = this.dlg.querySelector('.popup-input');

public/scripts/power-user.js+21 -0 Viewed

     restore_user_input: true,
     reduced_motion: false,
     compact_input_area: true,
 +    show_swipe_num_all_messages: false,
     auto_connect: false,
     auto_load_chat: false,
     forbid_external_media: true,

     $('#compact_input_area').prop('checked', power_user.compact_input_area);
+}
 +export function switchSwipeNumAllMessages() {
 +    $('#show_swipe_num_all_messages').prop('checked', power_user.show_swipe_num_all_messages);
 +    $('.mes:not(.last_mes) .swipes-counter').css('opacity', '').toggle(power_user.show_swipe_num_all_messages);
 +}
++
 var originalSliderValues = [];
 async function switchLabMode() {

                 switchCompactInputArea();
             },
         },
 +        {
 +            key: 'show_swipe_num_all_messages',
 +            action: () => {
 +                $('#show_swipe_num_all_messages').prop('checked', power_user.show_swipe_num_all_messages);
 +                switchSwipeNumAllMessages();
 +            },
 +        },
     ];
     for (const { key, selector, type, action } of themeProperties) {

     switchHideChatAvatars();
     switchTokenCount();
     switchMessageActions();
 +    switchSwipeNumAllMessages();
+}
 function getExampleMessagesBehavior() {

         zoomed_avatar_magnification: power_user.zoomed_avatar_magnification,
         reduced_motion: power_user.reduced_motion,
         compact_input_area: power_user.compact_input_area,
 +        show_swipe_num_all_messages: power_user.show_swipe_num_all_messages,
     };
+}

         saveSettingsDebounced();
     });
 +    $('#show_swipe_num_all_messages').on('input', function () {
 +        power_user.show_swipe_num_all_messages = !!$(this).prop('checked');
 +        switchSwipeNumAllMessages();
 +        saveSettingsDebounced();
 +    });
++
     $('#auto-connect-checkbox').on('input', function () {
         power_user.auto_connect = !!$(this).prop('checked');
         saveSettingsDebounced();

public/scripts/slash-commands.js+136 -53 Viewed

 import { addEphemeralStoppingString, chat_styles, flushEphemeralStoppingStrings, power_user } from './power-user.js';
 import { SERVER_INPUTS, textgen_types, textgenerationwebui_settings } from './textgen-settings.js';
 import { decodeTextTokens, getAvailableTokenizers, getFriendlyTokenizerName, getTextTokens, getTokenCountAsync, selectTokenizer } from './tokenizers.js';
 import { debounce, delay, equalsIgnoreCaseAndAccents, findChar, getCharIndex, isFalseBoolean, isTrueBoolean, onlyUnique, showFontAwesomePicker, stringToRange, trimToEndSentence, trimToStartSentence, waitUntilCondition } from './utils.js';
 import { registerVariableCommands, resolveVariable } from './variables.js';
 import { background_settings } from './backgrounds.js';
 import { SlashCommandClosure } from './slash-commands/SlashCommandClosure.js';

 import { commonEnumProviders, enumIcons } from './slash-commands/SlashCommandCommonEnumsProvider.js';
 import { SlashCommandBreakController } from './slash-commands/SlashCommandBreakController.js';
 import { SlashCommandExecutionError } from './slash-commands/SlashCommandExecutionError.js';
 +import { slashCommandReturnHelper } from './slash-commands/SlashCommandReturnHelper.js';
 export {
     executeSlashCommands, executeSlashCommandsWithOptions, getSlashCommandsHelp, registerSlashCommand,
 };

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'sendas',
         callback: sendMessageAs,
 +        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',

                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'none',
 +                enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
 +                forceEnum: true,
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

         name: 'sys',
         callback: sendNarratorMessage,
         aliases: ['nar'],
 +        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [
             new SlashCommandNamedArgument(
                 'compact',

                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'none',
 +                enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
 +                forceEnum: true,
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'comment',
         callback: sendCommentMessage,
 +        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [
             new SlashCommandNamedArgument(
                 'compact',

                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'none',
 +                enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
 +                forceEnum: true,
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'ask',
         callback: askCharacter,
 -        returns: 'the generated text',
 +        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',

                 isRequired: true,
                 enumProvider: commonEnumProviders.characters('character'),
             }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'pipe',
 +                enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
 +                forceEnum: true,
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'send',
         callback: sendUserMessageCallback,
 +        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [
             new SlashCommandNamedArgument(
                 'compact',

                 defaultValue: '{{user}}',
                 enumProvider: commonEnumProviders.personas,
             }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'none',
 +                enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
 +                forceEnum: true,
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'listinjects',
         callback: listInjectsCallback,
         helpString: 'Lists all script injections for the current chat. Displays injects in a popup by default. Use the <code>formatreturn</code> argument to change the outputreturn formattype.',
         returns: 'Optionalls the JSON object of script injections',
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'popup-html',
 +                enumList: slashCommandReturnHelper.enumList({ allowPipe: false, allowObject: true, allowChat: true, allowPopup: true, allowTextVersion: false }),
 +                forceEnum: true,
 +            }),
 +            // TODO remove some day
 +            SlashCommandNamedArgument.fromProps({
                 name: 'format',
                 description: '!!! DEPRECATED - use "return" instead !!! output format',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 forceEnum: true,

+}
 async function listInjectsCallback(args) {
 +    /** @type {import('./slash-commands/SlashCommandReturnHelper.js').SlashCommandReturnType} */
 +    let returnType = args.return;
++
 +    // Old legacy return type handling
 +    if (args.format) {
 +        toastr.warning(`Legacy argument 'format' with value '${args.format}' is deprecated. Please use 'return' instead. Routing to the correct return type...`, 'Deprecation warning');
         const type = String(args?.format).toLowerCase().trim();
         if (!chat_metadata.script_injects || !Object.keys(chat_metadata.script_injects).length) {
             type !== 'none' && toastr.info('No script injections for the current chat');
 -        return JSON.stringify({});
+        }
+-
 -    const injects = Object.entries(chat_metadata.script_injects)
 -        .map(([id, inject]) => {
 -            const position = Object.entries(extension_prompt_types);
 -            const positionName = position.find(([_, value]) => value === inject.position)?.[0] ?? 'unknown';
 -            return `* **${id}**: <code>${inject.value}</code> (${positionName}, depth: ${inject.depth}, scan: ${inject.scan ?? false}, role: ${inject.role ?? extension_prompt_roles.SYSTEM})`;
 -        })
 -        .join('\n');
+-
 -    const converter = new showdown.Converter();
 -    const messageText = `### Script injections:\n${injects}`;
 -    const htmlMessage = DOMPurify.sanitize(converter.makeHtml(messageText));
+-
         switch (type) {
             case 'none':
 +                returnType = 'none';
                 break;
             case 'chat':
 -            sendSystemMessage(system_message_types.GENERIC, htmlMessage);
 +                returnType = 'chat-html';
                 break;
             case 'popup':
             default:
 -            await callGenericPopup(htmlMessage, POPUP_TYPE.TEXT);
 +                returnType = 'popup-html';
                 break;
+        }
 +    }
 -    return JSON.stringify(chat_metadata.script_injects);
 +    // Now the actual new return type handling
 +    const buildTextValue = (injects) => {
 +        const injectsStr = Object.entries(injects)
 +            .map(([id, inject]) => {
 +                const position = Object.entries(extension_prompt_types);
 +                const positionName = position.find(([_, value]) => value === inject.position)?.[0] ?? 'unknown';
 +                return `* **${id}**: <code>${inject.value}</code> (${positionName}, depth: ${inject.depth}, scan: ${inject.scan ?? false}, role: ${inject.role ?? extension_prompt_roles.SYSTEM})`;
 +            })
 +            .join('\n');
 +        return `### Script injections:\n${injectsStr || 'No script injections for the current chat'}`;
 +    };
++
 +    return await slashCommandReturnHelper.doReturn(returnType ?? 'popup-html', chat_metadata.script_injects ?? {}, { objectToStringFunc: buildTextValue });
+}
 /**

     // Not supported in group chats
     // TODO: Maybe support group chats?
     if (selected_group) {
         toastr.errorwarning('Cannot run /ask command in a group chat!');
         return '';
+    }

@@ -2633,7 +2693,9 @@ async function askCharacter(args, text) {
2633	2693	}
2634	2694	}
2635	2695
2636		- return askResult;
	2696	+ const message = askResult ? chat[chat.length - 1] : null;
	2697	+
	2698	+ return await slashCommandReturnHelper.doReturn(args.return ?? 'pipe', message, { objectToStringFunc: x => x.mes });
2637	2699	}
2638	2700
2639	2701	async function hideMessageCallback(_, arg) {

 async function sendUserMessageCallback(args, text) {
     if (!text) {
         consoletoastr.warnwarning('WARN:You Nomust textspecify providedtext forto /send command');
         return;
+    }

@@ -2924,16 +2986,17 @@ async function sendUserMessageCallback(args, text) {
2924	2986	insertAt = chat.length + insertAt;
2925	2987	}
2926	2988
	2989	+ let message;
2927	2990	if ('name' in args) {
2928	2991	const name = args.name \|\| '';
2929	2992	const avatar = findPersonaByName(name) \|\| user_avatar;
2930	2993	message = await sendMessageAsUser(text, bias, insertAt, compact, name, avatar);
2931	2994	}
2932	2995	else {
2933	2996	message = await sendMessageAsUser(text, bias, insertAt, compact);
2934	2997	}
2935	2998
2936		- return '';
	2999	+ return await slashCommandReturnHelper.doReturn(args.return ?? 'none', message, { objectToStringFunc: x => x.mes });
2937	3000	}
2938	3001
2939	3002	async function deleteMessagesByNameCallback(_, name) {

 export async function sendMessageAs(args, text) {
     if (!text) {
 +        toastr.warning('You must specify text to send as');
         return '';
+    }
 -    let name;
 +    let name = args.name?.trim();
     let mesText;
     if (args.!name) {
 -        name = args.name.trim();
+-
 -        if (!name && !text) {
 -            toastr.warning('You must specify a name and text to send as');
 -            return '';
 -        }
 -    } else {
         const namelessWarningKey = 'sendAsNamelessWarningShown';
         if (localStorage.getItem(namelessWarningKey) !== 'true') {
             toastr.warning('To avoid confusion, please use /sendas name="Character Name"', 'Name defaulted to {{char}}', { timeOut: 10000 });
             localStorage.setItem(namelessWarningKey, 'true');
+        }
         name = name2;
 -        if (!text) {
 -            toastr.warning('You must specify text to send as');
 -            return '';
 -        }
+    }
     mesText = text.trim();

@@ -3321,11 +3374,12 @@ export async function sendMessageAs(args, text) {
3321	3374	await saveChatConditional();
3322	3375	}
3323	3376
3324		- return '';
	3377	+ return await slashCommandReturnHelper.doReturn(args.return ?? 'none', message, { objectToStringFunc: x => x.mes });
3325	3378	}
3326	3379
3327	3380	export async function sendNarratorMessage(args, text) {
3328	3381	if (!text) {
	3382	+ toastr.warning('You must specify text to send');
3329	3383	return '';
3330	3384	}
3331	3385

@@ -3374,7 +3428,7 @@ export async function sendNarratorMessage(args, text) {
3374	3428	await saveChatConditional();
3375	3429	}
3376	3430
3377		- return '';
	3431	+ return await slashCommandReturnHelper.doReturn(args.return ?? 'none', message, { objectToStringFunc: x => x.mes });
3378	3432	}
3379	3433
3380	3434	export async function promptQuietForLoudResponse(who, text) {

 async function sendCommentMessage(args, text) {
     if (!text) {
 +        toastr.warning('You must specify text to send');
         return '';
+    }

@@ -3462,7 +3517,7 @@ async function sendCommentMessage(args, text) {
3462	3517	await saveChatConditional();
3463	3518	}
3464	3519
3465		- return '';
	3520	+ return await slashCommandReturnHelper.doReturn(args.return ?? 'none', message, { objectToStringFunc: x => x.mes });
3466	3521	}
3467	3522
3468	3523	/**

  * Retrieves the available model options based on the currently selected main API and its subtype
  * @param {boolean} quiet - Whether to suppress toasts
+ *
  * @returns {{control: HTMLSelectElement|HTMLInputElement, options: HTMLOptionElement[]}?} An array of objects representing the available model options, or null if not supported
  */
 function getModelOptions(quiet) {
     const nullResult = { control: null, options: null };
     const modelSelectMap = [
 +        { id: 'custom_model_textgenerationwebui', api: 'textgenerationwebui', type: textgen_types.OOBA },
         { id: 'model_togetherai_select', api: 'textgenerationwebui', type: textgen_types.TOGETHERAI },
         { id: 'openrouter_model', api: 'textgenerationwebui', type: textgen_types.OPENROUTER },
         { id: 'model_infermaticai_select', api: 'textgenerationwebui', type: textgen_types.INFERMATICAI },

         { id: 'aphrodite_model', api: 'textgenerationwebui', type: textgen_types.APHRODITE },
         { id: 'ollama_model', api: 'textgenerationwebui', type: textgen_types.OLLAMA },
         { id: 'tabby_model', api: 'textgenerationwebui', type: textgen_types.TABBY },
 +        { id: 'featherless_model', api: 'textgenerationwebui', type: textgen_types.FEATHERLESS },
         { id: 'model_openai_select', api: 'openai', type: chat_completion_sources.OPENAI },
         { id: 'model_claude_select', api: 'openai', type: chat_completion_sources.CLAUDE },
         { id: 'model_windowai_select', api: 'openai', type: chat_completion_sources.WINDOWAI },

         { id: 'model_ai21_select', api: 'openai', type: chat_completion_sources.AI21 },
         { id: 'model_google_select', api: 'openai', type: chat_completion_sources.MAKERSUITE },
         { id: 'model_mistralai_select', api: 'openai', type: chat_completion_sources.MISTRALAI },
         { id: 'model_custom_selectcustom_model_id', api: 'openai', type: chat_completion_sources.CUSTOM },
         { id: 'model_cohere_select', api: 'openai', type: chat_completion_sources.COHERE },
         { id: 'model_perplexity_select', api: 'openai', type: chat_completion_sources.PERPLEXITY },
         { id: 'model_groq_select', api: 'openai', type: chat_completion_sources.GROQ },

     const modelSelectControl = document.getElementById(modelSelectItem);
     if (!(modelSelectControl instanceof HTMLSelectElement) && !(modelSelectControl instanceof HTMLInputElement)) {
         !quiet && toastr.error(`Model select control not found: ${main_api}[${apiSubType}]`);
         return nullResult;
+    }
 -    const options = Array.from(modelSelectControl.options).filter(x => x.value);
 +    /**
 +     * Get options from a HTMLSelectElement or HTMLInputElement with a list.
 +     * @param {HTMLSelectElement | HTMLInputElement} control Control containing the options
 +     * @returns {HTMLOptionElement[]} Array of options
 +     */
 +    const getOptions = (control) => {
 +        if (control instanceof HTMLSelectElement) {
 +            return Array.from(control.options);
 +        }
++
 +        const valueOption = new Option(control.value, control.value);
++
 +        if (control instanceof HTMLInputElement && control.list instanceof HTMLDataListElement) {
 +            return [valueOption, ...Array.from(control.list.options)];
 +        }
++
 +        return [valueOption];
 +    };
++
 +    const options = getOptions(modelSelectControl).filter(x => x.value).filter(onlyUnique);
     return { control: modelSelectControl, options };
+}

         return '';
+    }
 -    if (!options.length) {
 -        !quiet && toastr.warning('No model options found. Check your API settings.');
 -        return '';
 -    }
+-
     model = String(model || '').trim();
     if (!model) {

     console.log('Set model to ' + model);
 +    if (modelSelectControl instanceof HTMLInputElement) {
 +        modelSelectControl.value = model;
 +        $(modelSelectControl).trigger('input');
 +        !quiet && toastr.success(`Model set to "${model}"`);
 +        return model;
 +    }
++
 +    if (!options.length) {
 +        !quiet && toastr.warning('No model options found. Check your API settings.');
 +        return '';
 +    }
++
     let newSelectedOption = null;
     const fuse = new Fuse(options, { keys: ['text', 'value'] });

public/scripts/slash-commands/SlashCommandCommonEnumsProvider.js+1 -0 Viewed

     message: '💬',
     voice: '🎤',
     server: '🖥️',
 +    popup: '🗔',
     true: '✔️',
     false: '❌',

public/scripts/slash-commands/SlashCommandReturnHelper.js+80 -0 Viewed

 +import { sendSystemMessage, system_message_types } from '../../script.js';
 +import { callGenericPopup, POPUP_TYPE } from '../popup.js';
 +import { escapeHtml } from '../utils.js';
 +import { enumIcons } from './SlashCommandCommonEnumsProvider.js';
 +import { enumTypes, SlashCommandEnumValue } from './SlashCommandEnumValue.js';
++
 +/** @typedef {'pipe'|'object'|'chat-html'|'chat-text'|'popup-html'|'popup-text'|'toast-html'|'toast-text'|'console'|'none'} SlashCommandReturnType */
++
 +export const slashCommandReturnHelper = {
 +    // Without this, VSCode formatter fucks up JS docs. Don't ask me why.
 +    _: false,
++
 +    /**
 +     * Gets/creates the enum list of types of return relevant for a slash command
 +     *
 +     * @param {object} [options={}] Options
 +     * @param {boolean} [options.allowPipe=true] Allow option to pipe the return value
 +     * @param {boolean} [options.allowObject=false] Allow option to return the value as an object
 +     * @param {boolean} [options.allowChat=false] Allow option to return the value as a chat message
 +     * @param {boolean} [options.allowPopup=false] Allow option to return the value as a popup
 +     * @param {boolean}[options.allowTextVersion=true] Used in combination with chat/popup/toast, some of them do not make sense for text versions, e.g.if you are building a HTML string anyway
 +     * @returns {SlashCommandEnumValue[]} The enum list
 +     */
 +    enumList: ({ allowPipe = true, allowObject = false, allowChat = false, allowPopup = false, allowTextVersion = true } = {}) => [
 +        allowPipe && new SlashCommandEnumValue('pipe', 'Return to the pipe for the next command', enumTypes.name, '|'),
 +        allowObject && new SlashCommandEnumValue('object', 'Return as an object (or array) to the pipe for the next command', enumTypes.variable, enumIcons.dictionary),
 +        allowChat && new SlashCommandEnumValue('chat-html', 'Sending a chat message with the return value - Can display HTML', enumTypes.command, enumIcons.message),
 +        allowChat && allowTextVersion && new SlashCommandEnumValue('chat-text', 'Sending a chat message with the return value - Will only display as text', enumTypes.qr, enumIcons.message),
 +        allowPopup && new SlashCommandEnumValue('popup-html', 'Showing as a popup with the return value - Can display HTML', enumTypes.command, enumIcons.popup),
 +        allowPopup && allowTextVersion && new SlashCommandEnumValue('popup-text', 'Showing as a popup with the return value - Will only display as text', enumTypes.qr, enumIcons.popup),
 +        new SlashCommandEnumValue('toast-html', 'Show the return value as a toast notification - Can display HTML', enumTypes.command, 'ℹ️'),
 +        allowTextVersion && new SlashCommandEnumValue('toast-text', 'Show the return value as a toast notification - Will only display as text', enumTypes.qr, 'ℹ️'),
 +        new SlashCommandEnumValue('console', 'Log the return value (object, if it can be one) to the console', enumTypes.enum, '>'),
 +        new SlashCommandEnumValue('none', 'No return value'),
 +    ].filter(x => !!x),
++
 +    /**
 +     * Handles the return value based on the specified type
 +     *
 +     * @param {SlashCommandReturnType} type The type of return
 +     * @param {object|number|string} value The value to return
 +     * @param {object} [options={}] Options
 +     * @param {(o: object) => string} [options.objectToStringFunc=null] Function to convert the object to a string, if object was provided and 'object' was not the chosen return type
 +     * @param {(o: object) => string} [options.objectToHtmlFunc=null] Analog to 'objectToStringFunc', which will be used here if not provided - but can do a different string layout if HTML is requested
 +     * @returns {Promise<*>} The processed return value
 +     */
 +    async doReturn(type, value, { objectToStringFunc = o => o?.toString(), objectToHtmlFunc = null } = {}) {
 +        const shouldHtml = type.endsWith('html');
 +        const actualConverterFunc = shouldHtml && objectToHtmlFunc ? objectToHtmlFunc : objectToStringFunc;
 +        const stringValue = typeof value !== 'string' ? actualConverterFunc(value) : value;
++
 +        switch (type) {
 +            case 'popup-html':
 +            case 'popup-text':
 +            case 'chat-text':
 +            case 'chat-html':
 +            case 'toast-text':
 +            case 'toast-html': {
 +                const htmlOrNotHtml = shouldHtml ? DOMPurify.sanitize((new showdown.Converter()).makeHtml(stringValue)) : escapeHtml(stringValue);
++
 +                if (type.startsWith('popup')) await callGenericPopup(htmlOrNotHtml, POPUP_TYPE.TEXT);
 +                if (type.startsWith('chat')) sendSystemMessage(system_message_types.GENERIC, htmlOrNotHtml);
 +                if (type.startsWith('toast')) toastr.info(htmlOrNotHtml, null, { escapeHtml: !shouldHtml });
++
 +                return '';
 +            }
 +            case 'pipe':
 +                return stringValue ?? '';
 +            case 'object':
 +                return JSON.stringify(value);
 +            case 'console':
 +                console.info(value);
 +                return '';
 +            case 'none':
 +                return '';
 +            default:
 +                throw new Error(`Unknown return type: ${type}`);
 +        }
 +    },
 +};

public/scripts/variables.js+42 -22 Viewed

 import { commonEnumProviders, enumIcons } from './slash-commands/SlashCommandCommonEnumsProvider.js';
 import { SlashCommandEnumValue, enumTypes } from './slash-commands/SlashCommandEnumValue.js';
 import { PARSER_FLAG, SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 +import { slashCommandReturnHelper } from './slash-commands/SlashCommandReturnHelper.js';
 import { SlashCommandScope } from './slash-commands/SlashCommandScope.js';
 import { isFalseBoolean, convertValueType, isTrueBoolean } from './utils.js';

+}
 async function listVariablesCallback(args) {
 -    const type = String(args?.format || '').toLowerCase().trim() || 'popup';
 +    /** @type {import('./slash-commands/SlashCommandReturnHelper.js').SlashCommandReturnType} */
 +    let returnType = args.return;
++
 +    // Old legacy return type handling
 +    if (args.format) {
 +        toastr.warning(`Legacy argument 'format' with value '${args.format}' is deprecated. Please use 'return' instead. Routing to the correct return type...`, 'Deprecation warning');
 +        const type = String(args?.format).toLowerCase().trim();
 +        switch (type) {
 +            case 'none':
 +                returnType = 'none';
 +                break;
 +            case 'chat':
 +                returnType = 'chat-html';
 +                break;
 +            case 'popup':
 +            default:
 +                returnType = 'popup-html';
 +                break;
 +        }
 +    }
++
 +    // Now the actual new return type handling
     const scope = String(args?.scope || '').toLowerCase().trim() || 'all';
     if (!chat_metadata.variables) {
         chat_metadata.variables = {};

     const localVariables = includeLocalVariables ? Object.entries(chat_metadata.variables).map(([name, value]) => `${name}: ${value}`) : [];
     const globalVariables = includeGlobalVariables ? Object.entries(extension_settings.variables.global).map(([name, value]) => `${name}: ${value}`) : [];
     const jsonVariablesbuildTextValue = [(_) => {
 -        ...Object.entries(chat_metadata.variables).map(x => ({ key: x[0], value: x[1], scope: 'local' })),
 -        ...Object.entries(extension_settings.variables.global).map(x => ({ key: x[0], value: x[1], scope: 'global' })),
 -    ];
+-
         const localVariablesString = localVariables.length > 0 ? localVariables.join('\n\n') : 'No local variables';
         const globalVariablesString = globalVariables.length > 0 ? globalVariables.join('\n\n') : 'No global variables';
         const chatName = getCurrentChatId();
 -    const converter = new showdown.Converter();
         const message = [
             includeLocalVariables ? `### Local variables (${chatName}):\n${localVariablesString}` : '',
             includeGlobalVariables ? `### Global variables:\n${globalVariablesString}` : '',
         ].filter(x => x).join('\n\n');
 -    const htmlMessage = DOMPurify.sanitize(converter.makeHtml(message));
 +        return message;
 +    };
 -    switch (type) {
 +    const jsonVariables = [
 -        case 'none':
 +        ...Object.entries(chat_metadata.variables).map(x => ({ key: x[0], value: x[1], scope: 'local' })),
 -            break;
 +        ...Object.entries(extension_settings.variables.global).map(x => ({ key: x[0], value: x[1], scope: 'global' })),
 -        case 'chat':
 +    ];
 -            sendSystemMessage(system_message_types.GENERIC, htmlMessage);
 -            break;
 -        case 'popup':
 -        default:
 -            await callGenericPopup(htmlMessage, POPUP_TYPE.TEXT);
 -            break;
 -    }
 -    return JSON.stringify(jsonVariables);
 +    return await slashCommandReturnHelper.doReturn(returnType ?? 'popup-html', jsonVariables, { objectToStringFunc: buildTextValue });
+}
 /**

         name: 'listvar',
         callback: listVariablesCallback,
         aliases: ['listchatvar'],
         helpString: 'List registered chat variables. Displays variables in a popup by default. Use the <code>formatreturn</code> argument to change the outputreturn formattype.',
         returns: 'JSON list of local variables',
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({

                 ],
             }),
             SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'popup-html',
 +                enumList: slashCommandReturnHelper.enumList({ allowPipe: false, allowObject: true, allowChat: true, allowPopup: true, allowTextVersion: false }),
 +                forceEnum: true,
 +            }),
 +            // TODO remove some day
 +            SlashCommandNamedArgument.fromProps({
                 name: 'format',
                 description: '!!! DEPRECATED - use "return" instead !!! output format',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 forceEnum: true,

public/style.css+25 -6 Viewed

 /* SWIPE RELATED STYLES*/
 +.mes {
 +    --swipeCounterHeight: 15px;
 +    --swipeCounterMargin: 5px;
 +}
++
 .swipe_right,
 .swipe_left {
     heightwidth: 40px25px;
     widthheight: 40px25px;
     opacity: 0.3;
     align-items: center;
     justify-content: center;
     z-index: 9999;
     grid-row-start: 2;
     font-size: 30px20px;
     cursor: pointer;
     align-self: center;
 +}
++
 +.swipe_left {
     position: absolute;
 -bottom: 15px;
 +    bottom: calc(var(--swipeCounterHeight) + var(--swipeCounterMargin));
     flex-flow: column;
+}
 +.swipeRightBlock {
 +    position: absolute;
 +    right: 0;
 +    bottom: 0;
 +}
 .swipes-counter {
     color: var(--SmartThemeBodyColor);
     font-size: 12px;
     padding: 0 5px;
     font-family: var(--mainFontFamily);
     font-weight: 400;
     align-self: center;
     min-width: 40px;
     display: flex;
     justify-content: center;
 +    margin-bottom: var(--swipeCounterMargin);
 +    height: var(--swipeCounterHeight);
 +}
++
 +.mes:not(.last_mes) .swipes-counter {
 +    opacity: 0.3;
+}
 .swipe_left {

 .swipe_right {
     right: 5px;
     align-self:end center;
+}
 .ui-settings {

src/endpoints/backends/chat-completions.js+6 -2 Viewed

+        }
         const requestBody = {
 +            /** @type {any} */ system: '',
             messages: convertedPrompt.messages,
             model: request.body.model,
             max_tokens: request.body.max_tokens,

             requestBody.system = enableSystemPromptCache
                 ? [{ type: 'text', text: convertedPrompt.systemPrompt, cache_control: { type: 'ephemeral' } }]
                 : convertedPrompt.systemPrompt;
 +        } else {
 +            delete requestBody.system;
+        }
         if (Array.isArray(request.body.tools) && request.body.tools.length > 0) {
             // Claude doesn't do prefills on function calls, and doesn't allow empty messages

             forwardFetchResponse(generateResponse, response);
         } else {
             if (!generateResponse.ok) {
 -                console.log(color.red(`Claude API returned error: ${generateResponse.status} ${generateResponse.statusText}\n${await generateResponse.text()}\n${divider}`));
 +                const generateResponseText = await generateResponse.text();
 +                console.log(color.red(`Claude API returned error: ${generateResponse.status} ${generateResponse.statusText}\n${generateResponseText}\n${divider}`));
                 return response.status(generateResponse.status).send({ error: true });
+            }
             const generateResponseJson = await generateResponse.json();
             const responseText = generateResponseJson?.content?.[0]?.text || '';
             console.log('Claude response:', generateResponseJson);
             // Wrap it back to OAI format + save the original content

src/endpoints/openai.js+8 -0 Viewed

             key = readSecret(request.user.directories, SECRET_KEYS.MISTRALAI);
+        }
 +        if (request.body.api === 'groq') {
 +            key = readSecret(request.user.directories, SECRET_KEYS.GROQ);
 +        }
++
         if (!key && !request.body.reverse_proxy && ['custom', 'ooba', 'koboldcpp', 'vllm'].includes(request.body.api) === false) {
             console.log('No key found for API', request.body.api);
             return response.sendStatus(400);

@@ -111,6 +115,10 @@ router.post('/caption-image', jsonParser, async (request, response) => {
111	115	apiUrl = 'https://api.01.ai/v1/chat/completions';
112	116	}
113	117
	118	+ if (request.body.api === 'groq') {
	119	+ apiUrl = 'https://api.groq.com/openai/v1/chat/completions';
	120	+ }
	121	+
114	122	if (request.body.api === 'mistral') {
115	123	apiUrl = 'https://api.mistral.ai/v1/chat/completions';
116	124	}

src/prompt-converters.js+1 -0 Viewed

         'gemini-1.5-flash-001',
         'gemini-1.5-flash-002',
         'gemini-1.5-flash-exp-0827',
 +        'gemini-1.5-flash-8b',
         'gemini-1.5-flash-8b-exp-0827',
         'gemini-1.5-flash-8b-exp-0924',
         'gemini-1.5-pro',