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

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

@@ -2,7 +2,6 @@ import { describe, it, expect } from 'vitest';
 import {
   resolveSmallModel,
   parseModelRef,
-  isUsableAuthEntry,
   rankSmallModelCandidates,
   compareSmallModelCandidates,
 } from './resolve.js';
@@ -63,24 +62,9 @@ describe('parseModelRef', () => {
   });
 });
 
-describe('isUsableAuthEntry', () => {
-  it('accepts api keys, oauth tokens, and wellknown tokens', () => {
-    expect(isUsableAuthEntry({ type: 'api', key: 'sk-x' })).toBe(true);
-    expect(isUsableAuthEntry({ type: 'oauth', access: 'a', refresh: 'r', expires: 0 })).toBe(true);
-    expect(isUsableAuthEntry({ type: 'wellknown', key: 'k', token: 't' })).toBe(true);
-  });
-
-  it('rejects empty or malformed entries', () => {
-    expect(isUsableAuthEntry({ type: 'api', key: '' })).toBe(false);
-    expect(isUsableAuthEntry({ type: 'oauth' })).toBe(false);
-    expect(isUsableAuthEntry(null)).toBe(false);
-  });
-});
-
 describe('resolveSmallModel', () => {
   it('gives the OpenChamber settings override top priority', () => {
     const result = resolveSmallModel({
-      auth: { anthropic: { type: 'api', key: 'sk-x' } },
       catalog,
       settingsSmallModel: 'anthropic/claude-haiku-4-5',
       configSmallModel: 'openai/gpt-4o-mini',
@@ -90,108 +74,39 @@ describe('resolveSmallModel', () => {
   });
 
   it('prefers the configured small_model', () => {
-    const result = resolveSmallModel({
-      auth: { anthropic: { type: 'api', key: 'sk-x' } },
-      catalog,
-      configSmallModel: 'openai/gpt-4o-mini',
-    });
+    const result = resolveSmallModel({ catalog, configSmallModel: 'openai/gpt-4o-mini' });
     expect(result).toEqual({ providerID: 'openai', modelID: 'gpt-4o-mini', source: 'config' });
   });
 
-  it('scans authenticated providers by family priority, cheapest then newest within family', () => {
-    const result = resolveSmallModel({
-      auth: {
-        google: { type: 'api', key: 'g-key' },
-        anthropic: { type: 'api', key: 'sk-x' },
-      },
-      catalog,
-      configSmallModel: null,
-    });
-    // gemini-flash outranks other families; within family cheaper input wins.
+  it('scans connected providers by family priority, cheapest then newest within family', () => {
+    const result = resolveSmallModel({ catalog, configSmallModel: null });
     expect(result).toEqual({ providerID: 'google', modelID: 'gemini-2.0-flash', source: 'family-scan' });
   });
 
-  it('skips providers without a usable credential', () => {
-    const result = resolveSmallModel({
-      auth: {
-        google: { type: 'api', key: '' },
-        anthropic: { type: 'api', key: 'sk-x' },
-      },
-      catalog,
-      configSmallModel: null,
-    });
-    expect(result).toEqual({ providerID: 'anthropic', modelID: 'claude-haiku-4-5', source: 'family-scan' });
-  });
-
-  it('falls back to Copilot utility models when only Copilot is logged in', () => {
-    const result = resolveSmallModel({
-      auth: { 'github-copilot': { type: 'oauth', access: 't', refresh: 't', expires: 0 } },
-      catalog,
-      configSmallModel: null,
-    });
-    expect(result?.providerID).toBe('github-copilot');
-    expect(result?.source).toBe('copilot-utility');
-  });
-
-  it('returns null when nothing is authenticated', () => {
-    expect(resolveSmallModel({ auth: {}, catalog, configSmallModel: null })).toBeNull();
+  it('returns null when no provider is connected', () => {
+    expect(resolveSmallModel({ catalog: {}, configSmallModel: null })).toBeNull();
+    expect(resolveSmallModel({ catalog: null, configSmallModel: null })).toBeNull();
   });
 
-  it('prefers the session provider over other authenticated providers', () => {
-    const result = resolveSmallModel({
-      auth: {
-        google: { type: 'api', key: 'g-key' },
-        anthropic: { type: 'api', key: 'sk-x' },
-      },
-      catalog,
-      configSmallModel: null,
-      preferredProviderID: 'anthropic',
-    });
+  it('prefers the session provider over other connected providers', () => {
+    const result = resolveSmallModel({ catalog, configSmallModel: null, preferredProviderID: 'anthropic' });
     expect(result).toEqual({ providerID: 'anthropic', modelID: 'claude-haiku-4-5', source: 'family-scan' });
   });
 
-  it('ignores a preferred provider without a usable login', () => {
+  it('ignores a preferred provider that is not in the connected catalog', () => {
     const result = resolveSmallModel({
-      auth: { google: { type: 'api', key: 'g-key' } },
       catalog,
       configSmallModel: null,
-      preferredProviderID: 'anthropic',
+      preferredProviderID: 'mistral',
+      preferredModelID: 'mistral-large-latest',
     });
     expect(result).toEqual({ providerID: 'google', modelID: 'gemini-2.0-flash', source: 'family-scan' });
   });
 
-  it('never uses a session provider without a login (opencode free models)', () => {
-    // Vanilla setups default the picker to opencode/big-pickle with no
-    // opencode token — those free models only work through OpenCode itself
-    // and must never be called directly, so the session context is ignored.
-    const result = resolveSmallModel({
-      auth: { openai: { type: 'oauth', access: 'a', refresh: 'r', expires: Date.now() + 60_000 } },
-      catalog,
-      configSmallModel: null,
-      preferredProviderID: 'opencode',
-      preferredModelID: 'big-pickle',
-    });
-    expect(result).toEqual({ providerID: 'openai', modelID: 'gpt-5.4-mini', source: 'codex-small' });
-  });
-
-  it('resolves nothing on a vanilla setup with no logins at all', () => {
-    const result = resolveSmallModel({
-      auth: {},
-      catalog,
-      configSmallModel: null,
-      preferredProviderID: 'opencode',
-      preferredModelID: 'big-pickle',
-    });
-    expect(result).toBeNull();
-  });
-
   it('stays on the preferred provider via keyword scan instead of switching providers', () => {
     const result = resolveSmallModel({
-      auth: {
-        'opencode-go': { type: 'api', key: 'oc-key' },
-        openai: { type: 'oauth', access: 'a', refresh: 'r', expires: Date.now() + 60_000 },
-      },
       catalog: {
+        ...catalog,
         'opencode-go': {
           id: 'opencode-go',
           models: {
@@ -203,28 +118,24 @@ describe('resolveSmallModel', () => {
       preferredProviderID: 'opencode-go',
       preferredModelID: 'deepseek-v4-flash',
     });
-    // No gemini-flash/gpt-nano/claude-haiku family, but "flash" keyword matches
-    // within the preferred provider — never silently switch to openai oauth.
     expect(result).toEqual({ providerID: 'opencode-go', modelID: 'deepseek-v4-flash', source: 'keyword-scan' });
   });
 
-  it('falls back to the session model itself when nothing resolves', () => {
+  it('falls back to the session model when its connected provider has no small model', () => {
     const result = resolveSmallModel({
-      auth: { mistral: { type: 'api', key: 'm-key' } },
-      catalog,
+      catalog: {
+        ...catalog,
+        openai: { id: 'openai', models: { 'gpt-5.5': { id: 'gpt-5.5', release_date: '2026-01-01' } } },
+      },
       configSmallModel: null,
-      preferredProviderID: 'mistral',
-      preferredModelID: 'mistral-large-latest',
+      preferredProviderID: 'openai',
+      preferredModelID: 'gpt-5.5',
     });
-    expect(result).toEqual({ providerID: 'mistral', modelID: 'mistral-large-latest', source: 'session-model' });
+    expect(result).toEqual({ providerID: 'openai', modelID: 'gpt-5.5', source: 'session-model' });
   });
 
   it('picks keyword+cheapest catalog models when no family match exists', () => {
     const result = resolveSmallModel({
-      auth: {
-        codebuddy: { type: 'api', key: 'cb-key' },
-        deepseek: { type: 'api', key: 'ds-key' },
-      },
       catalog: {
         codebuddy: {
           id: 'codebuddy',
@@ -243,7 +154,6 @@ describe('resolveSmallModel', () => {
       },
       configSmallModel: null,
     });
-    // mini outranks lite/chat; within mini cheaper input would win (only one mini).
     expect(result).toEqual({ providerID: 'codebuddy', modelID: 'codebuddy-mini', source: 'keyword-scan' });
   });
 

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

@@ -1,7 +1,7 @@
 export function registerSmallModelRoutes(app, { getSmallModelService }) {
   app.get('/api/small-model', async (req, res) => {
     try {
-      const { describeSmallModel, listCallableProviders, listCallableModels } = await getSmallModelService();
+      const { describeSmallModel } = await getSmallModelService();
       const directory = typeof req.query.directory === 'string' ? req.query.directory : undefined;
       const resolved = await describeSmallModel({
         directory,
@@ -11,8 +11,6 @@ export function registerSmallModelRoutes(app, { getSmallModelService }) {
       res.json({
         available: Boolean(resolved),
         model: resolved,
-        authenticatedProviders: await listCallableProviders({ directory }),
-        callableModels: await listCallableModels({ directory }),
       });
     } catch (error) {
       console.error('Failed to resolve small model:', error);