modelmix 5.1.10 → 5.1.15

package/index.js

@@ -12,6 +12,13 @@ const { Client } = require("@modelcontextprotocol/sdk/client/index.js");
 const { StdioClientTransport } = require("@modelcontextprotocol/sdk/client/stdio.js");
 const { MCPToolsManager } = require('./mcp-tools');
 const { fetchBinaryResponse } = require('./http-client');
+const {
+    assertAbortSignal,
+    assertNoStoredSignal,
+    raceWithSignal,
+    sleepWithSignal,
+    throwIfAborted
+} = require('./lib/abort-signal');
 const { isPlainObject } = require('./lib/object-utils');
 const { normalizeContentCache } = require('./lib/content-cache');
 const tokenUsage = require('./lib/token-usage');
@@ -59,10 +66,6 @@ function getErrorStatusCode(error) {
     return error?.statusCode ?? error?.response?.status ?? error?.response?.statusCode ?? null;
 }
 
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
 function clonePluginValue(value, seen = new WeakMap()) {
     if (value === null || typeof value !== 'object') return value;
     if (Buffer.isBuffer(value)) return Buffer.from(value);
@@ -96,6 +99,8 @@ function validatePluginResult(result, pluginName) {
 class ModelMix {
 
     constructor({ options = {}, config = {}, mix = {} } = {}) {
+        assertNoStoredSignal(options, 'options');
+        assertNoStoredSignal(config, 'config');
         this.models = [];
         this.messages = [];
         this.tools = {};
@@ -144,7 +149,7 @@ class ModelMix {
         if (this.config.effort !== undefined && this.config.effort !== null) {
             this.config.effort = normalizeEffort(this.config.effort);
         }
-        const freeMix = { openrouter: true, cerebras: true, groq: true, together: false, lambda: false };
+        const freeMix = { openrouter: false, cerebras: true, groq: true, together: false, lambda: false };
         this.mix = { ...freeMix, ...mix };
 
         this.limiter = new Bottleneck(this.config.bottleneck);
@@ -255,13 +260,16 @@ class ModelMix {
             : this.plugins.filter(plugin => !uniqueNames.has(plugin.name));
     }
 
-    async _invokeChild(input, parentExecution) {
+    async _invokeChild(input, parentExecution, signal) {
         if (!isPlainObject(input)) {
             throw new TypeError('Child invocation must be a plain object.');
         }
         if (input.history !== undefined && input.history !== false) {
             throw new TypeError('Child invocations currently require history: false.');
         }
+        if (Object.prototype.hasOwnProperty.call(input, 'signal')) {
+            throw new TypeError('Child invocations inherit the parent AbortSignal and cannot override it.');
+        }
 
         const {
             system,
@@ -276,6 +284,9 @@ class ModelMix {
             plugins = 'inherit',
             outputMode = 'raw'
         } = input;
+        assertNoStoredSignal(options, 'options');
+        assertNoStoredSignal(config, 'config');
+        throwIfAborted(signal);
         if (!Array.isArray(messages)) {
             throw new TypeError('Child invocation messages must be an array.');
         }
@@ -318,6 +329,7 @@ class ModelMix {
         };
         const result = await child.execute({
             outputMode,
+            signal,
             _executionMetadata: execution
         });
         return { ...result, execution };
@@ -421,6 +433,9 @@ class ModelMix {
 
     attach(key, provider) {
 
+        assertNoStoredSignal(provider?.options, 'provider.options');
+        assertNoStoredSignal(provider?.config, 'provider.config');
+
         if (this.models.some(model => model.key === key
             && model.provider.constructor === provider.constructor)) {
             return this;
@@ -434,47 +449,59 @@ class ModelMix {
         return this;
     }
 
-    gpt5({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5', new MixOpenAI({ options, config }));
+    _attachOpenAIWithOpenRouter(officialKey, Provider, {
+        options = {},
+        config = {},
+        mix = {},
+        openRouterKey = `openai/${officialKey}`
+    } = {}) {
+        mix = { ...this.mix, ...mix };
+        this.attach(officialKey, new Provider({ options, config }));
+        if (mix.openrouter) this.attach(openRouterKey, new MixOpenRouter({ options, config }));
+        return this;
     }
-    gpt5mini({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5-mini', new MixOpenAI({ options, config }));
+
+    gpt5(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5', MixOpenAI, args);
+    }
+    gpt5mini(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5-mini', MixOpenAI, args);
+    }
+    gpt5nano(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5-nano', MixOpenAI, args);
     }
-    gpt5nano({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5-nano', new MixOpenAI({ options, config }));
+    gpt51(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.1', MixOpenAIResponses, args);
     }
-    gpt51({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.1', new MixOpenAIResponses({ options, config }));
+    gpt52(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.2', MixOpenAIResponses, args);
     }
-    gpt52({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.2', new MixOpenAIResponses({ options, config }));
+    gpt54(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.4', MixOpenAIResponses, args);
     }
-    gpt54({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.4', new MixOpenAIResponses({ options, config }));
+    gpt54mini(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.4-mini', MixOpenAIResponses, args);
     }
-    gpt54mini({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.4-mini', new MixOpenAIResponses({ options, config }));
+    gpt54nano(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.4-nano', MixOpenAIResponses, args);
     }
-    gpt54nano({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.4-nano', new MixOpenAIResponses({ options, config }));
-    }        
-    gpt54pro({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.4-pro', new MixOpenAIResponses({ options, config }));
+    gpt54pro(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.4-pro', MixOpenAIResponses, args);
     }
-    gpt55({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.5', new MixOpenAIResponses({ options, config }));
+    gpt55(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.5', MixOpenAIResponses, args);
     }
-    gpt55pro({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.5-pro', new MixOpenAIResponses({ options, config }));
+    gpt55pro(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.5-pro', MixOpenAIResponses, args);
     }
-    gpt56sol({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.6-sol', new MixOpenAIResponses({ options, config }));
+    gpt56sol(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.6-sol', MixOpenAIResponses, args);
     }
-    gpt56terra({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.6-terra', new MixOpenAIResponses({ options, config }));
+    gpt56terra(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.6-terra', MixOpenAIResponses, args);
     }
-    gpt56luna({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.6-luna', new MixOpenAIResponses({ options, config }));
+    gpt56luna(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.6-luna', MixOpenAIResponses, args);
     }
     gptRealtime({ options = {}, config = {} } = {}) {
         return this.attach('gpt-realtime', new MixOpenAIWebSocket({ options, config }));
@@ -482,11 +509,14 @@ class ModelMix {
     gptRealtimeMini({ options = {}, config = {} } = {}) {
         return this.attach('gpt-realtime-mini', new MixOpenAIWebSocket({ options, config }));
     }
-    gpt53codex({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.3-codex', new MixOpenAIResponses({ options, config }));
-    }          
-    gpt53chat({ options = {}, config = {} } = {}) {
-        return this.attach('gpt-5.3-chat-latest', new MixOpenAIResponses({ options, config }));
+    gpt53codex(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.3-codex', MixOpenAIResponses, args);
+    }
+    gpt53chat(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-5.3-chat-latest', MixOpenAIResponses, {
+            ...args,
+            openRouterKey: 'openai/gpt-5.3-chat'
+        });
     }
     gptOss({ options = {}, config = {}, mix = {} } = {}) {
         mix = { ...this.mix, ...mix };
@@ -504,6 +534,12 @@ class ModelMix {
     fable5(args = {}) {
         return this.fable50(args);
     }
+    fable51({ options = {}, config = {}, mix = {} } = {}) {
+        mix = { anthropic: true, ...this.mix, ...mix };
+        if (mix.anthropic) this.attach('claude-fable-5-1', new MixAnthropic({ options, config }));
+        if (mix.openrouter) this.attach('anthropic/claude-fable-5.1', new MixOpenRouter({ options, config }));
+        return this;
+    }
     opus50({ options = {}, config = {} } = {}) {
         return this.attach('claude-opus-5', new MixAnthropic({ options, config }));
     }
@@ -585,6 +621,10 @@ class ModelMix {
         return this;
     }
 
+    museSpark12Contributor({ options = {}, config = {} } = {}) {
+        return this.attach('meta/muse-spark-1.2-contributor', new MixOpenRouter({ options, config }));
+    }
+
     qwen35397b({ options = {}, config = {} } = {}) {
         return this.attach('qwen/qwen3.5-397b-a17b', new MixOpenRouter({ options, config }));
     }
@@ -628,7 +668,7 @@ class ModelMix {
         return this.attach('nousresearch/hermes-4-405b', new MixOpenRouter({ options, config }));
     }
 
-    hermes3({ options = {}, config = {}, mix = {} } = {}) {
+    hermes3({ options = {}, config = {}, mix = { openrouter: true } } = {}) {
         mix = { ...this.mix, ...mix };
         if (mix.lambda) this.attach('Hermes-3-Llama-3.1-405B-FP8', new MixLambda({ options, config }));
         if (mix.openrouter) this.attach('nousresearch/hermes-3-llama-3.1-405b:free', new MixOpenRouter({ options, config }));
@@ -673,7 +713,7 @@ class ModelMix {
     }
 
 
-    minimaxM27({ options = {}, config = {}, mix = { openrouter: true, minimax: true } } = {}) {
+    minimaxM27({ options = {}, config = {}, mix = { minimax: true } } = {}) {
         mix = { ...this.mix, ...mix };
         if (mix.nvidia) this.attach('minimaxai/minimax-m2.7', new MixNVIDIA({ options, config }));
         if (mix.fireworks) this.attach('accounts/fireworks/models/minimax-m2p7', new MixFireworks({ options, config }));
@@ -786,22 +826,23 @@ class ModelMix {
         return this;
     }
 
-    addImageFromBuffer(buffer, { role = "user", cache } = {}) {
+    _addImageSource(source, { role = "user", cache } = {}) {
         const contentCache = normalizeContentCache(cache);
         this.messages.push({
             role,
             content: [{
                 type: "image",
-                source: {
-                    type: "buffer",
-                    data: buffer
-                },
+                source,
                 ...(contentCache !== undefined && { cache: contentCache })
             }]
         });
         return this;
     }
 
+    addImageFromBuffer(buffer, { role = "user", cache } = {}) {
+        return this._addImageSource({ type: "buffer", data: buffer }, { role, cache });
+    }
+
     addImage(filePath, { role = "user", cache } = {}) {
         const absolutePath = path.resolve(filePath);
 
@@ -809,19 +850,7 @@ class ModelMix {
             throw new Error(`Image file not found: ${filePath}`);
         }
 
-        const contentCache = normalizeContentCache(cache);
-        this.messages.push({
-            role,
-            content: [{
-                type: "image",
-                source: {
-                    type: "file",
-                    data: filePath
-                },
-                ...(contentCache !== undefined && { cache: contentCache })
-            }]
-        });
-        return this;
+        return this._addImageSource({ type: "file", data: filePath }, { role, cache });
     }
 
     addImageFromUrl(url, { role = "user", cache } = {}) {
@@ -845,34 +874,28 @@ class ModelMix {
             };
         }
 
-        const contentCache = normalizeContentCache(cache);
-        this.messages.push({
-            role,
-            content: [{
-                type: "image",
-                source,
-                ...(contentCache !== undefined && { cache: contentCache })
-            }]
-        });
-
-        return this;
+        return this._addImageSource(source, { role, cache });
     }
 
-    async processImages() {
-        for (let i = 0; i < this.messages.length; i++) {
-            const message = this.messages[i];
+    async processImages(signal) {
+        assertAbortSignal(signal);
+        const preparedContent = [];
+        for (const message of this.messages) {
             if (!Array.isArray(message.content)) continue;
+            const nextContent = [];
 
-            for (let j = 0; j < message.content.length; j++) {
-                const content = message.content[j];
-                if (content.type !== 'image' || content.source.type === 'base64') continue;
+            for (const content of message.content) {
+                if (content.type !== 'image' || content.source.type === 'base64') {
+                    nextContent.push(content);
+                    continue;
+                }
 
                 try {
                     let buffer, mimeType;
 
                     switch (content.source.type) {
                         case 'url':
-                            const response = await fetchBinaryResponse(content.source.data);
+                            const response = await fetchBinaryResponse(content.source.data, { signal });
                             buffer = response.data;
                             mimeType = response.headers['content-type'];
                             break;
@@ -886,6 +909,8 @@ class ModelMix {
                             break;
                     }
 
+                    throwIfAborted(signal);
+
                     // Detect mimeType if not provided
                     if (!mimeType) {
                         if (typeof detectFileTypeFromBuffer !== 'function') {
@@ -898,32 +923,33 @@ class ModelMix {
                         mimeType = detectedType.mime;
                     }
 
-                    // Update the content with processed image
-                    message.content[j] = {
+                    nextContent.push({
                         ...content,
                         source: {
                             type: "base64",
                             media_type: mimeType,
                             data: buffer.toString('base64')
                         }
-                    };
+                    });
 
                 } catch (error) {
+                    throwIfAborted(signal);
                     console.error(`Error processing image:`, error);
-                    // Remove failed image from content
-                    message.content.splice(j, 1);
-                    j--;
                 }
             }
+            preparedContent.push({ message, content: nextContent });
         }
+        throwIfAborted(signal);
+        for (const prepared of preparedContent) prepared.message.content = prepared.content;
     }
 
-    async message() {
-        let raw = await this.execute({ options: { stream: false }, outputMode: 'message' });
+    async message(signal) {
+        let raw = await this.execute({ options: { stream: false }, outputMode: 'message', signal });
         return raw.message;
     }
 
-    async json(schemaExample = null, schemaDescription = {}, { type = 'json_object', addExample = false, addSchema = true, addNote = false } = {}) {
+    async json(schemaExample = null, schemaDescription = {}, { type = 'json_object', addExample = false, addSchema = true, addNote = false } = {}, signal) {
+        assertAbortSignal(signal);
 
         let isArrayWrap = false;
         if (Array.isArray(schemaExample)) {
@@ -955,7 +981,7 @@ class ModelMix {
                 systemSuffix += "\n\nOutput JSON Escape: double quotes, backslashes, and control characters inside JSON strings.\nEnsure the output contains no comments.";
             }
         }
-        const { message } = await this.execute({ options, config, systemSuffix, outputMode: 'json' });
+        const { message } = await this.execute({ options, config, systemSuffix, outputMode: 'json', signal });
         const parsed = JSON.parse(this._extractBlock(message));
         return isArrayWrap ? parsed.out : parsed;
     }
@@ -965,25 +991,28 @@ class ModelMix {
         return block ? block[1].trim() : response.trim();
     }
 
-    async block({ addSystemExtra = true } = {}) {
+    async block({ addSystemExtra = true } = {}, signal) {
+        assertAbortSignal(signal);
         const systemSuffix = addSystemExtra
             ? "\nReturn the result of the task between triple backtick block code tags ```"
             : '';
         const { message } = await this.execute({
             options: { stream: false },
             systemSuffix,
-            outputMode: 'block'
+            outputMode: 'block',
+            signal
         });
         return this._extractBlock(message);
     }
 
-    async raw() {
-        return this.execute({ options: { stream: false }, outputMode: 'raw' });
+    async raw(signal) {
+        return this.execute({ options: { stream: false }, outputMode: 'raw', signal });
     }
 
-    async stream(callback) {
+    async stream(callback, signal) {
+        assertAbortSignal(signal);
         this.streamCallback = callback;
-        return this.execute({ options: { stream: true }, outputMode: 'stream' });
+        return this.execute({ options: { stream: true }, outputMode: 'stream', signal });
     }
 
     assignKeyFromFile(key, filePath) {
@@ -1096,10 +1125,6 @@ class ModelMix {
             const shouldNotGroup = ModelMix.hasToolInteraction(currentMessage);
 
             if (index === 0 || currentMessage.role !== messages[index - 1].role || shouldNotGroup) {
-                // acc.push({
-                //     role: currentMessage.role,
-                //     content: currentMessage.content
-                // });
                 acc.push(currentMessage);
             } else {
                 acc[acc.length - 1].content = acc[acc.length - 1].content.concat(currentMessage.content);
@@ -1144,8 +1169,8 @@ class ModelMix {
         }
     }
 
-    async prepareMessages(renderContext = createTemplateRenderContext(() => this._choiceRandom())) {
-        await this.processImages();
+    async prepareMessages(renderContext = createTemplateRenderContext(() => this._choiceRandom()), signal) {
+        await this.processImages(signal);
 
         let messages = this.messages;
 
@@ -1237,13 +1262,13 @@ class ModelMix {
     async _executePlugins({
         config,
         options,
+        signal,
         systemSuffix,
         outputMode,
         templateContext,
-        executionMetadata,
-        isRootExecution
+        executionMetadata
     }) {
-        const preparedMessages = await this.prepareMessages(templateContext);
+        const preparedMessages = await this.prepareMessages(templateContext, signal);
         this._requirePreparedMessages(preparedMessages);
 
         const request = {
@@ -1266,6 +1291,7 @@ class ModelMix {
                 return this.execute({
                     config,
                     options,
+                    signal,
                     systemSuffix,
                     outputMode,
                     _templateContext: templateContext,
@@ -1275,6 +1301,7 @@ class ModelMix {
                 });
             }
 
+            throwIfAborted(signal);
             const plugin = this.plugins[index];
             let nextCalled = false;
             const next = () => {
@@ -1287,9 +1314,11 @@ class ModelMix {
             const context = {
                 request,
                 execution: Object.freeze({ ...metadata }),
-                invoke: input => this._invokeChild(input, metadata)
+                signal,
+                invoke: input => this._invokeChild(input, metadata, signal)
             };
             const result = await plugin.execute(context, next);
+            throwIfAborted(signal);
             return validatePluginResult(result, plugin.name);
         };
 
@@ -1302,7 +1331,6 @@ class ModelMix {
                 this._addText(result.message, { role: 'assistant' });
             }
         }
-        if (isRootExecution) this._commitTemplateRenderContext(templateContext);
         return result;
     }
 
@@ -1349,6 +1377,8 @@ class ModelMix {
         currentConfig.system = pluginRequest
             ? pluginRequest.system
             : this._renderSystem(config, provider.config, systemSuffix, templateContext);
+        assertNoStoredSignal(currentOptions, 'options');
+        assertNoStoredSignal(currentConfig, 'config');
 
         const resolvedModelKey = resolveGrok420ModelKey(
             currentModel.key,
@@ -1385,7 +1415,7 @@ class ModelMix {
         }
     }
 
-    async _invokeProviderWithRetry(provider, currentOptions, currentConfig, resolvedModelKey) {
+    async _invokeProviderWithRetry(provider, currentOptions, currentConfig, resolvedModelKey, signal) {
         if (currentOptions.stream && this.streamCallback) {
             provider.streamCallback = this.streamCallback;
         }
@@ -1404,9 +1434,12 @@ class ModelMix {
         while (true) {
             const startTime = Date.now();
             try {
-                const result = await provider.create({ options: currentOptions, config: currentConfig });
+                throwIfAborted(signal);
+                const result = await provider.create({ options: currentOptions, config: currentConfig, signal });
+                throwIfAborted(signal);
                 return { result, elapsedMs: Date.now() - startTime };
             } catch (error) {
+                throwIfAborted(signal);
                 const statusCode = getErrorStatusCode(error);
                 if (attempt >= retries || !retryableStatusCodes.has(statusCode)) throw error;
 
@@ -1414,7 +1447,7 @@ class ModelMix {
                     console.log(`↺ Retrying [${resolvedModelKey}] due to status ${statusCode} (${attempt + 2}/${retries + 1})`);
                 }
                 const delay = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
-                await sleep(delay);
+                await sleepWithSignal(delay, signal);
                 attempt += 1;
             }
         }
@@ -1438,9 +1471,10 @@ class ModelMix {
     }
 
     async _continueToolCalls(result, pluginRequest, execution) {
+        const originalMessages = this.messages;
         const toolMessages = pluginRequest
             ? clonePluginValue(pluginRequest.messages)
-            : this.messages;
+            : clonePluginValue(this.messages);
         if (result.assistantMessage) {
             toolMessages.push(result.assistantMessage);
         } else if (result.message) {
@@ -1464,7 +1498,7 @@ class ModelMix {
         if (!result.assistantMessage) {
             toolMessages.push({ role: 'assistant', content: null, tool_calls: result.toolCalls });
         }
-        const toolResults = await this.processToolCalls(result.toolCalls);
+        const toolResults = await this.processToolCalls(result.toolCalls, execution.signal);
         for (const toolResult of toolResults) {
             toolMessages.push({
                 role: 'tool',
@@ -1475,12 +1509,17 @@ class ModelMix {
         }
         this.messages = toolMessages;
 
-        return this.execute({
-            ...execution,
-            _pluginRequest: pluginRequest
-                ? { ...pluginRequest, messages: toolMessages }
-                : null
-        });
+        try {
+            return await this.execute({
+                ...execution,
+                _pluginRequest: pluginRequest
+                    ? { ...pluginRequest, messages: toolMessages }
+                    : null
+            });
+        } catch (error) {
+            if (execution.signal?.aborted) this.messages = originalMessages;
+            throw error;
+        }
     }
 
     _logProviderSuccess(result, currentConfig) {
@@ -1555,6 +1594,7 @@ class ModelMix {
     async _executeProviderChain({
         config,
         options,
+        signal,
         systemSuffix,
         outputMode,
         templateContext,
@@ -1564,7 +1604,7 @@ class ModelMix {
     }) {
         const preparedMessages = pluginRequest
             ? pluginRequest.messages
-            : await this.prepareMessages(templateContext);
+            : await this.prepareMessages(templateContext, signal);
         this._requirePreparedMessages(preparedMessages);
 
         const finalConfig = pluginRequest ? pluginRequest.config : this._mergeRequestConfig(config);
@@ -1598,7 +1638,8 @@ class ModelMix {
                     providerAttempt.provider,
                     providerAttempt.currentOptions,
                     providerAttempt.currentConfig,
-                    providerAttempt.resolvedModelKey
+                    providerAttempt.resolvedModelKey,
+                    signal
                 );
                 this._enrichResultTokens(result, providerAttempt.resolvedModelKey, elapsedMs);
 
@@ -1606,6 +1647,7 @@ class ModelMix {
                     return this._continueToolCalls(result, pluginRequest, {
                         options,
                         config,
+                        signal,
                         systemSuffix,
                         outputMode,
                         _templateContext: templateContext,
@@ -1618,6 +1660,7 @@ class ModelMix {
                 this._recordProviderResult(result);
                 return result;
             } catch (error) {
+                throwIfAborted(signal);
                 lastError = error;
                 this._logProviderFailure(error, currentModel.key, attempt, modelsToTry);
             }
@@ -1630,6 +1673,7 @@ class ModelMix {
     async execute({
         config = {},
         options = {},
+        signal,
         systemSuffix = '',
         outputMode = 'raw',
         _templateContext = null,
@@ -1637,43 +1681,56 @@ class ModelMix {
         _executionMetadata = null,
         _pluginsApplied = false
     } = {}) {
+        assertAbortSignal(signal);
+        assertNoStoredSignal(this.config, 'config');
+        assertNoStoredSignal(this.options, 'options');
+        assertNoStoredSignal(config, 'config');
+        assertNoStoredSignal(options, 'options');
+        for (const model of this.models) {
+            assertNoStoredSignal(model.provider?.config, 'provider.config');
+            assertNoStoredSignal(model.provider?.options, 'provider.options');
+        }
         const isRootExecution = _templateContext === null;
         const templateContext = _templateContext || createTemplateRenderContext(() => this._choiceRandom());
+        let execution;
 
         if (!_pluginsApplied && this.plugins.length > 0) {
-            return this._executePlugins({
+            execution = this._executePlugins({
                 config,
                 options,
+                signal,
                 systemSuffix,
                 outputMode,
                 templateContext,
-                executionMetadata: _executionMetadata,
-                isRootExecution
+                executionMetadata: _executionMetadata
+            });
+        } else {
+            if (!this.models || this.models.length === 0) {
+                throw new Error('No models specified. Use methods like .gpt5(), .sonnet46() first.');
+            }
+            execution = this.limiter.schedule(() => {
+                throwIfAborted(signal);
+                return this._executeProviderChain({
+                    config,
+                    options,
+                    signal,
+                    systemSuffix,
+                    outputMode,
+                    templateContext,
+                    pluginRequest: _pluginRequest,
+                    executionMetadata: _executionMetadata,
+                    pluginsApplied: _pluginsApplied
+                });
             });
         }
 
-        if (!this.models || this.models.length === 0) {
-            throw new Error('No models specified. Use methods like .gpt5(), .sonnet46() first.');
-        }
-
-        const execution = this.limiter.schedule(() => this._executeProviderChain({
-            config,
-            options,
-            systemSuffix,
-            outputMode,
-            templateContext,
-            pluginRequest: _pluginRequest,
-            executionMetadata: _executionMetadata,
-            pluginsApplied: _pluginsApplied
-        }));
-
-        if (!isRootExecution) return execution;
-
-        const result = await execution;
-        this._commitTemplateRenderContext(templateContext);
+        const result = await raceWithSignal(execution, signal);
+        throwIfAborted(signal);
+        if (isRootExecution) this._commitTemplateRenderContext(templateContext);
         return result;
     }
-    async processToolCalls(toolCalls) {
+    async processToolCalls(toolCalls, signal) {
+        assertAbortSignal(signal);
         const result = []
 
         for (const toolCall of toolCalls) {
@@ -1706,7 +1763,8 @@ class ModelMix {
 
                 // Verificar si es una herramienta local registrada
                 if (this.mcpToolsManager.hasTool(toolName)) {
-                    const response = await this.mcpToolsManager.executeTool(toolName, toolArgs);
+                    const response = await this.mcpToolsManager.executeTool(toolName, toolArgs, signal);
+                    throwIfAborted(signal);
                     result.push({
                         name: toolName,
                         tool_call_id: toolId,
@@ -1722,7 +1780,8 @@ class ModelMix {
                     const response = await client.callTool({
                         name: toolName,
                         arguments: toolArgs
-                    });
+                    }, undefined, signal ? { signal } : undefined);
+                    throwIfAborted(signal);
 
                     result.push({
                         name: toolName,
@@ -1731,6 +1790,7 @@ class ModelMix {
                     });
                 }
             } catch (error) {
+                throwIfAborted(signal);
                 console.error(`Error processing tool call ${toolName}:`, error);
                 result.push({
                     name: toolName || 'unknown',
@@ -1865,4 +1925,4 @@ class ModelMix {
     log
 }));
 
-module.exports = { MixCustom, ModelMix, ModerationMix, MixModeration, MixAnthropic, MixKimi, MixMiniMax, MixMiMo, MixOpenAI, MixOpenAIResponses, MixOpenAIModeration, MixOpenAIWebSocket, MixOpenRouter, MixPerplexity, MixOllama, MixLMStudio, MixGroq, MixTogether, MixGrok, MixCerebras, MixGoogle, MixFireworks, MixNVIDIA, normalizeEffort, applyUnifiedEffort, resolveProviderFamily };
+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 };