@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

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

@@ -1,25 +1,75 @@
 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 Database from 'better-sqlite3';
+
+import { closeConnection, initializeDatabase } from '@/modules/database/index.js';
 import {
   OpenCodeProviderModels,
   OPENCODE_PREDEFINED_MODELS,
 } from '@/modules/providers/list/opencode/opencode-models.provider.js';
 
-test('OpenCode exposes only the curated predefined catalog', async () => {
-  const adapter = new OpenCodeProviderModels();
+const OPENCODE_ENV_KEYS = ['OPENCODE_API_KEY', 'ANTHROPIC_API_KEY', 'OPENAI_API_KEY'];
 
-  assert.deepEqual(await adapter.getSupportedModels(), OPENCODE_PREDEFINED_MODELS);
-  assert.equal(
-    (await adapter.getCurrentActiveModel()).model,
-    OPENCODE_PREDEFINED_MODELS.DEFAULT,
-  );
+/**
+ * Runs one case against a throwaway OpenCode home, so the catalog the adapter
+ * reports depends on the fixture rather than on the providers the machine
+ * running the suite happens to be logged into.
+ */
+const withOpenCodeHome = async (
+  setUp: (homeDir: string) => Promise<void>,
+  runTest: (adapter: OpenCodeProviderModels) => Promise<void>,
+): Promise<void> => {
+  const homeDir = await mkdtemp(path.join(os.tmpdir(), 'opencode-catalog-'));
+  const originalHomedir = os.homedir;
+  const originalEnv = OPENCODE_ENV_KEYS.map((key) => [key, process.env[key]] as const);
+
+  (os as any).homedir = () => homeDir;
+  for (const key of OPENCODE_ENV_KEYS) {
+    delete process.env[key];
+  }
+
+  try {
+    await setUp(homeDir);
+    await runTest(new OpenCodeProviderModels());
+  } finally {
+    (os as any).homedir = originalHomedir;
+    for (const [key, value] of originalEnv) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+    await rm(homeDir, { recursive: true, force: true });
+  }
+};
+
+const writeOpenCodeAuth = async (homeDir: string, auth: Record<string, unknown>): Promise<void> => {
+  const authDir = path.join(homeDir, '.local', 'share', 'opencode');
+  await mkdir(authDir, { recursive: true });
+  await writeFile(path.join(authDir, 'auth.json'), JSON.stringify(auth), 'utf8');
+};
+
+test('OpenCode exposes only the curated predefined catalog', async () => {
+  await withOpenCodeHome(async () => {}, async (adapter) => {
+    // Nothing readable about this install, so the picker keeps every option
+    // rather than coming up empty.
+    assert.deepEqual(await adapter.getSupportedModels(), OPENCODE_PREDEFINED_MODELS);
+    assert.equal(
+      (await adapter.getCurrentActiveModel()).model,
+      OPENCODE_PREDEFINED_MODELS.DEFAULT,
+    );
+  });
   // OpenCode routes by `<providerID>/<modelID>`, so every option has to carry a
   // provider prefix that `opencode models --verbose` reports.
   const providerIds = new Set(
     OPENCODE_PREDEFINED_MODELS.OPTIONS.map((option) => option.value.split('/')[0]),
   );
-  assert.deepEqual([...providerIds].sort(), ['anthropic', 'opencode', 'openai'].sort());
+  assert.deepEqual([...providerIds].sort(), ['anthropic', 'opencode', 'opencode-go', 'openai'].sort());
   assert.equal(
     OPENCODE_PREDEFINED_MODELS.OPTIONS.every((option) => /^[a-z0-9-]+\/.+/.test(option.value)),
     true,
@@ -38,4 +88,212 @@ test('OpenCode exposes only the curated predefined catalog', async () => {
   assert.ok(
     OPENCODE_PREDEFINED_MODELS.OPTIONS.some((option) => option.value === 'openai/gpt-5.6'),
   );
+  // The Go gateway carries its own provider id, so its models must be curated
+  // too - a Go subscriber otherwise authenticates while the picker offers
+  // nothing they can run.
+  const opencodeGoOptions = OPENCODE_PREDEFINED_MODELS.OPTIONS.filter(
+    (option) => option.value.startsWith('opencode-go/'),
+  );
+  assert.equal(opencodeGoOptions.length, 27);
+  assert.ok(opencodeGoOptions.every((option) => option.description === 'OpenCode Go'));
+  const glmFlash = opencodeGoOptions.find(
+    (option) => option.value === 'opencode-go/glm-5.3-flash',
+  );
+  assert.ok(glmFlash);
+  // Effort choices come from `opencode models --verbose` variants; the runtime
+  // turns a selected value into `--variant`, so the values have to match the
+  // CLI's exactly.
+  assert.deepEqual(
+    glmFlash?.effort?.values.map((value) => value.value),
+    ['low', 'high', 'max'],
+  );
+  assert.ok(
+    opencodeGoOptions
+      .filter((option) => !option.effort)
+      .every((option) =>
+        ['glm-5.1', 'kimi-k2.6', 'kimi-k2.7-code', 'mimo-v2.5', 'mimo-v2.5-pro',
+          'minimax-m2.7', 'qwen3.6-plus', 'qwen3.7-max', 'qwen3.7-plus']
+          .includes(option.value.slice('opencode-go/'.length)),
+      ),
+  );
+});
+
+test('OpenCode offers only models the install can route to', async () => {
+  // Asking for a provider the user never connected fails the whole run with
+  // "Model <id> is not valid", so an OpenCode Zen model must not be offered -
+  // or defaulted to - on a machine that only holds an Anthropic key.
+  await withOpenCodeHome(
+    (homeDir) => writeOpenCodeAuth(homeDir, { anthropic: { type: 'api', key: 'test' } }),
+    async (adapter) => {
+      const catalog = await adapter.getSupportedModels();
+      const providerIds = new Set(catalog.OPTIONS.map((option) => option.value.split('/')[0]));
+
+      assert.deepEqual([...providerIds], ['anthropic']);
+      assert.ok(catalog.OPTIONS.length > 0);
+      assert.equal(catalog.DEFAULT.startsWith('anthropic/'), true);
+      assert.ok(catalog.OPTIONS.some((option) => option.value === catalog.DEFAULT));
+      assert.equal((await adapter.getCurrentActiveModel()).model, catalog.DEFAULT);
+    },
+  );
+
+  // A Go subscriber's auth store holds only `opencode-go`, so the whole catalog
+  // has to resolve to Go models and the default has to move onto one of them
+  // instead of the unreachable Zen default.
+  await withOpenCodeHome(
+    (homeDir) => writeOpenCodeAuth(homeDir, { 'opencode-go': { type: 'api', key: 'test' } }),
+    async (adapter) => {
+      const catalog = await adapter.getSupportedModels();
+      const providerIds = new Set(catalog.OPTIONS.map((option) => option.value.split('/')[0]));
+
+      assert.deepEqual([...providerIds], ['opencode-go']);
+      assert.equal(catalog.OPTIONS.length, 27);
+      assert.equal(catalog.DEFAULT, 'opencode-go/grok-4.6');
+      assert.ok(catalog.OPTIONS.some((option) => option.value === catalog.DEFAULT));
+      assert.equal((await adapter.getCurrentActiveModel()).model, catalog.DEFAULT);
+    },
+  );
+
+  // The catalog default survives whenever its own provider is connected.
+  await withOpenCodeHome(
+    (homeDir) => writeOpenCodeAuth(homeDir, {
+      opencode: { type: 'api', key: 'test' },
+      openai: { type: 'oauth' },
+    }),
+    async (adapter) => {
+      const catalog = await adapter.getSupportedModels();
+      const providerIds = new Set(catalog.OPTIONS.map((option) => option.value.split('/')[0]));
+
+      assert.deepEqual([...providerIds].sort(), ['opencode', 'openai'].sort());
+      assert.equal(catalog.DEFAULT, OPENCODE_PREDEFINED_MODELS.DEFAULT);
+    },
+  );
+
+  // Providers configured rather than logged into count too.
+  await withOpenCodeHome(
+    async (homeDir) => {
+      const configDir = path.join(homeDir, '.config', 'opencode');
+      await mkdir(configDir, { recursive: true });
+      await writeFile(
+        path.join(configDir, 'opencode.json'),
+        JSON.stringify({ provider: { anthropic: { options: {} } } }),
+        'utf8',
+      );
+    },
+    async (adapter) => {
+      const catalog = await adapter.getSupportedModels();
+      const providerIds = new Set(catalog.OPTIONS.map((option) => option.value.split('/')[0]));
+
+      assert.deepEqual([...providerIds], ['anthropic']);
+    },
+  );
+
+  // An API key in the environment is enough on its own.
+  await withOpenCodeHome(
+    async () => {
+      process.env.OPENAI_API_KEY = 'test';
+    },
+    async (adapter) => {
+      const catalog = await adapter.getSupportedModels();
+      const providerIds = new Set(catalog.OPTIONS.map((option) => option.value.split('/')[0]));
+
+      assert.deepEqual([...providerIds], ['openai']);
+    },
+  );
+});
+
+const writeOpenCodeSessionDatabase = async (homeDir: string, rows: Array<Record<string, unknown>>) => {
+  const dbPath = path.join(homeDir, '.local', 'share', 'opencode', 'opencode.db');
+  await mkdir(path.dirname(dbPath), { recursive: true });
+  const db = new Database(dbPath);
+  try {
+    db.exec(`
+      CREATE TABLE session (
+        id text PRIMARY KEY,
+        model text,
+        agent text,
+        directory text,
+        time_created integer NOT NULL,
+        time_updated integer NOT NULL
+      );
+    `);
+    const insert = db.prepare(
+      'INSERT INTO session (id, model, agent, directory, time_created, time_updated) VALUES (?, ?, ?, ?, ?, ?)',
+    );
+    for (const [index, row] of rows.entries()) {
+      insert.run(
+        row.id,
+        row.model,
+        row.agent ?? null,
+        row.directory ?? '/tmp/project',
+        row.timeCreated ?? 1700000000000,
+        row.timeUpdated ?? 1700000001000 + index,
+      );
+    }
+  } finally {
+    db.close();
+  }
+};
+
+test('OpenCode composes the provider prefix into session model ids', async () => {
+  // The lookup translates the app session id through the sessions database,
+  // so point it at a throwaway file rather than the developer's real one.
+  const tempSessionsDirectory = await mkdtemp(path.join(os.tmpdir(), 'opencode-session-model-'));
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  try {
+    closeConnection();
+    process.env.DATABASE_PATH = path.join(tempSessionsDirectory, 'auth.db');
+    await initializeDatabase();
+    // OpenCode stores the provider and model id in separate fields of the
+    // session row ({"id":"z-ai/glm-5.3-flash","providerID":"openrouter"}), but
+    // the CLI's `--model` flag only resolves the composed
+    // `<providerID>/<modelID>` form. Resuming such a session without the prefix
+    // fails with an unknown-model server error, which hits OpenRouter users
+    // hardest because their model ids carry a slash themselves.
+    await withOpenCodeHome(
+      (homeDir) => writeOpenCodeSessionDatabase(homeDir, [
+        {
+          id: 'ses_openrouter',
+          model: JSON.stringify({
+            id: 'z-ai/glm-5.3-flash',
+            providerID: 'openrouter',
+            variant: 'default',
+          }),
+        },
+        {
+          id: 'ses_qualified',
+          // An id that already carries the provider prefix must survive as-is.
+          model: JSON.stringify({
+            id: 'openrouter/z-ai/glm-5.3-flash',
+            providerID: 'openrouter',
+          }),
+        },
+        {
+          id: 'ses_plain_string',
+          model: 'opencode/gpt-5.6-terra',
+        },
+      ]),
+      async (adapter) => {
+        assert.equal(
+          (await adapter.getCurrentActiveModel('ses_openrouter')).model,
+          'openrouter/z-ai/glm-5.3-flash',
+        );
+        assert.equal(
+          (await adapter.getCurrentActiveModel('ses_qualified')).model,
+          'openrouter/z-ai/glm-5.3-flash',
+        );
+        assert.equal(
+          (await adapter.getCurrentActiveModel('ses_plain_string')).model,
+          'opencode/gpt-5.6-terra',
+        );
+      },
+    );
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempSessionsDirectory, { recursive: true, force: true });
+  }
 });

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

@@ -151,6 +151,30 @@ const createOpenCodeDatabase = async (homeDir: string, workspacePath: string): P
       3,
       2,
     );
+    db.prepare(`
+      INSERT INTO session (
+        id, project_id, parent_id, slug, directory, title, version, time_created, time_updated,
+        time_archived, tokens_input, tokens_output, tokens_reasoning, tokens_cache_read,
+        tokens_cache_write
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      'open-child-session-1',
+      'project-1',
+      'open-session-1',
+      'open-child-session-1',
+      workspacePath,
+      'OpenCode child session',
+      '0.0.0',
+      1_700_000_002_000,
+      1_700_000_005_000,
+      null,
+      5,
+      10,
+      2,
+      1,
+      1,
+    );
 
     const userMessageData = JSON.stringify({
       role: 'user',
@@ -255,16 +279,29 @@ test('OpenCode session synchronizer indexes sqlite sessions without deletable tr
   try {
     await createOpenCodeDatabase(tempRoot, workspacePath);
     await withIsolatedDatabase(() => {
+      sessionsDb.createAppSession('app-child-session-1', 'opencode', workspacePath);
+      sessionsDb.assignProviderSessionId('app-child-session-1', 'open-child-session-1');
+
       const synchronizer = new OpenCodeSessionSynchronizer();
       const processed = synchronizer.synchronize();
 
-      return Promise.resolve(processed).then((count) => {
+      return Promise.resolve(processed).then(async (count) => {
         assert.equal(count, 1);
         const indexed = sessionsDb.getSessionById('open-session-1');
         assert.equal(indexed?.provider, 'opencode');
         assert.equal(indexed?.project_path, workspacePath);
         assert.equal(indexed?.custom_name, 'OpenCode indexed title');
         assert.equal(indexed?.jsonl_path, null);
+        assert.equal(sessionsDb.getSessionById('app-child-session-1'), null);
+        assert.equal(sessionsDb.getSessionByProviderSessionId('open-child-session-1'), null);
+
+        sessionsDb.createAppSession('app-child-session-2', 'opencode', workspacePath);
+        sessionsDb.assignProviderSessionId('app-child-session-2', 'open-child-session-1');
+        await synchronizer.synchronize(new Date(1_700_000_004_500));
+        assert.equal(
+          sessionsDb.getSessionById('app-child-session-2')?.provider_session_id,
+          'open-child-session-1',
+        );
       });
     });
   } finally {
@@ -290,6 +327,7 @@ test('OpenCode session synchronizer returns the app session id once provider map
         assert.equal(sessionId, 'app-session-1');
         assert.equal(sessionsDb.getAllSessions().length, 1);
         assert.equal(sessionsDb.getSessionById('app-session-1')?.provider_session_id, 'open-session-1');
+        assert.equal(sessionsDb.getSessionById('open-child-session-1'), null);
       });
     });
   } finally {
@@ -438,6 +476,7 @@ const seedOpenCodeSession = async (
       CREATE TABLE session (
         id TEXT PRIMARY KEY,
         project_id TEXT,
+        parent_id TEXT,
         directory TEXT,
         title TEXT,
         time_created INTEGER,

package/server/modules/providers/tests/provider-capabilities.service.test.ts

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { CLAUDE_PREDEFINED_MODELS } from '@/modules/providers/list/claude/claude-models.provider.js';
+import { CODEX_PREDEFINED_MODELS } from '@/modules/providers/list/codex/codex-models.provider.js';
+import { CURSOR_PREDEFINED_MODELS } from '@/modules/providers/list/cursor/cursor-models.provider.js';
+import { OPENCODE_PREDEFINED_MODELS } from '@/modules/providers/list/opencode/opencode-models.provider.js';
+import { providerCapabilitiesService } from '@/modules/providers/services/provider-capabilities.service.js';
+import type { LLMProvider, ProviderModelsDefinition } from '@/shared/types.js';
+
+/**
+ * The full curated catalogs, before OpenCode narrows its list to the upstream
+ * providers a machine has connected.
+ */
+const CURATED_CATALOGS: Record<LLMProvider, ProviderModelsDefinition> = {
+  claude: CLAUDE_PREDEFINED_MODELS,
+  codex: CODEX_PREDEFINED_MODELS,
+  cursor: CURSOR_PREDEFINED_MODELS,
+  opencode: OPENCODE_PREDEFINED_MODELS,
+};
+
+test('capability effort levels cover every level a curated model declares', () => {
+  // Custom models may declare only these levels, so a level added to a curated
+  // model has to be added here too, or users could not give it to their own.
+  for (const [provider, catalog] of Object.entries(CURATED_CATALOGS) as Array<[LLMProvider, ProviderModelsDefinition]>) {
+    const { effortLevels, supportsEffort } = providerCapabilitiesService.getProviderCapabilities(provider);
+
+    assert.equal(supportsEffort, effortLevels.length > 0, `${provider}: supportsEffort disagrees with effortLevels`);
+    assert.equal(new Set(effortLevels).size, effortLevels.length, `${provider}: effortLevels lists a level twice`);
+
+    const declaredLevels = new Set(
+      catalog.OPTIONS.flatMap((option) => option.effort?.values.map((level) => level.value) ?? []),
+    );
+    const missingLevels = [...declaredLevels].filter((level) => !effortLevels.includes(level));
+    assert.deepEqual(missingLevels, [], `${provider}: effortLevels misses curated levels`);
+  }
+});

package/server/modules/providers/tests/provider-models.service.test.ts

@@ -69,6 +69,7 @@ const createCatalogStore = () => {
         modelId: input.id,
         model: input.model,
         sortOrder: readRows(provider).length,
+        effort: input.effort ?? null,
       };
       rows.set(provider, [...readRows(provider), record]);
       return record;
@@ -82,7 +83,13 @@ const createCatalogStore = () => {
       if (!existing) {
         return null;
       }
-      const updated = { ...existing, modelId: input.id, model: input.model };
+      const updated = {
+        ...existing,
+        modelId: input.id,
+        model: input.model,
+        // Mirrors the repository: an omitted effort keeps the stored levels.
+        effort: input.effort === undefined ? existing.effort : input.effort,
+      };
       rows.set(provider, readRows(provider).map((record) => (
         record.recordId === recordId ? updated : record
       )));
@@ -165,6 +172,97 @@ test('custom models can be created, edited, and deleted', async () => {
   assert.equal(removed.models.OPTIONS.some((option) => option.recordId === recordId), false);
 });
 
+test('custom models carry declared effort levels into the merged catalog', async () => {
+  const { service } = createTestService();
+
+  const created = await service.createCustomModel('claude', {
+    model: 'My Custom Model',
+    id: 'my-custom-model',
+    effort: { values: ['low', 'max'], default: 'max' },
+  });
+  const expectedEffort = { default: 'max', values: [{ value: 'low' }, { value: 'max' }] };
+  assert.deepEqual(created.model.effort, expectedEffort);
+
+  const catalog = await service.getProviderModels('claude');
+  const merged = catalog.OPTIONS.find((option) => option.value === 'my-custom-model');
+  assert.deepEqual(merged?.effort, expectedEffort);
+
+  // A rename that does not mention effort (an older client) keeps the levels.
+  const renamed = await service.updateCustomModel('claude', created.model.recordId as number, {
+    model: 'Renamed',
+    id: 'my-custom-model',
+  });
+  assert.deepEqual(renamed.model.effort, expectedEffort);
+
+  const cleared = await service.updateCustomModel('claude', created.model.recordId as number, {
+    model: 'Renamed',
+    id: 'my-custom-model',
+    effort: null,
+  });
+  assert.equal('effort' in cleared.model, false);
+});
+
+test('custom models without declared effort levels expose no effort', async () => {
+  const { service } = createTestService();
+
+  const created = await service.createCustomModel('codex', { model: 'Plain', id: 'plain-model' });
+
+  assert.equal('effort' in created.model, false);
+});
+
+test('custom effort levels must be levels the provider supports', async () => {
+  const { service } = createTestService();
+
+  await assert.rejects(
+    () => service.createCustomModel('codex', {
+      model: 'Unknown level',
+      id: 'unknown-level',
+      effort: { values: ['low', 'turbo'] },
+    }),
+    (error) => error instanceof AppError
+      && error.code === 'INVALID_MODEL_EFFORT'
+      && error.statusCode === 400,
+  );
+
+  await assert.rejects(
+    () => service.createCustomModel('cursor', {
+      model: 'Cursor effort',
+      id: 'cursor-effort',
+      effort: { values: ['low'] },
+    }),
+    (error) => error instanceof AppError
+      && error.code === 'MODEL_EFFORT_NOT_SUPPORTED'
+      && error.statusCode === 400,
+  );
+});
+
+test('allowed effort levels come from the provider, not from the built-in models this machine sees', async () => {
+  // The fake adapters' built-in models declare no effort at all, which is what
+  // the real OpenCode adapter returns once it narrows its catalog to OpenCode
+  // Zen, Anthropic, or OpenAI: only its OpenCode Go models declare effort.
+  const { service } = createTestService();
+
+  const created = await service.createCustomModel('opencode', {
+    model: 'Router model',
+    id: 'openrouter/router-model',
+    effort: { values: ['none', 'high'] },
+  });
+  assert.deepEqual(created.model.effort, { values: [{ value: 'none' }, { value: 'high' }] });
+
+  // Every merged catalog carries the provider's levels for the model library,
+  // weakest first, and an empty list where effort is unsupported.
+  const expectedLevels: Record<LLMProvider, string[]> = {
+    claude: ['low', 'medium', 'high', 'xhigh', 'max', 'ultracode'],
+    codex: ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
+    cursor: [],
+    opencode: ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'thinking'],
+  };
+  for (const [provider, levels] of Object.entries(expectedLevels) as Array<[LLMProvider, string[]]>) {
+    assert.deepEqual((await service.getProviderModels(provider)).EFFORT_LEVELS, levels, provider);
+  }
+  assert.deepEqual(created.models.EFFORT_LEVELS, expectedLevels.opencode);
+});
+
 test('duplicate model ids are rejected within one provider', async () => {
   const { service } = createTestService();
   await service.createCustomModel('cursor', { model: 'First', id: 'custom-id' });