@openchambery/web 1.19.22-beta.1 → 2.0.0-beta.3

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

@@ -1,41 +1,14 @@
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OpenCode } from '@opencode/client';
 
 // Directory-scoped OpenCode provider catalog for small-model resolution.
-// Never contacts models.dev — source of truth is client.config.providers().
-// On OpenCode failure the loader returns an explicit minimal fallback catalog
-// (not an authoritative empty map) so hardcoded candidates still resolve.
+// Never contacts models.dev — source of truth is provider.list + model.list,
+// the same connected catalog the LLM gateway checks before generating.
+// ModelInfo.id is the external model id; ModelInfo.modelID is internal.
+// OpenCode failure is an explicit error, never a substitute catalog.
 
 const CATALOG_TTL_MS = 30_000;
 const CATALOG_TIMEOUT_MS = 8_000;
 
-// Minimal catalog when OpenCode is unreachable. OpenAI OAuth and Copilot use
-// fixed utility models outside the catalog; Google/Anthropic need family
-// entries so the family-priority scan can still pick a small model.
-const MINIMAL_FALLBACK_CATALOG = Object.freeze({
-  google: Object.freeze({
-    id: 'google',
-    name: 'Google',
-    models: Object.freeze({
-      'gemini-2.5-flash': Object.freeze({
-        id: 'gemini-2.5-flash',
-        family: 'gemini-flash',
-        release_date: '2025-06-01',
-      }),
-    }),
-  }),
-  anthropic: Object.freeze({
-    id: 'anthropic',
-    name: 'Anthropic',
-    models: Object.freeze({
-      'claude-haiku-4-5': Object.freeze({
-        id: 'claude-haiku-4-5',
-        family: 'claude-haiku',
-        release_date: '2025-10-01',
-      }),
-    }),
-  }),
-});
-
 const normalizeDirectoryKey = (directory) => {
   if (typeof directory !== 'string') return '';
   const trimmed = directory.trim();
@@ -46,6 +19,67 @@ const normalizeDirectoryKey = (directory) => {
 
 const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 
+// v2 ModelInfo.cost is a tier array. Ranking still reads cost.input / cost.output.
+const projectCatalogCost = (cost) => {
+  const entry = Array.isArray(cost)
+    ? (cost.find((item) => isRecord(item) && !isRecord(item.tier)) || cost.find((item) => isRecord(item)))
+    : (isRecord(cost) ? cost : null);
+  if (!isRecord(entry)) return undefined;
+  const projected = Object.create(null);
+  if (Number.isFinite(entry.input)) projected.input = entry.input;
+  if (Number.isFinite(entry.output)) projected.output = entry.output;
+  return Object.keys(projected).length > 0 ? projected : undefined;
+};
+
+// Compose official v2 provider.list + model.list into the SDK catalog shape
+// consumed by toSmallModelCatalog. Missing arrays are failure, not empty success.
+const composeV2ProviderCatalogSource = (providers, models) => {
+  if (!Array.isArray(providers) || !Array.isArray(models)) return null;
+
+  const modelsByProvider = new Map();
+  for (const model of models) {
+    if (!isRecord(model)) continue;
+    const providerID = typeof model.providerID === 'string' ? model.providerID : '';
+    // ModelInfo.id is the external model id used in generate/session refs.
+    // ModelInfo.modelID is a separate internal field and must not be preferred.
+    const modelID = typeof model.id === 'string' && model.id
+      ? model.id
+      : (typeof model.modelID === 'string' ? model.modelID : '');
+    if (!providerID || !modelID) continue;
+    if (!modelsByProvider.has(providerID)) modelsByProvider.set(providerID, Object.create(null));
+    const entry = { id: modelID };
+    if (typeof model.family === 'string' && model.family) entry.family = model.family;
+    if (isRecord(model.limit)) {
+      const limit = Object.create(null);
+      if (Number.isFinite(model.limit.context)) limit.context = model.limit.context;
+      if (Number.isFinite(model.limit.output)) limit.output = model.limit.output;
+      if (Object.keys(limit).length > 0) entry.limit = limit;
+    }
+    const cost = projectCatalogCost(model.cost);
+    if (cost) entry.cost = cost;
+    if (isRecord(model.api) && typeof model.api.url === 'string' && model.api.url.trim()) {
+      entry.api = { url: model.api.url.trim() };
+    }
+    if (typeof model.time?.released === 'number' && Number.isFinite(model.time.released)) {
+      entry.release_date = new Date(model.time.released).toISOString().slice(0, 10);
+    } else if (typeof model.release_date === 'string' && model.release_date) {
+      entry.release_date = model.release_date;
+    }
+    modelsByProvider.get(providerID)[modelID] = entry;
+  }
+
+  const catalogProviders = [];
+  for (const provider of providers) {
+    if (!isRecord(provider) || typeof provider.id !== 'string' || !provider.id) continue;
+    catalogProviders.push({
+      id: provider.id,
+      name: typeof provider.name === 'string' && provider.name ? provider.name : provider.id,
+      models: modelsByProvider.get(provider.id) || Object.create(null),
+    });
+  }
+  return { providers: catalogProviders };
+};
+
 /**
  * Convert the official SDK provider list into the internal small-model catalog
  * shape. Keeps family / release_date / limit / cost.input|output /
@@ -121,22 +155,27 @@ export function createModelCatalogLoader({
   timeoutMs = CATALOG_TIMEOUT_MS,
   fetchImpl = globalThis.fetch.bind(globalThis),
 }) {
-  /** @type {Map<string, { catalog: object, cachedAt: number, source: string, inflight: Promise<object> | null }>} */
+  /** @type {Map<string, { catalog: object | null, cachedAt: number, inflight: Promise<object> | null }>} */
   const buckets = new Map();
 
   const fetchOpenCodeCatalog = async (directory) => {
     const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
-    const client = createOpencodeClient({
+    const client = OpenCode.make({
       baseUrl,
-      ...(directory ? { directory } : {}),
       headers: getOpenCodeAuthHeaders(),
-      fetch: (request) => fetchImpl(request, { signal: AbortSignal.timeout(timeoutMs) }),
+      fetch: (request, init) => fetchImpl(request, { ...init, signal: AbortSignal.timeout(timeoutMs) }),
     });
-    const response = await client.config.providers(directory ? { directory } : {});
-    if (response?.error || response?.data === undefined) {
+    const location = directory ? { directory } : undefined;
+    const request = location ? { location } : undefined;
+    const [providersResult, modelsResult] = await Promise.all([
+      client.provider.list(request),
+      client.model.list(request),
+    ]);
+    const source = composeV2ProviderCatalogSource(providersResult?.data, modelsResult?.data);
+    if (!source) {
       throw new Error('OpenCode provider catalog is unavailable');
     }
-    const catalog = toSmallModelCatalog(response.data);
+    const catalog = toSmallModelCatalog(source);
     if (!catalog) {
       throw new Error('OpenCode provider catalog returned an unexpected payload');
     }
@@ -144,8 +183,8 @@ export function createModelCatalogLoader({
   };
 
   /**
-   * Load (or serve cached) directory-scoped catalog.
-   * OpenCode failure → explicit minimal fallback (never an authoritative empty map).
+   * Load (or serve cached) directory-scoped catalog. Failures are not cached
+   * and reject with statusCode 502 so callers never resolve against a guess.
    */
   const getModelCatalog = async (directory) => {
     const key = normalizeDirectoryKey(directory);
@@ -156,7 +195,7 @@ export function createModelCatalogLoader({
     }
 
     if (!bucket) {
-      bucket = { catalog: null, cachedAt: 0, source: 'none', inflight: null };
+      bucket = { catalog: null, cachedAt: 0, inflight: null };
       buckets.set(key, bucket);
     }
 
@@ -166,18 +205,12 @@ export function createModelCatalogLoader({
           const catalog = await fetchOpenCodeCatalog(key || undefined);
           bucket.catalog = catalog;
           bucket.cachedAt = Date.now();
-          bucket.source = 'opencode';
           return catalog;
         } catch (error) {
-          // Explicit failure path: minimal hardcoded candidates only.
-          console.warn(
-            '[small-model] OpenCode provider catalog failed; using minimal fallback:',
-            error?.message || error,
+          throw Object.assign(
+            new Error(`OpenCode provider catalog is unavailable (${error?.message || error})`),
+            { statusCode: 502 },
           );
-          bucket.catalog = MINIMAL_FALLBACK_CATALOG;
-          bucket.cachedAt = Date.now();
-          bucket.source = 'fallback';
-          return MINIMAL_FALLBACK_CATALOG;
         } finally {
           bucket.inflight = null;
         }
@@ -192,8 +225,5 @@ export function createModelCatalogLoader({
     getCatalogProvider,
     /** @internal test helpers */
     _normalizeDirectoryKey: normalizeDirectoryKey,
-    _minimalFallbackCatalog: MINIMAL_FALLBACK_CATALOG,
   };
 }
-
-export { MINIMAL_FALLBACK_CATALOG };

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { createModelCatalogLoader, toSmallModelCatalog, MINIMAL_FALLBACK_CATALOG } from './catalog.js';
+import { createModelCatalogLoader, toSmallModelCatalog } from './catalog.js';
 
 describe('toSmallModelCatalog', () => {
   it('keeps family, release_date, limit, cost, model.api.url, and provider name', () => {
@@ -45,13 +45,15 @@ describe('toSmallModelCatalog', () => {
 });
 
 describe('createModelCatalogLoader', () => {
-  it('uses explicit minimal fallback when OpenCode is unreachable (not empty catalog)', async () => {
+  it('rejects with 502 when OpenCode is unreachable and does not cache the failure', async () => {
+    let calls = 0;
     const loader = createModelCatalogLoader({
       buildOpenCodeUrl: () => 'http://127.0.0.1:9/',
       getOpenCodeAuthHeaders: () => ({}),
       ttlMs: 30_000,
       timeoutMs: 50,
       fetchImpl: async () => {
+        calls += 1;
         throw new Error('network down');
       },
     });
@@ -59,13 +61,113 @@ describe('createModelCatalogLoader', () => {
     const a = loader.getModelCatalog('/proj');
     const b = loader.getModelCatalog('/proj/');
     // Single-flight + directory key normalization: same bucket for trailing slash.
-    const [catalogA, catalogB] = await Promise.all([a, b]);
-    expect(catalogA).toBe(MINIMAL_FALLBACK_CATALOG);
-    expect(catalogB).toBe(MINIMAL_FALLBACK_CATALOG);
-    expect(catalogA.google?.models?.['gemini-2.5-flash']?.family).toBe('gemini-flash');
-    expect(catalogA.anthropic?.models?.['claude-haiku-4-5']?.family).toBe('claude-haiku');
-    // Must not masquerade as authoritative empty success.
-    expect(Object.keys(catalogA).length).toBeGreaterThan(0);
+    const results = await Promise.allSettled([a, b]);
+    for (const result of results) {
+      expect(result.status).toBe('rejected');
+      expect(result.reason.statusCode).toBe(502);
+      expect(result.reason.message).toMatch(/provider catalog is unavailable/);
+    }
+    const callsAfterFirst = calls;
+    await expect(loader.getModelCatalog('/proj')).rejects.toMatchObject({ statusCode: 502 });
+    expect(calls).toBeGreaterThan(callsAfterFirst);
+  });
+
+  it('forwards OpenCode auth headers through the fetch wrapper', async () => {
+    const seen = [];
+    const loader = createModelCatalogLoader({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096/',
+      getOpenCodeAuthHeaders: () => ({ Authorization: 'Basic test' }),
+      fetchImpl: async (url, init) => {
+        seen.push(new Headers(init?.headers).get('authorization'));
+        return new Response(JSON.stringify({ data: [] }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        });
+      },
+    });
+
+    await loader.getModelCatalog('/proj');
+    expect(seen.length).toBeGreaterThan(0);
+    expect(seen.every((value) => value === 'Basic test')).toBe(true);
+  });
+
+  it('composes official v2 provider.list + model.list into the small-model catalog', async () => {
+    const loader = createModelCatalogLoader({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096/',
+      getOpenCodeAuthHeaders: () => ({ Authorization: 'Basic test' }),
+      fetchImpl: async (url) => {
+        const href = String(url);
+        const data = href.includes('/api/model')
+          ? [{
+              id: 'gemini-2.5-flash',
+              modelID: 'gemini-2.5-flash',
+              providerID: 'google',
+              family: 'gemini-flash',
+              name: 'Gemini 2.5 Flash',
+              capabilities: {},
+              variants: [],
+              time: { released: Date.parse('2025-06-01T00:00:00Z') },
+              cost: [],
+              status: 'active',
+              enabled: true,
+              limit: { context: 1_000_000, output: 8192 },
+              api: { url: 'https://generativelanguage.googleapis.com' },
+            }]
+          : [{ id: 'google', name: 'Google', package: '@ai-sdk/google' }];
+        return new Response(JSON.stringify({
+          location: { directory: '/proj', project: { id: 'p', directory: '/proj', canonical: '/proj' } },
+          data,
+        }), { status: 200, headers: { 'content-type': 'application/json' } });
+      },
+    });
+
+    const catalog = await loader.getModelCatalog('/proj');
+    expect(catalog.google).toEqual({
+      id: 'google',
+      name: 'Google',
+      models: {
+        'gemini-2.5-flash': {
+          id: 'gemini-2.5-flash',
+          family: 'gemini-flash',
+          release_date: '2025-06-01',
+          limit: { context: 1_000_000, output: 8192 },
+          api: { url: 'https://generativelanguage.googleapis.com' },
+        },
+      },
+    });
+  });
+
+  it('keys models by ModelInfo.id and keeps the base tier of array cost', async () => {
+    const loader = createModelCatalogLoader({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096/',
+      getOpenCodeAuthHeaders: () => ({}),
+      fetchImpl: async (url) => {
+        const href = String(url);
+        const data = href.includes('/api/model')
+          ? [{
+              id: 'gpt-5.4-mini',
+              modelID: 'internal-pack',
+              providerID: 'openai',
+              name: 'GPT-5.4 Mini',
+              cost: [
+                { tier: { type: 'context', size: 200000 }, input: 9, output: 9 },
+                { input: 1, output: 2 },
+              ],
+            }]
+          : [{ id: 'openai', name: 'OpenAI', package: '@ai-sdk/openai' }];
+        return new Response(JSON.stringify({ data }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        });
+      },
+    });
+
+    const catalog = await loader.getModelCatalog('/proj');
+    expect(catalog.openai?.models?.['gpt-5.4-mini']).toEqual({
+      id: 'gpt-5.4-mini',
+      cost: { input: 1, output: 2 },
+    });
+    expect(catalog.openai?.models?.['internal-pack']).toBeUndefined();
   });
 
   it('normalizes directory keys so trailing slashes share a bucket', () => {

package/server/lib/small-model/custom-api.js

@@ -1,5 +1,9 @@
 const TEST_TIMEOUT_MS = 15_000;
 const MODELS_TIMEOUT_MS = 8_000;
+const GENERATE_TIMEOUT_MS = 60_000;
+// Generous default: thinking models that can't be switched off spend part of
+// this budget on reasoning before the actual answer.
+const DEFAULT_MAX_OUTPUT_TOKENS = 4_000;
 
 const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 
@@ -96,6 +100,70 @@ export async function testCustomSummaryApi({
   }
 }
 
+/**
+ * Summary AI custom mode: one non-streaming chat completion against the
+ * user's own OpenAI-compatible endpoint. The token never leaves this process.
+ */
+export async function generateCustomSummaryText({
+  baseURL,
+  apiToken,
+  modelID,
+  prompt,
+  system,
+  maxOutputTokens,
+  fetchImpl = globalThis.fetch.bind(globalThis),
+}) {
+  const parsedBaseURL = parseCustomApiBaseURL(baseURL);
+  if (!parsedBaseURL) {
+    throw Object.assign(new Error('Custom summary API Base URL is invalid'), { statusCode: 400 });
+  }
+  const response = await fetchImpl(`${parsedBaseURL}/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+      Authorization: `Bearer ${apiToken}`,
+    },
+    body: JSON.stringify({
+      model: modelID,
+      messages: [
+        ...(system ? [{ role: 'system', content: system }] : []),
+        { role: 'user', content: prompt },
+      ],
+      max_tokens: Number(maxOutputTokens) > 0 ? Number(maxOutputTokens) : DEFAULT_MAX_OUTPUT_TOKENS,
+      stream: false,
+    }),
+    signal: AbortSignal.timeout(GENERATE_TIMEOUT_MS),
+  });
+  const bodyText = await response.text().catch(() => '');
+  if (!response.ok) {
+    const snippet = bodyText ? `: ${bodyText.slice(0, 300)}` : '';
+    throw new Error(`Custom summary API request failed with ${response.status}${snippet}`);
+  }
+  const payload = parseJson(bodyText);
+  const message = payload?.choices?.[0]?.message;
+  // Providers disagree on the content shape: plain string, an array of typed
+  // parts, or (thinking models) empty content with the budget spent on
+  // reasoning_content.
+  let text = '';
+  if (typeof message?.content === 'string') {
+    text = message.content;
+  } else if (Array.isArray(message?.content)) {
+    text = message.content.map((part) => (typeof part?.text === 'string' ? part.text : '')).join('');
+  }
+  if (!text.trim() && typeof message?.reasoning_content === 'string' && message.reasoning_content.trim()) {
+    const finishReason = payload?.choices?.[0]?.finish_reason;
+    throw new Error(
+      'Custom summary API spent the output budget on reasoning and returned no answer'
+      + (finishReason ? ` (finish_reason: ${finishReason})` : ''),
+    );
+  }
+  if (!text.trim()) {
+    throw new Error('Custom summary API returned no message content');
+  }
+  return text;
+}
+
 export async function listCustomSummaryModels({
   baseURL,
   apiToken,

package/server/lib/small-model/custom-api.test.js

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 import {
   classifyCustomSummaryApiFailure,
+  generateCustomSummaryText,
   listCustomSummaryModels,
   parseCustomApiBaseURL,
   testCustomSummaryApi,
@@ -99,3 +100,66 @@ describe('listCustomSummaryModels', () => {
     })).toEqual([]);
   });
 });
+
+describe('generateCustomSummaryText', () => {
+  const completion = (message, extra = {}) => new Response(JSON.stringify({
+    choices: [{ message, ...extra }],
+  }), { status: 200, headers: { 'content-type': 'application/json' } });
+
+  it('posts an OpenAI-compatible chat completion and returns the text', async () => {
+    const fetchImpl = vi.fn(async () => completion({ role: 'assistant', content: 'feat: add retries' }));
+    const text = await generateCustomSummaryText({
+      baseURL: 'https://summary.example.test/v1/',
+      apiToken: 'token',
+      modelID: 'summary-model',
+      prompt: 'Diff',
+      system: 'Return a commit subject.',
+      maxOutputTokens: 64,
+      fetchImpl,
+    });
+    expect(text).toBe('feat: add retries');
+    const [url, init] = fetchImpl.mock.calls[0];
+    expect(url).toBe('https://summary.example.test/v1/chat/completions');
+    expect(init.method).toBe('POST');
+    expect(JSON.parse(init.body)).toEqual({
+      model: 'summary-model',
+      messages: [
+        { role: 'system', content: 'Return a commit subject.' },
+        { role: 'user', content: 'Diff' },
+      ],
+      max_tokens: 64,
+      stream: false,
+    });
+  });
+
+  it('joins array content parts', async () => {
+    const fetchImpl = vi.fn(async () => completion({ content: [{ type: 'text', text: 'a' }, { type: 'text', text: 'b' }] }));
+    await expect(generateCustomSummaryText({
+      baseURL: 'https://summary.example.test/v1', apiToken: 't', modelID: 'm', prompt: 'p', fetchImpl,
+    })).resolves.toBe('ab');
+  });
+
+  it('rejects invalid base URLs before any request', async () => {
+    const fetchImpl = vi.fn();
+    await expect(generateCustomSummaryText({
+      baseURL: 'ftp://nope', apiToken: 't', modelID: 'm', prompt: 'p', fetchImpl,
+    })).rejects.toMatchObject({ statusCode: 400 });
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it('surfaces HTTP failures, reasoning-only replies, and empty content as errors', async () => {
+    const input = { baseURL: 'https://summary.example.test/v1', apiToken: 't', modelID: 'm', prompt: 'p' };
+    await expect(generateCustomSummaryText({
+      ...input,
+      fetchImpl: async () => new Response('rate limited', { status: 429 }),
+    })).rejects.toThrow(/failed with 429/);
+    await expect(generateCustomSummaryText({
+      ...input,
+      fetchImpl: async () => completion({ content: '', reasoning_content: 'thinking…' }, { finish_reason: 'length' }),
+    })).rejects.toThrow(/reasoning.*finish_reason: length/);
+    await expect(generateCustomSummaryText({
+      ...input,
+      fetchImpl: async () => completion({ content: '' }),
+    })).rejects.toThrow(/no message content/);
+  });
+});