@jsonstudio/rcc 0.85.9

package/scripts/responses-sse-capture.mjs

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+// Capture upstream SSE from a Responses provider (e.g., fc), log raw events, and run llmswitch-core converter.
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { pathToFileURL } from 'url';
+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 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 findProviderConfig(providerId='fc') {
+  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'));
+    }
+  }
+  throw new Error(`no provider config for ${providerId}`);
+}
+
+function resolveSecret(value) {
+  if (!value || typeof value !== 'string') return value;
+  const match = value.match(/^\$\{([^}:]+)(?::-(.*))?\}$/);
+  if (!match) return value;
+  const envName = match[1];
+  const fallback = match[2] ?? '';
+  return process.env[envName] ?? fallback;
+}
+
+function extractResponsesProviderEntry(doc, providerId='fc') {
+  const pipelines = doc?.pipeline_assembler?.config?.pipelines || [];
+  for (const p of pipelines) {
+    const prov = p?.modules?.provider;
+    const t = String(prov?.config?.providerType || prov?.type || '').toLowerCase();
+    if (t.includes('responses')) return prov;
+  }
+  // v1 fallback: treat as openai-standard pointing to responses upstream
+  const providers = doc?.virtualrouter?.providers || {};
+  const exact = providers?.[providerId];
+  if (exact) {
+    return {
+      type: exact.type || 'responses-http-provider',
+      config: {
+        providerType: exact.type || 'responses',
+        baseUrl: exact.baseURL || exact.baseUrl,
+        auth: exact.auth,
+        model: exact.model || exact.defaultModel
+      }
+    };
+  }
+  const first = Object.values(providers)[0];
+  if (first) {
+    return {
+      type: first.type || 'responses-http-provider',
+      config: {
+        providerType: first.type || 'responses',
+        baseUrl: first.baseURL || first.baseUrl,
+        auth: first.auth,
+        model: first.model || first.defaultModel
+      }
+    };
+  }
+  throw new Error('no responses provider entry');
+}
+
+function pickChatSample() {
+  const list = fs.readdirSync(CODEx_DIR).filter(f => /(_pipeline\.aggregate\.json|_provider-request\.json)$/.test(f)).sort();
+  for (const f of list) {
+    const obj = JSON.parse(fs.readFileSync(path.join(CODEx_DIR, f), 'utf-8'));
+    const body = obj?.data?.body || obj?.data || obj;
+    if (Array.isArray(body?.messages) && Array.isArray(body?.tools)) return body;
+  }
+  throw new Error('no suitable chat sample');
+}
+
+function loadResponsesSample() {
+  const samplePath = process.env.RCC_RESP_SAMPLE_PATH;
+  if (!samplePath) return null;
+  const fullPath = samplePath.startsWith('/') ? samplePath : path.join(RESP_SAMPLE_DIR, samplePath);
+  if (!fs.existsSync(fullPath)) {
+    throw new Error(`Responses sample not found: ${fullPath}`);
+  }
+  const doc = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+  const body = doc?.data?.body || doc?.body || doc;
+  if (!body || typeof body !== 'object') {
+    throw new Error(`Invalid responses sample body in ${fullPath}`);
+  }
+  return { payload: body, meta: { path: fullPath } };
+}
+
+async function main() {
+  const providerId = process.env.RCC_RESP_PROV || 'fc';
+  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 { 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;
+  const { buildResponsesRequestFromChat, buildChatResponseFromResponses } = await import(bridgePath);
+  const { ResponsesSseToJsonConverter } = await import(converterPath);
+
+  // headers
+  const headers = { 'Content-Type': 'application/json', 'OpenAI-Beta': 'responses-2024-12-17' };
+  const auth = cfg.config?.auth;
+  if (auth?.type === 'apikey' && auth.apiKey) headers['Authorization'] = `Bearer ${auth.apiKey}`;
+
+  // payload: chat → responses
+  const responsesSample = loadResponsesSample();
+  const chatBody = responsesSample ? null : pickChatSample();
+  const rawReq = responsesSample ? responsesSample.payload : (buildResponsesRequestFromChat(chatBody)?.request || {});
+  let respReq = JSON.parse(JSON.stringify(rawReq));
+  if (!responsesSample) {
+    // override model with provider config's modelId/defaultModel
+    try {
+      const provModel = cfg.config?.model || cfg.config?.modelId || cfg.config?.defaultModel;
+      if (provModel) respReq.model = provModel;
+    } catch { /* ignore */ }
+    // 强制工具触发：明确指令只执行函数调用
+    respReq.tool_choice = 'auto';
+    if (process.env.RCC_RESP_SIMPLE_INPUT === '1') {
+      // 某些上游不接受 instructions；使用最简 input 路径，重建请求
+      const model = respReq.model || chatBody.model || cfg.config?.model || cfg.config?.defaultModel;
+      respReq = {
+        model,
+        input: [
+          { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'Using tools, call add with {"a":2,"b":3}. Return only a function call.' }] }
+        ],
+        tools: Array.isArray(chatBody.tools) ? chatBody.tools : [],
+        stream: true,
+        tool_choice: 'auto'
+      };
+    } else {
+      respReq.instructions = 'Call add with {"a":2,"b":3}. Respond only with a function call.';
+    }
+    const overrideInstructions = process.env.RCC_RESP_INSTRUCTIONS;
+    if (overrideInstructions) {
+      if (overrideInstructions.toLowerCase() === 'none') {
+        delete respReq.instructions;
+      } else {
+        respReq.instructions = overrideInstructions;
+      }
+    } else if (!respReq.instructions) {
+      respReq.instructions = 'You are a helpful assistant.';
+    }
+    if (!Array.isArray(respReq.tools) || !respReq.tools.length) {
+      // 从 chat 样本复制工具定义
+      respReq.tools = (chatBody.tools || []).map(t => t);
+    }
+  }
+  respReq.stream = true;
+
+  const baseUrl = String(cfg.config?.baseUrl || '').replace(/\/$/, '');
+  const endpoint = '/responses';
+  const resolvedApiKey =
+    resolveSecret(auth?.apiKey) ||
+    resolveSecret(cfgDoc?.keyVault?.[providerId]?.key1?.value) ||
+    process.env.RCC_RESP_API_KEY ||
+    process.env.OPENAI_API_KEY ||
+    '';
+
+  // send SSE request
+  ensureDir(OUT_DIR);
+  const outBase = path.join(OUT_DIR, `${providerId}_${nowStamp()}`);
+  const sseLog = `${outBase}.sse.log`;
+  const jsonOut = `${outBase}.json`;
+  const reqOut = `${outBase}.request.json`;
+
+  const baseHeaders = { 'OpenAI-Beta': 'responses-2024-12-17' };
+  const captureClient = (process.env.RCC_RESP_CAPTURE_CLIENT || 'sdk').toLowerCase();
+  const useSdk = captureClient === 'sdk';
+  let json;
+
+  const logEvent = (evt) => {
+    try {
+      fs.appendFileSync(sseLog, `event: ${evt.type}\n`);
+      fs.appendFileSync(sseLog, `data: ${JSON.stringify(evt)}\n\n`);
+    } catch {}
+  };
+
+  if (useSdk) {
+    const client = new OpenAI({
+      apiKey: resolvedApiKey || 'sk-placeholder',
+      baseURL: baseUrl || undefined,
+      defaultHeaders: baseHeaders
+    });
+    const stream = await client.responses.stream(respReq);
+    for await (const event of stream) {
+      if (event?.type) logEvent(event);
+    }
+    json = await stream.finalResponse();
+    fs.writeFileSync(reqOut, JSON.stringify({ url: baseUrl ? baseUrl + endpoint : 'https://api.openai.com/v1/responses', headers: baseHeaders, body: respReq }, null, 2));
+  } else {
+    const headers = { 'Content-Type': 'application/json', ...baseHeaders };
+    if (resolvedApiKey) headers['Authorization'] = `Bearer ${resolvedApiKey}`;
+    fs.writeFileSync(reqOut, JSON.stringify({ url: baseUrl+endpoint, headers, body: respReq }, null, 2));
+    const client = new HttpClient({ baseUrl, timeout: 300000 });
+    const stream = await client.postStream(endpoint, respReq, { ...headers, Accept: 'text/event-stream' });
+    const converter = new ResponsesSseToJsonConverter();
+    json = await converter.convertSseToJson(stream, {
+      requestId: path.basename(outBase),
+      model: String(respReq.model||'unknown'),
+      onEvent: (evt) => logEvent({ type: evt.type, ...evt })
+    });
+  }
+
+  fs.writeFileSync(jsonOut, JSON.stringify(json, null, 2));
+  // Build Chat response shape via llmswitch-core and snapshot next to JSON
+  try {
+    const chat = buildChatResponseFromResponses(json);
+    const chatOut = `${outBase}.chat.json`;
+    fs.writeFileSync(chatOut, JSON.stringify(chat, null, 2));
+    console.log('[responses-sse-capture] saved', sseLog, jsonOut, chatOut);
+  } catch (e) {
+    console.warn('[responses-sse-capture] chat-convert failed:', e?.message || String(e));
+    console.log('[responses-sse-capture] saved', sseLog, jsonOut);
+  }
+}
+
+main().catch(e => { console.error(e); process.exit(1); });

package/scripts/responses-sse-proxy.mjs

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+// Standalone SSE passthrough proxy / mock for /v1/responses.
+// When RCC_RESP_REPLAY_LOG is set, replays a captured SSE log instead of forwarding to a live provider.
+// Otherwise, forwards requests to the configured provider and logs both inbound/outbound streams.
+
+import http from 'node:http';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { Readable } from 'node:stream';
+
+const DEFAULT_PORT = Number(process.env.RCC_RESP_PROXY_PORT || 9550);
+const DEFAULT_HOST = process.env.RCC_RESP_PROXY_HOST || '127.0.0.1';
+const providerId = process.env.RCC_RESP_PROV || getArg('--provider') || 'fai';
+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 CAPTURE_ROOT = path.join(os.homedir(), '.routecodex', 'codex-samples', 'openai-responses', 'sse-proxy');
+
+function getArg(flag) {
+  const idx = process.argv.indexOf(flag);
+  if (idx >= 0 && process.argv[idx + 1]) {
+    return process.argv[idx + 1];
+  }
+  return null;
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function loadProviderConfig(id) {
+  const baseDir = path.join(PROVIDER_ROOT, id);
+  const candidates = ['config.v1.json', 'config.json'];
+  for (const file of candidates) {
+    const candidatePath = path.join(baseDir, file);
+    if (fs.existsSync(candidatePath)) {
+      const doc = JSON.parse(fs.readFileSync(candidatePath, 'utf-8'));
+      const providers = doc?.virtualrouter?.providers || {};
+      if (providers[id]) {
+        return providers[id];
+      }
+    }
+  }
+  throw new Error(`Unable to find provider entry for ${id}`);
+}
+
+function normalizeBaseUrl(entry) {
+  const base = entry?.baseURL || entry?.baseUrl || '';
+  if (!base) throw new Error('Provider baseURL missing');
+  return String(base).replace(/\/$/, '');
+}
+
+function buildHeaders(entry) {
+  const headers = {
+    'OpenAI-Beta': 'responses-2024-12-17',
+    'Accept': 'text/event-stream',
+    'Content-Type': 'application/json'
+  };
+  const auth = entry?.auth;
+  if (auth?.type === 'apikey' && auth.apiKey) {
+    headers['Authorization'] = `Bearer ${auth.apiKey}`;
+  }
+  return headers;
+}
+
+function replayFromFile(logPath, res) {
+  const stream = fs.createReadStream(logPath, 'utf-8');
+  let buffer = '';
+  stream.on('data', chunk => {
+    buffer += chunk;
+    const parts = buffer.split(/\n\n/);
+    buffer = parts.pop() || '';
+    for (const frame of parts) {
+      res.write(frame + '\n\n');
+    }
+  });
+  stream.on('end', () => {
+    if (buffer.trim()) {
+      res.write(buffer + '\n\n');
+    }
+    res.end();
+  });
+  stream.on('error', err => {
+    res.write(`event: error\ndata: ${JSON.stringify({ message: err.message })}\n\n`);
+    res.end();
+  });
+}
+
+async function main() {
+  ensureDir(CAPTURE_ROOT);
+  let baseUrl, endpoint = '/responses', headers, client;
+  if (!replayLog) {
+    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 { HttpClient } = await import(httpClientPath);
+    client = new HttpClient({ baseUrl, timeout: 300000 });
+  } else {
+    console.log(`[responses-sse-proxy] replay mode enabled: ${replayLog}`);
+  }
+
+  const server = http.createServer(async (req, res) => {
+    if (req.method !== 'POST' || !(req.url || '').startsWith('/v1/responses')) {
+      res.statusCode = 404;
+      res.end('Not found');
+      return;
+    }
+
+    const requestId = `capture_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const captureDir = path.join(CAPTURE_ROOT, requestId);
+    ensureDir(captureDir);
+    const meta = {
+      requestId,
+      time: new Date().toISOString(),
+      clientHeaders: req.headers,
+      upstream: replayLog ? `[replay] ${replayLog}` : `${baseUrl}${endpoint}`
+    };
+    fs.writeFileSync(path.join(captureDir, 'meta.json'), JSON.stringify(meta, null, 2));
+
+    const reqLog = fs.createWriteStream(path.join(captureDir, 'request.sse.log'));
+    const rawChunks = [];
+    const finishWithError = (error) => {
+      if (!res.headersSent) {
+        res.statusCode = 502;
+        res.setHeader('Content-Type', 'application/json');
+      }
+      res.end(JSON.stringify({ error: { message: error instanceof Error ? error.message : String(error) } }));
+    };
+
+    req.on('data', (chunk) => {
+      rawChunks.push(chunk);
+      reqLog.write(chunk);
+    });
+
+    req.on('error', (error) => {
+      reqLog.end();
+      finishWithError(error);
+    });
+
+    req.on('end', async () => {
+      reqLog.end();
+      const rawBody = Buffer.concat(rawChunks).toString('utf8');
+
+      if (replayLog) {
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream; charset=utf-8',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive'
+        });
+        replayFromFile(replayLog, res);
+        console.log(`[responses-sse-proxy] replayed ${replayLog} for ${requestId}`);
+        return;
+      }
+
+      try {
+        const upstreamResponse = await fetch(`${baseUrl}${endpoint}`, {
+          method: 'POST',
+          headers,
+          body: rawBody
+        });
+        if (!upstreamResponse.ok || !upstreamResponse.body) {
+          const errText = await upstreamResponse.text();
+          throw new Error(`HTTP ${upstreamResponse.status}: ${errText}`);
+        }
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream; charset=utf-8',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive'
+        });
+        const respLog = fs.createWriteStream(path.join(captureDir, 'response.sse.log'));
+        const upstreamStream = Readable.fromWeb(upstreamResponse.body);
+        upstreamStream.on('data', (chunk) => {
+          respLog.write(chunk);
+          res.write(chunk);
+        });
+        upstreamStream.on('end', () => {
+          respLog.end();
+          res.end();
+          console.log(`[responses-sse-proxy] completed ${requestId}`);
+        });
+        upstreamStream.on('error', (error) => {
+          respLog.end();
+          if (!res.writableEnded) {
+            res.write(`event: error\ndata: ${JSON.stringify({ message: error.message })}\n\n`);
+            res.end();
+          }
+        });
+        req.on('close', () => {
+          upstreamStream.destroy();
+        });
+      } catch (error) {
+        finishWithError(error);
+      }
+    });
+  });
+
+  server.listen(port, host, () => {
+    console.log(`[responses-sse-proxy] listening on http://${host}:${port}/v1/responses`);
+    console.log(`[responses-sse-proxy] forwarding to ${baseUrl}${endpoint}`);
+    console.log(`[responses-sse-proxy] captures stored under ${CAPTURE_ROOT}`);
+  });
+
+  const shutdown = () => {
+    server.close(() => process.exit(0));
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main().catch((error) => {
+  console.error('[responses-sse-proxy] failed:', error);
+  process.exit(1);
+});

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

@@ -0,0 +1,138 @@
+#!/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
+// Env:
+//   RCC_RESP_PROV: fc|c4m|fai (default fc)
+//   RCC_RESP_PICK: substring to pick a specific sample file
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { pathToFileURL } from 'url';
+
+const PROVIDER_DIR = path.join(os.homedir(), '.routecodex', 'provider');
+const SAMPLES_DIR = 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 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'));
+    }
+  }
+  throw new Error(`No provider config for ${providerId}`);
+}
+
+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 listGoldenRequests() {
+  if (!fs.existsSync(SAMPLES_DIR)) return [];
+  return fs.readdirSync(SAMPLES_DIR).filter(n => n.endsWith('_provider-request.json'));
+}
+
+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;
+}
+
+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/modules/pipeline/modules/provider/v2/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 headers = {
+    'Content-Type': 'application/json',
+    'OpenAI-Beta': 'responses-2024-12-17',
+    'Authorization': `Bearer ${apiKey}`
+  };
+
+  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(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);
+}
+
+main().catch(e => { console.error(e); process.exit(1); });