@jsonstudio/rcc 0.85.9 → 0.89.3

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

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import { setTimeout as delay } from 'node:timers/promises';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.resolve(__dirname, '../..');
+const MOCK_SAMPLES_DIR = resolveSamplesDir();
+const REGISTRY_PATH = path.join(MOCK_SAMPLES_DIR, '_registry', 'index.json');
+const NAME_REGEX = /^[A-Za-z0-9_-]+$/;
+const ENTRY_FILTER = parseEntryFilter();
+
+function resolveSamplesDir() {
+  const override = String(process.env.ROUTECODEX_MOCK_SAMPLES_DIR || '').trim();
+  if (override) {
+    return path.isAbsolute(override) ? override : path.resolve(PROJECT_ROOT, override);
+  }
+  return path.join(PROJECT_ROOT, 'samples/mock-provider');
+}
+
+function parseEntryFilter() {
+  const raw = String(process.env.ROUTECODEX_MOCK_ENTRY_FILTER || 'openai-chat').trim();
+  if (!raw || raw.toLowerCase() === 'all') {
+    return null;
+  }
+  const parts = raw
+    .split(',')
+    .map((value) => value.trim())
+    .filter(Boolean);
+  return parts.length ? new Set(parts) : null;
+}
+
+async function ensureCliAvailable() {
+  const cliPath = path.join(PROJECT_ROOT, 'dist', 'cli.js');
+  try {
+    await fs.access(cliPath);
+  } catch {
+    throw new Error('dist/cli.js missing. Please run "npm run build:dev" before mock regressions.');
+  }
+}
+
+async function loadRegistry() {
+  const raw = await fs.readFile(REGISTRY_PATH, 'utf-8');
+  const registry = JSON.parse(raw);
+  if (!registry || !Array.isArray(registry.samples)) {
+    throw new Error('Mock registry missing samples array');
+  }
+  return registry.samples.filter((sample) => {
+    if (!ENTRY_FILTER) {
+      return true;
+    }
+    return sample.entry && ENTRY_FILTER.has(sample.entry);
+  });
+}
+
+async function loadSampleDocument(sample) {
+  const sampleDir = path.join(MOCK_SAMPLES_DIR, sample.path);
+  const requestPath = path.join(sampleDir, 'request.json');
+  const raw = await fs.readFile(requestPath, 'utf-8');
+  const doc = JSON.parse(raw);
+  if (!doc || typeof doc !== 'object' || !doc.body) {
+    throw new Error(`Sample ${sample.reqId} missing request body`);
+  }
+  return doc;
+}
+
+function parseProviderKey(providerKey) {
+  const parts = providerKey.split('.');
+  if (parts.length < 3) {
+    throw new Error(`Invalid providerId "${providerKey}" in registry (expected provider.alias.model)`);
+  }
+  return {
+    providerId: parts[0],
+    alias: parts[1],
+    model: parts.slice(2).join('.')
+  };
+}
+
+function resolveToolCallIdStyle(sample) {
+  const tags = Array.isArray(sample.tags) ? sample.tags : [];
+  if (tags.includes('missing_tool_call_id') || tags.includes('preserve_tool_call_id')) {
+    return 'preserve';
+  }
+  return 'fc';
+}
+
+function buildConfig(sample, port) {
+  const { providerId, alias, model } = parseProviderKey(sample.providerId);
+  const toolCallIdStyle = resolveToolCallIdStyle(sample);
+  return {
+    version: '1.0.0',
+    virtualrouter: {
+      inputProtocol: 'openai',
+      outputProtocol: 'openai',
+      providers: {
+        [providerId]: {
+          id: providerId,
+          enabled: true,
+          type: 'mock-provider',
+          providerType: 'responses',
+          baseURL: `https://mock.local/${providerId}`,
+          compat: 'passthrough',
+          providerId: sample.providerId,
+          auth: {
+            type: 'apikey',
+            keys: {
+              [alias]: {
+                value: `mock-${alias}-token-1234567890`
+              }
+            }
+          },
+          modelId: model,
+          models: {
+            [model]: {
+              maxTokens: 32768
+            }
+          },
+          responses: {
+            toolCallIdStyle
+          }
+        }
+      },
+      routing: {
+        default: [`${providerId}.${alias}.${model}`]
+      }
+    },
+    httpserver: {
+      host: '127.0.0.1',
+      port
+    }
+  };
+}
+
+async function writeTempConfig(sample, port) {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'routecodex-mock-'));
+  const file = path.join(dir, 'config.json');
+  const config = buildConfig(sample, port);
+  await fs.writeFile(file, JSON.stringify(config, null, 2), 'utf-8');
+  return { dir, file };
+}
+
+function createServer(configPath, port) {
+  const env = {
+    ...process.env,
+    ROUTECODEX_USE_MOCK: '1',
+    ROUTECODEX_MOCK_CONFIG_PATH: configPath,
+    ROUTECODEX_MOCK_SAMPLES_DIR: MOCK_SAMPLES_DIR,
+    ROUTECODEX_MOCK_VALIDATE_NAMES: '1',
+    ROUTECODEX_STAGE_LOG: process.env.ROUTECODEX_STAGE_LOG ?? '0',
+    ROUTECODEX_PORT: String(port),
+    ROUTECODEX_CONFIG_PATH: configPath
+  };
+  const child = spawn('routecodex', ['start', '--config', configPath], {
+    cwd: PROJECT_ROOT,
+    env,
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  let stdout = '';
+  let stderr = '';
+  child.stdout.on('data', (chunk) => {
+    stdout += chunk.toString();
+    if (stdout.length > 4000) {
+      stdout = stdout.slice(-4000);
+    }
+  });
+  child.stderr.on('data', (chunk) => {
+    stderr += chunk.toString();
+    if (stderr.length > 4000) {
+      stderr = stderr.slice(-4000);
+    }
+  });
+  return {
+    process: child,
+    logs: () => ({ stdout, stderr })
+  };
+}
+
+async function waitForHealth(port, serverProc, timeoutMs = 20000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (serverProc.exitCode !== null) {
+      throw new Error(`RouteCodex server exited early (code ${serverProc.exitCode})`);
+    }
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/health`, { method: 'GET' });
+      if (res.ok) {
+        return;
+      }
+    } catch {
+      // retry
+    }
+    await delay(250);
+  }
+  throw new Error('RouteCodex health check timed out');
+}
+
+async function stopServer(child, forceTimeout = 5000) {
+  if (!child || child.killed) {
+    return;
+  }
+  child.kill('SIGTERM');
+  const deadline = Date.now() + forceTimeout;
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null) {
+      return;
+    }
+    await delay(100);
+  }
+  child.kill('SIGKILL');
+}
+
+function collectInvalidNames(payload) {
+  const failures = [];
+  const check = (value, location) => {
+    if (typeof value !== 'string' || !value.trim()) {
+      return;
+    }
+    if (!NAME_REGEX.test(value)) {
+      failures.push({ location, value });
+    }
+  };
+
+  const visitArray = (value, base) => {
+    if (!Array.isArray(value)) {
+      return;
+    }
+    value.forEach((entry, index) => {
+      if (!entry || typeof entry !== 'object') {
+        return;
+      }
+      check(entry.name, `${base}[${index}].name`);
+      if (entry.function && typeof entry.function === 'object') {
+        check(entry.function.name, `${base}[${index}].function.name`);
+      }
+    });
+  };
+
+  if (payload && typeof payload === 'object') {
+    const record = payload;
+    visitArray(record.input, 'input');
+    visitArray(record.tools, 'tools');
+    const requiredAction = record.required_action;
+    if (requiredAction && typeof requiredAction === 'object') {
+      const submit = requiredAction.submit_tool_outputs;
+      if (submit && typeof submit === 'object') {
+        visitArray(submit.tool_calls, 'required_action.tool_calls');
+      }
+    }
+  }
+
+  return failures;
+}
+
+async function sendRequest(sample, requestDoc, port) {
+  const url = `http://127.0.0.1:${port}${requestDoc.endpoint || sample.entry}`;
+  const headers = { 'content-type': 'application/json' };
+  if (requestDoc.body?.stream === true) {
+    headers.accept = 'text/event-stream';
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 60000).unref?.();
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(requestDoc.body),
+      signal: controller.signal
+    });
+    const text = await res.text();
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status}: ${text}`);
+    }
+    return text;
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}
+
+async function runSample(sample, index) {
+  const requestDoc = await loadSampleDocument(sample);
+  const port = 5800 + index;
+  const { dir, file } = await writeTempConfig(sample, port);
+  const server = createServer(file, port);
+  try {
+    await waitForHealth(port, server.process);
+    const responseText = await sendRequest(sample, requestDoc, port);
+    const body = (() => {
+      try {
+        return JSON.parse(responseText);
+      } catch {
+        return undefined;
+      }
+    })();
+    if (body && Array.isArray(body.output)) {
+      const invalid = collectInvalidNames(body);
+      if (invalid.length) {
+        throw new Error(
+          `[${sample.reqId}] provider response still contains invalid names:\n${invalid
+            .map((item) => ` - ${item.location}: ${item.value}`)
+            .join('\n')}`
+        );
+      }
+    }
+  } catch (error) {
+    const logs = server.logs();
+    throw new Error(
+      `[${sample.reqId}] regression failed: ${error instanceof Error ? error.message : String(error)}\n` +
+        `--- RouteCodex stdout ---\n${logs.stdout}\n--- RouteCodex stderr ---\n${logs.stderr}`
+    );
+  } finally {
+    await stopServer(server.process);
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+}
+
+async function main() {
+  await ensureCliAvailable();
+  const samples = await loadRegistry();
+  const watchedTags = new Set(['invalid_name', 'missing_output', 'missing_tool_call_id', 'require_fc_call_ids', 'regression']);
+  const regressionSamples = samples.filter(
+    (sample) => Array.isArray(sample.tags) && sample.tags.some((tag) => watchedTags.has(tag))
+  );
+  if (!regressionSamples.length) {
+    console.warn('[mock:regressions] No regression-tagged samples matched current filters; skipping mock replay.');
+    return;
+  }
+  const tagCounter = Object.create(null);
+  const incrementTag = (tag) => {
+    if (!watchedTags.has(tag)) {
+      return;
+    }
+    tagCounter[tag] = (tagCounter[tag] || 0) + 1;
+  };
+  regressionSamples.forEach((sample) => {
+    const matched = new Set();
+    (sample.tags || []).forEach((tag) => {
+      if (watchedTags.has(tag) && !matched.has(tag)) {
+        incrementTag(tag);
+        matched.add(tag);
+      }
+    });
+  });
+  for (let idx = 0; idx < regressionSamples.length; idx += 1) {
+    const sample = regressionSamples[idx];
+    await runSample(sample, idx);
+  }
+  const summary = Array.from(watchedTags)
+    .map((tag) => `${tag}=${tagCounter[tag] || 0}`)
+    .join(', ');
+  console.log(`✅ mock provider regressions passed (${regressionSamples.length} samples · ${summary})`);
+}
+
+main().catch((error) => {
+  console.error(`[mock:regressions] Failed: ${error.message}`);
+  process.exitCode = 1;
+});

package/scripts/mock-provider/validate.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, '../..');
+
+function resolveSamplesDir() {
+  const override = String(process.env.ROUTECODEX_MOCK_SAMPLES_DIR || '').trim();
+  if (override) {
+    return path.isAbsolute(override) ? override : path.resolve(projectRoot, override);
+  }
+  return path.join(projectRoot, 'samples/mock-provider');
+}
+
+const MOCK_SAMPLES_DIR = resolveSamplesDir();
+const REGISTRY_PATH = path.join(MOCK_SAMPLES_DIR, '_registry/index.json');
+
+async function loadRegistry() {
+  const raw = await fs.readFile(REGISTRY_PATH, 'utf-8');
+  const registry = JSON.parse(raw);
+  if (!registry || typeof registry !== 'object' || !Array.isArray(registry.samples)) {
+    throw new Error('Registry missing samples array');
+  }
+  return registry.samples;
+}
+
+async function validateSample(sample) {
+  if (!sample || typeof sample !== 'object') {
+    throw new Error('Invalid registry entry');
+  }
+  const { reqId, path: relativePath } = sample;
+  if (typeof reqId !== 'string' || !reqId.includes('-')) {
+    throw new Error(`Invalid reqId: ${reqId}`);
+  }
+  if (typeof relativePath !== 'string' || !relativePath.trim()) {
+    throw new Error(`Sample ${reqId} missing path`);
+  }
+  const sampleDir = path.join(MOCK_SAMPLES_DIR, relativePath);
+  const requestPath = path.join(sampleDir, 'request.json');
+  const responsePath = path.join(sampleDir, 'response.json');
+  let request;
+  try {
+    const requestRaw = await fs.readFile(requestPath, 'utf-8');
+    request = JSON.parse(requestRaw);
+  } catch (error) {
+    throw new Error(`Sample ${reqId} missing request.json (${error.message})`);
+  }
+  if (request.reqId !== reqId) {
+    throw new Error(`Sample ${reqId} request reqId mismatch (${request.reqId})`);
+  }
+  try {
+    const responseRaw = await fs.readFile(responsePath, 'utf-8');
+    const response = JSON.parse(responseRaw);
+    if (response.reqId !== reqId) {
+      throw new Error(`Sample ${reqId} response reqId mismatch (${response.reqId})`);
+    }
+  } catch (error) {
+    throw new Error(`Sample ${reqId} missing response.json (${error.message})`);
+  }
+}
+
+async function main() {
+  try {
+    await fs.access(MOCK_SAMPLES_DIR);
+  } catch {
+    throw new Error(`Mock samples directory not found: ${MOCK_SAMPLES_DIR}`);
+  }
+  const samples = await loadRegistry();
+  if (samples.length === 0) {
+    throw new Error('Registry contains no samples');
+  }
+  let failures = 0;
+  for (const sample of samples) {
+    try {
+      await validateSample(sample);
+    } catch (error) {
+      failures++;
+      console.error(`❌ ${error.message}`);
+    }
+  }
+  if (failures > 0) {
+    throw new Error(`Validation failed for ${failures} sample(s)`);
+  }
+  console.log(`✅ ${samples.length} mock samples validated (${MOCK_SAMPLES_DIR})`);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error(`[mock:validate] Failed: ${error.message}`);
+    process.exitCode = 1;
+  });
+}
+

package/scripts/outbound-network-toolcall.mjs

@@ -6,7 +6,7 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import { ProviderFactory } from '../dist/modules/pipeline/modules/provider/v2/core/provider-factory.js';
+import { ProviderFactory } from '../dist/providers/core/runtime/provider-factory.js';
 
 const root = path.join(os.homedir(), '.routecodex', 'provider');
 const MAX_PROVIDERS = parseInt(process.env.RCC_NET_MAX_PROVIDERS || '5', 10);

package/scripts/outbound-regression-codex-samples.mjs

@@ -7,7 +7,7 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { pathToFileURL } from 'url';
-import { ProviderFactory } from '../dist/modules/pipeline/modules/provider/v2/core/provider-factory.js';
+import { ProviderFactory } from '../dist/providers/core/runtime/provider-factory.js';
 
 const CODEx_DIR = path.join(os.homedir(), '.routecodex', 'codex-samples', 'openai-chat');
 const RESPONSES_SAMPLE_DIR = path.join(os.homedir(), '.routecodex', 'codex-samples', 'openai-responses');

package/scripts/pack-mode.mjs

@@ -41,7 +41,7 @@ try {
       ...(original.dependencies || {}),
       "ajv": original.dependencies?.ajv || "^8.17.1",
       "zod": original.dependencies?.zod || "^3.23.8",
-      "rcc-llmswitch-core": original.dependencies?.["rcc-llmswitch-core"] || "^0.3.12"
+      "@jsonstudio/llms": original.dependencies?.["@jsonstudio/llms"] || "^0.4.3"
     };
   }
   fs.writeFileSync(pkgPath, JSON.stringify(mutated, null, 2));

package/scripts/probe-iflow-provider.mjs

@@ -45,7 +45,7 @@ async function run() {
   let tok0 = await loadLocalToken();
   if (process.env.IFLOW_FORCE_OAUTH === '1' || !tok0 || isExpired(tok0)) {
     console.log(`[iflow] obtaining token via device-code flow... (${tokenFile})`);
-    const { createProviderOAuthStrategy } = await import('../dist/modules/pipeline/modules/provider/v2/config/provider-oauth-configs.js');
+    const { createProviderOAuthStrategy } = await import('../dist/providers/core/config/provider-oauth-configs.js');
     const strat = createProviderOAuthStrategy('iflow', {
       flowType: 'device_code',
       endpoints: { deviceCodeUrl: 'https://iflow.cn/oauth/device/code', tokenUrl: 'https://iflow.cn/oauth/token', userInfoUrl: 'https://iflow.cn/api/oauth/getUserInfo' },
@@ -60,7 +60,7 @@ async function run() {
   }
 
   // 3) Create provider and send a chat request
-  const { ChatHttpProvider } = await import('../dist/modules/pipeline/modules/provider/v2/core/chat-http-provider.js');
+  const { ChatHttpProvider } = await import('../dist/providers/core/runtime/chat-http-provider.js');
   const provider = new ChatHttpProvider(cfg, {});
   await provider.initialize();
   const body = { model, messages: [{ role:'user', content:text }], stream:false };

package/scripts/responses-fai-capture.mjs

@@ -73,7 +73,7 @@ async function main() {
   const model = prov.model || prov.modelId || prov.defaultModel || 'gpt-5.1';
   if (!apiKey) throw new Error('no apikey');
 
-  const httpPath = pathToFileURL(path.join(process.cwd(), 'dist/modules/pipeline/modules/provider/v2/utils/http-client.js')).href;
+  const httpPath = pathToFileURL(path.join(process.cwd(), 'dist/providers/core/utils/http-client.js')).href;
   const { HttpClient } = await import(httpPath);
   const convPath = pathToFileURL(path.join(process.cwd(), 'sharedmodule/llmswitch-core/dist/sse/sse-to-json/index.js')).href;
   const { ResponsesSseToJsonConverter } = await import(convPath);

package/scripts/responses-sse-capture.mjs

@@ -103,7 +103,7 @@ async function main() {
   const cfgDoc = findProviderConfig(providerId);
   const provEntry = extractResponsesProviderEntry(cfgDoc, providerId);
   const cfg = { type: provEntry.type, config: provEntry.config };
-  const httpPath = pathToFileURL(path.join(BASEDIR, 'dist/modules/pipeline/modules/provider/v2/utils/http-client.js')).href;
+  const httpPath = pathToFileURL(path.join(BASEDIR, 'dist/providers/core/utils/http-client.js')).href;
   const { HttpClient } = await import(httpPath);
   const bridgePath = pathToFileURL(path.join(BASEDIR, 'sharedmodule/llmswitch-core/dist/conversion/responses/responses-openai-bridge.js')).href;
   const converterPath = pathToFileURL(path.join(BASEDIR, 'sharedmodule/llmswitch-core/dist/sse/sse-to-json/index.js')).href;

package/scripts/responses-sse-proxy.mjs

@@ -97,7 +97,7 @@ async function main() {
     const providerEntry = loadProviderConfig(providerId);
     baseUrl = normalizeBaseUrl(providerEntry);
     headers = buildHeaders(providerEntry);
-    const httpClientPath = pathToFileURL(path.join(process.cwd(), 'dist/modules/pipeline/modules/provider/v2/utils/http-client.js')).href;
+    const httpClientPath = pathToFileURL(path.join(process.cwd(), 'dist/providers/core/utils/http-client.js')).href;
     const { HttpClient } = await import(httpClientPath);
     client = new HttpClient({ baseUrl, timeout: 300000 });
   } else {

package/scripts/responses-sse-replay-golden.mjs

@@ -94,7 +94,7 @@ async function main() {
   body.model = model;
   body.stream = true;
 
-  const httpPath = pathToFileURL(path.join(process.cwd(), 'dist/modules/pipeline/modules/provider/v2/utils/http-client.js')).href;
+  const httpPath = pathToFileURL(path.join(process.cwd(), 'dist/providers/core/utils/http-client.js')).href;
   const { HttpClient } = await import(httpPath);
   const convPath = pathToFileURL(path.join(process.cwd(), 'sharedmodule/llmswitch-core/dist/sse/sse-to-json/index.js')).href;
   const bridgePath = pathToFileURL(path.join(process.cwd(), 'sharedmodule/llmswitch-core/dist/conversion/responses/responses-openai-bridge.js')).href;

package/scripts/snapshot-inspect.mjs

@@ -39,6 +39,31 @@ function diffKeys(a, b) {
   return { added, removed };
 }
 
+function unwrapPayload(obj) {
+  if (!obj || typeof obj !== 'object') return obj;
+  if (obj.body && typeof obj.body === 'object') {
+    return obj.body;
+  }
+  if (obj.bodyText && typeof obj.bodyText === 'string') {
+    return { bodyText: obj.bodyText };
+  }
+  if (obj.data && typeof obj.data === 'object') {
+    if (obj.data.payload && typeof obj.data.payload === 'object') {
+      return obj.data.payload;
+    }
+    return obj.data;
+  }
+  return obj;
+}
+
+function inferStageFromName(name) {
+  if (!name) return undefined;
+  const trimmed = name.replace(/\.json$/i, '');
+  const idx = trimmed.indexOf('_');
+  if (idx === -1) return undefined;
+  return trimmed.slice(idx + 1);
+}
+
 async function readJson(p) {
   try {
     const raw = await fs.readFile(p, 'utf8');
@@ -68,22 +93,20 @@ async function main() {
   }
 
   const rid = args.rid;
-  const files = [
-    `${rid}_http-request.json`,
-    `${rid}_http-request.parsed.json`,
-    `${rid}_pipeline.llmswitch.request.post.json`,
-    `${rid}_pipeline.compatibility.request.post.json`,
-    `${rid}_pipeline.provider.request.pre.json`,
-    `${rid}_pipeline.provider.response.json`,
-  ];
+  const entries = await fs.readdir(baseDir);
+  const matchedFiles = entries.filter(name => name.includes(rid)).sort();
+  if (!matchedFiles.length) {
+    console.error('No snapshots found for RID:', rid, 'under', baseDir);
+    process.exit(3);
+  }
 
   const records = [];
-  for (const name of files) {
+  for (const name of matchedFiles) {
     const p = path.join(baseDir, name);
     const obj = await readJson(p);
     if (!obj) continue;
-    const keys = topKeys(obj?.data?.payload || obj);
-    const payload = obj?.data?.payload || obj;
+    const payload = unwrapPayload(obj);
+    const keys = topKeys(payload);
     const msg = summarizeMessages(payload);
     const flags = {
       has_data: hasKey(payload, 'data'),
@@ -91,18 +114,17 @@ async function main() {
       has_stream: hasKey(payload, 'stream'),
       has_messages: hasKey(payload, 'messages'),
     };
-    records.push({ name, path: p, keys, msg, flags });
-  }
-
-  if (!records.length) {
-    console.error('No snapshots found for RID:', rid, 'under', baseDir);
-    process.exit(3);
+    const stage = obj?.meta?.stage || inferStageFromName(name);
+    const clientRid = obj?.meta?.clientRequestId;
+    records.push({ name, path: p, keys, msg, flags, stage, clientRid });
   }
 
   console.log('Endpoint dir:', baseDir);
   for (const r of records) {
     console.log(`\n=== ${r.name} ===`);
     console.log('- path:', r.path);
+    if (r.stage) console.log('- stage:', r.stage);
+    if (r.clientRid) console.log('- clientRequestId:', r.clientRid);
     console.log('- topKeys:', r.keys.join(', ') || '(none)');
     console.log(`- messages: count=${r.msg.count}, roles=${JSON.stringify(r.msg.roles)}, hasUser=${r.msg.hasUser}`);
     const suspicious = [];
@@ -132,4 +154,3 @@ async function main() {
 }
 
 main().catch(err => { console.error(err); process.exit(99); });
-