@jsonstudio/llms 0.6.147 → 0.6.198

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

@@ -1,6 +1,17 @@
 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';
-export function applyRequestCompat(profileId, payload) {
+const INTERNAL_STATE = Symbol('compat.internal_state');
+export function applyRequestCompat(profileId, payload, options) {
     const profile = getCompatProfile(profileId);
     if (!profile) {
         return { payload };
@@ -10,9 +21,10 @@ export function applyRequestCompat(profileId, payload) {
         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);
+            applyMapping(mutated, mapping, state);
         }
     }
     return {
@@ -20,7 +32,7 @@ export function applyRequestCompat(profileId, payload) {
         appliedProfile: profile.id
     };
 }
-export function applyResponseCompat(profileId, payload) {
+export function applyResponseCompat(profileId, payload, options) {
     const profile = getCompatProfile(profileId);
     if (!profile) {
         return { payload };
@@ -30,9 +42,10 @@ export function applyResponseCompat(profileId, payload) {
         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);
+            applyMapping(mutated, mapping, state);
         }
     }
     if (Array.isArray(stage.filters)) {
@@ -40,6 +53,10 @@ export function applyResponseCompat(profileId, payload) {
             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
@@ -66,7 +83,7 @@ function pickStageConfig(profile, stage) {
     }
     return null;
 }
-function applyMapping(root, mapping) {
+function applyMapping(root, mapping, state) {
     switch (mapping.action) {
         case 'remove':
             removePath(root, mapping.path);
@@ -95,6 +112,50 @@ function applyMapping(root, mapping) {
         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;
     }
@@ -109,6 +170,110 @@ function applyFilter(payload, filter) {
         }
     }
 }
+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;
@@ -665,3 +830,262 @@ function normalizeFinishReason(reason) {
     }
     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 '{}';
+    }
+}

package/dist/conversion/hub/pipeline/compat/compat-types.d.ts

@@ -1,4 +1,11 @@
 import type { JsonObject, JsonValue } from '../../types/json.js';
+import type { FilterConfig as ShapeFilterConfig } from '../../../compat/actions/universal-shape-filter.js';
+import type { ResponseBlacklistConfig } from '../../../compat/actions/response-blacklist.js';
+import type { FieldMapping } from '../../../compat/actions/field-mapping.js';
+import type { RequestRulesConfig } from '../../../compat/actions/request-rules.js';
+import type { AutoThinkingConfig } from '../../../compat/actions/auto-thinking.js';
+import type { ResponseNormalizeConfig } from '../../../compat/actions/response-normalize.js';
+import type { ResponseValidateConfig } from '../../../compat/actions/response-validate.js';
 export type CompatDirection = 'request' | 'response';
 export interface CompatProfileConfig {
     id: string;
@@ -51,6 +58,46 @@ export type MappingInstruction = {
     fallback?: JsonValue;
 } | {
     action: 'convert_responses_output_to_choices';
+} | {
+    action: 'extract_glm_tool_markup';
+} | {
+    action: 'dto_unwrap';
+} | {
+    action: 'dto_rewrap';
+} | {
+    action: 'shape_filter';
+    config: ShapeFilterConfig;
+    target?: CompatDirection;
+} | {
+    action: 'field_map';
+    direction?: 'incoming' | 'outgoing';
+    config: FieldMapping[];
+} | {
+    action: 'tool_schema_sanitize';
+    mode?: 'glm_shell';
+} | {
+    action: 'apply_rules';
+    config: RequestRulesConfig;
+} | {
+    action: 'auto_thinking';
+    config: AutoThinkingConfig;
+} | {
+    action: 'snapshot';
+    phase: 'compat-pre' | 'compat-post';
+    channel?: string;
+} | {
+    action: 'resp_blacklist';
+    config: ResponseBlacklistConfig;
+} | {
+    action: 'response_normalize';
+    config?: ResponseNormalizeConfig;
+} | {
+    action: 'response_validate';
+    config?: ResponseValidateConfig;
+} | {
+    action: 'qwen_request_transform';
+} | {
+    action: 'qwen_response_transform';
 };
 export type FilterInstruction = {
     action: 'rate_limit_text';

package/dist/conversion/hub/pipeline/hub-pipeline.d.ts

@@ -64,5 +64,7 @@ export declare class HubPipeline {
     private convertSsePayload;
     private resolveSseProtocol;
     private extractModelHint;
+    private resolveOutboundStreamIntent;
+    private applyOutboundStreamPreference;
 }
 export {};

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

@@ -142,6 +142,8 @@ export class HubPipeline {
         catch {
             // logging must not break routing
         }
+        const outboundStream = this.resolveOutboundStreamIntent(routing.target?.streaming);
+        this.applyOutboundStreamPreference(workingRequest, outboundStream);
         const outboundAdapterContext = this.buildAdapterContext(normalized, routing.target);
         if (routing.target?.compatibilityProfile) {
             outboundAdapterContext.compatibilityProfile = routing.target.compatibilityProfile;
@@ -226,7 +228,8 @@ export class HubPipeline {
             stream: normalized.stream,
             processMode: normalized.processMode,
             routeHint: normalized.routeHint,
-            target: routing.target
+            target: routing.target,
+            ...(typeof outboundStream === 'boolean' ? { providerStream: outboundStream } : {})
         };
         return {
             requestId: normalized.id,
@@ -508,6 +511,37 @@ export class HubPipeline {
         }
         return undefined;
     }
+    resolveOutboundStreamIntent(providerPreference) {
+        if (providerPreference === 'always') {
+            return true;
+        }
+        if (providerPreference === 'never') {
+            return false;
+        }
+        return undefined;
+    }
+    applyOutboundStreamPreference(request, stream) {
+        if (!request || typeof request !== 'object') {
+            return;
+        }
+        const parameters = request.parameters || {};
+        const nextParameters = { ...parameters };
+        if (typeof stream === 'boolean') {
+            nextParameters.stream = stream;
+        }
+        else if ('stream' in nextParameters) {
+            delete nextParameters.stream;
+        }
+        request.parameters = nextParameters;
+        if (request.metadata && typeof request.metadata === 'object') {
+            if (typeof stream === 'boolean') {
+                request.metadata.outboundStream = stream;
+            }
+            else if ('outboundStream' in request.metadata) {
+                delete request.metadata.outboundStream;
+            }
+        }
+    }
 }
 function normalizeToolCallIdStyleCandidate(value) {
     if (typeof value !== 'string') {

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js

@@ -5,7 +5,7 @@ function pickCompatProfile(adapterContext) {
 }
 export async function runReqOutboundStage3Compat(options) {
     const profile = pickCompatProfile(options.adapterContext);
-    const result = applyRequestCompat(profile, options.payload);
+    const result = applyRequestCompat(profile, options.payload, { adapterContext: options.adapterContext });
     options.stageRecorder?.record('req_outbound_stage3_compat', {
         applied: Boolean(result.appliedProfile),
         profile: result.appliedProfile || profile || 'passthrough'
@@ -14,7 +14,7 @@ export async function runReqOutboundStage3Compat(options) {
 }
 export function runRespInboundStageCompatResponse(options) {
     const profile = pickCompatProfile(options.adapterContext);
-    const result = applyResponseCompat(profile, options.payload);
+    const result = applyResponseCompat(profile, options.payload, { adapterContext: options.adapterContext });
     options.stageRecorder?.record('resp_inbound_stage_compat', {
         applied: Boolean(result.appliedProfile),
         profile: result.appliedProfile || profile || 'passthrough'

package/dist/conversion/hub/pipeline/target-utils.js

@@ -12,6 +12,9 @@ export function applyTargetMetadata(metadata, target, routeName, originalModel)
     if (target.responsesConfig?.toolCallIdStyle) {
         metadata.toolCallIdStyle = target.responsesConfig.toolCallIdStyle;
     }
+    if (target.streaming) {
+        metadata.targetStreaming = target.streaming;
+    }
     if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
         const trimmed = originalModel.trim();
         if (typeof metadata.originalModelId !== 'string' || !metadata.originalModelId) {