@cloudcli-ai/cloudcli 1.36.0 → 1.36.1

package/server/modules/providers/list/opencode/opencode-models.provider.ts

@@ -1,5 +1,3 @@
-import { spawn } from 'node:child_process';
-
 import Database from 'better-sqlite3';
 import crossSpawn from 'cross-spawn';
 
@@ -51,23 +49,15 @@ export const OPENCODE_FALLBACK_MODELS: ProviderModelsDefinition = {
       label: 'GPT-5.4 Mini',
       description: 'openai - openai/gpt-5.4-mini',
     },
-    {
-      value: 'google/gemini-2.5-pro',
-      label: 'Gemini 2.5 Pro',
-      description: 'google - google/gemini-2.5-pro',
-    },
-    {
-      value: 'google/gemini-2.5-flash',
-      label: 'Gemini 2.5 Flash',
-      description: 'google - google/gemini-2.5-flash',
-    },
   ],
   DEFAULT: 'anthropic/claude-sonnet-4-5',
 };
 
 const OPEN_CODE_MODELS_TIMEOUT_MS = 20_000;
 const MODEL_ID_LINE = /^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*$/i;
-const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
+// cross-spawn resolves .cmd shims/PATHEXT on Windows and delegates to
+// child_process.spawn everywhere else.
+const spawnFunction = crossSpawn;
 const DATE_TOKEN = /^\d{8}$/;
 const SIMPLE_NUMBER_TOKEN = /^\d$/;
 const VERSION_TOKEN = /^[a-z]\d+$/i;
@@ -239,6 +229,10 @@ const readOpenCodeModelParts = (id: string): { upstreamProvider: string; slug: s
   };
 };
 
+const isSupportedOpenCodeModelId = (id: string): boolean => (
+  readOpenCodeModelParts(id).upstreamProvider.toLowerCase() !== 'google'
+);
+
 const readOpenCodeVerboseModelId = (model: OpenCodeVerboseModel): string | null => {
   const id = readOptionalString(model.id);
   if (!id) {
@@ -296,7 +290,7 @@ const readOpenCodeEffortValues = (
 
 const mapOpenCodeVerboseModel = (model: OpenCodeVerboseModel): ProviderModelOption | null => {
   const value = readOpenCodeVerboseModelId(model);
-  if (!value) {
+  if (!value || !isSupportedOpenCodeModelId(value)) {
     return null;
   }
 
@@ -315,11 +309,13 @@ const mapOpenCodeVerboseModel = (model: OpenCodeVerboseModel): ProviderModelOpti
 };
 
 export const buildOpenCodeDefinitionFromIds = (ids: string[]): ProviderModelsDefinition => {
-  const options: ProviderModelOption[] = ids.map((value) => ({
-    value,
-    label: labelForOpenCodeModelId(value),
-    description: descriptionForOpenCodeModelId(value),
-  }));
+  const options: ProviderModelOption[] = ids
+    .filter(isSupportedOpenCodeModelId)
+    .map((value) => ({
+      value,
+      label: labelForOpenCodeModelId(value),
+      description: descriptionForOpenCodeModelId(value),
+    }));
 
   const defaultValue = options.find((option) => option.value === OPENCODE_FALLBACK_MODELS.DEFAULT)?.value
     ?? options[0]?.value

package/server/modules/providers/list/opencode/opencode-session-synchronizer.provider.ts

@@ -11,6 +11,7 @@ import {
   normalizeSessionName,
   readJsonRecord,
   readOptionalString,
+  unwrapJsonStringLiteral,
 } from '@/shared/utils.js';
 
 type OpenCodeSessionRow = {
@@ -128,9 +129,26 @@ export class OpenCodeSessionSynchronizer implements IProviderSessionSynchronizer
     const existingSession = sessionsDb.getSessionByProviderSessionId(sessionId)
       ?? sessionsDb.getSessionById(sessionId);
     const existingName = existingSession?.custom_name;
-    const nextName = existingName && existingName !== fallbackTitle
-      ? existingName
-      : readOptionalString(row.title) ?? this.readFirstUserText(db, sessionId);
+
+    // Sessions started by sending a message from cloudcli carry a distinct
+    // app-allocated session_id mapped to the provider id. For these we title the
+    // conversation from the first user message the user typed, matching how the
+    // app titles a brand-new conversation. Sessions discovered purely by
+    // indexing (session_id === provider_session_id) keep OpenCode's own stored
+    // title.
+    const isAppCreated =
+      existingSession != null &&
+      existingSession.provider_session_id != null &&
+      existingSession.session_id !== existingSession.provider_session_id;
+
+    let nextName: string | undefined;
+    if (existingName && existingName !== fallbackTitle) {
+      nextName = existingName;
+    } else if (isAppCreated) {
+      nextName = this.readFirstUserText(db, sessionId) ?? readOptionalString(row.title);
+    } else {
+      nextName = readOptionalString(row.title) ?? this.readFirstUserText(db, sessionId);
+    }
 
     // OpenCode stores every session in one shared sqlite database, so jsonl_path
     // must stay null to avoid deleting opencode.db when one app session is removed.
@@ -163,7 +181,10 @@ export class OpenCodeSessionSynchronizer implements IProviderSessionSynchronizer
       `).get(sessionId) as { data: string | null } | undefined;
 
       const data = readJsonRecord(row?.data);
-      return readOptionalString(data?.text);
+      const text = readOptionalString(data?.text);
+      // OpenCode persists the first prompt as a JSON string literal (e.g.
+      // `"hello"`), so decode it to avoid titling the session with quotes.
+      return text === undefined ? undefined : unwrapJsonStringLiteral(text);
     } catch {
       return undefined;
     }

package/server/modules/providers/list/opencode/opencode-sessions.provider.ts

@@ -2,6 +2,7 @@ import fsSync from 'node:fs';
 
 import Database from 'better-sqlite3';
 
+import { parseImagesInputTag } from '@/shared/image-attachments.js';
 import type { IProviderSessions } from '@/shared/interfaces.js';
 import type { AnyRecord, FetchHistoryOptions, FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
 import {
@@ -13,6 +14,7 @@ import {
   readJsonRecord,
   readOptionalString,
   sliceTailPage,
+  unwrapJsonStringLiteral,
 } from '@/shared/utils.js';
 
 const PROVIDER = 'opencode';
@@ -59,25 +61,6 @@ const formatToolContent = (value: unknown): string => {
   }
 };
 
-/**
- * OpenCode can persist the first prompt as a JSON string literal inside a text
- * part, for example `"hello"` instead of `hello`. Decode only complete JSON
- * string literals so normal assistant/user prose remains untouched.
- */
-const unwrapJsonStringLiteral = (value: string): string => {
-  const trimmed = value.trim();
-  if (!trimmed.startsWith('"') || !trimmed.endsWith('"')) {
-    return value;
-  }
-
-  try {
-    const parsed = JSON.parse(trimmed);
-    return typeof parsed === 'string' ? parsed : value;
-  } catch {
-    return value;
-  }
-};
-
 const extractText = (value: unknown): string => {
   if (typeof value === 'string') {
     return unwrapJsonStringLiteral(value);
@@ -418,8 +401,13 @@ export class OpenCodeSessionsProvider implements IProviderSessions {
       }
 
       if (partType === 'text') {
-        const content = extractText(partData);
-        if (content.trim()) {
+        const rawContent = extractText(partData);
+        // User prompts sent with attachments carry an <images_input> path
+        // list; strip it for display and surface the paths as images.
+        const { text: content, attachments } = messageRole === 'user'
+          ? parseImagesInputTag(rawContent)
+          : { text: rawContent, attachments: [] };
+        if (content.trim() || attachments.length > 0) {
           normalized.push(createNormalizedMessage({
             id: baseId,
             sessionId,
@@ -428,6 +416,7 @@ export class OpenCodeSessionsProvider implements IProviderSessions {
             kind: 'text',
             role: messageRole === 'user' ? 'user' : 'assistant',
             content,
+            images: attachments.length > 0 ? attachments : undefined,
           }));
         }
         continue;

package/server/modules/providers/provider.registry.ts

@@ -1,7 +1,6 @@
 import { ClaudeProvider } from '@/modules/providers/list/claude/claude.provider.js';
 import { CodexProvider } from '@/modules/providers/list/codex/codex.provider.js';
 import { CursorProvider } from '@/modules/providers/list/cursor/cursor.provider.js';
-import { GeminiProvider } from '@/modules/providers/list/gemini/gemini.provider.js';
 import { OpenCodeProvider } from '@/modules/providers/list/opencode/opencode.provider.js';
 import type { IProvider } from '@/shared/interfaces.js';
 import type { LLMProvider } from '@/shared/types.js';
@@ -11,7 +10,6 @@ const providers: Record<LLMProvider, IProvider> = {
   claude: new ClaudeProvider(),
   codex: new CodexProvider(),
   cursor: new CursorProvider(),
-  gemini: new GeminiProvider(),
   opencode: new OpenCodeProvider(),
 };
 

package/server/modules/providers/provider.routes.ts

@@ -285,7 +285,6 @@ const parseProvider = (value: unknown): LLMProvider => {
     normalized === 'claude'
     || normalized === 'codex'
     || normalized === 'cursor'
-    || normalized === 'gemini'
     || normalized === 'opencode'
   ) {
     return normalized;

package/server/modules/providers/services/provider-capabilities.service.ts

@@ -46,7 +46,7 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     provider: 'cursor',
     permissionModes: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
     defaultPermissionMode: 'default',
-    supportsImages: false,
+    supportsImages: true,
     supportsAbort: true,
     supportsPermissionRequests: false,
     supportsTokenUsage: false,
@@ -56,27 +56,20 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     provider: 'codex',
     permissionModes: ['default', 'acceptEdits', 'bypassPermissions'],
     defaultPermissionMode: 'default',
-    supportsImages: false,
+    supportsImages: true,
     supportsAbort: true,
     supportsPermissionRequests: false,
     supportsTokenUsage: true,
     supportsEffort: true,
   },
-  gemini: {
-    provider: 'gemini',
-    permissionModes: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
-    defaultPermissionMode: 'default',
-    supportsImages: false,
-    supportsAbort: true,
-    supportsPermissionRequests: false,
-    supportsTokenUsage: true,
-    supportsEffort: false,
-  },
   opencode: {
     provider: 'opencode',
-    permissionModes: ['default'],
+    // Mapped by the runtime onto OpenCode's controls: `--agent plan` (plan),
+    // `--auto` (bypassPermissions) and the OPENCODE_PERMISSION env var
+    // (acceptEdits). See resolveOpenCodePermissionOptions in opencode-cli.js.
+    permissionModes: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
     defaultPermissionMode: 'default',
-    supportsImages: false,
+    supportsImages: true,
     supportsAbort: true,
     supportsPermissionRequests: false,
     supportsTokenUsage: true,

package/server/modules/providers/services/provider-models.service.ts

@@ -17,7 +17,7 @@ import { readProviderSessionActiveModelChange } from '@/shared/utils.js';
 
 export const PROVIDER_MODELS_CACHE_TTL_MS = 3 * 24 * 60 * 60 * 1000;
 const PROVIDER_MODELS_CACHE_VERSION = 2;
-const UNCACHED_PROVIDERS = new Set<LLMProvider>(['claude', 'gemini']);
+const UNCACHED_PROVIDERS = new Set<LLMProvider>(['claude']);
 
 type ProviderModelsServiceDependencies = {
   resolveProvider?: (provider: LLMProvider) => Pick<IProvider, 'models'>;

package/server/modules/providers/services/session-conversations-search.service.ts

@@ -8,7 +8,7 @@ import { rgPath } from '@vscode/ripgrep';
 import { projectsDb, sessionsDb } from '@/modules/database/index.js';
 
 type AnyRecord = Record<string, any>;
-type SearchableProvider = 'claude' | 'codex' | 'gemini';
+type SearchableProvider = 'claude' | 'codex';
 
 type SearchSnippetHighlight = {
   start: number;
@@ -82,7 +82,7 @@ type ProjectBucket = {
   sessions: SearchableSessionRow[];
 };
 
-const SUPPORTED_PROVIDERS = new Set<SearchableProvider>(['claude', 'codex', 'gemini']);
+const SUPPORTED_PROVIDERS = new Set<SearchableProvider>(['claude', 'codex']);
 const MAX_MATCHES_PER_SESSION = 2;
 const RIPGREP_FILE_CHUNK_SIZE = 40;
 const RIPGREP_CHUNK_CONCURRENCY = 6;
@@ -455,21 +455,6 @@ function extractCodexText(content: unknown): string {
     .join(' ');
 }
 
-function extractGeminiText(content: unknown): string {
-  if (typeof content === 'string') {
-    return content;
-  }
-
-  if (!Array.isArray(content)) {
-    return '';
-  }
-
-  return content
-    .filter((part: AnyRecord) => typeof part?.text === 'string')
-    .map((part: AnyRecord) => String(part.text))
-    .join(' ');
-}
-
 function normalizeSearchableSessions(rows: SessionRepositoryRow[]): SearchableSessionRow[] {
   const normalizedRows: SearchableSessionRow[] = [];
   const projectArchiveStateByPath = new Map<string, boolean>();
@@ -1065,81 +1050,6 @@ async function parseCodexSessionMatches(
   };
 }
 
-async function parseGeminiSessionMatches(
-  session: SearchableSessionRow,
-  runtime: SearchRuntime,
-): Promise<SessionConversationResult | null> {
-  let data: string;
-  try {
-    data = await fs.readFile(session.jsonl_path, 'utf8');
-  } catch {
-    return null;
-  }
-
-  let parsed: AnyRecord;
-  try {
-    parsed = JSON.parse(data) as AnyRecord;
-  } catch {
-    return null;
-  }
-
-  const sourceMessages = Array.isArray(parsed.messages) ? parsed.messages as AnyRecord[] : [];
-  if (sourceMessages.length === 0) {
-    return null;
-  }
-
-  const matches: SessionConversationMatch[] = [];
-  let firstUserText: string | null = null;
-
-  for (const msg of sourceMessages) {
-    if (runtime.totalMatches >= runtime.limit || runtime.isAborted()) {
-      break;
-    }
-
-    const role = msg.type === 'user'
-      ? 'user'
-      : (msg.type === 'gemini' || msg.type === 'assistant')
-        ? 'assistant'
-        : null;
-    if (!role) {
-      continue;
-    }
-
-    const text = extractGeminiText(msg.content);
-    if (!text) {
-      continue;
-    }
-
-    if (role === 'user' && !firstUserText) {
-      firstUserText = text;
-    }
-
-    if (!runtime.matchesQuery(text)) {
-      continue;
-    }
-
-    const { snippet, highlights } = runtime.buildSnippet(text);
-    addSessionMatch(runtime, matches, {
-      role,
-      snippet,
-      highlights,
-      timestamp: msg.timestamp ? String(msg.timestamp) : null,
-      provider: 'gemini',
-    });
-  }
-
-  if (matches.length === 0) {
-    return null;
-  }
-
-  return {
-    sessionId: session.session_id,
-    provider: 'gemini',
-    sessionSummary: toSummaryText(session.custom_name, firstUserText, 'Gemini Session'),
-    matches,
-  };
-}
-
 async function parseSessionMatches(
   session: SearchableSessionRow,
   runtime: SearchRuntime,
@@ -1150,7 +1060,7 @@ async function parseSessionMatches(
   if (session.provider === 'codex') {
     return parseCodexSessionMatches(session, runtime);
   }
-  return parseGeminiSessionMatches(session, runtime);
+  return null;
 }
 
 export async function searchConversations(

package/server/modules/providers/services/session-synchronizer.service.ts

@@ -21,7 +21,6 @@ export const sessionSynchronizerService = {
       claude: 0,
       codex: 0,
       cursor: 0,
-      gemini: 0,
       opencode: 0,
     };
     const failures: string[] = [];

package/server/modules/providers/services/sessions-watcher.service.ts

@@ -25,16 +25,6 @@ const PROVIDER_WATCH_PATHS: Array<{ provider: LLMProvider; rootPath: string }> =
     provider: 'codex',
     rootPath: path.join(os.homedir(), '.codex', 'sessions'),
   },
-  // {
-  //   provider: 'gemini',
-  //   rootPath: path.join(os.homedir(), '.gemini', 'sessions'),
-  // },
-  // Keep `sessions/` watcher disabled: Gemini also mirrors artifacts there,
-  // which causes duplicate synchronization events.
-  {
-    provider: 'gemini',
-    rootPath: path.join(os.homedir(), '.gemini', 'tmp'),
-  },
   {
     provider: 'opencode',
     rootPath: path.join(os.homedir(), '.local', 'share', 'opencode'),
@@ -81,10 +71,6 @@ function isWatcherTargetFile(provider: LLMProvider, filePath: string): boolean {
     return path.basename(filePath) === 'opencode.db';
   }
 
-  if (provider === 'gemini') {
-    return filePath.endsWith('.json') || filePath.endsWith('.jsonl');
-  }
-
   return filePath.endsWith('.jsonl');
 }
 

package/server/modules/providers/tests/codex-sessions.test.ts

@@ -0,0 +1,111 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import { CodexSessionSynchronizer } from '@/modules/providers/list/codex/codex-session-synchronizer.provider.js';
+
+const patchHomeDir = (nextHomeDir: string) => {
+  const original = os.homedir;
+  (os as any).homedir = () => nextHomeDir;
+  return () => {
+    (os as any).homedir = original;
+  };
+};
+
+async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'codex-provider-db-'));
+  const databasePath = path.join(tempDirectory, 'auth.db');
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  await initializeDatabase();
+
+  try {
+    await runTest();
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Writes one Codex rollout transcript. `firstUserMessage` mirrors the
+ * `event_msg`/`user_message` payload the runtime records for the prompt the
+ * user typed; omitting it produces a transcript with no user turn.
+ */
+const writeCodexTranscript = async (
+  homeDir: string,
+  codexSessionId: string,
+  workspacePath: string,
+  firstUserMessage?: string,
+): Promise<string> => {
+  const sessionsDir = path.join(homeDir, '.codex', 'sessions', '2026', '07', '07');
+  await mkdir(sessionsDir, { recursive: true });
+
+  const lines: string[] = [
+    JSON.stringify({ type: 'session_meta', payload: { id: codexSessionId, cwd: workspacePath } }),
+  ];
+  if (firstUserMessage !== undefined) {
+    lines.push(JSON.stringify({ type: 'event_msg', payload: { type: 'user_message', message: firstUserMessage } }));
+  }
+
+  const filePath = path.join(sessionsDir, `rollout-${codexSessionId}.jsonl`);
+  await writeFile(filePath, `${lines.join('\n')}\n`, 'utf8');
+  return filePath;
+};
+
+test('Codex synchronizer titles app-created sessions from the first user message', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-session-sync-app-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    await writeCodexTranscript(tempRoot, 'codex-app-1', workspacePath, 'Fix the login redirect bug');
+    await withIsolatedDatabase(async () => {
+      // The app allocates its own id and later maps the provider id onto it,
+      // exactly as a message sent from cloudcli does.
+      sessionsDb.createAppSession('app-1', 'codex', workspacePath);
+      sessionsDb.assignProviderSessionId('app-1', 'codex-app-1');
+
+      const synchronizer = new CodexSessionSynchronizer();
+      await synchronizer.synchronize();
+
+      assert.equal(sessionsDb.getSessionById('app-1')?.custom_name, 'Fix the login redirect bug');
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('Codex synchronizer leaves indexed sessions untitled when no name is available', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-session-sync-indexed-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    // A CLI-created session has no app row; its first user message must NOT be
+    // used as the title, preserving the existing indexing behavior.
+    await writeCodexTranscript(tempRoot, 'codex-indexed-1', workspacePath, 'This prompt should be ignored');
+    await withIsolatedDatabase(async () => {
+      const synchronizer = new CodexSessionSynchronizer();
+      await synchronizer.synchronize();
+
+      assert.equal(sessionsDb.getSessionById('codex-indexed-1')?.custom_name, 'Untitled Codex Session');
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});

package/server/modules/providers/tests/mcp.test.ts

@@ -257,34 +257,15 @@ test('providerMcpService handles opencode MCP config and capability validation',
 });
 
 /**
- * This test covers Gemini/Cursor MCP JSON formats and user/project scope persistence.
+ * This test covers Cursor MCP JSON format and user/project scope persistence.
  */
-test('providerMcpService handles gemini and cursor MCP JSON config formats', { concurrency: false }, async () => {
+test('providerMcpService handles cursor MCP JSON config formats', { concurrency: false }, async () => {
   const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'llm-mcp-gc-'));
   const workspacePath = path.join(tempRoot, 'workspace');
   await fs.mkdir(workspacePath, { recursive: true });
 
   const restoreHomeDir = patchHomeDir(tempRoot);
   try {
-    await providerMcpService.upsertProviderMcpServer('gemini', {
-      name: 'gemini-stdio',
-      scope: 'user',
-      transport: 'stdio',
-      command: 'node',
-      args: ['server.js'],
-      env: { TOKEN: '$TOKEN' },
-      cwd: './server',
-    });
-
-    await providerMcpService.upsertProviderMcpServer('gemini', {
-      name: 'gemini-http',
-      scope: 'project',
-      transport: 'http',
-      url: 'https://gemini.example.com/mcp',
-      headers: { Authorization: 'Bearer token' },
-      workspacePath,
-    });
-
     await providerMcpService.upsertProviderMcpServer('cursor', {
       name: 'cursor-stdio',
       scope: 'project',
@@ -303,15 +284,6 @@ test('providerMcpService handles gemini and cursor MCP JSON config formats', { c
       headers: { API_KEY: 'value' },
     });
 
-    const geminiUserConfig = await readJson(path.join(tempRoot, '.gemini', 'settings.json'));
-    const geminiUserServer = (geminiUserConfig.mcpServers as Record<string, unknown>)['gemini-stdio'] as Record<string, unknown>;
-    assert.equal(geminiUserServer.command, 'node');
-    assert.equal(geminiUserServer.type, undefined);
-
-    const geminiProjectConfig = await readJson(path.join(workspacePath, '.gemini', 'settings.json'));
-    const geminiProjectServer = (geminiProjectConfig.mcpServers as Record<string, unknown>)['gemini-http'] as Record<string, unknown>;
-    assert.equal(geminiProjectServer.type, 'http');
-
     const cursorUserConfig = await readJson(path.join(tempRoot, '.cursor', 'mcp.json'));
     const cursorHttpServer = (cursorUserConfig.mcpServers as Record<string, unknown>)['cursor-http'] as Record<string, unknown>;
     assert.equal(cursorHttpServer.url, 'http://localhost:3333/mcp');
@@ -341,7 +313,7 @@ test('providerMcpService global adder writes to all providers and rejects unsupp
       workspacePath,
     });
 
-    assert.equal(globalResult.length, 5);
+    assert.equal(globalResult.length, 4);
     assert.ok(globalResult.every((entry) => entry.created === true));
 
     const claudeProject = await readJson(path.join(workspacePath, '.mcp.json'));
@@ -350,9 +322,6 @@ test('providerMcpService global adder writes to all providers and rejects unsupp
     const codexProject = TOML.parse(await fs.readFile(path.join(workspacePath, '.codex', 'config.toml'), 'utf8')) as Record<string, unknown>;
     assert.ok((codexProject.mcp_servers as Record<string, unknown>)['global-http']);
 
-    const geminiProject = await readJson(path.join(workspacePath, '.gemini', 'settings.json'));
-    assert.ok((geminiProject.mcpServers as Record<string, unknown>)['global-http']);
-
     const opencodeProject = await readJson(path.join(workspacePath, 'opencode.json'));
     assert.ok((opencodeProject.mcp as Record<string, unknown>)['global-http']);
 

package/server/modules/providers/tests/opencode-models.test.ts

@@ -30,6 +30,7 @@ test('OpenCode models provider formats frontend labels from provider-prefixed id
     'opencode/nemotron-3-super-free',
     'anthropic/claude-3-5-sonnet-20241022',
     'anthropic/claude-opus-4-7-fast',
+    'google/model-alpha',
     'openai/gpt-5.4-mini-fast',
     'openai/gpt-5.5-pro',
     'newprovider/alpha-v12-special-20261231',
@@ -104,6 +105,12 @@ anthropic/claude-sonnet-5
     }
   }
 }
+google/model-alpha
+{
+  "id": "model-alpha",
+  "providerID": "google",
+  "name": "Model Alpha"
+}
 `);
 
   const definition = buildOpenCodeDefinitionFromVerboseModels(models);