modelmix 5.1.10 → 5.1.15

package/lib/abort-signal.js

@@ -0,0 +1,57 @@
+function assertAbortSignal(signal) {
+    if (signal === undefined) return;
+    if (!(signal instanceof AbortSignal)) {
+        throw new TypeError('signal must be an AbortSignal.');
+    }
+    signal.throwIfAborted();
+}
+
+function assertNoStoredSignal(value, label) {
+    if (value && Object.prototype.hasOwnProperty.call(value, 'signal')) {
+        throw new TypeError(`${label}.signal is not supported; pass the AbortSignal to the execution method.`);
+    }
+}
+
+function throwIfAborted(signal) {
+    if (signal) signal.throwIfAborted();
+}
+
+function validateProviderExecution(provider, { config, options, signal }) {
+    assertAbortSignal(signal);
+    assertNoStoredSignal(provider.config, 'provider.config');
+    assertNoStoredSignal(provider.options, 'provider.options');
+    assertNoStoredSignal(config, 'config');
+    assertNoStoredSignal(options, 'options');
+}
+
+function raceWithSignal(promise, signal) {
+    if (!signal) return promise;
+    throwIfAborted(signal);
+    let onAbort;
+    const aborted = new Promise((_, reject) => {
+        onAbort = () => reject(signal.reason);
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+    return Promise.race([promise, aborted]).finally(() => {
+        signal.removeEventListener('abort', onAbort);
+    });
+}
+
+function sleepWithSignal(ms, signal) {
+    if (!signal) return new Promise(resolve => setTimeout(resolve, ms));
+    throwIfAborted(signal);
+    let timeout;
+    const sleep = new Promise(resolve => {
+        timeout = setTimeout(resolve, ms);
+    });
+    return raceWithSignal(sleep, signal).finally(() => clearTimeout(timeout));
+}
+
+module.exports = {
+    assertAbortSignal,
+    assertNoStoredSignal,
+    raceWithSignal,
+    sleepWithSignal,
+    throwIfAborted,
+    validateProviderExecution
+};

package/lib/model-chain.js

@@ -5,12 +5,12 @@ const CHAIN_MODEL_SHORTCUTS = new Set([
     'gpt51', 'gpt52', 'gpt54', 'gpt54mini', 'gpt54nano', 'gpt54pro',
     'gpt55', 'gpt55pro', 'gpt56sol', 'gpt56terra', 'gpt56luna',
     'gptRealtime', 'gptRealtimeMini', 'gpt53codex', 'gpt53chat', 'gptOss',
-    'fable50', 'fable5', 'opus50', 'opus5', 'opus48', 'opus47', 'opus46',
+    'fable51', 'fable50', 'fable5', 'opus50', 'opus5', 'opus48', 'opus47', 'opus46',
     'sonnet50', 'sonnet5', 'sonnet46', 'sonnet45', 'haiku45',
     'gemini31pro', 'gemini37flash', 'gemini36flash', 'gemini35flash',
     'gemini35flashLite', 'gemini31flashLite', 'sonarPro', 'sonar',
     'grok46', 'grok45', 'grok43', 'grok420multiAgent', 'grok420',
-    'museGlimmer30b',
+    'museGlimmer30b', 'museSpark12Contributor',
     'qwen35397b', 'qwen36plus', 'qwen37plus', 'qwen38max', 'qwen3827b', 'qwen38flash',
     'hermes470b', 'hermes4405b', 'hermes3',
     'kimiK26', 'kimiK27Code', 'kimiK3', 'kimiK25',

package/lib/provider-api-key.js

@@ -0,0 +1,9 @@
+function requireProviderApiKey(customConfig, environmentVariable, providerName) {
+    const apiKey = customConfig.apiKey || process.env[environmentVariable];
+    if (!apiKey) {
+        throw new Error(`${providerName} API key not found. Please provide it in config or set ${environmentVariable} environment variable.`);
+    }
+    return apiKey;
+}
+
+module.exports = { requireProviderApiKey };

package/lib/providers/anthropic.js

@@ -4,6 +4,25 @@ const {
     stripContentCacheMetadata,
     hasNeutralCacheBreakpoint
 } = require('../content-cache');
+const { requireProviderApiKey } = require('../provider-api-key');
+
+function rejectsAnthropicSamplingParams(model = '') {
+    const id = String(model).toLowerCase();
+    if (!id.includes('claude')) return false;
+    if (id.includes('mythos') || id.includes('fable')) return true;
+
+    const opus = id.match(/claude-opus-(\d+)(?:-(\d+))?/);
+    if (opus) {
+        const major = Number(opus[1]);
+        const minor = opus[2] !== undefined ? Number(opus[2]) : 0;
+        return major > 4 || (major === 4 && minor >= 7);
+    }
+
+    const sonnet = id.match(/claude-sonnet-(\d+)/);
+    if (sonnet) return Number(sonnet[1]) >= 5;
+
+    return false;
+}
 
 function createAnthropicProviders({ ModelMix, MixCustom, log }) {
     class MixAnthropic extends MixCustom {
@@ -30,28 +49,11 @@ function createAnthropicProviders({ ModelMix, MixCustom, log }) {
          * See: https://platform.claude.com/docs/en/about-claude/models/migration-guide
          */
         static rejectsSamplingParams(model = '') {
-            const id = String(model).toLowerCase();
-            if (!id.includes('claude')) return false;
-            if (id.includes('mythos') || id.includes('fable')) return true;
-    
-            const opus = id.match(/claude-opus-(\d+)(?:-(\d+))?/);
-            if (opus) {
-                const major = Number(opus[1]);
-                const minor = opus[2] !== undefined ? Number(opus[2]) : 0;
-                return major > 4 || (major === 4 && minor >= 7);
-            }
-    
-            const sonnet = id.match(/claude-sonnet-(\d+)/);
-            if (sonnet) return Number(sonnet[1]) >= 5;
-    
-            return false;
+            return rejectsAnthropicSamplingParams(model);
         }
     
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.ANTHROPIC_API_KEY;
-            if (!apiKey) {
-                throw new Error('Anthropic API key not found. Please provide it in config or set ANTHROPIC_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'ANTHROPIC_API_KEY', 'Anthropic');
     
             return super.getDefaultConfig({
                 url: 'https://api.anthropic.com/v1/messages',
@@ -60,7 +62,7 @@ function createAnthropicProviders({ ModelMix, MixCustom, log }) {
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
     
             delete options.response_format;
     
@@ -83,7 +85,7 @@ function createAnthropicProviders({ ModelMix, MixCustom, log }) {
             options.system = config.system;
     
             try {
-                return await super.create({ config: requestConfig, options });
+                return await super.create({ config: requestConfig, options, signal });
             } catch (error) {
                 // Log the error details for debugging
                 if (error.response && error.response.data) {
@@ -334,4 +336,4 @@ function createAnthropicProviders({ ModelMix, MixCustom, log }) {
     return { MixAnthropic };
 }
 
-module.exports = createAnthropicProviders;
+module.exports = { createAnthropicProviders, rejectsAnthropicSamplingParams };

package/lib/providers/base.js

@@ -11,10 +11,19 @@ const {
     stripContentCacheMetadata
 } = require('../content-cache');
 const { configForDebug, redactSecret } = require('../provider-debug');
+const { requireProviderApiKey } = require('../provider-api-key');
+const { normalizeOpenAIOptions } = require('./openai-options');
+const {
+    assertNoStoredSignal,
+    throwIfAborted,
+    validateProviderExecution
+} = require('../abort-signal');
 
 function createBaseProviders({ ModelMix }) {
     class MixCustom {
         constructor({ config = {}, options = {}, headers = {} } = {}) {
+            assertNoStoredSignal(config, 'config');
+            assertNoStoredSignal(options, 'options');
             this.config = this.getDefaultConfig(config);
             this.options = this.getDefaultOptions(options);
             this.headers = this.getDefaultHeaders(headers);
@@ -67,7 +76,8 @@ function createBaseProviders({ ModelMix }) {
             return buildRequestBodyAndHeaders(options, headers);
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
+            validateProviderExecution(this, { config, options, signal });
             try {
                 this.sanitizeCacheOptions(options);
                 if (Array.isArray(options.messages)) {
@@ -88,19 +98,22 @@ function createBaseProviders({ ModelMix }) {
                 }
     
                 if (options.stream) {
-                    return this.processStream(await fetchStreamResponse(this.config.url, {
+                    return await this.processStream(await fetchStreamResponse(this.config.url, {
                         method: 'POST',
                         headers: request.headers,
-                        body: request.body
+                        body: request.body,
+                        signal
                     }));
                 } else {
                     return this.processResponse(await fetchJsonResponse(this.config.url, {
                         method: 'POST',
                         headers: request.headers,
-                        body: request.body
+                        body: request.body,
+                        signal
                     }));
                 }
             } catch (error) {
+                throwIfAborted(signal);
                 throw this.handleError(error);
             }
         }
@@ -274,10 +287,7 @@ function createBaseProviders({ ModelMix }) {
         }
     
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.OPENAI_API_KEY;
-            if (!apiKey) {
-                throw new Error('OpenAI API key not found. Please provide it in config or set OPENAI_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'OPENAI_API_KEY', 'OpenAI');
     
             return super.getDefaultConfig({
                 url: 'https://api.openai.com/v1/chat/completions',
@@ -286,24 +296,9 @@ function createBaseProviders({ ModelMix }) {
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
-    
-            // Remove max_tokens and temperature for o1/o3 models
-            if (options.model?.startsWith('o')) {
-                delete options.max_tokens;
-                delete options.temperature;
-            }
-    
-            // Use max_completion_tokens and remove temperature for GPT-5 models
-            if (options.model?.includes('gpt-5')) {
-                if (options.max_tokens) {
-                    options.max_completion_tokens = options.max_tokens;
-                    delete options.max_tokens;
-                }
-                delete options.temperature;
-            }
-    
-            return super.create({ config, options });
+        async create({ config = {}, options = {}, signal } = {}) {
+            normalizeOpenAIOptions(options);
+            return super.create({ config, options, signal });
         }
     
         static convertMessages(messages, config) {
@@ -387,10 +382,8 @@ function createBaseProviders({ ModelMix }) {
                 }
             }
     
-            // Solo incluir tools si el array no está vacío
             if (toolsArray.length > 0) {
                 options.tools = toolsArray;
-                // options.tool_choice = "auto";
             }
     
             return options;

package/lib/providers/google.js

@@ -1,10 +1,15 @@
 const { fetchJsonResponse } = require('../../http-client');
 const { configForDebug } = require('../provider-debug');
+const { requireProviderApiKey } = require('../provider-api-key');
+const {
+    throwIfAborted,
+    validateProviderExecution
+} = require('../abort-signal');
 
 function createGoogleProviders({ ModelMix, MixCustom }) {
     class MixGoogle extends MixCustom {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.GEMINI_API_KEY;
+            const apiKey = requireProviderApiKey(customConfig, 'GEMINI_API_KEY', 'Gemini');
             return super.getDefaultConfig({
                 url: 'https://generativelanguage.googleapis.com/v1beta/models',
                 apiKey,
@@ -19,7 +24,7 @@ function createGoogleProviders({ ModelMix, MixCustom }) {
             };
         }
     
-        static convertMessages(messages, config) {
+        static convertMessages(messages) {
             return messages.map(message => {
     
                 // Handle assistant messages with tool_calls (content is null)
@@ -121,11 +126,8 @@ function createGoogleProviders({ ModelMix, MixCustom }) {
             }, []);
         }
     
-        async create({ config = {}, options = {} } = {}) {
-            if (!this.config.apiKey) {
-                throw new Error('Gemini API key not found. Please provide it in config or set GEMINI_API_KEY environment variable.');
-            }
-    
+        async create({ config = {}, options = {}, signal } = {}) {
+            validateProviderExecution(this, { config, options, signal });
             const generateContentApi = options.stream ? 'streamGenerateContent' : 'generateContent';
     
             const fullUrl = `${this.config.url}/${options.model}:${generateContentApi}?key=${this.config.apiKey}`;
@@ -190,10 +192,12 @@ function createGoogleProviders({ ModelMix, MixCustom }) {
                     return this.processResponse(await fetchJsonResponse(fullUrl, {
                         method: 'POST',
                         headers: this.headers,
-                        body: JSON.stringify(payload)
+                        body: JSON.stringify(payload),
+                        signal
                     }));
                 }
             } catch (error) {
+                throwIfAborted(signal);
                 throw this.handleError(error);
             }
         }

package/lib/providers/openai-compatible.js

@@ -2,14 +2,12 @@ const {
     GROK420_REASONING,
     GROK420_NON_REASONING
 } = require('../../effort');
+const { requireProviderApiKey } = require('../provider-api-key');
 
 function createCompatibleProviders({ MixCustom, MixOpenAI }) {
     class MixMiniMax extends MixOpenAI {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.MINIMAX_API_KEY;
-            if (!apiKey) {
-                throw new Error('MiniMax API key not found. Please provide it in config or set MINIMAX_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'MINIMAX_API_KEY', 'MiniMax');
     
             return MixCustom.prototype.getDefaultConfig.call(this, {
                 url: 'https://api.minimax.io/v1/chat/completions',
@@ -29,10 +27,7 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
     
     class MixMiMo extends MixOpenAI {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.MIMO_API_KEY;
-            if (!apiKey) {
-                throw new Error('MiMo API key not found. Please provide it in config or set MIMO_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'MIMO_API_KEY', 'MiMo');
     
             return MixCustom.prototype.getDefaultConfig.call(this, {
                 url: 'https://api.xiaomimimo.com/v1/chat/completions',
@@ -53,10 +48,7 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
     
     class MixPerplexity extends MixCustom {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.PPLX_API_KEY;
-            if (!apiKey) {
-                throw new Error('Perplexity API key not found. Please provide it in config or set PPLX_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'PPLX_API_KEY', 'Perplexity');
     
             return super.getDefaultConfig({
                 url: 'https://api.perplexity.ai/chat/completions',
@@ -65,7 +57,7 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
     
             if (config.schema) {
                 options.response_format = {
@@ -74,7 +66,7 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
                 };
             }
     
-            return super.create({ config, options });
+            return super.create({ config, options, signal });
         }
     }
     
@@ -133,10 +125,7 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
     
     class MixGrok extends MixOpenAI {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.XAI_API_KEY;
-            if (!apiKey) {
-                throw new Error('Grok API key not found. Please provide it in config or set XAI_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'XAI_API_KEY', 'Grok');
     
             return super.getDefaultConfig({
                 url: 'https://api.x.ai/v1/chat/completions',
@@ -145,20 +134,17 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
             if (options.model === GROK420_REASONING || options.model === GROK420_NON_REASONING) {
                 delete options.reasoning_effort;
             }
-            return super.create({ config, options });
+            return super.create({ config, options, signal });
         }
     }
     
     class MixLambda extends MixCustom {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.LAMBDA_API_KEY;
-            if (!apiKey) {
-                throw new Error('Lambda API key not found. Please provide it in config or set LAMBDA_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'LAMBDA_API_KEY', 'Lambda');
     
             return super.getDefaultConfig({
                 url: 'https://api.lambda.ai/v1/chat/completions',
@@ -176,14 +162,14 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
             });
         }
     
-        create({ config = {}, options = {} } = {}) {
+        create({ config = {}, options = {}, signal } = {}) {
             if (config.schema) {
                 options.response_format = {
                     type: 'json_schema',
                     json_schema: { schema: config.schema }
                 };
             }
-            return super.create({ config, options });
+            return super.create({ config, options, signal });
         }
     
         static extractThink(data) {
@@ -235,10 +221,7 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
     
     class MixGroq extends MixCustom {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.GROQ_API_KEY;
-            if (!apiKey) {
-                throw new Error('Groq API key not found. Please provide it in config or set GROQ_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'GROQ_API_KEY', 'Groq');
     
             return super.getDefaultConfig({
                 url: 'https://api.groq.com/openai/v1/chat/completions',
@@ -250,10 +233,7 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
     
     class MixTogether extends MixCustom {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.TOGETHER_API_KEY;
-            if (!apiKey) {
-                throw new Error('Together API key not found. Please provide it in config or set TOGETHER_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'TOGETHER_API_KEY', 'Together');
     
             return super.getDefaultConfig({
                 url: 'https://api.together.xyz/v1/chat/completions',
@@ -272,10 +252,7 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
     
     class MixCerebras extends MixCustom {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.CEREBRAS_API_KEY;
-            if (!apiKey) {
-                throw new Error('Cerebras API key not found. Please provide it in config or set CEREBRAS_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'CEREBRAS_API_KEY', 'Cerebras');
     
             return super.getDefaultConfig({
                 url: 'https://api.cerebras.ai/v1/chat/completions',
@@ -284,18 +261,15 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
             });
         }
     
-        create({ config = {}, options = {} } = {}) {
+        create({ config = {}, options = {}, signal } = {}) {
             delete options.response_format;
-            return super.create({ config, options });
+            return super.create({ config, options, signal });
         }
     }
     
     class MixFireworks extends MixCustom {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.FIREWORKS_API_KEY;
-            if (!apiKey) {
-                throw new Error('Fireworks API key not found. Please provide it in config or set FIREWORKS_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'FIREWORKS_API_KEY', 'Fireworks');
     
             return super.getDefaultConfig({
                 url: 'https://api.fireworks.ai/inference/v1/chat/completions',
@@ -307,10 +281,7 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
     
     class MixNVIDIA extends MixCustom {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.NVIDIA_API_KEY;
-            if (!apiKey) {
-                throw new Error('NVIDIA API key not found. Please provide it in config or set NVIDIA_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'NVIDIA_API_KEY', 'NVIDIA');
     
             return super.getDefaultConfig({
                 url: 'https://integrate.api.nvidia.com/v1/chat/completions',

package/lib/providers/openai-options.js

@@ -0,0 +1,16 @@
+function normalizeOpenAIOptions(options) {
+    if (/^o\d/.test(options.model || '')) {
+        delete options.max_tokens;
+        delete options.temperature;
+    }
+    if (options.model?.includes('gpt-5')) {
+        if (options.max_tokens) {
+            options.max_completion_tokens = options.max_tokens;
+            delete options.max_tokens;
+        }
+        delete options.temperature;
+    }
+    return options;
+}
+
+module.exports = { normalizeOpenAIOptions };