| import type { Db } from '../db/types.js'; | |
| import type { Scheduler } from '../lib/scheduler.js'; | |
| import { discoverEndpointModels } from './model-discovery.js'; | |
| import { registerCustomModels, type CustomModelEntry } from './custom-model-register.js'; | |
| import { isCustomModelTombstoned } from './custom-model-tombstone.js'; | |
| import { listCustomEndpoints } from './custom-endpoint.js'; | |
| import { endpointScopeForBaseUrl } from '../lib/endpoint-scope.js'; | |
| // ── Scheduled custom-model sync (#674/#663/#656) ───────────────────────────── | |
| // | |
| // Operators add a custom OpenAI-compatible provider and fetch its model list | |
| // once, but providers change their model availability almost daily. This walks | |
| // every configured custom endpoint on a schedule and registers whatever NEW | |
| // models it now serves, reusing the exact same registration path as the manual | |
| // POST /custom (see custom-model-register.ts) so the two can never drift. | |
| // | |
| // Deliberate bounds: | |
| // - ADD ONLY. Models that disappear upstream are left alone — an automated | |
| // pass must never delete a row the operator may have tuned by hand. | |
| // - One failing endpoint is logged and skipped; the others still sync, so a | |
| // dead relay cannot hold the whole schedule hostage. | |
| // - No catalog paywall interplay: these models come from the operator's own | |
| // endpoint with the operator's own key, not from the published catalog. | |
| /** Default: once a day (#674 asks for daily; #663's 5-minute ask targets the | |
| * bundled free catalog, which this pass deliberately never touches). */ | |
| const DEFAULT_SYNC_INTERVAL_MS = 24 * 60 * 60 * 1000; | |
| /** Interval in ms from `CUSTOM_MODEL_SYNC_INTERVAL_MS`; 0 disables the pass, | |
| * anything unset or malformed falls back to the daily default. */ | |
| export function customModelSyncIntervalMs(): number { | |
| const raw = process.env.CUSTOM_MODEL_SYNC_INTERVAL_MS; | |
| if (raw === undefined || raw.trim() === '') return DEFAULT_SYNC_INTERVAL_MS; | |
| const ms = Number(raw); | |
| return Number.isFinite(ms) && ms >= 0 ? ms : DEFAULT_SYNC_INTERVAL_MS; | |
| } | |
| /** Comma-separated glob patterns of model ids that are known-free (#746). | |
| * When set, the sync registers ONLY models matching a pattern — anything else | |
| * (presumably paid) is skipped, honoring the repo's free-only policy. When | |
| * unset, the sync keeps its legacy behavior of registering everything, so | |
| * existing operators are unaffected. */ | |
| export function customModelSyncFreePatterns(): string[] { | |
| const raw = process.env.CUSTOM_MODEL_SYNC_FREE_PATTERNS; | |
| if (raw === undefined || raw.trim() === '') return []; | |
| return raw.split(',').map(p => p.trim()).filter(p => p.length > 0); | |
| } | |
| /** Glob match where `*` matches any run of chars (incl. empty). */ | |
| function patternMatches(pattern: string, id: string): boolean { | |
| const escaped = pattern.split('*').map(seg => seg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')); | |
| return new RegExp(`^${escaped.join('.*')}$`).test(id); | |
| } | |
| export interface CustomModelSyncResult { | |
| endpoints: number; | |
| /** Models registered for the first time. */ | |
| added: number; | |
| /** Models already on this endpoint that were skipped. */ | |
| skipped: number; | |
| /** Models skipped because they matched no free pattern (#746). */ | |
| paidSkipped: number; | |
| /** Models skipped because the operator deleted them and they must stay deleted (#926). */ | |
| tombstoned: number; | |
| /** Models skipped because they are discernibly not chat models — embedding, | |
| * image, audio, transcription or video ids (#1051). Registering those as | |
| * chat models is how they used to 404 forever. */ | |
| nonChatSkipped: number; | |
| failures: Array<{ baseUrl: string; error: string }>; | |
| } | |
| /** Sync every configured custom endpoint once. Exported so tests (and an admin | |
| * that wants a manual pass) can run it directly without waiting for the timer. */ | |
| export async function runCustomModelSync(db: Db): Promise<CustomModelSyncResult> { | |
| const endpoints = listCustomEndpoints(db); | |
| const result: CustomModelSyncResult = { endpoints: endpoints.length, added: 0, skipped: 0, paidSkipped: 0, tombstoned: 0, nonChatSkipped: 0, failures: [] }; | |
| for (const endpoint of endpoints) { | |
| try { | |
| // A submitted key wins on the manual route; a scheduled pass can only use | |
| // what the endpoint already has on record. Keyless local servers keep the | |
| // 'no-key' sentinel, which the provider turns into an anonymous call | |
| // with no Authorization header (#1331). | |
| const discovered = await discoverEndpointModels(endpoint.baseUrl, endpoint.apiKey ?? 'no-key'); | |
| const scope = endpointScopeForBaseUrl(endpoint.baseUrl); | |
| const registeredIds = new Set( | |
| (db.prepare("SELECT model_id FROM models WHERE platform = 'custom' AND endpoint_scope = ?").all(scope) as { model_id: string }[]) | |
| .map(row => row.model_id), | |
| ); | |
| const freePatterns = customModelSyncFreePatterns(); | |
| const fresh: CustomModelEntry[] = []; | |
| for (const model of discovered) { | |
| if (registeredIds.has(model.id)) { | |
| result.skipped += 1; | |
| continue; | |
| } | |
| // #926: the operator deleted this model (or the key that owned it) and | |
| // expects it to stay gone. The sync's "add only" contract must not turn | |
| // a deliberate deletion into the next pass's "new model". | |
| if (isCustomModelTombstoned(db, scope, model.id)) { | |
| result.tombstoned += 1; | |
| continue; | |
| } | |
| // Free-only policy (#746): when FREE_PATTERNS is configured, a model | |
| // that matches none of the known-free patterns is presumably paid and | |
| // is skipped rather than silently registered. | |
| if (freePatterns.length > 0 && !freePatterns.some(p => patternMatches(p, model.id))) { | |
| result.paidSkipped += 1; | |
| continue; | |
| } | |
| // #1051: a diffusion/whisper/video/embedding id is not a chat model, | |
| // and registering it here is how it ends up 404ing in every chain. | |
| // The sync only ADDS chat models; media and embedding models go | |
| // through their own explicit registration paths. | |
| if (model.kind !== undefined) { | |
| result.nonChatSkipped += 1; | |
| continue; | |
| } | |
| // Bare id only, like the dashboard's bulk "Fetch models" submit: no name | |
| // or capability claims invented here, they resolve in SQL on insert. | |
| fresh.push({ modelId: model.id, displayName: null }); | |
| } | |
| if (fresh.length > 0) { | |
| const registered = registerCustomModels(db, endpoint.baseUrl, undefined, undefined, endpoint.keyId, fresh); | |
| result.added += registered.registered.filter(m => m.created).length; | |
| } | |
| } catch (err: any) { | |
| const message = err?.message ?? String(err); | |
| result.failures.push({ baseUrl: endpoint.baseUrl, error: message }); | |
| console.error(`[custom-model-sync] ${endpoint.baseUrl}: ${message}`); | |
| } | |
| } | |
| return result; | |
| } | |
| /** Register the daily pass on the server's scheduler. Returns null when the | |
| * interval is configured to 0 (disabled). */ | |
| export function startCustomModelSync(db: Db, scheduler: Scheduler): (() => void) | null { | |
| const intervalMs = customModelSyncIntervalMs(); | |
| if (intervalMs <= 0) return null; | |
| return scheduler.every(intervalMs, () => { void runCustomModelSync(db); }, { name: 'custom-model-sync' }); | |
| } | |