@axhub/genie 0.1.5 → 0.1.7

package/server/routes/agent.js

@@ -9,8 +9,10 @@ import { addProjectManually } from '../projects.js';
 import { queryClaudeSDK } from '../claude-sdk.js';
 import { spawnCursor } from '../cursor-cli.js';
 import { queryCodex } from '../openai-codex.js';
+import { queryGemini } from '../gemini-cli.js';
+import { queryOpencode } from '../opencode-cli.js';
 import { Octokit } from '@octokit/rest';
-import { CLAUDE_MODELS, CURSOR_MODELS, CODEX_MODELS } from '../../shared/modelConstants.js';
+import { CODEX_MODELS, GEMINI_MODELS, OPENCODE_MODELS } from '../../shared/modelConstants.js';
 import { IS_PLATFORM } from '../constants/config.js';
 
 const router = express.Router();
@@ -633,7 +635,7 @@ class ResponseCollector {
 /**
  * POST /api/agent
  *
- * Trigger an AI agent (Claude or Cursor) to work on a project.
+ * Trigger an AI agent (Claude, Cursor, Codex, or Gemini) to work on a project.
  * Supports automatic GitHub branch and pull request creation after successful completion.
  *
  * ================================================================================================
@@ -661,7 +663,7 @@ class ResponseCollector {
  * @param {string} sessionId - (Optional) Existing session ID to resume.
  *                            If provided, the request continues that session instead of creating a new one.
  *
- * @param {string} provider - (Optional) AI provider to use. Options: 'claude' | 'cursor'
+ * @param {string} provider - (Optional) AI provider to use. Options: 'claude' | 'cursor' | 'codex' | 'gemini'
  *                           Default: 'claude'
  *
  * @param {boolean} stream - (Optional) Enable Server-Sent Events (SSE) streaming for real-time updates.
@@ -677,6 +679,7 @@ class ResponseCollector {
  *                                       'gpt-5.1-codex', 'gpt-5.1-codex-high', 'gpt-5.1-codex-max',
  *                                       'gpt-5.1-codex-max-high', 'opus-4.1', 'grok', and thinking variants
  *                        Codex models: 'gpt-5.2' (default), 'gpt-5.1-codex-max', 'o3', 'o4-mini'
+ *                        Gemini models: 'gemini-2.5-pro' (default), 'gemini-2.5-flash', 'gemini-2.5-flash-lite'
  *
  * @param {boolean} cleanup - (Optional) Auto-cleanup project directory after completion.
  *                           Default: true
@@ -779,7 +782,7 @@ class ResponseCollector {
  * Input Validations (400 Bad Request):
  *   - Either githubUrl OR projectPath must be provided (not neither)
  *   - message must be non-empty string
- *   - provider must be 'claude' or 'cursor'
+ *   - provider must be 'claude', 'cursor', 'codex', or 'gemini'
  *   - createBranch/createPR requires githubUrl OR projectPath (not neither)
  *   - branchName must pass Git naming rules (if provided)
  *
@@ -872,7 +875,7 @@ router.post('/', validateExternalApiKey, async (req, res) => {
 
   // Parse stream and cleanup as booleans (handle string "true"/"false" from curl)
   const stream = req.body.stream === undefined ? true : (req.body.stream === true || req.body.stream === 'true');
-  const cleanup = req.body.cleanup === undefined ? true : (req.body.cleanup === true || req.body.cleanup === 'true');
+  const requestedCleanup = req.body.cleanup === undefined ? true : (req.body.cleanup === true || req.body.cleanup === 'true');
 
   // If branchName is provided, automatically enable createBranch
   const createBranch = branchName ? true : (req.body.createBranch === true || req.body.createBranch === 'true');
@@ -881,10 +884,13 @@ router.post('/', validateExternalApiKey, async (req, res) => {
   const normalizedMessage = typeof message === 'string' ? message.trim() : '';
   const requestedOpenOnly = openOnly === true || openOnly === 'true';
   const isOpenOnly = requestedOpenOnly || (!normalizedMessage && !!normalizedSessionId);
+  // Keep openOnly requests backward-compatible with existing docs/examples:
+  // cleanup is irrelevant when we only generate session navigation.
+  const cleanup = isOpenOnly ? false : requestedCleanup;
 
   // Validate inputs
-  if (!['claude', 'cursor', 'codex'].includes(provider)) {
-    return res.status(400).json({ error: 'provider must be "claude", "cursor", or "codex"' });
+  if (!['claude', 'cursor', 'codex', 'gemini', 'opencode'].includes(provider)) {
+    return res.status(400).json({ error: 'provider must be "claude", "cursor", "codex", "gemini", or "opencode"' });
   }
 
   if (sessionId !== undefined && (typeof sessionId !== 'string' || !sessionId.trim())) {
@@ -911,10 +917,6 @@ router.post('/', validateExternalApiKey, async (req, res) => {
     return res.status(400).json({ error: 'createBranch and createPR are not supported when openOnly=true' });
   }
 
-  if (isOpenOnly && cleanup) {
-    return res.status(400).json({ error: 'cleanup is not supported when openOnly=true' });
-  }
-
   // Validate GitHub branch/PR creation requirements
   // Allow branch/PR creation with projectPath as long as it has a GitHub remote
   if ((createBranch || createPR) && !githubUrl && !projectPath) {
@@ -1062,6 +1064,28 @@ router.post('/', validateExternalApiKey, async (req, res) => {
         model: model || CODEX_MODELS.DEFAULT,
         permissionMode: 'bypassPermissions'
       }, writer);
+    } else if (provider === 'gemini') {
+      console.log('💎 Starting Gemini CLI session');
+
+      await queryGemini(normalizedMessage, {
+        projectPath: finalProjectPath,
+        cwd: finalProjectPath,
+        sessionId: normalizedSessionId,
+        resume: !!normalizedSessionId,
+        model: model || GEMINI_MODELS.DEFAULT,
+        permissionMode: 'bypassPermissions'
+      }, writer);
+    } else if (provider === 'opencode') {
+      console.log('🧠 Starting OpenCode CLI session');
+
+      await queryOpencode(normalizedMessage, {
+        projectPath: finalProjectPath,
+        cwd: finalProjectPath,
+        sessionId: normalizedSessionId,
+        resume: !!normalizedSessionId,
+        model: model || OPENCODE_MODELS.DEFAULT,
+        permissionMode: 'bypassPermissions'
+      }, writer);
     }
 
     // Handle GitHub branch and PR creation after successful agent completion

package/server/routes/cli-auth.js

@@ -5,6 +5,172 @@ import path from 'path';
 import os from 'os';
 
 const router = express.Router();
+const INSTALLATION_CACHE_TTL_MS = 12 * 60 * 60 * 1000;
+const SUPPORTED_PROVIDER_COMMANDS = {
+  claude: 'claude',
+  cursor: 'cursor-agent',
+  codex: 'codex',
+  gemini: 'gemini',
+  opencode: 'opencode'
+};
+const installationStatusCache = new Map(); // provider -> status
+const installationStatusInFlight = new Map(); // provider -> Promise
+
+function getLocatorCommand() {
+  return process.platform === 'win32' ? 'where' : 'which';
+}
+
+function resolveCommandPath(command) {
+  return new Promise((resolve) => {
+    let childProcess;
+    let stdout = '';
+    let stderr = '';
+
+    try {
+      childProcess = spawn(getLocatorCommand(), [command], {
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+    } catch (error) {
+      resolve({
+        found: false,
+        resolvedPath: null,
+        reason: `Failed to run command locator: ${error.message}`
+      });
+      return;
+    }
+
+    childProcess.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    childProcess.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    childProcess.on('close', (code) => {
+      const lines = stdout
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean);
+      const resolvedPath = lines[0] || null;
+
+      if (code === 0 && resolvedPath) {
+        resolve({
+          found: true,
+          resolvedPath,
+          reason: null
+        });
+        return;
+      }
+
+      resolve({
+        found: false,
+        resolvedPath: null,
+        reason: `${command} not found in PATH${stderr?.trim() ? ` (${stderr.trim()})` : ''}`
+      });
+    });
+
+    childProcess.on('error', (error) => {
+      resolve({
+        found: false,
+        resolvedPath: null,
+        reason: `Failed to detect ${command}: ${error.message}`
+      });
+    });
+  });
+}
+
+function buildInstallationStatus(provider, command, installed, resolvedPath, reason, cacheHit = false) {
+  return {
+    success: true,
+    provider,
+    command,
+    installed,
+    reason,
+    resolvedPath,
+    checkedAt: new Date().toISOString(),
+    cacheHit,
+    ttlMs: INSTALLATION_CACHE_TTL_MS
+  };
+}
+
+async function detectProviderInstallationStatus(provider) {
+  const command = SUPPORTED_PROVIDER_COMMANDS[provider];
+  if (!command) {
+    throw new Error(`Unsupported provider: ${provider}`);
+  }
+
+  const now = Date.now();
+  const cached = installationStatusCache.get(provider);
+  if (cached && cached.expiresAt > now) {
+    return {
+      ...cached.status,
+      cacheHit: true
+    };
+  }
+
+  if (installationStatusInFlight.has(provider)) {
+    return installationStatusInFlight.get(provider);
+  }
+
+  const detectionPromise = (async () => {
+    const commandCheck = await resolveCommandPath(command);
+    const installed = commandCheck.found;
+    const status = buildInstallationStatus(
+      provider,
+      command,
+      installed,
+      commandCheck.resolvedPath,
+      commandCheck.reason,
+      false
+    );
+
+    if (installed) {
+      installationStatusCache.set(provider, {
+        status,
+        expiresAt: now + INSTALLATION_CACHE_TTL_MS
+      });
+    } else {
+      installationStatusCache.delete(provider);
+    }
+
+    return status;
+  })();
+
+  installationStatusInFlight.set(provider, detectionPromise);
+
+  try {
+    return await detectionPromise;
+  } finally {
+    installationStatusInFlight.delete(provider);
+  }
+}
+
+router.get('/providers/:provider/installation-status', async (req, res) => {
+  try {
+    const provider = String(req.params.provider || '').toLowerCase();
+    if (!Object.prototype.hasOwnProperty.call(SUPPORTED_PROVIDER_COMMANDS, provider)) {
+      return res.status(400).json({
+        success: false,
+        error: `Unsupported provider: ${provider}`
+      });
+    }
+
+    const forceRefresh = String(req.query.force || '').toLowerCase() === 'true';
+    if (forceRefresh) {
+      installationStatusCache.delete(provider);
+    }
+
+    const status = await detectProviderInstallationStatus(provider);
+    return res.json(status);
+  } catch (error) {
+    console.error('Error checking provider installation status:', error);
+    return res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
 
 router.get('/claude/status', async (req, res) => {
   try {
@@ -74,6 +240,26 @@ router.get('/codex/status', async (req, res) => {
   }
 });
 
+router.get('/gemini/status', async (req, res) => {
+  try {
+    const result = await checkGeminiCredentials();
+
+    res.json({
+      authenticated: result.authenticated,
+      email: result.email,
+      error: result.error
+    });
+
+  } catch (error) {
+    console.error('Error checking Gemini auth status:', error);
+    res.status(500).json({
+      authenticated: false,
+      email: null,
+      error: error.message
+    });
+  }
+});
+
 async function checkClaudeCredentials() {
   try {
     const credPath = path.join(os.homedir(), '.claude', '.credentials.json');
@@ -260,4 +446,89 @@ async function checkCodexCredentials() {
   }
 }
 
+async function checkGeminiCredentials() {
+  try {
+    const geminiDir = path.join(os.homedir(), '.gemini');
+    const oauthCredPath = path.join(geminiDir, 'oauth_creds.json');
+    const content = await fs.readFile(oauthCredPath, 'utf8');
+    const creds = JSON.parse(content);
+
+    if (creds?.access_token || creds?.refresh_token || creds?.token) {
+      return {
+        authenticated: true,
+        email: creds?.email || 'Authenticated'
+      };
+    }
+
+    return {
+      authenticated: false,
+      email: null,
+      error: 'No valid Gemini credentials found'
+    };
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return {
+        authenticated: false,
+        email: null,
+        error: 'Gemini not configured'
+      };
+    }
+
+    return {
+      authenticated: false,
+      email: null,
+      error: error.message
+    };
+  }
+}
+
+// OpenCode status helper
+async function checkOpencodeCredentials() {
+  try {
+    const candidates = [
+      path.join(os.homedir(), '.config', 'opencode', 'auth.json'),
+      path.join(os.homedir(), '.opencode', 'auth.json')
+    ];
+    let anyFileAccessible = false;
+    for (const p of candidates) {
+      try {
+        await fs.access(p);
+        anyFileAccessible = true;
+        const raw = await fs.readFile(p, 'utf8');
+        const data = JSON.parse(raw);
+        const token = data?.access_token || data?.token || data?.api_key;
+        if (token) {
+          const email = data.email || 'Authenticated';
+          return { authenticated: true, email, error: null };
+        }
+        // else try next candidate
+      } catch (err) {
+        // ignore and try next
+        continue;
+      }
+    }
+    if (anyFileAccessible) {
+      return { authenticated: false, email: null, error: 'Invalid OpenCode credentials format' };
+    }
+    return { authenticated: false, email: null, error: 'OpenCode not configured' };
+  } catch (error) {
+    return { authenticated: false, email: null, error: 'OpenCode not configured' };
+  }
+}
+
+// Route: GET /opencode/status
+router.get('/opencode/status', async (req, res) => {
+  try {
+    const result = await checkOpencodeCredentials();
+    res.json({
+      authenticated: result.authenticated,
+      email: result.email,
+      error: result.error
+    });
+  } catch (error) {
+    console.error('Error checking OpenCode auth status:', error);
+    res.status(500).json({ authenticated: false, email: null, error: error.message });
+  }
+});
+
 export default router;

package/server/routes/commands.js

@@ -4,7 +4,8 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import os from 'os';
 import matter from 'gray-matter';
-import { CLAUDE_MODELS, CURSOR_MODELS, CODEX_MODELS } from '../../shared/modelConstants.js';
+import { CLAUDE_MODELS, CURSOR_MODELS, CODEX_MODELS, GEMINI_MODELS, OPENCODE_MODELS } from '../../shared/modelConstants.js';
+import { listOpencodeModels } from '../opencode-cli.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -187,11 +188,35 @@ Custom commands can be created in:
     const availableModels = {
       claude: CLAUDE_MODELS.OPTIONS.map(o => o.value),
       cursor: CURSOR_MODELS.OPTIONS.map(o => o.value),
-      codex: CODEX_MODELS.OPTIONS.map(o => o.value)
+      codex: CODEX_MODELS.OPTIONS.map(o => o.value),
+      gemini: GEMINI_MODELS.OPTIONS.map(o => o.value),
+      opencode: OPENCODE_MODELS.OPTIONS.map(o => o.value)
     };
 
     const currentProvider = context?.provider || 'claude';
-    const currentModel = context?.model || CLAUDE_MODELS.DEFAULT;
+    const providerDefaults = {
+      claude: CLAUDE_MODELS.DEFAULT,
+      cursor: CURSOR_MODELS.DEFAULT,
+      codex: CODEX_MODELS.DEFAULT,
+      gemini: GEMINI_MODELS.DEFAULT,
+      opencode: OPENCODE_MODELS.DEFAULT
+    };
+    const currentModel = context?.model || providerDefaults[currentProvider] || CLAUDE_MODELS.DEFAULT;
+    let opencodeDiscovery = null;
+
+    if (context?.projectPath) {
+      try {
+        opencodeDiscovery = await listOpencodeModels({
+          projectPath: context?.projectPath,
+          cwd: context?.projectPath
+        });
+        if (opencodeDiscovery.models.length > 0) {
+          availableModels.opencode = opencodeDiscovery.models;
+        }
+      } catch (error) {
+        console.warn('Failed to query OpenCode runtime models:', error.message);
+      }
+    }
 
     return {
       type: 'builtin',
@@ -202,6 +227,7 @@ Custom commands can be created in:
           model: currentModel
         },
         available: availableModels,
+        opencodeDiscovery,
         message: args.length > 0
           ? `Switching to model: ${args[0]}`
           : `Current model: ${currentModel}`

package/server/routes/git.js

@@ -6,6 +6,7 @@ import { promises as fs } from 'fs';
 import { extractProjectDirectory } from '../projects.js';
 import { queryClaudeSDK } from '../claude-sdk.js';
 import { spawnCursor } from '../cursor-cli.js';
+import { queryGemini } from '../gemini-cli.js';
 
 const router = express.Router();
 const execAsync = promisify(exec);
@@ -519,8 +520,8 @@ router.post('/generate-commit-message', async (req, res) => {
   }
 
   // Validate provider
-  if (!['claude', 'cursor'].includes(provider)) {
-    return res.status(400).json({ error: 'provider must be "claude" or "cursor"' });
+  if (!['claude', 'cursor', 'gemini'].includes(provider)) {
+    return res.status(400).json({ error: 'provider must be "claude", "cursor", or "gemini"' });
   }
 
   try {
@@ -573,10 +574,10 @@ router.post('/generate-commit-message', async (req, res) => {
 });
 
 /**
- * Generates a commit message using AI (Claude SDK or Cursor CLI)
+ * Generates a commit message using AI (Claude SDK, Cursor CLI, or Gemini CLI)
  * @param {Array<string>} files - List of changed files
  * @param {string} diffContext - Git diff content
- * @param {string} provider - 'claude' or 'cursor'
+ * @param {string} provider - 'claude', 'cursor', or 'gemini'
  * @param {string} projectPath - Project directory path
  * @returns {Promise<string>} Generated commit message
  */
@@ -630,6 +631,9 @@ Generate the commit message:`;
             console.log('✅ Cursor output:', parsed.output.substring(0, 100));
             responseText += parsed.output;
           }
+          else if (parsed.type === 'claude-response' && parsed.data?.type === 'content_block_delta' && parsed.data?.delta?.text) {
+            responseText += parsed.data.delta.text;
+          }
           // Also handle direct text messages
           else if (parsed.type === 'text' && parsed.text) {
             console.log('✅ Direct text:', parsed.text.substring(0, 100));
@@ -658,6 +662,12 @@ Generate the commit message:`;
         cwd: projectPath,
         skipPermissions: true
       }, writer);
+    } else if (provider === 'gemini') {
+      await queryGemini(prompt, {
+        cwd: projectPath,
+        projectPath,
+        permissionMode: 'bypassPermissions'
+      }, writer);
     }
 
     console.log('📊 Total response text collected:', responseText.length, 'characters');
@@ -1125,4 +1135,4 @@ router.post('/delete-untracked', async (req, res) => {
   }
 });
 
-export default router;
+export default router;

package/server/routes/opencode.js

@@ -0,0 +1,72 @@
+import express from 'express';
+import {
+  getOpencodeSessions,
+  getOpencodeSessionMessages,
+  deleteOpencodeSession
+} from '../projects.js';
+import { listOpencodeModels } from '../opencode-cli.js';
+
+const router = express.Router();
+
+router.get('/models', async (req, res) => {
+  try {
+    const { projectPath } = req.query;
+
+    if (!projectPath) {
+      return res.status(400).json({ success: false, error: 'projectPath query parameter required' });
+    }
+
+    const discovery = await listOpencodeModels({ projectPath, cwd: projectPath });
+    res.json({ success: true, ...discovery });
+  } catch (error) {
+    console.error('Error fetching OpenCode models:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/sessions', async (req, res) => {
+  try {
+    const { projectPath } = req.query;
+
+    if (!projectPath) {
+      return res.status(400).json({ success: false, error: 'projectPath query parameter required' });
+    }
+
+    const sessions = await getOpencodeSessions(projectPath);
+    res.json({ success: true, sessions });
+  } catch (error) {
+    console.error('Error fetching OpenCode sessions:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/sessions/:sessionId/messages', async (req, res) => {
+  try {
+    const { sessionId } = req.params;
+    const { limit, offset } = req.query;
+
+    const result = await getOpencodeSessionMessages(
+      sessionId,
+      limit ? parseInt(limit, 10) : null,
+      offset ? parseInt(offset, 10) : 0
+    );
+
+    res.json({ success: true, ...result });
+  } catch (error) {
+    console.error('Error fetching OpenCode session messages:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.delete('/sessions/:sessionId', async (req, res) => {
+  try {
+    const { sessionId } = req.params;
+    await deleteOpencodeSession(sessionId);
+    res.json({ success: true });
+  } catch (error) {
+    console.error(`Error deleting OpenCode session ${req.params.sessionId}:`, error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+export default router;

package/shared/modelConstants.js

@@ -28,26 +28,35 @@ export const CLAUDE_MODELS = {
  */
 export const CURSOR_MODELS = {
   OPTIONS: [
-    { value: 'gpt-5.2-high', label: 'GPT-5.2 High' },
-    { value: 'gemini-3-pro', label: 'Gemini 3 Pro' },
-    { value: 'opus-4.5-thinking', label: 'Claude 4.5 Opus (Thinking)' },
-    { value: 'gpt-5.2', label: 'GPT-5.2' },
-    { value: 'gpt-5.1', label: 'GPT-5.1' },
-    { value: 'gpt-5.1-high', label: 'GPT-5.1 High' },
-    { value: 'composer-1', label: 'Composer 1' },
     { value: 'auto', label: 'Auto' },
-    { value: 'sonnet-4.5', label: 'Claude 4.5 Sonnet' },
-    { value: 'sonnet-4.5-thinking', label: 'Claude 4.5 Sonnet (Thinking)' },
+    { value: 'sonnet-4', label: 'Claude 4 Sonnet' },
+    { value: 'sonnet-4-1m', label: 'Claude 4 Sonnet 1M' },
+    { value: 'haiku-4.5', label: 'Claude 4.5 Haiku' },
     { value: 'opus-4.5', label: 'Claude 4.5 Opus' },
+    { value: 'sonnet-4.5', label: 'Claude 4.5 Sonnet' },
+    { value: 'opus-4.6', label: 'Claude 4.6 Opus' },
+    { value: 'opus-4.6-fast', label: 'Claude 4.6 Opus (Fast mode)' },
+    { value: 'composer-1', label: 'Composer 1' },
+    { value: 'composer-1.5', label: 'Composer 1.5' },
+    { value: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash' },
+    { value: 'gemini-3-flash', label: 'Gemini 3 Flash' },
+    { value: 'gemini-3-pro-preview', label: 'Gemini 3 Pro Preview' },
+    { value: 'gemini-3-pro', label: 'Gemini 3 Pro' },
+    { value: 'gemini-3-pro-image-preview', label: 'Gemini 3 Pro Image Preview' },
+    { value: 'gpt-5', label: 'GPT-5' },
+    { value: 'gpt-5-fast', label: 'GPT-5 Fast' },
+    { value: 'gpt-5-mini', label: 'GPT-5 Mini' },
+    { value: 'gpt-5-codex', label: 'GPT-5-Codex' },
     { value: 'gpt-5.1-codex', label: 'GPT-5.1 Codex' },
-    { value: 'gpt-5.1-codex-high', label: 'GPT-5.1 Codex High' },
     { value: 'gpt-5.1-codex-max', label: 'GPT-5.1 Codex Max' },
-    { value: 'gpt-5.1-codex-max-high', label: 'GPT-5.1 Codex Max High' },
-    { value: 'opus-4.1', label: 'Claude 4.1 Opus' },
-    { value: 'grok', label: 'Grok' }
+    { value: 'gpt-5.1-codex-mini', label: 'GPT-5.1 Codex Mini' },
+    { value: 'gpt-5.2', label: 'GPT-5.2' },
+    { value: 'gpt-5.2-codex', label: 'GPT-5.2 Codex' },
+    { value: 'gpt-5.3-codex', label: 'GPT-5.3 Codex' },
+    { value: 'grok-code', label: 'Grok Code' }
   ],
 
-  DEFAULT: 'gpt-5'
+  DEFAULT: 'auto'
 };
 
 /**
@@ -55,11 +64,47 @@ export const CURSOR_MODELS = {
  */
 export const CODEX_MODELS = {
   OPTIONS: [
-    { value: 'gpt-5.2-codex', label: 'GPT-5.2 Codex' },
-    { value: 'gpt-5.2', label: 'GPT-5.2' },
+    { value: 'gpt-5', label: 'GPT-5' },
+    { value: 'gpt-5-codex', label: 'GPT-5 Codex' },
+    { value: 'gpt-5-codex-mini', label: 'GPT-5 Codex Mini' },
+    { value: 'gpt-5.1', label: 'GPT-5.1' },
+    { value: 'gpt-5.1-codex', label: 'GPT-5.1 Codex' },
     { value: 'gpt-5.1-codex-max', label: 'GPT-5.1 Codex Max' },
-    { value: 'gpt-5.1-codex-mini', label: 'GPT-5.1 Codex Mini' }
+    { value: 'gpt-5.1-codex-mini', label: 'GPT-5.1 Codex Mini' },
+    { value: 'gpt-5.2', label: 'GPT-5.2' },
+    { value: 'gpt-5.2-codex', label: 'GPT-5.2 Codex' },
+    { value: 'gpt-5.2-high', label: 'GPT-5.2 High' },
+    { value: 'gpt-5.2-low', label: 'GPT-5.2 Low' },
+    { value: 'gpt-5.2-medium', label: 'GPT-5.2 Medium' },
+    { value: 'gpt-5.2-xhigh', label: 'GPT-5.2 XHigh' },
+    { value: 'gpt-5.3-codex', label: 'GPT-5.3 Codex' },
+    { value: 'gpt-5.3-codex-high', label: 'GPT-5.3 Codex High' },
+    { value: 'gpt-5.3-codex-low', label: 'GPT-5.3 Codex Low' },
+    { value: 'gpt-5.3-codex-medium', label: 'GPT-5.3 Codex Medium' },
+    { value: 'gpt-5.3-codex-xhigh', label: 'GPT-5.3 Codex XHigh' }
   ],
 
   DEFAULT: 'gpt-5.2-codex'
 };
+
+export const GEMINI_MODELS = {
+  OPTIONS: [
+    { value: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro' },
+    { value: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash' },
+    { value: 'gemini-3-pro-preview', label: 'Gemini 3 Pro Preview' },
+    { value: 'gemini-3-flash-preview', label: 'Gemini 3 Flash Preview' }
+  ],
+
+  DEFAULT: 'gemini-3-pro-preview'
+};
+
+/**
+ * OpenCode (OPENCODE) Models
+ */
+export const OPENCODE_MODELS = {
+  OPTIONS: [
+    { value: 'kimi-k2.5', label: 'Kimi K2.5' }
+  ],
+
+  DEFAULT: 'kimi-k2.5'
+};