@jsonstudio/llms 0.6.3271 → 0.6.3379

package/dist/conversion/shared/responses-tool-utils.js

@@ -1,75 +1,52 @@
-import { normalizeFunctionCallId, normalizeFunctionCallOutputId, normalizeResponsesCallId } from '../bridge-id-utils.js';
+import { createToolCallIdTransformerWithNative, normalizeFunctionCallIdWithNative, normalizeFunctionCallOutputIdWithNative, normalizeResponsesCallIdWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 import { sanitizeResponsesFunctionNameWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+function assertResponsesToolUtilsNativeAvailable() {
+    if (typeof createToolCallIdTransformerWithNative !== 'function' ||
+        typeof normalizeFunctionCallIdWithNative !== 'function' ||
+        typeof normalizeFunctionCallOutputIdWithNative !== 'function' ||
+        typeof normalizeResponsesCallIdWithNative !== 'function' ||
+        typeof sanitizeResponsesFunctionNameWithNative !== 'function') {
+        throw new Error('[responses-tool-utils] native bindings unavailable');
+    }
+}
 export function createToolCallIdTransformer(style) {
+    assertResponsesToolUtilsNativeAvailable();
     if (style !== 'fc') {
         return null;
     }
-    let callCounter = 0;
-    let itemCounter = 0;
-    let outputCounter = 0;
-    const callAlias = new Map();
-    const normalizeCallId = (raw) => {
-        const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
-        if (rawStr && callAlias.has(rawStr)) {
-            return callAlias.get(rawStr);
-        }
-        const normalized = normalizeResponsesCallId({
-            callId: rawStr,
-            fallback: `call_${++callCounter}`
-        });
-        if (rawStr) {
-            callAlias.set(rawStr, normalized);
-        }
-        return normalized;
-    };
-    const normalizeItemId = (raw, callId) => {
-        const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
-        return normalizeFunctionCallId({
-            callId: rawStr ?? callId,
-            fallback: `fc_item_${++itemCounter}`
-        });
-    };
-    const normalizeOutputId = (callId, raw) => {
-        const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
-        return normalizeFunctionCallOutputId({
-            callId,
-            fallback: rawStr ?? `fc_tool_${++outputCounter}`
-        });
-    };
+    const state = createToolCallIdTransformerWithNative(style);
     return {
-        normalizeCallId,
-        normalizeItemId,
-        normalizeOutputId
+        normalizeCallId(raw) {
+            return normalizeResponsesCallIdWithNative({
+                callId: typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined,
+                fallback: transformCounter(state, 'call')
+            });
+        },
+        normalizeItemId(raw, callId) {
+            return normalizeFunctionCallIdWithNative({
+                callId: typeof raw === 'string' && raw.trim().length ? raw.trim() : callId,
+                fallback: transformCounter(state, 'item')
+            });
+        },
+        normalizeOutputId(callId, raw) {
+            return normalizeFunctionCallOutputIdWithNative({
+                callId,
+                fallback: typeof raw === 'string' && raw.trim().length ? raw.trim() : transformCounter(state, 'tool')
+            });
+        }
     };
 }
-export function enforceToolCallIdStyle(input, transformer) {
-    for (const entry of input) {
-        if (!entry || typeof entry !== 'object')
-            continue;
-        const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : '';
-        if (type === 'function_call') {
-            const normalizedCallId = transformer.normalizeCallId(entry.call_id ?? entry.id);
-            entry.call_id = normalizedCallId;
-            entry.id = transformer.normalizeItemId(entry.id ?? normalizedCallId, normalizedCallId);
-            continue;
-        }
-        if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
-            const normalizedCallId = transformer.normalizeCallId(entry.call_id ?? entry.tool_call_id ?? entry.id);
-            entry.call_id = normalizedCallId;
-            // OpenAI `/v1/responses` request schema uses `call_id` for tool outputs.
-            // Some internal carriers may include `tool_call_id`; strip it before sending upstream
-            // to avoid strict schema errors (e.g. "Unknown parameter: input[N].tool_call_id").
-            if (entry.tool_call_id !== undefined) {
-                delete entry.tool_call_id;
-            }
-            entry.id = transformer.normalizeOutputId(normalizedCallId, entry.id);
-        }
-    }
+function transformCounter(state, prefix) {
+    const current = typeof state.__counter === 'number' ? state.__counter : 0;
+    const next = current + 1;
+    state.__counter = next;
+    return `${prefix}_${next}`;
 }
 function isStableToolCallId(raw) {
     return /^((fc|call)_[A-Za-z0-9_-]+)$/i.test(raw);
 }
 export function normalizeResponsesToolCallIds(payload) {
+    assertResponsesToolUtilsNativeAvailable();
     if (!payload || typeof payload !== 'object') {
         return;
     }
@@ -85,7 +62,7 @@ export function normalizeResponsesToolCallIds(payload) {
         }
         const normalized = trimmed && isStableToolCallId(trimmed)
             ? trimmed
-            : normalizeFunctionCallId({
+            : normalizeFunctionCallIdWithNative({
                 callId: trimmed || undefined,
                 fallback: nextFallback(fallbackPrefix)
             });
@@ -106,7 +83,7 @@ export function normalizeResponsesToolCallIds(payload) {
                 item.tool_call_id = normalizedCallId;
             }
             const rawOutputId = typeof item.id === 'string' ? item.id : undefined;
-            item.id = normalizeFunctionCallOutputId({
+            item.id = normalizeFunctionCallOutputIdWithNative({
                 callId: normalizedCallId,
                 fallback: rawOutputId ?? nextFallback('fc')
             });
@@ -119,7 +96,7 @@ export function normalizeResponsesToolCallIds(payload) {
                 item.tool_call_id = normalizedCallId;
             }
             const rawOutputId = typeof item.id === 'string' ? item.id : undefined;
-            item.id = normalizeFunctionCallOutputId({
+            item.id = normalizeFunctionCallOutputIdWithNative({
                 callId: normalizedCallId,
                 fallback: rawOutputId ?? nextFallback('fc')
             });
@@ -155,8 +132,6 @@ export function normalizeResponsesToolCallIds(payload) {
     }
 }
 export function resolveToolCallIdStyle(metadata) {
-    // Standard OpenAI `/v1/responses` requires function_call item ids to start with `fc_`.
-    // Default to `fc` unless explicitly overridden (e.g. LM Studio compat).
     if (!metadata)
         return 'fc';
     const raw = metadata.toolCallIdStyle;
@@ -171,6 +146,7 @@ export function resolveToolCallIdStyle(metadata) {
     }
     return 'fc';
 }
+const RAW_SYSTEM_SENTINEL = '__rcc_raw_system';
 export function stripInternalToolingMetadata(metadata) {
     if (!metadata || typeof metadata !== 'object')
         return;
@@ -203,7 +179,29 @@ function prunePrivateExtraFields(target) {
         }
     }
 }
-const RAW_SYSTEM_SENTINEL = '__rcc_raw_system';
 export function sanitizeResponsesFunctionName(rawName) {
+    assertResponsesToolUtilsNativeAvailable();
     return sanitizeResponsesFunctionNameWithNative(rawName);
 }
+export function enforceToolCallIdStyle(input, transformer) {
+    assertResponsesToolUtilsNativeAvailable();
+    for (const entry of input) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : '';
+        if (type === 'function_call') {
+            const normalizedCallId = transformer.normalizeCallId(entry.call_id ?? entry.id);
+            entry.call_id = normalizedCallId;
+            entry.id = transformer.normalizeItemId(entry.id ?? normalizedCallId, normalizedCallId);
+            continue;
+        }
+        if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
+            const normalizedCallId = transformer.normalizeCallId(entry.call_id ?? entry.tool_call_id ?? entry.id);
+            entry.call_id = normalizedCallId;
+            if (entry.tool_call_id !== undefined) {
+                delete entry.tool_call_id;
+            }
+            entry.id = transformer.normalizeOutputId(normalizedCallId, entry.id);
+        }
+    }
+}

package/dist/conversion/shared/streaming-text-extractor.d.ts

@@ -16,10 +16,5 @@ export declare class StreamingTextToolExtractor {
     constructor(opts?: StreamingToolExtractorOptions);
     reset(): void;
     feedText(text: string): StreamingToolCall[];
-    private genId;
-    private toToolCall;
-    private tryExtractStructuredBlocks;
-    private tryExtractFunctionExecuteBlocks;
-    private splitCommand;
 }
 export declare function createStreamingToolExtractor(opts?: StreamingToolExtractorOptions): StreamingTextToolExtractor;

package/dist/conversion/shared/streaming-text-extractor.js

@@ -1,10 +1,11 @@
 // Streaming textual tool intent extractor (对齐)
 // Detects <function=execute> blocks and structured apply_patch payloads
 // and converts them into OpenAI tool_calls incrementally.
-import { isStructuredApplyPatchPayload } from '../../tools/apply-patch-structured.js';
-import { repairArgumentsToStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
-function isObject(v) {
-    return !!v && typeof v === 'object' && !Array.isArray(v);
+import { extractStreamingToolCallsWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function assertStreamingToolExtractorNativeAvailable() {
+    if (typeof extractStreamingToolCallsWithNative !== 'function') {
+        throw new Error('[streaming-text-extractor] native bindings unavailable');
+    }
 }
 export class StreamingTextToolExtractor {
     opts;
@@ -18,114 +19,20 @@ export class StreamingTextToolExtractor {
         this.idCounter = 0;
     }
     feedText(text) {
-        const out = [];
         if (typeof text !== 'string' || !text)
-            return out;
-        this.buffer += text;
-        // 1) Structured apply_patch block detection (```json ... ```)
-        out.push(...this.tryExtractStructuredBlocks());
-        // 2) <function=execute> compact blocks detection
-        out.push(...this.tryExtractFunctionExecuteBlocks());
-        return out;
-    }
-    genId() {
-        const p = this.opts.idPrefix || 'call';
-        return `${p}_${Date.now()}_${(++this.idCounter).toString(36)}`;
-    }
-    toToolCall(name, argsObj) {
-        const argStr = repairArgumentsToStringWithNative(argsObj);
-        return { id: this.genId(), type: 'function', function: { name, arguments: argStr } };
-    }
-    tryExtractStructuredBlocks() {
-        const out = [];
-        let searchIdx = 0;
-        while (searchIdx < this.buffer.length) {
-            const startIdx = this.buffer.indexOf('```', searchIdx);
-            if (startIdx < 0)
-                break;
-            const headerEnd = this.buffer.indexOf('\n', startIdx + 3);
-            if (headerEnd < 0)
-                break;
-            const language = this.buffer.slice(startIdx + 3, headerEnd).trim().toLowerCase();
-            const endIdx = this.buffer.indexOf('```', headerEnd + 1);
-            if (endIdx < 0)
-                break;
-            const body = this.buffer.slice(headerEnd + 1, endIdx);
-            if (!language || language === 'json' || language === 'apply_patch' || language === 'toon') {
-                try {
-                    const parsed = JSON.parse(body);
-                    if (isStructuredApplyPatchPayload(parsed)) {
-                        out.push(this.toToolCall('apply_patch', parsed));
-                        this.buffer = this.buffer.slice(0, startIdx) + this.buffer.slice(endIdx + 3);
-                        searchIdx = 0;
-                        continue;
-                    }
-                }
-                catch {
-                    /* ignore parse errors */
-                }
-            }
-            searchIdx = endIdx + 3;
-        }
-        return out;
-    }
-    // rcc.tool.v1 JSON detection removed
-    tryExtractFunctionExecuteBlocks() {
-        const out = [];
-        // Very lightweight parser for <function=execute> <parameter=command>...</parameter>
-        const execRe = /<function=execute>[\s\S]*?<parameter=command>([\s\S]*?)<\/parameter>[\s\S]*?<\/function=execute>/gi;
-        let m;
-        while ((m = execRe.exec(this.buffer)) !== null) {
-            const cmd = (m[1] || '').trim();
-            if (cmd) {
-                // split a shell command string into argv best-effort
-                const argv = this.splitCommand(cmd);
-                out.push(this.toToolCall('shell', { command: argv }));
-            }
-        }
-        if (out.length > 0) {
-            this.buffer = this.buffer.replace(execRe, '');
-        }
-        return out;
-    }
-    splitCommand(s) {
-        try {
-            // basic quotes-aware split
-            const out = [];
-            let cur = '';
-            let quote = null;
-            for (let i = 0; i < s.length; i++) {
-                const ch = s[i];
-                if (quote) {
-                    if (ch === quote) {
-                        quote = null;
-                    }
-                    else {
-                        cur += ch;
-                    }
-                }
-                else {
-                    if (ch === '"' || ch === '\'') {
-                        quote = ch;
-                    }
-                    else if (/\s/.test(ch)) {
-                        if (cur) {
-                            out.push(cur);
-                            cur = '';
-                        }
-                    }
-                    else {
-                        cur += ch;
-                    }
-                }
-            }
-            if (cur)
-                out.push(cur);
-            return out;
-        }
-        catch {
-            return [s];
-        }
+            return [];
+        assertStreamingToolExtractorNativeAvailable();
+        const idPrefix = this.opts.idPrefix || 'call';
+        const output = extractStreamingToolCallsWithNative({
+            buffer: this.buffer,
+            text,
+            idPrefix,
+            idCounter: this.idCounter,
+            nowMs: Date.now()
+        });
+        this.buffer = typeof output.buffer === 'string' ? output.buffer : this.buffer;
+        this.idCounter = typeof output.idCounter === 'number' ? output.idCounter : this.idCounter;
+        return Array.isArray(output.toolCalls) ? output.toolCalls : [];
     }
 }
 export function createStreamingToolExtractor(opts) {

package/dist/conversion/shared/text-markup-normalizer/normalize.d.ts

@@ -1,2 +1,2 @@
 import type { TextMarkupNormalizeOptions } from '../../types/text-markup-normalizer.js';
-export declare function normalizeAssistantTextToToolCalls(message: Record<string, any>, _options?: TextMarkupNormalizeOptions): Record<string, any>;
+export declare function normalizeAssistantTextToToolCalls(message: Record<string, any>, options?: TextMarkupNormalizeOptions): Record<string, any>;

package/dist/conversion/shared/text-markup-normalizer/normalize.js

@@ -1,4 +1,4 @@
-import { extractToolCallsFromReasoningTextWithNative } from '../../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { normalizeAssistantTextToToolCallsWithNative } from '../../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 function enabled() {
     try {
         return String(process?.env?.RCC_TEXT_MARKUP_COMPAT ?? '1').trim() !== '0';
@@ -7,96 +7,8 @@ function enabled() {
         return true;
     }
 }
-export function normalizeAssistantTextToToolCalls(message, _options) {
+export function normalizeAssistantTextToToolCalls(message, options) {
     if (!enabled())
         return message;
-    try {
-        if (!message || typeof message !== 'object')
-            return message;
-        if (Array.isArray(message.tool_calls) && message.tool_calls.length)
-            return message;
-        const content = message.content;
-        const candidates = [];
-        if (typeof content === 'string') {
-            candidates.push(content);
-        }
-        else if (Array.isArray(content)) {
-            for (const part of content) {
-                if (!part || typeof part !== 'object')
-                    continue;
-                const p = part;
-                if (typeof p.text === 'string' && p.text.trim()) {
-                    candidates.push(p.text);
-                    continue;
-                }
-                if (typeof p.content === 'string' && p.content.trim()) {
-                    candidates.push(p.content);
-                    continue;
-                }
-            }
-        }
-        if (typeof message.reasoning === 'string' && message.reasoning.trim()) {
-            candidates.push(String(message.reasoning));
-        }
-        if (typeof message.thinking === 'string' && message.thinking.trim()) {
-            candidates.push(String(message.thinking));
-        }
-        if (!candidates.length)
-            return message;
-        let calls = null;
-        const mapNativeToolCalls = (raw) => {
-            const mapped = [];
-            raw.forEach((entry, index) => {
-                if (!entry || typeof entry !== 'object')
-                    return;
-                const functionNode = entry.function && typeof entry.function === 'object' && !Array.isArray(entry.function)
-                    ? entry.function
-                    : undefined;
-                const name = (typeof functionNode?.name === 'string' && functionNode.name.trim()) ||
-                    (typeof entry.name === 'string' && entry.name.trim()) ||
-                    undefined;
-                if (!name)
-                    return;
-                const argsCandidate = functionNode?.arguments ?? entry.arguments ?? entry.args ?? '{}';
-                let args = '{}';
-                if (typeof argsCandidate === 'string') {
-                    args = argsCandidate;
-                }
-                else {
-                    try {
-                        args = JSON.stringify(argsCandidate ?? {});
-                    }
-                    catch {
-                        args = '{}';
-                    }
-                }
-                const id = (typeof entry.id === 'string' && entry.id.trim()) ||
-                    (typeof entry.call_id === 'string' && entry.call_id.trim()) ||
-                    `call_${index + 1}`;
-                mapped.push({ id, name, args });
-            });
-            return mapped;
-        };
-        for (const text of candidates) {
-            const nativeParsed = extractToolCallsFromReasoningTextWithNative(text);
-            if (nativeParsed.toolCalls.length) {
-                const nativeCalls = mapNativeToolCalls(nativeParsed.toolCalls);
-                if (nativeCalls.length) {
-                    calls = nativeCalls;
-                    break;
-                }
-            }
-        }
-        if (calls && calls.length) {
-            const toolCalls = calls.map((c) => ({ id: c.id, type: 'function', function: { name: c.name, arguments: c.args } }));
-            const copy = { ...message };
-            copy.tool_calls = toolCalls;
-            copy.content = '';
-            return copy;
-        }
-    }
-    catch {
-        // ignore normalization failures
-    }
-    return message;
+    return normalizeAssistantTextToToolCallsWithNative(message, options);
 }

package/dist/conversion/shared/thought-signature-validator.js

@@ -4,13 +4,15 @@
  * 提供严格的 thoughtSignature 验证功能，用于 Claude/Gemini thinking 块的签名验证。
  * 参考 gcli2api 的实现，确保与上游 API 的兼容性。
  */
-import { sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
-const DEFAULT_OPTIONS = {
-    // Antigravity-Manager alignment: treat short signatures as noise.
-    minLength: 50,
-    allowEmptyThinkingWithSignature: true,
-    convertToTextOnFailure: true
-};
+import { filterInvalidThinkingBlocksWithNative, hasValidThoughtSignatureWithNative, removeTrailingUnsignedThinkingBlocksWithNative, sanitizeThinkingBlockWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function assertThoughtSignatureValidatorNativeAvailable() {
+    if (typeof hasValidThoughtSignatureWithNative !== 'function' ||
+        typeof sanitizeThinkingBlockWithNative !== 'function' ||
+        typeof filterInvalidThinkingBlocksWithNative !== 'function' ||
+        typeof removeTrailingUnsignedThinkingBlocksWithNative !== 'function') {
+        throw new Error('[thought-signature-validator] native bindings unavailable');
+    }
+}
 /**
  * 检查 thinking 块是否有有效的 thoughtSignature
  *
@@ -19,26 +21,8 @@ const DEFAULT_OPTIONS = {
  * @returns 是否有效
  */
 export function hasValidThoughtSignature(block, options) {
-    if (!block || typeof block !== 'object') {
-        return true; // 非 thinking 块默认有效
-    }
-    const obj = block;
-    const blockType = obj.type;
-    if (blockType !== 'thinking' && blockType !== 'reasoning' && blockType !== 'redacted_thinking') {
-        return true; // 非 thinking 块默认有效
-    }
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    const thinking = sanitizeReasoningTaggedTextWithNative(String(obj.thinking || obj.text || ''));
-    const signature = coerceThoughtSignature(obj.thoughtSignature || obj.signature);
-    // 空 thinking + 任意签名 = 有效 (trailing signature case)
-    if (!thinking.trim() && signature !== undefined && opts.allowEmptyThinkingWithSignature) {
-        return true;
-    }
-    // 有内容 + 足够长度的 signature = 有效
-    if (signature && signature.length >= opts.minLength) {
-        return true;
-    }
-    return false;
+    assertThoughtSignatureValidatorNativeAvailable();
+    return hasValidThoughtSignatureWithNative(block, options);
 }
 /**
  * 清理 thinking 块，移除额外字段，保留有效签名
@@ -47,23 +31,8 @@ export function hasValidThoughtSignature(block, options) {
  * @returns 清理后的块
  */
 export function sanitizeThinkingBlock(block) {
-    if (!block || typeof block !== 'object') {
-        return block;
-    }
-    const obj = block;
-    const blockType = obj.type;
-    if (blockType !== 'thinking' && blockType !== 'reasoning' && blockType !== 'redacted_thinking') {
-        return obj;
-    }
-    const sanitized = {
-        type: blockType,
-        thinking: sanitizeReasoningTaggedTextWithNative(String(obj.thinking || obj.text || ''))
-    };
-    const signature = coerceThoughtSignature(obj.thoughtSignature || obj.signature);
-    if (signature) {
-        sanitized.thoughtSignature = signature;
-    }
-    return sanitized;
+    assertThoughtSignatureValidatorNativeAvailable();
+    return sanitizeThinkingBlockWithNative(block);
 }
 /**
  * 过滤消息中的无效 thinking 块
@@ -72,58 +41,9 @@ export function sanitizeThinkingBlock(block) {
  * @param options - 验证选项
  */
 export function filterInvalidThinkingBlocks(messages, options) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    let totalFiltered = 0;
-    for (const msg of messages) {
-        if (!msg || typeof msg !== 'object')
-            continue;
-        const msgObj = msg;
-        const role = msgObj.role;
-        // 只处理 assistant 和 model 消息
-        if (role !== 'assistant' && role !== 'model')
-            continue;
-        const content = msgObj.content;
-        if (!Array.isArray(content))
-            continue;
-        const originalLen = content.length;
-        const newBlocks = [];
-        for (const block of content) {
-            if (!block || typeof block !== 'object') {
-                newBlocks.push(block);
-                continue;
-            }
-            const blockType = block.type;
-            if (blockType !== 'thinking' && blockType !== 'reasoning' && blockType !== 'redacted_thinking') {
-                newBlocks.push(block);
-                continue;
-            }
-            // 检查 thinking 块的有效性
-            if (hasValidThoughtSignature(block, opts)) {
-                // 有效签名，清理后保留
-                newBlocks.push(sanitizeThinkingBlock(block));
-            }
-            else {
-                // 无效签名
-                const thinkingText = String(block.thinking || block.text || '');
-                if (thinkingText.trim() && opts.convertToTextOnFailure) {
-                    // 有内容，转换为文本
-                    newBlocks.push({ type: 'text', text: thinkingText });
-                }
-                // 否则丢弃（空 thinking + 无效签名）
-            }
-        }
-        msgObj.content = newBlocks;
-        const filteredCount = originalLen - newBlocks.length;
-        totalFiltered += filteredCount;
-        // 如果过滤后为空，添加一个空文本块以保持消息有效
-        if (!newBlocks.length) {
-            msgObj.content = [{ type: 'text', text: '' }];
-        }
-    }
-    if (totalFiltered > 0) {
-        // 可以在这里添加日志记录
-        console.debug(`[ThoughtSignatureValidator] Filtered ${totalFiltered} invalid thinking block(s)`);
-    }
+    assertThoughtSignatureValidatorNativeAvailable();
+    const normalized = filterInvalidThinkingBlocksWithNative(messages, options);
+    messages.splice(0, messages.length, ...normalized);
 }
 /**
  * 移除末尾未签名的 thinking 块
@@ -132,41 +52,7 @@ export function filterInvalidThinkingBlocks(messages, options) {
  * @param options - 验证选项
  */
 export function removeTrailingUnsignedThinkingBlocks(blocks, options) {
-    if (!Array.isArray(blocks) || !blocks.length)
-        return;
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    let end_index = blocks.length;
-    // 从末尾向前查找第一个有效签名的 thinking 块
-    for (let i = blocks.length - 1; i >= 0; i--) {
-        const block = blocks[i];
-        if (!block || typeof block !== 'object')
-            continue;
-        const blockType = block.type;
-        if (blockType === 'thinking' || blockType === 'reasoning' || blockType === 'redacted_thinking') {
-            if (!hasValidThoughtSignature(block, opts)) {
-                end_index = i;
-            }
-            else {
-                break; // 遇到有效签名的 thinking 块，停止
-            }
-        }
-        else {
-            break; // 遇到非 thinking 块，停止
-        }
-    }
-    // 移除末尾未签名的 thinking 块
-    if (end_index < blocks.length) {
-        const removed = blocks.length - end_index;
-        blocks.splice(end_index);
-        console.debug(`[ThoughtSignatureValidator] Removed ${removed} trailing unsigned thinking block(s)`);
-    }
-}
-/**
- * 提取并强制转换 thoughtSignature
- */
-function coerceThoughtSignature(value) {
-    if (typeof value === 'string' && value.trim().length) {
-        return value.trim();
-    }
-    return undefined;
+    assertThoughtSignatureValidatorNativeAvailable();
+    const normalized = removeTrailingUnsignedThinkingBlocksWithNative(blocks, options);
+    blocks.splice(0, blocks.length, ...normalized);
 }