@jsonstudio/rcc 0.89.164 → 0.89.333

package/scripts/auth-antigravity-token.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// Antigravity OAuth authentication script
+// Usage:
+//   # 默认使用 ~/.routecodex/auth/antigravity-oauth.json（自动创建/更新）
+//   node scripts/auth-antigravity-token.mjs
+//
+//   # 或通过环境变量显式指定 token 文件（支持 ~ 展开）：
+//   // ANTIGRAVITY_TOKEN_FILE="~/.routecodex/auth/antigravity-oauth-alt.json" node scripts/auth-antigravity-token.mjs
+
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+
+async function resolveAntigravityTokenPath() {
+  const envFile =
+    (process.env.ANTIGRAVITY_TOKEN_FILE && process.env.ANTIGRAVITY_TOKEN_FILE.trim()) ||
+    (process.env.ROUTECODEX_ANTIGRAVITY_TOKEN_FILE && process.env.ROUTECODEX_ANTIGRAVITY_TOKEN_FILE.trim()) ||
+    '';
+
+  if (envFile) {
+    const normalized = envFile.startsWith('~')
+      ? envFile.replace(/^~(?=$|\/)/, os.homedir())
+      : envFile;
+    return path.resolve(normalized);
+  }
+
+  const home = os.homedir();
+  return path.join(home, '.routecodex', 'auth', 'antigravity-oauth.json');
+}
+
+async function run() {
+  const tokenPath = await resolveAntigravityTokenPath();
+  const dir = path.dirname(tokenPath);
+  await fs.mkdir(dir, { recursive: true });
+  try {
+    await fs.access(tokenPath);
+  } catch {
+    await fs.writeFile(tokenPath, '{}', 'utf-8');
+  }
+
+  const { ensureValidOAuthToken } = await import('../dist/providers/auth/oauth-lifecycle.js');
+
+  console.log(`[antigravity-auth] Authenticating token: ${tokenPath}`);
+
+  await ensureValidOAuthToken(
+    'antigravity',
+    {
+      type: 'antigravity-oauth',
+      tokenFile: tokenPath
+    },
+    {
+      forceReauthorize: true,
+      openBrowser: true
+    }
+  );
+
+  console.log(`[antigravity-auth] Token saved to: ${tokenPath}`);
+}
+
+run().catch((err) => {
+  console.error('[antigravity-auth] Error:', err);
+  process.exit(1);
+});
+

package/scripts/auth-gemini-cli-token.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+// Gemini CLI OAuth authentication script
+// Usage:
+//   # 默认使用 ~/.routecodex/auth/gemini-oauth.json（自动创建/更新）
+//   node scripts/auth-gemini-cli-token.mjs
+//
+//   # 或通过环境变量显式指定 token 文件（支持 ~ 展开）：
+//   // GEMINI_CLI_TOKEN_FILE="~/.routecodex/auth/gemini-oauth-1-primary.json" node scripts/auth-gemini-cli-token.mjs
+
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+
+async function resolveGeminiTokenPath() {
+  const envFile =
+    (process.env.GEMINI_CLI_TOKEN_FILE && process.env.GEMINI_CLI_TOKEN_FILE.trim()) ||
+    (process.env.ROUTECODEX_GEMINI_TOKEN_FILE && process.env.ROUTECODEX_GEMINI_TOKEN_FILE.trim()) ||
+    '';
+
+  if (envFile) {
+    const normalized = envFile.startsWith('~')
+      ? envFile.replace(/^~\//, `${os.homedir()}/`)
+      : envFile;
+    return { tokenPath: normalized, duplicates: [] };
+  }
+
+  const authDir = path.join(os.homedir(), '.routecodex', 'auth');
+  const primaryName = 'gemini-oauth.json';
+
+  let entries = [];
+  try {
+    entries = await fs.readdir(authDir);
+  } catch {
+    // directory may not exist yet
+    entries = [];
+  }
+
+  const matches = entries
+    .filter((entry) => entry.endsWith('.json'))
+    .filter((entry) => entry === primaryName || entry.startsWith('gemini-oauth-'));
+
+  matches.sort();
+  if (matches.length > 0) {
+    const canonical = path.join(authDir, matches[0]);
+    const duplicates = matches.slice(1).map((name) => path.join(authDir, name));
+    return { tokenPath: canonical, duplicates };
+  }
+
+  const canonical = path.join(authDir, primaryName);
+  return { tokenPath: canonical, duplicates: [] };
+}
+
+async function run() {
+  const { tokenPath, duplicates } = await resolveGeminiTokenPath();
+  console.log(`[gemini-cli-auth] Authenticating token: ${tokenPath}`);
+
+  // ensure token file exists so re-auth can recreate after delete
+  await fs.mkdir(path.dirname(tokenPath), { recursive: true });
+  try {
+    await fs.access(tokenPath);
+  } catch {
+    await fs.writeFile(tokenPath, '{}', 'utf-8');
+  }
+
+  const { ensureValidOAuthToken } = await import('../dist/providers/auth/oauth-lifecycle.js');
+
+  await ensureValidOAuthToken(
+    'gemini-cli',
+    {
+      type: 'gemini-cli-oauth',
+      tokenFile: tokenPath
+    },
+    {
+      forceReauthorize: true,
+      openBrowser: true
+    }
+  );
+
+  // clean up duplicate token files for the same family
+  for (const dup of duplicates) {
+    if (dup === tokenPath) continue;
+    try {
+      await fs.unlink(dup);
+      console.log(`[gemini-cli-auth] Removed duplicate token file: ${dup}`);
+    } catch {
+      // ignore
+    }
+  }
+
+  console.log(`[gemini-cli-auth] Token saved to: ${tokenPath}`);
+}
+
+run().catch((err) => {
+  console.error('[gemini-cli-auth] Error:', err);
+  process.exit(1);
+});

package/scripts/auth-iflow-manual.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+import { createProviderOAuthStrategy } from '../dist/providers/core/config/provider-oauth-configs.js';
+
+async function resolveIflowTokenPath() {
+  const envFile = process.env.IFLOW_TOKEN_FILE;
+  if (envFile && envFile.trim()) {
+    const normalized = envFile.startsWith('~') ? envFile.replace(/^~\//, `${os.homedir()}/`) : envFile;
+    return { tokenPath: normalized, duplicates: [] };
+  }
+
+  const authDir = path.join(os.homedir(), '.routecodex', 'auth');
+  const seq = 1;
+  const prefix = `iflow-oauth-${seq}`;
+  let entries = [];
+  try {
+    entries = await fs.readdir(authDir);
+  } catch {
+    // directory may not exist yet
+  }
+  const matches = entries
+    .filter((entry) => entry.endsWith('.json'))
+    .filter((entry) => entry === `${prefix}.json` || entry.startsWith(`${prefix}-`));
+  matches.sort();
+  if (matches.length > 0) {
+    const canonical = path.join(authDir, matches[0]);
+    const duplicates = matches.slice(1).map((name) => path.join(authDir, name));
+    return { tokenPath: canonical, duplicates };
+  }
+  const canonical = path.join(authDir, `${prefix}-primary.json`);
+  return { tokenPath: canonical, duplicates: [] };
+}
+
+async function run() {
+  const { tokenPath, duplicates } = await resolveIflowTokenPath();
+  console.log(`[iflow-manual] Manual auth for: ${tokenPath}`);
+  
+  // ensure token file exists
+  await fs.mkdir(path.dirname(tokenPath), { recursive: true });
+  try { await fs.access(tokenPath); } catch { await fs.writeFile(tokenPath, '{}', 'utf-8'); }
+  
+  // Use device code flow but let user open the URL manually
+  const strategy = 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'
+    },
+    client: { clientId: '10009311001', scopes: ['openid','profile','email','api'] }
+  }, tokenPath);
+  
+  // Manually trigger device code flow
+  const deviceCodeData = await strategy.initiateDeviceCodeFlow();
+  console.log('Please open this URL in your browser:');
+  console.log(deviceCodeData.verification_uri);
+  console.log('User code:', deviceCodeData.user_code);
+  console.log('Press Enter when you have authorized...');
+  
+  await new Promise(resolve => process.stdin.once('data', resolve));
+  
+  const token = await strategy.pollForToken(deviceCodeData);
+  await strategy.saveToken(token);
+
+  // clean up duplicate token files for the same sequence
+  for (const dup of duplicates) {
+    if (dup === tokenPath) continue;
+    try {
+      await fs.unlink(dup);
+      console.log(`[iflow-manual] Removed duplicate token file: ${dup}`);
+    } catch {
+      // ignore
+    }
+  }
+
+  console.log(`[iflow-manual] Token saved to: ${tokenPath}`);
+}
+
+run().catch(err => { console.error('[iflow-manual] Error:', err); process.exit(1); });

package/scripts/auth-iflow-token-direct.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+// iFlow token auth using direct device flow - no browser redirect
+// Usage: ILOW_TOKEN_FILE="~/.routecodex/auth/iflow-oauth-1-xxx.json" node scripts/auth-iflow-token-direct.mjs
+
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+
+async function resolveIflowTokenPath() {
+  const envFile = process.env.IFLOW_TOKEN_FILE;
+  if (envFile && envFile.trim()) {
+    const normalized = envFile.startsWith('~') ? envFile.replace(/^~\//, `${os.homedir()}/`) : envFile;
+    return { tokenPath: normalized, duplicates: [] };
+  }
+
+  const authDir = path.join(os.homedir(), '.routecodex', 'auth');
+  const seq = 1;
+  const prefix = `iflow-oauth-${seq}`;
+  let entries = [];
+  try {
+    entries = await fs.readdir(authDir);
+  } catch {
+    // directory may not exist yet
+  }
+  const matches = entries
+    .filter((entry) => entry.endsWith('.json'))
+    .filter((entry) => entry === `${prefix}.json` || entry.startsWith(`${prefix}-`));
+  matches.sort();
+  if (matches.length > 0) {
+    const canonical = path.join(authDir, matches[0]);
+    const duplicates = matches.slice(1).map((name) => path.join(authDir, name));
+    return { tokenPath: canonical, duplicates };
+  }
+  const canonical = path.join(authDir, `${prefix}-primary.json`);
+  return { tokenPath: canonical, duplicates: [] };
+}
+
+async function run() {
+  const { tokenPath, duplicates } = await resolveIflowTokenPath();
+  console.log(`[iflow-auth-direct] Starting device flow for: ${tokenPath}`);
+  
+  // ensure token file exists so re-auth can recreate after delete
+  await fs.mkdir(path.dirname(tokenPath), { recursive: true });
+  try {
+    await fs.access(tokenPath);
+  } catch {
+    await fs.writeFile(tokenPath, '{}', 'utf-8');
+  }
+  
+  const { createProviderOAuthStrategy } = await import('../dist/providers/core/config/provider-oauth-configs.js');
+  
+  // Use device code flow instead of auth code flow
+  const strategy = 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'
+    },
+    client: {
+      clientId: process.env.IFLOW_CLIENT_ID || 'iflow-desktop-client',
+      scopes: ['openid','profile','email','api']
+    }
+  }, tokenPath);
+  
+  console.log('[iflow-auth-direct] Opening browser for device code flow...');
+  const token = await strategy.authenticate({ openBrowser: true });
+  await strategy.saveToken(token);
+
+  // clean up duplicate token files for the same sequence
+  for (const dup of duplicates) {
+    if (dup === tokenPath) continue;
+    try {
+      await fs.unlink(dup);
+      console.log(`[iflow-auth-direct] Removed duplicate token file: ${dup}`);
+    } catch {
+      // ignore
+    }
+  }
+  
+  console.log(`[iflow-auth-direct] Token saved to: ${tokenPath}`);
+}
+
+run().catch(err => {
+  console.error('[iflow-auth-direct] Error:', err);
+  process.exit(1);
+});

package/scripts/auth-iflow-token.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// iFlow token authentication script for specific token file
+// Usage: ILOW_TOKEN_FILE="~/.routecodex/auth/iflow-oauth-1-xxx.json" node scripts/auth-iflow-token.mjs
+
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+
+async function resolveIflowTokenPath() {
+  const envFile = process.env.IFLOW_TOKEN_FILE;
+  if (envFile && envFile.trim()) {
+    const normalized = envFile.startsWith('~') ? envFile.replace(/^~\//, `${os.homedir()}/`) : envFile;
+    return { tokenPath: normalized, duplicates: [] };
+  }
+
+  const authDir = path.join(os.homedir(), '.routecodex', 'auth');
+  const seq = 1;
+  const prefix = `iflow-oauth-${seq}`;
+  let entries = [];
+  try {
+    entries = await fs.readdir(authDir);
+  } catch {
+    // directory may not exist yet
+  }
+  const matches = entries
+    .filter((entry) => entry.endsWith('.json'))
+    .filter((entry) => entry === `${prefix}.json` || entry.startsWith(`${prefix}-`));
+  matches.sort();
+  if (matches.length > 0) {
+    const canonical = path.join(authDir, matches[0]);
+    const duplicates = matches.slice(1).map((name) => path.join(authDir, name));
+    return { tokenPath: canonical, duplicates };
+  }
+  const canonical = path.join(authDir, `${prefix}-primary.json`);
+  return { tokenPath: canonical, duplicates: [] };
+}
+
+async function run() {
+  const { tokenPath, duplicates } = await resolveIflowTokenPath();
+  console.log(`[iflow-auth] Authenticating token: ${tokenPath}`);
+
+  // ensure token file exists so re-auth can recreate after delete
+  await fs.mkdir(path.dirname(tokenPath), { recursive: true });
+  try {
+    await fs.access(tokenPath);
+  } catch {
+    await fs.writeFile(tokenPath, '{}', 'utf-8');
+  }
+
+  const { ensureValidOAuthToken } = await import('../dist/providers/auth/oauth-lifecycle.js');
+  
+  await ensureValidOAuthToken('iflow', {
+    type: 'iflow-oauth',
+    tokenFile: tokenPath
+  }, {
+    forceReauthorize: true,
+    openBrowser: true
+  });
+
+  // clean up duplicate token files for the same sequence
+  for (const dup of duplicates) {
+    if (dup === tokenPath) continue;
+    try {
+      await fs.unlink(dup);
+      console.log(`[iflow-auth] Removed duplicate token file: ${dup}`);
+    } catch {
+      // ignore
+    }
+  }
+
+  console.log(`[iflow-auth] Token saved to: ${tokenPath}`);
+}
+
+run().catch(err => {
+  console.error('[iflow-auth] Error:', err);
+  process.exit(1);
+});

package/scripts/copy-compat-assets.mjs

@@ -15,23 +15,11 @@ async function ensureDir(p) {
 }
 
 async function main() {
-  const SRC = path.resolve(process.cwd(), 'src/providers/compat');
-  const DIST = path.resolve(process.cwd(), 'dist/providers/compat');
   const PROMPT_SRC = path.resolve(process.cwd(), 'src/config/system-prompts');
   const PROMPT_DIST = path.resolve(process.cwd(), 'dist/config/system-prompts');
-  const copied = [];
   const promptCopied = [];
   try {
-    for await (const file of walk(SRC)) {
-      if (file.endsWith('.json') && file.includes(`${path.sep}config${path.sep}`)) {
-        const rel = path.relative(SRC, file);
-        const dest = path.join(DIST, rel);
-        await ensureDir(path.dirname(dest));
-        await fs.copyFile(file, dest);
-        copied.push(rel);
-      }
-    }
-    // copy system prompt artifacts
+    // copy system prompt artifacts only; provider compat assets are owned by llmswitch-core
     try {
       for await (const file of walk(PROMPT_SRC)) {
         const stats = await fs.stat(file);
@@ -46,8 +34,8 @@ async function main() {
     } catch (promptErr) {
       if (promptErr && promptErr.code !== 'ENOENT') throw promptErr;
     }
-    // 不再复制 pipeline-config.generated.json 到 dist；统一从 ~/.routecodex/config/generated 读取
-    console.log(`[copy-compat-assets] copied ${copied.length} JSON assets; prompts: ${promptCopied.length}`);
+    // 不再复制 provider compat 资产；兼容层由 sharedmodule/llmswitch-core 提供
+    console.log(`[copy-compat-assets] prompts copied: ${promptCopied.length}`);
   } catch (err) {
     console.error('[copy-compat-assets] failed:', err?.message || String(err));
     process.exit(1);

package/scripts/install-verify.mjs

@@ -1027,6 +1027,7 @@ async function main() {
       messages: [...chatMessages, assistantMsg, toolMsg],
       tools: chatTools,
       stream: false,
+      tool_choice: 'auto'
     };
 
     console.log('📨 提交工具输出...');

package/scripts/pack-mode.mjs

@@ -14,14 +14,36 @@ function parseArgs(argv) {
   return out;
 }
 
+const projectRoot = process.cwd();
 const args = parseArgs(process.argv);
 if (!args.name || !args.bin) {
   console.error('Usage: node scripts/pack-mode.mjs --name <packageName> --bin <binName>');
   process.exit(1);
 }
 
-const pkgPath = path.join(process.cwd(), 'package.json');
+const pkgPath = path.join(projectRoot, 'package.json');
 const backupPath = pkgPath + '.bak.pack';
+const ensureScriptPath = path.join(projectRoot, 'scripts', 'ensure-llmswitch-mode.mjs');
+const llmsPath = path.join(projectRoot, 'node_modules', '@jsonstudio', 'llms');
+
+function runEnsureMode(mode) {
+  const env = { ...process.env, BUILD_MODE: mode };
+  const res = spawnSync(process.execPath, [ensureScriptPath], { stdio: 'inherit', env });
+  if ((res.status ?? 0) !== 0) {
+    throw new Error(`ensure-llmswitch-mode failed for ${mode}`);
+  }
+}
+
+function isSymlink(p) {
+  try {
+    return fs.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+const hadDevLink = isSymlink(llmsPath);
+runEnsureMode('release');
 
 const original = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
 fs.writeFileSync(backupPath, JSON.stringify(original, null, 2));
@@ -55,4 +77,11 @@ try {
   // restore
   fs.writeFileSync(pkgPath, fs.readFileSync(backupPath, 'utf-8'));
   fs.unlinkSync(backupPath);
+  if (hadDevLink) {
+    try {
+      runEnsureMode('dev');
+    } catch (err) {
+      console.warn('[pack-mode] failed to restore dev llms link:', err);
+    }
+  }
 }

package/scripts/publish-rcc.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+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);
+
+function run(command, args, options = {}) {
+  const res = spawnSync(command, args, { stdio: 'inherit', ...options });
+  if ((res.status ?? 0) !== 0) {
+    throw new Error(`${command} ${args.join(' ')} failed`);
+  }
+}
+
+try {
+  run(process.execPath, [PACK_SCRIPT, '--name', '@jsonstudio/rcc', '--bin', 'rcc'], { cwd: PROJECT_ROOT });
+  if (!fs.existsSync(tarballPath)) {
+    throw new Error(`tarball not found: ${tarballPath}`);
+  }
+  run('npm', ['publish', tarballName], { cwd: PROJECT_ROOT });
+} catch (err) {
+  console.error('[publish-rcc] failed:', err.message);
+  process.exit(1);
+}

package/scripts/replay-codex-sample.mjs

@@ -39,21 +39,26 @@ function readJson(file) {
 }
 
 function extractEndpoint(doc) {
-  return doc?.data?.url || doc?.endpoint || '/v1/responses';
+  return doc?.data?.url || doc?.url || doc?.endpoint || '/v1/responses';
 }
 
 function extractBody(doc) {
-  const body = doc?.data?.body;
-  if (!body) return undefined;
-  if (typeof body.body === 'object') return body.body;
-  if (typeof body === 'object') return body;
-  if (typeof doc.data.data === 'object') return doc.data.data;
+  const bodyNode = doc?.data?.body || doc?.body;
+  if (!bodyNode) {
+    if (typeof doc?.data?.data === 'object') return doc.data.data;
+    if (typeof doc?.body?.data === 'object') return doc.body.data;
+    return undefined;
+  }
+  if (typeof bodyNode.body === 'object') return bodyNode.body;
+  if (typeof bodyNode === 'object') return bodyNode;
+  if (typeof doc?.data?.data === 'object') return doc.data.data;
+  if (typeof doc?.body?.data === 'object') return doc.body.data;
   return undefined;
 }
 
 function detectStream(doc, requestBody) {
-  if (doc?.data?.meta?.stream === true) return true;
-  if (doc?.data?.body?.metadata?.stream === true) return true;
+  if (doc?.data?.meta?.stream === true || doc?.meta?.stream === true) return true;
+  if (doc?.data?.body?.metadata?.stream === true || doc?.body?.metadata?.stream === true) return true;
   if (requestBody?.stream === true) return true;
   return false;
 }

package/scripts/tests/chat-pipeline-blackbox.mjs

@@ -191,7 +191,7 @@ function resolveGoldenExpectations(sample) {
   if (sample.meta?.endpoint && sample.meta?.requestId) {
     const reqId = sample.meta.requestId;
     const endpoint = sample.meta.endpoint;
-    const baseDir = path.join(os.homedir(), '.routecodex', 'golden_samples');
+    const baseDir = path.join(os.homedir(), '.routecodex', 'codex-samples');
     const folder = endpoint.includes('/messages')
       ? 'anthropic-messages'
       : endpoint.includes('/responses')

package/scripts/tools/capture-provider-goldens.mjs

@@ -13,18 +13,19 @@ const ROOT = path.resolve(__dirname, '../..');
 
 const HOME = os.homedir();
 const PROVIDER_ROOT = path.join(HOME, '.routecodex', 'provider');
-const SNAPSHOT_ROOT = path.join(HOME, '.routecodex', 'golden_samples');
-const PROVIDER_GOLDEN_ROOT = path.join(SNAPSHOT_ROOT, 'provider_golden_samples');
+const RUNTIME_SNAPSHOT_ROOT = path.join(HOME, '.routecodex', 'codex-samples');
+const GOLDEN_ROOT = path.join(HOME, '.routecodex', 'golden_samples');
+const PROVIDER_GOLDEN_ROOT = path.join(GOLDEN_ROOT, 'provider_golden_samples');
 const CI_GOLDENS_ROOT = path.join(ROOT, 'samples', 'ci-goldens');
 const CUSTOM_SAMPLE_ROOTS = [
-  path.join(SNAPSHOT_ROOT, 'new'),
+  path.join(GOLDEN_ROOT, 'new'),
   CI_GOLDENS_ROOT
 ];
 const TEMP_ROOT = path.join(process.cwd(), 'tmp', 'provider-captures');
 const STAGE_DIRS = {
-  'openai-chat': path.join(SNAPSHOT_ROOT, 'openai-chat'),
-  'openai-responses': path.join(SNAPSHOT_ROOT, 'openai-responses'),
-  'anthropic-messages': path.join(SNAPSHOT_ROOT, 'anthropic-messages')
+  'openai-chat': path.join(RUNTIME_SNAPSHOT_ROOT, 'openai-chat'),
+  'openai-responses': path.join(RUNTIME_SNAPSHOT_ROOT, 'openai-responses'),
+  'anthropic-messages': path.join(RUNTIME_SNAPSHOT_ROOT, 'anthropic-messages')
 };
 const ENTRY_STAGE_MATRIX = {
   'openai-chat': {
@@ -437,7 +438,7 @@ function spawnServer(configPath, port) {
 }
 
 async function captureProvider(providerEntry, entryType, port, options, sanitizedProviderId) {
-  const stageDir = path.join(SNAPSHOT_ROOT, ENTRY_DEFS[entryType].stageDir);
+  const stageDir = path.join(RUNTIME_SNAPSHOT_ROOT, ENTRY_DEFS[entryType].stageDir);
   const suffix = '_req_outbound_stage2_format_build.json';
   const before = snapshotStageFiles(stageDir, suffix);
   const baseUrl = `http://127.0.0.1:${port}`;