vi.useRealTimers();

});

it("retries Telegram 421 responses after forcing transport fallback", async () => {

const forceFallback = vi.fn(() => true);

const fetchSpy = vi

.fn()

.mockResolvedValueOnce(new Response("Misdirected Request", { status: 421 }))

.mockResolvedValueOnce(new Response("{}", { status: 200 }));

const { clientFetch } = createWrappedTelegramClientFetchWithTransport({

fetch: fetchSpy as typeof fetch,

forceFallback,

});

const result = await clientFetch("https://api.telegram.org/bot123456:ABC/sendMessage");

expect(result).toBeInstanceOf(Response);

expect((result as Response).status).toBe(200);

expect(forceFallback).toHaveBeenCalledWith("misdirected-request");

expect(fetchSpy).toHaveBeenCalledTimes(2);

});

it("retries Telegram 421 fetch errors after forcing transport fallback", async () => {

const forceFallback = vi.fn(() => true);

const fetchSpy = vi

.fn()

.mockRejectedValueOnce(Object.assign(new Error("421 Misdirected Request"), { status: 421 }))

.mockResolvedValueOnce(new Response("{}", { status: 200 }));

const { clientFetch } = createWrappedTelegramClientFetchWithTransport({

fetch: fetchSpy as typeof fetch,

forceFallback,

});

const result = await clientFetch("https://api.telegram.org/bot123456:ABC/sendMessage");

expect(result).toBeInstanceOf(Response);

expect((result as Response).status).toBe(200);

expect(forceFallback).toHaveBeenCalledWith("misdirected-request");

expect(fetchSpy).toHaveBeenCalledTimes(2);

});

it("preserves the original fetch error when tagging cannot attach metadata", async () => {

const frozenError = Object.freeze(

Object.assign(new TypeError("fetch failed"), {

import type { ApiClientOptions } from "grammy";

import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";

import type { TelegramTransport } from "./fetch.js";

import { tagTelegramNetworkError } from "./network-errors.js";

import { isTelegramMisdirectedRequestError, tagTelegramNetworkError } from "./network-errors.js";

import { resolveTelegramRequestTimeoutMs } from "./request-timeouts.js";

type TelegramFetchInput = Parameters<NonNullable<ApiClientOptions["fetch"]>>[0];

: undefined;

const requestSignal = isTelegramAbortSignalLike(init?.signal) ? init.signal : undefined;

const canForceTransportFallback = (reason: string) =>

!shutdownSignal?.aborted &&

!requestSignal?.aborted &&

params.transport?.forceFallback?.(reason) === true;

const runFetch = async () => {

const controller = new AbortController();

const abortWith = (signal: Pick<TelegramAbortSignalLike, "reason">) =>

};

try {

return await runFetch();

const response = await runFetch();

if (response.status === 421 && canForceTransportFallback("misdirected-request")) {

return await runFetch();

}

return response;

} catch (err) {

if (

requestTimeoutMs &&

shouldRetryTimedOutTelegramControlRequest(method) &&

!shutdownSignal?.aborted &&

!requestSignal?.aborted &&

params.transport?.forceFallback?.("request-timeout")

canForceTransportFallback("request-timeout")

) {

return await runFetch();

}

if (

isTelegramMisdirectedRequestError(err) &&

canForceTransportFallback("misdirected-request")

) {

return await runFetch();

}

);

expect(isSafeToRetrySendError(wrapped)).toBe(false);

});

it.each([

["status", Object.assign(new Error("Misdirected Request"), { status: 421 })],

["statusCode", Object.assign(new Error("Misdirected Request"), { statusCode: "421" })],

["error_code", errorWithTelegramCode("Misdirected Request", 421)],

["message", new Error("421 Misdirected Request")],

[

"nested cause",

Object.assign(new Error("Network request for 'sendMessage' failed!"), {

cause: Object.assign(new Error("Misdirected Request"), { status: 421 }),

}),

],

[

"grammY HttpError",

new MockHttpError(

"Network request for 'sendMessage' failed!",

Object.assign(new Error("Misdirected Request"), { status: 421 }),

),

],

])("treats Telegram 421 Misdirected Request as safe to retry via %s", (_name, err) => {

expect(isSafeToRetrySendError(err)).toBe(true);

});

it("does not parse malformed status strings as Telegram 421", () => {

expect(

isSafeToRetrySendError(

Object.assign(new Error("Misdirected Request"), { statusCode: "421abc" }),

),

).toBe(false);

});

});

describe("isTelegramServerError", () => {

return undefined;

}

function getNumericHttpStatus(err: unknown): number | undefined {

if (!err || typeof err !== "object") {

return undefined;

}

const candidate = err as { error_code?: unknown; status?: unknown; statusCode?: unknown };

for (const value of [candidate.error_code, candidate.status, candidate.statusCode]) {

if (typeof value === "number" && Number.isFinite(value)) {

return value;

}

if (typeof value === "string") {

const trimmed = value.trim();

if (/^\d+$/.test(trimmed)) {

return Number.parseInt(trimmed, 10);

}

}

}

return undefined;

}

export function isTelegramMisdirectedRequestError(err: unknown): boolean {

for (const candidate of collectTelegramErrorCandidates(err)) {

const code = normalizeCode(getErrorCode(candidate));

if (code === "421" || getNumericHttpStatus(candidate) === 421) {

return true;

}

const message = normalizeLowercaseStringOrEmpty(formatErrorMessage(candidate));

if (/\b421\b/.test(message) && message.includes("misdirected request")) {

return true;

}

}

return false;

}

export type TelegramNetworkErrorContext = "polling" | "send" | "webhook" | "unknown";

export type TelegramNetworkErrorOrigin = {

method?: string | null;

if (!err) {

return false;

}

if (isTelegramMisdirectedRequestError(err)) {

return true;

}

for (const candidate of collectTelegramErrorCandidates(err)) {

const code = normalizeCode(getErrorCode(candidate));

if (code && PRE_CONNECT_ERROR_CODES.has(code)) {

});

});

describe("default retry behavior", () => {

it("retries misdirected request errors from Telegram edge nodes", async () => {

await runRetryCase({

runnerOptions: { retry: ZERO_DELAY_RETRY },

fnSteps: [

{

type: "reject" as const,

value: Object.assign(new Error("421 Misdirected Request"), {

status: 421,

}),

},

],

expectedCalls: 3,

expectedError: "421 Misdirected Request",

});

});

});

it("honors nested retry_after hints before retrying", async () => {

vi.useFakeTimers();

jitter: 0.1,

};

const CHANNEL_API_RETRY_RE = /429|timeout|connect|reset|closed|unavailable|temporarily/i;

const CHANNEL_API_RETRY_RE =

/429|421|timeout|connect|reset|closed|unavailable|temporarily|misdirected request/i;

const log = createSubsystemLogger("retry-policy");

function resolveChannelApiShouldRetry(params: {