@jsonstudio/rcc 0.89.1348 → 0.89.1488

package/scripts/tools-dev/responses-debug-client/src/index.ts

@@ -0,0 +1,281 @@
+#!/usr/bin/env tsx
+/**
+ * Responses Debug Client
+ * - Connects to RCC server (baseURL) using OpenAI SDK Responses stream
+ * - Consumes SSE named events, prints concise logs
+ * - Completes a minimal tool-calls loop by executing local tools and submitting outputs
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import OpenAI from 'openai';
+
+type Unknown = Record<string, any>;
+
+function parseArgs(argv: string[]): Record<string, string | boolean> {
+  const out: Record<string, string | boolean> = {};
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a) continue;
+    if (a.startsWith('--')) {
+      const [k, v] = a.split('=');
+      const key = k.replace(/^--/, '');
+      if (typeof v === 'string' && v.length) out[key] = v;
+      else if (i + 1 < argv.length && !argv[i + 1].startsWith('--')) { out[key] = argv[++i]; }
+      else out[key] = true;
+    }
+  }
+  return out;
+}
+
+function short(s: string, n = 60): string {
+  if (s.length <= n) return s;
+  return s.slice(0, n) + '…';
+}
+
+function nowIso(): string { return new Date().toISOString(); }
+
+async function readJson(file: string): Promise<Unknown> {
+  const abs = path.isAbsolute(file) ? file : path.resolve(process.cwd(), file);
+  const raw = await fs.readFile(abs, 'utf-8');
+  return JSON.parse(raw) as Unknown;
+}
+
+type ToolOutput = { tool_call_id: string; output: string };
+
+function safeJsonParse(s: string): any {
+  try { return JSON.parse(s); } catch { return s; }
+}
+
+// Minimal local tool handlers
+const localTools: Record<string, (args: any) => Promise<string> | string> = {
+  echo: (args: any) => {
+    if (typeof args?.text === 'string') return String(args.text);
+    return typeof args === 'string' ? args : JSON.stringify(args ?? {});
+  },
+  sum: (args: any) => {
+    const arr = Array.isArray(args?.numbers) ? args.numbers : [];
+    const total = arr.reduce((a: number, b: any) => a + (typeof b === 'number' ? b : 0), 0);
+    return String(total);
+  },
+  time: () => new Date().toISOString(),
+};
+
+async function executeTool(name: string, argStr: string): Promise<string> {
+  const n = String(name || '').trim();
+  const handler = localTools[n] || (async () => `Unsupported tool: ${n}`);
+  const args = typeof argStr === 'string' ? safeJsonParse(argStr) : argStr;
+  try { return await handler(args); } catch (e: any) { return `Tool error: ${e?.message || String(e)}`; }
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  const file = String(args.file || args.f || '');
+  if (!file) {
+    console.error('Usage: tsx scripts/tools-dev/responses-debug-client/src/index.ts --file <payload.json> [--baseURL URL] [--apiKey KEY] [--timeout 120] [--raw] [--save] [--maxRounds 3]');
+    process.exit(1);
+  }
+  const baseURL = String(args.baseURL || 'http://127.0.0.1:5520/v1');
+  const apiKey = String(args.apiKey || 'dummy');
+  const timeoutSec = Number(args.timeout || 120);
+  const raw = !!args.raw;
+  const save = !!args.save;
+  const maxRounds = Math.max(1, Number(args.maxRounds || 3));
+
+  const reqBody = await readJson(file);
+  if (reqBody.stream == null) reqBody.stream = true;
+
+  // Attach a client-side request id into payload.metadata for correlation
+  const clientRequestId = `cli_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    const meta = (reqBody && typeof reqBody === 'object' && (reqBody as any).metadata && typeof (reqBody as any).metadata === 'object')
+      ? (reqBody as any).metadata : {};
+    (reqBody as any).metadata = { ...meta, client_request_id: clientRequestId };
+  } catch { /* ignore */ }
+
+  // Snapshot exact client request body to ~/.routecodex/codex-samples/responses-client/
+  try {
+    const home = process.env.HOME || process.env.USERPROFILE || '.';
+    const dir = path.join(String(home), '.routecodex', 'codex-samples', 'responses-client');
+    await fs.mkdir(dir, { recursive: true });
+    const out = path.join(dir, `${clientRequestId}_client-request.json`);
+    await fs.writeFile(out, JSON.stringify({
+      timestamp: new Date().toISOString(),
+      baseURL,
+      request: reqBody
+    }, null, 2), 'utf-8');
+    if (!raw) console.log(`[${nowIso()}] saved client snapshot: ${out}`);
+  } catch { /* non-blocking */ }
+
+  const client = new OpenAI({ apiKey, baseURL });
+  const start = Date.now();
+  console.log(`[${nowIso()}] connect baseURL=${baseURL}`);
+
+  const stream: any = await client.responses.stream(reqBody as any);
+  let responseId = '';
+  let model = '';
+  let round = 1;
+  const textBuf: string[] = [];
+
+  // tool state
+  const toolArgs: Record<string, string> = {};
+  const toolMeta: Record<string, { name?: string; output_index?: number; type?: string }> = {};
+  let sawRequiredAction = false;
+  let submittedThisRound = false;
+  const seqCheck = { last: -1 };
+
+  const writeLine = async (o: any) => {
+    if (!save) return;
+    try {
+      const dir = path.resolve(process.cwd(), 'logs', 'responses-debug', responseId || 'unknown');
+      await fs.mkdir(dir, { recursive: true });
+      await fs.appendFile(path.join(dir, 'events.jsonl'), JSON.stringify({ ts: Date.now(), ...o }) + '\n', 'utf-8');
+    } catch { /* ignore */ }
+  };
+
+  const submitToolOutputs = async (requiredAction: any) => {
+    const tc = Array.isArray(requiredAction?.submit_tool_outputs?.tool_calls)
+      ? requiredAction.submit_tool_outputs.tool_calls : [];
+    const outputs: ToolOutput[] = [];
+    for (const call of tc) {
+      const id = String(call?.id || '');
+      const name = String(call?.function?.name || '');
+      const argStr = String(call?.function?.arguments || '');
+      const out = await executeTool(name, argStr);
+      outputs.push({ tool_call_id: id, output: out });
+      console.log(` ↳ tool[${name}] id=${id} -> output(${out.length})`);
+    }
+    if (typeof stream.submitToolOutputs === 'function') {
+      console.log(` -> submitToolOutputs(${outputs.length}) via stream`);
+      await stream.submitToolOutputs({ tool_outputs: outputs, stream: true });
+      return;
+    }
+    throw new Error('SDK stream.submitToolOutputs unavailable; please upgrade openai package');
+  };
+
+  const dumpEvent = (ev: any) => {
+    const t = ev?.type || 'event';
+    const d = ev?.data ?? ev;
+    const seq = typeof d?.sequence_number === 'number' ? d.sequence_number : undefined;
+    if (typeof seq === 'number') {
+      if (seq <= seqCheck.last) console.warn(` ! sequence rollback: ${seqCheck.last} -> ${seq}`);
+      seqCheck.last = seq;
+    }
+    if (raw) console.log('evt', t, JSON.stringify(d));
+  };
+
+  for await (const ev of stream) {
+    await writeLine({ type: ev?.type || 'event', data: ev });
+    dumpEvent(ev);
+
+    switch (ev?.type) {
+      case 'response.created': {
+        responseId = String(ev?.data?.response?.id || responseId);
+        model = String(ev?.data?.response?.model || model);
+        console.log(`created id=${responseId} model=${model}`);
+        break;
+      }
+      case 'response.in_progress': {
+        break;
+      }
+      case 'response.output_text.delta': {
+        const s = String(ev?.data?.delta || '');
+        textBuf.push(s);
+        console.log(` textΔ(${s.length}): ${short(s)}`);
+        break;
+      }
+      case 'response.output_text.done': {
+        console.log(` text✓ (total=${textBuf.join('').length})`);
+        break;
+      }
+      case 'response.output_item.added': {
+        const item = ev?.data?.item || {};
+        const id = String(item?.id || '');
+        toolMeta[id] = { name: item?.name, output_index: ev?.data?.output_index, type: item?.type };
+        toolArgs[id] = toolArgs[id] || '';
+        console.log(` tool+ id=${id} name=${item?.name || ''}`);
+        break;
+      }
+      case 'response.function_call_arguments.delta': {
+        const id = String(ev?.data?.id || ev?.data?.item_id || '');
+        const d = String(ev?.data?.delta || '');
+        toolArgs[id] = (toolArgs[id] || '') + d;
+        console.log(` argsΔ id=${id} (+${d.length})`);
+        break;
+      }
+      case 'response.function_call_arguments.done': {
+        const id = String(ev?.data?.id || ev?.data?.item_id || '');
+        const total = (toolArgs[id] || '').length;
+        console.log(` args✓ id=${id} (${total})`);
+        break;
+      }
+      case 'response.output_item.done': {
+        const item = ev?.data?.item || {};
+        const id = String(item?.id || '');
+        console.log(` tool✓ id=${id}`);
+        // Fallback path for providers不发 required_action：在 function_call 完成后立即提交工具输出
+        if (!sawRequiredAction && !submittedThisRound && (toolMeta[id]?.type === 'function_call')) {
+          const name = toolMeta[id]?.name || item?.name || '';
+          const argStr = item?.arguments || toolArgs[id] || '';
+          const outputs: ToolOutput[] = [{ tool_call_id: id, output: await executeTool(name, String(argStr)) }];
+          if (typeof stream.submitToolOutputs === 'function') {
+            console.log(` -> submitToolOutputs(fallback, ${outputs.length}) via stream [round ${round}]`);
+            await stream.submitToolOutputs({ tool_outputs: outputs, stream: true });
+            submittedThisRound = true;
+            round++;
+            if (round > maxRounds) throw new Error(`Exceeded maxRounds=${maxRounds}`);
+          }
+        }
+        break;
+      }
+      case 'response.required_action': {
+        const ra = ev?.data?.required_action || ev?.data; // SDK shape varies
+        const count = Array.isArray(ra?.submit_tool_outputs?.tool_calls) ? ra.submit_tool_outputs.tool_calls.length : 0;
+        console.log(` required_action submit_tool_outputs(${count}) [round ${round}]`);
+        sawRequiredAction = true;
+        await submitToolOutputs(ra);
+        round++;
+        if (round > maxRounds) throw new Error(`Exceeded maxRounds=${maxRounds}`);
+        break;
+      }
+      case 'response.completed': {
+        const u = ev?.data?.response?.usage || {};
+        const iu = Number(u?.input_tokens || 0);
+        const ou = Number(u?.output_tokens || 0);
+        const tt = Number(u?.total_tokens || 0);
+        console.log(` completed usage: in=${iu} out=${ou} total=${tt}`);
+        // Reset per-round flags to allow下一轮
+        submittedThisRound = false;
+        sawRequiredAction = false;
+        break;
+      }
+      case 'response.error': {
+        console.error(' error:', ev?.data?.error);
+        process.exitCode = 2;
+        break;
+      }
+      case 'response.done': {
+        const ms = Date.now() - start;
+        console.log(` done in ${ms} ms`);
+        return;
+      }
+      default: {
+        // Heartbeat or unknown event
+        const d = ev?.data;
+        if (d && typeof d === 'object' && d.type === 'heartbeat') {
+          // ignore
+        } else if (!raw) {
+          // print brief unknowns
+          const t = String(ev?.type || 'evt');
+          console.log(` ${t}`);
+        }
+      }
+    }
+  }
+}
+
+main().catch((e) => {
+  console.error('fatal:', e?.message || String(e));
+  process.exit(2);
+});

package/scripts/tools-dev/run-llmswitch-chat.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+// Quick llmswitch-core Chat filter runner: runStandardChatRequestFilters without starting server.
+// Usage:
+//   node scripts/tools-dev/run-llmswitch-chat.mjs path/to/chat-request.json [/v1/chat|/v1/messages|/v1/responses]
+
+import fs from 'fs';
+import path from 'path';
+import url from 'url';
+import { runStandardChatRequestFilters } from '../../sharedmodule/llmswitch-core/dist/conversion/index.js';
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+
+async function main() {
+  const file = process.argv[2];
+  const endpoint = process.argv[3] || '/v1/chat/completions';
+
+  if (!file) {
+    console.error('Usage: node scripts/tools-dev/run-llmswitch-chat.mjs <payload.json> [endpoint]');
+    process.exit(1);
+  }
+
+  const abs = path.isAbsolute(file) ? file : path.join(process.cwd(), file);
+  const txt = fs.readFileSync(abs, 'utf8');
+  const raw = JSON.parse(txt);
+
+  // Allow passing either a raw chat body, or a provider-request snapshot with { endpoint, data: { body } }
+  let payload = raw;
+  if (raw && typeof raw === 'object' && raw.data && typeof raw.data === 'object' && raw.data.body) {
+    payload = raw.data.body;
+  }
+
+  const requestId = `req_${Date.now()}`;
+  const profile = {
+    id: 'test-profile',
+    incomingProtocol: 'openai-chat',
+    outgoingProtocol: 'openai-chat'
+  };
+
+  const context = {
+    requestId,
+    entryEndpoint: endpoint,
+    endpoint,
+    metadata: {}
+  };
+
+  const out = await runStandardChatRequestFilters(payload, profile, context);
+  process.stdout.write(JSON.stringify(out, null, 2) + '\n');
+}
+
+main().catch(err => {
+  console.error('Error running llmswitch filters:', err);
+  process.exit(1);
+});

package/scripts/tools-dev/server-tools-dev/run-web-fetch.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import path from 'node:path';
+
+function parseArgs(argv) {
+  const out = { url: null, timeout: null, maxBytes: null, follow: true, headers: {} };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if ((a === '--url' || a === '-u') && i + 1 < argv.length) { out.url = argv[++i]; continue; }
+    if ((a === '--timeout' || a === '-t') && i + 1 < argv.length) { out.timeout = Number(argv[++i]); continue; }
+    if (a === '--no-follow') { out.follow = false; continue; }
+    if ((a === '--max-bytes' || a === '-m') && i + 1 < argv.length) { out.maxBytes = Number(argv[++i]); continue; }
+    if ((a === '--header' || a === '-H') && i + 1 < argv.length) {
+      const kv = String(argv[++i]);
+      const idx = kv.indexOf(':');
+      if (idx > 0) { const k = kv.slice(0, idx).trim(); const v = kv.slice(idx + 1).trim(); if (k) out.headers[k] = v; }
+      continue;
+    }
+    if (a === '--help' || a === '-h') { out.help = true; }
+  }
+  return out;
+}
+
+function usage() {
+  console.log('Usage: node scripts/tools-dev/server-tools-dev/run-web-fetch.mjs --url <URL> [--timeout 12000] [--max-bytes 524288] [--no-follow] [--header "Key: Value"]');
+}
+
+async function importCoreFetcher() {
+  // Prefer local sharedmodule path if exists; fallback to installed package
+  const __filename = fileURLToPath(import.meta.url);
+  const repoRoot = path.resolve(path.dirname(__filename), '../..');
+  const local = path.resolve(repoRoot, 'sharedmodule/llmswitch-core/dist/tools/web-fetch-html.js');
+  try {
+    const mod = await import(pathToFileURL(local).href);
+    if (typeof mod?.fetchRawHtml === 'function') return mod.fetchRawHtml;
+  } catch {}
+  throw new Error('Cannot locate fetchRawHtml in sharedmodule/llmswitch-core/dist。请先构建 sharedmodule/llmswitch-core。');
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.help || !args.url) { usage(); process.exit(args.help ? 0 : 1); }
+  const fetchRawHtml = await importCoreFetcher();
+  const res = await fetchRawHtml(args.url, {
+    timeoutMs: args.timeout || undefined,
+    followRedirects: args.follow,
+    maxBytes: args.maxBytes || undefined,
+    headers: Object.keys(args.headers).length ? args.headers : undefined,
+  });
+  if (res.ok) {
+    console.log('OK');
+    console.log(`status: ${res.status}`);
+    console.log(`content-type: ${res.contentType}`);
+    const preview = res.html ?? '';
+    console.log('--- html (first 2048 chars) ---');
+    console.log(preview.slice(0, 2048));
+  } else {
+    console.log('FAIL');
+    console.log(`error: ${res.error}`);
+    if (res.status) console.log(`status: ${res.status}`);
+    if (res.contentType) console.log(`content-type: ${res.contentType}`);
+  }
+}
+
+main().catch((e) => { console.error(e); process.exit(99); });

package/scripts/vendor-core.mjs

@@ -12,12 +12,18 @@ async function rmrf(p) {
 
 async function main() {
   const root = process.cwd();
+  const rawMode = String(process.env.BUILD_MODE || process.env.RCC_BUILD_MODE || 'release').toLowerCase();
+  const mode = rawMode === 'dev' ? 'dev' : 'release';
   const sharedDist = path.join(root, 'sharedmodule', 'llmswitch-core', 'dist');
   const legacyVendorDir = path.join(root, 'vendor', 'rcc-llmswitch-core');
   const scopedVendorDir = path.join(root, 'vendor', '@jsonstudio', 'llms');
 
-  if (!await exists(sharedDist)) {
-    console.error('[vendor-core] ERROR: 未找到 sharedmodule/llmswitch-core/dist');
+  // In release mode we rely on npm-installed `@jsonstudio/llms`, so the local sharedmodule dist
+  // is optional and must not block CI (where sharedmodule often doesn't exist).
+  // In dev mode, `node_modules/@jsonstudio/llms` is typically symlinked to sharedmodule/llmswitch-core,
+  // so we keep a hard requirement for the dist output.
+  if (mode === 'dev' && !await exists(sharedDist)) {
+    console.error('[vendor-core] ERROR: 未找到 sharedmodule/llmswitch-core/dist (BUILD_MODE=dev)');
     console.error('[vendor-core] 请先进入 sharedmodule/llmswitch-core 并运行 `npm run build`。');
     process.exit(2);
   }
@@ -31,7 +37,11 @@ async function main() {
     console.log('[vendor-core] removed legacy vendor/@jsonstudio/llms directory');
   }
 
-  console.log('[vendor-core] sharedmodule/llmswitch-core/dist 将被直接引用，已停止生成 vendor 副本。');
+  if (mode === 'dev') {
+    console.log('[vendor-core] sharedmodule/llmswitch-core/dist 将被直接引用，已停止生成 vendor 副本。');
+  } else {
+    console.log('[vendor-core] BUILD_MODE=release: using npm-installed @jsonstudio/llms (no vendor copy).');
+  }
 }
 
 main().catch((err) => {

package/scripts/test-fc-responses.mjs

@@ -1,66 +0,0 @@
-#!/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

@@ -1,100 +0,0 @@
-#!/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); });