fengming 0.3.3 → 0.3.5

package/dist/deliver-BkuuFBlm.js

@@ -0,0 +1,1399 @@
+import { i as formatErrorMessage } from "./errors-5ePGD43N.js";
+import { i as emitInternalDiagnosticEvent } from "./diagnostic-events-Bwqd0ZOT.js";
+import { t as createSubsystemLogger } from "./subsystem-46gngkCY.js";
+import { _ as runOutboundDeliveryCommitHooks, c as enqueueDelivery, g as attachOutboundDeliveryCommitHook, m as markDeliveryPlatformSendAttemptStarted, o as withActiveDeliveryClaim, p as markDeliveryPlatformOutcomeUnknown, s as ackDelivery, u as failDelivery } from "./delivery-queue-BqgHvNlY.js";
+import { t as getGlobalHookRunner, u as fireAndForgetHook } from "./hook-runner-global-lWQvOg8l.js";
+import { m as triggerInternalHook, n as createInternalHookEvent } from "./internal-hooks-BwDOyy7b.js";
+import { o as resolveMirroredTranscriptText } from "./transcript-B07Cf07z.js";
+import { a as toInternalMessageSentContext, d as toPluginMessageSentEvent, l as toPluginMessageContext, t as buildCanonicalSentMessageHookContext } from "./message-hook-mappers-Lw-1gD5K.js";
+import { C as createReplyToDeliveryPolicy } from "./reply-payload-swpu2tGD.js";
+import { a as hasReplyPayloadContent, f as renderMessagePresentationFallbackText, l as normalizeMessagePresentation } from "./payload-Cpx3heIy.js";
+import { t as diagnosticErrorCategory } from "./diagnostic-error-metadata-CJCFvsh5.js";
+import { c as resolveTextChunkLimit, i as chunkMarkdownTextWithMode, n as chunkByParagraph, s as resolveChunkMode } from "./chunk-1-pn-Qn8.js";
+import { n as adaptMessagePresentationForChannel } from "./interactive-BqFjV7hl.js";
+import { t as loadChannelOutboundAdapter } from "./load-D5fLrTyR.js";
+import { t as resolveAgentScopedOutboundMediaAccess } from "./read-capability-NsuJUjCO.js";
+import { n as resolveOutboundChannelMessageAdapter } from "./channel-resolution-DOPyiG4k.js";
+import { l as summarizeOutboundPayloadForTransport, t as createOutboundPayloadPlan } from "./payloads-Dg9aAEOC.js";
+import { n as stripInternalRuntimeScaffolding } from "./sanitize-text-Doydq6Q4.js";
+//#region src/infra/outbound/deliver-types.ts
+var OutboundDeliveryError = class extends Error {
+	constructor(message, options) {
+		super(message, { cause: options.cause });
+		this.name = "OutboundDeliveryError";
+		this.results = [...options.results ?? []];
+		this.payloadOutcomes = [...options.payloadOutcomes ?? []];
+		this.sentBeforeError = this.results.length > 0;
+		this.stage = options.stage ?? "unknown";
+	}
+};
+function isOutboundDeliveryError(error) {
+	return error instanceof OutboundDeliveryError;
+}
+//#endregion
+//#region src/auto-reply/reply/reply-payload-sending-hook.ts
+async function runReplyPayloadSendingHook(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("reply_payload_sending")) return params.payload;
+	const result = await hookRunner.runReplyPayloadSending({
+		payload: params.payload,
+		kind: params.kind,
+		channel: params.channel,
+		sessionKey: params.sessionKey,
+		runId: params.runId
+	}, params.context);
+	if (result?.cancel) return null;
+	return result?.payload ?? params.payload;
+}
+//#endregion
+//#region src/channels/message/rendered-batch.ts
+function countMedia(payload) {
+	return (payload.mediaUrls?.filter(Boolean).length ?? 0) + (payload.mediaUrl ? 1 : 0);
+}
+function collectMediaUrls(payload) {
+	return [payload.mediaUrl, ...payload.mediaUrls ?? []].map((url) => url?.trim()).filter((url) => Boolean(url));
+}
+function createRenderedMessageBatchPlanItem(payload, index) {
+	const text = payload.text?.trim();
+	const mediaUrls = collectMediaUrls(payload);
+	const presentationBlockCount = payload.presentation?.blocks?.length ?? 0;
+	const kinds = [];
+	if (text) kinds.push("text");
+	if (mediaUrls.length > 0) kinds.push(payload.audioAsVoice ? "voice" : "media");
+	if (presentationBlockCount > 0) kinds.push("presentation");
+	if (payload.interactive) kinds.push("interactive");
+	if (payload.channelData) kinds.push("channelData");
+	return {
+		index,
+		kinds: kinds.length > 0 ? kinds : ["empty"],
+		...text ? { text } : {},
+		mediaUrls,
+		...payload.audioAsVoice && mediaUrls.length > 0 ? { audioAsVoice: true } : {},
+		...presentationBlockCount > 0 ? { presentationBlockCount } : {},
+		...payload.interactive ? { hasInteractive: true } : {},
+		...payload.channelData ? { hasChannelData: true } : {}
+	};
+}
+function createRenderedMessageBatchPlan(payloads) {
+	const items = payloads.map(createRenderedMessageBatchPlanItem);
+	return payloads.reduce((plan, payload) => {
+		const text = payload.text?.trim();
+		const mediaCount = countMedia(payload);
+		return {
+			payloadCount: plan.payloadCount + 1,
+			textCount: plan.textCount + (text ? 1 : 0),
+			mediaCount: plan.mediaCount + mediaCount,
+			voiceCount: plan.voiceCount + (payload.audioAsVoice && mediaCount > 0 ? 1 : 0),
+			presentationCount: plan.presentationCount + (payload.presentation?.blocks?.length ? 1 : 0),
+			interactiveCount: plan.interactiveCount + (payload.interactive ? 1 : 0),
+			channelDataCount: plan.channelDataCount + (payload.channelData ? 1 : 0),
+			items: plan.items
+		};
+	}, {
+		payloadCount: 0,
+		textCount: 0,
+		mediaCount: 0,
+		voiceCount: 0,
+		presentationCount: 0,
+		interactiveCount: 0,
+		channelDataCount: 0,
+		items
+	});
+}
+function createRenderedMessageBatch(payloads) {
+	return {
+		payloads,
+		plan: createRenderedMessageBatchPlan(payloads)
+	};
+}
+//#endregion
+//#region src/infra/outbound/abort.ts
+/**
+* Utility for checking AbortSignal state and throwing a standard AbortError.
+*/
+/**
+* Throws an AbortError if the given signal has been aborted.
+* Use at async checkpoints to support cancellation.
+*/
+function throwIfAborted(abortSignal) {
+	if (abortSignal?.aborted) {
+		const err = /* @__PURE__ */ new Error("操作已中止");
+		err.name = "AbortError";
+		throw err;
+	}
+}
+//#endregion
+//#region src/infra/outbound/message-plan.ts
+function withPlannedReplyTo(overrides, consumeReplyTo) {
+	return consumeReplyTo ? consumeReplyTo({ ...overrides }) : { ...overrides };
+}
+function withChunkedTextFormatting(overrides, formatting) {
+	return formatting ? {
+		...overrides,
+		formatting: {
+			...overrides.formatting,
+			...formatting
+		}
+	} : overrides;
+}
+function chunkTextForPlan(params) {
+	return params.formatting ? params.chunker(params.text, params.limit, { formatting: params.formatting }) : params.chunker(params.text, params.limit);
+}
+function planOutboundTextMessageUnits(params) {
+	const planTextUnit = (text) => ({
+		kind: "text",
+		text,
+		overrides: withPlannedReplyTo(params.overrides, params.consumeReplyTo)
+	});
+	const planChunkedTextUnit = (text) => {
+		const unit = planTextUnit(text);
+		return {
+			...unit,
+			overrides: withChunkedTextFormatting(unit.overrides, params.chunkedTextFormatting)
+		};
+	};
+	if (!params.chunker || params.textLimit === void 0) return [planTextUnit(params.text)];
+	if (params.chunkMode === "newline") {
+		const blockChunks = (params.chunkerMode ?? "text") === "markdown" ? chunkMarkdownTextWithMode(params.text, params.textLimit, "newline") : chunkByParagraph(params.text, params.textLimit);
+		if (!blockChunks.length && params.text) blockChunks.push(params.text);
+		const units = [];
+		for (const blockChunk of blockChunks) {
+			const chunks = chunkTextForPlan({
+				text: blockChunk,
+				limit: params.textLimit,
+				chunker: params.chunker,
+				formatting: params.formatting
+			});
+			if (!chunks.length && blockChunk) chunks.push(blockChunk);
+			for (const chunk of chunks) units.push(planChunkedTextUnit(chunk));
+		}
+		return units;
+	}
+	return chunkTextForPlan({
+		text: params.text,
+		limit: params.textLimit,
+		chunker: params.chunker,
+		formatting: params.formatting
+	}).map(planChunkedTextUnit);
+}
+function planOutboundMediaMessageUnits(params) {
+	return params.mediaUrls.map((mediaUrl, index) => ({
+		kind: "media",
+		mediaUrl,
+		...index === 0 ? { caption: params.caption } : {},
+		overrides: withPlannedReplyTo(params.overrides, params.consumeReplyTo)
+	}));
+}
+//#endregion
+//#region src/infra/outbound/deliver.ts
+const log = createSubsystemLogger("outbound/deliver");
+let transcriptRuntimePromise;
+async function loadTranscriptRuntime() {
+	transcriptRuntimePromise ??= import("./transcript.runtime.js");
+	return await transcriptRuntimePromise;
+}
+let channelBootstrapRuntimePromise;
+async function loadChannelBootstrapRuntime() {
+	channelBootstrapRuntimePromise ??= import("./channel-bootstrap.runtime.js");
+	return await channelBootstrapRuntimePromise;
+}
+async function resolveChannelOutboundDirectiveOptions(params) {
+	return { extractMarkdownImages: (await loadBootstrappedOutboundAdapter(params))?.extractMarkdownImages === true ? true : void 0 };
+}
+async function createChannelHandler(params) {
+	const outbound = await loadBootstrappedOutboundAdapter(params);
+	const message = resolveOutboundChannelMessageAdapter(params);
+	const handler = createPluginHandler({
+		...params,
+		outbound,
+		message
+	});
+	if (!handler) throw new Error(`Outbound not configured for channel: ${params.channel}`);
+	return handler;
+}
+async function loadBootstrappedOutboundAdapter(params) {
+	let outbound = await loadChannelOutboundAdapter(params.channel);
+	if (!outbound) {
+		const { bootstrapOutboundChannelPlugin } = await loadChannelBootstrapRuntime();
+		bootstrapOutboundChannelPlugin({
+			channel: params.channel,
+			cfg: params.cfg
+		});
+		outbound = await loadChannelOutboundAdapter(params.channel);
+	}
+	return outbound;
+}
+async function runChannelMessageSendWithLifecycle(params) {
+	if (!params.lifecycle) return { result: await params.send() };
+	let attemptToken;
+	try {
+		attemptToken = await params.lifecycle.beforeSendAttempt?.(params.ctx);
+		const result = await params.send();
+		const successCtx = {
+			...params.ctx,
+			result,
+			...attemptToken !== void 0 ? { attemptToken } : {}
+		};
+		try {
+			await params.lifecycle.afterSendSuccess?.(successCtx);
+		} catch (successHookError) {
+			log.warn(`channel message send success hook failed after platform send; preserving send result: ${formatErrorMessage(successHookError)}`);
+		}
+		return {
+			result,
+			...params.lifecycle.afterCommit ? { afterCommit: async () => {
+				await params.lifecycle?.afterCommit?.(successCtx);
+			} } : {}
+		};
+	} catch (error) {
+		try {
+			await params.lifecycle.afterSendFailure?.({
+				...params.ctx,
+				error,
+				...attemptToken !== void 0 ? { attemptToken } : {}
+			});
+		} catch (cleanupError) {
+			log.warn(`channel message send failure cleanup failed; preserving original send error: ${formatErrorMessage(cleanupError)}`);
+		}
+		throw error;
+	}
+}
+async function resolveOutboundDurableFinalDeliverySupport(params) {
+	const outbound = await loadBootstrappedOutboundAdapter(params);
+	const message = resolveOutboundChannelMessageAdapter(params);
+	if (!message?.send?.text && !outbound?.sendText) return {
+		ok: false,
+		reason: "missing_outbound_handler"
+	};
+	const messageDurableFinal = message?.durableFinal;
+	const durableFinal = messageDurableFinal?.capabilities ?? outbound?.deliveryCapabilities?.durableFinal;
+	for (const [capability, required] of Object.entries(params.requirements ?? {})) {
+		if (required === true && durableFinal?.[capability] !== true) return {
+			ok: false,
+			reason: "capability_mismatch",
+			capability
+		};
+		if (required === true && capability === "reconcileUnknownSend" && typeof messageDurableFinal?.reconcileUnknownSend !== "function") return {
+			ok: false,
+			reason: "capability_mismatch",
+			capability
+		};
+	}
+	return { ok: true };
+}
+function createPluginHandler(params) {
+	const outbound = params.outbound;
+	const messageText = params.message?.send?.text;
+	const messageMedia = params.message?.send?.media;
+	const messagePayload = params.message?.send?.payload;
+	const messageLifecycle = params.message?.send?.lifecycle;
+	if (!messageText && !outbound?.sendText) return null;
+	const baseCtx = createChannelOutboundContextBase(params);
+	const sendText = outbound?.sendText;
+	const sendMedia = outbound?.sendMedia;
+	const chunker = outbound?.chunker ?? null;
+	const chunkerMode = outbound?.chunkerMode;
+	const resolveCtx = (overrides) => ({
+		...baseCtx,
+		replyToId: overrides && "replyToId" in overrides ? overrides.replyToId : baseCtx.replyToId,
+		replyToIdSource: overrides && "replyToIdSource" in overrides ? overrides.replyToIdSource : baseCtx.replyToIdSource,
+		threadId: overrides && "threadId" in overrides ? overrides.threadId : baseCtx.threadId,
+		audioAsVoice: overrides?.audioAsVoice,
+		formatting: overrides && "formatting" in overrides ? {
+			...baseCtx.formatting,
+			...overrides.formatting
+		} : baseCtx.formatting
+	});
+	const buildTargetRef = (overrides) => ({
+		channel: params.channel,
+		to: params.to,
+		accountId: params.accountId ?? void 0,
+		threadId: overrides?.threadId ?? baseCtx.threadId
+	});
+	return {
+		chunker,
+		chunkerMode,
+		chunkedTextFormatting: outbound?.chunkedTextFormatting,
+		textChunkLimit: outbound?.textChunkLimit,
+		supportsMedia: Boolean(messageMedia ?? sendMedia),
+		sanitizeText: outbound?.sanitizeText ? (payload) => outbound.sanitizeText({
+			text: payload.text ?? "",
+			payload
+		}) : void 0,
+		normalizePayload: outbound?.normalizePayload ? (payload) => outbound.normalizePayload({
+			payload,
+			cfg: params.cfg,
+			accountId: params.accountId
+		}) : void 0,
+		sendTextOnlyErrorPayloads: outbound?.sendTextOnlyErrorPayloads === true,
+		presentationCapabilities: outbound?.presentationCapabilities,
+		renderPresentation: outbound?.renderPresentation ? async (payload) => {
+			const presentation = normalizeMessagePresentation(payload.presentation);
+			if (!presentation) return payload;
+			const ctx = {
+				...resolveCtx({
+					replyToId: payload.replyToId ?? baseCtx.replyToId,
+					threadId: baseCtx.threadId,
+					audioAsVoice: payload.audioAsVoice
+				}),
+				text: payload.text ?? "",
+				mediaUrl: payload.mediaUrl,
+				payload
+			};
+			return await outbound.renderPresentation({
+				payload,
+				presentation,
+				ctx
+			});
+		} : void 0,
+		pinDeliveredMessage: outbound?.pinDeliveredMessage ? async ({ target, messageId, pin, gatewayClientScopes }) => outbound.pinDeliveredMessage({
+			cfg: params.cfg,
+			target,
+			messageId,
+			pin,
+			gatewayClientScopes
+		}) : void 0,
+		afterDeliverPayload: outbound?.afterDeliverPayload ? async ({ target, payload, results }) => outbound.afterDeliverPayload({
+			cfg: params.cfg,
+			target,
+			payload,
+			results
+		}) : void 0,
+		shouldSkipPlainTextSanitization: outbound?.shouldSkipPlainTextSanitization ? (payload) => outbound.shouldSkipPlainTextSanitization({ payload }) : void 0,
+		resolveEffectiveTextChunkLimit: outbound?.resolveEffectiveTextChunkLimit ? (fallbackLimit) => outbound.resolveEffectiveTextChunkLimit({
+			cfg: params.cfg,
+			accountId: params.accountId ?? void 0,
+			fallbackLimit
+		}) : void 0,
+		sendPayload: messagePayload || outbound?.sendPayload ? async (payload, overrides) => {
+			const payloadCtx = {
+				...resolveCtx(overrides),
+				kind: "payload",
+				text: payload.text ?? "",
+				mediaUrl: payload.mediaUrl,
+				payload
+			};
+			if (messagePayload) {
+				const sent = await runChannelMessageSendWithLifecycle({
+					lifecycle: messageLifecycle,
+					ctx: payloadCtx,
+					send: async () => {
+						await params.onPlatformSendStart?.();
+						return await messagePayload(payloadCtx);
+					}
+				});
+				return attachOutboundDeliveryCommitHook(normalizeChannelMessageSendResult(params.channel, sent.result), sent.afterCommit);
+			}
+			await params.onPlatformSendStart?.();
+			return outbound.sendPayload(payloadCtx);
+		} : void 0,
+		sendFormattedText: outbound?.sendFormattedText ? async (text, overrides) => {
+			await params.onPlatformSendStart?.();
+			return await outbound.sendFormattedText({
+				...resolveCtx(overrides),
+				text
+			});
+		} : void 0,
+		sendFormattedMedia: outbound?.sendFormattedMedia ? async (caption, mediaUrl, overrides) => {
+			await params.onPlatformSendStart?.();
+			return await outbound.sendFormattedMedia({
+				...resolveCtx(overrides),
+				text: caption,
+				mediaUrl
+			});
+		} : void 0,
+		sendText: async (text, overrides) => {
+			const textCtx = {
+				...resolveCtx(overrides),
+				kind: "text",
+				text
+			};
+			if (messageText) {
+				const sent = await runChannelMessageSendWithLifecycle({
+					lifecycle: messageLifecycle,
+					ctx: textCtx,
+					send: async () => {
+						await params.onPlatformSendStart?.();
+						return await messageText(textCtx);
+					}
+				});
+				return attachOutboundDeliveryCommitHook(normalizeChannelMessageSendResult(params.channel, sent.result), sent.afterCommit);
+			}
+			await params.onPlatformSendStart?.();
+			return sendText(textCtx);
+		},
+		buildTargetRef,
+		sendMedia: async (caption, mediaUrl, overrides) => {
+			const mediaCtx = {
+				...resolveCtx(overrides),
+				kind: "media",
+				text: caption,
+				mediaUrl
+			};
+			if (messageMedia) {
+				const sent = await runChannelMessageSendWithLifecycle({
+					lifecycle: messageLifecycle,
+					ctx: mediaCtx,
+					send: async () => {
+						await params.onPlatformSendStart?.();
+						return await messageMedia(mediaCtx);
+					}
+				});
+				return attachOutboundDeliveryCommitHook(normalizeChannelMessageSendResult(params.channel, sent.result), sent.afterCommit);
+			}
+			if (sendMedia) {
+				await params.onPlatformSendStart?.();
+				return sendMedia(mediaCtx);
+			}
+			await params.onPlatformSendStart?.();
+			return sendText(mediaCtx);
+		}
+	};
+}
+function normalizeChannelMessageSendResult(channel, result) {
+	const source = result;
+	return {
+		...source,
+		channel,
+		messageId: source.messageId ?? source.receipt.primaryPlatformMessageId ?? source.receipt.platformMessageIds[0] ?? "",
+		receipt: source.receipt
+	};
+}
+function createChannelOutboundContextBase(params) {
+	return {
+		cfg: params.cfg,
+		to: params.to,
+		accountId: params.accountId,
+		replyToId: params.replyToId,
+		replyToMode: params.replyToMode,
+		formatting: params.formatting,
+		threadId: params.threadId,
+		identity: params.identity,
+		gifPlayback: params.gifPlayback,
+		forceDocument: params.forceDocument,
+		deps: params.deps,
+		silent: params.silent,
+		mediaAccess: params.mediaAccess,
+		mediaLocalRoots: params.mediaAccess?.localRoots,
+		mediaReadFile: params.mediaAccess?.readFile,
+		gatewayClientScopes: params.gatewayClientScopes
+	};
+}
+const isAbortError = (err) => err instanceof Error && err.name === "AbortError";
+const isDeliveryAbortError = (err) => isAbortError(err) || err instanceof OutboundDeliveryError && isAbortError(err.cause);
+async function markQueuedPlatformSendAttemptStarted(params) {
+	try {
+		await markDeliveryPlatformSendAttemptStarted(params.queueId);
+		return true;
+	} catch (err) {
+		if (params.queuePolicy === "required") throw err;
+		log.warn(`failed to mark queued delivery ${params.queueId} as platform-send-attempt-started; continuing best-effort delivery: ${formatErrorMessage(err)}`);
+		return false;
+	}
+}
+async function markQueuedPlatformOutcomeUnknown(params) {
+	try {
+		await markDeliveryPlatformOutcomeUnknown(params.queueId);
+	} catch (err) {
+		if (params.queuePolicy === "required") throw err;
+		log.warn(`failed to mark queued delivery ${params.queueId} as platform-outcome-unknown; continuing best-effort delivery: ${formatErrorMessage(err)}`);
+	}
+}
+/**
+* Best-effort session identifier for delivery telemetry only. Falls back to
+* `policyKey` as a last resort so diagnostic emission still has a stable
+* string when neither mirror nor canonical key are available. **Do not use
+* this value for hook-context correlation** — use `sessionKeyForInternalHooks`
+* (mirror.sessionKey ?? session.key, no policyKey fallback) instead, so we
+* never accidentally hand the policy key to plugins that expect the canonical
+* session key.
+*/
+function sessionKeyForDeliveryDiagnostics(params) {
+	return params.mirror?.sessionKey ?? params.session?.key ?? params.session?.policyKey;
+}
+function deliveryKindForPayload(payload, payloadSummary) {
+	if (payloadSummary.mediaUrls.length > 0 || payload.mediaUrl || payload.mediaUrls?.length) return "media";
+	if (payload.presentation || payload.interactive || payload.channelData || payload.audioAsVoice) return "other";
+	return "text";
+}
+function emitMessageDeliveryStarted(params) {
+	emitInternalDiagnosticEvent({
+		type: "message.delivery.started",
+		channel: params.channel,
+		deliveryKind: params.deliveryKind,
+		...params.sessionKey ? { sessionKey: params.sessionKey } : {}
+	});
+}
+function emitMessageDeliveryCompleted(params) {
+	emitInternalDiagnosticEvent({
+		type: "message.delivery.completed",
+		channel: params.channel,
+		deliveryKind: params.deliveryKind,
+		durationMs: params.durationMs,
+		resultCount: params.resultCount,
+		...params.sessionKey ? { sessionKey: params.sessionKey } : {}
+	});
+}
+function emitMessageDeliveryError(params) {
+	emitInternalDiagnosticEvent({
+		type: "message.delivery.error",
+		channel: params.channel,
+		deliveryKind: params.deliveryKind,
+		durationMs: params.durationMs,
+		errorCategory: diagnosticErrorCategory(params.error),
+		...params.sessionKey ? { sessionKey: params.sessionKey } : {}
+	});
+}
+function normalizeEmptyPayloadForDelivery(payload) {
+	const text = typeof payload.text === "string" ? payload.text : "";
+	if (!text.trim()) {
+		if (!hasReplyPayloadContent({
+			...payload,
+			text
+		})) return null;
+		if (text) return {
+			...payload,
+			text: ""
+		};
+	}
+	return payload;
+}
+function normalizePayloadsForChannelDelivery(plan, handler) {
+	const normalizedPayloads = [];
+	for (const entry of plan) {
+		let sanitizedPayload = stripInternalRuntimeScaffoldingFromPayload(entry.payload);
+		if (handler.sanitizeText && sanitizedPayload.text) {
+			if (!handler.shouldSkipPlainTextSanitization?.(sanitizedPayload)) sanitizedPayload = {
+				...sanitizedPayload,
+				text: handler.sanitizeText(sanitizedPayload)
+			};
+		}
+		const normalizedPayload = handler.normalizePayload ? handler.normalizePayload(sanitizedPayload) : sanitizedPayload;
+		const normalized = normalizedPayload ? normalizeEmptyPayloadForDelivery(stripInternalRuntimeScaffoldingFromPayload(normalizedPayload)) : null;
+		if (normalized) normalizedPayloads.push({
+			index: entry.sourceIndex,
+			payload: normalized
+		});
+	}
+	return normalizedPayloads;
+}
+function stripInternalRuntimeScaffoldingFromValue(value) {
+	if (typeof value === "string") return stripInternalRuntimeScaffolding(value);
+	if (Array.isArray(value)) {
+		let changed = false;
+		const next = value.map((entry) => {
+			const stripped = stripInternalRuntimeScaffoldingFromValue(entry);
+			changed ||= stripped !== entry;
+			return stripped;
+		});
+		return changed ? next : value;
+	}
+	if (!value || typeof value !== "object") return value;
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return value;
+	let changed = false;
+	const next = {};
+	for (const [key, entry] of Object.entries(value)) {
+		const stripped = stripInternalRuntimeScaffoldingFromValue(entry);
+		changed ||= stripped !== entry;
+		next[key] = stripped;
+	}
+	return changed ? next : value;
+}
+function stripInternalRuntimeScaffoldingFromPayload(payload) {
+	const stripped = stripInternalRuntimeScaffoldingFromValue(payload);
+	return stripped && typeof stripped === "object" && !Array.isArray(stripped) ? stripped : payload;
+}
+function buildPayloadSummary(payload) {
+	return summarizeOutboundPayloadForTransport(payload);
+}
+function hasDeliveryResultIdentity(result) {
+	return Boolean(result.messageId || result.chatId || result.channelId || result.roomId || result.conversationId || result.toJid || result.pollId);
+}
+function normalizeDeliveryPin(payload) {
+	const pin = payload.delivery?.pin;
+	if (pin === true) return { enabled: true };
+	if (!pin || typeof pin !== "object" || Array.isArray(pin)) return;
+	if (!pin.enabled) return;
+	const normalized = { enabled: true };
+	if (pin.notify === true) normalized.notify = true;
+	if (pin.required === true) normalized.required = true;
+	return normalized;
+}
+async function maybePinDeliveredMessage(params) {
+	const pin = normalizeDeliveryPin(params.payload);
+	if (!pin) return;
+	if (!params.messageId) {
+		if (pin.required) throw new Error("请求了投递锁定，但未返回已投递的消息 id");
+		log.warn("Delivery pin requested, but no delivered message id was returned.", {
+			channel: params.target.channel,
+			to: params.target.to
+		});
+		return;
+	}
+	if (!params.handler.pinDeliveredMessage) {
+		if (pin.required) throw new Error(`Delivery pin is not supported by channel: ${params.target.channel}`);
+		log.warn("Delivery pin requested, but channel does not support pinning delivered messages.", {
+			channel: params.target.channel,
+			to: params.target.to
+		});
+		return;
+	}
+	try {
+		await params.handler.pinDeliveredMessage({
+			target: params.target,
+			messageId: params.messageId,
+			pin,
+			gatewayClientScopes: params.gatewayClientScopes
+		});
+	} catch (err) {
+		if (pin.required) throw err;
+		log.warn("Delivery pin requested, but channel failed to pin delivered message.", {
+			channel: params.target.channel,
+			to: params.target.to,
+			messageId: params.messageId,
+			error: formatErrorMessage(err)
+		});
+	}
+}
+async function maybeNotifyAfterDeliveredPayload(params) {
+	if (!params.handler.afterDeliverPayload || params.results.length === 0) return;
+	try {
+		await params.handler.afterDeliverPayload({
+			target: params.target,
+			payload: params.payload,
+			results: params.results
+		});
+	} catch (err) {
+		log.warn("Plugin outbound adapter after-delivery hook failed.", {
+			channel: params.target.channel,
+			to: params.target.to,
+			error: formatErrorMessage(err)
+		});
+	}
+}
+async function renderPresentationForDelivery(handler, payload) {
+	const presentation = normalizeMessagePresentation(payload.presentation);
+	if (!presentation) return payload;
+	const adaptedPresentation = adaptMessagePresentationForChannel({
+		presentation,
+		capabilities: handler.presentationCapabilities
+	});
+	const adaptedPayload = {
+		...payload,
+		presentation: adaptedPresentation
+	};
+	const rendered = handler.renderPresentation ? await handler.renderPresentation(adaptedPayload) : null;
+	if (rendered) {
+		const { presentation: _presentation, ...withoutPresentation } = rendered;
+		return withoutPresentation;
+	}
+	const { presentation: _presentation, ...withoutPresentation } = payload;
+	return {
+		...withoutPresentation,
+		text: renderMessagePresentationFallbackText({
+			text: payload.text,
+			presentation: adaptedPresentation
+		})
+	};
+}
+function createMessageSentEmitter(params) {
+	const hasMessageSentHooks = params.hookRunner?.hasHooks("message_sent") ?? false;
+	const canEmitInternalHook = Boolean(params.sessionKeyForInternalHooks);
+	const emitMessageSent = (event) => {
+		if (!hasMessageSentHooks && !canEmitInternalHook) return;
+		const canonical = buildCanonicalSentMessageHookContext({
+			to: params.to,
+			content: event.content,
+			success: event.success,
+			error: event.error,
+			channelId: params.channel,
+			accountId: params.accountId ?? void 0,
+			conversationId: params.to,
+			sessionKey: params.sessionKeyForInternalHooks,
+			messageId: event.messageId,
+			isGroup: params.mirrorIsGroup,
+			groupId: params.mirrorGroupId
+		});
+		if (hasMessageSentHooks) fireAndForgetHook(params.hookRunner.runMessageSent(toPluginMessageSentEvent(canonical), toPluginMessageContext(canonical)), "deliverOutboundPayloads: message_sent plugin hook failed", (message) => {
+			log.warn(message);
+		});
+		if (!canEmitInternalHook) return;
+		fireAndForgetHook(triggerInternalHook(createInternalHookEvent("message", "sent", params.sessionKeyForInternalHooks, toInternalMessageSentContext(canonical))), "deliverOutboundPayloads: message:sent internal hook failed", (message) => {
+			log.warn(message);
+		});
+	};
+	return {
+		emitMessageSent,
+		hasMessageSentHooks
+	};
+}
+async function applyMessageSendingHook(params) {
+	if (!params.enabled) return {
+		cancelled: false,
+		contentRewritten: false,
+		payload: params.payload,
+		payloadSummary: params.payloadSummary
+	};
+	try {
+		const sendingResult = await params.hookRunner.runMessageSending({
+			to: params.to,
+			content: params.payloadSummary.hookContent ?? params.payloadSummary.text,
+			replyToId: params.replyToId ?? void 0,
+			threadId: params.threadId ?? void 0,
+			metadata: {
+				channel: params.channel,
+				accountId: params.accountId,
+				mediaUrls: params.payloadSummary.mediaUrls
+			}
+		}, {
+			channelId: params.channel,
+			accountId: params.accountId ?? void 0,
+			conversationId: params.to,
+			...params.sessionKey ? { sessionKey: params.sessionKey } : {}
+		});
+		if (sendingResult?.cancel) return {
+			cancelled: true,
+			...sendingResult.cancelReason ? { cancelReason: sendingResult.cancelReason } : {},
+			...sendingResult.metadata ? { hookMetadata: sendingResult.metadata } : {},
+			contentRewritten: false,
+			payload: params.payload,
+			payloadSummary: params.payloadSummary
+		};
+		if (sendingResult?.content == null) return {
+			cancelled: false,
+			contentRewritten: false,
+			payload: params.payload,
+			payloadSummary: params.payloadSummary
+		};
+		if (params.payloadSummary.hookContent && !params.payloadSummary.text) {
+			const spokenText = sendingResult.content;
+			return {
+				cancelled: false,
+				contentRewritten: true,
+				payload: {
+					...params.payload,
+					spokenText
+				},
+				payloadSummary: {
+					...params.payloadSummary,
+					hookContent: spokenText
+				}
+			};
+		}
+		return {
+			cancelled: false,
+			contentRewritten: true,
+			payload: {
+				...params.payload,
+				text: sendingResult.content
+			},
+			payloadSummary: {
+				...params.payloadSummary,
+				text: sendingResult.content
+			}
+		};
+	} catch {
+		return {
+			cancelled: false,
+			contentRewritten: false,
+			payload: params.payload,
+			payloadSummary: params.payloadSummary
+		};
+	}
+}
+async function applyReplyPayloadSendingHook(params) {
+	if (!params.hook) return {
+		cancelled: false,
+		payload: params.payload,
+		changed: false
+	};
+	const nextPayload = await runReplyPayloadSendingHook({
+		payload: params.payload,
+		kind: params.hook.kind,
+		...params.hook.channel ? { channel: params.hook.channel } : {},
+		...params.hook.sessionKey ? { sessionKey: params.hook.sessionKey } : {},
+		...params.hook.runId ? { runId: params.hook.runId } : {},
+		context: params.hook.context
+	});
+	if (!nextPayload) return {
+		cancelled: true,
+		payload: params.payload,
+		changed: false
+	};
+	return {
+		cancelled: false,
+		payload: nextPayload,
+		changed: nextPayload !== params.payload
+	};
+}
+function toOutboundDeliveryError(params) {
+	if (params.error instanceof OutboundDeliveryError) return params.error;
+	return new OutboundDeliveryError(formatErrorMessage(params.error), {
+		cause: params.error,
+		results: params.results,
+		payloadOutcomes: params.payloadOutcomes,
+		stage: params.stage
+	});
+}
+function suppressedPayloadOutcome(params) {
+	return {
+		index: params.index,
+		status: "suppressed",
+		reason: params.reason,
+		...params.hookEffect ? { hookEffect: params.hookEffect } : {}
+	};
+}
+/**
+* @deprecated Direct outbound delivery is compatibility/runtime substrate.
+* New message lifecycle code should use `sendDurableMessageBatch` from
+* `src/channels/message/send.ts` or `deliverInboundReplyWithMessageSendContext`
+* from `src/channels/turn/durable-delivery.ts`. Keep direct use only for
+* outbound substrate, recovery, and compatibility paths.
+*/
+async function deliverOutboundPayloads(params) {
+	return await deliverOutboundPayloadsInternal(params);
+}
+async function deliverOutboundPayloadsInternal(params) {
+	const { channel, to, payloads } = params;
+	const queuePolicy = params.queuePolicy ?? "best_effort";
+	const queuePayloads = payloads.map(stripInternalRuntimeScaffoldingFromPayload);
+	const queuePayloadsChanged = queuePayloads.some((payload, index) => payload !== payloads[index]);
+	const renderedBatchPlan = params.renderedBatchPlan ?? createRenderedMessageBatchPlan(params.payloads);
+	const queueRenderedBatchPlan = queuePayloadsChanged ? createRenderedMessageBatchPlan(queuePayloads) : renderedBatchPlan;
+	const queueId = params.skipQueue ? null : await enqueueDelivery({
+		channel,
+		to,
+		accountId: params.accountId,
+		payloads: queuePayloads,
+		renderedBatchPlan: queueRenderedBatchPlan,
+		threadId: params.threadId,
+		replyToId: params.replyToId,
+		replyToMode: params.replyToMode,
+		formatting: params.formatting,
+		identity: params.identity,
+		bestEffort: params.bestEffort,
+		gifPlayback: params.gifPlayback,
+		forceDocument: params.forceDocument,
+		replyPayloadSendingHook: params.replyPayloadSendingHook,
+		silent: params.silent,
+		mirror: params.mirror,
+		session: params.session,
+		gatewayClientScopes: params.gatewayClientScopes
+	}).catch((err) => {
+		if (queuePolicy === "required") throw err;
+		return null;
+	});
+	if (queueId) params.onDeliveryIntent?.({
+		id: queueId,
+		channel,
+		to,
+		...params.accountId ? { accountId: params.accountId } : {},
+		queuePolicy
+	});
+	if (!queueId) return await deliverOutboundPayloadsWithQueueCleanup(params, null);
+	const claimResult = await withActiveDeliveryClaim(queueId, () => deliverOutboundPayloadsWithQueueCleanup(params, queueId));
+	if (claimResult.status === "claimed-by-other-owner") return [];
+	return claimResult.value;
+}
+async function deliverOutboundPayloadsWithQueueCleanup(params, queueId) {
+	let hadPartialFailure = false;
+	const wrappedParams = {
+		...params,
+		onError: (err, payload) => {
+			hadPartialFailure = true;
+			params.onError?.(err, payload);
+		}
+	};
+	const queuePolicy = params.queuePolicy ?? "best_effort";
+	let platformResultsReturned = false;
+	try {
+		let platformSendStarted = false;
+		const results = await deliverOutboundPayloadsCore({
+			...wrappedParams,
+			...queueId ? { onPlatformSendStart: async () => {
+				if (platformSendStarted) return;
+				platformSendStarted = await markQueuedPlatformSendAttemptStarted({
+					queueId,
+					queuePolicy
+				});
+			} } : {}
+		});
+		platformResultsReturned = true;
+		if (!queueId) {
+			if (!params.deferCommitHooks) await runOutboundDeliveryCommitHooks(results);
+			return results;
+		}
+		if (queueId) if (hadPartialFailure) await failDelivery(queueId, "partial delivery failure (bestEffort)").catch((err) => {
+			log.warn(`failed to mark queued delivery ${queueId} as failed after partial failure; continuing best-effort delivery: ${formatErrorMessage(err)}`);
+		});
+		else {
+			if (platformSendStarted) await markQueuedPlatformOutcomeUnknown({
+				queueId,
+				queuePolicy
+			});
+			if (await ackDelivery(queueId).then(() => true).catch((err) => {
+				if (queuePolicy === "required") throw err;
+				log.warn(`failed to ack queued delivery ${queueId}; continuing best-effort delivery: ${formatErrorMessage(err)}`);
+				return false;
+			})) await runOutboundDeliveryCommitHooks(results);
+		}
+		return results;
+	} catch (err) {
+		if (queueId) {
+			if (isDeliveryAbortError(err)) await ackDelivery(queueId).catch(() => {});
+			else if (!platformResultsReturned) await failDelivery(queueId, formatErrorMessage(err)).catch((failErr) => {
+				log.warn(`failed to mark queued delivery ${queueId} as failed: ${formatErrorMessage(failErr)}`);
+			});
+		}
+		throw err;
+	}
+}
+/** Core delivery logic (extracted for queue wrapper). */
+async function deliverOutboundPayloadsCore(params) {
+	const { cfg, channel, to, payloads } = params;
+	const directiveOptions = await resolveChannelOutboundDirectiveOptions({
+		cfg,
+		channel
+	});
+	const outboundPayloadPlan = createOutboundPayloadPlan(payloads, {
+		cfg,
+		sessionKey: params.session?.policyKey ?? params.session?.key,
+		surface: channel,
+		conversationType: params.session?.conversationType,
+		extractMarkdownImages: directiveOptions.extractMarkdownImages
+	});
+	const accountId = params.accountId;
+	const deps = params.deps;
+	const abortSignal = params.abortSignal;
+	const resolveMediaAccess = (mediaSources) => mediaSources.length > 0 ? resolveAgentScopedOutboundMediaAccess({
+		cfg,
+		agentId: params.session?.agentId ?? params.mirror?.agentId,
+		mediaSources,
+		mediaAccess: params.mediaAccess,
+		sessionKey: params.session?.key,
+		messageProvider: params.session?.key ? void 0 : channel,
+		accountId: params.session?.requesterAccountId ?? accountId,
+		requesterSenderId: params.session?.requesterSenderId,
+		requesterSenderName: params.session?.requesterSenderName,
+		requesterSenderUsername: params.session?.requesterSenderUsername,
+		requesterSenderE164: params.session?.requesterSenderE164
+	}) : params.mediaAccess ?? {};
+	const createHandler = (mediaSources) => createChannelHandler({
+		cfg,
+		channel,
+		to,
+		deps,
+		accountId,
+		replyToId: params.replyToId,
+		replyToMode: params.replyToMode,
+		formatting: params.formatting,
+		threadId: params.threadId,
+		identity: params.identity,
+		gifPlayback: params.gifPlayback,
+		forceDocument: params.forceDocument,
+		silent: params.silent,
+		mediaAccess: resolveMediaAccess(mediaSources),
+		gatewayClientScopes: params.gatewayClientScopes,
+		...params.onPlatformSendStart ? { onPlatformSendStart: params.onPlatformSendStart } : {}
+	});
+	const baseHandler = await createHandler([]);
+	const handlerByMediaSources = /* @__PURE__ */ new Map();
+	const getDeliveryHandler = (mediaSources) => {
+		if (mediaSources.length === 0) return Promise.resolve(baseHandler);
+		const key = JSON.stringify(mediaSources);
+		const cached = handlerByMediaSources.get(key);
+		if (cached) return cached;
+		const created = createHandler(mediaSources);
+		handlerByMediaSources.set(key, created);
+		return created;
+	};
+	const results = [];
+	const handler = baseHandler;
+	const configuredTextLimit = handler.chunker ? resolveTextChunkLimit(cfg, channel, accountId, { fallbackLimit: handler.textChunkLimit }) : void 0;
+	const textLimit = params.formatting?.textLimit ?? (handler.resolveEffectiveTextChunkLimit ? handler.resolveEffectiveTextChunkLimit(configuredTextLimit) : configuredTextLimit);
+	const chunkMode = handler.chunker ? params.formatting?.chunkMode ?? resolveChunkMode(cfg, channel, accountId) : "length";
+	const { resolveCurrentReplyTo, applyReplyToConsumption } = createReplyToDeliveryPolicy({
+		replyToId: params.replyToId,
+		replyToMode: params.replyToMode
+	});
+	const sendTextChunks = async (sendHandler, text, overrides = {}) => {
+		const units = planOutboundTextMessageUnits({
+			text,
+			overrides,
+			chunker: sendHandler.chunker,
+			chunkerMode: sendHandler.chunkerMode,
+			chunkedTextFormatting: sendHandler.chunkedTextFormatting,
+			textLimit,
+			chunkMode,
+			formatting: params.formatting,
+			consumeReplyTo: (value) => applyReplyToConsumption(value, { consumeImplicitReply: value.replyToIdSource === "implicit" })
+		});
+		for (const unit of units) {
+			if (unit.kind !== "text") continue;
+			throwIfAborted(abortSignal);
+			results.push(await sendHandler.sendText(unit.text, unit.overrides));
+		}
+	};
+	const normalizedPayloads = normalizePayloadsForChannelDelivery(outboundPayloadPlan, handler);
+	const payloadOutcomes = [];
+	const recordPayloadOutcome = (outcome) => {
+		payloadOutcomes.push(outcome);
+		params.onPayloadDeliveryOutcome?.(outcome);
+	};
+	if (normalizedPayloads.length === 0 && payloads.length > 0) payloads.forEach((_payload, index) => {
+		recordPayloadOutcome(suppressedPayloadOutcome({
+			index,
+			reason: "no_visible_payload"
+		}));
+	});
+	const deliveredMirrorPayloads = [];
+	const recordDeliveredMirrorPayload = (payloadSummary, deliveredResults) => {
+		if (!params.mirror || !params.replyPayloadSendingHook || deliveredResults.length === 0) return;
+		deliveredMirrorPayloads.push(payloadSummary);
+	};
+	const hookRunner = getGlobalHookRunner();
+	const sessionKeyForInternalHooks = params.mirror?.sessionKey ?? params.session?.key;
+	const mirrorIsGroup = params.mirror?.isGroup;
+	const mirrorGroupId = params.mirror?.groupId;
+	const { emitMessageSent, hasMessageSentHooks } = createMessageSentEmitter({
+		hookRunner,
+		channel,
+		to,
+		accountId,
+		sessionKeyForInternalHooks,
+		mirrorIsGroup,
+		mirrorGroupId
+	});
+	const hasMessageSendingHooks = hookRunner?.hasHooks("message_sending") ?? false;
+	const diagnosticSessionKey = sessionKeyForDeliveryDiagnostics(params);
+	if (hasMessageSentHooks && params.session?.agentId && !sessionKeyForInternalHooks) log.warn("deliverOutboundPayloads: session.agentId present without session key; internal message:sent hook will be skipped", {
+		channel,
+		to,
+		agentId: params.session.agentId
+	});
+	for (const { index: payloadIndex, payload } of normalizedPayloads) {
+		let payloadSummary = buildPayloadSummary(payload);
+		let deliveryKind = "other";
+		let deliveryStartedAt = 0;
+		let deliveryStarted = false;
+		let deliveryFinished = false;
+		const startDeliveryDiagnostics = (kind) => {
+			deliveryKind = kind;
+			deliveryStartedAt = Date.now();
+			deliveryStarted = true;
+			deliveryFinished = false;
+			emitMessageDeliveryStarted({
+				channel,
+				deliveryKind,
+				sessionKey: diagnosticSessionKey
+			});
+		};
+		const completeDeliveryDiagnostics = (resultCount) => {
+			if (!deliveryStarted) return;
+			deliveryFinished = true;
+			emitMessageDeliveryCompleted({
+				channel,
+				deliveryKind,
+				durationMs: Date.now() - deliveryStartedAt,
+				resultCount,
+				sessionKey: diagnosticSessionKey
+			});
+		};
+		const errorDeliveryDiagnostics = (err) => {
+			if (!deliveryStarted || deliveryFinished) return;
+			deliveryFinished = true;
+			emitMessageDeliveryError({
+				channel,
+				deliveryKind,
+				durationMs: Date.now() - deliveryStartedAt,
+				error: err,
+				sessionKey: diagnosticSessionKey
+			});
+		};
+		try {
+			throwIfAborted(abortSignal);
+			const replyHookResult = await applyReplyPayloadSendingHook({
+				hook: params.replyPayloadSendingHook,
+				payload
+			});
+			if (replyHookResult.cancelled) {
+				recordPayloadOutcome(suppressedPayloadOutcome({
+					index: payloadIndex,
+					reason: "cancelled_by_reply_payload_sending_hook"
+				}));
+				continue;
+			}
+			let deliveryPayload = replyHookResult.payload;
+			payloadSummary = buildPayloadSummary(deliveryPayload);
+			const hookResult = await applyMessageSendingHook({
+				hookRunner,
+				enabled: hasMessageSendingHooks,
+				payload: deliveryPayload,
+				payloadSummary,
+				to,
+				channel,
+				accountId,
+				replyToId: resolveCurrentReplyTo(deliveryPayload).replyToId,
+				threadId: params.threadId,
+				sessionKey: sessionKeyForInternalHooks
+			});
+			if (hookResult.cancelled) {
+				const hookEffect = hookResult.cancelReason || hookResult.hookMetadata ? {
+					...hookResult.cancelReason ? { cancelReason: hookResult.cancelReason } : {},
+					...hookResult.hookMetadata ? { metadata: hookResult.hookMetadata } : {}
+				} : void 0;
+				recordPayloadOutcome(suppressedPayloadOutcome({
+					index: payloadIndex,
+					reason: "cancelled_by_message_sending_hook",
+					...hookEffect ? { hookEffect } : {}
+				}));
+				continue;
+			}
+			deliveryPayload = hookResult.payload;
+			const renderedPayload = stripInternalRuntimeScaffoldingFromPayload(await renderPresentationForDelivery(await getDeliveryHandler(buildPayloadSummary(deliveryPayload).mediaUrls), deliveryPayload));
+			const renderedHandler = await getDeliveryHandler(buildPayloadSummary(renderedPayload).mediaUrls);
+			const normalizedEffectivePayload = renderedHandler.normalizePayload ? renderedHandler.normalizePayload(renderedPayload) : renderedPayload;
+			const effectivePayload = normalizedEffectivePayload ? normalizeEmptyPayloadForDelivery(stripInternalRuntimeScaffoldingFromPayload(normalizedEffectivePayload)) : null;
+			if (!effectivePayload) {
+				recordPayloadOutcome(suppressedPayloadOutcome({
+					index: payloadIndex,
+					reason: hookResult.contentRewritten ? "empty_after_message_sending_hook" : replyHookResult.changed ? "empty_after_reply_payload_sending_hook" : "no_visible_payload"
+				}));
+				continue;
+			}
+			payloadSummary = buildPayloadSummary(effectivePayload);
+			const deliveryHandler = await getDeliveryHandler(payloadSummary.mediaUrls);
+			startDeliveryDiagnostics(deliveryKindForPayload(effectivePayload, payloadSummary));
+			params.onPayload?.(payloadSummary);
+			const replyToResolution = resolveCurrentReplyTo(effectivePayload);
+			const sendOverrides = {
+				replyToId: replyToResolution.replyToId,
+				replyToIdSource: replyToResolution.source,
+				...params.threadId !== void 0 ? { threadId: params.threadId } : {},
+				...effectivePayload.audioAsVoice === true ? { audioAsVoice: true } : {},
+				...params.forceDocument !== void 0 ? { forceDocument: params.forceDocument } : {}
+			};
+			const applySendReplyToConsumption = (overrides) => applyReplyToConsumption(overrides, { consumeImplicitReply: replyToResolution.source === "implicit" });
+			const deliveryTarget = deliveryHandler.buildTargetRef({ threadId: sendOverrides.threadId });
+			if (deliveryHandler.sendPayload && (effectivePayload.isError === true && deliveryHandler.sendTextOnlyErrorPayloads === true || hasReplyPayloadContent({
+				presentation: effectivePayload.presentation,
+				interactive: effectivePayload.interactive,
+				channelData: effectivePayload.channelData
+			}) || effectivePayload.audioAsVoice === true)) {
+				const delivery = await deliveryHandler.sendPayload(effectivePayload, applySendReplyToConsumption(sendOverrides));
+				if (!hasDeliveryResultIdentity(delivery)) {
+					completeDeliveryDiagnostics(0);
+					recordPayloadOutcome(suppressedPayloadOutcome({
+						index: payloadIndex,
+						reason: "adapter_returned_no_identity"
+					}));
+					continue;
+				}
+				results.push(delivery);
+				recordPayloadOutcome({
+					index: payloadIndex,
+					status: "sent",
+					results: [delivery]
+				});
+				recordDeliveredMirrorPayload(payloadSummary, [delivery]);
+				await maybePinDeliveredMessage({
+					handler: deliveryHandler,
+					payload: effectivePayload,
+					target: deliveryTarget,
+					messageId: delivery.messageId,
+					gatewayClientScopes: params.gatewayClientScopes
+				});
+				await maybeNotifyAfterDeliveredPayload({
+					handler: deliveryHandler,
+					payload: effectivePayload,
+					target: deliveryTarget,
+					results: [delivery]
+				});
+				completeDeliveryDiagnostics(1);
+				emitMessageSent({
+					success: true,
+					content: payloadSummary.hookContent ?? payloadSummary.text,
+					messageId: delivery.messageId
+				});
+				continue;
+			}
+			if (payloadSummary.mediaUrls.length === 0) {
+				const beforeCount = results.length;
+				if (deliveryHandler.sendFormattedText) results.push(...await deliveryHandler.sendFormattedText(payloadSummary.text, applySendReplyToConsumption(sendOverrides)));
+				else await sendTextChunks(deliveryHandler, payloadSummary.text, sendOverrides);
+				const deliveredResults = results.slice(beforeCount);
+				if (deliveredResults.length > 0) {
+					recordPayloadOutcome({
+						index: payloadIndex,
+						status: "sent",
+						results: deliveredResults
+					});
+					recordDeliveredMirrorPayload(payloadSummary, deliveredResults);
+				} else recordPayloadOutcome(suppressedPayloadOutcome({
+					index: payloadIndex,
+					reason: "adapter_returned_no_identity"
+				}));
+				const messageId = results.at(-1)?.messageId;
+				const pinMessageId = deliveredResults.find((entry) => entry.messageId)?.messageId;
+				await maybePinDeliveredMessage({
+					handler: deliveryHandler,
+					payload: effectivePayload,
+					target: deliveryTarget,
+					messageId: pinMessageId,
+					gatewayClientScopes: params.gatewayClientScopes
+				});
+				await maybeNotifyAfterDeliveredPayload({
+					handler: deliveryHandler,
+					payload: effectivePayload,
+					target: deliveryTarget,
+					results: deliveredResults
+				});
+				completeDeliveryDiagnostics(deliveredResults.length);
+				emitMessageSent({
+					success: results.length > beforeCount,
+					content: payloadSummary.hookContent ?? payloadSummary.text,
+					messageId
+				});
+				continue;
+			}
+			if (!deliveryHandler.supportsMedia) {
+				log.warn("Plugin outbound adapter does not implement sendMedia; media URLs will be dropped and text fallback will be used", {
+					channel,
+					to,
+					mediaCount: payloadSummary.mediaUrls.length
+				});
+				const fallbackText = payloadSummary.text.trim();
+				if (!fallbackText) throw new Error("Plugin outbound adapter does not implement sendMedia and no text fallback is available for media payload");
+				const beforeCount = results.length;
+				await sendTextChunks(deliveryHandler, fallbackText, sendOverrides);
+				const deliveredResults = results.slice(beforeCount);
+				if (deliveredResults.length > 0) {
+					recordPayloadOutcome({
+						index: payloadIndex,
+						status: "sent",
+						results: deliveredResults
+					});
+					recordDeliveredMirrorPayload(payloadSummary, deliveredResults);
+				} else recordPayloadOutcome(suppressedPayloadOutcome({
+					index: payloadIndex,
+					reason: "adapter_returned_no_identity"
+				}));
+				const messageId = results.at(-1)?.messageId;
+				const pinMessageId = deliveredResults.find((entry) => entry.messageId)?.messageId;
+				await maybePinDeliveredMessage({
+					handler: deliveryHandler,
+					payload: effectivePayload,
+					target: deliveryTarget,
+					messageId: pinMessageId,
+					gatewayClientScopes: params.gatewayClientScopes
+				});
+				await maybeNotifyAfterDeliveredPayload({
+					handler: deliveryHandler,
+					payload: effectivePayload,
+					target: deliveryTarget,
+					results: deliveredResults
+				});
+				completeDeliveryDiagnostics(deliveredResults.length);
+				emitMessageSent({
+					success: results.length > beforeCount,
+					content: payloadSummary.hookContent ?? payloadSummary.text,
+					messageId
+				});
+				continue;
+			}
+			let firstMessageId;
+			let lastMessageId;
+			const beforeCount = results.length;
+			const mediaUnits = planOutboundMediaMessageUnits({
+				mediaUrls: payloadSummary.mediaUrls,
+				caption: payloadSummary.text,
+				overrides: sendOverrides,
+				consumeReplyTo: applySendReplyToConsumption
+			});
+			for (const unit of mediaUnits) {
+				if (unit.kind !== "media") continue;
+				throwIfAborted(abortSignal);
+				const delivery = deliveryHandler.sendFormattedMedia ? await deliveryHandler.sendFormattedMedia(unit.caption ?? "", unit.mediaUrl, unit.overrides) : await deliveryHandler.sendMedia(unit.caption ?? "", unit.mediaUrl, unit.overrides);
+				results.push(delivery);
+				firstMessageId ??= delivery.messageId;
+				lastMessageId = delivery.messageId;
+			}
+			await maybePinDeliveredMessage({
+				handler: deliveryHandler,
+				payload: effectivePayload,
+				target: deliveryTarget,
+				messageId: firstMessageId,
+				gatewayClientScopes: params.gatewayClientScopes
+			});
+			await maybeNotifyAfterDeliveredPayload({
+				handler: deliveryHandler,
+				payload: effectivePayload,
+				target: deliveryTarget,
+				results: results.slice(beforeCount)
+			});
+			const deliveredResults = results.slice(beforeCount);
+			if (deliveredResults.length > 0) {
+				recordPayloadOutcome({
+					index: payloadIndex,
+					status: "sent",
+					results: deliveredResults
+				});
+				recordDeliveredMirrorPayload(payloadSummary, deliveredResults);
+			} else recordPayloadOutcome(suppressedPayloadOutcome({
+				index: payloadIndex,
+				reason: "adapter_returned_no_identity"
+			}));
+			completeDeliveryDiagnostics(results.length - beforeCount);
+			emitMessageSent({
+				success: true,
+				content: payloadSummary.hookContent ?? payloadSummary.text,
+				messageId: lastMessageId
+			});
+		} catch (err) {
+			recordPayloadOutcome({
+				index: payloadIndex,
+				status: "failed",
+				error: err,
+				sentBeforeError: results.length > 0,
+				stage: "platform_send"
+			});
+			errorDeliveryDiagnostics(err);
+			emitMessageSent({
+				success: false,
+				content: payloadSummary.hookContent ?? payloadSummary.text,
+				error: formatErrorMessage(err)
+			});
+			if (!params.bestEffort) throw toOutboundDeliveryError({
+				error: err,
+				results,
+				payloadOutcomes,
+				stage: "platform_send"
+			});
+			params.onError?.(err, payloadSummary);
+		}
+	}
+	if (params.mirror && results.length > 0) {
+		const deliveredMirror = deliveredMirrorPayloads.length > 0 ? {
+			text: deliveredMirrorPayloads.map((payload) => payload.hookContent ?? payload.text).filter((text) => text.trim()).join("\n"),
+			mediaUrls: deliveredMirrorPayloads.flatMap((payload) => payload.mediaUrls)
+		} : params.mirror;
+		const mirrorText = resolveMirroredTranscriptText({
+			text: deliveredMirror.text,
+			mediaUrls: deliveredMirror.mediaUrls
+		});
+		if (mirrorText) {
+			const { appendAssistantMessageToSessionTranscript } = await loadTranscriptRuntime();
+			await appendAssistantMessageToSessionTranscript({
+				agentId: params.mirror.agentId,
+				sessionKey: params.mirror.sessionKey,
+				text: mirrorText,
+				idempotencyKey: params.mirror.idempotencyKey,
+				config: params.cfg
+			});
+		}
+	}
+	return results;
+}
+//#endregion
+export { createRenderedMessageBatch as a, throwIfAborted as i, deliverOutboundPayloadsInternal as n, runReplyPayloadSendingHook as o, resolveOutboundDurableFinalDeliverySupport as r, isOutboundDeliveryError as s, deliverOutboundPayloads as t };