@xelauvas/xela-cli 0.2.3 → 0.3.1

package/bin/xela.js

@@ -183,6 +183,18 @@ try {
   }
 } catch {}
 
+// Ensure esbuild is available (may be missing in global installs)
+try {
+  await import('esbuild');
+} catch {
+  try {
+    execSync('npm install esbuild --no-save --no-audit --no-fund', {
+      cwd: INSTALL_DIR,
+      stdio: 'pipe',
+    });
+  } catch {}
+}
+
 // Launch node with the TSX loader shim
 try {
   execFileSync(process.execPath, [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xelauvas/xela-cli",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Xela — AI coding assistant powered by any model (OpenRouter, Groq, Ollama, DeepSeek, OpenAI)",
   "author": "xelauvas",
   "license": "MIT",
@@ -9,7 +9,17 @@
     "type": "git",
     "url": "https://github.com/xelauvas/codeclau.git"
   },
-  "keywords": ["ai", "coding", "assistant", "cli", "openrouter", "groq", "ollama", "deepseek", "xela"],
+  "keywords": [
+    "ai",
+    "coding",
+    "assistant",
+    "cli",
+    "openrouter",
+    "groq",
+    "ollama",
+    "deepseek",
+    "xela"
+  ],
   "bin": {
     "xela": "./bin/xela.js"
   },
@@ -50,7 +60,7 @@
     "diff": "^7.0.0",
     "emoji-regex": "^10.4.0",
     "env-paths": "^3.0.0",
-    "esbuild": "^0.27.4",
+    "esbuild": "^0.27.7",
     "execa": "^9.5.2",
     "figures": "^6.1.0",
     "fuse.js": "^7.1.0",

package/src/_shims/openai_adapter.ts

@@ -35,6 +35,7 @@
  *   OPENAI_API_KEY=... OPENAI_BASE_URL=https://api.together.xyz/v1 OPENAI_MODEL=meta-llama/Llama-3.3-70B-Instruct-Turbo
  */
 import OpenAI from 'openai'
+import { isClaudeModelName } from '../utils/model/providerModels.js'
 
 // Auto-detect provider from API key prefix or base URL
 function detectProvider(): { baseURL?: string; model: string; maxTokens: number } {
@@ -67,6 +68,18 @@ const PROVIDER = detectProvider()
 const MODEL = PROVIDER.model
 const MAX_TOKENS = PROVIDER.maxTokens
 
+/**
+ * Resolve which model to send to the OpenAI-compatible provider.
+ * - Non-Claude names pass through directly (e.g. 'gpt-4o', 'deepseek-chat')
+ * - Claude names/aliases fall back to the provider default
+ * - Null/undefined uses the startup default
+ */
+function resolveModel(paramsModel: string | undefined): string {
+  if (!paramsModel) return MODEL
+  if (isClaudeModelName(paramsModel)) return MODEL
+  return paramsModel
+}
+
 let _openaiClient: OpenAI | null = null
 
 function getOpenAI(): OpenAI {
@@ -188,7 +201,7 @@ function mapStopReason(finishReason: string | null): string {
 async function* createAnthropicStyleStream(params: any, signal?: AbortSignal): AsyncGenerator<any> {
   const openai = getOpenAI()
   // Always use the configured MODEL — internal Claude model names don't exist on OpenAI-compatible providers
-  const model = MODEL
+  const model = resolveModel(params.model)
 
   const openaiMessages: any[] = []
 
@@ -398,7 +411,7 @@ export function createOpenAIBackedAnthropicClient(): any {
       const nonStreamingResult = (async () => {
       const openai = getOpenAI()
       // Always use the configured MODEL
-      const model = MODEL
+      const model = resolveModel(params.model)
 
       const openaiMessages: any[] = []
       if (params.system) {

package/src/commands/model/model.tsx

@@ -14,7 +14,8 @@ import { MODEL_ALIASES } from '../../utils/model/aliases.js';
 import { checkOpus1mAccess, checkSonnet1mAccess } from '../../utils/model/check1mAccess.js';
 import { getDefaultMainLoopModelSetting, isOpus1mMergeEnabled, renderDefaultModelSetting } from '../../utils/model/model.js';
 import { isModelAllowed } from '../../utils/model/modelAllowlist.js';
-import { validateModel } from '../../utils/model/validateModel.js';
+import { validateModel } from '../../utils/model/validateModel.js'
+import { isOpenAIBackend, isClaudeModelName } from '../../utils/model/providerModels.js';
 function ModelPickerWrapper(t0) {
   const $ = _c(17);
   const {
@@ -141,13 +142,30 @@ function SetModelAndClose({
   const model = args === 'default' ? null : args;
   React.useEffect(() => {
     async function handleModelChange(): Promise<void> {
-      if (model && !isModelAllowed(model)) {
+      if (model && !isOpenAIBackend() && !isModelAllowed(model)) {
         onDone(`Model '${model}' is not available. Your organization restricts model selection.`, {
           display: 'system'
         });
         return;
       }
 
+      // Skip validation for default model
+      if (!model) {
+        setModel(null);
+        return;
+      }
+
+      // OpenAI backend: skip all Claude-specific checks, go straight to validation
+      if (isOpenAIBackend()) {
+        const { valid, error: validationError } = await validateModel(model);
+        if (valid) {
+          setModel(model);
+        } else {
+          onDone(validationError || `Model '${model}' not found`, { display: 'system' });
+        }
+        return;
+      }
+
       // @[MODEL LAUNCH]: Update check for 1M access.
       if (model && isOpus1mUnavailable(model)) {
         onDone(`Opus 4.6 with 1M context is not available for your account. Learn more: https://code.claude.com/docs/en/model-config#extended-context-with-1m`, {
@@ -162,12 +180,6 @@ function SetModelAndClose({
         return;
       }
 
-      // Skip validation for default model
-      if (!model) {
-        setModel(null);
-        return;
-      }
-
       // Skip validation for known aliases - they're predefined and should work
       if (isKnownAlias(model)) {
         setModel(model);
@@ -291,6 +303,9 @@ export const call: LocalJSXCommandCall = async (onDone, _context, args) => {
   return <ModelPickerWrapper onDone={onDone} />;
 };
 function renderModelLabel(model: string | null): string {
+  if (isOpenAIBackend() && model && !isClaudeModelName(model)) {
+    return model;
+  }
   const rendered = renderDefaultModelSetting(model ?? getDefaultMainLoopModelSetting());
   return model === null ? `${rendered} (default)` : rendered;
 }

package/src/components/ModelPicker.tsx

@@ -18,6 +18,7 @@ import { Byline } from './design-system/Byline.js';
 import { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js';
 import { Pane } from './design-system/Pane.js';
 import { effortLevelToSymbol } from './EffortIndicator.js';
+import { isOpenAIBackend, fetchProviderModels, getOpenAIDefaultModel } from '../utils/model/providerModels.js';
 export type Props = {
   initial: string | null;
   sessionModel?: ModelSetting;
@@ -74,9 +75,38 @@ export function ModelPicker(t0) {
     t3 = $[3];
   }
   const modelOptions = t3;
+
+  const [providerModels, setProviderModels] = useState<Array<{value: string | null, label: string, description: string}>>([]);
+  const [providerLoading, setProviderLoading] = useState(isOpenAIBackend());
+
+  React.useEffect(() => {
+    if (!isOpenAIBackend()) return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const models = await fetchProviderModels();
+        if (cancelled) return;
+        const defaultModel = getOpenAIDefaultModel();
+        const options = [
+          { value: null, label: `Default (${defaultModel})`, description: 'Current default model' },
+          ...models.map(m => ({ value: m.id, label: m.id, description: m.name !== m.id ? m.name : '' })),
+        ];
+        setProviderModels(options);
+      } finally {
+        if (!cancelled) setProviderLoading(false);
+      }
+    })();
+    return () => { cancelled = true; };
+  }, []);
+
+  // When on OpenAI backend and provider models loaded, use them instead of Claude options
+  const effectiveModelOptions = isOpenAIBackend() && providerModels.length > 0
+    ? providerModels
+    : modelOptions;
+
   let t4;
   bb0: {
-    if (initial !== null && !modelOptions.some(opt => opt.value === initial)) {
+    if (initial !== null && !effectiveModelOptions.some(opt => opt.value === initial)) {
       let t5;
       if ($[4] !== initial) {
         t5 = modelDisplayString(initial);
@@ -100,7 +130,7 @@ export function ModelPicker(t0) {
       }
       let t7;
       if ($[9] !== modelOptions || $[10] !== t6) {
-        t7 = [...modelOptions, t6];
+        t7 = [...effectiveModelOptions, t6];
         $[9] = modelOptions;
         $[10] = t6;
         $[11] = t7;
@@ -110,7 +140,7 @@ export function ModelPicker(t0) {
       t4 = t7;
       break bb0;
     }
-    t4 = modelOptions;
+    t4 = effectiveModelOptions;
   }
   const optionsWithInitial = t4;
   let t5;
@@ -265,7 +295,7 @@ export function ModelPicker(t0) {
   } else {
     t15 = $[41];
   }
-  const t16 = headerText ?? "Switch between Claude models. Applies to this session and future Claude Code sessions. For other/previous model names, specify with --model.";
+  const t16 = headerText ?? (providerLoading ? 'Loading models from provider...' : isOpenAIBackend() ? 'Switch between provider models. Select a model or use /model <name> directly.' : "Switch between Claude models. Applies to this session and future Claude Code sessions. For other/previous model names, specify with --model.");
   let t17;
   if ($[42] !== t16) {
     t17 = <Text dimColor={true}>{t16}</Text>;

package/src/utils/model/model.ts

@@ -74,7 +74,8 @@ export function getUserSpecifiedModelSetting(): ModelSetting | undefined {
   }
 
   // Ignore the user-specified model if it's not in the availableModels allowlist.
-  if (specifiedModel && !isModelAllowed(specifiedModel)) {
+  // Skip this check on OpenAI backend — the allowlist is for Claude models only.
+  if (specifiedModel && !process.env.OPENAI_API_KEY && !isModelAllowed(specifiedModel)) {
     return undefined
   }
 
@@ -94,8 +95,12 @@ export function getUserSpecifiedModelSetting(): ModelSetting | undefined {
  * @returns The resolved model name to use
  */
 export function getMainLoopModel(): ModelName {
-  // When using OpenAI backend, return the OpenAI model name directly
+  // When using OpenAI backend, respect user-selected model, fall back to OPENAI_MODEL
   if (process.env.OPENAI_API_KEY) {
+    const model = getUserSpecifiedModelSetting()
+    if (model !== undefined && model !== null) {
+      return model
+    }
     return process.env.OPENAI_MODEL || 'gpt-4o'
   }
   const model = getUserSpecifiedModelSetting()
@@ -160,9 +165,9 @@ export function getRuntimeMainLoopModel(params: {
 }): ModelName {
   const { permissionMode, mainLoopModel, exceeds200kTokens = false } = params
 
-  // When using OpenAI backend, always use the configured model
+  // When using OpenAI backend, use the passed-in model (already resolved by caller)
   if (process.env.OPENAI_API_KEY) {
-    return process.env.OPENAI_MODEL || 'gpt-4o'
+    return mainLoopModel || process.env.OPENAI_MODEL || 'gpt-4o'
   }
 
   // opusplan uses Opus in plan mode without [1m] suffix.

package/src/utils/model/modelOptions.ts

@@ -32,6 +32,7 @@ import {
 } from './model.js'
 import { has1mContext } from '../context.js'
 import { getGlobalConfig } from '../config.js'
+import { isOpenAIBackend, getOpenAIDefaultModel, detectOpenAIProvider } from './providerModels.js'
 
 // @[MODEL LAUNCH]: Update all the available and default model option strings below.
 
@@ -266,6 +267,23 @@ function getOpusPlanOption(): ModelOption {
   }
 }
 
+/**
+ * Build model options from the OpenAI-compatible provider's model list.
+ * Called synchronously with cached data if available, otherwise returns
+ * a minimal default option.
+ */
+function getOpenAIModelOptions(): ModelOption[] {
+  const defaultModel = getOpenAIDefaultModel()
+  const provider = detectOpenAIProvider()
+  const providerLabel = provider === 'unknown' ? 'OpenAI-compatible' : provider.charAt(0).toUpperCase() + provider.slice(1)
+
+  return [{
+    value: null,
+    label: `Default (${defaultModel})`,
+    description: `${providerLabel} default model`,
+  }]
+}
+
 // @[MODEL LAUNCH]: Update the model picker lists below to include/reorder options for the new model.
 // Each user tier (ant, Max/Team Premium, Pro/Team Standard/Enterprise, PAYG 1P, PAYG 3P) has its own list.
 function getModelOptionsBase(fastMode = false): ModelOption[] {
@@ -459,6 +477,9 @@ function getKnownModelOption(model: string): ModelOption | null {
 }
 
 export function getModelOptions(fastMode = false): ModelOption[] {
+  if (isOpenAIBackend()) {
+    return getOpenAIModelOptions()
+  }
   const options = getModelOptionsBase(fastMode)
 
   // Add the custom model from the ANTHROPIC_CUSTOM_MODEL_OPTION env var

package/src/utils/model/providerModels.ts

@@ -0,0 +1,168 @@
+import OpenAI from 'openai'
+import { MODEL_ALIASES } from './aliases.js'
+
+export type ProviderModel = {
+  id: string
+  name: string
+}
+
+export type ProviderName =
+  | 'openai'
+  | 'groq'
+  | 'openrouter'
+  | 'deepseek'
+  | 'mistral'
+  | 'together'
+  | 'ollama'
+  | 'fireworks'
+  | 'moonshot'
+  | 'unknown'
+
+/**
+ * Returns true if the model name is a Claude model name or alias.
+ * These don't exist on OpenAI-compatible providers, so the adapter
+ * should fall back to the provider default.
+ */
+export function isClaudeModelName(model: string): boolean {
+  const lower = model.toLowerCase().trim()
+  if (lower.includes('claude')) return true
+  return (MODEL_ALIASES as readonly string[]).includes(lower)
+}
+
+/**
+ * Detect which OpenAI-compatible provider is configured.
+ */
+export function detectOpenAIProvider(): ProviderName {
+  const key = process.env.OPENAI_API_KEY || ''
+  const baseURL = process.env.OPENAI_BASE_URL || ''
+
+  if (baseURL.includes('groq.com') || key.startsWith('gsk_')) return 'groq'
+  if (baseURL.includes('openrouter.ai') || key.startsWith('sk-or-')) return 'openrouter'
+  if (baseURL.includes('deepseek.com')) return 'deepseek'
+  if (baseURL.includes('mistral.ai')) return 'mistral'
+  if (baseURL.includes('together.xyz')) return 'together'
+  if (baseURL.includes('localhost') || baseURL.includes('127.0.0.1')) return 'ollama'
+  if (baseURL.includes('fireworks.ai')) return 'fireworks'
+  if (baseURL.includes('moonshot.cn') || baseURL.includes('moonshot.ai')) return 'moonshot'
+  if (!baseURL || baseURL.includes('openai.com')) return 'openai'
+  return 'unknown'
+}
+
+const CURATED_MODELS: Record<ProviderName, ProviderModel[]> = {
+  openai: [
+    { id: 'gpt-4o', name: 'GPT-4o' },
+    { id: 'gpt-4o-mini', name: 'GPT-4o Mini' },
+    { id: 'gpt-4.1', name: 'GPT-4.1' },
+    { id: 'gpt-4.1-mini', name: 'GPT-4.1 Mini' },
+    { id: 'o3', name: 'o3' },
+    { id: 'o4-mini', name: 'o4 Mini' },
+  ],
+  groq: [
+    { id: 'llama-3.3-70b-versatile', name: 'Llama 3.3 70B' },
+    { id: 'llama-3.1-8b-instant', name: 'Llama 3.1 8B Instant' },
+    { id: 'gemma2-9b-it', name: 'Gemma 2 9B' },
+    { id: 'mixtral-8x7b-32768', name: 'Mixtral 8x7B' },
+  ],
+  openrouter: [
+    { id: 'google/gemini-2.0-flash-001', name: 'Gemini 2.0 Flash' },
+    { id: 'openai/gpt-4o', name: 'GPT-4o' },
+    { id: 'meta-llama/llama-3.3-70b', name: 'Llama 3.3 70B' },
+  ],
+  deepseek: [
+    { id: 'deepseek-chat', name: 'DeepSeek Chat' },
+    { id: 'deepseek-reasoner', name: 'DeepSeek Reasoner' },
+  ],
+  mistral: [
+    { id: 'mistral-large-latest', name: 'Mistral Large' },
+    { id: 'mistral-small-latest', name: 'Mistral Small' },
+    { id: 'codestral-latest', name: 'Codestral' },
+  ],
+  together: [
+    { id: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', name: 'Llama 3.3 70B Turbo' },
+    { id: 'Qwen/Qwen2.5-72B-Instruct-Turbo', name: 'Qwen 2.5 72B Turbo' },
+  ],
+  ollama: [
+    { id: 'llama3.2', name: 'Llama 3.2' },
+    { id: 'qwen2.5-coder', name: 'Qwen 2.5 Coder' },
+    { id: 'deepseek-r1', name: 'DeepSeek R1' },
+    { id: 'mistral', name: 'Mistral' },
+  ],
+  fireworks: [
+    { id: 'accounts/fireworks/models/llama-v3p3-70b-instruct', name: 'Llama 3.3 70B' },
+  ],
+  moonshot: [
+    { id: 'moonshot-v1-32k', name: 'Moonshot V1 32K' },
+    { id: 'moonshot-v1-128k', name: 'Moonshot V1 128K' },
+  ],
+  unknown: [],
+}
+
+export function getCuratedModels(provider: ProviderName): ProviderModel[] {
+  return CURATED_MODELS[provider] ?? []
+}
+
+let cachedModels: ProviderModel[] | null = null
+
+/**
+ * Fetch all available models from the provider via GET /v1/models.
+ * Results are cached in memory for the session.
+ * Returns curated fallback list on failure.
+ */
+export async function fetchProviderModels(): Promise<ProviderModel[]> {
+  if (cachedModels !== null) {
+    return cachedModels
+  }
+
+  const provider = detectOpenAIProvider()
+
+  try {
+    const client = new OpenAI({
+      apiKey: process.env.OPENAI_API_KEY,
+      ...(process.env.OPENAI_BASE_URL ? { baseURL: process.env.OPENAI_BASE_URL } : {}),
+      ...(provider === 'groq' && !process.env.OPENAI_BASE_URL
+        ? { baseURL: 'https://api.groq.com/openai/v1' }
+        : {}),
+      ...(provider === 'openrouter' && !process.env.OPENAI_BASE_URL
+        ? { baseURL: 'https://openrouter.ai/api/v1' }
+        : {}),
+    })
+
+    const response = await client.models.list({}, { timeout: 5000 })
+    const models: ProviderModel[] = []
+
+    for await (const model of response) {
+      models.push({ id: model.id, name: model.id })
+    }
+
+    models.sort((a, b) => a.id.localeCompare(b.id))
+    cachedModels = models
+    return models
+  } catch {
+    const fallback = getCuratedModels(provider)
+    cachedModels = fallback
+    return fallback
+  }
+}
+
+/**
+ * Check if a model ID exists in the cached provider model list.
+ * Returns false if the cache hasn't been populated yet.
+ */
+export function isKnownProviderModel(modelId: string): boolean {
+  if (!cachedModels) return false
+  return cachedModels.some(m => m.id === modelId)
+}
+
+/**
+ * Returns true if the app is using an OpenAI-compatible backend.
+ */
+export function isOpenAIBackend(): boolean {
+  return !!process.env.OPENAI_API_KEY
+}
+
+/**
+ * Get the startup default model for the current OpenAI provider.
+ */
+export function getOpenAIDefaultModel(): string {
+  return process.env.OPENAI_MODEL || 'gpt-4o'
+}

package/src/utils/model/validateModel.ts

@@ -10,6 +10,7 @@ import {
   AuthenticationError,
 } from '@anthropic-ai/sdk'
 import { getModelStrings } from './modelStrings.js'
+import { isOpenAIBackend, isKnownProviderModel, isClaudeModelName } from './providerModels.js'
 
 // Cache valid models to avoid repeated API calls
 const validModelCache = new Map<string, boolean>()
@@ -27,6 +28,24 @@ export async function validateModel(
     return { valid: false, error: 'Model name cannot be empty' }
   }
 
+  // OpenAI-compatible backend: skip Anthropic validation
+  if (isOpenAIBackend()) {
+    // Claude names don't exist on OpenAI providers
+    if (isClaudeModelName(normalizedModel)) {
+      return {
+        valid: false,
+        error: `'${normalizedModel}' is a Claude model name. Use a model name from your provider (e.g. 'gpt-4o', 'deepseek-chat').`,
+      }
+    }
+    // If we already fetched the model list, check against it
+    if (isKnownProviderModel(normalizedModel)) {
+      return { valid: true }
+    }
+    // Otherwise, trust the user — the adapter will try it and the provider
+    // will return an error if it doesn't exist
+    return { valid: true }
+  }
+
   // Check against availableModels allowlist before any API call
   if (!isModelAllowed(normalizedModel)) {
     return {