@jsonstudio/rcc 0.85.9 → 0.89.164

package/scripts/tools/responses-golden-dry-run.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+/**
+ * Dry-run Responses golden samples via debug toolkit (no upstream calls).
+ *
+ * Usage:
+ *   node scripts/tools/responses-golden-dry-run.mjs \
+ *     --dir ~/.routecodex/golden_samples/responses/2025-11-23T04-51-48-919Z \
+ *     --config ~/.routecodex/provider/c4m/config.v1.json \
+ *     --target c4m.gpt-5.1
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import process from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '../..');
+
+function usage(err) {
+  const msg = err ? `❌ ${err}\n` : '';
+  console.log(`${msg}Usage: node scripts/tools/responses-golden-dry-run.mjs --dir <path> [--config path] [--target provider.model] [--session id]`);
+  process.exit(err ? 1 : 0);
+}
+
+function parseArgs() {
+  const argv = process.argv.slice(2);
+  const opts = {
+    dir: null,
+    config: path.join(os.homedir(), '.routecodex', 'provider', 'c4m', 'config.v1.json'),
+    target: 'c4m.gpt-5.1',
+    session: null
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--dir') opts.dir = argv[++i];
+    else if (arg === '--config') opts.config = argv[++i];
+    else if (arg === '--target') opts.target = argv[++i];
+    else if (arg === '--session') opts.session = argv[++i];
+    else if (arg === '--help' || arg === '-h') usage();
+    else usage(`Unknown argument: ${arg}`);
+  }
+  if (!opts.dir) usage('Missing --dir pointing to golden_samples/responses/<timestamp>');
+  return opts;
+}
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function clone(value) {
+  if (typeof globalThis.structuredClone === 'function') {
+    return globalThis.structuredClone(value);
+  }
+  return value ? JSON.parse(JSON.stringify(value)) : value;
+}
+
+function resolveProviderRuntime(configPath, target) {
+  const cfg = readJson(configPath);
+  const [providerId, modelId = 'gpt-5.1'] = target.split('.');
+  const providerDef = cfg?.virtualrouter?.providers?.[providerId];
+  if (!providerDef) throw new Error(`Provider "${providerId}" not found in ${configPath}`);
+  const auth = providerDef.auth || {};
+  const apiKey = auth.apiKey || auth.value || process.env.C4M_API_KEY || process.env.RCC_PROVIDER_KEY;
+  if (!apiKey) throw new Error(`Missing API key for ${providerId} (set in config or env)`);
+const legacyCompatFields = [];
+if (typeof providerDef.compatibility_profile === 'string') legacyCompatFields.push('compatibility_profile');
+if (typeof providerDef.compat === 'string') legacyCompatFields.push('compat');
+if (providerDef.compatibility && typeof providerDef.compatibility === 'object') {
+  if (typeof providerDef.compatibility.profile === 'string') legacyCompatFields.push('compatibility.profile');
+  if (typeof providerDef.compatibility.id === 'string') legacyCompatFields.push('compatibility.id');
+}
+if (legacyCompatFields.length > 0) {
+  throw new Error(
+    `Provider ${providerId} uses legacy compatibility field(s): ${legacyCompatFields.join(
+      ', '
+    )}. Rename to "compatibilityProfile".`
+  );
+}
+const compatProfile =
+  (typeof providerDef.compatibilityProfile === 'string' && providerDef.compatibilityProfile.trim()) || undefined;
+  return {
+    runtimeKey: `${providerId}.golden.${Date.now()}`,
+    providerId,
+    providerKey: `${providerId}.golden`,
+    keyAlias: 'golden',
+    providerType: (providerDef.type || 'responses').toLowerCase(),
+    endpoint: providerDef.baseURL || providerDef.baseUrl || providerDef.endpoint || 'https://api.example.net/v1',
+    auth: { type: 'apikey', value: apiKey },
+    compatibilityProfile: compatProfile,
+    outboundProfile: 'openai-responses',
+    defaultModel: modelId
+  };
+}
+
+function buildMetadata(runtime, requestId, entryEndpoint, stream) {
+  return {
+    requestId,
+    providerId: runtime.providerId,
+    providerKey: runtime.providerKey,
+    providerType: runtime.providerType,
+    providerProtocol: 'openai-responses',
+    routeName: 'golden',
+    target: {
+      providerKey: `${runtime.providerId}.${runtime.keyAlias}.${runtime.defaultModel}`,
+      providerType: runtime.providerType,
+      compatibilityProfile: runtime.compatibilityProfile,
+      runtimeKey: runtime.runtimeKey,
+      modelId: runtime.defaultModel
+    },
+    metadata: {
+      stream,
+      entryEndpoint
+    }
+  };
+}
+
+async function main() {
+  const options = parseArgs();
+  if (!fs.existsSync(options.dir)) usage(`Directory not found: ${options.dir}`);
+  const goldenFile = path.join(options.dir, 'golden-samples.json');
+  if (!fs.existsSync(goldenFile)) usage(`golden-samples.json not found under ${options.dir}`);
+
+  const report = readJson(goldenFile);
+  const samples = Array.isArray(report.samples) ? report.samples : [];
+  if (!samples.length) usage('golden-samples.json has no "samples" entries');
+
+  const runtime = resolveProviderRuntime(options.config, options.target);
+  const { createDebugToolkit } = await import(
+    pathToFileURL(path.join(ROOT, 'dist/debug/index.js')).href
+  );
+  const toolkit = createDebugToolkit({ snapshotDirectory: path.join(ROOT, 'logs', 'debug') });
+  const sessionId = options.session || `golden-${Date.now()}`;
+
+  console.log(`[golden-dry-run] session=${sessionId} samples=${samples.length}`);
+  for (const [index, sample] of samples.entries()) {
+    const payload = sample?.request;
+    if (!payload || typeof payload !== 'object') {
+      console.warn(` - skip sample[${index}] ${sample?.name || 'unnamed'} (missing request)`);
+      continue;
+    }
+    const cloned = clone(payload);
+    if (!cloned.model) cloned.model = runtime.defaultModel;
+    const providerRequest = {
+      data: cloned,
+      metadata: {
+        entryEndpoint: '/v1/responses',
+        stream: cloned.stream === true
+      }
+    };
+    const metadata = buildMetadata(runtime, `golden-${index}-${Date.now()}`, '/v1/responses', cloned.stream === true);
+    const result = await toolkit.dryRunner.runProviderPreprocess({
+      runtime,
+      request: providerRequest,
+      metadata,
+      sessionId,
+      nodeId: `golden.${index}`
+    });
+    const body = result.processed?.data || result.processed;
+    const outPath = path.join(options.dir, `dryrun-${index + 1}.json`);
+    fs.writeFileSync(outPath, JSON.stringify(body, null, 2));
+    console.log(` - sample[${index}] ${sample?.name || 'unnamed'} → ${outPath}`);
+  }
+}
+
+main().catch((error) => {
+  console.error('[responses-golden-dry-run] failed:', error);
+  process.exit(1);
+});

package/scripts/tools/responses-provider-replay.mjs

@@ -201,7 +201,7 @@ async function convertSampleToChat(samplePath, modules) {
   return { chat: deepClone(info.payload), entryEndpoint, payloadKind: 'chat' };
 }
 
-async function initProvider(configPath, target) {
+function resolveProviderRuntime(configPath, target) {
   const config = readJson(configPath);
   const [providerId, modelId = 'gpt-5.1'] = target.split('.');
   const providerDef = config?.virtualrouter?.providers?.[providerId];
@@ -209,20 +209,42 @@ async function initProvider(configPath, target) {
   const auth = providerDef.auth || {};
   const apiKey = auth.apiKey || auth.value || process.env.C4M_API_KEY;
   if (!apiKey) throw new Error(`Missing API key for ${providerId}. set in config or C4M_API_KEY env`);
-  const runtime = {
-    runtimeKey: `${providerId}.replay.${Date.now()}`,
-    providerId,
-    providerKey: `${providerId}.replay`,
-    keyAlias: 'replay',
-    providerType: (providerDef.type || 'responses').toLowerCase(),
+  const legacyCompatFields = [];
+  if (typeof providerDef.compatibility_profile === 'string') legacyCompatFields.push('compatibility_profile');
+  if (typeof providerDef.compat === 'string') legacyCompatFields.push('compat');
+  if (providerDef.compatibility && typeof providerDef.compatibility === 'object') {
+    if (typeof providerDef.compatibility.profile === 'string') legacyCompatFields.push('compatibility.profile');
+    if (typeof providerDef.compatibility.id === 'string') legacyCompatFields.push('compatibility.id');
+  }
+  if (legacyCompatFields.length > 0) {
+    throw new Error(
+      `Provider ${providerId} uses legacy compatibility field(s): ${legacyCompatFields.join(
+        ', '
+      )}. Rename to "compatibilityProfile".`
+    );
+  }
+  const compatProfile =
+    (typeof providerDef.compatibilityProfile === 'string' && providerDef.compatibilityProfile.trim()) || undefined;
+  return {
+    runtime: {
+      runtimeKey: `${providerId}.replay.${Date.now()}`,
+      providerId,
+      providerKey: `${providerId}.replay`,
+      keyAlias: 'replay',
+      providerType: (providerDef.type || 'responses').toLowerCase(),
     endpoint: providerDef.baseURL || providerDef.baseUrl || providerDef.endpoint || 'https://api.example.net/v1',
     auth: { type: 'apikey', value: apiKey },
-    compatibilityProfile: providerDef.compat || 'default',
-    outboundProfile: 'openai-responses',
-    defaultModel: modelId
+    compatibilityProfile: compatProfile,
+      outboundProfile: 'openai-responses',
+      defaultModel: modelId
+    },
+    providerDef
   };
+}
+
+async function initProvider(runtime) {
   const { ProviderFactory } = await import(pathToFileURL(
-    path.join(ROOT, 'dist/modules/pipeline/modules/provider/v2/core/provider-factory.js')
+    path.join(ROOT, 'dist/providers/core/runtime/provider-factory.js')
   ).href);
   const provider = ProviderFactory.createProviderFromRuntime(runtime, {
     logger: {
@@ -238,7 +260,7 @@ async function initProvider(configPath, target) {
   });
   await provider.initialize();
   const runtimeHelpers = await import(pathToFileURL(
-    path.join(ROOT, 'dist/modules/pipeline/modules/provider/v2/core/provider-runtime-metadata.js')
+    path.join(ROOT, 'dist/providers/core/runtime/provider-runtime-metadata.js')
   ).href);
   return { provider, runtime, runtimeHelpers };
 }
@@ -246,7 +268,7 @@ async function initProvider(configPath, target) {
 async function main() {
   const options = parseArgs();
   const modules = await loadCoreModules();
-  const { provider, runtime, runtimeHelpers } = await initProvider(options.config, options.target);
+  const runtime = resolveProviderRuntime(options.config, options.target).runtime;
   try {
     const subject = await convertSampleToChat(options.sample, modules);
     let replayChat = deepClone(subject.chat);
@@ -283,7 +305,7 @@ async function main() {
     };
 
     const requestId = `replay-${Date.now()}`;
-    runtimeHelpers.attachProviderRuntimeMetadata(providerRequest, {
+    const providerMetadata = {
       requestId,
       providerId: runtime.providerId,
       providerKey: runtime.providerKey,
@@ -301,25 +323,39 @@ async function main() {
         stream: responsesRequest.stream === true,
         entryEndpoint: providerRequest.metadata.entryEndpoint
       }
-    });
+    };
 
     if (options.dryRun) {
       console.log('[replay] dry-run preprocess only');
-      const sanitized = await provider.preprocessRequest(providerRequest);
-      console.log(JSON.stringify(sanitized?.data || sanitized, null, 2));
+      const { createDebugToolkit } = await import(pathToFileURL(path.join(ROOT, 'dist/debug/index.js')).href);
+      const toolkit = createDebugToolkit({ snapshotDirectory: path.join(ROOT, 'logs', 'debug') });
+      const result = await toolkit.dryRunner.runProviderPreprocess({
+        runtime,
+        request: providerRequest,
+        metadata: providerMetadata,
+        sessionId: process.env.REPLAY_SESSION_ID || undefined,
+        nodeId: 'provider.replay'
+      });
+      console.log(JSON.stringify(result.processed?.data || result.processed, null, 2));
       return;
     }
 
-    console.log('[replay] sending request to provider…');
-    const response = await provider.processIncoming(providerRequest);
-    console.log('✅ provider responded');
-    const status = response?.status ?? response?.data?.status ?? 'unknown';
-    console.log(` - status: ${status}`);
-    const dumpFile = path.join(process.cwd(), `replay_${requestId}_response.json`);
-    fs.writeFileSync(dumpFile, JSON.stringify(response, null, 2));
-    console.log(` - saved response to ${dumpFile}`);
-  } finally {
-    await provider.cleanup().catch(() => {});
+    const { provider, runtimeHelpers } = await initProvider(runtime);
+    try {
+      runtimeHelpers.attachProviderRuntimeMetadata(providerRequest, providerMetadata);
+      console.log('[replay] sending request to provider…');
+      const response = await provider.processIncoming(providerRequest);
+      console.log('✅ provider responded');
+      const status = response?.status ?? response?.data?.status ?? 'unknown';
+      console.log(` - status: ${status}`);
+      const dumpFile = path.join(process.cwd(), `replay_${requestId}_response.json`);
+      fs.writeFileSync(dumpFile, JSON.stringify(response, null, 2));
+      console.log(` - saved response to ${dumpFile}`);
+    } finally {
+      await provider.cleanup().catch(() => {});
+    }
+  } catch (error) {
+    throw error;
   }
 }
 

package/scripts/tools/sync-ci-goldens.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = path.resolve(__dirname, '../..');
+const TARGET_ROOT = path.join(PROJECT_ROOT, 'samples', 'ci-goldens');
+const SOURCE_ROOT = path.join(os.homedir(), '.routecodex', 'golden_samples', 'new');
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf-8'));
+}
+
+function writeIfChanged(target, content) {
+  const next = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+  if (fs.existsSync(target)) {
+    const prev = fs.readFileSync(target, 'utf-8');
+    if (prev === next) {
+      return false;
+    }
+  }
+  fs.writeFileSync(target, next);
+  return true;
+}
+
+function syncProvider(entryType, providerId) {
+  const sourceDir = path.join(SOURCE_ROOT, entryType, providerId);
+  const requestPath = path.join(sourceDir, 'request.sample.json');
+  if (!fs.existsSync(requestPath)) {
+    console.warn(`[sync-ci-goldens] skip ${entryType}/${providerId}: request.sample.json missing`);
+    return { status: 'skipped' };
+  }
+  const targetDir = path.join(TARGET_ROOT, entryType, providerId);
+  ensureDir(targetDir);
+  const targetRequest = path.join(targetDir, 'request.sample.json');
+  const changedRequest = writeIfChanged(targetRequest, fs.readFileSync(requestPath, 'utf-8'));
+  const sourceMetaPath = path.join(sourceDir, 'meta.json');
+  const targetMeta = path.join(targetDir, 'meta.json');
+  if (fs.existsSync(sourceMetaPath)) {
+    const meta = readJson(sourceMetaPath);
+    meta.source = 'ci-goldens';
+    writeIfChanged(targetMeta, meta);
+  } else if (!fs.existsSync(targetMeta)) {
+    const meta = {
+      providerId,
+      entryType,
+      capturedAt: new Date().toISOString(),
+      source: 'ci-goldens',
+      stageFile: null
+    };
+    writeIfChanged(targetMeta, meta);
+  }
+  return { status: changedRequest ? 'updated' : 'unchanged', targetDir };
+}
+
+function listEntries() {
+  if (!fs.existsSync(SOURCE_ROOT)) {
+    throw new Error(`Source golden samples missing: ${SOURCE_ROOT}`);
+  }
+  const entries = [];
+  for (const entryType of fs.readdirSync(SOURCE_ROOT)) {
+    const entryDir = path.join(SOURCE_ROOT, entryType);
+    if (!fs.statSync(entryDir).isDirectory()) continue;
+    for (const providerId of fs.readdirSync(entryDir)) {
+      const providerDir = path.join(entryDir, providerId);
+      if (!fs.statSync(providerDir).isDirectory()) continue;
+      entries.push({ entryType, providerId });
+    }
+  }
+  return entries;
+}
+
+function usage() {
+  console.log('Usage: node scripts/tools/sync-ci-goldens.mjs [--entry <type>] [--provider <id>]');
+  process.exit(0);
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const filters = { entry: null, provider: null };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--entry') {
+      filters.entry = args[++i] || null;
+    } else if (arg === '--provider') {
+      filters.provider = args[++i] || null;
+    } else if (arg === '--help' || arg === '-h') {
+      usage();
+    } else {
+      console.error(`Unknown argument: ${arg}`);
+      usage();
+    }
+  }
+  return filters;
+}
+
+function main() {
+  const filters = parseArgs();
+  const entries = listEntries().filter((item) => {
+    if (filters.entry && filters.entry !== item.entryType) return false;
+    if (filters.provider && filters.provider !== item.providerId) return false;
+    return true;
+  });
+  if (!entries.length) {
+    console.warn('[sync-ci-goldens] no matching samples found');
+    return;
+  }
+  let updated = 0;
+  let unchanged = 0;
+  for (const item of entries) {
+    const result = syncProvider(item.entryType, item.providerId);
+    if (result.status === 'updated') updated += 1;
+    else if (result.status === 'unchanged') unchanged += 1;
+  }
+  console.log(`[sync-ci-goldens] synced ${entries.length} provider samples (${updated} updated, ${unchanged} unchanged).`);
+}
+
+try {
+  main();
+} catch (error) {
+  console.error('[sync-ci-goldens] failed:', error.message || error);
+  process.exit(1);
+}

package/scripts/update-models.mjs

@@ -1,19 +1,21 @@
 #!/usr/bin/env node
 /**
- * Update provider models from /v1/models endpoint and write into config/config.json
+ * Update provider models from /v1/models endpoint and write into the user's
+ * RouteCodex config (defaults to ~/.routecodex/config.json).
  *
  * Usage:
- *   node scripts/update-models.mjs --provider qwen-provider [--write]
+ *   node scripts/update-models.mjs --provider qwen-provider [--write] [--config path]
  */
 import fs from 'node:fs';
 import path from 'node:path';
 
 function parseArgs(argv){
-  const out={ provider:null, write:false };
+  const out={ provider:null, write:false, config:null };
   for(let i=2;i<argv.length;i++){
     const a=argv[i];
     if((a==='--provider'||a==='-p') && i+1<argv.length){ out.provider=argv[++i]; continue; }
     if(a==='--write'){ out.write=true; continue; }
+    if((a==='--config'||a==='-c') && i+1<argv.length){ out.config=argv[++i]; continue; }
     if(a==='--help'||a==='-h'){ out.help=true; }
   }
   return out;
@@ -21,7 +23,17 @@ function parseArgs(argv){
 
 function readJson(p){ try { return JSON.parse(fs.readFileSync(p,'utf8')); } catch { return null; } }
 function writeJson(p,obj){ fs.writeFileSync(p, JSON.stringify(obj,null,2)); }
-function expandHome(p){ return p.startsWith('~/')? p.replace(/^~\//, `${process.env.HOME||''}/`): p; }
+function expandHome(p){ return p && p.startsWith('~/')? p.replace(/^~\//, `${process.env.HOME||''}/`): p; }
+
+function resolveConfigPath(explicit){
+  const envPath = process.env.ROUTECODEX_CONFIG_PATH || process.env.ROUTECODEX_CONFIG;
+  const fallback = path.join(process.env.HOME || '', '.routecodex', 'config.json');
+  const candidate = expandHome(explicit || envPath || fallback);
+  if (!candidate) {
+    throw new Error('Unable to resolve configuration path');
+  }
+  return path.resolve(candidate);
+}
 
 function findQwenToken(){
   const home=process.env.HOME||'';
@@ -61,11 +73,11 @@ async function fetchModels(baseURL, auth){
 async function main(){
   const args=parseArgs(process.argv);
   if(args.help || !args.provider){
-    console.log('Usage: node scripts/update-models.mjs --provider <provider-id> [--write]');
+    console.log('Usage: node scripts/update-models.mjs --provider <provider-id> [--write] [--config <path>]');
     process.exit(args.help?0:1);
   }
 
-  const cfgPath = path.resolve('config','config.json');
+  const cfgPath = resolveConfigPath(args.config);
   const cfg = readJson(cfgPath);
   if(!cfg){ throw new Error(`Cannot read ${cfgPath}`); }
   const vr = cfg.virtualrouter || {};

package/scripts/vendor-core.mjs

@@ -13,7 +13,8 @@ async function rmrf(p) {
 async function main() {
   const root = process.cwd();
   const sharedDist = path.join(root, 'sharedmodule', 'llmswitch-core', 'dist');
-  const vendorDir = path.join(root, 'vendor', 'rcc-llmswitch-core');
+  const legacyVendorDir = path.join(root, 'vendor', 'rcc-llmswitch-core');
+  const scopedVendorDir = path.join(root, 'vendor', '@jsonstudio', 'llms');
 
   if (!await exists(sharedDist)) {
     console.error('[vendor-core] ERROR: 未找到 sharedmodule/llmswitch-core/dist');
@@ -21,10 +22,14 @@ async function main() {
     process.exit(2);
   }
 
-  if (await exists(vendorDir)) {
-    await rmrf(vendorDir);
+  if (await exists(legacyVendorDir)) {
+    await rmrf(legacyVendorDir);
     console.log('[vendor-core] removed legacy vendor/rcc-llmswitch-core directory');
   }
+  if (await exists(scopedVendorDir)) {
+    await rmrf(scopedVendorDir);
+    console.log('[vendor-core] removed legacy vendor/@jsonstudio/llms directory');
+  }
 
   console.log('[vendor-core] sharedmodule/llmswitch-core/dist 将被直接引用，已停止生成 vendor 副本。');
 }