@jsonstudio/rcc 0.90.323 → 0.90.364

package/scripts/install-release.sh

@@ -85,7 +85,7 @@ else
 fi
 
 verify_server_request() {
-  local VERIFY_CONFIG=${ROUTECODEX_INSTALL_VERIFY_CONFIG:-"$HOME/.routecodex/config.json"}
+  local VERIFY_CONFIG=${ROUTECODEX_INSTALL_VERIFY_CONFIG:-"$HOME/.rcc/config.json"}
   local VERIFY_TIMEOUT=${ROUTECODEX_INSTALL_VERIFY_TIMEOUT:-240}
   local VERIFY_LOG="/tmp/routecodex-release-verify-$(date +%s).log"
   local TIMEOUT_BIN=""

package/scripts/mock-provider/capture-from-configs.mjs

@@ -10,7 +10,7 @@ import { spawn } from 'node:child_process';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = path.resolve(__dirname, '../..');
 const HOME = os.homedir();
-const PROVIDER_ROOT = path.join(HOME, '.routecodex', 'provider');
+const PROVIDER_ROOT = path.join(HOME, '.rcc', 'provider');
 const GOLDEN_ROOT = path.join(HOME, '.routecodex', 'golden_samples');
 const CUSTOM_SAMPLE_ROOT = path.join(GOLDEN_ROOT, 'new');
 const MOCK_SAMPLES_ROOT = path.join(PROJECT_ROOT, 'samples', 'mock-provider');

package/scripts/outbound-network-toolcall.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // One-click outbound network toolcall tests against openai-compatible providers.
-// Reads provider configs under ~/.routecodex/provider/*/config*.json
+// Reads provider configs under ~/.rcc/provider/*/config*.json
 // Sends a function-calling prompt and reports whether a functionCall/tool_calls is returned.
 
 import fs from 'fs';
@@ -8,7 +8,7 @@ import path from 'path';
 import os from 'os';
 import { ProviderFactory } from '../dist/providers/core/runtime/provider-factory.js';
 
-const root = path.join(os.homedir(), '.routecodex', 'provider');
+const root = path.join(os.homedir(), '.rcc', 'provider');
 const MAX_PROVIDERS = parseInt(process.env.RCC_NET_MAX_PROVIDERS || '5', 10);
 // Per-provider rate limit: default 3 req/min (can override by RCC_NET_RATE_MAX_PER_MINUTE)
 const RATE_MAX_PER_MIN = parseInt(process.env.RCC_NET_RATE_MAX_PER_MINUTE || '3', 10);

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

@@ -12,7 +12,7 @@ import { ProviderFactory } from '../dist/providers/core/runtime/provider-factory
 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');
 const TARGET_TOOL_NAME = (process.env.RCC_REG_TOOL_NAME || 'add').toLowerCase();
-const PROVIDER_DIR = path.join(os.homedir(), '.routecodex', 'provider');
+const PROVIDER_DIR = path.join(os.homedir(), '.rcc', 'provider');
 const MAX_PER_PROVIDER_PER_MIN = parseInt(process.env.RCC_NET_RATE_MAX_PER_MINUTE || '3', 10);
 const RATE_DISABLED = (process.env.RCC_NET_RATE_DISABLED || '0') === '1';
 const TARGET_PROTOCOLS = new Set(

package/scripts/pack-mode.mjs

@@ -81,9 +81,10 @@ try {
     mutated.bundleDependencies = [];
     const llmsOverride = String(process.env.RCC_LLMS_VERSION || process.env.ROUTECODEX_PACK_LLMS_VERSION || '').trim();
     const localLlmsVersion = readLocalLlmsVersion();
-    const llmsVersion = (isRcc && llmsOverride)
-      ? llmsOverride
-      : (localLlmsVersion || original.dependencies?.['@jsonstudio/llms'] || '^0.6.230');
+    const declaredLlmsVersion = String(original.dependencies?.['@jsonstudio/llms'] || '').trim();
+    const llmsVersion = isRcc
+      ? (llmsOverride || localLlmsVersion || declaredLlmsVersion || '^0.6.230')
+      : (localLlmsVersion || declaredLlmsVersion || '^0.6.230');
     if (isRcc && llmsOverride) {
       console.log(`[pack-mode] using RCC_LLMS_VERSION override: @jsonstudio/llms=${llmsVersion}`);
     }
@@ -94,11 +95,14 @@ try {
     if (isRcc && deps['@jsonstudio/rcc']) {
       delete deps['@jsonstudio/rcc'];
     }
+    if (isRcc && deps['@jsonstudio/llms']) {
+      delete deps['@jsonstudio/llms'];
+    }
     mutated.dependencies = {
       ...deps,
       ajv: original.dependencies?.ajv || '^8.17.1',
       zod: original.dependencies?.zod || '^3.23.8',
-      '@jsonstudio/llms': llmsVersion
+      ...(isRcc ? {} : { '@jsonstudio/llms': llmsVersion })
     };
     // Ensure rcc ships bundled docs (copied to ~/.routecodex/docs by `rcc init`).
     if (isRcc) {
@@ -109,6 +113,9 @@ try {
       if (!baseFiles.includes('configsamples/')) {
         baseFiles.push('configsamples/');
       }
+      if (!baseFiles.includes('vendor/')) {
+        baseFiles.push('vendor/');
+      }
       mutated.files = baseFiles;
     }
   } else if (isRccx) {

package/scripts/provider-v2-smoke.mjs

@@ -6,10 +6,10 @@ import path from 'path';
 
 function readJson(p){ try { return JSON.parse(fs.readFileSync(p,'utf-8')); } catch { return null; } }
 function loadUserConfig(){
-  const explicit = process.env.ROUTECODEX_CONFIG_PATH;
+  const explicit = process.env.ROUTECODEX_CONFIG_PATH || process.env.RCC_CONFIG_PATH || process.env.ROUTECODEX_CONFIG || process.env.RCC_CONFIG;
   const candidate = explicit && explicit.trim()
     ? path.resolve(explicit.trim())
-    : path.join(os.homedir(), '.routecodex', 'config.json');
+    : path.join(os.homedir(), '.rcc', 'config.json');
   return readJson(candidate);
 }
 
@@ -18,7 +18,7 @@ const providers = cfg?.virtualrouter?.providers || {};
 const entries = Object.entries(providers);
 const glmEntry = entries.find(([id]) => id.includes('glm')) || entries[0];
 if (!glmEntry) {
-  console.error('no provider definition found in ~/.routecodex/config.json');
+  console.error('no provider definition found in ~/.rcc/config.json');
   process.exit(2);
 }
 const [providerId, providerConfig] = glmEntry;

package/scripts/publish-rcc.mjs

@@ -9,7 +9,6 @@ const PROJECT_ROOT = path.resolve(__dirname, '..');
 const PACK_SCRIPT = path.join(PROJECT_ROOT, 'scripts', 'pack-mode.mjs');
 const pkgPath = path.join(PROJECT_ROOT, 'package.json');
 const llmsPath = path.join(PROJECT_ROOT, 'node_modules', '@jsonstudio', 'llms');
-const localLlmsPkgPath = path.join(PROJECT_ROOT, 'sharedmodule', 'llmswitch-core', 'package.json');
 
 function parseArgs(argv) {
   const out = {};
@@ -40,11 +39,12 @@ function run(command, args, options = {}) {
 try {
   const args = parseArgs(process.argv);
   const llmsTgz = String(args.llmsTgz || process.env.RCC_LLMS_TGZ || '').trim();
-  const llmsVersion = String(
+  const llmsVersionOverride = String(
     args.llmsVersion ||
     process.env.RCC_LLMS_VERSION ||
-    (exists(localLlmsPkgPath) ? JSON.parse(fs.readFileSync(localLlmsPkgPath, 'utf-8')).version : '')
+    ''
   ).trim();
+  const llmsVersion = llmsVersionOverride;
 
   const hadDevLink = (() => {
     try {

package/scripts/replay-recorded-toolcall.mjs

@@ -41,7 +41,7 @@ async function sleep(ms) { await new Promise(r => setTimeout(r, ms)); }
 async function getPortFromConfig() {
   try {
     const envPath = process.env.ROUTECODEX_CONFIG_PATH || process.env.ROUTECODEX_CONFIG || '';
-    const candidate = envPath || path.join(os.homedir(), '.routecodex', 'config.json');
+    const candidate = envPath || path.join(os.homedir(), '.rcc', 'config.json');
     if (fsSync.existsSync(candidate)) {
       const cfg = await readJson(candidate);
       const p = (cfg && cfg.httpserver && typeof cfg.httpserver.port === 'number') ? cfg.httpserver.port : cfg.port;
@@ -227,4 +227,3 @@ async function main() {
 }
 
 main().catch(err => { console.error(err); process.exit(1); });
-

package/scripts/responses-fai-capture.mjs

@@ -7,7 +7,7 @@ import path from 'path';
 import { pathToFileURL } from 'url';
 
 const PROVIDER_ID = process.env.RCC_RESP_PROV || 'fai';
-const PROVIDER_DIR = path.join(os.homedir(), '.routecodex', 'provider');
+const PROVIDER_DIR = path.join(os.homedir(), '.rcc', 'provider');
 const OUT_DIR = path.join(os.homedir(), '.routecodex', 'golden_samples', 'provider_golden_samples', 'responses', PROVIDER_ID);
 
 function ensureDir(p) { fs.mkdirSync(p, { recursive: true }); }

package/scripts/responses-sse-capture.mjs

@@ -10,7 +10,7 @@ import OpenAI from 'openai';
 const BASEDIR = process.cwd();
 const CODEx_DIR = path.join(os.homedir(), '.routecodex', 'codex-samples', 'openai-chat');
 const RESP_SAMPLE_DIR = path.join(os.homedir(), '.routecodex', 'codex-samples', 'openai-responses');
-const PROVIDER_DIR = path.join(os.homedir(), '.routecodex', 'provider');
+const PROVIDER_DIR = path.join(os.homedir(), '.rcc', 'provider');
 const OUT_DIR = path.join(os.homedir(), '.routecodex', 'logs', 'responses-sse');
 
 function ensureDir(p) { fs.mkdirSync(p, { recursive: true }); }

package/scripts/responses-sse-proxy.mjs

@@ -17,7 +17,7 @@ const replayLog = process.env.RCC_RESP_REPLAY_LOG || getArg('--replay');
 const port = Number(getArg('--port') || DEFAULT_PORT);
 const host = getArg('--host') || DEFAULT_HOST;
 
-const PROVIDER_ROOT = path.join(os.homedir(), '.routecodex', 'provider');
+const PROVIDER_ROOT = path.join(os.homedir(), '.rcc', 'provider');
 const CAPTURE_ROOT = path.join(os.homedir(), '.routecodex', 'codex-samples', 'openai-responses', 'sse-proxy');
 
 function getArg(flag) {

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

@@ -1,138 +1,279 @@
 #!/usr/bin/env node
-// Replay a Responses golden provider-request sample to a live provider and aggregate SSE → JSON → Chat.
-// Usage:
-//   RCC_RESP_PROV=<providerId> node scripts/responses-sse-replay-golden.mjs
+// Server-side replay for codex-samples /v1/responses requests.
+// This script intentionally replays through RouteCodex HTTP server instead of calling provider URLs directly.
+//
 // Env:
-//   RCC_RESP_PROV: fc|c4m|fai (default fc)
-//   RCC_RESP_PICK: substring to pick a specific sample file
+//   RCC_REPLAY_BASE   server base URL (default http://127.0.0.1:5555)
+//   RCC_REPLAY_KEY    x-routecodex-api-key (default routecodex-test)
+//   RCC_RESP_PROVIDER provider directory filter (optional)
+//   RCC_RESP_PICK     request-id/path substring filter (optional)
+//   RCC_RESP_REQ      exact request directory name, e.g. req_1773310208018_9b3ec605 (optional)
+//
+// Output:
+//   ~/.routecodex/logs/responses-sse/server-replay_<timestamp>.{request,response,sse,json,chat}.*
 
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { pathToFileURL } from 'url';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 
-const PROVIDER_DIR = path.join(os.homedir(), '.routecodex', 'provider');
-const SAMPLES_DIR = path.join(os.homedir(), '.routecodex', 'codex-samples', 'openai-responses');
+const DEFAULT_BASE = process.env.RCC_REPLAY_BASE || 'http://127.0.0.1:5555';
+const DEFAULT_KEY =
+  process.env.RCC_REPLAY_KEY ||
+  process.env.ROUTECODEX_HTTP_APIKEY ||
+  process.env.ROUTECODEX_API_KEY ||
+  'routecodex-test';
+const FILTER_PROVIDER = (process.env.RCC_RESP_PROVIDER || '').trim();
+const FILTER_PICK = (process.env.RCC_RESP_PICK || '').trim();
+const FILTER_REQ = (process.env.RCC_RESP_REQ || '').trim();
+const SAMPLES_ROOT = path.join(os.homedir(), '.routecodex', 'codex-samples', 'openai-responses');
 const OUT_DIR = path.join(os.homedir(), '.routecodex', 'logs', 'responses-sse');
 
-function ensureDir(p) { fs.mkdirSync(p, { recursive: true }); }
-function nowStamp() { return new Date().toISOString().replace(/[:.]/g, '-'); }
+function nowStamp() {
+  return new Date().toISOString().replace(/[:.]/g, '-');
+}
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function readJson(p) {
+  return JSON.parse(fs.readFileSync(p, 'utf-8'));
+}
+
+async function healthCheck(baseUrl) {
+  try {
+    const res = await fetch(`${baseUrl.replace(/\/$/, '')}/health`, { method: 'GET' });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
 
-function findProviderConfig(providerId) {
-  const dir = path.join(PROVIDER_DIR, providerId);
-  const candidates = ['config.v1.json', 'config.json'];
-  for (const name of candidates) {
-    const p = path.join(dir, name);
-    if (fs.existsSync(p)) {
-      return JSON.parse(fs.readFileSync(p, 'utf-8'));
+function findClientRequestFiles(root) {
+  const result = [];
+  if (!fs.existsSync(root)) {
+    return result;
+  }
+  const providerDirs = fs.readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const providerDir of providerDirs) {
+    if (FILTER_PROVIDER && !providerDir.name.includes(FILTER_PROVIDER)) {
+      continue;
+    }
+    const providerPath = path.join(root, providerDir.name);
+    const reqDirs = fs.readdirSync(providerPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const reqDir of reqDirs) {
+      if (FILTER_REQ && reqDir.name !== FILTER_REQ) {
+        continue;
+      }
+      if (FILTER_PICK && !reqDir.name.includes(FILTER_PICK) && !providerDir.name.includes(FILTER_PICK)) {
+        continue;
+      }
+      const clientReq = path.join(providerPath, reqDir.name, 'client-request.json');
+      if (!fs.existsSync(clientReq)) {
+        continue;
+      }
+      const stat = fs.statSync(clientReq);
+      result.push({
+        provider: providerDir.name,
+        requestId: reqDir.name,
+        file: clientReq,
+        mtimeMs: stat.mtimeMs
+      });
     }
   }
-  throw new Error(`No provider config for ${providerId}`);
+  result.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return result;
 }
 
-function extractProviderEntry(doc, providerId) {
-  const pipelines = doc?.pipeline_assembler?.config?.pipelines || [];
-  for (const p of pipelines) {
-    const prov = p?.modules?.provider;
-    if (!prov?.config) continue;
-    const pid = prov.config.providerId || path.basename(path.dirname(p?.__file || ''));
-    if (pid === providerId) return prov.config;
-  }
-  // fallback v1
-  const providers = doc?.virtualrouter?.providers || {};
-  return Object.values(providers)[0] || null;
+function extractRequestBody(doc) {
+  if (doc && typeof doc === 'object') {
+    if (doc.body && typeof doc.body === 'object' && !Array.isArray(doc.body)) {
+      if (doc.body.body && typeof doc.body.body === 'object' && !Array.isArray(doc.body.body)) {
+        return doc.body.body;
+      }
+      return doc.body;
+    }
+    if (doc.data && typeof doc.data === 'object' && !Array.isArray(doc.data)) {
+      const data = doc.data;
+      if (data.body && typeof data.body === 'object' && !Array.isArray(data.body)) {
+        if (data.body.body && typeof data.body.body === 'object' && !Array.isArray(data.body.body)) {
+          return data.body.body;
+        }
+        return data.body;
+      }
+    }
+  }
+  return undefined;
 }
 
-function listGoldenRequests() {
-  if (!fs.existsSync(SAMPLES_DIR)) return [];
-  return fs.readdirSync(SAMPLES_DIR).filter(n => n.endsWith('_provider-request.json'));
+function extractEntryEndpoint(doc) {
+  const endpoint = doc?.meta?.entryEndpoint;
+  if (typeof endpoint === 'string' && endpoint.trim().length) {
+    return endpoint.trim();
+  }
+  return '/v1/responses';
 }
 
-function pickGoldenForBaseUrl(files, baseUrl, pickHint) {
-  const want = String(baseUrl || '').replace(/\/$/, '');
-  const host = want.split('://')[1] || want; // naive
-  let matches = files.filter(f => {
-    try {
-      const obj = JSON.parse(fs.readFileSync(path.join(SAMPLES_DIR, f), 'utf-8'));
-      const url = obj?.data?.url || obj?.url || '';
-      return typeof url === 'string' && url.includes(host);
-    } catch { return false; }
-  });
-  if (pickHint) matches = matches.filter(f => f.includes(pickHint));
-  if (!matches.length) matches = files; // fallback to any
-  // prefer ones containing input[] and tools
-matches.sort((a, b) => {
-  const aa = fs.readFileSync(path.join(SAMPLES_DIR, a), "utf-8");
-  const bb = fs.readFileSync(path.join(SAMPLES_DIR, b), "utf-8");
-  const sa = (aa.includes("\"input\"") ? 10 : 0) + (aa.includes("\"tools\"") ? 2 : 0) + (aa.includes("function_call_arguments") ? 1 : 0);
-  const sb = (bb.includes("\"input\"") ? 10 : 0) + (bb.includes("\"tools\"") ? 2 : 0) + (bb.includes("function_call_arguments") ? 1 : 0);
-  return sb - sa;
-});
-  return matches[0] || null;
+function extractStreamFlag(doc, body) {
+  if (typeof body?.stream === 'boolean') {
+    return body.stream;
+  }
+  if (typeof doc?.meta?.stream === 'boolean') {
+    return doc.meta.stream;
+  }
+  return true;
+}
+
+async function readSseFrames(stream) {
+  const reader = stream?.getReader?.();
+  if (!reader) {
+    return [];
+  }
+  const decoder = new TextDecoder();
+  let buffer = '';
+  const frames = [];
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffer += decoder.decode(value, { stream: true });
+    let idx = buffer.indexOf('\n\n');
+    while (idx >= 0) {
+      const frame = buffer.slice(0, idx).trim();
+      buffer = buffer.slice(idx + 2);
+      if (frame.length) {
+        frames.push(frame);
+      }
+      idx = buffer.indexOf('\n\n');
+    }
+  }
+  buffer += decoder.decode(new Uint8Array(), { stream: false });
+  if (buffer.trim().length) {
+    frames.push(buffer.trim());
+  }
+  return frames;
+}
+
+async function convertSseFramesToJson(frames, requestId, model) {
+  try {
+    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;
+    const { ResponsesSseToJsonConverter } = await import(convPath);
+    const { buildChatResponseFromResponses } = await import(bridgePath);
+    const converter = new ResponsesSseToJsonConverter();
+    async function* toChunks() {
+      for (const frame of frames) {
+        yield `${frame}\n\n`;
+      }
+    }
+    const json = await converter.convertSseToJson(toChunks(), {
+      requestId,
+      model: typeof model === 'string' && model.length ? model : 'unknown'
+    });
+    const chat = buildChatResponseFromResponses(json);
+    return { json, chat };
+  } catch {
+    return { json: null, chat: null };
+  }
 }
 
 async function main() {
-  const providerId = process.env.RCC_RESP_PROV || 'fc';
-  const pickHint = process.env.RCC_RESP_PICK || '';
-  const cfgDoc = findProviderConfig(providerId);
-  const prov = extractProviderEntry(cfgDoc, providerId);
-  if (!prov) throw new Error('provider entry missing');
-  const baseUrl = String(prov.baseUrl || prov.baseURL || '').replace(/\/$/, '');
-  const endpoint = String(prov.endpoint || '/responses');
-  const apiKey = prov.auth?.apiKey || cfgDoc?.keyVault?.[providerId]?.key1?.value;
-  if (!apiKey) throw new Error('no apikey');
-
-  const files = listGoldenRequests();
-  if (!files.length) throw new Error('no responses golden requests');
-  const chosen = pickGoldenForBaseUrl(files, baseUrl, pickHint);
-  if (!chosen) throw new Error('no suitable golden request');
-  const sample = JSON.parse(fs.readFileSync(path.join(SAMPLES_DIR, chosen), 'utf-8'));
-  const body = sample?.data?.body || sample?.body || sample?.data || sample;
-  if (!body || typeof body !== 'object') throw new Error('invalid golden body');
-  // Override model if provider specifies one
-  const model = prov.model || prov.modelId || prov.defaultModel || body.model;
-  body.model = model;
-  body.stream = true;
-
-  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;
-  const { ResponsesSseToJsonConverter } = await import(convPath);
-  const { buildChatResponseFromResponses } = await import(bridgePath);
+  const baseUrl = DEFAULT_BASE.replace(/\/$/, '');
+  const healthy = await healthCheck(baseUrl);
+  if (!healthy) {
+    throw new Error(`routecodex server not healthy: ${baseUrl}/health`);
+  }
+
+  const candidates = findClientRequestFiles(SAMPLES_ROOT);
+  if (!candidates.length) {
+    throw new Error(`no client-request samples found under ${SAMPLES_ROOT}`);
+  }
+  const picked = candidates[0];
+  const sample = readJson(picked.file);
+  const body = extractRequestBody(sample);
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    throw new Error(`invalid sample request body: ${picked.file}`);
+  }
+
+  const endpoint = extractEntryEndpoint(sample);
+  const wantsStream = extractStreamFlag(sample, body);
+  const requestBody = { ...body, stream: wantsStream };
+  const targetUrl = `${baseUrl}${endpoint.startsWith('/') ? endpoint : `/${endpoint}`}`;
+
+  ensureDir(OUT_DIR);
+  const runBase = path.join(OUT_DIR, `server-replay_${nowStamp()}`);
+  const requestOut = `${runBase}.request.json`;
+  const metaOut = `${runBase}.response.meta.json`;
+  const sseOut = `${runBase}.response.sse.log`;
+  const sseNdjsonOut = `${runBase}.response.sse.ndjson`;
+  const jsonOut = `${runBase}.response.json`;
+  const chatOut = `${runBase}.chat.json`;
 
   const headers = {
     'Content-Type': 'application/json',
+    'Accept': wantsStream ? 'text/event-stream' : 'application/json',
     'OpenAI-Beta': 'responses-2024-12-17',
-    'Authorization': `Bearer ${apiKey}`
+    'x-routecodex-api-key': DEFAULT_KEY
   };
 
-  ensureDir(OUT_DIR);
-  const base = path.join(OUT_DIR, `${providerId}_replay_${nowStamp()}`);
-  const sseLog = `${base}.sse.log`;
-  const jsonOut = `${base}.json`;
-  const chatOut = `${base}.chat.json`;
-  fs.writeFileSync(`${base}.request.json`, JSON.stringify({ url: baseUrl+endpoint, headers, body }, null, 2));
-
-  const client = new HttpClient({ baseUrl, timeout: 300000 });
-  const stream = await client.postStream(endpoint, body, { ...headers, Accept: 'text/event-stream' });
-  const conv = new ResponsesSseToJsonConverter();
-  const json = await conv.convertSseToJson(stream, {
-    requestId: path.basename(base),
-    model: String(body.model||'unknown'),
-    onEvent: (evt) => {
-      try {
-        fs.appendFileSync(sseLog, `event: ${evt.type}\n`);
-        fs.appendFileSync(sseLog, `data: ${JSON.stringify(evt.data)}\n\n`);
-      } catch {}
-    }
+  fs.writeFileSync(requestOut, JSON.stringify({
+    targetUrl,
+    endpoint,
+    sample: picked,
+    headers: { ...headers, 'x-routecodex-api-key': '***' },
+    body: requestBody
+  }, null, 2));
+
+  const res = await fetch(targetUrl, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(requestBody)
   });
-  fs.writeFileSync(jsonOut, JSON.stringify(json, null, 2));
-  const chat = buildChatResponseFromResponses(json);
-  fs.writeFileSync(chatOut, JSON.stringify(chat, null, 2));
-  const tc = chat?.choices?.[0]?.message?.tool_calls || [];
-  const ok = Array.isArray(tc) && tc.length > 0;
-  console.log('[responses-sse-replay-golden] provider=%s sample=%s tool_calls=%s out=%s', providerId, chosen, ok ? tc.length : 0, chatOut);
+  fs.writeFileSync(metaOut, JSON.stringify({
+    status: res.status,
+    statusText: res.statusText,
+    headers: Object.fromEntries(res.headers.entries())
+  }, null, 2));
+  if (!res.ok) {
+    const text = await res.text();
+    fs.writeFileSync(`${runBase}.response.error.txt`, text, 'utf-8');
+    throw new Error(`HTTP ${res.status}: ${text.slice(0, 500)}`);
+  }
+
+  if (!wantsStream) {
+    const json = await res.json();
+    fs.writeFileSync(jsonOut, JSON.stringify(json, null, 2));
+    console.log('[responses-sse-replay-golden] mode=json sample=%s out=%s', picked.file, jsonOut);
+    return;
+  }
+
+  const frames = await readSseFrames(res.body);
+  fs.writeFileSync(sseOut, frames.map((frame) => `${frame}\n\n`).join(''), 'utf-8');
+  fs.writeFileSync(sseNdjsonOut, frames.join('\n'), 'utf-8');
+  const converted = await convertSseFramesToJson(
+    frames,
+    picked.requestId,
+    typeof (requestBody).model === 'string' ? (requestBody).model : undefined
+  );
+  if (converted.json) {
+    fs.writeFileSync(jsonOut, JSON.stringify(converted.json, null, 2));
+  }
+  if (converted.chat) {
+    fs.writeFileSync(chatOut, JSON.stringify(converted.chat, null, 2));
+  }
+  console.log(
+    '[responses-sse-replay-golden] mode=sse sample=%s frames=%d sse=%s json=%s chat=%s',
+    picked.file,
+    frames.length,
+    sseOut,
+    converted.json ? jsonOut : '(skip)',
+    converted.chat ? chatOut : '(skip)'
+  );
 }
 
-main().catch(e => { console.error(e); process.exit(1); });
+main().catch((err) => {
+  console.error('[responses-sse-replay-golden] failed:', err?.message || String(err));
+  process.exit(1);
+});

package/scripts/run-bg.sh

@@ -44,7 +44,7 @@ detect_port() {
   local p="${TARGET_PORT:-}"
   if [[ -n "$p" ]]; then echo "$p"; return; fi
   if [[ -n "${ROUTECODEX_PORT:-}" ]]; then echo "${ROUTECODEX_PORT}"; return; fi
-  local cfg="$HOME/.routecodex/config.json"
+  local cfg="$HOME/.rcc/config.json"
   if command -v jq >/dev/null 2>&1 && [[ -f "$cfg" ]]; then
     p=$(jq -r '.port // empty' "$cfg" 2>/dev/null || true)
     if [[ -n "$p" && "$p" =~ ^[0-9]+$ ]]; then echo "$p"; return; fi

package/scripts/run-fg-gtimeout.sh

@@ -38,7 +38,7 @@ detect_port() {
   local p="${TARGET_PORT:-}"
   if [[ -n "$p" ]]; then echo "$p"; return; fi
   if [[ -n "${ROUTECODEX_PORT:-}" ]]; then echo "${ROUTECODEX_PORT}"; return; fi
-  local cfg="$HOME/.routecodex/config.json"
+  local cfg="$HOME/.rcc/config.json"
   if command -v jq >/dev/null 2>&1 && [[ -f "$cfg" ]]; then
     p=$(jq -r '.port // empty' "$cfg" 2>/dev/null || true)
     if [[ -n "$p" && "$p" =~ ^[0-9]+$ ]]; then echo "$p"; return; fi