vibe-coding-master 0.7.44 → 0.7.45

package/dist/backend/services/{ccr-integration-service.js → codex-bridge-integration-service.js}

@@ -1,19 +1,19 @@
-import { CCR_GATEWAY_BASE_URL, CCR_GPT_AUTO_COMPACT_PERCENT, CCR_GPT_AUTO_COMPACT_WINDOW_TOKENS, CCR_GPT_EFFECTIVE_CONTEXT_TOKENS, CCR_GPT_MODEL_ID, createSessionModelOptions, isCcrSessionModel } from "../../shared/types/session.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { CODEX_BRIDGE_AUTO_COMPACT_PERCENT, CODEX_BRIDGE_AUTO_COMPACT_WINDOW_TOKENS, CODEX_BRIDGE_BASE_URL, CODEX_BRIDGE_EFFECTIVE_CONTEXT_TOKENS, createSessionModelOptions, getCodexBridgeModelId, isCodexBridgeSessionModel } from "../../shared/types/session.js";
 import { VcmError } from "../errors.js";
 import { resolveVcmDataDir } from "../vcm-data-dir.js";
 const DEFAULT_CACHE_TTL_MS = 10_000;
-const DEFAULT_API_KEY_HELPER_PATH = fileURLToPath(new URL("../../../scripts/ccr-api-key-helper.mjs", import.meta.url));
-export function createCcrIntegrationService(deps) {
+const DEFAULT_API_KEY_HELPER_PATH = fileURLToPath(new URL("../../../scripts/codex-bridge-api-key-helper.mjs", import.meta.url));
+export function createCodexBridgeIntegrationService(deps) {
     const now = deps.now ?? (() => new Date());
     const cacheTtlMs = deps.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
     const baseEnv = deps.baseEnv ?? process.env;
-    const configDir = deps.configDir ?? path.join(resolveVcmDataDir(baseEnv), "claude", "ccr");
+    const configDir = deps.configDir ?? path.join(resolveVcmDataDir(baseEnv), "claude", "codex-bridge");
     let cachedProbe;
     let inFlight;
     async function probe(force = false) {
-        const settings = await deps.settings.getCcrIntegrationSettings();
+        const settings = await deps.settings.getCodexBridgeIntegrationSettings();
         if (!settings.apiKey) {
             throw missingApiKeyError();
         }
@@ -24,7 +24,7 @@ export function createCcrIntegrationService(deps) {
         if (inFlight) {
             return inFlight;
         }
-        inFlight = deps.gateway.probe(settings.apiKey).then((result) => {
+        inFlight = deps.bridge.probe(settings.apiKey).then((result) => {
             const checkedAtDate = now();
             cachedProbe = {
                 result,
@@ -38,14 +38,15 @@ export function createCcrIntegrationService(deps) {
         return inFlight;
     }
     async function buildStatus(options = {}) {
-        const settings = await deps.settings.getCcrIntegrationSettings();
+        const settings = await deps.settings.getCodexBridgeIntegrationSettings();
         if (!settings.enabled) {
             return createStatus({
                 enabled: false,
                 apiKeyConfigured: Boolean(settings.apiKey),
                 connectionState: "disabled",
                 modelAvailable: false,
-                error: settings.apiKey ? undefined : "Save a CCR API key before enabling CCR GPT models."
+                models: [],
+                error: settings.apiKey ? undefined : "Save a Codex Bridge API key before enabling Codex models."
             });
         }
         if (!cachedProbe && options.refreshIfMissing) {
@@ -56,7 +57,8 @@ export function createCcrIntegrationService(deps) {
                 enabled: true,
                 apiKeyConfigured: true,
                 connectionState: "checking",
-                modelAvailable: false
+                modelAvailable: false,
+                models: []
             });
         }
         return createStatus({
@@ -64,13 +66,14 @@ export function createCcrIntegrationService(deps) {
             apiKeyConfigured: true,
             connectionState: cachedProbe.result.connectionState,
             modelAvailable: cachedProbe.result.modelAvailable,
+            models: cachedProbe.result.models,
             checkedAt: cachedProbe.checkedAt,
             error: cachedProbe.result.error
         });
     }
     return {
         async initialize() {
-            const settings = await deps.settings.getCcrIntegrationSettings();
+            const settings = await deps.settings.getCodexBridgeIntegrationSettings();
             if (settings.enabled) {
                 await probe(true);
             }
@@ -80,15 +83,15 @@ export function createCcrIntegrationService(deps) {
         },
         async updateSettings(input) {
             if (input.apiKey !== undefined && typeof input.apiKey !== "string") {
-                throw invalidSettingsError("CCR API key must be a string.");
+                throw invalidSettingsError("Codex Bridge API key must be a string.");
             }
             if (input.enabled !== undefined && typeof input.enabled !== "boolean") {
-                throw invalidSettingsError("CCR enabled state must be a boolean.");
+                throw invalidSettingsError("Codex Bridge enabled state must be a boolean.");
             }
             if (input.clearApiKey !== undefined && typeof input.clearApiKey !== "boolean") {
-                throw invalidSettingsError("CCR clear-key state must be a boolean.");
+                throw invalidSettingsError("Codex Bridge clear-key state must be a boolean.");
             }
-            const current = await deps.settings.getCcrIntegrationSettings();
+            const current = await deps.settings.getCodexBridgeIntegrationSettings();
             const clearApiKey = input.clearApiKey === true;
             const nextApiKey = clearApiKey
                 ? ""
@@ -99,7 +102,7 @@ export function createCcrIntegrationService(deps) {
             if (nextEnabled && !nextApiKey) {
                 throw missingApiKeyError();
             }
-            await deps.settings.updateCcrIntegrationSettings({
+            await deps.settings.updateCodexBridgeIntegrationSettings({
                 enabled: nextEnabled,
                 apiKey: nextApiKey
             });
@@ -114,64 +117,65 @@ export function createCcrIntegrationService(deps) {
             return buildStatus();
         },
         async checkConnection() {
-            const settings = await deps.settings.getCcrIntegrationSettings();
+            const settings = await deps.settings.getCodexBridgeIntegrationSettings();
             if (!settings.enabled) {
                 throw new VcmError({
-                    code: "CCR_DISABLED",
-                    message: "CCR GPT models are disabled.",
+                    code: "CODEX_BRIDGE_DISABLED",
+                    message: "Codex Bridge models are disabled.",
                     statusCode: 409,
-                    hint: "Save the CCR API key and enable CCR GPT models before checking the connection."
+                    hint: "Save the Codex Bridge API key and enable Codex models before checking the connection."
                 });
             }
             await probe(true);
             return buildStatus();
         },
         async getLaunchEnvironment(model) {
-            if (!isCcrSessionModel(model)) {
+            if (!isCodexBridgeSessionModel(model)) {
                 return buildNativeLaunchEnvironment(baseEnv);
             }
-            const settings = await deps.settings.getCcrIntegrationSettings();
+            const settings = await deps.settings.getCodexBridgeIntegrationSettings();
             if (!settings.enabled) {
                 throw new VcmError({
-                    code: "CCR_DISABLED",
-                    message: "CCR GPT models are disabled.",
+                    code: "CODEX_BRIDGE_DISABLED",
+                    message: "Codex Bridge models are disabled.",
                     statusCode: 409,
-                    hint: "Enable CCR GPT models in VCM Settings before starting this session."
+                    hint: "Enable Codex Bridge in VCM Settings before starting this session."
                 });
             }
             const checked = await probe();
-            if (checked.result.connectionState !== "available" || !checked.result.modelAvailable) {
+            const modelId = getCodexBridgeModelId(model);
+            const modelAvailable = checked.result.models.some((available) => available.id === modelId);
+            if (checked.result.connectionState !== "available" || !modelAvailable) {
                 throw new VcmError({
-                    code: "CCR_MODEL_UNAVAILABLE",
-                    message: checked.result.error ?? `CCR model ${CCR_GPT_MODEL_ID} is unavailable.`,
+                    code: "CODEX_BRIDGE_MODEL_UNAVAILABLE",
+                    message: checked.result.error ?? `Codex Bridge model ${modelId} is unavailable.`,
                     statusCode: 409,
-                    hint: "Check that host CCR is running on port 3456 and exposes GPT-5.6 Sol."
+                    hint: "Check Codex Bridge on port 3456, refresh its Codex login, and verify the selected model."
                 });
             }
-            const gatewayBaseUrl = checked.result.baseUrl ?? CCR_GATEWAY_BASE_URL;
-            const gatewayHost = new URL(gatewayBaseUrl).hostname;
-            const noProxy = mergeNoProxy(deps.baseEnv?.NO_PROXY ?? deps.baseEnv?.no_proxy ?? process.env.NO_PROXY ?? process.env.no_proxy, gatewayHost);
+            const bridgeBaseUrl = checked.result.baseUrl ?? CODEX_BRIDGE_BASE_URL;
+            const bridgeHost = new URL(bridgeBaseUrl).hostname;
+            const noProxy = mergeNoProxy(deps.baseEnv?.NO_PROXY ?? deps.baseEnv?.no_proxy ?? process.env.NO_PROXY ?? process.env.no_proxy, bridgeHost);
             return {
-                ANTHROPIC_BASE_URL: gatewayBaseUrl,
-                ANTHROPIC_API_BASE_URL: gatewayBaseUrl,
-                CLAUDE_AGENT_API_BASE_URL: gatewayBaseUrl,
+                ANTHROPIC_BASE_URL: bridgeBaseUrl,
+                ANTHROPIC_API_BASE_URL: bridgeBaseUrl,
+                CLAUDE_AGENT_API_BASE_URL: bridgeBaseUrl,
                 ANTHROPIC_AUTH_TOKEN: undefined,
                 ANTHROPIC_API_KEY: undefined,
-                ANTHROPIC_MODEL: CCR_GPT_MODEL_ID,
-                CCR_CLAUDE_CODE_MODEL: CCR_GPT_MODEL_ID,
-                CODEXL_CLAUDE_CODE_MODEL: CCR_GPT_MODEL_ID,
-                ANTHROPIC_SMALL_FAST_MODEL: CCR_GPT_MODEL_ID,
+                ANTHROPIC_MODEL: modelId,
+                CODEX_BRIDGE_CLAUDE_MODEL: modelId,
+                ANTHROPIC_SMALL_FAST_MODEL: modelId,
                 CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1",
-                CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(CCR_GPT_EFFECTIVE_CONTEXT_TOKENS),
-                CLAUDE_CODE_AUTO_COMPACT_WINDOW: String(CCR_GPT_AUTO_COMPACT_WINDOW_TOKENS),
-                CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: String(CCR_GPT_AUTO_COMPACT_PERCENT),
+                CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(CODEX_BRIDGE_EFFECTIVE_CONTEXT_TOKENS),
+                CLAUDE_CODE_AUTO_COMPACT_WINDOW: String(CODEX_BRIDGE_AUTO_COMPACT_WINDOW_TOKENS),
+                CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: String(CODEX_BRIDGE_AUTO_COMPACT_PERCENT),
                 CLAUDE_CONFIG_DIR: configDir,
                 NO_PROXY: noProxy,
                 no_proxy: noProxy
             };
         },
         async getLaunchSettingsOverride(model) {
-            if (!isCcrSessionModel(model)) {
+            if (!isCodexBridgeSessionModel(model)) {
                 return undefined;
             }
             return {
@@ -180,51 +184,50 @@ export function createCcrIntegrationService(deps) {
         }
     };
 }
-const CCR_BASE_URL_KEYS = [
+const BRIDGE_BASE_URL_KEYS = [
     "ANTHROPIC_BASE_URL",
     "ANTHROPIC_API_BASE_URL",
     "CLAUDE_AGENT_API_BASE_URL"
 ];
-const CCR_MODEL_KEYS = [
+const BRIDGE_MODEL_KEYS = [
     "ANTHROPIC_MODEL",
     "ANTHROPIC_SMALL_FAST_MODEL"
 ];
-const CCR_ONLY_ENV_KEYS = [
-    "CCR_CLAUDE_CODE_MODEL",
-    "CODEXL_CLAUDE_CODE_MODEL",
+const BRIDGE_ONLY_ENV_KEYS = [
+    "CODEX_BRIDGE_CLAUDE_MODEL",
     "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"
 ];
 export function buildNativeLaunchEnvironment(baseEnv) {
     const environment = {};
-    let inheritedCcrTakeover = false;
+    let inheritedBridgeTakeover = false;
     if (baseEnv.CLAUDE_CONFIG_DIR?.trim()) {
         environment.CLAUDE_CONFIG_DIR = baseEnv.CLAUDE_CONFIG_DIR.trim();
     }
-    for (const key of CCR_BASE_URL_KEYS) {
-        if (isCcrGatewayUrl(baseEnv[key])) {
+    for (const key of BRIDGE_BASE_URL_KEYS) {
+        if (isCodexBridgeUrl(baseEnv[key])) {
             environment[key] = undefined;
-            inheritedCcrTakeover = true;
+            inheritedBridgeTakeover = true;
         }
     }
-    for (const key of CCR_MODEL_KEYS) {
-        if (isCcrModelName(baseEnv[key])) {
+    for (const key of BRIDGE_MODEL_KEYS) {
+        if (isCodexBridgeModelName(baseEnv[key], baseEnv.CODEX_BRIDGE_CLAUDE_MODEL)) {
             environment[key] = undefined;
-            inheritedCcrTakeover = true;
+            inheritedBridgeTakeover = true;
         }
     }
-    for (const key of CCR_ONLY_ENV_KEYS) {
+    for (const key of BRIDGE_ONLY_ENV_KEYS) {
         if (baseEnv[key] !== undefined) {
             environment[key] = undefined;
-            inheritedCcrTakeover = true;
+            inheritedBridgeTakeover = true;
         }
     }
-    if (inheritedCcrTakeover) {
+    if (inheritedBridgeTakeover) {
         environment.ANTHROPIC_AUTH_TOKEN = undefined;
         environment.ANTHROPIC_API_KEY = undefined;
     }
     return environment;
 }
-function isCcrGatewayUrl(value) {
+function isCodexBridgeUrl(value) {
     if (!value) {
         return false;
     }
@@ -237,32 +240,29 @@ function isCcrGatewayUrl(value) {
         return false;
     }
 }
-function isCcrModelName(value) {
-    if (!value) {
-        return false;
-    }
-    return value === CCR_GPT_MODEL_ID
-        || value.startsWith("anthropic/claude-ccr-h");
+function isCodexBridgeModelName(value, bridgeModel) {
+    return Boolean(value && bridgeModel && value === bridgeModel);
 }
 function createStatus(input) {
+    const { models, ...status } = input;
     const reason = input.error
-        ?? (input.enabled ? "CCR GPT-5.6 Sol is unavailable." : "Enable CCR GPT models in Settings.");
+        ?? (input.enabled ? "Codex Bridge models are unavailable." : "Enable Codex Bridge in Settings.");
     return {
-        ...input,
-        modelOptions: createSessionModelOptions(input.enabled && input.modelAvailable, reason)
+        ...status,
+        modelOptions: createSessionModelOptions(models, input.enabled && input.modelAvailable ? undefined : reason)
     };
 }
 function missingApiKeyError() {
     return new VcmError({
-        code: "CCR_API_KEY_MISSING",
-        message: "CCR API key is not configured.",
+        code: "CODEX_BRIDGE_API_KEY_MISSING",
+        message: "Codex Bridge API key is not configured.",
         statusCode: 400,
-        hint: "Save the CCR API key before enabling CCR GPT models."
+        hint: "Save the Codex Bridge API key before enabling Codex models."
     });
 }
 function invalidSettingsError(message) {
     return new VcmError({
-        code: "CCR_SETTINGS_INVALID",
+        code: "CODEX_BRIDGE_SETTINGS_INVALID",
         message,
         statusCode: 400
     });

package/dist/backend/services/session-service.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { ROLE_NAMES, isDispatchableRole } from "../../shared/constants.js";
-import { CCR_GPT_SESSION_MODEL, isCcrSessionModel } from "../../shared/types/session.js";
+import { isCodexBridgeSessionModel } from "../../shared/types/session.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -598,21 +598,21 @@ export function createSessionService(deps) {
         return migrateRunningProjectToolSessionCwd(repoRoot, resumed, targetCwd);
     }
     async function getModelLaunchEnvironment(model) {
-        if (!deps.ccrIntegration) {
-            if (isCcrSessionModel(model)) {
+        if (!deps.codexBridgeIntegration) {
+            if (isCodexBridgeSessionModel(model)) {
                 throw new VcmError({
-                    code: "CCR_UNAVAILABLE",
-                    message: "CCR integration is not available in this VCM runtime.",
+                    code: "CODEX_BRIDGE_UNAVAILABLE",
+                    message: "Codex Bridge integration is not available in this VCM runtime.",
                     statusCode: 409,
-                    hint: "Enable and configure CCR GPT models before starting this session."
+                    hint: "Enable and configure Codex Bridge before starting this session."
                 });
             }
             return {};
         }
-        return deps.ccrIntegration.getLaunchEnvironment(model);
+        return deps.codexBridgeIntegration.getLaunchEnvironment(model);
     }
     async function getModelLaunchSettingsOverride(model) {
-        return deps.ccrIntegration?.getLaunchSettingsOverride(model);
+        return deps.codexBridgeIntegration?.getLaunchSettingsOverride(model);
     }
     function isRuntimeSessionAlive(session) {
         if (!session || isExitedStatus(session.status) || session.pid === undefined) {
@@ -1642,7 +1642,7 @@ function normalizeClaudeModel(value) {
         || value === "claude-opus-4-8"
         || value === "sonnet"
         || value === "fable"
-        || value === CCR_GPT_SESSION_MODEL) {
+        || isCodexBridgeSessionModel(value)) {
         return value;
     }
     return "default";
@@ -1660,20 +1660,20 @@ function normalizeClaudeEffort(value) {
 }
 function assertResumeProviderCompatible(session, requestedModel) {
     const persistedModel = normalizeClaudeModel(session.model);
-    if (isCcrSessionModel(persistedModel) !== isCcrSessionModel(requestedModel)) {
+    if (isCodexBridgeSessionModel(persistedModel) !== isCodexBridgeSessionModel(requestedModel)) {
         throw new VcmError({
             code: "SESSION_PROVIDER_SWITCH_REQUIRES_RESTART",
             message: `Cannot resume ${session.role} with a different model provider.`,
             statusCode: 409,
-            hint: "Use Restart to switch between native Claude and CCR models."
+            hint: "Use Restart to switch between native Claude and Codex Bridge models."
         });
     }
-    if (isCcrSessionModel(requestedModel) && !session.claudeConfigDir) {
+    if (isCodexBridgeSessionModel(requestedModel) && !session.claudeConfigDir) {
         throw new VcmError({
-            code: "CCR_SESSION_CONFIG_MISSING",
-            message: `${session.role} was created before isolated CCR session storage was enabled.`,
+            code: "CODEX_BRIDGE_SESSION_CONFIG_MISSING",
+            message: `${session.role} was created without isolated Codex Bridge session storage.`,
             statusCode: 409,
-            hint: "Restart this role once to create an isolated CCR session."
+            hint: "Restart this role once to create an isolated Codex Bridge session."
         });
     }
 }
@@ -1713,7 +1713,7 @@ function buildUsageTelemetryEnvironment(apiUrl, role, model) {
         OTEL_LOG_TOOL_DETAILS: "0",
         OTEL_LOG_RAW_API_BODIES: "0"
     };
-    if (!apiUrl || isCcrSessionModel(model)) {
+    if (!apiUrl || isCodexBridgeSessionModel(model)) {
         return disabled;
     }
     return {

package/dist/backend/services/usage-analytics-service.js

@@ -76,7 +76,7 @@ function extractApiRequestEvents(payload) {
                     continue;
                 }
                 const model = normalizeModel(readString(attributes.model));
-                if (isCcrModel(model)) {
+                if (isCodexBridgeModel(model)) {
                     continue;
                 }
                 const sequence = readInteger(attributes["event.sequence"]);
@@ -334,9 +334,9 @@ function normalizeModel(input) {
     const model = input?.slice(0, 200).trim();
     return model && isSafeGroupKey(model) ? model : "unknown";
 }
-function isCcrModel(model) {
+function isCodexBridgeModel(model) {
     const normalized = model.toLowerCase();
-    return normalized.startsWith("gpt-") || normalized.startsWith("ccr:") || normalized.includes("codex api/");
+    return normalized.startsWith("gpt-") || normalized.startsWith("codex-bridge:");
 }
 function isSafeGroupKey(value) {
     return value !== "__proto__" && value !== "prototype" && value !== "constructor";

package/dist/shared/types/session.js

@@ -52,32 +52,38 @@ export const CLAUDE_MODEL_OPTIONS = [
         available: true
     }
 ];
-export const CCR_LOCAL_GATEWAY_BASE_URL = "http://127.0.0.1:3456";
-export const CCR_CONTAINER_GATEWAY_BASE_URL = "http://host.docker.internal:3456";
-export const CCR_GATEWAY_BASE_URL = CCR_CONTAINER_GATEWAY_BASE_URL;
-export const CCR_GATEWAY_BASE_URLS = [
-    CCR_LOCAL_GATEWAY_BASE_URL,
-    CCR_CONTAINER_GATEWAY_BASE_URL
+export const CODEX_BRIDGE_LOCAL_BASE_URL = "http://127.0.0.1:3456";
+export const CODEX_BRIDGE_CONTAINER_BASE_URL = "http://host.docker.internal:3456";
+export const CODEX_BRIDGE_BASE_URL = CODEX_BRIDGE_CONTAINER_BASE_URL;
+export const CODEX_BRIDGE_BASE_URLS = [
+    CODEX_BRIDGE_LOCAL_BASE_URL,
+    CODEX_BRIDGE_CONTAINER_BASE_URL
 ];
-export const CCR_GPT_MODEL_ID = "Codex API/gpt-5.6-sol";
-export const CCR_GPT_SESSION_MODEL = `ccr:${CCR_GPT_MODEL_ID}`;
-export const CCR_GPT_EFFECTIVE_CONTEXT_TOKENS = 258_400;
-export const CCR_GPT_AUTO_COMPACT_WINDOW_TOKENS = CCR_GPT_EFFECTIVE_CONTEXT_TOKENS;
-export const CCR_GPT_AUTO_COMPACT_PERCENT = 90;
-export function isCcrSessionModel(model) {
-    return model === CCR_GPT_SESSION_MODEL;
+export const CODEX_BRIDGE_EFFECTIVE_CONTEXT_TOKENS = 258_400;
+export const CODEX_BRIDGE_AUTO_COMPACT_WINDOW_TOKENS = CODEX_BRIDGE_EFFECTIVE_CONTEXT_TOKENS;
+export const CODEX_BRIDGE_AUTO_COMPACT_PERCENT = 90;
+export function isCodexBridgeSessionModel(model) {
+    return typeof model === "string"
+        && model.startsWith("codex-bridge:")
+        && model.length > "codex-bridge:".length;
 }
-export function createSessionModelOptions(ccrAvailable = false, unavailableReason = "CCR GPT models are unavailable.") {
+export function toCodexBridgeSessionModel(modelId) {
+    return `codex-bridge:${modelId}`;
+}
+export function getCodexBridgeModelId(model) {
+    return model.slice("codex-bridge:".length);
+}
+export function createSessionModelOptions(codexBridgeModels = [], unavailableReason) {
     return [
         ...CLAUDE_MODEL_OPTIONS,
-        {
-            value: CCR_GPT_SESSION_MODEL,
-            label: "GPT-5.6 Sol (CCR)",
-            description: "GPT-5.6 Sol through the host CCR gateway",
-            source: "ccr",
-            available: ccrAvailable,
-            ...(ccrAvailable ? {} : { unavailableReason })
-        }
+        ...codexBridgeModels.map((model) => ({
+            value: toCodexBridgeSessionModel(model.id),
+            label: `${model.displayName ?? model.id} (Codex Bridge)`,
+            description: `${model.id} through the host Codex Bridge`,
+            source: "codex-bridge",
+            available: unavailableReason === undefined,
+            ...(unavailableReason === undefined ? {} : { unavailableReason })
+        }))
     ];
 }
 const BASE_EFFORT_OPTIONS = [