@jsonstudio/llms 0.6.199 → 0.6.203

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

@@ -1,1091 +1,7 @@
-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';
-const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
-const INTERNAL_STATE = Symbol('compat.internal_state');
+import { runRequestCompatPipeline, runResponseCompatPipeline } from './compat-pipeline-executor.js';
 export function applyRequestCompat(profileId, payload, options) {
-    const profile = getCompatProfile(profileId);
-    if (!profile) {
-        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
-    };
+    return runRequestCompatPipeline(profileId, payload, options);
 }
 export function applyResponseCompat(profileId, payload, options) {
-    const profile = getCompatProfile(profileId);
-    if (!profile) {
-        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 applyMapping(root, mapping, state) {
-    switch (mapping.action) {
-        case 'remove':
-            removePath(root, mapping.path);
-            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 'inject_instruction':
-            injectInstruction(root, mapping);
-            break;
-        case 'convert_responses_output_to_choices':
-            convertResponsesOutputToChoices(root);
-            break;
-        case 'extract_glm_tool_markup':
-            extractGlmToolMarkup(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;
-        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);
-    if (isRecord(original.data)) {
-        state.dtoEnvelope = { original, isDto: true };
-        replaceRoot(root, original.data);
-    }
-    else {
-        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 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) {
-        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, '');
-}
-function resolveMaxLength(envVars) {
-    if (!envVars || !envVars.length) {
-        return undefined;
-    }
-    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;
-}
-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
-                }
-            }
-        ];
-    }
-}
-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);
-        }
-    });
-    return choices;
-}
-function convertOutputEntryToChoice(entry, index, root) {
-    const message = buildMessageFromOutputEntry(entry, index);
-    if (!message) {
-        return null;
-    }
-    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';
-    return {
-        index,
-        finish_reason: 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 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;
-    }
-    return undefined;
-}
-function extractGlmToolMarkup(root) {
-    const choicesRaw = root?.choices;
-    const choices = Array.isArray(choicesRaw) ? choicesRaw : [];
-    choices.forEach((choice, index) => {
-        if (!choice || typeof choice !== 'object') {
-            return;
-        }
-        const message = choice.message;
-        if (!message || typeof message !== 'object') {
-            return;
-        }
-        const msgRecord = message;
-        const contentField = msgRecord.content;
-        const reasoningField = msgRecord.reasoning_content;
-        const text = contentField !== undefined
-            ? flattenContent(contentField)
-            : (typeof reasoningField === 'string' ? reasoningField : '');
-        if (!text) {
-            return;
-        }
-        const extraction = extractToolCallsFromText(text, index + 1);
-        if (!extraction) {
-            return;
-        }
-        if (extraction.toolCalls.length) {
-            msgRecord.tool_calls = extraction.toolCalls;
-            if (contentField !== undefined) {
-                msgRecord.content = null;
-            }
-        }
-        if (extraction.reasoningText) {
-            msgRecord.reasoning_content = extraction.reasoningText;
-        }
-        else if ('reasoning_content' in msgRecord) {
-            delete msgRecord.reasoning_content;
-        }
-    });
-}
-function flattenContent(content, depth = 0) {
-    if (depth > 4 || content == null) {
-        return '';
-    }
-    if (typeof content === 'string') {
-        return content;
-    }
-    if (Array.isArray(content)) {
-        return content.map((entry) => flattenContent(entry, depth + 1)).join('');
-    }
-    if (typeof content === 'object') {
-        const record = content;
-        if (typeof record.text === 'string') {
-            return record.text;
-        }
-        if (record.content !== undefined) {
-            return flattenContent(record.content, depth + 1);
-        }
-    }
-    return '';
-}
-const GLM_CUSTOM_TAG = /<tool_call(?:\s+name="([^"]+)")?>([\s\S]*?)<\/tool_call>/gi;
-const GLM_TAGGED_SEQUENCE = /<tool_call(?:\s+name="([^"]+)")?\s*>([\s\S]*?)(?:<\/tool_call>|(?=<tool_call)|$)/gi;
-const GLM_TAGGED_BLOCK = /<arg_key>([\s\S]*?)<\/arg_key>\s*<arg_value>([\s\S]*?)<\/arg_value>/gi;
-const GLM_INLINE_NAME = /^[\s\r\n]*([A-Za-z0-9_.:-]+)/;
-const GENERIC_PATTERNS = [
-    [/```(?:tool|function|tool_call|function_call)?\s*([\s\S]*?)\s*```/gi, (match) => ({ body: match[1] ?? '' })],
-    [/\[(tool_call|function_call)(?:\s+name="([^"]+)")?\]([\s\S]*?)\[\/\1\]/gi, (match) => ({ body: match[3] ?? '', nameHint: match[2] })],
-    [/(tool_call|function_call)\s*[:=]\s*({[\s\S]+?})/gi, (match) => ({ body: match[2] ?? '' })]
-];
-function extractToolCallsFromText(text, choiceIndex) {
-    const matches = [];
-    const applyPattern = (pattern, factory) => {
-        pattern.lastIndex = 0;
-        let exec;
-        while ((exec = pattern.exec(text))) {
-            const payload = factory(exec);
-            if (!payload)
-                continue;
-            const parsed = parseToolCall(payload.body, payload.nameHint);
-            if (!parsed)
-                continue;
-            matches.push({
-                start: exec.index,
-                end: exec.index + exec[0].length,
-                call: parsed
-            });
-        }
-    };
-    applyPattern(GLM_CUSTOM_TAG, (match) => ({ body: match[2] ?? '', nameHint: match[1] }));
-    for (const [pattern, factory] of GENERIC_PATTERNS) {
-        applyPattern(pattern, factory);
-    }
-    applyTaggedArgPatterns(text, matches);
-    if (!matches.length && typeof text === 'string' && text.includes('<arg_key>')) {
-        GLM_INLINE_NAME.lastIndex = 0;
-        const inline = GLM_INLINE_NAME.exec(text);
-        GLM_INLINE_NAME.lastIndex = 0;
-        if (inline && inline[1]) {
-            const name = inline[1].trim();
-            const block = text.slice(inline[0].length);
-            const argsRecord = parseTaggedArgBlock(block);
-            if (name && argsRecord) {
-                matches.push({
-                    start: 0,
-                    end: text.length,
-                    call: {
-                        name,
-                        args: safeStringify(argsRecord)
-                    }
-                });
-            }
-        }
-    }
-    matches.sort((a, b) => a.start - b.start);
-    const toolCalls = matches.map((entry, idx) => ({
-        id: `glm_tool_${choiceIndex}_${idx + 1}`,
-        type: 'function',
-        function: {
-            name: entry.call.name,
-            arguments: entry.call.args
-        }
-    }));
-    matches.sort((a, b) => b.start - a.start);
-    let cleaned = text;
-    for (const entry of matches) {
-        cleaned = cleaned.slice(0, entry.start) + cleaned.slice(entry.end);
-    }
-    const reasoningText = cleaned.trim();
-    return {
-        toolCalls,
-        reasoningText: reasoningText.length ? reasoningText : undefined
-    };
-}
-function parseToolCall(body, nameHint) {
-    if (!body || typeof body !== 'string') {
-        return null;
-    }
-    const trimmed = body.trim();
-    if (!trimmed.length) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(trimmed);
-        if (!parsed || typeof parsed !== 'object') {
-            return null;
-        }
-        const record = parsed;
-        const candidateName = (typeof record.name === 'string' && record.name.trim().length ? record.name.trim() : undefined) ??
-            (typeof record.tool_name === 'string' && record.tool_name.trim().length ? record.tool_name.trim() : undefined) ??
-            (typeof record.tool === 'string' && record.tool.trim().length ? record.tool.trim() : undefined) ??
-            (nameHint && nameHint.trim().length ? nameHint.trim() : undefined);
-        if (!candidateName) {
-            return null;
-        }
-        const argsSource = record.arguments ??
-            record.input ??
-            record.params ??
-            record.parameters ??
-            record.payload ??
-            {};
-        let args = '{}';
-        if (typeof argsSource === 'string' && argsSource.trim().length) {
-            args = argsSource.trim();
-        }
-        else {
-            try {
-                args = JSON.stringify(argsSource ?? {});
-            }
-            catch {
-                args = '{}';
-            }
-        }
-        return { name: candidateName, args };
-    }
-    catch {
-        return null;
-    }
-}
-function applyTaggedArgPatterns(text, matches) {
-    if (!text || typeof text !== 'string') {
-        return;
-    }
-    GLM_TAGGED_SEQUENCE.lastIndex = 0;
-    let exec;
-    while ((exec = GLM_TAGGED_SEQUENCE.exec(text))) {
-        let name = typeof exec[1] === 'string' ? exec[1].trim() : '';
-        let block = exec[2] ?? '';
-        if (!name) {
-            const inline = GLM_INLINE_NAME.exec(block);
-            if (inline && inline[1]) {
-                name = inline[1].trim();
-                block = block.slice(inline[0].length);
-            }
-        }
-        if (!name) {
-            continue;
-        }
-        const argsRecord = parseTaggedArgBlock(block);
-        if (!argsRecord) {
-            continue;
-        }
-        matches.push({
-            start: exec.index,
-            end: exec.index + exec[0].length,
-            call: {
-                name,
-                args: safeStringify(argsRecord)
-            }
-        });
-    }
-}
-function parseTaggedArgBlock(block) {
-    if (!block || typeof block !== 'string') {
-        return null;
-    }
-    const record = {};
-    GLM_TAGGED_BLOCK.lastIndex = 0;
-    let exec;
-    while ((exec = GLM_TAGGED_BLOCK.exec(block))) {
-        const key = typeof exec[1] === 'string' ? exec[1].trim() : '';
-        if (!key) {
-            continue;
-        }
-        const rawValue = typeof exec[2] === 'string' ? exec[2].trim() : '';
-        record[key] = coerceTaggedValue(rawValue);
-    }
-    return Object.keys(record).length ? record : null;
-}
-function coerceTaggedValue(raw) {
-    if (!raw) {
-        return '';
-    }
-    const trimmed = raw.trim();
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return trimmed;
-    }
-}
-function safeStringify(value) {
-    try {
-        return JSON.stringify(value ?? {});
-    }
-    catch {
-        return '{}';
-    }
+    return runResponseCompatPipeline(profileId, payload, options);
 }