mirror of
https://github.com/diegosouzapw/OmniRoute.git
synced 2026-11-16 17:09:09 +00:00
588 lines
24 KiB
TypeScript
588 lines
24 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
const {
|
|
classifyProviderError,
|
|
isResourceNotFoundResponse,
|
|
isCloudflareFingerprintRejection,
|
|
isCloudflareChallengeInterstitial,
|
|
isAnthropicOAuthProvider,
|
|
isAnthropicRequestNotAllowed,
|
|
PROVIDER_ERROR_TYPES,
|
|
} = await import("../../open-sse/services/errorClassifier.ts");
|
|
|
|
test("classifyProviderError: 401 + account_deactivated => ACCOUNT_DEACTIVATED", () => {
|
|
const body = JSON.stringify({
|
|
error: { message: "account_deactivated: this account has been disabled" },
|
|
});
|
|
const result = classifyProviderError(401, body);
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.ACCOUNT_DEACTIVATED);
|
|
});
|
|
|
|
test("classifyProviderError: plain 401 => UNAUTHORIZED", () => {
|
|
const result = classifyProviderError(401, { error: { message: "token expired" } });
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.UNAUTHORIZED);
|
|
});
|
|
|
|
test("classifyProviderError: 402 => QUOTA_EXHAUSTED", () => {
|
|
const result = classifyProviderError(402, { error: { message: "payment required" } });
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED);
|
|
});
|
|
|
|
test("classifyProviderError: 400 + billing signal => QUOTA_EXHAUSTED", () => {
|
|
const result = classifyProviderError(400, {
|
|
error: { message: "insufficient_quota: exceeded your current quota" },
|
|
});
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED);
|
|
|
|
const resultExhausted = classifyProviderError(400, {
|
|
error: { message: "The free tier of the model has been exhausted." },
|
|
});
|
|
assert.equal(resultExhausted, PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED);
|
|
});
|
|
|
|
test("classifyProviderError: Kimi billing-cycle 403 => QUOTA_EXHAUSTED", () => {
|
|
const result = classifyProviderError(
|
|
403,
|
|
{
|
|
error: {
|
|
message:
|
|
"You've reached your usage limit for this billing cycle. Your quota will be refreshed in the next cycle.",
|
|
},
|
|
},
|
|
"kimi-coding"
|
|
);
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED);
|
|
});
|
|
|
|
test("classifyProviderError: 429 without billing signal => RATE_LIMITED", () => {
|
|
const result = classifyProviderError(429, { error: { message: "too many requests" } });
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.RATE_LIMITED);
|
|
});
|
|
|
|
test("classifyProviderError: 429 with billing signal and no provider keeps legacy QUOTA_EXHAUSTED", () => {
|
|
const result = classifyProviderError(429, {
|
|
error: { message: "insufficient_quota: exceeded your current quota" },
|
|
});
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED);
|
|
});
|
|
|
|
test("classifyProviderError: API-key provider 429 with billing signal => RATE_LIMITED", () => {
|
|
const result = classifyProviderError(
|
|
429,
|
|
{
|
|
error: { message: "insufficient_quota: exceeded your current quota" },
|
|
},
|
|
"openai"
|
|
);
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.RATE_LIMITED);
|
|
});
|
|
|
|
test("classifyProviderError: OAuth provider 429 with billing signal => QUOTA_EXHAUSTED", () => {
|
|
const result = classifyProviderError(
|
|
429,
|
|
{
|
|
error: { message: "insufficient_quota: exceeded your current quota" },
|
|
},
|
|
"codex"
|
|
);
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED);
|
|
});
|
|
|
|
test("classifyProviderError: 403 with 'has not been used in project' => PROJECT_ROUTE_ERROR (transient)", () => {
|
|
const result = classifyProviderError(403, {
|
|
error: {
|
|
message:
|
|
"Cloud Code Private API has not been used in project 12345 before or it is disabled.",
|
|
},
|
|
});
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.PROJECT_ROUTE_ERROR);
|
|
});
|
|
|
|
test("classifyProviderError: 403 plain => FORBIDDEN (terminal)", () => {
|
|
const result = classifyProviderError(403, {
|
|
error: { message: "The caller does not have permission" },
|
|
});
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.FORBIDDEN);
|
|
});
|
|
|
|
test("classifyProviderError: API-key provider plain 403 is recoverable", () => {
|
|
const result = classifyProviderError(
|
|
403,
|
|
{
|
|
error: { message: "The caller does not have permission" },
|
|
},
|
|
"glm"
|
|
);
|
|
assert.equal(result, null);
|
|
});
|
|
|
|
test("classifyProviderError: 403 with project string as plain string body => PROJECT_ROUTE_ERROR", () => {
|
|
const body = JSON.stringify({
|
|
error: { message: "API has not been used in project abc-xyz before" },
|
|
});
|
|
const result = classifyProviderError(403, body);
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.PROJECT_ROUTE_ERROR);
|
|
});
|
|
|
|
test("classifyProviderError: API-key provider 429 with daily quota signal => RATE_LIMITED", () => {
|
|
const body = JSON.stringify({
|
|
error: {
|
|
message:
|
|
"You have exceeded today's quota for model moonshotai/Kimi-K2.5, please try again tomorrow",
|
|
},
|
|
});
|
|
const result = classifyProviderError(429, body, "openai");
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.RATE_LIMITED);
|
|
});
|
|
|
|
test("classifyProviderError: OAuth provider 429 with daily quota signal => QUOTA_EXHAUSTED", () => {
|
|
const result = classifyProviderError(
|
|
429,
|
|
{
|
|
error: { message: "You have reached your daily quota limit" },
|
|
},
|
|
"codex"
|
|
);
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED);
|
|
});
|
|
|
|
// #6827 — 404 must be classified as MODEL_NOT_FOUND, not fall through to null.
|
|
// Without this, no cooldown/lockout is applied and the retry loop keeps hitting
|
|
// the dead endpoint until the upstream rate-limits it (404 + 429 storm).
|
|
test("classifyProviderError: 404 => MODEL_NOT_FOUND", () => {
|
|
const result = classifyProviderError(404, {
|
|
error: { message: "model v0-1.5-md not found" },
|
|
});
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.MODEL_NOT_FOUND);
|
|
});
|
|
|
|
test("classifyProviderError: 404 with provider => MODEL_NOT_FOUND", () => {
|
|
const result = classifyProviderError(404, { error: { message: "Not Found" } }, "v0-vercel");
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.MODEL_NOT_FOUND);
|
|
});
|
|
|
|
test("classifyProviderError: Files API 404 is request-scoped, not MODEL_NOT_FOUND", () => {
|
|
const body = {
|
|
error: {
|
|
message: "[404]: Files [file-be30851bd1614656872e725e] were not found",
|
|
type: "invalid_request_error",
|
|
// A compatibility layer may derive this from the HTTP status before the
|
|
// upstream file message is inspected. The resource signal must win.
|
|
code: "model_not_found",
|
|
},
|
|
};
|
|
|
|
assert.equal(isResourceNotFoundResponse(body), true);
|
|
assert.equal(classifyProviderError(404, body, "codex"), null);
|
|
});
|
|
|
|
test("classifyProviderError: other request-resource 404 shapes do not poison model health", () => {
|
|
const bodies = [
|
|
{ error: { message: "input_file file_id does not exist" } },
|
|
{ error: { message: "Response resp_123 was not found" } },
|
|
{ error: { message: "vector_store vs_123 not found" } },
|
|
"Upload upload_123 does not exist",
|
|
];
|
|
|
|
for (const body of bodies) {
|
|
assert.equal(isResourceNotFoundResponse(body), true);
|
|
assert.equal(classifyProviderError(404, body, "openai"), null);
|
|
}
|
|
});
|
|
|
|
test("classifyProviderError: Cloudflare 1010 (browser signature) => FINGERPRINT_REJECTION, not FORBIDDEN/banned", () => {
|
|
// Verbatim body shape from the 2026-08-08 incident: the gateway wraps the
|
|
// upstream Cloudflare error inside error.message as a nested JSON string.
|
|
const body = JSON.stringify({
|
|
error: {
|
|
message:
|
|
'[openai/deepseek-v4-flash-free] [403]: {"type":"https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1010/","title":"Error 1010: Access denied","status":403,"detail":"The site owner has blocked access based on your browser\'s signature.","instance":"a283cb68eb52bda8","error_code":1010,"error_name":"browser_signature_banned"}',
|
|
},
|
|
});
|
|
const result = classifyProviderError(403, body, "opencode");
|
|
assert.equal(
|
|
result,
|
|
PROVIDER_ERROR_TYPES.FINGERPRINT_REJECTION,
|
|
"a Cloudflare 1010 must be classified as fingerprint rejection, never FORBIDDEN"
|
|
);
|
|
assert.notEqual(
|
|
result,
|
|
PROVIDER_ERROR_TYPES.FORBIDDEN,
|
|
"must not fall through to FORBIDDEN/banned"
|
|
);
|
|
});
|
|
|
|
test("classifyProviderError: Cloudflare 1010 via error_name only (no numeric code) => FINGERPRINT_REJECTION", () => {
|
|
const body = JSON.stringify({
|
|
error: {
|
|
message:
|
|
'[403] {"error_name":"browser_signature_banned","detail":"blocked access based on your browser\'s signature"}',
|
|
},
|
|
});
|
|
const result = classifyProviderError(403, body);
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.FINGERPRINT_REJECTION);
|
|
});
|
|
|
|
test("classifyProviderError: plain 403 stays FORBIDDEN (not fingerprint rejection)", () => {
|
|
const result = classifyProviderError(403, { error: { message: "you do not have permission" } });
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.FORBIDDEN);
|
|
});
|
|
|
|
test("isCloudflareFingerprintRejection: error_code 10101 is NOT 1010 (boundary)", () => {
|
|
// Review finding: the code-number match must not trip on a longer numeric suffix.
|
|
assert.equal(isCloudflareFingerprintRejection('{"error_code":10101}'), false);
|
|
assert.equal(isCloudflareFingerprintRejection("error 10101: something else"), false);
|
|
});
|
|
|
|
test("isCloudflareFingerprintRejection: bare browser_signature_banned matches (no quotes needed)", () => {
|
|
// The error_name token may arrive bare via structuredError.code, not wrapped in
|
|
// quotes inside a JSON string. The token is unique to Cloudflare — safe to match bare.
|
|
assert.equal(isCloudflareFingerprintRejection("browser_signature_banned"), true);
|
|
assert.equal(isCloudflareFingerprintRejection('{"error_name":"browser_signature_banned"}'), true);
|
|
});
|
|
|
|
test("isCloudflareFingerprintRejection: Cloudflare-keyed 1010 forms are detected (round 3/4)", () => {
|
|
// The bare number 1010 is deliberately NOT a fingerprint signal (port/count/model id).
|
|
// Only explicit Cloudflare-keyed forms — error_code with = or :, the error-1010 URL path,
|
|
// the escaped-quote nested JSON form, browser_signature_banned, or the normalized type —
|
|
// qualify.
|
|
assert.equal(isCloudflareFingerprintRejection("error_code: 1010"), true, "colon code");
|
|
assert.equal(isCloudflareFingerprintRejection("error_code = 1010"), true, "eq code");
|
|
assert.equal(
|
|
isCloudflareFingerprintRejection('"error_code": "1010"'),
|
|
true,
|
|
"string-valued code"
|
|
);
|
|
assert.equal(
|
|
isCloudflareFingerprintRejection("https://.../cloudflare-1xxx-errors/error-1010/"),
|
|
true,
|
|
"error-1010 URL path"
|
|
);
|
|
// Escaped-quote form: when the upstream body is nested inside the gateway's
|
|
// error.message JSON string the quotes carry a backslash (\") — round 4 caught
|
|
// that this form was silently relying on the bare-number fallback.
|
|
assert.equal(
|
|
isCloudflareFingerprintRejection(
|
|
String.raw`{"error":{"message":"[403]: {\"error_code\":1010}"}}`
|
|
),
|
|
true,
|
|
"escaped-quote nested error_code"
|
|
);
|
|
assert.equal(isCloudflareFingerprintRejection("BROWSER_SIGNATURE_BANNED"), true, "case token");
|
|
assert.equal(isCloudflareFingerprintRejection("fingerprint_rejection"), true, "normalized type");
|
|
});
|
|
|
|
test("isCloudflareFingerprintRejection: a bare/unkeyed 1010 is NOT a fingerprint (round 4 FP guard)", () => {
|
|
// Round 4 finding: matching any standalone 1010 mistook ports/ids/model tokens for
|
|
// fingerprint rejections, skipping auth-level exhaustion for genuinely bad credentials.
|
|
assert.equal(isCloudflareFingerprintRejection("1010"), false, "bare numeric 1010");
|
|
assert.equal(isCloudflareFingerprintRejection("retry after 1010 seconds"), false, "count/port");
|
|
assert.equal(
|
|
isCloudflareFingerprintRejection("model foo-1010 is not supported"),
|
|
false,
|
|
"model id"
|
|
);
|
|
assert.equal(
|
|
isCloudflareFingerprintRejection("project 1010 has not been used"),
|
|
false,
|
|
"project id"
|
|
);
|
|
});
|
|
|
|
test("isCloudflareFingerprintRejection: larger numeric/the wrong key are NOT 1010 (boundary)", () => {
|
|
assert.equal(isCloudflareFingerprintRejection("error_code:10101"), false);
|
|
assert.equal(isCloudflareFingerprintRejection("HTTP 1019"), false);
|
|
assert.equal(isCloudflareFingerprintRejection("limit 101 tokens"), false);
|
|
});
|
|
|
|
test("isCloudflareFingerprintRejection: error-10101 is NOT 1010 (URL-path boundary, round 6)", () => {
|
|
// Round 6 finding: the second regex alternative (error-1010 / error_1010 URL-path form)
|
|
// lacked the (?!\d) suffix guard the error_code branch has, so a 4-digit code like 10101
|
|
// matched as 1010. The genuine 1010 path forms still match.
|
|
assert.equal(isCloudflareFingerprintRejection("error-10101"), false);
|
|
assert.equal(isCloudflareFingerprintRejection("/error_10109/"), false);
|
|
assert.equal(isCloudflareFingerprintRejection("error-1010"), true, "hyphen path 1010");
|
|
assert.equal(
|
|
isCloudflareFingerprintRejection("error-1010/"),
|
|
true,
|
|
"hyphen path 1010 with slash"
|
|
);
|
|
});
|
|
|
|
test("isCloudflareFingerprintRejection: 1010 must not absorb an alphanumeric suffix (round 7)", () => {
|
|
// Round 7 finding: (?!\d) only refused a following DIGIT, so a letter or underscore
|
|
// suffix (errorcode1010x / error_code:1010x) sailed through as 1010. (?!\w) refuses any
|
|
// word character. The real Cloudflare body ("error_code":1010,"error_name":...) ends the
|
|
// code on a non-word boundary and still matches.
|
|
assert.equal(isCloudflareFingerprintRejection("errorcode1010x"), false, "letter suffix");
|
|
assert.equal(
|
|
isCloudflareFingerprintRejection("error_code:1010x"),
|
|
false,
|
|
"letter suffix colon form"
|
|
);
|
|
assert.equal(isCloudflareFingerprintRejection("error-1010_tail"), false, "underscore suffix");
|
|
assert.equal(
|
|
isCloudflareFingerprintRejection('{"error_code":1010,"error_name":"browser_signature_banned"}'),
|
|
true,
|
|
"real Cloudflare body"
|
|
);
|
|
});
|
|
|
|
test("isCloudflareFingerprintRejection: error-1010 with a real-world prefix still matches (gemini round)", () => {
|
|
// Review finding (gemini backend): the URL-path alternative required error-1010 to be at
|
|
// the string start or after a literal "/", so the real upstream phrasing "[403] error-1010"
|
|
// or "Cloudflare error-1010: Access denied" leaked through as FORBIDDEN. A word-boundary
|
|
// lookbehind (same as the error_code branch) admits any non-word prefix while still
|
|
// rejecting my_error-1010 / xerror-1010.
|
|
assert.equal(isCloudflareFingerprintRejection("[403] error-1010"), true, "bracket prefix");
|
|
assert.equal(
|
|
isCloudflareFingerprintRejection("Cloudflare error-1010: Access denied"),
|
|
true,
|
|
"space prefix"
|
|
);
|
|
assert.equal(isCloudflareFingerprintRejection("(error-1010)"), true, "paren prefix");
|
|
assert.equal(
|
|
isCloudflareFingerprintRejection("my_error-1010"),
|
|
false,
|
|
"underscore prefix still FP-guarded"
|
|
);
|
|
assert.equal(
|
|
isCloudflareFingerprintRejection("xerror-1010"),
|
|
false,
|
|
"letter prefix still FP-guarded"
|
|
);
|
|
});
|
|
|
|
test("isCloudflareFingerprintRejection: no word-boundary false positives (round 5)", () => {
|
|
// error_code without a preceding word boundary matched my_error_code/twitter_error_code.
|
|
assert.equal(isCloudflareFingerprintRejection("my_error_code: 1010"), false);
|
|
assert.equal(isCloudflareFingerprintRejection("twitter_error_code 1010"), false);
|
|
// The bare phrase "error 1010" without the error_code key or URL path is too broad.
|
|
assert.equal(isCloudflareFingerprintRejection("error 1010 something else"), false);
|
|
});
|
|
|
|
test("isCloudflareFingerprintRejection: space-separated and URL-path forms match (round 5)", () => {
|
|
assert.equal(isCloudflareFingerprintRejection("error code: 1010"), true, "space separator");
|
|
assert.equal(isCloudflareFingerprintRejection("error-code = 1010"), true, "hyphen key");
|
|
assert.equal(
|
|
isCloudflareFingerprintRejection("https://.../cloudflare-1xxx-errors/error-1010/"),
|
|
true,
|
|
"URL path"
|
|
);
|
|
});
|
|
|
|
test("classifyProviderError: 422 + gcp_project_required => GCP_PROJECT_REQUIRED (BYOP fast-fail)", () => {
|
|
const body = JSON.stringify({
|
|
error: {
|
|
message:
|
|
"GCP_PROJECT_REQUIRED: Google Antigravity now requires a free GCP Project ID. " +
|
|
"Create one at console.cloud.google.com and enter it in Providers → Antigravity.",
|
|
type: "gcp_project_required",
|
|
code: "gcp_project_required",
|
|
},
|
|
});
|
|
assert.equal(
|
|
classifyProviderError(422, body, "antigravity"),
|
|
PROVIDER_ERROR_TYPES.GCP_PROJECT_REQUIRED
|
|
);
|
|
});
|
|
|
|
test("classifyProviderError: 422 without the BYOP code stays unclassified (no model lockout)", () => {
|
|
// The sibling missing-project error (code missing_project_id) and any other
|
|
// 422 must NOT map to GCP_PROJECT_REQUIRED — and never to MODEL_NOT_FOUND,
|
|
// so chatCore keeps its fail-closed behavior without locking the model.
|
|
assert.equal(
|
|
classifyProviderError(
|
|
422,
|
|
JSON.stringify({
|
|
error: { code: "missing_project_id", message: "Missing Google projectId" },
|
|
}),
|
|
"antigravity"
|
|
),
|
|
null
|
|
);
|
|
assert.equal(classifyProviderError(422, "some other body", "antigravity"), null);
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
// Cloudflare managed-challenge interstitial (Codex /responses/input_tokens)
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
// Trimmed but verbatim-shaped excerpt of the interstitial served by Cloudflare on
|
|
// POST chatgpt.com/backend-api/codex/responses/input_tokens (response headers carry
|
|
// `cf-mitigated: challenge`, `server: cloudflare`, `content-type: text/html`).
|
|
const CF_MANAGED_CHALLENGE_BODY = [
|
|
'<!DOCTYPE html><html lang="en-US"><head><title>Just a moment...</title></head><body>',
|
|
'<div class="main-content"><noscript><div class="h2">',
|
|
'<span id="challenge-error-text">Enable JavaScript and cookies to continue</span>',
|
|
"</div></noscript></div>",
|
|
"<script>(function(){window._cf_chl_opt = {cFPWv: 'g',cRay: 'a38b1a06cd3ea3e3',",
|
|
"cType: 'managed',cZone: 'chatgpt.com',cUPMDTk:\"/backend-api/codex/responses/input_tokens\"};",
|
|
"var a = document.createElement('script');",
|
|
"a.src = '/cdn-cgi/challenge-platform/h/g/orchestrate/chl_page/v1?ray=a38b1a06cd3ea3e3';",
|
|
"})();</script></body></html>",
|
|
].join("");
|
|
|
|
test("classifyProviderError: Cloudflare managed challenge on codex => FINGERPRINT_REJECTION, not FORBIDDEN", () => {
|
|
// Regression guard: this body previously fell through the whole 403 ladder to
|
|
// FORBIDDEN, which chatCore persists as the terminal banned/isActive:false state.
|
|
// The account was healthy — its OAuth token refreshed successfully in the same
|
|
// second and normal /responses traffic succeeded seconds before and after.
|
|
const result = classifyProviderError(403, CF_MANAGED_CHALLENGE_BODY, "codex");
|
|
assert.equal(
|
|
result,
|
|
PROVIDER_ERROR_TYPES.FINGERPRINT_REJECTION,
|
|
"a Cloudflare managed challenge must never terminalize the connection"
|
|
);
|
|
assert.notEqual(result, PROVIDER_ERROR_TYPES.FORBIDDEN, "must not fall through to FORBIDDEN");
|
|
});
|
|
|
|
test("classifyProviderError: managed challenge nested in the gateway error.message => FINGERPRINT_REJECTION", () => {
|
|
// The executor commonly wraps the upstream body inside error.message, which is
|
|
// how the operator-visible "[403]: <html>" message is produced.
|
|
const body = JSON.stringify({
|
|
error: { message: `[codex/gpt-5.6-sol] [403]: ${CF_MANAGED_CHALLENGE_BODY}` },
|
|
});
|
|
assert.equal(
|
|
classifyProviderError(403, body, "codex"),
|
|
PROVIDER_ERROR_TYPES.FINGERPRINT_REJECTION
|
|
);
|
|
});
|
|
|
|
test("isCloudflareChallengeInterstitial: each distinctive marker is recognized", () => {
|
|
assert.equal(isCloudflareChallengeInterstitial(CF_MANAGED_CHALLENGE_BODY), true, "full body");
|
|
assert.equal(
|
|
isCloudflareChallengeInterstitial("window._cf_chl_opt = {cType: 'managed'}"),
|
|
true,
|
|
"_cf_chl_opt"
|
|
);
|
|
assert.equal(
|
|
isCloudflareChallengeInterstitial("/cdn-cgi/challenge-platform/h/g/orchestrate/chl_page/v1"),
|
|
true,
|
|
"challenge-platform path"
|
|
);
|
|
assert.equal(
|
|
isCloudflareChallengeInterstitial('<span id="challenge-error-text">'),
|
|
true,
|
|
"challenge-error-text span"
|
|
);
|
|
assert.equal(
|
|
isCloudflareChallengeInterstitial(String.raw`<span id=\"challenge-error-text\">`),
|
|
true,
|
|
"escaped-quote nested form"
|
|
);
|
|
});
|
|
|
|
test("isCloudflareChallengeInterstitial: prose mentioning a challenge is NOT a match (FP guard)", () => {
|
|
// The markers are full Cloudflare-internal strings, never the loose word
|
|
// "challenge" — provider bodies legitimately discuss challenges in prose.
|
|
assert.equal(
|
|
isCloudflareChallengeInterstitial("this request failed a security challenge, please retry"),
|
|
false,
|
|
"prose challenge"
|
|
);
|
|
assert.equal(
|
|
isCloudflareChallengeInterstitial(
|
|
'{"error":"challenge_required","detail":"solve a challenge"}'
|
|
),
|
|
false,
|
|
"challenge_required code"
|
|
);
|
|
assert.equal(
|
|
isCloudflareChallengeInterstitial("challenge-platform"),
|
|
false,
|
|
"bare, no cdn-cgi path"
|
|
);
|
|
assert.equal(isCloudflareChallengeInterstitial(""), false, "empty body");
|
|
});
|
|
|
|
test("classifyProviderError: the terminal 403 paths are unchanged by the challenge branch", () => {
|
|
// Regression guard for the neighbouring carve-outs: a genuine permission 403
|
|
// still bans, and ChatGPT Web's Sentinel/Turnstile 403 (#8813) stays FORBIDDEN.
|
|
assert.equal(
|
|
classifyProviderError(403, { error: { message: "you do not have permission" } }, "codex"),
|
|
PROVIDER_ERROR_TYPES.FORBIDDEN
|
|
);
|
|
assert.equal(
|
|
classifyProviderError(403, JSON.stringify({ error: "SENTINEL_BLOCKED" }), "chatgpt-web"),
|
|
PROVIDER_ERROR_TYPES.FORBIDDEN
|
|
);
|
|
assert.equal(
|
|
classifyProviderError(403, "Turnstile required", "chatgpt-web"),
|
|
PROVIDER_ERROR_TYPES.FORBIDDEN
|
|
);
|
|
});
|
|
|
|
// ── Anthropic OAuth 403 "Request not allowed" is a per-request refusal, not a ban ──
|
|
|
|
test("classifyProviderError: claude 403 'Request not allowed' (Anthropic body) => REQUEST_REJECTED, never FORBIDDEN", () => {
|
|
// Verbatim Anthropic shape. On the reporting install this landed once between
|
|
// hundreds of 200s on the same OAuth token and permanently banned the only
|
|
// Claude connection.
|
|
const body = JSON.stringify({
|
|
type: "error",
|
|
error: { type: "permission_error", message: "Request not allowed" },
|
|
});
|
|
const result = classifyProviderError(403, body, "claude");
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.REQUEST_REJECTED);
|
|
assert.notEqual(result, PROVIDER_ERROR_TYPES.FORBIDDEN, "must not ban the connection");
|
|
});
|
|
|
|
test("classifyProviderError: claude 403 'Request not allowed' via gateway-wrapped message => REQUEST_REJECTED", () => {
|
|
// Shape as it reaches the classifier after the executor flattens the body.
|
|
const result = classifyProviderError(403, "[403]: Request not allowed", "claude");
|
|
assert.equal(result, PROVIDER_ERROR_TYPES.REQUEST_REJECTED);
|
|
});
|
|
|
|
test("classifyProviderError: 'Request not allowed' from a non-Anthropic OAuth provider keeps its 403 semantics", () => {
|
|
const body = JSON.stringify({ error: { message: "Request not allowed" } });
|
|
assert.equal(classifyProviderError(403, body, "codex"), PROVIDER_ERROR_TYPES.FORBIDDEN);
|
|
assert.equal(classifyProviderError(403, body, undefined), PROVIDER_ERROR_TYPES.FORBIDDEN);
|
|
});
|
|
|
|
test("classifyProviderError: other claude 403 bodies still classify as before", () => {
|
|
assert.equal(
|
|
classifyProviderError(403, { error: { message: "you do not have permission" } }, "claude"),
|
|
PROVIDER_ERROR_TYPES.FORBIDDEN
|
|
);
|
|
assert.equal(
|
|
classifyProviderError(
|
|
403,
|
|
JSON.stringify({ error: { message: "account_deactivated: this account has been disabled" } }),
|
|
"claude"
|
|
),
|
|
PROVIDER_ERROR_TYPES.ACCOUNT_DEACTIVATED
|
|
);
|
|
});
|
|
|
|
test("isAnthropicRequestNotAllowed / isAnthropicOAuthProvider helpers", () => {
|
|
assert.equal(isAnthropicRequestNotAllowed("Request not allowed"), true);
|
|
assert.equal(isAnthropicRequestNotAllowed('{"message":"request NOT allowed"}'), true);
|
|
assert.equal(isAnthropicRequestNotAllowed("requests not allowed here"), false);
|
|
assert.equal(isAnthropicRequestNotAllowed(""), false);
|
|
assert.equal(isAnthropicOAuthProvider("claude"), true);
|
|
assert.equal(isAnthropicOAuthProvider("Claude"), true);
|
|
assert.equal(isAnthropicOAuthProvider("anthropic"), false);
|
|
assert.equal(isAnthropicOAuthProvider(null), false);
|
|
});
|
|
|
|
test("#17043: Claude native weekly 429 is quota exhaustion, not an RPM throttle", () => {
|
|
const payload = {
|
|
error: { message: "This request would exceed your account's rate limit" },
|
|
};
|
|
assert.equal(
|
|
classifyProviderError(429, payload, "claude"),
|
|
PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED
|
|
);
|
|
assert.equal(
|
|
classifyProviderError(429, payload, "openai"),
|
|
PROVIDER_ERROR_TYPES.RATE_LIMITED,
|
|
"do not broaden the Claude-specific long-window signal to API-key providers"
|
|
);
|
|
assert.equal(
|
|
classifyProviderError(429, { error: { message: "Too many requests per minute" } }, "claude"),
|
|
PROVIDER_ERROR_TYPES.RATE_LIMITED
|
|
);
|
|
});
|