@jsonstudio/llms 0.6.2172 → 0.6.2979

package/dist/conversion/shared/bridge-id-utils.js

@@ -1,79 +1,13 @@
-import { createHash } from 'node:crypto';
-const MAX_RESPONSES_ITEM_ID_LENGTH = 64;
-function sanitizeCore(value) {
-    return value
-        .replace(/[^A-Za-z0-9_-]/g, '_')
-        .replace(/_{2,}/g, '_')
-        .replace(/^_+/, '')
-        .replace(/_+$/, '');
-}
-function shortHash(value) {
-    try {
-        return createHash('sha1').update(value).digest('hex').slice(0, 10);
-    }
-    catch {
-        return Math.random().toString(36).slice(2, 12);
-    }
-}
-function clampPrefixedId(prefix, core, hashSource) {
-    const sanitized = sanitizeCore(core) || Math.random().toString(36).slice(2, 10);
-    const direct = `${prefix}${sanitized}`;
-    if (direct.length <= MAX_RESPONSES_ITEM_ID_LENGTH) {
-        return direct;
-    }
-    const hash = shortHash(`${prefix}|${hashSource}|${sanitized}`);
-    const room = Math.max(1, MAX_RESPONSES_ITEM_ID_LENGTH - prefix.length - 1 - hash.length);
-    const head = sanitizeCore(sanitized.slice(0, room)) || 'id';
-    return `${prefix}${head}_${hash}`;
-}
-function extractCore(value) {
-    if (typeof value !== 'string')
-        return null;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return null;
-    let sanitized = sanitizeCore(trimmed);
-    if (!sanitized)
-        return null;
-    if (/^fc[_-]/i.test(sanitized)) {
-        sanitized = sanitized.replace(/^fc[_-]?/i, '');
-    }
-    else if (/^call[_-]/i.test(sanitized)) {
-        sanitized = sanitized.replace(/^call[_-]?/i, '');
-    }
-    return sanitizeCore(sanitized) || null;
-}
-function normalizeWithFallback(options, prefix) {
-    const callCore = extractCore(options.callId);
-    if (callCore) {
-        return clampPrefixedId(prefix, callCore, String(options.callId));
-    }
-    const fallbackCore = extractCore(options.fallback);
-    if (fallbackCore) {
-        return clampPrefixedId(prefix, fallbackCore, String(options.fallback));
-    }
-    const randomCore = Math.random().toString(36).slice(2, 10);
-    return clampPrefixedId(prefix, randomCore, randomCore);
-}
+import { clampResponsesInputItemIdWithNative, normalizeFunctionCallIdWithNative, normalizeFunctionCallOutputIdWithNative, normalizeResponsesCallIdWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function normalizeFunctionCallId(options) {
-    return normalizeWithFallback(options, 'fc_');
+    return normalizeFunctionCallIdWithNative(options);
 }
 export function normalizeFunctionCallOutputId(options) {
-    return normalizeWithFallback(options, 'fc_');
+    return normalizeFunctionCallOutputIdWithNative(options);
 }
 export function normalizeResponsesCallId(options) {
-    return normalizeWithFallback(options, 'call_');
+    return normalizeResponsesCallIdWithNative(options);
 }
 export function clampResponsesInputItemId(raw) {
-    const trimmed = typeof raw === 'string' ? raw.trim() : '';
-    if (!trimmed) {
-        return undefined;
-    }
-    if (trimmed.length <= MAX_RESPONSES_ITEM_ID_LENGTH) {
-        return trimmed;
-    }
-    const hash = shortHash(trimmed);
-    const room = Math.max(1, MAX_RESPONSES_ITEM_ID_LENGTH - 1 - hash.length);
-    const head = trimmed.slice(0, room);
-    return `${head}_${hash}`;
+    return clampResponsesInputItemIdWithNative(raw);
 }

package/dist/conversion/shared/bridge-instructions.js

@@ -1,3 +1,4 @@
+import { sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 function collectTextFromBlocks(blocks) {
     const parts = [];
     for (const block of blocks) {
@@ -77,7 +78,7 @@ function extractSystemInstruction(entry) {
                 collected.push(text);
         }
     }
-    const merged = collected.join('\n').trim();
+    const merged = sanitizeReasoningTaggedTextWithNative(collected.join('\n')).trim();
     return merged ? merged : null;
 }
 export function ensureBridgeInstructions(payload) {

package/dist/conversion/shared/bridge-message-types.d.ts

@@ -1,3 +1,4 @@
+import type { NativeReqInboundSemanticLiftApplyInput } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 export type BridgeContentPart = {
     type: string;
     text?: string;
@@ -37,3 +38,4 @@ export type BridgeToolDefinition = {
         parameters?: unknown;
     };
 };
+export type BridgeNativeEnvelope = NativeReqInboundSemanticLiftApplyInput['chatEnvelope'];

package/dist/conversion/shared/bridge-message-utils.js

@@ -1,6 +1,5 @@
-import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './bridge-id-utils.js';
 import { normalizeChatMessageContent } from './chat-output-normalizer.js';
-import { repairToolArguments } from './tool-argument-repairer.js';
+import { normalizeFunctionCallIdWithNative as normalizeFunctionCallId, normalizeFunctionCallOutputIdWithNative as normalizeFunctionCallOutputId, repairArgumentsToStringWithNative as repairToolArguments } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 function ensureAssistantToolCallIdentity(call, fallbackId) {
     const resolved = (typeof call.id === 'string' && call.id.trim().length ? call.id.trim() : undefined) ??
         (typeof call.tool_call_id === 'string' && call.tool_call_id.trim().length

package/dist/conversion/shared/bridge-metadata.d.ts

@@ -1 +1,2 @@
 export declare const BRIDGE_RAW_SYSTEM_METADATA_KEY = "__rcc_raw_system";
+export declare function resolveBridgeMetadataNativeProtocol(): string;

package/dist/conversion/shared/bridge-metadata.js

@@ -1 +1,5 @@
 export const BRIDGE_RAW_SYSTEM_METADATA_KEY = '__rcc_raw_system';
+import { normalizeProviderProtocolTokenWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export function resolveBridgeMetadataNativeProtocol() {
+    return normalizeProviderProtocolTokenWithNative('openai-responses') ?? 'openai-responses';
+}

package/dist/conversion/shared/bridge-policies.js

@@ -1,195 +1,11 @@
-import { RESPONSES_INSTRUCTIONS_REASONING_FIELD } from './reasoning-normalizer.js';
-import { ANTHROPIC_ALLOWED_FIELDS, GEMINI_ALLOWED_FIELDS, OPENAI_CHAT_ALLOWED_FIELDS, OPENAI_RESPONSES_ALLOWED_FIELDS } from './protocol-field-allowlists.js';
-function reasoningAction(idPrefix) {
-    return {
-        name: 'reasoning.extract',
-        options: {
-            dropFromContent: true,
-            idPrefix
-        }
-    };
-}
-function toolCallNormalizationAction(idPrefix) {
-    if (idPrefix && idPrefix.trim().length) {
-        return {
-            name: 'tools.normalize-call-ids',
-            options: { idPrefix: idPrefix.trim() }
-        };
-    }
-    return { name: 'tools.normalize-call-ids' };
-}
-const RESPONSES_POLICY = {
-    id: 'openai-responses-default',
-    protocol: 'openai-responses',
-    request: {
-        inbound: [
-            {
-                name: 'messages.inject-system-instruction',
-                options: {
-                    field: 'instructions',
-                    reasoningField: RESPONSES_INSTRUCTIONS_REASONING_FIELD
-                }
-            },
-            { name: 'messages.ensure-system-instruction' },
-            reasoningAction('responses_reasoning'),
-            toolCallNormalizationAction('responses_tool_call'),
-            { name: 'tools.ensure-placeholders' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_RESPONSES_ALLOWED_FIELDS } },
-            { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
-            { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } }
-        ],
-        outbound: [
-            { name: 'messages.normalize-history' },
-            { name: 'tools.capture-results' },
-            toolCallNormalizationAction('responses_tool_call'),
-            { name: 'tools.ensure-placeholders' },
-            { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
-            { name: 'messages.ensure-system-instruction' },
-            reasoningAction('responses_reasoning'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_RESPONSES_ALLOWED_FIELDS } },
-            { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
-            { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } }
-        ]
-    },
-    response: {
-        inbound: [
-            { name: 'reasoning.attach-output' },
-            reasoningAction('responses_reasoning'),
-            toolCallNormalizationAction('responses_tool_call'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_RESPONSES_ALLOWED_FIELDS } }
-        ],
-        outbound: [
-            reasoningAction('responses_reasoning'),
-            toolCallNormalizationAction('responses_tool_call'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_RESPONSES_ALLOWED_FIELDS } }
-        ]
-    }
-};
-const OPENAI_CHAT_POLICY = {
-    id: 'openai-chat-default',
-    protocol: 'openai-chat',
-    request: {
-        inbound: [
-            reasoningAction('openai_chat_reasoning'),
-            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
-            { name: 'messages.ensure-system-instruction' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } },
-            { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
-            { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } }
-        ],
-        outbound: [
-            { name: 'messages.normalize-history' },
-            { name: 'tools.capture-results' },
-            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
-            { name: 'tools.ensure-placeholders' },
-            { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
-            { name: 'messages.ensure-system-instruction' },
-            reasoningAction('openai_chat_reasoning'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } },
-            { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
-            { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } }
-        ]
-    },
-    response: {
-        inbound: [
-            reasoningAction('openai_chat_reasoning'),
-            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } }
-        ],
-        outbound: [
-            reasoningAction('openai_chat_reasoning'),
-            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } }
-        ]
-    }
-};
-const ANTHROPIC_POLICY = {
-    id: 'anthropic-messages-default',
-    protocol: 'anthropic-messages',
-    request: {
-        inbound: [
-            reasoningAction('anthropic_reasoning'),
-            toolCallNormalizationAction('anthropic_tool_call'),
-            { name: 'messages.ensure-system-instruction' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: ANTHROPIC_ALLOWED_FIELDS } }
-        ],
-        outbound: [
-            { name: 'messages.normalize-history' },
-            { name: 'tools.capture-results' },
-            toolCallNormalizationAction('anthropic_tool_call'),
-            { name: 'tools.ensure-placeholders' },
-            { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
-            { name: 'messages.ensure-system-instruction' },
-            reasoningAction('anthropic_reasoning'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: ANTHROPIC_ALLOWED_FIELDS } }
-        ]
-    },
-    response: {
-        inbound: [
-            reasoningAction('anthropic_reasoning'),
-            toolCallNormalizationAction('anthropic_tool_call'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: ANTHROPIC_ALLOWED_FIELDS } }
-        ],
-        outbound: [
-            reasoningAction('anthropic_reasoning'),
-            toolCallNormalizationAction('anthropic_tool_call'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: ANTHROPIC_ALLOWED_FIELDS } }
-        ]
-    }
-};
-const GEMINI_POLICY = {
-    id: 'gemini-chat-default',
-    protocol: 'gemini-chat',
-    request: {
-        inbound: [
-            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
-            { name: 'messages.ensure-system-instruction' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
-        ],
-        outbound: [
-            { name: 'messages.normalize-history' },
-            { name: 'tools.capture-results' },
-            { name: 'tools.ensure-placeholders' },
-            { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
-            { name: 'messages.ensure-system-instruction' },
-            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
-        ]
-    },
-    response: {
-        inbound: [
-            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
-        ],
-        outbound: [
-            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
-        ]
-    }
-};
-const POLICIES = [RESPONSES_POLICY, OPENAI_CHAT_POLICY, ANTHROPIC_POLICY, GEMINI_POLICY];
+import { resolveBridgePolicyActionsWithNative, resolveBridgePolicyWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.js';
 export function resolveBridgePolicy(options) {
-    if (!options)
+    const resolved = resolveBridgePolicyWithNative(options);
+    if (!resolved) {
         return undefined;
-    const { protocol, moduleType } = options;
-    if (protocol) {
-        const match = POLICIES.find((policy) => policy.protocol === protocol);
-        if (match)
-            return match;
-    }
-    if (moduleType) {
-        const match = POLICIES.find((policy) => policy.moduleType === moduleType);
-        if (match)
-            return match;
     }
-    return undefined;
+    return resolved;
 }
 export function resolvePolicyActions(policy, stage) {
-    if (!policy)
-        return undefined;
-    const [phaseKey, directionKey] = stage.split('_');
-    const phase = policy[phaseKey];
-    if (!phase)
-        return undefined;
-    return phase[directionKey];
+    return resolveBridgePolicyActionsWithNative(policy, stage);
 }

package/dist/conversion/shared/chat-envelope-validator.js

@@ -1,128 +1,4 @@
-import { isJsonObject } from '../hub/types/json.js';
-const ALLOWED_ROLES = new Set(['system', 'user', 'assistant', 'tool']);
-const RESERVED_EXACT_KEYS = new Set(['stages', 'stageExpectations']);
-const RESERVED_PREFIXES = ['__rcc_'];
+import { validateChatEnvelopeWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
 export function validateChatEnvelope(chat, options) {
-    if (!chat || typeof chat !== 'object') {
-        throw buildError('chatEnvelope_missing', 'Chat envelope must be an object', options);
-    }
-    assertNoReservedKeys(chat, 'chatEnvelope', options);
-    if (!Array.isArray(chat.messages) || chat.messages.length === 0) {
-        throw buildError('messages_missing', 'Chat envelope must include at least one message', options);
-    }
-    chat.messages.forEach((message, index) => {
-        if (!message || typeof message !== 'object') {
-            throw buildError('message_shape', `messages[${index}] must be an object`, options);
-        }
-        assertNoReservedKeys(message, `messages[${index}]`, options);
-        if (typeof message.role !== 'string' || !ALLOWED_ROLES.has(message.role)) {
-            throw buildError('message_role', `messages[${index}].role must be one of ${Array.from(ALLOWED_ROLES).join(', ')}`, options);
-        }
-        validateToolCalls(message, index, options);
-    });
-    if (!isJsonObject(chat.parameters) || typeof chat.parameters.model !== 'string' || !chat.parameters.model.trim()) {
-        throw buildError('parameters_model', 'Chat envelope parameters.model must be a string', options);
-    }
-    assertNoReservedKeys(chat.parameters, 'parameters', options);
-    validateTools(chat.tools, options);
-    validateToolOutputs(chat.toolOutputs, options);
-    validateMetadata(chat.metadata, options);
-}
-function validateToolCalls(message, messageIndex, options) {
-    if (!Array.isArray(message.tool_calls)) {
-        return;
-    }
-    message.tool_calls.forEach((entry, callIndex) => {
-        if (!entry || typeof entry !== 'object') {
-            throw buildError('tool_call_shape', `messages[${messageIndex}].tool_calls[${callIndex}] must be an object`, options);
-        }
-        if (entry.type !== 'function') {
-            throw buildError('tool_call_type', `messages[${messageIndex}].tool_calls[${callIndex}].type must equal "function"`, options);
-        }
-        const fnNode = entry.function;
-        if (!fnNode || typeof fnNode !== 'object') {
-            throw buildError('tool_call_function', `messages[${messageIndex}].tool_calls[${callIndex}].function must be an object`, options);
-        }
-        const fnRecord = fnNode;
-        if (typeof fnRecord.name !== 'string' || !fnRecord.name.trim()) {
-            throw buildError('tool_call_name', `messages[${messageIndex}].tool_calls[${callIndex}].function.name must be a string`, options);
-        }
-        if (typeof fnRecord.arguments !== 'string') {
-            throw buildError('tool_call_arguments', `messages[${messageIndex}].tool_calls[${callIndex}].function.arguments must be a JSON string`, options);
-        }
-    });
-}
-function validateTools(tools, options) {
-    if (tools === undefined) {
-        return;
-    }
-    if (!Array.isArray(tools)) {
-        throw buildError('tools_shape', 'Chat envelope tools must be an array when provided', options);
-    }
-    tools.forEach((tool, index) => {
-        if (!tool || typeof tool !== 'object') {
-            throw buildError('tools_shape', `tools[${index}] must be an object`, options);
-        }
-        if (tool.type !== 'function') {
-            throw buildError('tools_type', `tools[${index}].type must equal "function"`, options);
-        }
-        const fnNode = tool.function;
-        if (!fnNode || typeof fnNode !== 'object' || typeof fnNode.name !== 'string' || !fnNode.name.trim()) {
-            throw buildError('tools_function', `tools[${index}].function.name must be a string`, options);
-        }
-    });
-}
-function validateToolOutputs(outputs, options) {
-    if (outputs === undefined) {
-        return;
-    }
-    if (!Array.isArray(outputs)) {
-        throw buildError('tool_outputs_shape', 'toolOutputs must be an array when provided', options);
-    }
-    outputs.forEach((entry, index) => {
-        if (!entry || typeof entry !== 'object') {
-            throw buildError('tool_outputs_shape', `toolOutputs[${index}] must be an object`, options);
-        }
-        if (typeof entry.tool_call_id !== 'string' || !entry.tool_call_id.trim()) {
-            throw buildError('tool_outputs_id', `toolOutputs[${index}].tool_call_id must be a string`, options);
-        }
-        if (typeof entry.content !== 'string') {
-            throw buildError('tool_outputs_content', `toolOutputs[${index}].content must be a string`, options);
-        }
-    });
-}
-function validateMetadata(metadata, options) {
-    if (!isJsonObject(metadata)) {
-        throw buildError('metadata_shape', 'Chat envelope metadata must be an object', options);
-    }
-    assertNoReservedKeys(metadata, 'metadata', options);
-    if (!isJsonObject(metadata.context)) {
-        throw buildError('metadata_context', 'metadata.context must be an object', options);
-    }
-    if (metadata.extraFields !== undefined) {
-        if (!isJsonObject(metadata.extraFields)) {
-            throw buildError('metadata_extra_fields', 'metadata.extraFields must be an object when provided', options);
-        }
-        assertNoReservedKeys(metadata.extraFields, 'metadata.extraFields', options, true);
-    }
-    if (metadata.providerMetadata !== undefined && !isJsonObject(metadata.providerMetadata)) {
-        throw buildError('metadata_provider', 'metadata.providerMetadata must be an object when provided', options);
-    }
-}
-function assertNoReservedKeys(target, path, options, allowStageKeys = false) {
-    if (!target || typeof target !== 'object') {
-        return;
-    }
-    for (const key of Object.keys(target)) {
-        if (!allowStageKeys && RESERVED_EXACT_KEYS.has(key)) {
-            throw buildError('reserved_key', `${path} contains reserved field "${key}"`, options);
-        }
-        if (RESERVED_PREFIXES.some((prefix) => key.startsWith(prefix))) {
-            throw buildError('reserved_key', `${path} contains reserved field "${key}"`, options);
-        }
-    }
-}
-function buildError(code, detail, options) {
-    const source = options.source ? ` source=${options.source}` : '';
-    return new Error(`ChatEnvelopeValidationError(${options.stage}/${options.direction})[${code}] ${detail}${source}`);
+    validateChatEnvelopeWithNative(chat, options);
 }

package/dist/conversion/shared/chat-output-normalizer.js

@@ -1,56 +1,4 @@
-import { extractReasoningSegments, sanitizeReasoningTaggedText } from './reasoning-utils.js';
-function collectText(value, collector) {
-    if (value == null) {
-        return;
-    }
-    if (typeof value === 'string') {
-        const cleaned = extractReasoningSegments(value, collector.reasoningParts);
-        if (cleaned.length) {
-            collector.textParts.push(cleaned);
-        }
-        return;
-    }
-    if (Array.isArray(value)) {
-        for (const entry of value) {
-            collectText(entry, collector);
-        }
-        return;
-    }
-    if (typeof value === 'object') {
-        const record = value;
-        if (typeof record.text === 'string') {
-            collectText(record.text, collector);
-            return;
-        }
-        if (typeof record.content === 'string') {
-            collectText(record.content, collector);
-            return;
-        }
-        if (Array.isArray(record.content)) {
-            collectText(record.content, collector);
-            return;
-        }
-        if (record.type === 'image_url' && typeof record.image_url === 'string') {
-            collector.textParts.push(`[image:${record.image_url}]`);
-            return;
-        }
-        try {
-            collector.textParts.push(sanitizeReasoningTaggedText(JSON.stringify(record)));
-        }
-        catch {
-            collector.textParts.push(String(record));
-        }
-        return;
-    }
-    collector.textParts.push(sanitizeReasoningTaggedText(String(value)));
-}
+import { normalizeChatMessageContentWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function normalizeChatMessageContent(content) {
-    const collector = { textParts: [], reasoningParts: [] };
-    collectText(content, collector);
-    const text = collector.textParts.join('');
-    const reasoning = collector.reasoningParts.join('\n');
-    return {
-        contentText: text.length ? text : undefined,
-        reasoningText: reasoning.length ? reasoning : undefined
-    };
+    return normalizeChatMessageContentWithNative(content);
 }

package/dist/conversion/shared/compaction-detect.js

@@ -1,59 +1,4 @@
-function hasCompactionMarker(value) {
-    // Compaction markers are intended to be explicit “header-like” sentinels produced by
-    // our own compaction flows, not arbitrary substrings inside user/dev instructions.
-    //
-    // If we treat any occurrence as a compaction request, normal conversations that
-    // contain phrases like “handoff summary …” (e.g. debug summaries pasted into chat)
-    // will get misclassified and will disable stopMessage / other servertools.
-    const lower = value.trimStart().toLowerCase();
-    return (lower.startsWith('context checkpoint compaction') ||
-        lower.startsWith('checkpoint compaction') ||
-        lower.startsWith('handoff summary for another llm'));
-}
-function containsMarker(value) {
-    if (typeof value === 'string') {
-        return hasCompactionMarker(value);
-    }
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    if (Array.isArray(value)) {
-        return value.some((entry) => containsMarker(entry));
-    }
-    const record = value;
-    if (typeof record.text === 'string' && hasCompactionMarker(record.text)) {
-        return true;
-    }
-    if (typeof record.content === 'string' && hasCompactionMarker(record.content)) {
-        return true;
-    }
-    if (Array.isArray(record.content) && record.content.some((entry) => containsMarker(entry))) {
-        return true;
-    }
-    if (Array.isArray(record.parts) && record.parts.some((entry) => containsMarker(entry))) {
-        return true;
-    }
-    return false;
-}
+import { isCompactionRequestWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function isCompactionRequest(payload) {
-    if (containsMarker(payload)) {
-        return true;
-    }
-    const messages = payload.messages;
-    if (Array.isArray(messages) && messages.some((msg) => containsMarker(msg))) {
-        return true;
-    }
-    const input = payload.input;
-    if (containsMarker(input)) {
-        return true;
-    }
-    const system = payload.system;
-    if (containsMarker(system)) {
-        return true;
-    }
-    const instructions = payload.instructions;
-    if (containsMarker(instructions)) {
-        return true;
-    }
-    return false;
+    return isCompactionRequestWithNative(payload);
 }