ldrouter 1.5.1

package/dist/server/logging/logger.js

@@ -0,0 +1,35 @@
+import pino from 'pino';
+import { loadConfig } from '../config/index.js';
+let _logger = null;
+export function getLogger() {
+    if (_logger)
+        return _logger;
+    const cfg = loadConfig();
+    _logger = pino({
+        level: cfg.logLevel,
+        base: { app: 'latedev-router', version: cfg.appVersion },
+        redact: {
+            paths: [
+                'req.headers.authorization',
+                'req.headers["x-api-key"]',
+                'req.headers.cookie',
+                'res.headers["set-cookie"]',
+                'apiKey',
+                'apiKeyPlain',
+                'provider.apiKey',
+                'provider.encrypted_api_key',
+                'masterKey',
+                'totpSecret',
+                'recoveryCodes',
+                'password',
+                'currentPassword',
+                'newPassword',
+            ],
+            censor: '[redacted]',
+        },
+        transport: cfg.env === 'development'
+            ? { target: 'pino-pretty', options: { colorize: true, translateTime: 'SYS:HH:MM:ss' } }
+            : undefined,
+    });
+    return _logger;
+}

package/dist/server/maintenance/retention.js

@@ -0,0 +1,48 @@
+// Retention cleanup: chunked deletion of old request logs.
+// Audit logs are NEVER deleted here.
+import { lt, sql } from 'drizzle-orm';
+import { getDb, schema } from '../db/index.js';
+import { getSettings } from '../db/repositories/settings.js';
+import fs from 'node:fs';
+import path from 'node:path';
+const BATCH_SIZE = 1000;
+export function runRetentionCleanup(now = new Date(), opts = {}) {
+    const s = getSettings();
+    const cutoff = new Date(now.getTime() - s.retentionDays * 24 * 3600 * 1000).toISOString();
+    const db = getDb();
+    let deletedAttempts = 0;
+    let deletedRequests = 0;
+    if (opts.dryRun) {
+        const row = db.select({ c: sql `COUNT(*)` }).from(schema.requests).where(lt(schema.requests.createdAt, cutoff)).get();
+        return { deletedRequests: Number(row?.c ?? 0), deletedAttempts: 0, dryRun: true, cutoff };
+    }
+    // Cascade delete attempts
+    while (true) {
+        const rows = db
+            .select({ id: schema.requests.id })
+            .from(schema.requests)
+            .where(lt(schema.requests.createdAt, cutoff))
+            .limit(BATCH_SIZE)
+            .all();
+        if (rows.length === 0)
+            break;
+        const ids = rows.map((r) => r.id);
+        const del = db.delete(schema.requests).where(sql `id IN (${sql.join(ids.map((i) => sql `${i}`), sql `, `)})`).run();
+        deletedRequests += del.changes ?? 0;
+        if (rows.length < BATCH_SIZE)
+            break;
+    }
+    return { deletedRequests, deletedAttempts, dryRun: false, cutoff };
+}
+export function applyDbSizeGuard(dataDir) {
+    const s = getSettings();
+    const dbFile = path.join(dataDir, 'data.sqlite');
+    const walFile = path.join(dataDir, 'data.sqlite-wal');
+    const before = (fs.existsSync(dbFile) ? fs.statSync(dbFile).size : 0) + (fs.existsSync(walFile) ? fs.statSync(walFile).size : 0);
+    const limitBytes = s.dbSizeLimitMb * 1024 * 1024;
+    if (before <= limitBytes)
+        return { triggered: false, before, after: before };
+    const result = runRetentionCleanup();
+    const after = (fs.existsSync(dbFile) ? fs.statSync(dbFile).size : 0) + (fs.existsSync(walFile) ? fs.statSync(walFile).size : 0);
+    return { triggered: result.deletedRequests > 0, before, after };
+}

package/dist/server/metrics/registry.js

@@ -0,0 +1,169 @@
+// Prometheus-style metrics registry. Lightweight, no external dep.
+class CounterImpl {
+    name;
+    help;
+    series = [];
+    constructor(name, help) {
+        this.name = name;
+        this.help = help;
+    }
+    inc(labels = {}, n = 1) {
+        const found = this.series.find((s) => sameLabels(s.labels, labels));
+        if (found)
+            found.value += n;
+        else
+            this.series.push({ labels, value: n });
+        registryMetrics.push(this);
+    }
+    value(labels = {}) {
+        const found = this.series.find((s) => sameLabels(s.labels, labels));
+        return found?.value ?? 0;
+    }
+    render() {
+        if (this.series.length === 0)
+            return `# HELP ${this.name} ${this.help}\n# TYPE ${this.name} counter\n`;
+        return `# HELP ${this.name} ${this.help}\n# TYPE ${this.name} counter\n${this.series
+            .map((s) => `${this.name}${labelString(s.labels)} ${s.value}`)
+            .join('\n')}\n`;
+    }
+}
+const DEFAULT_BUCKETS_MS = [10, 50, 100, 250, 500, 1000, 2500, 5000, 10000, 30000, 60000, 120000, 300000];
+class HistogramImpl {
+    name;
+    help;
+    buckets;
+    series = [];
+    constructor(name, help, buckets) {
+        this.name = name;
+        this.help = help;
+        this.buckets = buckets;
+    }
+    observe(valueMs, labels = {}) {
+        let s = this.series.find((x) => sameLabels(x.labels, labels));
+        if (!s) {
+            s = { labels, buckets: [...this.buckets], counts: new Array(this.buckets.length).fill(0), count: 0, sum: 0 };
+            this.series.push(s);
+        }
+        s.count += 1;
+        s.sum += valueMs;
+        for (let i = 0; i < this.buckets.length; i++) {
+            if (valueMs <= this.buckets[i])
+                s.counts[i] += 1;
+        }
+        registryMetrics.push(this);
+    }
+    snapshot() {
+        return this.series.map((s) => ({
+            buckets: s.buckets.map((le, i) => ({ le, count: s.counts[i] })),
+            count: s.count,
+            sum: s.sum,
+            labels: Object.keys(s.labels),
+        }))[0] ?? { buckets: [], count: 0, sum: 0, labels: [] };
+    }
+    render() {
+        if (this.series.length === 0)
+            return `# HELP ${this.name} ${this.help}\n# TYPE ${this.name} histogram\n`;
+        let out = `# HELP ${this.name} ${this.help}\n# TYPE ${this.name} histogram\n`;
+        for (const s of this.series) {
+            for (let i = 0; i < s.buckets.length; i++) {
+                const count = s.counts[i];
+                out += `${this.name}_bucket{${labelString({ ...s.labels, le: String(s.buckets[i]) }, true)} ${count}\n`;
+            }
+            out += `${this.name}_bucket{${labelString({ ...s.labels, le: '+Inf' }, true)} ${s.count}\n`;
+            out += `${this.name}_count${labelString(s.labels)} ${s.count}\n`;
+            out += `${this.name}_sum${labelString(s.labels)} ${s.sum}\n`;
+        }
+        return out;
+    }
+}
+class GaugeImpl {
+    name;
+    help;
+    series = [];
+    constructor(name, help) {
+        this.name = name;
+        this.help = help;
+    }
+    set(v, labels = {}) {
+        const f = this.series.find((s) => sameLabels(s.labels, labels));
+        if (f)
+            f.value = v;
+        else
+            this.series.push({ labels, value: v });
+        registryMetrics.push(this);
+    }
+    inc(labels = {}, n = 1) { this.set(this.value(labels) + n, labels); }
+    dec(labels = {}, n = 1) { this.set(this.value(labels) - n, labels); }
+    value(labels = {}) { return this.series.find((s) => sameLabels(s.labels, labels))?.value ?? 0; }
+    render() {
+        if (this.series.length === 0)
+            return `# HELP ${this.name} ${this.help}\n# TYPE ${this.name} gauge\n`;
+        return `# HELP ${this.name} ${this.help}\n# TYPE ${this.name} gauge\n${this.series
+            .map((s) => `${this.name}${labelString(s.labels)} ${s.value}`)
+            .join('\n')}\n`;
+    }
+}
+function sameLabels(a, b) {
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    if (ak.length !== bk.length)
+        return false;
+    for (const k of ak)
+        if (a[k] !== b[k])
+            return false;
+    return true;
+}
+function labelString(labels, skipEmpty = false) {
+    const keys = Object.keys(labels);
+    if (keys.length === 0)
+        return '';
+    const filtered = skipEmpty ? keys.filter((k) => labels[k] !== undefined) : keys;
+    if (filtered.length === 0)
+        return '';
+    return `{${filtered.map((k) => `${k}="${(labels[k] ?? '').replace(/"/g, '\\"')}"`).join(',')}}`;
+}
+const registryMetrics = [];
+export const metricsRegistry = {
+    _logger: null,
+    init(logger) {
+        this._logger = logger;
+    },
+    counter(name, help) {
+        return new CounterImpl(name, help);
+    },
+    histogram(name, help, bucketsMs = DEFAULT_BUCKETS_MS) {
+        return new HistogramImpl(name, help, bucketsMs);
+    },
+    gauge(name, help) {
+        return new GaugeImpl(name, help);
+    },
+    render() {
+        const seen = new Set();
+        let out = '';
+        for (const m of registryMetrics) {
+            if (seen.has(m))
+                continue;
+            seen.add(m);
+            out += m.render();
+        }
+        return out;
+    },
+};
+// Predefined metrics used across the app
+export const metrics = {
+    requestsTotal: metricsRegistry.counter('latedev_requests_total', 'Total gateway requests by protocol and status class'),
+    requestDuration: metricsRegistry.histogram('latedev_request_duration_ms', 'Gateway request duration in ms'),
+    requestTtft: metricsRegistry.histogram('latedev_request_ttft_ms', 'Time to first token in ms'),
+    attemptsTotal: metricsRegistry.counter('latedev_upstream_attempts_total', 'Upstream attempts by provider and result'),
+    attemptDuration: metricsRegistry.histogram('latedev_upstream_attempt_duration_ms', 'Upstream attempt duration in ms'),
+    tokensInput: metricsRegistry.counter('latedev_tokens_input_total', 'Input tokens processed'),
+    tokensOutput: metricsRegistry.counter('latedev_tokens_output_total', 'Output tokens processed'),
+    tokensCacheRead: metricsRegistry.counter('latedev_tokens_cache_read_total', 'Provider cache read tokens'),
+    tokensCacheWrite: metricsRegistry.counter('latedev_tokens_cache_write_total', 'Provider cache write tokens'),
+    tokensReasoning: metricsRegistry.counter('latedev_tokens_reasoning_total', 'Reasoning tokens processed'),
+    fallbackCount: metricsRegistry.counter('latedev_fallback_total', 'Number of fallback transitions'),
+    activeRequests: metricsRegistry.gauge('latedev_active_requests', 'Number of in-flight gateway requests'),
+    circuitState: metricsRegistry.gauge('latedev_provider_circuit_state', 'Provider circuit state (0=closed, 1=open)'),
+    rateLimited: metricsRegistry.counter('latedev_rate_limited_total', 'Number of rate-limit denials'),
+    cacheHits: metricsRegistry.counter('latedev_gateway_cache_hits_total', 'Gateway response cache hits'),
+};

package/dist/server/protocols/anthropic.js

@@ -0,0 +1,154 @@
+// Anthropic <-> canonical protocol layer.
+export function anthropicToCanonical(req) {
+    const messages = [];
+    for (const m of req.messages) {
+        if (m.role === 'user') {
+            messages.push({ role: 'user', content: parseAnthropicUserContent(m.content) });
+        }
+        else if (m.role === 'assistant') {
+            const blocks = [];
+            const arr = Array.isArray(m.content) ? m.content : null;
+            if (arr) {
+                for (const b of arr) {
+                    if (b.type === 'text' && b.text)
+                        blocks.push({ type: 'text', text: b.text });
+                    if (b.type === 'tool_use' && b.id && b.name)
+                        blocks.push({ type: 'tool_use', toolUse: { id: b.id, name: b.name, input: b.input ?? {} } });
+                }
+            }
+            else {
+                blocks.push({ type: 'text', text: String(m.content) });
+            }
+            messages.push({ role: 'assistant', content: blocks });
+        }
+    }
+    const tools = req.tools?.map((t) => ({ name: t.name, description: t.description, inputSchema: t.input_schema }));
+    let system;
+    if (typeof req.system === 'string')
+        system = req.system;
+    else if (Array.isArray(req.system))
+        system = req.system.map((b) => b.text).join('\n');
+    return {
+        model: req.model,
+        messages,
+        system,
+        tools,
+        temperature: req.temperature,
+        topP: req.top_p,
+        maxOutputTokens: req.max_tokens,
+        stop: req.stop_sequences,
+        stream: Boolean(req.stream),
+        reasoning: req.thinking ? { budgetTokens: req.thinking.budget_tokens } : undefined,
+    };
+}
+function parseAnthropicUserContent(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', text: content }];
+    const out = [];
+    for (const b of content) {
+        if (b.type === 'text' && b.text)
+            out.push({ type: 'text', text: b.text });
+        if (b.type === 'image' && b.source) {
+            if (b.source.type === 'base64') {
+                out.push({ type: 'image', image: { base64: b.source.data, mimeType: b.source.media_type } });
+            }
+            else if (b.source.type === 'url') {
+                out.push({ type: 'image', image: { url: b.source.data } });
+            }
+        }
+        if (b.type === 'tool_result') {
+            out.push({
+                type: 'tool_result',
+                toolResult: {
+                    toolUseId: b.tool_use_id ?? '',
+                    content: typeof b.content === 'string' ? b.content : JSON.stringify(b.content ?? null),
+                    isError: b.is_error,
+                },
+            });
+        }
+    }
+    return out;
+}
+export function canonicalToAnthropicRequest(req, targetModel) {
+    const messages = [];
+    for (const m of req.messages) {
+        if (m.role === 'user') {
+            const allText = m.content.every((b) => b.type === 'text');
+            if (allText) {
+                messages.push({ role: 'user', content: m.content.map((b) => b.text ?? '').join('') });
+            }
+            else {
+                const blocks = [];
+                for (const b of m.content) {
+                    if (b.type === 'text' && b.text)
+                        blocks.push({ type: 'text', text: b.text });
+                    if (b.type === 'image' && b.image?.base64)
+                        blocks.push({ type: 'image', source: { type: 'base64', media_type: b.image.mimeType ?? 'image/png', data: b.image.base64 } });
+                    if (b.type === 'image' && b.image?.url)
+                        blocks.push({ type: 'image', source: { type: 'url', media_type: 'image/png', data: b.image.url } });
+                    if (b.type === 'tool_result')
+                        blocks.push({ type: 'tool_result', tool_use_id: b.toolResult.toolUseId, content: b.toolResult.content, is_error: b.toolResult.isError });
+                }
+                messages.push({ role: 'user', content: blocks });
+            }
+        }
+        else if (m.role === 'assistant') {
+            const blocks = [];
+            for (const b of m.content) {
+                if (b.type === 'text' && b.text)
+                    blocks.push({ type: 'text', text: b.text });
+                if (b.type === 'tool_use' && b.toolUse)
+                    blocks.push({ type: 'tool_use', id: b.toolUse.id, name: b.toolUse.name, input: b.toolUse.input });
+            }
+            messages.push({ role: 'assistant', content: blocks });
+        }
+        // role 'tool' is mapped into user with tool_result in Anthropic — already done above
+    }
+    const out = {
+        model: targetModel,
+        messages,
+        stream: req.stream,
+        max_tokens: req.maxOutputTokens ?? 1024,
+    };
+    if (req.system)
+        out.system = req.system;
+    if (req.temperature !== undefined)
+        out.temperature = req.temperature;
+    if (req.topP !== undefined)
+        out.top_p = req.topP;
+    if (req.stop)
+        out.stop_sequences = req.stop;
+    if (req.tools)
+        out.tools = req.tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.inputSchema }));
+    if (req.reasoning?.budgetTokens)
+        out.thinking = { type: 'enabled', budget_tokens: req.reasoning.budgetTokens };
+    return out;
+}
+export function anthropicResponseToCanonical(res, requestedModel) {
+    const text = res.content.filter((b) => b.type === 'text').map((b) => b.text).join('');
+    const toolCalls = res.content.filter((b) => b.type === 'tool_use').map((b) => {
+        const t = b;
+        return { id: t.id, name: t.name, input: t.input };
+    });
+    return {
+        model: requestedModel,
+        text,
+        toolCalls,
+        finishReason: res.stop_reason ?? null,
+        usage: {
+            input: res.usage.input_tokens ?? 0,
+            output: res.usage.output_tokens ?? 0,
+            cacheRead: res.usage.cache_read_input_tokens ?? 0,
+            cacheWrite: res.usage.cache_creation_input_tokens ?? 0,
+            reasoning: 0,
+            total: (res.usage.input_tokens ?? 0) + (res.usage.output_tokens ?? 0),
+        },
+    };
+}
+export function anthropicModelList(models) {
+    return {
+        data: models.map((m) => ({ type: 'model', id: m.publicModelId, display_name: m.upstreamModelId })),
+        first_id: models[0]?.publicModelId ?? null,
+        has_more: false,
+    };
+}

package/dist/server/protocols/canonical.js

@@ -0,0 +1,201 @@
+// Canonical protocol layer: OpenAI <-> canonical, Anthropic <-> canonical.
+import { GatewayError } from '../errors.js';
+export function openAIToCanonical(req) {
+    const messages = [];
+    let systemText;
+    for (const m of req.messages) {
+        if (m.role === 'system' || m.role === 'developer') {
+            const t = extractText(m.content);
+            if (t)
+                systemText = (systemText ? systemText + '\n' : '') + t;
+            continue;
+        }
+        if (m.role === 'user') {
+            messages.push({ role: 'user', content: normalizeContent(m.content) });
+            continue;
+        }
+        if (m.role === 'assistant') {
+            const blocks = [];
+            if (typeof m.content === 'string' && m.content)
+                blocks.push({ type: 'text', text: m.content });
+            else if (Array.isArray(m.content)) {
+                for (const c of m.content) {
+                    if (c.type === 'text' && c.text)
+                        blocks.push({ type: 'text', text: c.text });
+                    else if (c.type === 'image_url' && c.image_url)
+                        blocks.push({ type: 'image', image: { url: c.image_url.url } });
+                }
+            }
+            if (m.tool_calls) {
+                for (const tc of m.tool_calls) {
+                    blocks.push({ type: 'tool_use', toolUse: { id: tc.id, name: tc.function.name, input: safeJson(tc.function.arguments) } });
+                }
+            }
+            messages.push({ role: 'assistant', content: blocks });
+            continue;
+        }
+        if (m.role === 'tool') {
+            const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+            messages.push({
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool_result',
+                        toolResult: { toolUseId: m.tool_call_id ?? 'unknown', content },
+                    },
+                ],
+            });
+        }
+    }
+    const tools = req.tools?.map((t) => ({
+        name: t.function.name,
+        description: t.function.description,
+        inputSchema: t.function.parameters,
+    }));
+    let responseFormat;
+    if (req.response_format) {
+        if (req.response_format.type === 'json_schema' && req.response_format.json_schema) {
+            responseFormat = { type: 'json_schema', jsonSchema: req.response_format.json_schema.schema };
+        }
+        else if (req.response_format.type === 'json_object') {
+            responseFormat = { type: 'json_object' };
+        }
+        else {
+            responseFormat = { type: 'text' };
+        }
+    }
+    return {
+        model: req.model,
+        messages,
+        system: systemText,
+        tools,
+        temperature: req.temperature,
+        topP: req.top_p,
+        maxOutputTokens: req.max_tokens,
+        stop: Array.isArray(req.stop) ? req.stop : req.stop ? [req.stop] : undefined,
+        stream: Boolean(req.stream),
+        responseFormat,
+        reasoning: req.reasoning_effort ? { effort: req.reasoning_effort } : undefined,
+    };
+}
+export function canonicalToOpenAIRequest(req, targetModel) {
+    const out = {
+        model: targetModel,
+        stream: req.stream,
+        messages: [],
+    };
+    if (req.system)
+        out.messages.push({ role: 'system', content: req.system });
+    for (const m of req.messages) {
+        if (m.role === 'user') {
+            const text = m.content.map((b) => (b.type === 'text' ? b.text : '')).join('');
+            if (m.content.every((b) => b.type === 'text')) {
+                out.messages.push({ role: 'user', content: text });
+            }
+            else {
+                const blocks = [];
+                for (const b of m.content) {
+                    if (b.type === 'text' && b.text)
+                        blocks.push({ type: 'text', text: b.text });
+                    if (b.type === 'image' && b.image?.url)
+                        blocks.push({ type: 'image_url', image_url: { url: b.image.url } });
+                    if (b.type === 'image' && b.image?.base64)
+                        blocks.push({ type: 'image_url', image_url: { url: `data:${b.image.mimeType ?? 'image/png'};base64,${b.image.base64}` } });
+                }
+                out.messages.push({ role: 'user', content: blocks });
+            }
+        }
+        else if (m.role === 'assistant') {
+            const text = m.content.filter((b) => b.type === 'text').map((b) => b.text ?? '').join('');
+            const toolCalls = m.content.filter((b) => b.type === 'tool_use').map((b) => ({
+                id: b.toolUse.id,
+                type: 'function',
+                function: { name: b.toolUse.name, arguments: typeof b.toolUse.input === 'string' ? b.toolUse.input : JSON.stringify(b.toolUse.input) },
+            }));
+            out.messages.push({ role: 'assistant', content: text || null, ...(toolCalls.length ? { tool_calls: toolCalls } : {}) });
+        }
+        else if (m.role === 'tool') {
+            for (const b of m.content) {
+                if (b.type === 'tool_result') {
+                    out.messages.push({ role: 'tool', content: typeof b.toolResult.content === 'string' ? b.toolResult.content : JSON.stringify(b.toolResult.content), tool_call_id: b.toolResult.toolUseId });
+                }
+            }
+        }
+    }
+    if (req.tools)
+        out.tools = req.tools.map((t) => ({ type: 'function', function: { name: t.name, description: t.description, parameters: t.inputSchema } }));
+    if (req.temperature !== undefined)
+        out.temperature = req.temperature;
+    if (req.topP !== undefined)
+        out.top_p = req.topP;
+    if (req.maxOutputTokens !== undefined)
+        out.max_tokens = req.maxOutputTokens;
+    if (req.stop)
+        out.stop = req.stop;
+    if (req.responseFormat) {
+        if (req.responseFormat.type === 'json_schema' && req.responseFormat.jsonSchema) {
+            out.response_format = { type: 'json_schema', json_schema: { schema: req.responseFormat.jsonSchema } };
+        }
+        else if (req.responseFormat.type === 'json_object') {
+            out.response_format = { type: 'json_object' };
+        }
+        else {
+            out.response_format = { type: 'text' };
+        }
+    }
+    if (req.reasoning?.effort)
+        out.reasoning_effort = req.reasoning.effort;
+    return out;
+}
+export function openAIResponseToCanonical(res, requestedModel) {
+    const choice = res.choices[0];
+    return {
+        model: requestedModel,
+        text: choice?.message?.content ?? '',
+        toolCalls: (choice?.message?.tool_calls ?? []).map((tc) => ({ id: tc.id, name: tc.function.name, input: safeJson(tc.function.arguments) })),
+        finishReason: choice?.finish_reason ?? null,
+        usage: {
+            input: res.usage?.prompt_tokens ?? 0,
+            output: res.usage?.completion_tokens ?? 0,
+            cacheRead: res.usage?.prompt_tokens_details?.cached_tokens ?? 0,
+            cacheWrite: 0,
+            reasoning: res.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
+            total: res.usage?.total_tokens ?? 0,
+        },
+    };
+}
+function extractText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((b) => (b.type === 'text' ? b.text ?? '' : '')).join('');
+    }
+    return '';
+}
+function normalizeContent(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', text: content }];
+    if (Array.isArray(content)) {
+        const out = [];
+        for (const b of content) {
+            if (b.type === 'text' && b.text)
+                out.push({ type: 'text', text: b.text });
+            if (b.type === 'image_url' && b.image_url)
+                out.push({ type: 'image', image: { url: b.image_url.url } });
+        }
+        return out;
+    }
+    throw new GatewayError('invalid_request_error', 'Unsupported message content', { status: 400 });
+}
+function safeJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return s;
+    }
+}
+// OpenAI model list
+export function openAIModelList(models) {
+    return { object: 'list', data: models.map((m) => ({ id: m.publicModelId, object: 'model', created: 0, owned_by: m.publicModelId.split('/')[0] })) };
+}