import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { fileURLToPath } from "node:url"; import { fauxAssistantMessage, fauxToolCall, InMemoryCredentialStore, type JsonObject, } from "@earendil-works/pi-ai"; import type { ExtensionFactory, ExtensionUIDialogOptions, } from "@earendil-works/pi-coding-agent"; import { SessionManager } from "@earendil-works/pi-coding-agent"; import { Type } from "typebox"; import { afterEach, describe, expect, it, vi } from "vitest"; import { createPiSession, type PiSession, type PiSessionOptions, } from "../../../test/fixture/create-pi-session.ts"; let fixture: PiSession | undefined; const temporary: string[] = []; const observed = { activity: [] as unknown[], results: [] as { toolName: string; structuredContent: unknown; details: unknown; isError: boolean; }[], }; // Independent listener: the quota extension contract and codemode-visible structured output. const observer: ExtensionFactory = (pi) => { pi.events.on("quota:provider-activity", (data) => { observed.activity.push(data); }); pi.on("tool_result", (event) => { observed.results.push({ toolName: event.toolName, structuredContent: event.structuredContent, details: event.details, isError: event.isError, }); }); }; afterEach(async () => { await fixture?.dispose(); fixture = undefined; vi.unstubAllGlobals(); observed.activity.length = 0; observed.results.length = 0; for (const dir of temporary.splice(0)) await rm(dir, { recursive: true, force: true }); }); async function setup( key: string | null = "sk-cp-fixture", videoApproval?: "ask" | "always", options: Partial = {}, ) { const credentials = new InMemoryCredentialStore(); if (key) await credentials.modify("minimax", async () => ({ type: "api_key", key })); fixture = await createPiSession({ extensionPaths: [fileURLToPath(new URL("../index.ts", import.meta.url))], credentials, userSettings: videoApproval ? { minimax: { videoApproval } } : {}, ...options, extensionFactories: [observer, ...(options.extensionFactories ?? [])], env: { MINIMAX_API_KEY: undefined, PI_MINIMAX_VIDEO_APPROVAL: undefined, PI_MINIMAX_REGION: undefined, PI_MINIMAX_DEBUG: "0", ...options.env, }, }); expect(fixture.errors).toEqual([]); const runtime = fixture.session.modelRuntime; const image = runtime.getModelOfType("image", "minimax-media", "image-01"); if (!image) throw new Error("Image model absent"); return { runtime, image }; } const jpeg = Buffer.from([255, 216, 255, 224, 0, 0]).toString("base64"); const input = { input: [{ type: "text" as const, text: "A red square" }] }; const QUOTA = "https://www.minimax.io/v1/token_plan/remains"; const remains = { base_resp: { status_code: 0 }, model_remains: [ { model_name: "video", current_weekly_remaining_percent: 10 }, { model_name: "general", current_interval_remaining_percent: 93, current_weekly_remaining_percent: 92, }, ], }; const QUOTA_LINE = "M Plan left 5h 93% · wk 92%"; type Handler = ( url: string | URL | Request, init?: RequestInit, ) => Response | Promise; /** Routes the non-consuming quota read separately from consuming API requests. */ function api(handler: Handler, quota: Handler = () => Response.json(remains)) { return vi.fn(async (url: string | URL | Request, init?: RequestInit) => String(url) === QUOTA ? quota(url, init) : handler(url, init), ); } type Calls = { mock: { calls: unknown[][] } }; const apiCalls = (fetch: Calls) => fetch.mock.calls.filter((c) => String(c[0]) !== QUOTA) as [ string | URL | Request, RequestInit | undefined, ][]; const quotaCalls = (fetch: Calls) => fetch.mock.calls.filter((c) => String(c[0]) === QUOTA) as [ string, RequestInit | undefined, ][]; const posts = (fetch: Calls) => apiCalls(fetch).filter((c) => c[1]?.method === "POST"); function textOf(value: { content: { type: string; text?: string }[] }) { return value.content.map((b) => (b.type === "text" ? b.text : "")).join(""); } function lastStructured(toolName: string) { return observed.results.filter((r) => r.toolName === toolName).at(-1); } function useUI(select: (...args: never[]) => Promise) { const runner = fixture!.session.extensionRunner; const confirm = vi.fn(async () => true); runner.setUIContext( { ...runner.createCommandContext().ui, select: select as never, confirm, }, "tui", ); return { runner, confirm }; } describe("MiniMax native image slice", () => { it.each([null, "ambiguous", "sk-api-payg", "sk-cp-fixture"])( "keeps unrelated model discovery usable with MiniMax credential %s", async (key) => { const { runtime } = await setup(key); const fetch = vi.fn(); vi.stubGlobal("fetch", fetch); const images = await runtime.getAvailableOfType("image"); expect(images.some((model) => model.provider === "minimax-media")).toBe( key === "sk-cp-fixture", ); await expect( runtime.getAvailableOfType("classifier"), ).resolves.toBeDefined(); await expect(runtime.getAvailable()).resolves.toBeDefined(); expect(fetch).not.toHaveBeenCalled(); }, ); it("retains valid partial images and their estimate when another image is malformed", async () => { const { runtime, image } = await setup(); const fetch = api(async () => Response.json({ data: { image_base64: [jpeg, "not-an-image"] }, }), ); const value = await runtime.generateImages(image, input, { fetch, ...{ n: 2 }, }); expect(value.stopReason).toBe("error"); expect(value.output.filter((block) => block.type === "image")).toHaveLength( 1, ); expect(value.usage?.cost).toMatchObject({ total: 0.0035, totalFromProvider: false, }); const provenance = JSON.parse( value.output.find((block) => block.type === "text")?.text ?? "{}", ); expect(provenance).toMatchObject({ actualImages: 1, requestedImages: 2, partial: true, accounting: { remainingConsumption: "unknown", providerCharge: "unknown", }, }); expect(apiCalls(fetch)).toHaveLength(1); }); it("reuses ONLY existing minimax credentials, preserves chat, returns native usage, quota and activity event", async () => { const { runtime, image } = await setup(); const before = runtime.getModels("minimax").map((m) => [m.id, m.api]); expect(before.length).toBeGreaterThan(0); const fetch = api( async (url: string | URL | Request, init?: RequestInit) => { expect(String(url)).toBe("https://api.minimax.io/v1/image_generation"); expect(new Headers(init?.headers).get("Authorization")).toBe( "Bearer sk-cp-fixture", ); expect(JSON.parse(String(init?.body))).toMatchObject({ model: "image-01", response_format: "base64", n: 1, width: 512, height: 512, }); return Response.json({ id: "fixture", data: { image_base64: [jpeg] }, base_resp: { status_code: 0 }, }); }, ); const result = await runtime.generateImages(image, input, { fetch }); expect(result.stopReason, result.errorMessage).toBe("stop"); expect(result.output[0]).toEqual({ type: "image", data: jpeg, mimeType: "image/jpeg", }); expect(result.usage?.cost.total).toBe(0.0035); const provenance = JSON.parse( result.output.find((b) => b.type === "text")?.text ?? "{}", ); expect(provenance.accounting).toMatchObject({ kind: "catalog-estimate", unit: "image", tokens: "not reported", providerCharge: "unknown", creditsConsumed: "unknown", }); expect(provenance.quota).toMatchObject({ fiveHourLeft: 93, weeklyLeft: 92, observedAt: expect.any(Number), }); expect(runtime.getModels("minimax").map((m) => [m.id, m.api])).toEqual( before, ); expect(await runtime.getAuth("minimax-media")).toMatchObject({ auth: { apiKey: ["sk", "cp", "fixture"].join("-") }, }); expect(apiCalls(fetch)).toHaveLength(1); const [[, quotaInit] = []] = quotaCalls(fetch); expect(quotaInit).toMatchObject({ method: "GET", redirect: "error" }); expect(new Headers(quotaInit?.headers).get("Authorization")).toBe( "Bearer sk-cp-fixture", ); expect(quotaInit?.body).toBeUndefined(); expect(observed.activity).toEqual([{ provider: "minimax" }]); }); it.each([ ["HTTP 500", () => new Response("boom", { status: 500 })], [ "network failure", () => { throw new Error("offline"); }, ], ["malformed body", () => new Response("not json")], ] as const)( "quota %s never fails image generation and still emits activity", async (_name, quota) => { const { runtime, image } = await setup(); const fetch = api( () => Response.json({ data: { image_base64: [jpeg] } }), quota, ); const value = await runtime.generateImages(image, input, { fetch }); expect(value.stopReason).toBe("stop"); const provenance = JSON.parse( value.output.find((b) => b.type === "text")?.text ?? "{}", ); expect(provenance.quota).toBeUndefined(); expect(quotaCalls(fetch)).toHaveLength(1); expect(observed.activity).toEqual([{ provider: "minimax" }]); }, ); it.each(["missing", "ambiguous", "sk-api-payg"])( "rejects %s credentials without generation", async (key) => { const { runtime, image } = await setup(key === "missing" ? null : key); const fetch = vi.fn(); const result = await runtime.generateImages(image, input, { fetch }); expect(result.stopReason).toBe("error"); expect(result.usage).toBeUndefined(); expect(fetch).not.toHaveBeenCalled(); expect(observed.activity).toEqual([]); }, ); it("rejects agent approval metadata as an unsupported option", async () => { const { runtime, image } = await setup(); const fetch = vi.fn(); const result = await runtime.generateImages(image, input, { fetch, metadata: { approve: true }, }); expect(result.stopReason).toBe("error"); expect(fetch).not.toHaveBeenCalled(); }); it("settles cancellation while the execution credential lookup remains pending", async () => { const { runtime, image } = await setup(); const registry = fixture!.session.extensionRunner.createCommandContext().modelRegistry; const auth = await registry.getProviderAuth("minimax"); const resolving = vi .spyOn(registry, "getProviderAuth") .mockResolvedValueOnce(auth) .mockImplementation(() => new Promise(() => {})); const controller = new AbortController(); const fetch = vi.fn(); const pending = runtime.generateImages(image, input, { fetch, signal: controller.signal, }); await vi.waitFor(() => expect(resolving.mock.calls.length).toBeGreaterThanOrEqual(2), ); controller.abort(); expect((await pending).stopReason).toBe("aborted"); expect(fetch).not.toHaveBeenCalled(); }); it("propagates cancellation to HTTP without retry", async () => { const { runtime, image } = await setup(); const controller = new AbortController(); let requestSignal: AbortSignal | undefined; const fetch = vi.fn( async (_url: string | URL | Request, init?: RequestInit) => { requestSignal = init?.signal ?? undefined; controller.abort(); throw new Error("aborted"); }, ); const result = await runtime.generateImages(image, input, { fetch, signal: controller.signal, }); expect(requestSignal?.aborted).toBe(true); expect(result.stopReason).toBe("aborted"); expect(fetch).toHaveBeenCalledOnce(); }); it("rejects references and malformed replies; partial count uses actual images", async () => { const { runtime, image } = await setup(); const fetch = api(async () => Response.json({ data: { image_base64: [jpeg] } }), ); const invalid = await runtime.generateImages( image, { input: [{ type: "image", data: jpeg, mimeType: "image/jpeg" }] }, { fetch }, ); expect(invalid.stopReason).toBe("error"); expect(fetch).not.toHaveBeenCalled(); const result = await runtime.generateImages(image, input, { fetch, ...{ n: 2 }, }); expect(result.usage?.cost.total).toBe(0.0035); expect( result.output.some( (b) => b.type === "text" && b.text.includes('"partial":true'), ), ).toBe(true); const malformed = await runtime.generateImages(image, input, { fetch: api(async () => Response.json({ data: { image_urls: ["http://private.invalid/?secret=signed"] }, }), ), }); expect(malformed.stopReason).toBe("error"); expect(malformed.usage).toBeUndefined(); }); }); async function invoke(name: string, args: JsonObject) { if (!fixture) throw new Error("Fixture unavailable"); fixture.setResponses([ fauxAssistantMessage(fauxToolCall(name, args), { stopReason: "toolUse" }), fauxAssistantMessage("Done"), ]); await fixture.session.prompt("Exercise fixture tool"); const messages = fixture.session.messages.filter( (m) => m.role === "toolResult" && m.toolName === name, ); const value = messages.at(-1); if (value?.role !== "toolResult") throw new Error("Missing native tool result"); return value; } describe("MiniMax cheap operations need no approval", () => { it("runs image, understanding and speech noninteractively without any setting, and never opens a dialog with UI", async () => { const { runtime, image } = await setup(); const fetch = api(async (url) => { 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" }); return Response.json({ data: { audio: "494433", status: 2 }, extra_info: { usage_characters: 2 }, }); }); vi.stubGlobal("fetch", fetch); const source = join(fixture!.cwd, "input.jpg"); await writeFile(source, Buffer.from(jpeg, "base64")); const run = async (suffix: string) => { expect( (await runtime.generateImages(image, input, { fetch })).stopReason, ).toBe("stop"); expect( (await invoke("minimax_understand_image", { prompt: "Color?", source })) .isError, ).toBe(false); expect( ( await invoke("minimax_speech", { text: "Hi", outputPath: join(fixture!.cwd, `hi-${suffix}.mp3`), }) ).isError, ).toBe(false); }; await run("headless"); const select = vi.fn(async () => "Submit once"); const { runner, confirm } = useUI(select); await runner.emit({ type: "session_start", reason: "reload" }); await run("ui"); expect(select).not.toHaveBeenCalled(); expect(confirm).not.toHaveBeenCalled(); expect(apiCalls(fetch)).toHaveLength(6); expect(observed.activity).toHaveLength(6); }); }); describe("MiniMax speech artifact", () => { it("returns caller-owned MP3, concise text, native estimate using reported chars, quota and structured content", async () => { await setup(); const path = join(fixture!.cwd, "speech.mp3"); const fetch = api( async (url: string | URL | Request, init?: RequestInit) => { expect(String(url)).toBe("https://api.minimax.io/v1/t2a_v2"); expect(JSON.parse(String(init?.body))).toMatchObject({ model: "speech-2.8-turbo", output_format: "hex", stream: false, }); return Response.json({ data: { audio: "494433", status: 2 }, extra_info: { usage_characters: 6, audio_length: 972 }, base_resp: { status_code: 0 }, }); }, ); vi.stubGlobal("fetch", fetch); const value = await invoke("minimax_speech", { text: "Hello.", outputPath: path, }); expect(value.isError).toBe(false); expect(await readFile(path)).toEqual(Buffer.from("ID3")); expect(value.usage?.cost.total).toBeCloseTo(0.00036); expect(textOf(value)).toBe( `Saved MP3 → ${path} · 6 chars · est $0.00036 · ${QUOTA_LINE}`, ); expect(value.details).toMatchObject({ artifact: { path, format: "mp3" }, providerMeasurements: { usage_characters: 6, audio_length: 972 }, encodedDuration: "not measured", quota: { fiveHourLeft: 93, weeklyLeft: 92 }, }); expect(lastStructured("minimax_speech")?.structuredContent).toEqual( value.details, ); expect(observed.activity).toEqual([{ provider: "minimax" }]); const duplicate = await invoke("minimax_speech", { text: "Hello.", outputPath: path, }); expect(duplicate.isError).toBe(true); expect(lastStructured("minimax_speech")).toMatchObject({ isError: true, structuredContent: { error: expect.stringContaining("already exists") }, }); expect(apiCalls(fetch)).toHaveLength(1); expect(observed.activity).toHaveLength(1); }); it("does not turn missing character usage into free speech", async () => { await setup(); vi.stubGlobal( "fetch", api(async () => Response.json({ data: { audio: "494433", status: 2 } })), ); const value = await invoke("minimax_speech", { text: "Hi", outputPath: join(fixture!.cwd, "unknown.mp3"), }); expect(value.isError).toBe(false); expect(value.usage).toBeUndefined(); expect(textOf(value)).toContain("est unknown"); expect(value.details).toMatchObject({ accounting: { kind: "unknown", providerCharge: "unknown" }, }); }); }); describe("MiniMax explicit understanding", () => { it("returns answer text plus one meta line, labeled estimate, quota and structured answer", async () => { await setup(); const source = join(fixture!.cwd, "input.jpg"); await writeFile(source, Buffer.from(jpeg, "base64")); const fetch = api( async (url: string | URL | Request, init?: RequestInit) => { expect(String(url)).toBe("https://api.minimax.io/v1/coding_plan/vlm"); expect(JSON.parse(String(init?.body))).toEqual({ prompt: "Name color", image_url: `data:image/jpeg;base64,${jpeg}`, }); return Response.json({ content: "red", base_resp: { status_code: 0 } }); }, ); vi.stubGlobal("fetch", fetch); const value = await invoke("minimax_understand_image", { prompt: "Name color", source, }); expect(value.isError).toBe(false); expect(textOf(value)).toBe( `red\n\nMiniMax vlm · est $0.01 · ${QUOTA_LINE}`, ); expect(value.usage?.cost).toMatchObject({ total: 0.01, totalFromProvider: false, }); expect(value.details).toMatchObject({ answer: "red", accounting: { kind: "catalog-estimate", unit: "request", providerCharge: "unknown", tokens: "not reported", }, }); expect( lastStructured("minimax_understand_image")?.structuredContent, ).toEqual(value.details); expect(apiCalls(fetch)).toHaveLength(1); expect(observed.activity).toEqual([{ provider: "minimax" }]); }); it("keeps the answer when the quota read fails", async () => { await setup(); const source = join(fixture!.cwd, "input.jpg"); await writeFile(source, Buffer.from(jpeg, "base64")); vi.stubGlobal( "fetch", api( () => Response.json({ content: "blue" }), () => new Response(null, { status: 302, headers: { location: "/x" } }), ), ); const value = await invoke("minimax_understand_image", { prompt: "Name color", source, }); expect(value.isError).toBe(false); expect(textOf(value)).toBe("blue\n\nMiniMax vlm · est $0.01"); expect(value.details).not.toHaveProperty("quota"); expect(observed.activity).toEqual([{ provider: "minimax" }]); }); it("returns structured errors without requests or activity", async () => { await setup(); const fetch = vi.fn(); vi.stubGlobal("fetch", fetch); const value = await invoke("minimax_understand_image", { prompt: "Name color", source: "relative.jpg", }); expect(value.isError).toBe(true); expect(textOf(value)).toBe( "Image source must be absolute local path or public HTTPS URL.", ); expect(lastStructured("minimax_understand_image")).toMatchObject({ isError: true, structuredContent: { errorKind: "local-or-incompatible", error: "Image source must be absolute local path or public HTTPS URL.", }, }); expect(fetch).not.toHaveBeenCalled(); expect(observed.activity).toEqual([]); }); }); describe("MiniMax H3 ownership and resumption", () => { it("persists acknowledgment before observation; native estimate appears once across polling/reload", async () => { await setup("sk-cp-fixture", "always"); let polls = 0; const fetch = api( async (url: string | URL | Request, init?: RequestInit) => { if (init?.method === "POST") { expect(JSON.parse(String(init.body))).toMatchObject({ model: "MiniMax-H3", duration: 4, resolution: "768P", ratio: "1:1", content: [{ type: "text", text: "A red ball" }], }); return Response.json({ task_id: "task-owned" }); } expect(String(url)).toBe( "https://api.minimax.io/v2/query/video_generation/task-owned", ); polls++; return Response.json({ task: { id: "task-owned", model: "MiniMax-H3", status: polls === 1 ? "running" : "succeeded", usage: polls === 1 ? {} : { output_seconds: 4, input_seconds: 0, input_image_count: 0, total_tokens: 130196, completion_tokens: 130196, }, content: { url: "https://127.0.0.1/video.mp4?signature=do-not-expose", }, }, }); }, ); vi.stubGlobal("fetch", fetch); const submitted = await invoke("minimax_video", { action: "submit", job: "ball", prompt: "A red ball", }); expect(submitted.isError).toBe(false); expect(submitted.details).toMatchObject({ state: "pending", taskId: "task-owned", quota: { fiveHourLeft: 93 }, }); expect(textOf(submitted)).toBe( `H3 job ball · task task-owned · pending · ${QUOTA_LINE}`, ); expect(submitted.usage).toBeUndefined(); expect(apiCalls(fetch)).toHaveLength(1); expect( fixture!.session.sessionManager .getEntries() .filter((e) => e.type === "custom") .at(-1), ).toMatchObject({ customType: "minimax.h3.job.v1", data: { taskId: "task-owned", job: "ball", state: "pending" }, }); const pending = await invoke("minimax_video", { action: "status", job: "ball", }); expect(pending.details).toMatchObject({ state: "pending" }); expect(textOf(pending)).toBe("H3 job ball · task task-owned · pending"); expect(pending.usage).toBeUndefined(); expect(quotaCalls(fetch)).toHaveLength(1); const finished = await invoke("minimax_video", { action: "status", job: "ball", }); expect(finished.details).toMatchObject({ state: "completed", encodedDuration: "not measured", providerMeasurements: { total_tokens: 130196, output_seconds: 4 }, accounting: { kind: "catalog-estimate", unit: "provider-reported output second", }, quota: { weeklyLeft: 92 }, }); expect(textOf(finished)).toBe( `H3 job ball · task task-owned · completed · est $0.32 · ${QUOTA_LINE}`, ); expect(finished.usage?.cost.total).toBe(0.32); expect(finished.usage?.totalTokens).toBe(0); expect(quotaCalls(fetch)).toHaveLength(2); expect(observed.activity).toHaveLength(2); await fixture!.session.extensionRunner.emit({ type: "session_shutdown", reason: "reload", }); await fixture!.session.extensionRunner.emit({ type: "session_start", reason: "reload", }); const resumed = await invoke("minimax_video", { action: "status", job: "ball", }); expect(resumed.usage).toBeUndefined(); expect(resumed.details).toMatchObject({ accountingDelivery: "already emitted; not recounted", }); // Repeat observations must not present the estimate as a fresh charge. expect(textOf(resumed)).toBe( "H3 job ball · task task-owned · completed · counted earlier", ); expect(quotaCalls(fetch)).toHaveLength(2); const duplicate = await invoke("minimax_video", { action: "submit", job: "ball", prompt: "A red ball", }); expect(duplicate.details).toMatchObject({ taskId: "task-owned" }); expect(posts(fetch)).toHaveLength(1); const before = fetch.mock.calls.length; const stranger = await invoke("minimax_video", { action: "status", job: "unowned", }); expect(stranger.isError).toBe(true); expect(fetch).toHaveBeenCalledTimes(before); const listed = await invoke("minimax_video", { action: "list" }); expect(textOf(listed)).toBe("H3 job ball · task task-owned · completed"); expect(lastStructured("minimax_video")?.structuredContent).toMatchObject({ jobs: [{ job: "ball", state: "completed" }], networkRequests: 0, }); const retrieved = await invoke("minimax_video", { action: "retrieve", job: "ball", outputPath: join(fixture!.cwd, "output.mp4"), }); expect(retrieved.isError).toBe(true); expect(retrieved.usage).toBeUndefined(); expect(JSON.stringify(retrieved)).not.toContain("do-not-expose"); expect(JSON.stringify(retrieved)).not.toContain("127.0.0.1"); }); it("records unknown submit outcome; same job never resubmits", async () => { await setup("sk-cp-fixture", "always"); const fetch = vi.fn(async () => { throw new Error("network interrupted"); }); vi.stubGlobal("fetch", fetch); const lost = await invoke("minimax_video", { action: "submit", job: "lost", prompt: "A ball", }); expect(lost.isError).toBe(true); expect(lost.details).toMatchObject({ state: "unknown", job: "lost" }); expect(lastStructured("minimax_video")?.structuredContent).toMatchObject({ state: "unknown", job: "lost", }); await invoke("minimax_video", { action: "submit", job: "lost", prompt: "A ball", }); const observedJob = await invoke("minimax_video", { action: "status", job: "lost", }); expect(observedJob.details).toMatchObject({ state: "unknown" }); expect(fetch).toHaveBeenCalledOnce(); expect(observed.activity).toEqual([]); }); it.each(["cancelled", "deleted"])( "reports upstream %s instead of inventing cancellation/refund", async (action) => { await setup("sk-cp-fixture", "always"); const fetch = api( async (_url: string | URL | Request, init?: RequestInit) => { return Response.json( init?.method === "POST" ? { task_id: "task-cancel" } : init?.method === "DELETE" ? { task_id: "task-cancel", action, status: action } : { task: { id: "task-cancel", model: "MiniMax-H3", status: "queued", usage: {}, }, }, ); }, ); vi.stubGlobal("fetch", fetch); await invoke("minimax_video", { action: "submit", job: "cancel", prompt: "A ball", }); const cancelled = await invoke("minimax_video", { action: "cancel", job: "cancel", }); expect(cancelled.details).toMatchObject({ state: action, upstreamAction: action, }); expect(textOf(cancelled)).toBe( `H3 job cancel · task task-cancel · ${action} · upstream action; no refund claim.`, ); expect(cancelled.usage).toBeUndefined(); if (action === "deleted") expect(cancelled.details).toMatchObject({ accounting: { kind: "unknown" }, }); expect( apiCalls(fetch).filter((c) => c[1]?.method === "DELETE"), ).toHaveLength(1); }, ); }); describe("MiniMax local discovery", () => { it("reports tiered spending, conditional unavailable and unverified tier without any HTTP", async () => { await setup(); const fetch = vi.fn(); vi.stubGlobal("fetch", fetch); const value = await invoke("minimax_capabilities", {}); expect(value.isError).toBe(false); expect(fetch).not.toHaveBeenCalled(); expect(value.details).toMatchObject({ networkRequests: 0, accountTier: "unknown", credential: { state: "subscription-key-prefix" }, spending: { image: "no-approval", understanding: "no-approval", speech: "no-approval", video: "blocked-noninteractive-until-videoApproval-always", }, videoApproval: { source: "default", value: "ask" }, conditional: expect.arrayContaining([ { operation: "transcription", state: "unavailable-unverified", reason: expect.any(String), }, ]), }); expect(textOf(value)).not.toContain("{"); expect(textOf(value)).toContain("Purchased Credits"); expect(lastStructured("minimax_capabilities")?.structuredContent).toEqual( value.details, ); expect(JSON.stringify(value)).not.toContain("sk-cp-fixture"); expect(observed.activity).toEqual([]); }); it("reports CN unavailable without probe", async () => { await setup("sk-cp-fixture", "always"); process.env["PI_MINIMAX_REGION"] = "cn"; const fetch = vi.fn(); vi.stubGlobal("fetch", fetch); const value = await invoke("minimax_capabilities", {}); expect(value.details).toMatchObject({ region: "cn", core: expect.arrayContaining([ expect.objectContaining({ availability: "blocked", blocker: "CN media routes not established", }), ]), }); const image = fixture!.session.modelRuntime.getModelOfType( "image", "minimax-media", "image-01", )!; const generated = await fixture!.session.modelRuntime.generateImages( image, input, { fetch }, ); expect(generated.stopReason).toBe("error"); expect(fetch).not.toHaveBeenCalled(); }); }); function stubH3() { let acknowledged = 0; const fetch = api(async (_url, init) => Response.json( init?.method === "POST" ? { task_id: `task-${++acknowledged}` } : {}, ), ); vi.stubGlobal("fetch", fetch); return fetch; } const submit = (job: string, extra: JsonObject = {}) => invoke("minimax_video", { action: "submit", job, prompt: "A ball", ...extra, }); const jobEntries = (job: string) => fixture!.session.sessionManager .getEntries() .filter( (e) => e.type === "custom" && e.customType === "minimax.h3.job.v1" && (e.data as { job?: string }).job === job, ); describe("MiniMax tiered H3 approval", () => { it("blocks noninteractive H3 submit by default with an actionable error and zero requests", async () => { await setup(); const fetch = stubH3(); const value = await submit("headless"); expect(value.isError).toBe(true); expect(textOf(value)).toContain("minimax.videoApproval"); expect(textOf(value)).toContain("PI_MINIMAX_VIDEO_APPROVAL=always"); expect(fetch).not.toHaveBeenCalled(); expect(jobEntries("headless")).toEqual([]); expect(observed.activity).toEqual([]); }); it.each([ ["always", undefined, true], ["ask", "always", false], ["invalid", "always", false], ] as const)( "env %s overrides USER %s without fallthrough", async (env, user, allowed) => { await setup("sk-cp-fixture", user, { env: { PI_MINIMAX_VIDEO_APPROVAL: env }, }); const fetch = stubH3(); const value = await submit("env"); expect(value.isError).toBe(!allowed); expect(posts(fetch)).toHaveLength(allowed ? 1 : 0); }, ); it.each([ [undefined, "always", false], ["always", "ask", true], ] as const)( "trusted project %s never authorizes or revokes USER %s", async (user, project, allowed) => { await setup("sk-cp-fixture", user, { projectTrusted: true }); await mkdir(join(fixture!.cwd, ".pi"), { recursive: true }); await writeFile( join(fixture!.cwd, ".pi", "settings.json"), JSON.stringify({ minimax: { videoApproval: project } }), ); const fetch = stubH3(); const value = await submit("project"); expect(value.isError).toBe(!allowed); expect(posts(fetch)).toHaveLength(allowed ? 1 : 0); }, ); it.each([true, false])( "region obeys trusted project only: trust %s", async (trusted) => { const { runtime, image } = await setup("sk-cp-fixture", undefined, { projectTrusted: trusted, }); await mkdir(join(fixture!.cwd, ".pi"), { recursive: true }); await writeFile( join(fixture!.cwd, ".pi", "settings.json"), JSON.stringify({ minimax: { region: "cn" } }), ); const fetch = api(async () => Response.json({ data: { image_base64: [jpeg] } }), ); const value = await runtime.generateImages(image, input, { fetch }); expect(value.stopReason).toBe(trusted ? "error" : "stop"); expect(apiCalls(fetch)).toHaveLength(trusted ? 0 : 1); }, ); it("asks with cost disclosure; once, session allowance, cancel and dismissal behave exactly", async () => { await setup(); const answers: (string | undefined)[] = [ "Submit once", "Allow H3 for this session", "Cancel", undefined, ]; const select = vi.fn( async ( _title: string, _options: string[], _opts?: ExtensionUIDialogOptions, ) => answers.shift(), ); const { runner, confirm } = useUI(select); await runner.emit({ type: "session_start", reason: "reload" }); const fetch = stubH3(); expect( (await submit("once", { duration: 6, resolution: "2K" })).isError, ).toBe(false); expect(select).toHaveBeenCalledTimes(1); const [title, options, opts] = select.mock.calls[0]!; expect(title).toContain("6s at 2K"); expect(title).toContain("$0.78"); expect(title).toContain("0.08 USD/s at 768P"); expect(title).toContain("0.13 USD/s at 2K"); expect(title).toMatch(/weekly-only/); expect(title).toMatch(/Go plan lacks H3/); expect(title).toMatch(/Credits/); expect(options).toEqual([ "Submit once", "Allow H3 for this session", "Cancel", ]); expect(opts?.signal).toBeInstanceOf(AbortSignal); expect((await submit("session-1")).isError).toBe(false); expect(select).toHaveBeenCalledTimes(2); expect((await submit("session-2")).isError).toBe(false); expect(select).toHaveBeenCalledTimes(2); expect(posts(fetch)).toHaveLength(3); // A new session_start forgets the allowance. await runner.emit({ type: "session_start", reason: "reload" }); const before = fetch.mock.calls.length; const cancelled = await submit("cancelled"); expect(cancelled.isError).toBe(true); expect(textOf(cancelled)).toContain("declined"); const dismissed = await submit("dismissed"); expect(dismissed.isError).toBe(true); expect(select).toHaveBeenCalledTimes(4); expect(fetch).toHaveBeenCalledTimes(before); expect(jobEntries("cancelled")).toEqual([]); expect(jobEntries("dismissed")).toEqual([]); expect(confirm).not.toHaveBeenCalled(); }); it("abort while the select dialog is open sends nothing", async () => { await setup(); let dialogSignal: AbortSignal | undefined; const select = vi.fn( async (_t: string, _o: string[], opts?: ExtensionUIDialogOptions) => new Promise((resolve) => { dialogSignal = opts?.signal; opts?.signal?.addEventListener("abort", () => resolve(undefined), { once: true, }); void fixture!.session.abort(); }), ); const { runner } = useUI(select); await runner.emit({ type: "session_start", reason: "reload" }); const fetch = stubH3(); fixture!.setResponses([ fauxAssistantMessage( fauxToolCall("minimax_video", { action: "submit", job: "aborted", prompt: "A ball", }), { stopReason: "toolUse" }, ), fauxAssistantMessage("Done"), ]); await fixture!.session.prompt("Abort during dialog"); expect(select).toHaveBeenCalledOnce(); expect(dialogSignal?.aborted).toBe(true); expect(fetch).not.toHaveBeenCalled(); expect(jobEntries("aborted")).toEqual([]); }); it("USER always submits without opening a dialog even when UI exists", async () => { await setup("sk-cp-fixture", "always"); const select = vi.fn(async () => "Cancel"); const { runner } = useUI(select); await runner.emit({ type: "session_start", reason: "reload" }); const fetch = stubH3(); expect((await submit("always")).isError).toBe(false); expect(select).not.toHaveBeenCalled(); expect(posts(fetch)).toHaveLength(1); }); }); describe("MiniMax durable native accounting", () => { it("reopens actual persisted session with fresh extension, keeps task ownership, does not recount known value", async () => { const cwd = await mkdtemp(join(tmpdir(), "minimax-session-")); temporary.push(cwd); const manager = SessionManager.create(cwd, join(cwd, "sessions")); await setup("sk-cp-fixture", "always", { cwd, sessionManager: manager }); const fetch = api( async (_url: string | URL | Request, init?: RequestInit) => Response.json( init?.method === "POST" ? { task_id: "persistent-task" } : { task: { id: "persistent-task", model: "MiniMax-H3", status: "succeeded", usage: { output_seconds: 4, input_seconds: 0, input_image_count: 0, }, }, }, ), ); vi.stubGlobal("fetch", fetch); await invoke("minimax_video", { action: "submit", job: "persist", prompt: "A ball", }); const intent = manager .getEntries() .find((e) => e.type === "custom" && e.customType === "minimax.h3.job.v1"); const original = JSON.stringify(intent); const complete = await invoke("minimax_video", { action: "status", job: "persist", }); expect(complete.usage?.cost.total).toBe(0.32); expect(JSON.stringify(intent)).toBe(original); const path = manager.getSessionFile(); if (!path) throw new Error("Persisted fixture missing path"); await fixture!.dispose(); fixture = undefined; await setup("sk-cp-fixture", "always", { cwd, sessionManager: SessionManager.open(path), }); vi.stubGlobal("fetch", fetch); const resumed = await invoke("minimax_video", { action: "status", job: "persist", }); expect(resumed.usage).toBeUndefined(); expect(resumed.details).toMatchObject({ taskId: "persistent-task", state: "completed", }); const calls = fetch.mock.calls.length; await fixture!.dispose(); fixture = undefined; const fork = SessionManager.inMemory(cwd); for (const entry of manager.getEntries()) if (entry.type === "custom") fork.appendCustomEntry(entry.customType, entry.data); await setup("sk-cp-fixture", "always", { cwd, sessionManager: fork }); vi.stubGlobal("fetch", fetch); const foreign = await invoke("minimax_video", { action: "status", job: "persist", }); expect(foreign.isError).toBe(true); expect(fetch).toHaveBeenCalledTimes(calls); }); }); it("nested codemode-style calls retain native usage, structured content, per-job concurrency lock, persisted dedup", async () => { const cwd = await mkdtemp(join(tmpdir(), "minimax-nested-")); temporary.push(cwd); const manager = SessionManager.create(cwd, join(cwd, "sessions")); const ready = Promise.withResolvers(), release = Promise.withResolvers(); const bridge: ExtensionFactory = (pi) => { pi.registerTool({ name: "nested_noop", label: "Noop", description: "Bounded record fixture", parameters: Type.Object({}), async execute() { return { content: [{ type: "text", text: "ok" }], details: {} }; }, }); pi.registerTool({ name: "nested_h3", label: "Nested fixture", description: "Fixture nested API", parameters: Type.Object({ job: Type.String() }), async execute(_id, params, _signal, _update, ctx) { for (let i = 0; i < 256; i++) await ctx.executeTool("nested_noop", {}); const first = ctx.executeTool("minimax_video", { action: "status", job: params.job, }); await ready.promise; const second = await ctx.executeTool("minimax_video", { action: "status", job: params.job, }); const third = await ctx.executeTool("minimax_video", { action: "status", job: params.job, }); release.resolve(); const final = await first; return { content: final.result.content, details: { secondError: second.isError, thirdError: third.isError, completed: !final.isError, structured: final.result.structuredContent ?? null, }, }; }, }); }; await setup("sk-cp-fixture", "always", { cwd, sessionManager: manager, extensionFactories: [bridge], }); const fetch = api( async (_url: string | URL | Request, init?: RequestInit) => { if (init?.method === "POST") return Response.json({ task_id: "nested-task" }); ready.resolve(); await release.promise; return Response.json({ task: { id: "nested-task", model: "MiniMax-H3", status: "succeeded", usage: { output_seconds: 4, input_seconds: 0, input_image_count: 0 }, }, }); }, ); vi.stubGlobal("fetch", fetch); await invoke("minimax_video", { action: "submit", job: "nested", prompt: "A ball", }); const nested = await invoke("nested_h3", { job: "nested" }); expect(nested.isError).toBe(false); expect(nested.details).toMatchObject({ secondError: true, thirdError: true, completed: true, structured: { job: "nested", taskId: "nested-task", state: "completed" }, }); expect(nested.usage?.cost.total).toBe(0.32); expect(nested.nestedCalls?.calls).toHaveLength(256); expect(nested.nestedCalls?.complete).toBe(false); expect( nested.nestedCalls?.calls.some((call) => call.name === "minimax_video"), ).toBe(false); expect(apiCalls(fetch)).toHaveLength(2); const path = manager.getSessionFile(); if (!path) throw new Error("Persisted nested fixture absent"); await fixture!.dispose(); fixture = undefined; await setup("sk-cp-fixture", "always", { cwd, sessionManager: SessionManager.open(path), }); vi.stubGlobal("fetch", fetch); const again = await invoke("minimax_video", { action: "status", job: "nested", }); expect(again.usage).toBeUndefined(); expect(again.details).toMatchObject({ state: "completed" }); }); it.each([ [401, "authentication"], [403, "entitlement"], [402, "allowance-exhausted"], [429, "rate-limit"], ] as const)( "H3 rejection HTTP %s remains distinguishable with zero retries", async (status, kind) => { await setup("sk-cp-fixture", "always"); const fetch = vi.fn(async () => Response.json({}, { status })); vi.stubGlobal("fetch", fetch); const failed = await invoke("minimax_video", { action: "submit", job: "rejected", prompt: "A ball", }); expect(failed.isError).toBe(true); expect(failed.details).toMatchObject({ state: "failed", errorKind: kind, failureKind: kind, }); expect(failed.usage).toBeUndefined(); await invoke("minimax_video", { action: "submit", job: "rejected", prompt: "A ball", }); expect(fetch).toHaveBeenCalledOnce(); expect(observed.activity).toEqual([]); }, );