vanspod 0.0.0-stage → 0.1.2

package/dist/routeFiles.js

@@ -0,0 +1,646 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VS_CODE_ENV = void 0;
+exports.anthropicBaseValues = anthropicBaseValues;
+exports.createRouteFiles = createRouteFiles;
+const node_util_1 = require("node:util");
+const clientSettingsBackup_1 = require("./clientSettingsBackup");
+const node_child_process_1 = require("node:child_process");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.VS_CODE_ENV = "claudeCode.environmentVariables";
+function anthropicBaseValues(env) {
+    if (Array.isArray(env)) {
+        return env
+            .filter(isAnthropicBaseEntry)
+            .map((entry) => entry.value);
+    }
+    if (env && typeof env === "object") {
+        return [env.ANTHROPIC_BASE_URL];
+    }
+    return [];
+}
+function withoutVsCodeBaseUrl(doc) {
+    const env = doc[exports.VS_CODE_ENV];
+    if (Array.isArray(env)) {
+        return {
+            ...doc,
+            [exports.VS_CODE_ENV]: env.filter((entry) => !isAnthropicBaseEntry(entry)),
+        };
+    }
+    if (env && typeof env === "object") {
+        return {
+            ...doc,
+            [exports.VS_CODE_ENV]: withoutEnvKey(env, "ANTHROPIC_BASE_URL"),
+        };
+    }
+    return { ...doc };
+}
+function isAnthropicBaseEntry(entry) {
+    return (!!entry &&
+        typeof entry === "object" &&
+        entry.name === "ANTHROPIC_BASE_URL");
+}
+function withoutManagedVsCodeBaseUrl(doc, proxy) {
+    const env = doc[exports.VS_CODE_ENV];
+    if (!Array.isArray(env))
+        return withoutVsCodeBaseUrl(doc);
+    return { ...doc, [exports.VS_CODE_ENV]: env.filter(entry => !isAnthropicBaseEntry(entry) || !isManagedUrl(entry.value, proxy)) };
+}
+function withoutEnvKey(doc, key) {
+    const next = { ...doc };
+    delete next[key];
+    return next;
+}
+function createRouteFiles(paths) {
+    const codexBackup = (0, clientSettingsBackup_1.clientSettingsBackup)(node_path_1.default.join(node_path_1.default.dirname(paths.codex), "classroom-codex-settings-backup.json"), {
+        config: { file: paths.codex, restore: restoreTomlFields },
+        cache: { file: node_path_1.default.join(node_path_1.default.dirname(paths.codex), "models_cache.json"), restore: current => current },
+        catalog: { file: node_path_1.default.join(node_path_1.default.dirname(paths.codex), "classroom-catalog.json"), restore: current => current },
+    });
+    // Read-only compatibility journal. New writes use the route-specific journals below.
+    const legacyClaudeBackup = (0, clientSettingsBackup_1.clientSettingsBackup)(node_path_1.default.join(node_path_1.default.dirname(paths.claude), "classroom-claude-settings-backup.json"), {
+        config: { file: paths.claude, restore: restoreJsonFields },
+        vscode: { file: paths.vsCode, restore: restoreJsonFields },
+        gateway: { file: gatewayCachePath(paths.claude), restore: current => current },
+    });
+    const claudeCodeBackup = (0, clientSettingsBackup_1.clientSettingsBackup)(node_path_1.default.join(node_path_1.default.dirname(paths.claude), "classroom-claude-code-settings-backup.json"), {
+        config: { file: paths.claude, restore: restoreJsonFields },
+    });
+    async function migrateLegacyRouteState(proxy, clients) {
+        // ADR-0005 wrote one Claude/VS Code journal. Restore it before the routes split;
+        // this journal is never used for a new write.
+        const legacyResources = [
+            ...(clients.claude ? ["config", "gateway"] : []),
+            ...(clients.vsCodeChat ? ["vscode"] : []),
+        ];
+        if (legacyResources.length)
+            await legacyClaudeBackup.restore(legacyResources);
+        const saved = clients.codex || clients.claude ? await readDiskBackup(paths) : undefined;
+        const route = clients.codex
+            ? await (0, clientSettingsBackup_1.optionalText)(node_path_1.default.join(node_path_1.default.dirname(paths.codex), "classroom-codex-route-backup.json"))
+            : null;
+        if (clients.codex && (saved && (saved.clients?.codex ?? true) || route !== null)) {
+            let original = await readText(paths.codex);
+            const keys = [];
+            if (saved && (saved.clients?.codex ?? true)) {
+                if (readRootTomlString(original, "model")?.startsWith("VCRouter/")) {
+                    original = setTomlField(original, "model", saved.codexModel);
+                    keys.push("model");
+                }
+                if (readRootTomlString(original, "model_catalog_json") === node_path_1.default.join(node_path_1.default.dirname(paths.codex), "classroom-catalog.json")) {
+                    original = setTomlField(original, "model_catalog_json", saved.catalogPath);
+                    keys.push("model_catalog_json");
+                }
+                const cache = parseJsonObject(await readText(node_path_1.default.join(node_path_1.default.dirname(paths.codex), "models_cache.json")));
+                if (Array.isArray(cache?.models) && cache.models.length && cache.models.every(value => String(asRecord(value)?.slug).startsWith("VCRouter/")))
+                    await codexBackup.seed("cache", saved.modelsCache ?? null, []);
+            }
+            if (route !== null) {
+                const value = JSON.parse(route).baseUrl;
+                if (value !== null && typeof value !== "string")
+                    throw new Error("Invalid Codex route backup");
+                if (isManagedUrl(readRootTomlString(original, "openai_base_url"), proxy)) {
+                    original = setTomlField(original, "openai_base_url", isManagedUrl(value, proxy) ? undefined : value ?? undefined);
+                    keys.push("openai_base_url");
+                }
+            }
+            await codexBackup.seed("config", original, keys);
+        }
+        if (clients.claude && saved && (saved.clients?.claude ?? true)) {
+            const current = await readText(paths.claude);
+            const doc = parseJsonObject(current);
+            if (!doc)
+                throw new Error("Invalid Claude settings");
+            const gateway = parseJsonObject(await readText(gatewayCachePath(paths.claude)));
+            const keys = [];
+            if (isManagedUrl(asRecord(doc.env)?.ANTHROPIC_BASE_URL, proxy))
+                keys.push("env.ANTHROPIC_BASE_URL");
+            if (isManagedUrl(doc.ANTHROPIC_BASE_URL, proxy))
+                keys.push("ANTHROPIC_BASE_URL");
+            if (isManagedUrl(gateway?.baseUrl, proxy)) {
+                if (Array.isArray(gateway?.models) && gateway.models.some(value => asRecord(value)?.id === doc.model))
+                    keys.push("model");
+                if (typeof saved.gateway === "string") {
+                    await writeText(gatewayCachePath(paths.claude), saved.gateway);
+                }
+                else {
+                    await promises_1.default.rm(gatewayCachePath(paths.claude), { force: true });
+                }
+            }
+            const original = restoreJsonFields(current, personalClaudeText(saved.claudeFile ?? "", proxy), current, keys);
+            await claudeCodeBackup.seed("config", original, keys);
+        }
+        // New durable journals exist before obsolete backup files are removed.
+        const savedCodexPending = !!saved && (saved.clients?.codex ?? true) && !clients.codex;
+        const savedClaudePending = !!saved && (saved.clients?.claude ?? true) && !clients.claude;
+        if (saved && !savedCodexPending && !savedClaudePending)
+            await promises_1.default.rm(backupFile(paths), { force: true });
+        if (clients.codex && route !== null)
+            await promises_1.default.rm(node_path_1.default.join(node_path_1.default.dirname(paths.codex), "classroom-codex-route-backup.json"), { force: true });
+    }
+    return {
+        async migrateLegacyState(proxyBaseUrl, clients = { codex: true, claude: true, vsCodeChat: true }) {
+            await migrateLegacyRouteState(proxyBaseUrl, clients);
+            const text = clients.claude ? await (0, clientSettingsBackup_1.optionalText)(paths.claude) : null;
+            if (clients.claude && text !== null) {
+                let next = personalClaudeText(text, proxyBaseUrl);
+                const gateway = parseJsonObject(await readText(gatewayCachePath(paths.claude)));
+                if (isManagedUrl(gateway?.baseUrl, proxyBaseUrl)) {
+                    const doc = parseJsonObject(next);
+                    if (Array.isArray(gateway?.models) && gateway.models.some(value => asRecord(value)?.id === doc.model)) {
+                        delete doc.model;
+                        next = JSON.stringify(doc, null, 2) + "\n";
+                    }
+                }
+                if (next !== text)
+                    await writeText(paths.claude, next);
+                if (isManagedUrl(gateway?.baseUrl, proxyBaseUrl))
+                    await promises_1.default.rm(gatewayCachePath(paths.claude), { force: true });
+            }
+            const vscode = clients.vsCodeChat ? await (0, clientSettingsBackup_1.optionalText)(paths.vsCode) : null;
+            if (clients.vsCodeChat && vscode !== null) {
+                const doc = parseJsonObject(vscode);
+                if (!doc)
+                    throw new Error("Invalid VS Code settings");
+                if (anthropicBaseValues(doc[exports.VS_CODE_ENV]).some(value => isManagedUrl(value, proxyBaseUrl))) {
+                    await writeText(paths.vsCode, JSON.stringify(withoutManagedVsCodeBaseUrl(doc, proxyBaseUrl), null, 2) + "\n");
+                }
+            }
+        },
+        async setCodexRoute(options) {
+            const proxyBaseUrl = options.proxyBaseUrl;
+            const text = await readText(paths.codex);
+            if (options.mode === "classroom") {
+                const original = isManagedUrl(readRootTomlString(text, "openai_base_url"), proxyBaseUrl) ? removeRootTomlKey(text, "openai_base_url") : text;
+                const catalogPath = node_path_1.default.join(node_path_1.default.dirname(paths.codex), "classroom-catalog.json");
+                const cachePath = node_path_1.default.join(node_path_1.default.dirname(paths.codex), "models_cache.json");
+                const liveCache = await readOptional(cachePath);
+                const models = catalogModels(options.ids, pickTemplate(liveCache));
+                await codexBackup.write("catalog", `${JSON.stringify({ models }, null, 2)}\n`, []);
+                await codexBackup.write("cache", `${JSON.stringify({ fetched_at: "2000-01-01T00:00:00Z", client_version: "0.0.0", models }, null, 2)}\n`, []);
+                let next = upsertRootTomlString(text, "openai_base_url", proxyBaseUrl.replace(/\/$/, "") + "/v1");
+                next = upsertRootTomlString(next, "model_catalog_json", catalogPath);
+                next = upsertRootTomlString(next, "model", catalogSlug(options.selectedModel));
+                await codexBackup.write("config", next, ["openai_base_url", "model", "model_catalog_json"], original === text ? undefined : original);
+                if (options.restart)
+                    await restartCodexAppServers();
+            }
+            else {
+                await codexBackup.restore();
+                const current = await readText(paths.codex);
+                let next = current;
+                if (isManagedUrl(readRootTomlString(next, "openai_base_url"), proxyBaseUrl))
+                    next = removeRootTomlKey(next, "openai_base_url");
+                if (readRootTomlString(next, "model")?.startsWith("VCRouter/"))
+                    next = removeRootTomlKey(next, "model");
+                if (readRootTomlString(next, "model_catalog_json") === node_path_1.default.join(node_path_1.default.dirname(paths.codex), "classroom-catalog.json"))
+                    next = removeRootTomlKey(next, "model_catalog_json");
+                if (next !== current)
+                    await writeText(paths.codex, next);
+                const cachePath = node_path_1.default.join(node_path_1.default.dirname(paths.codex), "models_cache.json");
+                const cache = parseJsonObject(await readText(cachePath));
+                if (cache?.fetched_at === "2000-01-01T00:00:00Z" && Array.isArray(cache.models) && cache.models.every(value => String(asRecord(value)?.slug).startsWith("VCRouter/")))
+                    await promises_1.default.rm(cachePath, { force: true });
+            }
+        },
+        async setClaudeCodeRoute(classroom, proxyBaseUrl, model) {
+            if (!classroom) {
+                await claudeCodeBackup.restore();
+                const text = await (0, clientSettingsBackup_1.optionalText)(paths.claude);
+                if (text !== null) {
+                    const next = personalClaudeText(text, proxyBaseUrl);
+                    if (next !== text)
+                        await writeText(paths.claude, next);
+                }
+                return;
+            }
+            const text = await readText(paths.claude);
+            const doc = parseJsonObject(text);
+            if (!doc)
+                throw new Error("Invalid Claude settings");
+            // Gateway model discovery drops ids without "claude"/"anthropic" and needs a
+            // non-OAuth credential, so the /model picker entry comes from this option.
+            const env = { ...(asRecord(doc.env) ?? {}), ANTHROPIC_BASE_URL: proxyBaseUrl, ...(model ? { ANTHROPIC_CUSTOM_MODEL_OPTION: model } : {}) };
+            const next = replaceJsonProperty(text, "env", env);
+            const personal = personalClaudeText(text, proxyBaseUrl);
+            const keys = ["env.ANTHROPIC_BASE_URL", ...(model ? ["env.ANTHROPIC_CUSTOM_MODEL_OPTION"] : [])];
+            await claudeCodeBackup.write("config", next, keys, personal === text ? undefined : personal);
+        },
+    };
+}
+function isManagedUrl(value, proxy) {
+    if (typeof value !== "string")
+        return false;
+    try {
+        const origin = new URL(value).origin;
+        return origin === new URL(proxy).origin || origin === "http://127.0.0.1:47821";
+    }
+    catch {
+        return false;
+    }
+}
+function setTomlField(text, key, value) {
+    return value === undefined ? removeRootTomlKey(text, key) : upsertRootTomlString(text, key, value);
+}
+function restoreTomlFields(current, original, written, keys) {
+    return keys.reduce((text, key) => readRootTomlString(text, key) === readRootTomlString(written, key)
+        ? setTomlField(text, key, readRootTomlString(original, key)) : text, current);
+}
+function personalClaudeText(text, proxy) {
+    const doc = parseJsonObject(text);
+    if (!doc)
+        throw new Error("Invalid Claude settings");
+    const env = asRecord(doc.env);
+    if (!isManagedUrl(env?.ANTHROPIC_BASE_URL, proxy) && !isManagedUrl(doc.ANTHROPIC_BASE_URL, proxy))
+        return text;
+    if (env && isManagedUrl(env.ANTHROPIC_BASE_URL, proxy)) {
+        delete env.ANTHROPIC_BASE_URL;
+        if (!Object.keys(env).length)
+            delete doc.env;
+    }
+    if (isManagedUrl(doc.ANTHROPIC_BASE_URL, proxy))
+        delete doc.ANTHROPIC_BASE_URL;
+    return JSON.stringify(doc, null, 2) + "\n";
+}
+function restoreJsonFields(current, original, written, keys) {
+    const doc = parseJsonObject(current), before = parseJsonObject(original), managed = parseJsonObject(written);
+    if (!doc || !before || !managed)
+        throw new Error("Invalid client settings during restore");
+    let changed = false;
+    for (const key of keys) {
+        if (key === "vscodeBase") {
+            if (!(0, node_util_1.isDeepStrictEqual)(anthropicBaseValues(doc[exports.VS_CODE_ENV]), anthropicBaseValues(managed[exports.VS_CODE_ENV])))
+                continue;
+            const env = doc[exports.VS_CODE_ENV], previous = before[exports.VS_CODE_ENV];
+            if (Array.isArray(env)) {
+                const bases = Array.isArray(previous) ? previous.filter(isAnthropicBaseEntry)
+                    : asRecord(previous)?.ANTHROPIC_BASE_URL === undefined ? [] : [{ name: "ANTHROPIC_BASE_URL", value: asRecord(previous)?.ANTHROPIC_BASE_URL }];
+                doc[exports.VS_CODE_ENV] = [...env.filter(entry => !isAnthropicBaseEntry(entry)), ...bases];
+            }
+            else if (asRecord(env)) {
+                const value = Array.isArray(previous) ? previous.find(isAnthropicBaseEntry)?.value : asRecord(previous)?.ANTHROPIC_BASE_URL;
+                const next = { ...asRecord(env) };
+                if (value === undefined)
+                    delete next.ANTHROPIC_BASE_URL;
+                else
+                    next.ANTHROPIC_BASE_URL = value;
+                doc[exports.VS_CODE_ENV] = next;
+            }
+            changed = true;
+        }
+        else if (key.startsWith("env.")) {
+            const name = key.slice("env.".length);
+            const env = asRecord(doc.env), old = asRecord(before.env), expected = asRecord(managed.env);
+            if (!env || !(0, node_util_1.isDeepStrictEqual)(env[name], expected?.[name]))
+                continue;
+            if (old?.[name] === undefined)
+                delete env[name];
+            else
+                env[name] = old[name];
+            if (!Object.keys(env).length)
+                delete doc.env;
+            changed = true;
+        }
+        else if ((0, node_util_1.isDeepStrictEqual)(doc[key], managed[key])) {
+            if (before[key] === undefined)
+                delete doc[key];
+            else
+                doc[key] = before[key];
+            changed = true;
+        }
+    }
+    return changed ? JSON.stringify(doc, null, 2) + "\n" : current;
+}
+function gatewayCachePath(claudeSettings) {
+    return node_path_1.default.join(node_path_1.default.dirname(claudeSettings), "cache", "gateway-models.json");
+}
+const ROUTED_PREFIX = "VCRouter/";
+function catalogSlug(id) {
+    return id.startsWith(ROUTED_PREFIX) ? id : `${ROUTED_PREFIX}${id}`;
+}
+function pickTemplate(raw) {
+    if (!raw) {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    const models = Array.isArray(parsed)
+        ? parsed
+        : parsed && typeof parsed === "object" && Array.isArray(parsed.models)
+            ? parsed.models
+            : [];
+    const listed = models.find((model) => {
+        if (!model || typeof model !== "object" || Array.isArray(model)) {
+            return false;
+        }
+        return model.visibility === "list";
+    });
+    if (!listed || typeof listed !== "object" || Array.isArray(listed)) {
+        return undefined;
+    }
+    return structuredClone(listed);
+}
+function catalogModels(ids, template) {
+    return ids.map((id, index) => {
+        const slug = catalogSlug(id);
+        const entry = template ? structuredClone(template) : {
+            shell_type: "shell_command",
+            visibility: "list",
+            supported_in_api: true,
+            default_reasoning_level: "medium",
+            supported_reasoning_levels: [
+                { effort: "low", description: "Fast responses with lighter reasoning" },
+                { effort: "medium", description: "Balances speed and reasoning depth for everyday tasks" },
+                { effort: "high", description: "Greater reasoning depth for complex problems" },
+                { effort: "xhigh", description: "Extra high reasoning depth for complex problems" },
+                { effort: "max", description: "Maximum reasoning depth for the hardest problems" },
+                { effort: "ultra", description: "Maximum reasoning with automatic task delegation" },
+            ],
+            base_instructions: "You are a helpful coding assistant.",
+            supports_parallel_tool_calls: true,
+            context_window: 128000,
+            max_context_window: 128000,
+            input_modalities: ["text", "image"],
+        };
+        entry.slug = slug;
+        entry.display_name = slug;
+        entry.description = `Routed via classroom → VCRouter (${id}).`;
+        entry.visibility = "list";
+        entry.supported_in_api = true;
+        entry.priority = index + 1;
+        entry.upgrade = null;
+        return entry;
+    });
+}
+function rootTomlLines(text) {
+    const lines = text.split("\n");
+    const table = lines.findIndex((line) => /^\s*\[/.test(line));
+    return { lines, rootEnd: table === -1 ? lines.length : table };
+}
+function readRootTomlString(text, key) {
+    const { lines, rootEnd } = rootTomlLines(text);
+    const pattern = new RegExp(`^\\s*${key}\\s*=\\s*"((?:\\\\.|[^"\\\\])*)"`);
+    for (let i = 0; i < rootEnd; i += 1) {
+        const match = lines[i]?.match(pattern);
+        if (match?.[1] !== undefined) {
+            return match[1].replaceAll("\\\\", "\\").replaceAll('\\"', '"');
+        }
+    }
+    return undefined;
+}
+function upsertRootTomlString(text, key, value) {
+    const { lines, rootEnd } = rootTomlLines(stripKeyOutsideRoot(text, key));
+    const escaped = value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+    const line = `${key} = "${escaped}"`;
+    const pattern = new RegExp(`^\\s*${key}\\s*=`);
+    for (let i = 0; i < rootEnd; i += 1) {
+        if (pattern.test(lines[i] ?? "")) {
+            lines[i] = line;
+            return lines.join("\n");
+        }
+    }
+    let insertAt = rootEnd;
+    while (insertAt > 0 && (lines[insertAt - 1] ?? "").trim() === "") {
+        insertAt -= 1;
+    }
+    lines.splice(insertAt, 0, line);
+    return lines.join("\n");
+}
+function removeRootTomlKey(text, key) {
+    const { lines, rootEnd } = rootTomlLines(text);
+    const pattern = new RegExp(`^\\s*${key}\\s*=`);
+    return lines.filter((line, index) => index >= rootEnd || !pattern.test(line)).join("\n");
+}
+function stripKeyOutsideRoot(text, key) {
+    const { lines, rootEnd } = rootTomlLines(text);
+    const pattern = new RegExp(`^\\s*${key}\\s*=`);
+    return lines.filter((line, index) => index < rootEnd || !pattern.test(line)).join("\n");
+}
+function restartCodexAppServers() {
+    if (process.platform !== "win32") {
+        return Promise.resolve();
+    }
+    const script = [
+        "$ErrorActionPreference='SilentlyContinue'",
+        "Get-CimInstance Win32_Process | Where-Object {",
+        "  $_.CommandLine -and $_.CommandLine -match '(?i)(^|\\\\|\\s)codex(\\.exe|\\.cmd)?(\\s|\").*\\bapp-server\\b'",
+        "} | ForEach-Object { $_.ProcessId }",
+    ].join("\n");
+    return new Promise((resolve) => {
+        (0, node_child_process_1.execFile)("powershell.exe", ["-NoProfile", "-NoLogo", "-NonInteractive", "-WindowStyle", "Hidden", "-Command", script], { timeout: 12_000, windowsHide: true }, (_error, stdout) => {
+            const pids = String(stdout)
+                .split(/\r?\n/)
+                .map((line) => Number(line.trim()))
+                .filter((pid) => Number.isSafeInteger(pid) && pid > 1);
+            if (pids.length === 0) {
+                resolve();
+                return;
+            }
+            let left = pids.length;
+            for (const pid of pids) {
+                (0, node_child_process_1.execFile)("taskkill", ["/PID", String(pid), "/T"], { windowsHide: true }, () => {
+                    left -= 1;
+                    if (left === 0) {
+                        resolve();
+                    }
+                });
+            }
+        });
+    });
+}
+async function readOptional(file) {
+    return (await (0, clientSettingsBackup_1.optionalText)(file)) ?? undefined;
+}
+function backupFile(paths) {
+    return node_path_1.default.join(node_path_1.default.dirname(paths.codex), "classroom-model-backup.json");
+}
+async function readDiskBackup(paths) {
+    const raw = await readOptional(backupFile(paths));
+    if (!raw) {
+        return undefined;
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return undefined;
+    }
+    return parsed;
+}
+async function readText(file) {
+    return (await (0, clientSettingsBackup_1.optionalText)(file)) ?? "";
+}
+async function writeText(file, text) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(file), { recursive: true });
+    await promises_1.default.writeFile(file, text, "utf8");
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function parseJsonObject(text) {
+    if (text.trim() === "") {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(relaxJson(text));
+        return asRecord(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+// ponytail: trailing-comma removal can match inside strings. Upgrade path: a JSONC parser.
+function relaxJson(text) {
+    return stripJsonComments(text).replace(/,\s*([}\]])/g, "$1");
+}
+function stripJsonComments(text) {
+    let out = "";
+    let inString = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i += 1) {
+        const c = text[i];
+        const next = text[i + 1];
+        if (inString) {
+            out += c;
+            if (escape) {
+                escape = false;
+            }
+            else if (c === "\\") {
+                escape = true;
+            }
+            else if (c === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (c === '"') {
+            inString = true;
+            out += c;
+            continue;
+        }
+        if (c === "/" && next === "/") {
+            i += 1;
+            while (i + 1 < text.length && text[i + 1] !== "\n") {
+                i += 1;
+            }
+            continue;
+        }
+        if (c === "/" && next === "*") {
+            i += 2;
+            while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) {
+                i += 1;
+            }
+            i += 1;
+            continue;
+        }
+        out += c;
+    }
+    return out;
+}
+// ponytail: replaces the first property with this name. Upgrade path: a JSONC editor.
+function replaceJsonProperty(text, key, value) {
+    const serialized = JSON.stringify(value);
+    const needle = `"${key}"`;
+    const at = text.indexOf(needle);
+    if (at < 0) {
+        return insertJsonProperty(text, key, serialized);
+    }
+    let i = at + needle.length;
+    while (i < text.length && /\s/.test(text[i])) {
+        i += 1;
+    }
+    if (text[i] !== ":") {
+        return text;
+    }
+    i += 1;
+    while (i < text.length && /\s/.test(text[i])) {
+        i += 1;
+    }
+    const end = jsonValueEnd(text, i);
+    if (end < 0) {
+        return text;
+    }
+    return `${text.slice(0, i)}${serialized}${text.slice(end)}`;
+}
+function insertJsonProperty(text, key, serialized) {
+    if (text.trim() === "") {
+        return `{\n  "${key}": ${serialized}\n}\n`;
+    }
+    const end = text.lastIndexOf("}");
+    if (end < 0) {
+        return text;
+    }
+    const before = text.slice(0, end).trimEnd();
+    const comma = before.endsWith("{") || before.endsWith(",") ? "" : ",";
+    return `${before}${comma}\n  "${key}": ${serialized}\n${text.slice(end)}`;
+}
+function jsonValueEnd(text, start) {
+    const c = text[start];
+    if (c === '"') {
+        let escape = false;
+        for (let i = start + 1; i < text.length; i += 1) {
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (text[i] === "\\") {
+                escape = true;
+                continue;
+            }
+            if (text[i] === '"') {
+                return i + 1;
+            }
+        }
+        return -1;
+    }
+    if (c === "{" || c === "[") {
+        const close = c === "{" ? "}" : "]";
+        let depth = 0;
+        let inString = false;
+        let escape = false;
+        for (let i = start; i < text.length; i += 1) {
+            const ch = text[i];
+            if (inString) {
+                if (escape) {
+                    escape = false;
+                }
+                else if (ch === "\\") {
+                    escape = true;
+                }
+                else if (ch === '"') {
+                    inString = false;
+                }
+                continue;
+            }
+            if (ch === '"') {
+                inString = true;
+                continue;
+            }
+            if (ch === c) {
+                depth += 1;
+            }
+            else if (ch === close) {
+                depth -= 1;
+                if (depth === 0) {
+                    return i + 1;
+                }
+            }
+        }
+        return -1;
+    }
+    let i = start;
+    while (i < text.length && !/[\s,}\]]/.test(text[i])) {
+        i += 1;
+    }
+    return i;
+}

package/dist/routerSessionModels.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSessionModelProviders = fetchSessionModelProviders;
+function isProviderRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const models = value.models;
+    return Array.isArray(models) && models.every(model => {
+        if (!model || typeof model !== "object" || Array.isArray(model))
+            return false;
+        const id = model.id;
+        return typeof id === "string" && id.trim().length > 0;
+    });
+}
+async function fetchSessionModelProviders(options) {
+    const request = options.request ?? fetch;
+    const root = options.root.replace(/\/+$/, "");
+    const response = await request(`${root}/extension/chat-language-models`, {
+        signal: AbortSignal.timeout(5_000),
+        headers: {
+            Accept: "application/json",
+            Authorization: `Bearer ${options.apiKey}`,
+        },
+    });
+    if (!response.ok)
+        throw new Error("session models failed");
+    const payload = await response.json();
+    if (!Array.isArray(payload) || !payload.every(isProviderRecord)) {
+        throw new Error("session models failed");
+    }
+    return payload;
+}