ldrouter 1.16.2 → 1.16.4

package/dist/server/routes/admin/models.js

@@ -14,11 +14,24 @@ const ModelUpdate = z.object({
     displayName: z.string().min(1).max(128).optional(),
     enabled: z.boolean().optional(),
     upstreamAvailable: z.boolean().optional(),
-    capabilities: z.record(z.any()).optional(),
+    // Values may be true / false / null. null clears the key back to "unknown",
+    // which the router treats as "not verified" rather than "unsupported".
+    capabilities: z.record(z.union([z.boolean(), z.null()])).optional(),
     cacheOverrideEnabled: z.boolean().nullable().optional(),
     maxContextTokens: z.number().int().min(1).nullable().optional(),
     maxOutputTokens: z.number().int().min(1).nullable().optional(),
 });
+/** Apply an admin capability override. `null` removes the key (= unknown). */
+function applyCapabilityOverrides(stored, patch) {
+    const out = { ...stored };
+    for (const [k, v] of Object.entries(patch)) {
+        if (v === null)
+            delete out[k];
+        else
+            out[k] = v;
+    }
+    return out;
+}
 export async function registerModelRoutes(app) {
     app.addHook('preHandler', requireAdminAuth);
     app.get('/api/admin/models', async (req) => {
@@ -54,6 +67,7 @@ export async function registerModelRoutes(app) {
             enabled: m.enabled,
             upstreamAvailable: m.upstreamAvailable,
             capabilities: safeJson(m.capabilitiesJson),
+            discoveredCapabilities: m.discoveredMetadataJson ? safeJson(m.discoveredMetadataJson) : null,
             maxContextTokens: m.maxContextTokens,
             maxOutputTokens: m.maxOutputTokens,
             lastSeenUpstreamAt: m.lastSeenUpstreamAt,
@@ -69,7 +83,7 @@ export async function registerModelRoutes(app) {
             throw new GatewayError('invalid_request_error', 'Provider not found', { status: 404 });
         // Fetch discovered model metadata fresh (so import uses current discovery data)
         // For simplicity: re-discover and match by upstream id.
-        const { discoverProviderModels } = await import('../../providers/index.js');
+        const { discoverProviderModels, mergeDiscoveredCapabilities } = await import('../../providers/index.js');
         const { decryptSecret, decryptCustomHeaders } = await import('../../auth/crypto.js');
         const { codexModels } = await import('../../providers/codex.js');
         const { getCodexAccountById, listCodexAccountSummaries } = await import('../../db/repositories/codex-accounts.js');
@@ -105,7 +119,19 @@ export async function registerModelRoutes(app) {
             const disc = discMap.get(upstreamId);
             const caps = disc?.capabilities ?? { chat: true, streaming: true, tools: true };
             if (existing) {
-                db.update(schema.models).set({ upstreamAvailable: true, lastSeenUpstreamAt: now, updatedAt: now }).where(eq(schema.models.id, existing.id)).run();
+                // Refresh capabilities so stale discoveries (e.g. a wrong
+                // `image_input: false`) heal on re-import, while admin edits survive.
+                const merged = mergeDiscoveredCapabilities(safeJson(existing.capabilitiesJson), existing.discoveredMetadataJson ? safeJson(existing.discoveredMetadataJson) : null, caps);
+                db.update(schema.models)
+                    .set({
+                    upstreamAvailable: true,
+                    lastSeenUpstreamAt: now,
+                    updatedAt: now,
+                    capabilitiesJson: JSON.stringify(merged.capabilities),
+                    discoveredMetadataJson: JSON.stringify(merged.baseline),
+                })
+                    .where(eq(schema.models.id, existing.id))
+                    .run();
                 continue;
             }
             const publicModelId = `${provider.slug}/${upstreamId}`;
@@ -118,6 +144,7 @@ export async function registerModelRoutes(app) {
                 enabled: true,
                 upstreamAvailable: true,
                 capabilitiesJson: JSON.stringify(caps),
+                discoveredMetadataJson: JSON.stringify(caps),
                 maxContextTokens: typeof caps.max_context_tokens === 'number' ? caps.max_context_tokens : null,
                 maxOutputTokens: typeof caps.max_output_tokens === 'number' ? caps.max_output_tokens : null,
                 lastSeenUpstreamAt: now,
@@ -141,7 +168,7 @@ export async function registerModelRoutes(app) {
         if (body.upstreamAvailable !== undefined)
             update.upstreamAvailable = body.upstreamAvailable;
         if (body.capabilities) {
-            const merged = { ...safeJson(m.capabilitiesJson), ...body.capabilities };
+            const merged = applyCapabilityOverrides(safeJson(m.capabilitiesJson), body.capabilities);
             update.capabilitiesJson = JSON.stringify(merged);
             if (typeof merged.max_context_tokens === 'number')
                 update.maxContextTokens = merged.max_context_tokens;

package/dist/server/routes/gateway/anthropic.js

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { authenticateGatewayKey } from '../../auth/api-key.js';
 import { resolveClientIp } from '../../util/client-ip.js';
 import { anthropicToCanonical } from '../../protocols/anthropic.js';
-import { GatewayError, toAnthropicError } from '../../errors.js';
+import { GatewayError, toAnthropicError, outcomeError } from '../../errors.js';
 import { GatewayRunner } from '../../gateway/runner.js';
 import { uuid } from '../../auth/ids.js';
 import { lifecycle, debugHttp, debugBody, getDebugFlags, summarizeMessages, summarizeTools, summarizeHeaders, sanitizeJson, truncate } from '../../logging/debug.js';
@@ -58,7 +58,7 @@ export async function registerAnthropicRoutes(app) {
                     return reply;
                 }
                 if (!outcome.success) {
-                    const g = new GatewayError(outcome.errorType ?? 'gateway_error', outcome.errorMessage ?? 'Gateway error', { status: outcome.httpStatus });
+                    const g = outcomeError(outcome);
                     reply.code(outcome.httpStatus).send(toAnthropicError(g, ctx.requestId));
                     return;
                 }
@@ -66,7 +66,7 @@ export async function registerAnthropicRoutes(app) {
                 return;
             }
             if (!outcome.success) {
-                const g = new GatewayError(outcome.errorType ?? 'gateway_error', outcome.errorMessage ?? 'Gateway error', { status: outcome.httpStatus });
+                const g = outcomeError(outcome);
                 lifecycle(requestId, 'DONE', [`status=${outcome.httpStatus} durationMs=${outcome.latencyMs} error=true type=${g.type}`]);
                 reply.code(outcome.httpStatus).send(toAnthropicError(g, ctx.requestId));
                 return;

package/dist/server/routes/gateway/openai.js

@@ -5,7 +5,7 @@ import { getDb, schema } from '../../db/index.js';
 import { authenticateGatewayKey } from '../../auth/api-key.js';
 import { resolveClientIp } from '../../util/client-ip.js';
 import { openAIToCanonical, openAIModelList } from '../../protocols/canonical.js';
-import { GatewayError, toOpenAIError } from '../../errors.js';
+import { GatewayError, toOpenAIError, outcomeError } from '../../errors.js';
 import { GatewayRunner } from '../../gateway/runner.js';
 import { uuid } from '../../auth/ids.js';
 import { lifecycle, debugHttp, debugBody, getDebugFlags, summarizeBody, summarizeMessages, summarizeTools, summarizeHeaders, sanitizeJson, truncate } from '../../logging/debug.js';
@@ -86,7 +86,7 @@ export async function registerOpenAIRoutes(app) {
                 // the client should get a regular protocol error instead of a dangling
                 // stream.
                 if (!outcome.success) {
-                    const g = new GatewayError(outcome.errorType ?? 'gateway_error', outcome.errorMessage ?? 'Gateway error', { status: outcome.httpStatus });
+                    const g = outcomeError(outcome);
                     reply.code(outcome.httpStatus).send(toOpenAIError(g, ctx.requestId));
                     return;
                 }
@@ -95,7 +95,7 @@ export async function registerOpenAIRoutes(app) {
                 return;
             }
             if (!outcome.success) {
-                const g = new GatewayError(outcome.errorType ?? 'gateway_error', outcome.errorMessage ?? 'Gateway error', { status: outcome.httpStatus });
+                const g = outcomeError(outcome);
                 lifecycle(requestId, 'DONE', [`status=${outcome.httpStatus} durationMs=${outcome.latencyMs} error=true type=${g.type}`]);
                 reply.code(outcome.httpStatus).send(toOpenAIError(g, ctx.requestId));
                 return;
@@ -176,7 +176,7 @@ export async function registerOpenAIRoutes(app) {
                     return reply;
                 }
                 if (!outcome.success) {
-                    const g = new GatewayError(outcome.errorType ?? 'gateway_error', outcome.errorMessage ?? 'Gateway error', { status: outcome.httpStatus });
+                    const g = outcomeError(outcome);
                     reply.code(outcome.httpStatus).send(toOpenAIError(g, ctx.requestId));
                     return;
                 }
@@ -184,7 +184,7 @@ export async function registerOpenAIRoutes(app) {
                 return;
             }
             if (!outcome.success) {
-                const g = new GatewayError(outcome.errorType ?? 'gateway_error', outcome.errorMessage ?? 'Gateway error', { status: outcome.httpStatus });
+                const g = outcomeError(outcome);
                 reply.code(outcome.httpStatus).send(toOpenAIError(g, ctx.requestId));
                 return;
             }

package/dist/server/routing/capabilities.js

@@ -33,6 +33,36 @@ export function deriveRequiredCapabilities(req) {
         responses: false,
     };
 }
+/**
+ * The single table of "explicitly unsupported" checks. `modelMeets` and the
+ * rejection reporter both read it, so they can never disagree about a model.
+ * `reasoning` is deliberately absent: it is advisory metadata, because an
+ * upstream may support reasoning even when discovery cannot identify it.
+ */
+const CAPABILITY_CHECKS = [
+    { flag: 'streaming', required: 'streaming', reason: 'streaming', label: 'no streaming' },
+    { flag: 'tools', required: 'tools', reason: 'tools', label: 'no tool calling' },
+    { flag: 'structured_output', required: 'structuredOutput', reason: 'structured_output', label: 'no structured output' },
+    { flag: 'image_input', required: 'imageInput', reason: 'image_input', label: 'no image input' },
+    { flag: 'audio_input', required: 'audioInput', reason: 'audio_input', label: 'no audio input' },
+    { flag: 'responses', required: 'responses', reason: 'responses', label: 'no Responses API support' },
+];
+const NON_CAPABILITY_TEXT = {
+    model_not_found: 'model not found',
+    provider_not_found: 'provider not found',
+    provider_disabled: 'provider disabled',
+    model_disabled: 'model disabled',
+    upstream_unavailable: 'not available upstream',
+    circuit_open: 'provider circuit is open',
+    combo_disabled: 'combo disabled',
+    member_disabled: 'disabled in this combo',
+    codex_account_unavailable: 'no available Codex account',
+};
+const REASON_TEXT = {
+    ...NON_CAPABILITY_TEXT,
+    ...Object.fromEntries(CAPABILITY_CHECKS.map((c) => [c.reason, c.label])),
+};
+const CAPABILITY_REASONS = new Set(CAPABILITY_CHECKS.map((c) => c.reason));
 /**
  * Check if a model meets required capabilities.
  * IMPORTANT: Treat undefined as "unknown" rather than "unsupported".
@@ -43,18 +73,48 @@ export function deriveRequiredCapabilities(req) {
  * upstream may support it even when discovery cannot identify it.
  */
 export function modelMeets(caps, req) {
-    // Only reject if capability is explicitly false, not if unknown (undefined)
-    if (req.streaming && caps.streaming === false)
-        return false;
-    if (req.tools && caps.tools === false)
-        return false;
-    if (req.structuredOutput && caps.structured_output === false)
-        return false;
-    if (req.imageInput && caps.image_input === false)
-        return false;
-    if (req.audioInput && caps.audio_input === false)
-        return false;
-    if (req.responses && caps.responses === false)
-        return false;
-    return true;
+    return firstMissingCapability(caps, req) === null;
+}
+/** The first capability this model is KNOWN not to support (undefined = unknown
+ *  caps never reject), or null when nothing required is explicitly missing. */
+export function firstMissingCapability(caps, req) {
+    for (const c of CAPABILITY_CHECKS) {
+        if (req[c.required] && caps[c.flag] === false)
+            return c.reason;
+    }
+    return null;
+}
+/**
+ * `vl/gpt-5.5` is reported to clients as `gpt-5.5`: the provider prefix is the
+ * gateway's bookkeeping, not the operator's or the API client's vocabulary.
+ */
+export function bareModelName(publicModelId) {
+    const i = publicModelId.indexOf('/');
+    return i === -1 ? publicModelId : publicModelId.slice(i + 1);
+}
+/**
+ * Turn per-model rejection reasons into one client-facing error that names every
+ * excluded model and why. The old blanket strings ("No combo member satisfies
+ * the request capabilities or availability", "No available model candidates")
+ * told the caller nothing it could act on — docs/13 §10 records that as a bug.
+ *
+ * A capability miss is deterministic, so it wins the status code (400); reasons
+ * of mere *availability* are still listed so nothing is hidden. When no
+ * capability was involved the targetis simply unavailable (502).
+ */
+export function describeRejections(target, rejected) {
+    const groups = new Map();
+    for (const r of rejected) {
+        const label = REASON_TEXT[r.reason] ?? r.reason;
+        groups.set(label, [...(groups.get(label) ?? []), bareModelName(r.publicModelId)]);
+    }
+    // A direct model is also the target, so naming it twice would only be noise.
+    const detail = target.kind === 'model'
+        ? [...groups.keys()].join('; ')
+        : [...groups].map(([label, names]) => `${[...new Set(names)].join(', ')} (${label})`).join('; ');
+    const subject = target.kind === 'combo' ? `Combo "${target.publicModelId}"` : `Model "${bareModelName(target.publicModelId)}"`;
+    const message = `${subject} cannot serve this request: ${detail || 'no usable member'}`;
+    return rejected.some((r) => CAPABILITY_REASONS.has(r.reason))
+        ? { message, type: 'capability_not_supported', status: 400 }
+        : { message, type: 'upstream_unavailable', status: 502 };
 }

package/dist/server/routing/combo.js

@@ -1,7 +1,7 @@
 // Combo routing: fallback (ordered) or weighted round-robin.
 import { eq } from 'drizzle-orm';
 import { getDb, schema } from '../db/index.js';
-import { modelMeets } from './capabilities.js';
+import { firstMissingCapability } from './capabilities.js';
 export function loadCombo(comboId) {
     const db = getDb();
     const c = db.select().from(schema.combos).where(eq(schema.combos.id, comboId)).get();
@@ -44,6 +44,10 @@ export function selectCandidates(combo, allModels, req, onReject) {
             onReject?.({ modelId: m.modelId, publicModelId: m.modelId }, 'model_not_found');
             continue;
         }
+        if (c.providerEnabled === false) {
+            onReject?.(c, 'provider_disabled');
+            continue;
+        }
         if (!c.enabled) {
             onReject?.(c, 'model_disabled');
             continue;
@@ -56,30 +60,15 @@ export function selectCandidates(combo, allModels, req, onReject) {
             onReject?.(c, 'circuit_open');
             continue;
         }
-        if (!modelMeets(c.capabilities, req)) {
-            onReject?.(c, capabilityRejection(c.capabilities, req));
+        const missing = firstMissingCapability(c.capabilities, req);
+        if (missing) {
+            onReject?.(c, missing);
             continue;
         }
         candidates.push(c);
     }
     return candidates;
 }
-/** First capability that explicitly failed (undefined = unknown caps never reject). */
-function capabilityRejection(caps, req) {
-    if (req.streaming && caps.streaming === false)
-        return 'streaming';
-    if (req.tools && caps.tools === false)
-        return 'tools';
-    if (req.structuredOutput && caps.structured_output === false)
-        return 'structured_output';
-    if (req.imageInput && caps.image_input === false)
-        return 'image_input';
-    if (req.audioInput && caps.audio_input === false)
-        return 'audio_input';
-    if (req.responses && caps.responses === false)
-        return 'responses';
-    return 'capability_mismatch';
-}
 export function orderCandidates(combo, candidates) {
     if (combo.mode === 'fallback') {
         // Preserve declared position order

package/dist/server/routing/resolver.js

@@ -2,37 +2,42 @@
 import { eq, and } from 'drizzle-orm';
 import { getDb, schema } from '../db/index.js';
 import { GatewayError } from '../errors.js';
+/**
+ * Resolution is deliberately blind to `enabled`. A disabled model is NOT an
+ * unknown model: reporting it as `Unknown model: X` (404) sent operators hunting
+ * for a typo when the real answer was "you turned this off". The `enabled` flag
+ * travels with the target so the caller can say which it is.
+ */
 export function resolveRequestedModel(requested) {
     const db = getDb();
     // Physical model
     const model = db.select().from(schema.models).where(eq(schema.models.publicModelId, requested)).get();
-    if (model && model.enabled) {
-        return { kind: 'model', modelId: model.id, publicModelId: model.publicModelId };
-    }
+    if (model)
+        return { kind: 'model', modelId: model.id, publicModelId: model.publicModelId, enabled: model.enabled };
     // Combo by exact public ID — with-prefix ("combo/<slug>") or the
     // prefix-less default (<slug>).
     const combo = db.select().from(schema.combos).where(eq(schema.combos.publicModelId, requested)).get();
-    if (combo && combo.enabled)
-        return { kind: 'combo', comboId: combo.id, publicModelId: combo.publicModelId };
+    if (combo)
+        return { kind: 'combo', comboId: combo.id, publicModelId: combo.publicModelId, enabled: combo.enabled };
     // Alias (one hop only)
     const alias = db.select().from(schema.modelAliases).where(and(eq(schema.modelAliases.alias, requested), eq(schema.modelAliases.enabled, true))).get();
     if (alias) {
         if (alias.targetKind === 'model') {
             const m = db.select().from(schema.models).where(eq(schema.models.id, alias.targetId)).get();
-            if (m && m.enabled)
-                return { kind: 'alias', aliasId: alias.id, alias: alias.alias, resolved: { kind: 'model', modelId: m.id, publicModelId: m.publicModelId } };
+            if (m)
+                return { kind: 'alias', aliasId: alias.id, alias: alias.alias, resolved: { kind: 'model', modelId: m.id, publicModelId: m.publicModelId, enabled: m.enabled } };
         }
         else {
             const c = db.select().from(schema.combos).where(eq(schema.combos.id, alias.targetId)).get();
-            if (c && c.enabled)
-                return { kind: 'alias', aliasId: alias.id, alias: alias.alias, resolved: { kind: 'combo', comboId: c.id, publicModelId: c.publicModelId } };
+            if (c)
+                return { kind: 'alias', aliasId: alias.id, alias: alias.alias, resolved: { kind: 'combo', comboId: c.id, publicModelId: c.publicModelId, enabled: c.enabled } };
         }
     }
     // Maybe the user typed the combo slug without the prefix
     if (!requested.includes('/')) {
         const c = db.select().from(schema.combos).where(eq(schema.combos.slug, requested)).get();
-        if (c && c.enabled)
-            return { kind: 'combo', comboId: c.id, publicModelId: c.publicModelId };
+        if (c)
+            return { kind: 'combo', comboId: c.id, publicModelId: c.publicModelId, enabled: c.enabled };
     }
     throw new GatewayError('model_not_found', `Unknown model: ${requested}`, { status: 404 });
 }

package/dist/server/upstream/client.js

@@ -51,6 +51,22 @@ export function providerToUpstreamConfig(p, codexAccountId) {
         totalTimeoutMs: p.totalTimeoutMs,
     };
 }
+/**
+ * One conversion of an upstream HTTP status into a gateway error, shared by the
+ * streaming and non-streaming paths so both report identical type/code/status.
+ * Before this, the same upstream 429 arrived as "Upstream rate limited" over a
+ * stream and "Upstream rate limited (HTTP 429)" without one, with a different
+ * code (or none) each time.
+ */
+export function upstreamHttpError(status, bodyExcerpt, cause) {
+    if (status >= 500)
+        return new GatewayError('upstream_error', `Upstream HTTP ${status}`, { status: 502, cause, code: `upstream_http_${status}` });
+    if (status === 429)
+        return new GatewayError('upstream_rate_limit', `Upstream rate limited (HTTP ${status})`, { status: 429, cause, code: 'upstream_http_429' });
+    if (status === 401 || status === 403)
+        return new GatewayError('upstream_auth_error', `Upstream authentication failed (HTTP ${status})`, { status: 502, cause, code: `upstream_http_${status}` });
+    return new GatewayError('upstream_error', `Upstream HTTP ${status}: ${bodyExcerpt}`, { status: 502, cause, code: `upstream_http_${status}` });
+}
 export async function callUpstreamNonStreaming(cfg, url, payload, requestId = '-') {
     const ctl = new AbortController();
     const timer = setTimeout(() => ctl.abort(), cfg.totalTimeoutMs);
@@ -190,13 +206,7 @@ export async function callUpstreamStreaming(cfg, url, payload, onChunk, requestI
     }
     catch (e) {
         if (e instanceof UpstreamHttpError) {
-            if (e.status >= 500)
-                throw new GatewayError('upstream_error', `Upstream HTTP ${e.status}`, { status: 502, cause: e, code: 'upstream_http_' + e.status });
-            if (e.status === 429)
-                throw new GatewayError('upstream_rate_limit', 'Upstream rate limited', { status: 529, cause: e });
-            if (e.status === 401 || e.status === 403)
-                throw new GatewayError('upstream_auth_error', 'Upstream authentication failed', { status: 502, cause: e });
-            throw new GatewayError('upstream_error', `Upstream HTTP ${e.status}: ${e.bodyExcerpt}`, { status: 502, cause: e });
+            throw upstreamHttpError(e.status, e.bodyExcerpt, e);
         }
         const err = e;
         errorLine(requestId, 'UPSTREAM FETCH ERROR', [