@jsonstudio/llms 0.4.3 → 0.4.4

package/dist/conversion/conversion-v3/nodes/process/chat-process-node.js

@@ -1,854 +0,0 @@
-/**
- * Chat 处理节点
- *
- * 负责核心的 Chat 处理逻辑，包括工具调用处理、上下文管理等
- */
-import { BaseProcessNode } from './base-process-node.js';
-import { NodeType, ConversionError } from '../../types/index.js';
-import { runChatRequestToolFilters } from '../../../shared/tool-filter-pipeline.js';
-/**
- * Chat 处理节点实现
- *
- * 执行 Chat 请求的核心处理逻辑
- */
-export class ChatProcessNode extends BaseProcessNode {
-    constructor(config) {
-        super('chat-process', NodeType.PROCESS, 'Chat Process Node', config);
-    }
-    /**
-     * 处理请求核心逻辑
-     */
-    async processRequest(standardizedRequest, context) {
-        const processingStartTime = Date.now();
-        const governedRequest = await this.applyRequestToolGovernance(standardizedRequest, context);
-        const normalizedRequest = this.normalizeToolPayload(governedRequest);
-        // 1. 并行执行各项处理
-        const [processedMessages, toolCallResult, contextResult, streamingResult, parameterProcessing] = await Promise.all([
-            this.processMessages(normalizedRequest.messages, context),
-            this.processToolCalls(normalizedRequest.messages, normalizedRequest.tools, context),
-            this.processContext(normalizedRequest.metadata, context),
-            this.processStreaming(normalizedRequest.parameters, context),
-            this.processParameters(normalizedRequest.parameters, context)
-        ]);
-        // 2. 应用业务规则和优化（仅消息优化，保持工具列表不变）
-        const optimizedMessages = await this.optimizeMessages(processedMessages, toolCallResult, contextResult);
-        // 移除破坏性的工具优化，保持原有工具列表以支持服务器工具注入
-        const optimizedTools = normalizedRequest.tools;
-        // 3. 构建处理后的请求
-        const processedRequest = {
-            ...normalizedRequest,
-            messages: optimizedMessages,
-            tools: optimizedTools,
-            parameters: {
-                ...normalizedRequest.parameters,
-                ...parameterProcessing
-            },
-            processed: {
-                timestamp: processingStartTime,
-                appliedRules: [
-                    'tool-call-processing',
-                    'context-management',
-                    'streaming-handling',
-                    'parameter-normalization'
-                ],
-                status: this.determineProcessingStatus(toolCallResult, contextResult)
-            },
-            processingMetadata: {
-                toolCalls: toolCallResult.requiresToolExecution ? [
-                    {
-                        tool_call_id: 'unknown',
-                        status: 'pending',
-                        result: undefined,
-                        error: undefined,
-                        executionTime: undefined
-                    }
-                ] : undefined,
-                streaming: streamingResult,
-                context: contextResult
-            }
-        };
-        return processedRequest;
-    }
-    /**
-     * 后置处理请求
-     */
-    async postprocessRequest(processedRequest, context) {
-        // 1. 最终验证
-        this.validateProcessedRequest(processedRequest);
-        // 2. 应用优化策略
-        const optimizedRequest = await this.applyOptimizations(processedRequest, context);
-        // 3. 更新处理状态
-        optimizedRequest.processed.timestamp = Date.now();
-        return optimizedRequest;
-    }
-    /**
-     * 工具治理：在 Process 节点内部统一处理
-     */
-    async applyRequestToolGovernance(request, context) {
-        try {
-            const entryEndpointRaw = context.request.context?.['entryEndpoint'];
-            const entryEndpoint = typeof entryEndpointRaw === 'string'
-                ? entryEndpointRaw
-                : context.request.endpoint || '/v1/chat/completions';
-            const rawMetadata = context.request.context?.['metadata'];
-            const metadata = rawMetadata && typeof rawMetadata === 'object'
-                ? { ...rawMetadata }
-                : {};
-            const providerProtocol = typeof metadata.providerProtocol === 'string'
-                ? metadata.providerProtocol
-                : typeof metadata.provider === 'string'
-                    ? metadata.provider
-                    : 'openai-chat';
-            const metadataToolHints = metadata['toolFilterHints'];
-            const metadataStreamFlag = metadata['stream'];
-            const metadataStream = typeof metadataStreamFlag === 'boolean'
-                ? metadataStreamFlag
-                : request.parameters?.stream === true;
-            const profile = { outgoingProtocol: providerProtocol };
-            const toolContext = {
-                requestId: context.request.id,
-                entryEndpoint,
-                metadata: {
-                    ...metadata,
-                    toolFilterHints: metadataToolHints,
-                    stream: metadataStream
-                }
-            };
-            const shaped = {
-                model: request.model,
-                messages: this.deepClone(request.messages),
-                tools: request.tools ? this.deepClone(request.tools) : undefined,
-                tool_choice: request.parameters?.tool_choice,
-                stream: request.parameters?.stream === true,
-                parameters: { ...request.parameters }
-            };
-            // 运行完整的工具治理流程，获取所有治理结果
-            const governed = await runChatRequestToolFilters(shaped, {
-                entryEndpoint,
-                requestId: context.request.id,
-                model: request.model,
-                profile: profile.outgoingProtocol,
-                stream: toolContext.metadata?.stream === true,
-                toolFilterHints: metadataToolHints
-            });
-            // 完整复制治理结果，不丢弃任何信息
-            const finalRequest = {
-                ...request,
-                // 保留所有governed结果
-                ...governed,
-                // 确保元数据正确设置，优先使用governed结果
-                metadata: {
-                    ...request.metadata,
-                    toolChoice: governed?.tool_choice,
-                    originalStream: request.parameters?.stream === true,
-                    stream: governed?.stream !== undefined ? governed.stream : request.parameters?.stream,
-                    governedTools: governed?.tools !== undefined,
-                    governanceTimestamp: Date.now()
-                }
-            };
-            // 确保tools正确设置
-            if (governed?.tools !== undefined) {
-                finalRequest.tools = this.castGovernedTools(governed.tools);
-            }
-            // 关键修复：确保governed的顶级参数（如stream）正确传播到parameters
-            // 这确保下游节点使用治理后的参数值，而不是原始值
-            if (governed?.stream !== undefined) {
-                finalRequest.parameters = {
-                    ...finalRequest.parameters,
-                    stream: governed.stream
-                };
-            }
-            // 确保tool_choice正确设置
-            if (governed?.tool_choice !== undefined) {
-                finalRequest.parameters = {
-                    ...finalRequest.parameters,
-                    tool_choice: governed.tool_choice
-                };
-            }
-            return finalRequest;
-        }
-        catch {
-            return request;
-        }
-    }
-    /**
-     * 深拷贝工具/消息，避免 FilterEngine 副作用
-     */
-    deepClone(value) {
-        if (value === undefined)
-            return value;
-        return JSON.parse(JSON.stringify(value));
-    }
-    /**
-     * 过滤器输出 → 标准化工具定义
-     */
-    castGovernedTools(tools) {
-        if (!Array.isArray(tools))
-            return [];
-        const normalized = [];
-        for (const tool of tools) {
-            // 1) 优先按标准 function 形状解析
-            const converted = this.castSingleTool(tool);
-            if (converted) {
-                normalized.push(converted);
-                continue;
-            }
-            // 2) 兼容 custom 形状映射（例如 apply_patch 自定义工具）
-            const custom = this.castCustomTool(tool);
-            if (custom) {
-                normalized.push(custom);
-                continue;
-            }
-        }
-        return normalized;
-    }
-    castSingleTool(tool) {
-        if (!tool || typeof tool !== 'object')
-            return null;
-        const toolObj = tool;
-        const fn = toolObj.function;
-        if (!fn || typeof fn !== 'object')
-            return null;
-        const fnObj = fn;
-        const name = typeof fnObj.name === 'string' ? fnObj.name : undefined;
-        if (!name)
-            return null;
-        const parameters = this.castToolParameters(fnObj.parameters);
-        const description = typeof fnObj.description === 'string' ? fnObj.description : undefined;
-        const strictFlag = fnObj.strict === true || toolObj.strict === true;
-        return {
-            type: 'function',
-            function: {
-                name,
-                description,
-                parameters,
-                strict: strictFlag ? true : undefined
-            }
-        };
-    }
-    castToolParameters(params) {
-        if (params && typeof params === 'object' && !Array.isArray(params)) {
-            const paramsObj = params;
-            const properties = paramsObj.properties && typeof paramsObj.properties === 'object'
-                ? paramsObj.properties
-                : {};
-            const required = Array.isArray(paramsObj.required)
-                ? paramsObj.required
-                : undefined;
-            const additionalProperties = typeof paramsObj.additionalProperties === 'boolean'
-                ? paramsObj.additionalProperties
-                : undefined;
-            return {
-                type: 'object',
-                properties,
-                required,
-                additionalProperties
-            };
-        }
-        return {
-            type: 'object',
-            properties: {},
-            additionalProperties: true
-        };
-    }
-    /**
-     * 将常见的自定义工具映射为标准 function 工具。
-     * 目前仅内置 apply_patch 的规范化：
-     * - 输入 custom 形状（例如 { type:'custom', name:'apply_patch', ... }）
-     * - 输出 { type:'function', function:{ name:'apply_patch', parameters:{ patch:string } } }
-     */
-    castCustomTool(tool) {
-        try {
-            if (!tool || typeof tool !== 'object')
-                return null;
-            const t = tool;
-            const type = typeof t.type === 'string' ? t.type.toLowerCase() : '';
-            const name = typeof t.name === 'string' ? String(t.name) : '';
-            if (type !== 'custom' || !name)
-                return null;
-            // 仅为 apply_patch 提供内置映射，其它 custom 工具保持由治理/白名单控制
-            if (name.trim() === 'apply_patch') {
-                const description = typeof t.description === 'string' ? t.description : undefined;
-                // 规范化为要求一个字符串字段 patch 的函数工具
-                const parameters = {
-                    type: 'object',
-                    properties: {
-                        patch: { type: 'string', description: 'Unified diff patch content (FREEFORM, not JSON)' }
-                    },
-                    required: ['patch'],
-                    additionalProperties: false
-                };
-                return {
-                    type: 'function',
-                    function: {
-                        name: 'apply_patch',
-                        description: description,
-                        parameters,
-                        strict: true
-                    }
-                };
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * 处理消息
-     */
-    async processMessages(messages, context) {
-        const processedMessages = [];
-        for (const message of messages) {
-            try {
-                const processedMessage = await this.processSingleMessage(message, context);
-                processedMessages.push(processedMessage);
-            }
-            catch (error) {
-                throw new ConversionError(`Failed to process message with role ${message.role}: ${error instanceof Error ? error.message : 'Unknown error'}`, this.id, 'message_processing', error instanceof Error ? error : undefined);
-            }
-        }
-        return this.enforceToolResponseOrdering(processedMessages);
-    }
-    enforceToolResponseOrdering(messages) {
-        if (!messages.length) {
-            return messages;
-        }
-        const ordered = [];
-        const assistantMap = new Map();
-        const append = (message) => {
-            ordered.push(message);
-        };
-        for (const message of messages) {
-            if (message.role === 'assistant' && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
-                append(message);
-                for (const toolCall of message.tool_calls) {
-                    if (toolCall?.id) {
-                        assistantMap.set(toolCall.id, { message, inserted: 0 });
-                    }
-                }
-                continue;
-            }
-            if (message.role === 'tool' && typeof message.tool_call_id === 'string' && message.tool_call_id.trim()) {
-                const meta = assistantMap.get(message.tool_call_id.trim());
-                if (meta) {
-                    const baseIndex = ordered.indexOf(meta.message);
-                    if (baseIndex >= 0) {
-                        const insertPos = baseIndex + 1 + meta.inserted;
-                        ordered.splice(insertPos, 0, message);
-                        meta.inserted += 1;
-                        continue;
-                    }
-                }
-            }
-            append(message);
-        }
-        return ordered;
-    }
-    /**
-     * 处理单个消息
-     */
-    async processSingleMessage(message, context) {
-        const processedMessage = {
-            role: message.role,
-            content: message.content
-        };
-        // 处理内容
-        if (message.content !== null && message.content !== undefined) {
-            processedMessage.content = this.processMessageContent(message.content, context);
-        }
-        // 处理工具调用
-        if (message.tool_calls && message.tool_calls.length > 0) {
-            if (!this.validateToolCalls(message.tool_calls)) {
-                throw new ConversionError(`Invalid tool_calls format in message with role ${message.role}`, this.id, 'validation');
-            }
-            processedMessage.tool_calls = message.tool_calls.map(tc => {
-                const normalized = this.normalizeToolCallArguments(tc.function.name, tc.function.arguments);
-                return {
-                    ...tc,
-                    function: {
-                        name: normalized.name,
-                        arguments: normalized.arguments
-                    }
-                };
-            });
-        }
-        // 处理工具调用ID（仅 tool 角色）
-        if (message.tool_call_id) {
-            if (typeof message.tool_call_id !== 'string' || !message.tool_call_id.trim()) {
-                throw new ConversionError('tool_call_id must be a non-empty string', this.id, 'validation');
-            }
-            processedMessage.tool_call_id = message.tool_call_id.trim();
-        }
-        // 保留其他元数据
-        if (message.name) {
-            processedMessage.name = message.name;
-        }
-        if (message.metadata) {
-            processedMessage.metadata = { ...message.metadata };
-        }
-        return processedMessage;
-    }
-    /**
-     * 处理消息内容
-     */
-    processMessageContent(content, context) {
-        if (typeof content !== 'string') {
-            try {
-                content = String(content);
-            }
-            catch {
-                throw new ConversionError('Message content must be convertible to string', this.id, 'content_processing');
-            }
-        }
-        // 内容清理和标准化
-        return content
-            .trim()
-            .replace(/\r\n/g, '\n') // 标准化换行符
-            .replace(/\n{3,}/g, '\n\n'); // 减少多余空行
-    }
-    /**
-     * 处理工具调用
-     */
-    async processToolCalls(messages, tools, context) {
-        const toolCallMessages = messages.filter(m => m.role === 'assistant' && m.tool_calls);
-        const toolResultMessages = messages.filter(m => m.role === 'tool');
-        const processedToolCalls = [];
-        const toolResults = [];
-        const missingResults = [];
-        // 处理工具调用
-        for (const message of toolCallMessages) {
-            if (message.tool_calls) {
-                for (const toolCall of message.tool_calls) {
-                    // 验证工具调用是否在可用工具列表中
-                    if (tools && !this.isToolAvailable(toolCall.function.name, tools)) {
-                        throw new ConversionError(`Tool '${toolCall.function.name}' is not available in the tools list`, this.id, 'tool_validation');
-                    }
-                    const normalized = this.normalizeToolCallArguments(toolCall.function.name, toolCall.function.arguments);
-                    processedToolCalls.push({
-                        id: toolCall.id,
-                        type: toolCall.type,
-                        function: {
-                            name: normalized.name,
-                            arguments: normalized.arguments
-                        }
-                    });
-                    // 检查是否有对应的工具结果
-                    const hasResult = toolResultMessages.some(tr => tr.tool_call_id === toolCall.id);
-                    if (!hasResult) {
-                        missingResults.push(toolCall.id);
-                    }
-                }
-            }
-        }
-        // 处理工具结果
-        for (const message of toolResultMessages) {
-            if (!this.validateToolResults([message])) {
-                throw new ConversionError(`Invalid tool result format for tool_call_id: ${message.tool_call_id}`, this.id, 'tool_validation');
-            }
-            toolResults.push(message);
-        }
-        return {
-            processedToolCalls: processedToolCalls.length > 0 ? processedToolCalls : undefined,
-            toolResults,
-            requiresToolExecution: processedToolCalls.length > 0 && missingResults.length > 0,
-            missingResults
-        };
-    }
-    /**
-     * 处理上下文
-     */
-    async processContext(metadata, context) {
-        const contextResult = {
-            systemPrompt: undefined,
-            conversationHistory: [],
-            relevantContext: {},
-            contextSize: 0
-        };
-        // 提取系统提示词
-        if (metadata.capturedContext?.systemPrompt) {
-            const systemPrompt = metadata.capturedContext.systemPrompt;
-            if (typeof systemPrompt === 'string') {
-                contextResult.systemPrompt = systemPrompt.trim();
-            }
-        }
-        // 提取对话历史
-        if (metadata.capturedContext?.conversationHistory) {
-            const history = metadata.capturedContext.conversationHistory;
-            if (Array.isArray(history)) {
-                contextResult.conversationHistory = history
-                    .filter(h => typeof h === 'string')
-                    .map(h => h.trim());
-            }
-        }
-        // 提取相关上下文
-        if (metadata.capturedContext?.relevantContext) {
-            const relevantContext = metadata.capturedContext.relevantContext;
-            if (relevantContext && typeof relevantContext === 'object') {
-                contextResult.relevantContext = relevantContext;
-            }
-        }
-        // 计算上下文大小
-        contextResult.contextSize =
-            (contextResult.systemPrompt?.length || 0) +
-                contextResult.conversationHistory.reduce((sum, h) => sum + h.length, 0) +
-                JSON.stringify(contextResult.relevantContext).length;
-        return contextResult;
-    }
-    /**
-     * 处理流式
-     */
-    async processStreaming(parameters, context) {
-        const stream = parameters?.stream;
-        const streamingResult = {
-            enabled: stream === true,
-            chunkSize: 1000, // 默认块大小
-            streamingFormat: 'sse' // 默认使用 SSE
-        };
-        if (streamingResult.enabled) {
-            // 根据上下文确定流式格式
-            if (context.request.options?.streamingFormat) {
-                const format = context.request.options.streamingFormat;
-                if (['sse', 'websocket', 'polling'].includes(format)) {
-                    streamingResult.streamingFormat = format;
-                }
-            }
-            // 处理最大token数
-            if (parameters?.max_tokens) {
-                const maxTokens = parameters.max_tokens;
-                if (typeof maxTokens === 'number' && maxTokens > 0) {
-                    streamingResult.maxTokens = maxTokens;
-                }
-            }
-        }
-        return streamingResult;
-    }
-    /**
-     * 处理参数
-     */
-    async processParameters(parameters, context) {
-        const processedParams = { ...parameters };
-        // 参数标准化和验证
-        const STANDARD_PARAMS = ['temperature', 'top_p', 'frequency_penalty', 'presence_penalty'];
-        for (const param of STANDARD_PARAMS) {
-            if (param in processedParams) {
-                const value = processedParams[param];
-                if (typeof value === 'number') {
-                    // 确保数值在合理范围内
-                    processedParams[param] = this.clampParameterValue(param, value);
-                }
-                else {
-                    throw new ConversionError(`Parameter '${param}' must be a number, got ${typeof value}`, this.id, 'parameter_validation');
-                }
-            }
-        }
-        return processedParams;
-    }
-    /**
-     * 优化消息
-     */
-    async optimizeMessages(messages, toolCallResult, contextResult) {
-        let optimizedMessages = [...messages];
-        // 1. 如果有系统提示词且没有系统消息，添加系统消息
-        if (contextResult.systemPrompt && !optimizedMessages.some(m => m.role === 'system')) {
-            optimizedMessages.unshift({
-                role: 'system',
-                content: contextResult.systemPrompt
-            });
-        }
-        // 2. 保持消息原始顺序，维护对话语义
-        // 移除破坏性的角色重排序，保持用户/工具交错对话的时间顺序
-        // 3. 移除重复的工具结果
-        if (toolCallResult.toolResults.length > 0) {
-            optimizedMessages = this.deduplicateToolResults(optimizedMessages);
-        }
-        return optimizedMessages;
-    }
-    // optimizeTools方法已移除 - 原实现会破坏服务器工具注入
-    // 保留原有工具列表不变，确保MCP hook和RequestToolListFilter能够正常工作
-    /**
-     * 验证处理后的请求
-     */
-    validateProcessedRequest(request) {
-        if (!request.messages || !Array.isArray(request.messages)) {
-            throw new ConversionError('Processed request must have messages array', this.id, 'validation');
-        }
-        if (request.messages.length === 0) {
-            throw new ConversionError('Processed request messages array cannot be empty', this.id, 'validation');
-        }
-        if (!request.model) {
-            throw new ConversionError('Processed request must have model', this.id, 'validation');
-        }
-    }
-    /**
-     * 应用优化策略
-     */
-    async applyOptimizations(request, context) {
-        // 应用缓存策略
-        const cachedRequest = this.applyCaching(request, context);
-        // 应用压缩策略
-        const compressedRequest = this.applyCompression(cachedRequest, context);
-        return compressedRequest;
-    }
-    /**
-     * 应用缓存策略
-     */
-    applyCaching(request, context) {
-        // 简单的缓存逻辑，实际实现可能更复杂
-        return request;
-    }
-    /**
-     * 应用压缩策略
-     */
-    applyCompression(request, context) {
-        // 简单的压缩逻辑，实际实现可能更复杂
-        return request;
-    }
-    /**
-     * 确定处理状态
-     */
-    determineProcessingStatus(toolCallResult, contextResult) {
-        if (toolCallResult.requiresToolExecution && toolCallResult.missingResults.length > 0) {
-            return 'partial';
-        }
-        if (contextResult.contextSize > 100000) { // 上下文过大警告
-            return 'partial';
-        }
-        return 'success';
-    }
-    /**
-     * 工具方法：限制参数值
-     */
-    clampParameterValue(param, value) {
-        const limits = {
-            temperature: [0, 2],
-            top_p: [0, 1],
-            frequency_penalty: [-2, 2],
-            presence_penalty: [-2, 2]
-        };
-        const [min, max] = limits[param] || [0, 100];
-        return Math.max(min, Math.min(max, value));
-    }
-    // ensureMessageOrder方法已移除 - 原实现会破坏对话的时间顺序语义
-    // 保持消息原始顺序，维护用户/工具交错对话的语义完整性
-    /**
-     * 工具方法：去重工具结果
-     */
-    deduplicateToolResults(messages) {
-        const seenToolCallIds = new Set();
-        return messages.filter(message => {
-            if (message.role === 'tool' && message.tool_call_id) {
-                if (seenToolCallIds.has(message.tool_call_id)) {
-                    return false; // 重复的工具结果
-                }
-                seenToolCallIds.add(message.tool_call_id);
-            }
-            return true;
-        });
-    }
-    /**
-     * 工具方法：检查工具是否可用
-     */
-    isToolAvailable(toolName, tools) {
-        return tools.some(tool => tool.function.name === toolName);
-    }
-    /**
-     * 统一规范化工具调用参数（含 TOON 解码）
-     *
-     * - 默认启用 TOON（RCC_TOON_ENABLE/ROUTECODEX_TOON_ENABLE = 0|false|off 时关闭）
-     * - 当 arguments 形如 {"toon":"key: value\\n..."} 且可解析时：
-     *   - 提取 command / workdir 字段
-     *   - 将 arguments 归一为 {"command": "...", "workdir"?: "..."} 的 JSON 字符串
-     *   - 工具名 shell_toon 归一为 shell
-     * - 解码失败时保持原始 name/arguments 不变（Fail Fast 不隐式修复）
-     */
-    normalizeToolCallArguments(toolName, rawArguments) {
-        let name = toolName;
-        let args = rawArguments;
-        if (!this.isToonEnabled()) {
-            return { name, arguments: args };
-        }
-        if (typeof rawArguments !== 'string') {
-            return { name, arguments: args };
-        }
-        const trimmed = rawArguments.trim();
-        if (!trimmed) {
-            return { name, arguments: args };
-        }
-        try {
-            const parsed = JSON.parse(trimmed);
-            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-                return { name, arguments: args };
-            }
-            const toon = parsed.toon;
-            if (typeof toon !== 'string' || !toon.trim()) {
-                return { name, arguments: args };
-            }
-            const kv = this.decodeToonPairs(toon);
-            if (!kv) {
-                return { name, arguments: args };
-            }
-            const command = kv['command'];
-            const workdir = kv['workdir'];
-            if (typeof command === 'string' && command.trim()) {
-                const merged = { command };
-                if (typeof workdir === 'string' && workdir.trim()) {
-                    merged.workdir = workdir;
-                }
-                try {
-                    args = JSON.stringify(merged);
-                }
-                catch {
-                    // JSON.stringify 失败时保持原始 arguments
-                    return { name, arguments: rawArguments };
-                }
-                if (name === 'shell_toon') {
-                    name = 'shell';
-                }
-            }
-        }
-        catch {
-            // 解析失败时保持原始 name/arguments
-            return { name, arguments: args };
-        }
-        return { name, arguments: args };
-    }
-    /**
-     * TOON 是否启用（默认启用，可通过环境变量关闭）
-     */
-    isToonEnabled() {
-        try {
-            const env = String(process?.env?.RCC_TOON_ENABLE ??
-                process?.env?.ROUTECODEX_TOON_ENABLE ??
-                '').toLowerCase();
-            if (!env)
-                return true;
-            return !(env === '0' || env === 'false' || env === 'off');
-        }
-        catch {
-            return true;
-        }
-    }
-    /**
-     * 解析 TOON key: value 文本为键值对
-     */
-    decodeToonPairs(toon) {
-        try {
-            const out = {};
-            const lines = String(toon).split(/\r?\n/);
-            for (const raw of lines) {
-                const line = raw.trim();
-                if (!line)
-                    continue;
-                const m = line.match(/^([A-Za-z0-9_\-]+)\s*:\s*(.*)$/);
-                if (!m)
-                    return null;
-                const key = m[1];
-                const val = m[2];
-                out[key] = val;
-            }
-            return out;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * 工具治理入口：清理空 description、补齐 parameters
-     */
-    normalizeToolPayload(request) {
-        const normalizedMessages = request.messages.map(message => {
-            const cloned = { ...message };
-            if (Array.isArray(message.tool_calls)) {
-                cloned.tool_calls = message.tool_calls
-                    .map(tc => this.normalizeToolCall(tc))
-                    .filter((tc) => Boolean(tc));
-            }
-            return cloned;
-        });
-        const normalizedTools = request.tools
-            ? request.tools
-                .map(tool => this.normalizeToolDefinition(tool))
-                .filter((tool) => Boolean(tool))
-            : undefined;
-        return {
-            ...request,
-            messages: normalizedMessages,
-            tools: normalizedTools
-        };
-    }
-    normalizeToolDefinition(tool) {
-        if (!tool || typeof tool !== 'object')
-            return null;
-        const fn = tool.function || {};
-        const name = typeof fn.name === 'string' ? fn.name : '';
-        if (!name.trim())
-            return null;
-        const description = typeof fn.description === 'string' && fn.description.trim().length > 0
-            ? fn.description.trim()
-            : undefined;
-        const parameters = this.ensureObjectSchema(fn.parameters);
-        const strict = fn.strict === true ? true : undefined;
-        return {
-            type: 'function',
-            function: {
-                name: name.trim(),
-                description,
-                parameters,
-                strict
-            }
-        };
-    }
-    ensureObjectSchema(params) {
-        if (!params || typeof params !== 'object') {
-            return {
-                type: 'object',
-                properties: {},
-                additionalProperties: true
-            };
-        }
-        const properties = params.properties && typeof params.properties === 'object'
-            ? params.properties
-            : {};
-        const required = Array.isArray(params.required)
-            ? params.required.filter((item) => typeof item === 'string' && item.trim().length > 0)
-            : undefined;
-        const additionalProperties = typeof params.additionalProperties === 'boolean'
-            ? params.additionalProperties
-            : true;
-        const schema = {
-            type: 'object',
-            properties,
-            additionalProperties
-        };
-        if (required && required.length > 0) {
-            schema.required = required;
-        }
-        return schema;
-    }
-    normalizeToolCall(toolCall) {
-        if (!toolCall || typeof toolCall !== 'object')
-            return null;
-        const fn = toolCall.function || {};
-        const name = typeof fn.name === 'string' ? fn.name : '';
-        if (!name.trim())
-            return null;
-        return {
-            id: toolCall.id,
-            type: 'function',
-            function: {
-                name: name.trim(),
-                arguments: typeof fn.arguments === 'string'
-                    ? fn.arguments
-                    : (() => {
-                        try {
-                            return JSON.stringify(fn.arguments ?? {});
-                        }
-                        catch {
-                            return '{}';
-                        }
-                    })()
-            }
-        };
-    }
-}