@jsonstudio/rcc 0.89.168 → 0.89.333

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

@@ -1,667 +1,7 @@
-import { getCompatProfile } from './compat-profile-store.js';
-const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
-export function applyRequestCompat(profileId, payload) {
-    const profile = getCompatProfile(profileId);
-    if (!profile) {
-        return { payload };
-    }
-    const stage = pickStageConfig(profile, 'request');
-    if (!stage) {
-        return { payload };
-    }
-    const mutated = structuredClone(payload);
-    if (Array.isArray(stage.mappings)) {
-        for (const mapping of stage.mappings) {
-            applyMapping(mutated, mapping);
-        }
-    }
-    return {
-        payload: mutated,
-        appliedProfile: profile.id
-    };
+import { runRequestCompatPipeline, runResponseCompatPipeline } from './compat-pipeline-executor.js';
+export function applyRequestCompat(profileId, payload, options) {
+    return runRequestCompatPipeline(profileId, payload, options);
 }
-export function applyResponseCompat(profileId, payload) {
-    const profile = getCompatProfile(profileId);
-    if (!profile) {
-        return { payload };
-    }
-    const stage = pickStageConfig(profile, 'response');
-    if (!stage) {
-        return { payload };
-    }
-    const mutated = structuredClone(payload);
-    if (Array.isArray(stage.mappings)) {
-        for (const mapping of stage.mappings) {
-            applyMapping(mutated, mapping);
-        }
-    }
-    if (Array.isArray(stage.filters)) {
-        for (const filter of stage.filters) {
-            applyFilter(mutated, filter);
-        }
-    }
-    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) {
-    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;
-        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 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';
+export function applyResponseCompat(profileId, payload, options) {
+    return runResponseCompatPipeline(profileId, payload, options);
 }

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

@@ -0,0 +1,9 @@
+import type { JsonObject } from '../../types/json.js';
+import type { AdapterContext } from '../../types/chat-envelope.js';
+import type { CompatApplicationResult } from './compat-types.js';
+export declare function runRequestCompatPipeline(profileId: string | undefined, payload: JsonObject, options?: {
+    adapterContext?: AdapterContext;
+}): CompatApplicationResult;
+export declare function runResponseCompatPipeline(profileId: string | undefined, payload: JsonObject, options?: {
+    adapterContext?: AdapterContext;
+}): CompatApplicationResult;