@jsonstudio/rcc 0.89.168 → 0.89.524

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/compat/compat-pipeline-executor.js

@@ -0,0 +1,869 @@
+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 { applyGlmImageContentTransform } from '../../../compat/actions/glm-image-content.js';
+import { applyGlmVisionPromptTransform } from '../../../compat/actions/glm-vision-prompt.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 };
+    }
+    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 };
+    }
+    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;
+        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 '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);
+    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;
+}