@jsonstudio/rcc 0.89.873 → 0.89.932

package/scripts/tests/exec-command-loop.mjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+/**
+ * exec_command TOON → JSON 回环验证（模拟 Responses 客户端）。
+ *
+ * 目标：
+ * - 构造一条带 exec_command TOON arguments 的 chat 响应；
+ * - 通过 llmswitch-core 的 response 工具过滤管线（ResponseToolArgumentsToonDecodeFilter）做解码；
+ * - 使用 codex 的工具注册表 validateToolCall 校验最终 JSON 形状（必须包含 cmd，且不再暴露 toon）；
+ * - 只从“客户端视角”观察：发送/接收的都是 JSON，TOON 对客户端完全透明。
+ */
+
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, '..', '..');
+const coreLoaderPath = path.join(repoRoot, 'dist', 'modules', 'llmswitch', 'core-loader.js');
+const coreLoaderUrl = pathToFileURL(coreLoaderPath).href;
+
+const { importCoreModule } = await import(coreLoaderUrl);
+
+async function main() {
+  const { runChatResponseToolFilters } = await importCoreModule('conversion/shared/tool-filter-pipeline');
+  const { buildResponsesPayloadFromChat } = await importCoreModule(
+    'conversion/responses/responses-openai-bridge'
+  );
+
+  // 构造一条模拟的 chat 响应，其中 exec_command 使用 TOON 编码参数。
+  const chatPayload = {
+    id: 'chatcmpl_exec_toon',
+    object: 'chat.completion',
+    created: Math.floor(Date.now() / 1000),
+    model: 'gpt-5.2-codex',
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: 'assistant',
+          content: null,
+          tool_calls: [
+            {
+              id: 'call_exec_toon',
+              type: 'function',
+              function: {
+                name: 'exec_command',
+                arguments: JSON.stringify({
+                  toon: [
+                    'cmd: echo 1',
+                    'yield_time_ms: 500',
+                    'max_output_tokens: 128',
+                    'shell: /bin/bash',
+                    'login: false'
+                  ].join('\n')
+                })
+              }
+            }
+          ]
+        },
+        finish_reason: 'tool_calls'
+      }
+    ]
+  };
+
+  // 通过 response 工具管线运行，触发 TOON → JSON 解码。
+  const filtered = await runChatResponseToolFilters(chatPayload, {
+    entryEndpoint: '/v1/chat/completions',
+    requestId: 'req_exec_toon',
+    profile: 'openai-chat'
+  });
+
+  const choice = filtered?.choices?.[0];
+  const msg = choice?.message;
+  const toolCalls = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+  if (!toolCalls.length) {
+    throw new Error('[exec-command-loop] decoded payload missing tool_calls');
+  }
+
+  const fn = toolCalls[0]?.function;
+  if (!fn || typeof fn !== 'object') {
+    throw new Error('[exec-command-loop] first tool_call.function missing');
+  }
+  if (fn.name !== 'exec_command') {
+    throw new Error(`[exec-command-loop] expected exec_command, got ${String(fn.name)}`);
+  }
+  if (typeof fn.arguments !== 'string' || !fn.arguments.trim()) {
+    throw new Error('[exec-command-loop] decoded exec_command.arguments must be non-empty JSON string');
+  }
+
+  let args;
+  try {
+    args = JSON.parse(fn.arguments);
+  } catch (error) {
+    throw new Error(
+      `[exec-command-loop] decoded exec_command arguments not valid JSON: ${
+        error instanceof Error ? error.message : String(error ?? 'unknown')
+      }`
+    );
+  }
+
+  if (!args || typeof args !== 'object') {
+    throw new Error('[exec-command-loop] decoded exec_command arguments not an object');
+  }
+
+  // 与 codex exec_command Responses 工具保持一致：cmd 为必填字段，其它为可选字段。
+  if (typeof args.cmd !== 'string' || !args.cmd.trim()) {
+    throw new Error('[exec-command-loop] decoded exec_command.args missing cmd');
+  }
+
+  const forbiddenKeys = ['toon'];
+  for (const key of forbiddenKeys) {
+    if (Object.prototype.hasOwnProperty.call(args, key)) {
+      throw new Error(`[exec-command-loop] decoded exec_command.args must not expose ${key} to client`);
+    }
+  }
+
+  // 延伸验证：基于 chat 结果构建 Responses payload，确保 /v1/responses 视图中的
+  // function_call.arguments 同样保持 exec_command JSON 语义，而不会重新出现 toon。
+  const responsesPayload = buildResponsesPayloadFromChat(filtered, {
+    requestId: 'verify_exec_command_toon'
+  });
+  const outputItems = Array.isArray(responsesPayload?.output) ? responsesPayload.output : [];
+  const fnCall = outputItems.find(
+    (item) => item && item.type === 'function_call' && item.name === 'exec_command'
+  );
+  if (!fnCall) {
+    throw new Error('[exec-command-loop] Responses payload missing exec_command function_call');
+  }
+  if (typeof fnCall.arguments !== 'string' || !fnCall.arguments.trim()) {
+    throw new Error(
+      '[exec-command-loop] Responses function_call.arguments must be non-empty JSON string'
+    );
+  }
+  let respArgs;
+  try {
+    respArgs = JSON.parse(fnCall.arguments);
+  } catch (error) {
+    throw new Error(
+      `[exec-command-loop] Responses function_call.arguments not valid JSON: ${
+        error instanceof Error ? error.message : String(error ?? 'unknown')
+      }`
+    );
+  }
+  if (!respArgs || typeof respArgs !== 'object') {
+    throw new Error('[exec-command-loop] Responses function_call.arguments not an object');
+  }
+  if (typeof respArgs.cmd !== 'string' || !respArgs.cmd.trim()) {
+    throw new Error('[exec-command-loop] Responses exec_command.args missing cmd');
+  }
+  if (Object.prototype.hasOwnProperty.call(respArgs, 'toon')) {
+    throw new Error('[exec-command-loop] Responses exec_command.args must not expose toon');
+  }
+
+  console.log(
+    `[exec-command-loop] decoded cmd="${args.cmd}" yield_time_ms=${args.yield_time_ms ?? 'n/a'} max_output_tokens=${args.max_output_tokens ?? 'n/a'}`
+  );
+  console.log('✅ exec_command TOON decode passed (chat + responses views are JSON-only)');
+}
+
+main().catch((error) => {
+  console.error(
+    '[exec-command-loop] FAILED:',
+    error instanceof Error ? error.message : String(error ?? 'unknown')
+  );
+  process.exit(1);
+});

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-codex-error-samples.mjs

@@ -24,7 +24,10 @@ const ROOT =
     : path.join(os.homedir(), '.routecodex', 'errorsamples');
 
 const ERROR_PATTERNS = [
-  'failed to parse exec_command arguments',
+  // 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'
 ];
 

package/scripts/verify-e2e-toolcall.mjs

@@ -64,6 +64,9 @@ async function main() {
     await runToolcallVerification();
     console.log('✅ 端到端工具调用校验通过');
 
+    await runDaemonAdminSmokeCheck();
+    await runConfigV2ProvidersSmokeCheck();
+
     // 附加：Gemini CLI 配置健康性快速检查（仅尝试初始化，不做请求）
     await runGeminiCliStartupCheck();
   } finally {
@@ -163,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;