feat: add MiniMax as LLM provider

Add MiniMax (api.minimax.io) as a fifth LLM provider option alongside
Anthropic, OpenAI, Gemini, and Codex. MiniMax offers an
OpenAI-compatible Chat Completions API with the M2.5 model (204K
context window).

Changes:
- lib/llm/minimax.mjs: new provider using raw fetch (no SDK)
- lib/llm/index.mjs: register MiniMax in the factory
- .env.example, crucix.config.mjs, README.md: document the new option
- test/llm-minimax.test.mjs: 10 unit tests (node:test)
- test/llm-minimax-integration.test.mjs: live API integration test

Usage:
  LLM_PROVIDER=minimax
  LLM_API_KEY=sk-...
  LLM_MODEL=MiniMax-M2.5          # optional, this is the default

test/llm-minimax-integration.test.mjs

@@ -0,0 +1,30 @@
+// MiniMax provider — integration test (calls real API)
+// Requires MINIMAX_API_KEY environment variable
+// Run: MINIMAX_API_KEY=sk-... node --test test/llm-minimax-integration.test.mjs
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { MiniMaxProvider } from '../lib/llm/minimax.mjs';
+
+const API_KEY = process.env.MINIMAX_API_KEY;
+
+describe('MiniMax integration', { skip: !API_KEY && 'MINIMAX_API_KEY not set' }, () => {
+  it('should complete a prompt with MiniMax-M2.5', async () => {
+    const provider = new MiniMaxProvider({ apiKey: API_KEY, model: 'MiniMax-M2.5' });
+    assert.equal(provider.isConfigured, true);
+
+    const result = await provider.complete(
+      'You are a helpful assistant. Respond in exactly one sentence.',
+      'What is 2+2?',
+      { maxTokens: 128, timeout: 30000 }
+    );
+
+    assert.ok(result.text.length > 0, 'Response text should not be empty');
+    assert.ok(result.usage.inputTokens > 0, 'Should report input tokens');
+    assert.ok(result.usage.outputTokens > 0, 'Should report output tokens');
+    assert.ok(result.model, 'Should report model name');
+    console.log(`  Response: ${result.text}`);
+    console.log(`  Tokens: ${result.usage.inputTokens} in / ${result.usage.outputTokens} out`);
+    console.log(`  Model: ${result.model}`);
+  });
+});

test/llm-minimax.test.mjs

@@ -0,0 +1,144 @@
+// MiniMax provider — unit tests
+// Uses Node.js built-in test runner (node:test) — no extra dependencies
+
+import { describe, it, mock, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { MiniMaxProvider } from '../lib/llm/minimax.mjs';
+import { createLLMProvider } from '../lib/llm/index.mjs';
+
+// ─── Unit Tests ───
+
+describe('MiniMaxProvider', () => {
+  it('should set defaults correctly', () => {
+    const provider = new MiniMaxProvider({ apiKey: 'sk-test' });
+    assert.equal(provider.name, 'minimax');
+    assert.equal(provider.model, 'MiniMax-M2.5');
+    assert.equal(provider.isConfigured, true);
+  });
+
+  it('should accept custom model', () => {
+    const provider = new MiniMaxProvider({ apiKey: 'sk-test', model: 'MiniMax-M2.5-highspeed' });
+    assert.equal(provider.model, 'MiniMax-M2.5-highspeed');
+  });
+
+  it('should report not configured without API key', () => {
+    const provider = new MiniMaxProvider({});
+    assert.equal(provider.isConfigured, false);
+  });
+
+  it('should throw on API error', async () => {
+    const provider = new MiniMaxProvider({ apiKey: 'sk-test' });
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock.fn(() =>
+      Promise.resolve({ ok: false, status: 401, text: () => Promise.resolve('Unauthorized') })
+    );
+    try {
+      await assert.rejects(
+        () => provider.complete('system', 'user'),
+        (err) => {
+          assert.match(err.message, /MiniMax API 401/);
+          return true;
+        }
+      );
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('should parse successful response', async () => {
+    const provider = new MiniMaxProvider({ apiKey: 'sk-test' });
+    const mockResponse = {
+      choices: [{ message: { content: 'Hello from MiniMax' } }],
+      usage: { prompt_tokens: 10, completion_tokens: 5 },
+      model: 'MiniMax-M2.5',
+    };
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock.fn(() =>
+      Promise.resolve({ ok: true, json: () => Promise.resolve(mockResponse) })
+    );
+    try {
+      const result = await provider.complete('You are helpful.', 'Say hello');
+      assert.equal(result.text, 'Hello from MiniMax');
+      assert.equal(result.usage.inputTokens, 10);
+      assert.equal(result.usage.outputTokens, 5);
+      assert.equal(result.model, 'MiniMax-M2.5');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('should send correct request format', async () => {
+    const provider = new MiniMaxProvider({ apiKey: 'sk-test-key', model: 'MiniMax-M2.5' });
+    let capturedUrl, capturedOpts;
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock.fn((url, opts) => {
+      capturedUrl = url;
+      capturedOpts = opts;
+      return Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({
+          choices: [{ message: { content: 'ok' } }],
+          usage: { prompt_tokens: 1, completion_tokens: 1 },
+          model: 'MiniMax-M2.5',
+        }),
+      });
+    });
+    try {
+      await provider.complete('system prompt', 'user message', { maxTokens: 2048 });
+      assert.equal(capturedUrl, 'https://api.minimax.io/v1/chat/completions');
+      assert.equal(capturedOpts.method, 'POST');
+      const headers = capturedOpts.headers;
+      assert.equal(headers['Content-Type'], 'application/json');
+      assert.equal(headers['Authorization'], 'Bearer sk-test-key');
+      const body = JSON.parse(capturedOpts.body);
+      assert.equal(body.model, 'MiniMax-M2.5');
+      assert.equal(body.max_tokens, 2048);
+      assert.equal(body.messages[0].role, 'system');
+      assert.equal(body.messages[0].content, 'system prompt');
+      assert.equal(body.messages[1].role, 'user');
+      assert.equal(body.messages[1].content, 'user message');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('should handle empty response gracefully', async () => {
+    const provider = new MiniMaxProvider({ apiKey: 'sk-test' });
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock.fn(() =>
+      Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({ choices: [], usage: {} }),
+      })
+    );
+    try {
+      const result = await provider.complete('sys', 'user');
+      assert.equal(result.text, '');
+      assert.equal(result.usage.inputTokens, 0);
+      assert.equal(result.usage.outputTokens, 0);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+// ─── Factory Tests ───
+
+describe('createLLMProvider — minimax', () => {
+  it('should create MiniMaxProvider for provider=minimax', () => {
+    const provider = createLLMProvider({ provider: 'minimax', apiKey: 'sk-test', model: null });
+    assert.ok(provider instanceof MiniMaxProvider);
+    assert.equal(provider.name, 'minimax');
+    assert.equal(provider.isConfigured, true);
+  });
+
+  it('should be case-insensitive', () => {
+    const provider = createLLMProvider({ provider: 'MiniMax', apiKey: 'sk-test', model: null });
+    assert.ok(provider instanceof MiniMaxProvider);
+  });
+
+  it('should return null for empty provider', () => {
+    const provider = createLLMProvider({ provider: null, apiKey: 'sk-test', model: null });
+    assert.equal(provider, null);
+  });
+});