@askalf/dario 6.13.28 → 6.13.30

package/dist/cli.js

@@ -64,7 +64,7 @@ import { grantAge, describeGrantAge } from './refresh-grant.js';
 import { listAccountAliases, loadAllAccounts, addAccountViaOAuth, addAccountViaManualOAuth, addAccountFromKeychain, KeychainImportError, removeAccount, ensureLoginCredentialsInPool, resyncLoginFromCredentialsIfStale, MIGRATED_LOGIN_ALIAS } from './accounts.js';
 import { listCodexAccountAliases, loadAllCodexAccounts, startAddCodexAccount, completeAddCodexAccount, removeCodexAccount, parseCodexManualPaste } from './codex-accounts.js';
 import { describeCodexWindow } from './codex-usage.js';
-import { listBackends, saveBackend, removeBackend } from './openai-backend.js';
+import { listBackends, saveBackend, removeBackend, defaultBackendBaseUrl } from './openai-backend.js';
 import { parseOutboundProxy, installOutboundProxyWrapper } from './outbound-proxy.js';
 // `args` / `command` at module scope — command handlers below close over
 // `args` to read their own flags. Reading argv is harmless on import; only
@@ -1788,6 +1788,7 @@ async function backend() {
             console.error('    dario backend add openai --key=sk-proj-...');
             console.error('    dario backend add groq   --key=gsk_... --base-url=https://api.groq.com/openai/v1');
             console.error('    dario backend add openrouter --key=sk-or-... --base-url=https://openrouter.ai/api/v1');
+            console.error('    dario backend add minimax --key=<api-key>  (global; minimax-cn for China)');
             console.error('');
             process.exit(1);
         }
@@ -1798,7 +1799,7 @@ async function backend() {
         const keyArg = args.find(a => a.startsWith('--key='));
         const baseUrlArg = args.find(a => a.startsWith('--base-url='));
         const apiKey = keyArg ? keyArg.split('=').slice(1).join('=') : '';
-        const baseUrl = baseUrlArg ? baseUrlArg.split('=').slice(1).join('=') : 'https://api.openai.com/v1';
+        const baseUrl = baseUrlArg ? baseUrlArg.split('=').slice(1).join('=') : defaultBackendBaseUrl(name);
         if (!apiKey) {
             console.error('[dario] --key=<api-key> is required.');
             process.exit(1);

package/dist/live-fingerprint.d.ts

@@ -518,7 +518,7 @@ export declare function detectDrift(t: TemplateData, installedOverride?: string
  */
 export declare const SUPPORTED_CC_RANGE: {
     readonly min: "1.0.0";
-    readonly maxTested: "2.1.308";
+    readonly maxTested: "2.1.309";
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/live-fingerprint.js

@@ -1238,7 +1238,7 @@ export function detectDrift(t, installedOverride) {
  */
 export const SUPPORTED_CC_RANGE = {
     min: '1.0.0',
-    maxTested: '2.1.308',
+    maxTested: '2.1.309',
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/openai-backend.d.ts

@@ -1,4 +1,9 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare const MINIMAX_MODELS: readonly ["MiniMax-M3.1-Flash", "MiniMax-M3"];
+/** Presets use the existing single OpenAI-compatible backend slot. */
+export declare function defaultBackendBaseUrl(name: string): string;
+/** Only direct endpoints imply a MiniMax catalog; custom gateways stay explicit. */
+export declare function isMiniMaxBackend(backend: BackendCredentials | null): boolean;
 export interface BackendCredentials {
     provider: string;
     name: string;

package/dist/openai-backend.js

@@ -17,6 +17,20 @@ import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 const DARIO_DIR = join(homedir(), '.dario');
 const BACKENDS_DIR = join(DARIO_DIR, 'backends');
+export const MINIMAX_MODELS = ['MiniMax-M3.1-Flash', 'MiniMax-M3'];
+/** Presets use the existing single OpenAI-compatible backend slot. */
+export function defaultBackendBaseUrl(name) {
+    if (name.toLowerCase() === 'minimax')
+        return 'https://api.minimax.io/v1';
+    if (name.toLowerCase() === 'minimax-cn')
+        return 'https://api.minimax.cn/v1';
+    return 'https://api.openai.com/v1';
+}
+/** Only direct endpoints imply a MiniMax catalog; custom gateways stay explicit. */
+export function isMiniMaxBackend(backend) {
+    return backend?.provider === 'openai' &&
+        ['https://api.minimax.io/v1', 'https://api.minimax.cn/v1', 'https://api.minimaxi.com/v1'].includes(backend.baseUrl.replace(/\/$/, ''));
+}
 /**
  * Normalize a caller-supplied backend name into a filesystem-safe leaf.
  * Strips any directory component and rejects names outside the allowed

package/dist/proxy.d.ts

@@ -3,6 +3,7 @@ import { type WriteStream } from 'node:fs';
 import { getAccessToken, getStatus } from './oauth.js';
 import { type EffortValue } from './cc-template.js';
 import { type KeySocket } from './keys.js';
+import { type BackendCredentials } from './openai-backend.js';
 /**
  * Assemble the `x-anthropic-billing-header` system-block text, following
  * Claude Code's format:
@@ -87,6 +88,7 @@ export declare function budgetModelsFor(clientModel: string, ctx: {
     cliProviderOverride: 'openai' | 'claude' | 'codex' | null;
     cliModelRaw: string | null | undefined;
     isOpenAI: boolean;
+    compatBackend?: CompatBackendKind;
 }): string[];
 /**
  * Rebuild an OpenAI-shape request body with the model swapped to the pool-
@@ -95,6 +97,16 @@ export declare function budgetModelsFor(clientModel: string, ctx: {
  * tests; the two call sites are the pool-exhausted dispatch paths.
  */
 export declare function buildPoolFallbackBody(body: Buffer, fallbackModel: string): Buffer | null;
+/** Which kind of OpenAI-compatible backend is configured: a direct MiniMax endpoint, any other gateway, or none. */
+export type CompatBackendKind = 'minimax' | 'gateway' | null;
+export declare function compatBackendKind(backend: BackendCredentials | null): CompatBackendKind;
+/**
+ * The bare `minimax` model. On a direct MiniMax endpoint it is the shorthand for
+ * MiniMax-M3.1-Flash. On a custom gateway it is that gateway's own model id: the request goes
+ * to the gateway with the name unchanged (dario#1649 review). With no compatible backend it is
+ * left alone. `minimax:<model>` is explicit and always honored by the prefix parser.
+ */
+export declare function miniMaxShorthand(model: string, backend: CompatBackendKind): string;
 export declare function parseProviderPrefix(model: string): {
     provider: 'openai' | 'claude' | 'codex';
     model: string;

package/dist/proxy.js

@@ -30,7 +30,7 @@ import { resolveSeatPin, SEAT_PIN_HEADER, SEAT_PIN_TOKEN_HEADER } from './seat-p
 import { loadAllAccounts, loadAccount, saveAccount, refreshAccountToken, resyncLoginFromCredentialsIfStale, ensureLoginCredentialsInPool, mirrorLoginToCredentials, withObservedOrganization } from './accounts.js';
 import { handleAdminRequest } from './admin-api.js';
 import { createTokenBucket } from './rate-limit.js';
-import { getOpenAIBackend, isOpenAIModel, forwardToOpenAI } from './openai-backend.js';
+import { getOpenAIBackend, isOpenAIModel, forwardToOpenAI, isMiniMaxBackend, MINIMAX_MODELS } from './openai-backend.js';
 import { forwardToCodex, forwardResponsesToCodex, getCodexModelSlugs, peekCodexModelSlugs, isCodexModel, pickCodexFallback, pickClaudeTarget, CODEX_BACKEND_BASE_URL } from './codex-backend.js';
 import { effortForCodex } from './effort.js';
 import { MidstreamGuard, guardFor, loopbackBaseFor, chaosCutFetch, chaosCutState, CONTINUATION_HEADER, CONTINUATION_OF_HEADER, MAX_CONTINUATION_DEPTH, continuationDepth, continuationOfRequest } from './midstream.js';
@@ -378,7 +378,7 @@ export function selectModelOverride(incomingModel, modelOverride, fastModelOverr
  */
 export function budgetModelsFor(clientModel, ctx) {
     const out = new Set();
-    const aliased = applyModelAlias(clientModel, ctx.modelAliases) ?? clientModel;
+    const aliased = miniMaxShorthand(applyModelAlias(clientModel, ctx.modelAliases) ?? clientModel, ctx.compatBackend ?? null);
     const prefix = parseProviderPrefix(aliased);
     if (prefix) {
         out.add(prefix.provider === 'claude' ? resolveClaudeAlias(parseEffortSuffix(prefix.model).model) : prefix.model);
@@ -406,6 +406,7 @@ const PROVIDER_PREFIXES = {
     openai: 'openai',
     openrouter: 'openai',
     groq: 'openai',
+    minimax: 'openai',
     compat: 'openai',
     local: 'openai',
     codex: 'codex',
@@ -431,6 +432,26 @@ export function buildPoolFallbackBody(body, fallbackModel) {
         return null;
     }
 }
+export function compatBackendKind(backend) {
+    if (!backend)
+        return null;
+    return isMiniMaxBackend(backend) ? 'minimax' : 'gateway';
+}
+/**
+ * The bare `minimax` model. On a direct MiniMax endpoint it is the shorthand for
+ * MiniMax-M3.1-Flash. On a custom gateway it is that gateway's own model id: the request goes
+ * to the gateway with the name unchanged (dario#1649 review). With no compatible backend it is
+ * left alone. `minimax:<model>` is explicit and always honored by the prefix parser.
+ */
+export function miniMaxShorthand(model, backend) {
+    if (model.toLowerCase() !== 'minimax')
+        return model;
+    if (backend === 'minimax')
+        return `minimax:${MINIMAX_MODELS[0]}`;
+    if (backend === 'gateway')
+        return `openai:${model}`;
+    return model;
+}
 export function parseProviderPrefix(model) {
     const idx = model.indexOf(':');
     if (idx <= 0)
@@ -1915,14 +1936,14 @@ export async function startProxy(opts = {}) {
     // Parse --model once at startup. Supports `<provider>:<model>` to force
     // a backend for every request (e.g. `--model=openai:gpt-4o`). Back-compat:
     // bare names like `opus` resolve via MODEL_ALIASES.
-    const modelPrefix = opts.model ? parseProviderPrefix(opts.model) : null;
+    const modelPrefix = opts.model ? parseProviderPrefix(miniMaxShorthand(opts.model, compatBackendKind(openaiBackend))) : null;
     const cliModelRaw = modelPrefix ? modelPrefix.model : opts.model;
     const cliProviderOverride = modelPrefix ? modelPrefix.provider : null;
     const modelOverride = cliModelRaw ? resolveClaudeAlias(cliModelRaw) : null;
     // --fast-model: the model that Haiku-tier (Claude Code sub-agent) requests
     // route to instead of the forced `--model`, so sub-agents stay cheap. Parsed
     // like --model (alias + optional provider prefix). Null = disabled.
-    const fastModelPrefix = opts.fastModel ? parseProviderPrefix(opts.fastModel) : null;
+    const fastModelPrefix = opts.fastModel ? parseProviderPrefix(miniMaxShorthand(opts.fastModel, compatBackendKind(openaiBackend))) : null;
     const fastModelRaw = fastModelPrefix ? fastModelPrefix.model : opts.fastModel;
     const fastModelOverride = fastModelRaw ? resolveClaudeAlias(fastModelRaw) : null;
     const identity = loadClaudeIdentity();
@@ -3146,7 +3167,8 @@ export async function startProxy(opts = {}) {
             // User aliases are advertised after the real ids so pickers offer
             // them; already-advertised names aren't duplicated (an alias that
             // shadows a real id still applies at request time).
-            const advertised = withLongContextVariants(catalog.bases);
+            const minimaxNames = isMiniMaxBackend(openaiBackend) ? [...MINIMAX_MODELS] : [];
+            const advertised = withLongContextVariants(catalog.bases).concat(minimaxNames);
             const aliasNames = Object.keys(modelAliases).filter((n) => !advertised.includes(n));
             // Codex/ChatGPT-subscription slugs the backend lists for the stored
             // account (dario#1010), so a client's model picker can discover the
@@ -3164,7 +3186,8 @@ export async function startProxy(opts = {}) {
             // Codex slugs are served by the ChatGPT subscription, not Anthropic, so
             // they advertise `owned_by: "openai"` (dario#1137).
             const codexOwners = Object.fromEntries(codexNames.map((s) => [s, 'openai']));
-            const body = JSON.stringify(buildOpenAIModelsList(advertised.concat(aliasNames, codexNames), codexOwners));
+            const minimaxOwners = Object.fromEntries(minimaxNames.map((s) => [s, 'minimax']));
+            const body = JSON.stringify(buildOpenAIModelsList(advertised.concat(aliasNames, codexNames), { ...codexOwners, ...minimaxOwners }));
             res.writeHead(200, { ...JSON_HEADERS, 'Access-Control-Allow-Origin': corsOrigin });
             res.end(body);
             return;
@@ -3749,6 +3772,7 @@ export async function startProxy(opts = {}) {
                         : resolveMaxTokens(opts.maxTokens, { max_tokens: clientMax });
                     const billedAs = budgetModelsFor(typeof pb?.model === 'string' ? pb.model : '', {
                         modelAliases, modelOverride, fastModelOverride, cliProviderOverride, cliModelRaw, isOpenAI,
+                        compatBackend: compatBackendKind(openaiBackend),
                     });
                     budgetReserved = requestBudgetReservation(billedAs, body.length, outboundMax, costOfTokensFailClosed, Date.now(), passthrough ? 0 : CC_TEMPLATE_PROMPT_BYTES);
                     budgetInflightKey = requestAuth.key.name;
@@ -3852,7 +3876,7 @@ export async function startProxy(opts = {}) {
                         }
                     }
                     const rawModel = parsed.model ?? '';
-                    const prefix = parseProviderPrefix(rawModel);
+                    const prefix = parseProviderPrefix(miniMaxShorthand(rawModel, compatBackendKind(openaiBackend)));
                     if (prefix) {
                         forcedProvider = prefix.provider;
                         // dario#419 — optional effort suffix (model:high / model-high). Claude
@@ -3884,6 +3908,11 @@ export async function startProxy(opts = {}) {
                         parsed.model = cliModelRaw;
                         body = Buffer.from(JSON.stringify(parsed));
                     }
+                    else if (isOpenAI && forcedProvider === null && isMiniMaxBackend(openaiBackend) && /^MiniMax-M/i.test(rawModel)) {
+                        // Direct MiniMax text IDs, including saved legacy IDs, use the
+                        // compatible backend unchanged. Gateway IDs still need a prefix.
+                        forcedProvider = 'openai';
+                    }
                     else if (!isOpenAIModel(rawModel) && forcedProvider !== 'openai') {
                         // dario#419 — bare Claude model name carrying an effort suffix with no
                         // provider prefix (e.g. Cursor's `claude-opus-4-8-high`). OpenAI-bound

package/docs/routing.md

@@ -16,6 +16,31 @@ The tool doesn't know. The backend doesn't know. dario is the seam.
 
 **The full Claude lineup, autodetected.** Fable 5, Opus 5.5, Opus 5, Sonnet 5 and Haiku 4.5, plus `[1m]` long-context variants on every family except Haiku, by full id (`claude-opus-5-5`) or shortcut (`fable` / `opus` / `sonnet` / `haiku`; append `1m` for the long-context form; `opus5` / `opus48` / `opus47` / `opus46` / `sonnet46` pin a generation and never float). `GET /v1/models` reads Anthropic's live catalog (TTL-cached, baked fallback offline), so a new model resolves the day it lands with no dario release, and the model-specific request shape is applied automatically. Families pulled upstream are filtered from both the live catalog and the fallback, so `/v1/models` never advertises a model that 404s. A name no provider lists at all, such as a ChatGPT slug your account doesn't have or a typo that belongs to no family, is refused locally with `400` and `x-dario-upstream-rejection: model_unroutable` instead of spending a pool request on an upstream 404. The guard steps aside for `claude-*` names (Anthropic's own 404 stays authoritative there), for requests under a `--model` / `--fast-model` override, for upstream-API-key mode, and for the legacy OpenAI names the built-in map translates.
 
+## MiniMax API-key backend
+
+`dario backend add minimax --key=<api-key>` uses `https://api.minimax.io/v1`.
+Use the name `minimax-cn` for `https://api.minimax.cn/v1`, or pass `--base-url`
+to keep a custom endpoint. This uses the existing single compatible-backend
+slot; it does not add a second simultaneously active API-key backend. Restart
+the proxy after changing its backend. With no subscription account, start it
+with `dario proxy --no-claude-auth`.
+
+On a direct MiniMax endpoint, model `minimax` on `/v1/chat/completions` selects
+`MiniMax-M3.1-Flash`; on a custom gateway, `minimax` is that gateway's own model id and the request goes to the gateway with the name unchanged.
+Direct endpoints advertise `MiniMax-M3.1-Flash` followed by `MiniMax-M3` in
+`/v1/models`; either full ID routes directly. Use `minimax:<model>` for an
+explicit legacy or custom ID, or `--model=minimax:MiniMax-M3.1-Flash` for a server-wide Flash
+override. Custom gateways retain their own IDs and are not assigned a direct
+MiniMax catalog. This API-key route supports Chat Completions, not Messages.
+
+Request fields and streamed responses pass through unchanged. Flash defaults
+to adaptive thinking and `reasoning_effort: "max"` upstream; it accepts `low`,
+`medium`, `high`, `xhigh`, and `max`. Do not send `thinking.type: "disabled"`,
+`reasoning_effort: "none"`, `service_tier`, or `reasoning_split: false` to Flash.
+M3 also accepts disabled thinking. The proxy does not rewrite explicit settings
+or remove image/video content parts, tool calls, or reasoning history.
+See the [MiniMax API reference](https://platform.minimax.io/docs/api-reference/text-openai-api).
+
 ---
 
 [← README](../README.md) · [all reference docs](../README.md#reference)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.13.28",
+  "version": "6.13.30",
   "description": "Use your Claude and ChatGPT subscriptions in Cursor, Cline, Aider, Claude Code and the Agent SDK — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint: either plan answers either wire shape, with automatic failover when one hits its limit.",
   "type": "module",
   "bin": {