@cloudcli-ai/cloudcli 1.37.1 → 1.37.3

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

@@ -6,7 +6,7 @@ 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';
-import { CodexSessionsProvider } from '@/modules/providers/list/codex/codex-sessions.provider.js';
+import { CodexSessionsProvider, parseCodexExecScript, readCodexMemoryCitations } from '@/modules/providers/list/codex/codex-sessions.provider.js';
 
 const patchHomeDir = (nextHomeDir: string) => {
   const original = os.homedir;
@@ -152,7 +152,7 @@ test('Codex synchronizer leaves indexed sessions untitled when no name is availa
   }
 });
 
-test('Codex history preserves wrapped exec tool calls and results', { concurrency: false }, async () => {
+test('Codex history translates wrapped exec scripts into the tools they ran', { concurrency: false }, async () => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-exec-history-'));
   const workspacePath = path.join(tempRoot, 'workspace');
   await mkdir(workspacePath, { recursive: true });
@@ -161,6 +161,8 @@ test('Codex history preserves wrapped exec tool calls and results', { concurrenc
   try {
     const providerSessionId = 'codex-exec-1';
     const transcriptPath = await writeCodexTranscript(tempRoot, providerSessionId, workspacePath);
+    // Every shape Codex's "code mode" emits. Only a wrapper nothing recognizes
+    // may stay labelled `exec`; the rest must name the work they performed.
     const wrappedCalls = [
       {
         callId: 'shell-command-1',
@@ -176,14 +178,22 @@ test('Codex history preserves wrapped exec tool calls and results', { concurrenc
       },
       {
         callId: 'exec-command-1',
-        input: 'await tools.exec_command({"command":"echo current"});',
+        input: 'await tools.exec_command({"cmd":"npm test","workdir":"/repo","yield_time_ms":10000});',
         expectedToolName: 'Bash',
-        expectedToolInput: JSON.stringify({ command: 'echo current' }),
+        expectedToolInput: JSON.stringify({ command: 'npm test' }),
+      },
+      {
+        callId: 'web-run-1',
+        input: 'await tools.web__run({ search_query: [{ q: "Codex" }, { q: "rollout format" }] });',
+        expectedToolName: 'WebSearch',
+        expectedToolInput: JSON.stringify({ query: 'Codex | rollout format' }),
+      },
+      {
+        callId: 'unknown-1',
+        input: 'await tools.unknown_wrapper({ value: true });',
+        expectedToolName: 'exec',
+        expectedToolInput: 'await tools.unknown_wrapper({ value: true });',
       },
-      { callId: 'apply-patch-1', input: 'await tools.apply_patch("*** Begin Patch\\n*** End Patch");' },
-      { callId: 'web-run-1', input: 'await tools.web__run({ search_query: [{ q: "Codex" }] });' },
-      { callId: 'update-plan-1', input: 'await tools.update_plan({ plan: [] });' },
-      { callId: 'unknown-1', input: 'await tools.unknown_wrapper({ value: true });' },
     ];
     const transcriptLines = [
       JSON.stringify({ type: 'session_meta', payload: { id: providerSessionId, cwd: workspacePath } }),
@@ -209,19 +219,15 @@ test('Codex history preserves wrapped exec tool calls and results', { concurrenc
 
       const history = await new CodexSessionsProvider().fetchHistory('app-exec-1');
       const toolUses = history.messages.filter((message) => message.kind === 'tool_use');
-      const toolResults = history.messages.filter((message) => message.kind === 'tool_result');
       const toolUsesById = new Map(toolUses.map((message) => [message.toolId, message]));
-      const toolResultsById = new Map(toolResults.map((message) => [message.toolId, message]));
 
       assert.equal(toolUses.length, wrappedCalls.length);
-      assert.equal(toolResults.length, wrappedCalls.length);
       for (const call of wrappedCalls) {
         const toolUse = toolUsesById.get(call.callId);
-        assert.ok(toolUse);
-        assert.equal(toolUse.toolName, call.expectedToolName || 'exec');
-        assert.equal(toolUse.toolInput, call.expectedToolInput || call.input);
+        assert.ok(toolUse, `missing row for ${call.callId}`);
+        assert.equal(toolUse.toolName, call.expectedToolName);
+        assert.equal(toolUse.toolInput, call.expectedToolInput);
         assert.equal(toolUse.toolResult?.content, `result:${call.callId}`);
-        assert.equal(toolResultsById.get(call.callId)?.content, `result:${call.callId}`);
       }
     });
   } finally {
@@ -229,3 +235,319 @@ test('Codex history preserves wrapped exec tool calls and results', { concurrenc
     await rm(tempRoot, { recursive: true, force: true });
   }
 });
+
+test('Codex history strips the sandbox envelopes from shell output', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-exec-output-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    const providerSessionId = 'codex-output-1';
+    const transcriptPath = await writeCodexTranscript(tempRoot, providerSessionId, workspacePath);
+    await writeFile(transcriptPath, `${[
+      JSON.stringify({ type: 'session_meta', payload: { id: providerSessionId, cwd: workspacePath } }),
+      JSON.stringify({
+        type: 'response_item',
+        payload: {
+          type: 'custom_tool_call',
+          name: 'exec',
+          call_id: 'failing-1',
+          input: 'await tools.shell_command({ command: "npm test" });',
+        },
+      }),
+      // Codex nests two report headers: one for the sandbox script and one for
+      // the command it ran. Neither belongs in a chat transcript.
+      JSON.stringify({
+        type: 'response_item',
+        payload: {
+          type: 'custom_tool_call_output',
+          call_id: 'failing-1',
+          output: [
+            { type: 'input_text', text: 'Script failed\nWall time 1.2 seconds\nOutput:\n' },
+            { type: 'input_text', text: 'Script error:\nExit code: 1\nWall time: 1.1 seconds\nOutput:\n1 test failed\n' },
+          ],
+        },
+      }),
+    ].join('\n')}\n`, 'utf8');
+
+    await withIsolatedDatabase(async () => {
+      sessionsDb.createAppSession('app-output-1', 'codex', workspacePath);
+      sessionsDb.assignProviderSessionId('app-output-1', providerSessionId);
+      await new CodexSessionSynchronizer().synchronize();
+
+      const history = await new CodexSessionsProvider().fetchHistory('app-output-1');
+      const bash = history.messages.find((message) => message.kind === 'tool_use');
+
+      assert.equal(bash?.toolName, 'Bash');
+      assert.equal(bash?.toolResult?.content, '1 test failed\n');
+      assert.equal(bash?.toolResult?.isError, true, 'a non-zero exit code must mark the row failed');
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('Codex history renders one file row per patched file, from the applied diff', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-patch-history-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    const providerSessionId = 'codex-patch-1';
+    const transcriptPath = await writeCodexTranscript(tempRoot, providerSessionId, workspacePath);
+    const patch = [
+      '*** Begin Patch',
+      '*** Update File: /repo/a.ts',
+      '@@',
+      '-const a = 1;',
+      '+const a = 2;',
+      '*** Update File: /repo/b.ts',
+      '@@',
+      '-const b = 1;',
+      '+const b = 2;',
+      '*** End Patch',
+    ].join('\n');
+
+    await writeFile(transcriptPath, `${[
+      JSON.stringify({ type: 'session_meta', payload: { id: providerSessionId, cwd: workspacePath } }),
+      JSON.stringify({
+        type: 'response_item',
+        payload: { type: 'custom_tool_call', name: 'apply_patch', call_id: 'patch-1', input: patch },
+      }),
+      // The out-of-band report carries the real diffs, keyed by path in an
+      // order that does not follow the patch body.
+      JSON.stringify({
+        type: 'event_msg',
+        payload: {
+          type: 'patch_apply_end',
+          call_id: 'patch-1',
+          success: true,
+          changes: {
+            '/repo/b.ts': { type: 'update', unified_diff: '@@\n-const b = 1;\n+const b = 22;\n' },
+            '/repo/a.ts': { type: 'update', unified_diff: '@@\n-const a = 1;\n+const a = 22;\n' },
+          },
+        },
+      }),
+      JSON.stringify({
+        type: 'response_item',
+        payload: { type: 'custom_tool_call_output', call_id: 'patch-1', output: '{}' },
+      }),
+    ].join('\n')}\n`, 'utf8');
+
+    await withIsolatedDatabase(async () => {
+      sessionsDb.createAppSession('app-patch-1', 'codex', workspacePath);
+      sessionsDb.assignProviderSessionId('app-patch-1', providerSessionId);
+      await new CodexSessionSynchronizer().synchronize();
+
+      const history = await new CodexSessionsProvider().fetchHistory('app-patch-1');
+      const edits = history.messages.filter((message) => message.kind === 'tool_use');
+
+      assert.equal(edits.length, 2, 'the patch must not be rendered twice');
+      const byPath = new Map(edits.map((edit) => {
+        const input = JSON.parse(String(edit.toolInput)) as { file_path: string; new_string: string };
+        return [input.file_path, { edit, input }];
+      }));
+
+      assert.equal(byPath.get('/repo/a.ts')?.edit.toolName, 'Edit');
+      // The applied diff wins over the one reconstructed from the call input,
+      // and it must land on the row for its own file.
+      assert.equal(byPath.get('/repo/a.ts')?.input.new_string, 'const a = 22;');
+      assert.equal(byPath.get('/repo/b.ts')?.input.new_string, 'const b = 22;');
+      for (const edit of edits) {
+        assert.equal(edit.toolResult?.isError, false, 'a successful patch must resolve its row');
+      }
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('Codex history attaches a spawned agent\'s own transcript to the Task row', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-subagent-history-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    const providerSessionId = 'codex-parent-2';
+    const agentThreadId = 'codex-agent-thread-2';
+    const transcriptPath = await writeCodexTranscript(tempRoot, providerSessionId, workspacePath);
+
+    await writeFile(transcriptPath, `${[
+      JSON.stringify({ type: 'session_meta', payload: { id: providerSessionId, cwd: workspacePath } }),
+      JSON.stringify({
+        type: 'response_item',
+        payload: {
+          type: 'function_call',
+          name: 'spawn_agent',
+          call_id: 'spawn-1',
+          arguments: JSON.stringify({ task_name: 'test_agent_1' }),
+        },
+      }),
+      JSON.stringify({
+        type: 'event_msg',
+        payload: {
+          type: 'sub_agent_activity',
+          kind: 'started',
+          event_id: 'spawn-1',
+          agent_thread_id: agentThreadId,
+          agent_path: '/root/test_agent_1',
+        },
+      }),
+      JSON.stringify({
+        type: 'response_item',
+        payload: {
+          type: 'agent_message',
+          author: '/root/test_agent_1',
+          content: [{ type: 'input_text', text: 'Message Type: FINAL_ANSWER\nSender: /root/test_agent_1\nPayload:\nAll done.' }],
+        },
+      }),
+    ].join('\n')}\n`, 'utf8');
+
+    // Codex writes a spawned agent's rollout next to its parent's, named after
+    // the agent thread id.
+    await writeFile(
+      path.join(path.dirname(transcriptPath), `rollout-2026-07-07T00-00-00-${agentThreadId}.jsonl`),
+      `${[
+        JSON.stringify({
+          type: 'session_meta',
+          payload: { id: agentThreadId, cwd: workspacePath, thread_source: 'subagent', agent_nickname: 'Hegel' },
+        }),
+        JSON.stringify({
+          type: 'response_item',
+          payload: {
+            type: 'custom_tool_call',
+            name: 'exec',
+            call_id: 'agent-call-1',
+            input: 'await tools.shell_command({ command: "ls" });',
+          },
+        }),
+        JSON.stringify({
+          type: 'response_item',
+          payload: { type: 'custom_tool_call_output', call_id: 'agent-call-1', output: 'Exit code: 0\nOutput:\nREADME.md\n' },
+        }),
+      ].join('\n')}\n`,
+      'utf8',
+    );
+
+    await withIsolatedDatabase(async () => {
+      sessionsDb.createAppSession('app-parent-2', 'codex', workspacePath);
+      sessionsDb.assignProviderSessionId('app-parent-2', providerSessionId);
+      await new CodexSessionSynchronizer().synchronize();
+
+      const history = await new CodexSessionsProvider().fetchHistory('app-parent-2');
+      const task = history.messages.find((message) => message.kind === 'tool_use' && message.toolName === 'Task');
+
+      assert.ok(task, 'a spawned agent must produce a Task row');
+      assert.equal(task.subagent?.id, agentThreadId);
+      assert.equal(task.subagent?.name, 'Hegel');
+      assert.equal(task.subagent?.status, 'completed');
+      assert.equal(task.toolResult?.content, 'All done.');
+
+      // The agent's own shell call is translated exactly like the parent's.
+      assert.equal(task.subagentTools?.length, 1);
+      assert.equal(task.subagentTools?.[0].kind, 'tool');
+      assert.equal(task.subagentTools?.[0].toolName, 'Bash');
+      assert.equal(task.subagentTools?.[0].toolResult?.content, 'README.md\n');
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('Codex memory citations are lifted out of the reply they trail', () => {
+  const reply = [
+    'Here is the answer.',
+    '',
+    '<oai-mem-citation>',
+    '<citation_entries>',
+    'MEMORY.md:137-142|note=[used verified container provisioning details]',
+    'notes/deploy.md:4-9',
+    '</citation_entries>',
+    '<rollout_ids>',
+    '019eda6d-c2f7-70c1-8b42-bf03c44a1f35',
+    '</rollout_ids>',
+    '</oai-mem-citation>',
+  ].join('\n');
+
+  const { text, memoryCitations } = readCodexMemoryCitations(reply);
+
+  assert.equal(text, 'Here is the answer.');
+  assert.deepEqual(memoryCitations, [
+    { source: 'MEMORY.md:137-142', note: 'used verified container provisioning details' },
+    { source: 'notes/deploy.md:4-9' },
+  ]);
+});
+
+test('a plan followed by a memory citation is still recognized as a plan', async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-plan-citation-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    const providerSessionId = 'codex-plan-citation-1';
+    const sessionsDir = path.join(tempRoot, '.codex', 'sessions', '2026', '07', '07');
+    await mkdir(sessionsDir, { recursive: true });
+    await writeFile(path.join(sessionsDir, `rollout-${providerSessionId}.jsonl`), `${[
+      JSON.stringify({ type: 'session_meta', payload: { id: providerSessionId, cwd: workspacePath } }),
+      JSON.stringify({
+        type: 'response_item',
+        payload: {
+          type: 'message',
+          role: 'assistant',
+          id: 'plan-1',
+          content: [{
+            type: 'output_text',
+            text: '<proposed_plan>\n# Ship it\n</proposed_plan>\n\n<oai-mem-citation>\n<citation_entries>\nMEMORY.md:1-2|note=[prior deploy steps]\n</citation_entries>\n</oai-mem-citation>',
+          }],
+        },
+      }),
+    ].join('\n')}\n`, 'utf8');
+
+    await withIsolatedDatabase(async () => {
+      sessionsDb.createAppSession('app-plan-citation-1', 'codex', workspacePath);
+      sessionsDb.assignProviderSessionId('app-plan-citation-1', providerSessionId);
+      await new CodexSessionSynchronizer().synchronize();
+
+      const history = await new CodexSessionsProvider().fetchHistory('app-plan-citation-1');
+      const plan = history.messages.find((message) => message.toolName === 'ExitPlanMode');
+
+      assert.ok(plan, 'the trailing citation block must not hide the plan envelope');
+      assert.equal(JSON.parse(String(plan.toolInput)).plan, '# Ship it');
+      assert.deepEqual(plan.memoryCitations, [{ source: 'MEMORY.md:1-2', note: 'prior deploy steps' }]);
+      assert.ok(
+        !history.messages.some((message) => JSON.stringify(message).includes('oai-mem-citation')),
+        'no transcript row may still carry the raw citation markup',
+      );
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('an exec script that updates the plan yields the steps it set', () => {
+  const operations = parseCodexExecScript([
+    'const p = await tools.update_plan({plan:[',
+    '  {step:"Confirm the current workspace",status:"completed"},',
+    '  {step:"Check the Git working-tree status",status:"in_progress"},',
+    '  {step:"Identify the project",status:"pending"}',
+    ']});',
+    'text(p);',
+  ].join('\n'));
+
+  assert.deepEqual(operations, [{
+    kind: 'plan',
+    todos: [
+      { content: 'Confirm the current workspace', status: 'completed' },
+      { content: 'Check the Git working-tree status', status: 'in_progress' },
+      { content: 'Identify the project', status: 'pending' },
+    ],
+  }]);
+});

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

@@ -1,4 +1,7 @@
 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 {
@@ -6,20 +9,64 @@ import {
   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 +85,115 @@ 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']);
+    },
+  );
 });