@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/conversion/codecs/responses-openai-codec.js

@@ -160,7 +160,7 @@ export class ResponsesOpenAIConversionCodec {
         // No fallback append here: pairing must be produced upstream or by standard bridge mapping.
         // Debug snapshot after mapping to Responses JSON (non-stream)
         try {
-            const { writeSnapshotViaHooks } = await import('../shared/snapshot-hooks.js');
+            const { writeSnapshotViaHooks } = await import('../snapshot-utils.js');
             await writeSnapshotViaHooks({
                 endpoint: '/v1/responses',
                 stage: 'response_mapped_json',

package/dist/conversion/{shared/compaction-detect.d.ts → compaction-detect.d.ts}

@@ -1,2 +1,2 @@
-import type { JsonObject } from '../hub/types/json.js';
+import type { JsonObject } from './hub/types/json.js';
 export declare function isCompactionRequest(payload: JsonObject): boolean;

package/dist/conversion/compaction-detect.js

@@ -0,0 +1,4 @@
+import { isCompactionRequestWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function isCompactionRequest(payload) {
+    return isCompactionRequestWithNative(payload);
+}

package/dist/conversion/compat/actions/apply-patch-fixer.js

@@ -1,5 +1,5 @@
-import { registerBridgeAction } from '../../shared/bridge-actions.js';
-import { ensureMessagesArray } from '../../shared/bridge-message-utils.js';
+import { registerBridgeAction } from '../../bridge-actions.js';
+import { ensureMessagesArray } from '../../bridge-message-utils.js';
 import { validateToolCall } from '../../../tools/tool-registry.js';
 const fixApplyPatchAction = (ctx) => {
     const messages = ensureMessagesArray(ctx.state);

package/dist/conversion/compat/actions/deepseek-web-response.d.ts

@@ -3,7 +3,6 @@ import type { JsonObject } from '../../hub/types/json.js';
 import { type TextMarkupNormalizeOptions } from '../../shared/text-markup-normalizer.js';
 export interface DeepSeekWebResponseConfig {
     strictToolRequired?: boolean;
-    textToolFallback?: boolean;
     textNormalizer?: TextMarkupNormalizeOptions;
 }
 export declare function applyDeepSeekWebResponseTransform(payload: JsonObject, adapterContext?: AdapterContext, config?: DeepSeekWebResponseConfig): JsonObject;

package/dist/conversion/compat/actions/deepseek-web-response.js

@@ -1,9 +1,7 @@
-import { normalizeAssistantTextToToolCalls } from '../../shared/text-markup-normalizer.js';
 import { validateToolCall } from '../../../tools/tool-registry.js';
 import { encoding_for_model, get_encoding } from 'tiktoken';
 const DEFAULT_OPTIONS = {
     strictToolRequired: true,
-    textToolFallback: true,
     textNormalizer: undefined
 };
 const SHELL_LIKE_TOOL_NAMES = new Set(['exec_command', 'shell_command', 'shell', 'bash', 'terminal']);
@@ -121,17 +119,13 @@ function resolveOptions(adapterContext, config) {
         return {
             ...DEFAULT_OPTIONS,
             strictToolRequired: readOptionalBoolean(config?.strictToolRequired) ?? DEFAULT_OPTIONS.strictToolRequired,
-            textToolFallback: readOptionalBoolean(config?.textToolFallback) ?? DEFAULT_OPTIONS.textToolFallback,
             textNormalizer: config?.textNormalizer
         };
     }
     const strictOverride = readOptionalBoolean(config?.strictToolRequired);
-    const fallbackOverride = readOptionalBoolean(config?.textToolFallback);
     return {
         strictToolRequired: strictOverride ??
             readBoolean(deepseekNode.strictToolRequired, DEFAULT_OPTIONS.strictToolRequired),
-        textToolFallback: fallbackOverride ??
-            readBoolean(deepseekNode.textToolFallback, DEFAULT_OPTIONS.textToolFallback),
         textNormalizer: config?.textNormalizer && typeof config.textNormalizer === 'object'
             ? config.textNormalizer
             : undefined
@@ -610,369 +604,6 @@ function normalizeMessageToolCalls(message, allowedToolNames, callIdPrefix) {
     message.content = null;
     return true;
 }
-function collectMessageTextCandidates(message) {
-    const candidates = [];
-    const content = message.content;
-    if (typeof content === 'string' && content.trim().length) {
-        candidates.push(content);
-    }
-    else if (Array.isArray(content)) {
-        for (const part of content) {
-            if (!isRecord(part)) {
-                continue;
-            }
-            const text = readString(part.text) ?? readString(part.content);
-            if (text) {
-                candidates.push(text);
-            }
-        }
-    }
-    const reasoning = readString(message.reasoning) ?? readString(message.reasoning_content);
-    if (reasoning) {
-        candidates.push(reasoning);
-    }
-    return candidates;
-}
-function normalizeFunctionResultsMarkupText(value) {
-    let changed = false;
-    const replaced = value.replace(/<function_results>\s*([\s\S]*?)\s*<\/function_results>/gi, (_match, inner) => {
-        changed = true;
-        const payload = typeof inner === 'string' ? inner.trim() : '';
-        if (!payload.length) {
-            return '';
-        }
-        return `\n\`\`\`json\n${payload}\n\`\`\`\n`;
-    });
-    if (!changed) {
-        return { text: value, changed: false };
-    }
-    return {
-        text: replaced.replace(/\n{3,}/g, '\n\n').trim(),
-        changed: true
-    };
-}
-function normalizeCommentaryMarkupText(value) {
-    const capturedCommentary = [];
-    let changed = false;
-    const stripped = value.replace(/<\s*commentary\s*>([\s\S]*?)<\s*\/\s*commentary\s*>/gi, (_match, inner) => {
-        changed = true;
-        const text = typeof inner === 'string' ? inner.trim() : '';
-        if (text.length) {
-            capturedCommentary.push(text);
-        }
-        return '';
-    });
-    if (!changed) {
-        return { text: value, changed: false };
-    }
-    const collapsed = stripped.replace(/\n{3,}/g, '\n\n').trim();
-    if (collapsed.length) {
-        return { text: collapsed, changed: true };
-    }
-    return {
-        text: capturedCommentary.join('\n\n').trim(),
-        changed: true
-    };
-}
-function harvestFunctionResultsMarkup(message) {
-    let harvested = false;
-    const apply = (input) => {
-        if (typeof input !== 'string') {
-            return undefined;
-        }
-        const functionResultsNormalized = normalizeFunctionResultsMarkupText(input);
-        if (functionResultsNormalized.changed) {
-            harvested = true;
-        }
-        const commentaryNormalized = normalizeCommentaryMarkupText(functionResultsNormalized.text);
-        return commentaryNormalized.text;
-    };
-    if (typeof message.content === 'string') {
-        const next = apply(message.content);
-        if (typeof next === 'string') {
-            message.content = next;
-        }
-    }
-    else if (Array.isArray(message.content)) {
-        for (const part of message.content) {
-            if (!isRecord(part)) {
-                continue;
-            }
-            if (typeof part.text === 'string') {
-                const next = apply(part.text);
-                if (typeof next === 'string') {
-                    part.text = next;
-                }
-            }
-            if (typeof part.content === 'string') {
-                const next = apply(part.content);
-                if (typeof next === 'string') {
-                    part.content = next;
-                }
-            }
-        }
-    }
-    if (typeof message.reasoning === 'string') {
-        const next = apply(message.reasoning);
-        if (typeof next === 'string') {
-            message.reasoning = next;
-        }
-    }
-    if (typeof message.reasoning_content === 'string') {
-        const next = apply(message.reasoning_content);
-        if (typeof next === 'string') {
-            message.reasoning_content = next;
-        }
-    }
-    return harvested;
-}
-function extractToolCallsFromDeepSeekJsonText(text, allowedToolNames, callIdPrefix) {
-    const normalized = [];
-    const trimmed = text.trim();
-    if (!trimmed.length) {
-        return normalized;
-    }
-    const parseCandidate = (candidate) => {
-        if (!isRecord(candidate)) {
-            return;
-        }
-        const calls = coerceToolCallsValue(candidate.tool_calls);
-        for (const entry of calls) {
-            if (!isRecord(entry)) {
-                continue;
-            }
-            const call = normalizeToolCallEntry(entry, allowedToolNames, callIdPrefix, normalized.length);
-            if (call) {
-                normalized.push(call);
-            }
-        }
-    };
-    const standalonePayload = (() => {
-        const trimDeepSeekTailArtifacts = (value) => {
-            let out = value.trim();
-            // Remove DeepSeek sentinel tails (e.g. <|end|>, <| User |>).
-            out = out
-                .replace(/(?:<[\u007C\uFF5C]\s*end[^>\n]*[\u007C\uFF5C]>\s*)+$/i, '')
-                .replace(/(?:<[\u007C\uFF5C]\s*(?:user|assistant|system|tool|observation)[^>\n]*[\u007C\uFF5C]>\s*)+$/i, '')
-                .trim();
-            return out;
-        };
-        const extractLeadingJsonObject = (value) => {
-            const trimmedValue = value.trimStart();
-            if (!trimmedValue.startsWith('{')) {
-                return undefined;
-            }
-            let depth = 0;
-            let inString = false;
-            let escaped = false;
-            for (let i = 0; i < trimmedValue.length; i += 1) {
-                const ch = trimmedValue[i] ?? '';
-                if (inString) {
-                    if (escaped) {
-                        escaped = false;
-                        continue;
-                    }
-                    if (ch === '\\') {
-                        escaped = true;
-                        continue;
-                    }
-                    if (ch === '"') {
-                        inString = false;
-                    }
-                    continue;
-                }
-                if (ch === '"') {
-                    inString = true;
-                    continue;
-                }
-                if (ch === '{') {
-                    depth += 1;
-                    continue;
-                }
-                if (ch === '}') {
-                    depth -= 1;
-                    if (depth === 0) {
-                        return trimmedValue.slice(0, i + 1).trim();
-                    }
-                    continue;
-                }
-            }
-            return undefined;
-        };
-        let candidate = trimDeepSeekTailArtifacts(trimmed);
-        const fenced = candidate.match(/^```(?:json|tool_call|tool_calls)?\s*([\s\S]*?)\s*```/i);
-        if (fenced?.[1]) {
-            candidate = trimDeepSeekTailArtifacts(fenced[1]);
-        }
-        const leadingObject = extractLeadingJsonObject(candidate);
-        if (!leadingObject) {
-            return undefined;
-        }
-        if (!/["']tool_calls["']\s*:/.test(leadingObject)) {
-            return undefined;
-        }
-        return leadingObject;
-    })();
-    if (standalonePayload) {
-        const parsedRoot = tryParseJsonText(standalonePayload);
-        if (parsedRoot !== null) {
-            parseCandidate(parsedRoot);
-        }
-    }
-    if (normalized.length === 0) {
-        const sourceForRepair = standalonePayload ?? trimmed;
-        const hasToolCallsMarker = /tool_calls/i.test(sourceForRepair);
-        const hasApplyPatchMarker = /apply_patch/i.test(sourceForRepair);
-        if (hasToolCallsMarker && hasApplyPatchMarker) {
-            const patchMatch = sourceForRepair.match(/\*\*\*\s*Begin Patch[\s\S]*?\*\*\*\s*End Patch/);
-            const patchText = readString(patchMatch?.[0]);
-            const applyPatchAllowed = allowedToolNames.size === 0 || hasAllowedToolName(allowedToolNames, 'apply_patch');
-            if (patchText && applyPatchAllowed) {
-                const validation = validateToolCall('apply_patch', patchText);
-                if (validation.ok && typeof validation.normalizedArgs === 'string' && validation.normalizedArgs.trim().length > 0) {
-                    normalized.push({
-                        id: `${callIdPrefix}_repair_1`,
-                        type: 'function',
-                        function: {
-                            name: 'apply_patch',
-                            arguments: validation.normalizedArgs
-                        }
-                    });
-                }
-            }
-        }
-    }
-    return normalized;
-}
-function normalizeMessageTextToolCalls(message, allowedToolNames, callIdPrefix) {
-    const candidates = collectMessageTextCandidates(message);
-    if (!candidates.length) {
-        return false;
-    }
-    for (const text of candidates) {
-        const calls = extractToolCallsFromDeepSeekJsonText(text, allowedToolNames, callIdPrefix);
-        if (!calls.length) {
-            continue;
-        }
-        message.tool_calls = calls;
-        message.content = null;
-        return true;
-    }
-    return false;
-}
-function looksLikeShellCommand(value) {
-    return /^(?:pnpm|npm|yarn|node|git|rg|ls|cat|find|sed|head|tail|rm|cp|mv|mkdir|bash|sh|zsh)\b/i.test(value.trim());
-}
-function parseJsonArrayCommand(value) {
-    const trimmed = value.trim();
-    if (!trimmed.startsWith('[') || !trimmed.endsWith(']')) {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(trimmed);
-        if (!Array.isArray(parsed)) {
-            return undefined;
-        }
-        const tokens = parsed
-            .map((item) => (item == null ? '' : String(item)))
-            .filter((item) => item.length > 0);
-        if (!tokens.length) {
-            return undefined;
-        }
-        return tokens.join(' ');
-    }
-    catch {
-        return undefined;
-    }
-}
-function normalizeCommandLine(raw) {
-    return raw.trim().replace(/^\$\s*/, '').trim();
-}
-function extractCommandCandidates(text) {
-    const commands = [];
-    const seen = new Set();
-    const push = (value) => {
-        const normalized = value.trim();
-        if (!normalized || seen.has(normalized)) {
-            return;
-        }
-        seen.add(normalized);
-        commands.push(normalized);
-    };
-    const blockPattern = /```(?:bash|sh|zsh)?\s*\n([\s\S]*?)```/gi;
-    let blockMatch;
-    while ((blockMatch = blockPattern.exec(text)) !== null) {
-        const block = (blockMatch[1] ?? '').toString();
-        const lines = block
-            .split(/\r?\n/)
-            .map((line) => normalizeCommandLine(line))
-            .filter((line) => line.length > 0 && !line.startsWith('#'));
-        if (!lines.length) {
-            continue;
-        }
-        const first = lines[0];
-        if (!looksLikeShellCommand(first)) {
-            continue;
-        }
-        push(lines.join('\n'));
-    }
-    const linePattern = text.split(/\r?\n/);
-    for (const raw of linePattern) {
-        const line = raw.trim();
-        if (!line.length || line.startsWith('```')) {
-            continue;
-        }
-        const ran = line.match(/^(?:[•*+-]\s*)?Ran\s+(.+)$/i);
-        if (ran?.[1]) {
-            const payload = ran[1].trim();
-            const parsedArray = parseJsonArrayCommand(payload);
-            if (parsedArray && looksLikeShellCommand(parsedArray)) {
-                push(parsedArray);
-                continue;
-            }
-            if (looksLikeShellCommand(payload)) {
-                push(payload);
-                continue;
-            }
-        }
-        const normalized = normalizeCommandLine(line);
-        if (looksLikeShellCommand(normalized)) {
-            push(normalized);
-        }
-    }
-    return commands;
-}
-function normalizeMessageCommandToolCall(message, allowedToolNames, callIdPrefix) {
-    const commandToolName = hasAllowedToolName(allowedToolNames, 'exec_command')
-        ? 'exec_command'
-        : hasAllowedToolName(allowedToolNames, 'shell_command')
-            ? 'shell_command'
-            : 'exec_command';
-    const candidates = collectMessageTextCandidates(message);
-    if (!candidates.length) {
-        return false;
-    }
-    for (const text of candidates) {
-        const commands = extractCommandCandidates(text);
-        if (!commands.length) {
-            continue;
-        }
-        const cmd = commands[commands.length - 1];
-        message.tool_calls = [
-            {
-                id: `${callIdPrefix}_cmd_1`,
-                type: 'function',
-                function: {
-                    name: commandToolName,
-                    arguments: JSON.stringify({ cmd, command: cmd })
-                }
-            }
-        ];
-        message.content = null;
-        return true;
-    }
-    return false;
-}
 function normalizeUsageSnapshot(raw) {
     if (!isRecord(raw)) {
         return {};
@@ -996,9 +627,20 @@ function estimateCompletionTokensFromChoices(choices, modelHint) {
         if (!message) {
             continue;
         }
-        const candidates = collectMessageTextCandidates(message);
-        if (candidates.length) {
-            segments.push(...candidates);
+        const content = message.content;
+        if (typeof content === 'string' && content.trim().length) {
+            segments.push(content);
+        }
+        else if (Array.isArray(content)) {
+            for (const part of content) {
+                if (!isRecord(part)) {
+                    continue;
+                }
+                const text = readString(part.text);
+                if (text) {
+                    segments.push(text);
+                }
+            }
         }
         if (Array.isArray(message.tool_calls) && message.tool_calls.length) {
             try {
@@ -1054,41 +696,10 @@ function normalizeChoice(choice, options, allowedToolNames, callIdPrefix) {
         }
         return { hasNative: true, hasFallback: false, harvestedFunctionResults: false };
     }
-    if (!options.textToolFallback) {
-        return {
-            hasNative: false,
-            hasFallback: false,
-            harvestedFunctionResults: harvestFunctionResultsMarkup(message)
-        };
-    }
-    const transformed = normalizeAssistantTextToToolCalls(message, options.textNormalizer);
-    if (transformed !== message) {
-        choice.message = transformed;
-    }
-    const fallbackMessage = isRecord(choice.message) ? choice.message : message;
-    let fallback = normalizeMessageToolCalls(fallbackMessage, allowedToolNames, callIdPrefix);
-    if (!fallback) {
-        fallback = normalizeMessageTextToolCalls(fallbackMessage, allowedToolNames, callIdPrefix);
-    }
-    if (fallback) {
-        const finish = readString(choice.finish_reason)?.toLowerCase();
-        if (!finish || finish === 'stop') {
-            choice.finish_reason = 'tool_calls';
-        }
-        return { hasNative: false, hasFallback: true, harvestedFunctionResults: false };
-    }
-    const commandFallback = normalizeMessageCommandToolCall(fallbackMessage, allowedToolNames, callIdPrefix);
-    if (commandFallback) {
-        const finish = readString(choice.finish_reason)?.toLowerCase();
-        if (!finish || finish === 'stop') {
-            choice.finish_reason = 'tool_calls';
-        }
-        return { hasNative: false, hasFallback: true, harvestedFunctionResults: false };
-    }
     return {
         hasNative: false,
         hasFallback: false,
-        harvestedFunctionResults: harvestFunctionResultsMarkup(fallbackMessage)
+        harvestedFunctionResults: false
     };
 }
 function writeCompatState(root, state, source, harvestedFunctionResults) {
@@ -1139,7 +750,6 @@ export function applyDeepSeekWebResponseTransform(payload, adapterContext, confi
             requestId: readString(adapterContext?.requestId),
             phase: 'chat_process.resp.stage3.compat',
             state,
-            fallbackEnabled: options.textToolFallback,
             strictToolRequired: options.strictToolRequired
         };
         throw error;

package/dist/conversion/compat/actions/harvest-tool-calls-from-text.js

@@ -1,5 +1,5 @@
 import { normalizeAssistantTextToToolCalls } from '../../shared/text-markup-normalizer.js';
-import { normalizeFunctionCallId } from '../../shared/bridge-id-utils.js';
+import { normalizeFunctionCallId } from '../../bridge-id-utils.js';
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 function pickString(...candidates) {
     for (const c of candidates) {

package/dist/conversion/compat/actions/lmstudio-responses-fc-ids.js

@@ -1,4 +1,4 @@
-import { normalizeFunctionCallId, normalizeFunctionCallOutputId, normalizeResponsesCallId } from '../../shared/bridge-id-utils.js';
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId, normalizeResponsesCallId } from '../../bridge-id-utils.js';
 function isRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }

package/dist/conversion/compat/actions/qwen-transform.js

@@ -11,6 +11,15 @@ const FINISH_REASON_MAP = {
     content_filter: 'content_filter'
 };
 const isRecord = (value) => typeof value === 'object' && value !== null;
+const readReasoningEffort = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (isRecord(value) && typeof value.effort === 'string') {
+        return value.effort;
+    }
+    return undefined;
+};
 export function applyQwenRequestTransform(payload) {
     const cloned = structuredClone(payload);
     const transformed = convertToQwenRequest(cloned);
@@ -132,6 +141,10 @@ function extractParameters(request) {
     if (typeof request.debug === 'boolean') {
         parameters.debug = request.debug;
     }
+    const reasoningEffort = readReasoningEffort(request.reasoning)?.toLowerCase();
+    if (reasoningEffort !== 'low') {
+        parameters.reasoning = true;
+    }
     return parameters;
 }
 function transformQwenResponseToOpenAI(response) {
@@ -154,6 +167,17 @@ function transformQwenResponseToOpenAI(response) {
         _originalFormat: 'qwen',
         _targetFormat: 'openai'
     };
+    const firstMessage = (() => {
+        const choices = Array.isArray(transformed.choices) ? transformed.choices : [];
+        const primary = choices[0] && isRecord(choices[0]) ? choices[0] : undefined;
+        const message = primary && isRecord(primary.message) ? primary.message : undefined;
+        return message;
+    })();
+    if (firstMessage && typeof firstMessage.reasoning_content === 'string' && firstMessage.reasoning_content.trim()) {
+        transformed.__responses_reasoning = {
+            content: [{ type: 'reasoning_text', text: String(firstMessage.reasoning_content).trim() }]
+        };
+    }
     return transformed;
 }
 function transformChoices(rawChoices) {
@@ -163,17 +187,65 @@ function transformChoices(rawChoices) {
     return rawChoices.map((choice, index) => {
         const choiceObj = isRecord(choice) ? choice : {};
         const messageObj = isRecord(choiceObj.message) ? choiceObj.message : {};
+        const contentDetails = extractContentAndReasoning(messageObj.content);
+        const reasoningText = mergeReasoningText(contentDetails?.reasoningText, readString(messageObj.reasoning_content) ?? readString(messageObj.reasoning));
         return {
             index: typeof choiceObj.index === 'number' ? choiceObj.index : index,
             message: {
                 role: typeof messageObj.role === 'string' ? messageObj.role : 'assistant',
-                content: typeof messageObj.content === 'string' ? messageObj.content : '',
-                tool_calls: transformToolCalls(messageObj.tool_calls)
+                content: contentDetails?.contentText ?? (typeof messageObj.content === 'string' ? messageObj.content : ''),
+                tool_calls: transformToolCalls(messageObj.tool_calls),
+                ...(reasoningText ? { reasoning_content: reasoningText } : {})
             },
             finish_reason: transformFinishReason(typeof choiceObj.finish_reason === 'string' ? choiceObj.finish_reason : undefined)
         };
     });
 }
+function readString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function mergeReasoningText(primary, secondary) {
+    const parts = [primary, secondary].filter((item) => typeof item === 'string' && item.trim().length > 0);
+    if (parts.length === 0) {
+        return undefined;
+    }
+    return parts.join('\n');
+}
+function extractContentAndReasoning(content) {
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const contentParts = [];
+    const reasoningParts = [];
+    for (const chunk of content) {
+        if (typeof chunk === 'string') {
+            contentParts.push(chunk);
+            continue;
+        }
+        if (!isRecord(chunk)) {
+            continue;
+        }
+        const text = readString(chunk.text);
+        const type = typeof chunk.type === 'string' ? chunk.type.toLowerCase() : '';
+        const isThinking = Boolean(chunk.thought) || type === 'thinking' || type === 'reasoning';
+        if (text) {
+            if (isThinking) {
+                reasoningParts.push(text);
+            }
+            else {
+                contentParts.push(text);
+            }
+        }
+    }
+    return {
+        contentText: contentParts.join('\n'),
+        reasoningText: reasoningParts.length ? reasoningParts.join('\n') : undefined
+    };
+}
 function transformToolCalls(toolCalls) {
     if (!Array.isArray(toolCalls)) {
         return [];

package/dist/conversion/compat/actions/snapshot.js

@@ -1,4 +1,4 @@
-import { writeSnapshotViaHooks } from '../../shared/snapshot-hooks.js';
+import { writeSnapshotViaHooks } from '../../snapshot-utils.js';
 const SNAPSHOT_FLAG = String(process.env.ROUTECODEX_SNAPSHOT ?? '').toLowerCase();
 const SNAPSHOT_ENABLED = SNAPSHOT_FLAG === '1' || SNAPSHOT_FLAG === 'true';
 export async function writeCompatSnapshot(options) {