@grinev/opencode-telegram-bot 0.22.1 → 0.22.3

package/dist/app/services/edge-tts.js

@@ -0,0 +1,322 @@
+import { createHash, randomBytes, randomUUID } from "crypto";
+import { WebSocket } from "ws";
+import { logger } from "../../utils/logger.js";
+/**
+ * Microsoft Edge online text-to-speech client.
+ *
+ * Speaks the same WebSocket protocol used by Microsoft Edge's Read Aloud
+ * feature (wss://speech.platform.bing.com/.../readaloud/edge/v1). No API key
+ * is required; access is authenticated through a SHA256 "Sec-MS-GEC" token
+ * derived from the current time.
+ *
+ * Ported from the Python reference implementation at
+ * https://github.com/rany2/edge-tts.
+ */
+const BASE_URL = "speech.platform.bing.com/consumer/speech/synthesize/readaloud";
+const TRUSTED_CLIENT_TOKEN = "6A5AA1D4EAFF4E9FB37E23D68491D6F4";
+const WSS_URL = `wss://${BASE_URL}/edge/v1?TrustedClientToken=${TRUSTED_CLIENT_TOKEN}`;
+const CHROMIUM_FULL_VERSION = "143.0.3650.75";
+const CHROMIUM_MAJOR_VERSION = CHROMIUM_FULL_VERSION.split(".")[0];
+export const SEC_MS_GEC_VERSION = `1-${CHROMIUM_FULL_VERSION}`;
+export const EDGE_DEFAULT_VOICE = "en-US-EmmaMultilingualNeural";
+const WIN_EPOCH_SECONDS = 11644473600;
+const TICKS_PER_SECOND = 10_000_000;
+const ROUND_SECONDS = 300;
+const WSS_HEADERS = {
+    Pragma: "no-cache",
+    "Cache-Control": "no-cache",
+    Origin: "chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold",
+    "User-Agent": `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ` +
+        `(KHTML, like Gecko) Chrome/${CHROMIUM_MAJOR_VERSION}.0.0.0 Safari/537.36 ` +
+        `Edg/${CHROMIUM_MAJOR_VERSION}.0.0.0`,
+    "Accept-Encoding": "gzip, deflate, br, zstd",
+    "Accept-Language": "en-US,en;q=0.9",
+};
+const SYNTHESIS_TIMEOUT_MS = 60_000;
+const MAX_CHUNK_BYTES = 4096;
+let clockSkewSeconds = 0;
+/**
+ * Generates the Sec-MS-GEC DRM token Microsoft requires on every request.
+ *
+ * The token is the SHA256 (uppercased hex) of `<ticks><token>` where `ticks`
+ * is the current time as Windows file time (100-ns intervals since 1601-01-01)
+ * rounded down to the nearest 5 minutes. Rounded to limit token churn; the
+ * server accepts any token valid within the current 5-minute window.
+ */
+export function generateSecMsGec(now = new Date()) {
+    let seconds = now.getTime() / 1000 + clockSkewSeconds + WIN_EPOCH_SECONDS;
+    seconds -= seconds % ROUND_SECONDS;
+    const ticks = BigInt(Math.round(seconds)) * BigInt(TICKS_PER_SECOND);
+    const strToHash = `${ticks}${TRUSTED_CLIENT_TOKEN}`;
+    return createHash("sha256").update(strToHash, "ascii").digest("hex").toUpperCase();
+}
+/** @internal Reset clock skew (for tests only). */
+export function _resetClockSkew() {
+    clockSkewSeconds = 0;
+}
+function generateMuid() {
+    return randomBytes(16).toString("hex").toUpperCase();
+}
+function connectId() {
+    return randomUUID().replace(/-/g, "");
+}
+/** Formats like JS `Date.toString()` in UTC, the X-Timestamp shape Edge sends. */
+function jsDateString(date = new Date()) {
+    // toUTCString gives "Fri, 01 Jan 2024 00:00:00 GMT"; reorder its tokens.
+    const [day, dayNum, month, year, time] = date.toUTCString().replace(",", "").split(" ");
+    return `${day} ${month} ${dayNum} ${year} ${time} GMT+0000 (Coordinated Universal Time)`;
+}
+function escapeXml(text) {
+    return text
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+/** Escapes a value for interpolation into a single-quoted XML attribute. */
+function escapeXmlAttribute(value) {
+    return escapeXml(value).replace(/'/g, "&apos;").replace(/"/g, "&quot;");
+}
+/**
+ * Replaces control characters the service rejects (0x00-0x08, 0x0B-0x0C,
+ * 0x0E-0x1F) with spaces. Common in OCR'd text; without this the service
+ * returns an error.
+ */
+function removeIncompatibleCharacters(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g, " ");
+}
+/** Moves a split point back so it does not land inside an XML entity (&amp;). */
+function adjustForXmlEntity(buf, splitAt) {
+    let result = splitAt;
+    while (result > 0) {
+        const ampersandIndex = buf.subarray(0, result).lastIndexOf("&");
+        if (ampersandIndex < 0)
+            break;
+        if (buf.subarray(ampersandIndex, result).includes(";"))
+            break;
+        result = ampersandIndex;
+    }
+    return result;
+}
+/**
+ * Splits text into chunks no larger than `byteLength` UTF-8 bytes, preferring
+ * to break at newlines or spaces and never inside a multi-byte character or
+ * XML entity. Mirrors edge-tts's split_text_by_byte_length.
+ */
+export function splitTextByByteLength(text, byteLength) {
+    if (byteLength <= 0) {
+        throw new Error("byteLength must be greater than 0");
+    }
+    let rest = Buffer.from(text, "utf-8");
+    const chunks = [];
+    while (rest.length > byteLength) {
+        let splitAt = rest.lastIndexOf(0x0a, byteLength - 1);
+        if (splitAt < 0)
+            splitAt = rest.lastIndexOf(0x20, byteLength - 1);
+        if (splitAt < 0) {
+            splitAt = byteLength;
+            // Back up while the byte at the split is a UTF-8 continuation byte
+            // (10xxxxxx) so the cut never lands inside a multi-byte character.
+            while (splitAt > 0 && (rest[splitAt] & 0xc0) === 0x80) {
+                splitAt--;
+            }
+        }
+        splitAt = adjustForXmlEntity(rest, splitAt);
+        if (splitAt <= 0)
+            splitAt = 1;
+        const chunk = rest.subarray(0, splitAt).toString("utf-8").trim();
+        if (chunk)
+            chunks.push(chunk);
+        rest = rest.subarray(splitAt);
+    }
+    const remaining = rest.toString("utf-8").trim();
+    if (remaining)
+        chunks.push(remaining);
+    return chunks;
+}
+function buildSsml(voice, rate, volume, pitch, text) {
+    return ("<speak version='1.0' xmlns='http://www.w3.org/2001/10/synthesis' xml:lang='en-US'>" +
+        `<voice name='${escapeXmlAttribute(voice)}'>` +
+        `<prosody pitch='${escapeXmlAttribute(pitch)}' rate='${escapeXmlAttribute(rate)}' ` +
+        `volume='${escapeXmlAttribute(volume)}'>` +
+        text +
+        "</prosody></voice></speak>");
+}
+function parseRfc2616Date(date) {
+    const parsed = Date.parse(date);
+    return Number.isNaN(parsed) ? null : parsed / 1000;
+}
+class EdgeHttpUpgradeError extends Error {
+    statusCode;
+    serverDate;
+    constructor(statusCode, serverDate) {
+        super(`Edge TTS WebSocket upgrade failed: HTTP ${statusCode}`);
+        this.name = "EdgeHttpUpgradeError";
+        this.statusCode = statusCode;
+        this.serverDate = serverDate;
+    }
+}
+/**
+ * Synthesizes one SSML chunk over its own WebSocket connection and resolves
+ * with that chunk's MP3 audio bytes. Retries once on HTTP 403 (clock skew) by
+ * re-deriving the token against the server's reported time.
+ *
+ * The upstream edge-tts client also opens a fresh connection per chunk; the
+ * service does not reliably accept a second SSML turn on the same socket.
+ */
+async function synthesizeChunk(chunk, params) {
+    try {
+        return await attemptSynthesis(chunk, params);
+    }
+    catch (err) {
+        if (err instanceof EdgeHttpUpgradeError && err.statusCode === 403 && err.serverDate) {
+            const serverTime = parseRfc2616Date(err.serverDate);
+            if (serverTime !== null) {
+                clockSkewSeconds = serverTime - Date.now() / 1000;
+                logger.warn(`[EdgeTTS] HTTP 403: adjusted clock skew to ${clockSkewSeconds.toFixed(1)}s, retrying`);
+                return await attemptSynthesis(chunk, params);
+            }
+        }
+        throw err;
+    }
+}
+function attemptSynthesis(chunk, params) {
+    return new Promise((resolve, reject) => {
+        const gec = generateSecMsGec();
+        const url = `${WSS_URL}&ConnectionId=${connectId()}` +
+            `&Sec-MS-GEC=${gec}&Sec-MS-GEC-Version=${SEC_MS_GEC_VERSION}`;
+        const headers = { ...WSS_HEADERS, Cookie: `muid=${generateMuid()};` };
+        const ws = new WebSocket(url, { headers });
+        const audioChunks = [];
+        let audioReceived = false;
+        let settled = false;
+        let timer = null;
+        const finish = (error, result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            ws.removeAllListeners();
+            // Closing a still-connecting socket makes ws emit 'error' on the next
+            // tick; with no listener that is an uncaught exception, so keep a sink.
+            ws.on("error", () => { });
+            if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+                ws.close();
+            }
+            if (error)
+                reject(error);
+            else
+                resolve(result ?? Buffer.alloc(0));
+        };
+        timer = setTimeout(() => {
+            finish(new Error(`Edge TTS synthesis timed out after ${params.timeoutMs}ms`));
+        }, Math.max(0, params.deadline - Date.now()));
+        ws.on("unexpected-response", (_req, res) => {
+            const statusCode = res.statusCode ?? 0;
+            const serverDate = res.headers["date"] ?? null;
+            finish(new EdgeHttpUpgradeError(statusCode, serverDate));
+        });
+        ws.on("error", (err) => {
+            if (!settled)
+                finish(err);
+        });
+        ws.on("open", () => {
+            const configMessage = `X-Timestamp:${jsDateString()}\r\n` +
+                "Content-Type:application/json; charset=utf-8\r\n" +
+                "Path:speech.config\r\n\r\n" +
+                '{"context":{"synthesis":{"audio":{"metadataoptions":' +
+                '{"sentenceBoundaryEnabled":"true","wordBoundaryEnabled":"false"},' +
+                '"outputFormat":"audio-24khz-48kbitrate-mono-mp3"}}}}';
+            ws.send(configMessage);
+            const ssml = buildSsml(params.voice, params.rate, params.volume, params.pitch, chunk);
+            const ssmlMessage = `X-RequestId:${connectId()}\r\n` +
+                "Content-Type:application/ssml+xml\r\n" +
+                `X-Timestamp:${jsDateString()}Z\r\n` +
+                "Path:ssml\r\n\r\n" +
+                ssml;
+            ws.send(ssmlMessage);
+        });
+        ws.on("message", (data, isBinary) => {
+            if (settled)
+                return;
+            const buf = Buffer.isBuffer(data)
+                ? data
+                : Array.isArray(data)
+                    ? Buffer.concat(data)
+                    : Buffer.from(data);
+            if (isBinary) {
+                if (buf.length < 2) {
+                    finish(new Error("Edge TTS: binary message too short"));
+                    return;
+                }
+                // Binary frames: [2-byte big-endian header length][headers + \r\n][audio].
+                // The length value includes the trailing \r\n terminator, so audio
+                // starts immediately at offset 2 + headerLength.
+                const headerLength = buf.readUInt16BE(0);
+                if (2 + headerLength > buf.length) {
+                    finish(new Error("Edge TTS: binary header length exceeds message"));
+                    return;
+                }
+                const headersBlock = buf.subarray(2, 2 + headerLength).toString("utf-8");
+                if (!headersBlock.includes("Path:audio"))
+                    return;
+                const audioStart = 2 + headerLength;
+                const audio = audioStart < buf.length ? buf.subarray(audioStart) : Buffer.alloc(0);
+                if (audio.length > 0) {
+                    audioChunks.push(audio);
+                    audioReceived = true;
+                }
+                return;
+            }
+            const text = buf.toString("utf-8");
+            const sep = text.indexOf("\r\n\r\n");
+            const headerBlock = sep >= 0 ? text.slice(0, sep) : text;
+            if (!headerBlock.includes("Path:turn.end"))
+                return;
+            if (!audioReceived) {
+                finish(new Error("Edge TTS: no audio received from service"));
+            }
+            else {
+                finish(null, Buffer.concat(audioChunks));
+            }
+        });
+        // A close before turn.end means the turn never completed; partial audio
+        // must not be returned as success.
+        ws.on("close", () => {
+            if (!settled) {
+                finish(new Error("Edge TTS: connection closed before synthesis completed"));
+            }
+        });
+    });
+}
+/**
+ * Synthesizes `text` to an MP3 Buffer using Microsoft Edge's online TTS.
+ * Throws on protocol errors, timeouts, or if no audio is returned. The
+ * timeout bounds the entire synthesis, however many chunks it spans, so the
+ * caller-visible deadline matches the other TTS providers.
+ */
+export async function synthesizeWithEdgeTts(text, options) {
+    const voice = options.voice || EDGE_DEFAULT_VOICE;
+    const rate = options.rate ?? "+0%";
+    const volume = options.volume ?? "+0%";
+    const pitch = options.pitch ?? "+0Hz";
+    const timeoutMs = options.timeoutMs ?? SYNTHESIS_TIMEOUT_MS;
+    const cleaned = removeIncompatibleCharacters(text);
+    const escaped = escapeXml(cleaned);
+    const chunks = splitTextByByteLength(escaped, MAX_CHUNK_BYTES);
+    logger.debug(`[EdgeTTS] Synthesizing: voice=${voice}, chunks=${chunks.length}, chars=${text.length}`);
+    const params = {
+        voice,
+        rate,
+        volume,
+        pitch,
+        deadline: Date.now() + timeoutMs,
+        timeoutMs,
+    };
+    const buffers = [];
+    for (const chunk of chunks) {
+        buffers.push(await synthesizeChunk(chunk, params));
+    }
+    return Buffer.concat(buffers);
+}

package/dist/app/services/stt-service.js

@@ -1,19 +1,35 @@
 import { config } from "../../config.js";
 import { logger } from "../../utils/logger.js";
 const STT_REQUEST_TIMEOUT_MS = 60_000;
+const AUDIO_FORMAT_BY_EXTENSION = {
+    oga: "ogg",
+    ogg: "ogg",
+    mp3: "mp3",
+    wav: "wav",
+    m4a: "m4a",
+    flac: "flac",
+    aac: "aac",
+    webm: "webm",
+};
 /**
  * Returns true if STT is configured (API URL and API key are set).
  */
 export function isSttConfigured() {
     return Boolean(config.stt.apiUrl && config.stt.apiKey);
 }
+function getAudioFormat(filename) {
+    const extension = (filename.split(".").pop() || "").toLowerCase();
+    return AUDIO_FORMAT_BY_EXTENSION[extension] || "ogg";
+}
 /**
- * Transcribes an audio buffer using a Whisper-compatible API (OpenAI / Groq / etc.).
+ * Transcribes an audio buffer using a Whisper-compatible API.
  *
- * Sends a multipart/form-data POST to `{STT_API_URL}/audio/transcriptions`.
+ * Two request formats are supported via `STT_REQUEST_FORMAT`:
+ * - `multipart` (default): standard OpenAI/Groq `multipart/form-data` upload.
+ * - `json`: base64 audio in an `input_audio` JSON body (e.g. OpenRouter).
  *
  * @param audioBuffer - Raw audio file bytes (ogg, mp3, wav, m4a, webm, etc.)
- * @param filename    - Original filename with extension (used by the API to detect format)
+ * @param filename    - Original filename with extension (used to detect format)
  * @returns Transcribed text
  * @throws Error if STT is not configured, the request fails, or the response is invalid
  */
@@ -22,23 +38,44 @@ export async function transcribeAudio(audioBuffer, filename) {
         throw new Error("STT is not configured: STT_API_URL and STT_API_KEY are required");
     }
     const url = `${config.stt.apiUrl}/audio/transcriptions`;
-    const formData = new FormData();
-    formData.append("file", new Blob([new Uint8Array(audioBuffer)]), filename);
-    formData.append("model", config.stt.model);
-    formData.append("response_format", "json");
-    if (config.stt.language) {
-        formData.append("language", config.stt.language);
+    const useJsonFormat = config.stt.requestFormat === "json";
+    const headers = {
+        Authorization: `Bearer ${config.stt.apiKey}`,
+    };
+    let body;
+    if (useJsonFormat) {
+        const payload = {
+            model: config.stt.model,
+            input_audio: {
+                data: Buffer.from(audioBuffer).toString("base64"),
+                format: getAudioFormat(filename),
+            },
+        };
+        if (config.stt.language) {
+            payload.language = config.stt.language;
+        }
+        headers["Content-Type"] = "application/json";
+        body = JSON.stringify(payload);
+        logger.debug(`[STT] Sending transcription request (json): url=${url}, model=${config.stt.model}, format=${getAudioFormat(filename)}, size=${audioBuffer.length} bytes`);
+    }
+    else {
+        const formData = new FormData();
+        formData.append("file", new Blob([new Uint8Array(audioBuffer)]), filename);
+        formData.append("model", config.stt.model);
+        formData.append("response_format", "json");
+        if (config.stt.language) {
+            formData.append("language", config.stt.language);
+        }
+        body = formData;
+        logger.debug(`[STT] Sending transcription request (multipart): url=${url}, model=${config.stt.model}, filename=${filename}, size=${audioBuffer.length} bytes`);
     }
-    logger.debug(`[STT] Sending transcription request: url=${url}, model=${config.stt.model}, filename=${filename}, size=${audioBuffer.length} bytes`);
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), STT_REQUEST_TIMEOUT_MS);
     try {
         const response = await fetch(url, {
             method: "POST",
-            headers: {
-                Authorization: `Bearer ${config.stt.apiKey}`,
-            },
-            body: formData,
+            headers,
+            body,
             signal: controller.signal,
         });
         if (!response.ok) {

package/dist/app/services/tts-service.js

@@ -1,12 +1,16 @@
 import { config } from "../../config.js";
 import { logger } from "../../utils/logger.js";
 import textToSpeech from "@google-cloud/text-to-speech";
+import { synthesizeWithEdgeTts, EDGE_DEFAULT_VOICE } from "./edge-tts.js";
 const TTS_REQUEST_TIMEOUT_MS = 60_000;
 const MAX_TTS_INPUT_CHARS = 4_000;
 export function isTtsConfigured() {
     if (config.tts.provider === "google") {
         return Boolean(process.env.GOOGLE_APPLICATION_CREDENTIALS);
     }
+    if (config.tts.provider === "edge") {
+        return true;
+    }
     return Boolean(config.tts.apiUrl && config.tts.apiKey);
 }
 /**
@@ -141,6 +145,19 @@ async function synthesizeWithElevenLabs(text) {
         clearTimeout(timeout);
     }
 }
+async function synthesizeWithEdge(text) {
+    const voice = config.tts.voice || EDGE_DEFAULT_VOICE;
+    logger.debug(`[TTS] Edge: voice=${voice}, chars=${text.length}`);
+    const buffer = await synthesizeWithEdgeTts(text, {
+        voice,
+        timeoutMs: TTS_REQUEST_TIMEOUT_MS,
+    });
+    if (buffer.length === 0) {
+        throw new Error("Edge TTS returned an empty audio response");
+    }
+    logger.debug(`[TTS] Generated Edge speech audio: ${buffer.length} bytes`);
+    return { buffer, filename: "assistant-reply.mp3", mimeType: "audio/mpeg" };
+}
 // --- Public API ---
 function getNotConfiguredMessage() {
     if (config.tts.provider === "google") {
@@ -149,6 +166,8 @@ function getNotConfiguredMessage() {
     if (config.tts.provider === "elevenlabs") {
         return "TTS is not configured: set TTS_API_URL and TTS_API_KEY for ElevenLabs";
     }
+    // No "edge" branch: isTtsConfigured() is always true for edge, so this
+    // function is unreachable for that provider.
     return "TTS is not configured: set TTS_API_URL and TTS_API_KEY";
 }
 export async function synthesizeSpeech(text) {
@@ -167,6 +186,9 @@ export async function synthesizeSpeech(text) {
         if (config.tts.provider === "elevenlabs") {
             return await synthesizeWithElevenLabs(input);
         }
+        if (config.tts.provider === "edge") {
+            return await synthesizeWithEdge(input);
+        }
         return await synthesizeWithOpenAi(input);
     }
     catch (err) {

package/dist/app/stores/settings-store.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { cloneScheduledTask } from "../types/scheduled-task.js";
+import { config } from "../../config.js";
 import { getRuntimePaths } from "../../runtime/paths.js";
 import { logger } from "../../utils/logger.js";
 function cloneScheduledTasks(tasks) {
@@ -170,6 +171,64 @@ export function __resetSettingsForTests() {
     currentSettings = {};
     settingsWriteQueue = Promise.resolve();
 }
+const VALID_TTS_MODES = ["off", "all", "auto"];
+const VALID_STREAMING_MODES = ["edit", "draft"];
+function applyInitialSettingsPreset(preset) {
+    const knownKeys = new Set([
+        "ttsMode",
+        "compactOutputMode",
+        "showThinkingContent",
+        "showAssistantRunFooter",
+        "responseStreamingMode",
+        "sendDiffFileAttachments",
+    ]);
+    for (const [key, value] of Object.entries(preset)) {
+        if (!knownKeys.has(key)) {
+            throw new Error(`INITIAL_SETTINGS_PRESET: unknown key "${key}". Supported keys: ${[...knownKeys].join(", ")}.`);
+        }
+        if (key === "ttsMode") {
+            if (typeof value !== "string" || !VALID_TTS_MODES.includes(value)) {
+                throw new Error(`INITIAL_SETTINGS_PRESET: invalid value for "ttsMode"; expected one of ${VALID_TTS_MODES.join(", ")}.`);
+            }
+            if (currentSettings.ttsMode === undefined) {
+                currentSettings.ttsMode = value;
+            }
+        }
+        else if (key === "responseStreamingMode") {
+            if (typeof value !== "string" ||
+                !VALID_STREAMING_MODES.includes(value)) {
+                throw new Error(`INITIAL_SETTINGS_PRESET: invalid value for "responseStreamingMode"; expected one of ${VALID_STREAMING_MODES.join(", ")}.`);
+            }
+            if (currentSettings.responseStreamingMode === undefined) {
+                currentSettings.responseStreamingMode = value;
+            }
+        }
+        else {
+            // Boolean settings: compactOutputMode, showThinkingContent, showAssistantRunFooter, sendDiffFileAttachments
+            if (typeof value !== "boolean") {
+                throw new Error(`INITIAL_SETTINGS_PRESET: "${key}" must be a boolean.`);
+            }
+            switch (key) {
+                case "compactOutputMode":
+                    if (currentSettings.compactOutputMode === undefined)
+                        currentSettings.compactOutputMode = value;
+                    break;
+                case "showThinkingContent":
+                    if (currentSettings.showThinkingContent === undefined)
+                        currentSettings.showThinkingContent = value;
+                    break;
+                case "showAssistantRunFooter":
+                    if (currentSettings.showAssistantRunFooter === undefined)
+                        currentSettings.showAssistantRunFooter = value;
+                    break;
+                case "sendDiffFileAttachments":
+                    if (currentSettings.sendDiffFileAttachments === undefined)
+                        currentSettings.sendDiffFileAttachments = value;
+                    break;
+            }
+        }
+    }
+}
 export async function loadSettings() {
     const loadedSettings = (await readSettingsFile());
     let requiresRewrite = false;
@@ -192,6 +251,7 @@ export async function loadSettings() {
     currentSettings.scheduledTasks = cloneScheduledTasks(loadedSettings.scheduledTasks) ?? [];
     currentSettings.scheduledTaskSessionIgnores =
         cloneScheduledTaskSessionIgnores(loadedSettings.scheduledTaskSessionIgnores) ?? [];
+    applyInitialSettingsPreset(config.bot.initialSettingsPreset);
     if (requiresRewrite) {
         void writeSettingsFile(currentSettings);
     }

package/dist/app/types/model.js

@@ -11,7 +11,7 @@ export function formatModelForButton(providerID, modelID) {
     // If model name is too long, we only truncate the model part
     const displayModelId = modelID.length > 20 ? `${modelID.substring(0, 17)}...` : modelID;
     const displayProviderId = providerID.length > 15 ? `${providerID.substring(0, 12)}...` : providerID;
-    return `🤖 ${displayProviderId}\n${displayModelId}`;
+    return `🧠 ${displayProviderId}\n${displayModelId}`;
 }
 /**
  * Format model for display in messages (full format)