@jsonstudio/rcc 0.89.333 → 0.89.524

package/node_modules/@jsonstudio/llms/dist/telemetry/stats-center.d.ts

@@ -0,0 +1,73 @@
+export interface VirtualRouterHitEvent {
+    requestId: string;
+    timestamp: number;
+    entryEndpoint: string;
+    routeName: string;
+    pool: string;
+    providerKey: string;
+    runtimeKey?: string;
+    providerType?: string;
+    modelId?: string;
+}
+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>;
+}
+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/node_modules/@jsonstudio/llms/dist/telemetry/stats-center.js

@@ -0,0 +1,280 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+function createEmptyRouterBucket() {
+    return {
+        requestCount: 0,
+        poolHitCount: {},
+        routeHitCount: {},
+        providerHitCount: {}
+    };
+}
+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 = path.join(os.homedir(), '.routecodex', '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;
+        }
+    }
+    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);
+    // 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}`);
+        }
+    }
+    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/node_modules/@jsonstudio/llms/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.203",
+  "version": "0.6.375",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/rcc",
-  "version": "0.89.333",
+  "version": "0.89.524",
   "description": "Multi-provider OpenAI proxy server with anthropic/responses/chat support (dev)",
   "type": "module",
   "main": "dist/index.js",
@@ -126,7 +126,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.65.0",
-    "@jsonstudio/llms": "^0.6.203",
+    "@jsonstudio/llms": "^0.6.375",
     "@lmstudio/sdk": "^1.5.0",
     "@radix-ui/react-switch": "^1.2.6",
     "@types/socket.io": "^3.0.1",

package/scripts/pack-mode.mjs

@@ -59,11 +59,12 @@ try {
   if (args.name === 'routecodex' || args.name === 'rcc') {
     mutated.bundledDependencies = [];
     mutated.bundleDependencies = [];
+    const llmsVersion = original.dependencies?.['@jsonstudio/llms'] || '^0.6.230';
     mutated.dependencies = {
       ...(original.dependencies || {}),
       "ajv": original.dependencies?.ajv || "^8.17.1",
       "zod": original.dependencies?.zod || "^3.23.8",
-      "@jsonstudio/llms": original.dependencies?.["@jsonstudio/llms"] || "^0.4.3"
+      "@jsonstudio/llms": llmsVersion
     };
   }
   fs.writeFileSync(pkgPath, JSON.stringify(mutated, null, 2));

package/scripts/publish-rcc.mjs

@@ -7,10 +7,7 @@ import { fileURLToPath } from 'node:url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = path.resolve(__dirname, '..');
 const PACK_SCRIPT = path.join(PROJECT_ROOT, 'scripts', 'pack-mode.mjs');
-const packageJson = JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, 'package.json'), 'utf-8'));
-const version = packageJson.version;
-const tarballName = `jsonstudio-rcc-${version}.tgz`;
-const tarballPath = path.join(PROJECT_ROOT, tarballName);
+const pkgPath = path.join(PROJECT_ROOT, 'package.json');
 
 function run(command, args, options = {}) {
   const res = spawnSync(command, args, { stdio: 'inherit', ...options });
@@ -20,11 +17,30 @@ function run(command, args, options = {}) {
 }
 
 try {
+  // 1) 使用 release 模式构建 dist（依赖 npm 上的 @jsonstudio/llms）
+  run('npm', ['run', 'build:min'], {
+    cwd: PROJECT_ROOT,
+    env: { ...process.env, BUILD_MODE: 'release' }
+  });
+
+  // 2) 通过 pack-mode 生成 rcc tarball（内部会临时切换 package.json.name/bin 并确保 llms 为 release 包）
   run(process.execPath, [PACK_SCRIPT, '--name', '@jsonstudio/rcc', '--bin', 'rcc'], { cwd: PROJECT_ROOT });
+
+  // 构建过程中版本号可能被 bump（gen-build-info 会 auto-bump），因此需要在 pack 之后重新读取版本号
+  const updatedPkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  const version = updatedPkg.version;
+  const tarballName = `jsonstudio-rcc-${version}.tgz`;
+  const tarballPath = path.join(PROJECT_ROOT, tarballName);
+
   if (!fs.existsSync(tarballPath)) {
     throw new Error(`tarball not found: ${tarballPath}`);
   }
+
+  // 3) 发布 npm 包
   run('npm', ['publish', tarballName], { cwd: PROJECT_ROOT });
+
+  // 4) pack-mode 会在内部检测 dev 链接并调用 ensure-llmswitch-mode 恢复 dev 模式，
+  //    因此此处不再额外修改 BUILD_MODE 或重新 link。后续本地如需 dev build，可单独运行 `npm run build:dev`。
 } catch (err) {
   console.error('[publish-rcc] failed:', err.message);
   process.exit(1);

package/scripts/tests/virtual-router-health.mjs

@@ -13,7 +13,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(__dirname, '../..');
-const CORE_DIST = path.join(ROOT, 'sharedmodule', 'llmswitch-core', 'dist', 'v2', 'router', 'virtual-router');
+const CORE_DIST = path.join(ROOT, 'sharedmodule', 'llmswitch-core', 'dist', 'router', 'virtual-router');
 
 async function loadCoreModule(rel) {
   const file = path.join(CORE_DIST, rel);
@@ -21,16 +21,19 @@ async function loadCoreModule(rel) {
 }
 
 const { VirtualRouterEngine } = await loadCoreModule('engine.js');
+const { bootstrapVirtualRouterConfig } = await loadCoreModule('bootstrap.js');
 const { providerErrorCenter } = await loadCoreModule('error-center.js');
 const { VirtualRouterError } = await loadCoreModule('types.js');
 
 function parseArgs(argv) {
-  const args = { out: null };
+  const args = { out: null, config: null };
   const list = [...argv];
   while (list.length) {
     const cur = list.shift();
     if (cur === '--out' || cur === '--output') {
       args.out = list.shift() || null;
+    } else if (cur === '--config') {
+      args.config = list.shift() || null;
     } else if (cur === '--help' || cur === '-h') {
       args.help = true;
     }
@@ -57,9 +60,18 @@ function createRouterConfig() {
     'charlie.sim-model': buildProviderProfile('charlie.sim-model', 'https://charlie.local/v1')
   };
   const routing = {
-    default: Object.keys(providers),
-    coding: ['bravo.sim-model', 'charlie.sim-model'],
-    thinking: ['charlie.sim-model', 'alpha.sim-model']
+    default: [
+      { id: 'default-primary', priority: 200, targets: ['alpha.sim-model', 'bravo.sim-model'] },
+      { id: 'default-backup', backup: true, priority: 100, targets: ['charlie.sim-model'] }
+    ],
+    coding: [
+      { id: 'coding-primary', priority: 200, targets: ['bravo.sim-model', 'charlie.sim-model'] },
+      { id: 'coding-backup', backup: true, priority: 100, targets: ['alpha.sim-model'] }
+    ],
+    thinking: [
+      { id: 'thinking-primary', priority: 200, targets: ['charlie.sim-model'] },
+      { id: 'thinking-backup', backup: true, priority: 100, targets: ['bravo.sim-model'] }
+    ]
   };
   return {
     routing,
@@ -227,16 +239,128 @@ async function scenarioScheduler(sim) {
   sim.runRoute('thinking');
 }
 
+async function scenarioPriorityPools(sim) {
+  const first = sim.runRoute('thinking');
+  if (first !== 'charlie.sim-model') {
+    throw new Error(`expected primary thinking pool hit charlie.sim-model, got ${first}`);
+  }
+  sim.engine.handleProviderFailure({
+    providerKey: 'charlie.sim-model',
+    reason: 'priority-test',
+    fatal: true,
+    affectsHealth: true,
+    cooldownOverrideMs: 60_000
+  });
+  const second = sim.runRoute('thinking');
+  if (second !== 'bravo.sim-model') {
+    throw new Error(`expected thinking backup pool hit bravo.sim-model, got ${second}`);
+  }
+}
+
 async function scenarioRoutingDirectives(sim) {
   sim.runRoute('baseline', '普通请求');
   sim.runRoute('forced-thinking', '请仔细分析这个问题 <**thinking**>');
   sim.runRoute('forced-provider', '请强制使用这个provider <**charlie.sim-model**> 来回答');
 }
 
+async function scenarioRealConfig(configPath) {
+  const resolvedPath = path.resolve(configPath);
+  console.log(`\n=== Scenario: real-config (${resolvedPath}) ===`);
+  const source = JSON.parse(await fs.readFile(resolvedPath, 'utf-8'));
+  const section = source.virtualrouter && typeof source.virtualrouter === 'object' ? source.virtualrouter : source;
+  const { config } = bootstrapVirtualRouterConfig(section);
+  const engine = new VirtualRouterEngine();
+  engine.initialize(config);
+  const thinkingPools = config.routing.thinking ?? [];
+  const primaryPools = thinkingPools.filter((tier) => !tier.backup);
+  const backupPools = thinkingPools.filter((tier) => tier.backup);
+
+  const runThinking = (label) => {
+    const reqId = `real-config-${label}-${Date.now()}`;
+    const request = {
+      model: 'gpt-5.2-codex',
+      messages: [
+        { role: 'system', content: 'diagnostic' },
+        { role: 'user', content: `深入思考：${label}` }
+      ]
+    };
+    const metadata = {
+      requestId: reqId,
+      entryEndpoint: '/v1/responses',
+      processMode: 'chat',
+      stream: false,
+      direction: 'request',
+      providerProtocol: 'openai-responses'
+    };
+    const result = engine.route(request, metadata);
+    console.log(
+      JSON.stringify(
+        {
+          stage: 'real-config-route',
+          label,
+          providerKey: result.decision.providerKey,
+          route: result.decision.routeName,
+          poolId: result.decision.poolId
+        },
+        null,
+        2
+      )
+    );
+    return result.decision.providerKey;
+  };
+
+  const markUnavailable = (targets, reason) => {
+    for (const key of targets || []) {
+      engine.handleProviderFailure({
+        providerKey: key,
+        fatal: true,
+        affectsHealth: true,
+        reason,
+        cooldownOverrideMs: 60_000
+      });
+    }
+  };
+
+  // Primary hit
+  const firstProvider = runThinking('primary-hit');
+  const primaryTargets = primaryPools.flatMap((pool) => pool.targets ?? []);
+  const backupTargets = backupPools.flatMap((pool) => pool.targets ?? []);
+  if (primaryTargets.length === 0) {
+    console.warn('[real-config] No explicit primary thinking pool configured.');
+  } else if (!primaryTargets.includes(firstProvider)) {
+    console.warn('[real-config] First provider is not part of primary tier:', firstProvider);
+  }
+
+  // Drain primary
+  markUnavailable(primaryTargets, 'primary-exhausted');
+  const secondProvider = runThinking('backup-hit');
+  if (backupTargets.length && !backupTargets.includes(secondProvider)) {
+    throw new Error(
+      `[real-config] Expected backup pool provider after draining primary, got ${secondProvider}`
+    );
+  }
+
+  // Drain backup -> should fall to default
+  markUnavailable(backupTargets, 'backup-exhausted');
+  const thirdProvider = runThinking('default-fallback');
+  const usedRoute = engine.getStatus().routes;
+  console.log(
+    JSON.stringify(
+      {
+        stage: 'real-config-summary',
+        thirdProvider,
+        routes: usedRoute
+      },
+      null,
+      2
+    )
+  );
+}
+
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.help) {
-    console.log('Usage: node scripts/tests/virtual-router-health.mjs [--out summary.json]');
+    console.log('Usage: node scripts/tests/virtual-router-health.mjs [--out summary.json] [--config ~/.routecodex/config.json]');
     return;
   }
 
@@ -247,6 +371,7 @@ async function main() {
     ['upstream', scenarioUpstream],
     ['timeout', scenarioTimeout],
     ['scheduler', scenarioScheduler],
+    ['priority-pools', scenarioPriorityPools],
     ['routing-directives', scenarioRoutingDirectives]
   ];
 
@@ -260,6 +385,16 @@ async function main() {
     });
   }
 
+  if (args.config) {
+    try {
+      await scenarioRealConfig(args.config);
+      summary.push({ name: 'real-config', status: 'ok', lastHealth: null });
+    } catch (error) {
+      console.error('[real-config] failed:', error);
+      summary.push({ name: 'real-config', status: 'failed', error: error?.message || String(error), lastHealth: null });
+    }
+  }
+
   if (args.out) {
     const outFile = path.resolve(process.cwd(), args.out);
     await fs.mkdir(path.dirname(outFile), { recursive: true });

package/dist/tools/replay-request.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=replay-request.js.map

package/dist/tools/replay-request.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"replay-request.js","sourceRoot":"","sources":["../../src/tools/replay-request.ts"],"names":[],"mappings":""}