};

let runEmbeddedPiAgent: typeof import("./pi-embedded-runner/run.js").runEmbeddedPiAgent;

let authProfileUsageTesting: typeof import("./auth-profiles/usage.js").__testing;

let createDiagnosticLogRecordCaptureFn: typeof import("../logging/test-helpers/diagnostic-log-capture.js").createDiagnosticLogRecordCapture;

let cleanupLogCapture: (() => void) | undefined;

let resetLoggerFn: typeof import("../logging/logger.js").resetLogger;

vi.resetModules();

installRunEmbeddedMocks();

({ runEmbeddedPiAgent } = await import("./pi-embedded-runner/run.js"));

({ __testing: authProfileUsageTesting } = await import("./auth-profiles/usage.js"));

({ createDiagnosticLogRecordCapture: createDiagnosticLogRecordCaptureFn } =

await import("../logging/test-helpers/diagnostic-log-capture.js"));

({ resetLogger: resetLoggerFn, setLoggerOverride: setLoggerOverrideFn } =

afterEach(() => {

globalThis.fetch = originalFetch;

authProfileUsageTesting.setDepsForTest(null);

cleanupLogCapture?.();

cleanupLogCapture = undefined;

setLoggerOverrideFn(null);

expect(sleepWithAbortMock).not.toHaveBeenCalled();

});

it("starts the retry attempt before prompt failure cooldown marking finishes", async () => {

let releaseMark: (() => void) | undefined;

const markCanFinish = new Promise<void>((resolve) => {

releaseMark = resolve;

});

let markStarted = false;

authProfileUsageTesting.setDepsForTest({

updateAuthProfileStoreWithLock: async () => {

markStarted = true;

await markCanFinish;

return null;

},

});

try {

await withAgentWorkspace(async ({ agentDir, workspaceDir }) => {

await writeAuthStore(agentDir);

mockPromptErrorThenSuccessfulAttempt("rate limit exceeded");

const runPromise = runAutoPinnedOpenAiTurn({

agentDir,

workspaceDir,

sessionKey: "agent:test:prompt-deferred-mark",

runId: "run:prompt-deferred-mark",

});

await vi.waitFor(() => expect(runEmbeddedAttemptMock).toHaveBeenCalledTimes(2));

expect(markStarted).toBe(true);

releaseMark?.();

releaseMark = undefined;

await runPromise;

const usageStats = await readUsageStats(agentDir);

expect(typeof usageStats["openai:p2"]?.lastUsed).toBe("number");

});

} finally {

releaseMark?.();

}

});

it("uses configured overload backoff before rotating profiles", async () => {

const { usageStats } = await runAutoPinnedRotationCase({

errorMessage: '{"type":"error","error":{"type":"overloaded_error","message":"Overloaded"}}',

});

it("skips profiles in cooldown when rotating after failure", async () => {

await withTimedAgentWorkspace(async ({ agentDir, workspaceDir, now }) => {

await withAgentWorkspace(async ({ agentDir, workspaceDir }) => {

const authPath = path.join(agentDir, "auth-profiles.json");

const p2CooldownUntil = Date.now() + 60 * 60 * 1000;

const payload = {

version: 1,

profiles: {

},

usageStats: {

"openai:p1": { lastUsed: 1 },

"openai:p2": { cooldownUntil: now + 60 * 60 * 1000 }, // p2 in cooldown

"openai:p2": { cooldownUntil: p2CooldownUntil }, // p2 in cooldown

"openai:p3": { lastUsed: 3 },

},

};

const usageStats = await readUsageStats(agentDir);

expect(typeof usageStats["openai:p1"]?.lastUsed).toBe("number");

expect(typeof usageStats["openai:p3"]?.lastUsed).toBe("number");

expect(usageStats["openai:p2"]?.cooldownUntil).toBe(now + 60 * 60 * 1000);

expect(usageStats["openai:p2"]?.cooldownUntil).toBe(p2CooldownUntil);

});

});

});