jbai-cli 1.4.0 → 1.5.1

package/README.md

@@ -35,9 +35,10 @@ Expected output:
 ```
 Testing JetBrains AI Platform (staging)
 
-1. OpenAI Proxy (GPT): ✅ Working
-2. Anthropic Proxy (Claude): ✅ Working
-3. Google Proxy (Gemini): ✅ Working
+1. OpenAI Proxy (Chat): ✅ Working
+2. OpenAI Proxy (Codex /responses): ✅ Working
+3. Anthropic Proxy (Claude): ✅ Working
+4. Google Proxy (Gemini): ✅ Working
 ```
 
 ## Usage
@@ -103,7 +104,7 @@ Each tool has a sensible default, but you can specify any available model:
 jbai-claude --model claude-opus-4-1-20250805
 
 # Codex with GPT-5
-jbai-codex --model gpt-5-2025-08-07
+jbai-codex --model gpt-5.2-codex
 
 # Aider with Gemini Pro
 jbai-aider --model gemini/gemini-2.5-pro
@@ -126,10 +127,19 @@ jbai-aider --model gemini/gemini-2.5-pro
 | `gpt-4o-2024-11-20` | Default |
 | `gpt-5-2025-08-07` | Latest |
 | `gpt-5.1-2025-11-13` | |
+| `gpt-5.2-2025-12-11` | |
 | `gpt-5-mini-2025-08-07` | Fast |
 | `o3-2025-04-16` | Reasoning |
 | `o3-mini-2025-01-31` | |
 
+**Codex (OpenAI Responses)** - Use with Codex CLI: `jbai-codex --model <model>`
+| Model | Notes |
+|-------|-------|
+| `gpt-5.2-codex` | Default, coding-optimized |
+| `gpt-5.1-codex` | |
+| `gpt-5.1-codex-mini` | Faster |
+| `gpt-5.1-codex-max` | |
+
 **Gemini (Google)** - Use with Aider: `jbai-aider --model gemini/<model>`
 | Model | Notes |
 |-------|-------|

package/bin/jbai-codex.js

@@ -59,7 +59,7 @@ const hasModel = args.includes('--model');
 const finalArgs = ['-c', `model_provider=${providerName}`];
 
 if (!hasModel) {
-  finalArgs.push('--model', config.MODELS.openai.default);
+  finalArgs.push('--model', config.MODELS.codex?.default || config.MODELS.openai.default);
 }
 
 // Add super mode flags (full-auto)

package/bin/jbai-opencode.js

@@ -80,21 +80,6 @@ config.MODELS.openai.available.forEach(model => {
   };
 });
 
-// Add other provider models (DeepSeek, Mistral, Qwen, XAI, Meta) via OpenAI endpoint
-const otherModels = [
-  ...config.MODELS.other.deepseek,
-  ...config.MODELS.other.mistral,
-  ...config.MODELS.other.qwen,
-  ...config.MODELS.other.xai,
-  ...config.MODELS.other.meta
-];
-otherModels.forEach(model => {
-  opencodeConfig.provider[providerName].models[model] = {
-    name: model,
-    limit: { context: 128000, output: 8192 }
-  };
-});
-
 // Add JetBrains Anthropic provider for Claude models
 opencodeConfig.provider[anthropicProviderName] = {
   npm: '@ai-sdk/anthropic',

package/bin/jbai.js

@@ -18,12 +18,6 @@ const TOOLS = {
     install: 'npm install -g @openai/codex',
     check: 'codex --version'
   },
-  aider: {
-    name: 'Aider',
-    command: 'aider',
-    install: 'pipx install aider-chat',
-    check: 'aider --version'
-  },
   gemini: {
     name: 'Gemini CLI',
     command: 'gemini',
@@ -47,10 +41,10 @@ COMMANDS:
   jbai token           Show token status
   jbai token set       Set token interactively
   jbai token refresh   Refresh expired token
-  jbai test            Test all API endpoints
+  jbai test            Test API endpoints (incl. Codex /responses)
   jbai env [staging|production]  Switch environment
   jbai models          List available models
-  jbai install         Install all AI tools (claude, codex, aider)
+  jbai install         Install all AI tools (claude, codex, gemini, opencode)
   jbai install claude  Install specific tool
   jbai doctor          Check which tools are installed
   jbai help            Show this help
@@ -58,7 +52,6 @@ COMMANDS:
 TOOL WRAPPERS:
   jbai-claude   Launch Claude Code with JetBrains AI
   jbai-codex    Launch Codex CLI with JetBrains AI
-  jbai-aider    Launch Aider with JetBrains AI
   jbai-gemini   Launch Gemini CLI with JetBrains AI
   jbai-opencode Launch OpenCode with JetBrains AI
 
@@ -66,13 +59,13 @@ SUPER MODE:
   Add --super (or --yolo or -s) to skip confirmations:
   jbai-claude --super               # Skip permission prompts
   jbai-codex --super                # Full auto mode
-  jbai-aider --super                # Auto-confirm changes
+  jbai-gemini --super               # Auto-confirm changes
 
 EXAMPLES:
   jbai token set                    # Set your token
   jbai-claude                       # Start Claude Code
   jbai-codex exec "explain code"    # Run Codex task
-  jbai-aider                        # Start Aider
+  jbai-gemini                       # Start Gemini CLI
 
 TOKEN:
   Get token: ${config.getEndpoints().tokenUrl}
@@ -146,40 +139,61 @@ async function testEndpoints() {
   console.log(`Testing JetBrains AI Platform (${config.getEnvironment()})\n`);
 
   // Test OpenAI
-  process.stdout.write('1. OpenAI Proxy (GPT): ');
+  process.stdout.write('1. OpenAI Proxy (Chat): ');
   try {
     const result = await httpPost(
       `${endpoints.openai}/chat/completions`,
-      { model: 'gpt-4o-2024-11-20', messages: [{ role: 'user', content: 'Say OK' }], max_tokens: 5 },
+      { model: config.MODELS.openai.default, messages: [{ role: 'user', content: 'Say OK' }], max_tokens: 5 },
+      { 'Grazie-Authenticate-JWT': token }
+    );
+    const ok = result.statusCode === 200 && Array.isArray(result.json?.choices);
+    console.log(ok ? '✅ Working' : `❌ Failed (${result.statusCode})`);
+  } catch (e) {
+    console.log(`❌ ${e.message}`);
+  }
+
+  // Test Codex (Responses)
+  process.stdout.write('2. OpenAI Proxy (Codex /responses): ');
+  try {
+    const result = await httpPost(
+      `${endpoints.openai}/responses`,
+      { model: config.MODELS.codex.default, input: 'Say OK', max_output_tokens: 64 },
       { 'Grazie-Authenticate-JWT': token }
     );
-    console.log(result.choices ? '✅ Working' : '❌ Failed');
+    const outputText = result.json?.output
+      ?.find(o => o.type === 'message')
+      ?.content?.find(c => c.type === 'output_text')
+      ?.text;
+    const ok = result.statusCode === 200 && typeof outputText === 'string';
+    console.log(ok ? '✅ Working' : `❌ Failed (${result.statusCode})`);
   } catch (e) {
     console.log(`❌ ${e.message}`);
   }
 
   // Test Anthropic
-  process.stdout.write('2. Anthropic Proxy (Claude): ');
+  process.stdout.write('3. Anthropic Proxy (Claude): ');
   try {
     const result = await httpPost(
       `${endpoints.anthropic}/messages`,
       { model: 'claude-sonnet-4-5-20250929', messages: [{ role: 'user', content: 'Say OK' }], max_tokens: 10 },
       { 'Grazie-Authenticate-JWT': token, 'anthropic-version': '2023-06-01' }
     );
-    console.log(result.content ? '✅ Working' : '❌ Failed');
+    const ok = result.statusCode === 200 && Array.isArray(result.json?.content);
+    console.log(ok ? '✅ Working' : `❌ Failed (${result.statusCode})`);
   } catch (e) {
     console.log(`❌ ${e.message}`);
   }
 
   // Test Google
-  process.stdout.write('3. Google Proxy (Gemini): ');
+  process.stdout.write('4. Google Proxy (Gemini): ');
   try {
     const result = await httpPost(
       `${endpoints.google}/v1/projects/default/locations/default/publishers/google/models/gemini-2.5-flash:generateContent`,
       { contents: [{ role: 'user', parts: [{ text: 'Say OK' }] }] },
       { 'Grazie-Authenticate-JWT': token }
     );
-    console.log(result.candidates ? '✅ Working' : '❌ Failed');
+    const ok = result.statusCode === 200 && Array.isArray(result.json?.candidates);
+    console.log(ok ? '✅ Working' : `❌ Failed (${result.statusCode})`);
   } catch (e) {
     console.log(`❌ ${e.message}`);
   }
@@ -201,14 +215,16 @@ function httpPost(url, body, headers) {
         ...headers
       }
     }, (res) => {
-      let body = '';
-      res.on('data', chunk => body += chunk);
+      let rawBody = '';
+      res.on('data', chunk => rawBody += chunk);
       res.on('end', () => {
+        let json = null;
         try {
-          resolve(JSON.parse(body));
+          json = JSON.parse(rawBody);
         } catch {
-          reject(new Error('Invalid response'));
+          // Some proxy errors are plain text.
         }
+        resolve({ statusCode: res.statusCode, json, rawBody });
       });
     });
 
@@ -227,43 +243,32 @@ function showModels() {
     console.log(`  - ${m}${def}`);
   });
 
-  console.log('\nGPT (OpenAI) - jbai-codex, jbai-aider:');
+  console.log('\nGPT (OpenAI Chat) - jbai-aider, jbai-opencode:');
   config.MODELS.openai.available.forEach((m) => {
     const def = m === config.MODELS.openai.default ? ' (default)' : '';
     console.log(`  - ${m}${def}`);
   });
 
+  console.log('\nCodex (OpenAI Responses) - jbai-codex:');
+  config.MODELS.codex.available.forEach((m) => {
+    const def = m === config.MODELS.codex.default ? ' (default)' : '';
+    console.log(`  - ${m}${def}`);
+  });
+
   console.log('\nGemini (Google) - jbai-gemini:');
   config.MODELS.gemini.available.forEach((m) => {
     const def = m === config.MODELS.gemini.default ? ' (default)' : '';
     console.log(`  - ${m}${def}`);
   });
 
-  console.log('\nDeepSeek - jbai-aider, jbai-opencode:');
-  config.MODELS.other.deepseek.forEach((m) => console.log(`  - ${m}`));
-
-  console.log('\nMistral - jbai-aider, jbai-opencode:');
-  config.MODELS.other.mistral.forEach((m) => console.log(`  - ${m}`));
-
-  console.log('\nQwen - jbai-aider, jbai-opencode:');
-  config.MODELS.other.qwen.forEach((m) => console.log(`  - ${m}`));
-
-  console.log('\nXAI (Grok) - jbai-aider, jbai-opencode:');
-  config.MODELS.other.xai.forEach((m) => console.log(`  - ${m}`));
-
-  console.log('\nMeta (Llama) - jbai-aider, jbai-opencode:');
-  config.MODELS.other.meta.forEach((m) => console.log(`  - ${m}`));
-
   // Count total
   const total = config.MODELS.claude.available.length +
     config.MODELS.openai.available.length +
-    config.MODELS.gemini.available.length +
-    config.MODELS.other.deepseek.length +
-    config.MODELS.other.mistral.length +
-    config.MODELS.other.qwen.length +
-    config.MODELS.other.xai.length +
-    config.MODELS.other.meta.length;
+    config.MODELS.codex.available.length +
+    config.MODELS.gemini.available.length;
   console.log(`\nTotal: ${total} models`);
+  console.log('\nNote: Other providers (DeepSeek, Mistral, Qwen, XAI, Meta) are available');
+  console.log('via Grazie native API but not via OpenAI-compatible CLI tools.');
 }
 
 function setEnvironment(env) {

package/bin/test-models.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+
+/**
+ * E2E Model Compatibility Testing Script
+ * Tests all configured Grazie models against the API endpoints
+ * to identify which models are valid and which return 404 or errors.
+ */
+
+const https = require('https');
+const config = require('../lib/config');
+
+const token = config.getToken();
+if (!token) {
+  console.error('❌ No token found. Run: jbai token set');
+  process.exit(1);
+}
+
+const endpoints = config.getEndpoints();
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[2m'
+};
+
+function httpPost(url, body, headers) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const data = JSON.stringify(body);
+
+    const req = https.request({
+      hostname: urlObj.hostname,
+      port: 443,
+      path: urlObj.pathname + urlObj.search,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(data),
+        ...headers
+      },
+      timeout: 30000
+    }, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(body);
+          resolve({ status: res.statusCode, data: parsed });
+        } catch {
+          resolve({ status: res.statusCode, data: body, raw: true });
+        }
+      });
+    });
+
+    req.on('error', (e) => reject(e));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Timeout'));
+    });
+    req.write(data);
+    req.end();
+  });
+}
+
+async function testOpenAIModel(model) {
+  try {
+    // GPT-5.x and O-series models require max_completion_tokens instead of max_tokens
+    const needsCompletionTokens = model.startsWith('gpt-5') || model.startsWith('o1') ||
+                                   model.startsWith('o3') || model.startsWith('o4');
+
+    const bodyParams = needsCompletionTokens
+      ? { max_completion_tokens: 500 }  // O-series needs more tokens for reasoning
+      : { max_tokens: 5 };
+
+    const result = await httpPost(
+      `${endpoints.openai}/chat/completions`,
+      {
+        model: model,
+        messages: [{ role: 'user', content: 'Say OK' }],
+        ...bodyParams
+      },
+      { 'Grazie-Authenticate-JWT': token }
+    );
+
+    if (result.status === 200 && result.data.choices) {
+      return { success: true, message: 'OK' };
+    } else if (result.status === 404) {
+      return { success: false, message: `404 Not Found`, error: result.data.error?.message || 'Model not found' };
+    } else if (result.status === 400) {
+      return { success: false, message: `400 Bad Request`, error: result.data.error?.message || 'Invalid request' };
+    } else {
+      return { success: false, message: `Status ${result.status}`, error: result.data.error?.message || JSON.stringify(result.data).substring(0, 100) };
+    }
+  } catch (e) {
+    return { success: false, message: 'Error', error: e.message };
+  }
+}
+
+async function testAnthropicModel(model) {
+  try {
+    const result = await httpPost(
+      `${endpoints.anthropic}/messages`,
+      {
+        model: model,
+        messages: [{ role: 'user', content: 'Say OK' }],
+        max_tokens: 10
+      },
+      {
+        'Grazie-Authenticate-JWT': token,
+        'anthropic-version': '2023-06-01'
+      }
+    );
+
+    if (result.status === 200 && result.data.content) {
+      return { success: true, message: 'OK' };
+    } else if (result.status === 404) {
+      return { success: false, message: `404 Not Found`, error: result.data.error?.message || 'Model not found' };
+    } else if (result.status === 400) {
+      return { success: false, message: `400 Bad Request`, error: result.data.error?.message || 'Invalid request' };
+    } else {
+      return { success: false, message: `Status ${result.status}`, error: result.data.error?.message || JSON.stringify(result.data).substring(0, 100) };
+    }
+  } catch (e) {
+    return { success: false, message: 'Error', error: e.message };
+  }
+}
+
+async function testGeminiModel(model) {
+  try {
+    // Gemini API format via Vertex AI proxy
+    const result = await httpPost(
+      `${endpoints.google}/v1/projects/default/locations/default/publishers/google/models/${model}:generateContent`,
+      {
+        contents: [{ role: 'user', parts: [{ text: 'Say OK' }] }]
+      },
+      { 'Grazie-Authenticate-JWT': token }
+    );
+
+    if (result.status === 200 && result.data.candidates) {
+      return { success: true, message: 'OK' };
+    } else if (result.status === 404) {
+      return { success: false, message: `404 Not Found`, error: result.data.error?.message || 'Model not found' };
+    } else if (result.status === 400) {
+      return { success: false, message: `400 Bad Request`, error: result.data.error?.message || 'Invalid request' };
+    } else {
+      return { success: false, message: `Status ${result.status}`, error: result.data.error?.message || JSON.stringify(result.data).substring(0, 100) };
+    }
+  } catch (e) {
+    return { success: false, message: 'Error', error: e.message };
+  }
+}
+
+async function runTests() {
+  console.log(`\n${'='.repeat(70)}`);
+  console.log(`${colors.cyan}JBAI-CLI E2E MODEL COMPATIBILITY TESTING${colors.reset}`);
+  console.log(`Environment: ${config.getEnvironment()}`);
+  console.log(`${'='.repeat(70)}\n`);
+
+  const results = {
+    openai: { working: [], failing: [] },
+    anthropic: { working: [], failing: [] },
+    gemini: { working: [], failing: [] }
+  };
+
+  // Test Claude models (Anthropic)
+  console.log(`${colors.cyan}Testing Claude models (jbai-claude)...${colors.reset}`);
+  console.log('-'.repeat(50));
+  for (const model of config.MODELS.claude.available) {
+    process.stdout.write(`  ${model.padEnd(35)} `);
+    const result = await testAnthropicModel(model);
+    if (result.success) {
+      console.log(`${colors.green}✓ ${result.message}${colors.reset}`);
+      results.anthropic.working.push(model);
+    } else {
+      console.log(`${colors.red}✗ ${result.message}${colors.reset}`);
+      console.log(`    ${colors.dim}${result.error}${colors.reset}`);
+      results.anthropic.failing.push({ model, error: result.error });
+    }
+  }
+
+  // Test OpenAI models (Codex, OpenCode)
+  console.log(`\n${colors.cyan}Testing OpenAI/GPT models (jbai-codex, jbai-opencode)...${colors.reset}`);
+  console.log('-'.repeat(50));
+  for (const model of config.MODELS.openai.available) {
+    process.stdout.write(`  ${model.padEnd(35)} `);
+    const result = await testOpenAIModel(model);
+    if (result.success) {
+      console.log(`${colors.green}✓ ${result.message}${colors.reset}`);
+      results.openai.working.push(model);
+    } else {
+      console.log(`${colors.red}✗ ${result.message}${colors.reset}`);
+      console.log(`    ${colors.dim}${result.error}${colors.reset}`);
+      results.openai.failing.push({ model, error: result.error });
+    }
+  }
+
+  // Test Gemini models
+  console.log(`\n${colors.cyan}Testing Gemini models (jbai-gemini)...${colors.reset}`);
+  console.log('-'.repeat(50));
+  for (const model of config.MODELS.gemini.available) {
+    process.stdout.write(`  ${model.padEnd(35)} `);
+    const result = await testGeminiModel(model);
+    if (result.success) {
+      console.log(`${colors.green}✓ ${result.message}${colors.reset}`);
+      results.gemini.working.push(model);
+    } else {
+      console.log(`${colors.red}✗ ${result.message}${colors.reset}`);
+      console.log(`    ${colors.dim}${result.error}${colors.reset}`);
+      results.gemini.failing.push({ model, error: result.error });
+    }
+  }
+
+  // Summary
+  console.log(`\n${'='.repeat(70)}`);
+  console.log(`${colors.cyan}SUMMARY${colors.reset}`);
+  console.log(`${'='.repeat(70)}`);
+
+  const totalWorking = results.anthropic.working.length + results.openai.working.length +
+                       results.gemini.working.length;
+  const totalFailing = results.anthropic.failing.length + results.openai.failing.length +
+                       results.gemini.failing.length;
+
+  console.log(`\n${colors.green}Working Models: ${totalWorking}${colors.reset}`);
+  console.log(`${colors.red}Failing Models: ${totalFailing}${colors.reset}`);
+
+  console.log(`\n${colors.cyan}By Provider:${colors.reset}`);
+  console.log(`  Claude (Anthropic): ${colors.green}${results.anthropic.working.length}${colors.reset} working, ${colors.red}${results.anthropic.failing.length}${colors.reset} failing`);
+  console.log(`  OpenAI/GPT:         ${colors.green}${results.openai.working.length}${colors.reset} working, ${colors.red}${results.openai.failing.length}${colors.reset} failing`);
+  console.log(`  Gemini (Google):    ${colors.green}${results.gemini.working.length}${colors.reset} working, ${colors.red}${results.gemini.failing.length}${colors.reset} failing`);
+
+  if (totalFailing > 0) {
+    console.log(`\n${colors.red}FAILING MODELS TO REMOVE:${colors.reset}`);
+
+    if (results.anthropic.failing.length > 0) {
+      console.log(`\n  Claude models:`);
+      results.anthropic.failing.forEach(f => console.log(`    - ${f.model}`));
+    }
+    if (results.openai.failing.length > 0) {
+      console.log(`\n  OpenAI models:`);
+      results.openai.failing.forEach(f => console.log(`    - ${f.model}`));
+    }
+    if (results.gemini.failing.length > 0) {
+      console.log(`\n  Gemini models:`);
+      results.gemini.failing.forEach(f => console.log(`    - ${f.model}`));
+    }
+  } else {
+    console.log(`\n${colors.green}All models are working correctly!${colors.reset}`);
+  }
+
+  console.log(`\n${'='.repeat(70)}\n`);
+
+  // Return results for programmatic use
+  return results;
+}
+
+// Run tests
+runTests().catch(console.error);

package/lib/config.js

@@ -26,91 +26,91 @@ const ENDPOINTS = {
 };
 
 // All models available from JetBrains AI Platform (Grazie)
-// Model names are mapped to SDK-compatible format
+// Model names must match EXACTLY what the Grazie API accepts
+// Run 'node bin/test-models.js' to verify model availability
 const MODELS = {
   claude: {
     default: 'claude-sonnet-4-5-20250929',
     available: [
-      // Claude 4.x series (latest)
-      'claude-opus-4-5-20250929',
+      // Claude 4.5 series (latest)
+      'claude-opus-4-5-20251101',
       'claude-sonnet-4-5-20250929',
-      'claude-haiku-4-5-20250929',
+      'claude-haiku-4-5-20251001',
+      // Claude 4.x series
       'claude-opus-4-1-20250805',
       'claude-opus-4-20250514',
       'claude-sonnet-4-20250514',
       // Claude 3.x series
       'claude-3-7-sonnet-20250219',
-      'claude-3-5-sonnet-20241022',
-      'claude-3-5-haiku-20241022',
-      'claude-3-haiku-20240307'
+      'claude-3-5-haiku-20241022'
     ]
   },
   openai: {
-    default: 'gpt-4o',
+    // Chat/Completions models (used by Aider/OpenCode)
+    // Keep in sync with the OpenAI proxy's advertised list.
+    default: 'gpt-4o-2024-11-20',
     available: [
-      // GPT-5.x series (latest)
-      'gpt-5',
-      'gpt-5.1',
+      // GPT-5.x series (latest) - require date-versioned names
+      'gpt-5.2-2025-12-11',
       'gpt-5.2',
-      'gpt-5-mini',
-      'gpt-5-nano',
+      'gpt-5.1-2025-11-13',
+      'gpt-5-2025-08-07',
+      'gpt-5-mini-2025-08-07',
+      'gpt-5-nano-2025-08-07',
+      // GPT-4.1 series
+      'gpt-4.1-2025-04-14',
+      'gpt-4.1-mini-2025-04-14',
+      'gpt-4.1-nano-2025-04-14',
+      // GPT-4o/4-turbo
+      'gpt-4o-2024-11-20',
+      'gpt-4o-mini-2024-07-18',
+      'gpt-4-turbo-2024-04-09',
+      'gpt-4-0613',
+      // O-series (reasoning) - use max_completion_tokens instead of max_tokens
+      'o4-mini-2025-04-16',
+      'o3-2025-04-16',
+      'o3-mini-2025-01-31',
+      'o1-2024-12-17',
+      // Legacy
+      'gpt-3.5-turbo-0125'
+    ]
+  },
+  // Codex CLI uses the OpenAI "responses" API (wire_api = "responses")
+  codex: {
+    default: 'gpt-5.2-codex',
+    available: [
       'gpt-5-codex',
       'gpt-5.1-codex',
-      'gpt-5.1-codex-max',
       'gpt-5.1-codex-mini',
-      'gpt-5.2-codex',
-      'gpt-5.2-pro',
-      // GPT-4.x series
-      'gpt-4.1',
-      'gpt-4.1-mini',
-      'gpt-4.1-nano',
-      'gpt-4o',
-      'gpt-4o-mini',
-      'gpt-4-turbo',
-      'gpt-4',
-      // O-series (reasoning)
-      'o1',
-      'o3',
-      'o3-mini',
-      'o4-mini'
+      'gpt-5.1-codex-max',
+      'gpt-5.2-codex'
     ]
   },
   gemini: {
     default: 'gemini-2.5-flash',
     available: [
-      // Gemini 3.x (latest)
-      'gemini-3.0-pro',
-      'gemini-3.0-flash',
-      // Gemini 2.x
+      // Gemini 3.x (preview)
+      'gemini-3-pro-preview',
+      'gemini-3-flash-preview',
+      // Gemini 2.5
       'gemini-2.5-pro',
       'gemini-2.5-flash',
       'gemini-2.5-flash-lite',
-      'gemini-2.0-flash',
-      'gemini-2.0-flash-lite'
+      // Gemini 2.0
+      'gemini-2.0-flash-001',
+      'gemini-2.0-flash-lite-001'
     ]
-  },
-  // Other providers available via Grazie
-  other: {
-    deepseek: ['deepseek-r1'],
-    mistral: ['mistral-large', 'mistral-small', 'mistral-codestral', 'mistral-open-7b', 'mixtral-open-8x7b', 'mixtral-open-8x22b'],
-    qwen: ['qwen-max', 'qwen-max-longcontext', 'qwen-plus', 'qwen-turbo'],
-    xai: ['xai-grok-4', 'xai-grok-4-fast', 'xai-grok-4-1-fast', 'xai-grok-code-fast-1'],
-    meta: ['grazie-chat-llama-v3-8b-instruct']
   }
+  // NOTE: Other providers (DeepSeek, Mistral, Qwen, XAI, Meta) are available
+  // via Grazie native Chat API but NOT via the OpenAI-compatible proxy.
+  // They are not supported by CLI tools that use OpenAI API format.
 };
 
-// All models for tools that support multiple providers (like Aider, OpenCode)
+// All models for tools that support multiple providers (OpenCode, Codex)
 const ALL_MODELS = {
   openai: MODELS.openai.available,
   anthropic: MODELS.claude.available,
-  gemini: MODELS.gemini.available,
-  other: [
-    ...MODELS.other.deepseek,
-    ...MODELS.other.mistral,
-    ...MODELS.other.qwen,
-    ...MODELS.other.xai,
-    ...MODELS.other.meta
-  ]
+  gemini: MODELS.gemini.available
 };
 
 function ensureConfigDir() {
@@ -190,11 +190,6 @@ const TOOLS = {
     command: 'codex',
     install: 'npm install -g @openai/codex'
   },
-  aider: {
-    name: 'Aider',
-    command: 'aider',
-    install: 'brew install aider'
-  },
   gemini: {
     name: 'Gemini CLI',
     command: 'gemini',

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "jbai-cli",
-  "version": "1.4.0",
-  "description": "CLI wrappers to use AI coding tools (Claude Code, Codex, Aider, Gemini CLI, OpenCode) with JetBrains AI Platform",
+  "version": "1.5.1",
+  "description": "CLI wrappers to use AI coding tools (Claude Code, Codex, Gemini CLI, OpenCode) with JetBrains AI Platform",
   "keywords": [
     "jetbrains",
     "ai",
     "claude",
     "codex",
-    "aider",
     "gemini",
     "opencode",
     "cli",
@@ -29,7 +28,6 @@
     "jbai": "./bin/jbai.js",
     "jbai-claude": "./bin/jbai-claude.js",
     "jbai-codex": "./bin/jbai-codex.js",
-    "jbai-aider": "./bin/jbai-aider.js",
     "jbai-gemini": "./bin/jbai-gemini.js",
     "jbai-opencode": "./bin/jbai-opencode.js"
   },
@@ -41,9 +39,7 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "dependencies": {
-    "yaml": "^2.7.1"
-  },
+  "dependencies": {},
   "scripts": {
     "postinstall": "node lib/postinstall.js",
     "test": "node bin/jbai.js test"

package/bin/jbai-aider.js

@@ -1,94 +0,0 @@
-#!/usr/bin/env node
-
-const { spawn } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const yaml = require('yaml');
-const config = require('../lib/config');
-
-const token = config.getToken();
-if (!token) {
-  console.error('❌ No token found. Run: jbai token set');
-  process.exit(1);
-}
-
-if (config.isTokenExpired(token)) {
-  console.error('⚠️  Token expired. Run: jbai token refresh');
-  process.exit(1);
-}
-
-const endpoints = config.getEndpoints();
-const environment = config.getEnvironment();
-let args = process.argv.slice(2);
-
-// Check for super mode (--super, --yolo, -s)
-const superFlags = ['--super', '--yolo', '-s'];
-const superMode = args.some(a => superFlags.includes(a));
-args = args.filter(a => !superFlags.includes(a));
-
-// Create model settings file with extra headers for JetBrains authentication
-const configDir = path.join(os.homedir(), '.jbai');
-const modelSettingsFile = path.join(configDir, 'aider-model-settings.yml');
-
-// Ensure config directory exists
-if (!fs.existsSync(configDir)) {
-  fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
-}
-
-// Create model settings with extra_headers for authentication
-// Use aider/extra_params for global settings that apply to all models
-const modelSettings = [
-  {
-    name: 'aider/extra_params',
-    extra_params: {
-      extra_headers: {
-        'Grazie-Authenticate-JWT': token
-      }
-    }
-  }
-];
-
-// Write model settings file
-fs.writeFileSync(modelSettingsFile, yaml.stringify(modelSettings), { mode: 0o600 });
-
-// Build aider arguments
-// Note: --no-stream is required because JetBrains proxy has stream_options issues
-const hasModel = args.includes('--model');
-const aiderArgs = [
-  '--openai-api-base', endpoints.openai,
-  '--openai-api-key', 'placeholder',
-  '--model-settings-file', modelSettingsFile,
-  '--no-stream'
-];
-
-if (!hasModel) {
-  aiderArgs.push('--model', config.MODELS.openai.default);
-}
-
-// Add super mode flags (auto-confirm all)
-if (superMode) {
-  aiderArgs.push('--yes');
-  console.log('🚀 Super mode: --yes (auto-confirm) enabled');
-}
-
-aiderArgs.push(...args);
-
-const child = spawn('aider', aiderArgs, {
-  stdio: 'inherit',
-  env: process.env
-});
-
-child.on('error', (err) => {
-  if (err.code === 'ENOENT') {
-    const tool = config.TOOLS.aider;
-    console.error(`❌ ${tool.name} not found.\n`);
-    console.error(`Install with: ${tool.install}`);
-    console.error(`Or run: jbai install aider`);
-  } else {
-    console.error(`Error: ${err.message}`);
-  }
-  process.exit(1);
-});
-
-child.on('exit', (code) => process.exit(code || 0));