modelmix 5.1.20 → 5.2.0

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

@@ -136,6 +136,7 @@ function createOpenAIProviders({
         }
     
         static processResponsesResponse(response) {
+            MixCustom.assertResponse(response.data);
             const message = MixOpenAIResponses.extractResponsesMessage(response.data);
             return {
                 message,
@@ -148,9 +149,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)

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.0",
   "description": "🧬 Reliable interface with automatic fallback for AI LLMs.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -77,7 +77,8 @@
     "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: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/benchmark/test/**/*.test.js plugins/rlm/test/**/*.test.js --timeout 10000 --require test/setup.js"
   }
 }

package/plugins/benchmark/index.d.ts

@@ -0,0 +1,112 @@
+import type { ChatMessage, ModelMixMixFlags, ModelMixPlugin, TokenUsage } from '../..';
+
+export interface BenchmarkOptions {
+  criteriaModel: string;
+  models: string[];
+  mix?: ModelMixMixFlags;
+}
+
+export interface BenchmarkModel {
+  id: string;
+  shortcut: string;
+  effort: number | null;
+  canonicalModel: string;
+}
+
+export interface BenchmarkCriterion {
+  id: string;
+  description: string;
+}
+
+export interface BenchmarkScore {
+  criterionId: string;
+  score: number;
+  justification: string;
+}
+
+export interface BenchmarkCallMetrics {
+  elapsedMs: number;
+  tokens: Partial<TokenUsage> | null;
+  cost: number | null;
+}
+
+export interface BenchmarkEvaluation {
+  judge: BenchmarkModel;
+  scores: BenchmarkScore[];
+  metrics: BenchmarkCallMetrics;
+}
+
+export interface BenchmarkCriterionAverage {
+  criterionId: string;
+  score: number | null;
+}
+
+export interface BenchmarkResult {
+  id: string;
+  shortcut: string;
+  effort: number | null;
+  canonicalModel: string;
+  response: string | null;
+  responseMetrics: BenchmarkCallMetrics | null;
+  evaluations: BenchmarkEvaluation[];
+  averages: BenchmarkCriterionAverage[] | null;
+  score: number | null;
+  evaluationCount: {
+    expected: number;
+    valid: number;
+  };
+}
+
+export interface BenchmarkErrorDetails {
+  name: string;
+  message: string;
+  code?: unknown;
+  statusCode?: unknown;
+  details?: unknown;
+}
+
+export interface BenchmarkError {
+  stage: 'response' | 'evaluation';
+  participant: string;
+  judge?: string;
+  error: BenchmarkErrorDetails;
+  metrics: BenchmarkCallMetrics;
+}
+
+export interface BenchmarkTokenTotals {
+  input?: number;
+  output?: number;
+  thinking?: number;
+  total?: number;
+  cached?: number;
+  cacheWrite?: number;
+  cacheWrite5m?: number;
+  cacheWrite1h?: number;
+  uncachedInput?: number;
+}
+
+export interface BenchmarkReport {
+  task: {
+    system: string;
+    messages: ChatMessage[];
+  };
+  criteria: {
+    model: BenchmarkModel;
+    items: BenchmarkCriterion[];
+    metrics: BenchmarkCallMetrics;
+  };
+  results: BenchmarkResult[];
+  errors: BenchmarkError[];
+  metrics: {
+    elapsedMs: number;
+    tokens: BenchmarkTokenTotals | null;
+    cost: number | null;
+    calls: {
+      attempted: number;
+      withTokens: number;
+      withCost: number;
+    };
+  };
+}
+
+export declare function benchmark(options: BenchmarkOptions): ModelMixPlugin;