@jsonstudio/llms 0.6.473 → 0.6.567

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

@@ -15,6 +15,7 @@ import { applyGeminiWebSearchCompat } from '../../../compat/actions/gemini-web-s
 import { applyIflowWebSearchRequestTransform } from '../../../compat/actions/iflow-web-search.js';
 import { applyGlmImageContentTransform } from '../../../compat/actions/glm-image-content.js';
 import { applyGlmVisionPromptTransform } from '../../../compat/actions/glm-vision-prompt.js';
+import { applyClaudeThinkingToolSchemaCompat } from '../../../compat/actions/claude-thinking-tools.js';
 const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
 const INTERNAL_STATE = Symbol('compat.internal_state');
 export function runRequestCompatPipeline(profileId, payload, options) {
@@ -177,6 +178,11 @@ function applyMapping(root, mapping, state) {
                 replaceRoot(root, applyIflowWebSearchRequestTransform(root, state.adapterContext));
             }
             break;
+        case 'claude_thinking_tool_schema':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyClaudeThinkingToolSchemaCompat(root, state.adapterContext));
+            }
+            break;
         case 'glm_image_content':
             if (state.direction === 'request') {
                 replaceRoot(root, applyGlmImageContentTransform(root));

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

@@ -108,6 +108,8 @@ export type MappingInstruction = {
     action: 'gemini_web_search_request';
 } | {
     action: 'iflow_web_search_request';
+} | {
+    action: 'claude_thinking_tool_schema';
 };
 export type FilterInstruction = {
     action: 'rate_limit_text';

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

@@ -122,6 +122,8 @@ export class HubPipeline {
             ? normalizedMeta.responsesResume
             : undefined;
         const stdMetadata = workingRequest?.metadata;
+        const hasImageAttachment = (stdMetadata?.hasImageAttachment === true || stdMetadata?.hasImageAttachment === 'true') ||
+            (normalizedMeta?.hasImageAttachment === true || normalizedMeta?.hasImageAttachment === 'true');
         const serverToolRequired = stdMetadata?.webSearchEnabled === true ||
             stdMetadata?.serverToolRequired === true;
         const sessionIdentifiers = extractSessionIdentifiersFromMetadata(normalized.metadata);
@@ -256,6 +258,7 @@ export class HubPipeline {
         }
         const metadata = {
             ...normalized.metadata,
+            ...(hasImageAttachment ? { hasImageAttachment: true } : {}),
             ...(capturedChatRequest ? { capturedChatRequest } : {}),
             entryEndpoint: normalized.entryEndpoint,
             providerProtocol: outboundProtocol,
@@ -382,6 +385,18 @@ export class HubPipeline {
             adapterContext.serverToolFollowup = metadata
                 .serverToolFollowup;
         }
+        const sessionId = typeof metadata.sessionId === 'string'
+            ? metadata.sessionId.trim()
+            : '';
+        if (sessionId) {
+            adapterContext.sessionId = sessionId;
+        }
+        const conversationId = typeof metadata.conversationId === 'string'
+            ? metadata.conversationId.trim()
+            : '';
+        if (conversationId) {
+            adapterContext.conversationId = conversationId;
+        }
         if (target?.compatibilityProfile && typeof target.compatibilityProfile === 'string') {
             adapterContext.compatibilityProfile = target.compatibilityProfile;
         }

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

@@ -98,6 +98,21 @@ function collectToolOutputs(payload) {
         if (!id) {
             return;
         }
+        // 针对 apply_patch 工具的失败结果做醒目日志，便于监控
+        try {
+            const name = typeof entry.name === 'string' ? entry.name.trim() : undefined;
+            const output = typeof entry.output === 'string' ? entry.output : undefined;
+            if (name === 'apply_patch' &&
+                output &&
+                output.toLowerCase().includes('apply_patch verification failed')) {
+                const firstLine = output.split('\n')[0] ?? output;
+                // eslint-disable-next-line no-console
+                console.error(`\x1b[31m[apply_patch][tool_error] tool_call_id=${id} ${firstLine}\x1b[0m`);
+            }
+        }
+        catch {
+            // logging best-effort
+        }
         if (seen.has(id)) {
             return;
         }

package/dist/conversion/hub/process/chat-process.js

@@ -206,29 +206,56 @@ function castSingleTool(tool) {
     };
 }
 function containsImageAttachment(messages) {
-    if (!Array.isArray(messages)) {
+    if (!Array.isArray(messages) || !messages.length) {
         return false;
     }
-    for (const message of messages) {
-        if (!message || typeof message !== 'object') {
+    // 仅检查当前请求中「最新一条 user 消息」是否携带图片，避免历史对话中的图片导致后续轮次反复触发。
+    let latestUser;
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const candidate = messages[idx];
+        if (candidate && typeof candidate === 'object' && candidate.role === 'user') {
+            latestUser = candidate;
+            break;
+        }
+    }
+    if (!latestUser) {
+        return false;
+    }
+    const content = latestUser.content;
+    if (!Array.isArray(content)) {
+        return false;
+    }
+    for (const part of content) {
+        if (!part || typeof part !== 'object') {
             continue;
         }
-        const content = message.content;
-        if (!Array.isArray(content)) {
+        const typeValue = part.type;
+        if (typeof typeValue !== 'string') {
             continue;
         }
-        for (const part of content) {
-            if (!part || typeof part !== 'object') {
-                continue;
-            }
-            const typeValue = part.type;
-            if (typeof typeValue !== 'string') {
-                continue;
-            }
-            const normalized = typeValue.toLowerCase();
-            if (normalized.includes('image')) {
-                return true;
-            }
+        const normalized = typeValue.toLowerCase();
+        if (!normalized.includes('image')) {
+            continue;
+        }
+        const record = part;
+        let imageCandidate = '';
+        if (typeof record.image_url === 'string') {
+            imageCandidate = record.image_url;
+        }
+        else if (record.image_url && typeof record.image_url.url === 'string') {
+            imageCandidate = record.image_url.url ?? '';
+        }
+        else if (typeof record.url === 'string') {
+            imageCandidate = record.url;
+        }
+        else if (typeof record.uri === 'string') {
+            imageCandidate = record.uri;
+        }
+        else if (typeof record.data === 'string') {
+            imageCandidate = record.data;
+        }
+        if (imageCandidate.trim().length > 0) {
+            return true;
         }
     }
     return false;

package/dist/conversion/hub/semantic-mappers/anthropic-mapper.js

@@ -200,6 +200,14 @@ export class AnthropicSemanticMapper {
         return chatEnvelope;
     }
     async fromChat(chat, ctx) {
+        // Ensure tool_use / tool_result ordering and per-session history for /v1/messages style entrypoints.
+        try {
+            const { applyToolSessionCompat } = await import('../tool-session-compat.js');
+            await applyToolSessionCompat(chat, ctx);
+        }
+        catch {
+            // best-effort compat; do not block outbound mapping
+        }
         const model = chat.parameters?.model;
         if (typeof model !== 'string' || !model.trim()) {
             throw new Error('ChatEnvelope.parameters.model is required for anthropic-messages outbound conversion');

package/dist/conversion/hub/semantic-mappers/gemini-mapper.js

@@ -6,6 +6,7 @@ import { encodeMetadataPassthrough, extractMetadataPassthrough } from '../../sha
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../../shared/tool-mapping.js';
 import { prepareGeminiToolsForBridge, buildGeminiToolsFromBridge } from '../../shared/gemini-tool-utils.js';
 import { ensureProtocolState, getProtocolState } from '../../shared/protocol-state.js';
+import { applyClaudeThinkingToolSchemaCompat } from '../../compat/actions/claude-thinking-tools.js';
 const GENERATION_CONFIG_KEYS = [
     { source: 'temperature', target: 'temperature' },
     { source: 'topP', target: 'top_p' },
@@ -385,13 +386,6 @@ function buildGeminiRequestFromChat(chat, metadata) {
     if (Object.keys(generationConfig).length) {
         request.generationConfig = generationConfig;
     }
-    if (metadata?.extraFields && isJsonObject(metadata.extraFields)) {
-        for (const [key, value] of Object.entries(metadata.extraFields)) {
-            if (request[key] === undefined) {
-                request[key] = value;
-            }
-        }
-    }
     if (metadata?.providerMetadata && isJsonObject(metadata.providerMetadata)) {
         request.metadata = jsonClone(metadata.providerMetadata);
     }
@@ -413,7 +407,11 @@ function buildGeminiRequestFromChat(chat, metadata) {
             request.metadata[key] = value;
         }
     }
-    return request;
+    // Apply claude-thinking compat directly at Gemini mapping time to ensure it is always active
+    // for antigravity.*.claude-sonnet-4-5-thinking, regardless of compatibilityProfile wiring.
+    const adapterContext = metadata?.context;
+    const compatRequest = applyClaudeThinkingToolSchemaCompat(request, adapterContext);
+    return compatRequest;
 }
 function buildGenerationConfigFromParameters(parameters) {
     const config = {};
@@ -570,6 +568,13 @@ export class GeminiSemanticMapper {
         };
     }
     async fromChat(chat, ctx) {
+        try {
+            const { applyToolSessionCompat } = await import('../tool-session-compat.js');
+            await applyToolSessionCompat(chat, ctx);
+        }
+        catch {
+            // best-effort compat; do not block outbound mapping
+        }
         const envelopePayload = buildGeminiRequestFromChat(chat, chat.metadata);
         try {
             const bridgePolicy = resolveBridgePolicy({ protocol: 'gemini-chat' });

package/dist/conversion/hub/tool-session-compat.d.ts

@@ -0,0 +1,26 @@
+import type { ChatEnvelope } from './types/chat-envelope.js';
+import type { AdapterContext } from './types/chat-envelope.js';
+type ToolHistoryStatus = 'ok' | 'error' | 'unknown';
+export interface ToolHistoryMessageRecord {
+    role: 'user' | 'assistant' | 'tool';
+    tool_use?: {
+        id: string;
+        name?: string;
+    };
+    tool_result?: {
+        id: string;
+        name?: string;
+        status: ToolHistoryStatus;
+    };
+    ts: string;
+}
+export interface ToolSessionHistory {
+    lastMessages: ToolHistoryMessageRecord[];
+    pendingToolUses: Record<string, {
+        name?: string;
+        ts: string;
+    }>;
+    updatedAt: string;
+}
+export declare function applyToolSessionCompat(chat: ChatEnvelope, ctx: AdapterContext): Promise<void>;
+export {};

package/dist/conversion/hub/tool-session-compat.js

@@ -0,0 +1,299 @@
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { extractSessionIdentifiersFromMetadata } from './pipeline/session-identifiers.js';
+const TOOL_HISTORY_ROOT = path.join(os.homedir(), '.routecodex', 'tool-history');
+const TOOL_UNKNOWN_PREFIX = '[RouteCodex] Tool call result unknown';
+function ensureArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function normalizeToolCallId(call) {
+    if (!call || typeof call !== 'object') {
+        return undefined;
+    }
+    const raw = call.id ??
+        call.tool_call_id ??
+        call.call_id;
+    if (typeof raw !== 'string') {
+        return undefined;
+    }
+    const trimmed = raw.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function normalizeToolMessageId(message) {
+    if (!message || typeof message !== 'object') {
+        return undefined;
+    }
+    const raw = message.tool_call_id ??
+        message.call_id ??
+        message.id;
+    if (typeof raw !== 'string') {
+        return undefined;
+    }
+    const trimmed = raw.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function findFirstNonToolIndex(messages, startIndex) {
+    let index = startIndex;
+    while (index < messages.length) {
+        const msg = messages[index];
+        if (!msg || typeof msg !== 'object') {
+            break;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role !== 'tool') {
+            break;
+        }
+        index += 1;
+    }
+    return index;
+}
+function findToolMessageIndex(messages, startIndex, callId) {
+    for (let i = startIndex; i < messages.length; i += 1) {
+        const msg = messages[i];
+        if (!msg || typeof msg !== 'object') {
+            continue;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role !== 'tool') {
+            continue;
+        }
+        const id = normalizeToolMessageId(msg);
+        if (id === callId) {
+            return i;
+        }
+    }
+    return -1;
+}
+function createUnknownToolMessage(callId, call) {
+    let name;
+    const fn = call && typeof call === 'object' ? call.function : undefined;
+    if (fn && typeof fn.name === 'string' && fn.name.trim().length) {
+        name = fn.name.trim();
+    }
+    const description = name ? `tool "${name}"` : 'tool call';
+    const content = `${TOOL_UNKNOWN_PREFIX}: ${description} (${callId}) did not produce a result in this session. Treat this tool as failed with unknown status.`;
+    const msg = {
+        role: 'tool',
+        tool_call_id: callId,
+        content
+    };
+    if (name) {
+        msg.name = name;
+    }
+    return msg;
+}
+function normalizeToolCallOrdering(messages) {
+    let index = 0;
+    while (index < messages.length) {
+        const message = messages[index];
+        if (!message || typeof message !== 'object') {
+            index += 1;
+            continue;
+        }
+        const role = String(message.role || '').toLowerCase();
+        if (role !== 'assistant') {
+            index += 1;
+            continue;
+        }
+        const toolCalls = ensureArray(message.tool_calls);
+        if (!toolCalls.length) {
+            index += 1;
+            continue;
+        }
+        let insertionIndex = index + 1;
+        for (const call of toolCalls) {
+            if (!call || typeof call !== 'object') {
+                continue;
+            }
+            const callId = normalizeToolCallId(call);
+            if (!callId) {
+                continue;
+            }
+            const existingIndex = findToolMessageIndex(messages, insertionIndex, callId);
+            if (existingIndex >= 0) {
+                if (existingIndex === insertionIndex) {
+                    insertionIndex += 1;
+                    continue;
+                }
+                const [relocated] = messages.splice(existingIndex, 1);
+                messages.splice(insertionIndex, 0, relocated);
+                insertionIndex += 1;
+                continue;
+            }
+            const placeholder = createUnknownToolMessage(callId, call);
+            messages.splice(insertionIndex, 0, placeholder);
+            insertionIndex += 1;
+        }
+        index = Math.max(index + 1, insertionIndex);
+    }
+}
+function sanitizeSessionId(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return '';
+    }
+    return trimmed.replace(/[^A-Za-z0-9_.-]/g, '_');
+}
+async function loadSessionHistory(sessionId) {
+    try {
+        const file = path.join(TOOL_HISTORY_ROOT, `${sanitizeSessionId(sessionId)}.json`);
+        if (!fsSync.existsSync(file)) {
+            return null;
+        }
+        const text = await fs.readFile(file, 'utf-8');
+        const parsed = JSON.parse(text);
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        parsed.lastMessages = Array.isArray(parsed.lastMessages) ? parsed.lastMessages : [];
+        parsed.pendingToolUses = parsed.pendingToolUses && typeof parsed.pendingToolUses === 'object'
+            ? parsed.pendingToolUses
+            : {};
+        parsed.updatedAt = typeof parsed.updatedAt === 'string' && parsed.updatedAt.trim().length
+            ? parsed.updatedAt
+            : new Date().toISOString();
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+async function persistSessionHistory(sessionId, history) {
+    try {
+        if (!fsSync.existsSync(TOOL_HISTORY_ROOT)) {
+            await fs.mkdir(TOOL_HISTORY_ROOT, { recursive: true });
+        }
+        const file = path.join(TOOL_HISTORY_ROOT, `${sanitizeSessionId(sessionId)}.json`);
+        const payload = JSON.stringify(history);
+        await fs.writeFile(file, payload, 'utf-8');
+    }
+    catch {
+        // history persistence must never block the main flow
+    }
+}
+function collectToolHistoryRecords(messages) {
+    const now = new Date().toISOString();
+    const records = [];
+    for (const msg of messages) {
+        if (!msg || typeof msg !== 'object') {
+            continue;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role === 'assistant') {
+            const toolCalls = ensureArray(msg.tool_calls);
+            for (const call of toolCalls) {
+                const id = normalizeToolCallId(call);
+                if (!id) {
+                    continue;
+                }
+                const fn = call.function;
+                const name = fn && typeof fn.name === 'string' && fn.name.trim().length
+                    ? fn.name.trim()
+                    : undefined;
+                records.push({
+                    role: 'assistant',
+                    tool_use: { id, name },
+                    ts: now
+                });
+            }
+            continue;
+        }
+        if (role === 'tool') {
+            const id = normalizeToolMessageId(msg);
+            if (!id) {
+                continue;
+            }
+            const rawName = msg.name;
+            const name = typeof rawName === 'string' && rawName.trim().length ? rawName.trim() : undefined;
+            const content = msg.content;
+            const status = typeof content === 'string' && content.startsWith(TOOL_UNKNOWN_PREFIX) ? 'unknown' : 'ok';
+            records.push({
+                role: 'tool',
+                tool_result: { id, name, status },
+                ts: now
+            });
+        }
+    }
+    return records;
+}
+function buildUpdatedHistory(existing, delta) {
+    const prevMessages = existing?.lastMessages ?? [];
+    const combined = [...prevMessages, ...delta];
+    const trimmed = combined.slice(-10);
+    const pending = {};
+    for (const entry of trimmed) {
+        if (entry.tool_use) {
+            pending[entry.tool_use.id] = {
+                name: entry.tool_use.name,
+                ts: entry.ts
+            };
+        }
+        if (entry.tool_result) {
+            delete pending[entry.tool_result.id];
+        }
+    }
+    return {
+        lastMessages: trimmed,
+        pendingToolUses: pending,
+        updatedAt: new Date().toISOString()
+    };
+}
+export async function applyToolSessionCompat(chat, ctx) {
+    if (!chat || !Array.isArray(chat.messages) || chat.messages.length === 0) {
+        return;
+    }
+    const entry = (ctx.entryEndpoint || '').toLowerCase();
+    if (!entry.includes('/v1/messages')) {
+        normalizeToolCallOrdering(chat.messages);
+        return;
+    }
+    normalizeToolCallOrdering(chat.messages);
+    const validCallIds = new Set();
+    for (const msg of chat.messages) {
+        if (!msg || typeof msg !== 'object') {
+            continue;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role !== 'assistant') {
+            continue;
+        }
+        const toolCalls = ensureArray(msg.tool_calls);
+        for (const call of toolCalls) {
+            const id = normalizeToolCallId(call);
+            if (id) {
+                validCallIds.add(id);
+            }
+        }
+    }
+    if (Array.isArray(chat.toolOutputs) && chat.toolOutputs.length) {
+        const filtered = chat.toolOutputs.filter((entry) => {
+            if (!entry || typeof entry !== 'object') {
+                return false;
+            }
+            const rawId = entry.tool_call_id ??
+                entry.call_id ??
+                entry.id;
+            if (typeof rawId !== 'string') {
+                return false;
+            }
+            const trimmed = rawId.trim();
+            return trimmed.length > 0 && validCallIds.has(trimmed);
+        });
+        chat.toolOutputs = filtered.length ? filtered : undefined;
+    }
+    const metadata = (chat.metadata || {});
+    const identifiers = extractSessionIdentifiersFromMetadata(metadata);
+    const sessionId = identifiers.sessionId;
+    if (!sessionId) {
+        return;
+    }
+    const history = await loadSessionHistory(sessionId);
+    const records = collectToolHistoryRecords(chat.messages);
+    if (!records.length && !history) {
+        return;
+    }
+    const updated = buildUpdatedHistory(history, records);
+    await persistSessionHistory(sessionId, updated);
+}

package/dist/conversion/responses/responses-openai-bridge.d.ts

@@ -48,7 +48,6 @@ export declare function buildResponsesRequestFromChat(payload: Record<string, un
     bridgeHistory?: BridgeInputBuildResult;
     systemInstruction?: string;
 }): BuildResponsesRequestResult;
-export declare function ensureResponsesApplyPatchArguments(input?: BridgeInputItem[]): void;
 export declare function buildResponsesPayloadFromChat(payload: unknown, context?: ResponsesRequestContext): Record<string, unknown> | unknown;
 export declare function extractRequestIdFromResponse(response: any): string | undefined;
 export { buildChatResponseFromResponses } from '../shared/responses-response-utils.js';

package/dist/conversion/responses/responses-openai-bridge.js

@@ -21,7 +21,6 @@ function isObject(v) {
 // --- Public bridge functions ---
 export function captureResponsesContext(payload, dto) {
     const preservedInput = cloneBridgeEntries(payload.input);
-    ensureResponsesApplyPatchArguments(preservedInput);
     ensureBridgeInstructions(payload);
     const context = {
         requestId: dto?.route?.requestId,
@@ -398,76 +397,6 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     ensureBridgeInstructions(out);
     return { request: out, originalSystemMessages };
 }
-export function ensureResponsesApplyPatchArguments(input) {
-    if (!Array.isArray(input) || !input.length) {
-        return;
-    }
-    for (const entry of input) {
-        if (!entry || typeof entry !== 'object')
-            continue;
-        const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : '';
-        if (type !== 'function_call')
-            continue;
-        const name = (typeof entry.name === 'string' && entry.name.trim()) ||
-            (entry.function && typeof entry.function === 'object' && typeof entry.function.name === 'string' && entry.function.name.trim()) ||
-            '';
-        if (name !== 'apply_patch')
-            continue;
-        let normalized;
-        try {
-            normalized = normalizeApplyPatchArguments(entry.arguments ?? entry.function?.arguments);
-        }
-        catch {
-            // best-effort: do not fail the whole request due to a malformed historical tool call
-            normalized = undefined;
-        }
-        if (normalized === undefined) {
-            continue;
-        }
-        entry.arguments = normalized;
-        if (entry.function && typeof entry.function === 'object') {
-            entry.function.arguments = normalized;
-        }
-    }
-}
-function normalizeApplyPatchArguments(source) {
-    let parsed;
-    if (typeof source === 'string' && source.trim()) {
-        try {
-            parsed = JSON.parse(source);
-        }
-        catch {
-            parsed = { patch: source };
-        }
-    }
-    else if (source && typeof source === 'object') {
-        parsed = { ...source };
-    }
-    else if (source === undefined) {
-        parsed = {};
-    }
-    else {
-        return typeof source === 'string' ? source : undefined;
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return typeof source === 'string' ? source : undefined;
-    }
-    const patchText = typeof parsed.patch === 'string' && parsed.patch.trim().length
-        ? parsed.patch
-        : typeof parsed.input === 'string' && parsed.input.trim().length
-            ? parsed.input
-            : undefined;
-    if (patchText) {
-        parsed.patch = patchText;
-        parsed.input = patchText;
-    }
-    try {
-        return JSON.stringify(parsed);
-    }
-    catch {
-        return typeof source === 'string' ? source : undefined;
-    }
-}
 function readToolCallIdStyleFromContext(ctx) {
     if (!ctx) {
         return undefined;

package/dist/conversion/shared/gemini-tool-utils.js

@@ -12,6 +12,14 @@ function cloneParameters(value) {
     if (isPlainRecord(value)) {
         const cloned = {};
         for (const [key, entry] of Object.entries(value)) {
+            // Gemini function_declarations.parameters only support a subset of JSON Schema.
+            // Drop meta/unsupported fields that cause INVALID_ARGUMENT, such as $schema/exclusiveMinimum.
+            if (typeof key === 'string') {
+                if (key.startsWith('$'))
+                    continue;
+                if (key === 'exclusiveMinimum' || key === 'exclusiveMaximum')
+                    continue;
+            }
             cloned[key] = cloneParameters(entry);
         }
         return cloned;