@jsonstudio/rcc 0.89.1136 → 0.89.1205

package/scripts/antigravity-smoke.mjs

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * Antigravity upstream smoke test (direct provider call).
+ *
+ * Purpose:
+ * - Hit Antigravity (Cloud Code Assist) upstream using Gemini CLI HTTP provider.
+ * - Validate request shaping is accepted (especially "no body.request.request.*").
+ *
+ * Usage:
+ *   node scripts/antigravity-smoke.mjs
+ *
+ * Required:
+ *   - A valid Antigravity OAuth token file (JSON), e.g.
+ *     ~/.routecodex/auth/antigravity-oauth-1-<alias>.json
+ *   - Export env:
+ *       ANTIGRAVITY_TOKEN_FILE=/absolute/path/to/token.json
+ *
+ * Optional:
+ *   ANTIGRAVITY_BASEURL=https://daily-cloudcode-pa.sandbox.googleapis.com
+ *   ANTIGRAVITY_MODEL=gemini-3-pro-high
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { GeminiCLIHttpProvider } from '../dist/providers/core/runtime/gemini-cli-http-provider.js';
+import { GeminiSseToJsonConverter } from '../sharedmodule/llmswitch-core/dist/sse/sse-to-json/index.js';
+
+function resolveTokenFile() {
+  const raw =
+    (process.env.ANTIGRAVITY_TOKEN_FILE && process.env.ANTIGRAVITY_TOKEN_FILE.trim()) ||
+    (process.env.ROUTECODEX_ANTIGRAVITY_TOKEN_FILE && process.env.ROUTECODEX_ANTIGRAVITY_TOKEN_FILE.trim()) ||
+    (process.env.RCC_ANTIGRAVITY_TOKEN_FILE && process.env.RCC_ANTIGRAVITY_TOKEN_FILE.trim()) ||
+    '';
+  if (raw) {
+    const expanded = raw.startsWith('~/') ? path.join(os.homedir(), raw.slice(2)) : raw;
+    return path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
+  }
+  const authDir = path.join(os.homedir(), '.routecodex', 'auth');
+  const defaultPath = path.join(authDir, 'antigravity-oauth.json');
+  if (fs.existsSync(defaultPath)) {
+    return defaultPath;
+  }
+  try {
+    const candidates = fs
+      .readdirSync(authDir)
+      .filter((name) => name.startsWith('antigravity-oauth-') && name.endsWith('.json'))
+      .map((name) => path.join(authDir, name));
+    if (!candidates.length) {
+      return defaultPath;
+    }
+    candidates.sort((a, b) => {
+      try {
+        return fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs;
+      } catch {
+        return 0;
+      }
+    });
+    return candidates[0];
+  } catch {
+    return defaultPath;
+  }
+}
+
+function extractTextFromGeminiResponse(payload) {
+  const candidates = Array.isArray(payload?.candidates) ? payload.candidates : [];
+  const primary = candidates[0] && typeof candidates[0] === 'object' ? candidates[0] : null;
+  const parts = primary?.content?.parts;
+  if (!Array.isArray(parts)) return '';
+  return parts
+    .map((p) => (p && typeof p === 'object' && typeof p.text === 'string' ? p.text : ''))
+    .filter((s) => s.trim().length > 0)
+    .join('')
+    .trim();
+}
+
+async function decodeGeminiSse(stream, requestId) {
+  const converter = new GeminiSseToJsonConverter();
+  return await converter.convertSseToJson(stream, { requestId });
+}
+
+async function main() {
+  const tokenFile = resolveTokenFile();
+  if (!fs.existsSync(tokenFile)) {
+    console.error(`[antigravity-smoke] Missing token file: ${tokenFile}`);
+    console.error('[antigravity-smoke] Create one via: `node scripts/auth-antigravity-token.mjs`');
+    process.exit(2);
+  }
+
+  const baseUrl =
+    (process.env.ANTIGRAVITY_BASEURL && process.env.ANTIGRAVITY_BASEURL.trim()) ||
+    'https://daily-cloudcode-pa.sandbox.googleapis.com';
+  const model =
+    (process.env.ANTIGRAVITY_MODEL && process.env.ANTIGRAVITY_MODEL.trim()) || 'gemini-3-pro-high';
+
+  const config = {
+    id: 'antigravity-smoke',
+    config: {
+      // IMPORTANT: Antigravity uses Gemini CLI protocol (Cloud Code Assist v1internal).
+      providerType: 'gemini',
+      providerId: 'antigravity',
+      baseUrl,
+      auth: {
+        type: 'antigravity-oauth',
+        apiKey: '',
+        tokenFile
+      },
+      overrides: { maxRetries: 0 }
+    }
+  };
+
+  const dependencies = {
+    logger: { logModule: () => {}, logProviderRequest: () => {} },
+    errorHandlingCenter: { handleError: async () => {} }
+  };
+
+  const provider = new GeminiCLIHttpProvider(config, dependencies);
+  await provider.initialize();
+
+  const buildPayload = ({ nestedRequest }) => {
+    const core = {
+      model,
+      contents: [{ role: 'user', parts: [{ text: 'Reply with exactly: pong' }] }],
+      // Antigravity agent runtime may spend a portion of maxOutputTokens on internal thoughts.
+      // Use a sufficiently high value so we can reliably observe a visible text response.
+      generationConfig: { maxOutputTokens: 256 }
+    };
+    if (nestedRequest) {
+      // This intentionally mimics an illegal intermediate shape that used to produce
+      // `body.request.request.*` after protocol-client wrapping. Provider preprocess
+      // must flatten it before sending upstream.
+      return { model, request: { contents: core.contents, generationConfig: core.generationConfig } };
+    }
+    return core;
+  };
+
+  for (const variant of [
+    { name: 'top_level_contents', nestedRequest: false },
+    { name: 'nested_request_container', nestedRequest: true }
+  ]) {
+    const maxAttempts = 3;
+    let lastDecoded = null;
+    let okText = '';
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      const requestId = `antigravity-smoke-${variant.name}-a${attempt}-${Date.now()}`;
+      const request = { data: buildPayload(variant) };
+      const res = await provider.sendRequest(request);
+      const stream = res?.__sse_responses || res?.data?.__sse_responses;
+      if (!stream) {
+        console.error(`[antigravity-smoke] Missing SSE stream for ${variant.name} (attempt ${attempt}/${maxAttempts})`);
+        console.error(JSON.stringify(res?.data ?? res).slice(0, 800));
+        process.exit(3);
+      }
+      const decoded = await decodeGeminiSse(stream, requestId);
+      lastDecoded = decoded;
+      const text = extractTextFromGeminiResponse(decoded);
+      if (text && text.toLowerCase().includes('pong')) {
+        okText = text;
+        break;
+      }
+      if (attempt < maxAttempts) {
+        await new Promise((r) => setTimeout(r, 250));
+      }
+    }
+    if (!okText) {
+      console.error(`[antigravity-smoke] Unexpected response for ${variant.name}`);
+      console.error(JSON.stringify(lastDecoded).slice(0, 1200));
+      process.exit(4);
+    }
+    console.log(`[antigravity-smoke] OK ${variant.name}: ${JSON.stringify(okText).slice(0, 120)}`);
+  }
+
+  console.log('[antigravity-smoke] done');
+}
+
+main().catch((err) => {
+  console.error('[antigravity-smoke] Error:', err instanceof Error ? err.stack || err.message : String(err));
+  process.exit(1);
+});

package/scripts/backfill-apply-patch-exec-errorsamples.mjs

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+
+/**
+ * Backfill apply_patch execution failures into ~/.routecodex/errorsamples/apply_patch_exec/**.
+ *
+ * Source: ~/.routecodex/codex-samples/** (stage snapshots)
+ * Signal: tool role message name=apply_patch and content includes "apply_patch verification failed".
+ *
+ * This is a best-effort collector for debugging. It does NOT attempt any semantic repair.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+
+const HOME = os.homedir();
+const CODEX_ROOT_PRIMARY = path.join(HOME, '.routecodex', 'codex-samples');
+const CODEX_ROOT_ALT = path.join(HOME, '.routecodex', 'codex samples');
+
+const ERR_BASE =
+  process.env.ROUTECODEX_ERRORSAMPLES_DIR && process.env.ROUTECODEX_ERRORSAMPLES_DIR.trim().length
+    ? path.resolve(process.env.ROUTECODEX_ERRORSAMPLES_DIR)
+    : path.join(HOME, '.routecodex', 'errorsamples');
+const OUT_ROOT = path.join(ERR_BASE, 'apply_patch_exec');
+
+const MAX_PER_TYPE = 250;
+
+function detectApplyPatchToolMode() {
+  return 'freeform';
+}
+
+function classifyExecutionFailure(content) {
+  const raw = String(content || '');
+  const trimmed = raw.trim();
+  const prefix = 'apply_patch verification failed:';
+  const msg = trimmed.toLowerCase().startsWith(prefix) ? trimmed.slice(prefix.length).trim() : trimmed;
+  const lower = msg.toLowerCase();
+
+  if (lower.includes('failed to read file')) return { errorType: 'read_file_failed', message: msg };
+  if (lower.includes('no such file') || lower.includes('file not found')) return { errorType: 'file_not_found', message: msg };
+  if (lower.includes('failed to find context')) return { errorType: 'context_not_found', message: msg };
+  if (lower.includes('failed to find expected lines')) return { errorType: 'expected_lines_not_found', message: msg };
+  if (lower.includes('invalid patch')) return { errorType: 'invalid_patch', message: msg };
+  if (lower.includes('failed to parse')) return { errorType: 'parse_failed', message: msg };
+
+  return { errorType: 'unknown', message: msg };
+}
+
+function stableId({ errorType, errorMessage, toolCallId, toolCallArgs, requestId, mode }) {
+  const key = `${String(errorType)}:${String(errorMessage)}:${String(toolCallId || '')}:${String(toolCallArgs || '')}:${String(
+    requestId || ''
+  )}:${String(mode || '')}`;
+  return crypto.createHash('sha1').update(key).digest('hex').slice(0, 16);
+}
+
+async function fileExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function* walkJsonFiles(root) {
+  const stack = [root];
+  while (stack.length) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else if (entry.isFile() && entry.name.toLowerCase().endsWith('.json')) yield full;
+    }
+  }
+}
+
+async function ensureDir(p) {
+  await fs.mkdir(p, { recursive: true });
+}
+
+async function countJsonFiles(dir) {
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.toLowerCase().endsWith('.json')).length;
+  } catch {
+    return 0;
+  }
+}
+
+function buildToolCallArgsIndex(messages) {
+  const map = new Map();
+  for (const msg of messages) {
+    const toolCalls = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+    for (const tc of toolCalls) {
+      const id = typeof tc?.id === 'string' ? tc.id : '';
+      const fn = tc?.function;
+      const name = typeof fn?.name === 'string' ? String(fn.name).trim().toLowerCase() : '';
+      if (!id || name !== 'apply_patch') continue;
+      const args = typeof fn?.arguments === 'string' ? fn.arguments : '';
+      if (args) map.set(id, args);
+    }
+  }
+  return map;
+}
+
+async function main() {
+  const roots = [];
+  if (await fileExists(CODEX_ROOT_PRIMARY)) roots.push(CODEX_ROOT_PRIMARY);
+  if (await fileExists(CODEX_ROOT_ALT)) roots.push(CODEX_ROOT_ALT);
+
+  if (!roots.length) {
+    console.log('[backfill:apply_patch_exec] skip (no codex-samples root found)');
+    return;
+  }
+
+  await ensureDir(OUT_ROOT);
+
+  const mode = detectApplyPatchToolMode();
+
+  let scanned = 0;
+  let matchedFiles = 0;
+  let captured = 0;
+  let skippedLimit = 0;
+  let skippedExists = 0;
+
+  for (const root of roots) {
+    for await (const file of walkJsonFiles(root)) {
+      scanned += 1;
+      if (!file.endsWith('req_process_stage1_tool_governance.json')) continue;
+
+      let doc;
+      try {
+        doc = JSON.parse(await fs.readFile(file, 'utf-8'));
+      } catch {
+        continue;
+      }
+
+      const messages = Array.isArray(doc?.messages) ? doc.messages : [];
+      if (!messages.length) continue;
+
+      const toolCallArgsById = buildToolCallArgsIndex(messages);
+
+      const toolMsgs = messages.filter(
+        (m) =>
+          m &&
+          m.role === 'tool' &&
+          String(m.name || '').trim().toLowerCase() === 'apply_patch' &&
+          typeof m.content === 'string' &&
+          m.content.toLowerCase().includes('apply_patch verification failed')
+      );
+      if (!toolMsgs.length) continue;
+
+      matchedFiles += 1;
+
+      const metadata = doc?.metadata || {};
+      const requestId = typeof metadata?.requestId === 'string' ? metadata.requestId : undefined;
+      const entryEndpoint = typeof metadata?.originalEndpoint === 'string' ? metadata.originalEndpoint : undefined;
+      const providerKey = typeof metadata?.providerKey === 'string' ? metadata.providerKey : undefined;
+      const modelId = typeof doc?.model === 'string' ? doc.model : undefined;
+
+      for (const m of toolMsgs) {
+        const { errorType, message } = classifyExecutionFailure(m.content);
+        const safeType = String(errorType || 'unknown').replace(/[^a-z0-9-]/gi, '_');
+        const typeDir = path.join(OUT_ROOT, safeType);
+        await ensureDir(typeDir);
+
+        const currentCount = await countJsonFiles(typeDir);
+        if (currentCount >= MAX_PER_TYPE) {
+          skippedLimit += 1;
+          continue;
+        }
+
+        const toolCallId = typeof m.tool_call_id === 'string' ? m.tool_call_id : undefined;
+        const toolCallArgs = toolCallId ? toolCallArgsById.get(toolCallId) : undefined;
+        const id = `sample_${stableId({
+          errorType,
+          errorMessage: message,
+          toolCallId,
+          toolCallArgs,
+          requestId,
+          mode
+        })}`;
+        const outPath = path.join(typeDir, `${id}.json`);
+
+        if (await fileExists(outPath)) {
+          skippedExists += 1;
+          continue;
+        }
+
+        const payload = {
+          id,
+          timestamp: new Date().toISOString(),
+          errorType,
+          errorMessage: message,
+          toolCallId,
+          toolCallArgs,
+          requestId,
+          entryEndpoint,
+          providerKey,
+          model: modelId,
+          source: 'codex-samples:req_process_stage1_tool_governance',
+          meta: { applyPatchToolMode: mode, sourceFile: file }
+        };
+        await fs.writeFile(outPath, JSON.stringify(payload, null, 2), 'utf-8');
+        captured += 1;
+      }
+    }
+  }
+
+  console.log(
+    `[backfill:apply_patch_exec] scanned=${scanned} matchedFiles=${matchedFiles} captured=${captured} skippedExists=${skippedExists} skippedLimit=${skippedLimit} out=${OUT_ROOT}`
+  );
+}
+
+main().catch((err) => {
+  console.error('[backfill:apply_patch_exec] failed:', err?.stack || err?.message || String(err));
+  process.exit(2);
+});

package/scripts/compare-codex-rccx.mjs

@@ -23,8 +23,10 @@
  */
 
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
+import { writeErrorSampleJson } from './lib/errorsamples.mjs';
 
 const DEFAULT_ROUTE_BASE = process.env.ROUTECODEX_BASE || 'http://127.0.0.1:5555';
 const DEFAULT_RCCX_BASE = process.env.RCCX_BASE || 'http://127.0.0.1:5556';
@@ -230,6 +232,29 @@ async function main() {
       rccxRunDir,
       rccxError: rccxResult.error || null
     });
+    try {
+      const file = await writeErrorSampleJson({
+        group: 'compare-codex-rccx',
+        kind: 'missing-artifacts',
+        payload: {
+          kind: 'compare-codex-rccx-missing-artifacts',
+          stamp: new Date().toISOString(),
+          samplePath,
+          requestId,
+          routeBase: opts.routeBase,
+          rccxBase: opts.rccxBase,
+          routeLabel: opts.routeLabel,
+          rccxLabel: opts.rccxLabel,
+          routeRunDir,
+          rccxRunDir,
+          routeError: routeResult.error || null,
+          rccxError: rccxResult.error || null
+        }
+      });
+      console.error(`[compare-codex-rccx] wrote errorsample: ${file}`);
+    } catch (err) {
+      console.error('[compare-codex-rccx] failed to write errorsample:', err);
+    }
     process.exitCode = 1;
     return;
   }
@@ -252,6 +277,33 @@ async function main() {
     // 为了调试 429 / 系列冷却问题，额外打印一小段 body 样本。
     console.log('[compare-codex-rccx] routecodex.bodySample =', routeResult.bodySample);
     console.log('[compare-codex-rccx] rccx.bodySample      =', rccxResult.bodySample);
+    try {
+      const file = await writeErrorSampleJson({
+        group: 'compare-codex-rccx',
+        kind: 'mismatch',
+        payload: {
+          kind: 'compare-codex-rccx-mismatch',
+          stamp: new Date().toISOString(),
+          samplePath,
+          requestId,
+          routeBase: opts.routeBase,
+          rccxBase: opts.rccxBase,
+          routeLabel: opts.routeLabel,
+          rccxLabel: opts.rccxLabel,
+          routeRunDir,
+          rccxRunDir,
+          routeMeta,
+          rccxMeta,
+          routeBodyKind: routeResult.bodyKind,
+          rccxBodyKind: rccxResult.bodyKind,
+          routeBodySample: routeResult.bodySample,
+          rccxBodySample: rccxResult.bodySample
+        }
+      });
+      console.error(`[compare-codex-rccx] wrote errorsample: ${file}`);
+    } catch (err) {
+      console.error('[compare-codex-rccx] failed to write errorsample:', err);
+    }
     process.exitCode = 1;
     return;
   }
@@ -263,6 +315,12 @@ async function main() {
 
 main().catch((err) => {
   console.error('[compare-codex-rccx] fatal error:', err);
+  try {
+    const root = path.join(os.homedir(), '.routecodex', 'errorsamples', 'compare-codex-rccx');
+    const file = path.join(root, `fatal-${Date.now()}.txt`);
+    fs.mkdirSync(root, { recursive: true });
+    fs.writeFileSync(file, String(err?.stack || err), 'utf8');
+    console.error(`[compare-codex-rccx] wrote errorsample: ${file}`);
+  } catch {}
   process.exitCode = 1;
 });
-

package/scripts/compare-responses-request.mjs

@@ -10,6 +10,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { writeErrorSampleJson } from './lib/errorsamples.mjs';
 
 const protocolFolders = {
   'openai-responses': 'openai-responses',
@@ -118,9 +119,15 @@ function listCounts(label, payload) {
   console.log(
     `${label} counts → input:${inputCount} messages:${messageCount} tools:${toolCount} instructions:${typeof payload?.instructions === 'string'}`
   );
+  return {
+    input: inputCount,
+    messages: messageCount,
+    tools: toolCount,
+    hasInstructions: typeof payload?.instructions === 'string'
+  };
 }
 
-function main() {
+async function main() {
   const opts = parseArgs();
   const clientProtocol = opts.clientProtocol || opts.protocol;
   const providerProtocol = opts.providerProtocol || opts.protocol;
@@ -146,8 +153,8 @@ function main() {
   const clientPayload = extractPayload(clientSnapshot);
   const providerPayload = extractPayload(providerSnapshot);
 
-  listCounts('Client', clientPayload);
-  listCounts('Provider', providerPayload);
+  const clientCounts = listCounts('Client', clientPayload);
+  const providerCounts = listCounts('Provider', providerPayload);
 
   const diffs = diffPayloads(pruneUndefined(clientPayload), pruneUndefined(providerPayload));
   if (!diffs.length) {
@@ -160,6 +167,30 @@ function main() {
     if (diffs.length > 50) {
       console.log(`  ... ${diffs.length - 50} more differences`);
     }
+
+    const record = {
+      kind: 'compare-responses-request-diff',
+      requestId: normalizedId,
+      clientProtocol,
+      providerProtocol,
+      clientPath,
+      providerPath,
+      clientCounts,
+      providerCounts,
+      diffsCount: diffs.length,
+      diffsHead: diffs.slice(0, 200),
+      diffsTruncated: diffs.length > 200
+    };
+    try {
+      const file = await writeErrorSampleJson({
+        group: 'compare-responses-request',
+        kind: 'diff',
+        payload: record
+      });
+      console.error(`[compare-responses-request] wrote errorsample: ${file}`);
+    } catch (err) {
+      console.error('[compare-responses-request] failed to write errorsample:', err);
+    }
   }
 }
 
@@ -217,4 +248,19 @@ function diffPayloads(expected, actual, path = '<root>') {
   return [{ path, expected, actual }];
 }
 
-main();
+main().catch((err) => {
+  console.error('[compare-responses-request] fatal error:', err);
+  void writeErrorSampleJson({
+    group: 'compare-responses-request',
+    kind: 'fatal',
+    payload: {
+      kind: 'compare-responses-request-fatal',
+      stamp: new Date().toISOString(),
+      argv: process.argv.slice(2),
+      error: String(err?.stack || err)
+    }
+  }).then((file) => {
+    console.error(`[compare-responses-request] wrote errorsample: ${file}`);
+  }).catch(() => {});
+  process.exitCode = 1;
+});

package/scripts/lib/errorsamples.mjs

@@ -0,0 +1,23 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+function safeStamp() {
+  const iso = new Date().toISOString();
+  // 2026-01-18T12:34:56.789Z -> 20260118-123456-789Z
+  return iso.replace(/[-:]/g, '').replace('T', '-').replace('.', '-');
+}
+
+function safeName(name) {
+  return String(name || 'sample').replace(/[^\w.-]/g, '_');
+}
+
+export async function writeErrorSampleJson({ group, kind, payload }) {
+  const root = path.join(os.homedir(), '.routecodex', 'errorsamples');
+  const dir = path.join(root, safeName(group));
+  await fs.mkdir(dir, { recursive: true });
+  const file = path.join(dir, `${safeName(kind)}-${safeStamp()}-${Math.random().toString(16).slice(2)}.json`);
+  await fs.writeFile(file, JSON.stringify(payload, null, 2), 'utf8');
+  return file;
+}
+

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

@@ -188,7 +188,7 @@ async function writeTempConfig(sample, port) {
   return { dir, file };
 }
 
-function createServer(configPath, port, snapshotRoot) {
+async function createServer(configPath, port, snapshotRoot) {
   const env = {
     ...process.env,
     ROUTECODEX_USE_MOCK: '1',
@@ -207,6 +207,16 @@ function createServer(configPath, port, snapshotRoot) {
       : {})
   };
   const entry = path.join(PROJECT_ROOT, 'dist', 'index.js');
+  // Defensive: build scripts or other verification steps may clean dist between checks.
+  // Ensure the server entry exists right before spawning.
+  // (Avoids confusing "Cannot find module dist/index.js" regressions.)
+  if (!(await fileExists(entry))) {
+    console.warn('[mock:regressions] dist/index.js missing at spawn time, rebuilding via "npm run build:min"...');
+    await runBuildForMockRegressions();
+    if (!(await fileExists(entry))) {
+      throw new Error(`dist/index.js still missing after rebuild: ${entry}`);
+    }
+  }
   const child = spawn(process.execPath, [entry], {
     cwd: PROJECT_ROOT,
     env,
@@ -465,7 +475,7 @@ async function runSample(sample, index) {
   const { dir, file } = await writeTempConfig(sample, port);
   // 为当前样本创建独立的临时快照根目录，并在完成后整体删除
   const snapshotRoot = path.join(dir, 'codex-samples');
-  const server = createServer(file, port, snapshotRoot);
+  const server = await createServer(file, port, snapshotRoot);
   const tags = new Set(Array.isArray(sample.tags) ? sample.tags : []);
   const expectSseTerminationError = tags.has('responses_sse_terminated');
   const allowSampleError =