ldrouter 1.5.1

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

@@ -0,0 +1,112 @@
+// Anthropic-compatible gateway routes: /v1/messages, /v1/messages/count_tokens.
+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 { GatewayRunner } from '../../gateway/runner.js';
+import { uuid } from '../../auth/ids.js';
+const MessagesBody = z.object({
+    model: z.string().min(1),
+    messages: z.array(z.any()).min(1),
+    system: z.union([z.string(), z.array(z.any())]).optional(),
+    max_tokens: z.number().int().min(1).optional(),
+    temperature: z.number().optional(),
+    top_p: z.number().optional(),
+    stop_sequences: z.array(z.string()).optional(),
+    stream: z.boolean().optional(),
+    tools: z.array(z.any()).optional(),
+    tool_choice: z.any().optional(),
+    thinking: z.object({ type: z.literal('enabled'), budget_tokens: z.number().int().min(1) }).optional(),
+});
+const CountTokensBody = MessagesBody.omit({ stream: true });
+export async function registerAnthropicRoutes(app) {
+    const runner = new GatewayRunner();
+    app.get('/v1/messages', async (_req, reply) => {
+        reply.code(405).send(toAnthropicError(new GatewayError('invalid_request_error', 'Use POST /v1/messages', { status: 405 }), ''));
+    });
+    app.post('/v1/messages', async (req, reply) => {
+        const key = authenticateGatewayHeaders(req);
+        const body = MessagesBody.parse(req.body);
+        const ar = body;
+        if (!ar.max_tokens) {
+            throw new GatewayError('invalid_request_error', 'max_tokens is required', { status: 400 });
+        }
+        const canonical = anthropicToCanonical(ar);
+        const ctx = {
+            requestId: req.id || uuid(),
+            clientIp: resolveClientIp(req),
+            protocol: 'anthropic',
+            endpoint: 'messages',
+            requestedModel: body.model,
+            key,
+            reply,
+        };
+        try {
+            const outcome = await runner.execute({ canonical, protocol: 'anthropic', endpoint: 'messages' }, ctx);
+            if (body.stream) {
+                if (reply.raw.headersSent || reply.raw.writableEnded) {
+                    reply.hijack();
+                    return reply;
+                }
+                if (!outcome.success) {
+                    const g = new GatewayError(outcome.errorType ?? 'gateway_error', outcome.errorMessage ?? 'Gateway error', { status: outcome.httpStatus });
+                    reply.code(outcome.httpStatus).send(toAnthropicError(g, ctx.requestId));
+                    return;
+                }
+                reply.type('text/event-stream').send('data: [DONE]\n\n');
+                return;
+            }
+            if (!outcome.success) {
+                const g = new GatewayError(outcome.errorType ?? 'gateway_error', outcome.errorMessage ?? 'Gateway error', { status: outcome.httpStatus });
+                reply.code(outcome.httpStatus).send(toAnthropicError(g, ctx.requestId));
+                return;
+            }
+            reply.header('x-request-id', ctx.requestId);
+            reply.send({
+                id: `msg_${ctx.requestId}`,
+                type: 'message',
+                role: 'assistant',
+                model: body.model,
+                content: [
+                    ...(outcome.text ? [{ type: 'text', text: outcome.text }] : []),
+                    ...(outcome.toolCalls ?? []).map((tc) => ({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.input })),
+                ],
+                stop_reason: outcome.finishReason,
+                usage: {
+                    input_tokens: outcome.usage.input,
+                    output_tokens: outcome.usage.output,
+                    ...(outcome.usage.cacheRead ? { cache_read_input_tokens: outcome.usage.cacheRead } : {}),
+                    ...(outcome.usage.cacheWrite ? { cache_creation_input_tokens: outcome.usage.cacheWrite } : {}),
+                },
+            });
+        }
+        catch (e) {
+            if (e instanceof GatewayError) {
+                reply.code(e.status).send(toAnthropicError(e, ctx.requestId));
+                return;
+            }
+            throw e;
+        }
+    });
+    app.post('/v1/messages/count_tokens', async (req, reply) => {
+        const body = CountTokensBody.parse(req.body);
+        const ar = body;
+        const canonical = anthropicToCanonical(ar);
+        // Estimate: 1 token per 4 chars, conservative for v1 without provider call.
+        const json = JSON.stringify(canonical.messages) + (canonical.system ?? '');
+        const inputTokens = Math.ceil(json.length / 4);
+        reply.header('x-request-id', req.id);
+        reply.send({ input_tokens: inputTokens });
+    });
+}
+function authenticateGatewayHeaders(req) {
+    const key = authenticateGatewayKey(req);
+    if (!key)
+        throw new GatewayError('authentication_error', 'Missing API key', { status: 401 });
+    if (!key.enabled)
+        throw new GatewayError('authentication_error', 'API key disabled', { status: 401 });
+    if (key.expiresAt && new Date(key.expiresAt).getTime() < Date.now())
+        throw new GatewayError('authentication_error', 'API key expired', { status: 401 });
+    return key;
+}

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

@@ -0,0 +1,257 @@
+// OpenAI-compatible gateway routes: /v1/models, /v1/chat/completions, /v1/responses.
+import { z } from 'zod';
+import { eq, inArray } from 'drizzle-orm';
+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 { GatewayRunner } from '../../gateway/runner.js';
+import { uuid } from '../../auth/ids.js';
+const ChatBody = z.object({
+    model: z.string().min(1),
+    messages: z.array(z.any()).min(1),
+    tools: z.array(z.any()).optional(),
+    tool_choice: z.any().optional(),
+    stream: z.boolean().optional(),
+    temperature: z.number().optional(),
+    top_p: z.number().optional(),
+    max_tokens: z.number().int().min(1).optional(),
+    stop: z.union([z.array(z.string()), z.string()]).optional(),
+    response_format: z.any().optional(),
+    reasoning_effort: z.enum(['low', 'medium', 'high']).optional(),
+});
+const ResponsesBody = z.object({
+    model: z.string().min(1),
+    input: z.any(),
+    stream: z.boolean().optional(),
+    // Accept and pass through; full Responses support is a v1 subset.
+});
+export async function registerOpenAIRoutes(app) {
+    const runner = new GatewayRunner();
+    app.get('/v1/models', async (req) => {
+        const key = authenticateGatewayHeaders(req);
+        const db = getDb();
+        let models = db.select().from(schema.models).all();
+        if (!key.allowAllModels) {
+            const perms = db.select().from(schema.apiKeyModelPermissions).where(eq(schema.apiKeyModelPermissions.apiKeyId, key.id)).all();
+            const allowedModelIds = new Set(perms.filter((p) => p.targetKind === 'model').map((p) => p.targetId));
+            models = models.filter((m) => allowedModelIds.has(m.id) || (m.enabled && m.upstreamAvailable));
+        }
+        else {
+            models = models.filter((m) => m.enabled && m.upstreamAvailable);
+        }
+        const ids = listRoutableModelIds(models, key, db);
+        return openAIModelList(ids.map((id) => ({ publicModelId: id, upstreamModelId: id })));
+    });
+    app.post('/v1/chat/completions', async (req, reply) => {
+        const key = authenticateGatewayHeaders(req);
+        const body = ChatBody.parse(req.body);
+        const req1 = body;
+        const canonical = openAIToCanonical(req1);
+        const ctx = {
+            requestId: req.id || uuid(),
+            clientIp: resolveClientIp(req),
+            protocol: 'openai',
+            endpoint: 'chat/completions',
+            requestedModel: body.model,
+            key,
+            reply,
+        };
+        try {
+            const outcome = await runner.execute({ canonical, protocol: 'openai', endpoint: 'chat/completions' }, ctx);
+            if (req1.stream) {
+                // The runner streams to reply.raw once the upstream commits. If the raw
+                // response has begun (head sent or ended), it's already fully handled —
+                // hijack so Fastify does not append its own reply.
+                if (reply.raw.headersSent || reply.raw.writableEnded) {
+                    reply.hijack();
+                    return reply;
+                }
+                // Nothing was streamed: the upstream failed before the first chunk, so
+                // 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 });
+                    reply.code(outcome.httpStatus).send(toOpenAIError(g, ctx.requestId));
+                    return;
+                }
+                // Success with no streamed chunks — terminate the SSE cleanly.
+                reply.type('text/event-stream').send('data: [DONE]\n\n');
+                return;
+            }
+            if (!outcome.success) {
+                const g = new GatewayError(outcome.errorType ?? 'gateway_error', outcome.errorMessage ?? 'Gateway error', { status: outcome.httpStatus });
+                reply.code(outcome.httpStatus).send(toOpenAIError(g, ctx.requestId));
+                return;
+            }
+            reply.header('x-request-id', ctx.requestId);
+            reply.send({
+                id: `chatcmpl-${ctx.requestId}`,
+                object: 'chat.completion',
+                created: Math.floor(Date.now() / 1000),
+                model: body.model,
+                choices: [
+                    {
+                        index: 0,
+                        message: {
+                            role: 'assistant',
+                            content: outcome.text,
+                            ...(outcome.toolCalls && outcome.toolCalls.length
+                                ? { tool_calls: outcome.toolCalls.map((tc) => ({ id: tc.id, type: 'function', function: { name: tc.name, arguments: JSON.stringify(tc.input) } })) }
+                                : {}),
+                        },
+                        finish_reason: outcome.finishReason,
+                    },
+                ],
+                usage: {
+                    prompt_tokens: outcome.usage.input,
+                    completion_tokens: outcome.usage.output,
+                    total_tokens: outcome.usage.total,
+                    ...(outcome.usage.cacheRead ? { prompt_tokens_details: { cached_tokens: outcome.usage.cacheRead } } : {}),
+                    ...(outcome.usage.reasoning ? { completion_tokens_details: { reasoning_tokens: outcome.usage.reasoning } } : {}),
+                },
+            });
+        }
+        catch (e) {
+            if (e instanceof GatewayError) {
+                reply.code(e.status).send(toOpenAIError(e, ctx.requestId));
+                return;
+            }
+            throw e;
+        }
+    });
+    app.post('/v1/responses', async (req, reply) => {
+        const key = authenticateGatewayHeaders(req);
+        // v1 subset: accept Responses-style input, flatten to chat-completions messages.
+        const body = ResponsesBody.parse(req.body);
+        const flat = responsesInputToChat(body.input);
+        const chatBody = {
+            model: body.model,
+            messages: flat.messages,
+            tools: flat.tools,
+            stream: body.stream,
+        };
+        const canonical = openAIToCanonical(chatBody);
+        const ctx = {
+            requestId: req.id || uuid(),
+            clientIp: resolveClientIp(req),
+            protocol: 'openai',
+            endpoint: 'responses',
+            requestedModel: body.model,
+            key,
+            reply,
+        };
+        try {
+            const outcome = await runner.execute({ canonical, protocol: 'openai', endpoint: 'responses' }, ctx);
+            if (body.stream) {
+                if (reply.raw.headersSent || reply.raw.writableEnded) {
+                    reply.hijack();
+                    return reply;
+                }
+                if (!outcome.success) {
+                    const g = new GatewayError(outcome.errorType ?? 'gateway_error', outcome.errorMessage ?? 'Gateway error', { status: outcome.httpStatus });
+                    reply.code(outcome.httpStatus).send(toOpenAIError(g, ctx.requestId));
+                    return;
+                }
+                reply.type('text/event-stream').send('data: [DONE]\n\n');
+                return;
+            }
+            if (!outcome.success) {
+                const g = new GatewayError(outcome.errorType ?? 'gateway_error', outcome.errorMessage ?? 'Gateway error', { status: outcome.httpStatus });
+                reply.code(outcome.httpStatus).send(toOpenAIError(g, ctx.requestId));
+                return;
+            }
+            reply.header('x-request-id', ctx.requestId);
+            reply.send({
+                id: `resp-${ctx.requestId}`,
+                object: 'response',
+                created_at: Math.floor(Date.now() / 1000),
+                model: body.model,
+                output: [
+                    {
+                        type: 'message',
+                        role: 'assistant',
+                        content: [{ type: 'output_text', text: outcome.text ?? '' }],
+                    },
+                ],
+                usage: {
+                    input_tokens: outcome.usage.input,
+                    output_tokens: outcome.usage.output,
+                    total_tokens: outcome.usage.total,
+                },
+            });
+        }
+        catch (e) {
+            if (e instanceof GatewayError) {
+                reply.code(e.status).send(toOpenAIError(e, ctx.requestId));
+                return;
+            }
+            throw e;
+        }
+    });
+}
+export function listRoutableModelIds(models, key, db) {
+    const modelIds = new Set(models.map((m) => m.id));
+    const modelById = new Map(models.map((m) => [m.id, m.publicModelId]));
+    let combos = db.select().from(schema.combos).where(eq(schema.combos.enabled, true)).all();
+    const members = combos.length > 0
+        ? db.select().from(schema.comboMembers).where(inArray(schema.comboMembers.comboId, combos.map((c) => c.id))).all()
+        : [];
+    const memberByCombo = new Map();
+    for (const mm of members) {
+        if (!memberByCombo.has(mm.comboId))
+            memberByCombo.set(mm.comboId, new Set());
+        memberByCombo.get(mm.comboId).add(mm.modelId);
+    }
+    // A combo with no routable members would always fail at runtime — hide it.
+    combos = combos.filter((c) => {
+        const ids = memberByCombo.get(c.id);
+        return ids !== undefined && ids.size > 0 && [...ids].some((id) => modelIds.has(id));
+    });
+    let aliases = db.select().from(schema.modelAliases).where(eq(schema.modelAliases.enabled, true)).all();
+    aliases = aliases.filter((a) => {
+        if (a.targetKind === 'model')
+            return modelById.has(a.targetId);
+        return combos.some((c) => c.id === a.targetId);
+    });
+    const ids = models.map((m) => m.publicModelId).concat(combos.map((c) => c.publicModelId), aliases.map((a) => a.alias));
+    if (key.allowAllModels)
+        return ids;
+    const perms = db.select().from(schema.apiKeyModelPermissions).where(eq(schema.apiKeyModelPermissions.apiKeyId, key.id)).all();
+    const allowModels = new Set(perms.filter((p) => p.targetKind === 'model').map((p) => p.targetId));
+    const allowCombos = new Set(perms.filter((p) => p.targetKind === 'combo').map((p) => p.targetId));
+    return ids.filter((id) => models.some((m) => m.publicModelId === id && allowModels.has(m.id))
+        || combos.some((c) => c.publicModelId === id && allowCombos.has(c.id))
+        || aliases.some((a) => a.alias === id && (a.targetKind === 'model' ? allowModels.has(a.targetId) : allowCombos.has(a.targetId))));
+}
+function authenticateGatewayHeaders(req) {
+    const key = authenticateGatewayKey(req);
+    if (!key)
+        throw new GatewayError('authentication_error', 'Missing API key', { status: 401 });
+    if (!key.enabled)
+        throw new GatewayError('authentication_error', 'API key disabled', { status: 401 });
+    if (key.expiresAt && new Date(key.expiresAt).getTime() < Date.now())
+        throw new GatewayError('authentication_error', 'API key expired', { status: 401 });
+    return key;
+}
+function responsesInputToChat(input) {
+    // Minimal Responses-to-Chat mapping (v1 subset).
+    if (typeof input === 'string')
+        return { messages: [{ role: 'user', content: input }] };
+    if (Array.isArray(input)) {
+        const messages = [];
+        for (const item of input) {
+            if (item && typeof item === 'object' && 'role' in item && 'content' in item) {
+                messages.push({ role: item.role, content: item.content });
+            }
+            else if (item && typeof item === 'object' && 'type' in item) {
+                const t = item.type;
+                if (t === 'message')
+                    messages.push({ role: (item.role ?? 'user'), content: item.content });
+            }
+        }
+        return { messages };
+    }
+    return { messages: [{ role: 'user', content: '' }] };
+}

package/dist/server/routes/gateway.js

@@ -0,0 +1,7 @@
+// Gateway public API routes (mounted at /v1/*). Auth via ld-.. API keys.
+import { registerOpenAIRoutes } from './gateway/openai.js';
+import { registerAnthropicRoutes } from './gateway/anthropic.js';
+export async function registerGatewayRoutes(app) {
+    await registerOpenAIRoutes(app);
+    await registerAnthropicRoutes(app);
+}

package/dist/server/routes/health.js

@@ -0,0 +1,27 @@
+// Operational routes: /health, /ready, /metrics.
+import { getDb, schema } from '../db/index.js';
+import { sql } from 'drizzle-orm';
+import { loadConfig } from '../config/index.js';
+import { metricsRegistry } from '../metrics/registry.js';
+export async function registerHealthRoutes(app) {
+    app.get('/health', async () => {
+        return { status: 'ok', version: loadConfig().appVersion };
+    });
+    app.get('/ready', async (_req, reply) => {
+        try {
+            const db = getDb();
+            const row = db.select({ c: sql `1` }).from(schema.appSettings).get();
+            if (!row) {
+                reply.code(503).send({ status: 'not_ready', reason: 'settings_missing' });
+                return;
+            }
+            return { status: 'ready' };
+        }
+        catch (e) {
+            reply.code(503).send({ status: 'not_ready', reason: 'db_error', detail: e.message });
+        }
+    });
+    app.get('/metrics', async (_req, reply) => {
+        reply.type('text/plain; version=0.0.4; charset=utf-8').send(metricsRegistry.render());
+    });
+}

package/dist/server/routing/capabilities.js

@@ -0,0 +1,52 @@
+// Derive capability requirements from a canonical request.
+export function deriveRequiredCapabilities(req) {
+    let tools = false;
+    let imageInput = false;
+    let audioInput = false;
+    for (const m of req.messages) {
+        for (const b of m.content ?? []) {
+            if (b.type === 'image')
+                imageInput = true;
+            if (b.type === 'audio')
+                audioInput = true;
+        }
+    }
+    if (req.tools && req.tools.length > 0)
+        tools = true;
+    // tool_use/tool_result blocks imply tool calling
+    for (const m of req.messages) {
+        for (const b of m.content ?? []) {
+            if (b.type === 'tool_use' || b.type === 'tool_result')
+                tools = true;
+        }
+    }
+    let structuredOutput = false;
+    if (req.responseFormat && (req.responseFormat.type === 'json_object' || req.responseFormat.type === 'json_schema'))
+        structuredOutput = true;
+    return {
+        streaming: Boolean(req.stream),
+        tools,
+        structuredOutput,
+        imageInput,
+        audioInput,
+        reasoning: Boolean(req.reasoning),
+        responses: false,
+    };
+}
+export function modelMeets(caps, req) {
+    if (req.streaming && !caps.streaming)
+        return false;
+    if (req.tools && !caps.tools)
+        return false;
+    if (req.structuredOutput && !caps.structured_output)
+        return false;
+    if (req.imageInput && !caps.image_input)
+        return false;
+    if (req.audioInput && !caps.audio_input)
+        return false;
+    if (req.reasoning && !caps.reasoning)
+        return false;
+    if (req.responses && !caps.responses)
+        return false;
+    return true;
+}

package/dist/server/routing/circuit.js

@@ -0,0 +1,37 @@
+// In-memory circuit breaker state per provider.
+const store = new Map();
+export function circuitState(providerId) {
+    const s = store.get(providerId);
+    if (!s)
+        return 'closed';
+    return s.state;
+}
+export function isOpen(providerId) {
+    return circuitState(providerId) === 'open';
+}
+export function recordSuccess(providerId) {
+    store.set(providerId, { state: 'closed', consecutiveFailures: 0, openedAt: 0 });
+}
+export function recordFailure(providerId, threshold, _cooldownSeconds) {
+    const s = store.get(providerId) ?? { state: 'closed', consecutiveFailures: 0, openedAt: 0 };
+    s.consecutiveFailures += 1;
+    if (s.state === 'half_open' || s.consecutiveFailures >= threshold) {
+        s.state = 'open';
+        s.openedAt = Date.now();
+        // Auto-transition to half-open after cooldown via getEffectiveState
+    }
+    store.set(providerId, s);
+}
+export function getEffectiveState(providerId, cooldownSeconds) {
+    const s = store.get(providerId);
+    if (!s)
+        return 'closed';
+    if (s.state === 'open' && Date.now() - s.openedAt > cooldownSeconds * 1000) {
+        s.state = 'half_open';
+        store.set(providerId, s);
+    }
+    return s.state;
+}
+export function halfOpenProbeAllowed(providerId) {
+    return circuitState(providerId) === 'half_open';
+}

package/dist/server/routing/combo.js

@@ -0,0 +1,100 @@
+// 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';
+export function loadCombo(comboId) {
+    const db = getDb();
+    const c = db.select().from(schema.combos).where(eq(schema.combos.id, comboId)).get();
+    if (!c)
+        return null;
+    const members = db.select().from(schema.comboMembers).where(eq(schema.comboMembers.comboId, comboId)).all();
+    return {
+        comboId: c.id,
+        mode: c.mode,
+        maxTotalAttempts: c.maxTotalAttempts,
+        members: members.map((m) => ({ id: m.id, modelId: m.modelId, position: m.position, weight: m.weight, enabled: m.enabled })),
+        trigger: {
+            connection: c.fallbackOnConnection,
+            connectTimeout: c.fallbackOnConnectTimeout,
+            firstTokenTimeout: c.fallbackOnFirstTokenTimeout,
+            on408: c.fallbackOn408,
+            on429: c.fallbackOn429,
+            on5xx: c.fallbackOn5xx,
+        },
+    };
+}
+export function selectCandidates(combo, allModels, req) {
+    // Resolve each combo member to a candidate and apply filters
+    const map = new Map(allModels.map((m) => [m.modelId, m]));
+    const candidates = [];
+    for (const m of combo.members) {
+        if (!m.enabled)
+            continue;
+        const c = map.get(m.modelId);
+        if (!c)
+            continue;
+        if (!c.enabled)
+            continue;
+        if (!c.upstreamAvailable)
+            continue;
+        if (c.circuitOpen)
+            continue;
+        if (!modelMeets(c.capabilities, req))
+            continue;
+        candidates.push(c);
+    }
+    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, candidates);
+    return cursor;
+}
+const comboCursors = new Map();
+function nextCursor(comboId, candidates) {
+    if (candidates.length === 0)
+        return [];
+    // Compute total weight of available candidates
+    const totalWeight = candidates.reduce((s, c) => {
+        const m = (candidates.find((x) => x.modelId === c.modelId));
+        void m;
+        return s + 1; // weight normalization happens upstream
+    }, 0);
+    void totalWeight;
+    // Simple modulo rotation for determinism in tests
+    const cur = (comboCursors.get(comboId) ?? 0) % candidates.length;
+    comboCursors.set(comboId, cur + 1);
+    return [...candidates.slice(cur), ...candidates.slice(0, cur)];
+}
+export function shouldFallback(combo, reason) {
+    switch (reason.type) {
+        case 'connection_error':
+            return combo.trigger.connection;
+        case 'connect_timeout':
+            return combo.trigger.connectTimeout;
+        case 'first_token_timeout':
+            return combo.trigger.firstTokenTimeout;
+        case 'http_status':
+            if (reason.status === 408)
+                return combo.trigger.on408;
+            if (reason.status === 429)
+                return combo.trigger.on429;
+            if (reason.status && reason.status >= 500 && reason.status < 600)
+                return combo.trigger.on5xx;
+            return false;
+        case 'stream_partial':
+            // Per spec: never fallback after stream content has been sent.
+            return false;
+        default:
+            return false;
+    }
+}

package/dist/server/routing/quota.js

@@ -0,0 +1,51 @@
+// Daily / monthly token quota enforcement using usage_daily/usage_monthly tables.
+import { and, eq, sql } from 'drizzle-orm';
+import { getDb, schema } from '../db/index.js';
+export function checkDailyMonthly(keyId, dailyLimit, monthlyLimit, tokens) {
+    const db = getDb();
+    const now = new Date();
+    const day = now.toISOString().slice(0, 10);
+    const month = now.toISOString().slice(0, 7);
+    if (dailyLimit != null && dailyLimit > 0) {
+        const row = db.select({ t: schema.usageDaily.totalTokens }).from(schema.usageDaily).where(and(eq(schema.usageDaily.day, day), eq(schema.usageDaily.apiKeyId, keyId))).get();
+        const used = row?.t ?? 0;
+        if (used + tokens > dailyLimit)
+            return { allowed: false, reason: 'daily' };
+    }
+    if (monthlyLimit != null && monthlyLimit > 0) {
+        const row = db.select({ t: schema.usageMonthly.totalTokens }).from(schema.usageMonthly).where(and(eq(schema.usageMonthly.month, month), eq(schema.usageMonthly.apiKeyId, keyId))).get();
+        const used = row?.t ?? 0;
+        if (used + tokens > monthlyLimit)
+            return { allowed: false, reason: 'monthly' };
+    }
+    return { allowed: true };
+}
+export function consumeUsage(keyId, inputTokens, outputTokens) {
+    const db = getDb();
+    const now = new Date();
+    const day = now.toISOString().slice(0, 10);
+    const month = now.toISOString().slice(0, 7);
+    const total = inputTokens + outputTokens;
+    db.insert(schema.usageDaily)
+        .values({ day, apiKeyId: keyId, inputTokens, outputTokens, totalTokens: total })
+        .onConflictDoUpdate({
+        target: [schema.usageDaily.day, schema.usageDaily.apiKeyId],
+        set: {
+            inputTokens: sql `input_tokens + ${inputTokens}`,
+            outputTokens: sql `output_tokens + ${outputTokens}`,
+            totalTokens: sql `total_tokens + ${total}`,
+        },
+    })
+        .run();
+    db.insert(schema.usageMonthly)
+        .values({ month, apiKeyId: keyId, inputTokens, outputTokens, totalTokens: total })
+        .onConflictDoUpdate({
+        target: [schema.usageMonthly.month, schema.usageMonthly.apiKeyId],
+        set: {
+            inputTokens: sql `input_tokens + ${inputTokens}`,
+            outputTokens: sql `output_tokens + ${outputTokens}`,
+            totalTokens: sql `total_tokens + ${total}`,
+        },
+    })
+        .run();
+}