@jsonstudio/rcc 0.85.9

package/scripts/snapshot-inspect.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+function parseArgs(argv) {
+  const args = { endpoint: null, rid: null };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if ((a === '--endpoint' || a === '-e') && i + 1 < argv.length) { args.endpoint = argv[++i]; continue; }
+    if ((a === '--rid' || a === '-r') && i + 1 < argv.length) { args.rid = argv[++i]; continue; }
+    if (a === '--help' || a === '-h') { args.help = true; }
+  }
+  return args;
+}
+
+function topKeys(obj) {
+  if (!obj || typeof obj !== 'object' || Array.isArray(obj)) return [];
+  return Object.keys(obj).sort();
+}
+
+function hasKey(obj, k) { return !!obj && typeof obj === 'object' && k in obj; }
+
+function summarizeMessages(payload) {
+  const out = { count: 0, roles: {}, hasUser: false };
+  const msgs = Array.isArray(payload?.messages) ? payload.messages : [];
+  out.count = msgs.length;
+  for (const m of msgs) {
+    const r = (m && typeof m.role === 'string') ? m.role : 'unknown';
+    out.roles[r] = (out.roles[r] || 0) + 1;
+    if (r === 'user') out.hasUser = true;
+  }
+  return out;
+}
+
+function diffKeys(a, b) {
+  const A = new Set(a || []); const B = new Set(b || []);
+  const added = [...B].filter(k => !A.has(k));
+  const removed = [...A].filter(k => !B.has(k));
+  return { added, removed };
+}
+
+async function readJson(p) {
+  try {
+    const raw = await fs.readFile(p, 'utf8');
+    return JSON.parse(raw);
+  } catch { return null; }
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.help || !args.rid) {
+    console.log('Usage: node scripts/snapshot-inspect.mjs --rid <RID> [--endpoint <dir>]');
+    console.log('  endpoint: openai-responses | openai-chat | anthropic-messages (auto when omitted)');
+    process.exit(args.help ? 0 : 1);
+  }
+
+  const HOME = process.env.HOME || process.env.USERPROFILE || '';
+  const root = path.join(HOME, '.routecodex', 'codex-samples');
+  const endpoints = args.endpoint ? [args.endpoint] : ['openai-responses','openai-chat','anthropic-messages'];
+  let baseDir = null;
+  for (const ep of endpoints) {
+    const d = path.join(root, ep);
+    try { await fs.access(d); baseDir = d; break; } catch {}
+  }
+  if (!baseDir) {
+    console.error('No endpoint directory found under', root);
+    process.exit(2);
+  }
+
+  const rid = args.rid;
+  const files = [
+    `${rid}_http-request.json`,
+    `${rid}_http-request.parsed.json`,
+    `${rid}_pipeline.llmswitch.request.post.json`,
+    `${rid}_pipeline.compatibility.request.post.json`,
+    `${rid}_pipeline.provider.request.pre.json`,
+    `${rid}_pipeline.provider.response.json`,
+  ];
+
+  const records = [];
+  for (const name of files) {
+    const p = path.join(baseDir, name);
+    const obj = await readJson(p);
+    if (!obj) continue;
+    const keys = topKeys(obj?.data?.payload || obj);
+    const payload = obj?.data?.payload || obj;
+    const msg = summarizeMessages(payload);
+    const flags = {
+      has_data: hasKey(payload, 'data'),
+      has_metadata: hasKey(payload, 'metadata'),
+      has_stream: hasKey(payload, 'stream'),
+      has_messages: hasKey(payload, 'messages'),
+    };
+    records.push({ name, path: p, keys, msg, flags });
+  }
+
+  if (!records.length) {
+    console.error('No snapshots found for RID:', rid, 'under', baseDir);
+    process.exit(3);
+  }
+
+  console.log('Endpoint dir:', baseDir);
+  for (const r of records) {
+    console.log(`\n=== ${r.name} ===`);
+    console.log('- path:', r.path);
+    console.log('- topKeys:', r.keys.join(', ') || '(none)');
+    console.log(`- messages: count=${r.msg.count}, roles=${JSON.stringify(r.msg.roles)}, hasUser=${r.msg.hasUser}`);
+    const suspicious = [];
+    if (r.flags.has_data) suspicious.push('data');
+    if (r.flags.has_metadata) suspicious.push('metadata');
+    if (r.flags.has_stream) suspicious.push('stream');
+    if (suspicious.length) console.log('- suspiciousTopLevel:', suspicious.join(', '));
+  }
+
+  const byName = Object.fromEntries(records.map(r => [r.name, r]));
+  const pairs = [
+    ['llmswitch', 'compatibility'],
+    ['compatibility', 'provider'],
+  ];
+  const resolve = (prefix) => Object.keys(byName).find(k => k.includes(prefix));
+  for (const [a, b] of pairs) {
+    const A = byName[resolve(`${a}.request.post`) || resolve(`${a}.request`)] || byName[resolve(a)] || null;
+    const B = byName[resolve(`${b}.request.pre`) || resolve(`${b}.request`)] || byName[resolve(b)] || null;
+    if (A && B) {
+      const d = diffKeys(A.keys, B.keys);
+      console.log(`\n--- Diff: ${A.name} -> ${B.name} ---`);
+      if (d.added.length) console.log('  added to later:', d.added.join(', '));
+      if (d.removed.length) console.log('  removed in later:', d.removed.join(', '));
+      if (!d.added.length && !d.removed.length) console.log('  (no top-level key changes)');
+    }
+  }
+}
+
+main().catch(err => { console.error(err); process.exit(99); });
+

package/scripts/start-verify.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+/**
+ * Wrapper around install-verify:
+ * - Ensures default mode is `responses`
+ * - Allows existing CLI flags to pass through unchanged
+ */
+
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const args = process.argv.slice(2);
+const hasModeFlag = args.some((arg, idx) => arg === '--mode' && typeof args[idx + 1] === 'string');
+// 默认改为同时验证 Chat + Responses（可以通过 --mode chat/responses/both/all 覆盖）
+const forwarded = hasModeFlag ? args : [...args, '--mode', 'both'];
+
+const target = path.join(__dirname, 'install-verify.mjs');
+const childProcess = (await import('node:child_process')).spawn;
+const child = childProcess(process.execPath, [target, ...forwarded], {
+  stdio: 'inherit',
+  env: process.env,
+  cwd: process.cwd()
+});
+child.on('exit', (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+  } else {
+    process.exit(code ?? 0);
+  }
+});

package/scripts/test-fc-responses.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * Minimal Responses client using the same OpenAI SDK
+ * semantics as tools/responses-debug-client, for testing
+ * upstream /v1/responses SSE behaviour.
+ */
+
+import OpenAI from 'openai';
+
+const baseURL = process.argv[2] || 'https://www.fakercode.top/v1';
+const apiKey =
+  process.argv[3] ||
+  process.env.FC_API_KEY ||
+  process.env.OPENAI_API_KEY ||
+  '';
+
+if (!apiKey) {
+  console.error('FC_API_KEY / OPENAI_API_KEY is required');
+  process.exit(1);
+}
+
+const client = new OpenAI({ apiKey, baseURL });
+
+const payload = {
+  model: process.env.FC_MODEL || 'gpt-5.1',
+  input: [
+    {
+      role: 'user',
+      content: [
+        {
+          type: 'input_text',
+          text: '用一句话说“你好”，不要解释。'
+        }
+      ]
+    }
+  ],
+  stream: true
+};
+
+console.log('BASE_URL', baseURL);
+console.log('MODEL', payload.model);
+
+try {
+  const stream = await client.responses.stream(payload);
+  console.log('STREAM_OK');
+  for await (const event of stream) {
+    console.log('EVENT', JSON.stringify(event));
+  }
+} catch (err) {
+  console.log('STREAM_ERROR');
+  console.log(
+    JSON.stringify(
+      {
+        name: err?.name,
+        message: err?.message,
+        status: err?.status,
+        code: err?.code,
+        type: err?.type,
+        data: err?.response?.data
+      },
+      null,
+      2
+    )
+  );
+  process.exit(1);
+}

package/scripts/test-guidance.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { pathToFileURL } from 'url';
+
+const HOME = os.homedir();
+const base = path.join(HOME, '.routecodex', 'codex-samples');
+const guidanceMod = path.resolve(process.cwd(), 'sharedmodule/llmswitch-core/dist/guidance/index.js');
+
+async function loadGuidance() {
+  const mod = await import(pathToFileURL(guidanceMod).href);
+  const { refineSystemToolGuidance, augmentOpenAITools, augmentAnthropicTools, buildSystemToolGuidance } = mod;
+  return { refineSystemToolGuidance, augmentOpenAITools, augmentAnthropicTools, buildSystemToolGuidance };
+}
+
+function readJsonSafe(p) {
+  try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
+}
+
+function collectFiles(dir) {
+  const out = [];
+  try {
+    for (const name of fs.readdirSync(dir)) {
+      const full = path.join(dir, name);
+      const st = fs.statSync(full);
+      if (st.isFile()) out.push(full);
+    }
+  } catch { /* ignore */ }
+  return out;
+}
+
+function extractRequest(obj) {
+  // Try common capture shapes
+  if (obj && typeof obj === 'object') {
+    if (obj.body && typeof obj.body === 'object') return obj.body;
+    if (obj.data && typeof obj.data === 'object') return obj.data;
+  }
+  return obj;
+}
+
+function hasOpenAITools(tools) {
+  return Array.isArray(tools) && tools.some(t => t && typeof t === 'object' && t.function && typeof t.function === 'object');
+}
+
+function hasAnthropicTools(tools) {
+  return Array.isArray(tools) && tools.some(t => t && typeof t === 'object' && t.input_schema);
+}
+
+async function main() {
+  const { refineSystemToolGuidance, augmentOpenAITools, augmentAnthropicTools } = await loadGuidance();
+  const targets = [
+    path.join(base, 'openai-chat'),
+    path.join(base, 'responses-replay'),
+    path.join(base, 'anth-replay')
+  ];
+
+  let total = 0, refined = 0, augmented = 0;
+
+  for (const d of targets) {
+    const files = collectFiles(d);
+    for (const f of files) {
+      const j = readJsonSafe(f);
+      if (!j) continue;
+      const req = extractRequest(j);
+      if (!req || typeof req !== 'object') continue;
+      total++;
+      // Refine system/instructions
+      try {
+        if (Array.isArray(req.messages) && req.messages.length && req.messages[0]?.role === 'system' && typeof req.messages[0].content === 'string') {
+          const before = req.messages[0].content || '';
+          const after = refineSystemToolGuidance(before);
+          if (after !== before) refined++;
+        } else if (typeof req.instructions === 'string' && req.instructions) {
+          const before = req.instructions;
+          const after = refineSystemToolGuidance(before);
+          if (after !== before) refined++;
+        }
+      } catch { /* ignore */ }
+      // Augment tools
+      try {
+        if (hasOpenAITools(req.tools)) {
+          const before = JSON.stringify(req.tools);
+          const t = augmentOpenAITools(req.tools);
+          const after = JSON.stringify(t);
+          if (after !== before) augmented++;
+        } else if (hasAnthropicTools(req.tools)) {
+          const before = JSON.stringify(req.tools);
+          const t = augmentAnthropicTools(req.tools);
+          const after = JSON.stringify(t);
+          if (after !== before) augmented++;
+        }
+      } catch { /* ignore */ }
+    }
+  }
+
+  console.log(JSON.stringify({ base, scannedDirs: targets, total, refined, augmented }, null, 2));
+}
+
+main().catch((e) => { console.error(e); process.exit(1); });

package/scripts/test-iflow.mjs

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+// iFlow test script with OAuth token lifecycle management + optional tool SSE loop
+// Examples:
+//  - Ensure token then proxy chat: RC_BASE=http://127.0.0.1:5506 node scripts/test-iflow.mjs --mode=proxy --endpoint=/v1/chat/completions
+//  - Ensure token then upstream chat: IFLOW_CLIENT_ID=... node scripts/test-iflow.mjs --mode=upstream
+//  - Responses tool loop (one-shot delta): RC_BASE=http://127.0.0.1:5506 node scripts/test-iflow.mjs --mode=proxy --endpoint=/v1/responses --tools
+
+import fs from 'fs';
+import fsp from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { spawn } from 'child_process';
+
+/**
+ * Options via env/args
+ *  - MODE: proxy | upstream (default: proxy)
+ *  - RC_BASE: default http://127.0.0.1:5506
+ *  - RC_ENDPOINT: default /v1/chat/completions (also supports /v1/responses)
+ *  - IFLOW_MODEL: default gpt-4o-mini
+ *  - TEXT: default "hello from RouteCodex test"
+ *  - CONFIG: RouteCodex user config path (default ~/.routecodex/config/v2/iflow-only.json)
+ *  - tools: flag to run /v1/responses SSE tool loop
+ */
+
+const args = Object.fromEntries(process.argv.slice(2).map(kv => {
+  const m = kv.match(/^--([^=]+)=(.*)$/);
+  if (m) return [m[1], m[2]];
+  if (kv.startsWith('--')) return [kv.slice(2), true];
+  return [kv, true];
+}));
+
+const MODE = String(args.mode || process.env.MODE || 'proxy');
+const RC_BASE = String(process.env.RC_BASE || 'http://127.0.0.1:5506').replace(/\/$/, '');
+const RC_ENDPOINT = String(args.endpoint || process.env.RC_ENDPOINT || '/v1/chat/completions');
+const IFLOW_MODEL = String(process.env.IFLOW_MODEL || 'gpt-4o-mini');
+const TEXT = String(process.env.TEXT || 'hello from RouteCodex test');
+const RUN_TOOLS = !!args.tools;
+const CONFIG_PATH = expandHome(String(process.env.CONFIG || args.config || path.join(os.homedir(), '.routecodex', 'config', 'v2', 'iflow-only.json')));
+
+function expandHome(p) { return p.startsWith('~') ? path.join(os.homedir(), p.slice(1)) : p; }
+
+async function loadIFlowOAuthConfig(configPath) {
+  const raw = await fsp.readFile(configPath, 'utf-8');
+  const j = JSON.parse(raw);
+  const prov = j?.virtualrouter?.providers?.iflow;
+  if (!prov) throw new Error('iflow provider not found in config');
+  const oauth = prov?.oauth?.default || {};
+  return {
+    clientId: process.env.IFLOW_CLIENT_ID || oauth.clientId,
+    deviceCodeUrl: process.env.IFLOW_DEVICE_CODE_URL || oauth.deviceCodeUrl || oauth.device_code_url,
+    tokenUrl: process.env.IFLOW_TOKEN_URL || oauth.tokenUrl,
+    scopes: Array.isArray(oauth.scopes) ? oauth.scopes : (typeof oauth.scope === 'string' ? oauth.scope.split(/[\s,]+/).filter(Boolean) : ['inference']),
+    tokenFile: expandHome(oauth.tokenFile || path.join(os.homedir(), '.routecodex', 'tokens', 'iflow-default.json')),
+    apiBase: prov?.baseURL || 'https://api.iflow.cn/v1'
+  };
+}
+
+async function readToken(file) {
+  try { const txt = await fsp.readFile(file, 'utf-8'); return JSON.parse(txt); } catch { return null; }
+}
+
+async function saveToken(file, tok) {
+  await fsp.mkdir(path.dirname(file), { recursive: true });
+  const withIssued = { ...tok };
+  if (!withIssued.issued_at) withIssued.issued_at = Math.floor(Date.now()/1000);
+  await fsp.writeFile(file, JSON.stringify(withIssued, null, 2), 'utf-8');
+}
+
+function isExpired(tok, skewSec = 60) {
+  const now = Math.floor(Date.now()/1000);
+  const issued = Number(tok.issued_at || 0);
+  const expAt = tok.expires_at ? Number(tok.expires_at) : (tok.expires_in ? issued + Number(tok.expires_in) : 0);
+  if (!expAt) return false; // if unknown, assume valid
+  return now >= (expAt - skewSec);
+}
+
+async function refreshToken(oauth, tok) {
+  if (!tok?.refresh_token) throw new Error('No refresh_token to refresh');
+  const body = new URLSearchParams();
+  body.set('grant_type', 'refresh_token');
+  body.set('client_id', oauth.clientId);
+  body.set('refresh_token', tok.refresh_token);
+  if (process.env.IFLOW_CLIENT_SECRET) body.set('client_secret', process.env.IFLOW_CLIENT_SECRET);
+  const res = await fetch(oauth.tokenUrl, { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body });
+  const text = await res.text();
+  if (!res.ok) throw new Error(`refresh failed ${res.status}: ${text}`);
+  const j = JSON.parse(text);
+  const merged = { ...tok, ...j, issued_at: Math.floor(Date.now()/1000) };
+  if (j.expires_in && !j.expires_at) merged.expires_at = merged.issued_at + Number(j.expires_in);
+  return merged;
+}
+
+async function openBrowser(url) {
+  try {
+    const platform = process.platform;
+    if (platform === 'darwin') spawn('open', [url], { stdio: 'ignore', detached: true }).unref();
+    else if (platform === 'win32') spawn('cmd', ['/c', 'start', '""', url]);
+    else spawn('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
+  } catch { /* ignore */ }
+}
+
+async function deviceCodeFlow(oauth) {
+  const body = new URLSearchParams();
+  body.set('client_id', oauth.clientId);
+  if (oauth.scopes?.length) body.set('scope', oauth.scopes.join(' '));
+  const res = await fetch(oauth.deviceCodeUrl, { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body });
+  const txt = await res.text();
+  if (!res.ok) throw new Error(`device code request failed ${res.status}: ${txt}`);
+  const dc = JSON.parse(txt);
+  const verifyUrl = dc.verification_uri_complete || dc.verification_uri;
+  console.log(`Open this URL to authorize:
+  ${verifyUrl}
+  code: ${dc.user_code || '(auto)'}`);
+  if (verifyUrl) await openBrowser(verifyUrl);
+  const intervalMs = Math.max(5, Number(dc.interval || 5)) * 1000;
+  const deadline = Date.now() + (Number(dc.expires_in || 600) * 1000);
+  while (Date.now() < deadline) {
+    await new Promise(r => setTimeout(r, intervalMs));
+    const poll = new URLSearchParams();
+    poll.set('grant_type', 'urn:ietf:params:oauth:grant-type:device_code');
+    poll.set('device_code', dc.device_code);
+    poll.set('client_id', oauth.clientId);
+    if (process.env.IFLOW_CLIENT_SECRET) poll.set('client_secret', process.env.IFLOW_CLIENT_SECRET);
+    const pr = await fetch(oauth.tokenUrl, { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: poll });
+    const ptxt = await pr.text();
+    if (pr.status === 200) {
+      const tok = JSON.parse(ptxt);
+      tok.issued_at = Math.floor(Date.now()/1000);
+      if (tok.expires_in && !tok.expires_at) tok.expires_at = tok.issued_at + Number(tok.expires_in);
+      return tok;
+    }
+    try {
+      const j = JSON.parse(ptxt);
+      const err = j.error || '';
+      if (err === 'authorization_pending') continue;
+      if (err === 'slow_down') { await new Promise(r => setTimeout(r, 5000)); continue; }
+      throw new Error(`device flow error: ${ptxt}`);
+    } catch {
+      throw new Error(`device flow error: ${ptxt}`);
+    }
+  }
+  throw new Error('device code expired');
+}
+
+async function ensureToken(oauth) {
+  let tok = await readToken(oauth.tokenFile);
+  if (tok && !isExpired(tok)) return tok;
+  if (tok && tok.refresh_token) {
+    try {
+      console.log('[iflow] refreshing token...');
+      tok = await refreshToken(oauth, tok);
+      await saveToken(oauth.tokenFile, tok);
+      return tok;
+    } catch (e) {
+      console.warn(`[iflow] refresh failed: ${e?.message || e}`);
+    }
+  }
+  console.log('[iflow] starting device-code flow to obtain new token...');
+  const newTok = await deviceCodeFlow(oauth);
+  await saveToken(oauth.tokenFile, newTok);
+  return newTok;
+}
+
+async function requestUpstreamChat(oauth, token) {
+  const url = `${oauth.apiBase.replace(/\/$/, '')}/chat/completions`;
+  const payload = { model: IFLOW_MODEL, messages: [{ role: 'user', content: TEXT }], stream: false };
+  const res = await fetch(url, { method: 'POST', headers: { 'Authorization': `Bearer ${token.access_token}`, 'Content-Type': 'application/json' }, body: JSON.stringify(payload) });
+  const body = await res.text();
+  console.log(`[UPSTREAM] status=${res.status}`);
+  try { console.log(JSON.stringify(JSON.parse(body), null, 2)); } catch { console.log(body); }
+}
+
+async function requestProxyChat() {
+  const url = `${RC_BASE}${RC_ENDPOINT}`;
+  const payload = { model: IFLOW_MODEL, messages: [{ role: 'user', content: TEXT }], stream: false };
+  const res = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload) });
+  const body = await res.text();
+  console.log(`[PROXY] ${url} status=${res.status}`);
+  try { console.log(JSON.stringify(JSON.parse(body), null, 2)); } catch { console.log(body); }
+}
+
+async function runResponsesToolLoop() {
+  const url = `${RC_BASE}/v1/responses`;
+  const payload = {
+    model: IFLOW_MODEL,
+    input: [ { type: 'text', text: `${TEXT}. 请使用可用的工具完成任务。` } ],
+    stream: true
+  };
+  const res = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'text/event-stream' }, body: JSON.stringify(payload) });
+  if (!res.ok || !res.body) { console.error(`[RESPONSES] HTTP ${res.status}`); console.log(await res.text()); return; }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = '';
+  let responseId = '';
+  let required = null;
+  console.log('[RESPONSES] streaming...');
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    const chunks = buf.split(/\n\n/);
+    buf = chunks.pop() || '';
+    for (const chunk of chunks) {
+      const lines = chunk.split(/\n/);
+      let ev = '';
+      let data = '';
+      for (const ln of lines) {
+        if (ln.startsWith('event:')) ev = ln.slice(6).trim();
+        if (ln.startsWith('data:')) data += ln.slice(5).trim();
+      }
+      if (!data) continue;
+      try {
+        const j = JSON.parse(data);
+        if (j?.response?.id && !responseId) responseId = j.response.id;
+        if (ev === 'response.required_action' || (j?.type === 'response.required_action')) {
+          required = j;
+        }
+        if (ev === 'response.done' || j?.type === 'response.done') {
+          console.log('[RESPONSES] done');
+        }
+      } catch { /* ignore */ }
+    }
+    if (required && responseId) break; // got required_action
+  }
+  if (!required || !responseId) { console.warn('[RESPONSES] no required_action found'); return; }
+  const toolCalls = required?.response?.required_action?.submit_tool_outputs?.tool_calls || [];
+  console.log(`[RESPONSES] tool_calls: ${toolCalls.length}`);
+  const outputs = toolCalls.map(tc => ({ tool_call_id: tc?.id || tc?.tool_call_id || '', output: 'ok' }));
+  const contUrl = `${RC_BASE}/v1/responses/${encodeURIComponent(responseId)}/submit_tool_outputs`;
+  const contPayload = { model: IFLOW_MODEL, tool_outputs: outputs, stream: true };
+  const cont = await fetch(contUrl, { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'text/event-stream' }, body: JSON.stringify(contPayload) });
+  console.log(`[RESPONSES][CONT] status=${cont.status}`);
+  // Read until response.done or short timeout
+  if (cont.body) {
+    const reader2 = cont.body.getReader();
+    const decoder2 = new TextDecoder();
+    let buf2 = '';
+    const until = Date.now() + 15000; // 15s max
+    let finished = false;
+    while (Date.now() < until) {
+      const { value, done } = await reader2.read();
+      if (done) break;
+      buf2 += decoder2.decode(value, { stream: true });
+      const parts = buf2.split(/\n\n/);
+      buf2 = parts.pop() || '';
+      for (const ch of parts) {
+        const lines = ch.split(/\n/);
+        let ev = '';
+        let data = '';
+        for (const ln of lines) {
+          if (ln.startsWith('event:')) ev = ln.slice(6).trim();
+          if (ln.startsWith('data:')) data += ln.slice(5).trim();
+        }
+        try {
+          const jj = JSON.parse(data);
+          if (ev === 'response.done' || jj?.type === 'response.done') {
+            console.log('[RESPONSES][CONT] done');
+            finished = true;
+            break;
+          }
+        } catch { /* ignore */ }
+      }
+      if (finished) break;
+    }
+    try { await reader2.cancel(); } catch { /* ignore */ }
+  }
+}
+
+async function main() {
+  // 1) Load OAuth config & ensure token freshness before any real request
+  const oauth = await loadIFlowOAuthConfig(CONFIG_PATH);
+  const token = await ensureToken(oauth);
+
+  // 2) Perform requested action
+  if (MODE === 'upstream') {
+    await requestUpstreamChat(oauth, token);
+    return;
+  }
+  if (RUN_TOOLS) {
+    await requestProxyChat(); // warmup
+    await runResponsesToolLoop();
+    return;
+  }
+  await requestProxyChat();
+}
+
+main().catch(err => { console.error(err); process.exit(1); });

package/scripts/test-tool-exec.mjs

@@ -0,0 +1,26 @@
+import { executeTool } from '../dist/server/utils/tool-executor.js';
+
+async function run() {
+  const payloads = [
+    { name: 'string_cmd_readme_head', args: { command: 'find . -type f -name "README*" | head -20' } },
+    { name: 'string_cmd_md_grep', args: { command: 'find . -type f -name "*.md" | grep -i readme | head -20' } },
+    { name: 'argv_cmd_simple', args: { command: ['find', '.', '-type', 'f', '-name', 'README*'] } },
+  ];
+
+  for (const p of payloads) {
+    const argStr = JSON.stringify(p.args);
+    const res = await executeTool({ id: 'test', name: 'shell', args: argStr });
+    console.log('--- case:', p.name, '---');
+    console.log('args:', argStr);
+    if (res.error) {
+      console.log('ERROR:', res.error);
+    } else {
+      const out = (res.output || '').split('\n').slice(0, 10).join('\n');
+      console.log('OK (first 10 lines)');
+      console.log(out);
+    }
+  }
+}
+
+run().catch(e => { console.error(e); process.exit(1); });
+