From fecd331f0247c7ff224a3723268233a62799425b Mon Sep 17 00:00:00 2001 From: Time Attakc <89218912+time-attack@users.noreply.github.com> Date: Thu, 23 Jul 2026 12:14:07 -0700 Subject: [PATCH] fix(recipes/minimax): embedding wire-shape compat fetch + chat touchpoint (#1977) (#3089) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit MiniMax's /v1/embeddings endpoint is not OpenAI-compatible: it requires texts (not input) plus a type field and returns {vectors} instead of {data:[{embedding}]}. The recipe shipped no transport shim, so every embed call failed with an invalid-params error, and it declared no chat touchpoint, so assertTouchpoint blocked gbrain think even though MiniMax chat is genuinely OpenAI-compatible. Fix (takeover of #2882, corrected): - minimaxCompatFetch via the DeepSeek-style compat.fetch seam (keeps cfg.base_urls overrides working; no new env var), gated on the /embeddings path so chat requests/responses pass through untouched. - Response rewrite parses via resp.clone() and rebuilds with fresh headers — never returns a body-consumed Response (the flaw in #2882's wrapper, which broke every non-streaming chat completion). - chat touchpoint with the /v1/models list from #1977. Fixes #1977 Co-authored-by: Garry Tan Co-authored-by: ArthurHeung Co-authored-by: Claude Fable 5 --- src/core/ai/recipes/minimax.ts | 114 ++++++++++++++++++++++++++++++++- test/ai/recipe-minimax.test.ts | 108 ++++++++++++++++++++++++++++++- 2 files changed, 219 insertions(+), 3 deletions(-) diff --git a/src/core/ai/recipes/minimax.ts b/src/core/ai/recipes/minimax.ts index 49a756057..469c48248 100644 --- a/src/core/ai/recipes/minimax.ts +++ b/src/core/ai/recipes/minimax.ts @@ -1,8 +1,100 @@ import type { Recipe } from '../types.ts'; /** - * MiniMax (海螺AI). OpenAI-compatible /embeddings endpoint at - * api.minimax.chat. The flagship embedding model is `embo-01` (1536 dims). + * MiniMax transport shim (#1977). MiniMax's `/v1/embeddings` endpoint is NOT + * OpenAI-compatible at the wire level despite the recipe's + * `implementation: 'openai-compatible'`: + * - Request: requires `texts` (the AI SDK sends `input`) plus an optional + * `type: 'db' | 'query'` asymmetric-retrieval field, and rejects OpenAI's + * `encoding_format`. + * - Response: returns `{vectors: number[][], total_tokens}` where the AI + * SDK's Zod schema expects `{data: [{embedding, index}], usage}`. + * + * Chat (`/chat/completions`) IS OpenAI-compatible, and this same fetch is + * applied to every openai-compatible touchpoint by `applyOpenAICompatConfig`, + * so everything outside the embeddings path passes through untouched — and + * the response rewrite parses via `resp.clone()` only (never consume the + * body of a response we return as-is; the DeepSeek shim rule). Fail-open: + * any rewrite error returns the original request/response. + * + * @internal exported for tests. + */ +// Cast through `unknown` because Bun's `typeof fetch` carries a `preconnect` +// member the arrow function does not implement (matches deepseek.ts). +export const minimaxCompatFetch = (async ( + input: RequestInfo | URL, + init?: RequestInit, +): Promise => { + const url = + typeof input === 'string' ? input : input instanceof URL ? input.href : input.url; + const isEmbeddings = url.includes('/embeddings'); + + // OUTBOUND (embeddings only): `input` → `texts`, default `type: 'db'` + // (the recipe's documented symmetric default — the AI SDK adapter strips + // the `type` threaded via providerOptions before it reaches the wire, + // same class as #1400), and drop `encoding_format` (not a MiniMax param). + if (isEmbeddings && init?.body && typeof init.body === 'string') { + try { + const parsed = JSON.parse(init.body); + if ( + parsed && typeof parsed === 'object' && + parsed.input !== undefined && parsed.texts === undefined + ) { + parsed.texts = Array.isArray(parsed.input) ? parsed.input : [parsed.input]; + delete parsed.input; + delete parsed.encoding_format; + if (parsed.type === undefined) parsed.type = 'db'; + // Drop Content-Length so fetch recomputes from the new body. + const headers = new Headers(init.headers ?? {}); + headers.delete('content-length'); + init = { ...init, body: JSON.stringify(parsed), headers }; + } + } catch { + // Body wasn't JSON — pass through untouched. + } + } + + const res = await fetch(input as any, init as any); + + // INBOUND (embeddings only): `{vectors: [[...]]}` → `{data: [{embedding}]}`. + // Anything else (chat completions, MiniMax base_resp errors, non-JSON) + // returns the ORIGINAL response with its body unread. + if (!isEmbeddings || !res.ok) return res; + const ctype = res.headers.get('content-type') ?? ''; + if (!ctype.toLowerCase().includes('application/json')) return res; + try { + const json = await res.clone().json(); + if (!json || typeof json !== 'object' || !Array.isArray(json.vectors)) return res; + const totalTokens = typeof json.total_tokens === 'number' ? json.total_tokens : 0; + const rewritten = { + object: 'list', + data: (json.vectors as number[][]).map((embedding, index) => ({ + object: 'embedding', + embedding, + index, + })), + model: typeof json.model === 'string' ? json.model : 'embo-01', + usage: { prompt_tokens: totalTokens, total_tokens: totalTokens }, + }; + // Fresh header set: the body changed, so upstream content-length / + // content-encoding would now be wrong. + const headers = new Headers(res.headers); + headers.delete('content-length'); + headers.delete('content-encoding'); + return new Response(JSON.stringify(rewritten), { + status: res.status, + statusText: res.statusText, + headers, + }); + } catch { + return res; + } +}) as unknown as typeof fetch; + +/** + * MiniMax (海螺AI). `/embeddings` endpoint at api.minimaxi.com (wire shape + * normalized by `minimaxCompatFetch` above); OpenAI-compatible + * `/chat/completions`. The flagship embedding model is `embo-01` (1536 dims). * * MiniMax's API takes an extra `type: 'db' | 'query'` field for asymmetric * retrieval. gbrain currently has no notion of "this is a document vs a @@ -38,7 +130,25 @@ export const minimax: Recipe = { // halving in the gateway catches token-limit errors at runtime. max_batch_tokens: 4096, }, + chat: { + // Model list from MiniMax's /v1/models (#1977). Chat is genuinely + // OpenAI-compatible — no wire rewrite needed (minimaxCompatFetch + // passes non-embedding requests through untouched). + models: [ + 'MiniMax-M3', + 'MiniMax-M2.7', + 'MiniMax-M2.7-highspeed', + 'MiniMax-M2.5', + 'MiniMax-M2.5-highspeed', + 'MiniMax-M2.1', + 'MiniMax-M2.1-highspeed', + 'MiniMax-M2', + ], + supports_tools: false, + supports_subagent_loop: false, + }, }, setup_hint: 'Get an API key at https://www.minimaxi.com, then `export MINIMAX_API_KEY=...`', + compat: { fetch: minimaxCompatFetch }, }; diff --git a/test/ai/recipe-minimax.test.ts b/test/ai/recipe-minimax.test.ts index 96f6c9eda..ced6c03ef 100644 --- a/test/ai/recipe-minimax.test.ts +++ b/test/ai/recipe-minimax.test.ts @@ -6,10 +6,14 @@ * - default auth: MINIMAX_API_KEY → "Bearer "; missing → AIConfigError * - dimsProviderOptions threads `type: 'db'` for embo-01 (the asymmetric * retrieval field default) — pins the v1 indexing-only behavior + * - #1977: chat touchpoint declared; minimaxCompatFetch rewrites the + * embedding wire shape both directions, passes chat through with the + * response body UNREAD (the consumed-body regression), fail-open. */ -import { describe, expect, test } from 'bun:test'; +import { afterEach, describe, expect, test } from 'bun:test'; import { getRecipe } from '../../src/core/ai/recipes/index.ts'; +import { minimaxCompatFetch } from '../../src/core/ai/recipes/minimax.ts'; import { defaultResolveAuth } from '../../src/core/ai/gateway.ts'; import { dimsProviderOptions } from '../../src/core/ai/dims.ts'; import { AIConfigError } from '../../src/core/ai/errors.ts'; @@ -56,4 +60,106 @@ describe('recipe: minimax', () => { expect(dimsProviderOptions('openai-compatible', 'voyage-3-lite', 512)).toBeUndefined(); expect(dimsProviderOptions('openai-compatible', 'nomic-embed-text', 768)).toBeUndefined(); }); + + test('chat touchpoint declared (#1977) so assertTouchpoint permits gbrain think', () => { + const r = getRecipe('minimax')!; + expect(r.touchpoints.chat).toBeDefined(); + expect(r.touchpoints.chat!.models).toContain('MiniMax-M3'); + expect(r.touchpoints.chat!.supports_tools).toBe(false); + expect(r.touchpoints.chat!.supports_subagent_loop).toBe(false); + }); + + test('recipe ships minimaxCompatFetch via compat.fetch (no env-templated base URL)', () => { + const r = getRecipe('minimax')!; + expect(r.compat?.fetch).toBe(minimaxCompatFetch); + // base_urls config override must keep working: no resolveOpenAICompatConfig. + expect(r.resolveOpenAICompatConfig).toBeUndefined(); + }); +}); + +describe('minimaxCompatFetch (#1977)', () => { + const realFetch = globalThis.fetch; + afterEach(() => { globalThis.fetch = realFetch; }); + + function stubFetch(body: unknown, init?: { status?: number; contentType?: string }) { + const calls: { url: string; init?: RequestInit }[] = []; + globalThis.fetch = (async (input: any, i?: RequestInit) => { + calls.push({ url: String(input), init: i }); + return new Response(typeof body === 'string' ? body : JSON.stringify(body), { + status: init?.status ?? 200, + headers: { 'content-type': init?.contentType ?? 'application/json' }, + }); + }) as unknown as typeof fetch; + return calls; + } + + const EMBED_URL = 'https://api.minimaxi.com/v1/embeddings'; + const CHAT_URL = 'https://api.minimaxi.com/v1/chat/completions'; + + test('embedding request: input → texts, type:db injected, encoding_format dropped', async () => { + const calls = stubFetch({ vectors: [[0.1, 0.2]] }); + await minimaxCompatFetch(EMBED_URL, { + method: 'POST', + headers: { 'content-type': 'application/json', 'content-length': '99' }, + body: JSON.stringify({ model: 'embo-01', input: ['hello', 'world'], encoding_format: 'float' }), + }); + const wire = JSON.parse(calls[0]!.init!.body as string); + expect(wire.texts).toEqual(['hello', 'world']); + expect(wire.input).toBeUndefined(); + expect(wire.encoding_format).toBeUndefined(); + expect(wire.type).toBe('db'); + expect(new Headers(calls[0]!.init!.headers).get('content-length')).toBeNull(); + }); + + test('embedding response: {vectors} rewritten to OpenAI {data:[{embedding}]}', async () => { + stubFetch({ vectors: [[0.1, 0.2], [0.3, 0.4]], total_tokens: 7 }); + const res = await minimaxCompatFetch(EMBED_URL, { + method: 'POST', + body: JSON.stringify({ model: 'embo-01', input: ['a', 'b'] }), + }); + const json = await res.json(); + expect(json.data).toEqual([ + { object: 'embedding', embedding: [0.1, 0.2], index: 0 }, + { object: 'embedding', embedding: [0.3, 0.4], index: 1 }, + ]); + expect(json.usage).toEqual({ prompt_tokens: 7, total_tokens: 7 }); + }); + + test('chat completion passes through with body UNREAD (consumed-body regression)', async () => { + stubFetch({ choices: [{ message: { role: 'assistant', content: 'hi' } }] }); + const res = await minimaxCompatFetch(CHAT_URL, { + method: 'POST', + body: JSON.stringify({ model: 'MiniMax-M3', messages: [{ role: 'user', content: 'say hi' }] }), + }); + expect(res.bodyUsed).toBe(false); // the broken PR #2882 wrapper consumed this + const json = await res.json(); // must NOT throw "Body already used" + expect(json.choices[0].message.content).toBe('hi'); + }); + + test('chat request body is never rewritten (messages untouched, no type injected)', async () => { + const calls = stubFetch({ choices: [] }); + const body = JSON.stringify({ model: 'MiniMax-M3', messages: [{ role: 'user', content: 'x' }] }); + await minimaxCompatFetch(CHAT_URL, { method: 'POST', body }); + expect(calls[0]!.init!.body).toBe(body); + }); + + test('embedding error response ({vectors:null, base_resp}) passes through re-readable', async () => { + stubFetch({ vectors: null, base_resp: { status_code: 2013, status_msg: 'invalid params' } }); + const res = await minimaxCompatFetch(EMBED_URL, { + method: 'POST', + body: JSON.stringify({ model: 'embo-01', input: ['a'] }), + }); + expect(res.bodyUsed).toBe(false); + const json = await res.json(); + expect(json.base_resp.status_code).toBe(2013); + }); + + test('fail-open: non-JSON response body passes through untouched', async () => { + stubFetch('not json', { contentType: 'application/json' }); + const res = await minimaxCompatFetch(EMBED_URL, { + method: 'POST', + body: JSON.stringify({ model: 'embo-01', input: ['a'] }), + }); + expect(await res.text()).toBe('not json'); + }); });