copilot-hub 0.1.19 → 0.1.21

package/README.md

@@ -82,6 +82,7 @@ copilot-hub start
 
 `start` runs guided setup automatically if required values are missing.
 On interactive terminals, `start` can also offer OS-native service installation when it is not yet configured.
+`start` and `update` also verify the supported Codex CLI range and can install the validated version automatically when needed.
 
 ## Quick start from source
 
@@ -165,9 +166,9 @@ Default values are already applied, and actions start from that agent workspace
 ## Startup troubleshooting
 
 - If `npm run start` fails, first read the error and follow the suggested action.
-- `npm run start` now auto-detects Codex from VS Code (Windows) and can install Codex CLI automatically if missing.
+- `npm run start` now checks that Codex CLI is inside the supported range and can install the validated version automatically if missing or outside that range.
 - For Codex login issues, run `codex login` (or the configured `CODEX_BIN`) and retry `npm run start`.
-- If auto-install is skipped or unavailable, install Codex CLI with `npm install -g @openai/codex` or set `CODEX_BIN` in `.env`.
+- If auto-install is skipped or unavailable, install Codex CLI with `npm install -g @openai/codex@0.113.0` or set `CODEX_BIN` in `.env` to a binary in the supported `0.113.x` range.
 - If you are still stuck, ask your favorite LLM with the exact error output.
 
 ## Commands

package/apps/agent-engine/dist/config.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { spawnSync } from "node:child_process";
 import dotenv from "dotenv";
 import { createWorkspaceBoundaryPolicy, assertWorkspaceAllowed, parseWorkspaceAllowedRoots, } from "@copilot-hub/core/workspace-policy";
 import { parseTurnActivityTimeoutSetting } from "@copilot-hub/core/codex-app-utils";
@@ -124,6 +125,10 @@ function resolveCodexBin(rawValue) {
         return value;
     }
     if (process.platform === "win32") {
+        const npmGlobalCodex = findWindowsNpmGlobalCodexBin();
+        if (npmGlobalCodex) {
+            return npmGlobalCodex;
+        }
         const vscodeCodex = findVscodeCodexExe();
         if (vscodeCodex) {
             return vscodeCodex;
@@ -155,6 +160,59 @@ function findVscodeCodexExe() {
     }
     return null;
 }
+function findWindowsNpmGlobalCodexBin() {
+    if (process.platform !== "win32") {
+        return null;
+    }
+    const candidates = [];
+    const appData = String(process.env.APPDATA ?? "").trim();
+    if (appData) {
+        candidates.push(path.join(appData, "npm", "codex.cmd"));
+        candidates.push(path.join(appData, "npm", "codex.exe"));
+        candidates.push(path.join(appData, "npm", "codex"));
+    }
+    const npmPrefix = readNpmPrefix();
+    if (npmPrefix) {
+        candidates.push(path.join(npmPrefix, "codex.cmd"));
+        candidates.push(path.join(npmPrefix, "codex.exe"));
+        candidates.push(path.join(npmPrefix, "codex"));
+    }
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function readNpmPrefix() {
+    const result = spawnNpm(["config", "get", "prefix"]);
+    if (result.error || result.status !== 0) {
+        return "";
+    }
+    const value = String(result.stdout ?? "").trim();
+    if (!value || value.toLowerCase() === "undefined") {
+        return "";
+    }
+    return value;
+}
+function spawnNpm(args) {
+    if (process.platform === "win32") {
+        const comspec = process.env.ComSpec || "cmd.exe";
+        const commandLine = ["npm", ...args].join(" ");
+        return spawnSync(comspec, ["/d", "/s", "/c", commandLine], {
+            cwd: process.cwd(),
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: false,
+            encoding: "utf8",
+        });
+    }
+    return spawnSync("npm", args, {
+        cwd: process.cwd(),
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false,
+        encoding: "utf8",
+    });
+}
 function normalizeThreadMode(value) {
     const mode = String(value ?? "single")
         .trim()

package/apps/agent-engine/dist/index.js

@@ -5,7 +5,9 @@ import { fileURLToPath } from "node:url";
 import express from "express";
 import { BotManager } from "@copilot-hub/core/bot-manager";
 import { CodexAppClient } from "@copilot-hub/core/codex-app-client";
+import { buildShellWrappedCommandLine, requiresShellWrappedSpawn, } from "@copilot-hub/core/codex-app-utils";
 import { loadBotRegistry } from "@copilot-hub/core/bot-registry";
+import { invalidateCodexQuotaUsageCache } from "@copilot-hub/core/telegram-channel";
 import { config } from "./config.js";
 import { InstanceLock } from "@copilot-hub/core/instance-lock";
 import { KernelControlPlane } from "@copilot-hub/core/kernel-control-plane";
@@ -215,6 +217,7 @@ function buildApiApp({ botManager, controlPlane, registryFilePath, }) {
         const refreshed = await refreshRunningBotProviders({
             botManager: requireBotManager(),
         });
+        invalidateCodexQuotaUsageCache();
         res.json({
             ok: true,
             switched: true,
@@ -273,8 +276,18 @@ function buildApiApp({ botManager, controlPlane, registryFilePath, }) {
             .trim()
             .toLowerCase();
         const hasModel = Object.prototype.hasOwnProperty.call(req.body ?? {}, "model");
+        const hasReasoningEffort = Object.prototype.hasOwnProperty.call(req.body ?? {}, "reasoningEffort");
+        const hasServiceTier = Object.prototype.hasOwnProperty.call(req.body ?? {}, "serviceTier");
         const rawModel = req.body?.model;
+        const rawReasoningEffort = req.body?.reasoningEffort;
+        const rawServiceTier = req.body?.serviceTier;
         const model = rawModel === null || rawModel === undefined ? null : String(rawModel).trim();
+        const reasoningEffort = rawReasoningEffort === null || rawReasoningEffort === undefined
+            ? null
+            : String(rawReasoningEffort).trim().toLowerCase();
+        const serviceTier = rawServiceTier === null || rawServiceTier === undefined
+            ? null
+            : String(rawServiceTier).trim().toLowerCase();
         if (!sandboxMode) {
             res.status(400).json({ error: "Field 'sandboxMode' is required." });
             return;
@@ -291,6 +304,12 @@ function buildApiApp({ botManager, controlPlane, registryFilePath, }) {
         if (hasModel) {
             payload.model = model;
         }
+        if (hasReasoningEffort) {
+            payload.reasoningEffort = reasoningEffort;
+        }
+        if (hasServiceTier) {
+            payload.serviceTier = serviceTier;
+        }
         const result = await controlPlane.runSystemAction(CONTROL_ACTIONS.BOTS_SET_POLICY, payload);
         res.json(result);
     }));
@@ -476,13 +495,21 @@ function startCodexDeviceAuthSession() {
         refreshedBots: [],
         refreshFailures: [],
     };
-    const child = spawn(codexBin, ["login", "--device-auth"], {
-        cwd: config.kernelRootPath,
-        shell: false,
-        stdio: ["ignore", "pipe", "pipe"],
-        windowsHide: true,
-        env: process.env,
-    });
+    const child = requiresShellWrappedSpawn(codexBin)
+        ? spawn(buildShellWrappedCommandLine(codexBin, ["login", "--device-auth"]), {
+            cwd: config.kernelRootPath,
+            shell: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            env: process.env,
+        })
+        : spawn(codexBin, ["login", "--device-auth"], {
+            cwd: config.kernelRootPath,
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            env: process.env,
+        });
     session.child = child;
     codexDeviceAuthSession = session;
     child.stdout.on("data", (chunk) => {
@@ -507,6 +534,7 @@ function startCodexDeviceAuthSession() {
                 botManager: requireBotManager(),
             })
                 .then((refreshed) => {
+                invalidateCodexQuotaUsageCache();
                 session.refreshedBots = refreshed.refreshedBotIds;
                 session.refreshFailures = refreshed.failures;
                 session.status = "succeeded";
@@ -706,6 +734,8 @@ function normalizeModelCatalog(rawModels) {
             displayName: String(entry?.displayName ?? model).trim() || model,
             description: String(entry?.description ?? "").trim(),
             isDefault: entry?.isDefault === true,
+            supportedReasoningEfforts: normalizeReasoningCatalog(entry?.supportedReasoningEfforts),
+            defaultReasoningEffort: normalizeReasoningEffortValue(entry?.defaultReasoningEffort),
         });
     }
     return normalized.sort((a, b) => {
@@ -725,17 +755,58 @@ function looksLikeCodexApiKey(value) {
     }
     return key.startsWith("sk-");
 }
+function normalizeReasoningCatalog(value) {
+    const options = [];
+    const seen = new Set();
+    for (const entry of Array.isArray(value) ? value : []) {
+        const option = isRecord(entry) ? entry : {};
+        const reasoningEffort = normalizeReasoningEffortValue(option.reasoningEffort ?? option.effort ?? option.id);
+        if (!reasoningEffort || seen.has(reasoningEffort)) {
+            continue;
+        }
+        seen.add(reasoningEffort);
+        options.push({
+            reasoningEffort,
+            description: String(option.description ?? "").trim(),
+        });
+    }
+    return options;
+}
+function normalizeReasoningEffortValue(value) {
+    const normalized = String(value ?? "")
+        .trim()
+        .toLowerCase();
+    if (normalized === "none" ||
+        normalized === "minimal" ||
+        normalized === "low" ||
+        normalized === "medium" ||
+        normalized === "high" ||
+        normalized === "xhigh") {
+        return normalized;
+    }
+    return null;
+}
 function runCodexCommand(args, { inputText = "" } = {}) {
     const codexBin = String(config.codexBin ?? "codex").trim() || "codex";
-    const result = spawnSync(codexBin, args, {
-        cwd: config.kernelRootPath,
-        shell: false,
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true,
-        encoding: "utf8",
-        input: inputText,
-        env: process.env,
-    });
+    const result = requiresShellWrappedSpawn(codexBin)
+        ? spawnSync(buildShellWrappedCommandLine(codexBin, args), {
+            cwd: config.kernelRootPath,
+            shell: true,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+            encoding: "utf8",
+            input: inputText,
+            env: process.env,
+        })
+        : spawnSync(codexBin, args, {
+            cwd: config.kernelRootPath,
+            shell: false,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+            encoding: "utf8",
+            input: inputText,
+            env: process.env,
+        });
     if (result.error) {
         return {
             ok: false,
@@ -764,6 +835,9 @@ function formatCodexSpawnError(codexBin, error) {
     if (code === "EPERM") {
         return `Codex binary '${codexBin}' cannot be executed (EPERM).`;
     }
+    if (code === "EINVAL" && requiresShellWrappedSpawn(codexBin)) {
+        return `Codex binary '${codexBin}' must be launched through the Windows shell.`;
+    }
     const message = error instanceof Error ? error.message : String(error);
     return `Failed to execute '${codexBin}': ${firstNonEmptyLine(message)}`;
 }

package/apps/control-plane/dist/channels/codex-quota-cache.js

@@ -0,0 +1,16 @@
+let cachedCodexUsage = null;
+export function readCachedCodexQuotaSnapshot(now) {
+    if (cachedCodexUsage && now < cachedCodexUsage.expiresAt) {
+        return cachedCodexUsage.snapshot;
+    }
+    return null;
+}
+export function writeCachedCodexQuotaSnapshot(snapshot, expiresAt) {
+    cachedCodexUsage = {
+        expiresAt,
+        snapshot,
+    };
+}
+export function invalidateCodexQuotaUsageCache() {
+    cachedCodexUsage = null;
+}

package/apps/control-plane/dist/channels/hub-model-utils.js

@@ -1,4 +1,4 @@
-const MODEL_INLINE_MAX = 6;
+const MODEL_INLINE_MAX = 24;
 const MODEL_PATTERN = /^[A-Za-z0-9._:-]+$/;
 export function parseSetModelCommand(text, botIdPattern) {
     const tokens = String(text ?? "")
@@ -88,6 +88,30 @@ export function formatModelLabel(value) {
     }
     return model;
 }
+export function formatReasoningLabel(value) {
+    const reasoningEffort = normalizeReasoningEffortValue(value);
+    if (!reasoningEffort) {
+        return "Default";
+    }
+    switch (reasoningEffort) {
+        case "xhigh":
+            return "Extra High";
+        case "none":
+            return "None";
+        default:
+            return reasoningEffort.charAt(0).toUpperCase() + reasoningEffort.slice(1);
+    }
+}
+export function formatFastModeLabel(value) {
+    const serviceTier = normalizeServiceTierValue(value);
+    if (serviceTier === "fast") {
+        return "Fast";
+    }
+    if (serviceTier === "flex") {
+        return "Flex (manual)";
+    }
+    return "Standard";
+}
 export function formatModelButtonText(label, selected) {
     const text = String(label ?? "").trim() || "Model";
     return selected ? `* ${text}` : text;
@@ -117,6 +141,8 @@ export function buildSessionModelOptions({ catalog, currentModel, inlineMax = MO
             label: String(entry.displayName ?? model).trim() || model,
             isDefault: entry.isDefault === true,
             selected: normalizedCurrent === key,
+            supportedReasoningEfforts: normalizeReasoningCatalog(entry.supportedReasoningEfforts),
+            defaultReasoningEffort: normalizeReasoningEffortValue(entry.defaultReasoningEffort),
         });
     }
     options.sort((a, b) => {
@@ -136,6 +162,47 @@ export function buildSessionModelOptions({ catalog, currentModel, inlineMax = MO
         key: `k${index}`,
     }));
 }
+export function buildReasoningOptionsForModel({ modelSelection, currentModel, currentReasoningEffort, }) {
+    if (!modelSelection.ok || !modelSelection.model) {
+        return [
+            {
+                key: "default",
+                reasoningEffort: null,
+                label: "Default",
+                description: "Use the default reasoning level for the resolved model.",
+                selected: true,
+            },
+        ];
+    }
+    const selectedModel = String(modelSelection.model).trim().toLowerCase();
+    const normalizedCurrentModel = String(currentModel ?? "")
+        .trim()
+        .toLowerCase();
+    const normalizedCurrentReasoning = normalizeReasoningEffortValue(currentReasoningEffort);
+    const selectedReasoning = selectedModel === normalizedCurrentModel ? normalizedCurrentReasoning : null;
+    const options = [
+        {
+            key: "default",
+            reasoningEffort: null,
+            label: "Default",
+            description: modelSelection.defaultReasoningEffort !== null
+                ? `Use ${formatReasoningLabel(modelSelection.defaultReasoningEffort)} for this model.`
+                : "Use the model default reasoning level.",
+            selected: selectedReasoning === null,
+        },
+    ];
+    for (const entry of modelSelection.supportedReasoningEfforts) {
+        options.push({
+            key: `r${options.length - 1}`,
+            reasoningEffort: entry.reasoningEffort,
+            label: formatReasoningLabel(entry.reasoningEffort),
+            description: String(entry.description ?? "").trim() ||
+                `${formatReasoningLabel(entry.reasoningEffort)} reasoning effort.`,
+            selected: selectedReasoning === entry.reasoningEffort,
+        });
+    }
+    return options;
+}
 export function resolveModelSelectionFromAction({ session, profileId, }) {
     const target = String(profileId ?? "")
         .trim()
@@ -143,15 +210,21 @@ export function resolveModelSelectionFromAction({ session, profileId, }) {
     if (!target) {
         return {
             ok: false,
+            key: "",
             model: null,
             label: "",
+            supportedReasoningEfforts: [],
+            defaultReasoningEffort: null,
         };
     }
     if (target === "auto") {
         return {
             ok: true,
+            key: "auto",
             model: null,
             label: "Auto (workspace default)",
+            supportedReasoningEfforts: [],
+            defaultReasoningEffort: null,
         };
     }
     const options = Array.isArray(session?.modelOptions) ? session.modelOptions : [];
@@ -161,14 +234,47 @@ export function resolveModelSelectionFromAction({ session, profileId, }) {
     if (!matched) {
         return {
             ok: false,
+            key: "",
             model: null,
             label: "",
+            supportedReasoningEfforts: [],
+            defaultReasoningEffort: null,
         };
     }
     return {
         ok: true,
+        key: matched.key,
         model: String(matched.model ?? "").trim() || null,
         label: String(matched.label ?? matched.model ?? "custom").trim(),
+        supportedReasoningEfforts: matched.supportedReasoningEfforts,
+        defaultReasoningEffort: matched.defaultReasoningEffort,
+    };
+}
+export function resolveReasoningSelectionFromAction({ options, profileId, }) {
+    const target = String(profileId ?? "")
+        .trim()
+        .toLowerCase();
+    if (!target) {
+        return {
+            ok: false,
+            reasoningEffort: null,
+            label: "",
+        };
+    }
+    const matched = options.find((entry) => String(entry?.key ?? "")
+        .trim()
+        .toLowerCase() === target);
+    if (!matched) {
+        return {
+            ok: false,
+            reasoningEffort: null,
+            label: "",
+        };
+    }
+    return {
+        ok: true,
+        reasoningEffort: matched.reasoningEffort,
+        label: matched.label,
     };
 }
 export async function fetchCodexModelOptions(apiGet) {
@@ -193,7 +299,10 @@ export async function fetchCodexModelOptions(apiGet) {
             models.push({
                 model,
                 displayName: String(entry.displayName ?? model).trim() || model,
+                description: String(entry.description ?? "").trim(),
                 isDefault: entry.isDefault === true,
+                supportedReasoningEfforts: normalizeReasoningCatalog(entry.supportedReasoningEfforts),
+                defaultReasoningEffort: normalizeReasoningEffortValue(entry.defaultReasoningEffort),
             });
         }
         return {
@@ -226,9 +335,6 @@ export function resolveApprovalPolicy(value) {
     }
     return "never";
 }
-function isObject(value) {
-    return value !== null && typeof value === "object";
-}
 export function getBotPolicyState(botState) {
     const provider = isObject(botState) && isObject(botState.provider) ? botState.provider : null;
     const options = provider && isObject(provider.options) ? provider.options : {};
@@ -237,35 +343,68 @@ export function getBotPolicyState(botState) {
         approvalPolicy: resolveApprovalPolicy(options.approvalPolicy),
     };
 }
-export async function applyBotModelPolicy({ apiPost, botId, botState, model, }) {
-    const policyState = getBotPolicyState(botState);
-    return apiPost(`/api/bots/${encodeURIComponent(botId)}/policy`, {
-        sandboxMode: policyState.sandboxMode,
-        approvalPolicy: policyState.approvalPolicy,
-        model,
-    });
+export function getBotProviderSelection(botState) {
+    const provider = isObject(botState) && isObject(botState.provider) ? botState.provider : null;
+    const options = provider && isObject(provider.options) ? provider.options : {};
+    return {
+        model: normalizeModelValue(options.model),
+        reasoningEffort: normalizeReasoningEffortValue(options.reasoningEffort),
+        serviceTier: normalizeServiceTierValue(options.serviceTier),
+    };
 }
-export function getRuntimeModel(runtime) {
+export function getRuntimeProviderSelection(runtime) {
     if (!runtime || typeof runtime.getProviderOptions !== "function") {
-        return null;
+        return {
+            model: null,
+            reasoningEffort: null,
+            serviceTier: null,
+        };
     }
     const options = runtime.getProviderOptions();
-    if (!isObject(options)) {
-        return null;
+    const record = isObject(options) ? options : {};
+    return {
+        model: normalizeModelValue(record.model),
+        reasoningEffort: normalizeReasoningEffortValue(record.reasoningEffort),
+        serviceTier: normalizeServiceTierValue(record.serviceTier),
+    };
+}
+export async function applyBotProviderPolicy({ apiPost, botId, botState, patch, }) {
+    const policyState = getBotPolicyState(botState);
+    const payload = {
+        sandboxMode: policyState.sandboxMode,
+        approvalPolicy: policyState.approvalPolicy,
+    };
+    if (Object.prototype.hasOwnProperty.call(patch, "model")) {
+        payload.model = patch.model ?? null;
+    }
+    if (Object.prototype.hasOwnProperty.call(patch, "reasoningEffort")) {
+        payload.reasoningEffort = patch.reasoningEffort ?? null;
     }
-    const model = String(options.model ?? "").trim();
-    return model || null;
+    if (Object.prototype.hasOwnProperty.call(patch, "serviceTier")) {
+        payload.serviceTier = patch.serviceTier ?? null;
+    }
+    return apiPost(`/api/bots/${encodeURIComponent(botId)}/policy`, payload);
 }
-export async function applyRuntimeModelPolicy({ runtime, model, }) {
+export async function applyRuntimeProviderPolicy({ runtime, patch, }) {
     if (!runtime || typeof runtime.setProviderOptions !== "function") {
-        throw new Error("Hub model update is not available on this runtime.");
+        throw new Error("Hub provider update is not available on this runtime.");
+    }
+    const payload = {};
+    if (Object.prototype.hasOwnProperty.call(patch, "model")) {
+        payload.model = patch.model ?? null;
+    }
+    if (Object.prototype.hasOwnProperty.call(patch, "reasoningEffort")) {
+        payload.reasoningEffort = patch.reasoningEffort ?? null;
     }
-    await runtime.setProviderOptions({ model });
+    if (Object.prototype.hasOwnProperty.call(patch, "serviceTier")) {
+        payload.serviceTier = patch.serviceTier ?? null;
+    }
+    await runtime.setProviderOptions(payload);
 }
 export function resolveSharedModel(models) {
     let normalizedModel;
     for (const entry of Array.isArray(models) ? models : []) {
-        const nextModel = String(entry ?? "").trim() || null;
+        const nextModel = normalizeModelValue(entry);
         if (normalizedModel === undefined) {
             normalizedModel = nextModel;
             continue;
@@ -279,7 +418,41 @@ export function resolveSharedModel(models) {
         model: normalizedModel ?? null,
     };
 }
-export async function applyModelPolicyToBots({ apiPost, bots, model, }) {
+export function resolveSharedReasoningEffort(values) {
+    let normalizedValue;
+    for (const entry of Array.isArray(values) ? values : []) {
+        const nextValue = normalizeReasoningEffortValue(entry);
+        if (normalizedValue === undefined) {
+            normalizedValue = nextValue;
+            continue;
+        }
+        if (normalizedValue !== nextValue) {
+            return { mode: "mixed" };
+        }
+    }
+    return {
+        mode: "uniform",
+        reasoningEffort: normalizedValue ?? null,
+    };
+}
+export function resolveSharedServiceTier(values) {
+    let normalizedValue;
+    for (const entry of Array.isArray(values) ? values : []) {
+        const nextValue = normalizeServiceTierValue(entry);
+        if (normalizedValue === undefined) {
+            normalizedValue = nextValue;
+            continue;
+        }
+        if (normalizedValue !== nextValue) {
+            return { mode: "mixed" };
+        }
+    }
+    return {
+        mode: "uniform",
+        serviceTier: normalizedValue ?? null,
+    };
+}
+export async function applyProviderPolicyToBots({ apiPost, bots, patch, }) {
     const updatedBotIds = [];
     const failures = [];
     for (const botState of Array.isArray(bots) ? bots : []) {
@@ -288,11 +461,11 @@ export async function applyModelPolicyToBots({ apiPost, bots, model, }) {
             continue;
         }
         try {
-            await applyBotModelPolicy({
+            await applyBotProviderPolicy({
                 apiPost,
                 botId,
                 botState,
-                model,
+                patch,
             });
             updatedBotIds.push(botId);
         }
@@ -308,6 +481,53 @@ export async function applyModelPolicyToBots({ apiPost, bots, model, }) {
         failures,
     };
 }
+function isObject(value) {
+    return value !== null && typeof value === "object";
+}
+function normalizeModelValue(value) {
+    const normalized = String(value ?? "").trim();
+    return normalized || null;
+}
+function normalizeReasoningCatalog(value) {
+    const options = [];
+    const seen = new Set();
+    for (const entry of Array.isArray(value) ? value : []) {
+        const option = isObject(entry) ? entry : {};
+        const reasoningEffort = normalizeReasoningEffortValue(option.reasoningEffort ?? option.effort ?? option.id);
+        if (!reasoningEffort || seen.has(reasoningEffort)) {
+            continue;
+        }
+        seen.add(reasoningEffort);
+        options.push({
+            reasoningEffort,
+            description: String(option.description ?? "").trim(),
+        });
+    }
+    return options;
+}
+function normalizeReasoningEffortValue(value) {
+    const normalized = String(value ?? "")
+        .trim()
+        .toLowerCase();
+    if (normalized === "none" ||
+        normalized === "minimal" ||
+        normalized === "low" ||
+        normalized === "medium" ||
+        normalized === "high" ||
+        normalized === "xhigh") {
+        return normalized;
+    }
+    return null;
+}
+function normalizeServiceTierValue(value) {
+    const normalized = String(value ?? "")
+        .trim()
+        .toLowerCase();
+    if (normalized === "fast" || normalized === "flex") {
+        return normalized;
+    }
+    return null;
+}
 function sanitizeError(error) {
     const raw = error instanceof Error ? error.message : String(error);
     return raw.split(/\r?\n/).slice(0, 6).join("\n");