@jsonstudio/rcc 0.85.9

package/scripts/fc-responses-from-snapshot.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+// Use OpenAI Responses SDK to send an existing snapshot's originalData
+// directly to an upstream /v1/responses endpoint, to verify whether the
+// "correct" payload shape (as captured via monitor) succeeds.
+//
+// Usage:
+//   FC_API_KEY=... node scripts/fc-responses-from-snapshot.mjs \
+//     ~/.routecodex/codex-samples/openai-responses/req_xxx_request_1_validation_pre.json \
+//     [baseUrl]
+//
+// baseUrl defaults to https://www.fakercode.top/v1
+
+import fs from 'fs/promises';
+import path from 'path';
+import OpenAI from 'openai';
+
+const snapshotPath = process.argv[2];
+if (!snapshotPath) {
+  console.error('Usage: node scripts/fc-responses-from-snapshot.mjs <snapshot.json> [baseUrl]');
+  process.exit(1);
+}
+
+const baseURL = process.argv[3] || 'https://www.fakercode.top/v1';
+
+const apiKey =
+  process.env.FC_API_KEY ||
+  process.env.OPENAI_API_KEY ||
+  '';
+
+if (!apiKey) {
+  console.error('FC_API_KEY / OPENAI_API_KEY is required');
+  process.exit(1);
+}
+
+async function loadOriginalData(p) {
+  const abs = path.isAbsolute(p) ? p : path.resolve(process.cwd(), p);
+  const text = await fs.readFile(abs, 'utf-8');
+  const json = JSON.parse(text);
+  const data = json && typeof json === 'object' && json.data && typeof json.data === 'object'
+    ? json.data
+    : json;
+  const original = data && typeof data === 'object' && data.originalData && typeof data.originalData === 'object'
+    ? data.originalData
+    : data;
+  return original;
+}
+
+async function main() {
+  const original = await loadOriginalData(snapshotPath);
+  if (!original || typeof original !== 'object') {
+    console.error('snapshot does not contain usable originalData');
+    process.exit(2);
+  }
+
+  // Allow overriding model to gpt-5.1 via env, but keep everything else as-is.
+  const modelOverride = process.env.FC_MODEL || process.env.OPENAI_MODEL;
+  const payload = {
+    ...original,
+    ...(modelOverride ? { model: modelOverride } : {})
+  };
+
+  const client = new OpenAI({ apiKey, baseURL });
+
+  console.log('[fc-snap] BASE_URL', baseURL);
+  console.log('[fc-snap] MODEL', payload.model);
+
+  try {
+    const stream = await client.responses.stream(payload);
+    console.log('[fc-snap] STREAM_OK');
+    const eventCounts = {};
+    let firstEvents = [];
+
+    for await (const event of stream) {
+      const t = event?.type || 'unknown';
+      eventCounts[t] = (eventCounts[t] || 0) + 1;
+      if (firstEvents.length < 5) {
+        firstEvents.push(event);
+      }
+    }
+
+    console.log('[fc-snap] EVENT_COUNTS', JSON.stringify(eventCounts, null, 2));
+    console.log('[fc-snap] FIRST_EVENTS', JSON.stringify(firstEvents, null, 2));
+  } catch (err) {
+    console.log('[fc-snap] STREAM_ERROR');
+    console.log(
+      JSON.stringify(
+        {
+          name: err?.name,
+          message: err?.message,
+          status: err?.status,
+          code: err?.code,
+          type: err?.type,
+          data: err?.response?.data
+        },
+        null,
+        2
+      )
+    );
+    process.exit(1);
+  }
+}
+
+main().catch((e) => {
+  console.error('[fc-snap] FATAL', e?.message || String(e));
+  process.exit(3);
+});
+

package/scripts/fc-responses-tool-loop.mjs

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+// FC /v1/responses tool-call smoke test (no RouteCodex server involved)
+// - Sends a Responses request with a simple echo tool
+// - Consumes SSE named events until it sees response.required_action
+// - Prints basic stats so we can confirm upstream supports tools on Responses wire
+//
+// Usage:
+//   FC_API_KEY=... node scripts/fc-responses-tool-loop.mjs [baseUrl]
+//
+// baseUrl defaults to https://www.fakercode.top/v1
+
+import http from 'node:http';
+import https from 'node:https';
+import { TextDecoder } from 'node:util';
+
+const BASE_URL = process.argv[2] || 'https://www.fakercode.top/v1';
+const API_KEY =
+  process.env.FC_API_KEY ||
+  process.env.OPENAI_API_KEY ||
+  '';
+
+if (!API_KEY) {
+  console.error('FC_API_KEY / OPENAI_API_KEY is required');
+  process.exit(1);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function parseEventFrame(frame) {
+  const lines = frame.split('\n');
+  let event = 'message';
+  let data = '';
+  for (const ln of lines) {
+    if (ln.startsWith(':')) return { event: 'comment', data: ln.slice(1).trim() };
+    if (ln.startsWith('event:')) event = ln.slice(6).trim();
+    if (ln.startsWith('data:')) data += (data ? '\n' : '') + ln.slice(5).trim();
+  }
+  return { event, data };
+}
+
+async function* consumeSSE(res) {
+  const decoder = new TextDecoder();
+  let buf = '';
+  for await (const chunk of res) {
+    const s = typeof chunk === 'string' ? chunk : decoder.decode(chunk);
+    buf += s;
+    while (true) {
+      const idx = buf.indexOf('\n\n');
+      if (idx < 0) break;
+      const frame = buf.slice(0, idx);
+      buf = buf.slice(idx + 2);
+      yield frame;
+    }
+  }
+}
+
+async function main() {
+  const base = BASE_URL.endsWith('/') ? BASE_URL : `${BASE_URL}/`;
+  const url = new URL('responses', base);
+  const isHttps = url.protocol === 'https:';
+
+  const payload = {
+    model: process.env.FC_MODEL || 'gpt-5.1',
+    instructions:
+      'You are a precise coding assistant. ' +
+      'When the user asks to call a tool, you MUST respond using tool calls only, not natural language.',
+    input: [
+      {
+        type: 'message',
+        role: 'user',
+        content: [
+          {
+            type: 'input_text',
+            text: '调用 echo 工具，参数 {"text":"ping"}，请严格通过工具返回结果，不要直接回答。'
+          }
+        ]
+      }
+    ],
+    tools: [
+      {
+        type: 'function',
+        name: 'echo',
+        description: '回显传入的文本内容',
+        parameters: {
+          type: 'object',
+          properties: {
+            text: { type: 'string', description: '要回显的文本' }
+          },
+          required: ['text']
+        }
+      }
+    ],
+    stream: true
+  };
+
+  console.log('[fc] POST', url.toString());
+  console.log('[fc] model', payload.model);
+
+  const agent = isHttps
+    ? new https.Agent({ keepAlive: true })
+    : new http.Agent({ keepAlive: true });
+
+  const reqOptions = {
+    method: 'POST',
+    headers: {
+      Accept: 'text/event-stream',
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${API_KEY}`
+    },
+    agent
+  };
+
+  await new Promise((resolve, reject) => {
+    const req = (isHttps ? https : http).request(url, reqOptions, async (res) => {
+      if (res.statusCode && res.statusCode >= 400) {
+        let body = '';
+        for await (const chunk of res) body += chunk.toString();
+        console.error('[fc] upstream error', res.statusCode, body);
+        reject(new Error(`Upstream error ${res.statusCode}`));
+        return;
+      }
+
+      let sawCreated = false;
+      let sawRequiredAction = false;
+      let responseId = '';
+      let toolCalls = [];
+
+      for await (const frame of consumeSSE(res)) {
+        const ev = parseEventFrame(frame);
+        if (ev.event === 'comment') continue;
+        if (ev.event === 'message' && ev.data === '[DONE]') break;
+        if (!ev.data) continue;
+        let data;
+        try {
+          data = JSON.parse(ev.data);
+        } catch {
+          continue;
+        }
+
+        if (ev.event === 'response.created') {
+          sawCreated = true;
+          responseId = String(data?.response?.id || '');
+          console.log('[fc] response.created id=', responseId);
+        } else if (ev.event === 'response.required_action') {
+          sawRequiredAction = true;
+          const calls = (data?.required_action?.submit_tool_outputs?.tool_calls) || [];
+          toolCalls = calls;
+          console.log('[fc] required_action tool_calls=', calls.length);
+          break;
+        } else if (ev.event === 'response.output_text.delta') {
+          // just log a tiny marker, avoid flooding stdout
+          process.stdout.write('.');
+        }
+      }
+
+      console.log('');
+      console.log('[fc] sawCreated=', sawCreated, 'sawRequiredAction=', sawRequiredAction, 'toolCalls=', toolCalls.length);
+      if (!sawCreated || !sawRequiredAction || toolCalls.length === 0) {
+        reject(new Error('Tool call not emitted by upstream'));
+        return;
+      }
+      resolve(null);
+    });
+
+    req.on('error', reject);
+    req.write(JSON.stringify(payload));
+    req.end();
+  });
+
+  await sleep(100); // allow agent to flush
+  console.log('[fc] PASSED (responses + tools)');
+}
+
+main().catch((err) => {
+  console.error('[fc] FAILED', err?.message || String(err));
+  process.exit(1);
+});

package/scripts/gemini-smoke.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { GeminiHttpProvider } from '../dist/modules/pipeline/modules/provider/v2/core/gemini-http-provider.js';
+import { fileURLToPath } from 'url';
+
+const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
+if (!apiKey) {
+  console.error('Set GEMINI_API_KEY to run this smoke test');
+  process.exit(1);
+}
+
+const config = {
+  type: 'gemini-http-provider',
+  config: {
+    providerType: 'gemini',
+    baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
+    model: process.env.GEMINI_MODEL || 'gemini-2.5-flash-lite',
+    auth: { type: 'apikey', headerName: 'x-goog-api-key', apiKey },
+    overrides: { maxRetries: 0 }
+  }
+};
+
+const dependencies = {
+  logger: { logModule: () => {}, logProviderRequest: () => {} },
+  errorHandlingCenter: { handleError: async () => {} }
+};
+
+const provider = new GeminiHttpProvider(config, dependencies);
+await provider.initialize();
+
+const request = {
+  data: {
+    model: config.config.model,
+    messages: [{ role: 'user', content: 'Say hi in one word.' }]
+  }
+};
+
+const res = await provider.sendRequest(request);
+console.log('[gemini-smoke] status:', res?.status || 200);
+console.log('[gemini-smoke] body snippet:', JSON.stringify(res?.data || res).slice(0, 500));

package/scripts/gen-build-info.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+
+const cwd = process.cwd();
+const pkgPath = path.join(cwd, 'package.json');
+const outPath = path.join(cwd, 'src', 'build-info.ts');
+
+const mode = String(process.env.BUILD_MODE || process.env.RCC_BUILD_MODE || 'release').toLowerCase();
+const valid = new Set(['dev', 'release']);
+const buildMode = valid.has(mode) ? mode : 'release';
+
+let version = '0.0.0';
+try {
+  version = JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version || version;
+} catch {}
+
+const content = `// Auto-generated by scripts/gen-build-info.mjs
+export interface BuildInfo { mode: 'dev' | 'release'; version: string; buildTime: string }
+export const buildInfo: BuildInfo = {
+  mode: '${buildMode}',
+  version: '${version}',
+  buildTime: '${new Date().toISOString()}'
+};
+`;
+
+fs.mkdirSync(path.dirname(outPath), { recursive: true });
+fs.writeFileSync(outPath, content, 'utf-8');
+console.log(`[build-info] mode=${buildMode} version=${version} → ${outPath}`);
+

package/scripts/generate-snapshot-data.mjs

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+
+/**
+ * 生成V1/V2快照数据脚本
+ * 用于创建一致性测试的输入数据
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.join(__dirname, '..');
+
+// 配置
+const SAMPLES_DIR = path.join(process.env.HOME || '', '.routecodex/codex-samples');
+const OUTPUT_DIR = path.join(projectRoot, 'test-results', 'snapshots');
+const MAX_SAMPLES = 10; // 每个协议的最大样本数
+
+class SnapshotDataGenerator {
+  constructor() {
+    this.samplesGenerated = 0;
+  }
+
+  /**
+   * 生成所有协议的快照数据
+   */
+  async generateAllSnapshots() {
+    console.log('🚀 开始生成V1/V2快照数据');
+    console.log('================================');
+    
+    await fs.mkdir(OUTPUT_DIR, { recursive: true });
+    
+    // 生成OpenAI Chat快照
+    await this.generateOpenAIChatSnapshots();
+    
+    // 生成Anthropic Messages快照
+    await this.generateAnthropicMessagesSnapshots();
+    
+    // 生成Responses快照
+    await this.generateResponsesSnapshots();
+    
+    console.log(`\n✅ 快照生成完成! 总计: ${this.samplesGenerated} 个样本`);
+    console.log(`📁 输出目录: ${OUTPUT_DIR}`);
+  }
+
+  /**
+   * 生成OpenAI Chat快照
+   */
+  async generateOpenAIChatSnapshots() {
+    console.log('\n📋 生成OpenAI Chat快照...');
+    
+    const openaiDir = path.join(SAMPLES_DIR, 'openai-chat');
+    const outputDir = path.join(OUTPUT_DIR, 'openai-chat');
+    
+    try {
+      await fs.mkdir(outputDir, { recursive: true });
+      const files = await fs.readdir(openaiDir);
+      
+      // 按请求ID分组
+      const groups = this.groupFilesByRequestId(files);
+      let count = 0;
+      
+      for (const [requestId, groupFiles] of Object.entries(groups)) {
+        if (count >= MAX_SAMPLES) break;
+        
+        const snapshot = await this.buildSnapshotFromFiles(
+          requestId, 
+          'openai-chat', 
+          groupFiles, 
+          openaiDir
+        );
+        
+        if (snapshot) {
+          const outputPath = path.join(outputDir, `${requestId}.json`);
+          await fs.writeFile(outputPath, JSON.stringify(snapshot, null, 2));
+          console.log(`  ✅ 生成快照: ${requestId}`);
+          count++;
+          this.samplesGenerated++;
+        }
+      }
+      
+      console.log(`  📊 OpenAI Chat: ${count} 个快照`);
+    } catch (error) {
+      console.warn('  ⚠️ 生成OpenAI Chat快照失败:', error.message);
+    }
+  }
+
+  /**
+   * 生成Anthropic Messages快照
+   */
+  async generateAnthropicMessagesSnapshots() {
+    console.log('\n📋 生成Anthropic Messages快照...');
+    
+    const anthropicDir = path.join(SAMPLES_DIR, 'anthropic-messages');
+    const outputDir = path.join(OUTPUT_DIR, 'anthropic-messages');
+    
+    try {
+      await fs.mkdir(outputDir, { recursive: true });
+      const subdirs = await fs.readdir(anthropicDir);
+      
+      let count = 0;
+      for (const subdir of subdirs) {
+        if (count >= MAX_SAMPLES) break;
+        
+        const subdirPath = path.join(anthropicDir, subdir);
+        const stat = await fs.stat(subdirPath);
+        
+        if (stat.isDirectory()) {
+          const files = await fs.readdir(subdirPath);
+          const relevantFiles = files.filter(f => 
+            f.includes('request') || f.includes('response')
+          );
+          
+          const snapshot = await this.buildSnapshotFromFiles(
+            subdir, 
+            'anthropic-messages', 
+            relevantFiles, 
+            subdirPath
+          );
+          
+          if (snapshot) {
+            const outputPath = path.join(outputDir, `${subdir}.json`);
+            await fs.writeFile(outputPath, JSON.stringify(snapshot, null, 2));
+            console.log(`  ✅ 生成快照: ${subdir}`);
+            count++;
+            this.samplesGenerated++;
+          }
+        }
+      }
+      
+      console.log(`  📊 Anthropic Messages: ${count} 个快照`);
+    } catch (error) {
+      console.warn('  ⚠️ 生成Anthropic Messages快照失败:', error.message);
+    }
+  }
+
+  /**
+   * 生成Responses快照
+   */
+  async generateResponsesSnapshots() {
+    console.log('\n📋 生成Responses快照...');
+    
+    const responsesDir = path.join(SAMPLES_DIR, 'openai-responses');
+    const outputDir = path.join(OUTPUT_DIR, 'openai-responses');
+    
+    try {
+      await fs.mkdir(outputDir, { recursive: true });
+      const files = await fs.readdir(responsesDir);
+      
+      const groups = this.groupFilesByRequestId(files);
+      let count = 0;
+      
+      for (const [requestId, groupFiles] of Object.entries(groups)) {
+        if (count >= MAX_SAMPLES) break;
+        
+        const snapshot = await this.buildSnapshotFromFiles(
+          requestId, 
+          'openai-responses', 
+          groupFiles, 
+          responsesDir
+        );
+        
+        if (snapshot) {
+          const outputPath = path.join(outputDir, `${requestId}.json`);
+          await fs.writeFile(outputPath, JSON.stringify(snapshot, null, 2));
+          console.log(`  ✅ 生成快照: ${requestId}`);
+          count++;
+          this.samplesGenerated++;
+        }
+      }
+      
+      console.log(`  📊 Responses: ${count} 个快照`);
+    } catch (error) {
+      console.warn('  ⚠️ 生成Responses快照失败:', error.message);
+    }
+  }
+
+  /**
+   * 按请求ID分组文件
+   */
+  groupFilesByRequestId(files) {
+    const groups = {};
+    
+    for (const file of files) {
+      const match = file.match(/^(req[^_]+)_/); // 匹配请求ID
+      if (match) {
+        const requestId = match[1];
+        if (!groups[requestId]) {
+          groups[requestId] = [];
+        }
+        groups[requestId].push(file);
+      }
+    }
+    
+    return groups;
+  }
+
+  /**
+   * 从文件构建快照数据
+   */
+  async buildSnapshotFromFiles(requestId, protocol, files, dirPath) {
+    try {
+      const v1Data = {};
+      const v2Data = {};
+      let inputRequest = null;
+      let timestamp = '';
+      
+      // 加载并分类文件
+      for (const file of files) {
+        const filePath = path.join(dirPath, file);
+        const content = await fs.readFile(filePath, 'utf-8');
+        const data = JSON.parse(content);
+        
+        // 提取时间戳
+        if (!timestamp) {
+          const timestampMatch = file.match(/(\d{10,13})/);
+          if (timestampMatch) {
+            timestamp = timestampMatch[1];
+          }
+        }
+        
+        // 分类数据
+        if (file.includes('compat-pre')) {
+          v1Data.compatPre = data.data || data;
+        } else if (file.includes('compat-post')) {
+          v1Data.compatPost = data.data || data;
+        } else if (file.includes('provider-request')) {
+          v2Data.providerRequest = {
+            url: data.url,
+            headers: data.headers,
+            body: data.body
+          };
+          if (!inputRequest) {
+            inputRequest = data.body;
+          }
+        } else if (file.includes('provider-response')) {
+          v2Data.providerResponse = data.data || data;
+        } else if (file.includes('request')) {
+          if (!inputRequest) {
+            inputRequest = data.data || data;
+          }
+        } else if (file.includes('response')) {
+          v1Data.finalResponse = data.data || data;
+        }
+      }
+      
+      return {
+        id: requestId,
+        timestamp,
+        protocol,
+        inputRequest,
+        v1Data,
+        v2Data,
+        metadata: {
+          generatedAt: new Date().toISOString(),
+          generator: 'generate-snapshot-data.mjs',
+          version: '1.0.0'
+        }
+      };
+    } catch (error) {
+      console.warn(`    ⚠️ 构建快照失败 ${requestId}:`, error.message);
+      return null;
+    }
+  }
+}
+
+// 主函数
+async function main() {
+  const generator = new SnapshotDataGenerator();
+  await generator.generateAllSnapshots();
+}
+
+// 运行
+if (import.meta.url === `file://\${process.argv[1]}`) {
+  main().catch(console.error);
+}
+
+export { SnapshotDataGenerator };