ldrouter 1.17.9 → 1.18.0

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

@@ -32,9 +32,12 @@ export function toSummary(r, maps) {
         endpoint: r.endpoint,
         requestedModel: r.requestedModel,
         resolvedTargetKind: r.resolvedTargetKind,
+        resolvedTargetId: r.resolvedTargetId,
         finalModelPublicId: finalModel?.publicModelId ?? null,
+        finalModelUpstreamId: finalModel?.upstreamModelId ?? null,
         providerId: provider ? finalModel.providerId : null,
         providerName: provider?.name ?? null,
+        providerSlug: provider?.slug ?? null,
         providerType: provider?.type ?? null,
         streaming: Boolean(r.streaming),
         httpStatus: r.httpStatus,
@@ -53,6 +56,27 @@ export function toSummary(r, maps) {
         gatewayCacheHit: Boolean(r.gatewayCacheHit),
     };
 }
+function quoteCurlJson(value) {
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function buildReproductionCurl(request, redactedPayload) {
+    const endpoint = request.protocol === 'anthropic'
+        ? '/v1/messages'
+        : `/v1/${request.endpoint.replace(/^\/?v1\/?/, '')}`;
+    let body = { model: request.requestedModel };
+    if (redactedPayload) {
+        try {
+            const parsed = JSON.parse(redactedPayload);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                body = { ...parsed, model: request.requestedModel };
+        }
+        catch { }
+    }
+    const headers = request.protocol === 'anthropic'
+        ? "-H 'x-api-key: REPLACE_WITH_LD_KEY' -H 'anthropic-version: 2023-06-01'"
+        : "-H 'Authorization: Bearer ld-REPLACE_WITH_KEY'";
+    return `curl http://localhost:8787${endpoint} -H 'content-type: application/json' ${headers} --data-raw ${quoteCurlJson(JSON.stringify(body))}`;
+}
 export async function registerRequestRoutes(app) {
     app.addHook('preHandler', requireAdminAuth);
     app.get('/api/admin/requests', async (req) => {
@@ -205,7 +229,12 @@ export async function registerRequestRoutes(app) {
                 endpoint: r.endpoint,
                 requestedModel: r.requestedModel,
                 resolvedTargetKind: r.resolvedTargetKind,
+                resolvedTargetId: r.resolvedTargetId,
                 finalModelPublicId: finalModel?.publicModelId ?? null,
+                finalModelUpstreamId: finalModel?.upstreamModelId ?? null,
+                providerId: finalModel?.providerId ?? null,
+                providerName: providerMap.get(finalModel?.providerId ?? '')?.name ?? null,
+                providerSlug: providerMap.get(finalModel?.providerId ?? '')?.slug ?? null,
                 streaming: Boolean(r.streaming),
                 httpStatus: r.httpStatus,
                 success: Boolean(r.success),
@@ -222,6 +251,8 @@ export async function registerRequestRoutes(app) {
                 errorMessage: r.errorMessage,
                 requestPayload: redactJsonString(r.requestPayloadJson),
                 responsePayload: redactJsonString(r.responsePayloadJson),
+                reproductionCurl: buildReproductionCurl(r, redactJsonString(r.requestPayloadJson)),
+                fallbackReasons: [...new Set(attempts.map((a) => a.failureReason).filter((reason) => Boolean(reason)))],
                 gatewayCacheHit: Boolean(r.gatewayCacheHit),
             },
             attempts: attempts.map((a) => ({
@@ -231,6 +262,7 @@ export async function registerRequestRoutes(app) {
                 providerName: providerMap.get(a.providerId)?.name ?? '',
                 modelId: a.modelId,
                 modelPublicId: modelMap.get(a.modelId)?.publicModelId ?? '',
+                upstreamModelId: modelMap.get(a.modelId)?.upstreamModelId ?? '',
                 codexAccountId: a.codexAccountId,
                 startedAt: a.startedAt,
                 completedAt: a.completedAt,

package/dist/server/routes/admin.js

@@ -13,8 +13,6 @@ import { registerAuditRoutes } from './admin/audit.js';
 import { registerSettingsRoutes } from './admin/settings.js';
 import { registerBackupRoutes } from './admin/backup.js';
 import { registerDashboardRoutes } from './admin/dashboard.js';
-import { registerCodexRoutes, registerCodexOAuthCallbackRoute } from './admin/codex.js';
-import { registerQoderRoutes } from './admin/qoder.js';
 export async function registerAdminRoutes(app) {
     // Setup routes are always reachable (used on first run).
     await app.register(async (instance) => {
@@ -25,10 +23,6 @@ export async function registerAdminRoutes(app) {
     await app.register(async (instance) => {
         await registerAuthRoutes(instance);
     });
-    // The Codex OAuth loopback callback is hit by the browser's redirect, so it is public too.
-    await app.register(async (instance) => {
-        await registerCodexOAuthCallbackRoute(instance);
-    });
     // Authenticated admin routes
     await app.register(async (instance) => {
         instance.addHook('preHandler', requireAdminAuth);
@@ -46,8 +40,6 @@ export async function registerAdminRoutes(app) {
         await registerAuditRoutes(instance);
         await registerSettingsRoutes(instance);
         await registerDashboardRoutes(instance);
-        await registerCodexRoutes(instance);
-        await registerQoderRoutes(instance);
     });
     // Backup routes get their own scope. The first-run import (setup.tsx) must be reachable before
     // any admin account exists, but this scope's parent runs the other admin modules' auth hooks,

package/dist/server/routing/combo.js

@@ -1,4 +1,4 @@
-// Combo routing: fallback (ordered) or weighted round-robin.
+// Combo routing: ordered fallback.
 import { eq } from 'drizzle-orm';
 import { getDb, schema } from '../db/index.js';
 import { firstMissingCapability } from './capabilities.js';
@@ -10,9 +10,9 @@ export function loadCombo(comboId) {
     const members = db.select().from(schema.comboMembers).where(eq(schema.comboMembers.comboId, comboId)).all();
     return {
         comboId: c.id,
-        mode: c.mode,
+        mode: 'fallback',
         maxTotalAttempts: c.maxTotalAttempts,
-        members: members.map((m) => ({ id: m.id, modelId: m.modelId, position: m.position, weight: m.weight, enabled: m.enabled })),
+        members: members.map((m) => ({ id: m.id, modelId: m.modelId, position: m.position, enabled: m.enabled })),
         trigger: {
             connection: c.fallbackOnConnection,
             connectTimeout: c.fallbackOnConnectTimeout,
@@ -89,35 +89,12 @@ export function selectCandidates(combo, allModels, req, onReject) {
     return candidates;
 }
 export function orderCandidates(combo, candidates) {
-    if (combo.mode === 'fallback') {
-        // Preserve declared position order
-        return [...candidates].sort((a, b) => {
-            const am = combo.members.find((m) => m.modelId === a.modelId);
-            const bm = combo.members.find((m) => m.modelId === b.modelId);
-            return (am?.position ?? 0) - (bm?.position ?? 0);
-        });
-    }
-    // Weighted round-robin: stable order with weighted lead bias.
-    // We rotate via a process-local cursor keyed by combo id.
-    const cursor = nextCursor(combo.comboId, combo.members, candidates);
-    return cursor;
-}
-const comboCursors = new Map();
-function nextCursor(comboId, members, candidates) {
-    if (candidates.length === 0)
-        return [];
-    // Repeat each available member according to its configured positive weight,
-    // then advance one slot per request. This is deterministic weighted RR.
-    const slots = members.flatMap((member) => {
-        const candidate = candidates.find((c) => c.modelId === member.modelId);
-        if (!candidate)
-            return [];
-        return Array.from({ length: Math.max(1, member.weight) }, () => candidate);
+    // Preserve declared position order.
+    return [...candidates].sort((a, b) => {
+        const am = combo.members.find((m) => m.modelId === a.modelId);
+        const bm = combo.members.find((m) => m.modelId === b.modelId);
+        return (am?.position ?? 0) - (bm?.position ?? 0);
     });
-    const cur = (comboCursors.get(comboId) ?? 0) % Math.max(1, slots.length);
-    comboCursors.set(comboId, cur + 1);
-    const selected = slots[cur] ?? candidates[0];
-    return [selected, ...candidates.filter((candidate) => candidate !== selected)];
 }
 export function shouldFallback(combo, reason) {
     switch (reason.type) {

package/dist/server/upstream/client.js

@@ -3,35 +3,12 @@ import { decryptSecret, decryptCustomHeaders } from '../auth/crypto.js';
 import { GatewayError } from '../errors.js';
 import { buildHeaders, stripSlash } from '../providers/index.js';
 import { redactString } from '../security/redact.js';
-import { getCodexAccountForProvider, getCodexAccountById } from '../db/repositories/codex-accounts.js';
-import { findEligibleQoderAccount } from '../db/repositories/qoder-accounts.js';
 import { debugUpstream, errorLine, formatError, truncate } from '../logging/debug.js';
-export function providerToUpstreamConfig(p, codexAccountId) {
+export function providerToUpstreamConfig(p, _codexAccountId) {
     let apiKey;
     let customHeaders;
-    if (p.type === 'codex') {
-        const account = codexAccountId ? getCodexAccountById(codexAccountId) : getCodexAccountForProvider(p.id);
-        if (!account)
-            throw new GatewayError('authentication_error', 'No usable Codex account is configured', { status: 503 });
-        return {
-            type: 'codex', baseUrl: p.baseUrl, customHeaders: {},
-            connectTimeoutMs: p.connectTimeoutMs, firstTokenTimeoutMs: p.firstTokenTimeoutMs,
-            streamIdleTimeoutMs: p.streamIdleTimeoutMs, totalTimeoutMs: p.totalTimeoutMs,
-            codexAccountId: account.chatgptAccountId, accountRecordId: account.id,
-        };
-    }
-    if (p.type === 'qoder') {
-        // Account-pool provider: no API key on the row. The runner normally overrides the account
-        // from the expanded candidate; this resolves the first eligible one for direct callers.
-        const account = findEligibleQoderAccount(p.id);
-        if (!account)
-            throw new GatewayError('authentication_error', 'No usable Qoder account is configured', { status: 503 });
-        return {
-            type: 'qoder', baseUrl: p.baseUrl, customHeaders: {},
-            connectTimeoutMs: p.connectTimeoutMs, firstTokenTimeoutMs: p.firstTokenTimeoutMs,
-            streamIdleTimeoutMs: p.streamIdleTimeoutMs, totalTimeoutMs: p.totalTimeoutMs,
-            qoderUserId: account.qoderUserId, qoderAccountRecordId: account.id,
-        };
+    if (p.type === 'codex' || p.type === 'qoder') {
+        throw new GatewayError('invalid_request_error', `${p.type} providers are no longer supported`, { status: 410 });
     }
     if (!p.encryptedApiKey || !p.apiKeyNonce) {
         throw new GatewayError('invalid_request_error', 'Provider credentials are missing', { status: 501 });