llm-simple-router 0.2.0 → 0.3.6

package/dist/middleware/auth.js

@@ -4,6 +4,7 @@ import { isInitialized } from "../db/settings.js";
 import { insertRequestLog } from "../db/logs.js";
 const SKIP_PATHS = ["/health", "/admin"];
 const HTTP_UNAUTHORIZED = 401;
+const HTTP_SERVICE_UNAVAILABLE = 503;
 const BEARER_PREFIX_LENGTH = "Bearer ".length;
 function shouldSkipAuth(url) {
     const path = url.split("?")[0];
@@ -56,15 +57,15 @@ const authMiddlewareRaw = (app, options, done) => {
         // 未初始化时代理层不可用
         if (!isInitialized(options.db)) {
             if (proxyApiType) {
-                logRejectedAuth(options.db, proxyApiType, 503, "Service not initialized", request);
+                logRejectedAuth(options.db, proxyApiType, HTTP_SERVICE_UNAVAILABLE, "Service not initialized", request);
             }
-            reply.code(503).send({ error: { message: "Service not initialized" } });
+            reply.code(HTTP_SERVICE_UNAVAILABLE).send({ error: { message: "Service not initialized" } });
             return reply;
         }
         const authHeader = request.headers.authorization;
         if (!authHeader || !authHeader.startsWith("Bearer ")) {
             if (proxyApiType) {
-                logRejectedAuth(options.db, proxyApiType, 401, "Invalid API key", request);
+                logRejectedAuth(options.db, proxyApiType, HTTP_UNAUTHORIZED, "Invalid API key", request);
             }
             unauthorizedReply(reply);
             return reply;
@@ -74,7 +75,7 @@ const authMiddlewareRaw = (app, options, done) => {
         const row = stmt.get(hash);
         if (!row) {
             if (proxyApiType) {
-                logRejectedAuth(options.db, proxyApiType, 401, "Invalid API key", request);
+                logRejectedAuth(options.db, proxyApiType, HTTP_UNAUTHORIZED, "Invalid API key", request);
             }
             unauthorizedReply(reply);
             return reply;

package/dist/monitor/request-tracker.d.ts

@@ -0,0 +1,49 @@
+import type { ServerResponse } from "node:http";
+import { StatsAggregator } from "./stats-aggregator.js";
+import { RuntimeCollector } from "./runtime-collector.js";
+import type { ProviderSemaphoreManager } from "../proxy/semaphore.js";
+import type { ActiveRequest, ProviderConcurrencySnapshot, RuntimeMetrics, StatsSnapshot } from "./types.js";
+export declare class RequestTracker {
+    private activeMap;
+    private recentCompleted;
+    private clients;
+    private providerConfigCache;
+    private pushTimer;
+    private tickCount;
+    /** Visible for testing */
+    readonly statsAggregator: StatsAggregator;
+    readonly runtimeCollector: RuntimeCollector;
+    private readonly semaphoreManager?;
+    constructor(deps?: {
+        semaphoreManager?: ProviderSemaphoreManager;
+        runtimeCollector?: RuntimeCollector;
+    });
+    start(req: ActiveRequest): void;
+    update(id: string, patch: Partial<ActiveRequest>): void;
+    appendStreamChunk(id: string, rawLine: string, apiType: "openai" | "anthropic", maxRaw: number, maxText: number): void;
+    complete(id: string, result: {
+        status: "completed" | "failed";
+        statusCode?: number;
+    }): void;
+    getActive(): ActiveRequest[];
+    getRecent(limit?: number): ActiveRequest[];
+    get(id: string): ActiveRequest | undefined;
+    getStats(): StatsSnapshot;
+    getConcurrency(): ProviderConcurrencySnapshot[];
+    getRuntime(): RuntimeMetrics;
+    addClient(res: ServerResponse): void;
+    removeClient(res: ServerResponse): void;
+    startPushInterval(): void;
+    stopPushInterval(): void;
+    broadcast(event: string, data: unknown): void;
+    updateProviderConfig(providerId: string, config: {
+        name: string;
+        maxConcurrency: number;
+        queueTimeoutMs: number;
+        maxQueueSize: number;
+    }): void;
+    removeProviderConfig(providerId: string): void;
+    private cleanupRecent;
+    /** 最终一致性兜底：清理异常残留的 active 条目 */
+    private cleanupStaleActive;
+}

package/dist/monitor/request-tracker.js

@@ -0,0 +1,279 @@
+import { StatsAggregator } from "./stats-aggregator.js";
+import { RuntimeCollector } from "./runtime-collector.js";
+function extractStreamText(line, apiType) {
+    const empty = { text: '', block: null };
+    if (!line.startsWith(SSE_DATA_PREFIX))
+        return empty;
+    const jsonStr = line.slice(SSE_DATA_PREFIX.length);
+    if (jsonStr === '[DONE]')
+        return empty;
+    let obj;
+    try {
+        obj = JSON.parse(jsonStr);
+    }
+    catch {
+        return empty;
+    }
+    if (apiType === 'openai') {
+        const choices = obj.choices;
+        const delta = choices?.[0]?.delta;
+        const text = delta?.content ?? '';
+        return { text, block: text ? { index: 0, type: 'text', content: text } : null };
+    }
+    // Anthropic
+    const type = obj.type;
+    const index = obj.index;
+    const delta = obj.delta;
+    if (type === 'content_block_start') {
+        const contentBlock = obj.content_block;
+        const blockType = contentBlock?.type;
+        const name = blockType === 'tool_use' ? contentBlock?.name : undefined;
+        if (blockType === 'thinking' || blockType === 'text' || blockType === 'tool_use') {
+            return { text: '', block: { index: index ?? 0, type: blockType, content: '', name } };
+        }
+        return empty;
+    }
+    if (type === 'content_block_delta' && delta) {
+        const deltaType = delta.type;
+        if (deltaType === 'thinking_delta') {
+            const thinking = delta.thinking ?? '';
+            return { text: '', block: { index: index ?? 0, type: 'thinking', content: thinking } };
+        }
+        if (deltaType === 'text_delta') {
+            const text = delta.text ?? '';
+            return { text, block: { index: index ?? 0, type: 'text', content: text } };
+        }
+        if (deltaType === 'input_json_delta') {
+            const partialJson = delta.partial_json ?? '';
+            return { text: '', block: { index: index ?? 0, type: 'tool_use', content: partialJson } };
+        }
+    }
+    return empty;
+}
+const SSE_DATA_PREFIX = "data: ";
+const RUNTIME_PUSH_TICK_INTERVAL = 2;
+const RECENT_COMPLETED_MAX = 200;
+const RECENT_TTL_MS = 5 * 60 * 1000; // eslint-disable-line no-magic-numbers
+const ACTIVE_MAX_AGE_MS = 60 * 60 * 1000; // eslint-disable-line no-magic-numbers
+const PUSH_INTERVAL_MS = 5000;
+export class RequestTracker {
+    activeMap = new Map();
+    recentCompleted = [];
+    clients = new Set();
+    providerConfigCache = new Map();
+    pushTimer = null;
+    tickCount = 0;
+    /** Visible for testing */
+    statsAggregator;
+    runtimeCollector;
+    semaphoreManager;
+    constructor(deps) {
+        this.semaphoreManager = deps?.semaphoreManager;
+        this.runtimeCollector = deps?.runtimeCollector ?? new RuntimeCollector();
+        this.statsAggregator = new StatsAggregator();
+    }
+    // --- Core methods ---
+    start(req) {
+        this.activeMap.set(req.id, { ...req });
+        this.broadcast("request_start", req);
+    }
+    update(id, patch) {
+        const req = this.activeMap.get(id);
+        if (!req)
+            return;
+        const prevQueued = req.queued;
+        Object.assign(req, patch);
+        // queued 状态变化时立即广播，让前端即时看到排队/取消排队
+        if (patch.queued !== undefined && patch.queued !== prevQueued) {
+            this.broadcast("request_update", this.getActive());
+        }
+    }
+    appendStreamChunk(id, rawLine, apiType, maxRaw, maxText) {
+        const req = this.activeMap.get(id);
+        if (!req)
+            return;
+        if (!req.streamContent) {
+            req.streamContent = { rawChunks: "", textContent: "", totalChars: 0, blocks: [] };
+        }
+        const sc = req.streamContent;
+        sc.totalChars += rawLine.length;
+        // 环形缓冲区：超过限制时截断保留尾部
+        sc.rawChunks += rawLine + "\n";
+        if (sc.rawChunks.length > maxRaw) {
+            sc.rawChunks = sc.rawChunks.slice(-maxRaw);
+        }
+        // 初始化 blocks 数组
+        if (!sc.blocks) {
+            sc.blocks = [];
+        }
+        const extracted = extractStreamText(rawLine, apiType);
+        // 拼接纯文本（text 和 text_delta）
+        if (extracted.text) {
+            sc.textContent += extracted.text;
+            if (sc.textContent.length > maxText) {
+                sc.textContent = sc.textContent.slice(-maxText);
+            }
+        }
+        // 维护结构化内容块
+        if (extracted.block) {
+            const { index, type, content, name } = extracted.block;
+            while (sc.blocks.length <= index) {
+                sc.blocks.push({ type: 'text', content: '' });
+            }
+            if (name) {
+                sc.blocks[index].name = name;
+            }
+            if (content === '' && type !== 'text') {
+                sc.blocks[index].type = type;
+            }
+            else if (content) {
+                sc.blocks[index].content += content;
+                sc.blocks[index].type = type;
+            }
+            const MAX_BLOCK_CONTENT = maxText;
+            for (const block of sc.blocks) {
+                if (block.content.length > MAX_BLOCK_CONTENT) {
+                    block.content = block.content.slice(-MAX_BLOCK_CONTENT);
+                }
+            }
+        }
+    }
+    complete(id, result) {
+        const req = this.activeMap.get(id);
+        if (!req)
+            return;
+        const now = Date.now();
+        const latency = now - req.startTime;
+        const statusCode = result.statusCode ?? 0;
+        this.statsAggregator.recordLatency(latency);
+        this.statsAggregator.recordRequest(req.providerId, req.providerName, statusCode, req.retryCount > 0, false);
+        this.statsAggregator.recordProviderLatency(req.providerId, latency);
+        const completed = {
+            ...req,
+            status: result.status,
+            completedAt: now,
+        };
+        this.activeMap.delete(id);
+        this.recentCompleted.unshift(completed);
+        if (this.recentCompleted.length > RECENT_COMPLETED_MAX) {
+            this.recentCompleted.length = RECENT_COMPLETED_MAX;
+        }
+        this.broadcast("request_complete", completed);
+    }
+    // --- Query methods ---
+    getActive() {
+        const result = [];
+        for (const req of this.activeMap.values()) {
+            if (req.status === "pending")
+                result.push(req);
+        }
+        return result;
+    }
+    getRecent(limit) {
+        const list = limit != null ? this.recentCompleted.slice(0, limit) : this.recentCompleted;
+        return list;
+    }
+    get(id) {
+        return this.activeMap.get(id) ?? this.recentCompleted.find((r) => r.id === id);
+    }
+    // --- Stats / monitoring ---
+    getStats() {
+        return this.statsAggregator.getStats();
+    }
+    getConcurrency() {
+        if (!this.semaphoreManager)
+            return [];
+        const result = [];
+        for (const [providerId, config] of this.providerConfigCache) {
+            const status = this.semaphoreManager.getStatus(providerId);
+            result.push({
+                providerId,
+                providerName: config.name,
+                maxConcurrency: config.maxConcurrency,
+                active: status.active,
+                queued: status.queued,
+                queueTimeoutMs: config.queueTimeoutMs,
+                maxQueueSize: config.maxQueueSize,
+            });
+        }
+        return result;
+    }
+    getRuntime() {
+        return this.runtimeCollector.collect();
+    }
+    // --- SSE client management ---
+    addClient(res) {
+        this.clients.add(res);
+        res.on("close", () => {
+            this.clients.delete(res);
+        });
+    }
+    removeClient(res) {
+        this.clients.delete(res);
+    }
+    // --- Push interval ---
+    startPushInterval() {
+        if (this.pushTimer)
+            return;
+        this.tickCount = 0;
+        this.pushTimer = setInterval(() => {
+            this.tickCount++;
+            this.cleanupRecent();
+            this.cleanupStaleActive();
+            this.broadcast("request_update", this.getActive());
+            this.broadcast("concurrency_update", this.getConcurrency());
+            this.broadcast("stats_update", this.getStats());
+            // Every 10s (every 2nd tick)
+            if (this.tickCount % RUNTIME_PUSH_TICK_INTERVAL === 0) {
+                this.broadcast("runtime_update", this.getRuntime());
+            }
+        }, PUSH_INTERVAL_MS);
+    }
+    stopPushInterval() {
+        if (this.pushTimer) {
+            clearInterval(this.pushTimer);
+            this.pushTimer = null;
+        }
+    }
+    broadcast(event, data) {
+        const msg = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+        for (const client of this.clients) {
+            try {
+                if (!client.writableEnded)
+                    client.write(msg);
+            }
+            catch {
+                this.clients.delete(client);
+            }
+        }
+    }
+    // --- Provider config cache ---
+    updateProviderConfig(providerId, config) {
+        this.providerConfigCache.set(providerId, config);
+    }
+    removeProviderConfig(providerId) {
+        this.providerConfigCache.delete(providerId);
+    }
+    // --- Internal ---
+    cleanupRecent() {
+        const cutoff = Date.now() - RECENT_TTL_MS;
+        // recentCompleted is sorted desc by completedAt, so we find the cutoff index
+        let i = 0;
+        for (; i < this.recentCompleted.length; i++) {
+            if (this.recentCompleted[i].completedAt != null &&
+                this.recentCompleted[i].completedAt < cutoff) {
+                break;
+            }
+        }
+        this.recentCompleted = this.recentCompleted.slice(0, Math.min(i, RECENT_COMPLETED_MAX));
+    }
+    /** 最终一致性兜底：清理异常残留的 active 条目 */
+    cleanupStaleActive() {
+        const cutoff = Date.now() - ACTIVE_MAX_AGE_MS;
+        for (const [id, req] of this.activeMap) {
+            if (req.startTime < cutoff) {
+                this.activeMap.delete(id);
+            }
+        }
+    }
+}

package/dist/monitor/runtime-collector.d.ts

@@ -0,0 +1,11 @@
+import type { RuntimeMetrics } from "./types.js";
+export declare class RuntimeCollector {
+    private histogram?;
+    /** Start monitoring the event loop delay histogram */
+    start(): void;
+    /** Stop monitoring and disable the histogram */
+    stop(): void;
+    /** Collect a single runtime metrics snapshot */
+    collect(): RuntimeMetrics;
+    private getEventLoopDelayMs;
+}

package/dist/monitor/runtime-collector.js

@@ -0,0 +1,41 @@
+import { performance } from "node:perf_hooks";
+const MS_PER_SECOND = 1000;
+const NS_PER_MS = 1e6;
+const perf = performance;
+const proc = process;
+export class RuntimeCollector {
+    histogram;
+    /** Start monitoring the event loop delay histogram */
+    start() {
+        if (this.histogram)
+            return;
+        if (typeof perf.monitorEventLoopDelay !== "function")
+            return;
+        this.histogram = perf.monitorEventLoopDelay({ resolution: 1 });
+        this.histogram.enable();
+    }
+    /** Stop monitoring and disable the histogram */
+    stop() {
+        if (this.histogram) {
+            this.histogram.disable();
+            this.histogram = undefined;
+        }
+    }
+    /** Collect a single runtime metrics snapshot */
+    collect() {
+        return {
+            uptimeMs: process.uptime() * MS_PER_SECOND,
+            memoryUsage: process.memoryUsage(),
+            activeHandles: proc._getActiveHandles().length,
+            activeRequests: proc._getActiveRequests().length,
+            eventLoopDelayMs: this.getEventLoopDelayMs(),
+        };
+    }
+    getEventLoopDelayMs() {
+        if (!this.histogram) {
+            return 0;
+        }
+        // mean is in nanoseconds; convert to milliseconds
+        return this.histogram.mean / NS_PER_MS;
+    }
+}

package/dist/monitor/stats-aggregator.d.ts

@@ -0,0 +1,22 @@
+import type { StatsSnapshot } from "./types.js";
+export declare class StatsAggregator {
+    private latencyBuffer;
+    private totalRequests;
+    private successCount;
+    private errorCount;
+    private retryCount;
+    private failoverCount;
+    private byStatusCode;
+    private providers;
+    private providerNames;
+    constructor(capacity?: number);
+    recordLatency(ms: number): void;
+    recordRequest(providerId: string, providerName: string, statusCode: number, isRetry: boolean, isFailover: boolean): void;
+    /**
+     * Associate a latency sample with a provider for per-provider avgLatencyMs.
+     * Must be called alongside recordRequest for accurate per-provider latency.
+     */
+    recordProviderLatency(providerId: string, ms: number): void;
+    getStats(): StatsSnapshot;
+    reset(): void;
+}

package/dist/monitor/stats-aggregator.js

@@ -0,0 +1,166 @@
+/**
+ * Fixed-size circular buffer for latency samples.
+ * Overwrites oldest entries when full — O(1) append.
+ */
+class RingBuffer {
+    capacity;
+    buf;
+    head = 0; // next write position
+    len = 0;
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.buf = new Array(capacity);
+    }
+    push(value) {
+        this.buf[this.head] = value;
+        this.head = (this.head + 1) % this.capacity;
+        if (this.len < this.capacity)
+            this.len++;
+    }
+    /** Returns a sorted copy of current values. */
+    sorted() {
+        const slice = this.buf.slice(0, this.len);
+        slice.sort((a, b) => a - b);
+        return slice;
+    }
+    clear() {
+        this.head = 0;
+        this.len = 0;
+    }
+}
+function emptyAccumulator() {
+    return {
+        totalRequests: 0,
+        successCount: 0,
+        errorCount: 0,
+        retryCount: 0,
+        latencySum: 0,
+        latencyCount: 0,
+        errorsByCode: new Map(),
+    };
+}
+const TOP_ERRORS_LIMIT = 5;
+const DEFAULT_CAPACITY = 1000;
+const HTTP_SUCCESS_RANGE_MIN = 200;
+const HTTP_SUCCESS_RANGE_MAX = 400;
+const PERCENTILE_P50 = 0.5;
+const PERCENTILE_P99 = 0.99;
+export class StatsAggregator {
+    latencyBuffer;
+    totalRequests = 0;
+    successCount = 0;
+    errorCount = 0;
+    retryCount = 0;
+    failoverCount = 0;
+    byStatusCode = new Map();
+    providers = new Map();
+    providerNames = new Map();
+    constructor(capacity = DEFAULT_CAPACITY) {
+        this.latencyBuffer = new RingBuffer(Math.max(1, capacity));
+    }
+    recordLatency(ms) {
+        this.latencyBuffer.push(ms);
+    }
+    recordRequest(providerId, providerName, statusCode, isRetry, isFailover) {
+        this.totalRequests++;
+        this.providerNames.set(providerId, providerName);
+        // Global status code counters
+        this.byStatusCode.set(statusCode, (this.byStatusCode.get(statusCode) ?? 0) + 1);
+        if (statusCode >= HTTP_SUCCESS_RANGE_MIN && statusCode < HTTP_SUCCESS_RANGE_MAX) {
+            this.successCount++;
+        }
+        else {
+            this.errorCount++;
+        }
+        if (isRetry)
+            this.retryCount++;
+        if (isFailover)
+            this.failoverCount++;
+        // Per-provider accumulator
+        let acc = this.providers.get(providerId);
+        if (!acc) {
+            acc = emptyAccumulator();
+            this.providers.set(providerId, acc);
+        }
+        acc.totalRequests++;
+        if (statusCode >= HTTP_SUCCESS_RANGE_MIN && statusCode < HTTP_SUCCESS_RANGE_MAX) {
+            acc.successCount++;
+        }
+        else {
+            acc.errorCount++;
+            acc.errorsByCode.set(statusCode, (acc.errorsByCode.get(statusCode) ?? 0) + 1);
+        }
+        if (isRetry)
+            acc.retryCount++;
+    }
+    /**
+     * Associate a latency sample with a provider for per-provider avgLatencyMs.
+     * Must be called alongside recordRequest for accurate per-provider latency.
+     */
+    recordProviderLatency(providerId, ms) {
+        let acc = this.providers.get(providerId);
+        if (!acc) {
+            acc = emptyAccumulator();
+            this.providers.set(providerId, acc);
+        }
+        acc.latencySum += ms;
+        acc.latencyCount++;
+    }
+    getStats() {
+        const sorted = this.latencyBuffer.sorted();
+        const count = sorted.length;
+        const avgLatencyMs = count > 0 ? sorted.reduce((s, v) => s + v, 0) / count : 0;
+        const p50LatencyMs = count > 0 ? percentile(sorted, PERCENTILE_P50) : 0;
+        const p99LatencyMs = count > 0 ? percentile(sorted, PERCENTILE_P99) : 0;
+        const byProvider = {};
+        for (const [id, acc] of this.providers) {
+            const topErrors = [...acc.errorsByCode.entries()]
+                .map(([code, count]) => ({ code, count }))
+                .sort((a, b) => b.count - a.count)
+                .slice(0, TOP_ERRORS_LIMIT);
+            byProvider[id] = {
+                providerName: this.providerNames.get(id) ?? id,
+                totalRequests: acc.totalRequests,
+                successCount: acc.successCount,
+                errorCount: acc.errorCount,
+                avgLatencyMs: acc.latencyCount > 0
+                    ? acc.latencySum / acc.latencyCount
+                    : 0,
+                retryCount: acc.retryCount,
+                topErrors,
+            };
+        }
+        const byStatusCode = {};
+        for (const [code, cnt] of this.byStatusCode) {
+            byStatusCode[code] = cnt;
+        }
+        return {
+            totalRequests: this.totalRequests,
+            successCount: this.successCount,
+            errorCount: this.errorCount,
+            retryCount: this.retryCount,
+            failoverCount: this.failoverCount,
+            avgLatencyMs,
+            p50LatencyMs,
+            p99LatencyMs,
+            byProvider,
+            byStatusCode,
+        };
+    }
+    reset() {
+        this.latencyBuffer.clear();
+        this.totalRequests = 0;
+        this.successCount = 0;
+        this.errorCount = 0;
+        this.retryCount = 0;
+        this.failoverCount = 0;
+        this.byStatusCode.clear();
+        this.providers.clear();
+        this.providerNames.clear();
+    }
+}
+/** Nearest-rank percentile on a pre-sorted ascending array. */
+function percentile(sorted, p) {
+    const idx = Math.ceil(p * sorted.length) - 1;
+    return sorted[Math.max(0, Math.min(idx, sorted.length - 1))];
+}

package/dist/monitor/types.d.ts

@@ -0,0 +1,84 @@
+export interface ContentBlock {
+    type: 'thinking' | 'text' | 'tool_use';
+    content: string;
+    name?: string;
+}
+export interface StreamContentSnapshot {
+    /** 最近的原始 SSE 文本，环形缓冲区（最多 ~8KB） */
+    rawChunks: string;
+    /** 从 SSE 事件中提取并拼接的文本内容（最多 ~4KB） */
+    textContent: string;
+    /** 累计接收的流字符数 */
+    totalChars: number;
+    blocks?: ContentBlock[];
+}
+export interface ActiveRequest {
+    id: string;
+    apiType: "openai" | "anthropic";
+    model: string;
+    providerId: string;
+    providerName: string;
+    isStream: boolean;
+    queued?: boolean;
+    startTime: number;
+    status: "pending" | "completed" | "failed";
+    retryCount: number;
+    attempts: AttemptSnapshot[];
+    streamMetrics?: StreamMetricsSnapshot;
+    streamContent?: StreamContentSnapshot;
+    clientIp?: string;
+    completedAt?: number;
+}
+export interface AttemptSnapshot {
+    statusCode: number | null;
+    error: string | null;
+    latencyMs: number;
+    providerId: string;
+}
+export interface StreamMetricsSnapshot {
+    inputTokens: number | null;
+    outputTokens: number | null;
+    ttftMs: number | null;
+    stopReason: string | null;
+    isComplete: boolean;
+}
+export interface ProviderConcurrencySnapshot {
+    providerId: string;
+    providerName: string;
+    maxConcurrency: number;
+    active: number;
+    queued: number;
+    queueTimeoutMs: number;
+    maxQueueSize: number;
+}
+export interface StatsSnapshot {
+    totalRequests: number;
+    successCount: number;
+    errorCount: number;
+    retryCount: number;
+    failoverCount: number;
+    avgLatencyMs: number;
+    p50LatencyMs: number;
+    p99LatencyMs: number;
+    byProvider: Record<string, ProviderStats>;
+    byStatusCode: Record<number, number>;
+}
+export interface ProviderStats {
+    providerName: string;
+    totalRequests: number;
+    successCount: number;
+    errorCount: number;
+    avgLatencyMs: number;
+    retryCount: number;
+    topErrors: Array<{
+        code: number;
+        count: number;
+    }>;
+}
+export interface RuntimeMetrics {
+    uptimeMs: number;
+    memoryUsage: NodeJS.MemoryUsage;
+    activeHandles: number;
+    activeRequests: number;
+    eventLoopDelayMs: number;
+}

package/dist/monitor/types.js

@@ -0,0 +1 @@
+export {};