@jsonstudio/rcc 0.89.935 → 0.89.1083

package/scripts/mock-provider/extract.mjs

@@ -105,8 +105,8 @@ function findProviderId(node) {
 }
 
 async function detectProviderId(entryDir, prefix, request) {
-  const semanticPath = path.join(entryDir, `${prefix}_semantic_map_from_chat.json`);
-  if (await fileExists(semanticPath)) {
+  const semanticPath = prefix ? path.join(entryDir, `${prefix}_semantic_map_from_chat.json`) : null;
+  if (semanticPath && (await fileExists(semanticPath))) {
     try {
       const semantic = JSON.parse(await fs.readFile(semanticPath, 'utf-8'));
       const detected = findProviderId(semantic);
@@ -119,24 +119,100 @@ async function detectProviderId(entryDir, prefix, request) {
   }
   const fallback =
     request?.providerId ||
-    request?.data?.providerId ||
-    request?.data?.meta?.providerId ||
+    request?.meta?.providerId ||
+    request?.body?.providerId ||
+    request?.body?.meta?.providerId ||
     'unknown';
   return sanitizeComponent(fallback, 'unknown');
 }
 
 function buildTags(response) {
   const tags = [];
-  const body = response?.data?.body;
-  if (body?.__sse_responses) {
+  const body = response?.body || response?.data?.body;
+  if (body?.__sse_responses || body?.mode === 'sse') {
     tags.push('sse');
   }
-  if (Array.isArray(body?.tool_calls) && body.tool_calls.length > 0) {
+  const toolCalls = body?.tool_calls || body?.output?.tool_calls;
+  if (Array.isArray(toolCalls) && toolCalls.length > 0) {
     tags.push('tool-call');
   }
   return tags;
 }
 
+function parseRequestTimestamp(requestId, request) {
+  if (typeof request?.timestamp === 'number' && Number.isFinite(request.timestamp)) {
+    return request.timestamp;
+  }
+  const buildTime = request?.meta?.buildTime;
+  if (typeof buildTime === 'string') {
+    const parsed = Date.parse(buildTime);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  const match = String(requestId || '').match(/(\d{8})T(\d{6})(\d{3})?/);
+  if (match) {
+    const ymd = match[1];
+    const hms = match[2];
+    const ms = match[3] || '000';
+    const year = Number(ymd.slice(0, 4));
+    const month = Number(ymd.slice(4, 6));
+    const day = Number(ymd.slice(6, 8));
+    const hour = Number(hms.slice(0, 2));
+    const min = Number(hms.slice(2, 4));
+    const sec = Number(hms.slice(4, 6));
+    const msNum = Number(ms);
+    if ([year, month, day, hour, min, sec, msNum].every((v) => Number.isFinite(v))) {
+      return new Date(year, month - 1, day, hour, min, sec, msNum).getTime();
+    }
+  }
+  return Date.now();
+}
+
+function extractModelFromProviderRequest(request) {
+  const body = request?.body || request?.data?.body;
+  const raw =
+    body?.model ||
+    body?.data?.model ||
+    request?.model ||
+    request?.data?.model ||
+    undefined;
+  return typeof raw === 'string' && raw.trim() ? raw.trim() : 'unknown';
+}
+
+async function detectProviderIdFromRequestDir(requestDir, request) {
+  try {
+    const files = await fs.readdir(requestDir);
+    const semanticCandidates = files
+      .filter((name) => name.toLowerCase().endsWith('.json') && name.toLowerCase().includes('semantic_map'))
+      .slice(0, 10);
+    for (const file of semanticCandidates) {
+      try {
+        const semantic = JSON.parse(await fs.readFile(path.join(requestDir, file), 'utf-8'));
+        const detected = findProviderId(semantic);
+        if (detected) {
+          return sanitizeComponent(detected, 'unknown');
+        }
+      } catch {
+        // ignore semantic parse errors
+      }
+    }
+  } catch {
+    // ignore dir read errors
+  }
+  return await detectProviderId(requestDir, null, request);
+}
+
+function pickLatestStageFile(files, prefix) {
+  const candidates = files
+    .filter((name) => name.toLowerCase().endsWith('.json') && name.startsWith(prefix))
+    .sort((a, b) => a.localeCompare(b, 'en'));
+  if (!candidates.length) {
+    return null;
+  }
+  return candidates[candidates.length - 1];
+}
+
 async function extractPair(entryName, entryDir, file, registry, seqMap, filters = {}) {
   const prefix = file.replace('_provider-request.json', '');
   const requestPath = path.join(entryDir, file);
@@ -152,8 +228,8 @@ async function extractPair(entryName, entryDir, file, registry, seqMap, filters
   if (filters.provider && providerId !== sanitizeComponent(filters.provider, filters.provider)) {
     return;
   }
-  const model = sanitizeComponent(request?.data?.body?.model, 'unknown');
-  const tsToken = timestampToToken(request?.timestamp);
+  const model = sanitizeComponent(extractModelFromProviderRequest(request), 'unknown');
+  const tsToken = timestampToToken(parseRequestTimestamp(prefix, request));
   const seqKey = `${entryName}|${providerId}|${model}|${tsToken}`;
   const seq = (seqMap.get(seqKey) || 0) + 1;
   seqMap.set(seqKey, seq);
@@ -170,6 +246,21 @@ async function extractPair(entryName, entryDir, file, registry, seqMap, filters
   await fs.writeFile(path.join(targetDir, 'request.json'), JSON.stringify(enrichedRequest, null, 2));
   await fs.writeFile(path.join(targetDir, 'response.json'), JSON.stringify(enrichedResponse, null, 2));
 
+   // 可选：如果存在入口层的 client-request 快照，一并抽取，便于端到端重放。
+   const clientSnapshotPath = path.join(entryDir, `${prefix}_client-request.json`);
+   if (await fileExists(clientSnapshotPath)) {
+     try {
+       const client = JSON.parse(await fs.readFile(clientSnapshotPath, 'utf-8'));
+       const enrichedClient = { ...client, reqId, entryEndpoint: client?.endpoint };
+       await fs.writeFile(
+         path.join(targetDir, 'client-request.json'),
+         JSON.stringify(enrichedClient, null, 2)
+       );
+     } catch {
+       // client-request 仅用于重放，解析失败不阻断样本注册。
+     }
+   }
+
   registry.samples = registry.samples.filter((sample) => sample.reqId !== reqId);
   registry.samples.push({
     reqId,
@@ -183,6 +274,66 @@ async function extractPair(entryName, entryDir, file, registry, seqMap, filters
   console.log(`✅ ${reqId}`);
 }
 
+async function extractPairFromRequestDir(entryName, requestDir, registry, seqMap, filters = {}) {
+  const files = await fs.readdir(requestDir);
+  const providerRequestFile = pickLatestStageFile(files, 'provider-request');
+  const providerResponseFile = pickLatestStageFile(files, 'provider-response');
+  if (!providerRequestFile || !providerResponseFile) {
+    return;
+  }
+
+  const requestPath = path.join(requestDir, providerRequestFile);
+  const responsePath = path.join(requestDir, providerResponseFile);
+  const request = JSON.parse(await fs.readFile(requestPath, 'utf-8'));
+  const response = JSON.parse(await fs.readFile(responsePath, 'utf-8'));
+
+  const requestId = path.basename(requestDir);
+  const providerId = await detectProviderIdFromRequestDir(requestDir, request);
+  if (filters.provider && providerId !== sanitizeComponent(filters.provider, filters.provider)) {
+    return;
+  }
+  const model = sanitizeComponent(extractModelFromProviderRequest(request), 'unknown');
+  const tsToken = timestampToToken(parseRequestTimestamp(requestId, request));
+  const seqKey = `${entryName}|${providerId}|${model}|${tsToken}`;
+  const seq = (seqMap.get(seqKey) || 0) + 1;
+  seqMap.set(seqKey, seq);
+  const seqStr = String(seq).padStart(3, '0');
+  const reqId = `${entryName}-${providerId}-${model}-${tsToken}-${seqStr}`;
+
+  const daySegment = tsToken.slice(0, 8);
+  const timeSegment = tsToken.slice(9);
+  const targetDir = path.join(MOCK_SAMPLES_DIR, entryName, providerId, model, daySegment, timeSegment, seqStr);
+  await ensureDir(targetDir);
+
+  const enrichedRequest = { ...request, reqId, entryEndpoint: request?.endpoint };
+  const enrichedResponse = { ...response, reqId, entryEndpoint: response?.endpoint };
+  await fs.writeFile(path.join(targetDir, 'request.json'), JSON.stringify(enrichedRequest, null, 2));
+  await fs.writeFile(path.join(targetDir, 'response.json'), JSON.stringify(enrichedResponse, null, 2));
+
+  const clientRequestFile = pickLatestStageFile(files, 'client-request');
+  if (clientRequestFile) {
+    try {
+      const client = JSON.parse(await fs.readFile(path.join(requestDir, clientRequestFile), 'utf-8'));
+      const enrichedClient = { ...client, reqId, entryEndpoint: client?.endpoint };
+      await fs.writeFile(path.join(targetDir, 'client-request.json'), JSON.stringify(enrichedClient, null, 2));
+    } catch {
+      // ignore client-request parse errors
+    }
+  }
+
+  registry.samples = registry.samples.filter((sample) => sample.reqId !== reqId);
+  registry.samples.push({
+    reqId,
+    entry: entryName,
+    providerId,
+    model,
+    timestamp: new Date(parseRequestTimestamp(requestId, request)).toISOString(),
+    path: path.relative(MOCK_SAMPLES_DIR, targetDir),
+    tags: buildTags(response)
+  });
+  console.log(`✅ ${reqId}`);
+}
+
 async function extractAll(options = {}) {
   console.log('[mock:extract] Preparing directories...');
   await ensureDir(MOCK_SAMPLES_DIR);
@@ -199,7 +350,41 @@ async function extractAll(options = {}) {
       continue;
     }
     const entryDir = path.join(CODEX_SAMPLES_DIR, dirEntry.name);
-    const files = await fs.readdir(entryDir);
+    const entries = await fs.readdir(entryDir, { withFileTypes: true });
+
+    // Newer layout: entry/<provider>/<requestId>/... (all stages in one directory)
+    // Previous layout: entry/<requestId>/... (single-level request directory)
+    for (const sub of entries) {
+      if (!sub.isDirectory()) continue;
+      const maybeProviderOrRequestDir = path.join(entryDir, sub.name);
+      let nested = [];
+      try {
+        nested = await fs.readdir(maybeProviderOrRequestDir, { withFileTypes: true });
+      } catch {
+        nested = [];
+      }
+      const hasJsonFiles = nested.some((e) => e.isFile() && e.name.toLowerCase().endsWith('.json'));
+      if (hasJsonFiles) {
+        try {
+          await extractPairFromRequestDir(dirEntry.name, maybeProviderOrRequestDir, registry, seqMap, { provider: providerFilter });
+        } catch (error) {
+          console.warn(`⚠️  Skipped ${sub.name}: ${error.message}`);
+        }
+        continue;
+      }
+      const requestDirs = nested.filter((e) => e.isDirectory());
+      for (const reqSub of requestDirs) {
+        const requestDir = path.join(maybeProviderOrRequestDir, reqSub.name);
+        try {
+          await extractPairFromRequestDir(dirEntry.name, requestDir, registry, seqMap, { provider: providerFilter });
+        } catch (error) {
+          console.warn(`⚠️  Skipped ${sub.name}/${reqSub.name}: ${error.message}`);
+        }
+      }
+    }
+
+    // Legacy layout: entry/*_provider-request.json
+    const files = entries.filter((e) => e.isFile()).map((e) => e.name);
     const requests = files.filter((name) => name.endsWith('_provider-request.json'));
     for (const file of requests) {
       try {
@@ -215,25 +400,73 @@ async function extractAll(options = {}) {
 }
 
 async function extractSingle(reqId) {
-  const parts = reqId.split('-');
-  if (parts.length < 5) {
-    throw new Error(`Invalid requestId format: ${reqId}`);
+  await ensureDir(MOCK_SAMPLES_DIR);
+  await ensureDir(path.join(MOCK_SAMPLES_DIR, '_registry'));
+  const registry = await loadRegistry();
+  const seqMap = buildSeqMapFromRegistry(registry);
+
+  const inferredEntry = inferEntryFolder(reqId);
+  const entryDir = path.join(CODEX_SAMPLES_DIR, inferredEntry);
+  const requestDir = path.join(entryDir, sanitizeRequestDirName(reqId));
+  try {
+    const stat = await fs.stat(requestDir);
+    if (stat.isDirectory()) {
+      await extractPairFromRequestDir(inferredEntry, requestDir, registry, seqMap);
+      await saveRegistry(registry);
+      return;
+    }
+  } catch {
+    // fall through
   }
-  const entry = parts.slice(0, parts.length - 4).join('-') || parts[0];
-  const entryDir = path.join(CODEX_SAMPLES_DIR, entry);
+
+  // Newer layout: entry/<provider>/<requestId>/...
+  try {
+    const providerDirs = await fs.readdir(entryDir, { withFileTypes: true });
+    for (const providerDir of providerDirs) {
+      if (!providerDir.isDirectory()) continue;
+      const candidate = path.join(entryDir, providerDir.name, sanitizeRequestDirName(reqId));
+      try {
+        const stat = await fs.stat(candidate);
+        if (stat.isDirectory()) {
+          await extractPairFromRequestDir(inferredEntry, candidate, registry, seqMap);
+          await saveRegistry(registry);
+          return;
+        }
+      } catch {
+        // continue
+      }
+    }
+  } catch {
+    // ignore entryDir scan errors
+  }
+
   const files = await fs.readdir(entryDir);
   const target = files.find((file) => file.includes(reqId) && file.endsWith('_provider-request.json'));
   if (!target) {
-    throw new Error(`Request ${reqId} not found under ${entry}`);
+    throw new Error(`Request ${reqId} not found under ${inferredEntry}`);
   }
-  await ensureDir(MOCK_SAMPLES_DIR);
-  await ensureDir(path.join(MOCK_SAMPLES_DIR, '_registry'));
-  const registry = await loadRegistry();
-  const seqMap = buildSeqMapFromRegistry(registry);
-  await extractPair(entry, entryDir, target, registry, seqMap);
+  await extractPair(inferredEntry, entryDir, target, registry, seqMap);
   await saveRegistry(registry);
 }
 
+function sanitizeRequestDirName(value) {
+  if (typeof value !== 'string' || !value.trim()) {
+    return `req_${Date.now()}`;
+  }
+  return value.trim().replace(/[^A-Za-z0-9_.-]/g, '_');
+}
+
+function inferEntryFolder(reqId) {
+  const lower = String(reqId || '').toLowerCase();
+  if (lower.includes('openai-responses') || lower.includes('responses')) {
+    return 'openai-responses';
+  }
+  if (lower.includes('anthropic')) {
+    return 'anthropic-messages';
+  }
+  return 'openai-chat';
+}
+
 function parseArguments(argv) {
   const opts = { mode: 'all', reqId: undefined, provider: undefined, entry: undefined };
   for (const arg of argv) {

package/scripts/mock-provider/run-regressions.mjs

@@ -37,13 +37,14 @@ function parseEntryFilter() {
 
 async function ensureCliAvailable() {
   const cliPath = path.join(PROJECT_ROOT, 'dist', 'cli.js');
-  if (await fileExists(cliPath)) {
+  const serverPath = path.join(PROJECT_ROOT, 'dist', 'index.js');
+  if ((await fileExists(cliPath)) && (await fileExists(serverPath))) {
     return;
   }
-  console.warn('[mock:regressions] dist/cli.js missing, running "npm run build:min" automatically...');
+  console.warn('[mock:regressions] dist artifacts missing (cli.js/index.js), running "npm run build:min" automatically...');
   await runBuildForMockRegressions();
-  if (!(await fileExists(cliPath))) {
-    throw new Error('dist/cli.js missing after automatic build. Please run "npm run build:dev" manually.');
+  if (!(await fileExists(cliPath)) || !(await fileExists(serverPath))) {
+    throw new Error('dist artifacts missing after automatic build. Please run "npm run build:dev" manually.');
   }
 }
 
@@ -187,7 +188,7 @@ async function writeTempConfig(sample, port) {
   return { dir, file };
 }
 
-function createServer(configPath, port) {
+function createServer(configPath, port, snapshotRoot) {
   const env = {
     ...process.env,
     ROUTECODEX_USE_MOCK: '1',
@@ -196,7 +197,14 @@ function createServer(configPath, port) {
     ROUTECODEX_MOCK_VALIDATE_NAMES: '1',
     ROUTECODEX_STAGE_LOG: process.env.ROUTECODEX_STAGE_LOG ?? '0',
     ROUTECODEX_PORT: String(port),
-    ROUTECODEX_CONFIG_PATH: configPath
+    ROUTECODEX_CONFIG_PATH: configPath,
+    // 将快照写入临时目录，避免污染全局 ~/.routecodex/codex-samples 样本
+    ...(snapshotRoot
+      ? {
+          ROUTECODEX_SNAPSHOT_DIR: snapshotRoot,
+          RCC_SNAPSHOT_DIR: snapshotRoot
+        }
+      : {})
   };
   const entry = path.join(PROJECT_ROOT, 'dist', 'index.js');
   const child = spawn(process.execPath, [entry], {
@@ -305,10 +313,9 @@ function validateToolCallIds(payload, sample, tagSet) {
   if (!payload || typeof payload !== 'object') {
     return errors;
   }
-  const wantsFcIds =
-    tagSet.has('require_fc_call_ids') ||
-    tagSet.has('missing_tool_call_id') ||
-    tagSet.has('regression');
+  const enforceCallIdFormat = tagSet.has('require_fc_call_ids');
+  const isValidCallId = (value) =>
+    /^call_[A-Za-z0-9]+$/.test(value) || /^fc[_-][A-Za-z0-9-]+$/.test(value);
 
   const allToolCallIds = new Set();
   if (Array.isArray(payload.output)) {
@@ -323,7 +330,7 @@ function validateToolCallIds(payload, sample, tagSet) {
           return;
         }
         allToolCallIds.add(rawId);
-        if (wantsFcIds && !/^call_[A-Za-z0-9]+$/.test(rawId)) {
+        if (enforceCallIdFormat && !isValidCallId(rawId)) {
           errors.push(`output[${oi}].tool_calls[${ti}].id has invalid format: ${rawId}`);
         }
       });
@@ -340,12 +347,16 @@ function validateToolCallIds(payload, sample, tagSet) {
   if (Array.isArray(submitCalls)) {
     submitCalls.forEach((tc, i) => {
       if (!tc || typeof tc !== 'object') return;
-      const rawId = typeof tc.tool_call_id === 'string' ? tc.tool_call_id.trim() : '';
+      const rawId = typeof tc.tool_call_id === 'string'
+        ? tc.tool_call_id.trim()
+        : typeof tc.id === 'string'
+          ? tc.id.trim()
+          : '';
       if (!rawId) {
         errors.push(`required_action.submit_tool_outputs.tool_calls[${i}].tool_call_id missing`);
         return;
       }
-      if (wantsFcIds && !/^call_[A-Za-z0-9]+$/.test(rawId)) {
+      if (enforceCallIdFormat && !isValidCallId(rawId)) {
         errors.push(
           `required_action.submit_tool_outputs.tool_calls[${i}].tool_call_id has invalid format: ${rawId}`
         );
@@ -395,6 +406,10 @@ function resolveRequestUrl(sample, requestDoc, port) {
 async function sendRequest(sample, requestDoc, port) {
   const url = resolveRequestUrl(sample, requestDoc, port);
   const payload = extractRequestBody(requestDoc);
+  if (payload && typeof payload === 'object') {
+    const meta = payload.metadata && typeof payload.metadata === 'object' ? payload.metadata : {};
+    payload.metadata = { ...meta, mockSampleReqId: sample.reqId };
+  }
   const headers = { 'content-type': 'application/json' };
   const wantsStream =
     payload?.stream === true ||
@@ -424,15 +439,64 @@ async function sendRequest(sample, requestDoc, port) {
   }
 }
 
+function looksLikeSseErrorStream(text) {
+  if (typeof text !== 'string') {
+    return false;
+  }
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return false;
+  }
+  // 简单判定：包含 SSE error 事件头和 JSON error 负载。
+  if (trimmed.includes('event: error') && trimmed.includes('data:')) {
+    return true;
+  }
+  if (trimmed.includes('"type":"error"') || trimmed.includes('"status":502')) {
+    return true;
+  }
+  return false;
+}
+
 async function runSample(sample, index) {
   const clientDoc = await loadSampleDocument(sample, { fileName: 'client-request.json', optional: true });
   const requestDoc = clientDoc || (await loadSampleDocument(sample));
+  const responseDoc = await loadSampleDocument(sample, { fileName: 'response.json', optional: true });
   const port = 5800 + index;
   const { dir, file } = await writeTempConfig(sample, port);
-  const server = createServer(file, port);
+  // 为当前样本创建独立的临时快照根目录，并在完成后整体删除
+  const snapshotRoot = path.join(dir, 'codex-samples');
+  const server = createServer(file, port, snapshotRoot);
+  const tags = new Set(Array.isArray(sample.tags) ? sample.tags : []);
+  const expectSseTerminationError = tags.has('responses_sse_terminated');
+  const allowSampleError =
+    responseDoc && typeof responseDoc.status === 'number' && responseDoc.status >= 400;
   try {
     await waitForHealth(port, server.process);
-    const responseText = await sendRequest(sample, requestDoc, port);
+    let responseText;
+    try {
+      responseText = await sendRequest(sample, requestDoc, port);
+      if (expectSseTerminationError) {
+        if (!looksLikeSseErrorStream(responseText)) {
+          throw new Error(
+            'expected SSE termination to surface as HTTP error or SSE error event, but got successful non-error payload'
+          );
+        }
+        // 对于 SSE 终止样本，只要以 SSE error 事件形式返回即可视为通过。
+        return;
+      }
+    } catch (sendError) {
+      if (expectSseTerminationError || allowSampleError) {
+        const msg = sendError instanceof Error ? sendError.message : String(sendError);
+        if (!/HTTP\s+4\d\d|HTTP\s+5\d\d/i.test(msg)) {
+          throw new Error(
+            `expected HTTP 4xx/5xx error, but got: ${msg}`
+          );
+        }
+        // 对于错误类样本，只要成功以 HTTP 错误形式透出即可。
+        return;
+      }
+      throw sendError;
+    }
     const body = (() => {
       try {
         return JSON.parse(responseText);
@@ -440,7 +504,6 @@ async function runSample(sample, index) {
         return undefined;
       }
     })();
-    const tags = new Set(Array.isArray(sample.tags) ? sample.tags : []);
     if (body && Array.isArray(body.output)) {
       const invalid = collectInvalidNames(body);
       if (invalid.length) {
@@ -482,6 +545,10 @@ async function main() {
     console.warn('[mock:regressions] No regression-tagged samples matched current filters; skipping mock replay.');
     return;
   }
+
+  const coverageByEntry = Object.create(null);
+  const coverageByProvider = Object.create(null);
+
   const tagCounter = Object.create(null);
   const incrementTag = (tag) => {
     if (!watchedTags.has(tag)) {
@@ -491,6 +558,12 @@ async function main() {
   };
   regressionSamples.forEach((sample) => {
     const matched = new Set();
+    const entry = typeof sample.entry === 'string' && sample.entry.trim().length ? sample.entry.trim() : 'unknown';
+    const providerId =
+      typeof sample.providerId === 'string' && sample.providerId.trim().length ? sample.providerId.trim() : 'unknown';
+    coverageByEntry[entry] = (coverageByEntry[entry] || 0) + 1;
+    coverageByProvider[providerId] = (coverageByProvider[providerId] || 0) + 1;
+
     (sample.tags || []).forEach((tag) => {
       if (watchedTags.has(tag) && !matched.has(tag)) {
         incrementTag(tag);
@@ -506,6 +579,14 @@ async function main() {
     .map((tag) => `${tag}=${tagCounter[tag] || 0}`)
     .join(', ');
   console.log(`✅ mock provider regressions passed (${regressionSamples.length} samples · ${summary})`);
+  const byEntry = Object.entries(coverageByEntry)
+    .map(([entry, count]) => `${entry}=${count}`)
+    .join(', ');
+  const byProvider = Object.entries(coverageByProvider)
+    .map(([pid, count]) => `${pid}=${count}`)
+    .join(', ');
+  console.log(`[mock:regressions] coverage by entry: ${byEntry}`);
+  console.log(`[mock:regressions] coverage by providerId: ${byProvider}`);
 }
 
 main().catch((error) => {

package/scripts/quota-dryrun.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+/**
+ * Quota dry-run helper:
+ * 从简单的 JSON 事件数组读取错误/成功/usage 事件，驱动 provider-quota-center，
+ * 并将结果写入 ~/.routecodex/quota/provider-quota.json，方便人工检查。
+ *
+ * 用法:
+ *   node scripts/quota-dryrun.mjs path/to/events.json
+ *
+ * 事件格式示例:
+ * [
+ *   { "type": "error", "providerKey": "antigravity.alias1.gemini-3-pro-high", "httpStatus": 429 },
+ *   { "type": "success", "providerKey": "antigravity.alias1.gemini-3-pro-high", "usedTokens": 120 },
+ *   { "type": "usage", "providerKey": "antigravity.alias1.gemini-3-pro-high", "requestedTokens": 80 }
+ * ]
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  applyErrorEvent,
+  applySuccessEvent,
+  applyUsageEvent,
+  createInitialQuotaState
+} from '../src/manager/quota/provider-quota-center.js';
+import {
+  saveProviderQuotaSnapshot
+} from '../src/manager/quota/provider-quota-store.js';
+
+async function main() {
+  const fileArg = process.argv[2];
+  if (!fileArg) {
+    // eslint-disable-next-line no-console
+    console.error('Usage: node scripts/quota-dryrun.mjs path/to/events.json');
+    process.exitCode = 1;
+    return;
+  }
+  const filePath = path.resolve(process.cwd(), fileArg);
+  const raw = await fs.readFile(filePath, 'utf8');
+  const events = JSON.parse(raw);
+  if (!Array.isArray(events)) {
+    throw new Error('events file must contain a JSON array');
+  }
+
+  const states = new Map();
+  const nowMs = Date.now();
+
+  for (const entry of events) {
+    if (!entry || typeof entry !== 'object') {
+      // eslint-disable-next-line no-console
+      console.warn('[quota-dryrun] skip non-object event', entry);
+      continue;
+    }
+    const record = entry;
+    const providerKey = typeof record.providerKey === 'string' ? record.providerKey.trim() : '';
+    if (!providerKey) {
+      // eslint-disable-next-line no-console
+      console.warn('[quota-dryrun] event missing providerKey', record);
+      continue;
+    }
+    const type = typeof record.type === 'string' ? record.type.trim().toLowerCase() : '';
+    if (!type) {
+      // eslint-disable-next-line no-console
+      console.warn('[quota-dryrun] event missing type', record);
+      continue;
+    }
+    const existing = states.get(providerKey) as any | undefined;
+    const baseState =
+      existing ??
+      createInitialQuotaState(providerKey, undefined, nowMs);
+    let nextState = baseState;
+
+    if (type === 'error') {
+      nextState = applyErrorEvent(
+        baseState,
+        {
+          providerKey,
+          code: record.code,
+          httpStatus: record.httpStatus,
+          fatal: record.fatal === true
+        },
+        nowMs
+      );
+    } else if (type === 'success') {
+      nextState = applySuccessEvent(
+        baseState,
+        {
+          providerKey,
+          usedTokens: record.usedTokens
+        },
+        nowMs
+      );
+    } else if (type === 'usage') {
+      nextState = applyUsageEvent(
+        baseState,
+        {
+          providerKey,
+          requestedTokens: record.requestedTokens
+        },
+        nowMs
+      );
+    } else {
+      // eslint-disable-next-line no-console
+      console.warn('[quota-dryrun] unknown event type', type);
+      continue;
+    }
+    states.set(providerKey, nextState);
+  }
+
+  const snapshot = Object.fromEntries(states.entries());
+  await saveProviderQuotaSnapshot(snapshot, new Date());
+  // eslint-disable-next-line no-console
+  console.log(
+    `[quota-dryrun] wrote snapshot for ${states.size} provider(s) to ~/.routecodex/quota/provider-quota.json`
+  );
+}
+
+main().catch((error) => {
+  // eslint-disable-next-line no-console
+  console.error('[quota-dryrun] failed:', error);
+  process.exitCode = 1;
+});
+