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

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

@@ -1,41 +1,14 @@
 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,18 @@ 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) => {
@@ -55,9 +40,11 @@ const composeV2ProviderCatalogSource = (providers, models) => {
   for (const model of models) {
     if (!isRecord(model)) continue;
     const providerID = typeof model.providerID === 'string' ? model.providerID : '';
-    const modelID = typeof model.modelID === 'string' && model.modelID
-      ? model.modelID
-      : (typeof model.id === 'string' ? model.id : '');
+    // 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 };
@@ -68,6 +55,8 @@ const composeV2ProviderCatalogSource = (providers, models) => {
       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() };
     }
@@ -166,7 +155,7 @@ 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) => {
@@ -174,7 +163,7 @@ export function createModelCatalogLoader({
     const client = OpenCode.make({
       baseUrl,
       headers: getOpenCodeAuthHeaders(),
-      fetch: (request) => fetchImpl(request, { signal: AbortSignal.timeout(timeoutMs) }),
+      fetch: (request, init) => fetchImpl(request, { ...init, signal: AbortSignal.timeout(timeoutMs) }),
     });
     const location = directory ? { directory } : undefined;
     const request = location ? { location } : undefined;
@@ -194,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);
@@ -206,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);
     }
 
@@ -216,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;
         }
@@ -242,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,34 @@ 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 () => {
@@ -99,7 +122,6 @@ describe('createModelCatalogLoader', () => {
     });
 
     const catalog = await loader.getModelCatalog('/proj');
-    expect(catalog).not.toBe(MINIMAL_FALLBACK_CATALOG);
     expect(catalog.google).toEqual({
       id: 'google',
       name: 'Google',
@@ -115,6 +137,39 @@ describe('createModelCatalogLoader', () => {
     });
   });
 
+  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', () => {
     const loader = createModelCatalogLoader({
       buildOpenCodeUrl: () => 'http://127.0.0.1:9/',

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/);
+  });
+});