@cloudcli-ai/cloudcli 1.35.1 → 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,29 +49,28 @@ 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;
 const NUMERIC_TOKEN = /^\d+(?:\.\d+)*$/;
 const SHORT_ACRONYM_TOKEN = /^[a-z]{2,3}$/;
 
+type OpenCodeVerboseModel = {
+  id?: string;
+  name?: string;
+  providerID?: string;
+  variants?: Record<string, unknown>;
+};
+
 export const parseOpenCodeModelsStdout = (stdout: string): string[] => {
   const ids: string[] = [];
 
@@ -91,6 +88,83 @@ export const parseOpenCodeModelsStdout = (stdout: string): string[] => {
   return [...new Set(ids)];
 };
 
+const countJsonBraceDelta = (value: string): number => {
+  let delta = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (const character of value) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+
+    if (character === '\\') {
+      escaped = inString;
+      continue;
+    }
+
+    if (character === '"') {
+      inString = !inString;
+      continue;
+    }
+
+    if (inString) {
+      continue;
+    }
+
+    if (character === '{') {
+      delta += 1;
+    } else if (character === '}') {
+      delta -= 1;
+    }
+  }
+
+  return delta;
+};
+
+const isOpenCodeVerboseModel = (value: unknown): value is OpenCodeVerboseModel => {
+  const record = readObjectRecord(value);
+  return Boolean(record && readOptionalString(record.id));
+};
+
+export const parseOpenCodeVerboseModelsStdout = (stdout: string): OpenCodeVerboseModel[] => {
+  const models: OpenCodeVerboseModel[] = [];
+  let buffer: string[] = [];
+  let depth = 0;
+
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (buffer.length === 0) {
+      if (line === '{') {
+        buffer = [rawLine];
+        depth = 1;
+      }
+      continue;
+    }
+
+    buffer.push(rawLine);
+    depth += countJsonBraceDelta(rawLine);
+
+    if (depth !== 0) {
+      continue;
+    }
+
+    try {
+      const parsed = JSON.parse(buffer.join('\n'));
+      if (isOpenCodeVerboseModel(parsed)) {
+        models.push(parsed);
+      }
+    } catch {
+      // Ignore malformed verbose blocks and fall back to the plain id parser.
+    }
+
+    buffer = [];
+  }
+
+  return models;
+};
+
 const formatDateToken = (token: string): string => (
   `${token.slice(0, 4)}-${token.slice(4, 6)}-${token.slice(6, 8)}`
 );
@@ -155,6 +229,24 @@ 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) {
+    return null;
+  }
+
+  if (id.includes('/')) {
+    return id;
+  }
+
+  const upstreamProvider = readOptionalString(model.providerID);
+  return upstreamProvider ? `${upstreamProvider}/${id}` : id;
+};
+
 const labelForOpenCodeModelId = (id: string): string => {
   const fallbackLabel = OPENCODE_FALLBACK_MODELS.OPTIONS.find((option) => option.value === id)?.label;
   if (fallbackLabel) {
@@ -170,12 +262,90 @@ const descriptionForOpenCodeModelId = (id: string): string => {
   return upstreamProvider ? `${upstreamProvider} - ${id}` : id;
 };
 
-export const buildOpenCodeDefinitionFromIds = (ids: string[]): ProviderModelsDefinition => {
-  const options: ProviderModelOption[] = ids.map((value) => ({
+const readOpenCodeVariantEffort = (key: string, value: unknown): string | null => {
+  const variant = readObjectRecord(value);
+  return readOptionalString(variant?.reasoningEffort)
+    ?? readOptionalString(variant?.effort)
+    ?? key;
+};
+
+const readOpenCodeEffortValues = (
+  variants: OpenCodeVerboseModel['variants'],
+): NonNullable<ProviderModelOption['effort']>['values'] => {
+  const effortValues: NonNullable<ProviderModelOption['effort']>['values'] = [];
+  const seenValues = new Set<string>();
+
+  for (const [key, value] of Object.entries(variants ?? {})) {
+    const effort = readOpenCodeVariantEffort(key, value);
+    if (!effort || seenValues.has(effort)) {
+      continue;
+    }
+
+    seenValues.add(effort);
+    effortValues.push({ value: effort });
+  }
+
+  return effortValues;
+};
+
+const mapOpenCodeVerboseModel = (model: OpenCodeVerboseModel): ProviderModelOption | null => {
+  const value = readOpenCodeVerboseModelId(model);
+  if (!value || !isSupportedOpenCodeModelId(value)) {
+    return null;
+  }
+
+  const effortValues = readOpenCodeEffortValues(model.variants);
+
+  return {
     value,
-    label: labelForOpenCodeModelId(value),
+    label: readOptionalString(model.name) ?? labelForOpenCodeModelId(value),
     description: descriptionForOpenCodeModelId(value),
-  }));
+    effort: effortValues.length > 0
+      ? {
+          values: effortValues,
+        }
+      : undefined,
+  };
+};
+
+export const buildOpenCodeDefinitionFromIds = (ids: string[]): ProviderModelsDefinition => {
+  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
+    ?? OPENCODE_FALLBACK_MODELS.DEFAULT;
+
+  return {
+    OPTIONS: options,
+    DEFAULT: defaultValue,
+  };
+};
+
+export const buildOpenCodeDefinitionFromVerboseModels = (
+  models: OpenCodeVerboseModel[],
+): ProviderModelsDefinition => {
+  const options: ProviderModelOption[] = [];
+  const seenValues = new Set<string>();
+
+  for (const model of models) {
+    const mappedModel = mapOpenCodeVerboseModel(model);
+    if (!mappedModel || seenValues.has(mappedModel.value)) {
+      continue;
+    }
+
+    seenValues.add(mappedModel.value);
+    options.push(mappedModel);
+  }
+
+  if (options.length === 0) {
+    return OPENCODE_FALLBACK_MODELS;
+  }
 
   const defaultValue = options.find((option) => option.value === OPENCODE_FALLBACK_MODELS.DEFAULT)?.value
     ?? options[0]?.value
@@ -214,7 +384,7 @@ const parseOpenCodeSessionModelValue = (rawModel: unknown): string | null => {
 };
 
 const runOpenCodeModelsCommand = (): Promise<string> => new Promise((resolve, reject) => {
-  const openCodeProcess = spawnFunction('opencode', ['models'], {
+  const openCodeProcess = spawnFunction('opencode', ['models', '--verbose'], {
     cwd: process.cwd(),
     env: { ...process.env },
   });
@@ -273,6 +443,11 @@ export class OpenCodeProviderModels implements IProviderModels {
   async getSupportedModels(): Promise<ProviderModelsDefinition> {
     try {
       const stdout = await runOpenCodeModelsCommand();
+      const verboseModels = parseOpenCodeVerboseModelsStdout(stdout);
+      if (verboseModels.length > 0) {
+        return buildOpenCodeDefinitionFromVerboseModels(verboseModels);
+      }
+
       const ids = parseOpenCodeModelsStdout(stdout);
       if (ids.length === 0) {
         return OPENCODE_FALLBACK_MODELS;

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

@@ -21,6 +21,8 @@ type ProviderCapabilities = {
   supportsPermissionRequests: boolean;
   /** Whether the token-usage endpoint has data for this provider. */
   supportsTokenUsage: boolean;
+  /** Whether the provider runtime can accept model-level reasoning effort. */
+  supportsEffort: boolean;
 };
 
 /**
@@ -38,42 +40,40 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     supportsAbort: true,
     supportsPermissionRequests: true,
     supportsTokenUsage: true,
+    supportsEffort: true,
   },
   cursor: {
     provider: 'cursor',
     permissionModes: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
     defaultPermissionMode: 'default',
-    supportsImages: false,
+    supportsImages: true,
     supportsAbort: true,
     supportsPermissionRequests: false,
     supportsTokenUsage: false,
+    supportsEffort: false,
   },
   codex: {
     provider: 'codex',
     permissionModes: ['default', 'acceptEdits', 'bypassPermissions'],
     defaultPermissionMode: 'default',
-    supportsImages: false,
-    supportsAbort: true,
-    supportsPermissionRequests: false,
-    supportsTokenUsage: true,
-  },
-  gemini: {
-    provider: 'gemini',
-    permissionModes: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
-    defaultPermissionMode: 'default',
-    supportsImages: false,
+    supportsImages: true,
     supportsAbort: true,
     supportsPermissionRequests: false,
     supportsTokenUsage: true,
+    supportsEffort: true,
   },
   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,
+    supportsEffort: true,
   },
 };
 

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

@@ -16,8 +16,8 @@ import type {
 import { readProviderSessionActiveModelChange } from '@/shared/utils.js';
 
 export const PROVIDER_MODELS_CACHE_TTL_MS = 3 * 24 * 60 * 60 * 1000;
-const PROVIDER_MODELS_CACHE_VERSION = 1;
-const UNCACHED_PROVIDERS = new Set<LLMProvider>(['claude', 'gemini']);
+const PROVIDER_MODELS_CACHE_VERSION = 2;
+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');
 }