@jsonstudio/llms 0.6.34 → 0.6.54

package/dist/conversion/hub/pipeline/compat/compat-profile-store.js

@@ -0,0 +1,76 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+const builtinDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../compat/profiles');
+const USER_COMPAT_DIR = (process.env.ROUTECODEX_COMPAT_DIR && process.env.ROUTECODEX_COMPAT_DIR.trim()) ||
+    path.join(os.homedir(), '.routecodex', 'compat');
+let profileMap = null;
+function normalizeProfiles(profiles) {
+    const map = new Map();
+    for (const profile of profiles) {
+        if (!profile || typeof profile !== 'object') {
+            continue;
+        }
+        const id = typeof profile.id === 'string' ? profile.id.trim() : '';
+        if (!id) {
+            continue;
+        }
+        map.set(id, {
+            ...profile,
+            id
+        });
+    }
+    return map;
+}
+function loadProfilesFromDir(dir) {
+    try {
+        if (!fs.existsSync(dir)) {
+            return [];
+        }
+        const entries = fs.readdirSync(dir);
+        const configs = [];
+        for (const entry of entries) {
+            if (!entry.endsWith('.json')) {
+                continue;
+            }
+            const file = path.join(dir, entry);
+            try {
+                const text = fs.readFileSync(file, 'utf8');
+                const json = JSON.parse(text);
+                if (!json.id) {
+                    json.id = entry.replace(/\.json$/i, '');
+                }
+                configs.push(json);
+            }
+            catch (error) {
+                console.warn(`[compat] Failed to load ${file}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return configs;
+    }
+    catch {
+        return [];
+    }
+}
+function buildProfileMap() {
+    const merged = new Map();
+    const builtinProfiles = normalizeProfiles(loadProfilesFromDir(builtinDir));
+    for (const [key, value] of builtinProfiles.entries()) {
+        merged.set(key, value);
+    }
+    const userProfiles = normalizeProfiles(loadProfilesFromDir(USER_COMPAT_DIR));
+    for (const [key, value] of userProfiles.entries()) {
+        merged.set(key, value);
+    }
+    return merged;
+}
+export function getCompatProfile(profileId) {
+    if (!profileId || !profileId.trim()) {
+        return null;
+    }
+    if (!profileMap) {
+        profileMap = buildProfileMap();
+    }
+    return profileMap.get(profileId.trim()) ?? null;
+}

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

@@ -0,0 +1,62 @@
+import type { JsonObject, JsonValue } from '../../types/json.js';
+export type CompatDirection = 'request' | 'response';
+export interface CompatProfileConfig {
+    id: string;
+    protocol: string;
+    direction?: CompatDirection;
+    mappings?: MappingInstruction[];
+    filters?: FilterInstruction[];
+    request?: CompatStageConfig;
+    response?: CompatStageConfig;
+}
+export interface CompatStageConfig {
+    mappings?: MappingInstruction[];
+    filters?: FilterInstruction[];
+}
+export type MappingInstruction = {
+    action: 'remove';
+    path: string;
+} | {
+    action: 'rename';
+    from: string;
+    to: string;
+} | {
+    action: 'set';
+    path: string;
+    value: JsonValue;
+} | {
+    action: 'stringify';
+    path: string;
+    fallback?: JsonValue;
+} | {
+    action: 'set_default';
+    path: string;
+    value?: JsonValue;
+    valueSource?: 'timestamp_seconds' | 'chat_completion_id';
+} | {
+    action: 'normalize_tool_choice';
+    path?: string;
+    objectReplacement?: string;
+} | {
+    action: 'inject_instruction';
+    sourcePath: string;
+    targetPath?: string;
+    role?: string;
+    contentType?: string;
+    stripHtml?: boolean;
+    maxLengthEnv?: string[];
+} | {
+    action: 'parse_json';
+    path: string;
+    fallback?: JsonValue;
+} | {
+    action: 'convert_responses_output_to_choices';
+};
+export type FilterInstruction = {
+    action: 'rate_limit_text';
+    needle: string;
+};
+export interface CompatApplicationResult {
+    payload: JsonObject;
+    appliedProfile?: string;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -55,6 +55,7 @@ export declare class HubPipeline {
     private buildAdapterContext;
     private maybeCreateStageRecorder;
     private asJsonObject;
+    private pickRawRequestBody;
     private normalizeRequest;
     private convertProcessNodeResult;
     private materializePayload;

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

@@ -18,6 +18,7 @@ import { runReqProcessStage1ToolGovernance } from './stages/req_process/req_proc
 import { runReqProcessStage2RouteSelect } from './stages/req_process/req_process_stage2_route_select/index.js';
 import { runReqOutboundStage1SemanticMap } from './stages/req_outbound/req_outbound_stage1_semantic_map/index.js';
 import { runReqOutboundStage2FormatBuild } from './stages/req_outbound/req_outbound_stage2_format_build/index.js';
+import { runReqOutboundStage3Compat } from './stages/req_outbound/req_outbound_stage3_compat/index.js';
 export class HubPipeline {
     routerEngine;
     config;
@@ -109,6 +110,9 @@ export class HubPipeline {
             stageRecorder: inboundRecorder
         });
         const outboundAdapterContext = this.buildAdapterContext(normalized, routing.target);
+        if (routing.target?.compatibilityProfile) {
+            outboundAdapterContext.compatibilityProfile = routing.target.compatibilityProfile;
+        }
         const outboundProtocol = outboundAdapterContext.providerProtocol;
         const protocolSwitch = outboundProtocol !== normalized.providerProtocol;
         const outboundHooks = protocolSwitch ? this.resolveProtocolHooks(outboundProtocol) : hooks;
@@ -122,35 +126,66 @@ export class HubPipeline {
         const outboundEndpoint = resolveEndpointForProviderProtocol(outboundAdapterContext.providerProtocol);
         const outboundRecorder = this.maybeCreateStageRecorder(outboundAdapterContext, outboundEndpoint);
         const outboundStart = Date.now();
-        const outboundStage1 = await runReqOutboundStage1SemanticMap({
-            request: workingRequest,
-            adapterContext: outboundAdapterContext,
-            semanticMapper: outboundSemanticMapper,
-            contextSnapshot: outboundContextSnapshot,
-            contextMetadataKey: outboundContextMetadataKey,
-            stageRecorder: outboundRecorder
-        });
-        const providerPayload = await runReqOutboundStage2FormatBuild({
-            formatEnvelope: outboundStage1.formatEnvelope,
-            adapterContext: outboundAdapterContext,
-            formatAdapter: outboundFormatAdapter,
-            stageRecorder: outboundRecorder
-        });
-        const outboundEnd = Date.now();
-        nodeResults.push({
-            id: 'req_outbound',
-            success: true,
-            metadata: {
-                node: 'req_outbound',
-                executionTime: outboundEnd - outboundStart,
-                startTime: outboundStart,
-                endTime: outboundEnd,
-                dataProcessed: {
-                    messages: workingRequest.messages.length,
-                    tools: workingRequest.tools?.length ?? 0
+        const isResponsesSubmit = normalized.entryEndpoint === '/v1/responses.submit_tool_outputs' &&
+            outboundProtocol === 'openai-responses';
+        let providerPayload;
+        if (isResponsesSubmit) {
+            providerPayload =
+                this.pickRawRequestBody(normalized.metadata) ?? normalized.payload;
+            const outboundEnd = Date.now();
+            nodeResults.push({
+                id: 'req_outbound',
+                success: true,
+                metadata: {
+                    node: 'req_outbound',
+                    executionTime: outboundEnd - outboundStart,
+                    startTime: outboundStart,
+                    endTime: outboundEnd,
+                    dataProcessed: {
+                        messages: 0,
+                        tools: 0
+                    },
+                    bypass: 'responses-submit-passthrough'
                 }
-            }
-        });
+            });
+        }
+        else {
+            const outboundStage1 = await runReqOutboundStage1SemanticMap({
+                request: workingRequest,
+                adapterContext: outboundAdapterContext,
+                semanticMapper: outboundSemanticMapper,
+                contextSnapshot: outboundContextSnapshot,
+                contextMetadataKey: outboundContextMetadataKey,
+                stageRecorder: outboundRecorder
+            });
+            let formattedPayload = await runReqOutboundStage2FormatBuild({
+                formatEnvelope: outboundStage1.formatEnvelope,
+                adapterContext: outboundAdapterContext,
+                formatAdapter: outboundFormatAdapter,
+                stageRecorder: outboundRecorder
+            });
+            formattedPayload = await runReqOutboundStage3Compat({
+                payload: formattedPayload,
+                adapterContext: outboundAdapterContext,
+                stageRecorder: outboundRecorder
+            });
+            providerPayload = formattedPayload;
+            const outboundEnd = Date.now();
+            nodeResults.push({
+                id: 'req_outbound',
+                success: true,
+                metadata: {
+                    node: 'req_outbound',
+                    executionTime: outboundEnd - outboundStart,
+                    startTime: outboundStart,
+                    endTime: outboundEnd,
+                    dataProcessed: {
+                        messages: workingRequest.messages.length,
+                        tools: workingRequest.tools?.length ?? 0
+                    }
+                }
+            });
+        }
         const metadata = {
             ...normalized.metadata,
             entryEndpoint: normalized.entryEndpoint,
@@ -271,6 +306,9 @@ export class HubPipeline {
         if (typeof metadata.assignedModelId === 'string') {
             adapterContext.modelId = metadata.assignedModelId;
         }
+        if (target?.compatibilityProfile && typeof target.compatibilityProfile === 'string') {
+            adapterContext.compatibilityProfile = target.compatibilityProfile;
+        }
         return adapterContext;
     }
     maybeCreateStageRecorder(context, endpoint) {
@@ -292,6 +330,16 @@ export class HubPipeline {
         }
         return value;
     }
+    pickRawRequestBody(metadata) {
+        if (!metadata || typeof metadata !== 'object') {
+            return undefined;
+        }
+        const raw = metadata.__raw_request_body;
+        if (!raw || typeof raw !== 'object') {
+            return undefined;
+        }
+        return raw;
+    }
     async normalizeRequest(request) {
         if (!request || typeof request !== 'object') {
             throw new Error('HubPipeline requires request payload');

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/index.js

@@ -19,18 +19,6 @@ export async function runReqInboundStage3ContextCapture(options) {
         ? augmentContextSnapshot(context, fallbackSnapshot)
         : fallbackSnapshot;
     recordStage(options.stageRecorder, 'req_inbound_stage3_context_capture', snapshot);
-    if (options.adapterContext.providerProtocol === 'openai-responses') {
-        try {
-            captureResponsesRequestContext({
-                requestId: options.adapterContext.requestId,
-                payload: options.rawRequest,
-                context: snapshot
-            });
-        }
-        catch {
-            /* ignore capture failures */
-        }
-    }
     return context ?? snapshot;
 }
 export function runChatContextCapture(options) {
@@ -66,6 +54,16 @@ export function captureResponsesContextSnapshot(options) {
     catch {
         // best-effort context capture
     }
+    try {
+        captureResponsesRequestContext({
+            requestId: options.adapterContext.requestId,
+            payload: options.rawRequest,
+            context
+        });
+    }
+    catch {
+        // ignore store capture failures
+    }
     return context;
 }
 function captureChatContextSnapshot(options) {

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage3_compat/index.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { JsonObject } from '../../../../types/json.js';
+export type ProviderPayload = JsonObject;
+export declare function runReqOutboundStage3Compat(options: {
+    payload: ProviderPayload;
+    adapterContext: AdapterContext;
+    stageRecorder?: StageRecorder;
+}): Promise<ProviderPayload>;
+export declare function runRespInboundStageCompatResponse(options: {
+    payload: ProviderPayload;
+    adapterContext: AdapterContext;
+    stageRecorder?: StageRecorder;
+}): ProviderPayload;

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

@@ -0,0 +1,23 @@
+import { applyRequestCompat, applyResponseCompat } from '../../../compat/compat-engine.js';
+function pickCompatProfile(adapterContext) {
+    const candidate = adapterContext.compatibilityProfile;
+    return typeof candidate === 'string' && candidate.trim() ? candidate.trim() : undefined;
+}
+export async function runReqOutboundStage3Compat(options) {
+    const profile = pickCompatProfile(options.adapterContext);
+    const result = applyRequestCompat(profile, options.payload);
+    options.stageRecorder?.record('req_outbound_stage3_compat', {
+        applied: Boolean(result.appliedProfile),
+        profile: result.appliedProfile || profile || 'passthrough'
+    });
+    return result.payload;
+}
+export function runRespInboundStageCompatResponse(options) {
+    const profile = pickCompatProfile(options.adapterContext);
+    const result = applyResponseCompat(profile, options.payload);
+    options.stageRecorder?.record('resp_inbound_stage_compat', {
+        applied: Boolean(result.appliedProfile),
+        profile: result.appliedProfile || profile || 'passthrough'
+    });
+    return result.payload;
+}

package/dist/conversion/hub/response/provider-response.js

@@ -6,10 +6,12 @@ import { OpenAIChatResponseMapper, ResponsesResponseMapper, AnthropicResponseMap
 import { runRespInboundStage1SseDecode } from '../pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/index.js';
 import { runRespInboundStage2FormatParse } from '../pipeline/stages/resp_inbound/resp_inbound_stage2_format_parse/index.js';
 import { runRespInboundStage3SemanticMap } from '../pipeline/stages/resp_inbound/resp_inbound_stage3_semantic_map/index.js';
+import { runRespInboundStageCompatResponse } from '../pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js';
 import { runRespProcessStage1ToolGovernance } from '../pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js';
 import { runRespProcessStage2Finalize } from '../pipeline/stages/resp_process/resp_process_stage2_finalize/index.js';
 import { runRespOutboundStage1ClientRemap } from '../pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js';
 import { runRespOutboundStage2SseStream } from '../pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js';
+import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
 function resolveChatReasoningMode(entryEndpoint) {
     const envRaw = (process.env.ROUTECODEX_CHAT_REASONING_MODE || process.env.RCC_CHAT_REASONING_MODE || '').trim().toLowerCase();
     const map = {
@@ -105,6 +107,22 @@ export async function convertProviderResponse(options) {
         formatAdapter,
         stageRecorder: options.stageRecorder
     });
+    if (options.providerProtocol === 'openai-responses') {
+        try {
+            recordResponsesResponse({
+                requestId: options.context.requestId,
+                response: formatEnvelope.payload
+            });
+        }
+        catch {
+            // ignore conversation capture errors
+        }
+    }
+    formatEnvelope.payload = runRespInboundStageCompatResponse({
+        payload: formatEnvelope.payload,
+        adapterContext: options.context,
+        stageRecorder: options.stageRecorder
+    });
     const chatResponse = await runRespInboundStage3SemanticMap({
         adapterContext: options.context,
         formatEnvelope,

package/dist/conversion/hub/response/response-mappers.d.ts

@@ -9,7 +9,7 @@ export declare class OpenAIChatResponseMapper implements ResponseMapper {
     toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
 }
 export declare class ResponsesResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, ctx: AdapterContext): ChatCompletionLike;
+    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
 }
 export declare class AnthropicResponseMapper implements ResponseMapper {
     toChatCompletion(format: FormatEnvelope, ctx: AdapterContext): ChatCompletionLike;

package/dist/conversion/hub/response/response-mappers.js

@@ -1,6 +1,5 @@
 import { buildOpenAIChatFromGeminiResponse } from '../../codecs/gemini-openai-codec.js';
 import { buildChatResponseFromResponses } from '../../shared/responses-response-utils.js';
-import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
 import { buildOpenAIChatFromAnthropicMessage } from './response-runtime.js';
 export class OpenAIChatResponseMapper {
     toChatCompletion(format, _ctx) {
@@ -8,17 +7,8 @@ export class OpenAIChatResponseMapper {
     }
 }
 export class ResponsesResponseMapper {
-    toChatCompletion(format, ctx) {
-        const payload = (format.payload ?? {});
-        if (ctx?.requestId) {
-            try {
-                recordResponsesResponse({ requestId: ctx.requestId, response: payload });
-            }
-            catch {
-                /* ignore capture failures */
-            }
-        }
-        return buildChatResponseFromResponses(payload);
+    toChatCompletion(format, _ctx) {
+        return buildChatResponseFromResponses(format.payload ?? {});
     }
 }
 export class AnthropicResponseMapper {

package/dist/conversion/shared/responses-output-builder.js

@@ -112,50 +112,29 @@ export function buildResponsesOutputFromChat(options) {
     };
 }
 function normalizeUsage(usageRaw) {
-    if (!usageRaw || typeof usageRaw !== 'object') {
-        return undefined;
-    }
-    const source = usageRaw;
-    const usage = {};
-    const inputValue = normalizeNumber(source.input_tokens ?? source.prompt_tokens);
-    if (inputValue !== undefined) {
-        usage.input_tokens = inputValue;
-    }
-    const outputValue = normalizeNumber(source.output_tokens ?? source.completion_tokens);
-    if (outputValue !== undefined) {
-        usage.output_tokens = outputValue;
-    }
-    const totalValue = normalizeNumber(source.total_tokens);
-    if (totalValue !== undefined) {
-        usage.total_tokens = totalValue;
-    }
-    else if (inputValue !== undefined && outputValue !== undefined) {
-        usage.total_tokens = inputValue + outputValue;
-    }
-    const inputDetails = extractTokenDetails(source.input_tokens_details ??
-        source.prompt_tokens_details);
-    if (inputDetails) {
-        usage.input_tokens_details = inputDetails;
-    }
-    const outputDetails = extractTokenDetails(source.output_tokens_details ??
-        source.completion_tokens_details);
-    if (outputDetails) {
-        usage.output_tokens_details = outputDetails;
-    }
-    return Object.keys(usage).length ? usage : undefined;
-}
-function normalizeNumber(value) {
-    if (value == null) {
-        return undefined;
-    }
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : undefined;
-}
-function extractTokenDetails(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return undefined;
+    if (usageRaw && typeof usageRaw === 'object') {
+        const usage = { ...usageRaw };
+        if (usage.input_tokens != null && usage.prompt_tokens == null) {
+            usage.prompt_tokens = usage.input_tokens;
+        }
+        if (usage.output_tokens != null && usage.completion_tokens == null) {
+            usage.completion_tokens = usage.output_tokens;
+        }
+        if (usage.prompt_tokens != null && usage.completion_tokens != null && usage.total_tokens == null) {
+            const total = Number(usage.prompt_tokens) + Number(usage.completion_tokens);
+            if (!Number.isNaN(total))
+                usage.total_tokens = total;
+        }
+        try {
+            delete usage.input_tokens;
+            delete usage.output_tokens;
+        }
+        catch {
+            /* ignore */
+        }
+        return usage;
     }
-    return { ...raw };
+    return usageRaw;
 }
 function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, baseCount, offset) {
     try {

package/dist/conversion/shared/responses-response-utils.js

@@ -167,7 +167,7 @@ export function buildChatResponseFromResponses(payload) {
     const created = typeof response.created_at === 'number'
         ? response.created_at
         : (response.created ?? Math.floor(Date.now() / 1000));
-    const usage = mapResponsesUsageToChat(response.usage);
+    const usage = response.usage;
     const toolCalls = collectToolCallsFromResponses(response);
     const { textParts, reasoningParts } = extractOutputSegments(response);
     const rawReasoningSegments = collectRawReasoningSegments(response);
@@ -237,49 +237,3 @@ export function buildChatResponseFromResponses(payload) {
     }
     return chat;
 }
-function mapResponsesUsageToChat(usageRaw) {
-    if (!usageRaw || typeof usageRaw !== 'object') {
-        return undefined;
-    }
-    const source = usageRaw;
-    const usage = {};
-    const promptValue = toNumber(source.prompt_tokens ?? source.input_tokens);
-    if (promptValue !== undefined) {
-        usage.prompt_tokens = promptValue;
-    }
-    const completionValue = toNumber(source.completion_tokens ?? source.output_tokens);
-    if (completionValue !== undefined) {
-        usage.completion_tokens = completionValue;
-    }
-    const totalValue = toNumber(source.total_tokens);
-    if (totalValue !== undefined) {
-        usage.total_tokens = totalValue;
-    }
-    else if (promptValue !== undefined && completionValue !== undefined) {
-        usage.total_tokens = promptValue + completionValue;
-    }
-    const promptDetails = extractDetailObject(source.prompt_tokens_details ??
-        source.input_tokens_details);
-    if (promptDetails) {
-        usage.prompt_tokens_details = promptDetails;
-    }
-    const completionDetails = extractDetailObject(source.completion_tokens_details ??
-        source.output_tokens_details);
-    if (completionDetails) {
-        usage.completion_tokens_details = completionDetails;
-    }
-    return Object.keys(usage).length ? usage : undefined;
-}
-function toNumber(value) {
-    if (value == null) {
-        return undefined;
-    }
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : undefined;
-}
-function extractDetailObject(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return undefined;
-    }
-    return { ...raw };
-}

package/dist/conversion/shared/text-markup-normalizer.js

@@ -95,10 +95,10 @@ export function extractApplyPatchCallsFromText(text) {
                     continue;
                 let argsStr = '{}';
                 try {
-                    argsStr = JSON.stringify({ input: patch });
+                    argsStr = JSON.stringify({ patch });
                 }
                 catch {
-                    argsStr = '{"input":""}';
+                    argsStr = '{"patch":""}';
                 }
                 out.push({ id: genId(), name: 'apply_patch', args: argsStr });
             }