repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/minimax/__tests__/verify-sdk.ts
Rawimport assert from "node:assert/strict";
import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { dirname, join, resolve } from "node:path";
import { fileURLToPath, pathToFileURL } from "node:url";
// Explicit installed SDK, no installation, network, auth reads, or user settings writes.
const sdk = process.argv[2];
if (!sdk) throw new Error("Provide installed pi-coding-agent package path.");
const metadata = JSON.parse(
await readFile(join(sdk, "package.json"), "utf8"),
) as { name: string; version: string };
assert.equal(metadata.name, "@earendil-works/pi-coding-agent");
const root = await mkdtemp(join(tmpdir(), "minimax-sdk-"));
try {
const agentDir = join(root, "agent");
await mkdir(agentDir);
for (const key of [
"HOME",
"USERPROFILE",
"XDG_CONFIG_HOME",
"XDG_STATE_HOME",
"XDG_DATA_HOME",
"XDG_CACHE_HOME",
])
process.env[key] = join(root, key);
process.env["PI_CODING_AGENT_DIR"] = agentDir;
process.env["PI_OFFLINE"] = "1";
process.env["MINIMAX_API_KEY"] = "sk-cp-fixture";
// Cheap operations must run without any approval setting; H3 is enabled later.
delete process.env["PI_MINIMAX_VIDEO_APPROVAL"];
process.env["PI_MINIMAX_REGION"] = "global";
process.env["PI_MINIMAX_DEBUG"] = "0";
const api = (await import(
pathToFileURL(join(sdk, "dist/index.js")).href
)) as typeof import("@earendil-works/pi-coding-agent");
const ai = (await import(
pathToFileURL(join(sdk, "../pi-ai/dist/index.js")).href
)) as typeof import("@earendil-works/pi-ai");
const source = resolve(
dirname(fileURLToPath(import.meta.url)),
"../../../dist/minimax",
);
const relocated = join(root, "package");
await cp(source, relocated, { recursive: true });
const activity: unknown[] = [];
const structured: { toolName: string; structuredContent: unknown }[] = [];
const observer: import("@earendil-works/pi-coding-agent").ExtensionFactory = (
pi,
) => {
pi.events.on("quota:provider-activity", (data) => {
activity.push(data);
});
pi.on("tool_result", (event) => {
structured.push({
toolName: event.toolName,
structuredContent: event.structuredContent,
});
});
};
const loader = new api.DefaultResourceLoader({
cwd: root,
agentDir,
noExtensions: true,
noSkills: true,
noPromptTemplates: true,
noThemes: true,
noContextFiles: true,
additionalExtensionPaths: [relocated],
extensionFactories: [observer],
});
await loader.reload();
assert.deepEqual(loader.getExtensions().errors, []);
const credentials = new ai.InMemoryCredentialStore();
const runtime = await api.ModelRuntime.create({
credentials,
modelsStore: new ai.InMemoryModelsStore(),
refreshOnCreate: false,
});
const faux = ai.createFauxCore({
provider: "faux",
api: "openai",
models: [{ id: "fixture", name: "Fixture" }],
});
runtime.registerProvider("faux", {
apiKey: "fixture",
api: "openai",
baseUrl: "https://faux.invalid",
streamSimple: faux.streamSimple,
models: [
{
id: "fixture",
name: "Fixture",
reasoning: false,
input: ["text"],
contextWindow: 200000,
maxTokens: 8192,
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
},
],
});
const model = runtime.getModel("faux", "fixture");
assert.ok(model);
const { session } = await api.createAgentSession({
cwd: root,
agentDir,
model,
modelRuntime: runtime,
sessionManager: api.SessionManager.inMemory(root),
resourceLoader: loader,
});
const errors: string[] = [];
await session.bindExtensions({
mode: "print",
onError: (e) => errors.push(e.error),
});
const declarations = session.agent.state.tools.map(
({ name, description, parameters }) => ({ name, description, parameters }),
);
const baseline = declarations.filter(
(tool) => !tool.name.startsWith("minimax_"),
);
console.log(
JSON.stringify({
contextMeasurement:
"standalone native tool-declaration heuristic; not provider tokens or complete configured Pi context",
withoutMiniMax: Math.ceil(JSON.stringify(baseline).length / 4),
withMiniMax: Math.ceil(JSON.stringify(declarations).length / 4),
delta:
Math.ceil(JSON.stringify(declarations).length / 4) -
Math.ceil(JSON.stringify(baseline).length / 4),
newTools: declarations
.filter((tool) => tool.name.startsWith("minimax_"))
.map((tool) => tool.name),
}),
);
const jpeg = Buffer.from([255, 216, 255, 224, 0, 0]).toString("base64");
let requests = 0;
let quotaReads = 0;
globalThis.fetch = async (url, init) => {
requests++;
assert.equal(
new Headers(init?.headers).get("Authorization"),
"Bearer sk-cp-fixture",
);
if (String(url) === "https://www.minimax.io/v1/token_plan/remains") {
quotaReads++;
assert.equal(init?.method, "GET");
assert.equal(init?.redirect, "error");
return Response.json({
base_resp: { status_code: 0 },
model_remains: [
{
model_name: "general",
current_interval_remaining_percent: 93,
current_weekly_remaining_percent: 92,
},
],
});
}
const path = new URL(String(url)).pathname;
if (path === "/v1/image_generation")
return Response.json({ data: { image_base64: [jpeg] } });
if (path === "/v1/coding_plan/vlm")
return Response.json({ content: "red" });
if (path === "/v1/t2a_v2")
return Response.json({
data: { audio: "494433", status: 2 },
extra_info: { usage_characters: 6 },
});
if (path === "/v2/video_generation")
return Response.json({ task_id: "sdk-task" });
if (path === "/v2/query/video_generation/sdk-task")
return Response.json({
task: {
id: "sdk-task",
model: "MiniMax-H3",
status: "succeeded",
usage: { output_seconds: 4, input_seconds: 0, input_image_count: 0 },
},
});
throw new Error("Unexpected SDK fixture request; network blocked.");
};
try {
const image = runtime.getModelOfType("image", "minimax-media", "image-01");
assert.ok(image);
const before = runtime.getModels("minimax");
assert.ok(before.length);
const generated = await runtime.generateImages(image, {
input: [{ type: "text", text: "A square" }],
});
assert.equal(generated.stopReason, "stop", generated.errorMessage ?? "");
assert.equal(generated.usage?.cost.total, 0.0035);
assert.deepEqual(runtime.getModels("minimax"), before);
assert.match(
generated.output.find((b) => b.type === "text")?.text ?? "",
/"fiveHourLeft":93/,
);
const source = join(root, "input.jpg");
await writeFile(source, Buffer.from(jpeg, "base64"));
const run = async (
name: string,
args: import("@earendil-works/pi-ai").JsonObject,
) => {
faux.setResponses([
ai.fauxAssistantMessage(ai.fauxToolCall(name, args), {
stopReason: "toolUse",
}),
ai.fauxAssistantMessage("Done"),
]);
await session.prompt("Run deterministic fixture");
const message = session.messages
.filter((m) => m.role === "toolResult" && m.toolName === name)
.at(-1);
assert.ok(message?.role === "toolResult");
const text = message.content
.map((b) => (b.type === "text" ? b.text : ""))
.join("");
assert.ok(
structured.at(-1)?.toolName === name &&
structured.at(-1)?.structuredContent,
`${name} lacks structuredContent`,
);
return { message, text };
};
for (const [name, args] of [
["minimax_capabilities", {}],
["minimax_understand_image", { prompt: "Color?", source }],
[
"minimax_speech",
{ text: "Hello.", outputPath: join(root, "speech.mp3") },
],
] as const) {
const { message, text } = await run(name, args);
assert.equal(message.isError, false, text);
if (name !== "minimax_capabilities")
assert.match(text, /M Plan left 5h 93% · wk 92%/);
}
const submitArgs = { action: "submit", job: "sdk", prompt: "A ball" };
const requestsBefore = requests;
const blocked = await run("minimax_video", submitArgs);
assert.equal(blocked.message.isError, true);
assert.match(blocked.text, /PI_MINIMAX_VIDEO_APPROVAL=always/);
assert.equal(requests, requestsBefore, "blocked H3 submit sent requests");
process.env["PI_MINIMAX_VIDEO_APPROVAL"] = "always";
for (const args of [
submitArgs,
{ action: "status", job: "sdk" },
{ action: "status", job: "sdk" },
]) {
const { message, text } = await run("minimax_video", args);
assert.equal(message.isError, false, text);
}
const video = session.messages.filter(
(m) => m.role === "toolResult" && m.toolName === "minimax_video",
);
assert.equal(
video[2]?.role === "toolResult" ? video[2].usage?.cost.total : undefined,
0.32,
);
assert.equal(
video[3]?.role === "toolResult" ? video[3].usage : undefined,
undefined,
);
// image, understanding, speech, H3 submit, first H3 completion.
assert.equal(quotaReads, 5);
assert.deepEqual(
activity,
Array.from({ length: 5 }, () => ({ provider: "minimax" })),
);
assert.deepEqual(errors, []);
console.log(
`OK Pi ${metadata.version}: relocated MiniMax native image + four tools; cheap ops ungated, H3 gated; chat preserved; native usage once; ${quotaReads} quota reads + events; ${requests} mocked requests, no live calls`,
);
} finally {
await session.extensionRunner.emit({
type: "session_shutdown",
reason: "quit",
});
session.dispose();
await session.settingsManager.flush();
}
} finally {
await rm(root, { recursive: true, force: true });
}