@jsonstudio/llms 0.6.1739 → 0.6.1890

package/dist/conversion/compat/actions/gemini-cli-request.js

@@ -520,7 +520,9 @@ function shouldEnableAntigravitySignature(adapterContext) {
     // Treat the first segment as the effective provider id for compatibility checks.
     const providerIdOrKey = providerIdOrKeyRaw.trim().toLowerCase();
     const effectiveProviderId = providerIdOrKey.split('.')[0] ?? '';
-    return effectiveProviderId === 'antigravity';
+    // Antigravity-Manager alignment: thoughtSignature compat applies to both Antigravity and Gemini CLI
+    // (both route to Google Gemini internals that enforce thoughtSignature on tool loops).
+    return effectiveProviderId === 'antigravity' || effectiveProviderId === 'gemini-cli';
 }
 function injectAntigravityThoughtSignature(requestNode, signature) {
     if (!signature || !signature.trim())

package/dist/conversion/compat/profiles/chat-deepseek-web.json

@@ -0,0 +1,18 @@
+{
+  "id": "chat:deepseek-web",
+  "protocol": "openai-chat",
+  "request": {
+    "mappings": [
+      { "action": "snapshot", "phase": "compat-pre" },
+      { "action": "deepseek_web_request" },
+      { "action": "snapshot", "phase": "compat-post" }
+    ]
+  },
+  "response": {
+    "mappings": [
+      { "action": "snapshot", "phase": "compat-pre" },
+      { "action": "deepseek_web_response" },
+      { "action": "snapshot", "phase": "compat-post" }
+    ]
+  }
+}

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

@@ -12,7 +12,8 @@ const ANTHROPIC_PARAMETER_KEYS = [
     'max_output_tokens',
     'metadata',
     'stream',
-    'tool_choice'
+    'tool_choice',
+    'thinking'
 ];
 const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
     'model',
@@ -27,10 +28,20 @@ const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
     'max_output_tokens',
     'metadata',
     'stream',
-    'tool_choice'
+    'tool_choice',
+    'thinking'
 ]);
 const PASSTHROUGH_METADATA_PREFIX = 'rcc_passthrough_';
 const PASSTHROUGH_PARAMETERS = ['tool_choice'];
+const RESPONSES_DROPPED_PARAMETER_KEYS = [
+    'prompt_cache_key',
+    'response_format',
+    'parallel_tool_calls',
+    'service_tier',
+    'truncation',
+    'include',
+    'store'
+];
 function ensureSemantics(chat) {
     if (!chat.semantics || typeof chat.semantics !== 'object') {
         chat.semantics = {};
@@ -88,6 +99,86 @@ function collectParameters(payload) {
     }
     return Object.keys(params).length ? params : undefined;
 }
+function mapReasoningEffortToAnthropicBudget(effort) {
+    const normalized = effort.trim().toLowerCase();
+    if (normalized === 'minimal' || normalized === 'low')
+        return 1024;
+    if (normalized === 'medium')
+        return 4096;
+    if (normalized === 'high')
+        return 8192;
+    return 4096;
+}
+function buildAnthropicThinkingFromReasoning(reasoning) {
+    if (reasoning === undefined || reasoning === null) {
+        return undefined;
+    }
+    if (typeof reasoning === 'boolean') {
+        if (!reasoning) {
+            return { type: 'disabled' };
+        }
+        return { type: 'enabled', budget_tokens: 4096 };
+    }
+    if (typeof reasoning === 'string') {
+        const normalized = reasoning.trim().toLowerCase();
+        if (!normalized.length) {
+            return undefined;
+        }
+        if (normalized === 'off' || normalized === 'none' || normalized === 'disabled' || normalized === 'false') {
+            return { type: 'disabled' };
+        }
+        return {
+            type: 'enabled',
+            budget_tokens: mapReasoningEffortToAnthropicBudget(normalized)
+        };
+    }
+    if (typeof reasoning === 'number' && Number.isFinite(reasoning)) {
+        const budget = Math.max(0, Math.floor(reasoning));
+        return budget <= 0
+            ? { type: 'disabled' }
+            : { type: 'enabled', budget_tokens: budget };
+    }
+    if (!isJsonObject(reasoning)) {
+        return undefined;
+    }
+    const node = reasoning;
+    const enabledRaw = node.enabled;
+    if (enabledRaw === false) {
+        return { type: 'disabled' };
+    }
+    const effortRaw = typeof node.effort === 'string'
+        ? node.effort
+        : typeof node.level === 'string'
+            ? node.level
+            : undefined;
+    const budgetRaw = typeof node.budget_tokens === 'number'
+        ? node.budget_tokens
+        : typeof node.budget === 'number'
+            ? node.budget
+            : typeof node.max_tokens === 'number'
+                ? node.max_tokens
+                : undefined;
+    if (typeof budgetRaw === 'number' && Number.isFinite(budgetRaw)) {
+        const budget = Math.max(0, Math.floor(budgetRaw));
+        return budget <= 0
+            ? { type: 'disabled' }
+            : { type: 'enabled', budget_tokens: budget };
+    }
+    if (typeof effortRaw === 'string' && effortRaw.trim().length) {
+        const normalized = effortRaw.trim().toLowerCase();
+        if (normalized === 'off' || normalized === 'none' || normalized === 'disabled') {
+            return { type: 'disabled' };
+        }
+        return {
+            type: 'enabled',
+            budget_tokens: mapReasoningEffortToAnthropicBudget(normalized)
+        };
+    }
+    if (enabledRaw === true) {
+        return { type: 'enabled', budget_tokens: 4096 };
+    }
+    return { type: 'enabled', budget_tokens: 4096 };
+}
 function cloneAnthropicSystemBlocks(value) {
     if (value === undefined || value === null) {
         return undefined;
@@ -98,6 +189,55 @@ function cloneAnthropicSystemBlocks(value) {
     }
     return blocks.map((entry) => jsonClone(entry));
 }
+function isResponsesOrigin(chat) {
+    const semantics = chat?.semantics;
+    if (semantics && semantics.responses && isJsonObject(semantics.responses)) {
+        return true;
+    }
+    const ctx = chat?.metadata && typeof chat.metadata === 'object'
+        ? chat.metadata.context
+        : undefined;
+    const protocol = typeof ctx?.providerProtocol === 'string' ? ctx.providerProtocol.trim().toLowerCase() : '';
+    if (protocol === 'openai-responses') {
+        return true;
+    }
+    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;
+}
+function appendDroppedFieldAudit(chat, options) {
+    appendMappingAudit(chat, {
+        bucket: 'dropped',
+        ...options
+    });
+}
+function appendLossyFieldAudit(chat, options) {
+    appendMappingAudit(chat, {
+        bucket: 'lossy',
+        ...options
+    });
+}
 export class AnthropicSemanticMapper {
     chatMapper = new ChatSemanticMapper();
     async toChat(format, ctx) {
@@ -215,6 +355,19 @@ export class AnthropicSemanticMapper {
         };
         const explicitEmptyTools = hasExplicitEmptyToolsSemantics(chat);
         const trimmedParameters = chat.parameters && typeof chat.parameters === 'object' ? chat.parameters : undefined;
+        const responsesOrigin = isResponsesOrigin(chat);
+        if (trimmedParameters && responsesOrigin) {
+            for (const field of RESPONSES_DROPPED_PARAMETER_KEYS) {
+                if (!Object.prototype.hasOwnProperty.call(trimmedParameters, field)) {
+                    continue;
+                }
+                appendDroppedFieldAudit(chat, {
+                    field,
+                    targetProtocol: 'anthropic-messages',
+                    reason: 'unsupported_semantics_no_equivalent'
+                });
+            }
+        }
         if (trimmedParameters) {
             for (const [key, value] of Object.entries(trimmedParameters)) {
                 if (ANTHROPIC_TOP_LEVEL_FIELDS.has(key) || key === 'stop') {
@@ -242,6 +395,17 @@ export class AnthropicSemanticMapper {
         if (baseRequest.max_output_tokens && !baseRequest.max_tokens) {
             baseRequest.max_tokens = baseRequest.max_output_tokens;
         }
+        const mappedThinking = buildAnthropicThinkingFromReasoning(trimmedParameters?.reasoning);
+        if (mappedThinking && baseRequest.thinking === undefined) {
+            baseRequest.thinking = mappedThinking;
+        }
+        if (responsesOrigin && trimmedParameters && Object.prototype.hasOwnProperty.call(trimmedParameters, 'reasoning')) {
+            appendLossyFieldAudit(chat, {
+                field: 'reasoning',
+                targetProtocol: 'anthropic-messages',
+                reason: 'normalized_to_anthropic_thinking_budget'
+            });
+        }
         // 出站阶段不再直接透传其它协议的 providerMetadata，避免跨协议打洞；
         // Anthropic 自身入口的 metadata 已在入站阶段通过 collectParameters/encodeMetadataPassthrough
         // 按白名单收集，这里仅依赖这些显式映射结果。

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

@@ -18,6 +18,15 @@ const GENERATION_CONFIG_KEYS = [
 ];
 const PASSTHROUGH_METADATA_PREFIX = 'rcc_passthrough_';
 const PASSTHROUGH_PARAMETERS = ['tool_choice'];
+const RESPONSES_DROPPED_PARAMETER_KEYS = [
+    'prompt_cache_key',
+    'response_format',
+    'parallel_tool_calls',
+    'service_tier',
+    'truncation',
+    'include',
+    'store'
+];
 // Ported from CLIProxyAPI v6.6.89 (antigravity auth constants)
 const ANTIGRAVITY_SYSTEM_INSTRUCTION = `You are Antigravity, a powerful agentic AI coding assistant designed by the Google DeepMind team working on Advanced Agentic Coding.
 You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.
@@ -662,6 +671,19 @@ function buildGeminiRequestFromChat(chat, metadata) {
     const isGeminiCliProvider = providerIdPrefix === 'gemini-cli';
     const requiresThoughtSignature = isAntigravityProvider || isGeminiCliProvider;
     const parameters = chat.parameters && typeof chat.parameters === 'object' ? chat.parameters : {};
+    const responsesOrigin = isResponsesOrigin(chat);
+    if (responsesOrigin) {
+        for (const field of RESPONSES_DROPPED_PARAMETER_KEYS) {
+            if (!Object.prototype.hasOwnProperty.call(parameters, field)) {
+                continue;
+            }
+            appendDroppedFieldAudit(chat, {
+                field,
+                targetProtocol: 'gemini-chat',
+                reason: 'unsupported_semantics_no_equivalent'
+            });
+        }
+    }
     const isAntigravityClaudeThinking = providerIdPrefix === 'antigravity' &&
         typeof parameters.model === 'string' &&
         String(parameters.model).includes('claude-sonnet-4-5-thinking');
@@ -901,6 +923,13 @@ function buildGeminiRequestFromChat(chat, metadata) {
         }
     }
     const generationConfig = buildGenerationConfigFromParameters(chat.parameters || {});
+    if (responsesOrigin && Object.prototype.hasOwnProperty.call(parameters, 'reasoning')) {
+        appendLossyFieldAudit(chat, {
+            field: 'reasoning',
+            targetProtocol: 'gemini-chat',
+            reason: 'normalized_to_gemini_thinking_config'
+        });
+    }
     if (semanticsNode?.generationConfig && isJsonObject(semanticsNode.generationConfig)) {
         for (const [key, value] of Object.entries(semanticsNode.generationConfig)) {
             if (generationConfig[key] !== undefined) {
@@ -1210,6 +1239,97 @@ function buildGenerationConfigFromParameters(parameters) {
             config[source] = value;
         }
     }
+    const reasoningRaw = parameters.reasoning;
+    const applyThinkingDisabled = () => {
+        config.thinkingConfig = {
+            includeThoughts: false,
+            thinkingBudget: 0
+        };
+    };
+    const applyThinkingEnabled = (budget) => {
+        const next = {
+            includeThoughts: true
+        };
+        if (typeof budget === 'number' && Number.isFinite(budget) && budget > 0) {
+            next.thinkingBudget = Math.floor(budget);
+        }
+        config.thinkingConfig = next;
+    };
+    if (typeof reasoningRaw === 'boolean') {
+        if (reasoningRaw) {
+            applyThinkingEnabled();
+        }
+        else {
+            applyThinkingDisabled();
+        }
+    }
+    else if (typeof reasoningRaw === 'string') {
+        const normalized = reasoningRaw.trim().toLowerCase();
+        if (normalized === 'off' || normalized === 'none' || normalized === 'disabled' || normalized === 'false') {
+            applyThinkingDisabled();
+        }
+        else if (normalized.length) {
+            const effortBudget = {
+                minimal: 1024,
+                low: 1024,
+                medium: 4096,
+                high: 8192
+            };
+            applyThinkingEnabled(effortBudget[normalized]);
+        }
+    }
+    else if (typeof reasoningRaw === 'number' && Number.isFinite(reasoningRaw)) {
+        if (reasoningRaw <= 0) {
+            applyThinkingDisabled();
+        }
+        else {
+            applyThinkingEnabled(reasoningRaw);
+        }
+    }
+    else if (isJsonObject(reasoningRaw)) {
+        const node = reasoningRaw;
+        const enabled = node.enabled;
+        if (enabled === false) {
+            applyThinkingDisabled();
+        }
+        else {
+            const effort = typeof node.effort === 'string'
+                ? node.effort.trim().toLowerCase()
+                : typeof node.level === 'string'
+                    ? node.level.trim().toLowerCase()
+                    : '';
+            const budget = typeof node.budget_tokens === 'number'
+                ? node.budget_tokens
+                : typeof node.budget === 'number'
+                    ? node.budget
+                    : typeof node.max_tokens === 'number'
+                        ? node.max_tokens
+                        : undefined;
+            if (typeof budget === 'number' && Number.isFinite(budget)) {
+                if (budget <= 0) {
+                    applyThinkingDisabled();
+                }
+                else {
+                    applyThinkingEnabled(budget);
+                }
+            }
+            else if (effort === 'off' || effort === 'none' || effort === 'disabled') {
+                applyThinkingDisabled();
+            }
+            else if (effort.length) {
+                const effortBudget = {
+                    minimal: 1024,
+                    low: 1024,
+                    medium: 4096,
+                    high: 8192
+                };
+                applyThinkingEnabled(effortBudget[effort]);
+            }
+            else if (enabled === true) {
+                applyThinkingEnabled();
+            }
+        }
+    }
     return config;
 }
 function mapChatRoleToGemini(role) {
@@ -1270,6 +1390,55 @@ function cloneAsJsonValue(value) {
         return String(value ?? '');
     }
 }
+function isResponsesOrigin(chat) {
+    const semantics = chat?.semantics;
+    if (semantics && semantics.responses && isJsonObject(semantics.responses)) {
+        return true;
+    }
+    const ctx = chat?.metadata && typeof chat.metadata === 'object'
+        ? chat.metadata.context
+        : undefined;
+    const protocol = typeof ctx?.providerProtocol === 'string' ? ctx.providerProtocol.trim().toLowerCase() : '';
+    if (protocol === 'openai-responses') {
+        return true;
+    }
+    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;
+}
+function appendDroppedFieldAudit(chat, options) {
+    appendMappingAudit(chat, {
+        bucket: 'dropped',
+        ...options
+    });
+}
+function appendLossyFieldAudit(chat, options) {
+    appendMappingAudit(chat, {
+        bucket: 'lossy',
+        ...options
+    });
+}
 export class GeminiSemanticMapper {
     async toChat(format, ctx) {
         const payload = (format.payload ?? {});

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

@@ -6,11 +6,17 @@ const RESPONSES_PARAMETER_KEYS = [
     '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',

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

@@ -15,6 +15,8 @@ import { applyGeminiWebSearchCompat } from '../../../compat/actions/gemini-web-s
 import { applyIflowWebSearchRequestTransform } from '../../../compat/actions/iflow-web-search.js';
 import { applyIflowToolTextFallback } from '../../../compat/actions/iflow-tool-text-fallback.js';
 import { unwrapIflowResponseBodyEnvelope } from '../../../compat/actions/iflow-response-body-unwrap.js';
+import { applyDeepSeekWebRequestTransform } from '../../../compat/actions/deepseek-web-request.js';
+import { applyDeepSeekWebResponseTransform } from '../../../compat/actions/deepseek-web-response.js';
 import { applyIflowKimiHistoryMediaPlaceholder } from '../../../compat/actions/iflow-kimi-history-media-placeholder.js';
 import { applyIflowKimiCliDefaults } from '../../../compat/actions/iflow-kimi-cli-defaults.js';
 import { fillIflowKimiThinkingReasoningContent } from '../../../compat/actions/iflow-kimi-thinking-reasoning-fill.js';
@@ -267,6 +269,16 @@ function applyMapping(root, mapping, state) {
                 replaceRoot(root, unwrapIflowResponseBodyEnvelope(root));
             }
             break;
+        case 'deepseek_web_request':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyDeepSeekWebRequestTransform(root, state.adapterContext));
+            }
+            break;
+        case 'deepseek_web_response':
+            if (state.direction === 'response') {
+                replaceRoot(root, applyDeepSeekWebResponseTransform(root, state.adapterContext));
+            }
+            break;
         case 'claude_thinking_tool_schema':
             if (state.direction === 'request') {
                 replaceRoot(root, applyClaudeThinkingToolSchemaCompat(root, state.adapterContext));

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

@@ -1,6 +1,7 @@
 const PROFILE_BY_PROVIDER_FAMILY = {
     iflow: 'chat:iflow',
     lmstudio: 'chat:lmstudio',
+    deepseek: 'chat:deepseek-web',
     antigravity: 'chat:gemini-cli',
     'gemini-cli': 'chat:gemini-cli'
 };

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

@@ -132,6 +132,10 @@ export type MappingInstruction = {
     models?: string[];
 } | {
     action: 'iflow_response_body_unwrap';
+} | {
+    action: 'deepseek_web_request';
+} | {
+    action: 'deepseek_web_response';
 } | {
     action: 'claude_thinking_tool_schema';
 } | {