ChannelMessageUnknownSendReconciliationResult,

} from "../../channels/message/types.js";

import type { OpenClawConfig } from "../../config/types.openclaw.js";

import {

claimRecoveryEntry as claimSharedRecoveryEntry,

computeBackoffMs,

getErrnoCode,

releaseRecoveryEntry as releaseSharedRecoveryEntry,

} from "../delivery-recovery.shared.js";

import { formatErrorMessage } from "../errors.js";

import { resolveOutboundChannelMessageAdapter } from "./channel-resolution.js";

import type { OutboundDeliveryResult } from "./deliver-types.js";

type QueuedDeliveryPayload,

} from "./delivery-queue-storage.js";

export { computeBackoffMs };

export type RecoverySummary = {

recovered: number;

failed: number;

const MAX_RETRIES = 5;

/** Backoff delays in milliseconds indexed by retry count (1-based). */

const BACKOFF_MS: readonly number[] = [

5_000, // retry 1: 5s

25_000, // retry 2: 25s

120_000, // retry 3: 2m

600_000, // retry 4: 10m

];

const PERMANENT_ERROR_PATTERNS: readonly RegExp[] = [

/no conversation reference found/i,

/chat not found/i,

return resolveExpiresAtMsFromDurationMs(durationMs) ?? resolveDateTimestampMs(Date.now());

}

function getErrnoCode(err: unknown): string | null {

return err && typeof err === "object" && "code" in err

? String((err as { code?: unknown }).code)

: null;

}

function createEmptyRecoverySummary(): RecoverySummary {

return {

recovered: 0,

};

}

function claimRecoveryEntry(entryId: string): boolean {

if (entriesInProgress.has(entryId)) {

return false;

}

entriesInProgress.add(entryId);

return true;

}

function releaseRecoveryEntry(entryId: string): void {

entriesInProgress.delete(entryId);

}

export async function withActiveDeliveryClaim<T>(

entryId: string,

fn: () => Promise<T>,

): Promise<ActiveDeliveryClaimResult<T>> {

if (!claimRecoveryEntry(entryId)) {

if (!claimSharedRecoveryEntry(entriesInProgress, entryId)) {

return { status: "claimed-by-other-owner" };

}

try {

return { status: "claimed", value: await fn() };

} finally {

releaseRecoveryEntry(entryId);

releaseSharedRecoveryEntry(entriesInProgress, entryId);

}

}

}

}

/** Compute the backoff delay in ms for a given retry count. */

export function computeBackoffMs(retryCount: number): number {

if (retryCount <= 0) {

return 0;

}

return BACKOFF_MS[Math.min(retryCount - 1, BACKOFF_MS.length - 1)] ?? BACKOFF_MS.at(-1) ?? 0;

}

export function isEntryEligibleForRecoveryRetry(

entry: QueuedDelivery,

now: number,

);

for (const entry of matchingEntries) {

if (!claimRecoveryEntry(entry.id)) {

if (!claimSharedRecoveryEntry(entriesInProgress, entry.id)) {

opts.log.info(`${opts.logLabel}: entry ${entry.id} is already being recovered`);

continue;

}

);

}

} finally {

releaseRecoveryEntry(entry.id);

releaseSharedRecoveryEntry(entriesInProgress, entry.id);

}

}

} finally {

break;

}

if (!claimRecoveryEntry(entry.id)) {

if (!claimSharedRecoveryEntry(entriesInProgress, entry.id)) {

opts.log.info(`Recovery skipped for delivery ${entry.id}: already being processed`);

continue;

}

continue;

}

} finally {

releaseRecoveryEntry(entry.id);

releaseSharedRecoveryEntry(entriesInProgress, entry.id);

}

}