@openchambery/web 2.0.0-beta.1 → 2.0.0-beta.4

package/server/lib/small-model/index.js

@@ -1,15 +1,12 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { readAuthFile } from '../opencode/auth.js';
 import { readConfigLayers } from '../opencode/shared.js';
 import { OpenCode } from '@opencode/client';
-import { loadConnectedCatalog } from '../llm/catalog.js';
-import { createModelCatalogLoader, getCatalogProvider } from './catalog.js';
-import { resolveSmallModel, parseModelRef, isUsableAuthEntry, getAuthEntryForProvider } from './resolve.js';
-import { callSmallModel } from './call.js';
-import { generateViaOpenCodeSession, stop as stopOpenCodeSessionTemp } from './opencode-session.js';
-import { listCustomSummaryModels, testCustomSummaryApi } from './custom-api.js';
+import { createChatCompletion } from '../llm/completions.js';
+import { createModelCatalogLoader } from './catalog.js';
+import { resolveSmallModel, parseModelRef } from './resolve.js';
+import { generateCustomSummaryText, listCustomSummaryModels, testCustomSummaryApi } from './custom-api.js';
 
 const OPENCHAMBER_SETTINGS_FILE = path.join(
   process.env.OPENCHAMBER_DATA_DIR
@@ -68,8 +65,7 @@ const readSmallModelSettingsOverride = () => {
 
 // Rough safety clamp so a huge input never blows the model's context window.
 // Token estimate is ~4 chars/token; when the catalog has no limit for the
-// model (Copilot/codex utility models are not listed) a conservative default
-// applies.
+// model (or the call goes to a custom API) a conservative default applies.
 const DEFAULT_CONTEXT_TOKENS = 64_000;
 const OUTPUT_RESERVE_TOKENS = 4_000;
 
@@ -84,106 +80,6 @@ const clampPromptToModelLimit = ({ prompt, catalog, providerID, modelID }) => {
   return { prompt: `${prompt.slice(0, maxChars)}…`, truncated: true };
 };
 
-// Dedicated adapters keep the direct wire-format path. Everything else
-// (plugin providers, credential-chain, missing api.url, …) goes through a
-// temporary OpenCode session so auth/endpoint rewrite stay in the runtime.
-const DEDICATED_DIRECT_PROVIDERS = new Set(['openai', 'anthropic', 'google', 'github-copilot']);
-
-// Mirrors pickWithinProvider / callSmallModel auth gates so Settings pickers
-// never list dedicated providers that would only fail at dispatch time.
-const isCallableDedicatedAuth = (auth, providerID) => {
-  if (providerID === 'openai') {
-    const entry = auth?.openai;
-    return isUsableAuthEntry(entry) && (entry.type === 'api' || entry.type === 'oauth');
-  }
-  if (providerID === 'anthropic') {
-    const entry = auth?.anthropic;
-    return entry?.type === 'api' && isUsableAuthEntry(entry);
-  }
-  if (providerID === 'google') {
-    const entry = auth?.google;
-    return entry?.type === 'api' && isUsableAuthEntry(entry);
-  }
-  if (providerID === 'github-copilot') {
-    return isUsableAuthEntry(getAuthEntryForProvider(auth, 'github-copilot'));
-  }
-  return false;
-};
-
-const providerHasCatalogModels = (provider) => {
-  if (!provider || typeof provider !== 'object') return false;
-  return Object.values(provider.models || {}).some(
-    (model) => typeof model?.id === 'string' && model.id.trim().length > 0,
-  );
-};
-
-const shouldUseDirectAdapter = (providerID, auth) => {
-  if (!DEDICATED_DIRECT_PROVIDERS.has(providerID)) return false;
-  return isCallableDedicatedAuth(auth, providerID);
-};
-
-const addNonDedicatedCallableProvider = (ids, catalog, providerID) => {
-  if (!providerID || providerID === 'copilot' || DEDICATED_DIRECT_PROVIDERS.has(providerID)) return;
-  const provider = getCatalogProvider(catalog, providerID);
-  if (providerHasCatalogModels(provider)) ids.add(providerID);
-};
-
-const listCallableProviderIDsForState = (auth, catalog, connectedIDs) => {
-  const ids = new Set();
-  for (const providerID of DEDICATED_DIRECT_PROVIDERS) {
-    if (isCallableDedicatedAuth(auth, providerID)) ids.add(providerID);
-  }
-  if (isUsableAuthEntry(getAuthEntryForProvider(auth, 'github-copilot'))) {
-    ids.add('github-copilot');
-  }
-
-  if (Array.isArray(connectedIDs)) {
-    for (const providerID of connectedIDs) {
-      addNonDedicatedCallableProvider(ids, catalog, providerID);
-    }
-  } else {
-    // Connected catalog failed: do not pretend plugin providers are absent.
-    for (const providerID of Object.keys(auth || {})) {
-      if (providerID === 'copilot') continue;
-      if (!isUsableAuthEntry(auth[providerID])) continue;
-      addNonDedicatedCallableProvider(ids, catalog, providerID);
-    }
-  }
-  return Array.from(ids);
-};
-
-const listCallableModelsForState = (auth, catalog, connectedIDs) => {
-  const result = {};
-  for (const providerID of listCallableProviderIDsForState(auth, catalog, connectedIDs)) {
-    if (providerID === 'openai' && auth.openai?.type === 'oauth') {
-      result[providerID] = ['gpt-5.4-mini'];
-      continue;
-    }
-    if (providerID === 'github-copilot') {
-      result[providerID] = ['gpt-5.4-nano'];
-      continue;
-    }
-    const provider = getCatalogProvider(catalog, providerID);
-    const modelIDs = Object.values(provider?.models || {})
-      .map((model) => (typeof model?.id === 'string' ? model.id : ''))
-      .filter(Boolean);
-    if (modelIDs.length > 0) {
-      result[providerID] = modelIDs;
-    }
-  }
-  return result;
-};
-
-const resolveDefaultSummaryModel = (auth, catalog, connectedIDs) => {
-  const callableModels = listCallableModelsForState(auth, catalog, connectedIDs);
-  const providerIDs = Object.keys(callableModels);
-  const providerID = callableModels.openai ? 'openai' : providerIDs[0];
-  const modelID = providerID ? callableModels[providerID]?.[0] : undefined;
-  return providerID && modelID
-    ? { providerID, modelID, source: 'summary-default' }
-    : null;
-};
-
 const readConfiguredSmallModel = (workingDirectory) => {
   try {
     const { mergedConfig } = readConfigLayers(workingDirectory);
@@ -203,39 +99,117 @@ const readConfiguredSmallModel = (workingDirectory) => {
  *   buildOpenCodeUrl: (pathname: string, search?: string) => string,
  *   getOpenCodeAuthHeaders: () => Record<string, string>,
  *   getModelCatalog?: (directory?: string) => Promise<object>,
- *   getConnectedCatalog?: (directory?: string) => Promise<{ connected?: string[] }>,
+ *   openCodeClientFactory?: () => object,
+ *   createChatCompletion?: typeof createChatCompletion,
+ *   persistSessionMetadata?: (sessionID: string, patch: object) => Promise<unknown>,
+ *   onSystemSessionPersisted?: (input: { sessionID: string, directory: string, metadata: object }) => void,
  * }} dependencies
  */
 export function createSmallModelService(dependencies) {
   const buildOpenCodeUrl = dependencies.buildOpenCodeUrl;
   const getOpenCodeAuthHeaders = dependencies.getOpenCodeAuthHeaders;
+  const persistSessionMetadata = dependencies.persistSessionMetadata || null;
+  const onSystemSessionPersisted = dependencies.onSystemSessionPersisted || null;
   const getModelCatalog = dependencies.getModelCatalog
     || createModelCatalogLoader({
       buildOpenCodeUrl,
       getOpenCodeAuthHeaders,
     }).getModelCatalog;
-  const getConnectedCatalog = dependencies.getConnectedCatalog || (async (directory) => {
-    const client = OpenCode.make({
-      baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
-      headers: getOpenCodeAuthHeaders(),
-    });
-    void directory;
-    return loadConnectedCatalog(client);
-  });
-
-  const loadCallableContext = async (directory) => {
-    const auth = readAuthFile();
-    const catalog = await getModelCatalog(directory);
-    let connectedIDs = null;
+  const openCodeClient = dependencies.openCodeClientFactory || (() => OpenCode.make({
+    baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
+    headers: getOpenCodeAuthHeaders(),
+  }));
+  const runChatCompletion = dependencies.createChatCompletion || createChatCompletion;
+
+  // No saved Summary AI model follows OpenCode's own default model.
+  const resolveSummaryProviderModel = async (summarySettings, directory) => {
+    if (summarySettings?.providerID && summarySettings?.modelID) {
+      return { providerID: summarySettings.providerID, modelID: summarySettings.modelID, source: 'summary-provider' };
+    }
+    let result;
     try {
-      const connectedCatalog = await getConnectedCatalog(directory);
-      connectedIDs = Array.isArray(connectedCatalog?.connected) ? connectedCatalog.connected : [];
-    } catch {
-      connectedIDs = null;
+      result = await openCodeClient().model.default(directory ? { location: { directory } } : undefined);
+    } catch (error) {
+      throw Object.assign(
+        new Error(`OpenCode default model is unavailable (${error?.message || error})`),
+        { statusCode: 502 },
+      );
     }
-    return { auth, catalog, connectedIDs };
+    const providerID = typeof result?.data?.providerID === 'string' ? result.data.providerID : '';
+    const modelID = typeof result?.data?.id === 'string' ? result.data.id : '';
+    if (!providerID || !modelID) {
+      throw Object.assign(new Error('No OpenCode default model is configured'), { statusCode: 404 });
+    }
+    return { providerID, modelID, source: 'summary-default' };
   };
 
+  // Every OpenCode-backed call shares the Assistant LLM gateway: connected
+  // catalog check, then a throwaway-session `session.generate`.
+  const generateThroughGateway = async ({ resolved, prompt, system, directory }) => {
+    const catalog = await getModelCatalog(directory);
+    const clamped = clampPromptToModelLimit({ prompt, catalog, providerID: resolved.providerID, modelID: resolved.modelID });
+    const { completion } = await runChatCompletion({
+      body: {
+        providerID: resolved.providerID,
+        modelID: resolved.modelID,
+        messages: [
+          ...(system ? [{ role: 'system', content: system }] : []),
+          { role: 'user', content: clamped.prompt },
+        ],
+      },
+      buildOpenCodeUrl,
+      getOpenCodeAuthHeaders,
+      clientFactory: openCodeClient,
+      persistSessionMetadata,
+      onSystemSessionPersisted,
+    });
+    const text = completion?.choices?.[0]?.message?.content;
+    return {
+      text: typeof text === 'string' ? text.trim() : '',
+      providerID: resolved.providerID,
+      modelID: resolved.modelID,
+      source: resolved.source,
+      ...(clamped.truncated ? { inputTruncated: true } : {}),
+    };
+  };
+
+  // Summary AI (commit / session-title): the saved OpenCode model or OpenCode's
+  // default through the gateway, or the user's custom OpenAI-compatible API.
+  async function generateSummaryText({ prompt, system, maxOutputTokens, directory, purpose }) {
+    const summarySettings = readSummarySettings();
+    const effectiveSystem = summarySettings?.prompts?.[purpose]
+      || (typeof system === 'string' && system.trim() ? system.trim() : undefined);
+
+    if (summarySettings?.mode === 'custom') {
+      const custom = summarySettings.custom;
+      if (!custom) {
+        throw Object.assign(
+          new Error('Custom summary API requires a Base URL, model ID, and API token'),
+          { statusCode: 400 },
+        );
+      }
+      const clamped = clampPromptToModelLimit({ prompt, catalog: {}, providerID: 'custom', modelID: custom.modelID });
+      const text = await generateCustomSummaryText({
+        baseURL: custom.baseURL,
+        apiToken: custom.apiToken,
+        modelID: custom.modelID,
+        prompt: clamped.prompt,
+        system: effectiveSystem,
+        maxOutputTokens,
+      });
+      return {
+        text: text.trim(),
+        providerID: 'custom',
+        modelID: custom.modelID,
+        source: 'summary-custom',
+        ...(clamped.truncated ? { inputTruncated: true } : {}),
+      };
+    }
+
+    const resolved = await resolveSummaryProviderModel(summarySettings, directory);
+    return generateThroughGateway({ resolved, prompt, system: effectiveSystem, directory });
+  }
+
   const resolveCustomApiInput = (body = {}) => {
     const summarySettings = readSummarySettings();
     const baseURL = typeof body.baseURL === 'string' && body.baseURL.trim()
@@ -251,8 +225,8 @@ export function createSmallModelService(dependencies) {
   };
 
   /**
-   * Generates text with the user's small model, resolved and authenticated
-   * entirely server-side from the OpenCode config and auth store.
+   * Generates text with the user's small model, resolved server-side from
+   * OpenChamber settings, the OpenCode config, and the connected catalog.
    */
   async function generateSmallModelText({
     prompt,
@@ -269,48 +243,24 @@ export function createSmallModelService(dependencies) {
       throw Object.assign(new Error('prompt is required'), { statusCode: 400 });
     }
 
-    const { auth, catalog, connectedIDs } = await loadCallableContext(directory);
-    const summarySettings = SUMMARY_PURPOSES.has(purpose) ? readSummarySettings() : null;
-    const summaryPrompt = summarySettings?.prompts?.[purpose];
-    const defaultSummaryModel = SUMMARY_PURPOSES.has(purpose)
-      ? resolveDefaultSummaryModel(auth, catalog, connectedIDs)
-      : null;
+    if (SUMMARY_PURPOSES.has(purpose)) {
+      return generateSummaryText({ prompt: prompt.trim(), system, maxOutputTokens, directory, purpose });
+    }
 
     const explicit = parseModelRef(model);
-    const summaryProvider = summarySettings?.mode === 'provider' && summarySettings.providerID && summarySettings.modelID
-      ? {
-          providerID: summarySettings.providerID,
-          modelID: summarySettings.modelID,
-          source: 'summary-provider',
-        }
-      : summarySettings?.mode !== 'custom'
-        ? defaultSummaryModel
-        : null;
-    const summaryCustom = summarySettings?.mode === 'custom' ? summarySettings.custom : null;
-    if (summarySettings?.mode === 'custom' && !summaryCustom) {
-      throw Object.assign(
-        new Error('Custom summary API requires a Base URL, model ID, and API token'),
-        { statusCode: 400 },
-      );
-    }
-    const resolved = summaryCustom
-      ? { providerID: 'custom', modelID: summaryCustom.modelID, source: 'summary-custom' }
-      : summaryProvider
-        ? summaryProvider
-        : explicit
-          ? { ...explicit, source: 'request' }
-          : resolveSmallModel({
-            auth,
-            catalog,
-            settingsSmallModel: readSmallModelSettingsOverride(),
-            configSmallModel: readConfiguredSmallModel(directory),
-            preferredProviderID: summarySettings?.providerID || preferredProviderID,
-            preferredModelID,
-          });
+    const resolved = explicit
+      ? { ...explicit, source: 'request' }
+      : resolveSmallModel({
+        catalog: await getModelCatalog(directory),
+        settingsSmallModel: readSmallModelSettingsOverride(),
+        configSmallModel: readConfiguredSmallModel(directory),
+        preferredProviderID,
+        preferredModelID,
+      });
 
     if (!resolved) {
       throw Object.assign(
-        new Error('No small model available — no authenticated provider has a suitable model'),
+        new Error('No small model available — no connected OpenCode provider has a suitable model'),
         { statusCode: 404 },
       );
     }
@@ -320,7 +270,7 @@ export function createSmallModelService(dependencies) {
     // model) is always allowed, anything else must stay on the session's
     // provider.
     if (restrictToPreferredProvider
-      && !['settings', 'config', 'request', 'summary-provider', 'summary-default', 'summary-custom'].includes(resolved.source)
+      && !['settings', 'config', 'request'].includes(resolved.source)
       && resolved.providerID !== preferredProviderID) {
       throw Object.assign(
         new Error('No small model available within the session provider'),
@@ -328,71 +278,12 @@ export function createSmallModelService(dependencies) {
       );
     }
 
-    const clamped = clampPromptToModelLimit({
+    return generateThroughGateway({
+      resolved,
       prompt: prompt.trim(),
-      catalog,
-      providerID: resolved.providerID,
-      modelID: resolved.modelID,
+      system: typeof system === 'string' && system.trim() ? system.trim() : undefined,
+      directory,
     });
-
-    const effectiveSystem = summaryPrompt || (typeof system === 'string' && system.trim() ? system.trim() : undefined);
-
-    let text;
-    if (summaryCustom || shouldUseDirectAdapter(resolved.providerID, auth)) {
-      text = await callSmallModel({
-        auth,
-        catalog,
-        workingDirectory: directory,
-        providerID: resolved.providerID,
-        modelID: resolved.modelID,
-        prompt: clamped.prompt,
-        system: effectiveSystem,
-        maxOutputTokens,
-        custom: summaryCustom,
-      });
-    } else {
-      text = await generateViaOpenCodeSession({
-        buildOpenCodeUrl,
-        getOpenCodeAuthHeaders,
-        providerID: resolved.providerID,
-        modelID: resolved.modelID,
-        prompt: clamped.prompt,
-        system: effectiveSystem,
-        purpose: typeof purpose === 'string' && purpose.trim() ? purpose.trim() : 'generate',
-        directory,
-      });
-    }
-
-    return {
-      text: text.trim(),
-      providerID: resolved.providerID,
-      modelID: resolved.modelID,
-      source: resolved.source,
-      ...(clamped.truncated ? { inputTruncated: true } : {}),
-    };
-  }
-
-  /**
-   * Provider ids with a usable OpenCode login — the set the small model can
-   * actually call. Used by the settings override picker to hide providers that
-   * would only ever fail (e.g. opencode free models without a token).
-   */
-  async function listCallableProviders({ directory } = {}) {
-    try {
-      const { auth, catalog, connectedIDs } = await loadCallableContext(directory);
-      return listCallableProviderIDsForState(auth, catalog, connectedIDs);
-    } catch {
-      return [];
-    }
-  }
-
-  async function listCallableModels({ directory } = {}) {
-    try {
-      const { auth, catalog, connectedIDs } = await loadCallableContext(directory);
-      return listCallableModelsForState(auth, catalog, connectedIDs);
-    } catch {
-      return {};
-    }
   }
 
   async function testCustomApi(body) {
@@ -408,26 +299,19 @@ export function createSmallModelService(dependencies) {
    * Reports which model would be used, without calling it.
    */
   async function describeSmallModel({ directory, preferredProviderID, preferredModelID } = {}) {
-    const auth = readAuthFile();
-    const catalog = await getModelCatalog(directory);
-    const resolved = resolveSmallModel({
-      auth,
-      catalog,
+    return resolveSmallModel({
+      catalog: await getModelCatalog(directory),
       settingsSmallModel: readSmallModelSettingsOverride(),
       configSmallModel: readConfiguredSmallModel(directory),
       preferredProviderID,
       preferredModelID,
     });
-    return resolved;
   }
 
   return {
     generateSmallModelText,
-    listCallableProviders,
-    listCallableModels,
     testCustomApi,
     listCustomModels,
     describeSmallModel,
-    stop: stopOpenCodeSessionTemp,
   };
 }

package/server/lib/small-model/resolve.js

@@ -1,15 +1,11 @@
 import { getCatalogProvider } from './catalog.js';
 
-// Mirrors OpenCode's getSmallModel fallback chain, with OpenChamber's own
-// keyword + cheapest-first default when no session/family match applies:
+// Mirrors OpenCode's getSmallModel fallback chain over the connected OpenCode
+// catalog, with OpenChamber's own keyword + cheapest-first default when no
+// session/family match applies:
 // 1. `small_model` from the merged config layers ("provider/model").
-// 2. Family-priority / keyword scan of authenticated providers' catalog models.
-// 3. GitHub Copilot's hidden utility models when Copilot is logged in.
+// 2. Family-priority / keyword scan of connected providers' catalog models.
 const FAMILY_PRIORITY = ['gemini-flash', 'gpt-nano', 'claude-haiku'];
-const COPILOT_UTILITY_MODELS = ['gpt-5.4-nano', 'gpt-4.1', 'gpt-4o', 'gpt-4o-mini'];
-// The ChatGPT-plan codex backend only accepts a small allowlist of models
-// (nano/API-key models are rejected with 400) — this is its cheapest one.
-const OPENAI_OAUTH_SMALL_MODEL = 'gpt-5.4-mini';
 
 // Tokenize model ids so "mini" does not match inside "gemini".
 const modelIdTokens = (id) => String(id || '')
@@ -33,32 +29,6 @@ const SMALL_MODEL_KEYWORD_TIERS = Object.freeze([
   { tier: 8, test: (id) => idHasToken(id, 'chat') },
 ]);
 
-const AUTH_PROVIDER_ALIASES = {
-  'github-copilot': ['github-copilot', 'copilot'],
-};
-
-export function getAuthEntryForProvider(auth, providerID) {
-  const aliases = AUTH_PROVIDER_ALIASES[providerID] || [providerID];
-  for (const alias of aliases) {
-    const entry = auth?.[alias];
-    if (entry && typeof entry === 'object') {
-      return entry;
-    }
-  }
-  return null;
-}
-
-export function isUsableAuthEntry(entry) {
-  if (!entry || typeof entry !== 'object') return false;
-  if (entry.type === 'api') return typeof entry.key === 'string' && entry.key.length > 0;
-  if (entry.type === 'oauth') {
-    return (typeof entry.access === 'string' && entry.access.length > 0)
-      || (typeof entry.refresh === 'string' && entry.refresh.length > 0);
-  }
-  if (entry.type === 'wellknown') return typeof entry.token === 'string' && entry.token.length > 0;
-  return false;
-}
-
 export function parseModelRef(value) {
   if (typeof value !== 'string') return null;
   const trimmed = value.trim();
@@ -115,71 +85,25 @@ export function rankSmallModelCandidates(models) {
     .map((entry) => entry.model);
 }
 
-// Small-model candidates within ONE provider, by family priority. Copilot and
-// ChatGPT-plan OpenAI have fixed small models that never appear in the
-// catalog; everyone else is scanned through the catalog families.
-// Auth-type constraints for the four minimal hardcoded providers:
-// OpenAI OAuth → hardcoded codex-small only; OpenAI API key → catalog families;
-// Anthropic/Google require API keys; Copilot supports auth aliases.
-const pickWithinProvider = (providerID, auth, catalog, family) => {
-  if (providerID === 'openai' && auth.openai?.type === 'oauth') {
-    if (!isUsableAuthEntry(auth.openai)) return null;
-    return family === 'gpt-nano'
-      ? { providerID, modelID: OPENAI_OAUTH_SMALL_MODEL, source: 'codex-small' }
-      : null;
-  }
-  if (providerID === 'github-copilot') {
-    if (!isUsableAuthEntry(getAuthEntryForProvider(auth, 'github-copilot'))) return null;
-    return family === 'gpt-nano'
-      ? { providerID, modelID: COPILOT_UTILITY_MODELS[0], source: 'copilot-utility' }
-      : null;
-  }
-  if (providerID === 'openai') {
-    if (auth.openai?.type !== 'api' || !isUsableAuthEntry(auth.openai)) return null;
-  }
-  if (providerID === 'anthropic') {
-    if (auth.anthropic?.type !== 'api' || !isUsableAuthEntry(auth.anthropic)) return null;
-  }
-  if (providerID === 'google') {
-    if (auth.google?.type !== 'api' || !isUsableAuthEntry(auth.google)) return null;
-  }
-  const provider = getCatalogProvider(catalog, providerID);
-  if (!provider || !provider.models || typeof provider.models !== 'object') return null;
-  const model = pickByFamily(provider.models, family);
+const catalogModels = (catalog, providerID) => {
+  const models = getCatalogProvider(catalog, providerID)?.models;
+  return models && typeof models === 'object' ? models : null;
+};
+
+const pickWithinProvider = (catalog, providerID, family) => {
+  const models = catalogModels(catalog, providerID);
+  const model = models ? pickByFamily(models, family) : null;
   return model?.id ? { providerID, modelID: model.id, source: 'family-scan' } : null;
 };
 
-const pickKeywordDefault = (auth, catalog, excludeProviderID) => {
+const pickKeywordDefault = (catalog, providerIDs) => {
   /** @type {Array<{ providerID: string, model: object }>} */
   const candidates = [];
-  const providerIDs = Object.keys(auth || {}).filter((providerID) => {
-    if (providerID === 'copilot') return false;
-    if (excludeProviderID && providerID === excludeProviderID) return false;
-    return isUsableAuthEntry(getAuthEntryForProvider(auth, providerID));
-  });
-  // Surface github-copilot when only the `copilot` alias is present.
-  if (
-    !providerIDs.includes('github-copilot')
-    && isUsableAuthEntry(getAuthEntryForProvider(auth, 'github-copilot'))
-    && excludeProviderID !== 'github-copilot'
-  ) {
-    providerIDs.push('github-copilot');
-  }
-
   for (const providerID of providerIDs) {
-    if (providerID === 'openai' && auth.openai?.type === 'oauth') continue;
-    if (providerID === 'github-copilot') continue;
-    if (providerID === 'openai' && (auth.openai?.type !== 'api' || !isUsableAuthEntry(auth.openai))) continue;
-    if (providerID === 'anthropic' && (auth.anthropic?.type !== 'api' || !isUsableAuthEntry(auth.anthropic))) continue;
-    if (providerID === 'google' && (auth.google?.type !== 'api' || !isUsableAuthEntry(auth.google))) continue;
-
-    const provider = getCatalogProvider(catalog, providerID);
-    if (!provider?.models) continue;
-    for (const model of rankSmallModelCandidates(provider.models)) {
+    for (const model of rankSmallModelCandidates(catalogModels(catalog, providerID))) {
       candidates.push({ providerID, model });
     }
   }
-
   if (candidates.length === 0) return null;
   candidates.sort((a, b) => {
     const tierDiff = smallModelKeywordTier(a.model) - smallModelKeywordTier(b.model);
@@ -190,7 +114,16 @@ const pickKeywordDefault = (auth, catalog, excludeProviderID) => {
   return { providerID: best.providerID, modelID: best.model.id, source: 'keyword-scan' };
 };
 
-export function resolveSmallModel({ auth, catalog, settingsSmallModel, configSmallModel, preferredProviderID, preferredModelID }) {
+/**
+ * @param {{
+ *   catalog: object | null,
+ *   settingsSmallModel?: string | null,
+ *   configSmallModel?: string | null,
+ *   preferredProviderID?: string,
+ *   preferredModelID?: string,
+ * }} input
+ */
+export function resolveSmallModel({ catalog, settingsSmallModel, configSmallModel, preferredProviderID, preferredModelID }) {
   // OpenChamber's own setting (Settings → Sessions → Small Model override)
   // outranks everything, including the OpenCode config.
   const fromSettings = parseModelRef(settingsSmallModel);
@@ -210,47 +143,29 @@ export function resolveSmallModel({ auth, catalog, settingsSmallModel, configSma
   const preferred = typeof preferredProviderID === 'string' && preferredProviderID
     ? preferredProviderID
     : null;
-  if (preferred && isUsableAuthEntry(getAuthEntryForProvider(auth, preferred))) {
+  if (preferred && getCatalogProvider(catalog, preferred)) {
     for (const family of FAMILY_PRIORITY) {
-      const match = pickWithinProvider(preferred, auth, catalog, family);
+      const match = pickWithinProvider(catalog, preferred, family);
       if (match) return match;
     }
-    const preferredCatalog = getCatalogProvider(catalog, preferred);
-    if (preferredCatalog?.models) {
-      const ranked = rankSmallModelCandidates(preferredCatalog.models);
-      if (ranked[0]?.id) {
-        return { providerID: preferred, modelID: ranked[0].id, source: 'keyword-scan' };
-      }
+    const ranked = rankSmallModelCandidates(catalogModels(catalog, preferred));
+    if (ranked[0]?.id) {
+      return { providerID: preferred, modelID: ranked[0].id, source: 'keyword-scan' };
     }
     if (typeof preferredModelID === 'string' && preferredModelID) {
       return { providerID: preferred, modelID: preferredModelID, source: 'session-model' };
     }
   }
 
-  // No session context (or its provider has no usable login): scan all
-  // authenticated providers by family priority, then keyword+cost default.
-  const authedProviders = Object.keys(auth || {}).filter((providerID) =>
-    providerID !== preferred && isUsableAuthEntry(auth[providerID]));
-
+  // No session context (or its provider is not connected): scan the other
+  // connected providers by family priority, then keyword+cost default.
+  const otherProviders = Object.keys(catalog || {}).filter((providerID) => providerID !== preferred);
   for (const family of FAMILY_PRIORITY) {
-    for (const providerID of authedProviders) {
-      const match = pickWithinProvider(providerID, auth, catalog, family);
+    for (const providerID of otherProviders) {
+      const match = pickWithinProvider(catalog, providerID, family);
       if (match) return match;
     }
   }
 
-  const keywordDefault = pickKeywordDefault(auth, catalog, preferred);
-  if (keywordDefault) return keywordDefault;
-
-  // Copilot's utility fallback for legacy auth aliases the loop above missed.
-  const copilotEntry = getAuthEntryForProvider(auth, 'github-copilot');
-  if (isUsableAuthEntry(copilotEntry)) {
-    return {
-      providerID: 'github-copilot',
-      modelID: COPILOT_UTILITY_MODELS[0],
-      source: 'copilot-utility',
-    };
-  }
-
-  return null;
+  return pickKeywordDefault(catalog, otherProviders);
 }