modelmix 4.6.0 → 4.6.2

package/MODELS.md

@@ -344,6 +344,15 @@ All providers inherit from `MixCustom` base class which provides common function
 - **Output Format**: Same as OpenAI
 - **Special Notes**: Uses OpenAI-compatible format
 
+### Moonshot (MixKimi)
+- **Base URL**: `https://api.moonshot.ai/v1/chat/completions`
+- **Input Format**: Same as OpenAI
+- **Output Format**: Same as OpenAI
+- **Special Notes**:
+  - Requires `MOONSHOT_API_KEY` environment variable
+  - Available model: `kimi-k3`
+  - K3 always uses thinking and requires fixed sampling parameters to be omitted
+
 ### MiniMax (MixMiniMax)
 - **Base URL**: `https://api.minimax.io/v1/chat/completions`
 - **Input Format**: Same as OpenAI

package/README.md

@@ -32,6 +32,7 @@ Only the API keys you plan to use are required.
 ANTHROPIC_API_KEY="sk-ant-..."
 OPENAI_API_KEY="sk-proj-..."
 OPENROUTER_API_KEY="sk-or-..."
+MOONSHOT_API_KEY="your-moonshot-key..."
 MINIMAX_API_KEY="your-minimax-key..."
 NVIDIA_API_KEY="nvapi-..."
 ...
@@ -175,6 +176,7 @@ Here's a comprehensive list of available methods:
 | `sonar()`           | Perplexity | sonar                        | [\$1.00 / \$1.00][4]       |
 | `sonarPro()`        | Perplexity | sonar-pro                    | [\$3.00 / \$15.00][4]      |
 | `hermes3()`         | Lambda     | Hermes-3-Llama-3.1-405B-FP8  | [\$0.80 / \$0.80][8]       |
+| `kimiK3()`          | Moonshot   | kimi-k3                      | [\$3.00 / \$15.00][11]     |
 | `kimiK25think()`    | Together   | Kimi-K2.5                    | [\$0.50 / \$2.80][7]       |
 | `kimiK26think()`    | Fireworks  | models/kimi-k2p6             | [\$0.95 / \$4.00][10]      |
 
@@ -188,10 +190,12 @@ Here's a comprehensive list of available methods:
 [8]: https://lambda.ai/inference "Lambda Pricing"
 [9]: https://platform.minimax.io/docs/api-reference/anthropic-api-compatible-cache#supported-models-and-pricing "MiniMax Pricing"
 [10]: https://fireworks.ai/pricing#serverless-pricing "Fireworks Pricing"
+[11]: https://platform.kimi.ai/docs/guide/kimi-k3-pricing "Kimi K3 Pricing"
 
 Each method accepts optional `options`, `config`, and (for multi-provider methods) `mix` parameters to customize behavior.  
 For NVIDIA on DeepSeek V4 Pro, use `deepseekV4Pro({ mix: { nvidia: true } })`.
 For Together on Qwen 3.6 Plus, use `qwen36plus({ mix: { fireworks: false, together: true } })`.
+For OpenRouter instead of Moonshot's native API, use `kimiK3({ mix: { moonshot: false, openrouter: true } })`.
 
 ```javascript
 const result = await ModelMix.new({ 

package/demo/default.env

@@ -7,4 +7,5 @@ XAI_API_KEY="xai-..."
 CEREBRAS_API_KEY="csk-..."
 GEMINI_API_KEY="AIza..."
 LAMBDA_API_KEY="secret_..."
+MOONSHOT_API_KEY="your-moonshot-key..."
 BRAVE_API_KEY="BSA0..._fm"

package/index.js

@@ -118,6 +118,9 @@ const MODEL_PRICING = {
     // Kimi K2.5 (Together/Fireworks/OpenRouter)
     'moonshotai/Kimi-K2.5': [0.50, 2.80],
     'moonshotai/kimi-k2.5': [0.50, 2.80],
+    // Kimi K3
+    'kimi-k3': [3.00, 15.00],
+    'moonshotai/kimi-k3': [3.00, 15.00],
     // DeepSeek V3.2 (OpenRouter)
     'deepseek/deepseek-v3.2': [0.56, 1.68],
     // GLM 4.7 (OpenRouter/Cerebras)
@@ -523,6 +526,13 @@ class ModelMix {
         return this;
     }
 
+    kimiK3({ options = {}, config = {}, mix = { moonshot: true, openrouter: false } } = {}) {
+        mix = { ...this.mix, ...mix };
+        if (mix.moonshot) this.attach('kimi-k3', new MixKimi({ options, config }));
+        if (mix.openrouter) this.attach('moonshotai/kimi-k3', new MixOpenRouter({ options, config }));
+        return this;
+    }
+
     kimiK25think({ options = {}, config = {}, mix = { together: true } } = {}) {
         mix = { ...this.mix, ...mix };
         if (mix.together) this.attach('moonshotai/Kimi-K2.5', new MixTogether({ options, config }));
@@ -1079,8 +1089,9 @@ class ModelMix {
                     }
 
                     if (result.toolCalls && result.toolCalls.length > 0) {
-
-                        if (result.message) {
+                        if (result.assistantMessage) {
+                            this.messages.push(result.assistantMessage);
+                        } else if (result.message) {
                             if (result.signature) {
                                 this.messages.push({
                                     role: "assistant", content: [{
@@ -1094,7 +1105,9 @@ class ModelMix {
                             }
                         }
 
-                        this.messages.push({ role: "assistant", content: null, tool_calls: result.toolCalls });
+                        if (!result.assistantMessage) {
+                            this.messages.push({ role: "assistant", content: null, tool_calls: result.toolCalls });
+                        }
 
                         const toolResults = await this.processToolCalls(result.toolCalls);
                         for (const toolResult of toolResults) {
@@ -1153,7 +1166,9 @@ class ModelMix {
                         this.messages = [];
                     } else if (result.message) {
                         // Persist assistant response for multi-turn conversations
-                        if (result.signature) {
+                        if (result.assistantMessage) {
+                            this.messages.push(result.assistantMessage);
+                        } else if (result.signature) {
                             this.messages.push({
                                 role: "assistant", content: [{
                                     type: "thinking",
@@ -1653,7 +1668,12 @@ class MixOpenAI extends MixCustom {
         for (const message of messages) {
 
             if (message.tool_calls) {
-                results.push({ role: 'assistant', tool_calls: message.tool_calls })
+                results.push({
+                    role: 'assistant',
+                    content: message.content ?? null,
+                    ...(message.reasoning_content && { reasoning_content: message.reasoning_content }),
+                    tool_calls: message.tool_calls
+                })
                 continue;
             }
 
@@ -2102,6 +2122,46 @@ class MixOpenRouter extends MixOpenAI {
     }
 }
 
+class MixKimi extends MixOpenAI {
+    getDefaultConfig(customConfig) {
+        if (!process.env.MOONSHOT_API_KEY) {
+            throw new Error('Moonshot API key not found. Please provide it in config or set MOONSHOT_API_KEY environment variable.');
+        }
+
+        return MixCustom.prototype.getDefaultConfig.call(this, {
+            url: 'https://api.moonshot.ai/v1/chat/completions',
+            apiKey: process.env.MOONSHOT_API_KEY,
+            ...customConfig
+        });
+    }
+
+    async create({ config = {}, options = {} } = {}) {
+        if (Object.hasOwn(options, 'max_tokens')) {
+            options.max_completion_tokens = options.max_tokens;
+            delete options.max_tokens;
+        }
+
+        delete options.temperature;
+        delete options.top_p;
+        delete options.n;
+        delete options.presence_penalty;
+        delete options.frequency_penalty;
+
+        return super.create({ config, options });
+    }
+
+    extractDelta(data) {
+        return data?.choices?.[0]?.delta?.content || '';
+    }
+
+    processResponse(response) {
+        return {
+            ...super.processResponse(response),
+            assistantMessage: response.data?.choices?.[0]?.message
+        };
+    }
+}
+
 class MixAnthropic extends MixCustom {
 
     static thinkingOptions = {
@@ -2931,4 +2991,4 @@ class MixGoogle extends MixCustom {
     }
 }
 
-module.exports = { MixCustom, ModelMix, MixAnthropic, MixMiniMax, MixMiMo, MixOpenAI, MixOpenAIResponses, MixOpenAIWebSocket, MixOpenRouter, MixPerplexity, MixOllama, MixLMStudio, MixGroq, MixTogether, MixGrok, MixCerebras, MixGoogle, MixFireworks, MixNVIDIA };
+module.exports = { MixCustom, ModelMix, MixAnthropic, MixKimi, MixMiniMax, MixMiMo, MixOpenAI, MixOpenAIResponses, MixOpenAIWebSocket, MixOpenRouter, MixPerplexity, MixOllama, MixLMStudio, MixGroq, MixTogether, MixGrok, MixCerebras, MixGoogle, MixFireworks, MixNVIDIA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "4.6.0",
+  "version": "4.6.2",
   "description": "🧬 Reliable interface with automatic fallback for AI LLMs.",
   "main": "index.js",
   "repository": {

package/skills/modelmix/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: modelmix
-description: Instructions for using the ModelMix Node.js library to interact with multiple AI LLM providers through a unified interface. Use when writing code that calls AI models (OpenAI, Anthropic, Google, Groq, Perplexity, Grok, MiniMax, Fireworks, Together, Lambda, Cerebras, OpenRouter, Ollama, LM Studio), chaining models with fallback, getting structured JSON from LLMs, adding MCP tools, streaming responses, managing multi-provider AI workflows, round-robin load balancing, or rate limiting API requests in Node.js. Also use when the user mentions "modelmix", "ModelMix", asks to "call an LLM", "query a model", "add AI to my app", or wants to integrate any supported provider.
+description: Instructions for using the ModelMix Node.js library to interact with multiple AI LLM providers through a unified interface. Use when writing code that calls AI models (OpenAI, Anthropic, Google, Groq, Perplexity, Grok, Moonshot, MiniMax, Fireworks, Together, Lambda, Cerebras, OpenRouter, Ollama, LM Studio), chaining models with fallback, getting structured JSON from LLMs, adding MCP tools, streaming responses, managing multi-provider AI workflows, round-robin load balancing, or rate limiting API requests in Node.js. Also use when the user mentions "modelmix", "ModelMix", asks to "call an LLM", "query a model", "add AI to my app", or wants to integrate any supported provider.
 metadata:
   tags: [llm, ai, openai, anthropic, google, groq, perplexity, grok, mcp, streaming, json-output]
 ---
@@ -112,6 +112,9 @@ Thinking variants: append `think` — e.g. `fable5think()` `opus48think()` `opus
 ### Together
 `qwen36plus()` `GLM52()` `kimiK25think()` `gptOss()`
 
+### Moonshot
+`kimiK3()` — requires `MOONSHOT_API_KEY`; use `{ mix: { moonshot: false, openrouter: true } }` for OpenRouter.
+
 ### MiniMax
 `minimaxM25()` `minimaxM27()` `minimaxM3()`
 
@@ -471,7 +474,7 @@ const model = ModelMix.new({
 
 ## Available Provider Classes
 
-`MixOpenAI` `MixAnthropic` `MixGoogle` `MixPerplexity` `MixGroq` `MixTogether` `MixGrok` `MixOpenRouter` `MixOllama` `MixLMStudio` `MixCustom` `MixCerebras` `MixFireworks` `MixMiniMax` `MixLambda`
+`MixOpenAI` `MixAnthropic` `MixGoogle` `MixPerplexity` `MixGroq` `MixTogether` `MixGrok` `MixOpenRouter` `MixOllama` `MixLMStudio` `MixCustom` `MixCerebras` `MixFireworks` `MixKimi` `MixMiniMax` `MixLambda`
 
 ## Troubleshooting
 

package/test/kimi.test.js

@@ -1,5 +1,6 @@
 const { expect } = require('chai');
-const { ModelMix, MixTogether } = require('../index.js');
+const nock = require('nock');
+const { ModelMix, MixKimi, MixOpenRouter, MixTogether } = require('../index.js');
 
 describe('Kimi Model Registration Tests', () => {
     it('should register Together Kimi K2.7 Code by default', () => {
@@ -10,4 +11,146 @@ describe('Kimi Model Registration Tests', () => {
         expect(model.models[0].key).to.equal('moonshotai/Kimi-K2.7-Code');
         expect(model.models[0].provider).to.be.instanceOf(MixTogether);
     });
+
+    it('should register Kimi K3 with the native Moonshot provider by default', () => {
+        const originalMoonshotApiKey = process.env.MOONSHOT_API_KEY;
+        process.env.MOONSHOT_API_KEY = 'test-moonshot-key';
+
+        try {
+            const model = ModelMix.new().kimiK3();
+
+            expect(model.models).to.have.length(1);
+            expect(model.models[0].key).to.equal('kimi-k3');
+            expect(model.models[0].provider).to.be.instanceOf(MixKimi);
+            expect(model.models[0].provider.config.url).to.equal('https://api.moonshot.ai/v1/chat/completions');
+        } finally {
+            if (originalMoonshotApiKey === undefined) delete process.env.MOONSHOT_API_KEY;
+            else process.env.MOONSHOT_API_KEY = originalMoonshotApiKey;
+        }
+    });
+
+    it('should support Kimi K3 through OpenRouter when requested', () => {
+        const originalOpenRouterApiKey = process.env.OPENROUTER_API_KEY;
+        process.env.OPENROUTER_API_KEY = 'test-openrouter-key';
+
+        try {
+            const model = ModelMix.new().kimiK3({ mix: { moonshot: false, openrouter: true } });
+
+            expect(model.models).to.have.length(1);
+            expect(model.models[0].key).to.equal('moonshotai/kimi-k3');
+            expect(model.models[0].provider).to.be.instanceOf(MixOpenRouter);
+        } finally {
+            if (originalOpenRouterApiKey === undefined) delete process.env.OPENROUTER_API_KEY;
+            else process.env.OPENROUTER_API_KEY = originalOpenRouterApiKey;
+        }
+    });
+
+    it('should adapt Kimi K3 requests to its fixed sampling API', async () => {
+        const originalMoonshotApiKey = process.env.MOONSHOT_API_KEY;
+        process.env.MOONSHOT_API_KEY = 'test-moonshot-key';
+
+        try {
+            const provider = new MixKimi();
+            let requestBody;
+            nock('https://api.moonshot.ai')
+                .post('/v1/chat/completions', body => {
+                    requestBody = body;
+                    return true;
+                })
+                .reply(200, {
+                    choices: [{ message: { content: 'Done' } }]
+                });
+
+            await provider.create({
+                config: { system: 'You are an assistant.' },
+                options: {
+                    model: 'kimi-k3',
+                    messages: [{ role: 'user', content: 'Hello' }],
+                    max_tokens: 1000,
+                    temperature: 0.5,
+                    top_p: 0.9,
+                    n: 2,
+                    presence_penalty: 0.2,
+                    frequency_penalty: 0.3
+                }
+            });
+
+            expect(requestBody.max_completion_tokens).to.equal(1000);
+            expect(requestBody).to.not.have.property('max_tokens');
+            expect(requestBody).to.not.have.property('temperature');
+            expect(requestBody).to.not.have.property('top_p');
+            expect(requestBody).to.not.have.property('n');
+            expect(requestBody).to.not.have.property('presence_penalty');
+            expect(requestBody).to.not.have.property('frequency_penalty');
+        } finally {
+            if (originalMoonshotApiKey === undefined) delete process.env.MOONSHOT_API_KEY;
+            else process.env.MOONSHOT_API_KEY = originalMoonshotApiKey;
+        }
+    });
+
+    it('should preserve Kimi K3 reasoning content in tool-call continuations', async () => {
+        const originalMoonshotApiKey = process.env.MOONSHOT_API_KEY;
+        process.env.MOONSHOT_API_KEY = 'test-moonshot-key';
+
+        try {
+            let continuationBody;
+            nock('https://api.moonshot.ai')
+                .post('/v1/chat/completions')
+                .reply(200, {
+                    choices: [{
+                        message: {
+                            role: 'assistant',
+                            content: 'I will calculate that.',
+                            reasoning_content: 'I need the calculator tool.',
+                            tool_calls: [{
+                                id: 'call_calculate',
+                                type: 'function',
+                                function: {
+                                    name: 'calculate',
+                                    arguments: '{"expression":"2 + 2"}'
+                                }
+                            }]
+                        }
+                    }]
+                })
+                .post('/v1/chat/completions', body => {
+                    continuationBody = body;
+                    return true;
+                })
+                .reply(200, {
+                    choices: [{ message: { role: 'assistant', content: 'The answer is 4.' } }]
+                });
+
+            const model = ModelMix.new().kimiK3();
+            model.addTool({
+                name: 'calculate',
+                description: 'Evaluates an expression.',
+                inputSchema: {
+                    type: 'object',
+                    properties: { expression: { type: 'string' } },
+                    required: ['expression']
+                }
+            }, ({ expression }) => expression === '2 + 2' ? 4 : null);
+            model.addText('What is 2 + 2?');
+
+            expect(await model.message()).to.equal('The answer is 4.');
+            const assistantMessage = continuationBody.messages.find(message => message.role === 'assistant');
+            expect(assistantMessage).to.deep.equal({
+                role: 'assistant',
+                content: 'I will calculate that.',
+                reasoning_content: 'I need the calculator tool.',
+                tool_calls: [{
+                    id: 'call_calculate',
+                    type: 'function',
+                    function: {
+                        name: 'calculate',
+                        arguments: '{"expression":"2 + 2"}'
+                    }
+                }]
+            });
+        } finally {
+            if (originalMoonshotApiKey === undefined) delete process.env.MOONSHOT_API_KEY;
+            else process.env.MOONSHOT_API_KEY = originalMoonshotApiKey;
+        }
+    });
 });