/** Dispatches isolated cron output to direct delivery, mirrors, and follow-up queues. */

import { isAudioFileName } from "@openclaw/media-core/mime";

import { normalizeOptionalString } from "@openclaw/normalization-core/string-coerce";

import { retireSessionMcpRuntime } from "../../agents/agent-bundle-mcp-tools.js";

import type { ReplyPayload } from "../../auto-reply/reply-payload.js";

import {

isSilentReplyText,

import { hasReplyPayloadContent } from "../../interactive/payload.js";

import { stringifyRouteThreadId } from "../../plugin-sdk/channel-route.js";

import {

isCronSessionKey,

parseThreadSessionSuffix,

resolveAgentIdFromSessionKey,

} from "../../routing/session-key.js";

import type { DeliveryTargetResolution } from "./delivery-target.js";

import { pickLastNonEmptyTextFromPayloads, pickSummaryFromOutput } from "./helpers.js";

import type { RunCronAgentTurnResult } from "./run.types.js";

import { cleanupCronRunSessionAfterRun } from "./session-cleanup.js";

import { expectsSubagentFollowup, isLikelyInterimCronMessage } from "./subagent-followup-hints.js";

function normalizeDeliveryTarget(channel: string, to: string): string {

result?: RunCronAgentTurnResult;

delivered: boolean;

deliveryAttempted: boolean;

cronRunSessionCleanupAttempted: boolean;

summary?: string;

outputText?: string;

synthesizedText?: string;

results: OutboundDeliveryResult[];

};

const gatewayCallRuntimeLoader = createLazyImportLoader(

() => import("../../gateway/call.runtime.js"),

);

const deliveryOutboundRuntimeLoader = createLazyImportLoader(

() => import("./delivery-outbound.runtime.js"),

);

const COMPLETED_DIRECT_CRON_DELIVERIES = new Map<string, CompletedDirectCronDelivery>();

async function loadGatewayCallRuntime(): Promise<typeof import("../../gateway/call.runtime.js")> {

return await gatewayCallRuntimeLoader.load();

}

async function loadDeliveryOutboundRuntime(): Promise<

typeof import("./delivery-outbound.runtime.js")

> {

sessionId: string;

retireReason: string;

}): Promise<void> {

if (!params.job.deleteAfterRun) {

return;

}

if (!isCronSessionKey(params.agentSessionKey)) {

return;

}

try {

const { callGateway } = await loadGatewayCallRuntime();

await callGateway({

method: "sessions.delete",

params: {

key: params.agentSessionKey,

deleteTranscript: true,

emitLifecycleHooks: false,

},

timeoutMs: 10_000,

});

} catch {

await retireSessionMcpRuntime({

sessionId: params.sessionId,

reason: params.retireReason,

});

}

await cleanupCronRunSessionAfterRun({

job: params.job,

agentSessionKey: params.agentSessionKey,

sessionId: params.sessionId,

reason: params.retireReason,

});

}

function logCronDeliveryErrorDeferred(message: string): void {

let delivered = verifiedMessageToolDelivery;

let deliveryAttempted = verifiedMessageToolDelivery;

let directCronSessionDeleted = false;

let directCronSessionCleanupAttempted = false;

const buildDeliveryState = (result?: RunCronAgentTurnResult): DispatchCronDeliveryState => ({

...(result ? { result } : {}),

delivered,

deliveryAttempted,

cronRunSessionCleanupAttempted: directCronSessionCleanupAttempted,

summary,

outputText,

synthesizedText,

deliveryPayloads,

});

const formatDeliveryTargetError = (error: string) =>

params.sourceDeliveryOutcome.unverifiedMessageToolDelivery

? `${error}; the agent used the message tool, but OpenClaw could not verify that message matched the cron delivery target`

...params.telemetry,

});

const cleanupDirectCronSessionIfNeeded = async (): Promise<void> => {

if (directCronSessionDeleted) {

if (directCronSessionCleanupAttempted) {

return;

}

directCronSessionDeleted = true;

await cleanupDirectCronSession({

const cleanupAttempted = await cleanupCronRunSessionAfterRun({

job: params.job,

agentSessionKey: params.agentSessionKey,

sessionId: params.sessionId,

retireReason: "cron-delete-after-run-fallback",

reason: "cron-delete-after-run-fallback",

});

if (cleanupAttempted) {

directCronSessionCleanupAttempted = true;

}

};

const finishSilentReplyDelivery = async (): Promise<RunCronAgentTurnResult> => {

deliveryAttempted = true;

// non-deleteAfterRun / non-cron sessions (see cleanupDirectCronSession).

await cleanupDirectCronSessionIfNeeded();

if (!params.deliveryBestEffort) {

return {

result: failDeliveryTarget(params.resolvedDelivery.error.message),

delivered,

deliveryAttempted,

summary,

outputText,

synthesizedText,

deliveryPayloads,

};

return buildDeliveryState(failDeliveryTarget(params.resolvedDelivery.error.message));

}

await logCronDeliveryWarn(`[cron:${params.job.id}] ${params.resolvedDelivery.error.message}`);

return {

result: params.withRunSession({

return buildDeliveryState(

params.withRunSession({

status: "ok",

summary,

outputText,

deliveryAttempted,

...params.telemetry,

}),

delivered,

deliveryAttempted,

summary,

outputText,

synthesizedText,

deliveryPayloads,

};

);

}

// Finalize descendant/subagent output first for text-only cron runs, then

if (useDirectDelivery) {

const directResult = await deliverViaDirectAndCleanup(params.resolvedDelivery);

if (directResult) {

return {

result: directResult,

delivered,

deliveryAttempted,

summary,

outputText,

synthesizedText,

deliveryPayloads,

};

return buildDeliveryState(directResult);

}

} else {

const finalizedTextResult = await finalizeTextDelivery(params.resolvedDelivery);

if (finalizedTextResult) {

return {

result: finalizedTextResult,

delivered,

deliveryAttempted,

summary,

outputText,

synthesizedText,

deliveryPayloads,

};

return buildDeliveryState(finalizedTextResult);

}

}

}

return {

delivered,

deliveryAttempted,

summary,

outputText,

synthesizedText,

deliveryPayloads,

};

return buildDeliveryState();

}