@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/conversion/hub/operation-table/semantic-mappers/responses-mapper.d.ts

@@ -0,0 +1,21 @@
+import type { SemanticMapper } from '../../format-adapters/index.js';
+import type { AdapterContext, ChatEnvelope } from '../../types/chat-envelope.js';
+import type { FormatEnvelope } from '../../types/format-envelope.js';
+import { type JsonObject, type JsonValue } from '../../types/json.js';
+interface ResponsesToolOutputEntry extends JsonObject {
+    tool_call_id?: string;
+    call_id?: string;
+    id?: string;
+    output?: JsonValue;
+    name?: string;
+}
+interface ResponsesPayload extends JsonObject {
+    input?: JsonValue[];
+    tools?: JsonValue[];
+    tool_outputs?: ResponsesToolOutputEntry[];
+}
+export declare class ResponsesSemanticMapper implements SemanticMapper {
+    toChat(format: FormatEnvelope<ResponsesPayload>, ctx: AdapterContext): Promise<ChatEnvelope>;
+    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
+}
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/operation-table/semantic-mappers/responses-mapper.js

@@ -0,0 +1,491 @@
+import { isJsonObject, jsonClone } from '../../types/json.js';
+import { captureResponsesContext, buildChatRequestFromResponses, buildResponsesRequestFromChat } from '../../../responses/responses-openai-bridge.js';
+import { logHubStageTiming } from '../../pipeline/hub-stage-timing.js';
+import { maybeAugmentApplyPatchErrorContent } from './chat-mapper.js';
+import { mapReqInboundBridgeToolsToChatWithNative, mapReqInboundResumeToolOutputsDetailedWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+const RESPONSES_PARAMETER_KEYS = [
+    'model',
+    'temperature',
+    'top_p',
+    'top_k',
+    'prompt_cache_key',
+    'reasoning',
+    'max_tokens',
+    'max_output_tokens',
+    'response_format',
+    'tool_choice',
+    'parallel_tool_calls',
+    'service_tier',
+    'truncation',
+    'include',
+    'store',
+    'user',
+    'logit_bias',
+    'seed',
+    'stop',
+    'stop_sequences',
+    'modalities'
+];
+const RESPONSES_SUBMIT_ENDPOINT = '/v1/responses.submit_tool_outputs';
+function mapToolOutputs(entries, missing) {
+    if (!entries || !entries.length)
+        return undefined;
+    const outputs = [];
+    entries.forEach((entry, index) => {
+        if (!isJsonObject(entry)) {
+            missing.push({ path: `tool_outputs[${index}]`, reason: 'invalid_entry', originalValue: jsonClone(entry) });
+            return;
+        }
+        const callId = entry.tool_call_id || entry.call_id || entry.id;
+        if (!callId) {
+            missing.push({ path: `tool_outputs[${index}].tool_call_id`, reason: 'missing_tool_call_id' });
+            return;
+        }
+        let content = '';
+        if (typeof entry.output === 'string') {
+            content = entry.output;
+        }
+        else if (entry.output != null) {
+            try {
+                content = JSON.stringify(entry.output);
+            }
+            catch {
+                content = String(entry.output);
+            }
+        }
+        const nameValue = typeof entry.name === 'string' ? entry.name : undefined;
+        const augmented = maybeAugmentApplyPatchErrorContent(content, nameValue);
+        outputs.push({
+            tool_call_id: String(callId),
+            content: augmented,
+            name: nameValue
+        });
+    });
+    return outputs.length ? outputs : undefined;
+}
+function deriveResumeToolOutputsFromResume(resume) {
+    if (!resume || typeof resume !== 'object') {
+        return undefined;
+    }
+    const mapped = mapReqInboundResumeToolOutputsDetailedWithNative(resume);
+    if (!Array.isArray(mapped) || mapped.length === 0) {
+        return undefined;
+    }
+    const outputs = mapped.map((entry) => ({
+        tool_call_id: entry.tool_call_id,
+        content: entry.content
+    }));
+    return outputs.length ? outputs : undefined;
+}
+function collectParameters(payload, streamHint) {
+    const params = {};
+    for (const key of RESPONSES_PARAMETER_KEYS) {
+        if (payload[key] !== undefined) {
+            params[key] = payload[key];
+        }
+    }
+    if (streamHint !== undefined) {
+        params.stream = streamHint;
+    }
+    return Object.keys(params).length ? params : undefined;
+}
+function normalizeTools(rawTools, missing) {
+    if (!rawTools || rawTools.length === 0) {
+        return undefined;
+    }
+    const tools = mapReqInboundBridgeToolsToChatWithNative(rawTools);
+    if (tools.length === 0) {
+        rawTools.forEach((tool, index) => {
+            missing.push({ path: `tools[${index}]`, reason: 'invalid_entry', originalValue: jsonClone(tool) });
+        });
+    }
+    return tools.length ? tools : undefined;
+}
+function normalizeMessages(value, missing) {
+    if (!Array.isArray(value)) {
+        if (value !== undefined) {
+            missing.push({ path: 'messages', reason: 'invalid_type', originalValue: jsonClone(value) });
+        }
+        else {
+            missing.push({ path: 'messages', reason: 'absent' });
+        }
+        return [];
+    }
+    const messages = [];
+    value.forEach((item, index) => {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            missing.push({ path: `messages[${index}]`, reason: 'invalid_entry', originalValue: jsonClone(item) });
+            return;
+        }
+        messages.push(item);
+    });
+    return messages;
+}
+function serializeSystemContent(message) {
+    if (!message)
+        return undefined;
+    const content = message.content;
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        content.forEach(part => {
+            if (typeof part === 'string') {
+                parts.push(part);
+            }
+            else if (part && typeof part === 'object') {
+                const text = part.text;
+                if (typeof text === 'string') {
+                    parts.push(text);
+                }
+            }
+        });
+        return parts.join('');
+    }
+    if (content != null) {
+        try {
+            return JSON.stringify(content);
+        }
+        catch {
+            return String(content);
+        }
+    }
+    return undefined;
+}
+function mergeMetadata(a, b) {
+    if (!a && !b) {
+        return undefined;
+    }
+    if (!a && b) {
+        return jsonClone(b);
+    }
+    if (a && !b) {
+        return jsonClone(a);
+    }
+    const left = jsonClone(a);
+    const right = jsonClone(b);
+    return { ...left, ...right };
+}
+function isSubmitToolOutputsEndpoint(ctx) {
+    if (!ctx || typeof ctx !== 'object') {
+        return false;
+    }
+    const entry = typeof ctx.entryEndpoint === 'string' ? ctx.entryEndpoint.trim().toLowerCase() : '';
+    return entry === RESPONSES_SUBMIT_ENDPOINT;
+}
+function attachResponsesSemantics(existing, context, resume) {
+    if (!context && !resume) {
+        return existing;
+    }
+    const next = existing ? { ...existing } : {};
+    const currentNode = next.responses && isJsonObject(next.responses) ? { ...next.responses } : {};
+    if (context) {
+        currentNode.context = jsonClone(context);
+    }
+    if (resume) {
+        currentNode.resume = jsonClone(resume);
+    }
+    next.responses = currentNode;
+    return next;
+}
+function extractResponsesSemanticsNode(chat) {
+    if (!chat?.semantics || typeof chat.semantics !== 'object') {
+        return undefined;
+    }
+    const node = chat.semantics.responses;
+    return node && isJsonObject(node) ? node : undefined;
+}
+function readResponsesContextFromSemantics(chat) {
+    const node = extractResponsesSemanticsNode(chat);
+    if (!node) {
+        return undefined;
+    }
+    const contextNode = node.context;
+    if (!contextNode || !isJsonObject(contextNode)) {
+        return undefined;
+    }
+    return jsonClone(contextNode);
+}
+function readResponsesResumeFromSemantics(chat) {
+    const node = extractResponsesSemanticsNode(chat);
+    if (!node) {
+        return undefined;
+    }
+    const resumeNode = node.resume;
+    if (!resumeNode || !isJsonObject(resumeNode)) {
+        return undefined;
+    }
+    return jsonClone(resumeNode);
+}
+function selectResponsesContextSnapshot(chat, envelopeMetadata) {
+    const semanticsContext = readResponsesContextFromSemantics(chat);
+    const context = semanticsContext ??
+        {
+            metadata: envelopeMetadata
+        };
+    const mergedMetadata = mergeMetadata(context.metadata ?? undefined, envelopeMetadata);
+    if (mergedMetadata) {
+        context.metadata = mergedMetadata;
+    }
+    return context;
+}
+function resolveSubmitResponseId(resumeMeta, responsesContext) {
+    const resumeId = typeof resumeMeta?.restoredFromResponseId === 'string'
+        ? resumeMeta.restoredFromResponseId.trim()
+        : undefined;
+    if (resumeId) {
+        return resumeId;
+    }
+    const contextRecord = responsesContext && typeof responsesContext === 'object'
+        ? responsesContext
+        : undefined;
+    const previousId = typeof contextRecord?.previous_response_id === 'string'
+        ? contextRecord.previous_response_id.trim()
+        : undefined;
+    if (previousId) {
+        return previousId;
+    }
+    return undefined;
+}
+function extractSubmitMetadata(responsesContext, resumeMeta) {
+    if (responsesContext && responsesContext.metadata && isJsonObject(responsesContext.metadata)) {
+        return jsonClone(responsesContext.metadata);
+    }
+    if (resumeMeta && resumeMeta.metadata && isJsonObject(resumeMeta.metadata)) {
+        return jsonClone(resumeMeta.metadata);
+    }
+    return undefined;
+}
+function coerceOutputText(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value === undefined || value === null) {
+        return '';
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function extractCapturedToolOutputs(responsesContext) {
+    if (!responsesContext || typeof responsesContext !== 'object') {
+        return [];
+    }
+    const snapshot = responsesContext.__captured_tool_results;
+    if (!Array.isArray(snapshot) || !snapshot.length) {
+        return [];
+    }
+    const entries = [];
+    snapshot.forEach((entry) => {
+        if (!entry || typeof entry !== 'object') {
+            return;
+        }
+        const record = entry;
+        const toolId = typeof record.tool_call_id === 'string' && record.tool_call_id.trim().length
+            ? record.tool_call_id.trim()
+            : typeof record.call_id === 'string' && record.call_id.trim().length
+                ? record.call_id.trim()
+                : undefined;
+        if (!toolId) {
+            return;
+        }
+        entries.push({
+            tool_call_id: toolId,
+            id: toolId,
+            output: typeof record.output === 'string' ? record.output : coerceOutputText(record.output),
+            name: typeof record.name === 'string' ? record.name : undefined
+        });
+    });
+    return entries;
+}
+function collectSubmitToolOutputs(chat, responsesContext) {
+    const outputs = [];
+    const seen = new Set();
+    const append = (idSeed, outputSeed, name) => {
+        const trimmed = typeof idSeed === 'string' && idSeed.trim().length ? idSeed.trim() : '';
+        const fallbackId = trimmed || `submit_tool_${outputs.length + 1}`;
+        if (seen.has(fallbackId)) {
+            return;
+        }
+        seen.add(fallbackId);
+        outputs.push({
+            tool_call_id: fallbackId,
+            id: fallbackId,
+            output: coerceOutputText(outputSeed),
+            name
+        });
+    };
+    if (Array.isArray(chat.toolOutputs) && chat.toolOutputs.length) {
+        chat.toolOutputs.forEach((entry) => {
+            append(entry.tool_call_id ?? entry.call_id, entry.content, entry.name);
+        });
+    }
+    if (!outputs.length) {
+        const captured = extractCapturedToolOutputs(responsesContext);
+        captured.forEach((entry) => append(entry.tool_call_id ?? entry.id, entry.output, entry.name));
+    }
+    if (!outputs.length) {
+        const resume = readResponsesResumeFromSemantics(chat);
+        if (resume) {
+            const resumeOutputs = deriveResumeToolOutputsFromResume(resume);
+            if (resumeOutputs?.length) {
+                resumeOutputs.forEach((entry) => append(entry.tool_call_id, entry.content, entry.name));
+            }
+        }
+    }
+    return outputs;
+}
+function resolveSubmitStreamFlag(chat, _ctx, _responsesContext) {
+    if (chat.parameters && typeof chat.parameters.stream === 'boolean') {
+        return chat.parameters.stream;
+    }
+    return undefined;
+}
+function resolveSubmitModel(chat, _responsesContext) {
+    const direct = chat.parameters && typeof chat.parameters.model === 'string'
+        ? chat.parameters.model.trim()
+        : undefined;
+    if (direct) {
+        return direct;
+    }
+    return undefined;
+}
+function buildSubmitToolOutputsPayload(chat, ctx, responsesContext) {
+    const resumeMeta = (() => {
+        try {
+            const resume = readResponsesResumeFromSemantics(chat);
+            return resume && typeof resume === 'object' && !Array.isArray(resume) ? resume : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const responseId = resolveSubmitResponseId(resumeMeta, responsesContext);
+    if (!responseId) {
+        throw new Error('Submit tool outputs requires response_id from Responses resume context');
+    }
+    const toolOutputs = collectSubmitToolOutputs(chat, responsesContext);
+    if (!toolOutputs.length) {
+        throw new Error('Submit tool outputs requires at least one tool output entry');
+    }
+    const payload = {
+        response_id: responseId,
+        tool_outputs: toolOutputs
+    };
+    const modelValue = resolveSubmitModel(chat, responsesContext);
+    if (modelValue) {
+        payload.model = modelValue;
+    }
+    const streamValue = resolveSubmitStreamFlag(chat, ctx, responsesContext);
+    if (typeof streamValue === 'boolean') {
+        payload.stream = streamValue;
+    }
+    const metadata = extractSubmitMetadata(responsesContext, resumeMeta);
+    if (metadata) {
+        payload.metadata = metadata;
+    }
+    return payload;
+}
+export class ResponsesSemanticMapper {
+    async toChat(format, ctx) {
+        const requestId = typeof ctx.requestId === 'string' && ctx.requestId.trim().length ? ctx.requestId : 'unknown';
+        const payload = format.payload || {};
+        logHubStageTiming(requestId, 'req_inbound.responses.capture_context', 'start');
+        const captureStart = Date.now();
+        const responsesContext = captureResponsesContext(payload, { route: { requestId: ctx.requestId } });
+        logHubStageTiming(requestId, 'req_inbound.responses.capture_context', 'completed', {
+            elapsedMs: Date.now() - captureStart,
+            forceLog: true
+        });
+        logHubStageTiming(requestId, 'req_inbound.responses.build_chat_request', 'start');
+        const buildChatStart = Date.now();
+        const { request, toolsNormalized } = buildChatRequestFromResponses(payload, responsesContext);
+        logHubStageTiming(requestId, 'req_inbound.responses.build_chat_request', 'completed', {
+            elapsedMs: Date.now() - buildChatStart,
+            forceLog: true
+        });
+        const missingFields = [];
+        const messages = normalizeMessages(request.messages, missingFields);
+        let toolOutputs = mapToolOutputs(payload.tool_outputs, missingFields);
+        const parameters = collectParameters(payload, typeof payload.stream === 'boolean' ? payload.stream : undefined);
+        const metadata = { context: ctx };
+        if (missingFields.length) {
+            metadata.missingFields = missingFields;
+        }
+        // Keep responses protocol semantics in chat.semantics (not metadata).
+        const semantics = attachResponsesSemantics(undefined, responsesContext, undefined);
+        return {
+            messages,
+            tools: normalizeTools(toolsNormalized, missingFields),
+            toolOutputs,
+            parameters,
+            semantics,
+            metadata
+        };
+    }
+    async fromChat(chat, ctx) {
+        const requestId = typeof ctx.requestId === 'string' && ctx.requestId.trim().length ? ctx.requestId : 'unknown';
+        const envelopeMetadata = chat.metadata && isJsonObject(chat.metadata) ? chat.metadata : undefined;
+        const responsesContext = selectResponsesContextSnapshot(chat, envelopeMetadata);
+        if (isSubmitToolOutputsEndpoint(ctx)) {
+            const submitPayload = buildSubmitToolOutputsPayload(chat, ctx, responsesContext);
+            return {
+                protocol: 'openai-responses',
+                direction: 'response',
+                payload: submitPayload,
+                meta: {
+                    context: ctx,
+                    submitToolOutputs: true
+                }
+            };
+        }
+        const modelValue = chat.parameters?.model;
+        if (typeof modelValue !== 'string' || !modelValue.trim()) {
+            throw new Error('ChatEnvelope.parameters.model is required for openai-responses outbound conversion');
+        }
+        const requestShape = {
+            ...(chat.parameters || {}),
+            model: modelValue,
+            messages: chat.messages,
+            tools: chat.tools
+        };
+        if (!Array.isArray(responsesContext.originalSystemMessages) || responsesContext.originalSystemMessages.length === 0) {
+            const originalSystemMessages = (chat.messages || [])
+                .filter((message) => Boolean(message && typeof message === 'object' && message.role === 'system'))
+                .map(message => serializeSystemContent(message))
+                .filter((content) => typeof content === 'string' && content.length > 0);
+            responsesContext.originalSystemMessages = originalSystemMessages;
+        }
+        logHubStageTiming(requestId, 'req_outbound.responses.build_request', 'start');
+        const buildRequestStart = Date.now();
+        const responsesResult = buildResponsesRequestFromChat(requestShape, responsesContext);
+        logHubStageTiming(requestId, 'req_outbound.responses.build_request', 'completed', {
+            elapsedMs: Date.now() - buildRequestStart,
+            forceLog: true
+        });
+        const responses = responsesResult.request;
+        if (chat.parameters && chat.parameters.stream !== undefined) {
+            responses.stream = chat.parameters.stream;
+        }
+        // Do not forward ChatEnvelope.toolOutputs to OpenAI Responses create requests.
+        // Upstream expects historical tool results to remain inside input[] as
+        // tool role messages; sending the legacy top-level `tool_outputs` field
+        // causes providers like FAI to reject the request (HTTP 400). Any actual
+        // submit_tool_outputs call should be issued via the dedicated endpoint
+        // upstream, not through this mapper.
+        const result = {
+            protocol: 'openai-responses',
+            direction: 'response',
+            payload: responses,
+            meta: {
+                context: ctx
+            }
+        };
+        // Sampling knobs should remain intact for OpenAI Responses protocol.
+        // Provider-specific removal belongs in compatibility profiles, not here.
+        return result;
+    }
+}

package/vendor/llmswitch-core/dist/conversion/hub/ops/operations.d.ts

@@ -0,0 +1,19 @@
+import type { StandardizedRequest, StandardizedTool } from '../types/standardized.js';
+export type HubOperation = {
+    op: 'set_request_metadata_fields';
+    fields: Record<string, unknown>;
+} | {
+    op: 'unset_request_metadata_keys';
+    keys: string[];
+} | {
+    op: 'set_request_parameter_fields';
+    fields: Record<string, unknown>;
+} | {
+    op: 'unset_request_parameter_keys';
+    keys: string[];
+} | {
+    op: 'append_tool_if_missing';
+    toolName: string;
+    tool: StandardizedTool;
+};
+export declare function applyHubOperations<T extends StandardizedRequest>(request: T, ops: HubOperation[]): T;

package/vendor/llmswitch-core/dist/conversion/hub/ops/operations.js

@@ -0,0 +1,7 @@
+import { applyHubOperationsWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-process-semantics.js';
+export function applyHubOperations(request, ops) {
+    if (!ops || ops.length === 0) {
+        return request;
+    }
+    return applyHubOperationsWithNative(request, ops);
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/compat/compat-engine.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 applyRequestCompat(profileId: string | undefined, payload: JsonObject, options?: {
+    adapterContext?: AdapterContext;
+}): CompatApplicationResult;
+export declare function applyResponseCompat(profileId: string | undefined, payload: JsonObject, options?: {
+    adapterContext?: AdapterContext;
+}): CompatApplicationResult;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/compat/compat-engine.js

@@ -0,0 +1,13 @@
+import { runRequestCompatPipeline, runResponseCompatPipeline } from './compat-pipeline-executor.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+function assertCompatNativeBoundary() {
+    normalizeProviderProtocolTokenWithNative('openai-responses');
+}
+export function applyRequestCompat(profileId, payload, options) {
+    assertCompatNativeBoundary();
+    return runRequestCompatPipeline(profileId, payload, options);
+}
+export function applyResponseCompat(profileId, payload, options) {
+    assertCompatNativeBoundary();
+    return runResponseCompatPipeline(profileId, payload, options);
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/compat/compat-pipeline-executor.d.ts

@@ -0,0 +1,9 @@
+import type { AdapterContext } from '../../types/chat-envelope.js';
+import type { JsonObject } from '../../types/json.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;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/compat/compat-pipeline-executor.js

@@ -0,0 +1,46 @@
+import { runReqOutboundStage3CompatWithNative, runRespInboundStage3CompatWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+import { buildNativeReqOutboundCompatAdapterContext } from './native-adapter-context.js';
+const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
+function normalizeProfileId(profileId) {
+    if (typeof profileId !== 'string') {
+        return undefined;
+    }
+    const trimmed = profileId.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function toCompatResult(payload, appliedProfile) {
+    if (typeof appliedProfile === 'string' && appliedProfile.trim().length) {
+        return { payload, appliedProfile: appliedProfile.trim() };
+    }
+    return { payload };
+}
+export function runRequestCompatPipeline(profileId, payload, options) {
+    const explicitProfile = normalizeProfileId(profileId);
+    if (!explicitProfile) {
+        return { payload };
+    }
+    const nativeCompat = runReqOutboundStage3CompatWithNative({
+        payload,
+        explicitProfile,
+        adapterContext: buildNativeReqOutboundCompatAdapterContext(options?.adapterContext)
+    });
+    return toCompatResult(nativeCompat.payload, nativeCompat.appliedProfile);
+}
+export function runResponseCompatPipeline(profileId, payload, options) {
+    const explicitProfile = normalizeProfileId(profileId);
+    if (!explicitProfile) {
+        return { payload };
+    }
+    const nativeCompat = runRespInboundStage3CompatWithNative({
+        payload,
+        explicitProfile,
+        adapterContext: buildNativeReqOutboundCompatAdapterContext(options?.adapterContext)
+    });
+    if (nativeCompat.nativeApplied === true && nativeCompat.rateLimitDetected === true) {
+        const err = new Error('Provider returned rate limit notice');
+        err.code = RATE_LIMIT_ERROR;
+        err.statusCode = 429;
+        throw err;
+    }
+    return toCompatResult(nativeCompat.payload, nativeCompat.appliedProfile);
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/compat/compat-profile-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterContext } from '../../types/chat-envelope.js';
+export declare function resolveCompatProfileForContext(adapterContext: AdapterContext): string | undefined;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/compat/compat-profile-resolver.js

@@ -0,0 +1,14 @@
+import { normalizeProviderProtocolTokenWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+function readNonEmptyString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+export function resolveCompatProfileForContext(adapterContext) {
+    normalizeProviderProtocolTokenWithNative(adapterContext.providerProtocol);
+    const context = adapterContext;
+    const explicit = readNonEmptyString(context.compatibilityProfile);
+    return explicit;
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/compat/compat-profile-store.d.ts

@@ -0,0 +1,2 @@
+import type { CompatProfileConfig } from './compat-types.js';
+export declare function getCompatProfile(profileId?: string): CompatProfileConfig | null;