@jsonstudio/rcc 0.85.9

package/scripts/batch-toolcall-report.mjs

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+// Batch tool-call regression across providers (responses + anthropic)
+// Outputs a JSON report to stdout and prints a summary
+
+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 RESP_SAMPLES_DIR = path.join(os.homedir(), '.routecodex', 'codex-samples', 'openai-responses');
+const RESP_OUT_DIR = path.join(os.homedir(), '.routecodex', 'logs', 'responses-sse');
+const ANTH_OUT_DIR = path.join(os.homedir(), '.routecodex', 'logs', 'anthropic-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 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 extractResponsesConfig(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 && (prov.providerType||'').includes('responses')) 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('responses provider entry missing');
+}
+
+function listRespSamples() {
+  if (!fs.existsSync(RESP_SAMPLES_DIR)) return [];
+  return fs.readdirSync(RESP_SAMPLES_DIR).filter(n => n.endsWith('_provider-request.json'));
+}
+
+function pickRespSampleFor(provCfg) {
+  const files = listRespSamples();
+  const base = String(provCfg.baseUrl||'').replace(/\/$/,'');
+  const host = base.split('://')[1] || base;
+  let matches = files.filter(f => {
+    try {
+      const obj = JSON.parse(fs.readFileSync(path.join(RESP_SAMPLES_DIR, f), 'utf-8'));
+      const url = obj?.data?.url || obj?.url || '';
+      return typeof url === 'string' && url.includes(host);
+    } catch { return false; }
+  });
+  if (!matches.length) matches = files;
+  matches.sort((a, b) => {
+    const aa = fs.readFileSync(path.join(RESP_SAMPLES_DIR, a), 'utf-8');
+    const bb = fs.readFileSync(path.join(RESP_SAMPLES_DIR, b), 'utf-8');
+    const score = txt => (txt.includes('"input"')?10:0)+(txt.includes('"tools"')?2:0)+(txt.includes('function_call_arguments')?1:0);
+    return score(bb)-score(aa);
+  });
+  return matches[0] || null;
+}
+
+async function runResponses(providerId) {
+  const cfgDoc = findProviderConfig(providerId);
+  const provCfg = extractResponsesConfig(cfgDoc, providerId);
+  const baseUrl = String(provCfg.baseUrl||provCfg.baseURL||'').replace(/\/$/,'');
+  const endpoint = String(provCfg.endpoint||'/responses');
+  const apiKey = provCfg?.auth?.apiKey || cfgDoc?.keyVault?.[providerId]?.key1?.value;
+  if (!apiKey) throw new Error('no apikey');
+  const chosen = pickRespSampleFor(provCfg);
+  if (!chosen) throw new Error('no golden sample');
+  const sample = JSON.parse(fs.readFileSync(path.join(RESP_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');
+  const model = provCfg.model || provCfg.modelId || provCfg.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);
+
+  ensureDir(RESP_OUT_DIR);
+  const base = path.join(RESP_OUT_DIR, `${providerId}_batch_${nowStamp()}`);
+  const sseLog = `${base}.sse.log`, jsonOut = `${base}.json`, chatOut = `${base}.chat.json`;
+
+  const headers = { 'Content-Type':'application/json', 'OpenAI-Beta':'responses-2024-12-17', 'Authorization':`Bearer ${apiKey}` };
+  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;
+  return { providerId, family:'responses', status: ok?'ok':'no_toolcall', toolCalls: ok? tc.length: 0, artifacts: { sseLog, jsonOut, chatOut }, sample: chosen };
+}
+
+async function runAnthropic(providerId='glm-anthropic') {
+  const cfgDoc = findProviderConfig(providerId);
+  // pipeline_assembler preferred
+  let baseURL, apiKey, model;
+  try {
+    const p = cfgDoc?.pipeline_assembler?.config?.pipelines?.[0]?.modules?.provider?.config;
+    baseURL = (p?.baseUrl||p?.baseURL||'').replace(/\/$/,''); apiKey = p?.auth?.apiKey; model = p?.model||p?.modelId||p?.defaultModel||'glm-4.6';
+  } catch {}
+  if (!baseURL) {
+    const entry = cfgDoc?.virtualrouter?.providers?.[providerId] || Object.values(cfgDoc?.virtualrouter?.providers||{})[0];
+    baseURL = (entry?.baseURL||'https://api.anthropic.com/v1').replace(/\/$/,'');
+    apiKey = entry?.auth?.apiKey || (Array.isArray(entry?.apiKey)?entry.apiKey[0]:entry?.apiKey);
+    const route = (cfgDoc?.virtualrouter?.routing?.default||[''])[0];
+    model = route?.split('.')?.[1] || 'glm-4.6';
+  }
+  if (!apiKey) throw new Error('no apikey');
+  const codecPath = pathToFileURL(path.join(process.cwd(), 'sharedmodule/llmswitch-core/dist/conversion/codecs/anthropic-openai-codec.js')).href;
+  const { buildAnthropicRequestFromOpenAIChat, buildOpenAIChatFromAnthropic } = await import(codecPath);
+  const chat = { model:'dummy', messages:[{ role:'user', content:'Using tools, call add with {"a":2,"b":3}. Return only a function call.' }], tools:[{ type:'function', function:{ name:'add', description:'add two numbers', parameters:{ type:'object', properties:{ a:{type:'number'}, b:{type:'number'}}, required:['a','b'] } } }], tool_choice:'auto' };
+  const req = buildAnthropicRequestFromOpenAIChat(chat);
+  req.model = model; req.max_tokens = 256; req.stream = true;
+
+  ensureDir(ANTH_OUT_DIR);
+  const base = path.join(ANTH_OUT_DIR, `${providerId}_batch_${nowStamp()}`);
+  const sseLog = `${base}.sse.log`, jsonOut = `${base}.json`, chatOut = `${base}.chat.json`;
+  fs.writeFileSync(`${base}.request.json`, JSON.stringify(req, null, 2));
+  const headers = { 'content-type':'application/json', 'accept':'text/event-stream', 'x-api-key': apiKey, 'anthropic-version':'2023-06-01' };
+  const resp = await fetch(baseURL + '/messages', { method:'POST', headers, body: JSON.stringify(req) });
+  if (!resp.ok || !resp.body) { const t = await resp.text().catch(()=> ''); throw new Error(`HTTP ${resp.status} ${resp.statusText}: ${t}`); }
+  const reader = resp.body.getReader(); const decoder = new TextDecoder(); let buffer=''; const events=[];
+  while (true) { const {value,done} = await reader.read(); if (done) break; const chunk = decoder.decode(value); const lines=(buffer+chunk).split('\n'); buffer=lines.pop()||''; let cur={}; for (const l of lines){const s=l.trim(); if(!s){ if(Object.keys(cur).length){ events.push(cur); cur={}; } continue;} if(s.startsWith('event:')) cur.event=s.slice(6).trim(); else if(s.startsWith('data:')){ const d=s.slice(5).trim(); try{ cur.data=JSON.parse(d);}catch{cur.data={raw:d}} } }
+    if (Object.keys(cur).length) { events.push(cur); cur={}; }
+  }
+  const sseText = events.map(ev => `event: ${ev.event}\n`+`data: ${JSON.stringify(ev.data)}\n\n`).join('');
+  fs.writeFileSync(sseLog, sseText, 'utf-8');
+  const convPath = pathToFileURL(path.join(process.cwd(), 'sharedmodule/llmswitch-core/dist/sse/sse-to-json/anthropic-sse-to-json-converter.js')).href;
+  const { AnthropicSseToJsonConverter } = await import(convPath);
+  async function* gen(){ yield sseText; }
+  const conv = new AnthropicSseToJsonConverter();
+  const message = await conv.convertSseToJson(gen(), { requestId: path.basename(base) });
+  fs.writeFileSync(jsonOut, JSON.stringify(message, null, 2));
+  const chatResp = buildOpenAIChatFromAnthropic({ messages: [message] });
+  fs.writeFileSync(chatOut, JSON.stringify(chatResp, null, 2));
+  const tc = chatResp?.messages?.[0]?.tool_calls || [];
+  const ok = Array.isArray(tc) && tc.length>0;
+  return { providerId, family:'anthropic', status: ok?'ok':'no_toolcall', toolCalls: ok? tc.length: 0, artifacts: { sseLog, jsonOut, chatOut } };
+}
+
+async function main(){
+  const tasks = [
+    { family:'responses', providerId:'fc' },
+    { family:'responses', providerId:'c4m' },
+    { family:'responses', providerId:'fai' },
+    { family:'anthropic', providerId:'glm-anthropic' },
+  ];
+  const report = [];
+  for (const t of tasks) {
+    try {
+      const r = t.family==='responses' ? await runResponses(t.providerId) : await runAnthropic(t.providerId);
+      report.push(r);
+    } catch (e) {
+      report.push({ providerId: t.providerId, family: t.family, status:'error', error: (e?.message||String(e)).slice(0,500) });
+    }
+  }
+  const summary = report.reduce((acc, r)=>{ acc[r.status]=(acc[r.status]||0)+1; return acc; }, {});
+  console.log('[batch-toolcall-report] summary:', summary);
+  console.log(JSON.stringify(report, null, 2));
+}
+
+main().catch(e => { console.error(e); process.exit(1); });

package/scripts/build-core.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const root = process.cwd();
+const skip = String(process.env.ROUTECODEX_SKIP_CORE_BUILD || process.env.SKIP_CORE_BUILD || '').trim().toLowerCase();
+const tsc = path.join(root, 'node_modules', 'typescript', 'bin', 'tsc');
+const proj = path.join(root, 'sharedmodule', 'llmswitch-core', 'tsconfig.json');
+const coreRoot = path.join(root, 'sharedmodule', 'llmswitch-core');
+const outDir = path.join(coreRoot, 'dist');
+const requiredOutputs = [
+  path.join(outDir, 'bridge', 'routecodex-adapter.js'),
+  path.join(outDir, 'conversion', 'hub', 'response', 'provider-response.js')
+];
+
+function fail(msg){ console.error(`[build-core] ${msg}`); process.exit(2); }
+
+function distIsValid() {
+  if (!fs.existsSync(outDir)) return false;
+  return requiredOutputs.every(file => fs.existsSync(file));
+}
+
+function getFileMtime(filePath) {
+  try {
+    return fs.statSync(filePath).mtimeMs || 0;
+  } catch {
+    return 0;
+  }
+}
+
+function walkLatestMtime(entry) {
+  let latest = 0;
+  if (!fs.existsSync(entry)) return latest;
+  const stat = fs.statSync(entry);
+  if (stat.isDirectory()) {
+    const entries = fs.readdirSync(entry, { withFileTypes: true });
+    for (const dirent of entries) {
+      if (dirent.name === 'dist' || dirent.name === 'node_modules' || dirent.name.startsWith('.')) continue;
+      latest = Math.max(latest, walkLatestMtime(path.join(entry, dirent.name)));
+    }
+  } else {
+    latest = Math.max(latest, stat.mtimeMs || 0);
+  }
+  return latest;
+}
+
+function latestSourceMtime() {
+  const candidates = [
+    path.join(coreRoot, 'src'),
+    path.join(coreRoot, 'interpreter'),
+    path.join(coreRoot, 'exporters'),
+    path.join(coreRoot, 'package.json'),
+    path.join(coreRoot, 'tsconfig.json')
+  ];
+  return candidates.reduce((max, candidate) => Math.max(max, walkLatestMtime(candidate)), 0);
+}
+
+function earliestDistMtime() {
+  const times = requiredOutputs.map(getFileMtime).filter(Boolean);
+  if (!times.length) return 0;
+  return Math.min(...times);
+}
+
+function shouldSkipBuild() {
+  if (!distIsValid()) return false;
+  const srcMtime = latestSourceMtime();
+  if (!srcMtime) return false;
+  const distMtime = earliestDistMtime();
+  if (!distMtime) return false;
+  return distMtime >= srcMtime;
+}
+
+if (!fs.existsSync(tsc)) fail('TypeScript not installed in root node_modules. Run npm i.');
+if (!fs.existsSync(proj)) {
+  console.log('[build-core] llmswitch-core source not found under sharedmodule; skip local core build (依赖包将用于运行/打包)');
+  process.exit(0);
+}
+
+// Allow skip via env or if dist already present
+if (skip === '1' || skip === 'true' || skip === 'yes') {
+  console.log('[build-core] skip requested by env (ROUTECODEX_SKIP_CORE_BUILD/SKIP_CORE_BUILD)');
+  process.exit(0);
+}
+if (shouldSkipBuild()) {
+  console.log('[build-core] dist up-to-date; skip rebuild:', outDir);
+  process.exit(0);
+}
+
+console.log('[build-core] Dist missing or invalid, compiling llmswitch-core...');
+
+const res = spawnSync(process.execPath, [tsc, '-p', proj], { stdio: 'inherit' });
+if ((res.status ?? 0) !== 0) {
+  console.error('[build-core] TypeScript build failed for llmswitch-core. Fallback is disabled.');
+  process.exit(res.status ?? 2);
+}
+
+if (!distIsValid()) fail('llmswitch-core dist not produced or missing required outputs');
+console.log('[build-core] llmswitch-core built:', outDir);

package/scripts/check-chat-loop.ts

@@ -0,0 +1,37 @@
+import fs from 'fs';
+import path from 'path';
+
+function readJson(p: string): any { return JSON.parse(fs.readFileSync(p, 'utf-8')); }
+function hostPortOfUrl(u: string): string | null { try { const { host } = new URL(u); return host; } catch { return null; } }
+
+function main() {
+  const configPath = process.argv[2] || path.join(process.cwd(), 'config', 'config.json');
+  if (!fs.existsSync(configPath)) { console.error('[loop-check] config not found:', configPath); process.exit(2); }
+  const m = readJson(configPath);
+  const http = m.httpserver || (m.modules?.httpserver?.config) || {};
+  const selfHost = String(http.host || '0.0.0.0');
+  const selfPort = Number(http.port || 0);
+  const selfKey = selfPort ? `${selfHost}:${selfPort}` : null;
+  const issues: Array<{ providerId: string; baseUrl: string; reason: string }>
+    = [];
+
+  const providers = m.virtualrouter?.providers || m.providers || {};
+  for (const [pid, p] of Object.entries<any>(providers)) {
+    const baseUrl = String(p.baseUrl || p.baseURL || '');
+    if (!baseUrl) continue;
+    const hp = hostPortOfUrl(baseUrl);
+    if (hp && selfKey && (hp === selfKey || hp.startsWith('127.0.0.1:') || hp.startsWith('localhost:'))) {
+      issues.push({ providerId: pid, baseUrl, reason: 'provider baseUrl points to local host/port (potential recursion)' });
+    }
+  }
+
+  console.log('[loop-check] server:', { host: selfHost, port: selfPort });
+  if (issues.length) {
+    console.log('[loop-check] potential recursion risks:', issues);
+    process.exit(1);
+  } else {
+    console.log('[loop-check] no loop risk detected based on baseUrl/port heuristic');
+  }
+}
+
+main();

package/scripts/check-glm-compat.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+async function main() {
+  const rawPath = process.argv[2] || path.join(os.homedir(), '.routecodex', 'codex-samples', 'openai-chat', 'req_1762264740299_ifnozpv3l_raw-request.json');
+  const outDir = process.argv[3] || path.join(process.cwd(), 'test-results', 'glm-compat');
+  await fs.mkdir(outDir, { recursive: true });
+  const rawTxt = await fs.readFile(rawPath, 'utf-8');
+  const raw = JSON.parse(rawTxt);
+  const body = raw.body || raw;
+
+  // Step1: convert to OpenAI-OpenAI via codec (so we get normalized chat shape)
+  const openaiCodecUrl = pathToFileURL(path.join(process.cwd(), 'sharedmodule', 'llmswitch-core', 'dist', 'v2', 'conversion', 'codecs', 'openai-openai-codec.js')).href;
+  const { OpenAIOpenAIConversionCodec } = await import(openaiCodecUrl);
+  const codec = new OpenAIOpenAIConversionCodec({});
+  const profile = { outgoingProtocol: 'openai-chat' };
+  const ctx = { requestId: 'check_glm_' + Date.now(), endpoint: '/v1/chat/completions', entryEndpoint: '/v1/chat/completions', metadata: {} };
+  const openaiReq = await codec.convertRequest(body, profile, ctx);
+
+  // Step2: run GLM compatibility incoming path on the normalized request
+  const glmCompatUrl = pathToFileURL(path.join(process.cwd(), 'dist', 'modules', 'pipeline', 'modules', 'compatibility', 'glm', 'glm-compatibility.js')).href;
+  const { GLMCompatibility } = await import(glmCompatUrl);
+  const compat = new GLMCompatibility({ logger: { logModule: ()=>{}, logError: ()=>{} } });
+  await compat.initialize();
+  const out = await compat.processIncoming(openaiReq, { requestId: ctx.requestId, entryEndpoint: '/v1/chat/completions' });
+
+  const outFile = path.join(outDir, 'glm_compat_request.json');
+  await fs.writeFile(outFile, JSON.stringify(out, null, 2), 'utf-8');
+  console.log('GLM compat request written:', outFile);
+
+  // Quick assertions printed to stdout
+  const tools = Array.isArray(out.tools) ? out.tools : [];
+  const shell = tools.find(t => t?.function?.name === 'shell');
+  const cmdSchema = shell?.function?.parameters?.properties?.command;
+  console.log('[schema] shell.command oneOf:', !!(cmdSchema && cmdSchema.oneOf));
+  console.log('[schema] shell.command.type:', cmdSchema?.type);
+  const msgs = Array.isArray(out.messages) ? out.messages : [];
+  const toolCalls = msgs.filter(m => Array.isArray(m?.tool_calls)).flatMap(m => m.tool_calls);
+  const argTypeSet = new Set(toolCalls.map(tc => typeof tc?.function?.arguments));
+  console.log('[messages] function.arguments types:', Array.from(argTypeSet).join(','));
+}
+
+main().catch(err => { console.error(err); process.exit(1); });
+

package/scripts/claude-e2e-listdir-all.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# E2E: Iterate providers, set anthropic routing to each, and run Claude CLI listdir prompt.
+# Usage:
+#   bash scripts/claude-e2e-listdir-all.sh
+
+set -euo pipefail
+
+CONF="$HOME/.routecodex/config.json"
+READ_CONF="$HOME/.routecodex/config/config.json"
+export CONF READ_CONF
+if [ ! -f "$CONF" ]; then
+  echo "Config not found: $CONF" >&2
+  exit 2
+fi
+
+PROMPT="列出本地文件目录（只输出名称列表）"
+
+# Helper: update anthropic routing to a single target and save
+set_routing() {
+  node - <<'NODE'
+const fs=require('fs'); const p=process.env.CONF;
+const j=JSON.parse(fs.readFileSync(p,'utf8'));
+if(!j.virtualrouter) j.virtualrouter={};
+if(!j.virtualrouter.routing) j.virtualrouter.routing={};
+j.virtualrouter.routing.anthropic=[`${process.env.P}:${process.env.M}.${process.env.K}`.replace(':','.')];
+fs.writeFileSync(p, JSON.stringify(j,null,2));
+console.log('anthropic routing ->', j.virtualrouter.routing.anthropic[0]);
+NODE
+}
+
+# Helper: start server and wait ready
+start_ready() {
+  node scripts/start-verify.mjs --mode bg --timeout 120 || true
+}
+
+# Force Claude env for local proxy
+export ANTHROPIC_BASE_URL="http://127.0.0.1:5520"
+export ANTHROPIC_API_KEY="rcc-proxy-key"
+unset ANTHROPIC_TOKEN ANTHROPIC_AUTH_TOKEN || true
+
+echo "=== Providers from source config ==="
+node - <<'NODE'
+const fs=require('fs'); const p=fs.existsSync(process.env.READ_CONF)?process.env.READ_CONF:process.env.CONF;
+const j=JSON.parse(fs.readFileSync(p,'utf8'));
+const prov=Object.keys(j?.virtualrouter?.providers||{});
+console.log(prov.join('\n'));
+NODE
+
+echo "=== Begin E2E (Claude CLI) ==="
+node - <<'NODE'
+const fs=require('fs'); const p=fs.existsSync(process.env.READ_CONF)?process.env.READ_CONF:process.env.CONF;
+const j=JSON.parse(fs.readFileSync(p,'utf8'));
+const prov=j?.virtualrouter?.providers||{};
+for(const pid of Object.keys(prov)){
+  const models=Object.keys((prov[pid]?.models)||{});
+  if(models.length===0) continue;
+  console.log(`[E2E] ${pid} -> ${models[0]}`);
+}
+NODE
+
+# Iterate providers with first model
+SRC_LIST="$READ_CONF"; [ -f "$SRC_LIST" ] || SRC_LIST="$CONF"
+while IFS= read -r pid; do
+  [ -z "$pid" ] && continue
+  srcc=$READ_CONF; [ -f "$srcc" ] || srcc="$CONF"
+  model=$(jq -r --arg P "$pid" '.virtualrouter.providers[$P].models | keys[0] // empty' "$srcc")
+  [ -z "$model" ] && continue
+  echo "\n-- Testing $pid model=$model"
+  P="$pid" M="$model" K="key1" CONF="$CONF" set_routing >/dev/null
+  start_ready >/dev/null
+  echo "CLAUDE_PROMPT: $PROMPT"
+  # Run Claude CLI; ignore debug EPERM and capture first lines
+  (claude --print "$PROMPT" || true) | head -n 20
+done < <(jq -r '.virtualrouter.providers | keys[]' "$SRC_LIST")
+
+echo "\n=== Done ==="

package/scripts/claude-e2e-listdir-from-list.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# E2E: Read a JSON file containing an array of config file paths, and run Claude listdir test for each.
+# Usage:
+#   bash scripts/claude-e2e-listdir-from-list.sh /path/to/configs.json
+# Optionally override prompt via env: PROMPT="列出本地文件目录（只输出名称列表）"
+
+set -euo pipefail
+
+if [ $# -lt 1 ]; then
+  echo "Usage: $0 <configs.json>" >&2
+  exit 2
+fi
+
+LIST_JSON="$1"
+if [ ! -f "$LIST_JSON" ]; then
+  echo "JSON list not found: $LIST_JSON" >&2
+  exit 2
+fi
+
+PROMPT=${PROMPT:-"列出本地文件目录（只输出名称列表）"}
+
+run_one() {
+  local cfg="$1"
+  echo "\n=== Testing config: $cfg ==="
+  local READY
+  READY=$(node scripts/start-verify.mjs --mode bg --timeout 120 --config "$cfg" || true)
+  echo "$READY" | sed -n '1,1p'
+  local ok=$(echo "$READY" | jq -r .ok 2>/dev/null || echo false)
+  local host=$(echo "$READY" | jq -r .host 2>/dev/null || echo 127.0.0.1)
+  local port=$(echo "$READY" | jq -r .port 2>/dev/null || echo 5520)
+  local pid=$(echo "$READY" | jq -r .pid 2>/dev/null || echo "")
+  if [ "$ok" != "true" ]; then
+    echo "[WARN] Not ready for $cfg" >&2
+    return 0
+  fi
+  export ANTHROPIC_BASE_URL="http://$host:$port"
+  export ANTHROPIC_API_KEY="rcc-proxy-key"
+  unset ANTHROPIC_TOKEN ANTHROPIC_AUTH_TOKEN || true
+  echo "CLAUDE_PROMPT: $PROMPT"
+  claude --version || true
+  (claude --print "$PROMPT" || true) | head -n 40
+  # Graceful shutdown
+  curl -s -X POST "http://$host:$port/shutdown" >/dev/null 2>&1 || true
+  if [ -n "$pid" ]; then kill -TERM "$pid" >/dev/null 2>&1 || true; fi
+}
+
+CFGS=$(jq -r '.[]' "$LIST_JSON" 2>/dev/null || true)
+if [ -z "$CFGS" ]; then
+  echo "No configs in list: $LIST_JSON" >&2
+  exit 1
+fi
+
+echo "$CFGS" | while IFS= read -r cfg; do
+  if [ -f "$cfg" ]; then
+    run_one "$cfg"
+  else
+    echo "[WARN] config not found: $cfg" >&2
+  fi
+done
+
+echo "\n=== All done ==="

package/scripts/claude-e2e-listdir-per-config.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# Run Claude CLI listdir prompt per provider config file, without modifying config.json.
+# Discovers configs under ~/.routecodex/config matching common provider names.
+
+set -euo pipefail
+
+PROMPT=${PROMPT:-"列出本地文件目录（只输出名称列表）"}
+CONF_DIR="$HOME/.routecodex/config"
+
+if [ ! -d "$CONF_DIR" ]; then
+  echo "Config dir not found: $CONF_DIR" >&2
+  exit 2
+fi
+
+discover_configs() {
+  # Discover any files under config dir containing virtualrouter (include backups)
+  rg -l '"virtualrouter"' "$CONF_DIR"/* 2>/dev/null || true
+}
+
+run_one() {
+  local cfg="$1"
+  echo "\n=== Testing config: $cfg ==="
+  # Start server with this config
+  local READY
+  READY=$(node scripts/start-verify.mjs --mode bg --timeout 120 --config "$cfg" || true)
+  echo "$READY" | sed -n '1,1p'
+  local ok=$(echo "$READY" | jq -r .ok 2>/dev/null || echo false)
+  local host=$(echo "$READY" | jq -r .host 2>/dev/null || echo 127.0.0.1)
+  local port=$(echo "$READY" | jq -r .port 2>/dev/null || echo 5520)
+  local pid=$(echo "$READY" | jq -r .pid 2>/dev/null || echo "")
+  if [ "$ok" != "true" ]; then
+    echo "[WARN] Not ready for $cfg" >&2
+    return 0
+  fi
+  # Configure Claude env and run prompt
+  export ANTHROPIC_BASE_URL="http://$host:$port"
+  export ANTHROPIC_API_KEY="rcc-proxy-key"
+  unset ANTHROPIC_TOKEN ANTHROPIC_AUTH_TOKEN || true
+  echo "CLAUDE_PROMPT: $PROMPT"
+  claude --version || true
+  (claude --print "$PROMPT" || true) | head -n 24
+  # Stop server gracefully
+  curl -s -X POST "http://$host:$port/shutdown" >/dev/null 2>&1 || true
+  if [ -n "$pid" ]; then kill -TERM "$pid" >/dev/null 2>&1 || true; fi
+}
+
+# If user provided explicit config file paths as arguments, use them; else discover
+if [ "$#" -gt 0 ]; then
+  for cfg in "$@"; do
+    if [ -f "$cfg" ]; then
+      run_one "$cfg"
+    else
+      echo "[WARN] config not found: $cfg" >&2
+    fi
+  done
+else
+  FILES=( $(discover_configs) )
+  if [ ${#FILES[@]} -eq 0 ]; then
+    echo "No provider-specific configs found under $CONF_DIR; running default ~/.routecodex/config.json"
+    run_one "$HOME/.routecodex/config.json"
+  else
+    for f in "${FILES[@]}"; do
+      run_one "$CONF_DIR/$f"
+    done
+  fi
+fi
+
+echo "\n=== All done ==="

package/scripts/claude-e2e-listdir.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Claude CLI E2E test via RouteCodex (Anthropic endpoint)
+# Usage:
+#   bash scripts/claude-e2e-listdir.sh [prompt]
+# Default prompt: 列出本地文件目录
+
+set -euo pipefail
+
+PROMPT=${1:-"列出本地文件目录"}
+
+# 1) Ensure server is ready (background start + /ready check)
+READY_JSON=$(node scripts/start-verify.mjs --mode bg --timeout 120 || true)
+echo "$READY_JSON" | sed -n '1,1p' >/dev/null
+
+# 2) Configure Claude environment (same as RCC code)
+export ANTHROPIC_BASE_URL=${ANTHROPIC_BASE_URL:-http://127.0.0.1:5520}
+export ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY:-rcc-proxy-key}
+unset ANTHROPIC_TOKEN ANTHROPIC_AUTH_TOKEN || true
+
+echo "[Claude E2E] BASE=$ANTHROPIC_BASE_URL"
+echo "[Claude E2E] PROMPT=$PROMPT"
+
+# 3) Invoke Claude CLI
+claude --version || true
+claude --print "$PROMPT"
+