march-cli 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",

package/src/agent/runner.mjs

@@ -18,16 +18,17 @@ import { resolveRunnerSessionOptions } from "./session/session-options.mjs";
 import { createSessionBinding } from "./session/session-binding.mjs";
 import { maybeAutoNameSession } from "./session/session-auto-name.mjs";
 import { MARCH_BASE_TOOL_NAMES } from "./tool-names.mjs";
-import { isModelStreamIdleTimeoutError, runRunnerTurn } from "./turn/turn-runner.mjs";
+import { runRunnerTurn } from "./turn/turn-runner.mjs";
 import { appendFastVariants, createFastModelEntry, fromFastEntryModel, isFastProvider } from "./runner/fast-model.mjs";
 import { registerSuperGrokProvider } from "../supergrok/provider.mjs";
+import { registerCustomProviders } from "../provider/custom-provider.mjs";
 
 export { MARCH_BASE_TOOL_NAMES };
 export { installModelPayloadDumper } from "./model-payload-dumper.mjs";
 export { createDefaultSessionManager, resolveRunnerSessionManager } from "./runner/runner-init.mjs";
 export { getRunnerSessionStats, syncEngineSessionState } from "./runner/runner-session-state.mjs";
 
-export async function createRunner({ cwd, modelId = null, provider = null, providers = {}, stateRoot, ui, memoryRoot = null, centerMemoryPath = null, memoryStore = null, memoryTools = [], shellRuntime = null, mcpTools = [], mcpInjections = [], mcpClientManager = null, webTools = [], namespace = "", sessionManager = null, useRuntimeHost = false, projectMarchDir = null, syncPiSidecar = false, extensionPaths = [], lifecycleHooks = [], lifecycleDiagnostics = [], authStorage = null, permissionController = null, modelContextDumper = null, turnNotifier = null, onModelPayload = null, createAgentSessionImpl = createAgentSession, createAgentSessionRuntimeImpl, createRuntimeServices, createRuntimeSessionFromServices, maxTurns, trimBatch, serviceTier = null, modelStreamIdleTimeoutMs = 7000, modelStreamIdleMaxRetries = 5 }) {
+export async function createRunner({ cwd, modelId = null, provider = null, providers = {}, stateRoot, ui, memoryRoot = null, centerMemoryPath = null, memoryStore = null, memoryTools = [], shellRuntime = null, mcpTools = [], mcpInjections = [], mcpClientManager = null, webTools = [], namespace = "", sessionManager = null, useRuntimeHost = false, projectMarchDir = null, syncPiSidecar = false, extensionPaths = [], lifecycleHooks = [], lifecycleDiagnostics = [], authStorage = null, permissionController = null, modelContextDumper = null, turnNotifier = null, onModelPayload = null, createAgentSessionImpl = createAgentSession, createAgentSessionRuntimeImpl, createRuntimeServices, createRuntimeSessionFromServices, maxTurns, trimBatch, serviceTier = null }) {
   if (!useRuntimeHost && extensionPaths.length > 0) {
     throw new Error("--extension requires the default pi runtime host path");
   }
@@ -38,6 +39,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
   const resolvedAuth = authConfig.authStorage;
   const modelRegistry = ModelRegistry.create(resolvedAuth);
   registerSuperGrokProvider(modelRegistry);
+  registerCustomProviders(modelRegistry, providers);
   const selectedModel = resolveInitialModel({ modelRegistry, provider, modelId });
   if (!selectedModel) throw new Error("No authenticated models available. Run: march provider --config");
   provider = selectedModel.provider;
@@ -63,6 +65,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
     runtimeHost = await createRunnerRuntimeHost({
       cwd, stateRoot, provider, modelId,
       authStorage: resolvedAuth, settingsManager, modelRegistry,
+      providers,
       sessionManager: resolvedSessionManager, sessionBinding, engine, ui,
       projectMarchDir,
       memoryTools, memoryStore, shellRuntime, lspService, mcpTools, webTools,
@@ -113,7 +116,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       const turnStartedAt = Date.now();
       try {
         const result = await runRunnerTurn({
-          prompt, userMessage, options: { userRecallHints, currentProject, modelStreamIdleTimeoutMs, modelStreamIdleMaxRetries },
+          prompt, userMessage, options: { userRecallHints, currentProject },
           sessionBinding, engine, ui, projectMarchDir, memoryStore,
           setModelCallKind: (kind) => { currentModelCallKind = kind; },
           onMidTurnRecallHints: (hints) => { pendingMidTurnRecallHints.push(...hints); },
@@ -129,9 +132,6 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
         });
         return result;
       } catch (err) {
-        if (isModelStreamIdleTimeoutError(err)) {
-          nextTurnContextMode = "continueExistingPiTranscript";
-        }
         lastNotificationResult = await notifyTurnEndBestEffort(turnNotifier, {
           status: "error",
           sessionName: engine.sessionName,

package/src/agent/runtime/runner-runtime-host.mjs

@@ -3,6 +3,7 @@ import { createMarchRuntimeFactory } from "./runtime-factory.mjs";
 import { createRuntimeHost } from "./runtime-host.mjs";
 import { resolveRunnerSessionOptions } from "../session/session-options.mjs";
 import { registerSuperGrokProvider } from "../../supergrok/provider.mjs";
+import { registerCustomProviders } from "../../provider/custom-provider.mjs";
 
 export async function createRunnerRuntimeHost({
   cwd,
@@ -12,6 +13,7 @@ export async function createRunnerRuntimeHost({
   authStorage,
   settingsManager,
   modelRegistry,
+  providers = {},
   sessionManager,
   sessionBinding,
   engine,
@@ -42,6 +44,7 @@ export async function createRunnerRuntimeHost({
     resolveSessionOptions: ({ cwd: sessionCwd, services }) => {
       const activeModelRegistry = services.modelRegistry ?? modelRegistry;
       registerSuperGrokProvider(activeModelRegistry);
+      registerCustomProviders(activeModelRegistry, providers);
       return resolveRunnerSessionOptions({
         cwd: sessionCwd,
         provider,

package/src/agent/turn/turn-runner.mjs

@@ -1,10 +1,6 @@
 import { resolveImageAttachmentReferences } from "../../session/attachment-references.mjs";
 import { closeAssistantReply, createTurnEventState, handleRunnerSessionEvent } from "./turn-events.mjs";
 
-export function isModelStreamIdleTimeoutError(err) {
-  return err?.code === "MODEL_STREAM_IDLE_TIMEOUT";
-}
-
 export async function runRunnerTurn({
   prompt,
   userMessage,
@@ -23,21 +19,13 @@ export async function runRunnerTurn({
   const {
     userRecallHints = [],
     currentProject = "",
-    modelStreamIdleTimeoutMs = 7000,
-    modelStreamIdleMaxRetries = 5,
   } = options;
   const activeSession = sessionBinding.get();
   const turnState = createTurnEventState();
   const midTurnRecallHints = [];
-  const modelIdleWatchdog = createModelStreamIdleWatchdog({
-    session: activeSession,
-    ui,
-    timeoutMs: modelStreamIdleTimeoutMs,
-  });
   ui.turnStart();
 
   const unsubscribe = activeSession.subscribe((event) => {
-    modelIdleWatchdog.handleEvent(event);
     handleRunnerSessionEvent(event, { ui, engine, state: turnState });
     if (event.type === "tool_execution_start") {
       const hints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });
@@ -56,32 +44,12 @@ export async function runRunnerTurn({
     });
     setModelCallKind("user");
     try {
-      await promptWithModelIdleRetry({
-        session: activeSession,
-        prompt: contextMode === "continueExistingPiTranscript" ? (userMessage ?? prompt) : prompt,
-        promptOptions: attachmentReferences.images.length > 0 ? { images: attachmentReferences.images } : undefined,
-        resetBeforeAttempt: contextMode === "rebuild",
-        maxRetries: modelStreamIdleMaxRetries,
-        watchdog: modelIdleWatchdog,
-      });
-    } catch (err) {
-      if (!isModelStreamIdleTimeoutError(err)) throw err;
-      finalizeTurn({
-        prompt,
-        userMessage,
-        userRecallHints,
-        currentProject,
-        memoryStore,
-        engine,
-        ui,
-        turnState,
-        midTurnRecallHints,
-        syncCurrentPiSidecar,
-        autoNameSession,
-      });
-      throw err;
+      if (contextMode === "rebuild") resetPiMessageHistory(activeSession);
+      await activeSession.prompt(
+        contextMode === "continueExistingPiTranscript" ? (userMessage ?? prompt) : prompt,
+        attachmentReferences.images.length > 0 ? { images: attachmentReferences.images } : undefined,
+      );
     } finally {
-      modelIdleWatchdog.stop();
       setModelCallKind("model");
     }
 
@@ -105,38 +73,6 @@ export async function runRunnerTurn({
   }
 }
 
-async function promptWithModelIdleRetry({ session, prompt, promptOptions, resetBeforeAttempt, maxRetries, watchdog }) {
-  let attempt = 0;
-  while (true) {
-    attempt += 1;
-    if (resetBeforeAttempt) resetPiMessageHistory(session);
-    const messageHistorySnapshot = clonePiMessageHistory(session);
-    watchdog.startAttempt({ attempt, maxAttempts: maxRetries + 1 });
-    let idleTimedOut = false;
-    try {
-      await session.prompt(prompt, promptOptions);
-      idleTimedOut = watchdog.consumeTimedOut();
-      if (!idleTimedOut) {
-        if (attempt > 1) watchdog.reportRecovered({ attempt: attempt - 1 });
-        return;
-      }
-    } catch (err) {
-      idleTimedOut = watchdog.consumeTimedOut();
-      if (!idleTimedOut) throw err;
-    } finally {
-      watchdog.stop();
-    }
-
-    if (attempt > maxRetries) {
-      const err = createModelStreamIdleTimeoutError(watchdog.timeoutMs);
-      watchdog.reportExhausted({ attempt, error: err });
-      throw err;
-    }
-    restorePiMessageHistory(session, messageHistorySnapshot);
-    watchdog.reportRetry({ attempt, maxAttempts: maxRetries + 1 });
-  }
-}
-
 function finalizeTurn({ prompt, userMessage, userRecallHints, currentProject, memoryStore, engine, ui, turnState, midTurnRecallHints, syncCurrentPiSidecar, autoNameSession }) {
   closeAssistantReply({ ui, state: turnState });
   const assistantRecallHints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });
@@ -154,95 +90,6 @@ function finalizeTurn({ prompt, userMessage, userRecallHints, currentProject, me
   syncCurrentPiSidecar();
 }
 
-function createModelStreamIdleTimeoutError(timeoutMs) {
-  const err = new Error(`Model stream idle for ${timeoutMs}ms`);
-  err.code = "MODEL_STREAM_IDLE_TIMEOUT";
-  return err;
-}
-
-function createModelStreamIdleWatchdog({ session, ui, timeoutMs }) {
-  let timer = null;
-  let active = false;
-  let inTool = false;
-  let timedOut = false;
-
-  return {
-    timeoutMs,
-    startAttempt() {
-      timedOut = false;
-      inTool = false;
-      active = true;
-      arm();
-    },
-    handleEvent(event) {
-      if (!active || timedOut) return;
-      if (event.type === "tool_execution_start") {
-        inTool = true;
-        clear();
-        return;
-      }
-      if (event.type === "tool_execution_end") {
-        inTool = false;
-        arm();
-        return;
-      }
-      if (event.type === "message_update") arm();
-    },
-    stop() {
-      active = false;
-      clear();
-    },
-    consumeTimedOut() {
-      const value = timedOut;
-      timedOut = false;
-      return value;
-    },
-    reportRetry({ attempt, maxAttempts }) {
-      ui.retryStart?.({
-        attempt,
-        maxAttempts,
-        delayMs: 0,
-        errorMessage: `Model stream idle for ${timeoutMs}ms; retrying request`,
-      });
-    },
-    reportRecovered({ attempt }) {
-      ui.retryEnd?.({ success: true, attempt });
-    },
-    reportExhausted({ attempt, error }) {
-      ui.retryEnd?.({ success: false, attempt, finalError: error.message });
-    },
-  };
-
-  function arm() {
-    clear();
-    if (!active || inTool || timeoutMs <= 0) return;
-    timer = setTimeout(() => {
-      timedOut = true;
-      active = false;
-      clear();
-      session.abortRetry?.();
-      session.abort();
-    }, timeoutMs);
-  }
-
-  function clear() {
-    if (!timer) return;
-    clearTimeout(timer);
-    timer = null;
-  }
-}
-
-function clonePiMessageHistory(session) {
-  const messages = session?.agent?.state?.messages;
-  if (!Array.isArray(messages)) return null;
-  return JSON.parse(JSON.stringify(messages));
-}
-
-function restorePiMessageHistory(session, messages) {
-  if (!Array.isArray(session?.agent?.state?.messages) || !Array.isArray(messages)) return;
-  session.agent.state.messages = JSON.parse(JSON.stringify(messages));
-}
-
 function flushAssistantRecall({ memoryStore, engine, turnState, currentProject }) {
   if (!memoryStore) return [];
   const text = assistantRecallDeltaText(turnState);

package/src/auth/storage.mjs

@@ -13,11 +13,12 @@ export function createMarchAuthStorage({
 } = {}) {
   const resolvedAuthStorage = authStorage ?? AuthStorage.create(getMarchAuthPath(homeDir));
 
-  for (const profile of Object.values(providers ?? {})) {
+  for (const [id, profile] of Object.entries(providers ?? {})) {
     if (!profile || typeof profile !== "object") continue;
     const type = profile.type ?? profile.provider;
+    const providerKey = type === "openai-compatible" ? id : type;
     const profileKey = profile.auth?.method === "apiKey" ? profile.auth?.apiKey : null;
-    if (type && profileKey) resolvedAuthStorage.setRuntimeApiKey(type, profileKey);
+    if (providerKey && profileKey) resolvedAuthStorage.setRuntimeApiKey(providerKey, profileKey);
   }
   const hasStoredAuth = Boolean(resolvedAuthStorage.list?.().length);
   const hasConfiguredProvider = Object.values(providers ?? {}).some((profile) => {

package/src/cli/commands/model-command.mjs

@@ -1,6 +1,34 @@
 import { getProviderLabel } from "../../provider/presets.mjs";
 import { globalConfigJsonPath, upsertModelSelection } from "../../config/config-json.mjs";
 
+// Deduplicate models by id, preferring canonical providers.
+// When the same model id appears under multiple providers (e.g. supergrok-oauth
+// and xai-oauth), keep only the entry with the preferred provider.
+const PREFERRED_PROVIDERS = ["supergrok-oauth"];
+
+function dedupByModelId(scopedModels) {
+  const seen = new Map();
+  const result = [];
+  for (const entry of scopedModels) {
+    const { model } = entry;
+    const existing = seen.get(model.id);
+    if (!existing) {
+      seen.set(model.id, entry);
+      result.push(entry);
+    } else {
+      // Prefer canonical provider when duplicates exist
+      const existingPref = PREFERRED_PROVIDERS.indexOf(existing.model.provider);
+      const currentPref = PREFERRED_PROVIDERS.indexOf(model.provider);
+      if (currentPref !== -1 && (existingPref === -1 || currentPref < existingPref)) {
+        const idx = result.indexOf(existing);
+        result[idx] = entry;
+        seen.set(model.id, entry);
+      }
+    }
+  }
+  return result;
+}
+
 export function parseModelCommand(input) {
   if (input !== "/model" && !input.startsWith("/model ")) {
     return { type: "none" };
@@ -21,9 +49,10 @@ export async function selectModelByIndex(index, { runner }) {
 }
 
 export function buildModelSelectItems({ current, scopedModels = [] }) {
-  return scopedModels.map(({ model }, index) => ({
+  const deduped = dedupByModelId(scopedModels);
+  return deduped.map(({ model }, index) => ({
     value: String(index),
-    label: `${getProviderLabel(model.provider)} / ${model.name || model.id}`,
+    label: `${model.name || model.id} (${getProviderLabel(model.provider)})`,
     description: current && model.id === current.id && model.provider === current.provider ? "current" : model.provider,
     model,
   }));
@@ -34,19 +63,20 @@ export async function handleModelCommand(parsed, { runner, ui = null, configHome
     const scopedModels = runner.getScopedModels?.() || [];
     if (!ui?.selectList || scopedModels.length === 0) return "Use Ctrl+L to choose a model.";
     const current = runner.getCurrentModel?.();
-    const selectedIndex = Math.max(0, scopedModels.findIndex(({ model }) =>
-      current && model.id === current.id && model.provider === current.provider
+    const items = buildModelSelectItems({ current, scopedModels });
+    const selectedIndex = Math.max(0, items.findIndex((item) =>
+      current && item.model.id === current.id && item.model.provider === current.provider
     ));
-    const item = await ui.selectList({
-      items: buildModelSelectItems({ current, scopedModels }),
+    const selectedItem = await ui.selectList({
+      items,
       selectedIndex,
       width: 72,
       suppressInitialConfirm: true,
       searchable: true,
       getSearchText: modelSelectSearchText,
     });
-    if (!item) return "Model unchanged.";
-    const model = await runner.setModel(item.model);
+    if (!selectedItem) return "Model unchanged.";
+    const model = await runner.setModel(selectedItem.model);
     persistModelSelection(model, { configHomeDir });
     return `Model: ${model.name || model.id} (${model.provider})`;
   }
@@ -85,8 +115,9 @@ export function formatModelsList({ current, scopedModels = [] }) {
 }
 
 function formatGroupedModels({ current, scopedModels }) {
+  const deduped = dedupByModelId(scopedModels);
   const groups = new Map();
-  for (const item of scopedModels) {
+  for (const item of deduped) {
     const provider = item.model.provider;
     if (!groups.has(provider)) groups.set(provider, []);
     groups.get(provider).push(item);

package/src/cli/commands/provider-command.mjs

@@ -11,8 +11,12 @@ export function parseProviderCommand(input) {
 
 export function listProviders({ runner }) {
   const scopedModels = runner.getScopedModels?.() || [];
+  const seen = new Set();
   const providers = new Map();
   for (const { model } of scopedModels) {
+    // Deduplicate: skip models that differ only by provider (e.g. supergrok-oauth vs xai-oauth)
+    if (seen.has(model.id)) continue;
+    seen.add(model.id);
     if (!providers.has(model.provider)) {
       providers.set(model.provider, {
         provider: model.provider,

package/src/cli/tui/tui-handlers.mjs

@@ -76,19 +76,20 @@ export function wireTuiHandlers({
       const scopedModels = runner.getScopedModels?.() || [];
       if (ui.selectList && scopedModels.length > 0) {
         const current = runner.getCurrentModel?.();
-        const selectedIndex = Math.max(0, scopedModels.findIndex(({ model }) =>
-          current && model.id === current.id && model.provider === current.provider
+        const items = buildModelSelectItems({ current, scopedModels });
+        const selectedIndex = Math.max(0, items.findIndex((item) =>
+          current && item.model.id === current.id && item.model.provider === current.provider
         ));
-        const item = await ui.selectList({
-          items: buildModelSelectItems({ current, scopedModels }),
+        const selectedItem = await ui.selectList({
+          items,
           selectedIndex,
           width: 72,
         });
-        if (!item) {
+        if (!selectedItem) {
           ui.writeln(brightBlack(`● model: unchanged`));
           return;
         }
-        const model = await runner.setModel(item.model);
+        const model = await runner.setModel(selectedItem.model);
         persistModelSelection(model, { configHomeDir });
         const name = model.name || model.id;
         ui.writeln(brightBlack(`● model: ${name} (${model.provider})`));

package/src/provider/custom-provider.mjs

@@ -0,0 +1,112 @@
+const CUSTOM_PROVIDER_TYPE = "openai-compatible";
+const DEFAULT_API = "openai-completions";
+const SUPPORTED_APIS = new Set(["openai-completions", "openai-responses"]);
+const DEFAULT_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+
+export function registerCustomProviders(modelRegistry, providers = {}) {
+  if (!modelRegistry?.registerProvider) return [];
+  const registered = [];
+
+  for (const [providerId, profile] of Object.entries(providers ?? {})) {
+    if (!isCustomProviderProfile(profile)) continue;
+    modelRegistry.registerProvider(providerId, toProviderConfig(providerId, profile));
+    registered.push(providerId);
+  }
+
+  return registered;
+}
+
+export function isCustomProviderProfile(profile) {
+  return Boolean(profile && typeof profile === "object" && profile.type === CUSTOM_PROVIDER_TYPE);
+}
+
+function toProviderConfig(providerId, profile) {
+  const api = normalizeApi(providerId, profile.api ?? DEFAULT_API);
+  const baseUrl = requireString(providerId, "baseUrl", profile.baseUrl);
+  const models = normalizeModels(providerId, profile.models, { api, baseUrl });
+  return omitUndefined({
+    name: typeof profile.name === "string" && profile.name.trim() ? profile.name : providerId,
+    baseUrl,
+    apiKey: profile.auth?.method === "apiKey" ? profile.auth.apiKey : undefined,
+    api,
+    headers: normalizeHeaders(providerId, profile.headers),
+    authHeader: typeof profile.authHeader === "boolean" ? profile.authHeader : undefined,
+    models,
+  });
+}
+
+function normalizeModels(providerId, models, { api, baseUrl }) {
+  if (!Array.isArray(models) || models.length === 0) {
+    throw new Error(`Custom provider "${providerId}" requires a non-empty models array`);
+  }
+
+  return models.map((model, index) => {
+    if (!model || typeof model !== "object" || Array.isArray(model)) {
+      throw new Error(`Custom provider "${providerId}" model #${index + 1} must be an object`);
+    }
+    const id = requireString(providerId, `models[${index}].id`, model.id);
+    return omitUndefined({
+      ...model,
+      id,
+      name: typeof model.name === "string" && model.name.trim() ? model.name : id,
+      api: normalizeApi(providerId, model.api ?? api),
+      baseUrl: typeof model.baseUrl === "string" && model.baseUrl.trim() ? model.baseUrl : baseUrl,
+      reasoning: typeof model.reasoning === "boolean" ? model.reasoning : false,
+      input: normalizeInput(model.input),
+      cost: normalizeCost(model.cost),
+      contextWindow: normalizePositiveNumber(model.contextWindow, 128000),
+      maxTokens: normalizePositiveNumber(model.maxTokens, 4096),
+      headers: normalizeHeaders(providerId, model.headers),
+    });
+  });
+}
+
+function normalizeApi(providerId, api) {
+  if (typeof api !== "string" || !SUPPORTED_APIS.has(api)) {
+    throw new Error(`Custom provider "${providerId}" api must be "openai-completions" or "openai-responses"`);
+  }
+  return api;
+}
+
+function requireString(providerId, field, value) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`Custom provider "${providerId}" requires ${field}`);
+  }
+  return value;
+}
+
+function normalizeInput(input) {
+  if (!Array.isArray(input) || input.length === 0) return ["text"];
+  const normalized = input.filter((item) => item === "text" || item === "image");
+  return normalized.length > 0 ? normalized : ["text"];
+}
+
+function normalizeCost(cost) {
+  if (!cost || typeof cost !== "object" || Array.isArray(cost)) return DEFAULT_COST;
+  return {
+    input: normalizeNumber(cost.input, 0),
+    output: normalizeNumber(cost.output, 0),
+    cacheRead: normalizeNumber(cost.cacheRead, 0),
+    cacheWrite: normalizeNumber(cost.cacheWrite, 0),
+  };
+}
+
+function normalizeHeaders(providerId, headers) {
+  if (headers == null) return undefined;
+  if (typeof headers !== "object" || Array.isArray(headers)) {
+    throw new Error(`Custom provider "${providerId}" headers must be an object`);
+  }
+  return Object.fromEntries(Object.entries(headers).filter(([, value]) => typeof value === "string"));
+}
+
+function normalizePositiveNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+function normalizeNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function omitUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}

package/src/provider/presets.mjs

@@ -28,10 +28,10 @@ const PROVIDER_LABELS = {
   openai: "OpenAI",
   "openai-codex": "OpenAI Codex",
   openrouter: "OpenRouter",
-  "supergrok-oauth": "SuperGrok OAuth (xAI Subscription)",
+  "supergrok-oauth": "SuperGrok",
   "vercel-ai-gateway": "Vercel AI Gateway",
   xai: "xAI",
-  "xai-oauth": "xAI OAuth (SuperGrok compatible)",
+  "xai-oauth": "xAI OAuth",
   zai: "ZAI",
   xiaomi: "Xiaomi MiMo",
   "xiaomi-token-plan-cn": "Xiaomi MiMo Token Plan (China)",

package/src/supergrok/provider.mjs

@@ -14,7 +14,7 @@ export function registerSuperGrokProvider(modelRegistry) {
   if (!modelRegistry?.registerProvider) return;
   for (const providerId of [SUPERGROK_OAUTH_PROVIDER_ID, XAI_OAUTH_COMPAT_PROVIDER_ID]) {
     modelRegistry.registerProvider(providerId, {
-      name: providerId === SUPERGROK_OAUTH_PROVIDER_ID ? "SuperGrok OAuth (xAI Subscription)" : "xAI OAuth (SuperGrok compatible)",
+      name: providerId === SUPERGROK_OAUTH_PROVIDER_ID ? "SuperGrok" : "xAI OAuth",
       baseUrl: XAI_BASE_URL,
       api: "openai-responses",
       oauth: { ...superGrokOAuthProvider, id: providerId },
@@ -33,4 +33,4 @@ export function registerSuperGrokProvider(modelRegistry) {
 
 export function getDefaultSuperGrokModelId() {
   return DEFAULT_SUPERGROK_MODEL;
-}
+}