@jsonstudio/rcc 0.85.9 → 0.89.3

package/README.md

@@ -6,7 +6,7 @@
 
 RouteCodex是一个功能强大的多提供商OpenAI代理服务器，基于配置驱动的V2架构，支持原生dry-run调试能力、动态路由分类、4层管道架构和实时监控。提供统一的API接口，无缝集成多个AI服务提供商。
 
-当前开发版本：`0.81.54`
+当前开发版本：`0.87.1`
 
 ## LLM Switch（前后半段）总览
 
@@ -38,6 +38,13 @@ RouteCodex是一个功能强大的多提供商OpenAI代理服务器，基于配
   - `Output/SSE Nodes`：把 `processedRequest` 还原为目标协议，生成 usage、SSE 流和最终响应。
 - **Host 职责**：`RouteCodexHttpServer` 只负责 HTTP/SSE 封装与 Provider runtime 映射，工具治理与路由决策全部在 llmswitch-core 完成。
 
+### Reasoning / Tool 骨架
+
+- **入站统一拆分**：`sharedmodule/llmswitch-core/src/conversion/shared/reasoning-normalizer.ts` 会在 Chat/Responses/Anthropic/Gemini 入站阶段，把 `<think>/<reasoning>` 段落剥离到 `reasoning_content`，并同步处理 instructions/input/required_action。
+- **工具/理由写回**：`reasoning-tool-normalizer.ts` 与 `tool-call-utils.ts` 负责把 reasoning 文本中的工具片段转换为 `tool_calls`，处理 placeholder、capturedToolResults、metadata.extra-fields 等动作由 `bridge-actions.ts` 统一驱动。
+- **协议中性命名**：所有共享动作均使用 `messages.*`、`tools.*` 等协议无关名称（如 `messages.inject-system-instruction`、`tools.ensure-response-placeholders`）。兼容层不得新增带协议前缀的 helper。
+- **兼容层职责切换**：GLM/iFlow 等 compat hook 仅处理 usage、finish_reason、schema 轻量标准化，Reasoning 拆分/清理禁止下沉到 compat；若 Provider 需特殊字段，必须通过 JSON config 描述。
+
 ## 快照排查指南（命令行）
 
 - 快速查看某个请求 RID 在各阶段的顶层键/消息概况/可疑字段：
@@ -55,13 +62,13 @@ RouteCodex是一个功能强大的多提供商OpenAI代理服务器，基于配
 ### 🏗️ V2 核心组件
 
 - **Compatibility V2（配置驱动）**
-  - 位置：`src/modules/pipeline/modules/provider/v2/compatibility/glm/*`（模块化 + Hook 系统）
-  - 职责：仅做 Provider 特定的最小字段标准化与 reasoning_content 处理
+  - 位置：`src/providers/compat/glm/*`（模块化 + Hook 系统）
+  - 职责：仅做 Provider 特定的最小字段标准化；reasoning/tool 清理统一由 conversion 骨架完成
   - 特性：配置驱动字段映射、GLM 专用最小清理与 1210/1214 错误兼容
   - 工具治理：统一在 llmswitch-core v2 处理；兼容层不进行工具语义修复/文本收割
 
 - **Provider V2（统一OpenAI标准）**
-  - 位置：`src/modules/pipeline/modules/provider/v2/*`
+  - 位置：`src/providers/*`
   - 能力：统一 HTTP 发送、认证管理、请求/响应快照
   - 支持服务：OpenAI、GLM、Qwen、iFlow、LM Studio
   - 策略：Fail Fast 原则，无隐藏兜底机制
@@ -85,14 +92,14 @@ RouteCodex是一个功能强大的多提供商OpenAI代理服务器，基于配
 
 ### Compatibility（最小兼容层）
 - Do
-  - Provider 字段标准化、reasoning_content 处理、配置驱动映射
+  - Provider 字段标准化（usage/finish_reason 等）、配置驱动映射，遵守 shared 骨架输出
   - 1210/1214 最小兼容（GLM）
   - 请求侧最小黑名单（例如 GLM 删除 `tools[].function.strict`；无 tools 删除 `tool_choice`）
   - 响应侧最小黑名单（仅非流式）：默认仅删 `usage.prompt_tokens_details.cached_tokens`
-    - 配置：`src/modules/pipeline/modules/provider/v2/compatibility/<provider>/config/response-blacklist.json`
+    - 配置：`src/providers/compat/<provider>/config/response-blacklist.json`
     - 关键字段保护：status/output/output_text/required_action/choices[].message.content/tool_calls/finish_reason
 - Don't
-  - 工具语义修复或文本收割（统一由 llmswitch-core 处理）
+  - 工具语义修复、reasoning 拆分或文本收割（统一由 llmswitch-core 骨架处理）
 
 ### Provider V2（HTTP 通信）
 - Do
@@ -845,7 +852,7 @@ RouteCodex V2架构已完成兼容层的函数化重构，实现了两层架构
 #### 核心文件结构
 
 ```
-src/modules/pipeline/modules/provider/v2/compatibility/
+src/providers/compat/
 ├── compatibility-interface.ts           # 兼容层接口定义
 ├── compatibility-adapter.ts             # PipelineModule适配器
 ├── base-compatibility.ts                # 基础兼容抽象类

package/config/chat-pipeline-blackbox.json

@@ -0,0 +1,89 @@
+{
+  "legacyWorktree": "/Users/fanzhang/Documents/github/sharedmodule/llmswitch-core-worktree/legacy",
+  "samples": [
+    {
+      "name": "anthropic_request_basic",
+      "codec": "anthropic",
+      "mode": "request",
+      "path": "samples/chat-blackbox/anthropic/request-basic.json",
+      "stages": true,
+      "compareStages": false
+    },
+    {
+      "name": "anthropic_request_glm45_stream_20251209T202812462",
+      "codec": "anthropic",
+      "mode": "request",
+      "path": "samples/chat-blackbox/anthropic/legacy-glm4.5a-20251209T202812462.json",
+      "stages": true,
+      "compareStages": false
+    },
+    {
+      "name": "anthropic_request_glm46_stream_20251209T202812535",
+      "codec": "anthropic",
+      "mode": "request",
+      "path": "samples/chat-blackbox/anthropic/legacy-glm4.6a-20251209T202812535.json",
+      "stages": true,
+      "compareStages": false,
+      "comparePayload": false
+    },
+    {
+      "name": "anthropic_request_glm45_nostream_20251209T202814202",
+      "codec": "anthropic",
+      "mode": "request",
+      "path": "samples/chat-blackbox/anthropic/legacy-glm4.5b-20251209T202814202.json",
+      "stages": true,
+      "compareStages": false
+    },
+    {
+      "name": "anthropic_request_glm45_nostream_20251209T202846673",
+      "codec": "anthropic",
+      "mode": "request",
+      "path": "samples/chat-blackbox/anthropic/legacy-glm4.5c-20251209T202846673.json",
+      "stages": true,
+      "compareStages": false
+    },
+    {
+      "name": "anthropic_response_basic",
+      "codec": "anthropic",
+      "mode": "response",
+      "path": "samples/chat-blackbox/anthropic/response-basic.json",
+      "stages": true,
+      "compareStages": false
+    },
+    {
+      "name": "openai_request_basic",
+      "codec": "openai",
+      "mode": "request",
+      "path": "samples/chat-blackbox/openai/request-basic.json",
+      "stages": true
+    },
+    {
+      "name": "openai_response_basic",
+      "codec": "openai",
+      "mode": "response",
+      "path": "samples/chat-blackbox/openai/response-basic.json",
+      "stages": true
+    },
+    {
+      "name": "responses_request_basic",
+      "codec": "responses",
+      "mode": "request",
+      "path": "samples/chat-blackbox/responses/request-basic.json",
+      "stages": false
+    },
+    {
+      "name": "responses_request_toolcall_fc_ids",
+      "codec": "responses",
+      "mode": "request",
+      "path": "samples/chat-blackbox/responses/request-toolcall.json",
+      "stages": false
+    },
+    {
+      "name": "responses_response_basic",
+      "codec": "responses",
+      "mode": "response",
+      "path": "samples/chat-blackbox/responses/response-basic.json",
+      "stages": false
+    }
+  ]
+}

package/config/semantic-map.json

@@ -0,0 +1,166 @@
+{
+  "version": "2024-12-02",
+  "fields": [
+    {
+      "id": "system_instruction",
+      "label": "System Instructions",
+      "summary": "systemInstructions",
+      "changeDescription": "systemInstructionDelta",
+      "normalize": "systemMessages",
+      "sources": [
+        {
+          "protocols": ["client-request"],
+          "path": "instructions",
+          "match": {
+            "entryEndpointIncludes": "/v1/responses"
+          }
+        },
+        {
+          "protocols": ["openai-chat", "hub", "client-request"],
+          "selector": "messages.system"
+        },
+        {
+          "protocols": ["anthropic-messages"],
+          "path": "system"
+        },
+        {
+          "protocols": ["provider-request"],
+          "selector": "provider.system"
+        }
+      ]
+    },
+    {
+      "id": "messages",
+      "label": "Chat Messages",
+      "summary": "messagesByRole",
+      "sources": [
+        {
+          "protocols": ["client-request", "openai-chat", "hub", "provider-request", "anthropic-messages"],
+          "path": "messages"
+        }
+      ]
+    },
+    {
+      "id": "tool_calls",
+      "label": "Tool Calls",
+      "summary": "toolCalls",
+      "changeDescription": "toolCallsDelta",
+      "sources": [
+        {
+          "protocols": ["openai-responses", "provider-response"],
+          "path": "required_action.submit_tool_outputs.tool_calls"
+        },
+        {
+          "protocols": ["hub", "openai-chat", "provider-request", "anthropic-messages", "client-request"],
+          "selector": "toolCalls.fromMessages"
+        }
+      ]
+    },
+    {
+      "id": "tool_definitions",
+      "label": "Tool Definitions",
+      "summary": "toolDefinitions",
+      "sources": [
+        {
+          "protocols": ["client-request", "openai-chat", "hub", "provider-request", "provider-response", "anthropic-messages", "client-response"],
+          "selector": "tools.list"
+        }
+      ]
+    },
+    {
+      "id": "required_action",
+      "label": "Required Action",
+      "summary": "requiredAction",
+      "sources": [
+        {
+          "protocols": ["openai-responses", "provider-response"],
+          "path": "required_action"
+        }
+      ]
+    },
+    {
+      "id": "response_content",
+      "label": "Response Content",
+      "summary": "contentPreview",
+      "changeDescription": "contentLengthDelta",
+      "sources": [
+        {
+          "protocols": ["openai-responses", "provider-response"],
+          "selector": "content.responses"
+        },
+        {
+          "protocols": ["openai-chat", "hub", "anthropic-messages", "client-response"],
+          "selector": "content.primary"
+        }
+      ]
+    },
+    {
+      "id": "finish_reason",
+      "label": "Finish Reason",
+      "summary": "finishReason",
+      "sources": [
+        {
+          "protocols": ["openai-chat", "hub", "provider-response", "client-response", "openai-responses"],
+          "path": "choices[0].finish_reason"
+        },
+        {
+          "protocols": ["anthropic-messages"],
+          "path": "stop_reason"
+        }
+      ]
+    },
+    {
+      "id": "route_target",
+      "label": "Route Target",
+      "summary": "routeTarget",
+      "optional": true,
+      "sources": [
+        {
+          "protocols": ["hub", "provider-request", "provider-response"],
+          "selector": "route.target"
+        }
+      ]
+    },
+    {
+      "id": "model_id",
+      "label": "Model",
+      "summary": "modelId",
+      "sources": [
+        {
+          "protocols": ["client-request", "client-response", "openai-chat", "openai-responses", "anthropic-messages", "provider-request", "provider-response"],
+          "path": "model"
+        },
+        {
+          "protocols": ["hub"],
+          "selector": "route.model"
+        }
+      ]
+    },
+    {
+      "id": "usage",
+      "label": "Usage",
+      "summary": "usageMetrics",
+      "optional": true,
+      "sources": [
+        {
+          "protocols": ["openai-chat", "openai-responses", "provider-response", "hub", "client-response", "anthropic-messages"],
+          "path": "usage"
+        }
+      ]
+    },
+    {
+      "id": "tool_results",
+      "label": "Tool Results",
+      "summary": "toolResults",
+      "optional": true,
+      "sources": [
+        {
+          "match": {
+            "stageIncludes": "context_capture"
+          },
+          "path": "tool_outputs"
+        }
+      ]
+    }
+  ]
+}

package/dist/build-info.js

@@ -1,6 +1,6 @@
 export const buildInfo = {
     mode: 'release',
-    version: '0.85.9',
-    buildTime: '2025-12-03T09:43:48.014Z'
+    version: '0.89.3',
+    buildTime: '2025-12-12T04:09:13.943Z'
 };
 //# sourceMappingURL=build-info.js.map

package/dist/cli.js

@@ -5,34 +5,36 @@
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { LOCAL_HOSTS, HTTP_PROTOCOLS, API_PATHS, DEFAULT_CONFIG, API_ENDPOINTS } from "./constants/index.js";
 import fs from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { LOCAL_HOSTS, HTTP_PROTOCOLS, API_PATHS, DEFAULT_CONFIG, API_ENDPOINTS } from './constants/index.js';
 import { buildInfo } from './build-info.js';
 async function createSpinner(text) {
-    try {
-        const mod = await dynamicImport('ora');
-        const oraFn = mod?.default || mod;
-        if (typeof oraFn === 'function') {
-            const s = oraFn(text);
-            return s.start();
+    const mod = await dynamicImport('ora');
+    const oraFactory = typeof mod?.default === 'function' ? mod.default : undefined;
+    if (oraFactory) {
+        const instance = oraFactory(text);
+        if (typeof instance.start === 'function') {
+            instance.start(text);
+            return instance;
         }
     }
-    catch {
-        // fall through to stub
-    }
-    // Fallback stub spinner that just logs messages
     let currentText = text;
     const log = (prefix, msg) => {
-        const m = msg ?? currentText;
-        if (!m)
+        const message = msg ?? currentText;
+        if (!message) {
             return;
-        // eslint-disable-next-line no-console
-        console.log(`${prefix} ${m}`);
+        }
+        console.log(`${prefix} ${message}`);
     };
     const stub = {
         start(msg) {
-            if (msg)
+            if (msg) {
                 currentText = msg;
+            }
             log('...', msg);
             return stub;
         },
@@ -42,14 +44,10 @@ async function createSpinner(text) {
         info(msg) { log('ℹ', msg); },
         stop() { },
         get text() { return currentText; },
-        set text(v) { currentText = v; }
+        set text(value) { currentText = value; }
     };
     return stub;
 }
-import path from "path";
-import { homedir } from 'os';
-import { spawnSync } from 'child_process';
-import { fileURLToPath, pathToFileURL } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // Simple logger
@@ -61,11 +59,13 @@ const logger = {
     debug: (msg) => console.log(`${chalk.gray('◉')} ${msg}`)
 };
 // Ensure llmswitch-core is resolvable（dev/worktree 场景下由 pipeline 加载 vendor）
-async function dynamicImport(p) {
-    // Avoid TypeScript/ESM static resolution so we can probe optional entries safely
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval
-    const fn = Function('p', 'return import(p)');
-    return fn(p);
+async function dynamicImport(specifier) {
+    try {
+        return (await import(specifier));
+    }
+    catch {
+        return undefined;
+    }
 }
 async function ensureCoreOrFail() {
     // 在当前 worktree/dev 场景下：
@@ -90,6 +90,7 @@ const pkgVersion = (() => {
         return '0.0.0';
     }
 })();
+const cliVersion = buildInfo?.version ?? pkgVersion;
 // Resolve package name for display / binary naming
 const pkgName = (() => {
     try {
@@ -113,7 +114,7 @@ const DEFAULT_DEV_PORT = 5555;
 program
     .name(pkgName === 'rcc' ? 'rcc' : 'routecodex')
     .description('RouteCodex CLI - Multi-provider OpenAI proxy server and Claude Code interface')
-    .version(pkgVersion);
+    .version(cliVersion);
 // Provider command group - update models and generate minimal provider config
 try {
     const { createProviderUpdateCommand } = await import('./commands/provider-update.js');
@@ -142,9 +143,8 @@ program
     .argument('[extraArgs...]', 'Additional args to pass through to Claude')
     .allowUnknownOption(true)
     .allowExcessArguments(true)
-    .action(async (...cmdArgs) => {
-    const options = cmdArgs.pop(); // Commander passes options as last arg
-    const extraArgsFromCommander = Array.isArray(cmdArgs[0]) ? cmdArgs[0] : [];
+    .action(async (extraArgs = [], options) => {
+    const extraArgsFromCommander = Array.isArray(extraArgs) ? extraArgs : [];
     const spinner = await createSpinner('Preparing Claude Code with RouteCodex...');
     try {
         // Resolve configuration and determine port
@@ -267,10 +267,13 @@ program
             try {
                 const d = options.cwd ? String(options.cwd) : process.cwd();
                 const resolved = path.resolve(d);
-                if (fs.existsSync(resolved))
+                if (fs.existsSync(resolved)) {
                     return resolved;
+                }
+            }
+            catch {
+                return process.cwd();
             }
-            catch { }
             return process.cwd();
         })();
         const claudeEnv = {
@@ -319,8 +322,9 @@ program
             for (let i = 0; i < tail.length; i++) {
                 const tok = tail[i];
                 if (knownOpts.has(tok)) {
-                    if (requireValue.has(tok))
+                    if (requireValue.has(tok)) {
                         i++;
+                    }
                     continue;
                 }
                 // 若是组合形式 --opt=value 且 opt 为已识别的，跳过
@@ -350,16 +354,22 @@ program
                 claudeArgs.push(...merged);
             }
         }
-        catch { /* ignore passthrough errors */ }
+        catch {
+            // ignore passthrough errors
+            void 0;
+        }
         // Launch Claude Code
         const { spawn } = await import('child_process');
         const claudeBin = (() => {
             try {
                 const v = String(options?.claudePath || '').trim();
-                if (v)
+                if (v) {
                     return v;
+                }
+            }
+            catch {
+                // ignore
             }
-            catch { }
             const envPath = String(process.env.CLAUDE_PATH || '').trim();
             return envPath || 'claude';
         })();
@@ -396,7 +406,10 @@ program
             }
         });
         // Keep process alive
-        await new Promise(() => { });
+        await new Promise(() => {
+            // Keep process alive until interrupted
+            return;
+        });
     }
     catch (error) {
         spinner.fail('Failed to launch Claude Code');
@@ -414,34 +427,29 @@ program
     .option('--json', 'Output JSON instead of shell exports')
     .action(async (options) => {
     try {
-        let configPath = options.config;
-        if (!configPath) {
-            configPath = path.join(homedir(), '.routecodex', 'config.json');
-        }
-        let host = options.host || undefined;
-        let port = options.port ? parseInt(String(options.port), 10) : NaN;
+        const configPath = options.config
+            ? options.config
+            : path.join(homedir(), '.routecodex', 'config.json');
+        let host = options.host;
+        let port = normalizePort(options.port);
         if (IS_DEV_PACKAGE) {
-            // dev 包：env>flag>5555，不从配置里解析端口
-            if (!Number.isFinite(port) || port <= 0) {
+            if (!Number.isFinite(port)) {
                 const envPort = Number(process.env.ROUTECODEX_PORT || process.env.RCC_PORT || NaN);
                 port = Number.isFinite(envPort) && envPort > 0 ? envPort : DEFAULT_DEV_PORT;
             }
         }
         else {
-            // release 包：若未显式指定端口，则从配置解析
-            if (!Number.isFinite(port) || port <= 0) {
-                if (fs.existsSync(configPath)) {
-                    try {
-                        const raw = fs.readFileSync(configPath, 'utf8');
-                        const cfg = JSON.parse(raw);
-                        port = (cfg?.httpserver?.port ?? cfg?.server?.port ?? cfg?.port) || port;
-                        host = (cfg?.httpserver?.host || cfg?.server?.host || cfg?.host || host);
-                    }
-                    catch { /* ignore */ }
-                }
+            if (!Number.isFinite(port) && fs.existsSync(configPath)) {
+                const cfg = safeReadJson(configPath);
+                port = normalizePort(cfg?.httpserver?.port ?? cfg?.server?.port ?? cfg?.port);
+                host = typeof cfg?.httpserver?.host === 'string'
+                    ? cfg.httpserver.host
+                    : typeof cfg?.server?.host === 'string'
+                        ? cfg.server.host
+                        : cfg?.host ?? host;
             }
         }
-        if (!Number.isFinite(port) || port <= 0) {
+        if (!Number.isFinite(port) || !port || port <= 0) {
             throw new Error('Missing port. Set via --port, env or config file');
         }
         const norm = (h) => {
@@ -671,7 +679,10 @@ program
             }
         });
         // Do not exit parent; keep process alive to relay signals
-        await new Promise(() => { });
+        await new Promise(() => {
+            // Keep supervisor alive until shutdown completes
+            return;
+        });
     }
     catch (error) {
         spinner.fail('Failed to start server');
@@ -917,7 +928,7 @@ async function initializeConfig(configPath, template, force = false) {
 program
     .command('stop')
     .description('Stop the RouteCodex server')
-    .action(async (options) => {
+    .action(async () => {
     const spinner = await createSpinner('Stopping RouteCodex server...');
     try {
         // Resolve config path and port
@@ -1138,7 +1149,10 @@ program
                 process.exit(code ?? 0);
             }
         });
-        await new Promise(() => { });
+        await new Promise(() => {
+            // Keep CLI alive (never resolves)
+            return;
+        });
     }
     catch (e) {
         spinner.fail(`Failed to restart: ${e.message}`);
@@ -1372,21 +1386,6 @@ program
     console.log('    -d \'{"model": "gpt-4", "messages": [{"role": "user", "content": "Hello!"}]}\'');
     console.log('');
 });
-function determinePort(configPath, fallback) {
-    try {
-        const content = fs.readFileSync(configPath, 'utf8');
-        const config = JSON.parse(content);
-        const candidate = config?.server?.port ?? config?.httpserver?.port ?? config?.port;
-        const parsed = parseInt(candidate, 10);
-        if (!Number.isNaN(parsed) && parsed > 0) {
-            return parsed;
-        }
-    }
-    catch {
-        // ignore parsing errors and fall back
-    }
-    return fallback;
-}
 async function ensurePortAvailable(port, parentSpinner, opts = {}) {
     if (!port || Number.isNaN(port)) {
         return;
@@ -1501,8 +1500,27 @@ function findListeningPids(port) {
         return [];
     }
 }
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+function normalizePort(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return NaN;
+}
+function safeReadJson(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
 }
 // Fallback keypress setup: capture Ctrl+C and 'q' to trigger shutdown when SIGINT is not delivered
 function setupKeypress(onInterrupt) {
@@ -1547,8 +1565,13 @@ function setupKeypress(onInterrupt) {
             };
         }
     }
-    catch { /* ignore */ }
-    return () => { };
+    catch {
+        /* ignore */
+    }
+    return () => {
+        // No-op cleanup when stdin is not interactive
+        return;
+    };
 }
 async function isServerHealthyQuick(port) {
     try {
@@ -1615,7 +1638,9 @@ program
                 try {
                     cmd = spawnSync('ps', ['-o', 'command=', '-p', String(pid)], { encoding: 'utf8' }).stdout.trim();
                 }
-                catch { }
+                catch {
+                    cmd = '';
+                }
                 const origin = /node\s+.*routecodex-worktree/.test(cmd) ? 'local-dev' : (/node\s+.*lib\/node_modules\/routecodex/.test(cmd) ? 'global' : 'unknown');
                 console.log(`  PID ${pid} [${origin}] ${cmd}`);
             }