@jsonstudio/rcc 0.89.683 → 0.89.912

package/scripts/tool-classification-report.ts

@@ -0,0 +1,281 @@
+#!/usr/bin/env tsx
+/**
+ * Generate a tool classification report for codex samples using the
+ * virtual router tool classifier (read/write/search/other).
+ *
+ * Usage:
+ *   npx tsx scripts/tool-classification-report.ts [samplesRoot] [outputFile]
+ *
+ * Defaults:
+ *   samplesRoot = ~/.routecodex/codex-samples
+ *   outputFile  = ./reports/tool-classification-report.md
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+
+import {
+  canonicalizeToolName,
+  classifyToolCallForReport,
+  type ToolCategory
+} from '../sharedmodule/llmswitch-core/src/router/virtual-router/tool-signals.js';
+
+type CategoryCounts = Record<ToolCategory, number>;
+
+type ExampleEntry = {
+  category: ToolCategory;
+  file: string;
+  snippet?: string;
+};
+
+type ToolSummary = {
+  total: number;
+  categories: CategoryCounts;
+  examples: Record<ToolCategory, ExampleEntry[]>;
+};
+
+const CATEGORY_KEYS: ToolCategory[] = ['websearch', 'read', 'write', 'search', 'other'];
+const SAMPLE_SUFFIX = '_req_process_tool_filters_request_pre.json';
+const EXAMPLE_LIMIT = 5;
+
+async function main(): Promise<void> {
+  const [, , rootArg, outputArg] = process.argv;
+  const sampleRoot = rootArg || path.join(os.homedir(), '.routecodex', 'codex-samples');
+  const outputFile = outputArg || path.join(process.cwd(), 'reports', 'tool-classification-report.md');
+
+  if (!fs.existsSync(sampleRoot)) {
+    throw new Error(`Sample root not found: ${sampleRoot}`);
+  }
+
+  const files = await collectSampleFiles(sampleRoot);
+  files.sort((a, b) => a.localeCompare(b));
+
+  const processedRequests = new Set<string>();
+  const summary = new Map<string, ToolSummary>();
+  const categoryTotals: CategoryCounts = emptyCounts();
+  let totalCalls = 0;
+  let classifiedCalls = 0;
+  let unclassifiedCalls = 0;
+  let skippedDuplicates = 0;
+
+  for (const filePath of files) {
+    const requestKey = extractRequestKey(filePath);
+    if (processedRequests.has(requestKey)) {
+      skippedDuplicates += 1;
+      continue;
+    }
+    processedRequests.add(requestKey);
+
+    const data = await readJsonSafe(filePath);
+    if (!data) {
+      continue;
+    }
+    const messages = Array.isArray(data.messages) ? data.messages : [];
+    for (const msg of messages) {
+      if (!msg || typeof msg !== 'object') {
+        continue;
+      }
+      if (msg.role !== 'assistant') {
+        continue;
+      }
+      const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+      for (const call of toolCalls) {
+        totalCalls += 1;
+        const classification = classifyToolCallForReport(call as any);
+        if (!classification) {
+          unclassifiedCalls += 1;
+          continue;
+        }
+        classifiedCalls += 1;
+        const toolName = canonicalizeToolName(classification.name ?? '') || '(unknown)';
+        const entry = ensureSummary(summary, toolName);
+        entry.total += 1;
+        entry.categories[classification.category] += 1;
+        categoryTotals[classification.category] += 1;
+        const examples = entry.examples[classification.category];
+        if (examples.length < EXAMPLE_LIMIT) {
+          examples.push({
+            category: classification.category,
+            file: path.relative(sampleRoot, filePath),
+            snippet: classification.commandSnippet || buildFallbackSnippet(call)
+          });
+        }
+      }
+    }
+  }
+
+  const orderedSummaries = Array.from(summary.entries()).sort((a, b) => b[1].total - a[1].total);
+  const report = buildReport({
+    sampleRoot,
+    outputFile,
+    filesScanned: files.length,
+    uniqueRequests: processedRequests.size,
+    skippedDuplicates,
+    totalCalls,
+    classifiedCalls,
+    unclassifiedCalls,
+    categoryTotals,
+    summaries: orderedSummaries
+  });
+
+  await mkdir(path.dirname(outputFile), { recursive: true });
+  await writeFile(outputFile, report.join('\n'), 'utf8');
+  console.log(`[tool-classification-report] wrote ${outputFile}`);
+}
+
+function emptyCounts(): CategoryCounts {
+  return { websearch: 0, read: 0, write: 0, search: 0, other: 0 };
+}
+
+function emptyExampleBuckets(): Record<ToolCategory, ExampleEntry[]> {
+  return {
+    websearch: [],
+    read: [],
+    write: [],
+    search: [],
+    other: []
+  };
+}
+
+function ensureSummary(summary: Map<string, ToolSummary>, name: string): ToolSummary {
+  if (!summary.has(name)) {
+    summary.set(name, {
+      total: 0,
+      categories: emptyCounts(),
+      examples: emptyExampleBuckets()
+    });
+  }
+  return summary.get(name)!;
+}
+
+async function collectSampleFiles(dir: string): Promise<string[]> {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files: string[] = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectSampleFiles(fullPath);
+      files.push(...nested);
+    } else if (entry.isFile() && entry.name.endsWith(SAMPLE_SUFFIX)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+async function readJsonSafe(filePath: string): Promise<any | null> {
+  try {
+    const raw = await readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function extractRequestKey(filePath: string): string {
+  const base = path.basename(filePath);
+  const match = base.match(/^(req_[^_]+_[^_]+)/);
+  return match ? match[1] : base;
+}
+
+function sanitizeSnippet(snippet?: string): string {
+  if (!snippet) {
+    return '(no snippet)';
+  }
+  return snippet.replace(/[\r\n]+/g, ' ').replace(/`/g, "'");
+}
+
+function titleCase(category: ToolCategory): string {
+  if (category === 'websearch') {
+    return 'WebSearch';
+  }
+  return category.charAt(0).toUpperCase() + category.slice(1);
+}
+
+function buildFallbackSnippet(call: any): string | undefined {
+  const rawArgs = call?.function?.arguments;
+  if (typeof rawArgs === 'string' && rawArgs.trim()) {
+    const trimmed = rawArgs.trim().replace(/\s+/g, ' ');
+    return trimmed.length > 120 ? `${trimmed.slice(0, 117)}…` : trimmed;
+  }
+  return undefined;
+}
+
+function buildReport(options: {
+  sampleRoot: string;
+  outputFile: string;
+  filesScanned: number;
+  uniqueRequests: number;
+  skippedDuplicates: number;
+  totalCalls: number;
+  classifiedCalls: number;
+  unclassifiedCalls: number;
+  categoryTotals: CategoryCounts;
+  summaries: Array<[string, ToolSummary]>;
+}): string[] {
+  const {
+    sampleRoot,
+    filesScanned,
+    uniqueRequests,
+    skippedDuplicates,
+    totalCalls,
+    classifiedCalls,
+    unclassifiedCalls,
+    categoryTotals,
+    summaries
+  } = options;
+
+  const lines: string[] = [];
+  lines.push('# Tool Classification Report');
+  lines.push('');
+  lines.push(`- Sample root: ${sampleRoot}`);
+  lines.push(`- Files scanned: ${filesScanned}`);
+  lines.push(`- Unique requests: ${uniqueRequests}`);
+  lines.push(`- Skipped duplicates: ${skippedDuplicates}`);
+  lines.push(`- Tool calls processed: ${totalCalls}`);
+  lines.push(`- Classified calls: ${classifiedCalls}`);
+  lines.push(`- Unclassified calls: ${unclassifiedCalls}`);
+  lines.push(`- Generated at: ${new Date().toISOString()}`);
+  lines.push('');
+  lines.push('## Category Totals');
+  lines.push('');
+  for (const category of CATEGORY_KEYS) {
+    lines.push(`- ${category}: ${categoryTotals[category]}`);
+  }
+  lines.push('');
+  lines.push('## Per-Tool Summary');
+  lines.push('');
+  const categoryHeader = CATEGORY_KEYS.map((key) => titleCase(key)).join(' | ');
+  lines.push(`| Tool | Total | ${categoryHeader} |`);
+  lines.push(`| --- | ---: | ${CATEGORY_KEYS.map(() => '---:').join(' | ')} |`);
+  for (const [name, info] of summaries) {
+    const counts = CATEGORY_KEYS.map((key) => info.categories[key]);
+    lines.push(`| ${name} | ${info.total} | ${counts.join(' | ')} |`);
+  }
+  lines.push('');
+  for (const [name, info] of summaries) {
+    lines.push(`### ${name} (total ${info.total})`);
+    const countSummary = CATEGORY_KEYS.map((key) => `${key}: ${info.categories[key]}`).join(', ');
+    lines.push(`Counts → ${countSummary}`);
+    for (const category of CATEGORY_KEYS) {
+      const examples = info.examples[category];
+      if (!examples.length) {
+        continue;
+      }
+      lines.push(`- ${category} examples:`);
+      for (const example of examples) {
+        lines.push(
+          `  - ${example.file}: \`${sanitizeSnippet(example.snippet)}\``
+        );
+      }
+    }
+    lines.push('');
+  }
+  return lines;
+}
+
+main().catch((err) => {
+  console.error('[tool-classification-report] failed', err);
+  process.exit(1);
+});

package/scripts/verification/samples/openai-chat-list-local-files.json

@@ -3,7 +3,7 @@
   "source": "synthetic",
   "endpoint": "/v1/chat/completions",
   "payload": {
-    "model": "glm-4.6",
+    "model": "glm-4.7",
     "temperature": 0,
     "stream": false,
     "tool_choice": {

package/scripts/verify-apply-patch.mjs

@@ -3,7 +3,7 @@
  * Minimal apply_patch governance verifier (CI client)
  *
  * 直接调用 llmswitch-core 的文本 → tool_calls → 校验链路，
- * 用统一 diff（*** Begin Patch/*** End Patch）触发 apply_patch。
+ * 用结构化 apply_patch payload（changes 数组）触发校验。
  */
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -18,7 +18,7 @@ async function loadCoreModule(subpath) {
   return importCoreModule(subpath);
 }
 
-async function runApplyPatchTextCase(label, patchText) {
+async function runApplyPatchTextCase(label, payloadText) {
   const { normalizeAssistantTextToToolCalls } = await loadCoreModule(
     'conversion/shared/text-markup-normalizer'
   );
@@ -29,7 +29,7 @@ async function runApplyPatchTextCase(label, patchText) {
 
   const message = {
     role: 'assistant',
-    content: patchText
+    content: payloadText
   };
   const normalizedMsg = normalizeAssistantTextToToolCalls(message);
   const toolCalls = normalizedMsg?.tool_calls;
@@ -106,22 +106,33 @@ async function main() {
   }
 
   try {
-    const plainPatch =
-      '*** Begin Patch\n' +
-      '*** Add File: hello.txt\n' +
-      '+Hello from apply_patch\n' +
-      '*** End Patch\n';
+    const plainJson = JSON.stringify({
+      file: 'src/demo.ts',
+      changes: [
+        {
+          kind: 'insert_after',
+          anchor: 'const foo = 1;',
+          lines: ['const bar = 2;']
+        }
+      ]
+    }, null, 2);
 
-    const fencedPatch =
-      '```patch\n' +
-      '*** Begin Patch\n' +
-      '*** Add File: hello-fenced.txt\n' +
-      '+Hello from apply_patch (fenced)\n' +
-      '*** End Patch\n' +
-      '```';
+    const fencedJson =
+      '```json\n' +
+      JSON.stringify({
+        file: 'src/demo-fenced.ts',
+        changes: [
+          {
+            kind: 'replace',
+            target: 'const status = "old";',
+            lines: ['const status = "new";']
+          }
+        ]
+      }, null, 2) +
+      '\n```';
 
-    await runApplyPatchTextCase('plain', plainPatch);
-    await runApplyPatchTextCase('fenced', fencedPatch);
+    await runApplyPatchTextCase('plain', plainJson);
+    await runApplyPatchTextCase('fenced', fencedJson);
 
     console.log('✅ verify-apply-patch: text→tool_calls pipeline passed');
   } catch (error) {

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

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+/**
+ * Lightweight regression guard for previously captured Codex error样本.
+ *
+ * 目标：
+ * - 扫描 ~/.routecodex/errorsamples 目录下的 *.json 文件；
+ * - 如果仍包含已知错误模式（例如 exec_command 参数解析失败、apply_patch 验证失败），则视为回归；
+ * - 目录不存在或为空时直接跳过（不影响构建）。
+ *
+ * 注意：
+ * - 该脚本只是“错误字符串回归检测”，不会主动重放请求；
+ * - 每当修复一批问题后，应将修复后的样本覆盖到 ~/.routecodex/errorsamples，再由本脚本做守护。
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+const ROOT =
+  process.env.ROUTECODEX_ERROR_SAMPLES_DIR &&
+  process.env.ROUTECODEX_ERROR_SAMPLES_DIR.trim().length
+    ? path.resolve(process.env.ROUTECODEX_ERROR_SAMPLES_DIR)
+    : path.join(os.homedir(), '.routecodex', 'errorsamples');
+
+const ERROR_PATTERNS = [
+  // exec_command / apply_patch 参数解码错误（CLI 侧报错）
+  'failed to parse function arguments: missing field `cmd`',
+  'failed to parse function arguments: missing field `input`',
+  // 历史回滚：统一 diff 校验失败
+  'apply_patch verification failed'
+];
+
+async function fileExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function collectSampleFiles(rootDir) {
+  const entries = await fs.readdir(rootDir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (!entry.name.toLowerCase().endsWith('.json')) continue;
+    files.push(path.join(rootDir, entry.name));
+  }
+  return files;
+}
+
+async function checkFile(filePath) {
+  const raw = await fs.readFile(filePath, 'utf-8');
+  const hits = [];
+  for (const pattern of ERROR_PATTERNS) {
+    if (raw.includes(pattern)) {
+      hits.push(pattern);
+    }
+  }
+  return hits;
+}
+
+async function main() {
+  if (!(await fileExists(ROOT))) {
+    console.log(`[verify:errorsamples] skip (directory not found: ${ROOT})`);
+    return;
+  }
+
+  const files = await collectSampleFiles(ROOT);
+  if (!files.length) {
+    console.log(`[verify:errorsamples] skip (no *.json samples under ${ROOT})`);
+    return;
+  }
+
+  console.log(`[verify:errorsamples] scanning ${files.length} sample(s) under ${ROOT}`);
+
+  const failures = [];
+  for (const file of files) {
+    const hits = await checkFile(file);
+    if (hits.length) {
+      failures.push({ file, hits });
+    }
+  }
+
+  if (!failures.length) {
+    console.log('[verify:errorsamples] ✅ no known error patterns found');
+    return;
+  }
+
+  console.error('[verify:errorsamples] ❌ detected legacy error patterns in samples:');
+  for (const item of failures) {
+    console.error(` - ${path.basename(item.file)} → ${item.hits.join(', ')}`);
+  }
+  process.exitCode = 1;
+}
+
+main().catch((error) => {
+  console.error('[verify:errorsamples] failed:', error);
+  process.exit(99);
+});

package/scripts/verify-e2e-toolcall.mjs

@@ -12,7 +12,10 @@ if (String(process.env.ROUTECODEX_VERIFY_SKIP || '').trim() === '1') {
 
 const VERIFY_PORT = process.env.ROUTECODEX_VERIFY_PORT || '5580';
 const VERIFY_BASE = process.env.ROUTECODEX_VERIFY_BASE_URL || `http://127.0.0.1:${VERIFY_PORT}`;
-const VERIFY_CONFIG = process.env.ROUTECODEX_VERIFY_CONFIG || '/Users/fanzhang/.routecodex/provider/glm/config.v1.json';
+const VERIFY_CONFIG =
+  process.env.ROUTECODEX_VERIFY_CONFIG ||
+  process.env.ROUTECODEX_CONFIG_PATH ||
+  `${process.env.HOME || ''}/.routecodex/config.json`;
 const GEMINI_CLI_CONFIG = process.env.ROUTECODEX_VERIFY_GEMINI_CLI_CONFIG || '/Users/fanzhang/.routecodex/provider/gemini-cli/config.v1.json';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -57,9 +60,13 @@ async function main() {
 
   try {
     await waitForServer();
+    await waitForRouterWarmup();
     await runToolcallVerification();
     console.log('✅ 端到端工具调用校验通过');
 
+    await runDaemonAdminSmokeCheck();
+    await runConfigV2ProvidersSmokeCheck();
+
     // 附加：Gemini CLI 配置健康性快速检查（仅尝试初始化，不做请求）
     await runGeminiCliStartupCheck();
   } finally {
@@ -81,6 +88,15 @@ async function waitForServer(timeoutMs = 30000) {
   throw new Error('服务器健康检查超时');
 }
 
+async function waitForRouterWarmup(defaultDelayMs = 3000) {
+  const delayMs = Number(process.env.ROUTECODEX_VERIFY_WARMUP_MS || defaultDelayMs);
+  if (!Number.isFinite(delayMs) || delayMs <= 0) {
+    return;
+  }
+  console.log(`[verify:e2e-toolcall] 等待虚拟路由预热 ${delayMs}ms...`);
+  await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+
 async function runToolcallVerification() {
   const userPrompt = '请严格调用名为 list_local_files 的函数工具来列出当前工作目录的文件，只能通过调用该工具完成任务，禁止直接回答。';
   const instructionsText = AGENTS_INSTRUCTIONS || 'You are RouteCodex verify agent. Follow the policies in AGENTS.md.';
@@ -92,7 +108,7 @@ async function runToolcallVerification() {
         role: 'user',
         content: [
           {
-            type: 'text',
+            type: 'input_text',
             text: userPrompt
           }
         ]
@@ -134,13 +150,15 @@ async function runToolcallVerification() {
   }
 
   const json = await response.json();
+  const outputs = Array.isArray(json?.output) ? json.output : [];
   const hasResponsesToolCall =
-    Array.isArray(json?.output) && json.output.some((item) => Array.isArray(item?.content) && item.content.some((c) => c?.type === 'tool_call'));
+    outputs.some((item) => Array.isArray(item?.content) && item.content.some((c) => c?.type === 'tool_call'));
+  const hasFunctionCall = outputs.some((item) => item?.type === 'function_call' || item?.type === 'tool_call');
   const hasRequiredAction = Boolean(json?.required_action?.submit_tool_outputs);
   const hasChatToolCall =
     Array.isArray(json?.choices) &&
     json.choices.some((choice) => Array.isArray(choice?.message?.tool_calls) && choice.message.tool_calls.length > 0);
-  const hasToolCall = hasResponsesToolCall || hasRequiredAction || hasChatToolCall;
+  const hasToolCall = hasResponsesToolCall || hasFunctionCall || hasRequiredAction || hasChatToolCall;
 
   if (!hasToolCall) {
     console.error('[verify:e2e-toolcall] Unexpected response:', JSON.stringify(json, null, 2));
@@ -148,6 +166,55 @@ async function runToolcallVerification() {
   }
 }
 
+async function runDaemonAdminSmokeCheck() {
+  // 仅做最小的健康性探测：确保 daemon 管理类只读 API 可用，不做语义校验。
+  try {
+    const res = await fetch(`${VERIFY_BASE}/daemon/status`);
+    if (!res.ok) {
+      throw new Error(`daemon/status HTTP ${res.status}`);
+    }
+    const json = await res.json();
+    if (!json || typeof json !== 'object' || json.ok !== true) {
+      throw new Error('daemon/status 返回值不符合预期形态');
+    }
+  } catch (error) {
+    console.error('[verify:e2e-toolcall] /daemon/status smoke 检查失败:', error);
+    throw error;
+  }
+
+  const paths = ['/daemon/credentials', '/quota/summary', '/providers/runtimes'];
+  for (const path of paths) {
+    try {
+      const res = await fetch(`${VERIFY_BASE}${path}`);
+      if (!res.ok) {
+        throw new Error(`${path} HTTP ${res.status}`);
+      }
+      // 只要 JSON 可解析即可视为通过，避免把语义校验塞到这里。
+      await res.json().catch(() => ({}));
+    } catch (error) {
+      console.error('[verify:e2e-toolcall] Daemon admin smoke 检查失败:', path, error);
+      throw error;
+    }
+  }
+}
+
+async function runConfigV2ProvidersSmokeCheck() {
+  try {
+    const res = await fetch(`${VERIFY_BASE}/config/providers/v2`);
+    if (!res.ok) {
+      throw new Error(`/config/providers/v2 HTTP ${res.status}`);
+    }
+    const json = await res.json();
+    if (!Array.isArray(json)) {
+      // 出于兼容考虑，只要不是致命错误就通过；Config V2 视图是辅助信息。
+      console.warn('[verify:e2e-toolcall] /config/providers/v2 未返回数组形态，跳过进一步校验');
+    }
+  } catch (error) {
+    console.error('[verify:e2e-toolcall] Config V2 providers smoke 检查失败:', error);
+    // 不将 Config V2 视图问题视为构建阻断条件，以免挡住主链路；仅提示。
+  }
+}
+
 async function runGeminiCliStartupCheck() {
   if (!GEMINI_CLI_CONFIG || !fs.existsSync(GEMINI_CLI_CONFIG)) {
     return;