@jsonstudio/rcc 0.89.683 → 0.89.873

package/scripts/classify-codex-samples.mjs

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+// classify-codex-samples.mjs
+// 按照 Virtual Router classifier 分类 codex 样本
+// 支持 providerKey、工具类型、tool_calls 结构识别
+
+import { readdir, readFile } from 'node:fs/promises';
+import { join, dirname, basename } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SAMPLES_ROOT = join(__dirname, '..', 'samples', 'mock-provider');
+
+// Virtual Router classifier 规则
+const PROVIDER_KEYS = {
+  'glm.default': 'glm',
+  'glm.key1': 'glm',
+  'gemini.default': 'gemini',
+  'openai.default': 'openai',
+  'anthropic.default': 'anthropic',
+  'kimi.key1': 'kimi',
+  'qwen.key1': 'qwen',
+  'iflow.key1': 'iflow',
+  'tab.key1': 'tab',
+  'crs.key1': 'crs',
+  'fai.key1': 'fai',
+  'modelscope.default': 'modelscope',
+  'unknown': 'unknown'
+};
+
+const TOOL_TYPES = {
+  'apply_patch': 'apply_patch',
+  'shell': 'shell_command',
+  'toon': 'toon_tool',
+  'submit_tool_outputs': 'tool_loop',
+  'list_files': 'file_operation',
+  'write_file': 'file_operation',
+  'read_file': 'file_operation'
+};
+
+// 样本分类结果
+class SampleClassifier {
+  constructor() {
+    this.samples = [];
+    this.stats = {
+      total: 0,
+      byProvider: {},
+      byToolType: {},
+      withToolCalls: 0,
+      withToon: 0,
+      errors: 0
+    };
+  }
+
+  // 从路径提取 provider key
+  extractProviderKey(filePath) {
+    const parts = filePath.split('/');
+    const providerPart = parts.find(part => Object.keys(PROVIDER_KEYS).some(key => part.includes(key)));
+    
+    if (!providerPart) return 'unknown';
+    
+    for (const [key, value] of Object.entries(PROVIDER_KEYS)) {
+      if (providerPart.includes(key)) return value;
+    }
+    return 'unknown';
+  }
+
+  // 识别工具类型
+  identifyToolType(toolCall) {
+    const funcName = toolCall.function?.name || '';
+    
+    // 检查 TOON 格式
+    if (this.isToonTool(toolCall)) return 'toon_tool';
+    
+    // 检查已知工具名称
+    for (const [pattern, type] of Object.entries(TOOL_TYPES)) {
+      if (funcName.toLowerCase().includes(pattern)) return type;
+    }
+    
+    // 默认分类
+    if (funcName.includes('patch')) return 'apply_patch';
+    if (funcName.includes('shell')) return 'shell_command';
+    if (funcName.includes('file')) return 'file_operation';
+    
+    return 'unknown_tool';
+  }
+
+  // 检查是否为 TOON 工具
+  isToonTool(toolCall) {
+    const args = toolCall.function?.arguments;
+    if (!args) return false;
+    
+    try {
+      const parsed = JSON.parse(args);
+      return parsed && typeof parsed.toon === 'string';
+    } catch {
+      return false;
+    }
+  }
+
+  // 分析单个样本
+  async analyzeSample(filePath) {
+    try {
+      const content = await readFile(filePath, 'utf-8');
+      const data = JSON.parse(content);
+      
+      const providerKey = this.extractProviderKey(filePath);
+      const sampleId = basename(dirname(filePath)) + '/' + basename(filePath, '.json');
+      
+      let toolCalls = [];
+      let hasToon = false;
+      
+      // 提取 tool_calls
+      if (data.tool_calls) {
+        toolCalls = data.tool_calls;
+      } else if (data.choices?.[0]?.message?.tool_calls) {
+        toolCalls = data.choices[0].message.tool_calls;
+      } else if (data.messages) {
+        // 查找最后一条用户消息中的工具调用
+        const lastMessage = data.messages[data.messages.length - 1];
+        if (lastMessage.tool_calls) {
+          toolCalls = lastMessage.tool_calls;
+        }
+      }
+      
+      // 分析工具调用
+      const toolTypes = [];
+      for (const toolCall of toolCalls) {
+        const toolType = this.identifyToolType(toolCall);
+        toolTypes.push(toolType);
+        
+        if (toolType === 'toon_tool') hasToon = true;
+        
+        // 更新统计
+        this.stats.byToolType[toolType] = (this.stats.byToolType[toolType] || 0) + 1;
+      }
+      
+      const sample = {
+        id: sampleId,
+        provider: providerKey,
+        filePath,
+        hasToolCalls: toolCalls.length > 0,
+        toolTypes,
+        hasToon,
+        toolCallCount: toolCalls.length
+      };
+      
+      this.samples.push(sample);
+      
+      // 更新统计
+      this.stats.total++;
+      this.stats.byProvider[providerKey] = (this.stats.byProvider[providerKey] || 0) + 1;
+      if (toolCalls.length > 0) this.stats.withToolCalls++;
+      if (hasToon) this.stats.withToon++;
+      
+    } catch (error) {
+      console.error(`Error analyzing ${filePath}:`, error.message);
+      this.stats.errors++;
+    }
+  }
+
+  // 递归查找 JSON 文件
+  async findJsonFiles(dir) {
+    const files = [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...await this.findJsonFiles(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith('.json')) {
+        files.push(fullPath);
+      }
+    }
+    
+    return files;
+  }
+
+  // 运行分类
+  async run() {
+    console.log('🔍 开始分析 samples/mock-provider 目录...');
+    
+    const jsonFiles = await this.findJsonFiles(SAMPLES_ROOT);
+    console.log(`📁 找到 ${jsonFiles.length} 个 JSON 文件`);
+    
+    for (const file of jsonFiles) {
+      await this.analyzeSample(file);
+    }
+    
+    this.printResults();
+  }
+
+  // 打印结果
+  printResults() {
+    console.log('\n📊 分类结果统计:');
+    console.log('==================');
+    
+    console.log(`总样本数: ${this.stats.total}`);
+    console.log(`包含工具调用: ${this.stats.withToolCalls}`);
+    console.log(`包含 TOON: ${this.stats.withToon}`);
+    console.log(`错误数: ${this.stats.errors}`);
+    
+    console.log('\n按 Provider 分布:');
+    for (const [provider, count] of Object.entries(this.stats.byProvider)) {
+      console.log(`  ${provider}: ${count}`);
+    }
+    
+    console.log('\n按工具类型分布:');
+    for (const [toolType, count] of Object.entries(this.stats.byToolType)) {
+      console.log(`  ${toolType}: ${count}`);
+    }
+    
+    // 详细样本列表
+    console.log('\n📋 详细样本分类:');
+    console.log('==================');
+    
+    for (const sample of this.samples) {
+      if (sample.hasToolCalls) {
+        console.log(`${sample.provider.padEnd(12)} | ${sample.toolTypes.join(', ').padEnd(20)} | ${sample.id}`);
+      }
+    }
+    
+    // 识别未覆盖场景
+    console.log('\n⚠️  未覆盖场景:');
+    console.log('==================');
+    
+    const hasApplyPatch = this.stats.byToolType['apply_patch'] > 0;
+    const hasToon = this.stats.byToolType['toon_tool'] > 0;
+    const hasShell = this.stats.byToolType['shell_command'] > 0;
+    
+    if (!hasApplyPatch) console.log('  - 缺少 apply_patch 样本');
+    if (!hasToon) console.log('  - 缺少 TOON 工具样本');
+    if (!hasShell) console.log('  - 缺少 shell command 样本');
+    
+    // TOON 样本详情
+    if (this.stats.withToon > 0) {
+      console.log('\n🔧 TOON 工具样本:');
+      const toonSamples = this.samples.filter(s => s.hasToon);
+      for (const sample of toonSamples) {
+        console.log(`  - ${sample.provider}: ${sample.id}`);
+      }
+    }
+  }
+}
+
+// 主函数
+async function main() {
+  const classifier = new SampleClassifier();
+  await classifier.run();
+}
+
+main().catch(console.error);

package/scripts/cleanup-codex-error-samples.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+/**
+ * Cleanup stale Codex error samples so that后续运行只记录新的失败。
+ *
+ * 行为：
+ * - 扫描 ~/.routecodex/codex-samples/openai-responses 下所有 *.json；
+ * - 如果包含以下任一错误模式，则视为“旧错误样本”，移动到归档目录：
+ *   ~/.routecodex/codex-samples-archive/openai-responses
+ *   - "apply_patch verification failed"
+ *   - "failed to parse exec_command arguments"
+ *   - "Instructions are not valid"
+ *
+ * 注意：
+ * - 只做移动（rename），不直接删除文件，方便必要时回溯；
+ * - 归档目录不参与当前 verify:errorsamples/分析脚本。
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+const HOME = os.homedir();
+const RESPONSES_DIR = path.join(HOME, '.routecodex', 'codex-samples', 'openai-responses');
+
+const PATTERNS = [
+  'apply_patch verification failed',
+  'failed to parse exec_command arguments',
+  'Instructions are not valid'
+];
+
+async function listJsonFiles(root) {
+  const entries = await fs.readdir(root);
+  return entries
+    .filter((name) => name.toLowerCase().endsWith('.json'))
+    .map((name) => path.join(root, name));
+}
+
+async function hasErrorPattern(filePath) {
+  const text = await fs.readFile(filePath, 'utf-8');
+  return PATTERNS.some((p) => text.includes(p));
+}
+
+async function main() {
+  try {
+    const st = await fs.stat(RESPONSES_DIR);
+    if (!st.isDirectory()) {
+      console.log('[cleanup-codex-error-samples] no codex-samples directory:', RESPONSES_DIR);
+      return;
+    }
+  } catch {
+    console.log('[cleanup-codex-error-samples] no codex-samples directory:', RESPONSES_DIR);
+    return;
+  }
+
+  const files = await listJsonFiles(RESPONSES_DIR);
+  if (!files.length) {
+    console.log('[cleanup-codex-error-samples] no JSON files under', RESPONSES_DIR);
+    return;
+  }
+
+  console.log(`[cleanup-codex-error-samples] scanning ${files.length} file(s) under ${RESPONSES_DIR}`);
+
+  let removed = 0;
+  for (const file of files) {
+    try {
+      const shouldMove = await hasErrorPattern(file);
+      if (!shouldMove) continue;
+      await fs.unlink(file);
+      removed += 1;
+      if (removed <= 10) {
+        console.log(`  removed: ${path.basename(file)}`);
+      }
+    } catch {
+      // best-effort: skip problematic file
+    }
+  }
+
+  console.log(`[cleanup-codex-error-samples] removed ${removed} file(s) matching error patterns.`);
+  if (removed > 10) {
+    console.log('  (only first 10 shown above)');
+  }
+}
+
+main().catch((error) => {
+  console.error('[cleanup-codex-error-samples] failed:', error);
+  process.exit(99);
+});

package/scripts/compare-codex-rccx.mjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+/**
+ * 黑盒对比：使用 codex-samples 中的一条样本，
+ * 分别通过 RouteCodex(dev) 和 rccx(wasm 引擎) 重放，
+ * 然后对比 HTTP 元数据和基础响应结构。
+ *
+ * 前提：
+ * - 已经有 RouteCodex 服务在某个端口运行（默认 http://127.0.0.1:5555）；
+ * - 已经有 rccx 服务在另一个端口运行（默认 http://127.0.0.1:5556）；
+ * - codex 样本是由 RouteCodex 捕获的 client-request JSON（~/.routecodex/codex-samples/...）。
+ *
+ * 使用方式（示例）：
+ *   node scripts/compare-codex-rccx.mjs \\
+ *     --sample ~/.routecodex/codex-samples/openai-responses/xxx_client-request.json \\
+ *     --route-base http://127.0.0.1:5555 \\
+ *     --rccx-base http://127.0.0.1:5556
+ *
+ * 脚本会调用 scripts/replay-codex-sample.mjs 对同一条样本重放两次：
+ * - label=routecodex，base = --route-base；
+ * - label=rccx，     base = --rccx-base；
+ *
+ * 然后读取各自 runs/<requestId>/<label>/response.* 进行对比。
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const DEFAULT_ROUTE_BASE = process.env.ROUTECODEX_BASE || 'http://127.0.0.1:5555';
+const DEFAULT_RCCX_BASE = process.env.RCCX_BASE || 'http://127.0.0.1:5556';
+const DEFAULT_API_KEY = process.env.ROUTECODEX_API_KEY || 'routecodex-test';
+
+function usage() {
+  console.log(`Usage:
+  node scripts/compare-codex-rccx.mjs --sample <file> [--route-base URL] [--rccx-base URL] [--key TOKEN]
+
+Environment:
+  ROUTECODEX_BASE     默认 RouteCodex 基础 URL (默认 ${DEFAULT_ROUTE_BASE})
+  RCCX_BASE           默认 rccx 基础 URL (默认 ${DEFAULT_RCCX_BASE})
+  ROUTECODEX_API_KEY  默认 API key (默认 ${DEFAULT_API_KEY})
+`);
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = {
+    routeBase: DEFAULT_ROUTE_BASE,
+    rccxBase: DEFAULT_RCCX_BASE,
+    key: DEFAULT_API_KEY,
+    routeLabel: 'routecodex',
+    rccxLabel: 'rccx'
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (a === '--sample') opts.sample = args[++i];
+    else if (a === '--route-base') opts.routeBase = args[++i];
+    else if (a === '--rccx-base') opts.rccxBase = args[++i];
+    else if (a === '--key') opts.key = args[++i];
+    else if (a === '--route-label') opts.routeLabel = args[++i];
+    else if (a === '--rccx-label') opts.rccxLabel = args[++i];
+    else if (a === '--help' || a === '-h') {
+      usage();
+      process.exit(0);
+    } else {
+      console.error(`Unknown arg: ${a}`);
+      usage();
+      process.exit(1);
+    }
+  }
+  if (!opts.sample) {
+    usage();
+    process.exit(1);
+  }
+  return opts;
+}
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function computeRequestId(sample) {
+  return (
+    sample?.requestId ||
+    sample?.data?.meta?.requestId ||
+    sample?.meta?.requestId ||
+    `sample_${Date.now()}`
+  );
+}
+
+function computeRunDir(samplePath, requestId, label) {
+  const baseDir = path.dirname(path.resolve(samplePath));
+  return path.join(baseDir, 'runs', requestId, label);
+}
+
+function runReplay({ base, label, samplePath, key }) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      'scripts/replay-codex-sample.mjs',
+      '--sample',
+      samplePath,
+      '--label',
+      label,
+      '--base',
+      base,
+      '--key',
+      key
+    ];
+    const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
+    const child = spawn(process.execPath, args, {
+      cwd: repoRoot,
+      stdio: 'inherit'
+    });
+    child.on('exit', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`replay-codex-sample failed for label=${label} (exit ${code})`));
+    });
+    child.on('error', (err) => reject(err));
+  });
+}
+
+function loadRunResult(runDir) {
+  const metaPath = path.join(runDir, 'response.meta.json');
+  if (!fs.existsSync(metaPath)) {
+    return { error: `missing response.meta.json in ${runDir}` };
+  }
+  const meta = readJson(metaPath);
+
+  const jsonPath = path.join(runDir, 'response.json');
+  const errorPath = path.join(runDir, 'response.error.txt');
+  const ssePath = path.join(runDir, 'response.sse.ndjson');
+
+  let bodyKind = 'none';
+  let bodySample = null;
+
+  if (fs.existsSync(jsonPath)) {
+    bodyKind = 'json';
+    try {
+      bodySample = readJson(jsonPath);
+    } catch {
+      bodySample = null;
+    }
+  } else if (fs.existsSync(errorPath)) {
+    bodyKind = 'error-text';
+    try {
+      const txt = fs.readFileSync(errorPath, 'utf8');
+      bodySample = txt.slice(0, 1024);
+    } catch {
+      bodySample = null;
+    }
+  } else if (fs.existsSync(ssePath)) {
+    bodyKind = 'sse';
+    try {
+      const txt = fs.readFileSync(ssePath, 'utf8');
+      const lines = txt.split('\n').filter(Boolean);
+      bodySample = lines.slice(0, 5);
+    } catch {
+      bodySample = null;
+    }
+  }
+
+  return { meta, bodyKind, bodySample };
+}
+
+function stableSubset(meta) {
+  if (!meta || typeof meta !== 'object') return null;
+  return {
+    status: meta.status,
+    statusText: meta.statusText,
+    endpoint: meta.endpoint,
+    targetUrl: meta.targetUrl,
+    wantsSse: meta.wantsSse,
+    contentType: meta.headers && meta.headers['content-type'],
+    routeHint:
+      (meta.headers && (meta.headers['x-route-hint'] || meta.headers['X-Route-Hint'])) || undefined
+  };
+}
+
+function stableStringify(value) {
+  return JSON.stringify(
+    value,
+    (key, val) => {
+      if (val && typeof val === 'object' && !Array.isArray(val)) {
+        const out = {};
+        for (const k of Object.keys(val).sort()) {
+          out[k] = val[k];
+        }
+        return out;
+      }
+      return val;
+    }
+  );
+}
+
+async function main() {
+  const opts = parseArgs();
+  const samplePath = path.resolve(opts.sample);
+  const sample = readJson(samplePath);
+  const requestId = computeRequestId(sample);
+
+  console.log(
+    `[compare-codex-rccx] sample=${samplePath} requestId=${requestId} routeBase=${opts.routeBase} rccxBase=${opts.rccxBase}`
+  );
+
+  // RouteCodex 路径
+  console.log('[compare-codex-rccx] ▶ routecodex replay...');
+  await runReplay({
+    base: opts.routeBase,
+    label: opts.routeLabel,
+    samplePath,
+    key: opts.key
+  });
+  const routeRunDir = computeRunDir(samplePath, requestId, opts.routeLabel);
+  const routeResult = loadRunResult(routeRunDir);
+
+  // rccx 路径
+  console.log('[compare-codex-rccx] ▶ rccx replay...');
+  await runReplay({
+    base: opts.rccxBase,
+    label: opts.rccxLabel,
+    samplePath,
+    key: opts.key
+  });
+  const rccxRunDir = computeRunDir(samplePath, requestId, opts.rccxLabel);
+  const rccxResult = loadRunResult(rccxRunDir);
+
+  if (routeResult.error || rccxResult.error) {
+    console.error('[compare-codex-rccx] ❌ missing run artifacts:', {
+      routeRunDir,
+      routeError: routeResult.error || null,
+      rccxRunDir,
+      rccxError: rccxResult.error || null
+    });
+    process.exitCode = 1;
+    return;
+  }
+
+  const routeMeta = stableSubset(routeResult.meta);
+  const rccxMeta = stableSubset(rccxResult.meta);
+
+  const metaEqual = stableStringify(routeMeta) === stableStringify(rccxMeta);
+  const bodyKindEqual = routeResult.bodyKind === rccxResult.bodyKind;
+
+  console.log('[compare-codex-rccx] routecodex.meta =', routeMeta);
+  console.log('[compare-codex-rccx] rccx.meta      =', rccxMeta);
+  console.log('[compare-codex-rccx] routecodex.bodyKind =', routeResult.bodyKind);
+  console.log('[compare-codex-rccx] rccx.bodyKind      =', rccxResult.bodyKind);
+
+  if (!metaEqual || !bodyKindEqual) {
+    console.log('[compare-codex-rccx] ❌ mismatch detected between RouteCodex and rccx');
+    console.log('[compare-codex-rccx] routecodex runDir =', routeRunDir);
+    console.log('[compare-codex-rccx] rccx runDir      =', rccxRunDir);
+    // 为了调试 429 / 系列冷却问题，额外打印一小段 body 样本。
+    console.log('[compare-codex-rccx] routecodex.bodySample =', routeResult.bodySample);
+    console.log('[compare-codex-rccx] rccx.bodySample      =', rccxResult.bodySample);
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log('[compare-codex-rccx] ✅ meta/bodyKind aligned for this sample');
+  console.log('[compare-codex-rccx] routecodex runDir =', routeRunDir);
+  console.log('[compare-codex-rccx] rccx runDir      =', rccxRunDir);
+}
+
+main().catch((err) => {
+  console.error('[compare-codex-rccx] fatal error:', err);
+  process.exitCode = 1;
+});
+

package/scripts/copy-compat-assets.mjs

@@ -17,7 +17,10 @@ async function ensureDir(p) {
 async function main() {
   const PROMPT_SRC = path.resolve(process.cwd(), 'src/config/system-prompts');
   const PROMPT_DIST = path.resolve(process.cwd(), 'dist/config/system-prompts');
+  const CAMOUFOX_SRC = path.resolve(process.cwd(), 'scripts/camoufox');
+  const CAMOUFOX_DIST = path.resolve(process.cwd(), 'dist/scripts/camoufox');
   const promptCopied = [];
+  const camoufoxCopied = [];
   try {
     // copy system prompt artifacts only; provider compat assets are owned by llmswitch-core
     try {
@@ -35,7 +38,22 @@ async function main() {
       if (promptErr && promptErr.code !== 'ENOENT') throw promptErr;
     }
     // 不再复制 provider compat 资产；兼容层由 sharedmodule/llmswitch-core 提供
+    try {
+      for await (const file of walk(CAMOUFOX_SRC)) {
+        const stats = await fs.stat(file);
+        if (stats.isFile()) {
+          const rel = path.relative(CAMOUFOX_SRC, file);
+          const dest = path.join(CAMOUFOX_DIST, rel);
+          await ensureDir(path.dirname(dest));
+          await fs.copyFile(file, dest);
+          camoufoxCopied.push(rel);
+        }
+      }
+    } catch (camoufoxErr) {
+      if (camoufoxErr && camoufoxErr.code !== 'ENOENT') throw camoufoxErr;
+    }
     console.log(`[copy-compat-assets] prompts copied: ${promptCopied.length}`);
+    console.log(`[copy-compat-assets] camoufox assets copied: ${camoufoxCopied.length}`);
   } catch (err) {
     console.error('[copy-compat-assets] failed:', err?.message || String(err));
     process.exit(1);

package/scripts/install-release.sh

@@ -85,7 +85,7 @@ else
 fi
 
 verify_server_request() {
-  local VERIFY_CONFIG=${ROUTECODEX_INSTALL_VERIFY_CONFIG:-"$HOME/.routecodex/provider/glm/config.v1.json"}
+  local VERIFY_CONFIG=${ROUTECODEX_INSTALL_VERIFY_CONFIG:-"$HOME/.routecodex/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/local-replay-openai-response.mjs

@@ -25,7 +25,7 @@ async function main() {
   const payload = obj?.data || obj; // accept wrapped
   const requestId = (obj?.requestId) || `replay_${Date.now()}`;
 
-  const codecUrl = pathToFileURL(path.join(process.cwd(), 'sharedmodule', 'llmswitch-core', 'dist', 'v2', 'conversion', 'codecs', 'openai-openai-codec.js')).href;
+  const codecUrl = pathToFileURL(path.join(process.cwd(), 'sharedmodule', 'llmswitch-core', 'dist', 'conversion', 'codecs', 'openai-openai-codec.js')).href;
   const { OpenAIOpenAIConversionCodec } = await import(codecUrl);
   const codec = new OpenAIOpenAIConversionCodec({});
   const profile = { outgoingProtocol: 'openai-chat' };
@@ -38,4 +38,3 @@ async function main() {
 }
 
 main().catch(err => { console.error(err); process.exit(1); });
-

package/scripts/pack-mode.mjs

@@ -77,14 +77,24 @@ try {
       '@jsonstudio/llms': llmsVersion
     };
   } else if (isRccx) {
-    // rccx: wasm-backed llms 核心，使用 dev 配置，不强制切换 release llms。
+    // rccx: wasm-backed llms 核心，通过 npm alias 将 @jsonstudio/llms 指向 wasm 引擎包。
     mutated.bundledDependencies = [];
     mutated.bundleDependencies = [];
-    mutated.dependencies = {
-      ...(original.dependencies || {}),
-      ajv: original.dependencies?.ajv || '^8.17.1',
-      zod: original.dependencies?.zod || '^3.23.8'
-    };
+
+    const deps = { ...(original.dependencies || {}) };
+    // 移除原有 TS 版 llms 直连依赖
+    if (deps['@jsonstudio/llms']) {
+      delete deps['@jsonstudio/llms'];
+    }
+    // 推断 wasm 引擎版本，若未声明则使用本地 llms-engine 缺省版本
+    const engineVersion = deps['@jsonstudio/llms-engine'] || '^0.3.0';
+    deps['@jsonstudio/llms-engine'] = engineVersion;
+    // 通过 npm alias 保持 import 形状不变
+    deps['@jsonstudio/llms'] = `npm:@jsonstudio/llms-engine@${engineVersion}`;
+    deps.ajv = deps.ajv || '^8.17.1';
+    deps.zod = deps.zod || '^3.23.8';
+
+    mutated.dependencies = deps;
   }
   fs.writeFileSync(pkgPath, JSON.stringify(mutated, null, 2));