@jsonstudio/llms 0.6.2172 → 0.6.2979

package/dist/conversion/hub/pipeline/compat/compat-pipeline-executor.js

@@ -1,1055 +1,46 @@
-import { getCompatProfile } from './compat-profile-store.js';
-import { UniversalShapeFilter } from '../../../compat/actions/universal-shape-filter.js';
-import { ResponseBlacklistSanitizer } from '../../../compat/actions/response-blacklist.js';
-import { applyFieldMappings } from '../../../compat/actions/field-mapping.js';
-import { sanitizeToolSchema } from '../../../compat/actions/tool-schema.js';
-import { applyRequestRules } from '../../../compat/actions/request-rules.js';
-import { applyAutoThinking as runAutoThinking } from '../../../compat/actions/auto-thinking.js';
-import { normalizeResponsePayload } from '../../../compat/actions/response-normalize.js';
-import { validateResponsePayload } from '../../../compat/actions/response-validate.js';
-import { writeCompatSnapshot } from '../../../compat/actions/snapshot.js';
-import { applyQwenRequestTransform, applyQwenResponseTransform } from '../../../compat/actions/qwen-transform.js';
-import { extractGlmToolMarkup } from '../../../compat/actions/glm-tool-extraction.js';
-import { applyGlmWebSearchRequestTransform } from '../../../compat/actions/glm-web-search.js';
-import { applyGeminiWebSearchCompat } from '../../../compat/actions/gemini-web-search.js';
-import { applyIflowWebSearchRequestTransform } from '../../../compat/actions/iflow-web-search.js';
-import { applyIflowToolTextFallback } from '../../../compat/actions/iflow-tool-text-fallback.js';
-import { unwrapIflowResponseBodyEnvelope } from '../../../compat/actions/iflow-response-body-unwrap.js';
-import { applyDeepSeekWebRequestTransform } from '../../../compat/actions/deepseek-web-request.js';
-import { applyDeepSeekWebResponseTransform } from '../../../compat/actions/deepseek-web-response.js';
-import { applyIflowKimiHistoryMediaPlaceholder } from '../../../compat/actions/iflow-kimi-history-media-placeholder.js';
-import { applyIflowKimiCliDefaults } from '../../../compat/actions/iflow-kimi-cli-defaults.js';
-import { fillIflowKimiThinkingReasoningContent } from '../../../compat/actions/iflow-kimi-thinking-reasoning-fill.js';
-import { applyGlmImageContentTransform } from '../../../compat/actions/glm-image-content.js';
-import { applyGlmVisionPromptTransform } from '../../../compat/actions/glm-vision-prompt.js';
-import { applyClaudeThinkingToolSchemaCompat } from '../../../compat/actions/claude-thinking-tools.js';
-import { wrapGeminiCliRequest } from '../../../compat/actions/gemini-cli-request.js';
-import { prepareAntigravityThoughtSignatureForGeminiRequest } from '../../../compat/actions/antigravity-thought-signature-prepare.js';
-import { cacheAntigravityThoughtSignatureFromGeminiResponse } from '../../../compat/actions/antigravity-thought-signature-cache.js';
-import { applyAnthropicClaudeCodeSystemPromptCompat } from '../../../compat/actions/anthropic-claude-code-system-prompt.js';
-import { normalizeToolCallIdsInPlace } from '../../../compat/actions/normalize-tool-call-ids.js';
-import { harvestToolCallsFromTextWithConfig } from '../../../compat/actions/harvest-tool-calls-from-text.js';
-import { stripOrphanFunctionCallsTag } from '../../../compat/actions/strip-orphan-function-calls-tag.js';
-import { stringifyLmstudioResponsesInput } from '../../../compat/actions/lmstudio-responses-input-stringify.js';
-import { enforceLmstudioResponsesFcToolCallIds } from '../../../compat/actions/lmstudio-responses-fc-ids.js';
-import { applyToolTextRequestGuidance } from '../../../compat/actions/tool-text-request-guidance.js';
+import { runReqOutboundStage3CompatWithNative, runRespInboundStage3CompatWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+import { buildNativeReqOutboundCompatAdapterContext } from './native-adapter-context.js';
 const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
-const INTERNAL_STATE = Symbol('compat.internal_state');
-export function runRequestCompatPipeline(profileId, payload, options) {
-    const profile = getCompatProfile(profileId);
-    if (!profile) {
-        return { payload };
-    }
-    if (!isProtocolCompatible(profile, options?.adapterContext)) {
-        return { payload };
-    }
-    const stage = pickStageConfig(profile, 'request');
-    if (!stage) {
-        return { payload };
-    }
-    const mutated = structuredClone(payload);
-    const state = initializeInternalState(mutated, 'request', options?.adapterContext);
-    if (Array.isArray(stage.mappings)) {
-        for (const mapping of stage.mappings) {
-            applyMapping(mutated, mapping, state);
-        }
-    }
-    return {
-        payload: mutated,
-        appliedProfile: profile.id
-    };
-}
-export function runResponseCompatPipeline(profileId, payload, options) {
-    const profile = getCompatProfile(profileId);
-    if (!profile) {
-        return { payload };
-    }
-    if (!isProtocolCompatible(profile, options?.adapterContext)) {
-        return { payload };
-    }
-    const stage = pickStageConfig(profile, 'response');
-    if (!stage) {
-        return { payload };
-    }
-    const mutated = structuredClone(payload);
-    const state = initializeInternalState(mutated, 'response', options?.adapterContext);
-    if (Array.isArray(stage.mappings)) {
-        for (const mapping of stage.mappings) {
-            applyMapping(mutated, mapping, state);
-        }
-    }
-    if (Array.isArray(stage.filters)) {
-        for (const filter of stage.filters) {
-            applyFilter(mutated, filter);
-        }
-    }
-    const requestIdFallback = state.originalRequestId || state.adapterContext?.requestId;
-    if (requestIdFallback && typeof mutated.request_id !== 'string') {
-        mutated.request_id = requestIdFallback;
-    }
-    return {
-        payload: mutated,
-        appliedProfile: profile.id
-    };
-}
-function pickStageConfig(profile, stage) {
-    if (!profile) {
-        return null;
-    }
-    if (stage === 'request' && profile.request) {
-        return profile.request;
-    }
-    if (stage === 'response' && profile.response) {
-        return profile.response;
-    }
-    if (profile.direction && profile.direction !== stage) {
-        return null;
-    }
-    if (profile.mappings || profile.filters) {
-        return {
-            mappings: profile.mappings,
-            filters: profile.filters
-        };
-    }
-    return null;
-}
-function isProtocolCompatible(profile, adapterContext) {
-    const required = typeof profile.protocol === 'string' ? profile.protocol.trim().toLowerCase() : '';
-    if (!required) {
-        return true;
-    }
-    const actual = typeof adapterContext?.providerProtocol === 'string' && adapterContext.providerProtocol.trim()
-        ? adapterContext.providerProtocol.trim().toLowerCase()
-        : '';
-    return Boolean(actual) && actual === required;
-}
-function applyMapping(root, mapping, state) {
-    switch (mapping.action) {
-        case 'remove':
-            removePath(root, mapping.path);
-            break;
-        case 'shallow_pick': {
-            const allow = new Set(Array.isArray(mapping.allowTopLevel) ? mapping.allowTopLevel : []);
-            const next = {};
-            for (const [key, value] of Object.entries(root)) {
-                if (allow.has(key)) {
-                    next[key] = value;
-                }
-            }
-            replaceRoot(root, next);
-            break;
-        }
-        case 'rename':
-            renamePath(root, mapping.from, mapping.to);
-            break;
-        case 'set':
-            setPath(root, mapping.path, mapping.value);
-            break;
-        case 'stringify':
-            stringifyPath(root, mapping.path, mapping.fallback);
-            break;
-        case 'parse_json':
-            parseJsonPath(root, mapping.path, mapping.fallback);
-            break;
-        case 'set_default':
-            setDefaultPath(root, mapping.path, mapping.value, mapping.valueSource);
-            break;
-        case 'normalize_tool_choice':
-            normalizeToolChoice(root, mapping);
-            break;
-        case 'normalize_tool_call_ids':
-            normalizeToolCallIdsInPlace(root);
-            break;
-        case 'lmstudio_responses_fc_ids':
-            if (state.direction === 'request') {
-                replaceRoot(root, enforceLmstudioResponsesFcToolCallIds(root));
-            }
-            break;
-        case 'lmstudio_responses_input_stringify':
-            if (state.direction === 'request') {
-                replaceRoot(root, stringifyLmstudioResponsesInput(root, state.adapterContext));
-            }
-            break;
-        case 'inject_instruction':
-            injectInstruction(root, mapping);
-            break;
-        case 'convert_responses_output_to_choices':
-            convertResponsesOutputToChoices(root);
-            break;
-        case 'extract_glm_tool_markup':
-            extractGlmToolMarkup(root);
-            break;
-        case 'harvest_tool_calls_from_text':
-            if (state.direction === 'response') {
-                replaceRoot(root, harvestToolCallsFromTextWithConfig(root, mapping.config));
-            }
-            break;
-        case 'tool_text_request_guidance':
-            if (state.direction === 'request') {
-                replaceRoot(root, applyToolTextRequestGuidance(root, mapping.config));
-            }
-            break;
-        case 'strip_orphan_function_calls_tag':
-            if (state.direction === 'response') {
-                replaceRoot(root, stripOrphanFunctionCallsTag(root));
-            }
-            break;
-        case 'iflow_kimi_thinking_reasoning_fill':
-            if (state.direction === 'request') {
-                replaceRoot(root, fillIflowKimiThinkingReasoningContent(root));
-            }
-            break;
-        case 'iflow_kimi_history_media_placeholder':
-            if (state.direction === 'request') {
-                replaceRoot(root, applyIflowKimiHistoryMediaPlaceholder(root));
-            }
-            break;
-        case 'iflow_kimi_cli_defaults':
-            if (state.direction === 'request') {
-                replaceRoot(root, applyIflowKimiCliDefaults(root));
-            }
-            break;
-        case 'dto_unwrap':
-            dtoUnwrap(root, state);
-            break;
-        case 'dto_rewrap':
-            dtoRewrap(root, state);
-            break;
-        case 'shape_filter':
-            applyShapeFilterMapping(root, mapping, state);
-            break;
-        case 'field_map':
-            applyFieldMap(root, mapping, state);
-            break;
-        case 'tool_schema_sanitize':
-            applyToolSchemaSanitize(root, mapping);
-            break;
-        case 'apply_rules':
-            applyRules(root, mapping, state);
-            break;
-        case 'auto_thinking':
-            applyAutoThinkingAction(root, mapping, state);
-            break;
-        case 'snapshot':
-            triggerSnapshot(root, mapping, state);
-            break;
-        case 'resp_blacklist':
-            applyResponseBlacklist(root, mapping, state);
-            break;
-        case 'response_normalize':
-            applyResponseNormalize(root, mapping, state);
-            break;
-        case 'response_validate':
-            if (state.direction === 'response') {
-                validateResponsePayload(root, mapping.config);
-            }
-            break;
-        case 'qwen_request_transform':
-            replaceRoot(root, applyQwenRequestTransform(root));
-            break;
-        case 'qwen_response_transform':
-            replaceRoot(root, applyQwenResponseTransform(root));
-            break;
-        case 'glm_web_search_request':
-            if (state.direction === 'request') {
-                replaceRoot(root, applyGlmWebSearchRequestTransform(root));
-            }
-            break;
-        case 'gemini_web_search_request':
-            if (state.direction === 'request') {
-                replaceRoot(root, applyGeminiWebSearchCompat(root, state.adapterContext));
-            }
-            break;
-        case 'iflow_web_search_request':
-            if (state.direction === 'request') {
-                replaceRoot(root, applyIflowWebSearchRequestTransform(root, state.adapterContext));
-            }
-            break;
-        case 'iflow_tool_text_fallback':
-            if (state.direction === 'request') {
-                replaceRoot(root, applyIflowToolTextFallback(root, {
-                    models: mapping.models,
-                    routeId: typeof state.adapterContext?.routeId === 'string' ? state.adapterContext.routeId : undefined
-                }));
-            }
-            break;
-        case 'iflow_response_body_unwrap':
-            if (state.direction === 'response') {
-                replaceRoot(root, unwrapIflowResponseBodyEnvelope(root));
-            }
-            break;
-        case 'deepseek_web_request':
-            if (state.direction === 'request') {
-                replaceRoot(root, applyDeepSeekWebRequestTransform(root, state.adapterContext));
-            }
-            break;
-        case 'deepseek_web_response':
-            if (state.direction === 'response') {
-                replaceRoot(root, applyDeepSeekWebResponseTransform(root, state.adapterContext, mapping.config));
-            }
-            break;
-        case 'claude_thinking_tool_schema':
-            if (state.direction === 'request') {
-                replaceRoot(root, applyClaudeThinkingToolSchemaCompat(root, state.adapterContext));
-            }
-            break;
-        case 'gemini_cli_request_wrap':
-            if (state.direction === 'request') {
-                replaceRoot(root, wrapGeminiCliRequest(root, state.adapterContext));
-            }
-            break;
-        case 'antigravity_thought_signature_prepare':
-            if (state.direction === 'request') {
-                replaceRoot(root, prepareAntigravityThoughtSignatureForGeminiRequest(root, state.adapterContext));
-            }
-            break;
-        case 'antigravity_thought_signature_cache':
-            if (state.direction === 'response') {
-                replaceRoot(root, cacheAntigravityThoughtSignatureFromGeminiResponse(root, state.adapterContext));
-            }
-            break;
-        case 'anthropic_claude_code_system_prompt':
-            if (state.direction === 'request') {
-                replaceRoot(root, applyAnthropicClaudeCodeSystemPromptCompat(root, mapping.config, state.adapterContext));
-            }
-            break;
-        case 'glm_image_content':
-            if (state.direction === 'request') {
-                replaceRoot(root, applyGlmImageContentTransform(root));
-            }
-            break;
-        case 'glm_vision_prompt':
-            if (state.direction === 'request') {
-                replaceRoot(root, applyGlmVisionPromptTransform(root));
-            }
-            break;
-        default:
-            break;
-    }
-}
-function applyFilter(payload, filter) {
-    if (filter.action === 'rate_limit_text') {
-        if (detectRateLimitText(payload, filter.needle)) {
-            const err = new Error('Provider returned rate limit notice');
-            err.code = RATE_LIMIT_ERROR;
-            err.statusCode = 429;
-            throw err;
-        }
-    }
-}
-function initializeInternalState(root, direction, adapterContext) {
-    const state = {
-        direction,
-        adapterContext,
-        originalRequestId: direction === 'response' ? extractRequestId(root) : undefined
-    };
-    Object.defineProperty(root, INTERNAL_STATE, {
-        value: state,
-        enumerable: false,
-        configurable: true
-    });
-    return state;
-}
-function replaceRoot(target, source) {
-    if (target === source) {
-        return;
-    }
-    for (const key of Object.keys(target)) {
-        delete target[key];
-    }
-    for (const [key, value] of Object.entries(source)) {
-        target[key] = value;
-    }
-}
-function dtoUnwrap(root, state) {
-    const original = structuredClone(root);
-    const data = original.data;
-    if (isRecord(data)) {
-        state.dtoEnvelope = { original, isDto: true };
-        replaceRoot(root, data);
-        return;
-    }
-    // Transport compatibility: some upstreams return JSON bodies but mislabel the content-type,
-    // causing HTTP clients to surface `data` as a string. When a compat profile opts into dto_unwrap,
-    // best-effort parse JSON strings so downstream semantic mapping sees canonical objects.
-    if (typeof data === 'string') {
-        const parsed = tryParseJsonRecord(data);
-        if (parsed) {
-            state.dtoEnvelope = { original, isDto: true };
-            replaceRoot(root, parsed);
-            return;
-        }
-    }
-    state.dtoEnvelope = { original, isDto: false };
-}
-function dtoRewrap(root, state) {
-    const envelope = state.dtoEnvelope;
-    if (!envelope) {
-        return;
-    }
-    if (!envelope.isDto) {
-        state.dtoEnvelope = undefined;
-        return;
-    }
-    const rebuilt = structuredClone(envelope.original);
-    rebuilt.data = structuredClone(root);
-    replaceRoot(root, rebuilt);
-    state.dtoEnvelope = undefined;
-}
-function tryParseJsonRecord(raw) {
-    try {
-        let text = typeof raw === 'string' ? raw.trim() : '';
-        if (!text)
-            return null;
-        // anti-XSSI prefix: ")]}',\n{...}"
-        text = text.replace(/^\)\]\}',?\s*/u, '');
-        // single-line SSE-like wrapper sometimes returned as plain text
-        text = text.replace(/^data:\s*/iu, '');
-        // Quick structural guards to avoid parsing random prose.
-        const first = text.charAt(0);
-        const last = text.charAt(text.length - 1);
-        if (first !== '{' || last !== '}') {
-            return null;
-        }
-        // Guard: avoid unbounded parsing for pathological payloads.
-        if (text.length > 10 * 1024 * 1024) {
-            return null;
-        }
-        const parsed = JSON.parse(text);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return null;
-        }
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-function applyShapeFilterMapping(root, mapping, state) {
-    const target = mapping.target ?? state.direction;
-    const filter = new UniversalShapeFilter(mapping.config);
-    const filtered = target === 'request'
-        ? filter.applyRequestFilter(root)
-        : filter.applyResponseFilter(root, state.adapterContext);
-    if (filtered === root) {
-        return;
-    }
-    replaceRoot(root, filtered);
-}
-function applyFieldMap(root, mapping, state) {
-    const direction = mapping.direction ?? state.direction;
-    const result = applyFieldMappings(root, mapping.config);
-    replaceRoot(root, result);
-}
-function applyToolSchemaSanitize(root, mapping) {
-    const sanitized = sanitizeToolSchema(root, mapping.mode ?? 'glm_shell');
-    replaceRoot(root, sanitized);
-}
-function applyRules(root, mapping, state) {
-    if (state.direction !== 'request') {
-        return;
-    }
-    const result = applyRequestRules(root, mapping.config);
-    replaceRoot(root, result);
-}
-function applyAutoThinkingAction(root, mapping, state) {
-    if (state.direction !== 'request') {
-        return;
-    }
-    runAutoThinking(root, mapping.config);
-}
-function triggerSnapshot(root, mapping, state) {
-    void writeCompatSnapshot({
-        phase: mapping.phase,
-        requestId: state.adapterContext?.requestId,
-        entryEndpoint: state.adapterContext?.entryEndpoint,
-        data: structuredClone(root)
-    });
-}
-function applyResponseBlacklist(root, mapping, state) {
-    if (state.direction !== 'response') {
-        return;
-    }
-    const sanitizer = new ResponseBlacklistSanitizer(mapping.config);
-    const result = sanitizer.apply(root);
-    replaceRoot(root, result);
-}
-function applyResponseNormalize(root, mapping, state) {
-    if (state.direction !== 'response') {
-        return;
-    }
-    const result = normalizeResponsePayload(root, mapping.config);
-    replaceRoot(root, result);
-}
-function detectRateLimitText(payload, needle) {
-    if (!needle || !payload) {
-        return false;
-    }
-    const normalizedNeedle = needle.toLowerCase();
-    const stack = [payload];
-    while (stack.length) {
-        const current = stack.pop();
-        if (typeof current === 'string') {
-            if (current.toLowerCase().includes(normalizedNeedle)) {
-                return true;
-            }
-            continue;
-        }
-        if (Array.isArray(current)) {
-            for (const entry of current) {
-                stack.push(entry);
-            }
-            continue;
-        }
-        if (isRecord(current)) {
-            for (const value of Object.values(current)) {
-                stack.push(value);
-            }
-        }
-    }
-    return false;
-}
-function parsePath(path) {
-    if (!path || typeof path !== 'string') {
-        return [];
-    }
-    return path
-        .split('.')
-        .map((segment) => segment.trim())
-        .filter(Boolean)
-        .map((segment) => {
-        if (segment.endsWith('[*]')) {
-            return {
-                key: segment.slice(0, -3),
-                wildcard: true
-            };
-        }
-        return {
-            key: segment,
-            wildcard: false
-        };
-    });
-}
-function removePath(root, path) {
-    const steps = parsePath(path);
-    if (!steps.length) {
-        return;
-    }
-    const parentSteps = steps.slice(0, -1);
-    const finalStep = steps[steps.length - 1];
-    const targets = resolveTargets(root, parentSteps);
-    for (const target of targets) {
-        if (isRecord(target) && finalStep && finalStep.key in target) {
-            delete target[finalStep.key];
-        }
-    }
-}
-function renamePath(root, fromPath, toPath) {
-    const value = getPathValue(root, fromPath);
-    if (value === undefined) {
-        return;
-    }
-    setPath(root, toPath, value);
-    removePath(root, fromPath);
-}
-function setPath(root, path, value) {
-    const steps = parsePath(path);
-    if (!steps.length) {
-        return;
-    }
-    let cursor = root;
-    for (let i = 0; i < steps.length; i++) {
-        const step = steps[i];
-        if (step.wildcard) {
-            throw new Error(`Cannot set wildcard path: ${path}`);
-        }
-        if (i === steps.length - 1) {
-            if (isRecord(cursor)) {
-                cursor[step.key] = structuredClone(value);
-            }
-        }
-        else {
-            if (!isRecord(cursor[step.key])) {
-                cursor[step.key] = {};
-            }
-            cursor = cursor[step.key];
-        }
-    }
-}
-function getPathValue(root, path) {
-    const steps = parsePath(path);
-    if (!steps.length) {
+function normalizeProfileId(profileId) {
+    if (typeof profileId !== 'string') {
         return undefined;
     }
-    let cursor = root;
-    for (const step of steps) {
-        if (step.wildcard) {
-            if (!isRecord(cursor)) {
-                return undefined;
-            }
-            const arr = cursor[step.key];
-            if (!Array.isArray(arr) || !arr.length) {
-                return undefined;
-            }
-            cursor = arr[0];
-            continue;
-        }
-        if (!isRecord(cursor)) {
-            return undefined;
-        }
-        cursor = cursor[step.key];
-        if (cursor === undefined) {
-            return undefined;
-        }
-    }
-    return cursor;
-}
-function stringifyPath(root, path, fallback) {
-    const steps = parsePath(path);
-    if (!steps.length) {
-        return;
-    }
-    const parentSteps = steps.slice(0, -1);
-    const finalStep = steps[steps.length - 1];
-    const targets = resolveTargets(root, parentSteps);
-    for (const target of targets) {
-        if (!isRecord(target) || !finalStep) {
-            continue;
-        }
-        const current = target[finalStep.key];
-        if (typeof current === 'string') {
-            continue;
-        }
-        try {
-            if (current === undefined) {
-                target[finalStep.key] = JSON.stringify(fallback ?? {});
-            }
-            else {
-                target[finalStep.key] = JSON.stringify(current);
-            }
-        }
-        catch {
-            try {
-                target[finalStep.key] = JSON.stringify(fallback ?? {});
-            }
-            catch {
-                target[finalStep.key] = '{}';
-            }
-        }
-    }
-}
-function parseJsonPath(root, path, fallback) {
-    const steps = parsePath(path);
-    if (!steps.length) {
-        return;
-    }
-    const parentSteps = steps.slice(0, -1);
-    const finalStep = steps[steps.length - 1];
-    const targets = resolveTargets(root, parentSteps);
-    for (const target of targets) {
-        if (!isRecord(target) || !finalStep) {
-            continue;
-        }
-        const current = target[finalStep.key];
-        if (current === undefined || current === null) {
-            if (fallback !== undefined) {
-                target[finalStep.key] = structuredClone(fallback);
-            }
-            continue;
-        }
-        if (typeof current !== 'string') {
-            continue;
-        }
-        const trimmed = current.trim();
-        if (!trimmed) {
-            if (fallback !== undefined) {
-                target[finalStep.key] = structuredClone(fallback);
-            }
-            continue;
-        }
-        try {
-            target[finalStep.key] = JSON.parse(trimmed);
-        }
-        catch {
-            if (fallback !== undefined) {
-                target[finalStep.key] = structuredClone(fallback);
-            }
-        }
-    }
-}
-function setDefaultPath(root, path, value, source) {
-    const current = getPathValue(root, path);
-    if (current !== undefined) {
-        return;
-    }
-    let finalValue = value;
-    if (source === 'timestamp_seconds') {
-        finalValue = Math.floor(Date.now() / 1000);
-    }
-    else if (source === 'chat_completion_id') {
-        finalValue = `chatcmpl_${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
-    }
-    if (finalValue === undefined) {
-        return;
-    }
-    setPath(root, path, finalValue);
-}
-function normalizeToolChoice(root, mapping) {
-    const path = mapping.path || 'tool_choice';
-    const current = getPathValue(root, path);
-    if (!current || typeof current !== 'object' || Array.isArray(current)) {
-        return;
-    }
-    const replacement = mapping.objectReplacement ?? 'required';
-    setPath(root, path, replacement);
-}
-function injectInstruction(root, mapping) {
-    const raw = getPathValue(root, mapping.sourcePath);
-    removePath(root, mapping.sourcePath);
-    const value = typeof raw === 'string' ? raw.trim() : '';
-    if (!value) {
-        return;
-    }
-    let text = value;
-    if (mapping.stripHtml) {
-        text = stripHtml(text);
-    }
-    const maxLength = resolveMaxLength(mapping.maxLengthEnv);
-    if (maxLength && text.length > maxLength) {
-        text = text.slice(0, maxLength);
-    }
-    if (!text) {
-        return;
-    }
-    const targetPath = mapping.targetPath || 'input';
-    const targetArray = ensureArray(root, targetPath);
-    const message = {
-        type: 'message',
-        role: mapping.role || 'system',
-        content: [
-            {
-                type: mapping.contentType || 'input_text',
-                text
-            }
-        ]
-    };
-    targetArray.unshift(message);
-}
-function resolveTargets(root, steps) {
-    if (!steps.length) {
-        return [root];
-    }
-    const results = [];
-    const traverse = (node, index) => {
-        const step = steps[index];
-        if (!step || !isRecord(node)) {
-            return;
-        }
-        const next = node[step.key];
-        if (step.wildcard && Array.isArray(next)) {
-            if (index === steps.length - 1) {
-                for (const child of next) {
-                    if (isRecord(child)) {
-                        results.push(child);
-                    }
-                }
-            }
-            else {
-                for (const child of next) {
-                    traverse(child, index + 1);
-                }
-            }
-            return;
-        }
-        if (!step.wildcard && isRecord(next)) {
-            if (index === steps.length - 1) {
-                results.push(next);
-            }
-            else {
-                traverse(next, index + 1);
-            }
-        }
-    };
-    traverse(root, 0);
-    return results;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-function ensureArray(root, path) {
-    const steps = parsePath(path);
-    if (!steps.length) {
-        throw new Error(`Invalid array path: ${path}`);
-    }
-    let cursor = root;
-    for (let i = 0; i < steps.length; i++) {
-        const step = steps[i];
-        if (step.wildcard) {
-            throw new Error(`Array path does not support wildcards: ${path}`);
-        }
-        if (i === steps.length - 1) {
-            if (!Array.isArray(cursor[step.key])) {
-                cursor[step.key] = [];
-            }
-            if (!Array.isArray(cursor[step.key])) {
-                cursor[step.key] = [];
-            }
-            return cursor[step.key];
-        }
-        if (!isRecord(cursor[step.key])) {
-            cursor[step.key] = {};
-        }
-        cursor = cursor[step.key];
-    }
-    throw new Error(`Failed to resolve array path: ${path}`);
-}
-function stripHtml(value) {
-    return value.replace(/<\/?[^>]+(>|$)/g, '');
+    const trimmed = profileId.trim();
+    return trimmed.length ? trimmed : undefined;
 }
-function resolveMaxLength(envVars) {
-    if (!envVars || !envVars.length) {
-        return undefined;
+function toCompatResult(payload, appliedProfile) {
+    if (typeof appliedProfile === 'string' && appliedProfile.trim().length) {
+        return { payload, appliedProfile: appliedProfile.trim() };
     }
-    for (const envName of envVars) {
-        if (!envName)
-            continue;
-        const raw = process.env[envName];
-        if (!raw) {
-            continue;
-        }
-        const parsed = Number(raw);
-        if (Number.isFinite(parsed) && parsed > 0) {
-            return Math.floor(parsed);
-        }
-    }
-    return undefined;
+    return { payload };
 }
-function convertResponsesOutputToChoices(root) {
-    if (!isRecord(root)) {
-        return;
-    }
-    const existingChoices = root.choices;
-    if (Array.isArray(existingChoices) && existingChoices.length > 0) {
-        return;
-    }
-    const choicesFromOutput = buildChoicesFromResponsesOutput(root);
-    if (choicesFromOutput.length > 0) {
-        root.choices = choicesFromOutput;
-        return;
-    }
-    const fallbackText = extractOutputText(root);
-    if (typeof fallbackText === 'string') {
-        root.choices = [
-            {
-                index: 0,
-                finish_reason: normalizeFinishReason(typeof root.status === 'string' ? root.status : 'stop'),
-                message: {
-                    role: 'assistant',
-                    content: fallbackText
-                }
-            }
-        ];
+export function runRequestCompatPipeline(profileId, payload, options) {
+    const explicitProfile = normalizeProfileId(profileId);
+    if (!explicitProfile) {
+        return { payload };
     }
-}
-function buildChoicesFromResponsesOutput(root) {
-    const outputEntries = Array.isArray(root.output) ? root.output : [];
-    const choices = [];
-    outputEntries.forEach((entry) => {
-        if (!isRecord(entry)) {
-            return;
-        }
-        if ('type' in entry && typeof entry.type === 'string' && entry.type !== 'message') {
-            return;
-        }
-        const choice = convertOutputEntryToChoice(entry, choices.length, root);
-        if (choice) {
-            choices.push(choice);
-        }
+    const nativeCompat = runReqOutboundStage3CompatWithNative({
+        payload,
+        explicitProfile,
+        adapterContext: buildNativeReqOutboundCompatAdapterContext(options?.adapterContext)
     });
-    return choices;
+    return toCompatResult(nativeCompat.payload, nativeCompat.appliedProfile);
 }
-function convertOutputEntryToChoice(entry, index, root) {
-    const message = buildMessageFromOutputEntry(entry, index);
-    if (!message) {
-        return null;
+export function runResponseCompatPipeline(profileId, payload, options) {
+    const explicitProfile = normalizeProfileId(profileId);
+    if (!explicitProfile) {
+        return { payload };
     }
-    const finishReasonCandidate = (typeof entry.stop_reason === 'string' && entry.stop_reason) ||
-        (typeof entry.finish_reason === 'string' && entry.finish_reason) ||
-        (typeof entry.status === 'string' && entry.status) ||
-        (typeof root.status === 'string' && root.status) ||
-        'stop';
-    const hasToolCalls = message &&
-        typeof message === 'object' &&
-        Array.isArray(message.tool_calls) &&
-        message.tool_calls.length > 0;
-    return {
-        index,
-        finish_reason: hasToolCalls ? 'tool_calls' : normalizeFinishReason(finishReasonCandidate),
-        message
-    };
-}
-function buildMessageFromOutputEntry(entry, choiceIndex) {
-    const role = normalizeRole(typeof entry.role === 'string' ? entry.role : 'assistant');
-    const contentArray = Array.isArray(entry.content) ? entry.content : [];
-    const textSegments = [];
-    const toolCalls = [];
-    contentArray.forEach((part, partIndex) => {
-        if (!isRecord(part)) {
-            const fallback = coerceText(part);
-            if (fallback) {
-                textSegments.push(fallback);
-            }
-            return;
-        }
-        const type = typeof part.type === 'string'
-            ? part.type
-            : typeof part.content_type === 'string'
-                ? part.content_type
-                : '';
-        switch (type) {
-            case 'output_text': {
-                const txt = typeof part.text === 'string'
-                    ? part.text
-                    : coerceText(part.text);
-                if (txt) {
-                    textSegments.push(txt);
-                }
-                break;
-            }
-            case 'tool_call': {
-                const normalized = normalizeToolCall(part, choiceIndex, toolCalls.length);
-                if (normalized) {
-                    toolCalls.push(normalized);
-                }
-                break;
-            }
-            case 'input_text':
-            case 'reasoning_content': {
-                const txt = typeof part.text === 'string'
-                    ? part.text
-                    : coerceText(part.text);
-                if (txt) {
-                    textSegments.push(txt);
-                }
-                break;
-            }
-            default: {
-                const fallback = coerceText(part);
-                if (fallback) {
-                    textSegments.push(fallback);
-                }
-                break;
-            }
-        }
+    const nativeCompat = runRespInboundStage3CompatWithNative({
+        payload,
+        explicitProfile,
+        adapterContext: buildNativeReqOutboundCompatAdapterContext(options?.adapterContext)
     });
-    const message = {
-        role,
-        content: textSegments.join('')
-    };
-    if (toolCalls.length) {
-        message.tool_calls = toolCalls;
-        if (typeof message.content !== 'string') {
-            message.content = '';
-        }
-    }
-    return message;
-}
-function normalizeToolCall(part, choiceIndex, callIndex) {
-    const payload = isRecord(part.tool_call) ? part.tool_call : part;
-    const fnPayload = isRecord(payload.function)
-        ? payload.function
-        : isRecord(part.function)
-            ? part.function
-            : null;
-    const name = typeof fnPayload?.name === 'string' ? fnPayload.name : undefined;
-    if (!name) {
-        return null;
-    }
-    const rawArgs = fnPayload?.arguments;
-    let argString;
-    if (typeof rawArgs === 'string') {
-        argString = rawArgs;
-    }
-    else {
-        try {
-            argString = JSON.stringify(rawArgs ?? {});
-        }
-        catch {
-            argString = '{}';
-        }
-    }
-    const idCandidate = (typeof payload.id === 'string' && payload.id) ||
-        (typeof payload.tool_call_id === 'string'
-            ? payload.tool_call_id
-            : undefined) ||
-        (typeof payload.call_id === 'string'
-            ? payload.call_id
-            : undefined);
-    return {
-        id: idCandidate || `call_${choiceIndex}_${callIndex}`,
-        type: 'function',
-        function: {
-            name,
-            arguments: argString
-        }
-    };
-}
-function extractOutputText(root) {
-    const textCandidate = root.output_text;
-    if (typeof textCandidate === 'string' && textCandidate.length > 0) {
-        return textCandidate;
-    }
-    return undefined;
-}
-function normalizeRole(role) {
-    const normalized = role.toLowerCase();
-    if (normalized === 'assistant' || normalized === 'system' || normalized === 'user' || normalized === 'tool') {
-        return normalized;
-    }
-    return 'assistant';
-}
-function coerceText(value) {
-    if (typeof value === 'string') {
-        return value;
-    }
-    if (typeof value === 'number' || typeof value === 'boolean') {
-        return String(value);
-    }
-    if (Array.isArray(value)) {
-        return value.map((entry) => coerceText(entry)).join('');
-    }
-    if (isRecord(value)) {
-        try {
-            return JSON.stringify(value);
-        }
-        catch {
-            return '';
-        }
-    }
-    return '';
-}
-function normalizeFinishReason(reason) {
-    const normalized = reason.toLowerCase();
-    if (normalized.includes('tool')) {
-        return 'tool_calls';
-    }
-    if (normalized.includes('length') || normalized.includes('max_token') || normalized.includes('in_progress')) {
-        return 'length';
-    }
-    if (normalized.includes('filter')) {
-        return 'content_filter';
-    }
-    return 'stop';
-}
-function extractRequestId(node) {
-    if (typeof node.request_id === 'string') {
-        return node.request_id;
-    }
-    const dataNode = isRecord(node.data)
-        ? node.data
-        : undefined;
-    if (dataNode && typeof dataNode.request_id === 'string') {
-        return dataNode.request_id;
+    if (nativeCompat.nativeApplied === true && nativeCompat.rateLimitDetected === true) {
+        const err = new Error('Provider returned rate limit notice');
+        err.code = RATE_LIMIT_ERROR;
+        err.statusCode = 429;
+        throw err;
     }
-    return undefined;
+    return toCompatResult(nativeCompat.payload, nativeCompat.appliedProfile);
 }