@jsonstudio/rcc 0.90.872 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/anthropic-semantics-audit.d.ts

@@ -2,6 +2,7 @@ import type { ChatEnvelope, ChatSemantics } from '../../types/chat-envelope.js';
 import { type JsonObject, type JsonValue } from '../../types/json.js';
 export declare function ensureSemantics(chat: ChatEnvelope): ChatSemantics;
 export declare function ensureToolsSemanticsNode(chat: ChatEnvelope): JsonObject;
+export declare function ensureAnthropicSemanticsNode(chat: ChatEnvelope): JsonObject;
 export declare function markExplicitEmptyTools(chat: ChatEnvelope): void;
 export declare function hasExplicitEmptyToolsSemantics(chat: ChatEnvelope): boolean;
 export declare function cloneAnthropicSystemBlocks(value: JsonValue | undefined): JsonValue[] | undefined;
@@ -16,3 +17,13 @@ export declare function appendLossyFieldAudit(chat: ChatEnvelope, options: {
     targetProtocol: string;
     reason: string;
 }): void;
+export declare function appendPreservedFieldAudit(chat: ChatEnvelope, options: {
+    field: string;
+    targetProtocol: string;
+    reason: string;
+}): void;
+export declare function appendUnsupportedFieldAudit(chat: ChatEnvelope, options: {
+    field: string;
+    targetProtocol?: string;
+    reason: string;
+}): void;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/anthropic-semantics-audit.js

@@ -1,4 +1,5 @@
 import { isJsonObject, jsonClone } from '../../types/json.js';
+import { appendDroppedFieldAudit as appendDroppedFieldAuditShared, appendLossyFieldAudit as appendLossyFieldAuditShared, appendPreservedFieldAudit as appendPreservedFieldAuditShared, appendUnsupportedFieldAudit as appendUnsupportedFieldAuditShared, } from './protocol-mapping-audit.js';
 export function ensureSemantics(chat) {
     if (!chat.semantics || typeof chat.semantics !== 'object') {
         chat.semantics = {};
@@ -12,6 +13,13 @@ export function ensureToolsSemanticsNode(chat) {
     }
     return semantics.tools;
 }
+export function ensureAnthropicSemanticsNode(chat) {
+    const semantics = ensureSemantics(chat);
+    if (!semantics.anthropic || !isJsonObject(semantics.anthropic)) {
+        semantics.anthropic = {};
+    }
+    return semantics.anthropic;
+}
 export function markExplicitEmptyTools(chat) {
     const semantics = ensureSemantics(chat);
     if (!semantics.tools || !isJsonObject(semantics.tools)) {
@@ -54,37 +62,15 @@ export function isResponsesOrigin(chat) {
     const endpoint = typeof ctx?.entryEndpoint === 'string' ? ctx.entryEndpoint.trim().toLowerCase() : '';
     return endpoint === '/v1/responses';
 }
-function appendMappingAudit(chat, options) {
-    const metadata = chat.metadata && typeof chat.metadata === 'object'
-        ? chat.metadata
-        : (chat.metadata = { context: chat.metadata?.context ?? {} });
-    const root = metadata.mappingAudit && typeof metadata.mappingAudit === 'object' && !Array.isArray(metadata.mappingAudit)
-        ? metadata.mappingAudit
-        : (metadata.mappingAudit = {});
-    const current = Array.isArray(root[options.bucket]) ? root[options.bucket] : [];
-    const duplicate = current.find((entry) => entry &&
-        entry.field === options.field &&
-        entry.targetProtocol === options.targetProtocol &&
-        entry.reason === options.reason);
-    if (!duplicate) {
-        current.push({
-            field: options.field,
-            source: options.source ?? 'chat.parameters',
-            targetProtocol: options.targetProtocol,
-            reason: options.reason
-        });
-    }
-    root[options.bucket] = current;
-}
 export function appendDroppedFieldAudit(chat, options) {
-    appendMappingAudit(chat, {
-        bucket: 'dropped',
-        ...options
-    });
+    appendDroppedFieldAuditShared(chat, options);
 }
 export function appendLossyFieldAudit(chat, options) {
-    appendMappingAudit(chat, {
-        bucket: 'lossy',
-        ...options
-    });
+    appendLossyFieldAuditShared(chat, options);
+}
+export function appendPreservedFieldAudit(chat, options) {
+    appendPreservedFieldAuditShared(chat, options);
+}
+export function appendUnsupportedFieldAudit(chat, options) {
+    appendUnsupportedFieldAuditShared(chat, options);
 }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/gemini-mapper-config.js

@@ -3,7 +3,6 @@ export const GEMINI_PASSTHROUGH_METADATA_PREFIX = 'rcc_passthrough_';
 export const GEMINI_PASSTHROUGH_PARAMETERS = ['tool_choice'];
 const RESPONSES_DROPPED_PARAMETER_KEYS = [
     'prompt_cache_key',
-    'response_format',
     'parallel_tool_calls',
     'service_tier',
     'truncation',

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/gemini-mapper-from-chat.js

@@ -6,7 +6,7 @@ import { getProtocolState } from '../../../protocol-state.js';
 import { ANTIGRAVITY_DEFAULT_SAFETY_SETTINGS, deepCleanUndefined, injectGoogleSearchTool, pruneSearchFunctionDeclarations, resolveAntigravityRequestConfig, stripOnlineSuffix } from './gemini-antigravity-request.js';
 import { applyGeminiRequestSystemInstruction, readSystemTextBlocksFromSemantics } from './gemini-system-semantics.js';
 import { applyAntigravityThinkingConfig, buildGenerationConfigFromParameters } from './gemini-thinking-config.js';
-import { appendLossyFieldAudit } from './gemini-mapping-audit.js';
+import { appendLossyFieldAudit, appendPreservedFieldAudit, appendUnsupportedFieldAudit } from './gemini-mapping-audit.js';
 import { buildFunctionResponseEntry, cloneAsJsonValue, convertToolMessageToOutput, normalizeToolContent, sanitizeAntigravityToolCallId, synthesizeToolOutputsFromMessages } from './gemini-tool-output.js';
 import { alignToolCallArgsToSchema, appendChatContentToGeminiParts, buildToolSchemaKeyMap, collectAssistantToolCallIds, isResponsesOrigin, mapChatRoleToGemini, mapToolNameForGemini } from './gemini-chat-request-helpers.js';
 import { hasExplicitEmptyToolsSemantics, readGeminiSemantics } from './gemini-semantics-state.js';
@@ -26,6 +26,13 @@ export function buildGeminiRequestFromChat(chat, metadata) {
     const isAntigravityProvider = providerIdPrefix === 'antigravity';
     const parameters = chat.parameters && typeof chat.parameters === 'object' ? chat.parameters : {};
     const responsesOrigin = isResponsesOrigin(chat);
+    if (Object.prototype.hasOwnProperty.call(parameters, 'response_format')) {
+        appendUnsupportedFieldAudit(chat, {
+            field: 'response_format',
+            targetProtocol: 'gemini-chat',
+            reason: 'structured_output_not_supported'
+        });
+    }
     recordGeminiResponsesDroppedParameters(chat, parameters, responsesOrigin);
     const keepReasoning = Boolean(parameters.keep_thinking) ||
         Boolean(parameters.keep_reasoning);
@@ -268,6 +275,13 @@ export function buildGeminiRequestFromChat(chat, metadata) {
             request.metadata[key] = value;
         }
     }
+    if (Object.prototype.hasOwnProperty.call(parameters, 'tool_choice')) {
+        appendPreservedFieldAudit(chat, {
+            field: 'tool_choice',
+            targetProtocol: 'gemini-chat',
+            reason: 'preserved_via_metadata_passthrough'
+        });
+    }
     if (isAntigravityProvider) {
         request.metadata = request.metadata ?? {};
         const existing = request.metadata.antigravitySessionId;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/gemini-mapping-audit.d.ts

@@ -9,3 +9,13 @@ export declare function appendLossyFieldAudit(chat: ChatEnvelope, options: {
     targetProtocol: string;
     reason: string;
 }): void;
+export declare function appendPreservedFieldAudit(chat: ChatEnvelope, options: {
+    field: string;
+    targetProtocol: string;
+    reason: string;
+}): void;
+export declare function appendUnsupportedFieldAudit(chat: ChatEnvelope, options: {
+    field: string;
+    targetProtocol?: string;
+    reason: string;
+}): void;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/gemini-mapping-audit.js

@@ -1,34 +1,13 @@
-function appendMappingAudit(chat, options) {
-    const metadata = chat.metadata && typeof chat.metadata === 'object'
-        ? chat.metadata
-        : (chat.metadata = { context: chat.metadata?.context ?? {} });
-    const root = metadata.mappingAudit && typeof metadata.mappingAudit === 'object' && !Array.isArray(metadata.mappingAudit)
-        ? metadata.mappingAudit
-        : (metadata.mappingAudit = {});
-    const current = Array.isArray(root[options.bucket]) ? root[options.bucket] : [];
-    const duplicate = current.find((entry) => entry &&
-        entry.field === options.field &&
-        entry.targetProtocol === options.targetProtocol &&
-        entry.reason === options.reason);
-    if (!duplicate) {
-        current.push({
-            field: options.field,
-            source: options.source ?? 'chat.parameters',
-            targetProtocol: options.targetProtocol,
-            reason: options.reason
-        });
-    }
-    root[options.bucket] = current;
-}
+import { appendDroppedFieldAudit as appendDroppedFieldAuditShared, appendLossyFieldAudit as appendLossyFieldAuditShared, appendPreservedFieldAudit as appendPreservedFieldAuditShared, appendUnsupportedFieldAudit as appendUnsupportedFieldAuditShared, } from './protocol-mapping-audit.js';
 export function appendDroppedFieldAudit(chat, options) {
-    appendMappingAudit(chat, {
-        bucket: 'dropped',
-        ...options
-    });
+    appendDroppedFieldAuditShared(chat, options);
 }
 export function appendLossyFieldAudit(chat, options) {
-    appendMappingAudit(chat, {
-        bucket: 'lossy',
-        ...options
-    });
+    appendLossyFieldAuditShared(chat, options);
+}
+export function appendPreservedFieldAudit(chat, options) {
+    appendPreservedFieldAuditShared(chat, options);
+}
+export function appendUnsupportedFieldAudit(chat, options) {
+    appendUnsupportedFieldAuditShared(chat, options);
 }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/protocol-mapping-audit.d.ts

@@ -0,0 +1,43 @@
+import type { ChatEnvelope, ChatProtocolMappingAuditEntry, ChatProtocolMappingDisposition, ChatSemanticAudit } from '../../types/chat-envelope.js';
+export declare const DISABLE_LEGACY_PROTOCOL_MAPPING_AUDIT_MIRROR_ENV = "ROUTECODEX_DISABLE_LEGACY_PROTOCOL_MAPPING_AUDIT_MIRROR";
+export declare function shouldMirrorProtocolMappingAuditToLegacy(env?: Record<string, string | undefined>): boolean;
+export declare function readProtocolMappingAudit(chat: ChatEnvelope): NonNullable<ChatSemanticAudit['protocolMapping']> | undefined;
+export declare function readLegacyProtocolMappingAudit(chat: ChatEnvelope): NonNullable<ChatSemanticAudit['protocolMapping']> | undefined;
+export declare function readProtocolMappingAuditBucket(chat: ChatEnvelope, bucket: ChatProtocolMappingDisposition): ChatProtocolMappingAuditEntry[];
+export declare function readLegacyProtocolMappingAuditBucket(chat: ChatEnvelope, bucket: ChatProtocolMappingDisposition): ChatProtocolMappingAuditEntry[];
+export declare function appendProtocolMappingAudit(chat: ChatEnvelope, options: {
+    bucket: ChatProtocolMappingDisposition;
+    field: string;
+    targetProtocol?: string;
+    sourceProtocol?: string;
+    reason: string;
+    source?: string;
+}): void;
+export declare function appendDroppedFieldAudit(chat: ChatEnvelope, options: {
+    field: string;
+    targetProtocol: string;
+    reason: string;
+    source?: string;
+    sourceProtocol?: string;
+}): void;
+export declare function appendLossyFieldAudit(chat: ChatEnvelope, options: {
+    field: string;
+    targetProtocol: string;
+    reason: string;
+    source?: string;
+    sourceProtocol?: string;
+}): void;
+export declare function appendPreservedFieldAudit(chat: ChatEnvelope, options: {
+    field: string;
+    targetProtocol: string;
+    reason: string;
+    source?: string;
+    sourceProtocol?: string;
+}): void;
+export declare function appendUnsupportedFieldAudit(chat: ChatEnvelope, options: {
+    field: string;
+    targetProtocol?: string;
+    reason: string;
+    source?: string;
+    sourceProtocol?: string;
+}): void;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/protocol-mapping-audit.js

@@ -0,0 +1,148 @@
+export const DISABLE_LEGACY_PROTOCOL_MAPPING_AUDIT_MIRROR_ENV = 'ROUTECODEX_DISABLE_LEGACY_PROTOCOL_MAPPING_AUDIT_MIRROR';
+function ensureSemantics(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        chat.semantics = {};
+    }
+    return chat.semantics;
+}
+function ensureAuditRoot(chat) {
+    const semantics = ensureSemantics(chat);
+    if (!semantics.audit || typeof semantics.audit !== 'object' || Array.isArray(semantics.audit)) {
+        semantics.audit = {};
+    }
+    const audit = semantics.audit;
+    if (!audit.protocolMapping || typeof audit.protocolMapping !== 'object' || Array.isArray(audit.protocolMapping)) {
+        audit.protocolMapping = {};
+    }
+    return audit.protocolMapping;
+}
+function ensureLegacyMetadataAuditRoot(chat) {
+    const metadata = chat.metadata && typeof chat.metadata === 'object'
+        ? chat.metadata
+        : (chat.metadata = { context: chat.metadata?.context ?? {} });
+    const root = metadata.mappingAudit && typeof metadata.mappingAudit === 'object' && !Array.isArray(metadata.mappingAudit)
+        ? metadata.mappingAudit
+        : (metadata.mappingAudit = {});
+    return root;
+}
+function readSourceProtocol(chat) {
+    const context = chat.metadata && typeof chat.metadata === 'object'
+        ? chat.metadata.context
+        : undefined;
+    return typeof context?.providerProtocol === 'string' && context.providerProtocol.trim()
+        ? context.providerProtocol.trim()
+        : undefined;
+}
+function readRuntimeEnv() {
+    if (typeof process !== 'undefined' && process?.env) {
+        return process.env;
+    }
+    return {};
+}
+export function shouldMirrorProtocolMappingAuditToLegacy(env = readRuntimeEnv()) {
+    const disabled = env[DISABLE_LEGACY_PROTOCOL_MAPPING_AUDIT_MIRROR_ENV];
+    return disabled !== '1';
+}
+export function readProtocolMappingAudit(chat) {
+    const semanticsAudit = chat.semantics?.audit;
+    if (semanticsAudit && typeof semanticsAudit === 'object' && !Array.isArray(semanticsAudit)) {
+        const protocolMapping = semanticsAudit.protocolMapping;
+        if (protocolMapping && typeof protocolMapping === 'object' && !Array.isArray(protocolMapping)) {
+            return protocolMapping;
+        }
+    }
+    const metadata = chat.metadata && typeof chat.metadata === 'object'
+        ? chat.metadata
+        : undefined;
+    const legacy = metadata?.mappingAudit;
+    if (legacy && typeof legacy === 'object' && !Array.isArray(legacy)) {
+        return legacy;
+    }
+    return undefined;
+}
+export function readLegacyProtocolMappingAudit(chat) {
+    const metadata = chat.metadata && typeof chat.metadata === 'object'
+        ? chat.metadata
+        : undefined;
+    const legacy = metadata?.mappingAudit;
+    if (legacy && typeof legacy === 'object' && !Array.isArray(legacy)) {
+        return legacy;
+    }
+    return undefined;
+}
+export function readProtocolMappingAuditBucket(chat, bucket) {
+    const root = readProtocolMappingAudit(chat);
+    const items = root?.[bucket];
+    return Array.isArray(items) ? items : [];
+}
+export function readLegacyProtocolMappingAuditBucket(chat, bucket) {
+    const root = readLegacyProtocolMappingAudit(chat);
+    const items = root?.[bucket];
+    return Array.isArray(items) ? items : [];
+}
+export function appendProtocolMappingAudit(chat, options) {
+    const sourceProtocol = options.sourceProtocol ?? readSourceProtocol(chat);
+    const entry = {
+        field: options.field,
+        disposition: options.bucket,
+        reason: options.reason,
+        ...(sourceProtocol ? { sourceProtocol } : {}),
+        ...(options.targetProtocol ? { targetProtocol: options.targetProtocol } : {}),
+        source: options.source ?? 'chat.parameters'
+    };
+    const auditRoot = ensureAuditRoot(chat);
+    const current = Array.isArray(auditRoot[options.bucket])
+        ? [...auditRoot[options.bucket]]
+        : [];
+    const duplicate = current.find((candidate) => candidate &&
+        candidate.field === entry.field &&
+        candidate.targetProtocol === entry.targetProtocol &&
+        candidate.reason === entry.reason &&
+        candidate.source === entry.source &&
+        candidate.sourceProtocol === entry.sourceProtocol);
+    if (!duplicate) {
+        current.push(entry);
+    }
+    auditRoot[options.bucket] = current;
+    if (!shouldMirrorProtocolMappingAuditToLegacy()) {
+        return;
+    }
+    const legacyRoot = ensureLegacyMetadataAuditRoot(chat);
+    const legacyCurrent = Array.isArray(legacyRoot[options.bucket])
+        ? legacyRoot[options.bucket]
+        : [];
+    const legacyDuplicate = legacyCurrent.find((candidate) => candidate &&
+        candidate.field === entry.field &&
+        candidate.targetProtocol === entry.targetProtocol &&
+        candidate.reason === entry.reason &&
+        candidate.source === entry.source &&
+        candidate.sourceProtocol === entry.sourceProtocol);
+    if (!legacyDuplicate) {
+        legacyCurrent.push(entry);
+    }
+    legacyRoot[options.bucket] = legacyCurrent;
+}
+export function appendDroppedFieldAudit(chat, options) {
+    appendProtocolMappingAudit(chat, {
+        bucket: 'dropped',
+        ...options
+    });
+}
+export function appendLossyFieldAudit(chat, options) {
+    appendProtocolMappingAudit(chat, {
+        bucket: 'lossy',
+        ...options
+    });
+}
+export function appendPreservedFieldAudit(chat, options) {
+    appendProtocolMappingAudit(chat, {
+        bucket: 'preserved',
+        ...options
+    });
+}
+export function appendUnsupportedFieldAudit(chat, options) {
+    appendProtocolMappingAudit(chat, {
+        bucket: 'unsupported',
+        ...options
+    });
+}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/responses-mapper-from-chat.js

@@ -2,11 +2,18 @@ import { isJsonObject } from '../../types/json.js';
 import { buildResponsesRequestFromChat } from '../../../responses/responses-openai-bridge.js';
 import { logHubStageTiming } from '../../pipeline/hub-stage-timing.js';
 import { buildSubmitToolOutputsPayload, isSubmitToolOutputsEndpoint, } from './responses-submit-tool-outputs.js';
-import { selectResponsesContextSnapshot, serializeSystemContent, } from './responses-mapper-helpers.js';
+import { readResponsesRequestParametersFromSemantics, selectResponsesContextSnapshot, serializeSystemContent, } from './responses-mapper-helpers.js';
 export async function buildResponsesFormatEnvelopeFromChat(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);
+    const semanticsParameters = readResponsesRequestParametersFromSemantics(chat);
+    const mergedParameters = semanticsParameters || chat.parameters
+        ? {
+            ...(semanticsParameters ?? {}),
+            ...(chat.parameters ?? {})
+        }
+        : undefined;
     if (isSubmitToolOutputsEndpoint(ctx)) {
         const submitPayload = buildSubmitToolOutputsPayload(chat, ctx, responsesContext);
         return {
@@ -19,15 +26,18 @@ export async function buildResponsesFormatEnvelopeFromChat(chat, ctx) {
             }
         };
     }
-    const modelValue = chat.parameters?.model;
+    const modelValue = mergedParameters?.model;
     if (typeof modelValue !== 'string' || !modelValue.trim()) {
         throw new Error('ChatEnvelope.parameters.model is required for openai-responses outbound conversion');
     }
     const requestShape = {
-        ...(chat.parameters || {}),
+        ...(mergedParameters || {}),
         model: modelValue,
         messages: chat.messages,
-        tools: chat.tools
+        tools: chat.tools,
+        semantics: chat.semantics && typeof chat.semantics === 'object'
+            ? chat.semantics
+            : undefined
     };
     if (!Array.isArray(responsesContext.originalSystemMessages) || responsesContext.originalSystemMessages.length === 0) {
         const originalSystemMessages = (chat.messages || [])
@@ -44,8 +54,8 @@ export async function buildResponsesFormatEnvelopeFromChat(chat, ctx) {
         forceLog: true
     });
     const responses = responsesResult.request;
-    if (chat.parameters && chat.parameters.stream !== undefined) {
-        responses.stream = chat.parameters.stream;
+    if (mergedParameters && mergedParameters.stream !== undefined) {
+        responses.stream = mergedParameters.stream;
     }
     // Do not forward ChatEnvelope.toolOutputs to OpenAI Responses create requests.
     // Upstream expects historical tool results to remain inside input[] as

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/responses-mapper-helpers.d.ts

@@ -6,5 +6,6 @@ export declare function mapToolOutputs(entries: ResponsesToolOutputEntry[] | und
 export declare function normalizeTools(rawTools: JsonValue[] | undefined, missing: MissingField[]): ChatToolDefinition[] | undefined;
 export declare function normalizeMessages(value: JsonValue | undefined, missing: MissingField[]): ChatEnvelope['messages'];
 export declare function serializeSystemContent(message: ChatMessage): string | undefined;
-export declare function attachResponsesSemantics(existing: ChatSemantics | undefined, context?: ResponsesRequestContext, resume?: JsonObject): ChatSemantics | undefined;
+export declare function attachResponsesSemantics(existing: ChatSemantics | undefined, context?: ResponsesRequestContext, resume?: JsonObject, requestParameters?: JsonObject): ChatSemantics | undefined;
+export declare function readResponsesRequestParametersFromSemantics(chat: ChatEnvelope): JsonObject | undefined;
 export declare function selectResponsesContextSnapshot(chat: ChatEnvelope, envelopeMetadata?: JsonObject): ResponsesRequestContext;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/responses-mapper-helpers.js

@@ -1,6 +1,19 @@
 import { isJsonObject, jsonClone } from '../../types/json.js';
 import { maybeAugmentApplyPatchErrorContent } from './chat-mapper.js';
 import { mapReqInboundBridgeToolsToChatWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+const RESPONSES_SEMANTIC_PARAMETER_FIELDS = [
+    ['responseFormat', 'response_format'],
+    ['include', 'include'],
+    ['store', 'store'],
+    ['promptCacheKey', 'prompt_cache_key'],
+    ['toolChoice', 'tool_choice'],
+    ['parallelToolCalls', 'parallel_tool_calls'],
+    ['reasoning', 'reasoning'],
+    ['text', 'text'],
+    ['serviceTier', 'service_tier'],
+    ['truncation', 'truncation'],
+    ['modalities', 'modalities'],
+];
 export function mapToolOutputs(entries, missing) {
     if (!entries || !entries.length)
         return undefined;
@@ -114,18 +127,32 @@ function mergeMetadata(a, b) {
     const right = jsonClone(b);
     return { ...left, ...right };
 }
-export function attachResponsesSemantics(existing, context, resume) {
-    if (!context && !resume) {
+export function attachResponsesSemantics(existing, context, resume, requestParameters) {
+    if (!context && !resume && !requestParameters) {
         return existing;
     }
     const next = existing ? { ...existing } : {};
     const currentNode = next.responses && isJsonObject(next.responses) ? { ...next.responses } : {};
+    const effectiveRequestParameters = requestParameters && isJsonObject(requestParameters)
+        ? jsonClone(requestParameters)
+        : context?.parameters && isJsonObject(context.parameters)
+            ? jsonClone(context.parameters)
+            : undefined;
     if (context) {
         currentNode.context = jsonClone(context);
     }
     if (resume) {
         currentNode.resume = jsonClone(resume);
     }
+    if (effectiveRequestParameters) {
+        currentNode.requestParameters = effectiveRequestParameters;
+    }
+    for (const [semanticKey, parameterKey] of RESPONSES_SEMANTIC_PARAMETER_FIELDS) {
+        const parameterValue = effectiveRequestParameters?.[parameterKey];
+        if (parameterValue !== undefined) {
+            currentNode[semanticKey] = jsonClone(parameterValue);
+        }
+    }
     next.responses = currentNode;
     return next;
 }
@@ -147,6 +174,41 @@ function readResponsesContextFromSemantics(chat) {
     }
     return jsonClone(contextNode);
 }
+export function readResponsesRequestParametersFromSemantics(chat) {
+    const node = extractResponsesSemanticsNode(chat);
+    if (!node) {
+        return undefined;
+    }
+    const merged = node.requestParameters && isJsonObject(node.requestParameters)
+        ? jsonClone(node.requestParameters)
+        : {};
+    let mutated = Object.keys(merged).length > 0;
+    for (const [semanticKey, parameterKey] of RESPONSES_SEMANTIC_PARAMETER_FIELDS) {
+        const semanticValue = node[semanticKey];
+        if (semanticValue === undefined) {
+            continue;
+        }
+        merged[parameterKey] = jsonClone(semanticValue);
+        mutated = true;
+    }
+    return mutated ? merged : undefined;
+}
+function hydrateResponsesContextWithSemantics(context, chat) {
+    const next = jsonClone(context);
+    const requestParameters = readResponsesRequestParametersFromSemantics(chat);
+    if (requestParameters) {
+        next.parameters = requestParameters;
+        for (const [semanticKey, parameterKey] of RESPONSES_SEMANTIC_PARAMETER_FIELDS) {
+            const value = requestParameters[parameterKey];
+            if (value === undefined) {
+                continue;
+            }
+            next[semanticKey] = jsonClone(value);
+            next[parameterKey] = jsonClone(value);
+        }
+    }
+    return next;
+}
 export function selectResponsesContextSnapshot(chat, envelopeMetadata) {
     const semanticsContext = readResponsesContextFromSemantics(chat);
     const context = semanticsContext ??
@@ -157,5 +219,5 @@ export function selectResponsesContextSnapshot(chat, envelopeMetadata) {
     if (mergedMetadata) {
         context.metadata = mergedMetadata;
     }
-    return context;
+    return hydrateResponsesContextWithSemantics(context, chat);
 }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/responses-mapper-to-chat.js

@@ -30,7 +30,7 @@ export async function buildResponsesChatEnvelopeFromPayload(format, ctx) {
         metadata.missingFields = missingFields;
     }
     // Keep responses protocol semantics in chat.semantics (not metadata).
-    const semantics = attachResponsesSemantics(undefined, responsesContext, undefined);
+    const semantics = attachResponsesSemantics(undefined, responsesContext, undefined, parameters);
     return {
         messages,
         tools: normalizeTools(toolsNormalized, missingFields),

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/responses-mapper.d.ts

@@ -3,7 +3,7 @@ import type { AdapterContext, ChatEnvelope } from '../../types/chat-envelope.js'
 import type { FormatEnvelope } from '../../types/format-envelope.js';
 import type { ResponsesPayload } from './responses-mapper-config.js';
 export type { ResponsesPayload };
-export { attachResponsesSemantics, mapToolOutputs, normalizeMessages, normalizeTools, selectResponsesContextSnapshot, serializeSystemContent, } from './responses-mapper-helpers.js';
+export { attachResponsesSemantics, mapToolOutputs, normalizeMessages, normalizeTools, readResponsesRequestParametersFromSemantics, selectResponsesContextSnapshot, serializeSystemContent, } from './responses-mapper-helpers.js';
 export declare class ResponsesSemanticMapper implements SemanticMapper {
     toChat(format: FormatEnvelope<ResponsesPayload>, ctx: AdapterContext): Promise<ChatEnvelope>;
     fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/responses-mapper.js

@@ -1,6 +1,6 @@
 import { buildResponsesChatEnvelopeFromPayload } from './responses-mapper-to-chat.js';
 import { buildResponsesFormatEnvelopeFromChat } from './responses-mapper-from-chat.js';
-export { attachResponsesSemantics, mapToolOutputs, normalizeMessages, normalizeTools, selectResponsesContextSnapshot, serializeSystemContent, } from './responses-mapper-helpers.js';
+export { attachResponsesSemantics, mapToolOutputs, normalizeMessages, normalizeTools, readResponsesRequestParametersFromSemantics, selectResponsesContextSnapshot, serializeSystemContent, } from './responses-mapper-helpers.js';
 export class ResponsesSemanticMapper {
     async toChat(format, ctx) {
         return await buildResponsesChatEnvelopeFromPayload(format, ctx);