yepanywhere 0.6.0 → 0.6.2

package/dist/routes/settings-parsers.js

@@ -0,0 +1,896 @@
+import { ALL_PERMISSION_MODES, ALL_PROVIDERS, HELPER_SIDE_MODEL_CHEAPEST, HELPER_SIDE_MODEL_SAME_AS_MAIN, DEFAULT_CACHE_MISS_BILLING_SETTINGS, PROMPT_CACHE_KEEPALIVE_MODES, PROMPT_SUGGESTION_MODES, RECAP_MODES, clampRecapAfterSeconds, } from "../../bundled/@yep-anywhere/shared/dist/index.js";
+import { normalizeFileAccess, } from "../middleware/file-access.js";
+import { DEFAULT_SERVER_SETTINGS, DEFAULT_SPEECH_AUDIO_RETENTION_MAX_AGE_DAYS, DEFAULT_SPEECH_AUDIO_RETENTION_MAX_BYTES, } from "../services/ServerSettingsService.js";
+import { isValidSshHostAlias, normalizeSshHostAlias, } from "../utils/sshHostAlias.js";
+const HELPER_TARGET_ID_PATTERN = /^[A-Za-z0-9._-]{1,64}$/;
+const MAX_HELPER_TARGETS = 20;
+const HELPER_TARGET_MODEL_DISCOVERY_TIMEOUT_MS = 5000;
+const SESSION_TOOLBAR_PRESENCE_CLIENT_DEFAULT_KEYS = [
+    "modeSelector",
+    "steerNow",
+    "attachments",
+    "slashMenu",
+    "thinkingToggle",
+    "renderMode",
+    "microphone",
+    "waveform",
+    "shortcutsHelp",
+    "contextUsage",
+    "btw",
+    "nudge",
+    "sessionStatus",
+    "projectQueue",
+];
+const TOOLBAR_CONTROL_PRESENCES = [
+    "hidden",
+    "pin",
+    "last",
+    "mid",
+    "first",
+];
+const CLIENT_DEFAULT_KEYS = [
+    "speech",
+    "busyComposerDefaultAction",
+    "collapsedComposerButton",
+    "sessionToolbarPresence",
+    "steerNowDefault",
+    "patientQueueDefault",
+    "projectQueueCtrlEnterEnabled",
+    "compactAtContextPercent",
+];
+const BUSY_COMPOSER_DEFAULT_ACTIONS = [
+    "steer",
+    "queue",
+];
+const COLLAPSED_COMPOSER_BUTTON_PREFERENCES = [
+    "primary",
+    "alternate",
+    "microphone",
+];
+const SPEECH_CLIENT_DEFAULT_KEYS = [
+    "voiceInputEnabled",
+    "speechMethod",
+    "speechSmartTurnSettings",
+    "grokSpeechAudioSettings",
+];
+const THINKING_MODES = [
+    "off",
+    "auto",
+    "on",
+];
+const EFFORT_LEVELS = [
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+const MAX_SPEECH_SMART_TURN_TIMEOUT_MS = 10000;
+export function parseHostAliasList(rawHosts) {
+    const hosts = [];
+    for (const rawHost of rawHosts) {
+        if (typeof rawHost !== "string")
+            continue;
+        const host = normalizeSshHostAlias(rawHost);
+        if (!host)
+            continue;
+        if (!isValidSshHostAlias(host)) {
+            return { hosts: [], invalidHost: host };
+        }
+        hosts.push(host);
+    }
+    return { hosts };
+}
+export function normalizeOpenAiCompatibleBaseUrl(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)
+        ? trimmed
+        : `http://${trimmed}`;
+    try {
+        const url = new URL(withScheme);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            return null;
+        if (url.pathname === "" || url.pathname === "/") {
+            url.pathname = "/v1";
+        }
+        const normalized = url.toString();
+        return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Returns:
+ * - `null` when the payload is invalid
+ * - `undefined` when the setting should be cleared
+ * - an array when valid helper targets should be saved
+ */
+export function parseHelperTargets(raw) {
+    if (raw === undefined)
+        return null;
+    if (raw === null || raw === "")
+        return undefined;
+    if (!Array.isArray(raw) || raw.length > MAX_HELPER_TARGETS)
+        return null;
+    const seenIds = new Set();
+    const parsed = [];
+    for (const entry of raw) {
+        if (!entry || typeof entry !== "object")
+            return null;
+        const input = entry;
+        const id = typeof input.id === "string" ? input.id.trim() : "";
+        const name = typeof input.name === "string" ? input.name.trim() : "";
+        const baseUrl = normalizeOpenAiCompatibleBaseUrl(input.baseUrl);
+        const model = typeof input.model === "string" ? input.model.trim() : "";
+        if (!HELPER_TARGET_ID_PATTERN.test(id) ||
+            seenIds.has(id) ||
+            !name ||
+            name.length > 80 ||
+            input.kind !== "openai-compatible" ||
+            !baseUrl ||
+            model.length > 200) {
+            return null;
+        }
+        seenIds.add(id);
+        parsed.push({
+            id,
+            name,
+            kind: "openai-compatible",
+            baseUrl,
+            ...(model ? { model } : {}),
+        });
+    }
+    return parsed;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function parseOptionalString(value, maxLength) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (typeof value !== "string")
+        return null;
+    return value.length > 0 ? value.slice(0, maxLength) : undefined;
+}
+function parseProviderSessionDefaults(raw) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    if (!isRecord(raw))
+        return null;
+    const parsed = {};
+    if ("model" in raw) {
+        const model = parseOptionalString(raw.model, 200);
+        if (model === null)
+            return null;
+        if (model)
+            parsed.model = model;
+    }
+    if ("serviceTier" in raw) {
+        const serviceTier = parseOptionalString(raw.serviceTier, 64);
+        if (serviceTier === null)
+            return null;
+        if (serviceTier)
+            parsed.serviceTier = serviceTier;
+    }
+    if ("thinkingMode" in raw) {
+        if (raw.thinkingMode !== undefined &&
+            raw.thinkingMode !== null &&
+            raw.thinkingMode !== "" &&
+            !THINKING_MODES.includes(raw.thinkingMode)) {
+            return null;
+        }
+        if (typeof raw.thinkingMode === "string" && raw.thinkingMode.length > 0) {
+            parsed.thinkingMode = raw.thinkingMode;
+        }
+    }
+    if ("effortLevel" in raw) {
+        if (raw.effortLevel !== undefined &&
+            raw.effortLevel !== null &&
+            raw.effortLevel !== "" &&
+            !EFFORT_LEVELS.includes(raw.effortLevel)) {
+            return null;
+        }
+        if (typeof raw.effortLevel === "string" && raw.effortLevel.length > 0) {
+            parsed.effortLevel = raw.effortLevel;
+        }
+    }
+    if ("helperSideModel" in raw) {
+        const helperSideModel = parseOptionalString(raw.helperSideModel, 200);
+        if (helperSideModel === null)
+            return null;
+        if (helperSideModel) {
+            parsed.helperSideModel =
+                helperSideModel === HELPER_SIDE_MODEL_SAME_AS_MAIN
+                    ? HELPER_SIDE_MODEL_SAME_AS_MAIN
+                    : helperSideModel === HELPER_SIDE_MODEL_CHEAPEST
+                        ? HELPER_SIDE_MODEL_CHEAPEST
+                        : helperSideModel;
+        }
+    }
+    return Object.keys(parsed).length > 0 ? parsed : undefined;
+}
+const MAX_FILE_ACCESS_CUSTOM_ENTRIES = 100;
+const MAX_FILE_ACCESS_CUSTOM_LENGTH = 1024;
+/**
+ * Returns:
+ * - `null` when the payload is invalid
+ * - `undefined` when the setting should be cleared (reset to secure defaults)
+ * - a normalized object when valid
+ */
+export function parseFileAccess(raw) {
+    if (raw === undefined)
+        return null;
+    if (raw === null || raw === "")
+        return undefined;
+    if (!isRecord(raw))
+        return null;
+    const allowedKeys = new Set([
+        "projects",
+        "uploads",
+        "temp",
+        "home",
+        "custom",
+    ]);
+    for (const key of Object.keys(raw)) {
+        if (!allowedKeys.has(key))
+            return null;
+    }
+    for (const key of ["projects", "uploads", "temp", "home"]) {
+        if (key in raw && typeof raw[key] !== "boolean")
+            return null;
+    }
+    if ("custom" in raw) {
+        if (!Array.isArray(raw.custom) ||
+            raw.custom.length > MAX_FILE_ACCESS_CUSTOM_ENTRIES) {
+            return null;
+        }
+        for (const entry of raw.custom) {
+            if (typeof entry !== "string" ||
+                entry.length > MAX_FILE_ACCESS_CUSTOM_LENGTH) {
+                return null;
+            }
+        }
+    }
+    return normalizeFileAccess({
+        projects: raw.projects,
+        uploads: raw.uploads,
+        temp: raw.temp,
+        home: raw.home,
+        custom: raw.custom ?? [],
+    });
+}
+function parseOpenAiModelsResponse(raw) {
+    if (!isRecord(raw) || !Array.isArray(raw.data))
+        return null;
+    const models = [];
+    for (const entry of raw.data) {
+        if (!isRecord(entry) || typeof entry.id !== "string" || !entry.id.trim()) {
+            continue;
+        }
+        const metadata = isRecord(entry.metadata) ? entry.metadata : undefined;
+        const rawContextWindow = typeof entry.max_model_len === "number"
+            ? entry.max_model_len
+            : typeof entry.maxModelLen === "number"
+                ? entry.maxModelLen
+                : typeof metadata?.max_model_len === "number"
+                    ? metadata.max_model_len
+                    : undefined;
+        const contextWindow = rawContextWindow !== undefined && Number.isFinite(rawContextWindow)
+            ? rawContextWindow
+            : undefined;
+        models.push({
+            id: entry.id,
+            name: entry.id,
+            ...(contextWindow ? { contextWindow } : {}),
+        });
+    }
+    return models;
+}
+export function parseAgentContextHints(raw, current) {
+    if (raw === undefined || raw === null)
+        return {};
+    if (!isRecord(raw))
+        return null;
+    const parsed = { ...current };
+    if ("latexMathRendering" in raw) {
+        if (typeof raw.latexMathRendering !== "boolean")
+            return null;
+        parsed.latexMathRendering = raw.latexMathRendering;
+    }
+    return parsed;
+}
+export async function discoverOpenAiCompatibleModels(baseUrl) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), HELPER_TARGET_MODEL_DISCOVERY_TIMEOUT_MS);
+    try {
+        const response = await fetch(`${baseUrl}/models`, {
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return null;
+        return parseOpenAiModelsResponse(await response.json());
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Returns:
+ * - `null` when the payload is invalid
+ * - `undefined` when the setting should be cleared
+ * - an object when valid defaults should be saved
+ */
+export function parseNewSessionDefaults(raw) {
+    if (raw === undefined)
+        return null;
+    if (raw === null || raw === "")
+        return undefined;
+    if (typeof raw !== "object")
+        return null;
+    const input = raw;
+    const parsed = {};
+    if ("provider" in input) {
+        if (input.provider !== undefined &&
+            input.provider !== null &&
+            input.provider !== "" &&
+            !ALL_PROVIDERS.includes(input.provider)) {
+            return null;
+        }
+        if (typeof input.provider === "string" && input.provider.length > 0) {
+            parsed.provider = input.provider;
+        }
+    }
+    if ("model" in input) {
+        const model = parseOptionalString(input.model, 200);
+        if (model === null)
+            return null;
+        if (model)
+            parsed.model = model;
+    }
+    if ("serviceTier" in input) {
+        const serviceTier = parseOptionalString(input.serviceTier, 64);
+        if (serviceTier === null)
+            return null;
+        if (serviceTier)
+            parsed.serviceTier = serviceTier;
+    }
+    if ("permissionMode" in input) {
+        if (input.permissionMode !== undefined &&
+            input.permissionMode !== null &&
+            input.permissionMode !== "" &&
+            !ALL_PERMISSION_MODES.includes(input.permissionMode)) {
+            return null;
+        }
+        if (typeof input.permissionMode === "string" &&
+            input.permissionMode.length > 0) {
+            parsed.permissionMode = input.permissionMode;
+        }
+    }
+    if ("recapMode" in input) {
+        if (input.recapMode !== undefined &&
+            input.recapMode !== null &&
+            input.recapMode !== "" &&
+            !RECAP_MODES.includes(input.recapMode)) {
+            return null;
+        }
+        if (typeof input.recapMode === "string" && input.recapMode.length > 0) {
+            parsed.recapMode = input.recapMode;
+        }
+    }
+    if ("recapAfterSeconds" in input) {
+        if (input.recapAfterSeconds !== undefined &&
+            input.recapAfterSeconds !== null &&
+            input.recapAfterSeconds !== "" &&
+            (typeof input.recapAfterSeconds !== "number" ||
+                !Number.isFinite(input.recapAfterSeconds))) {
+            return null;
+        }
+        if (typeof input.recapAfterSeconds === "number" &&
+            Number.isFinite(input.recapAfterSeconds)) {
+            parsed.recapAfterSeconds = clampRecapAfterSeconds(input.recapAfterSeconds);
+        }
+    }
+    if ("promptSuggestionMode" in input) {
+        if (input.promptSuggestionMode !== undefined &&
+            input.promptSuggestionMode !== null &&
+            input.promptSuggestionMode !== "" &&
+            !PROMPT_SUGGESTION_MODES.includes(input.promptSuggestionMode)) {
+            return null;
+        }
+        if (typeof input.promptSuggestionMode === "string" &&
+            input.promptSuggestionMode.length > 0) {
+            parsed.promptSuggestionMode =
+                input.promptSuggestionMode;
+        }
+    }
+    if ("providers" in input) {
+        if (input.providers !== undefined &&
+            input.providers !== null &&
+            input.providers !== "" &&
+            !isRecord(input.providers)) {
+            return null;
+        }
+        if (isRecord(input.providers)) {
+            const providers = {};
+            for (const [providerName, rawDefaults] of Object.entries(input.providers)) {
+                if (!ALL_PROVIDERS.includes(providerName)) {
+                    return null;
+                }
+                const parsedProviderDefaults = parseProviderSessionDefaults(rawDefaults);
+                if (parsedProviderDefaults === null)
+                    return null;
+                if (parsedProviderDefaults) {
+                    providers[providerName] = parsedProviderDefaults;
+                }
+            }
+            if (Object.keys(providers).length > 0) {
+                parsed.providers = providers;
+            }
+        }
+    }
+    return Object.keys(parsed).length > 0 ? parsed : undefined;
+}
+function parseSpeechSmartTurnClientDefault(raw) {
+    if (!isRecord(raw))
+        return null;
+    if (typeof raw.enabled !== "boolean" ||
+        typeof raw.threshold !== "number" ||
+        typeof raw.timeoutMs !== "number" ||
+        !Number.isFinite(raw.threshold) ||
+        !Number.isFinite(raw.timeoutMs) ||
+        raw.threshold < 0 ||
+        raw.threshold > 1 ||
+        raw.timeoutMs < 0 ||
+        raw.timeoutMs > MAX_SPEECH_SMART_TURN_TIMEOUT_MS) {
+        return null;
+    }
+    return {
+        enabled: raw.enabled,
+        threshold: raw.threshold,
+        timeoutMs: Math.round(raw.timeoutMs),
+    };
+}
+function parseGrokSpeechAudioClientDefault(raw) {
+    if (!isRecord(raw))
+        return null;
+    if (raw.uplinkMode !== "pcm16" && raw.uplinkMode !== "browser-compressed") {
+        return null;
+    }
+    return { uplinkMode: raw.uplinkMode };
+}
+function parseSessionToolbarPresenceClientDefaults(raw) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    if (!isRecord(raw))
+        return null;
+    const allowedKeys = new Set(SESSION_TOOLBAR_PRESENCE_CLIENT_DEFAULT_KEYS);
+    for (const key of Object.keys(raw)) {
+        if (!allowedKeys.has(key))
+            return null;
+    }
+    const allowedPresences = new Set(TOOLBAR_CONTROL_PRESENCES);
+    const parsed = {};
+    for (const key of SESSION_TOOLBAR_PRESENCE_CLIENT_DEFAULT_KEYS) {
+        if (!(key in raw))
+            continue;
+        const value = raw[key];
+        if (typeof value !== "string" || !allowedPresences.has(value))
+            return null;
+        parsed[key] = value;
+    }
+    return Object.keys(parsed).length > 0 ? parsed : null;
+}
+// Per-model compaction thresholds: each value is "compact at X% of that
+// model's context window". Reject non-numbers (the slider only ever sends
+// numbers), but treat out-of-range like the load path does — keep 1–99 and
+// drop anything else (including >= 100 = "off"). An empty result clears the
+// setting. The returned map is authoritative: the client always sends the
+// full map, so mergeClientDefaults replaces rather than per-model merges,
+// which is what makes turning a model "off" (dropping its key) take effect.
+function parseCompactAtContextPercent(raw) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    if (!isRecord(raw))
+        return null;
+    const cleaned = {};
+    for (const [modelId, value] of Object.entries(raw)) {
+        if (typeof value !== "number" || !Number.isFinite(value))
+            return null;
+        const pct = Math.round(value);
+        if (pct > 0 && pct < 100)
+            cleaned[modelId] = pct;
+    }
+    return Object.keys(cleaned).length > 0 ? cleaned : undefined;
+}
+export function parseClientDefaults(raw) {
+    if (raw === undefined)
+        return null;
+    if (raw === null || raw === "")
+        return undefined;
+    if (!isRecord(raw))
+        return null;
+    const allowedKeys = new Set(CLIENT_DEFAULT_KEYS);
+    for (const key of Object.keys(raw)) {
+        if (!allowedKeys.has(key))
+            return null;
+    }
+    if (Object.keys(raw).length === 0)
+        return null;
+    const parsed = {};
+    if ("speech" in raw) {
+        if (raw.speech === undefined || raw.speech === null || raw.speech === "") {
+            parsed.speech = undefined;
+        }
+        else if (!isRecord(raw.speech)) {
+            return null;
+        }
+        else {
+            const allowedSpeechKeys = new Set(SPEECH_CLIENT_DEFAULT_KEYS);
+            for (const key of Object.keys(raw.speech)) {
+                if (!allowedSpeechKeys.has(key))
+                    return null;
+            }
+            const speech = {};
+            if ("voiceInputEnabled" in raw.speech) {
+                if (typeof raw.speech.voiceInputEnabled !== "boolean")
+                    return null;
+                speech.voiceInputEnabled = raw.speech.voiceInputEnabled;
+            }
+            if ("speechMethod" in raw.speech) {
+                if (typeof raw.speech.speechMethod !== "string" ||
+                    raw.speech.speechMethod.trim().length === 0) {
+                    return null;
+                }
+                speech.speechMethod = raw.speech.speechMethod.trim().slice(0, 120);
+            }
+            if ("speechSmartTurnSettings" in raw.speech) {
+                const parsedSmartTurn = parseSpeechSmartTurnClientDefault(raw.speech.speechSmartTurnSettings);
+                if (!parsedSmartTurn)
+                    return null;
+                speech.speechSmartTurnSettings = parsedSmartTurn;
+            }
+            if ("grokSpeechAudioSettings" in raw.speech) {
+                const parsedGrokAudio = parseGrokSpeechAudioClientDefault(raw.speech.grokSpeechAudioSettings);
+                if (!parsedGrokAudio)
+                    return null;
+                speech.grokSpeechAudioSettings = parsedGrokAudio;
+            }
+            if (Object.keys(speech).length === 0)
+                return null;
+            parsed.speech = speech;
+        }
+    }
+    if ("busyComposerDefaultAction" in raw) {
+        if (raw.busyComposerDefaultAction === undefined ||
+            raw.busyComposerDefaultAction === null) {
+            parsed.busyComposerDefaultAction = undefined;
+        }
+        else if (!BUSY_COMPOSER_DEFAULT_ACTIONS.includes(raw.busyComposerDefaultAction)) {
+            return null;
+        }
+        else {
+            parsed.busyComposerDefaultAction =
+                raw.busyComposerDefaultAction;
+        }
+    }
+    if ("collapsedComposerButton" in raw) {
+        if (raw.collapsedComposerButton === undefined ||
+            raw.collapsedComposerButton === null) {
+            parsed.collapsedComposerButton = undefined;
+        }
+        else if (!COLLAPSED_COMPOSER_BUTTON_PREFERENCES.includes(raw.collapsedComposerButton)) {
+            return null;
+        }
+        else {
+            parsed.collapsedComposerButton =
+                raw.collapsedComposerButton;
+        }
+    }
+    if ("steerNowDefault" in raw) {
+        if (raw.steerNowDefault === undefined || raw.steerNowDefault === null) {
+            parsed.steerNowDefault = undefined;
+        }
+        else if (typeof raw.steerNowDefault !== "boolean") {
+            return null;
+        }
+        else {
+            parsed.steerNowDefault = raw.steerNowDefault;
+        }
+    }
+    if ("patientQueueDefault" in raw) {
+        if (raw.patientQueueDefault === undefined ||
+            raw.patientQueueDefault === null) {
+            parsed.patientQueueDefault = undefined;
+        }
+        else if (typeof raw.patientQueueDefault !== "boolean") {
+            return null;
+        }
+        else {
+            parsed.patientQueueDefault = raw.patientQueueDefault;
+        }
+    }
+    if ("projectQueueCtrlEnterEnabled" in raw) {
+        if (raw.projectQueueCtrlEnterEnabled === undefined ||
+            raw.projectQueueCtrlEnterEnabled === null) {
+            parsed.projectQueueCtrlEnterEnabled = undefined;
+        }
+        else if (typeof raw.projectQueueCtrlEnterEnabled !== "boolean") {
+            return null;
+        }
+        else {
+            parsed.projectQueueCtrlEnterEnabled = raw.projectQueueCtrlEnterEnabled;
+        }
+    }
+    if ("sessionToolbarPresence" in raw) {
+        const parsedPresence = parseSessionToolbarPresenceClientDefaults(raw.sessionToolbarPresence);
+        if (parsedPresence === null)
+            return null;
+        parsed.sessionToolbarPresence = parsedPresence;
+    }
+    if ("compactAtContextPercent" in raw) {
+        const parsedCompact = parseCompactAtContextPercent(raw.compactAtContextPercent);
+        if (parsedCompact === null)
+            return null;
+        parsed.compactAtContextPercent = parsedCompact;
+    }
+    return Object.keys(parsed).length > 0 ? parsed : undefined;
+}
+export function mergeClientDefaults(current, update) {
+    if (!update)
+        return undefined;
+    const merged = { ...current };
+    if ("speech" in update) {
+        if (update.speech === undefined) {
+            delete merged.speech;
+        }
+        else {
+            merged.speech = {
+                ...current?.speech,
+                ...update.speech,
+            };
+        }
+    }
+    if ("busyComposerDefaultAction" in update) {
+        if (update.busyComposerDefaultAction === undefined) {
+            delete merged.busyComposerDefaultAction;
+        }
+        else {
+            merged.busyComposerDefaultAction = update.busyComposerDefaultAction;
+        }
+    }
+    if ("collapsedComposerButton" in update) {
+        if (update.collapsedComposerButton === undefined) {
+            delete merged.collapsedComposerButton;
+        }
+        else {
+            merged.collapsedComposerButton = update.collapsedComposerButton;
+        }
+    }
+    if ("steerNowDefault" in update) {
+        if (update.steerNowDefault === undefined) {
+            delete merged.steerNowDefault;
+        }
+        else {
+            merged.steerNowDefault = update.steerNowDefault;
+        }
+    }
+    if ("patientQueueDefault" in update) {
+        if (update.patientQueueDefault === undefined) {
+            delete merged.patientQueueDefault;
+        }
+        else {
+            merged.patientQueueDefault = update.patientQueueDefault;
+        }
+    }
+    if ("projectQueueCtrlEnterEnabled" in update) {
+        if (update.projectQueueCtrlEnterEnabled === undefined) {
+            delete merged.projectQueueCtrlEnterEnabled;
+        }
+        else {
+            merged.projectQueueCtrlEnterEnabled = update.projectQueueCtrlEnterEnabled;
+        }
+    }
+    if ("sessionToolbarPresence" in update) {
+        if (update.sessionToolbarPresence === undefined) {
+            delete merged.sessionToolbarPresence;
+        }
+        else {
+            merged.sessionToolbarPresence = {
+                ...current?.sessionToolbarPresence,
+                ...update.sessionToolbarPresence,
+            };
+        }
+    }
+    if ("compactAtContextPercent" in update) {
+        // Replace the whole map (not a per-model merge): the client always sends
+        // the complete map, so a model dropped from it means "off" for that model.
+        if (update.compactAtContextPercent === undefined) {
+            delete merged.compactAtContextPercent;
+        }
+        else {
+            merged.compactAtContextPercent = update.compactAtContextPercent;
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+export function parseSpeechAudioRetention(raw) {
+    if (raw === undefined || raw === null) {
+        return DEFAULT_SERVER_SETTINGS.speechAudioRetention;
+    }
+    if (!isRecord(raw))
+        return null;
+    const enabled = typeof raw.enabled === "boolean"
+        ? raw.enabled
+        : DEFAULT_SERVER_SETTINGS.speechAudioRetention.enabled;
+    const maxAgeDays = raw.maxAgeDays === undefined || raw.maxAgeDays === null
+        ? DEFAULT_SPEECH_AUDIO_RETENTION_MAX_AGE_DAYS
+        : raw.maxAgeDays;
+    const maxBytes = raw.maxBytes === undefined || raw.maxBytes === null
+        ? DEFAULT_SPEECH_AUDIO_RETENTION_MAX_BYTES
+        : raw.maxBytes;
+    if (typeof maxAgeDays !== "number" ||
+        !Number.isInteger(maxAgeDays) ||
+        maxAgeDays < 1 ||
+        maxAgeDays > 3650) {
+        return null;
+    }
+    if (typeof maxBytes !== "number" ||
+        !Number.isInteger(maxBytes) ||
+        maxBytes < 1024 * 1024 ||
+        maxBytes > 100 * 1024 * 1024 * 1024) {
+        return null;
+    }
+    return { enabled, maxAgeDays, maxBytes };
+}
+export function parsePromptCacheKeepalive(raw) {
+    if (raw === undefined)
+        return null;
+    if (raw === null || raw === "")
+        return undefined;
+    if (!isRecord(raw))
+        return null;
+    const rawProviders = raw.providers;
+    if (rawProviders === undefined || rawProviders === null)
+        return {};
+    if (!isRecord(rawProviders))
+        return null;
+    const providers = {};
+    for (const [providerName, rawProviderSetting] of Object.entries(rawProviders)) {
+        if (!ALL_PROVIDERS.includes(providerName))
+            return null;
+        if (rawProviderSetting === undefined || rawProviderSetting === null) {
+            continue;
+        }
+        if (!isRecord(rawProviderSetting))
+            return null;
+        const setting = {};
+        if ("mode" in rawProviderSetting) {
+            if (typeof rawProviderSetting.mode !== "string" ||
+                !PROMPT_CACHE_KEEPALIVE_MODES.includes(rawProviderSetting.mode)) {
+                return null;
+            }
+            setting.mode = rawProviderSetting.mode;
+        }
+        if ("inactivityMinutes" in rawProviderSetting) {
+            const value = rawProviderSetting.inactivityMinutes;
+            if (typeof value !== "number" ||
+                !Number.isInteger(value) ||
+                value < 1 ||
+                value > 1440) {
+                return null;
+            }
+            setting.inactivityMinutes = value;
+        }
+        if (Object.keys(setting).length > 0) {
+            providers[providerName] = setting;
+        }
+    }
+    return { providers };
+}
+export function parseCacheMissBilling(raw) {
+    if (raw === undefined)
+        return null;
+    if (raw === null || raw === "")
+        return DEFAULT_CACHE_MISS_BILLING_SETTINGS;
+    if (!isRecord(raw))
+        return null;
+    const parsed = {};
+    if ("enabled" in raw) {
+        if (raw.enabled === undefined || raw.enabled === null) {
+            parsed.enabled = DEFAULT_CACHE_MISS_BILLING_SETTINGS.enabled;
+        }
+        else if (typeof raw.enabled !== "boolean") {
+            return null;
+        }
+        else {
+            parsed.enabled = raw.enabled;
+        }
+    }
+    if ("showToasts" in raw) {
+        if (raw.showToasts === undefined || raw.showToasts === null) {
+            parsed.showToasts = DEFAULT_CACHE_MISS_BILLING_SETTINGS.showToasts;
+        }
+        else if (typeof raw.showToasts !== "boolean") {
+            return null;
+        }
+        else {
+            parsed.showToasts = raw.showToasts;
+        }
+    }
+    if ("freshWindowMinutes" in raw) {
+        if (raw.freshWindowMinutes === undefined ||
+            raw.freshWindowMinutes === null) {
+            parsed.freshWindowMinutes =
+                DEFAULT_CACHE_MISS_BILLING_SETTINGS.freshWindowMinutes;
+        }
+        else if (typeof raw.freshWindowMinutes !== "number" ||
+            !Number.isInteger(raw.freshWindowMinutes) ||
+            raw.freshWindowMinutes < 1 ||
+            raw.freshWindowMinutes > 1440) {
+            return null;
+        }
+        else {
+            parsed.freshWindowMinutes = raw.freshWindowMinutes;
+        }
+    }
+    if ("providerFreshWindowMinutes" in raw) {
+        if (raw.providerFreshWindowMinutes === undefined ||
+            raw.providerFreshWindowMinutes === null) {
+            parsed.providerFreshWindowMinutes =
+                DEFAULT_CACHE_MISS_BILLING_SETTINGS.providerFreshWindowMinutes;
+        }
+        else if (!isRecord(raw.providerFreshWindowMinutes)) {
+            return null;
+        }
+        else {
+            const providerFreshWindowMinutes = {};
+            for (const [providerName, value] of Object.entries(raw.providerFreshWindowMinutes)) {
+                if (!ALL_PROVIDERS.includes(providerName)) {
+                    return null;
+                }
+                if (typeof value !== "number" ||
+                    !Number.isInteger(value) ||
+                    value < 1 ||
+                    value > 1440) {
+                    return null;
+                }
+                providerFreshWindowMinutes[providerName] = value;
+            }
+            parsed.providerFreshWindowMinutes = providerFreshWindowMinutes;
+        }
+    }
+    if ("minimumInputTokens" in raw) {
+        if (raw.minimumInputTokens === undefined ||
+            raw.minimumInputTokens === null) {
+            parsed.minimumInputTokens =
+                DEFAULT_CACHE_MISS_BILLING_SETTINGS.minimumInputTokens;
+        }
+        else if (typeof raw.minimumInputTokens !== "number" ||
+            !Number.isInteger(raw.minimumInputTokens) ||
+            raw.minimumInputTokens < 1 ||
+            raw.minimumInputTokens > 5_000_000) {
+            return null;
+        }
+        else {
+            parsed.minimumInputTokens = raw.minimumInputTokens;
+        }
+    }
+    const result = {
+        ...DEFAULT_CACHE_MISS_BILLING_SETTINGS,
+        ...parsed,
+        providerFreshWindowMinutes: {
+            ...DEFAULT_CACHE_MISS_BILLING_SETTINGS.providerFreshWindowMinutes,
+            ...parsed.providerFreshWindowMinutes,
+        },
+    };
+    return result;
+}
+//# sourceMappingURL=settings-parsers.js.map