@jsonstudio/rcc 0.90.323 → 0.90.364

package/vendor/@jsonstudio/llms/dist/conversion/shared/responses-response-utils.js

@@ -0,0 +1,254 @@
+import { createBridgeActionState, runBridgeActionPipeline } from '../bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../bridge-policies.js';
+import { registerResponsesPayloadSnapshot, registerResponsesPassthrough } from './responses-reasoning-registry.js';
+import { buildChatResponseFromResponsesWithNative, collectToolCallsFromResponsesWithNative, normalizeFunctionCallIdWithNative, resolveFinishReasonWithNative } 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 selectCallId(entry) {
+    const candidates = [
+        entry?.call_id,
+        entry?.tool_call_id,
+        entry?.tool_use_id,
+        entry?.id
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            return candidate.trim();
+        }
+    }
+    return undefined;
+}
+function normalizeToolCall(entry, fallbackPrefix) {
+    if (!entry || typeof entry !== 'object')
+        return null;
+    const fn = entry.function || {};
+    const rawName = sanitizeResponsesFunctionNameWithNative(fn.name ?? entry.name);
+    if (!rawName)
+        return null;
+    const argsRaw = fn.arguments ?? entry.arguments ?? {};
+    const argsStr = typeof argsRaw === 'string'
+        ? argsRaw
+        : (() => {
+            try {
+                return JSON.stringify(argsRaw ?? {});
+            }
+            catch {
+                return '{}';
+            }
+        })();
+    const callIdRaw = selectCallId(entry);
+    const callId = typeof callIdRaw === 'string' && callIdRaw.length
+        ? callIdRaw
+        : normalizeFunctionCallIdWithNative({
+            callId: callIdRaw,
+            fallback: `${fallbackPrefix}_${Math.random().toString(36).slice(2, 10)}`
+        });
+    return {
+        id: callId,
+        type: 'function',
+        function: {
+            name: rawName,
+            arguments: argsStr
+        }
+    };
+}
+export function collectToolCallsFromResponses(response) {
+    return collectToolCallsFromResponsesWithNative(response);
+}
+export function resolveFinishReason(response, toolCalls) {
+    return resolveFinishReasonWithNative(response, toolCalls);
+}
+function unwrapResponsesResponse(payload) {
+    if (!payload || typeof payload !== 'object')
+        return undefined;
+    if (typeof payload.object === 'string' && payload.object === 'response') {
+        return payload;
+    }
+    if (Array.isArray(payload.output) ||
+        typeof payload.status === 'string' ||
+        payload.required_action) {
+        return payload;
+    }
+    let current = payload;
+    const visited = new Set();
+    while (current && typeof current === 'object' && !Array.isArray(current)) {
+        if (visited.has(current))
+            break;
+        visited.add(current);
+        if (typeof current.object === 'string' && current.object === 'response') {
+            return current;
+        }
+        if (current.response && typeof current.response === 'object') {
+            current = current.response;
+            continue;
+        }
+        if (current.data && typeof current.data === 'object') {
+            current = current.data;
+            continue;
+        }
+        break;
+    }
+    return undefined;
+}
+function collectRawReasoningSegments(response) {
+    const segments = [];
+    const outputItems = Array.isArray(response.output) ? response.output : [];
+    for (const item of outputItems) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type !== 'reasoning')
+            continue;
+        const content = Array.isArray(item.content) ? item.content : [];
+        for (const part of content) {
+            if (part && typeof part === 'object' && typeof part.text === 'string') {
+                segments.push(part.text);
+            }
+        }
+    }
+    return segments;
+}
+function collectReasoningSummarySegments(response) {
+    const segments = [];
+    const outputItems = Array.isArray(response.output) ? response.output : [];
+    for (const item of outputItems) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type !== 'reasoning')
+            continue;
+        const summary = Array.isArray(item.summary) ? item.summary : [];
+        for (const entry of summary) {
+            if (typeof entry === 'string') {
+                segments.push(entry);
+                continue;
+            }
+            if (entry && typeof entry === 'object' && typeof entry.text === 'string') {
+                segments.push(entry.text);
+            }
+        }
+    }
+    return segments;
+}
+function collectReasoningEncryptedContent(response) {
+    const outputItems = Array.isArray(response.output) ? response.output : [];
+    for (const item of outputItems) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type !== 'reasoning')
+            continue;
+        const encrypted = item.encrypted_content;
+        if (typeof encrypted === 'string' && encrypted.trim().length) {
+            return encrypted;
+        }
+    }
+    return undefined;
+}
+function buildReasoningPayload(options) {
+    const { summarySegments, contentSegments, encryptedContent } = options;
+    const summary = summarySegments.length
+        ? summarySegments.map((text) => ({ type: 'summary_text', text }))
+        : undefined;
+    const content = contentSegments.length
+        ? contentSegments.map((text) => ({ type: 'reasoning_text', text }))
+        : undefined;
+    if (!summary && !content && encryptedContent === undefined) {
+        return undefined;
+    }
+    return {
+        summary,
+        content,
+        encrypted_content: encryptedContent
+    };
+}
+function registerPassthroughSnapshot(payload) {
+    const ids = new Set();
+    const requestId = typeof payload?.request_id === 'string' ? payload.request_id.trim() : '';
+    const id = typeof payload?.id === 'string' ? payload.id.trim() : '';
+    if (requestId.length)
+        ids.add(requestId);
+    if (id.length)
+        ids.add(id);
+    for (const candidate of ids) {
+        registerResponsesPassthrough(candidate, payload);
+    }
+}
+function cloneSnapshot(value) {
+    try {
+        const structuredCloneImpl = globalThis.structuredClone;
+        if (typeof structuredCloneImpl === 'function') {
+            return structuredCloneImpl(value);
+        }
+    }
+    catch {
+        /* ignore structuredClone failures */
+    }
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return { ...value };
+    }
+}
+export function buildChatResponseFromResponses(payload) {
+    if (!payload || typeof payload !== 'object')
+        return payload;
+    if (typeof buildChatResponseFromResponsesWithNative !== 'function') {
+        throw new Error('[responses-response-utils] native bindings unavailable');
+    }
+    const response = unwrapResponsesResponse(payload);
+    if (!response) {
+        if (Array.isArray(payload.choices)) {
+            registerPassthroughSnapshot(payload);
+            return payload;
+        }
+        return payload;
+    }
+    const chat = buildChatResponseFromResponsesWithNative(response);
+    if (!chat || typeof chat !== 'object' || Array.isArray(chat)) {
+        return payload;
+    }
+    const choices = Array.isArray(chat.choices) ? chat.choices : [];
+    const primary = choices[0] && typeof choices[0] === 'object' ? choices[0] : undefined;
+    const message = primary && typeof primary.message === 'object'
+        ? primary.message
+        : undefined;
+    try {
+        if (message) {
+            const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
+            const policyActions = resolvePolicyActions(bridgePolicy, 'response_inbound');
+            if (policyActions?.length) {
+                const actionState = createBridgeActionState({
+                    messages: [message],
+                    rawResponse: response
+                });
+                runBridgeActionPipeline({
+                    stage: 'response_inbound',
+                    actions: policyActions,
+                    protocol: bridgePolicy?.protocol ?? 'openai-responses',
+                    moduleType: bridgePolicy?.moduleType ?? 'openai-responses',
+                    requestId: typeof response?.id === 'string' ? response.id : undefined,
+                    state: actionState
+                });
+            }
+        }
+    }
+    catch {
+        // Ignore policy errors
+    }
+    const id = typeof chat.id === 'string' ? chat.id : undefined;
+    const requestId = typeof chat.request_id === 'string'
+        ? chat.request_id
+        : (typeof response.request_id === 'string' ? response.request_id : undefined);
+    if (id) {
+        registerResponsesPayloadSnapshot(id, response);
+    }
+    if (requestId) {
+        registerResponsesPayloadSnapshot(requestId, response);
+    }
+    const snapshot = cloneSnapshot(response);
+    if (snapshot) {
+        chat.__responses_payload_snapshot = snapshot;
+    }
+    return chat;
+}

package/vendor/@jsonstudio/llms/dist/conversion/shared/responses-tool-utils.d.ts

@@ -0,0 +1,14 @@
+export type ToolCallIdStyle = 'preserve' | 'fc';
+type BridgeInputItem = Record<string, unknown>;
+export interface CallIdTransformer {
+    normalizeCallId(raw: unknown): string;
+    normalizeItemId(raw: unknown, callId: string): string;
+    normalizeOutputId(callId: string, raw: unknown): string;
+}
+export declare function createToolCallIdTransformer(style: ToolCallIdStyle): CallIdTransformer | null;
+export declare function normalizeResponsesToolCallIds(payload: Record<string, unknown> | null | undefined): void;
+export declare function resolveToolCallIdStyle(metadata: Record<string, unknown> | undefined): ToolCallIdStyle;
+export declare function stripInternalToolingMetadata(metadata: unknown): void;
+export declare function sanitizeResponsesFunctionName(rawName: unknown): string | undefined;
+export declare function enforceToolCallIdStyle(input: BridgeInputItem[], transformer: CallIdTransformer): void;
+export {};

package/vendor/@jsonstudio/llms/dist/conversion/shared/responses-tool-utils.js

@@ -0,0 +1,102 @@
+import { createToolCallIdTransformerWithNative, normalizeResponsesToolCallIdsWithNative, normalizeFunctionCallIdWithNative, normalizeFunctionCallOutputIdWithNative, normalizeResponsesCallIdWithNative, resolveToolCallIdStyleWithNative, stripInternalToolingMetadataWithNative } 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 normalizeResponsesToolCallIdsWithNative !== 'function' ||
+        typeof normalizeFunctionCallIdWithNative !== 'function' ||
+        typeof normalizeFunctionCallOutputIdWithNative !== 'function' ||
+        typeof normalizeResponsesCallIdWithNative !== 'function' ||
+        typeof resolveToolCallIdStyleWithNative !== 'function' ||
+        typeof stripInternalToolingMetadataWithNative !== 'function' ||
+        typeof sanitizeResponsesFunctionNameWithNative !== 'function') {
+        throw new Error('[responses-tool-utils] native bindings unavailable');
+    }
+}
+function replaceMutableRecord(target, next) {
+    for (const key of Object.keys(target)) {
+        delete target[key];
+    }
+    Object.assign(target, next);
+}
+export function createToolCallIdTransformer(style) {
+    assertResponsesToolUtilsNativeAvailable();
+    if (style !== 'fc') {
+        return null;
+    }
+    const state = createToolCallIdTransformerWithNative(style);
+    return {
+        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')
+            });
+        }
+    };
+}
+function transformCounter(state, prefix) {
+    const current = typeof state.__counter === 'number' ? state.__counter : 0;
+    const next = current + 1;
+    state.__counter = next;
+    return `${prefix}_${next}`;
+}
+export function normalizeResponsesToolCallIds(payload) {
+    assertResponsesToolUtilsNativeAvailable();
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return;
+    }
+    const normalized = normalizeResponsesToolCallIdsWithNative(payload);
+    if (normalized && typeof normalized === 'object' && !Array.isArray(normalized)) {
+        replaceMutableRecord(payload, normalized);
+    }
+}
+export function resolveToolCallIdStyle(metadata) {
+    assertResponsesToolUtilsNativeAvailable();
+    const style = resolveToolCallIdStyleWithNative(metadata ?? null);
+    return style === 'preserve' ? 'preserve' : 'fc';
+}
+export function stripInternalToolingMetadata(metadata) {
+    assertResponsesToolUtilsNativeAvailable();
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata))
+        return;
+    const normalized = stripInternalToolingMetadataWithNative(metadata);
+    if (normalized && typeof normalized === 'object' && !Array.isArray(normalized)) {
+        replaceMutableRecord(metadata, normalized);
+    }
+}
+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;
+            // Keep tool_call_id for providers that expect it (e.g., Qwen)
+            entry.tool_call_id = normalizedCallId;
+            entry.id = transformer.normalizeOutputId(normalizedCallId, entry.id);
+        }
+    }
+}

package/vendor/@jsonstudio/llms/dist/conversion/shared/streaming-text-extractor.d.ts

@@ -0,0 +1,19 @@
+export interface StreamingToolCall {
+    id?: string;
+    type: 'function';
+    function: {
+        name?: string;
+        arguments?: string;
+    };
+}
+export interface StreamingToolExtractorOptions {
+    idPrefix?: string;
+}
+export declare class StreamingTextToolExtractor {
+    private opts;
+    private state;
+    constructor(opts?: StreamingToolExtractorOptions);
+    reset(): void;
+    feedText(text: string): StreamingToolCall[];
+}
+export declare function createStreamingToolExtractor(opts?: StreamingToolExtractorOptions): StreamingTextToolExtractor;

package/vendor/@jsonstudio/llms/dist/conversion/shared/streaming-text-extractor.js

@@ -0,0 +1,39 @@
+// Streaming textual tool intent extractor (对齐)
+// Detects <function=execute> blocks and structured apply_patch payloads
+// and converts them into OpenAI tool_calls incrementally.
+import { createStreamingToolExtractorStateWithNative, feedStreamingToolExtractorWithNative, resetStreamingToolExtractorStateWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function assertStreamingToolExtractorNativeAvailable() {
+    if (typeof createStreamingToolExtractorStateWithNative !== 'function' ||
+        typeof resetStreamingToolExtractorStateWithNative !== 'function' ||
+        typeof feedStreamingToolExtractorWithNative !== 'function') {
+        throw new Error('[streaming-text-extractor] native bindings unavailable');
+    }
+}
+export class StreamingTextToolExtractor {
+    opts;
+    state;
+    constructor(opts = {}) {
+        this.opts = opts;
+        assertStreamingToolExtractorNativeAvailable();
+        this.state = createStreamingToolExtractorStateWithNative(this.opts.idPrefix || 'call');
+    }
+    reset() {
+        assertStreamingToolExtractorNativeAvailable();
+        this.state = resetStreamingToolExtractorStateWithNative(this.state);
+    }
+    feedText(text) {
+        if (typeof text !== 'string' || !text)
+            return [];
+        assertStreamingToolExtractorNativeAvailable();
+        const output = feedStreamingToolExtractorWithNative({
+            state: this.state,
+            text,
+            nowMs: Date.now()
+        });
+        this.state = output.state;
+        return output.toolCalls;
+    }
+}
+export function createStreamingToolExtractor(opts) {
+    return new StreamingTextToolExtractor(opts);
+}

package/vendor/@jsonstudio/llms/dist/conversion/shared/text-markup-normalizer/normalize.d.ts

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

package/vendor/@jsonstudio/llms/dist/conversion/shared/text-markup-normalizer/normalize.js

@@ -0,0 +1,116 @@
+import { stripReasoningTransportNoise } from '../reasoning-normalizer.js';
+import { extractToolCallsFromReasoningTextWithNative, normalizeAssistantTextToToolCallsWithNative, parseLenientJsonishWithNative } from '../../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+const TOOL_HARVEST_KEYS = ['reasoning', 'reasoning_content', 'content'];
+const TOOL_CALL_OPEN_RE = /<tool_call(?:\s|>)/i;
+const TOOL_CALL_CLOSE_RE = /<\/tool_call>/i;
+const BARE_TOOL_CALL_PREFIX_RE = /^\s*[a-zA-Z0-9_.-]+\s*(?=<arg_key>|<arg_value>|<argument\b|<parameter\b)/i;
+const TOOL_CALL_FENCE_RE = /^```tool_call\s*([\s\S]*?)```$/i;
+const JSONISH_START_RE = /^\s*\{/;
+function enabled() {
+    try {
+        return String(process?.env?.RCC_TEXT_MARKUP_COMPAT ?? '1').trim() !== '0';
+    }
+    catch {
+        return true;
+    }
+}
+function prepareReasoningTextForHarvest(raw) {
+    const stripped = stripReasoningTransportNoise(raw);
+    if (!stripped) {
+        return '';
+    }
+    const fenced = tryNormalizeFencedToolCallJson(stripped);
+    if (fenced) {
+        return fenced;
+    }
+    if (!TOOL_CALL_OPEN_RE.test(stripped) && TOOL_CALL_CLOSE_RE.test(stripped) && BARE_TOOL_CALL_PREFIX_RE.test(stripped)) {
+        return `<tool_call>${stripped}`;
+    }
+    return stripped;
+}
+function tryNormalizeFencedToolCallJson(raw) {
+    const match = raw.match(TOOL_CALL_FENCE_RE);
+    const body = match?.[1]?.trim();
+    if (!body || !JSONISH_START_RE.test(body)) {
+        return null;
+    }
+    const balanced = balanceJsonishObject(body);
+    let parsed = null;
+    try {
+        parsed = JSON.parse(balanced);
+    }
+    catch {
+        parsed = parseLenientJsonishWithNative(balanced);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return null;
+    }
+    const name = typeof parsed.name === 'string' ? parsed.name.trim() : '';
+    if (!name) {
+        return null;
+    }
+    const argumentsValue = parsed.arguments;
+    const argumentsObject = argumentsValue && typeof argumentsValue === 'object' && !Array.isArray(argumentsValue)
+        ? argumentsValue
+        : {};
+    return `[tool_call name="${name}"]${JSON.stringify({ arguments: argumentsObject })}[/tool_call]`;
+}
+function balanceJsonishObject(raw) {
+    const openBraces = (raw.match(/\{/g) || []).length;
+    const closeBraces = (raw.match(/\}/g) || []).length;
+    if (closeBraces >= openBraces) {
+        return raw;
+    }
+    return raw + '}'.repeat(openBraces - closeBraces);
+}
+function consumeHarvestedReasoningText(target, sourceMessage) {
+    let changed = false;
+    const next = { ...target };
+    for (const key of TOOL_HARVEST_KEYS) {
+        const raw = typeof next?.[key] === 'string'
+            ? next[key]
+            : typeof sourceMessage?.[key] === 'string'
+                ? sourceMessage[key]
+                : '';
+        if (!raw.trim()) {
+            continue;
+        }
+        const sourceText = prepareReasoningTextForHarvest(raw);
+        if (!sourceText) {
+            if (key in next) {
+                delete next[key];
+                changed = true;
+            }
+            continue;
+        }
+        const extracted = extractToolCallsFromReasoningTextWithNative(sourceText, 'reasoning');
+        if (!Array.isArray(extracted.toolCalls) || extracted.toolCalls.length === 0) {
+            continue;
+        }
+        const cleanedText = typeof extracted.cleanedText === 'string' ? extracted.cleanedText.trim() : '';
+        if (cleanedText) {
+            if (next[key] !== cleanedText) {
+                next[key] = cleanedText;
+                changed = true;
+            }
+        }
+        else if (key in next) {
+            delete next[key];
+            changed = true;
+        }
+        if (!Array.isArray(next.tool_calls) || next.tool_calls.length === 0) {
+            next.tool_calls = extracted.toolCalls;
+            changed = true;
+        }
+    }
+    return changed ? next : target;
+}
+export function normalizeAssistantTextToToolCalls(message, options) {
+    if (!enabled())
+        return message;
+    const normalized = normalizeAssistantTextToToolCallsWithNative(message, options);
+    if (Array.isArray(normalized?.tool_calls) && normalized.tool_calls.length > 0) {
+        return consumeHarvestedReasoningText(normalized, message);
+    }
+    return consumeHarvestedReasoningText(normalized, message);
+}

package/vendor/@jsonstudio/llms/dist/conversion/shared/text-markup-normalizer.d.ts

@@ -0,0 +1,4 @@
+export type { JsonToolRepairConfig, TextMarkupNormalizeOptions, ToolCallLite } from '../types/text-markup-normalizer.js';
+export { extractApplyPatchCallsFromTextWithNative as extractApplyPatchCallsFromText, extractBareExecCommandFromTextWithNative as extractBareExecCommandFromText, extractExecuteBlocksFromTextWithNative as extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromTextWithNative as extractExploredListDirectoryCallsFromText, extractInvokeToolsFromTextWithNative as extractInvokeToolsFromText, extractJsonToolCallsFromTextWithNative as extractJsonToolCallsFromText, extractParameterXmlToolsFromTextWithNative as extractParameterXmlToolsFromText, extractQwenToolCallTokensFromTextWithNative as extractQwenToolCallTokensFromText, extractSimpleXmlToolsFromTextWithNative as extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromTextWithNative as extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromTextWithNative as extractXMLToolCallsFromText } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export { normalizeAssistantTextToToolCalls } from './text-markup-normalizer/normalize.js';
+export { extractToolCallsFromReasoningTextWithNative, parseLenientJsonishWithNative, repairArgumentsToStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';

package/vendor/@jsonstudio/llms/dist/conversion/shared/text-markup-normalizer.js

@@ -0,0 +1,3 @@
+export { extractApplyPatchCallsFromTextWithNative as extractApplyPatchCallsFromText, extractBareExecCommandFromTextWithNative as extractBareExecCommandFromText, extractExecuteBlocksFromTextWithNative as extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromTextWithNative as extractExploredListDirectoryCallsFromText, extractInvokeToolsFromTextWithNative as extractInvokeToolsFromText, extractJsonToolCallsFromTextWithNative as extractJsonToolCallsFromText, extractParameterXmlToolsFromTextWithNative as extractParameterXmlToolsFromText, extractQwenToolCallTokensFromTextWithNative as extractQwenToolCallTokensFromText, extractSimpleXmlToolsFromTextWithNative as extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromTextWithNative as extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromTextWithNative as extractXMLToolCallsFromText } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export { normalizeAssistantTextToToolCalls } from './text-markup-normalizer/normalize.js';
+export { extractToolCallsFromReasoningTextWithNative, parseLenientJsonishWithNative, repairArgumentsToStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';

package/vendor/@jsonstudio/llms/dist/conversion/shared/thought-signature-validator.d.ts

@@ -0,0 +1,52 @@
+/**
+ * ThoughtSignature Validator
+ *
+ * 提供严格的 thoughtSignature 验证功能，用于 Claude/Gemini thinking 块的签名验证。
+ * 参考 gcli2api 的实现，确保与上游 API 的兼容性。
+ */
+import type { JsonObject, JsonValue } from '../hub/types/json.js';
+export interface ThoughtSignatureValidationOptions {
+    /**
+     * 最小签名长度（默认 50 个字符）
+     */
+    minLength?: number;
+    /**
+     * 是否允许空 thinking + 任意签名（trailing signature case）
+     * 默认 true
+     */
+    allowEmptyThinkingWithSignature?: boolean;
+    /**
+     * 是否在验证失败时将 thinking 转换为文本
+     * 默认 true
+     */
+    convertToTextOnFailure?: boolean;
+}
+/**
+ * 检查 thinking 块是否有有效的 thoughtSignature
+ *
+ * @param block - thinking 块对象
+ * @param options - 验证选项
+ * @returns 是否有效
+ */
+export declare function hasValidThoughtSignature(block: unknown, options?: ThoughtSignatureValidationOptions): boolean;
+/**
+ * 清理 thinking 块，移除额外字段，保留有效签名
+ *
+ * @param block - thinking 块对象
+ * @returns 清理后的块
+ */
+export declare function sanitizeThinkingBlock(block: unknown): JsonObject;
+/**
+ * 过滤消息中的无效 thinking 块
+ *
+ * @param messages - Anthropic messages 列表（会被修改）
+ * @param options - 验证选项
+ */
+export declare function filterInvalidThinkingBlocks(messages: JsonValue[], options?: ThoughtSignatureValidationOptions): void;
+/**
+ * 移除末尾未签名的 thinking 块
+ *
+ * @param blocks - content blocks 列表（会被修改）
+ * @param options - 验证选项
+ */
+export declare function removeTrailingUnsignedThinkingBlocks(blocks: JsonValue[], options?: ThoughtSignatureValidationOptions): void;

package/vendor/@jsonstudio/llms/dist/conversion/shared/thought-signature-validator.js

@@ -0,0 +1,58 @@
+/**
+ * ThoughtSignature Validator
+ *
+ * 提供严格的 thoughtSignature 验证功能，用于 Claude/Gemini thinking 块的签名验证。
+ * 参考 gcli2api 的实现，确保与上游 API 的兼容性。
+ */
+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
+ *
+ * @param block - thinking 块对象
+ * @param options - 验证选项
+ * @returns 是否有效
+ */
+export function hasValidThoughtSignature(block, options) {
+    assertThoughtSignatureValidatorNativeAvailable();
+    return hasValidThoughtSignatureWithNative(block, options);
+}
+/**
+ * 清理 thinking 块，移除额外字段，保留有效签名
+ *
+ * @param block - thinking 块对象
+ * @returns 清理后的块
+ */
+export function sanitizeThinkingBlock(block) {
+    assertThoughtSignatureValidatorNativeAvailable();
+    return sanitizeThinkingBlockWithNative(block);
+}
+/**
+ * 过滤消息中的无效 thinking 块
+ *
+ * @param messages - Anthropic messages 列表（会被修改）
+ * @param options - 验证选项
+ */
+export function filterInvalidThinkingBlocks(messages, options) {
+    assertThoughtSignatureValidatorNativeAvailable();
+    const normalized = filterInvalidThinkingBlocksWithNative(messages, options);
+    messages.splice(0, messages.length, ...normalized);
+}
+/**
+ * 移除末尾未签名的 thinking 块
+ *
+ * @param blocks - content blocks 列表（会被修改）
+ * @param options - 验证选项
+ */
+export function removeTrailingUnsignedThinkingBlocks(blocks, options) {
+    assertThoughtSignatureValidatorNativeAvailable();
+    const normalized = removeTrailingUnsignedThinkingBlocksWithNative(blocks, options);
+    blocks.splice(0, blocks.length, ...normalized);
+}