modelmix 5.1.12 → 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/providers/anthropic.js

@@ -62,7 +62,7 @@ function createAnthropicProviders({ ModelMix, MixCustom, log }) {
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
     
             delete options.response_format;
     
@@ -85,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) {

package/lib/providers/base.js

@@ -13,10 +13,17 @@ const {
 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);
@@ -69,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)) {
@@ -90,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);
             }
         }
@@ -285,9 +296,9 @@ function createBaseProviders({ ModelMix }) {
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
             normalizeOpenAIOptions(options);
-            return super.create({ config, options });
+            return super.create({ config, options, signal });
         }
     
         static convertMessages(messages, config) {

package/lib/providers/google.js

@@ -1,6 +1,10 @@
 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 {
@@ -122,7 +126,8 @@ function createGoogleProviders({ ModelMix, MixCustom }) {
             }, []);
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        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}`;
@@ -187,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

@@ -57,7 +57,7 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
     
             if (config.schema) {
                 options.response_format = {
@@ -66,7 +66,7 @@ function createCompatibleProviders({ MixCustom, MixOpenAI }) {
                 };
             }
     
-            return super.create({ config, options });
+            return super.create({ config, options, signal });
         }
     }
     
@@ -134,11 +134,11 @@ 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 });
         }
     }
     
@@ -162,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) {
@@ -261,9 +261,9 @@ 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 });
         }
     }
     

package/lib/providers/openai.js

@@ -6,6 +6,10 @@ const {
 } = require('../content-cache');
 const { requireProviderApiKey } = require('../provider-api-key');
 const { normalizeOpenAIOptions } = require('./openai-options');
+const {
+    throwIfAborted,
+    validateProviderExecution
+} = require('../abort-signal');
 
 function createOpenAIProviders({
     ModelMix,
@@ -17,15 +21,18 @@ function createOpenAIProviders({
     const WebSocket = require('ws');
 
     class MixOpenAIResponses extends MixOpenAI {
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
+            validateProviderExecution(this, { config, options, signal });
             normalizeOpenAIOptions(options);
             const responsesUrl = this.config.url.replace('/chat/completions', '/responses');
             const request = MixOpenAIResponses.buildResponsesRequest(options, config);
             const response = await fetchJsonResponse(responsesUrl, {
                 method: 'POST',
                 headers: this.headers,
-                body: JSON.stringify(request)
+                body: JSON.stringify(request),
+                signal
             });
+            throwIfAborted(signal);
     
             return MixOpenAIResponses.processResponsesResponse(response);
         }
@@ -245,7 +252,8 @@ function createOpenAIProviders({
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
+            validateProviderExecution(this, { config, options, signal });
             if (options.stream) {
                 throw new Error('Stream is not supported for OpenAI moderation');
             }
@@ -254,8 +262,10 @@ function createOpenAIProviders({
             const response = await fetchJsonResponse(this.config.url, {
                 method: 'POST',
                 headers: this.headers,
-                body: JSON.stringify({ model: options.model, input })
+                body: JSON.stringify({ model: options.model, input }),
+                signal
             });
+            throwIfAborted(signal);
     
             return {
                 moderation: response.data.results,
@@ -343,7 +353,8 @@ function createOpenAIProviders({
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
+            validateProviderExecution(this, { config, options, signal });
             normalizeOpenAIOptions(options);
             const mergedConfig = { ...this.config, ...config };
             const realtimeUrl = `${mergedConfig.realtimeUrl}?model=${encodeURIComponent(options.model)}`;
@@ -372,7 +383,18 @@ function createOpenAIProviders({
                     });
                 }, timeoutMs);
     
-                const cleanUp = () => clearTimeout(timeout);
+                const cleanUp = () => {
+                    clearTimeout(timeout);
+                    signal?.removeEventListener('abort', onAbort);
+                };
+                const onAbort = () => {
+                    if (settled) return;
+                    settled = true;
+                    cleanUp();
+                    ws.terminate();
+                    reject(signal.reason);
+                };
+                signal?.addEventListener('abort', onAbort, { once: true });
     
                 ws.on('open', () => {
                     const session = {
@@ -541,13 +563,13 @@ function createOpenAIProviders({
             });
         }
 
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
             if (rejectsAnthropicSamplingParams(options.model)) {
                 delete options.temperature;
                 delete options.top_p;
                 delete options.top_k;
             }
-            return super.create({ config, options });
+            return super.create({ config, options, signal });
         }
     }
     
@@ -562,7 +584,7 @@ function createOpenAIProviders({
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
             if (Object.hasOwn(options, 'max_tokens')) {
                 options.max_completion_tokens = options.max_tokens;
                 delete options.max_tokens;
@@ -574,7 +596,7 @@ function createOpenAIProviders({
             delete options.presence_penalty;
             delete options.frequency_penalty;
     
-            return super.create({ config, options });
+            return super.create({ config, options, signal });
         }
     
         extractDelta(data) {

package/mcp-tools.js

@@ -36,14 +36,16 @@ class MCPToolsManager {
         }
     }
 
-    async executeTool(name, args) {
+    async executeTool(name, args, signal) {
         const callback = this.callbacks.get(name);
         if (!callback) {
             throw new Error(`Tool not found: ${name}`);
         }
 
         try {
-            const result = await callback(args);
+            signal?.throwIfAborted();
+            const result = await callback(args, signal);
+            signal?.throwIfAborted();
             // For primitive values (numbers, booleans), convert to string
             // For objects/arrays, stringify them
             let textResult;
@@ -62,6 +64,7 @@ class MCPToolsManager {
                 }]
             };
         } catch (error) {
+            signal?.throwIfAborted();
             log.error(`Error executing tool ${name}:`, error);
             return {
                 content: [{ 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "5.1.12",
+  "version": "5.1.15",
   "description": "🧬 Reliable interface with automatic fallback for AI LLMs.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -78,6 +78,6 @@
     "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:rlm": "mocha plugins/rlm/test/**/*.test.js --timeout 10000 --require test/setup.js",
-    "test:offline": "mocha 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/moderation.test.js test/plugins.test.js plugins/rlm/test/**/*.test.js --timeout 10000 --require test/setup.js"
   }
 }

package/plugins/rlm/index.d.ts

@@ -159,6 +159,7 @@ export interface RlmSandbox {
       parentExecutionId: string | null;
       depth: number;
     };
+    signal?: AbortSignal;
     timeoutMs: number;
   }): Promise<unknown>;
 }

package/plugins/rlm/lib/isolated-vm-sandbox.js

@@ -21,7 +21,8 @@ function sandboxSource(code) {
 
 function createIsolatedVmSandbox() {
     return {
-        async execute({ code, variables, query, limits, timeoutMs }) {
+        async execute({ code, variables, query, limits, signal, timeoutMs }) {
+            signal?.throwIfAborted();
             if (limits.sandboxMemoryBytes < MINIMUM_ISOLATE_MEMORY_BYTES) {
                 throw new TypeError(
                     `limits.sandboxMemoryBytes must be at least ${MINIMUM_ISOLATE_MEMORY_BYTES}.`
@@ -35,6 +36,10 @@ function createIsolatedVmSandbox() {
                 timedOut = true;
                 if (!isolate.isDisposed) isolate.dispose();
             }, timeoutMs);
+            const onAbort = () => {
+                if (!isolate.isDisposed) isolate.dispose();
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
 
             try {
                 const context = await isolate.createContext();
@@ -68,6 +73,7 @@ function createIsolatedVmSandbox() {
                     timeout: timeoutMs
                 });
             } catch (error) {
+                signal?.throwIfAborted();
                 if (memoryError(error)) {
                     throw new RlmLimitError(
                         'sandboxMemoryBytes',
@@ -78,6 +84,7 @@ function createIsolatedVmSandbox() {
                 throw error;
             } finally {
                 clearTimeout(timeout);
+                signal?.removeEventListener('abort', onAbort);
                 if (!isolate.isDisposed) isolate.dispose();
             }
         }

package/plugins/rlm/lib/plugin.js

@@ -13,7 +13,7 @@ const { isPlainObject } = require('./validation');
 
 function validateSandbox(sandbox) {
     if (!sandbox || typeof sandbox !== 'object' || typeof sandbox.execute !== 'function') {
-        throw new TypeError('sandbox must define execute({ code, variables, query, limits }).');
+        throw new TypeError('sandbox must define execute({ code, variables, query, limits, signal }).');
     }
     return sandbox;
 }
@@ -91,9 +91,11 @@ function executionInput(context, configuredVariables) {
     };
 }
 
-function runWithTimeout(operation, timeoutMs) {
+function runWithTimeout(operation, timeoutMs, signal) {
+    signal?.throwIfAborted();
     let timeout;
-    return Promise.race([
+    let onAbort;
+    const promises = [
         operation(),
         new Promise((_, reject) => {
             timeout = setTimeout(() => reject(new RlmLimitError(
@@ -101,7 +103,17 @@ function runWithTimeout(operation, timeoutMs) {
                 'RLM wall-time limit exceeded.'
             )), timeoutMs);
         })
-    ]).finally(() => clearTimeout(timeout));
+    ];
+    if (signal) {
+        promises.push(new Promise((_, reject) => {
+            onAbort = () => reject(signal.reason);
+            signal.addEventListener('abort', onAbort, { once: true });
+        }));
+    }
+    return Promise.race(promises).finally(() => {
+        clearTimeout(timeout);
+        if (onAbort) signal.removeEventListener('abort', onAbort);
+    });
 }
 
 function rlm({ maxDepth, variables = {}, documents, workers, limits, sandbox } = {}) {
@@ -122,6 +134,7 @@ function rlm({ maxDepth, variables = {}, documents, workers, limits, sandbox } =
     return {
         name: 'rlm',
         async execute(context) {
+            context.signal?.throwIfAborted();
             if (context.request.outputMode === 'stream') {
                 throw new Error('RLM streaming is not supported; use a buffered output mode.');
             }
@@ -145,6 +158,7 @@ function rlm({ maxDepth, variables = {}, documents, workers, limits, sandbox } =
                         outputSchema: context.request.config.schema || null
                     })
                 ));
+                context.signal?.throwIfAborted();
                 state.record('planner', plannerResult, {
                     worker: null,
                     elapsedMs: Date.now() - plannerStartedAt
@@ -167,10 +181,13 @@ function rlm({ maxDepth, variables = {}, documents, workers, limits, sandbox } =
                         query,
                         limits: validatedLimits,
                         execution: context.execution,
+                        signal: context.signal,
                         timeoutMs
                     }),
-                    timeoutMs
+                    timeoutMs,
+                    context.signal
                 );
+                context.signal?.throwIfAborted();
                 const message = serializeResult(value);
                 state.budget.accountFinalOutput(message);
                 return {
@@ -179,6 +196,7 @@ function rlm({ maxDepth, variables = {}, documents, workers, limits, sandbox } =
                     rlm: state.diagnostics(context.execution)
                 };
             } catch (error) {
+                context.signal?.throwIfAborted();
                 error.rlm = state.diagnostics(
                     context.execution,
                     error.limit ? `limit:${error.limit}` : 'error'

package/plugins/rlm/test/isolated-vm-sandbox.test.js

@@ -69,6 +69,29 @@ describe('RLM isolated-vm sandbox', () => {
         expect(failure.limit).to.equal('maxWallTimeMs');
     });
 
+    it('disposes an in-flight isolate and preserves the abort reason', async () => {
+        const controller = new AbortController();
+        const reason = new Error('stop sandbox');
+        const execution = createIsolatedVmSandbox().execute({
+            code: '(async () => { while (true) {} })()',
+            variables: {},
+            query: async () => '',
+            limits: limits(),
+            signal: controller.signal,
+            timeoutMs: 1000
+        });
+
+        setTimeout(() => controller.abort(reason), 20);
+
+        let failure;
+        try {
+            await execution;
+        } catch (error) {
+            failure = error;
+        }
+        expect(failure).to.equal(reason);
+    });
+
     it('rejects memory limits below the isolated-vm minimum', async () => {
         let failure;
         try {

package/skills/modelmix/SKILL.md

@@ -105,7 +105,7 @@ const model = ModelMix.new()
 
 ### Instance plugins
 
-Register middleware with `.use({ name, execute })`. Plugins are scoped to the instance, run in registration order, and receive the rendered provider-neutral request. They may edit `context.request`, call `next()`, or return a complete ModelMix result.
+Register middleware with `.use({ name, execute })`. Plugins are scoped to the instance, run in registration order, and receive the rendered provider-neutral request. They may edit `context.request`, call `next()`, or return a complete ModelMix result. `context.signal` is the current execution's `AbortSignal` and is inherited by `context.invoke()` children.
 
 ```javascript
 model.use({
@@ -332,6 +332,24 @@ const raw = await ModelMix.new()
 // raw.message, raw.think, raw.tokens, raw.toolCalls, raw.response
 ```
 
+### Cancel one execution
+
+Pass an `AbortSignal` directly to the terminal method:
+
+```javascript
+const controller = new AbortController();
+const pending = model.message(controller.signal);
+controller.abort(new Error('Request cancelled'));
+await pending;
+```
+
+The other forms are `raw(signal)`, `stream(callback, signal)`,
+`block(options, signal)`, and `json(example, description, jsonOptions, signal)`.
+For `execute()`, use the top-level `{ signal }` field. Never place `signal` in
+`config` or `options`; ModelMix rejects those reusable/payload-bearing locations.
+Plugins read `context.signal`, child invocations inherit it, and local tool
+callbacks receive it as their second argument.
+
 ### Access full response with lastRaw
 
 After calling `message()`, `json()`, `block()`, or `stream()`, use `lastRaw` to access the complete response:
@@ -614,12 +632,12 @@ const model = ModelMix.new({
 | `.assign({})` | `this` | Assign EJS template data |
 | `.assignKey(key, value)` | `this` | Assign one EJS template-data value |
 | `.assignKeyFromFile(key, path)` | `this` | Assign the rendered output of an EJS file to one key |
-| `.message()` | `Promise<string>` | Get text response |
-| `.json(example, desc?, opts?)` | `Promise<object\|array>` | Get structured JSON |
-| `.raw()` | `Promise<{message, think, toolCalls, tokens, response}>` | Full response |
+| `.message(signal?)` | `Promise<string>` | Get text response |
+| `.json(example, desc?, opts?, signal?)` | `Promise<object\|array>` | Get structured JSON |
+| `.raw(signal?)` | `Promise<{message, think, toolCalls, tokens, response}>` | Full response |
 | `.lastRaw` | `object \| null` | Full response from last call |
-| `.stream(callback)` | `Promise` | Stream response |
-| `.block({addSystemExtra?})` | `Promise<string>` | Extract code block from response |
+| `.stream(callback, signal?)` | `Promise` | Stream response |
+| `.block({addSystemExtra?}, signal?)` | `Promise<string>` | Extract code block from response |
 | `.addMCP(package)` | `Promise` | Add MCP server tools |
 | `.addTool(def, callback)` | `this` | Register custom local tool |
 | `.addTools([{tool, callback}])` | `this` | Register multiple tools |