modelmix 5.1.20 → 5.2.1

package/index.js

@@ -8,6 +8,7 @@ const log = require('lemonlog')('ModelMix');
 const Bottleneck = require('bottleneck');
 const path = require('path');
 const generateJsonSchema = require('./schema');
+const parseJsonResponse = require('./lib/parse-json-response');
 const { Client } = require("@modelcontextprotocol/sdk/client/index.js");
 const { StdioClientTransport } = require("@modelcontextprotocol/sdk/client/stdio.js");
 const { MCPToolsManager } = require('./mcp-tools');
@@ -47,6 +48,7 @@ let MixKimi;
 let MixAnthropic;
 let MixMiniMax;
 let MixMiMo;
+let MixDeepSeek;
 let MixPerplexity;
 let MixOllama;
 let MixGrok;
@@ -764,6 +766,10 @@ class ModelMix {
         return this;
     }
 
+    deepseekPro({ options = {}, config = {} } = {}) {
+        return this.attach('deepseek/deepseek-v4-pro-0813', new MixOpenRouter({ options, config }));
+    }
+
     deepseekV4Pro({ options = {}, config = {}, mix = { fireworks: true } } = {}) {
         mix = { ...this.mix, ...mix };
         if (mix.nvidia) this.attach('deepseek-ai/deepseek-v4-pro', new MixNVIDIA({ options, config }));
@@ -782,6 +788,14 @@ class ModelMix {
         return this;
     }
 
+    deepseekV41Flash({ options = {}, config = {}, mix = { deepseek: true } } = {}) {
+        mix = { ...this.mix, ...mix };
+        if (mix.deepseek) this.attach('deepseek-flash', new MixDeepSeek({ options, config }));
+        if (mix.fireworks) this.attach('accounts/fireworks/models/deepseek-v4p1-flash', new MixFireworks({ options, config }));
+        if (mix.openrouter) this.attach('deepseek/deepseek-v4.1-flash', new MixOpenRouter({ options, config }));
+        return this;
+    }
+
     GLM52({ options = {}, config = {}, mix = { together: true } } = {}) {
         mix = { ...this.mix, ...mix };
         if (mix.together) this.attach('zai-org/GLM-5.2', new MixTogether({ options, config }));
@@ -1000,7 +1014,13 @@ class ModelMix {
             }
         }
         const { message } = await this.execute({ options, config, systemSuffix, outputMode: 'json', signal });
-        const parsed = JSON.parse(this._extractBlock(message));
+        let parsed;
+        try {
+            parsed = parseJsonResponse(message);
+        } catch (error) {
+            if (!(error instanceof SyntaxError)) throw error;
+            parsed = JSON.parse(this._extractBlock(message));
+        }
         return isArrayWrap ? parsed.out : parsed;
     }
 
@@ -1292,6 +1312,7 @@ class ModelMix {
         const request = {
             system: this._renderSystem(config, {}, systemSuffix, templateContext),
             messages: clonePluginValue(preparedMessages),
+            tools: [],
             options: clonePluginValue({ ...this.options, ...options }),
             config: clonePluginValue(this._mergeRequestConfig(config)),
             outputMode
@@ -1363,15 +1384,34 @@ class ModelMix {
         templateContext
     }) {
         const provider = currentModel.provider;
+        const tools = pluginRequest?.tools.length ? {
+            ...this.tools,
+            local: [...(this.tools.local || []), ...pluginRequest.tools.map(entry => entry.tool)]
+        } : this.tools;
+        const toolOptions = provider.getOptionsTools(tools);
         const currentOptions = {
             ...this.options,
             messages: preparedMessages,
             ...provider.options,
-            ...provider.getOptionsTools(this.tools),
+            ...toolOptions,
             ...options,
             ...(pluginRequest?.options || {}),
             model: currentModel.key
         };
+        if (pluginRequest?.tools.length && currentOptions.tools !== toolOptions.tools) {
+            if (!Array.isArray(currentOptions.tools)) {
+                throw new TypeError('Request options.tools must be an array when using plugin tools.');
+            }
+            currentOptions.tools = [...(toolOptions.tools || []), ...currentOptions.tools];
+            const names = new Set();
+            for (const tool of currentOptions.tools) {
+                for (const definition of tool.functionDeclarations || [tool.function || tool]) {
+                    if (!definition.name) continue;
+                    if (names.has(definition.name)) throw new Error(`Duplicate tool name: ${definition.name}`);
+                    names.add(definition.name);
+                }
+            }
+        }
         const currentConfig = pluginRequest
             ? {
                 ...provider.config,
@@ -1471,24 +1511,28 @@ class ModelMix {
         }
     }
 
-    _enrichResultTokens(result, resolvedModelKey, elapsedMs) {
+    _enrichResultTokens(result, resolvedModelKey, elapsedMs, provider) {
         if (!result.tokens) return;
 
         const normalizedTokens = ModelMix.normalizeTokenUsage(result.tokens);
         const costBreakdown = ModelMix.calculateCostBreakdown(resolvedModelKey, normalizedTokens);
         const cacheMetrics = ModelMix.calculateCacheMetrics(resolvedModelKey, normalizedTokens);
+        const response = Array.isArray(result.response)
+            ? result.response.findLast(chunk => chunk.usage)
+            : result.response;
+        const reportedCost = provider instanceof MixOpenRouter ? response?.usage?.cost : undefined;
         result.tokens = {
             ...result.tokens,
             ...normalizedTokens,
             ...cacheMetrics,
-            cost: tokenUsage.hasModelPricing(resolvedModelKey) ? costBreakdown.total : 0,
+            cost: Number.isFinite(reportedCost) && reportedCost >= 0 ? reportedCost : costBreakdown.total,
             costBreakdown
         };
         const elapsedSec = elapsedMs / 1000;
         result.tokens.speed = elapsedSec > 0 ? Math.round(result.tokens.output / elapsedSec) : 0;
     }
 
-    async _continueToolCalls(result, pluginRequest, execution) {
+    async _continueToolCalls(result, pluginRequest, execution, pluginTools) {
         const originalMessages = this.messages;
         const toolMessages = pluginRequest
             ? clonePluginValue(pluginRequest.messages)
@@ -1516,7 +1560,7 @@ class ModelMix {
         if (!result.assistantMessage) {
             toolMessages.push({ role: 'assistant', content: null, tool_calls: result.toolCalls });
         }
-        const toolResults = await this.processToolCalls(result.toolCalls, execution.signal);
+        const toolResults = await this.processToolCalls(result.toolCalls, execution.signal, pluginTools);
         for (const toolResult of toolResults) {
             toolMessages.push({
                 role: 'tool',
@@ -1626,6 +1670,23 @@ class ModelMix {
         this._requirePreparedMessages(preparedMessages);
 
         const finalConfig = pluginRequest ? pluginRequest.config : this._mergeRequestConfig(config);
+        const pluginTools = pluginRequest ? new MCPToolsManager() : null;
+        if (pluginRequest) {
+            if (!Array.isArray(pluginRequest.tools)) {
+                throw new TypeError('Plugin request tools must be an array.');
+            }
+            const names = new Set(Object.values(this.tools).flat().map(tool => tool.name));
+            for (const entry of pluginRequest.tools) {
+                if (!isPlainObject(entry) || !isPlainObject(entry.tool)) {
+                    throw new TypeError('Plugin request tools must contain { tool, callback }.');
+                }
+                if (names.has(entry.tool.name)) {
+                    throw new Error(`Duplicate tool name: ${entry.tool.name}`);
+                }
+                pluginTools.registerTool(entry.tool, entry.callback);
+                names.add(entry.tool.name);
+            }
+        }
         const modelsToTry = this.models.map((model, index) => ({ model, index }));
         if (finalConfig.roundRobin && this.models.length > 1) {
             this.models.push(this.models.shift());
@@ -1659,7 +1720,7 @@ class ModelMix {
                     providerAttempt.resolvedModelKey,
                     signal
                 );
-                this._enrichResultTokens(result, providerAttempt.resolvedModelKey, elapsedMs);
+                this._enrichResultTokens(result, providerAttempt.resolvedModelKey, elapsedMs, providerAttempt.provider);
 
                 if (result.toolCalls && result.toolCalls.length > 0) {
                     return this._continueToolCalls(result, pluginRequest, {
@@ -1671,7 +1732,7 @@ class ModelMix {
                         _templateContext: templateContext,
                         _executionMetadata: executionMetadata,
                         _pluginsApplied: pluginsApplied
-                    });
+                    }, pluginTools);
                 }
 
                 this._logProviderSuccess(result, providerAttempt.currentConfig);
@@ -1747,7 +1808,7 @@ class ModelMix {
         if (isRootExecution) this._commitTemplateRenderContext(templateContext);
         return result;
     }
-    async processToolCalls(toolCalls, signal) {
+    async processToolCalls(toolCalls, signal, pluginTools) {
         assertAbortSignal(signal);
         const result = []
 
@@ -1780,8 +1841,9 @@ class ModelMix {
                 }
 
                 // Verificar si es una herramienta local registrada
-                if (this.mcpToolsManager.hasTool(toolName)) {
-                    const response = await this.mcpToolsManager.executeTool(toolName, toolArgs, signal);
+                if (pluginTools?.hasTool(toolName) || this.mcpToolsManager.hasTool(toolName)) {
+                    const manager = pluginTools?.hasTool(toolName) ? pluginTools : this.mcpToolsManager;
+                    const response = await manager.executeTool(toolName, toolArgs, signal);
                     throwIfAborted(signal);
                     result.push({
                         name: toolName,
@@ -1926,6 +1988,7 @@ class ModelMix {
     MixAnthropic,
     MixMiniMax,
     MixMiMo,
+    MixDeepSeek,
     MixPerplexity,
     MixOllama,
     MixGrok,
@@ -1943,4 +2006,4 @@ class ModelMix {
     log
 }));
 
-module.exports = { MixCustom, ModelMix, ModerationMix, MixModeration, MixAnthropic, MixKimi, MixMiniMax, MixMiMo, MixOpenAI, MixOpenAIResponses, MixOpenAIModeration, MixOpenAIWebSocket, MixOpenRouter, MixPerplexity, MixOllama, MixLambda, MixLMStudio, MixGroq, MixTogether, MixGrok, MixCerebras, MixGoogle, MixFireworks, MixNVIDIA, normalizeEffort, applyUnifiedEffort, resolveProviderFamily };
+module.exports = { MixCustom, ModelMix, ModerationMix, MixModeration, MixAnthropic, MixKimi, MixMiniMax, MixMiMo, MixDeepSeek, MixOpenAI, MixOpenAIResponses, MixOpenAIModeration, MixOpenAIWebSocket, MixOpenRouter, MixPerplexity, MixOllama, MixLambda, MixLMStudio, MixGroq, MixTogether, MixGrok, MixCerebras, MixGoogle, MixFireworks, MixNVIDIA, normalizeEffort, applyUnifiedEffort, resolveProviderFamily };

package/lib/model-chain.js

@@ -15,7 +15,7 @@ const CHAIN_MODEL_SHORTCUTS = new Set([
     'hermes470b', 'hermes4405b', 'hermes3',
     'kimiK26', 'kimiK27Code', 'kimiK3', 'kimiK25',
     'minimaxM27', 'minimaxM3', 'mimo25', 'mimo25pro',
-    'deepseekV4Pro', 'deepseekV4Flash', 'GLM52', 'GLM53', 'GLM53Flash'
+    'deepseekV4Pro', 'deepseekPro', 'deepseekV4Flash', 'deepseekV41Flash', 'GLM52', 'GLM53', 'GLM53Flash'
 ]);
 
 function parseChainModels(modelSpecs) {

package/lib/parse-json-response.js

@@ -0,0 +1,14 @@
+function parseJsonResponse(message) {
+    try {
+        return JSON.parse(message);
+    } catch (error) {
+        if (!(error instanceof SyntaxError) || typeof message !== 'string') throw error;
+        const text = message.trim();
+        const fenced = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+        if (fenced) return JSON.parse(fenced[1]);
+        if (text.endsWith('```')) return JSON.parse(text.slice(0, -3));
+        throw error;
+    }
+}
+
+module.exports = parseJsonResponse;

package/lib/providers/anthropic.js

@@ -278,9 +278,11 @@ function createAnthropicProviders({ ModelMix, MixCustom, log }) {
                 );
                 const input = (data.usage.input_tokens || 0) + cached + cacheWrite;
                 const output = data.usage.output_tokens || 0;
+                const thinking = data.usage.output_tokens_details?.thinking_tokens || 0;
                 return ModelMix.normalizeTokenUsage({
                     input,
-                    output,
+                    output: output - thinking,
+                    thinking,
                     total: input + output,
                     cached,
                     cacheWrite,

package/lib/providers/base.js

@@ -146,6 +146,10 @@ function createBaseProviders({ ModelMix }) {
                 let raw = [];
                 let message = '';
                 let buffer = '';
+                let completed = false;
+                let chatCompletion = false;
+                let usage = {};
+                let usageMetadata;
     
                 response.data.on('data', chunk => {
                     buffer += chunk.toString();
@@ -156,39 +160,75 @@ function createBaseProviders({ ModelMix }) {
                         buffer = buffer.slice(boundary + 1);
     
                         const firstBraceIndex = dataStr.indexOf('{');
-                        if (dataStr === '[DONE]' || firstBraceIndex === -1) continue;
+                        if (dataStr === 'data: [DONE]' || dataStr === '[DONE]') {
+                            completed = true;
+                            continue;
+                        }
+                        if (firstBraceIndex === -1) continue;
     
                         const jsonStr = dataStr.slice(firstBraceIndex);
                         try {
                             const data = JSON.parse(jsonStr);
+                            MixCustom.assertResponse(data);
+                            chatCompletion ||= Array.isArray(data.choices);
+                            completed ||= Boolean(data.choices?.[0]?.finish_reason);
+                            raw.push(data);
+                            usage = { ...usage, ...data.message?.usage, ...data.usage };
+                            if (data.usageMetadata) usageMetadata = data.usageMetadata;
+                            const delta = this.extractDelta(data);
+                            message += delta;
                             if (this.streamCallback) {
-                                const delta = this.extractDelta(data);
-                                message += delta;
                                 this.streamCallback({ response: data, message, delta });
-                                raw.push(data);
                             }
                         } catch (error) {
-                            console.error('Error parsing JSON:', error);
+                            reject(error);
+                            response.data.destroy();
+                            return;
                         }
                     }
                 });
     
-                response.data.on('end', () => resolve({
-                    response: raw,
-                    message: message.trim(),
-                    toolCalls: [],
-                    think: null,
-                    tokens: raw.length > 0 ? MixCustom.extractTokens(raw[raw.length - 1]) : { input: 0, output: 0, total: 0, cached: 0 }
-                }));
+                response.data.on('end', () => {
+                    if (chatCompletion && !completed) {
+                        reject(MixCustom.responseError(raw.at(-1), 'Provider stream ended without completing.'));
+                        return;
+                    }
+                    resolve({
+                        response: raw,
+                        message: message.trim(),
+                        toolCalls: [],
+                        think: null,
+                        tokens: this.constructor.extractTokens({ usage, usageMetadata })
+                    });
+                });
                 response.data.on('error', reject);
             });
         }
     
         extractDelta(data) {
-            return data.choices[0].delta.content;
+            return data.choices?.[0]?.delta?.content || '';
+        }
+
+        static responseError(data, message, statusCode = 502) {
+            const error = new Error(message);
+            error.statusCode = statusCode;
+            error.details = data;
+            return error;
+        }
+
+        static assertResponse(data) {
+            const failure = data?.error || data?.choices?.find(choice => choice.error)?.error;
+            if (failure || data?.choices?.some(choice => choice.finish_reason === 'error') || data?.status === 'failed') {
+                throw MixCustom.responseError(
+                    data,
+                    failure?.message || 'Provider failed to complete the response.',
+                    Number.isInteger(failure?.code) && failure.code >= 400 && failure.code <= 599 ? failure.code : 502
+                );
+            }
         }
     
         static extractMessage(data) {
+            MixCustom.assertResponse(data);
             const choice = data?.choices?.[0] || {};
             const messageObj = choice.message || {};
             const finishReason = choice.finish_reason;
@@ -254,9 +294,12 @@ function createBaseProviders({ ModelMix }) {
         static extractTokens(data) {
             // OpenAI/Groq/Together/Lambda/Cerebras/Fireworks format
             if (data.usage) {
+                const output = data.usage.completion_tokens || 0;
+                const thinking = data.usage.completion_tokens_details?.reasoning_tokens || 0;
                 return ModelMix.normalizeTokenUsage({
                     input: data.usage.prompt_tokens || 0,
-                    output: data.usage.completion_tokens || 0,
+                    output: output - thinking,
+                    thinking,
                     total: data.usage.total_tokens,
                     cached: ModelMix.extractCacheTokens(data.usage),
                     cacheWrite: ModelMix.extractCacheWriteTokens(data.usage)
@@ -266,11 +309,16 @@ function createBaseProviders({ ModelMix }) {
         }
     
         processResponse(response) {
+            const message = MixCustom.extractMessage(response.data);
+            const toolCalls = MixCustom.extractToolCalls(response.data);
+            if (!message && toolCalls.length === 0 && response.data?.choices?.[0]?.finish_reason !== 'length') {
+                throw MixCustom.responseError(response.data, 'Provider returned no text or tool calls without completing a usable response.');
+            }
             return {
-                message: MixCustom.extractMessage(response.data),
+                message,
                 think: MixCustom.extractThink(response.data),
-                toolCalls: MixCustom.extractToolCalls(response.data),
-                tokens: MixCustom.extractTokens(response.data),
+                toolCalls,
+                tokens: this.constructor.extractTokens(response.data),
                 response: response.data
             }
         }

package/lib/providers/google.js

@@ -61,6 +61,12 @@ function createGoogleProviders({ ModelMix, MixCustom }) {
                     }
                 }
     
+                if (typeof message.content === 'string') {
+                    return {
+                        role: message.role === 'assistant' ? 'model' : 'user',
+                        parts: [{ text: message.content }]
+                    };
+                }
                 if (!Array.isArray(message.content)) return message;
                 const role = (message.role === 'assistant' || message.role === 'tool') ? 'model' : 'user'
     
@@ -164,7 +170,10 @@ function createGoogleProviders({ ModelMix, MixCustom }) {
                 options.tools.some(t => t.functionDeclarations && t.functionDeclarations.length > 0);
     
             if (!hasTools) {
-                generationConfig.responseMimeType = "text/plain";
+                generationConfig.responseMimeType = options.response_format?.type === 'json_object'
+                    || options.response_format?.type === 'json_schema'
+                    ? 'application/json'
+                    : 'text/plain';
             }
     
             const payload = {
@@ -230,7 +239,9 @@ function createGoogleProviders({ ModelMix, MixCustom }) {
         }
     
         static extractMessage(data) {
-            return data.candidates?.[0]?.content?.parts?.[0]?.text;
+            const parts = data.candidates?.[0]?.content?.parts;
+            const textParts = parts?.filter(part => !part.thought && typeof part.text === 'string');
+            return textParts?.length ? textParts.map(part => part.text).join('') : undefined;
         }
     
         static extractTokens(data) {

package/lib/providers/openai-compatible.js

@@ -5,6 +5,29 @@ const {
 const { requireProviderApiKey } = require('../provider-api-key');
 
 function createCompatibleProviders({ MixCustom, MixOpenAI }) {
+    class MixDeepSeek extends MixOpenAI {
+        getDefaultConfig(customConfig) {
+            const apiKey = requireProviderApiKey(customConfig, 'DEEPSEEK_API_KEY', 'DeepSeek');
+
+            return MixCustom.prototype.getDefaultConfig.call(this, {
+                url: 'https://api.deepseek.com/chat/completions',
+                apiKey,
+                ...customConfig
+            });
+        }
+
+        extractDelta(data) {
+            return data?.choices?.[0]?.delta?.content || '';
+        }
+
+        processResponse(response) {
+            return {
+                ...super.processResponse(response),
+                assistantMessage: response.data?.choices?.[0]?.message
+            };
+        }
+    }
+
     class MixMiniMax extends MixOpenAI {
         getDefaultConfig(customConfig) {
             const apiKey = requireProviderApiKey(customConfig, 'MINIMAX_API_KEY', 'MiniMax');
@@ -124,6 +147,18 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
     }
     
     class MixGrok extends MixOpenAI {
+        static extractTokens(data) {
+            if (!data.usage) return MixCustom.extractTokens(data);
+            return MixCustom.extractTokens({
+                ...data,
+                usage: {
+                    ...data.usage,
+                    completion_tokens: (data.usage.completion_tokens || 0)
+                        + (data.usage.completion_tokens_details?.reasoning_tokens || 0)
+                }
+            });
+        }
+
         getDefaultConfig(customConfig) {
             const apiKey = requireProviderApiKey(customConfig, 'XAI_API_KEY', 'Grok');
     
@@ -292,6 +327,7 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
     }
 
     return {
+        MixDeepSeek,
         MixMiniMax,
         MixMiMo,
         MixPerplexity,

package/lib/providers/openai.js

@@ -54,6 +54,17 @@ function createOpenAIProviders({
     
             if (options.reasoning_effort) request.reasoning = { effort: options.reasoning_effort };
             if (options.verbosity) request.text = { verbosity: options.verbosity };
+            if (options.tools !== undefined) {
+                request.tools = options.tools.map(tool => tool.type === 'function' && tool.function
+                    ? { type: 'function', strict: false, ...tool.function }
+                    : tool);
+            }
+            if (options.tool_choice !== undefined) {
+                request.tool_choice = options.tool_choice?.function
+                    ? { type: 'function', name: options.tool_choice.function.name }
+                    : options.tool_choice;
+            }
+            if (options.parallel_tool_calls !== undefined) request.parallel_tool_calls = options.parallel_tool_calls;
     
             if (options.response_format) {
                 const rf = options.response_format;
@@ -136,11 +147,27 @@ function createOpenAIProviders({
         }
     
         static processResponsesResponse(response) {
+            MixCustom.assertResponse(response.data);
             const message = MixOpenAIResponses.extractResponsesMessage(response.data);
+            const toolCalls = (response.data.output || [])
+                .filter(item => item.type === 'function_call')
+                .map(item => ({
+                    id: item.call_id,
+                    type: 'function',
+                    function: { name: item.name, arguments: item.arguments }
+                }));
             return {
                 message,
                 think: null,
-                toolCalls: [],
+                toolCalls,
+                ...(toolCalls.length > 0 && {
+                    assistantMessage: {
+                        role: 'assistant',
+                        content: message || null,
+                        tool_calls: toolCalls,
+                        _responsesOutput: response.data.output
+                    }
+                }),
                 tokens: MixOpenAIResponses.extractResponsesTokens(response.data),
                 response: response.data
             };
@@ -148,9 +175,12 @@ function createOpenAIProviders({
     
         static extractResponsesTokens(data) {
             if (data.usage) {
+                const output = data.usage.output_tokens || 0;
+                const thinking = data.usage.output_tokens_details?.reasoning_tokens || 0;
                 return ModelMix.normalizeTokenUsage({
                     input: data.usage.input_tokens || 0,
-                    output: data.usage.output_tokens || 0,
+                    output: output - thinking,
+                    thinking,
                     total: data.usage.total_tokens,
                     cached: ModelMix.extractCacheTokens(data.usage),
                     cacheWrite: ModelMix.extractCacheWriteTokens(data.usage)
@@ -175,7 +205,14 @@ function createOpenAIProviders({
     
             for (const message of messages) {
                 if (!message || !message.role) continue;
-                if (message.tool_calls || message.role === 'tool') continue;
+                if (message.role === 'assistant' && Array.isArray(message._responsesOutput)) {
+                    mapped.push(...message._responsesOutput);
+                    continue;
+                }
+                if (message.role === 'tool') {
+                    mapped.push({ type: 'function_call_output', call_id: message.tool_call_id, output: message.content });
+                    continue;
+                }
     
                 const content = [];
                 const isAssistant = message.role === 'assistant';
@@ -230,11 +267,18 @@ function createOpenAIProviders({
                     }
                 }
     
-                if (content.length === 0) continue;
-                mapped.push({
-                    role: message.role,
-                    content
-                });
+                if (content.length > 0) {
+                    mapped.push({ role: message.role, content });
+                }
+                for (const call of message.tool_calls || []) {
+                    const args = call.function ? call.function.arguments : call.input ?? call.arguments ?? {};
+                    mapped.push({
+                        type: 'function_call',
+                        call_id: call.id,
+                        name: call.function ? call.function.name : call.name,
+                        arguments: typeof args === 'string' ? args : JSON.stringify(args)
+                    });
+                }
             }
     
             return mapped;

package/lib/token-usage.js

@@ -96,6 +96,10 @@ const MODEL_PRICING = {
     'deepseek-ai/DeepSeek-V4-Flash': { input: 0.14, output: 0.28 },
     'deepseek-ai/DeepSeek-V4-Pro': { input: 2.10, output: 4.40 },
     'deepseek/deepseek-v4-flash': { input: 0.09, output: 0.18 },
+    'deepseek/deepseek-v4.1-flash': { input: 0.15, cachedInput: 0.015, output: 0.60 },
+    'accounts/fireworks/models/deepseek-v4p1-flash': { input: 0.22, cachedInput: 0.007, output: 0.66 },
+    'deepseek-flash': { input: 0.30, cachedInput: 0.006, output: 1.20 },
+    'deepseek/deepseek-v4-pro-0813': { input: 0.5808, cachedInput: 0.05808, output: 1.7424 },
     'accounts/fireworks/models/glm-4p7': { input: 0.55, output: 2.19 },
     'zai-org/GLM-5.2': { input: 1.40, cachedInput: 0.26, output: 4.40 },
     'accounts/fireworks/models/glm-5p2': { input: 1.40, cachedInput: 0.14, output: 4.40 },
@@ -322,6 +326,7 @@ function getModelPricing(modelKey) {
 function extractCacheTokens(usage = {}) {
     return usage.input_tokens_details?.cached_tokens
         ?? usage.prompt_tokens_details?.cached_tokens
+        ?? usage.prompt_cache_hit_tokens
         ?? usage.cache_read_input_tokens
         ?? usage.cachedContentTokenCount
         ?? usage.cached_content_token_count

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "5.1.20",
+  "version": "5.2.1",
   "description": "🧬 Reliable interface with automatic fallback for AI LLMs.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -56,6 +56,7 @@
     "bottleneck": "^2.19.5",
     "ejs": "6.0.1",
     "file-type": "^21.3.4",
+    "js-yaml": "4.3.2",
     "lemonlog": "^1.2.2",
     "ws": "^8.21.1"
   },
@@ -77,7 +78,9 @@
     "test:live.mcp": "mocha test/live.mcp.js --timeout 60000 --require test/setup.js",
     "test:tokens": "mocha test/tokens.test.js --timeout 10000 --require test/setup.js",
     "test:plugins": "mocha test/plugins.test.js --timeout 10000 --require test/setup.js",
+    "test:skills": "mocha plugins/skills/test/**/*.test.js --timeout 10000 --require test/setup.js",
+    "test:benchmark": "mocha plugins/benchmark/test/**/*.test.js --timeout 10000 --require test/setup.js",
     "test:rlm": "mocha plugins/rlm/test/**/*.test.js --timeout 10000 --require test/setup.js",
-    "test:offline": "mocha test/abort.test.js test/json.test.js test/fallback.test.js test/templates.test.js test/images.test.js test/bottleneck.test.js test/tokens.test.js test/history.test.js test/anthropic.test.js test/effort.test.js test/grok.test.js test/moderation.test.js test/plugins.test.js plugins/rlm/test/**/*.test.js --timeout 10000 --require test/setup.js"
+    "test:offline": "mocha test/abort.test.js test/json.test.js test/fallback.test.js test/templates.test.js test/images.test.js test/bottleneck.test.js test/tokens.test.js test/history.test.js test/anthropic.test.js test/effort.test.js test/grok.test.js test/google.test.js test/moderation.test.js test/plugins.test.js plugins/skills/test/**/*.test.js plugins/benchmark/test/**/*.test.js plugins/rlm/test/**/*.test.js --timeout 10000 --require test/setup.js"
   }
 }