activeclaw 2026.2.11 → 2026.2.13

package/dist/{deliver-hf-WKyWd.js → deliver-CIU9Npgs.js}

@@ -1,19 +1,275 @@
 import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
-import { st as getActivePluginRegistry, w as shouldLogVerbose, x as logVerbose } from "./entry.js";
+import { S as logVerbose, T as shouldLogVerbose, lt as getActivePluginRegistry, o as createSubsystemLogger } from "./entry.js";
 import { c as normalizeAccountId$1 } from "./session-key-DVvxnFKg.js";
-import { c as escapeRegExp, y as resolveUserPath } from "./utils-Dk86IbEs.js";
-import { i as loadConfig } from "./config-B00lvFac.js";
-import { t as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-BlgPSDAh.js";
-import { r as normalizeChannelId, t as getChannelPlugin } from "./plugins-Db5BiELK.js";
-import { C as mediaKindFromMime, S as maxBytesForKind, a as closeDispatcher, c as resolvePinnedHostnameWithPolicy, d as hasAlphaChannel, f as optimizeImageToPng, h as extensionForMime, l as convertHeicToJpeg, m as detectMime, o as createPinnedDispatcher, p as resizeToJpeg, r as saveMediaBuffer, s as resolvePinnedHostname } from "./routes-B4QQiFju.js";
-import { i as isMessagingToolDuplicate } from "./pi-embedded-helpers-Bkpd4fTr.js";
-import { l as appendAssistantMessageToSessionTranscript, ot as resolveSignalAccount, rt as getChannelDock, u as resolveMirroredTranscriptText } from "./sandbox-Aks-9EcZ.js";
+import { c as escapeRegExp, y as resolveUserPath } from "./utils-BLJAc3ZV.js";
+import { i as loadConfig } from "./config-Bdhomfei.js";
+import { t as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-C_MmebBt.js";
+import { r as normalizeChannelId, t as getChannelPlugin } from "./plugins-4Hqd1WGf.js";
+import { S as mediaKindFromMime, c as convertHeicToJpeg, d as optimizeImageToPng, f as resizeToJpeg, m as extensionForMime, p as detectMime, r as saveMediaBuffer, u as hasAlphaChannel, x as maxBytesForKind } from "./routes-DewK5tq2.js";
+import { i as isMessagingToolDuplicate } from "./pi-embedded-helpers-DfwkwPYD.js";
+import { r as fetchRemoteMedia, t as fetchWithTimeout } from "./fetch-timeout-DTK9vxex.js";
+import { l as appendAssistantMessageToSessionTranscript, ot as resolveSignalAccount, rt as getChannelDock, u as resolveMirroredTranscriptText } from "./sandbox-BKYnhYQH.js";
 import path from "node:path";
+import os from "node:os";
 import fs from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
 import MarkdownIt from "markdown-it";
 
+//#region src/plugins/hooks.ts
+/**
+* Get hooks for a specific hook name, sorted by priority (higher first).
+*/
+function getHooksForName(registry, hookName) {
+	return registry.typedHooks.filter((h) => h.hookName === hookName).toSorted((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+}
+/**
+* Create a hook runner for a specific registry.
+*/
+function createHookRunner(registry, options = {}) {
+	const logger = options.logger;
+	const catchErrors = options.catchErrors ?? true;
+	/**
+	* Run a hook that doesn't return a value (fire-and-forget style).
+	* All handlers are executed in parallel for performance.
+	*/
+	async function runVoidHook(hookName, event, ctx) {
+		const hooks = getHooksForName(registry, hookName);
+		if (hooks.length === 0) return;
+		logger?.debug?.(`[hooks] running ${hookName} (${hooks.length} handlers)`);
+		const promises = hooks.map(async (hook) => {
+			try {
+				await hook.handler(event, ctx);
+			} catch (err) {
+				const msg = `[hooks] ${hookName} handler from ${hook.pluginId} failed: ${String(err)}`;
+				if (catchErrors) logger?.error(msg);
+				else throw new Error(msg, { cause: err });
+			}
+		});
+		await Promise.all(promises);
+	}
+	/**
+	* Run a hook that can return a modifying result.
+	* Handlers are executed sequentially in priority order, and results are merged.
+	*/
+	async function runModifyingHook(hookName, event, ctx, mergeResults) {
+		const hooks = getHooksForName(registry, hookName);
+		if (hooks.length === 0) return;
+		logger?.debug?.(`[hooks] running ${hookName} (${hooks.length} handlers, sequential)`);
+		let result;
+		for (const hook of hooks) try {
+			const handlerResult = await hook.handler(event, ctx);
+			if (handlerResult !== void 0 && handlerResult !== null) if (mergeResults && result !== void 0) result = mergeResults(result, handlerResult);
+			else result = handlerResult;
+		} catch (err) {
+			const msg = `[hooks] ${hookName} handler from ${hook.pluginId} failed: ${String(err)}`;
+			if (catchErrors) logger?.error(msg);
+			else throw new Error(msg, { cause: err });
+		}
+		return result;
+	}
+	/**
+	* Run before_agent_start hook.
+	* Allows plugins to inject context into the system prompt.
+	* Runs sequentially, merging systemPrompt and prependContext from all handlers.
+	*/
+	async function runBeforeAgentStart(event, ctx) {
+		return runModifyingHook("before_agent_start", event, ctx, (acc, next) => ({
+			systemPrompt: next.systemPrompt ?? acc?.systemPrompt,
+			prependContext: acc?.prependContext && next.prependContext ? `${acc.prependContext}\n\n${next.prependContext}` : next.prependContext ?? acc?.prependContext
+		}));
+	}
+	/**
+	* Run agent_end hook.
+	* Allows plugins to analyze completed conversations.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runAgentEnd(event, ctx) {
+		return runVoidHook("agent_end", event, ctx);
+	}
+	/**
+	* Run before_compaction hook.
+	*/
+	async function runBeforeCompaction(event, ctx) {
+		return runVoidHook("before_compaction", event, ctx);
+	}
+	/**
+	* Run after_compaction hook.
+	*/
+	async function runAfterCompaction(event, ctx) {
+		return runVoidHook("after_compaction", event, ctx);
+	}
+	/**
+	* Run message_received hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runMessageReceived(event, ctx) {
+		return runVoidHook("message_received", event, ctx);
+	}
+	/**
+	* Run message_sending hook.
+	* Allows plugins to modify or cancel outgoing messages.
+	* Runs sequentially.
+	*/
+	async function runMessageSending(event, ctx) {
+		return runModifyingHook("message_sending", event, ctx, (acc, next) => ({
+			content: next.content ?? acc?.content,
+			cancel: next.cancel ?? acc?.cancel
+		}));
+	}
+	/**
+	* Run message_sent hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runMessageSent(event, ctx) {
+		return runVoidHook("message_sent", event, ctx);
+	}
+	/**
+	* Run before_tool_call hook.
+	* Allows plugins to modify or block tool calls.
+	* Runs sequentially.
+	*/
+	async function runBeforeToolCall(event, ctx) {
+		return runModifyingHook("before_tool_call", event, ctx, (acc, next) => ({
+			params: next.params ?? acc?.params,
+			block: next.block ?? acc?.block,
+			blockReason: next.blockReason ?? acc?.blockReason
+		}));
+	}
+	/**
+	* Run after_tool_call hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runAfterToolCall(event, ctx) {
+		return runVoidHook("after_tool_call", event, ctx);
+	}
+	/**
+	* Run tool_result_persist hook.
+	*
+	* This hook is intentionally synchronous: it runs in hot paths where session
+	* transcripts are appended synchronously.
+	*
+	* Handlers are executed sequentially in priority order (higher first). Each
+	* handler may return `{ message }` to replace the message passed to the next
+	* handler.
+	*/
+	function runToolResultPersist(event, ctx) {
+		const hooks = getHooksForName(registry, "tool_result_persist");
+		if (hooks.length === 0) return;
+		let current = event.message;
+		for (const hook of hooks) try {
+			const out = hook.handler({
+				...event,
+				message: current
+			}, ctx);
+			if (out && typeof out.then === "function") {
+				const msg = `[hooks] tool_result_persist handler from ${hook.pluginId} returned a Promise; this hook is synchronous and the result was ignored.`;
+				if (catchErrors) {
+					logger?.warn?.(msg);
+					continue;
+				}
+				throw new Error(msg);
+			}
+			const next = out?.message;
+			if (next) current = next;
+		} catch (err) {
+			const msg = `[hooks] tool_result_persist handler from ${hook.pluginId} failed: ${String(err)}`;
+			if (catchErrors) logger?.error(msg);
+			else throw new Error(msg, { cause: err });
+		}
+		return { message: current };
+	}
+	/**
+	* Run session_start hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runSessionStart(event, ctx) {
+		return runVoidHook("session_start", event, ctx);
+	}
+	/**
+	* Run session_end hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runSessionEnd(event, ctx) {
+		return runVoidHook("session_end", event, ctx);
+	}
+	/**
+	* Run gateway_start hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runGatewayStart(event, ctx) {
+		return runVoidHook("gateway_start", event, ctx);
+	}
+	/**
+	* Run gateway_stop hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runGatewayStop(event, ctx) {
+		return runVoidHook("gateway_stop", event, ctx);
+	}
+	/**
+	* Check if any hooks are registered for a given hook name.
+	*/
+	function hasHooks(hookName) {
+		return registry.typedHooks.some((h) => h.hookName === hookName);
+	}
+	/**
+	* Get count of registered hooks for a given hook name.
+	*/
+	function getHookCount(hookName) {
+		return registry.typedHooks.filter((h) => h.hookName === hookName).length;
+	}
+	return {
+		runBeforeAgentStart,
+		runAgentEnd,
+		runBeforeCompaction,
+		runAfterCompaction,
+		runMessageReceived,
+		runMessageSending,
+		runMessageSent,
+		runBeforeToolCall,
+		runAfterToolCall,
+		runToolResultPersist,
+		runSessionStart,
+		runSessionEnd,
+		runGatewayStart,
+		runGatewayStop,
+		hasHooks,
+		getHookCount
+	};
+}
+
+//#endregion
+//#region src/plugins/hook-runner-global.ts
+const log = createSubsystemLogger("plugins");
+let globalHookRunner = null;
+let globalRegistry = null;
+/**
+* Initialize the global hook runner with a plugin registry.
+* Called once when plugins are loaded during gateway startup.
+*/
+function initializeGlobalHookRunner(registry) {
+	globalRegistry = registry;
+	globalHookRunner = createHookRunner(registry, {
+		logger: {
+			debug: (msg) => log.debug(msg),
+			warn: (msg) => log.warn(msg),
+			error: (msg) => log.error(msg)
+		},
+		catchErrors: true
+	});
+	const hookCount = registry.hooks.length;
+	if (hookCount > 0) log.info(`hook runner initialized with ${hookCount} registered hooks`);
+}
+/**
+* Get the global hook runner.
+* Returns null if plugins haven't been loaded yet.
+*/
+function getGlobalHookRunner() {
+	return globalHookRunner;
+}
+
+//#endregion
 //#region src/markdown/fences.ts
 function parseFenceSpans(buffer) {
 	const spans = [];
@@ -357,250 +613,35 @@ function resolveMarkdownTableMode(params) {
 }
 
 //#endregion
-//#region src/infra/net/fetch-guard.ts
-const DEFAULT_MAX_REDIRECTS = 3;
-function isRedirectStatus(status) {
-	return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
-}
-function buildAbortSignal(params) {
-	const { timeoutMs, signal } = params;
-	if (!timeoutMs && !signal) return {
-		signal: void 0,
-		cleanup: () => {}
-	};
-	if (!timeoutMs) return {
-		signal,
-		cleanup: () => {}
-	};
-	const controller = new AbortController();
-	const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-	const onAbort = () => controller.abort();
-	if (signal) if (signal.aborted) controller.abort();
-	else signal.addEventListener("abort", onAbort, { once: true });
-	const cleanup = () => {
-		clearTimeout(timeoutId);
-		if (signal) signal.removeEventListener("abort", onAbort);
-	};
-	return {
-		signal: controller.signal,
-		cleanup
-	};
-}
-async function fetchWithSsrFGuard(params) {
-	const fetcher = params.fetchImpl ?? globalThis.fetch;
-	if (!fetcher) throw new Error("fetch is not available");
-	const maxRedirects = typeof params.maxRedirects === "number" && Number.isFinite(params.maxRedirects) ? Math.max(0, Math.floor(params.maxRedirects)) : DEFAULT_MAX_REDIRECTS;
-	const { signal, cleanup } = buildAbortSignal({
-		timeoutMs: params.timeoutMs,
-		signal: params.signal
-	});
-	let released = false;
-	const release = async (dispatcher) => {
-		if (released) return;
-		released = true;
-		cleanup();
-		await closeDispatcher(dispatcher ?? void 0);
-	};
-	const visited = /* @__PURE__ */ new Set();
-	let currentUrl = params.url;
-	let redirectCount = 0;
-	while (true) {
-		let parsedUrl;
-		try {
-			parsedUrl = new URL(currentUrl);
-		} catch {
-			await release();
-			throw new Error("Invalid URL: must be http or https");
-		}
-		if (!["http:", "https:"].includes(parsedUrl.protocol)) {
-			await release();
-			throw new Error("Invalid URL: must be http or https");
-		}
-		let dispatcher = null;
-		try {
-			const pinned = Boolean(params.policy?.allowPrivateNetwork || params.policy?.allowedHostnames?.length) ? await resolvePinnedHostnameWithPolicy(parsedUrl.hostname, {
-				lookupFn: params.lookupFn,
-				policy: params.policy
-			}) : await resolvePinnedHostname(parsedUrl.hostname, params.lookupFn);
-			if (params.pinDns !== false) dispatcher = createPinnedDispatcher(pinned);
-			const init = {
-				...params.init ? { ...params.init } : {},
-				redirect: "manual",
-				...dispatcher ? { dispatcher } : {},
-				...signal ? { signal } : {}
-			};
-			const response = await fetcher(parsedUrl.toString(), init);
-			if (isRedirectStatus(response.status)) {
-				const location = response.headers.get("location");
-				if (!location) {
-					await release(dispatcher);
-					throw new Error(`Redirect missing location header (${response.status})`);
-				}
-				redirectCount += 1;
-				if (redirectCount > maxRedirects) {
-					await release(dispatcher);
-					throw new Error(`Too many redirects (limit: ${maxRedirects})`);
-				}
-				const nextUrl = new URL(location, parsedUrl).toString();
-				if (visited.has(nextUrl)) {
-					await release(dispatcher);
-					throw new Error("Redirect loop detected");
-				}
-				visited.add(nextUrl);
-				response.body?.cancel();
-				await closeDispatcher(dispatcher);
-				currentUrl = nextUrl;
-				continue;
-			}
-			return {
-				response,
-				finalUrl: currentUrl,
-				release: async () => release(dispatcher)
-			};
-		} catch (err) {
-			await release(dispatcher);
-			throw err;
-		}
-	}
-}
-
-//#endregion
-//#region src/media/fetch.ts
-var MediaFetchError = class extends Error {
-	constructor(code, message) {
-		super(message);
-		this.code = code;
-		this.name = "MediaFetchError";
-	}
-};
-function stripQuotes(value) {
-	return value.replace(/^["']|["']$/g, "");
-}
-function parseContentDispositionFileName(header) {
-	if (!header) return;
-	const starMatch = /filename\*\s*=\s*([^;]+)/i.exec(header);
-	if (starMatch?.[1]) {
-		const cleaned = stripQuotes(starMatch[1].trim());
-		const encoded = cleaned.split("''").slice(1).join("''") || cleaned;
-		try {
-			return path.basename(decodeURIComponent(encoded));
-		} catch {
-			return path.basename(encoded);
-		}
-	}
-	const match = /filename\s*=\s*([^;]+)/i.exec(header);
-	if (match?.[1]) return path.basename(stripQuotes(match[1].trim()));
+//#region src/web/media.ts
+function getDefaultLocalRoots() {
+	const home = os.homedir();
+	return [
+		os.tmpdir(),
+		path.join(home, ".openclaw", "media"),
+		path.join(home, ".openclaw", "agents")
+	];
 }
-async function readErrorBodySnippet(res, maxChars = 200) {
+async function assertLocalMediaAllowed(mediaPath, localRoots) {
+	if (localRoots === "any") return;
+	const roots = localRoots ?? getDefaultLocalRoots();
+	let resolved;
 	try {
-		const text = await res.text();
-		if (!text) return;
-		const collapsed = text.replace(/\s+/g, " ").trim();
-		if (!collapsed) return;
-		if (collapsed.length <= maxChars) return collapsed;
-		return `${collapsed.slice(0, maxChars)}…`;
+		resolved = await fs.realpath(mediaPath);
 	} catch {
-		return;
+		resolved = path.resolve(mediaPath);
 	}
-}
-async function fetchRemoteMedia(options) {
-	const { url, fetchImpl, filePathHint, maxBytes, maxRedirects, ssrfPolicy, lookupFn } = options;
-	let res;
-	let finalUrl = url;
-	let release = null;
-	try {
-		const result = await fetchWithSsrFGuard({
-			url,
-			fetchImpl,
-			maxRedirects,
-			policy: ssrfPolicy,
-			lookupFn
-		});
-		res = result.response;
-		finalUrl = result.finalUrl;
-		release = result.release;
-	} catch (err) {
-		throw new MediaFetchError("fetch_failed", `Failed to fetch media from ${url}: ${String(err)}`);
-	}
-	try {
-		if (!res.ok) {
-			const statusText = res.statusText ? ` ${res.statusText}` : "";
-			const redirected = finalUrl !== url ? ` (redirected to ${finalUrl})` : "";
-			let detail = `HTTP ${res.status}${statusText}`;
-			if (!res.body) detail = `HTTP ${res.status}${statusText}; empty response body`;
-			else {
-				const snippet = await readErrorBodySnippet(res);
-				if (snippet) detail += `; body: ${snippet}`;
-			}
-			throw new MediaFetchError("http_error", `Failed to fetch media from ${url}${redirected}: ${detail}`);
-		}
-		const contentLength = res.headers.get("content-length");
-		if (maxBytes && contentLength) {
-			const length = Number(contentLength);
-			if (Number.isFinite(length) && length > maxBytes) throw new MediaFetchError("max_bytes", `Failed to fetch media from ${url}: content length ${length} exceeds maxBytes ${maxBytes}`);
-		}
-		const buffer = maxBytes ? await readResponseWithLimit(res, maxBytes) : Buffer.from(await res.arrayBuffer());
-		let fileNameFromUrl;
+	for (const root of roots) {
+		let resolvedRoot;
 		try {
-			const parsed = new URL(finalUrl);
-			fileNameFromUrl = path.basename(parsed.pathname) || void 0;
-		} catch {}
-		const headerFileName = parseContentDispositionFileName(res.headers.get("content-disposition"));
-		let fileName = headerFileName || fileNameFromUrl || (filePathHint ? path.basename(filePathHint) : void 0);
-		const filePathForMime = headerFileName && path.extname(headerFileName) ? headerFileName : filePathHint ?? finalUrl;
-		const contentType = await detectMime({
-			buffer,
-			headerMime: res.headers.get("content-type"),
-			filePath: filePathForMime
-		});
-		if (fileName && !path.extname(fileName) && contentType) {
-			const ext = extensionForMime(contentType);
-			if (ext) fileName = `${fileName}${ext}`;
-		}
-		return {
-			buffer,
-			contentType: contentType ?? void 0,
-			fileName
-		};
-	} finally {
-		if (release) await release();
-	}
-}
-async function readResponseWithLimit(res, maxBytes) {
-	const body = res.body;
-	if (!body || typeof body.getReader !== "function") {
-		const fallback = Buffer.from(await res.arrayBuffer());
-		if (fallback.length > maxBytes) throw new MediaFetchError("max_bytes", `Failed to fetch media from ${res.url || "response"}: payload exceeds maxBytes ${maxBytes}`);
-		return fallback;
-	}
-	const reader = body.getReader();
-	const chunks = [];
-	let total = 0;
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			if (value?.length) {
-				total += value.length;
-				if (total > maxBytes) {
-					try {
-						await reader.cancel();
-					} catch {}
-					throw new MediaFetchError("max_bytes", `Failed to fetch media from ${res.url || "response"}: payload exceeds maxBytes ${maxBytes}`);
-				}
-				chunks.push(value);
-			}
+			resolvedRoot = await fs.realpath(root);
+		} catch {
+			resolvedRoot = path.resolve(root);
 		}
-	} finally {
-		try {
-			reader.releaseLock();
-		} catch {}
+		if (resolved === resolvedRoot || resolved.startsWith(resolvedRoot + path.sep)) return;
 	}
-	return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)), total);
+	throw new Error(`Local media path is not under an allowed directory: ${mediaPath}`);
 }
-
-//#endregion
-//#region src/web/media.ts
 const HEIC_MIME_RE = /^image\/hei[cf]$/i;
 const HEIC_EXT_RE = /\.(heic|heif)$/i;
 const MB$1 = 1024 * 1024;
@@ -659,7 +700,7 @@ async function optimizeImageWithFallback(params) {
 	};
 }
 async function loadWebMediaInternal(mediaUrl, options = {}) {
-	const { maxBytes, optimizeImages = true, ssrfPolicy } = options;
+	const { maxBytes, optimizeImages = true, ssrfPolicy, localRoots } = options;
 	if (mediaUrl.startsWith("file://")) try {
 		mediaUrl = fileURLToPath(mediaUrl);
 	} catch {
@@ -727,6 +768,7 @@ async function loadWebMediaInternal(mediaUrl, options = {}) {
 		});
 	}
 	if (mediaUrl.startsWith("~")) mediaUrl = resolveUserPath(mediaUrl);
+	await assertLocalMediaAllowed(mediaUrl, localRoots);
 	const data = await fs.readFile(mediaUrl);
 	const mime = await detectMime({
 		buffer: data,
@@ -749,14 +791,16 @@ async function loadWebMedia(mediaUrl, maxBytes, options) {
 	return await loadWebMediaInternal(mediaUrl, {
 		maxBytes,
 		optimizeImages: true,
-		ssrfPolicy: options?.ssrfPolicy
+		ssrfPolicy: options?.ssrfPolicy,
+		localRoots: options?.localRoots
 	});
 }
 async function loadWebMediaRaw(mediaUrl, maxBytes, options) {
 	return await loadWebMediaInternal(mediaUrl, {
 		maxBytes,
 		optimizeImages: false,
-		ssrfPolicy: options?.ssrfPolicy
+		ssrfPolicy: options?.ssrfPolicy,
+		localRoots: options?.localRoots
 	});
 }
 async function optimizeImageToJpeg(buffer, maxBytes, opts = {}) {
@@ -1199,8 +1243,10 @@ function renderTokens(tokens, state) {
 			break;
 		case "blockquote_open":
 			if (state.blockquotePrefix) state.text += state.blockquotePrefix;
+			openStyle(state, "blockquote");
 			break;
 		case "blockquote_close":
+			closeStyle(state, "blockquote");
 			state.text += "\n";
 			break;
 		case "bullet_list_open":
@@ -1516,12 +1562,20 @@ function normalizeMediaSource(src) {
 function cleanCandidate(raw) {
 	return raw.replace(/^[`"'[{(]+/, "").replace(/[`"'\\})\],]+$/, "");
 }
+const WINDOWS_DRIVE_RE = /^[a-zA-Z]:[\\/]/;
+const SCHEME_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+const HAS_FILE_EXT = /\.\w{1,10}$/;
+function isLikelyLocalPath(candidate) {
+	return candidate.startsWith("/") || candidate.startsWith("./") || candidate.startsWith("../") || candidate.startsWith("~") || WINDOWS_DRIVE_RE.test(candidate) || candidate.startsWith("\\\\") || !SCHEME_RE.test(candidate) && (candidate.includes("/") || candidate.includes("\\"));
+}
 function isValidMedia(candidate, opts) {
 	if (!candidate) return false;
 	if (candidate.length > 4096) return false;
 	if (!opts?.allowSpaces && /\s/.test(candidate)) return false;
 	if (/^https?:\/\//i.test(candidate)) return true;
-	return candidate.startsWith("./") && !candidate.includes("..");
+	if (isLikelyLocalPath(candidate)) return true;
+	if (opts?.allowBareFilename && !SCHEME_RE.test(candidate) && HAS_FILE_EXT.test(candidate)) return true;
+	return false;
 }
 function unwrapQuoted(value) {
 	const trimmed = value.trim();
@@ -1583,7 +1637,7 @@ function splitMediaFromOutput(raw) {
 				} else invalidParts.push(part);
 			}
 			const trimmedPayload = payloadValue.trim();
-			const looksLikeLocalPath = trimmedPayload.startsWith("/") || trimmedPayload.startsWith("./") || trimmedPayload.startsWith("../") || trimmedPayload.startsWith("~") || trimmedPayload.startsWith("file://");
+			const looksLikeLocalPath = isLikelyLocalPath(trimmedPayload) || trimmedPayload.startsWith("file://");
 			if (!unwrapped && validCount === 1 && invalidParts.length > 0 && /\s/.test(payloadValue) && looksLikeLocalPath) {
 				const fallback = normalizeMediaSource(cleanCandidate(payloadValue));
 				if (isValidMedia(fallback, { allowSpaces: true })) {
@@ -1596,7 +1650,10 @@ function splitMediaFromOutput(raw) {
 			}
 			if (!hasValidMedia) {
 				const fallback = normalizeMediaSource(cleanCandidate(payloadValue));
-				if (isValidMedia(fallback, { allowSpaces: true })) {
+				if (isValidMedia(fallback, {
+					allowSpaces: true,
+					allowBareFilename: true
+				})) {
 					media.push(fallback);
 					hasValidMedia = true;
 					foundMediaToken = true;
@@ -1605,7 +1662,8 @@ function splitMediaFromOutput(raw) {
 			}
 			if (hasValidMedia) {
 				if (invalidParts.length > 0) pieces.push(invalidParts.join(" "));
-			} else pieces.push(match[0]);
+			} else if (looksLikeLocalPath) foundMediaToken = true;
+			else pieces.push(match[0]);
 			cursor = start + match[0].length;
 		}
 		pieces.push(line.slice(cursor));
@@ -1681,7 +1739,7 @@ function normalizeChannelTargetInput(raw) {
 function normalizeTargetForProvider(provider, raw) {
 	if (!raw) return;
 	const providerId = normalizeChannelId(provider);
-	return ((providerId ? getChannelPlugin(providerId) : void 0)?.messaging?.normalizeTarget?.(raw) ?? (raw.trim().toLowerCase() || void 0)) || void 0;
+	return ((providerId ? getChannelPlugin(providerId) : void 0)?.messaging?.normalizeTarget?.(raw) ?? (raw.trim() || void 0)) || void 0;
 }
 function buildTargetResolverSignature(channel) {
 	const resolver = getChannelPlugin(channel)?.messaging?.targetResolver;
@@ -1928,31 +1986,6 @@ function resolveFetch(fetchImpl) {
 	return wrapFetchWithAbortSignal(resolved);
 }
 
-//#endregion
-//#region src/utils/fetch-timeout.ts
-/**
-* Fetch wrapper that adds timeout support via AbortController.
-*
-* @param url - The URL to fetch
-* @param init - RequestInit options (headers, method, body, etc.)
-* @param timeoutMs - Timeout in milliseconds
-* @param fetchFn - The fetch implementation to use (defaults to global fetch)
-* @returns The fetch Response
-* @throws AbortError if the request times out
-*/
-async function fetchWithTimeout(url, init, timeoutMs, fetchFn = fetch) {
-	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), Math.max(1, timeoutMs));
-	try {
-		return await fetchFn(url, {
-			...init,
-			signal: controller.signal
-		});
-	} finally {
-		clearTimeout(timer);
-	}
-}
-
 //#endregion
 //#region src/signal/client.ts
 const DEFAULT_TIMEOUT_MS = 1e4;
@@ -2564,23 +2597,80 @@ async function deliverOutboundPayloads(params) {
 			})
 		};
 	};
-	const normalizedPayloads = normalizeReplyPayloadsForDelivery(payloads);
+	const normalizeWhatsAppPayload = (payload) => {
+		const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+		const normalizedText = (typeof payload.text === "string" ? payload.text : "").replace(/^(?:[ \t]*\r?\n)+/, "");
+		if (!normalizedText.trim()) {
+			if (!hasMedia) return null;
+			return {
+				...payload,
+				text: ""
+			};
+		}
+		return {
+			...payload,
+			text: normalizedText
+		};
+	};
+	const normalizedPayloads = normalizeReplyPayloadsForDelivery(payloads).flatMap((payload) => {
+		if (channel !== "whatsapp") return [payload];
+		const normalized = normalizeWhatsAppPayload(payload);
+		return normalized ? [normalized] : [];
+	});
+	const hookRunner = getGlobalHookRunner();
 	for (const payload of normalizedPayloads) {
 		const payloadSummary = {
 			text: payload.text ?? "",
 			mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []),
 			channelData: payload.channelData
 		};
+		const emitMessageSent = (success, error) => {
+			if (!hookRunner?.hasHooks("message_sent")) return;
+			hookRunner.runMessageSent({
+				to,
+				content: payloadSummary.text,
+				success,
+				...error ? { error } : {}
+			}, {
+				channelId: channel,
+				accountId: accountId ?? void 0
+			}).catch(() => {});
+		};
 		try {
 			throwIfAborted(abortSignal);
+			let effectivePayload = payload;
+			if (hookRunner?.hasHooks("message_sending")) try {
+				const sendingResult = await hookRunner.runMessageSending({
+					to,
+					content: payloadSummary.text,
+					metadata: {
+						channel,
+						accountId,
+						mediaUrls: payloadSummary.mediaUrls
+					}
+				}, {
+					channelId: channel,
+					accountId: accountId ?? void 0
+				});
+				if (sendingResult?.cancel) continue;
+				if (sendingResult?.content != null) {
+					effectivePayload = {
+						...payload,
+						text: sendingResult.content
+					};
+					payloadSummary.text = sendingResult.content;
+				}
+			} catch {}
 			params.onPayload?.(payloadSummary);
-			if (handler.sendPayload && payload.channelData) {
-				results.push(await handler.sendPayload(payload));
+			if (handler.sendPayload && effectivePayload.channelData) {
+				results.push(await handler.sendPayload(effectivePayload));
+				emitMessageSent(true);
 				continue;
 			}
 			if (payloadSummary.mediaUrls.length === 0) {
 				if (isSignalChannel) await sendSignalTextChunks(payloadSummary.text);
 				else await sendTextChunks(payloadSummary.text);
+				emitMessageSent(true);
 				continue;
 			}
 			let first = true;
@@ -2591,7 +2681,9 @@ async function deliverOutboundPayloads(params) {
 				if (isSignalChannel) results.push(await sendSignalMedia(caption, url));
 				else results.push(await handler.sendMedia(caption, url));
 			}
+			emitMessageSent(true);
 		} catch (err) {
+			emitMessageSent(false, err instanceof Error ? err.message : String(err));
 			if (!params.bestEffort) throw err;
 			params.onError?.(err, payloadSummary);
 		}
@@ -2611,4 +2703,4 @@ async function deliverOutboundPayloads(params) {
 }
 
 //#endregion
-export { HEARTBEAT_TOKEN as A, fetchWithSsrFGuard as B, buildTargetResolverSignature as C, parseReplyDirectives as D, throwIfAborted as E, markdownToIRWithMeta as F, chunkText as G, chunkByNewline as H, loadWebMedia as I, resolveTextChunkLimit as J, chunkTextWithMode as K, loadWebMediaRaw as L, isSilentReplyText as M, chunkMarkdownIR as N, splitMediaFromOutput as O, markdownToIR as P, MediaFetchError as R, wrapFetchWithAbortSignal as S, normalizeTargetForProvider as T, chunkMarkdownText as U, resolveMarkdownTableMode as V, chunkMarkdownTextWithMode as W, isSafeFenceBreak as X, findFenceSpanAt as Y, parseFenceSpans as Z, signalCheck as _, normalizeOutboundPayloadsForJson as a, fetchWithTimeout as b, applyReplyThreading as c, shouldSuppressMessagingToolReplies as d, createReplyToModeFilterForChannel as f, sendTypingSignal as g, sendReadReceiptSignal as h, normalizeOutboundPayloads as i, SILENT_REPLY_TOKEN as j, parseInlineDirectives as k, filterMessagingToolDuplicates as l, sendMessageSignal as m, deliver_exports as n, normalizeReplyPayloadsForDelivery as o, resolveReplyToMode as p, resolveChunkMode as q, formatOutboundPayloadLog as r, applyReplyTagsToPayload as s, deliverOutboundPayloads as t, isRenderablePayload as u, signalRpcRequest as v, normalizeChannelTargetInput as w, resolveFetch as x, streamSignalEvents as y, fetchRemoteMedia as z };
+export { SILENT_REPLY_TOKEN as A, chunkMarkdownTextWithMode as B, normalizeChannelTargetInput as C, splitMediaFromOutput as D, parseReplyDirectives as E, loadWebMedia as F, findFenceSpanAt as G, chunkTextWithMode as H, loadWebMediaRaw as I, getGlobalHookRunner as J, isSafeFenceBreak as K, resolveMarkdownTableMode as L, chunkMarkdownIR as M, markdownToIR as N, parseInlineDirectives as O, markdownToIRWithMeta as P, chunkByNewline as R, buildTargetResolverSignature as S, throwIfAborted as T, resolveChunkMode as U, chunkText as V, resolveTextChunkLimit as W, initializeGlobalHookRunner as Y, signalCheck as _, normalizeOutboundPayloadsForJson as a, resolveFetch as b, applyReplyThreading as c, shouldSuppressMessagingToolReplies as d, createReplyToModeFilterForChannel as f, sendTypingSignal as g, sendReadReceiptSignal as h, normalizeOutboundPayloads as i, isSilentReplyText as j, HEARTBEAT_TOKEN as k, filterMessagingToolDuplicates as l, sendMessageSignal as m, deliver_exports as n, normalizeReplyPayloadsForDelivery as o, resolveReplyToMode as p, parseFenceSpans as q, formatOutboundPayloadLog as r, applyReplyTagsToPayload as s, deliverOutboundPayloads as t, isRenderablePayload as u, signalRpcRequest as v, normalizeTargetForProvider as w, wrapFetchWithAbortSignal as x, streamSignalEvents as y, chunkMarkdownText as z };