modelmix 5.2.3 → 5.3.1

package/plugins/benchmark/test/benchmark.test.js

@@ -1,7 +1,7 @@
 const { expect } = require('chai');
 const sinon = require('sinon');
 
-const { MixOpenAI, ModelMix } = require('../../..');
+const { MixOpenAI, MixOpenAIResponses, ModelMix } = require('../../..');
 const { benchmark } = require('..');
 
 const criteria = {
@@ -53,18 +53,18 @@ function directContext(invoke, overrides = {}) {
 
 describe('Empty benchmark responses', () => {
     it('records a generation failure and never evaluates an empty candidate', async () => {
-        const plugin = benchmark({ criteriaModel: 'gpt5nano', models: ['gpt5', 'gpt5mini'] });
+        const plugin = benchmark({ criteriaModel: 'gpt5nano', models: ['gpt52', 'gpt5mini'] });
         const result = await plugin.execute(directContext(async input => {
             if (input.system.includes('define evaluation criteria')) return metricsResult(JSON.stringify(criteria));
             if (input.system.includes('evaluate one candidate response')) {
                 expect(input.messages[0].content).to.include('usable response');
                 return metricsResult(validEvaluation());
             }
-            return metricsResult(modelKey(input) === 'gpt-5' ? '  ' : 'usable response');
+            return metricsResult(modelKey(input) === 'gpt-5.2' ? '  ' : 'usable response');
         }));
         expect(result.benchmark.results[0]).to.include({ response: null, score: null });
         expect(result.benchmark.results[0].evaluationCount).to.deep.equal({ expected: 0, valid: 0 });
-        expect(result.benchmark.errors[0]).to.include({ stage: 'response', participant: 'gpt5' });
+        expect(result.benchmark.errors[0]).to.include({ stage: 'response', participant: 'gpt52' });
         expect(result.benchmark.errors[0].error.message).to.include('no text response');
     });
 });
@@ -91,7 +91,7 @@ describe('benchmark plugin', () => {
         try {
             const plugin = benchmark({
                 criteriaModel: 'deepseekV41Flash@20',
-                models: ['deepseekV41Flash@60', 'gpt5'],
+                models: ['deepseekV41Flash@60', 'gpt52'],
                 mix: { deepseek: true, openrouter: false }
             });
             const raw = await plugin.execute(directContext(async input => {
@@ -122,7 +122,7 @@ describe('benchmark plugin', () => {
 
     it('accepts a closing Markdown delimiter on criteria and evaluations without changing the response', async () => {
         const response = 'Candidate with ```text\ncontent\n```';
-        const plugin = benchmark({ criteriaModel: 'gpt5nano', models: ['gpt5', 'sonnet5'] });
+        const plugin = benchmark({ criteriaModel: 'gpt5nano', models: ['gpt52', 'sonnet5'] });
         const raw = await plugin.execute(directContext(async input => {
             if (input.system.includes('define evaluation criteria')) {
                 return metricsResult(JSON.stringify(criteria) + '```');
@@ -138,7 +138,7 @@ describe('benchmark plugin', () => {
     });
 
     it('still rejects invalid or incomplete evaluations with closing Markdown delimiters', async () => {
-        const plugin = benchmark({ criteriaModel: 'gpt5nano', models: ['gpt5', 'sonnet5'] });
+        const plugin = benchmark({ criteriaModel: 'gpt5nano', models: ['gpt52', 'sonnet5'] });
         let evaluation = 0;
         const invalid = [validEvaluation() + ' explanation```', '{"scores":[]}```'];
         const raw = await plugin.execute(directContext(async input => {
@@ -209,7 +209,7 @@ describe('benchmark plugin', () => {
     }
 
     it('preserves Markdown fences inside valid JSON evaluations and the final JSON report', async () => {
-        sinon.stub(MixOpenAI.prototype, 'create').callsFake(async ({ config }) => {
+        const respond = async ({ config }) => {
             if (config.system.includes('define evaluation criteria')) {
                 return metricsResult(JSON.stringify(criteria));
             }
@@ -219,9 +219,11 @@ describe('benchmark plugin', () => {
                 return metricsResult(JSON.stringify(value));
             }
             return metricsResult('```text\nA candidate answer\n```');
-        });
+        };
+        sinon.stub(MixOpenAI.prototype, 'create').callsFake(respond);
+        sinon.stub(MixOpenAIResponses.prototype, 'create').callsFake(respond);
         const report = await ModelMix.new().use(benchmark({
-            criteriaModel: 'gpt5nano', models: ['gpt5', 'gpt5mini']
+            criteriaModel: 'gpt5nano', models: ['gpt52', 'gpt5mini']
         })).addText('Evaluate the answer.').json();
         expect(report.errors).to.deep.equal([]);
         expect(report.results[0].response).to.equal('```text\nA candidate answer\n```');
@@ -229,7 +231,7 @@ describe('benchmark plugin', () => {
     });
 
     it('rejects truncated output with its finish reason and preserves the text and metrics', async () => {
-        const plugin = benchmark({ criteriaModel: 'gpt5nano', models: ['gpt5', 'sonnet5'] });
+        const plugin = benchmark({ criteriaModel: 'gpt5nano', models: ['gpt52', 'sonnet5'] });
         const log = sinon.stub(console, 'log');
         const raw = await plugin.execute(directContext(async input => {
             if (input.system.includes('define evaluation criteria')) {
@@ -258,7 +260,7 @@ describe('benchmark plugin', () => {
         const calls = [];
         const plugin = benchmark({
             criteriaModel: 'gpt5nano@10',
-            models: ['gpt5@0', 'gpt5mini@25', 'sonnet5@50']
+            models: ['gpt52@0', 'gpt5mini@25', 'sonnet5@50']
         });
         const context = directContext(async input => {
             calls.push(input);
@@ -279,7 +281,7 @@ describe('benchmark plugin', () => {
         expect(report.criteria.model).to.include({ id: 'gpt5nano@10', effort: 10 });
         expect(report.results).to.have.length(3);
         expect(report.results.map(result => result.response)).to.deep.equal([
-            'response:gpt-5',
+            'response:gpt-5.2',
             'response:gpt-5-mini',
             'response:claude-sonnet-5'
         ]);
@@ -312,7 +314,7 @@ describe('benchmark plugin', () => {
     it('treats aliases as one model for duplicates and self-evaluation exclusion', async () => {
         const plugin = benchmark({
             criteriaModel: 'gpt5nano',
-            models: ['sonnet5@10', 'sonnet50@20', 'gpt5@30']
+            models: ['sonnet5@10', 'sonnet50@20', 'gpt52@30']
         });
         const raw = await plugin.execute(directContext(async input => {
             if (input.system.includes('define evaluation criteria')) {
@@ -329,8 +331,8 @@ describe('benchmark plugin', () => {
             { expected: 1, valid: 1 },
             { expected: 2, valid: 2 }
         ]);
-        expect(raw.benchmark.results[0].evaluations[0].judge.canonicalModel).to.equal('gpt-5');
-        expect(raw.benchmark.results[1].evaluations[0].judge.canonicalModel).to.equal('gpt-5');
+        expect(raw.benchmark.results[0].evaluations[0].judge.canonicalModel).to.equal('gpt-5.2');
+        expect(raw.benchmark.results[1].evaluations[0].judge.canonicalModel).to.equal('gpt-5.2');
         expect(raw.benchmark.results[2].evaluations.map(item => item.judge.id)).to.deep.equal([
             'sonnet5@10',
             'sonnet50@20'
@@ -338,7 +340,7 @@ describe('benchmark plugin', () => {
 
         const duplicate = benchmark({
             criteriaModel: 'gpt5nano',
-            models: ['sonnet5@100', 'sonnet50@100', 'gpt5']
+            models: ['sonnet5@100', 'sonnet50@100', 'gpt52']
         });
         await expectRejection(duplicate.execute(directContext(async () => {
             throw new Error('should not be called');
@@ -346,7 +348,7 @@ describe('benchmark plugin', () => {
 
         const inheritedDuplicate = benchmark({
             criteriaModel: 'gpt5nano',
-            models: ['sonnet5', 'sonnet50', 'gpt5']
+            models: ['sonnet5', 'sonnet50', 'gpt52']
         });
         await expectRejection(inheritedDuplicate.execute(directContext(async () => {
             throw new Error('should not be called');
@@ -367,7 +369,7 @@ describe('benchmark plugin', () => {
         const evaluationCalls = [];
         const plugin = benchmark({
             criteriaModel: 'gpt5nano',
-            models: ['gpt5', 'gpt5mini', 'sonnet5']
+            models: ['gpt52', 'gpt5mini', 'sonnet5']
         });
         const raw = await plugin.execute(directContext(async input => {
             if (input.system.includes('define evaluation criteria')) {
@@ -382,7 +384,7 @@ describe('benchmark plugin', () => {
                 }
                 return metricsResult(validEvaluation(9, 7));
             }
-            if (modelKey(input) === 'gpt-5') throw new Error('participant unavailable');
+            if (modelKey(input) === 'gpt-5.2') throw new Error('participant unavailable');
             return metricsResult(`response:${modelKey(input)}`);
         }));
 
@@ -395,11 +397,11 @@ describe('benchmark plugin', () => {
         expect(sonnet.evaluationCount).to.deep.equal({ expected: 2, valid: 2 });
         expect(sonnet.score).to.equal(8);
         expect(evaluationCalls).to.deep.include({
-            judge: 'gpt-5',
+            judge: 'gpt-5.2',
             response: 'response:gpt-5-mini'
         });
         expect(evaluationCalls).to.deep.include({
-            judge: 'gpt-5',
+            judge: 'gpt-5.2',
             response: 'response:claude-sonnet-5'
         });
         expect(raw.benchmark.errors.map(error => error.stage)).to.deep.equal([
@@ -414,7 +416,7 @@ describe('benchmark plugin', () => {
     it('rejects incomplete evaluations without using any of their scores', async () => {
         const plugin = benchmark({
             criteriaModel: 'gpt5nano',
-            models: ['gpt5', 'sonnet5']
+            models: ['gpt52', 'sonnet5']
         });
         const raw = await plugin.execute(directContext(async input => {
             if (input.system.includes('define evaluation criteria')) {
@@ -446,7 +448,7 @@ describe('benchmark plugin', () => {
     it('aborts when criteria generation fails and propagates cancellation', async () => {
         const invalidCriteria = benchmark({
             criteriaModel: 'gpt5nano',
-            models: ['gpt5', 'sonnet5']
+            models: ['gpt52', 'sonnet5']
         });
         await expectRejection(invalidCriteria.execute(directContext(async () => (
             metricsResult(JSON.stringify({ criteria: [] }))
@@ -465,7 +467,7 @@ describe('benchmark plugin', () => {
     it('logs intermediate progress when ModelMix debug is enabled', async () => {
         const plugin = benchmark({
             criteriaModel: 'gpt5nano',
-            models: ['gpt5', 'sonnet5']
+            models: ['gpt52', 'sonnet5']
         });
         const log = sinon.stub(console, 'log');
         try {
@@ -486,13 +488,13 @@ describe('benchmark plugin', () => {
 
         const output = log.args.flat().join('\n');
         expect(output).to.include('[benchmark] Generating criteria with gpt5nano.');
-        expect(output).to.include('[benchmark] Running response 1/2: gpt5.');
+        expect(output).to.include('[benchmark] Running response 1/2: gpt52.');
         expect(output).to.include('[benchmark] Running evaluation 2/2:');
         expect(output).to.include('[benchmark] Completed benchmark');
     });
 
     it('integrates with ModelMix json() and exposes the same report through lastRaw', async () => {
-        sinon.stub(MixOpenAI.prototype, 'create').callsFake(async ({ config, options }) => {
+        const respond = async ({ config, options }) => {
             if (config.system.includes('define evaluation criteria')) {
                 return metricsResult(JSON.stringify(criteria));
             }
@@ -501,11 +503,13 @@ describe('benchmark plugin', () => {
             }
             expect(options).to.not.have.property('response_format');
             return metricsResult(`response:${options.model}`);
-        });
+        };
+        sinon.stub(MixOpenAI.prototype, 'create').callsFake(respond);
+        sinon.stub(MixOpenAIResponses.prototype, 'create').callsFake(respond);
         const model = ModelMix.new()
             .use(benchmark({
                 criteriaModel: 'gpt5nano',
-                models: ['gpt5', 'gpt5mini']
+                models: ['gpt52', 'gpt5mini']
             }))
             .addText('Complete the task.');
 

package/skills/modelmix/SKILL.md

@@ -84,13 +84,13 @@ Chain shorthand methods to attach providers. First model is primary; others are
 
 ```javascript
 const model = ModelMix.new()
-    .sonnet46()        // primary
+    .sonnet5()         // primary
     .gpt52()           // fallback 1
     .gemini38flash()   // fallback 2
     .addText("Hello!")
 ```
 
-If `sonnet46` fails, it automatically tries `gpt52`, then `gemini38flash`.
+If `sonnet5` 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,7 +99,7 @@ provider default when no chain effort is configured:
 
 ```javascript
 const model = ModelMix.new()
-    .chain('sonnet46', 'gpt52@20', 'gemini38flash@-1')
+    .chain('sonnet5', 'gpt52@20', 'gemini38flash@-1')
     .addText('Hello!');
 ```
 
@@ -147,7 +147,7 @@ With plugin tools, native `options.tools` entries are combined with registered a
 Provider-agnostic reasoning intensity. **Not** an `options` field — use `config.effort` or `.effort(n)`.
 
 ```javascript
-ModelMix.new({ config: { effort: 40 } }).sonnet46().addText('Plan this refactor').message();
+ModelMix.new({ config: { effort: 40 } }).sonnet5().addText('Plan this refactor').message();
 ModelMix.new().deepseekV4Flash({ config: { effort: 100 } }).addText('...').message();
 ModelMix.new().effort(-1).minimaxM3().addText('Quick question').message();
 
@@ -164,7 +164,7 @@ ModelMix.new({ config: { effort: 80 } })
 | DeepSeek V4 | off | `low`↑ | `high`↑ | `high`↑ | `max`↑ | — |
 | MiniMax M3 | off | adaptive | adaptive | adaptive | adaptive | adaptive |
 
-\* GPT-6 Astra maps 0–39 / 40–59 / 60–79 / 80–99 / 100 to `low` / `medium` / `high` / `xhigh` / `max`. 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.
+\* GPT-6 Astra maps 0–39 / 40–59 / 60–79 / 80–99 / 100 to `low` / `medium` / `high` / `xhigh` / `max`. GPT-6 Sol, GPT-6 Luna, and GPT-5.6 map `100` to `max` and keep `xhigh` for 80–99, with OpenAI's `none` band at 0–19. 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: `kimiK26()`.
 
 ## Available Model Shorthands
 
@@ -172,31 +172,31 @@ ModelMix.new({ config: { effort: 80 } })
 
 Use `ModerationMix.new().openai()` with `.raw()` to classify text and images through OpenAI's Moderations endpoint. Read the results from `raw.moderation`. `ModerationMix` accepts moderation providers as ordered fallbacks, rejects generative providers, and does not generate text or support streaming.
 
-`gpt6astra()` `gpt56sol()` `gpt56terra()` `gpt56luna()` `gpt55()` `gpt55pro()` `gpt54()` `gpt54mini()` `gpt54nano()` `gpt54pro()` `gpt53codex()` `gpt53chat()` `gpt52()` `gpt51()` `gpt5()` `gpt5mini()` `gpt5nano()` `gptRealtime()` `gptRealtimeMini()` `gptOss()`
+`gpt6astra()` `gpt6sol()` `gpt6luna()` `gpt56sol()` `gpt56terra()` `gpt56luna()` `gpt55()` `gpt55pro()` `gpt54()` `gpt54mini()` `gpt54nano()` `gpt54pro()` `gpt52()` `gpt5mini()` `gpt5nano()` `gptRealtime()` `gptRealtimeMini()`
 
-Every textual GPT-5 and GPT-6 shortcut registers only the official OpenAI model by default. Pass `mix: { openrouter: true }` to `ModelMix.new()` or to an individual shortcut to append its `openai/*` OpenRouter route as a fallback. `gpt53chat()` uses `gpt-5.3-chat-latest` officially and `openai/gpt-5.3-chat` through OpenRouter. Both API keys are required when that fallback is enabled. Realtime shortcuts remain official-only.
+Every textual GPT-5 and GPT-6 shortcut registers only the official OpenAI model by default. Pass `mix: { openrouter: true }` to `ModelMix.new()` or to an individual shortcut to append its `openai/*` OpenRouter route as a fallback. Both API keys are required when that fallback is enabled. Realtime shortcuts remain official-only.
 
 ### Anthropic
-`fable51()` `fable50()` `opus55()` `opus50()` `opus48()` `opus47()` `opus46()` `sonnet5()` `sonnet46()` `sonnet45()` `haiku45()`
+`fable51()` `fable50()` `opus55()` `opus50()` `opus48()` `opus47()` `opus46()` `sonnet5()` `sonnet45()` `haiku45()`
 
 Use `.effort(n)` (or `config.effort`) to enable Anthropic thinking — e.g. `.effort(100).opus50()`. `fable5()` and `opus5()` remain available as compatibility aliases.
 
 `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()` `gemini38flash()` `gemini37flash()` `gemini36flash()` `gemini35flash()` `gemini35flashLite()` `gemini31flashLite()`
+`gemini38flash()` `gemini37flash()` `gemini36flash()` `gemini35flash()` `gemini35flashLite()` `gemini31flashLite()`
 
 ### Grok
-`grok47()` `grok46()` `grok45()` `grok43()` `grok420multiAgent()` `grok420()`
+`grok47()` `grok46()` `grok43()`
 
 ### Perplexity
 `sonar()` `sonarPro()`
 
 ### Together
-`museGlimmer30b()` `qwen36plus()` `qwen37plus()` `GLM52()` `kimiK25()` `kimiK26()` `kimiK27Code()` `kimiK3()` `minimaxM27()` `minimaxM3()` `gptOss()`
+`museGlimmer30b()` `qwen36plus()` `qwen37plus()` `GLM52()` `kimiK26()` `kimiK27Code()` `kimiK3()` `minimaxM27()` `minimaxM3()`
 
 ### NVIDIA
-`museGlimmer30b()` `gptOss()` `minimaxM27()`
+`museGlimmer30b()` `minimaxM27()`
 
 ### Moonshot
 `kimiK3()` — requires `MOONSHOT_API_KEY`; Fireworks, OpenRouter, and Together are available through `mix`.
@@ -208,12 +208,10 @@ Use `.effort(n)` (or `config.effort`) to enable Anthropic thinking — e.g. `.ef
 `mimo26pro()` — uses OpenRouter (`xiaomi/mimo-v2.6-pro`) by default; the native API requires `MIMO_API_KEY` and `mix: { mimo: true }`.
 
 ### DeepSeek
-`deepseekV41Flash({ mix: { deepseek: true, openrouter: false } })` uses the native API at `https://api.deepseek.com/chat/completions` with model `deepseek-flash` (currently V4.1 Flash). Requires `DEEPSEEK_API_KEY`; `MixDeepSeek` supports explicit `.attach()` calls. Unified effort and native cache usage are supported, and assistant reasoning is preserved for tool continuations. Cost estimates use peak rates per 1M tokens: $0.30 input, $0.006 cached input, $1.20 output; off-peak charges are half. Enabling all three providers orders them DeepSeek → Fireworks → OpenRouter.
+`deepseekV41Flash({ mix: { deepseek: true, openrouter: false } })` uses the native API at `https://api.deepseek.com/chat/completions` with model `deepseek-flash` (currently V4.1 Flash). Requires `DEEPSEEK_API_KEY`; `MixDeepSeek` supports explicit `.attach()` calls. Unified effort and native cache usage are supported, and assistant reasoning is preserved for tool continuations. Cost estimates use peak rates per 1M tokens: $0.30 input, $0.006 cached input, $1.20 output; off-peak charges are half. Optional routes: `mix: { fireworks: true }` selects `accounts/fireworks/models/deepseek-v4p1-flash` with `FIREWORKS_API_KEY`, and `mix: { openrouter: true }` selects `deepseek/deepseek-v4.1-flash` (text and image input) with `OPENROUTER_API_KEY`; enabling all three routes orders them DeepSeek → Fireworks → OpenRouter.
 
 ### Fireworks
-`museGlimmer30b()` `gptOss()` `qwen36plus()` (private/on-demand only) `qwen37plus()` `qwen38max()` `deepseekV4Flash()` `deepseekV4Pro()` `kimiK26()` `kimiK27Code()` `kimiK3()` `minimaxM27()` `minimaxM3()` `GLM52()`
-
-`deepseekV41Flash({ mix: { fireworks: true, openrouter: false } })` selects `accounts/fireworks/models/deepseek-v4p1-flash` and requires `FIREWORKS_API_KEY`. Per 1M tokens: $0.22 input, $0.007 cached input, $0.66 output. Set both providers to `true` for Fireworks followed by OpenRouter fallback; no arguments selects OpenRouter.
+`museGlimmer30b()` `qwen36plus()` (private/on-demand only) `qwen37plus()` `qwen38max()` `deepseekV4Flash()` `deepseekV4Pro()` `kimiK26()` `kimiK27Code()` `kimiK3()` `minimaxM27()` `minimaxM3()` `GLM52()`
 
 ### Cerebras
 `GLM46()`
@@ -221,14 +219,12 @@ Use `.effort(n)` (or `config.effort`) to enable Anthropic thinking — e.g. `.ef
 ### OpenRouter
 `deepseekPro()` uses `deepseek/deepseek-v4-pro-0813` through OpenRouter. Requires `OPENROUTER_API_KEY`; supports the DeepSeek effort mapping and `chain('deepseekPro@100')`. Base cost estimates per 1M tokens: $0.5808 input, $0.05808 cached input, $1.7424 output. Actual rates may change, including provider and time-based pricing.
 
-`museGlimmer30b()` `museSpark12()` `museSpark12c()` `museSpark13()` `museSpark13c()` `gptOss()` `qwen35397b()` `qwen36plus()` `qwen37plus()` `qwen3827b()` `qwen38flash()` `hermes470b()` `hermes4405b()` `qwen38max()` `kimiK27Code()` `kimiK3()` `minimaxM27()` `minimaxM3()` `GLM45()` `GLM52()` `GLM53()` `GLM53Flash()` `deepseekV41Flash()`
-
-`deepseekV41Flash()` selects `deepseek/deepseek-v4.1-flash` (text and image input) and requires `OPENROUTER_API_KEY`. It supports the DeepSeek effort mapping above, including `chain('deepseekV41Flash@100')`. Base cost estimates per 1M tokens: $0.15 input, $0.015 cached input, $0.60 output; actual OpenRouter pricing varies by provider and time.
+`museGlimmer30b()` `museSpark12()` `museSpark12c()` `museSpark13()` `museSpark13c()` `qwen35397b()` `qwen36plus()` `qwen37plus()` `qwen3827b()` `qwen38flash()` `hermes470b()` `hermes4405b()` `qwen38max()` `kimiK27Code()` `kimiK3()` `minimaxM27()` `minimaxM3()` `GLM45()` `GLM52()` `GLM53()` `GLM53Flash()`
 
 Muse Spark: the `c` suffix selects Contributor, where prompts and outputs may be used to improve Meta products. Without `c`, the standard tier is selected. Use `museSpark12c()` for the former `museSpark12()` Contributor behavior.
 
 ### Multi-provider (auto-fallback across free/paid tiers)
-`hermes3()` `kimiK25()`
+`hermes3()` `kimiK26()`
 
 ### Local
 `lmstudio()` — for LM Studio local models
@@ -411,7 +407,7 @@ console.log(model.lastRaw.think);    // reasoning content (if available)
 console.log(model.lastRaw.response); // raw API response
 ```
 
-### GPT-5.6 explicit prompt caching
+### GPT-5.6 and GPT-6 explicit prompt caching
 
 ```javascript
 const model = ModelMix.new()
@@ -434,9 +430,9 @@ const model = ModelMix.new()
 const result = await model.raw();
 ```
 
-`cache: { breakpoint: true }` is provider-neutral: GPT-5.6 receives `prompt_cache_breakpoint`, Anthropic receives `cache_control`, and unsupported providers omit it. Keep native request policies inside each model shorthand so they do not leak across fallbacks. Anthropic usage separates `cacheWrite5m` and `cacheWrite1h`; `cacheWrite` stays as their compatible aggregate.
+`cache: { breakpoint: true }` is provider-neutral: GPT-5.6 and GPT-6 receive `prompt_cache_breakpoint`, Anthropic receives `cache_control`, and unsupported providers omit it. Keep native request policies inside each model shorthand so they do not leak across fallbacks. Anthropic usage separates `cacheWrite5m` and `cacheWrite1h`; `cacheWrite` stays as their compatible aggregate.
 
-GPT-5.6 replaces `prompt_cache_retention` with `prompt_cache_options.ttl`. Explicit breakpoints also work on image methods and Responses-native `input_text`, `input_image`, and `input_file` blocks. Prompts need at least 1,024 tokens to be cached. Requests over 272K input tokens use 2× input and 1.5× output prices for the complete request; ModelMix applies these multipliers to `cost`, `costBreakdown`, and cache economics.
+GPT-5.6 and GPT-6 replace `prompt_cache_retention` with `prompt_cache_options.ttl`. Explicit breakpoints also work on image methods and Responses-native `input_text`, `input_image`, and `input_file` blocks. Prompts need at least 1,024 tokens to be cached. Requests over 272K input tokens use 2× input and 1.5× output prices for the complete request; ModelMix applies these multipliers to `cost`, `costBreakdown`, and cache economics.
 
 ### Add images
 
@@ -609,13 +605,13 @@ For full debug output, also set: `DEBUG=ModelMix* node script.js`
 
 ```javascript
 const model = ModelMix.new()
-    .gptOss()
-    .kimiK25()
+    .kimiK26()
+    .GLM52()
     .addText("What is the capital of France?");
 console.log(await model.message());
 ```
 
-These use providers with free quotas (Groq, Cerebras, and Together). OpenRouter is disabled because its GPT-OSS 120B route is no longer free. If one runs out of quota, ModelMix falls back to the next.
+Each shortcut registers its default provider and accepts additional providers through `mix`. If one model fails, ModelMix falls back to the next.
 
 ### Multi-provider routing
 
@@ -624,16 +620,11 @@ Some model shorthands register the same model across multiple providers for maxi
 ```javascript
 const model = ModelMix.new({
     mix: {
-        anthropic: true,    // fable51() default: true
-        openrouter: false,  // fallback default: false
-        cerebras: true,      // default: true
-        groq: true,          // default: true
-        together: false,     // default: false
-        lambda: false,       // default: false
-        minimax: false,      // default: false
-        fireworks: false     // default: false
+        fireworks: true,     // kimiK26() default: true
+        openrouter: false,   // default: false
+        together: false      // default: false
     }
-}).kimiK25();
+}).kimiK26();
 ```
 
 ## Agent Usage Rules

package/test/abort.test.js

@@ -443,7 +443,7 @@ describe('AbortSignal execution contract', () => {
             });
         });
         const model = ModelMix.new({ config: { bottleneck: { maxConcurrent: 1, minTime: 0 } } })
-            .gpt51()
+            .gpt52()
             .addText('test');
 
         const execution = model.raw(controller.signal);

package/test/bottleneck.test.js

@@ -72,9 +72,9 @@ describe('Rate Limiting with Bottleneck Tests', () => {
         it('should enforce minimum time between requests', async () => {
             const startTimes = [];
             
-            model.gpt51();
+            model.gpt52();
             
-            // Mock API responses (gpt51 uses /v1/responses)
+            // Mock API responses (gpt52 uses /v1/responses)
             nock('https://api.openai.com')
                 .post('/v1/responses')
                 .times(3)
@@ -116,9 +116,9 @@ describe('Rate Limiting with Bottleneck Tests', () => {
                 }
             });
             
-            model.gpt51();
+            model.gpt52();
             
-            // Mock API with delay to simulate concurrent requests (gpt51 uses /v1/responses)
+            // Mock API with delay to simulate concurrent requests (gpt52 uses /v1/responses)
             nock('https://api.openai.com')
                 .post('/v1/responses')
                 .times(5)
@@ -171,7 +171,7 @@ describe('Rate Limiting with Bottleneck Tests', () => {
         it('should apply rate limiting to OpenAI requests', async () => {
             const requestTimes = [];
             
-            model.gpt51();
+            model.gpt52();
             
             nock('https://api.openai.com')
                 .post('/v1/responses')
@@ -195,7 +195,7 @@ describe('Rate Limiting with Bottleneck Tests', () => {
         it('should apply rate limiting to Anthropic requests', async () => {
             const requestTimes = [];
             
-            model.sonnet46();
+            model.sonnet5();
             
             nock('https://api.anthropic.com')
                 .post('/v1/messages')
@@ -247,7 +247,7 @@ describe('Rate Limiting with Bottleneck Tests', () => {
         });
 
         it('should handle rate limiting with API errors', async () => {
-            model.gpt51({ mix: { openrouter: false } });
+            model.gpt52({ mix: { openrouter: false } });
             
             nock('https://api.openai.com')
                 .post('/v1/responses')
@@ -269,7 +269,7 @@ describe('Rate Limiting with Bottleneck Tests', () => {
         it('should continue rate limiting after errors', async () => {
             const requestTimes = [];
             
-            model.gpt51();
+            model.gpt52();
             
             // First request fails
             nock('https://api.openai.com')
@@ -319,7 +319,7 @@ describe('Rate Limiting with Bottleneck Tests', () => {
                 }
             });
             
-            model.gpt51();
+            model.gpt52();
             
             let requestCount = 0;
             
@@ -360,7 +360,7 @@ describe('Rate Limiting with Bottleneck Tests', () => {
                 }
             });
             
-            model.gpt51();
+            model.gpt52();
             
             const results = [];
             
@@ -403,7 +403,7 @@ describe('Rate Limiting with Bottleneck Tests', () => {
                 }
             });
             
-            model.gpt51();
+            model.gpt52();
             
             nock('https://api.openai.com')
                 .post('/v1/responses')
@@ -445,7 +445,7 @@ describe('Rate Limiting with Bottleneck Tests', () => {
                 done();
             });
             
-            model.gpt51();
+            model.gpt52();
             
             nock('https://api.openai.com')
                 .post('/v1/responses')

package/test/effort.test.js

@@ -90,6 +90,15 @@ describe('Unified effort scale', () => {
             }
         });
 
+        it('maps GPT-6 Sol and Luna effort from none to max', () => {
+            for (const model of ['gpt-6-sol', 'gpt-6-luna']) {
+                for (const [effort, level] of [[0, 'none'], [20, 'low'], [40, 'medium'], [60, 'high'], [99, 'xhigh'], [100, 'max']]) {
+                    expect(mapEffort('openai', effort, model)).to.deep.equal({ reasoning_effort: level });
+                }
+                expect(mapEffort('openai', 100, `openai/${model}`)).to.deep.equal({ reasoning_effort: 'max' });
+            }
+        });
+
         it('sets OpenAI adaptive only when supported (otherwise no-op)', () => {
             expect(mapEffort('openai', -1)).to.equal(null);
             expect(mapEffort('openai', -1, 'gpt-5.2')).to.equal(null);