Luigit
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;
}