Skip to content

#1 Persistent memory for AI coding agents based on real-world benchmarks

feat: add MiniMax provider and fix ANTHROPIC_BASE_URL not passed to SDK

翔 高ab0901f25d42
diff --git a/src/config.ts b/src/config.ts
index 4c3faedf..936c43c3 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -44,11 +44,21 @@ function loadEnvFile(): Record<string, string> {
function detectProvider(env: Record<string, string>): ProviderConfig {
const maxTokens = parseInt(env["MAX_TOKENS"] || "4096", 10);
+ // MiniMax: Anthropic-compatible API, requires raw fetch to avoid SDK stainless headers
+ if (env["MINIMAX_API_KEY"]) {
+ return {
+ provider: "minimax",
+ model: env["MINIMAX_MODEL"] || "MiniMax-M2.7",
+ maxTokens,
+ };
+ }
+
if (env["ANTHROPIC_API_KEY"]) {
return {
provider: "anthropic",
model: env["ANTHROPIC_MODEL"] || "claude-sonnet-4-20250514",
maxTokens,
+ baseURL: env["ANTHROPIC_BASE_URL"],
};
}
if (env["GEMINI_API_KEY"]) {
@@ -205,6 +215,7 @@ const VALID_PROVIDERS = new Set([
"gemini",
"openrouter",
"agent-sdk",
+ "minimax",
]);
export function loadFallbackConfig(): FallbackConfig {
diff --git a/src/providers/anthropic.ts b/src/providers/anthropic.ts
index 3a0e5b65..73722e13 100644
--- a/src/providers/anthropic.ts
+++ b/src/providers/anthropic.ts
@@ -7,8 +7,8 @@ export class AnthropicProvider implements MemoryProvider {
private model: string
private maxTokens: number
- constructor(apiKey: string, model: string, maxTokens: number) {
- this.client = new Anthropic({ apiKey })
+ constructor(apiKey: string, model: string, maxTokens: number, baseURL?: string) {
+ this.client = new Anthropic({ apiKey, ...(baseURL ? { baseURL } : {}) })
this.model = model
this.maxTokens = maxTokens
}
diff --git a/src/providers/index.ts b/src/providers/index.ts
index becf491c..82d7de9a 100644
--- a/src/providers/index.ts
+++ b/src/providers/index.ts
@@ -5,6 +5,7 @@ import type {
} from "../types.js";
import { AgentSDKProvider } from "./agent-sdk.js";
import { AnthropicProvider } from "./anthropic.js";
+import { MinimaxProvider } from "./minimax.js";
import { OpenRouterProvider } from "./openrouter.js";
import { ResilientProvider } from "./resilient.js";
import { FallbackChainProvider } from "./fallback-chain.js";
@@ -57,11 +58,18 @@ export function createFallbackProvider(
function createBaseProvider(config: ProviderConfig): MemoryProvider {
switch (config.provider) {
+ case "minimax":
+ return new MinimaxProvider(
+ requireEnvVar("MINIMAX_API_KEY"),
+ config.model,
+ config.maxTokens,
+ );
case "anthropic":
return new AnthropicProvider(
requireEnvVar("ANTHROPIC_API_KEY"),
config.model,
config.maxTokens,
+ config.baseURL,
);
case "gemini":
return new OpenRouterProvider(
diff --git a/src/providers/minimax.ts b/src/providers/minimax.ts
new file mode 100644
index 00000000..3fb8776b
--- /dev/null
+++ b/src/providers/minimax.ts
@@ -0,0 +1,68 @@
+import type { MemoryProvider } from '../types.js'
+
+/**
+ * MiniMax provider using raw fetch to call MiniMax's Anthropic-compatible API.
+ *
+ * The Anthropic SDK automatically injects `x-stainless-*` headers that MiniMax
+ * rejects with 403. This provider bypasses the SDK and calls the API directly.
+ *
+ * Required env vars:
+ * MINIMAX_API_KEY — your MiniMax API key
+ * MINIMAX_MODEL — model name (default: MiniMax-M2.7)
+ * MAX_TOKENS — max output tokens (default: 800; MiniMax-M2.7 needs ≤800)
+ *
+ * Optional:
+ * MINIMAX_BASE_URL — base URL without path (default: https://api.minimaxi.com/anthropic)
+ */
+export class MinimaxProvider implements MemoryProvider {
+ name = 'minimax'
+ private apiKey: string
+ private model: string
+ private maxTokens: number
+ private baseUrl: string
+
+ constructor(apiKey: string, model: string, maxTokens: number) {
+ this.apiKey = apiKey
+ this.model = model
+ this.maxTokens = maxTokens
+ this.baseUrl =
+ process.env['MINIMAX_BASE_URL'] || 'https://api.minimaxi.com/anthropic'
+ }
+
+ async compress(systemPrompt: string, userPrompt: string): Promise<string> {
+ return this.call(systemPrompt, userPrompt)
+ }
+
+ async summarize(systemPrompt: string, userPrompt: string): Promise<string> {
+ return this.call(systemPrompt, userPrompt)
+ }
+
+ private async call(systemPrompt: string, userPrompt: string): Promise<string> {
+ const url = `${this.baseUrl}/v1/messages`
+ const response = await fetch(url, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'x-api-key': this.apiKey,
+ 'anthropic-version': '2023-06-01',
+ },
+ body: JSON.stringify({
+ model: this.model,
+ max_tokens: this.maxTokens,
+ system: systemPrompt,
+ messages: [{ role: 'user', content: userPrompt }],
+ }),
+ })
+
+ if (!response.ok) {
+ const text = await response.text()
+ throw new Error(`MiniMax API error ${response.status}: ${text}`)
+ }
+
+ const data = (await response.json()) as {
+ content?: Array<{ type: string; text?: string }>
+ }
+ const textBlock = data.content?.find((b) => b.type === 'text')
+ return textBlock?.text ?? ''
+ }
+}
diff --git a/src/types.ts b/src/types.ts
index 673b5c36..be439a26 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -113,9 +113,11 @@ export interface ProviderConfig {
provider: ProviderType;
model: string;
maxTokens: number;
+ /** Optional base URL override (e.g. for Anthropic-compatible APIs or local proxies) */
+ baseURL?: string;
}
-export type ProviderType = "agent-sdk" | "anthropic" | "gemini" | "openrouter";
+export type ProviderType = "agent-sdk" | "anthropic" | "gemini" | "openrouter" | "minimax";
export interface MemoryProvider {
name: string;