/** * MiniMax M Plan search client. * * M Plan search uses only Pi's global `minimax` credential and MiniMax's global * endpoint, so a configured chat-model host or CN credential cannot receive it. */ import type { ExtensionContext } from "@earendil-works/pi-coding-agent"; import { abortable } from "./abort.js"; import { readBoundedText } from "./http-body.js"; import { legacyMinimaxApiHost } from "./settings.ts"; const MINIMAX_GLOBAL_API_ORIGIN = "https://api.minimax.io"; const MINIMAX_SEARCH_PATH = "/v1/coding_plan/search"; export interface MinimaxSearchResult { title: string; link: string; snippet: string; date?: string; } interface MinimaxSearchResponse { organic: MinimaxSearchResult[]; related_searches: { query: string }[]; base_resp: { status_code: number; status_msg: string; }; } /** Current M Plan search has one verified global endpoint. */ export function resolveMinimaxBaseUrl(): string { return MINIMAX_GLOBAL_API_ORIGIN; } function obsoleteHostError(ctx: ExtensionContext): Error | undefined { if (!legacyMinimaxApiHost(ctx)) return undefined; return new Error( "web.minimax.apiHost is obsolete and ignored; remove it. M Plan search always uses Pi's global minimax credential at https://api.minimax.io.", ); } function assertCurrentMPlanConfiguration(ctx: ExtensionContext): void { const error = obsoleteHostError(ctx); if (error) throw error; } function assertGlobalOrigin(baseUrl: string | undefined, owner: string): void { if (!baseUrl) throw new Error( `MiniMax ${owner} endpoint missing; global api.minimax.io is required.`, ); let origin: string; try { origin = new URL(baseUrl).origin; } catch { throw new Error( `MiniMax ${owner} endpoint invalid; global api.minimax.io is required.`, ); } if (origin !== MINIMAX_GLOBAL_API_ORIGIN) throw new Error( `MiniMax ${owner} endpoint/region mismatch: global api.minimax.io is required.`, ); } /** * Resolve the complete configured authentication before accepting its key. * This preserves credential/base-URL coherence and rejects PAYG or unknown keys. */ export async function resolveMinimaxApiKey( ctx: ExtensionContext, signal?: AbortSignal, ): Promise { signal?.throwIfAborted(); const provider = ctx.modelRegistry.getProvider("minimax"); if (provider?.id !== "minimax") throw new Error( 'MiniMax M Plan search requires Pi provider "minimax" configured for global api.minimax.io.', ); assertGlobalOrigin(provider.baseUrl, "provider"); let resolved: Awaited< ReturnType >; try { resolved = await abortable( ctx.modelRegistry.getProviderAuth("minimax"), signal, ); } catch (error) { signal?.throwIfAborted(); throw new Error( "Pi MiniMax credential resolution failed; inspect existing Pi minimax configuration. No fallback.", { cause: error }, ); } signal?.throwIfAborted(); assertGlobalOrigin(resolved?.auth.baseUrl ?? provider.baseUrl, "credential"); const apiKey = resolved?.auth.apiKey?.trim(); if (!apiKey) throw new Error( 'MiniMax M Plan search requires an M Plan Subscription Key registered in Pi as provider "minimax".', ); if (apiKey.startsWith("sk-api-")) throw new Error( "PAYG MiniMax key rejected: use an M Plan Subscription Key from Plan Details.", ); if (!apiKey.startsWith("sk-cp-")) throw new Error( "Ambiguous MiniMax credential rejected: an M Plan Subscription Key is required.", ); return apiKey; } /** * Automatic provider selection includes MiniMax only for a valid M Plan key. * This check resolves configuration only; it does not send a search request. */ export async function isMinimaxAvailable( ctx: ExtensionContext, signal?: AbortSignal, ): Promise { try { assertCurrentMPlanConfiguration(ctx); await resolveMinimaxApiKey(ctx, signal); return true; } catch { return false; } } async function minimaxPost( apiKey: string, body: Record, signal?: AbortSignal, ): Promise { const deadline = AbortSignal.timeout(30_000); const requestSignal = signal ? AbortSignal.any([signal, deadline]) : deadline; const response = await fetch( `${MINIMAX_GLOBAL_API_ORIGIN}${MINIMAX_SEARCH_PATH}`, { method: "POST", redirect: "error", headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json", "MM-API-Source": "pi-extension", }, body: JSON.stringify(body), signal: requestSignal, }, ); if (!response.ok) { await response.body?.cancel().catch(() => {}); throw new Error( `MiniMax API error: HTTP ${response.status} ${response.statusText}`, ); } const parsed: unknown = JSON.parse( await readBoundedText(response, undefined, requestSignal), ); if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("MiniMax API returned invalid search response"); const data = parsed as T; const baseResp = (data as Record)["base_resp"] as | { status_code: number; status_msg: string } | undefined; if (baseResp && baseResp.status_code !== 0) throw new Error( `MiniMax API error: ${baseResp.status_code} - ${baseResp.status_msg}`, ); return data; } export async function minimaxSearch( query: string, ctx: ExtensionContext, signal?: AbortSignal, ): Promise { assertCurrentMPlanConfiguration(ctx); const response = await minimaxPost( await resolveMinimaxApiKey(ctx, signal), { q: query }, signal, ); if (!Array.isArray(response.organic)) throw new Error("MiniMax search returned invalid organic results"); return response; }