@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/sse/types/utility-types.d.ts

@@ -0,0 +1,234 @@
+/**
+ * 工具类型定义
+ * 提供JSON↔SSE双向转换中常用的工具类型和辅助函数
+ */
+import type { JsonObject, JsonValue } from './core-interfaces.js';
+export type ProtocolType = 'chat' | 'responses';
+export type ConversionDirection = 'json_to_sse' | 'sse_to_json';
+export interface EventTypeMap {
+    chat: {
+        SSE_EVENT: 'chat_chunk' | 'chat.done' | 'error' | 'ping';
+        JSON_TYPE: 'ChatCompletionChunk' | 'ChatCompletionResponse';
+    };
+    responses: {
+        SSE_EVENT: 'response.created' | 'response.in_progress' | 'response.completed' | 'response.required_action' | 'response.done' | 'response.output_item.added' | 'response.output_item.done' | 'response.content_part.added' | 'response.content_part.done' | 'response.output_text.delta' | 'response.output_text.done' | 'response.reasoning_text.delta' | 'response.reasoning_text.done' | 'response.function_call_arguments.delta' | 'response.function_call_arguments.done';
+        JSON_TYPE: 'ResponsesResponse' | 'ResponsesRequest';
+    };
+}
+export interface GenericConverter<TProtocol extends ProtocolType, TDirection extends ConversionDirection> {
+    protocol: TProtocol;
+    direction: TDirection;
+    convert(input: unknown, options: JsonObject): Promise<unknown>;
+    validate?(input: unknown): boolean;
+    getStats?(): JsonObject;
+}
+export interface UnifiedConversionOptions {
+    requestId: string;
+    model: string;
+    protocol: ProtocolType;
+    direction: ConversionDirection;
+    timeoutMs?: number;
+    enableHeartbeat?: boolean;
+    heartbeatIntervalMs?: number;
+    validationMode?: 'none' | 'basic' | 'strict';
+    debugMode?: boolean;
+    onError?: (error: Error) => void;
+    onComplete?: () => void;
+}
+export interface UnifiedEventStream extends AsyncIterable<unknown> {
+    protocol: ProtocolType;
+    direction: ConversionDirection;
+    requestId: string;
+    getStats(): JsonObject;
+    getConfig(): JsonObject;
+    pause?(): void;
+    resume?(): void;
+    complete(): void;
+    abort(error?: Error): void;
+    on?(event: 'error', handler: (error: Error) => void): this;
+    on?(event: 'complete', handler: () => void): this;
+    on?(event: 'timeout', handler: () => void): this;
+    on?(event: 'stats', handler: (stats: JsonObject) => void): this;
+}
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type RequireKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;
+export type JsonType<TProtocol extends ProtocolType> = TProtocol extends 'chat' ? ChatJsonType : TProtocol extends 'responses' ? ResponsesJsonType : never;
+export type SseEventType<TProtocol extends ProtocolType> = TProtocol extends 'chat' ? ChatSseEventType : TProtocol extends 'responses' ? ResponsesSseEventType : never;
+export interface ChatJsonType {
+    id: string;
+    object: 'chat.completion' | 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: unknown[];
+    usage?: JsonObject;
+}
+export type ChatSseEventType = 'chat_chunk' | 'chat.done' | 'error' | 'ping';
+export interface ResponsesJsonType {
+    id: string;
+    object: 'response';
+    created_at: number;
+    model: string;
+    status: string;
+    output: unknown[];
+    usage?: JsonObject;
+}
+export type ResponsesSseEventType = 'response.created' | 'response.in_progress' | 'response.completed' | 'response.required_action' | 'response.done' | 'response.output_item.added' | 'response.output_item.done' | 'response.content_part.added' | 'response.content_part.done' | 'response.output_text.delta' | 'response.output_text.done' | 'response.reasoning_text.delta' | 'response.reasoning_text.done' | 'response.function_call_arguments.delta' | 'response.function_call_arguments.done';
+export interface ConversionResult<TSuccess = unknown, TError = Error> {
+    success: boolean;
+    data?: TSuccess;
+    error?: TError;
+    metadata?: {
+        duration: number;
+        eventsProcessed: number;
+        bytesProcessed: number;
+        protocol: ProtocolType;
+        direction: ConversionDirection;
+    };
+}
+export type AsyncConversionResult<TSuccess = unknown, TError = Error> = Promise<ConversionResult<TSuccess, TError>>;
+export interface ConverterFactory {
+    createJsonToSseConverter<TProtocol extends ProtocolType>(protocol: TProtocol, options: UnifiedConversionOptions): GenericConverter<TProtocol, 'json_to_sse'>;
+    createSseToJsonConverter<TProtocol extends ProtocolType>(protocol: TProtocol, options: UnifiedConversionOptions): GenericConverter<TProtocol, 'sse_to_json'>;
+}
+export interface ConverterRegistry {
+    register<TProtocol extends ProtocolType, TDirection extends ConversionDirection>(protocol: TProtocol, direction: TDirection, converter: GenericConverter<TProtocol, TDirection>): void;
+    get<TProtocol extends ProtocolType, TDirection extends ConversionDirection>(protocol: TProtocol, direction: TDirection): GenericConverter<TProtocol, TDirection> | undefined;
+    list(): Array<{
+        protocol: ProtocolType;
+        direction: ConversionDirection;
+        converter: GenericConverter<ProtocolType, ConversionDirection>;
+    }>;
+}
+export interface Validator<T> {
+    validate(input: T): ValidationResult;
+    isValid(input: T): boolean;
+    getErrors(input: T): string[];
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+}
+export interface ValidationError {
+    code: string;
+    message: string;
+    path: string;
+    value?: JsonValue;
+}
+export interface ValidationWarning {
+    code: string;
+    message: string;
+    path: string;
+    value?: JsonValue;
+}
+export interface Serializer<T> {
+    serialize(input: T): string;
+    deserialize(input: string): T;
+    isValid(input: string): boolean;
+}
+export interface Cache<K, V> {
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    size: number;
+}
+export interface MetricsCollector {
+    incrementCounter(name: string, tags?: Record<string, string>): void;
+    recordHistogram(name: string, value: number, tags?: Record<string, string>): void;
+    setGauge(name: string, value: number, tags?: Record<string, string>): void;
+    recordTimer(name: string, duration: number, tags?: Record<string, string>): void;
+    getMetrics(): Record<string, unknown>;
+}
+type LoggerMetadata = Record<string, unknown>;
+export interface Logger {
+    debug(message: string, meta?: LoggerMetadata): void;
+    info(message: string, meta?: LoggerMetadata): void;
+    warn(message: string, meta?: LoggerMetadata): void;
+    error(message: string, error?: Error, meta?: LoggerMetadata): void;
+    child(meta: LoggerMetadata): Logger;
+}
+export interface RetryConfig {
+    maxAttempts: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    backoffMultiplier: number;
+    jitter: boolean;
+    retryableErrors: string[];
+}
+export interface CircuitBreakerConfig {
+    failureThreshold: number;
+    recoveryTimeoutMs: number;
+    monitoringPeriodMs: number;
+    expectedRecoveryTimeMs: number;
+}
+export interface RateLimitConfig {
+    windowMs: number;
+    maxRequests: number;
+    burstSize?: number;
+    strategy: 'sliding_window' | 'fixed_window' | 'token_bucket';
+}
+export interface HealthCheck {
+    isHealthy(): Promise<boolean>;
+    getStatus(): HealthStatus;
+    onHealthChange(callback: (status: HealthStatus) => void): void;
+}
+export interface HealthStatus {
+    healthy: boolean;
+    timestamp: number;
+    details?: Record<string, unknown>;
+}
+type LifecycleContext = Record<string, unknown>;
+export interface LifecycleHooks {
+    beforeConversion?: (context: LifecycleContext) => Promise<void>;
+    afterConversion?: (context: LifecycleContext, result: unknown) => Promise<void>;
+    onError?: (context: LifecycleContext, error: Error) => Promise<void>;
+    onTimeout?: (context: LifecycleContext) => Promise<void>;
+    onRetry?: (context: LifecycleContext, attempt: number) => Promise<void>;
+}
+export interface Middleware {
+    name: string;
+    priority: number;
+    beforeConversion?: (context: LifecycleContext) => Promise<void>;
+    afterConversion?: (context: LifecycleContext, result: unknown) => Promise<void>;
+    onError?: (context: LifecycleContext, error: Error) => Promise<void>;
+}
+export interface Plugin {
+    name: string;
+    version: string;
+    initialize(context: LifecycleContext): Promise<void>;
+    destroy(): Promise<void>;
+    getMiddlewares(): Middleware[];
+    getHooks(): LifecycleHooks;
+}
+export interface ConfigMerger {
+    merge<T>(base: T, override: Partial<T>): T;
+    validate<T>(config: T): ValidationResult;
+    normalize<T>(config: T): T;
+}
+export interface EnvironmentParser {
+    getString(key: string, defaultValue?: string): string;
+    getNumber(key: string, defaultValue?: number): number;
+    getBoolean(key: string, defaultValue?: boolean): boolean;
+    getArray(key: string, delimiter?: string): string[];
+    getObject(key: string): JsonObject;
+}
+export declare const TypeGuards: {
+    isString: (value: unknown) => value is string;
+    isNumber: (value: unknown) => value is number;
+    isBoolean: (value: unknown) => value is boolean;
+    isObject: (value: unknown) => value is JsonObject;
+    isArray: (value: unknown) => value is JsonValue[];
+    isFunction: (value: unknown) => value is (...args: unknown[]) => unknown;
+    isDate: (value: unknown) => value is Date;
+    isNull: (value: unknown) => value is null;
+    isUndefined: (value: unknown) => value is undefined;
+    isNullOrUndefined: (value: unknown) => value is null | undefined;
+};
+export declare const AsyncUtils: {
+    delay: (ms: number) => Promise<void>;
+    timeout: <T>(promise: Promise<T>, ms: number) => Promise<T>;
+    retry: <T>(fn: () => Promise<T>, config: RetryConfig) => Promise<T>;
+};
+export {};

package/vendor/llmswitch-core/dist/sse/types/utility-types.js

@@ -0,0 +1,46 @@
+/**
+ * 工具类型定义
+ * 提供JSON↔SSE双向转换中常用的工具类型和辅助函数
+ */
+// 类型守卫工具函数
+export const TypeGuards = {
+    isString: (value) => typeof value === 'string',
+    isNumber: (value) => typeof value === 'number' && !Number.isNaN(value),
+    isBoolean: (value) => typeof value === 'boolean',
+    isObject: (value) => value !== null && typeof value === 'object' && !Array.isArray(value),
+    isArray: (value) => Array.isArray(value),
+    isFunction: (value) => typeof value === 'function',
+    isDate: (value) => value instanceof Date,
+    isNull: (value) => value === null,
+    isUndefined: (value) => value === undefined,
+    isNullOrUndefined: (value) => value === null || value === undefined
+};
+// 异步工具函数
+export const AsyncUtils = {
+    delay: (ms) => new Promise(resolve => setTimeout(resolve, ms)),
+    timeout: (promise, ms) => {
+        return Promise.race([
+            promise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Operation timed out after ${ms}ms`)), ms))
+        ]);
+    },
+    retry: async (fn, config) => {
+        let lastError;
+        for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                const normalizedError = error instanceof Error ? error : new Error(String(error));
+                lastError = normalizedError;
+                if (!config.retryableErrors.includes(normalizedError.name) || attempt === config.maxAttempts) {
+                    throw normalizedError;
+                }
+                const delay = Math.min(config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt - 1), config.maxDelayMs);
+                const jitter = config.jitter ? Math.random() * delay * 0.1 : 0;
+                await AsyncUtils.delay(delay + jitter);
+            }
+        }
+        throw lastError ?? new Error('Operation failed after retry attempts');
+    }
+};

package/vendor/llmswitch-core/dist/telemetry/stats-center.d.ts

@@ -0,0 +1,82 @@
+export interface VirtualRouterHitEvent {
+    requestId: string;
+    timestamp: number;
+    entryEndpoint: string;
+    routeName: string;
+    pool: string;
+    providerKey: string;
+    runtimeKey?: string;
+    providerType?: string;
+    modelId?: string;
+    reason?: string;
+    requestTokens?: number;
+    selectionPenalty?: number;
+    stopMessageActive?: boolean;
+    stopMessageMode?: 'on' | 'off' | 'auto' | 'unset';
+    stopMessageRemaining?: number;
+}
+export interface ProviderUsageEvent {
+    requestId: string;
+    timestamp: number;
+    providerKey: string;
+    runtimeKey?: string;
+    providerType: string;
+    modelId?: string;
+    routeName?: string;
+    entryEndpoint?: string;
+    success: boolean;
+    latencyMs: number;
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+}
+export interface RouterStatsBucket {
+    requestCount: number;
+    poolHitCount: Record<string, number>;
+    routeHitCount: Record<string, number>;
+    providerHitCount: Record<string, number>;
+    reasonHitCount: Record<string, number>;
+    penaltyHitCount: Record<string, number>;
+    stopMessageActiveCount: number;
+}
+export interface RouterStatsSnapshot {
+    global: RouterStatsBucket;
+    byEntryEndpoint: Record<string, RouterStatsBucket>;
+}
+export interface ProviderStatsBucket {
+    requestCount: number;
+    successCount: number;
+    errorCount: number;
+    latencySumMs: number;
+    minLatencyMs: number;
+    maxLatencyMs: number;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+export interface ProviderStatsSnapshot {
+    global: ProviderStatsBucket;
+    byProviderKey: Record<string, ProviderStatsBucket>;
+    byRoute: Record<string, ProviderStatsBucket>;
+    byEntryEndpoint: Record<string, ProviderStatsBucket>;
+}
+export interface StatsSnapshot {
+    router: RouterStatsSnapshot;
+    providers: ProviderStatsSnapshot;
+}
+export interface StatsCenterOptions {
+    enable?: boolean;
+    autoPrintOnExit?: boolean;
+    persistPath?: string | null;
+}
+export interface StatsCenter {
+    recordVirtualRouterHit(ev: VirtualRouterHitEvent): void;
+    recordProviderUsage(ev: ProviderUsageEvent): void;
+    getSnapshot(): StatsSnapshot;
+    flushToDisk(): Promise<void>;
+    reset(): void;
+}
+export declare function initStatsCenter(options?: StatsCenterOptions): StatsCenter;
+export declare function getStatsCenter(): StatsCenter;

package/vendor/llmswitch-core/dist/telemetry/stats-center.js

@@ -0,0 +1,308 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { resolveRccPath } from '../runtime/user-data-paths.js';
+function createEmptyRouterBucket() {
+    return {
+        requestCount: 0,
+        poolHitCount: {},
+        routeHitCount: {},
+        providerHitCount: {},
+        reasonHitCount: {},
+        penaltyHitCount: {},
+        stopMessageActiveCount: 0
+    };
+}
+function createEmptyProviderBucket() {
+    return {
+        requestCount: 0,
+        successCount: 0,
+        errorCount: 0,
+        latencySumMs: 0,
+        minLatencyMs: Number.POSITIVE_INFINITY,
+        maxLatencyMs: 0,
+        usage: {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0
+        }
+    };
+}
+function createEmptySnapshot() {
+    return {
+        router: {
+            global: createEmptyRouterBucket(),
+            byEntryEndpoint: {}
+        },
+        providers: {
+            global: createEmptyProviderBucket(),
+            byProviderKey: {},
+            byRoute: {},
+            byEntryEndpoint: {}
+        }
+    };
+}
+class NoopStatsCenter {
+    recordVirtualRouterHit() { }
+    recordProviderUsage() { }
+    getSnapshot() { return createEmptySnapshot(); }
+    async flushToDisk() { }
+    reset() { }
+}
+class DefaultStatsCenter {
+    snapshot = createEmptySnapshot();
+    dirty = false;
+    flushInFlight = false;
+    persistPath;
+    constructor(persistPath) {
+        if (persistPath === null) {
+            this.persistPath = null;
+        }
+        else if (typeof persistPath === 'string' && persistPath.trim().length) {
+            this.persistPath = persistPath.trim();
+        }
+        else {
+            const base = resolveRccPath('stats');
+            this.persistPath = path.join(base, 'stats.json');
+        }
+    }
+    recordVirtualRouterHit(ev) {
+        if (!ev || !ev.routeName || !ev.providerKey) {
+            return;
+        }
+        const snap = this.snapshot;
+        this.applyRouterHitToBucket(snap.router.global, ev);
+        const entryKey = ev.entryEndpoint || 'unknown';
+        if (!snap.router.byEntryEndpoint[entryKey]) {
+            snap.router.byEntryEndpoint[entryKey] = createEmptyRouterBucket();
+        }
+        this.applyRouterHitToBucket(snap.router.byEntryEndpoint[entryKey], ev);
+        this.dirty = true;
+    }
+    recordProviderUsage(ev) {
+        if (!ev || !ev.providerKey || !ev.providerType) {
+            return;
+        }
+        const snap = this.snapshot;
+        this.applyProviderUsageToBucket(snap.providers.global, ev);
+        const providerKey = ev.providerKey;
+        if (!snap.providers.byProviderKey[providerKey]) {
+            snap.providers.byProviderKey[providerKey] = createEmptyProviderBucket();
+        }
+        this.applyProviderUsageToBucket(snap.providers.byProviderKey[providerKey], ev);
+        const routeKey = ev.routeName || 'unknown';
+        if (!snap.providers.byRoute[routeKey]) {
+            snap.providers.byRoute[routeKey] = createEmptyProviderBucket();
+        }
+        this.applyProviderUsageToBucket(snap.providers.byRoute[routeKey], ev);
+        const entryKey = ev.entryEndpoint || 'unknown';
+        if (!snap.providers.byEntryEndpoint[entryKey]) {
+            snap.providers.byEntryEndpoint[entryKey] = createEmptyProviderBucket();
+        }
+        this.applyProviderUsageToBucket(snap.providers.byEntryEndpoint[entryKey], ev);
+        this.dirty = true;
+    }
+    getSnapshot() {
+        return this.snapshot;
+    }
+    reset() {
+        this.snapshot = createEmptySnapshot();
+        this.dirty = false;
+    }
+    async flushToDisk() {
+        if (!this.persistPath || !this.dirty || this.flushInFlight) {
+            return;
+        }
+        this.flushInFlight = true;
+        try {
+            const dir = path.dirname(this.persistPath);
+            await fs.mkdir(dir, { recursive: true });
+            const payload = JSON.stringify(this.snapshot, null, 2);
+            await fs.writeFile(this.persistPath, payload, 'utf-8');
+            this.dirty = false;
+        }
+        catch {
+            // ignore persistence errors
+        }
+        finally {
+            this.flushInFlight = false;
+        }
+    }
+    applyRouterHitToBucket(bucket, ev) {
+        bucket.requestCount += 1;
+        if (ev.pool) {
+            bucket.poolHitCount[ev.pool] = (bucket.poolHitCount[ev.pool] || 0) + 1;
+        }
+        if (ev.routeName) {
+            bucket.routeHitCount[ev.routeName] = (bucket.routeHitCount[ev.routeName] || 0) + 1;
+        }
+        if (ev.providerKey) {
+            bucket.providerHitCount[ev.providerKey] = (bucket.providerHitCount[ev.providerKey] || 0) + 1;
+        }
+        if (typeof ev.reason === 'string' && ev.reason.trim()) {
+            const reason = ev.reason.trim();
+            bucket.reasonHitCount[reason] = (bucket.reasonHitCount[reason] || 0) + 1;
+        }
+        if (typeof ev.selectionPenalty === 'number' && Number.isFinite(ev.selectionPenalty) && ev.selectionPenalty > 0) {
+            const key = String(Math.floor(ev.selectionPenalty));
+            bucket.penaltyHitCount[key] = (bucket.penaltyHitCount[key] || 0) + 1;
+        }
+        if (ev.stopMessageActive === true) {
+            bucket.stopMessageActiveCount += 1;
+        }
+    }
+    applyProviderUsageToBucket(bucket, ev) {
+        bucket.requestCount += 1;
+        if (ev.success) {
+            bucket.successCount += 1;
+        }
+        else {
+            bucket.errorCount += 1;
+        }
+        if (Number.isFinite(ev.latencyMs) && ev.latencyMs >= 0) {
+            bucket.latencySumMs += ev.latencyMs;
+            if (ev.latencyMs < bucket.minLatencyMs) {
+                bucket.minLatencyMs = ev.latencyMs;
+            }
+            if (ev.latencyMs > bucket.maxLatencyMs) {
+                bucket.maxLatencyMs = ev.latencyMs;
+            }
+        }
+        if (typeof ev.promptTokens === 'number' && Number.isFinite(ev.promptTokens)) {
+            bucket.usage.promptTokens += Math.max(0, ev.promptTokens);
+        }
+        if (typeof ev.completionTokens === 'number' && Number.isFinite(ev.completionTokens)) {
+            bucket.usage.completionTokens += Math.max(0, ev.completionTokens);
+        }
+        if (typeof ev.totalTokens === 'number' && Number.isFinite(ev.totalTokens)) {
+            bucket.usage.totalTokens += Math.max(0, ev.totalTokens);
+        }
+        else {
+            const derivedTotal = (typeof ev.promptTokens === 'number' ? Math.max(0, ev.promptTokens) : 0) +
+                (typeof ev.completionTokens === 'number' ? Math.max(0, ev.completionTokens) : 0);
+            bucket.usage.totalTokens += derivedTotal;
+        }
+    }
+}
+let instance = null;
+function resolveEnableFlag(defaultValue) {
+    const raw = process.env.ROUTECODEX_STATS;
+    if (!raw)
+        return defaultValue;
+    const normalized = raw.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'off'].includes(normalized))
+        return false;
+    return defaultValue;
+}
+function printStatsToConsole(snapshot) {
+    const router = snapshot.router;
+    const providers = snapshot.providers;
+    const totalRequests = router.global.requestCount;
+    const poolEntries = Object.entries(router.global.poolHitCount);
+    const providerEntries = Object.entries(router.global.providerHitCount);
+    const reasonEntries = Object.entries(router.global.reasonHitCount);
+    // Router summary
+    // eslint-disable-next-line no-console
+    console.log('[stats] Virtual Router:');
+    // eslint-disable-next-line no-console
+    console.log(`  total requests: ${totalRequests}`);
+    if (poolEntries.length) {
+        // eslint-disable-next-line no-console
+        console.log('  pools:');
+        for (const [pool, count] of poolEntries) {
+            const ratio = totalRequests > 0 ? (count / totalRequests) * 100 : 0;
+            // eslint-disable-next-line no-console
+            console.log(`    ${pool}: ${count} (${ratio.toFixed(2)}%)`);
+        }
+    }
+    if (providerEntries.length) {
+        // eslint-disable-next-line no-console
+        console.log('  top providers:');
+        const sorted = providerEntries.sort((a, b) => b[1] - a[1]).slice(0, 5);
+        for (const [providerKey, count] of sorted) {
+            // eslint-disable-next-line no-console
+            console.log(`    ${providerKey}: ${count}`);
+        }
+    }
+    if (reasonEntries.length) {
+        // eslint-disable-next-line no-console
+        console.log('  top reasons:');
+        const sortedReasons = reasonEntries.sort((a, b) => b[1] - a[1]).slice(0, 5);
+        for (const [reason, count] of sortedReasons) {
+            // eslint-disable-next-line no-console
+            console.log(`    ${reason}: ${count}`);
+        }
+    }
+    if (router.global.stopMessageActiveCount > 0) {
+        // eslint-disable-next-line no-console
+        console.log(`  stopMessage-active hits: ${router.global.stopMessageActiveCount}`);
+    }
+    const globalProvider = providers.global;
+    const totalProviderRequests = globalProvider.requestCount;
+    const avgLatency = globalProvider.successCount > 0 ? globalProvider.latencySumMs / globalProvider.successCount : 0;
+    // Provider summary
+    // eslint-disable-next-line no-console
+    console.log('\n[stats] Providers:');
+    // eslint-disable-next-line no-console
+    console.log(`  total requests : ${totalProviderRequests} (success=${globalProvider.successCount}, error=${globalProvider.errorCount})`);
+    // eslint-disable-next-line no-console
+    console.log(`  avg latency    : ${avgLatency.toFixed(1)} ms`);
+    // eslint-disable-next-line no-console
+    console.log(`  total tokens   : prompt=${globalProvider.usage.promptTokens} completion=${globalProvider.usage.completionTokens} total=${globalProvider.usage.totalTokens}`);
+}
+export function initStatsCenter(options) {
+    if (instance) {
+        return instance;
+    }
+    const enabled = resolveEnableFlag(options?.enable ?? true);
+    if (!enabled) {
+        instance = new NoopStatsCenter();
+        return instance;
+    }
+    const center = new DefaultStatsCenter(options?.persistPath);
+    instance = center;
+    const autoPrint = options?.autoPrintOnExit !== false;
+    if (autoPrint && typeof process !== 'undefined' && typeof process.on === 'function') {
+        const handler = async () => {
+            try {
+                await center.flushToDisk();
+            }
+            catch {
+                // ignore
+            }
+            try {
+                const snapshot = center.getSnapshot();
+                printStatsToConsole(snapshot);
+            }
+            catch {
+                // ignore
+            }
+        };
+        try {
+            process.once('beforeExit', handler);
+        }
+        catch {
+            // ignore
+        }
+        try {
+            process.once('SIGINT', handler);
+        }
+        catch {
+            // ignore
+        }
+        try {
+            process.once('SIGTERM', handler);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return instance;
+}
+export function getStatsCenter() {
+    if (!instance) {
+        return initStatsCenter();
+    }
+    return instance;
+}

package/vendor/llmswitch-core/dist/tools/apply-patch/args-normalizer/default-actions.d.ts

@@ -0,0 +1,2 @@
+import type { ApplyPatchNormalizeAction } from './types.js';
+export declare const DEFAULT_APPLY_PATCH_NORMALIZE_ACTIONS: ApplyPatchNormalizeAction[];

package/vendor/llmswitch-core/dist/tools/apply-patch/args-normalizer/default-actions.js

@@ -0,0 +1,12 @@
+export const DEFAULT_APPLY_PATCH_NORMALIZE_ACTIONS = [
+    { action: 'raw_non_json_patch' },
+    { action: 'json_container_patch_fallback' },
+    { action: 'record_text_fields', fields: ['patch'] },
+    { action: 'record_conflict_patch', patchField: 'patch', fileFields: ['file', 'path', 'filepath', 'filename'] },
+    { action: 'record_text_fields', fields: ['diff', 'patchText', 'body', 'input', 'instructions', 'command'] },
+    { action: 'record_raw_envelope', field: '_raw', parseJson: true, maxDepth: 3 },
+    { action: 'record_structured_payload' },
+    { action: 'array_structured_payload' },
+    { action: 'raw_string_patch' },
+    { action: 'invalid_json_guard' }
+];

package/vendor/llmswitch-core/dist/tools/apply-patch/args-normalizer/extract-patch.d.ts

@@ -0,0 +1,2 @@
+import type { ApplyPatchExtraction } from './types.js';
+export declare function extractNormalizedPatch(value: string | undefined | null): ApplyPatchExtraction;