repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/web/minimax.ts
Raw/**
* 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<string> {
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<ExtensionContext["modelRegistry"]["getProviderAuth"]>
>;
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<boolean> {
try {
assertCurrentMPlanConfiguration(ctx);
await resolveMinimaxApiKey(ctx, signal);
return true;
} catch {
return false;
}
}
async function minimaxPost<T>(
apiKey: string,
body: Record<string, unknown>,
signal?: AbortSignal,
): Promise<T> {
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<string, unknown>)["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<MinimaxSearchResponse> {
assertCurrentMPlanConfiguration(ctx);
const response = await minimaxPost<MinimaxSearchResponse>(
await resolveMinimaxApiKey(ctx, signal),
{ q: query },
signal,
);
if (!Array.isArray(response.organic))
throw new Error("MiniMax search returned invalid organic results");
return response;
}