@jsonstudio/rcc 0.85.9

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

@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+
+/**
+ * Responses provider replay harness.
+ *
+ * 加载 codex 样本 → 转换为 Chat → Responses 请求 → 直接调用 Responses Provider。
+ * 支持替换系统提示词、dry-run 只看 preprocess、或真实发到上游。
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import process from 'node:process';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '../..');
+const CORE_DIST = path.join(ROOT, 'sharedmodule', 'llmswitch-core', 'dist');
+
+const DEFAULT_CONFIG = path.join(os.homedir(), '.routecodex', 'provider', 'c4m', 'config.v1.json');
+const DEFAULT_TARGET = 'c4m.gpt-5.1';
+
+function usage(err) {
+  if (err) console.error(`❌ ${err}`);
+  console.log(`Usage:
+  node scripts/tools/responses-provider-replay.mjs --sample <codex-sample.json>
+      [--config ${DEFAULT_CONFIG}]
+      [--target c4m.gpt-5.1]
+      [--system-source <anthropic-sample.json>]
+      [--entry-endpoint </v1/messages>]
+      [--dry-run]
+      [--dump ./tmp/replay.json]
+`);
+  process.exit(err ? 1 : 0);
+}
+
+function parseArgs() {
+  const argv = process.argv.slice(2);
+  const opts = {
+    sample: null,
+    config: DEFAULT_CONFIG,
+    target: DEFAULT_TARGET,
+    systemSource: null,
+    entryEndpoint: null,
+    dryRun: false,
+    dumpPath: null
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--sample') opts.sample = argv[++i];
+    else if (arg === '--config') opts.config = argv[++i];
+    else if (arg === '--target') opts.target = argv[++i];
+    else if (arg === '--system-source') opts.systemSource = argv[++i];
+    else if (arg === '--entry-endpoint') opts.entryEndpoint = argv[++i];
+    else if (arg === '--dry-run') opts.dryRun = true;
+    else if (arg === '--dump') opts.dumpPath = argv[++i];
+    else if (arg === '--help' || arg === '-h') usage();
+    else usage(`Unknown argument: ${arg}`);
+  }
+  if (!opts.sample) usage('Missing --sample');
+  return opts;
+}
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function looksAnthropic(node) {
+  if (!node || typeof node !== 'object') return false;
+  if (node.protocol === 'anthropic-messages') return true;
+  if (Array.isArray(node.system)) return true;
+  if (Array.isArray(node.messages) && node.messages.some((m) => Array.isArray(m?.content))) return true;
+  if (typeof node.stop_reason === 'string' && typeof node.role === 'string') return true;
+  return false;
+}
+
+function looksResponses(node) {
+  if (!node || typeof node !== 'object') return false;
+  if (node.protocol === 'openai-responses') return true;
+  if (Array.isArray(node.input)) return true;
+  if (typeof node.instructions === 'string') return true;
+  if (node.object === 'response' && Array.isArray(node.output)) return true;
+  return false;
+}
+
+function looksChat(node) {
+  if (!node || typeof node !== 'object') return false;
+  if (Array.isArray(node.messages) && node.messages.every((m) => typeof m?.role === 'string')) return true;
+  return false;
+}
+
+function directPayloadCandidate(doc) {
+  const candidates = [
+    doc?.body?.payload,
+    doc?.body?.request,
+    doc?.body?.data,
+    doc?.payload,
+    doc?.data?.payload,
+    doc?.data?.body,
+    doc?.request?.body,
+    doc?.body
+  ];
+  for (const candidate of candidates) {
+    if (candidate && typeof candidate === 'object') return candidate;
+  }
+  return null;
+}
+
+function bfsFindPayload(doc) {
+  const queue = [doc];
+  const seen = new WeakSet();
+  while (queue.length) {
+    const current = queue.shift();
+    if (!current || typeof current !== 'object') continue;
+    if (seen.has(current)) continue;
+    seen.add(current);
+    if (looksAnthropic(current)) return { payload: current, kind: 'anthropic' };
+    if (looksResponses(current)) return { payload: current, kind: 'responses' };
+    if (looksChat(current)) return { payload: current, kind: 'chat' };
+    for (const value of Object.values(current)) {
+      if (value && typeof value === 'object') queue.push(value);
+    }
+  }
+  return null;
+}
+
+function resolveEntryEndpoint(doc, fallback = '/v1/messages') {
+  return doc?.meta?.endpoint ||
+    doc?.body?.endpoint ||
+    doc?.data?.meta?.entryEndpoint ||
+    doc?.body?.meta?.entryEndpoint ||
+    fallback;
+}
+
+async function loadCoreModules() {
+  const anthPath = path.join(CORE_DIST, 'conversion', 'codecs', 'anthropic-openai-codec.js');
+  const respPath = path.join(CORE_DIST, 'conversion', 'responses', 'responses-openai-bridge.js');
+  const anth = await import(pathToFileURL(anthPath).href);
+  const resp = await import(pathToFileURL(respPath).href);
+  const required = [
+    'buildOpenAIChatFromAnthropic',
+    'buildResponsesRequestFromChat',
+    'buildChatRequestFromResponses',
+    'captureResponsesContext'
+  ];
+  if (typeof anth.buildOpenAIChatFromAnthropic !== 'function') throw new Error('buildOpenAIChatFromAnthropic missing');
+  if (typeof resp.buildResponsesRequestFromChat !== 'function' ||
+      typeof resp.buildChatRequestFromResponses !== 'function' ||
+      typeof resp.captureResponsesContext !== 'function') {
+    throw new Error('Responses bridge helpers missing');
+  }
+  return {
+    buildOpenAIChatFromAnthropic: anth.buildOpenAIChatFromAnthropic,
+    buildResponsesRequestFromChat: resp.buildResponsesRequestFromChat,
+    buildChatRequestFromResponses: resp.buildChatRequestFromResponses,
+    captureResponsesContext: resp.captureResponsesContext
+  };
+}
+
+function deepClone(value) {
+  return value ? JSON.parse(JSON.stringify(value)) : value;
+}
+
+function extractSystemMessages(chat) {
+  const messages = Array.isArray(chat?.messages) ? chat.messages : [];
+  return messages.filter((m) => m && typeof m === 'object' && m.role === 'system')
+    .map((m) => (typeof m.content === 'string' ? m.content : Array.isArray(m.content) ? m.content.join('\n') : ''))
+    .map((text) => text.trim())
+    .filter(Boolean);
+}
+
+function replaceSystemMessages(chat, replacements) {
+  const rest = (Array.isArray(chat?.messages) ? chat.messages : []).filter((m) => m.role !== 'system');
+  const systemEntries = replacements.map((text) => ({ role: 'system', content: text }));
+  return { ...chat, messages: [...systemEntries, ...rest] };
+}
+
+async function convertSampleToChat(samplePath, modules) {
+  const doc = readJson(samplePath);
+  let info = null;
+  const direct = directPayloadCandidate(doc);
+  if (direct && typeof direct === 'object') {
+    if (looksAnthropic(direct)) info = { payload: direct, kind: 'anthropic' };
+    else if (looksResponses(direct)) info = { payload: direct, kind: 'responses' };
+    else if (looksChat(direct)) info = { payload: direct, kind: 'chat' };
+  }
+  if (!info) {
+    info = bfsFindPayload(doc);
+  }
+  if (!info) throw new Error(`无法在样本中找到可识别 payload: ${samplePath}`);
+  const entryEndpoint = resolveEntryEndpoint(doc, info.kind === 'responses' ? '/v1/responses' : '/v1/messages');
+  if (info.kind === 'anthropic') {
+    const chat = modules.buildOpenAIChatFromAnthropic(info.payload);
+    return { chat, entryEndpoint, payloadKind: 'anthropic' };
+  }
+  if (info.kind === 'responses') {
+    const ctx = modules.captureResponsesContext(info.payload, { route: { requestId: `replay-${Date.now()}` } });
+    const { request } = modules.buildChatRequestFromResponses(info.payload, ctx);
+    return { chat: request, entryEndpoint, payloadKind: 'responses' };
+  }
+  return { chat: deepClone(info.payload), entryEndpoint, payloadKind: 'chat' };
+}
+
+async function initProvider(configPath, target) {
+  const config = readJson(configPath);
+  const [providerId, modelId = 'gpt-5.1'] = target.split('.');
+  const providerDef = config?.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;
+  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(),
+    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
+  };
+  const { ProviderFactory } = await import(pathToFileURL(
+    path.join(ROOT, 'dist/modules/pipeline/modules/provider/v2/core/provider-factory.js')
+  ).href);
+  const provider = ProviderFactory.createProviderFromRuntime(runtime, {
+    logger: {
+      logModule: (module, event, data) => {
+        if (process.env.REPLAY_LOG_VERBOSE === '1') console.log(`[${module}] ${event}`, data || '');
+      },
+      logError: (error, ctx) => console.error('[replay] logError', error.message, ctx || {}),
+      logProviderRequest: () => {},
+      logProviderResponse: () => {}
+    },
+    errorHandlingCenter: { handleError: () => {} },
+    debugCenter: { log: () => {} }
+  });
+  await provider.initialize();
+  const runtimeHelpers = await import(pathToFileURL(
+    path.join(ROOT, 'dist/modules/pipeline/modules/provider/v2/core/provider-runtime-metadata.js')
+  ).href);
+  return { provider, runtime, runtimeHelpers };
+}
+
+async function main() {
+  const options = parseArgs();
+  const modules = await loadCoreModules();
+  const { provider, runtime, runtimeHelpers } = await initProvider(options.config, options.target);
+  try {
+    const subject = await convertSampleToChat(options.sample, modules);
+    let replayChat = deepClone(subject.chat);
+    console.log(`[replay] loaded sample ${options.sample}`);
+    console.log(` - entryEndpoint: ${options.entryEndpoint || subject.entryEndpoint}`);
+    console.log(` - payload kind: ${subject.payloadKind}`);
+    console.log(` - existing system prompts: ${extractSystemMessages(replayChat).length}`);
+
+    if (options.systemSource) {
+      const replacement = await convertSampleToChat(options.systemSource, modules);
+      const replacementSystems = extractSystemMessages(replacement.chat);
+      if (!replacementSystems.length) throw new Error(`System source ${options.systemSource} 未找到系统提示`);
+      replayChat = replaceSystemMessages(replayChat, replacementSystems);
+      console.log(` - replaced system prompts using ${options.systemSource} (${replacementSystems.length} blocks)`);
+    }
+
+    if (!replayChat.model) replayChat.model = runtime.defaultModel;
+
+    const { request: responsesRequest } = await modules.buildResponsesRequestFromChat(deepClone(replayChat));
+    if (!responsesRequest || typeof responsesRequest !== 'object') throw new Error('buildResponsesRequestFromChat failed');
+    if (!responsesRequest.model) responsesRequest.model = runtime.defaultModel;
+
+    if (options.dumpPath) {
+      fs.writeFileSync(options.dumpPath, JSON.stringify({ chat: replayChat, responses: responsesRequest }, null, 2));
+      console.log(` - dumped payloads → ${options.dumpPath}`);
+    }
+
+    const providerRequest = {
+      data: responsesRequest,
+      metadata: {
+        entryEndpoint: options.entryEndpoint || subject.entryEndpoint || '/v1/messages',
+        stream: responsesRequest.stream === true
+      }
+    };
+
+    const requestId = `replay-${Date.now()}`;
+    runtimeHelpers.attachProviderRuntimeMetadata(providerRequest, {
+      requestId,
+      providerId: runtime.providerId,
+      providerKey: runtime.providerKey,
+      providerType: runtime.providerType,
+      providerProtocol: 'openai-responses',
+      routeName: 'replay',
+      target: {
+        providerKey: `${runtime.providerId}.${runtime.keyAlias}.${runtime.defaultModel}`,
+        providerType: runtime.providerType,
+        compatibilityProfile: runtime.compatibilityProfile,
+        runtimeKey: runtime.runtimeKey,
+        modelId: runtime.defaultModel
+      },
+      metadata: {
+        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));
+      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(() => {});
+  }
+}
+
+main().catch((error) => {
+  console.error('[responses-provider-replay] failed:', error);
+  process.exit(1);
+});

package/scripts/toon-suite.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+// TOON tool-call probe: sends Chat requests that require arguments.toon, decodes via @toon-format/cli, and summarizes results.
+
+import fetch from 'node-fetch';
+import { spawnSync } from 'node:child_process';
+
+function arg(k, d){ const i=process.argv.indexOf(k); return (i>0 && process.argv[i+1]) ? process.argv[i+1] : d; }
+function flag(k){ return process.argv.includes(k); }
+
+const server = arg('--server', 'http://127.0.0.1:5520');
+const endpoint = arg('--endpoint', '/v1/chat/completions');
+const url = `${server.replace(/\/$/,'')}${endpoint}`;
+const model = arg('--model', 'glm.glm-4.6');
+const doExec = flag('--exec'); // optional local execution (unsafe; whitelist only)
+
+const systemMsg = (
+  '当你使用工具 (tool_calls) 时，将 function.arguments 设为 JSON 字符串，且只包含字段 toon（字符串，多行 TOON）。' +
+  '不要输出其它字段、不要解释。' +
+  '示例：{"toon": "command: bash -lc \'echo ok\'\\nworkdir: .\\n"}。' +
+  '务必返回 tool_calls，并仅填充 arguments.toon。'
+);
+
+const tools = [
+  {
+    type: 'function',
+    function: {
+      name: 'shell_toon',
+      description: 'TOON 参数承载：将所有参数用 TOON 字符串放入 arguments.toon',
+      parameters: {
+        type: 'object',
+        properties: { toon: { type: 'string', description: 'TOON-encoded arguments' } },
+        required: ['toon'],
+        additionalProperties: false
+      }
+    }
+  }
+];
+
+const cases = [
+  {
+    title: 'find_parens_exec',
+    user: "请使用 shell_toon：bash -lc 执行：find . -type f \\( -name '*.md' -o -name '*.txt' \\) -exec basename {} \\; | sort -u | head -n 5。只返回 tool_calls。"
+  },
+  {
+    title: 'awk_regex',
+    user: "请用 shell_toon：bash -lc 执行：printf 'alpha,error\\nbeta,ok\\n' | awk -F, '{ if (\\$2 ~ /error/) print \\$1 }'。只返回 tool_calls。"
+  },
+  {
+    title: 'sed_replace',
+    user: "请用 shell_toon：bash -lc 执行：printf 'a=1\\nb=2\\n' | sed -E 's/([ab])=(\\\\d+)/\\\\1: \\\\2/g'。只返回 tool_calls。"
+  },
+  {
+    title: 'python_heredoc',
+    user: `请用 shell_toon：构造“单行” bash -lc 命令来执行多行 Python。禁止在命令中出现真实换行符；改用 ANSI-C 风格 $'...' 在“一行内”嵌入换行(\\n)。示例（仅示意）：bash -lc $'python3 - <<\'PY\'\\nprint(1)\\nPY'。实际请输出：用 $'...' 方式在一行内执行 python3 - <<'PY' 的多行脚本：\nimport json\nprint(json.dumps({"ok": true, "sum": 1+2+3}))\n并保持整条命令为一行。只返回 tool_calls。`
+  },
+  {
+    title: 'xargs_space',
+    user: "请用 shell_toon：bash -lc 执行：printf 'A B.md\\nC D.md\\n' | xargs -I{} bash -lc 'echo \"{}\" | tr \" \" _'。只返回 tool_calls。"
+  },
+  {
+    title: 'grep_sort_uniq',
+    user: "请用 shell_toon：bash -lc 执行：printf 'a\\nb\\na\\nc\\n' | grep -E '[a-c]' | sort | uniq -c | sort -nr。只返回 tool_calls。"
+  }
+];
+
+function decodeToon(toonStr){
+  const res = spawnSync('npx', ['-y','@toon-format/cli','--decode'], { input: toonStr, encoding: 'utf-8' });
+  if ((res.status ?? 0) !== 0) return { ok: false, error: res.stderr || 'decode failed' };
+  try { const obj = JSON.parse(res.stdout || '{}'); return { ok: true, value: obj }; } catch (e){ return { ok: false, error: 'json parse failed', raw: res.stdout }; }
+}
+
+function safeExec(cmd){
+  const allow = /^(bash\s+-lc\s+).*/s.test(cmd) && /(find|printf|awk|sed|python3|ls|sort|head|uniq|tr)/.test(cmd);
+  if (!allow) return { ok: false, skipped: true };
+  const res = spawnSync('bash', ['-lc', cmd], { encoding: 'utf-8' });
+  return {
+    ok: true,
+    code: res.status ?? 0,
+    stdout: (res.stdout || '').split('\n').slice(0, 20).join('\n'),
+    stderr: (res.stderr || '').split('\n').slice(0, 20).join('\n')
+  };
+}
+
+async function runCase(c){
+  const payload = {
+    model,
+    stream: false,
+    tool_choice: { type: 'function', function: { name: 'shell_toon' } },
+    messages: [ { role: 'system', content: systemMsg }, { role: 'user', content: c.user } ],
+    tools
+  };
+  const res = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload) });
+  let body; try { body = await res.json(); } catch { return { title: c.title, status: 'http_error', note: res.statusText }; }
+  const msg = body?.choices?.[0]?.message;
+  const argStr = msg?.tool_calls?.[0]?.function?.arguments;
+  if (typeof argStr !== 'string') return { title: c.title, status: 'no_arguments' };
+  let argumentsObj; try { argumentsObj = JSON.parse(argStr); } catch { return { title: c.title, status: 'arguments_not_json' }; }
+  const toon = argumentsObj?.toon;
+  if (typeof toon !== 'string' || !toon.trim()) return { title: c.title, status: 'no_toon' };
+  const decoded = decodeToon(toon);
+  if (!decoded.ok) return { title: c.title, status: 'toon_decode_fail', note: decoded.error };
+  const cmd = decoded.value?.command;
+  let execRes = undefined;
+  if (doExec && typeof cmd === 'string' && cmd.trim()) execRes = safeExec(cmd);
+  return { title: c.title, status: 'ok', toon, decoded: decoded.value, exec: execRes };
+}
+
+async function main(){
+  console.log(`TOON probe → ${url} model=${model} exec=${doExec?'on':'off'}`);
+  const results = [];
+  for (const c of cases) {
+    try {
+      const r = await runCase(c);
+      results.push(r);
+      console.log(`\n=== ${c.title} ===`);
+      console.log(`status: ${r.status}`);
+      if (r.status === 'ok') {
+        const preview = String(r.toon).split('\n').slice(0,4).join('\n');
+        console.log('toon:\n' + preview);
+        console.log('decoded:', JSON.stringify(r.decoded));
+        if (r.exec && r.exec.ok) {
+          console.log('exec code:', r.exec.code);
+          console.log('stdout:\n' + r.exec.stdout);
+          if (r.exec.stderr) console.log('stderr:\n' + r.exec.stderr);
+        }
+      } else if (r.note) {
+        console.log('note:', r.note);
+      }
+    } catch (e) {
+      results.push({ title: c.title, status: 'exception', note: e?.message || String(e) });
+      console.log(`\n=== ${c.title} ===`);
+      console.log('status: exception');
+      console.log('note:', e?.message || String(e));
+    }
+  }
+  const ok = results.filter(x=>x.status==='ok').length;
+  console.log('\nSUMMARY:', `${ok}/${results.length} ok`);
+  for (const r of results) console.log(`- ${r.title}: ${r.status}`);
+}
+
+main().catch(e=>{ console.error('fatal:', e?.message || e); process.exit(1); });

package/scripts/update-models.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * Update provider models from /v1/models endpoint and write into config/config.json
+ *
+ * Usage:
+ *   node scripts/update-models.mjs --provider qwen-provider [--write]
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+function parseArgs(argv){
+  const out={ provider:null, write:false };
+  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==='--help'||a==='-h'){ out.help=true; }
+  }
+  return out;
+}
+
+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 findQwenToken(){
+  const home=process.env.HOME||'';
+  const rc=path.join(home,'.routecodex','tokens','qwen-default.json');
+  try{ if(fs.existsSync(rc)) { const t=readJson(rc); if(t && (t.access_token||t.AccessToken)) return t; } }catch{}
+  const dir=path.join(home,'.cli-proxy-api');
+  try{
+    const list=fs.readdirSync(dir).filter(n=>/^qwen-.*\.json$/i.test(n)).sort();
+    for(const f of list){ const t=readJson(path.join(dir,f)); if(t && (t.access_token||t.AccessToken)) return t; }
+  }catch{}
+  return null;
+}
+
+async function fetchModels(baseURL, auth){
+  const headers = { 'Accept':'application/json' };
+  if (auth?.bearer){ headers['Authorization'] = `Bearer ${auth.bearer}`; }
+  const candidates = [];
+  const b=baseURL.replace(/\/?$/,'');
+  candidates.push(`${b}/models`);
+  // DashScope compatible mode fallback
+  if (/\/v1$/.test(b)) candidates.push(b.replace(/\/v1$/, '/compatible-mode/v1') + '/models');
+  candidates.push('https://dashscope.aliyuncs.com/compatible-mode/v1/models');
+  let lastErr=null;
+  for(const url of candidates){
+    try{
+      const res = await fetch(url, { headers });
+      if (!res.ok){ lastErr = new Error(`GET ${url} -> ${res.status}`); continue; }
+      const body = await res.json();
+      const arr = Array.isArray(body?.data) ? body.data : (Array.isArray(body?.models)? body.models: []);
+      const ids = arr.map(it => (typeof it==='string'? it: it?.id)).filter(Boolean);
+      if (ids.length) return [...new Set(ids)].sort();
+    }catch(e){ lastErr = e; }
+  }
+  if (lastErr) throw lastErr; else throw new Error('No models endpoint succeeded');
+}
+
+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]');
+    process.exit(args.help?0:1);
+  }
+
+  const cfgPath = path.resolve('config','config.json');
+  const cfg = readJson(cfgPath);
+  if(!cfg){ throw new Error(`Cannot read ${cfgPath}`); }
+  const vr = cfg.virtualrouter || {};
+  const providers = vr.providers || {};
+  const p = providers[args.provider];
+  if(!p){ throw new Error(`Provider not found in config: ${args.provider}`); }
+  const baseURL = p.baseURL || p.baseUrl || 'https://api.qwen.ai/v1';
+
+  let bearer = null;
+  // Only for qwen: try token files
+  if (/qwen/i.test(args.provider) || /qwen/i.test(baseURL)){
+    const tok = findQwenToken();
+    if(tok) bearer = tok.access_token || tok.AccessToken;
+  }
+  // Otherwise, try apikey in config
+  if(!bearer && Array.isArray(p.apiKey) && p.apiKey[0]){
+    bearer = p.apiKey[0];
+  }
+
+  const models = await fetchModels(baseURL, bearer? { bearer } : null);
+  if(models.length===0){ throw new Error('No models returned by /models'); }
+  console.log(`Fetched ${models.length} models from ${baseURL}/models`);
+  if(!p.models) p.models = {};
+  // reset models to fetched list
+  p.models = Object.fromEntries(models.map(id => [id, {}]));
+  providers[args.provider] = p;
+  cfg.virtualrouter.providers = providers;
+  if(args.write){ writeJson(cfgPath, cfg); console.log(`Updated ${cfgPath}`); }
+}
+
+main().catch(e=>{ console.error(e?.message||String(e)); process.exit(1); });