aicodeswitch 5.1.1 → 5.1.3

package/dist/server/coding-plan-headers.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * 编程套餐 Headers 覆盖模块
+ *
+ * 当 APIService 启用 enableCodingPlan 时，将发送到上游的请求 Headers
+ * 覆盖为对应编程工具（Claude Code / Codex）的标准 Headers，
+ * 使供应商验证通过。
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCodingPlanHeaders = applyCodingPlanHeaders;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * 代理已设置的需要保留的 Headers
+ * 这些 Headers 由 buildUpstreamHeaders 设置，不能被覆盖删除
+ */
+const KEEP_HEADERS = new Set([
+    'authorization', // 认证头
+    'x-api-key', // Claude 认证头
+    'x-goog-api-key', // Gemini 认证头
+    'content-type', // 内容类型
+    'accept', // 接受类型
+    'accept-encoding', // 编码
+    'connection', // 连接
+    'content-length', // 内容长度
+    'anthropic-version', // Claude API 版本
+]);
+/**
+ * 构建 Claude Code 标准请求 Headers
+ */
+function buildClaudeCodeHeaders(sessionId) {
+    return {
+        'user-agent': 'claude-cli/2.1.168 (external, claude-vscode, agent-sdk/0.3.168)',
+        'x-claude-code-session-id': sessionId,
+        'x-stainless-arch': 'arm64',
+        'x-stainless-lang': 'js',
+        'x-stainless-os': 'MacOS',
+        'x-stainless-package-version': '0.94.0',
+        'x-stainless-retry-count': '0',
+        'x-stainless-runtime': 'node',
+        'x-stainless-runtime-version': 'v24.3.0',
+        'x-stainless-timeout': '3000',
+        'anthropic-beta': 'claude-code-20250219,context-1m-2025-08-07,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07,effort-2025-11-24',
+        'anthropic-dangerous-direct-browser-access': 'true',
+        'x-app': 'cli',
+    };
+}
+/**
+ * 构建 Codex 标准请求 Headers
+ */
+function buildCodexHeaders(sessionId) {
+    return {
+        'x-codex-beta-features': 'terminal_resize_reflow,remote_compaction_v2',
+        'x-codex-turn-metadata': JSON.stringify({
+            session_id: sessionId,
+            thread_id: sessionId,
+            thread_source: 'user',
+            turn_id: crypto_1.default.randomUUID(),
+            sandbox: 'none',
+            workspace_kind: 'project',
+            request_kind: 'turn',
+        }),
+        'x-codex-window-id': `${sessionId}:0`,
+        'x-client-request-id': sessionId,
+        'session-id': sessionId,
+        'thread-id': sessionId,
+        'originator': 'codex_vscode',
+        'user-agent': 'codex_vscode/0.137.0-alpha.4 (Mac OS 26.5.0; arm64) unknown (VS Code; 26.602.40724)',
+    };
+}
+/**
+ * 判断 sourceType 是否为 Claude 源
+ */
+function isClaudeSourceType(sourceType) {
+    return sourceType === 'claude' || sourceType === 'claude-chat';
+}
+/**
+ * 判断 sourceType 是否为 OpenAI 源
+ */
+function isOpenAISourceType(sourceType) {
+    return sourceType === 'openai' || sourceType === 'openai-chat';
+}
+/**
+ * 应用编程工具 Headers 覆盖
+ *
+ * 当 service.enableCodingPlan 为 true 时调用。
+ * 清除原始请求中无关的 Headers，注入对应编程工具的标准 Headers。
+ *
+ * - Claude 源（claude/claude-chat）→ 注入 Claude Code Headers
+ * - OpenAI 源（openai/openai-chat）→ 注入 Codex Headers
+ * - Gemini 源不处理，保持原样
+ *
+ * @param headers     当前已构建的上游 Headers（会被原地修改）
+ * @param sourceType  上游服务的源类型
+ */
+function applyCodingPlanHeaders(headers, sourceType) {
+    const isClaude = isClaudeSourceType(sourceType);
+    const isOpenAI = isOpenAISourceType(sourceType);
+    // Gemini 源不需要 Headers 覆盖
+    if (!isClaude && !isOpenAI) {
+        return;
+    }
+    const sessionId = crypto_1.default.randomUUID();
+    // 1. 删除不在保留列表中的 Headers
+    for (const key of Object.keys(headers)) {
+        if (!KEEP_HEADERS.has(key.toLowerCase())) {
+            delete headers[key];
+        }
+    }
+    // 2. 注入编程工具标准 Headers
+    // 2. 注入编程工具标准 Headers
+    const toolHeaders = isClaude
+        ? buildClaudeCodeHeaders(sessionId)
+        : buildCodexHeaders(sessionId);
+    for (const [key, value] of Object.entries(toolHeaders)) {
+        headers[key] = value;
+    }
+    console.log(`\x1b[36m[CodingPlan-Headers]\x1b[0m Applied ${isClaude ? 'Claude Code' : 'Codex'} header override for upstream sourceType=${sourceType}`);
+}

package/dist/server/config-managed-fields.js

@@ -38,6 +38,7 @@ exports.CODEX_CONFIG_MANAGED_FIELDS = [
     { path: ['requires_openai_auth'] },
     { path: ['enableRouteSelection'] },
     { path: ['model_providers', 'aicodeswitch'], isSection: true },
+    { path: ['mcp_servers'], isSection: true, optional: true },
 ];
 /**
  * Codex auth.json 管理字段定义

package/dist/server/conversions/body-sanitizer.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Request body sanitizer for AICodeSwitch proxy.
+ *
+ * Defensively cleans incoming request bodies before format transformation
+ * and upstream forwarding. Catches issues that originate from client bugs
+ * (e.g. Codex sending improperly escaped content) so that upstream APIs
+ * receive well-formed JSON.
+ *
+ * Sanitization steps:
+ * 1. Strip illegal C0 control characters from string values
+ * 2. Fix `function_call.arguments` that are not valid JSON strings
+ * 3. Remove `undefined` values from the object tree
+ * 4. Guard against circular references and excessive depth
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeRequestBody = sanitizeRequestBody;
+// C0 control characters except TAB (0x09), LF (0x0A), CR (0x0D).
+// These are the only three control chars allowed in JSON strings (RFC 8259 §7).
+const CONTROL_CHAR_REGEX = /[\x00-\x08\x0b\x0c\x0e-\x1f]/g;
+const MAX_DEPTH = 64;
+/**
+ * Deep-sanitize a request body object.
+ *
+ * @param body - The parsed request body (a plain JS object).
+ * @returns A new object with fixes applied and a list of human-readable
+ *          change descriptions (empty when nothing was modified).
+ */
+function sanitizeRequestBody(body) {
+    if (body === null || body === undefined || typeof body !== 'object') {
+        return { body, changes: [] };
+    }
+    const changes = [];
+    const seen = new WeakSet();
+    const result = sanitizeValue(body, '', changes, seen, 0);
+    return { body: result, changes };
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function sanitizeValue(value, path, changes, seen, depth) {
+    // Primitive types ----------------------------------------------------------
+    if (value === null)
+        return null;
+    if (value === undefined) {
+        changes.push(`removed undefined at ${path || '$'}`);
+        return null; // replaced with null rather than silently dropped
+    }
+    if (typeof value === 'string') {
+        return sanitizeString(value, path, changes);
+    }
+    if (typeof value !== 'object') {
+        return value; // numbers, booleans — pass through
+    }
+    // Guard: depth -------------------------------------------------------------
+    if (depth >= MAX_DEPTH) {
+        changes.push(`max depth exceeded at ${path || '$'}`);
+        return value;
+    }
+    // Guard: circular reference ------------------------------------------------
+    if (seen.has(value)) {
+        changes.push(`circular reference at ${path || '$'}`);
+        return '[Circular]';
+    }
+    seen.add(value);
+    // Arrays -------------------------------------------------------------------
+    if (Array.isArray(value)) {
+        return value.map((item, i) => {
+            const itemPath = `${path}[${i}]`;
+            const sanitized = sanitizeValue(item, itemPath, changes, seen, depth + 1);
+            // Fix function_call.arguments inside Responses API input arrays
+            if (sanitized !== null &&
+                typeof sanitized === 'object' &&
+                !Array.isArray(sanitized) &&
+                sanitized.type === 'function_call') {
+                fixFunctionCallArguments(sanitized, itemPath, changes);
+            }
+            return sanitized;
+        });
+    }
+    // Plain objects ------------------------------------------------------------
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+        // Remove undefined values entirely
+        if (val === undefined) {
+            changes.push(`removed undefined key ${path}.${key}`);
+            continue;
+        }
+        const childPath = path ? `${path}.${key}` : key;
+        result[key] = sanitizeValue(val, childPath, changes, seen, depth + 1);
+    }
+    // Post-process: fix function_call.arguments in input arrays
+    if (Array.isArray(result.input)) {
+        for (let i = 0; i < result.input.length; i++) {
+            const item = result.input[i];
+            if (item !== null &&
+                typeof item === 'object' &&
+                !Array.isArray(item) &&
+                item.type === 'function_call') {
+                fixFunctionCallArguments(item, `${path}.input[${i}]`, changes);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Strip illegal control characters from a string value.
+ */
+function sanitizeString(str, path, changes) {
+    if (!CONTROL_CHAR_REGEX.test(str))
+        return str;
+    const cleaned = str.replace(CONTROL_CHAR_REGEX, '');
+    changes.push(`stripped control chars at ${path || '$'}`);
+    return cleaned;
+}
+/**
+ * Ensure `arguments` on a function_call item is a valid JSON string.
+ *
+ * The Responses API spec requires `arguments` to be a JSON-encoded string.
+ * If Codex sends a malformed string (e.g. containing raw unescaped content),
+ * we wrap it so downstream code can safely `JSON.parse` it.
+ */
+function fixFunctionCallArguments(item, path, changes) {
+    const args = item.arguments;
+    if (typeof args !== 'string' || args === '')
+        return;
+    // Already valid JSON — nothing to do
+    try {
+        JSON.parse(args);
+        return;
+    }
+    catch (_a) {
+        // Malformed — wrap it
+    }
+    // Wrap the raw string so JSON.parse will succeed downstream
+    item.arguments = JSON.stringify({ _raw: args });
+    changes.push(`fixed invalid arguments at ${path}`);
+}

package/dist/server/conversions/index.js

@@ -15,7 +15,7 @@
  * is driven by the ReasoningConfig passed through TransformRequestOptions.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processCompactResponse = exports.prepareCompactRequest = exports.buildCompactedResponse = exports.extractSummaryFromResponse = exports.buildCompactUpstreamRequest = exports.buildCompactionPrompt = exports.COMPACTION_SYSTEM_PROMPT = exports.isCodexCompactRequest = exports.isLastClaudeMessageCompact = exports.isClaudeCompactRequest = exports.extractMessageContent = exports.extractConversationText = exports.getReasoningConfig = exports.sourceTypeToFormat = exports.detectRequestFormat = void 0;
+exports.processCompactResponse = exports.prepareCompactRequest = exports.buildCompactedResponse = exports.extractSummaryFromResponse = exports.buildCompactUpstreamRequest = exports.buildCompactionPrompt = exports.COMPACTION_SYSTEM_PROMPT = exports.isCodexCompactRequest = exports.isLastClaudeMessageCompact = exports.isClaudeCompactRequest = exports.extractMessageContent = exports.extractConversationText = exports.sanitizeRequestBody = exports.getServerToolSupport = exports.getReasoningConfig = exports.sourceTypeToFormat = exports.detectRequestFormat = void 0;
 exports.transformRequest = transformRequest;
 exports.transformResponse = transformResponse;
 exports.createStreamConverter = createStreamConverter;
@@ -26,6 +26,12 @@ Object.defineProperty(exports, "sourceTypeToFormat", { enumerable: true, get: fu
 var providers_js_1 = require("./thinking/providers.js");
 Object.defineProperty(exports, "getReasoningConfig", { enumerable: true, get: function () { return providers_js_1.getReasoningConfig; } });
 const providers_js_2 = require("./thinking/providers.js");
+var providers_js_3 = require("./server-tool/providers.js");
+Object.defineProperty(exports, "getServerToolSupport", { enumerable: true, get: function () { return providers_js_3.getServerToolSupport; } });
+const mapper_js_1 = require("./server-tool/mapper.js");
+// --- Body sanitizer ---
+var body_sanitizer_js_1 = require("./body-sanitizer.js");
+Object.defineProperty(exports, "sanitizeRequestBody", { enumerable: true, get: function () { return body_sanitizer_js_1.sanitizeRequestBody; } });
 // --- Compact API ---
 var compact_js_1 = require("./compact.js");
 Object.defineProperty(exports, "extractConversationText", { enumerable: true, get: function () { return compact_js_1.extractConversationText; } });
@@ -84,7 +90,8 @@ const request_js_13 = require("./pairs/gemini-responses/request.js");
 const response_js_12 = require("./pairs/gemini-responses/response.js");
 const streaming_js_12 = require("./pairs/gemini-responses/streaming.js");
 // --- Provider-driven post-processing ---
-const mapper_js_1 = require("./thinking/mapper.js");
+const mapper_js_2 = require("./thinking/mapper.js");
+const tool_result_js_1 = require("./utils/tool-result.js");
 const effort_js_1 = require("./thinking/effort.js");
 // ============================================================
 // Public API: Request Transformation
@@ -197,63 +204,69 @@ function createStreamConverter(options) {
  * with provider-driven post-processing for completions targets.
  */
 function buildTargetBody(options) {
-    const { fromFormat, toFormat, body, sanitizeBody, providerConfig } = options;
+    const { fromFormat, toFormat, sanitizeBody, providerConfig, serverToolConfig } = options;
+    // Pre-processing: convert server_tool_use → tool_use when upstream doesn't support it.
+    // Must happen before format conversion so all pair transformers handle the blocks correctly.
+    let processedBody = options.body;
+    if (fromFormat === 'claude' && !(serverToolConfig === null || serverToolConfig === void 0 ? void 0 : serverToolConfig.supportsServerToolUse)) {
+        processedBody = (0, mapper_js_1.convertServerToolUseToToolUse)(processedBody);
+    }
     // Dispatch to the correct conversion pair
     const key = `${fromFormat}->${toFormat}`;
     let result;
     switch (key) {
         // --- claude → * ---
         case 'claude->completions':
-            result = (0, request_js_1.claudeToCompletions)(body);
+            result = (0, request_js_1.claudeToCompletions)(processedBody);
             break;
         case 'claude->responses':
-            result = (0, request_js_2.claudeToResponses)(body);
+            result = (0, request_js_2.claudeToResponses)(processedBody);
             break;
         case 'claude->gemini':
-            result = (0, request_js_3.claudeToGemini)(body);
+            result = (0, request_js_3.claudeToGemini)(processedBody);
             break;
         // --- responses → * ---
         case 'responses->completions':
-            result = (0, request_js_8.responsesToCompletions)(body);
+            result = (0, request_js_8.responsesToCompletions)(processedBody);
             break;
         case 'responses->claude':
-            result = (0, request_js_7.responsesToClaude)(body);
+            result = (0, request_js_7.responsesToClaude)(processedBody);
             break;
         case 'responses->gemini':
-            result = (0, request_js_9.responsesToGeminiRequest)(body);
+            result = (0, request_js_9.responsesToGeminiRequest)(processedBody);
             break;
         case 'responses->responses': {
             if (sanitizeBody) {
                 // Responses 格式降级兼容：委托给 responses-responses pair 处理
-                result = (0, request_js_10.downgradeResponsesRequest)(body);
+                result = (0, request_js_10.downgradeResponsesRequest)(processedBody);
             }
             else {
-                result = body;
+                result = processedBody;
             }
             break;
         }
         // --- completions → * ---
         case 'completions->claude':
-            result = (0, request_js_4.completionsToClaude)(body);
+            result = (0, request_js_4.completionsToClaude)(processedBody);
             break;
         case 'completions->responses':
-            result = (0, request_js_5.completionsToResponses)(body);
+            result = (0, request_js_5.completionsToResponses)(processedBody);
             break;
         case 'completions->gemini':
-            result = (0, request_js_6.completionsToGemini)(body);
+            result = (0, request_js_6.completionsToGemini)(processedBody);
             break;
         // --- gemini → * ---
         case 'gemini->claude':
-            result = (0, request_js_11.geminiToClaude)(body);
+            result = (0, request_js_11.geminiToClaude)(processedBody);
             break;
         case 'gemini->completions':
-            result = (0, request_js_12.geminiToCompletions)(body);
+            result = (0, request_js_12.geminiToCompletions)(processedBody);
             break;
         case 'gemini->responses':
-            result = (0, request_js_13.geminiToResponsesRequest)(body);
+            result = (0, request_js_13.geminiToResponsesRequest)(processedBody);
             break;
         default:
-            result = body;
+            result = processedBody;
     }
     // --- Provider-driven post-processing for completions targets ---
     if (toFormat === 'completions' && providerConfig) {
@@ -261,21 +274,33 @@ function buildTargetBody(options) {
         if (isReasoningContentCompletion) {
             // 修复历史：确保 assistant + tool_calls 消息有 reasoning_content
             if (result.messages) {
-                result.messages = (0, mapper_js_1.fixThinkingHistory)(result.messages, 'completions');
+                result.messages = (0, mapper_js_2.fixThinkingHistory)(result.messages, 'completions');
             }
             // 剥离 stream_options（reasoning_content 提供商通常不支持）
             delete result.stream_options;
         }
         // 注入 thinking 参数（如 thinking: { type: 'enabled' }）和 effort 参数
         if (providerConfig.supportsThinking || providerConfig.supportsEffort) {
-            const effort = body.thinking ? (0, effort_js_1.claudeThinkingToReasoningEffort)(body.thinking) : null;
+            const effort = processedBody.thinking ? (0, effort_js_1.claudeThinkingToReasoningEffort)(processedBody.thinking) : null;
             result = (0, providers_js_2.applyReasoningConfig)(result, providerConfig, effort);
         }
     }
+    // --- Provider-driven: convert redacted_thinking → thinking for providers that don't support redacted_thinking ---
+    // DeepSeek 等 provider 的 Anthropic 端点不识别 redacted_thinking，需要转换为 thinking 块
+    if (toFormat === 'claude' && (providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.supportsThinking) && result.messages) {
+        result.messages = (0, mapper_js_2.convertRedactedThinkingForProvider)(result.messages);
+    }
     // --- Safety net for Claude upstream: ensure thinking blocks alongside tool_use ---
     // When thinking mode is enabled, Claude requires thinking blocks in assistant messages with tool_use
     if (toFormat === 'claude' && result.thinking && result.messages) {
-        result.messages = (0, mapper_js_1.fixThinkingHistory)(result.messages, 'claude');
+        result.messages = (0, mapper_js_2.fixThinkingHistory)(result.messages, 'claude');
+    }
+    // --- Ensure tool_result blocks have id for Claude-compatible providers ---
+    // Some providers (e.g. GLM) require an id field on tool_result content blocks,
+    // but standard Claude API tool_result blocks only have tool_use_id without id.
+    if (toFormat === 'claude' && result.messages) {
+        const { messages: patchedMessages } = (0, tool_result_js_1.ensureToolResultIds)(result.messages);
+        result.messages = patchedMessages;
     }
     return result;
 }

package/dist/server/conversions/server-tool/mapper.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Server tool use content block transformation.
+ *
+ * Converts server_tool_use blocks to regular tool_use blocks so that upstream
+ * providers which do not recognise the server_tool_use type can still process
+ * the conversation history correctly.
+ *
+ * Conversion is simple: only the `type` field changes from 'server_tool_use'
+ * to 'tool_use'. The `id`, `name`, and `input` fields are preserved, and
+ * matching `tool_result` blocks (which reference by `tool_use_id`) remain valid.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertServerToolUseToToolUse = convertServerToolUseToToolUse;
+/**
+ * Convert all server_tool_use content blocks in the request body to tool_use.
+ *
+ * Scans assistant messages in body.messages and replaces the block type.
+ * Returns a shallow-cloned body with modified messages; original body is not mutated.
+ */
+function convertServerToolUseToToolUse(body) {
+    if (!(body === null || body === void 0 ? void 0 : body.messages) || !Array.isArray(body.messages)) {
+        return body;
+    }
+    let modified = false;
+    const newMessages = body.messages.map((msg) => {
+        // server_tool_use only appears in assistant messages
+        if (msg.role !== 'assistant' || !Array.isArray(msg.content)) {
+            return msg;
+        }
+        let msgModified = false;
+        const newContent = msg.content.map((block) => {
+            if ((block === null || block === void 0 ? void 0 : block.type) === 'server_tool_use') {
+                msgModified = true;
+                return Object.assign(Object.assign({}, block), { type: 'tool_use' });
+            }
+            return block;
+        });
+        if (msgModified) {
+            modified = true;
+            return Object.assign(Object.assign({}, msg), { content: newContent });
+        }
+        return msg;
+    });
+    if (!modified) {
+        return body;
+    }
+    return Object.assign(Object.assign({}, body), { messages: newMessages });
+}

package/dist/server/conversions/server-tool/providers.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Server tool use (server_tool_use) provider support detection.
+ *
+ * server_tool_use is a Claude-specific content block type used by built-in
+ * server-side tools (e.g. webReader). Most third-party Claude-compatible APIs
+ * do not accept this type in request messages. This module detects whether the
+ * upstream provider supports it natively, following the same pattern as
+ * thinking/providers.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_CONFIG = exports.DEFAULT_CONFIG = void 0;
+exports.getServerToolSupport = getServerToolSupport;
+/**
+ * Providers known to support server_tool_use content blocks in request messages.
+ * Detection is based on URL / provider name substring matching.
+ */
+const SUPPORTED_PATTERNS = [
+    'api.anthropic.com',
+    'anthropic',
+];
+const SUPPORTED_CONFIG = { supportsServerToolUse: true };
+exports.SUPPORTED_CONFIG = SUPPORTED_CONFIG;
+const DEFAULT_CONFIG = { supportsServerToolUse: false };
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+/**
+ * Detect whether the upstream provider supports server_tool_use content blocks.
+ *
+ * @param providerName  Service name (e.g. "Anthropic", "OpenRouter")
+ * @param baseUrl       Service API URL
+ */
+function getServerToolSupport(providerName, baseUrl) {
+    const haystack = `${providerName} ${baseUrl}`.toLowerCase();
+    for (const pattern of SUPPORTED_PATTERNS) {
+        if (haystack.includes(pattern)) {
+            return SUPPORTED_CONFIG;
+        }
+    }
+    return DEFAULT_CONFIG;
+}

package/dist/server/conversions/thinking/mapper.js

@@ -7,6 +7,7 @@ exports.thinkingToReasoningContent = thinkingToReasoningContent;
 exports.reasoningContentToThinking = reasoningContentToThinking;
 exports.reasoningToThinking = reasoningToThinking;
 exports.thinkingToReasoningSummary = thinkingToReasoningSummary;
+exports.convertRedactedThinkingForProvider = convertRedactedThinkingForProvider;
 exports.fixThinkingHistory = fixThinkingHistory;
 exports.redactedThinkingPlaceholder = redactedThinkingPlaceholder;
 /** Claude thinking text → reasoning_content string */
@@ -29,6 +30,26 @@ function reasoningToThinking(summary) {
 function thinkingToReasoningSummary(thinking) {
     return [{ type: 'summary_text', text: thinking }];
 }
+/**
+ * 将 assistant 消息中的 redacted_thinking 块转换为 thinking 块。
+ * 用于不支持 redacted_thinking 的上游 provider（如 DeepSeek Anthropic 端点）。
+ *
+ * DeepSeek V4 模型的 Anthropic 兼容端点在 thinking 模式下仅识别 content[].thinking，
+ * 不识别 redacted_thinking 类型。Claude Code 在多轮对话中会将历史 thinking 压缩为
+ * redacted_thinking 以节省 token，因此需要在转发前做转换。
+ */
+function convertRedactedThinkingForProvider(messages) {
+    return messages.map(msg => {
+        if (msg.role !== 'assistant' || !Array.isArray(msg.content))
+            return msg;
+        const hasRedacted = msg.content.some((b) => b.type === 'redacted_thinking');
+        if (!hasRedacted)
+            return msg;
+        return Object.assign(Object.assign({}, msg), { content: msg.content.map((b) => b.type === 'redacted_thinking'
+                ? { type: 'thinking', thinking: '[thinking content redacted]' }
+                : b) });
+    });
+}
 /** Fix history messages: ensure thinking/reasoning_content is present alongside tool use */
 function fixThinkingHistory(messages, format) {
     return messages.map(msg => {

package/dist/server/conversions/utils/tool-result.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Tool result content block utilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureToolResultIds = ensureToolResultIds;
+/**
+ * 为所有缺少 id 的 tool_result 块补上 id。
+ *
+ * 部分 Claude 兼容端点（如 GLM）要求 tool_result 内容块必须包含 id 字段，
+ * 但标准 Claude API 的 tool_result 块仅有 tool_use_id 而不带 id。
+ *
+ * id 取值策略：优先使用 tool_use_id（与对应的 tool_use.id 保持一致），
+ * 若 tool_use_id 也不存在则生成唯一 id。
+ */
+function ensureToolResultIds(messages) {
+    let totalPatched = 0;
+    const result = messages.map(msg => {
+        if (msg.role !== 'user' || !Array.isArray(msg.content))
+            return msg;
+        let patched = false;
+        const newContent = msg.content.map((b) => {
+            if (b.type === 'tool_result' && !b.id) {
+                patched = true;
+                totalPatched++;
+                // 使用 tool_use_id 作为 id，保持与对应 tool_use 块的 id 一致
+                const id = b.tool_use_id || `toolu_${crypto.randomUUID().replace(/-/g, '').slice(0, 24)}`;
+                return Object.assign(Object.assign({}, b), { id });
+            }
+            return b;
+        });
+        return patched ? Object.assign(Object.assign({}, msg), { content: newContent }) : msg;
+    });
+    return { messages: result, patchedCount: totalPatched };
+}

package/dist/server/fs-database.js

@@ -1597,6 +1597,18 @@ class FileSystemDatabaseManager {
             yield this.saveRules();
             this.routes.splice(index, 1);
             yield this.saveRoutes();
+            // 级联清理：清除绑定到该路由的会话的绑定关系
+            let sessionChanged = false;
+            for (const session of this.sessions) {
+                if (session.routeId === id) {
+                    session.routeId = undefined;
+                    session.routeName = undefined;
+                    sessionChanged = true;
+                }
+            }
+            if (sessionChanged) {
+                yield this.saveSessions();
+            }
             return true;
         });
     }
@@ -3052,6 +3064,11 @@ class FileSystemDatabaseManager {
                 existing.highIqRuleId = session.highIqRuleId;
             if (Object.prototype.hasOwnProperty.call(session, 'highIqEnabledAt'))
                 existing.highIqEnabledAt = session.highIqEnabledAt;
+            // 保留已有的路由绑定（不传入时不覆盖）
+            if (session.routeId !== undefined)
+                existing.routeId = session.routeId;
+            if (session.routeName !== undefined)
+                existing.routeName = session.routeName;
         }
         else {
             // 创建新 session
@@ -3071,11 +3088,52 @@ class FileSystemDatabaseManager {
                 highIqMode: session.highIqMode,
                 highIqRuleId: session.highIqRuleId,
                 highIqEnabledAt: session.highIqEnabledAt,
+                routeId: session.routeId,
+                routeName: session.routeName,
             });
         }
         // 异步保存（不阻塞）
         this.saveSessions().catch(console.error);
     }
+    /**
+     * 绑定会话到路由
+     */
+    bindSessionRoute(sessionId, routeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = this.sessions.find(s => s.id === sessionId);
+            if (!session)
+                return null;
+            const route = this.routes.find(r => r.id === routeId);
+            if (!route)
+                return null;
+            session.routeId = routeId;
+            session.routeName = route.name;
+            yield this.saveSessions();
+            return session;
+        });
+    }
+    /**
+     * 解绑会话路由
+     */
+    unbindSessionRoute(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = this.sessions.find(s => s.id === sessionId);
+            if (!session)
+                return false;
+            session.routeId = undefined;
+            session.routeName = undefined;
+            yield this.saveSessions();
+            return true;
+        });
+    }
+    /**
+     * 获取绑定到指定路由的所有会话
+     */
+    getBoundSessions(routeId) {
+        return this.sessions
+            .filter(s => s.routeId === routeId)
+            .sort((a, b) => b.lastRequestAt - a.lastRequestAt);
+    }
     // 新增方法：获取规则黑名单状态
     getRuleBlacklistStatus(serviceId, routeId, contentType) {
         return __awaiter(this, void 0, void 0, function* () {