resolveFinalAssistantRawText,

resolveFinalAssistantVisibleText,

resolveNextSameModelRateLimitRetryCount,

resolveSameModelRateLimitBackoffMs,

resolveSameModelRateLimitRetryDelayMs,

} from "./helpers.js";

});

});

describe("resolveSameModelRateLimitBackoffMs", () => {

describe("resolveSameModelRateLimitRetryDelayMs", () => {

it("waits 10s/20s/30s linearly before the 1st/2nd/3rd same-model retry", () => {

expect(resolveSameModelRateLimitBackoffMs(0)).toBe(10_000);

expect(resolveSameModelRateLimitBackoffMs(1)).toBe(20_000);

expect(resolveSameModelRateLimitBackoffMs(2)).toBe(30_000);

expect(resolveSameModelRateLimitRetryDelayMs({ retriesSoFar: 0 })).toBe(10_000);

expect(resolveSameModelRateLimitRetryDelayMs({ retriesSoFar: 1 })).toBe(20_000);

expect(resolveSameModelRateLimitRetryDelayMs({ retriesSoFar: 2 })).toBe(30_000);

});

it("caps at 60s if the retry count is ever raised further", () => {

expect(resolveSameModelRateLimitBackoffMs(10)).toBe(60_000);

expect(resolveSameModelRateLimitRetryDelayMs({ retriesSoFar: 10 })).toBe(60_000);

});

it("is deterministic so RPM windows clear predictably", () => {

expect(resolveSameModelRateLimitBackoffMs(2)).toBe(resolveSameModelRateLimitBackoffMs(2));

expect(resolveSameModelRateLimitRetryDelayMs({ retriesSoFar: 2 })).toBe(

resolveSameModelRateLimitRetryDelayMs({ retriesSoFar: 2 }),

);

});

});

describe("resolveSameModelRateLimitRetryDelayMs", () => {

it("honors a short provider Retry-After when it is longer than the fixed backoff", () => {

expect(

resolveSameModelRateLimitRetryDelayMs({

* retries already happened. Linear and deterministic (no jitter) so RPM

* windows clear predictably and tests can assert exact values.

*/

export function resolveSameModelRateLimitBackoffMs(retriesSoFar: number): number {

const delay = SAME_MODEL_RATE_LIMIT_BACKOFF_STEP_MS * (Math.max(0, retriesSoFar) + 1);

return Math.min(SAME_MODEL_RATE_LIMIT_MAX_BACKOFF_MS, delay);

}

export function resolveSameModelRateLimitRetryDelayMs(params: {

retriesSoFar: number;

retryAfterSeconds?: number;

}): number {

const backoffMs = resolveSameModelRateLimitBackoffMs(params.retriesSoFar);

const backoffDelayMs =

SAME_MODEL_RATE_LIMIT_BACKOFF_STEP_MS * (Math.max(0, params.retriesSoFar) + 1);

const backoffMs = Math.min(SAME_MODEL_RATE_LIMIT_MAX_BACKOFF_MS, backoffDelayMs);

const retryAfterMs = Number.isFinite(params.retryAfterSeconds)

? Math.ceil(Math.max(0, params.retryAfterSeconds ?? 0) * 1000)

: 0;