@jsonstudio/rcc 0.85.9

package/scripts/replay-recorded-toolcall.mjs

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+// End-to-end tool-call replay using a recorded OpenAI Chat raw request
+// Usage:
+//   node scripts/replay-recorded-toolcall.mjs [--raw <path/to/_raw-request.json>] [--port <n>]
+// Behavior:
+//   - Starts the RouteCodex server if not healthy
+//   - Sends a streaming Chat request using the recorded body (with stream:true)
+//   - Captures the first tool_calls SSE chunk
+//   - Executes supported tools locally (shell, update_plan minimal)
+//   - Sends a second non-stream request with assistant tool_calls + tool result
+//   - Prints a one-line summary of success
+
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const DEV_ROOT = path.resolve(__dirname, '..');
+
+function parseArgs(argv) {
+  const out = { raw: '', port: 0 };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--raw') { out.raw = String(argv[++i] || ''); continue; }
+    if (a === '--port') { out.port = Number(argv[++i] || '0'); continue; }
+  }
+  return out;
+}
+
+async function readJson(p) {
+  const raw = await fs.readFile(p, 'utf-8');
+  return JSON.parse(raw);
+}
+
+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');
+    if (fsSync.existsSync(candidate)) {
+      const cfg = await readJson(candidate);
+      const p = (cfg && cfg.httpserver && typeof cfg.httpserver.port === 'number') ? cfg.httpserver.port : cfg.port;
+      if (typeof p === 'number' && p > 0) return p;
+    }
+  } catch {}
+  return 5520;
+}
+
+async function health(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`);
+    if (!res.ok) return false;
+    const j = await res.json().catch(() => null);
+    return !!j && (j.status === 'ok' || j.status === 'healthy' || j.status === 'ready');
+  } catch { return false; }
+}
+
+async function startServerIfNeeded(port) {
+  if (await health(port)) return;
+  await new Promise((resolve, reject) => {
+    const p = spawn('npm', ['-s', 'run', 'start:bg'], { cwd: DEV_ROOT, stdio: 'ignore' });
+    p.on('error', reject);
+    p.on('exit', () => resolve());
+  });
+  for (let i = 0; i < 60; i++) { if (await health(port)) return; await sleep(500); }
+  throw new Error('Server not healthy after start');
+}
+
+function pickLatestRaw() {
+  const dir = path.join(os.homedir(), '.routecodex', 'codex-samples', 'openai-chat');
+  if (!fsSync.existsSync(dir)) throw new Error(`No snapshot dir: ${dir}`);
+  const files = fsSync.readdirSync(dir)
+    .filter(f => f.endsWith('_raw-request.json'))
+    .map(f => ({ f, mtime: fsSync.statSync(path.join(dir, f)).mtimeMs }))
+    .sort((a, b) => b.mtime - a.mtime);
+  if (!files.length) throw new Error('No *_raw-request.json found');
+  return path.join(dir, files[0].f);
+}
+
+async function readStreamingToolCall(port, body) {
+  const ctrl = new AbortController();
+  const to = setTimeout(() => { try { ctrl.abort(); } catch {} }, 60000);
+  const res = await fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Accept': 'text/event-stream' },
+    body: JSON.stringify({ ...body, stream: true }),
+    signal: ctrl.signal
+  });
+  if (!res.ok || !res.body) throw new Error(`SSE request failed: ${res.status}`);
+  const reader = res.body.getReader();
+  let buf = '';
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buf += Buffer.from(value).toString('utf-8');
+      // Look for a data: line with tool_calls
+      const lines = buf.split(/\r?\n/);
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const jsonStr = line.slice(6);
+        if (jsonStr === '[DONE]') continue;
+        let obj; try { obj = JSON.parse(jsonStr); } catch { continue; }
+        const tc = obj?.choices?.[0]?.delta?.tool_calls;
+        if (Array.isArray(tc) && tc.length > 0) {
+          clearTimeout(to);
+          return { chunk: obj, toolCall: tc[0] };
+        }
+      }
+      // retain only the last few KB
+      if (buf.length > 100_000) buf = buf.slice(-50_000);
+    }
+  } finally { clearTimeout(to); }
+  throw new Error('No tool_calls observed in SSE');
+}
+
+async function runTool(toolCall) {
+  const name = String(toolCall?.function?.name || '');
+  const argsStr = String(toolCall?.function?.arguments || '');
+  let args = {};
+  try { args = JSON.parse(argsStr); } catch {}
+  if (name === 'shell') {
+    const cmd = args.command;
+    if (!cmd) return { output: 'no command' };
+    if (Array.isArray(cmd)) {
+      return await execSpawn(cmd[0], cmd.slice(1));
+    } else if (typeof cmd === 'string') {
+      return await execShell(cmd);
+    }
+    return { output: 'unsupported command format' };
+  }
+  if (name === 'update_plan') {
+    return { status: 'ok', note: 'update_plan acknowledged' };
+  }
+  return { error: 'unsupported_tool', name };
+}
+
+async function execSpawn(bin, args) {
+  return await new Promise(resolve => {
+    const p = spawn(bin, Array.isArray(args) ? args : [], { stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = '', err = '';
+    p.stdout.on('data', d => out += String(d));
+    p.stderr.on('data', d => err += String(d));
+    p.on('close', code => resolve({ code, stdout: out, stderr: err }));
+    p.on('error', e => resolve({ error: String(e) }));
+  });
+}
+
+async function execShell(cmd) {
+  return await new Promise(resolve => {
+    const p = spawn('bash', ['-lc', cmd], { stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = '', err = '';
+    p.stdout.on('data', d => out += String(d));
+    p.stderr.on('data', d => err += String(d));
+    p.on('close', code => resolve({ code, stdout: out, stderr: err }));
+    p.on('error', e => resolve({ error: String(e) }));
+  });
+}
+
+function buildAssistantToolMsg(tc) {
+  return {
+    role: 'assistant',
+    tool_calls: [
+      {
+        id: tc.id || `call_${Date.now()}`,
+        type: 'function',
+        function: {
+          name: tc?.function?.name || 'unknown',
+          arguments: String(tc?.function?.arguments || '{}')
+        }
+      }
+    ]
+  };
+}
+
+function buildToolResultMsg(tc, toolResultObj) {
+  return {
+    role: 'tool',
+    tool_call_id: tc.id || `call_${Date.now()}`,
+    content: JSON.stringify(toolResultObj)
+  };
+}
+
+async function main() {
+  const { raw, port: cliPort } = parseArgs(process.argv);
+  const port = cliPort > 0 ? cliPort : await getPortFromConfig();
+  await startServerIfNeeded(port);
+  const rawPath = raw || pickLatestRaw();
+  const recorded = await readJson(rawPath);
+  const body = recorded?.body;
+  if (!body || !Array.isArray(body.messages)) throw new Error('Invalid raw-request body');
+
+  console.log(`[replay] Using raw-request: ${rawPath}`);
+  const { toolCall } = await readStreamingToolCall(port, body);
+  const toolName = toolCall?.function?.name || 'unknown';
+  console.log(`[replay] tool_call received: ${toolName}`);
+  const toolResult = await runTool(toolCall);
+  console.log(`[replay] tool executed: ${toolName} -> ${Object.keys(toolResult).join(',')}`);
+
+  const assistantMsg = buildAssistantToolMsg(toolCall);
+  const toolMsg = buildToolResultMsg(toolCall, toolResult);
+  const second = {
+    model: body.model,
+    tools: body.tools,
+    messages: [...body.messages, assistantMsg, toolMsg]
+  };
+
+  const res2 = await fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+    body: JSON.stringify(second)
+  });
+  const j2 = await res2.json().catch(() => null);
+  if (!res2.ok) {
+    console.error('[replay] second call failed', j2 || res2.statusText);
+    process.exit(2);
+  }
+  const finish = j2?.choices?.[0]?.finish_reason || 'unknown';
+  const content = j2?.choices?.[0]?.message?.content || null;
+  const nextTool = j2?.choices?.[0]?.message?.tool_calls || null;
+  console.log('[replay] second call ok:', { finish, content: content ? String(content).slice(0, 160) : null, nextTool: Array.isArray(nextTool) ? nextTool[0]?.function?.name : null });
+}
+
+main().catch(err => { console.error(err); process.exit(1); });
+

package/scripts/replay-responses-sse.mjs

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+// Offline replay for Responses SSE: take a snapshot JSON (finalize-pre/post or raw Chat JSON),
+// run through core finalize → bridge → SSE synth, and print a concise summary.
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function pickChatPayload(obj) {
+  if (!obj || typeof obj !== 'object') return obj;
+  // Hooks snapshots shape: { context, inputData: { data: <chatLike> } }
+  if ('inputData' in obj && obj.inputData && typeof obj.inputData === 'object') {
+    const id = obj.inputData;
+    if ('data' in id && id.data && typeof id.data === 'object') return id.data;
+  }
+  // Fallback: snapshots or pipeline dtos that use { data: <chatLike> }
+  if ('data' in obj && obj.data && typeof obj.data === 'object') {
+    const d = obj.data;
+    if (d && typeof d === 'object' && 'data' in d) return d.data;
+    return d;
+  }
+  return obj;
+}
+
+async function main() {
+  const inputPath = process.argv[2];
+  if (!inputPath) {
+    console.error('Usage: node scripts/replay-responses-sse.mjs <snapshot.json>');
+    process.exit(1);
+  }
+  const abs = path.isAbsolute(inputPath) ? inputPath : path.resolve(process.cwd(), inputPath);
+  let raw;
+  try {
+    const text = await fs.readFile(abs, 'utf-8');
+    raw = JSON.parse(text);
+  } catch (e) {
+    console.error('Failed to read/parse JSON:', e?.message || String(e));
+    process.exit(2);
+  }
+
+  // 仅允许本地 sharedmodule 构建
+  const repoRoot = path.resolve(__dirname, '..');
+  const localBase = path.join(repoRoot, 'sharedmodule', 'llmswitch-core', 'dist', 'v2', 'conversion');
+  try {
+    await fs.access(localBase);
+  } catch {
+    console.error('未找到 sharedmodule/llmswitch-core/dist。请先在 sharedmodule/llmswitch-core 内运行 npm run build。');
+    process.exit(3);
+  }
+
+  const importCore = async (relPath) => import(pathToFileURL(path.join(localBase, relPath)).href);
+
+  const finalizeMod = await importCore(path.join('shared', 'openai-finalizer.js'));
+  const bridgeMod = await importCore(path.join('responses', 'responses-openai-bridge.js'));
+  const sseMod = await importCore(path.join('streaming', 'json-to-responses-sse.js'));
+
+  const requestId = (() => {
+    const bn = path.basename(abs).replace(/\.json$/i, '');
+    const m = /req[_-]/i.test(bn) ? bn : `req_${Date.now()}`;
+    return m;
+  })();
+
+  // Unwrap snapshot → Chat JSON
+  const chatLike = pickChatPayload(raw);
+  // Finalize Chat JSON (idempotent)
+  const finalized = await finalizeMod.finalizeOpenAIChatResponse(chatLike, { requestId, endpoint: '/v1/responses' });
+  // Map to Responses JSON (non-stream)
+  const mapped = bridgeMod.buildResponsesPayloadFromChat(finalized, undefined);
+
+  // Summarize mapping
+  const outputText = (mapped && typeof mapped === 'object') ? (mapped.output_text || '') : '';
+  const ra = (mapped && typeof mapped === 'object' && mapped.required_action && mapped.required_action.type === 'submit_tool_outputs')
+    ? (Array.isArray(mapped.required_action.submit_tool_outputs?.tool_calls) ? mapped.required_action.submit_tool_outputs.tool_calls.length : 0)
+    : 0;
+
+  // Generate synthetic Responses SSE from Chat JSON
+  const readable = sseMod.createResponsesSSEStreamFromChatJson(finalized, { requestId });
+  const stats = { textDelta: 0, ra: 0, completed: 0, done: 0, doneToken: 0 };
+  let chunks = 0;
+  await new Promise((resolve) => {
+    readable.on('data', (buf) => {
+      try {
+        const s = buf.toString();
+        chunks++;
+        if (s.includes('event: response.output_text.delta')) stats.textDelta++;
+        if (s.includes('event: response.required_action')) stats.ra++;
+        if (s.includes('event: response.completed')) stats.completed++;
+        if (s.includes('event: response.done')) stats.done++;
+        if (s.includes('data: [DONE]')) stats.doneToken++;
+      } catch { /* ignore */ }
+    });
+    readable.on('end', resolve);
+    readable.on('error', resolve);
+  });
+
+  // Print concise summary
+  console.log('— Replay Summary —');
+  console.log('file:', abs);
+  console.log('requestId:', requestId);
+  console.log('mapped.output_text.length:', typeof outputText === 'string' ? outputText.length : 0);
+  console.log('mapped.required_action.tool_calls:', ra);
+  console.log('sse: chunks=%d textDelta=%d required_action=%d completed=%d done=%d doneToken=%d',
+    chunks, stats.textDelta, stats.ra, stats.completed, stats.done, stats.doneToken);
+}
+
+main().catch((e) => {
+  console.error('replay failed:', e?.message || String(e));
+  process.exit(3);
+});

package/scripts/responses-fai-capture.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+// Probe/capture a fai-compatible Responses golden sample by trying minimal variants until success.
+
+import fs from 'fs';
+import os from 'os';
+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 OUT_DIR = path.join(os.homedir(), '.routecodex', 'golden_samples', 'provider_golden_samples', 'responses', PROVIDER_ID);
+
+function ensureDir(p) { fs.mkdirSync(p, { recursive: true }); }
+
+function findProviderConfig(providerId) {
+  const dir = path.join(PROVIDER_DIR, providerId);
+  const files = ['config.v1.json', 'config.json'];
+  for (const f of files) { const p = path.join(dir, f); if (fs.existsSync(p)) return JSON.parse(fs.readFileSync(p, 'utf-8')); }
+  throw new Error(`no provider config for ${providerId}`);
+}
+
+function extract(doc, providerId) {
+  const pipelines = doc?.pipeline_assembler?.config?.pipelines || [];
+  for (const p of pipelines) {
+    const prov = p?.modules?.provider?.config;
+    if (!prov) continue;
+    if ((prov.providerId || providerId) === providerId) return prov;
+  }
+  const providers = doc?.virtualrouter?.providers || {};
+  for (const [pid, prov] of Object.entries(providers)) {
+    if (pid === providerId) return { baseUrl: prov.baseURL||prov.baseUrl, endpoint:'/responses', auth: prov.auth, modelId: (doc?.virtualrouter?.routing?.default||[''])[0]?.split('.')?.[1] };
+  }
+  throw new Error('provider entry missing');
+}
+
+function basePayload() {
+  const tools = [{ type:'function', name:'add', description:'add two numbers', parameters:{ type:'object', properties:{ a:{type:'number'}, b:{type:'number'} }, required:['a','b'] } }];
+  return {
+    tools,
+    tool_choice: 'auto',
+    instructions: 'You are a helpful assistant.',
+    input: [ { type:'message', role:'user', content:[ { type:'input_text', text: 'Using tools, call add with {"a":2,"b":3}. Return only a function call.' } ] } ]
+  };
+}
+
+function variants(payload) {
+  const v = [];
+  // v1: as-is (short instructions + input[] + tool_choice='auto')
+  v.push(JSON.parse(JSON.stringify(payload)));
+  // v2: tool_choice object
+  { const p = JSON.parse(JSON.stringify(payload)); p.tool_choice = { type:'function', function:{ name:'add' } }; v.push(p); }
+  // v3: remove instructions, keep input[] (some providers complain instructions invalid)
+  { const p = JSON.parse(JSON.stringify(payload)); delete p.instructions; v.push(p); }
+  // v4: keep instructions only, no input[] (some require instructions only)
+  { const p = JSON.parse(JSON.stringify(payload)); delete p.input; v.push(p); }
+  // v5: compact tools (remove description)
+  { const p = JSON.parse(JSON.stringify(payload)); p.tools = p.tools.map(t => ({ type:'function', name:t.name, parameters:t.parameters })); v.push(p); }
+  // v6: chat-style tools nesting (some proxies expect {type:'function', function:{name,parameters}})
+  { const p = JSON.parse(JSON.stringify(payload)); p.tools = p.tools.map(t => ({ type:'function', function:{ name: t.name, description: t.description, parameters: t.parameters } })); v.push(p); }
+  return v;
+}
+
+async function main() {
+  const cfgDoc = findProviderConfig(PROVIDER_ID);
+  const prov = extract(cfgDoc, PROVIDER_ID);
+  const baseUrl = String(prov.baseUrl||prov.baseURL||'').replace(/\/$/,'');
+  let endpoint = String(prov.endpoint||'/responses');
+  // Heuristic: fai baseUrl ends with '/openai/' → they likely expect '/v1/responses'
+  if (/\/openai\/?$/.test(baseUrl) && !/\/v1\/?$/.test(baseUrl)) {
+    endpoint = '/v1/responses';
+  }
+  const apiKey = prov?.auth?.apiKey || cfgDoc?.keyVault?.[PROVIDER_ID]?.key1?.value;
+  const model = prov.model || prov.modelId || prov.defaultModel || 'gpt-5.1';
+  if (!apiKey) throw new Error('no apikey');
+
+  const httpPath = pathToFileURL(path.join(process.cwd(), 'dist/modules/pipeline/modules/provider/v2/utils/http-client.js')).href;
+  const { HttpClient } = await import(httpPath);
+  const convPath = pathToFileURL(path.join(process.cwd(), 'sharedmodule/llmswitch-core/dist/sse/sse-to-json/index.js')).href;
+  const { ResponsesSseToJsonConverter } = await import(convPath);
+
+  const headers = { 'Content-Type':'application/json', 'OpenAI-Beta':'responses-2024-12-17', 'Authorization':`Bearer ${apiKey}`, 'User-Agent': 'RouteCodex/2.0 (+https://github.com/routecodex)'};
+  const client = new HttpClient({ baseUrl, timeout:300000 });
+  // Optional: use an exact golden request body ("same request")
+  const SAMPLE = process.env.RCC_FAICAP_SAMPLE;
+  let tries;
+  if (SAMPLE && fs.existsSync(SAMPLE)) {
+    try {
+      const obj = JSON.parse(fs.readFileSync(SAMPLE, 'utf-8'));
+      const body = obj?.data?.body || obj?.body || obj?.data || obj;
+      if (!body || typeof body !== 'object') throw new Error('invalid sample body');
+      tries = [body];
+    } catch (e) {
+      console.error('[fai-capture] invalid sample, fallback to variants:', e?.message||String(e));
+      const base = basePayload();
+      tries = variants(base);
+    }
+  } else {
+    const base = basePayload();
+    tries = variants(base);
+  }
+  let lastErr;
+  for (let i=0;i<tries.length;i++) {
+    try {
+      const body = { ...tries[i], model, stream:true };
+      const stream = await client.postStream(endpoint, body, { ...headers, Accept:'text/event-stream' });
+      const conv = new ResponsesSseToJsonConverter();
+      const reqId = `fai_probe_${Date.now()}_${i}`;
+      const json = await conv.convertSseToJson(stream, { requestId: reqId, model:String(model) });
+      // success: write golden
+      const outdir = path.join(OUT_DIR, reqId);
+      ensureDir(outdir);
+      fs.writeFileSync(path.join(outdir, 'provider-request.json'), JSON.stringify({ url: baseUrl+endpoint, headers, body }, null, 2));
+      fs.writeFileSync(path.join(outdir, 'provider-response.json'), JSON.stringify(json, null, 2));
+      console.log('[fai-capture] success variant=%d out=%s', i+1, outdir);
+      return;
+    } catch (e) {
+      lastErr = e;
+      continue;
+    }
+  }
+  throw lastErr || new Error('all variants failed');
+}
+
+main().catch(e => { console.error('[fai-capture] failed:', e?.message||String(e)); process.exit(1); });