modelmix 5.1.12 → 5.1.16

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/lib/token-usage.js

@@ -64,6 +64,7 @@ const MODEL_PRICING = {
     'gemini-3.1-pro-preview': { input: 2.00, output: 12.00 },
     'gemini-3-pro-preview': { input: 2.00, output: 12.00 },
     'gemini-3-flash-preview': { input: 0.50, output: 3.00 },
+    'gemini-3.8-flash': { input: 0.75, cachedInput: 0.075, output: 3.75 },
     'gemini-3.7-flash': { input: 0.75, cachedInput: 0.075, output: 3.75 },
     'gemini-3.6-flash': { input: 0.75, cachedInput: 0.075, output: 3.75 },
     'gemini-3.5-flash': { input: 0.75, output: 4.50 },

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.16",
   "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

@@ -86,11 +86,11 @@ Chain shorthand methods to attach providers. First model is primary; others are
 const model = ModelMix.new()
     .sonnet46()        // primary
     .gpt52()           // fallback 1
-    .gemini37flash()   // fallback 2
+    .gemini38flash()   // fallback 2
     .addText("Hello!")
 ```
 
-If `sonnet46` fails, it automatically tries `gpt52`, then `gemini37flash`.
+If `sonnet46` fails, it automatically tries `gpt52`, then `gemini38flash`.
 
 The equivalent `chain()` form accepts public shortcut names directly in the
 same order. Append `@effort` for a per-model unified effort override (`-1` or
@@ -99,13 +99,13 @@ provider default when no chain effort is configured:
 
 ```javascript
 const model = ModelMix.new()
-    .chain('sonnet46', 'gpt52@20', 'gemini37flash@-1')
+    .chain('sonnet46', 'gpt52@20', 'gemini38flash@-1')
     .addText('Hello!');
 ```
 
 ### 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({
@@ -143,7 +143,7 @@ ModelMix.new({ config: { effort: 80 } })
 | DeepSeek V4 | off | `low`↑ | `high`↑ | `high`↑ | `max`↑ | — |
 | MiniMax M3 | off | adaptive | adaptive | adaptive | adaptive | adaptive |
 
-\* GPT-5.6 maps `100` to `max`; 80–99 remains `xhigh`. Qwen 3.8 27B and Flash map 0–39 / 40–79 / 80–100 to `low` / `medium` / `xhigh`; Qwen 3.8 Flash is the managed production version based on Flash-Next. GLM 5.3 and GLM 5.3 Flash require reasoning and map those bands to `low` / `high` / `max`. Gemini bands: 0–24 / 25–49 / 50–74 / 75–100. Gemini 3.7 Flash supports only `low` / `medium` / `high`, so the first two bands clamp to `low`; `-1` keeps its native `medium` default. DeepSeek `↑` = thinking on; `off` = thinking disabled. MiniMax `off`/`adaptive` = `thinking.disabled` / `thinking.type=adaptive`. Gemini 2.5 maps 0–100 to `thinkingBudget`. Anthropic: adaptive + `output_config.effort` on Claude 5 / Fable / Opus 4.6+ / Sonnet 4.6+; Sonnet 4.5 / Haiku 4.5 use `thinking.type=enabled` + `budget_tokens`. Grok 4.6 maps 0–39 / 40–59 / 60–79 / 80–100 to `low` / `medium` / `high` / `xhigh`; without effort it uses native `high`. `-1` = adaptive/dynamic when available, else no-op. Levels clamp per model. Former `*think()` methods are removed — use `.effort(n).<model>()`. Kimi: `kimiK25()` / `kimiK26()`. Grok 4.20: `.grok420()` non-reasoning; `.effort(20+|-1).grok420()` selects reasoning.
+\* GPT-5.6 maps `100` to `max`; 80–99 remains `xhigh`. Qwen 3.8 27B and Flash map 0–39 / 40–79 / 80–100 to `low` / `medium` / `xhigh`; Qwen 3.8 Flash is the managed production version based on Flash-Next. GLM 5.3 and GLM 5.3 Flash require reasoning and map those bands to `low` / `high` / `max`. Gemini bands: 0–24 / 25–49 / 50–74 / 75–100. Gemini 3.8 Flash and 3.7 Flash support only `low` / `medium` / `high`, so the first two bands clamp to `low`; `-1` keeps their native `medium` default. DeepSeek `↑` = thinking on; `off` = thinking disabled. MiniMax `off`/`adaptive` = `thinking.disabled` / `thinking.type=adaptive`. Gemini 2.5 maps 0–100 to `thinkingBudget`. Anthropic: adaptive + `output_config.effort` on Claude 5 / Fable / Opus 4.6+ / Sonnet 4.6+; Sonnet 4.5 / Haiku 4.5 use `thinking.type=enabled` + `budget_tokens`. Grok 4.6 maps 0–39 / 40–59 / 60–79 / 80–100 to `low` / `medium` / `high` / `xhigh`; without effort it uses native `high`. `-1` = adaptive/dynamic when available, else no-op. Levels clamp per model. Former `*think()` methods are removed — use `.effort(n).<model>()`. Kimi: `kimiK25()` / `kimiK26()`. Grok 4.20: `.grok420()` non-reasoning; `.effort(20+|-1).grok420()` selects reasoning.
 
 ## Available Model Shorthands
 
@@ -163,7 +163,7 @@ Use `.effort(n)` (or `config.effort`) to enable Anthropic thinking — e.g. `.ef
 `fable51()` registers `claude-fable-5-1` through Anthropic by default. Pass `mix: { openrouter: true }` to append `anthropic/claude-fable-5.1` as its fallback.
 
 ### Google
-`gemini31pro()` `gemini37flash()` `gemini36flash()` `gemini35flash()` `gemini35flashLite()` `gemini31flashLite()`
+`gemini31pro()` `gemini38flash()` `gemini37flash()` `gemini36flash()` `gemini35flash()` `gemini35flashLite()` `gemini31flashLite()`
 
 ### Grok
 `grok46()` `grok45()` `grok43()` `grok420multiAgent()` `grok420()`
@@ -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:
@@ -467,7 +485,7 @@ Omit all weights for equal probabilities. Otherwise every option needs a positiv
 const pool = ModelMix.new({ config: { roundRobin: true } })
     .gpt5mini()
     .sonnet45()
-    .gemini37flash();
+    .gemini38flash();
 
 const r1 = await pool.new().addText("Request 1").message();
 const r2 = await pool.new().addText("Request 2").message();
@@ -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 |