remoteclaw 0.0.0 → 0.0.1

package/dist/targets-BegO82oK.js

@@ -0,0 +1,2614 @@
+import { n as normalizeVerboseLevel } from "./thinking-4nOZPunr.js";
+import { h as normalizeAnyChannelId } from "./subsystem-BAW_f3DI.js";
+import { i as defaultRuntime } from "./ansi-DtaiOnt1.js";
+import { h as normalizeAccountId, v as deriveSessionChatType } from "./session-key-CgKWfjoZ.js";
+import { a as normalizeProviderId } from "./provider-utils-C9kBVF1f.js";
+import { c as normalizeMessageChannel, n as isDeliverableMessageChannel, t as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-CtcVHawF.js";
+import { t as parseDiscordTarget } from "./targets-BpTQ50aN.js";
+import { t as getChannelDock } from "./dock-Hf1acwVy.js";
+import { a as isWhatsAppGroupJid, o as normalizeWhatsAppTarget, r as normalizeChannelId, t as getChannelPlugin } from "./plugins-Cjhc9NMf.js";
+import { t as normalizeChatType } from "./chat-type-BP9akbag.js";
+import { t as formatCliCommand } from "./command-format-Dntg_tnC.js";
+import { t as SILENT_REPLY_TOKEN } from "./tokens-TtJJxzRr.js";
+import { p as getGlobalHookRunner } from "./reply-payloads-DDrMOUKP.js";
+import { t as parseSlackTarget } from "./targets-_UWmnyI9.js";
+import { d as deliveryContextFromSession } from "./store-BmUyjVdV.js";
+import { n as extensionForMime$1, t as detectMime } from "./mime-CAqaK3kp.js";
+import { t as logDebug } from "./logger-ASsO5Nz-.js";
+import { n as fetchRemoteMedia } from "./fetch-BMQq41sB.js";
+import { i as resolveTelegramTargetChatType, r as parseTelegramTarget } from "./targets-BtGRUQMa.js";
+import { n as missingTargetError } from "./target-errors-ChjvOMuV.js";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdir, mkdtemp, readFile, readdir, rm, rmdir, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { execFileSync, spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+
+//#region src/sessions/send-policy.ts
+function normalizeSendPolicy(raw) {
+	const value = raw?.trim().toLowerCase();
+	if (value === "allow") return "allow";
+	if (value === "deny") return "deny";
+}
+function normalizeMatchValue(raw) {
+	const value = raw?.trim().toLowerCase();
+	return value ? value : void 0;
+}
+function stripAgentSessionKeyPrefix(key) {
+	if (!key) return;
+	const parts = key.split(":").filter(Boolean);
+	if (parts.length >= 3 && parts[0] === "agent") return parts.slice(2).join(":");
+	return key;
+}
+function deriveChannelFromKey(key) {
+	const normalizedKey = stripAgentSessionKeyPrefix(key);
+	if (!normalizedKey) return;
+	const parts = normalizedKey.split(":").filter(Boolean);
+	if (parts.length >= 3 && (parts[1] === "group" || parts[1] === "channel")) return normalizeMatchValue(parts[0]);
+}
+function deriveChatTypeFromKey(key) {
+	const chatType = deriveSessionChatType(key);
+	return chatType === "unknown" ? void 0 : chatType;
+}
+function resolveSendPolicy(params) {
+	const override = normalizeSendPolicy(params.entry?.sendPolicy);
+	if (override) return override;
+	const policy = params.cfg.session?.sendPolicy;
+	if (!policy) return "allow";
+	const channel = normalizeMatchValue(params.channel) ?? normalizeMatchValue(params.entry?.channel) ?? normalizeMatchValue(params.entry?.lastChannel) ?? deriveChannelFromKey(params.sessionKey);
+	const chatType = normalizeChatType(params.chatType ?? params.entry?.chatType) ?? normalizeChatType(deriveChatTypeFromKey(params.sessionKey));
+	const rawSessionKey = params.sessionKey ?? "";
+	const strippedSessionKey = stripAgentSessionKeyPrefix(rawSessionKey) ?? "";
+	const rawSessionKeyNorm = rawSessionKey.toLowerCase();
+	const strippedSessionKeyNorm = strippedSessionKey.toLowerCase();
+	let allowedMatch = false;
+	for (const rule of policy.rules ?? []) {
+		if (!rule) continue;
+		const action = normalizeSendPolicy(rule.action) ?? "allow";
+		const match = rule.match ?? {};
+		const matchChannel = normalizeMatchValue(match.channel);
+		const matchChatType = normalizeChatType(match.chatType);
+		const matchPrefix = normalizeMatchValue(match.keyPrefix);
+		const matchRawPrefix = normalizeMatchValue(match.rawKeyPrefix);
+		if (matchChannel && matchChannel !== channel) continue;
+		if (matchChatType && matchChatType !== chatType) continue;
+		if (matchRawPrefix && !rawSessionKeyNorm.startsWith(matchRawPrefix)) continue;
+		if (matchPrefix && !rawSessionKeyNorm.startsWith(matchPrefix) && !strippedSessionKeyNorm.startsWith(matchPrefix)) continue;
+		if (action === "deny") return "deny";
+		allowedMatch = true;
+	}
+	if (allowedMatch) return "allow";
+	return normalizeSendPolicy(policy.default) ?? "allow";
+}
+
+//#endregion
+//#region src/sessions/level-overrides.ts
+function parseVerboseOverride(raw) {
+	if (raw === null) return {
+		ok: true,
+		value: null
+	};
+	if (raw === void 0) return {
+		ok: true,
+		value: void 0
+	};
+	if (typeof raw !== "string") return {
+		ok: false,
+		error: "invalid verboseLevel (use \"on\"|\"off\")"
+	};
+	const normalized = normalizeVerboseLevel(raw);
+	if (!normalized) return {
+		ok: false,
+		error: "invalid verboseLevel (use \"on\"|\"off\")"
+	};
+	return {
+		ok: true,
+		value: normalized
+	};
+}
+function applyVerboseOverride(entry, level) {
+	if (level === void 0) return;
+	if (level === null) {
+		delete entry.verboseLevel;
+		return;
+	}
+	entry.verboseLevel = level;
+}
+
+//#endregion
+//#region src/infra/system-events.ts
+const MAX_EVENTS = 20;
+const queues = /* @__PURE__ */ new Map();
+function requireSessionKey(key) {
+	const trimmed = typeof key === "string" ? key.trim() : "";
+	if (!trimmed) throw new Error("system events require a sessionKey");
+	return trimmed;
+}
+function normalizeContextKey(key) {
+	if (!key) return null;
+	const trimmed = key.trim();
+	if (!trimmed) return null;
+	return trimmed.toLowerCase();
+}
+function isSystemEventContextChanged(sessionKey, contextKey) {
+	const key = requireSessionKey(sessionKey);
+	const existing = queues.get(key);
+	return normalizeContextKey(contextKey) !== (existing?.lastContextKey ?? null);
+}
+function enqueueSystemEvent(text, options) {
+	const key = requireSessionKey(options?.sessionKey);
+	const entry = queues.get(key) ?? (() => {
+		const created = {
+			queue: [],
+			lastText: null,
+			lastContextKey: null
+		};
+		queues.set(key, created);
+		return created;
+	})();
+	const cleaned = text.trim();
+	if (!cleaned) return;
+	const normalizedContextKey = normalizeContextKey(options?.contextKey);
+	entry.lastContextKey = normalizedContextKey;
+	if (entry.lastText === cleaned) return;
+	entry.lastText = cleaned;
+	entry.queue.push({
+		text: cleaned,
+		ts: Date.now(),
+		contextKey: normalizedContextKey
+	});
+	if (entry.queue.length > MAX_EVENTS) entry.queue.shift();
+}
+function drainSystemEventEntries(sessionKey) {
+	const key = requireSessionKey(sessionKey);
+	const entry = queues.get(key);
+	if (!entry || entry.queue.length === 0) return [];
+	const out = entry.queue.slice();
+	entry.queue.length = 0;
+	entry.lastText = null;
+	entry.lastContextKey = null;
+	queues.delete(key);
+	return out;
+}
+function peekSystemEventEntries(sessionKey) {
+	const key = requireSessionKey(sessionKey);
+	return queues.get(key)?.queue.map((event) => ({ ...event })) ?? [];
+}
+function peekSystemEvents(sessionKey) {
+	return peekSystemEventEntries(sessionKey).map((event) => event.text);
+}
+
+//#endregion
+//#region src/agents/channel-tools.ts
+/**
+* Get the list of supported message actions for a specific channel.
+* Returns an empty array if channel is not found or has no actions configured.
+*/
+function listChannelSupportedActions(params) {
+	if (!params.channel) return [];
+	const plugin = getChannelPlugin(params.channel);
+	if (!plugin?.actions?.listActions) return [];
+	return runPluginListActions(plugin, params.cfg ?? {});
+}
+function resolveChannelMessageToolHints(params) {
+	const channelId = normalizeAnyChannelId(params.channel);
+	if (!channelId) return [];
+	const resolve = getChannelDock(channelId)?.agentPrompt?.messageToolHints;
+	if (!resolve) return [];
+	return (resolve({
+		cfg: params.cfg ?? {},
+		accountId: params.accountId
+	}) ?? []).map((entry) => entry.trim()).filter(Boolean);
+}
+const loggedListActionErrors = /* @__PURE__ */ new Set();
+function runPluginListActions(plugin, cfg) {
+	if (!plugin.actions?.listActions) return [];
+	try {
+		const listed = plugin.actions.listActions({ cfg });
+		return Array.isArray(listed) ? listed : [];
+	} catch (err) {
+		logListActionsError(plugin.id, err);
+		return [];
+	}
+}
+function logListActionsError(pluginId, err) {
+	const message = err instanceof Error ? err.message : String(err);
+	const key = `${pluginId}:${message}`;
+	if (loggedListActionErrors.has(key)) return;
+	loggedListActionErrors.add(key);
+	const details = (err instanceof Error && err.stack ? err.stack : null) ?? message;
+	defaultRuntime.error?.(`[channel-tools] ${pluginId}.actions.listActions failed: ${details}`);
+}
+
+//#endregion
+//#region src/middleware/error-classifier.ts
+const retryablePatterns = [
+	/rate.?limit/i,
+	/429/i,
+	/503/i,
+	/overloaded/i,
+	/ETIMEDOUT/i,
+	/ECONNRESET/i,
+	/ECONNREFUSED/i,
+	/network/i
+];
+const contextOverflowPatterns = [
+	/context.?length/i,
+	/context.?window/i,
+	/context.?overflow/i,
+	/too many tokens/i,
+	/maximum context/i,
+	/token.?limit/i
+];
+const fatalAuthPatterns = [
+	/401/i,
+	/403/i,
+	/unauthorized/i,
+	/forbidden/i,
+	/invalid.?key/i,
+	/authentication/i
+];
+/**
+* Rate-limit and auth failure patterns that may benefit from key rotation.
+*
+* Includes rate-limit indicators (429, quota) and auth failures
+* (401, invalid key) — a different API key might succeed in either case.
+*/
+const authRotatablePatterns = [
+	/rate.?limit/i,
+	/\b429\b/,
+	/quota.?exceeded/i,
+	/resource.?exhausted/i,
+	/too many requests/i,
+	/\b401\b/,
+	/unauthorized/i,
+	/invalid.?key/i
+];
+/**
+* Test whether an error message indicates a rate-limit or auth failure
+* that could be resolved by rotating to a different API key.
+*/
+function isAuthRotatableError(message) {
+	return authRotatablePatterns.some((pattern) => pattern.test(message));
+}
+/**
+* Classify an error message string into an actionable category.
+*
+* Uses first-match-wins semantics across ordered pattern arrays:
+* 1. Retryable patterns checked first
+* 2. Context overflow patterns checked second
+* 3. Fatal auth patterns checked third
+* 4. Default: "fatal" for unmatched messages
+*
+* Case-insensitive matching throughout.
+*/
+function classifyError(message) {
+	for (const pattern of retryablePatterns) if (pattern.test(message)) {
+		logDebug(`[error-classifier] classified as retryable: ${message.slice(0, 200)}`);
+		return "retryable";
+	}
+	for (const pattern of contextOverflowPatterns) if (pattern.test(message)) {
+		logDebug(`[error-classifier] classified as context_overflow: ${message.slice(0, 200)}`);
+		return "context_overflow";
+	}
+	for (const pattern of fatalAuthPatterns) if (pattern.test(message)) {
+		logDebug(`[error-classifier] classified as fatal (auth): ${message.slice(0, 200)}`);
+		return "fatal";
+	}
+	logDebug(`[error-classifier] classified as fatal (unmatched): ${message.slice(0, 200)}`);
+	return "fatal";
+}
+
+//#endregion
+//#region src/middleware/delivery-adapter.ts
+const DEFAULT_CHUNK_LIMIT = 4e3;
+/**
+* Converts AgentEvent async iterable into channel-deliverable ReplyPayload chunks.
+*
+* Handles:
+* - Text accumulation and chunking at channel limits
+* - Progressive streaming via BridgeCallbacks
+* - Tool result formatting
+* - Error event formatting
+*/
+var DeliveryAdapter = class {
+	constructor(options) {
+		this.chunkLimit = options?.chunkLimit ?? DEFAULT_CHUNK_LIMIT;
+	}
+	/**
+	* Process an event stream, invoking callbacks for real-time delivery
+	* and returning final payloads for post-execution delivery.
+	*
+	* @param events - AgentEvent async iterable from runtime.execute()
+	* @param callbacks - Optional streaming callbacks for real-time delivery
+	* @returns Final ReplyPayload array for post-execution delivery
+	*/
+	async process(events, callbacks) {
+		let textBuffer = "";
+		const payloads = [];
+		/** Track media delivered via streaming events to avoid duplicates from result.media. */
+		const deliveredMediaKeys = /* @__PURE__ */ new Set();
+		let eventCount = 0;
+		for await (const event of events) {
+			eventCount++;
+			switch (event.type) {
+				case "text":
+					if (event.text === "") break;
+					textBuffer += event.text;
+					while (textBuffer.length > this.chunkLimit) {
+						const { chunk, rest } = splitAtBoundary(textBuffer, this.chunkLimit);
+						textBuffer = rest;
+						const payload = { text: chunk };
+						payloads.push(payload);
+						await callbacks?.onPartialReply?.(payload);
+					}
+					break;
+				case "media": {
+					const mediaUrl = event.media.filePath ?? event.media.sourceUrl;
+					if (mediaUrl) {
+						if (textBuffer.length > 0) {
+							const textPayload = { text: textBuffer };
+							payloads.push(textPayload);
+							await callbacks?.onBlockReply?.(textPayload);
+							textBuffer = "";
+						}
+						deliveredMediaKeys.add(mediaUrl);
+						const payload = { mediaUrl };
+						payloads.push(payload);
+						await callbacks?.onBlockReply?.(payload);
+					}
+					break;
+				}
+				case "thinking":
+					if (event.text) callbacks?.onThinking?.({ text: event.text });
+					break;
+				case "tool_use": break;
+				case "tool_result": {
+					const payload = { text: formatToolResult(event.toolId, event.output, event.isError) };
+					await callbacks?.onToolResult?.(payload);
+					break;
+				}
+				case "error": {
+					const payload = {
+						text: event.code ? `[${event.code}] ${event.message}` : event.message,
+						isError: true
+					};
+					payloads.push(payload);
+					await callbacks?.onBlockReply?.(payload);
+					break;
+				}
+				case "done":
+					if (textBuffer.length > 0) {
+						const payload = { text: textBuffer };
+						payloads.push(payload);
+						await callbacks?.onBlockReply?.(payload);
+						textBuffer = "";
+					}
+					if (event.result.media?.length) for (const media of event.result.media) {
+						const url = media.filePath ?? media.sourceUrl;
+						if (url && !deliveredMediaKeys.has(url)) {
+							const payload = { mediaUrl: url };
+							payloads.push(payload);
+							await callbacks?.onBlockReply?.(payload);
+						}
+					}
+					break;
+			}
+		}
+		if (textBuffer.length > 0) {
+			const payload = { text: textBuffer };
+			payloads.push(payload);
+		}
+		logDebug(`[delivery-adapter] processed ${eventCount} events into ${payloads.length} payloads (chunkLimit=${this.chunkLimit})`);
+		return payloads;
+	}
+};
+/** Format a tool result for display. */
+function formatToolResult(toolId, output, isError) {
+	return `${isError ? `Tool ${toolId} error` : `Tool ${toolId} result`}: ${output}`;
+}
+/**
+* Split text at the nearest safe boundary before the limit.
+*
+* Preference order:
+* 1. Paragraph break (\n\n)
+* 2. Line break (\n)
+* 3. Word boundary (space)
+* 4. Hard split at limit
+*
+* Markdown-aware: preserves code fence boundaries by closing/reopening
+* fences at split points when a split occurs inside a fenced code block.
+*/
+function splitAtBoundary(text, limit) {
+	const fenceInfo = findOpenCodeFence(text, limit);
+	if (fenceInfo !== void 0) {
+		const beforeFence = text.substring(0, fenceInfo.fenceStart);
+		if (beforeFence.trimEnd().length > 0) {
+			const trimmed = beforeFence.trimEnd();
+			return {
+				chunk: trimmed,
+				rest: text.substring(trimmed.length).trimStart()
+			};
+		}
+		const closingFence = `\n${fenceInfo.fence}`;
+		const openingFence = `${fenceInfo.fence}\n`;
+		const splitPoint = findSplitPoint(text, limit - closingFence.length);
+		return {
+			chunk: text.substring(0, splitPoint) + closingFence,
+			rest: openingFence + text.substring(splitPoint)
+		};
+	}
+	const splitPoint = findSplitPoint(text, limit);
+	return {
+		chunk: text.substring(0, splitPoint),
+		rest: text.substring(splitPoint)
+	};
+}
+/** Find the best split point within the text up to the given limit. */
+function findSplitPoint(text, limit) {
+	if (limit <= 0) return Math.min(1, text.length);
+	const searchRegion = text.substring(0, limit);
+	const paragraphIdx = searchRegion.lastIndexOf("\n\n");
+	if (paragraphIdx > 0) return paragraphIdx + 2;
+	const lineIdx = searchRegion.lastIndexOf("\n");
+	if (lineIdx > 0) return lineIdx + 1;
+	const spaceIdx = searchRegion.lastIndexOf(" ");
+	if (spaceIdx > 0) return spaceIdx + 1;
+	return limit;
+}
+/**
+* Detect if the text has an unclosed code fence at or before the limit position.
+* Returns info about the open fence, or undefined if no open fence.
+*/
+function findOpenCodeFence(text, limit) {
+	const fenceRegex = /^(`{3,}|~{3,})/gm;
+	let openFence;
+	let match;
+	while ((match = fenceRegex.exec(text)) !== null) {
+		if (match.index >= limit) break;
+		if (openFence === void 0) openFence = {
+			fenceStart: match.index,
+			fence: match[1]
+		};
+		else if (match[1].charAt(0) === openFence.fence.charAt(0) && match[1].length >= openFence.fence.length) openFence = void 0;
+	}
+	return openFence;
+}
+
+//#endregion
+//#region src/middleware/mcp-side-effects.ts
+async function readMcpSideEffects(filePath) {
+	const result = {
+		sentTexts: [],
+		sentMediaUrls: [],
+		sentTargets: [],
+		cronAdds: 0
+	};
+	let content;
+	try {
+		content = await readFile(filePath, "utf-8");
+	} catch {
+		return result;
+	}
+	const lines = content.split("\n").filter(Boolean);
+	for (const line of lines) {
+		let record;
+		try {
+			record = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (record.type === "message_sent") {
+			result.sentTexts.push(record.text);
+			if (record.mediaUrl) result.sentMediaUrls.push(record.mediaUrl);
+			const target = {
+				tool: record.tool,
+				provider: record.provider,
+				...record.accountId ? { accountId: record.accountId } : {},
+				...record.to ? { to: record.to } : {}
+			};
+			result.sentTargets.push(target);
+		} else if (record.type === "cron_added") result.cronAdds += 1;
+		else if (record.type === "heartbeat_report") result.heartbeatReport = {
+			anythingDone: record.anythingDone,
+			summary: record.summary
+		};
+	}
+	return result;
+}
+
+//#endregion
+//#region src/middleware/media-capability.ts
+/**
+* Partition media attachments by whether the runtime accepts them.
+*
+* If the runtime does not declare `mediaCapabilities` at all, all media is
+* treated as supported (backwards-compatible — the runtime decides what to do).
+*/
+function partitionMedia(runtime, media) {
+	const prefixes = runtime.mediaCapabilities?.acceptsInbound;
+	if (prefixes === void 0) return {
+		supported: media,
+		unsupported: []
+	};
+	const supported = [];
+	const unsupported = [];
+	for (const attachment of media) if (prefixes.some((prefix) => attachment.mimeType.startsWith(prefix))) supported.push(attachment);
+	else unsupported.push(attachment);
+	return {
+		supported,
+		unsupported
+	};
+}
+/**
+* Format a user-facing warning for media the runtime cannot handle.
+*
+* Returns `undefined` when there are no unsupported attachments.
+*/
+function formatUnsupportedMediaWarning(unsupported, runtimeName) {
+	if (unsupported.length === 0) return;
+	const typeSummary = summarizeMediaTypes(unsupported);
+	const runtimeLabel = runtimeName.toLowerCase();
+	if (unsupported.length === 1) return `\u26a0\ufe0f Your ${typeSummary} was received but the current runtime (${runtimeLabel}) doesn't support ${typeSummary} input. Its content was not included in the conversation.`;
+	return `\u26a0\ufe0f ${unsupported.length} media attachments were received but the current runtime (${runtimeLabel}) doesn't support them: ${typeSummary}. Their content was not included in the conversation.`;
+}
+/**
+* Produce a human-readable summary of MIME type categories.
+*
+* Groups by top-level type (image, audio, video) and deduplicates.
+* Falls back to "media" for unknown types.
+*/
+function summarizeMediaTypes(attachments) {
+	const categories = /* @__PURE__ */ new Set();
+	for (const a of attachments) switch (a.mimeType.split("/")[0]) {
+		case "image":
+			categories.add("image");
+			break;
+		case "audio":
+			categories.add("audio");
+			break;
+		case "video":
+			categories.add("video");
+			break;
+		default:
+			categories.add("media");
+			break;
+	}
+	return [...categories].toSorted().join("/");
+}
+
+//#endregion
+//#region src/middleware/media-resolver.ts
+/** Max download size for inbound channel media (100 MB). */
+const MAX_INBOUND_MEDIA_BYTES = 100 * 1024 * 1024;
+/**
+* Resolve an array of media URLs (HTTP or local paths) into MediaAttachment
+* objects suitable for passing to {@link AgentRuntime.execute}.
+*
+* Remote URLs are downloaded into `tempDir` so that CLI runtimes can access
+* them as local files.  Local paths are validated for MIME type only.
+*
+* Individual resolution failures are silently skipped — a single bad URL
+* should not prevent the rest of the message from being processed.
+*/
+async function resolveMediaAttachments(mediaUrls, tempDir) {
+	const results = [];
+	for (const [index, url] of mediaUrls.entries()) try {
+		const attachment = await resolveOne(url, tempDir, index);
+		if (attachment) {
+			logDebug(`[media-resolver] resolved: url=${url} mime=${attachment.mimeType} path=${attachment.filePath}`);
+			results.push(attachment);
+		}
+	} catch (err) {
+		logDebug(`[media-resolver] failed: url=${url} error=${String(err)}`);
+	}
+	return results;
+}
+async function resolveOne(url, tempDir, index) {
+	if (/^https?:\/\//i.test(url)) return downloadRemote(url, tempDir, index);
+	return resolveLocal(url);
+}
+async function downloadRemote(url, tempDir, index) {
+	const fetched = await fetchRemoteMedia({
+		url,
+		maxBytes: MAX_INBOUND_MEDIA_BYTES
+	});
+	const mimeType = fetched.contentType ?? "application/octet-stream";
+	const fileName = `inbound-media-${index}${extensionForMime$1(mimeType) ?? ""}`;
+	const filePath = join(tempDir, fileName);
+	await writeFile(filePath, fetched.buffer);
+	return {
+		mimeType,
+		filePath,
+		sourceUrl: url,
+		fileName: fetched.fileName ?? fileName
+	};
+}
+async function resolveLocal(filePath) {
+	return {
+		mimeType: await detectMime({ filePath }) ?? "application/octet-stream",
+		filePath
+	};
+}
+
+//#endregion
+//#region src/middleware/cli-runtime-base.ts
+/**
+* Abstract base class encapsulating shared subprocess machinery for CLI-based agent runtimes.
+*
+* Concrete runtimes (Claude, Gemini, Codex, OpenCode) extend this and implement only
+* the CLI-specific parts: argument construction, event extraction, and environment setup.
+*/
+var CLIRuntimeBase = class CLIRuntimeBase {
+	static {
+		this.STDIN_PROMPT_THRESHOLD = 1e4;
+	}
+	constructor(command, timeoutMs = 3e5) {
+		this.command = command;
+		this.timeoutMs = timeoutMs;
+	}
+	/**
+	* Compose the full prompt from structured parts (system + extra context + user).
+	* Runtimes that support separate system prompt delivery (e.g. Claude) should
+	* override or bypass this and handle the parts individually.
+	*/
+	composePrompt(params) {
+		let composed = "";
+		if (params.systemPrompt) composed += params.systemPrompt;
+		if (params.extraContext) composed += (composed ? "\n\n" : "") + params.extraContext;
+		if (params.threadContext && !params.sessionId) composed += (composed ? "\n\n" : "") + params.threadContext;
+		composed += (composed ? "\n\n" : "") + params.prompt;
+		return composed;
+	}
+	/**
+	* Construct a custom stdin payload for the subprocess.
+	* When this returns a string, it is written to stdin instead of
+	* the default large-prompt fallback.  Subclasses may override.
+	*/
+	buildStdinPayload(_params) {}
+	/** Whether this CLI accepts prompts via stdin. Subclasses may override. */
+	get supportsStdinPrompt() {
+		return true;
+	}
+	/**
+	* Which subprocess stream carries NDJSON output.
+	* Defaults to `"stdout"`. Override to `"stderr"` for CLIs (like Claude)
+	* that emit structured output on stderr.
+	*/
+	get ndjsonStream() {
+		return "stdout";
+	}
+	async *execute(params) {
+		const args = this.buildArgs(params);
+		if (params.extraArgs && params.extraArgs.length > 0) args.push(...params.extraArgs);
+		const runtimeEnv = this.buildEnv(params);
+		const callerEnv = params.env ?? {};
+		const env = {
+			...process.env,
+			...runtimeEnv,
+			...callerEnv
+		};
+		logDebug(`[agent-runtime] spawn: ${this.command} ${args.map((a) => JSON.stringify(a)).join(" ")}`);
+		logDebug(`[agent-runtime] cwd: ${params.workingDirectory ?? process.cwd()}`);
+		if (Object.keys(runtimeEnv).length > 0) logDebug(`[agent-runtime] runtime env keys: ${Object.keys(runtimeEnv).join(", ")}`);
+		if (Object.keys(callerEnv).length > 0) logDebug(`[agent-runtime] caller env keys: ${Object.keys(callerEnv).join(", ")}`);
+		const child = spawn(this.command, args, {
+			cwd: params.workingDirectory,
+			env,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		logDebug(`[agent-runtime] spawned pid=${child.pid}`);
+		const startMs = Date.now();
+		const stderrChunks = [];
+		let aborted = false;
+		let yieldedEvents = false;
+		let escalationTimer;
+		const killWithEscalation = () => {
+			if (escalationTimer === void 0) escalationTimer = setTimeout(() => {
+				try {
+					child.kill("SIGKILL");
+				} catch {}
+			}, 1500);
+			child.kill("SIGTERM");
+		};
+		child.on("exit", () => {
+			if (escalationTimer !== void 0) {
+				clearTimeout(escalationTimer);
+				escalationTimer = void 0;
+			}
+		});
+		let startupTimer;
+		let startupTimedOut = false;
+		startupTimer = setTimeout(() => {
+			startupTimedOut = true;
+			logDebug(`[agent-runtime] pid=${child.pid}: startup timeout — no output within ${this.timeoutMs}ms`);
+			killWithEscalation();
+		}, this.timeoutMs);
+		const ndjsonSource = this.ndjsonStream === "stderr" ? child.stderr : child.stdout;
+		(this.ndjsonStream === "stderr" ? child.stdout : child.stderr)?.on("data", (chunk) => {
+			stderrChunks.push(chunk.toString());
+		});
+		const rl = createInterface({ input: ndjsonSource });
+		const eventQueue = [];
+		let resolveNext;
+		let streamDone = false;
+		const enqueue = (event) => {
+			eventQueue.push(event);
+			resolveNext?.();
+		};
+		rl.on("line", (line) => {
+			if (startupTimer !== void 0) {
+				clearTimeout(startupTimer);
+				startupTimer = void 0;
+			}
+			if (!line.trim()) return;
+			try {
+				JSON.parse(line);
+			} catch {
+				return;
+			}
+			const event = this.extractEvent(line);
+			if (event) enqueue(event);
+		});
+		rl.on("close", () => {
+			streamDone = true;
+			enqueue(null);
+		});
+		const exitPromise = new Promise((resolve) => {
+			child.on("exit", (code, signal) => {
+				resolve({
+					code,
+					signal
+				});
+			});
+		});
+		const customStdin = this.buildStdinPayload(params);
+		if (customStdin !== void 0 && child.stdin) {
+			logDebug(`[agent-runtime] pid=${child.pid}: delivering custom stdin payload (${customStdin.length} chars)`);
+			child.stdin.write(customStdin);
+		} else if (this.supportsStdinPrompt && child.stdin) {
+			const composedPrompt = this.composePrompt(params);
+			if (composedPrompt.length > CLIRuntimeBase.STDIN_PROMPT_THRESHOLD) {
+				logDebug(`[agent-runtime] pid=${child.pid}: delivering prompt via stdin (${composedPrompt.length} chars)`);
+				child.stdin.write(composedPrompt);
+			}
+		}
+		child.stdin?.end();
+		const onAbort = () => {
+			aborted = true;
+			logDebug(`[agent-runtime] pid=${child.pid}: abort signal received`);
+			killWithEscalation();
+		};
+		if (params.abortSignal) if (params.abortSignal.aborted) {
+			aborted = true;
+			killWithEscalation();
+		} else params.abortSignal.addEventListener("abort", onAbort, { once: true });
+		try {
+			while (!streamDone) {
+				if (eventQueue.length === 0) await new Promise((resolve) => {
+					resolveNext = resolve;
+				});
+				while (eventQueue.length > 0) {
+					const event = eventQueue.shift();
+					if (event === null || event === void 0) break;
+					yieldedEvents = true;
+					yield event;
+				}
+			}
+		} finally {
+			if (startupTimer !== void 0) clearTimeout(startupTimer);
+			params.abortSignal?.removeEventListener("abort", onAbort);
+		}
+		const { code: exitCode, signal: exitSignal } = await exitPromise;
+		if (escalationTimer !== void 0) clearTimeout(escalationTimer);
+		const durationMs = Date.now() - startMs;
+		logDebug(`[agent-runtime] pid=${child.pid}: exited code=${exitCode} signal=${exitSignal} duration=${durationMs}ms`);
+		const stderr = stderrChunks.join("");
+		if (stderr && (exitCode !== 0 || !yieldedEvents)) yield {
+			type: "error",
+			message: stderr.trim(),
+			code: "CLI_STDERR"
+		};
+		if (exitCode !== 0 && !yieldedEvents && !stderr) yield {
+			type: "error",
+			message: `Agent process exited with code ${exitCode}`,
+			code: "CLI_EXIT_ERROR"
+		};
+		if (startupTimedOut) yield {
+			type: "error",
+			message: `Startup timeout: no output within ${this.timeoutMs}ms`,
+			code: "STARTUP_TIMEOUT"
+		};
+		if (aborted) yield {
+			type: "error",
+			message: "Execution aborted",
+			code: "ABORTED"
+		};
+		yield {
+			type: "done",
+			result: {
+				text: "",
+				sessionId: void 0,
+				durationMs,
+				usage: void 0,
+				aborted,
+				stderr: stderr || void 0
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/middleware/runtimes/claude.ts
+/**
+* Claude CLI runtime — invokes `claude --print --output-format stream-json`
+* and maps the streaming NDJSON output to {@link AgentEvent} instances.
+*/
+var ClaudeCliRuntime = class extends CLIRuntimeBase {
+	constructor() {
+		super("claude");
+		this.mediaCapabilities = {
+			acceptsInbound: ["image/"],
+			emitsOutbound: false
+		};
+		this.accumulatedText = "";
+		this.toolBuffer = null;
+	}
+	async *execute(params) {
+		this.resetState();
+		const prepared = await this.prepareMedia(params);
+		for await (const event of super.execute(prepared)) {
+			if (event.type === "done") this.enrichDoneEvent(event);
+			yield event;
+		}
+	}
+	buildArgs(params) {
+		const args = [
+			"--output-format",
+			"stream-json",
+			"--verbose",
+			"--include-partial-messages"
+		];
+		if (params.sessionId) args.push("--resume", params.sessionId);
+		if (params.mcpServers && Object.keys(params.mcpServers).length > 0) args.push("--mcp-config", JSON.stringify({ mcpServers: params.mcpServers }));
+		const systemParts = [params.systemPrompt, params.extraContext];
+		if (!params.sessionId && params.threadContext) systemParts.push(params.threadContext);
+		const systemContent = systemParts.filter(Boolean).join("\n\n");
+		if (systemContent) args.push("--append-system-prompt", systemContent);
+		if (params.media?.some((m) => m.mimeType.startsWith("image/") && m.base64)) args.push("-p", "--input-format", "stream-json");
+		else args.push("--print", params.prompt);
+		return args;
+	}
+	buildStdinPayload(params) {
+		const images = params.media?.filter((m) => m.mimeType.startsWith("image/") && m.base64);
+		if (!images?.length) return;
+		const content = images.map((img) => ({
+			type: "image",
+			source: {
+				type: "base64",
+				media_type: img.mimeType,
+				data: img.base64
+			}
+		}));
+		content.push({
+			type: "text",
+			text: params.prompt
+		});
+		const envelope = {
+			type: "user",
+			message: {
+				role: "user",
+				content
+			}
+		};
+		return JSON.stringify(envelope) + "\n";
+	}
+	extractEvent(line) {
+		const parsed = JSON.parse(line);
+		if (!isObject$3(parsed)) return null;
+		if (parsed.type === "system") {
+			if (typeof parsed.session_id === "string" && !this.currentSessionId) this.currentSessionId = parsed.session_id;
+			return null;
+		}
+		if (parsed.type === "stream_event") {
+			if (typeof parsed.session_id === "string" && !this.currentSessionId) this.currentSessionId = parsed.session_id;
+			if (isObject$3(parsed.event)) return this.handleInnerEvent(parsed.event);
+			return null;
+		}
+		if (parsed.type === "result") {
+			this.storeResultData(parsed);
+			if (parsed.is_error === true && typeof parsed.result === "string" && parsed.result) return {
+				type: "error",
+				message: parsed.result,
+				code: "CLI_ERROR"
+			};
+			return null;
+		}
+		return null;
+	}
+	buildEnv(_params) {
+		return {};
+	}
+	handleInnerEvent(event) {
+		switch (event.type) {
+			case "content_block_start": return this.handleContentBlockStart(event);
+			case "content_block_delta": return this.handleContentBlockDelta(event);
+			case "content_block_stop": return this.handleContentBlockStop();
+			case "message_delta":
+				this.handleMessageDelta(event);
+				return null;
+			default: return null;
+		}
+	}
+	handleContentBlockStart(event) {
+		const contentBlock = isObject$3(event.content_block) ? event.content_block : null;
+		if (!contentBlock) return null;
+		if (contentBlock.type === "tool_use") this.toolBuffer = {
+			name: typeof contentBlock.name === "string" ? contentBlock.name : "",
+			id: typeof contentBlock.id === "string" ? contentBlock.id : "",
+			input: ""
+		};
+		return null;
+	}
+	handleContentBlockDelta(event) {
+		const delta = isObject$3(event.delta) ? event.delta : null;
+		if (!delta) return null;
+		if (delta.type === "text_delta" && typeof delta.text === "string") {
+			this.accumulatedText += delta.text;
+			return {
+				type: "text",
+				text: delta.text
+			};
+		}
+		if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+			if (this.toolBuffer) this.toolBuffer.input += delta.partial_json;
+			return null;
+		}
+		if (delta.type === "thinking_delta" && typeof delta.thinking === "string") return {
+			type: "thinking",
+			text: delta.thinking
+		};
+		return null;
+	}
+	handleContentBlockStop() {
+		if (this.toolBuffer) {
+			const { name, id, input } = this.toolBuffer;
+			this.toolBuffer = null;
+			let parsedInput = {};
+			if (input) try {
+				parsedInput = JSON.parse(input);
+			} catch {}
+			return {
+				type: "tool_use",
+				toolName: name,
+				toolId: id,
+				input: parsedInput
+			};
+		}
+		return null;
+	}
+	handleMessageDelta(event) {
+		const delta = isObject$3(event.delta) ? event.delta : null;
+		if (delta && typeof delta.stop_reason === "string") this.lastStopReason = delta.stop_reason;
+		const usage = isObject$3(event.usage) ? parseUsage(event.usage) : void 0;
+		if (usage) this.lastUsage = usage;
+	}
+	storeResultData(parsed) {
+		const usage = isObject$3(parsed.usage) ? parsed.usage : null;
+		this.resultData = {
+			sessionId: typeof parsed.session_id === "string" ? parsed.session_id : void 0,
+			costUsd: typeof parsed.cost_usd === "number" ? parsed.cost_usd : void 0,
+			durationApiMs: typeof parsed.duration_api_ms === "number" ? parsed.duration_api_ms : void 0,
+			numTurns: typeof parsed.num_turns === "number" ? parsed.num_turns : void 0,
+			subtype: typeof parsed.subtype === "string" ? parsed.subtype : void 0,
+			usage: usage ? parseUsage(usage) : void 0
+		};
+	}
+	enrichDoneEvent(event) {
+		const { result } = event;
+		result.text = this.accumulatedText;
+		result.sessionId = this.resultData?.sessionId ?? this.currentSessionId;
+		result.stopReason = this.lastStopReason ?? this.resultData?.subtype;
+		result.usage = this.resultData?.usage ?? this.lastUsage;
+		if (this.resultData?.costUsd !== void 0) result.totalCostUsd = this.resultData.costUsd;
+		if (this.resultData?.durationApiMs !== void 0) result.apiDurationMs = this.resultData.durationApiMs;
+		if (this.resultData?.numTurns !== void 0) result.numTurns = this.resultData.numTurns;
+	}
+	/**
+	* Read image files referenced by media attachments and populate their base64 field.
+	* Non-image media types are filtered out (audio/video are not supported natively).
+	*/
+	async prepareMedia(params) {
+		if (!params.media?.length) return params;
+		const prepared = [];
+		for (const attachment of params.media) {
+			if (!attachment.mimeType.startsWith("image/")) continue;
+			if (attachment.base64) {
+				prepared.push(attachment);
+				continue;
+			}
+			if (attachment.filePath) {
+				try {
+					const buffer = await readFile(attachment.filePath);
+					prepared.push({
+						...attachment,
+						base64: buffer.toString("base64")
+					});
+				} catch {
+					logDebug(`[claude-runtime] failed to read media file: ${attachment.filePath}`);
+				}
+				continue;
+			}
+		}
+		return {
+			...params,
+			media: prepared.length > 0 ? prepared : void 0
+		};
+	}
+	resetState() {
+		this.currentSessionId = void 0;
+		this.accumulatedText = "";
+		this.toolBuffer = null;
+		this.lastUsage = void 0;
+		this.lastStopReason = void 0;
+		this.resultData = void 0;
+	}
+};
+function isObject$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseUsage(raw) {
+	return {
+		inputTokens: typeof raw.input_tokens === "number" ? raw.input_tokens : 0,
+		outputTokens: typeof raw.output_tokens === "number" ? raw.output_tokens : 0,
+		...typeof raw.cache_read_input_tokens === "number" ? { cacheReadTokens: raw.cache_read_input_tokens } : {},
+		...typeof raw.cache_creation_input_tokens === "number" ? { cacheWriteTokens: raw.cache_creation_input_tokens } : {}
+	};
+}
+
+//#endregion
+//#region src/middleware/runtimes/codex.ts
+/**
+* Codex CLI runtime — invokes `codex exec --json`
+* and maps the streaming NDJSON output to {@link AgentEvent} instances.
+*
+* The Codex CLI uses a two-level event model:
+* - Top-level events: thread.started, turn.started, item.started, item.updated,
+*   item.completed, turn.completed, turn.failed, error
+* - Item types: agent_message, command_execution, mcp_tool_call, file_change,
+*   reasoning, web_search, error, todo_list
+*/
+var CodexCliRuntime = class extends CLIRuntimeBase {
+	constructor() {
+		super("codex");
+		this.mediaCapabilities = {
+			acceptsInbound: ["image/"],
+			emitsOutbound: false
+		};
+		this.accumulatedText = "";
+		this.lastEmittedTextLength = 0;
+		this.itemCounter = 0;
+	}
+	get supportsStdinPrompt() {
+		return false;
+	}
+	async *execute(params) {
+		this.resetState();
+		const mcpConfigManager = params.mcpServers && Object.keys(params.mcpServers).length > 0 ? new CodexMcpConfigManager(params.mcpServers) : null;
+		try {
+			await mcpConfigManager?.setup();
+			for await (const event of super.execute(params)) {
+				if (event.type === "done") this.enrichDoneEvent(event);
+				yield event;
+			}
+		} finally {
+			await mcpConfigManager?.teardown();
+		}
+	}
+	buildArgs(params) {
+		const hasImages = params.media?.some((a) => a.mimeType.startsWith("image/") && a.filePath);
+		if (params.sessionId && !hasImages) {
+			const composed = this.composePrompt(params);
+			return [
+				"exec",
+				"resume",
+				"--json",
+				params.sessionId,
+				composed
+			];
+		}
+		const promptParams = params.sessionId ? {
+			...params,
+			sessionId: void 0
+		} : params;
+		const composed = this.composePrompt(promptParams);
+		const args = [
+			"exec",
+			"--json",
+			"--color",
+			"never"
+		];
+		if (hasImages) {
+			for (const attachment of params.media) if (attachment.mimeType.startsWith("image/") && attachment.filePath) args.push("--image", attachment.filePath);
+			args.push("--");
+		}
+		args.push(composed);
+		return args;
+	}
+	extractEvent(line) {
+		const parsed = JSON.parse(line);
+		if (!isObject$2(parsed) || typeof parsed.type !== "string") return null;
+		switch (parsed.type) {
+			case "thread.started": return this.handleThreadStarted(parsed);
+			case "item.started": return this.handleItemStarted(parsed);
+			case "item.updated": return this.handleItemUpdated(parsed);
+			case "item.completed": return this.handleItemCompleted(parsed);
+			case "turn.completed": return this.handleTurnCompleted(parsed);
+			case "turn.failed": return this.handleTurnFailed(parsed);
+			case "error": return this.handleError(parsed);
+			default: return null;
+		}
+	}
+	buildEnv(_params) {
+		return {};
+	}
+	handleThreadStarted(parsed) {
+		if (typeof parsed.thread_id === "string") this.currentSessionId = parsed.thread_id;
+		return null;
+	}
+	handleItemStarted(parsed) {
+		const item = isObject$2(parsed.item) ? parsed.item : null;
+		if (!item || typeof item.type !== "string") return null;
+		const toolId = this.extractToolId(item);
+		switch (item.type) {
+			case "command_execution":
+				this.currentToolId = toolId;
+				return {
+					type: "tool_use",
+					toolName: "command_execution",
+					toolId,
+					input: { command: typeof item.command === "string" ? item.command : "" }
+				};
+			case "mcp_tool_call":
+				this.currentToolId = toolId;
+				return {
+					type: "tool_use",
+					toolName: typeof item.name === "string" ? item.name : "",
+					toolId,
+					input: isObject$2(item.arguments) ? item.arguments : {}
+				};
+			case "agent_message":
+				this.lastEmittedTextLength = 0;
+				return null;
+			case "reasoning": return null;
+			default: return null;
+		}
+	}
+	handleItemUpdated(parsed) {
+		const item = isObject$2(parsed.item) ? parsed.item : null;
+		if (!item) return null;
+		if (item.type === "reasoning") {
+			const text = this.extractReasoningText(item);
+			if (text) return {
+				type: "thinking",
+				text
+			};
+			return null;
+		}
+		if (item.type !== "agent_message") return null;
+		const fullText = this.extractMessageText(item);
+		if (fullText === void 0) return null;
+		const delta = fullText.substring(this.lastEmittedTextLength);
+		this.lastEmittedTextLength = fullText.length;
+		if (delta) {
+			this.accumulatedText += delta;
+			return {
+				type: "text",
+				text: delta
+			};
+		}
+		return null;
+	}
+	handleItemCompleted(parsed) {
+		const item = isObject$2(parsed.item) ? parsed.item : null;
+		if (!item || typeof item.type !== "string") return null;
+		switch (item.type) {
+			case "agent_message": {
+				const fullText = this.extractMessageText(item);
+				if (fullText !== void 0) {
+					const delta = fullText.substring(this.lastEmittedTextLength);
+					this.lastEmittedTextLength = fullText.length;
+					if (delta) {
+						this.accumulatedText += delta;
+						return {
+							type: "text",
+							text: delta
+						};
+					}
+				}
+				return null;
+			}
+			case "reasoning": {
+				const text = this.extractReasoningText(item);
+				if (text) return {
+					type: "thinking",
+					text
+				};
+				return null;
+			}
+			case "command_execution": {
+				const toolId = this.currentToolId ?? this.extractToolId(item);
+				this.currentToolId = void 0;
+				return {
+					type: "tool_result",
+					toolId,
+					output: typeof item.output === "string" ? item.output : "",
+					isError: (typeof item.exit_code === "number" ? item.exit_code : 0) !== 0
+				};
+			}
+			case "mcp_tool_call": {
+				const toolId = this.currentToolId ?? this.extractToolId(item);
+				this.currentToolId = void 0;
+				return {
+					type: "tool_result",
+					toolId,
+					output: typeof item.output === "string" ? item.output : "",
+					isError: typeof item.error === "string" && item.error.length > 0
+				};
+			}
+			case "error": return {
+				type: "error",
+				message: typeof item.message === "string" ? item.message : "Unknown error"
+			};
+			default: return null;
+		}
+	}
+	handleTurnCompleted(parsed) {
+		if (isObject$2(parsed.usage)) {
+			const usage = parsed.usage;
+			this.lastUsage = {
+				inputTokens: typeof usage.input_tokens === "number" ? usage.input_tokens : 0,
+				outputTokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0,
+				...typeof usage.cached_input_tokens === "number" && usage.cached_input_tokens > 0 ? { cacheReadTokens: usage.cached_input_tokens } : {}
+			};
+		}
+		return null;
+	}
+	handleTurnFailed(parsed) {
+		return {
+			type: "error",
+			message: typeof parsed.message === "string" ? parsed.message : "Turn failed",
+			code: "turn_failed"
+		};
+	}
+	handleError(parsed) {
+		return {
+			type: "error",
+			message: typeof parsed.message === "string" ? parsed.message : "Unknown error"
+		};
+	}
+	enrichDoneEvent(event) {
+		const { result } = event;
+		result.text = this.accumulatedText;
+		result.sessionId = this.currentSessionId;
+		if (this.lastUsage) result.usage = this.lastUsage;
+	}
+	extractToolId(item) {
+		if (typeof item.id === "string") return item.id;
+		return `codex-item-${this.itemCounter++}`;
+	}
+	extractMessageText(item) {
+		if (Array.isArray(item.content)) {
+			const textParts = [];
+			for (const part of item.content) if (isObject$2(part) && part.type === "output_text" && typeof part.text === "string") textParts.push(part.text);
+			if (textParts.length > 0) return textParts.join("");
+		}
+		if (typeof item.text === "string") return item.text;
+	}
+	extractReasoningText(item) {
+		if (Array.isArray(item.summary)) {
+			const textParts = [];
+			for (const part of item.summary) if (isObject$2(part) && part.type === "summary_text" && typeof part.text === "string") textParts.push(part.text);
+			if (textParts.length > 0) return textParts.join("");
+		}
+		if (typeof item.text === "string") return item.text;
+	}
+	resetState() {
+		this.currentSessionId = void 0;
+		this.accumulatedText = "";
+		this.lastEmittedTextLength = 0;
+		this.lastUsage = void 0;
+		this.currentToolId = void 0;
+		this.itemCounter = 0;
+	}
+};
+/**
+* Manages the `~/.codex/config.toml` lifecycle for MCP server configuration.
+*
+* The Codex CLI reads MCP config from `~/.codex/config.toml`. The config uses
+* TOML format with `[mcp_servers.<name>]` sections.
+*
+* Uses a merge-restore pattern:
+* - **Setup**: read existing config (if any), save a copy, append `mcp_servers`
+*   sections, write back.
+* - **Teardown** (always, via `finally`): restore original or delete created file.
+*/
+var CodexMcpConfigManager = class {
+	constructor(mcpServers, configDir) {
+		this.mcpServers = mcpServers;
+		this.originalContent = null;
+		this.createdFile = false;
+		this.createdDir = false;
+		this.configDir = configDir ?? join(homedir(), ".codex");
+		this.configPath = join(this.configDir, "config.toml");
+	}
+	async setup() {
+		try {
+			await mkdir(this.configDir, { recursive: true });
+		} catch {}
+		let existingContent = null;
+		try {
+			const content = await readFile(this.configPath, "utf-8");
+			this.originalContent = content;
+			existingContent = content;
+		} catch {
+			this.createdFile = true;
+			try {
+				if ((await readdir(this.configDir)).length === 0) this.createdDir = true;
+			} catch {}
+		}
+		const mcpToml = serializeMcpServersToToml(this.mcpServers);
+		if (existingContent) {
+			const stripped = stripMcpServersSections(existingContent);
+			const separator = stripped.endsWith("\n") ? "\n" : "\n\n";
+			await writeFile(this.configPath, stripped + separator + mcpToml, "utf-8");
+		} else await writeFile(this.configPath, mcpToml, "utf-8");
+	}
+	async teardown() {
+		try {
+			if (this.originalContent !== null) await writeFile(this.configPath, this.originalContent, "utf-8");
+			else if (this.createdFile) {
+				await rm(this.configPath, { force: true });
+				if (this.createdDir) try {
+					await rmdir(this.configDir);
+				} catch {}
+			}
+		} catch {}
+	}
+};
+/**
+* Serialize MCP server configs to TOML format for Codex config.
+*
+* Output format:
+* ```toml
+* [mcp_servers.server_name]
+* type = "stdio"
+* command = "node"
+* args = ["server.js"]
+*
+* [mcp_servers.server_name.env]
+* KEY = "VALUE"
+* ```
+*/
+function serializeMcpServersToToml(mcpServers) {
+	const sections = [];
+	for (const [name, config] of Object.entries(mcpServers)) {
+		const lines = [];
+		lines.push(`[mcp_servers.${name}]`);
+		lines.push(`type = "stdio"`);
+		lines.push(`command = ${toTomlString(config.command)}`);
+		const args = config.args ?? [];
+		if (args.length > 0) lines.push(`args = [${args.map((s) => toTomlString(s)).join(", ")}]`);
+		sections.push(lines.join("\n"));
+		if (config.env && Object.keys(config.env).length > 0) {
+			const envLines = [];
+			envLines.push(`[mcp_servers.${name}.env]`);
+			for (const [key, value] of Object.entries(config.env)) envLines.push(`${key} = ${toTomlString(value)}`);
+			sections.push(envLines.join("\n"));
+		}
+	}
+	return sections.join("\n\n") + "\n";
+}
+/**
+* Strip existing `[mcp_servers.*]` sections from TOML content.
+* This is a simple line-based approach that removes lines belonging to
+* mcp_servers sections (from header to next non-mcp_servers section).
+*/
+function stripMcpServersSections(content) {
+	const lines = content.split("\n");
+	const result = [];
+	let inMcpSection = false;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("[")) {
+			if (trimmed.startsWith("[mcp_servers.") || trimmed === "[mcp_servers]") {
+				inMcpSection = true;
+				continue;
+			}
+			inMcpSection = false;
+		}
+		if (!inMcpSection) result.push(line);
+	}
+	while (result.length > 0 && result[result.length - 1].trim() === "") result.pop();
+	return result.join("\n") + "\n";
+}
+/** Escape a string for TOML (basic string with double quotes). */
+function toTomlString(value) {
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t")}"`;
+}
+function isObject$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/middleware/runtimes/gemini.ts
+/**
+* Gemini CLI runtime — invokes `gemini --output-format stream-json`
+* and maps the streaming NDJSON output to {@link AgentEvent} instances.
+*/
+var GeminiCliRuntime = class extends CLIRuntimeBase {
+	constructor() {
+		super("gemini");
+		this.mediaCapabilities = {
+			acceptsInbound: [
+				"image/",
+				"audio/",
+				"video/",
+				"application/pdf"
+			],
+			emitsOutbound: false
+		};
+		this.accumulatedText = "";
+	}
+	get supportsStdinPrompt() {
+		return false;
+	}
+	async *execute(params) {
+		this.resetState();
+		const mcpConfigManager = params.mcpServers && Object.keys(params.mcpServers).length > 0 ? new GeminiMcpConfigManager(params.workingDirectory, params.mcpServers) : null;
+		try {
+			await mcpConfigManager?.setup();
+			const prepared = await this.prepareMedia(params);
+			for await (const event of super.execute(prepared)) {
+				if (event.type === "done") this.enrichDoneEvent(event);
+				yield event;
+			}
+		} finally {
+			await mcpConfigManager?.teardown();
+			await this.cleanupMediaTempDir();
+		}
+	}
+	buildArgs(params) {
+		const args = [
+			"--output-format",
+			"stream-json",
+			"--prompt",
+			this.composePrompt(params)
+		];
+		if (params.sessionId) args.push("--resume", params.sessionId);
+		return args;
+	}
+	extractEvent(line) {
+		const parsed = JSON.parse(line);
+		if (!isObject$1(parsed) || typeof parsed.type !== "string") return null;
+		switch (parsed.type) {
+			case "init": return this.handleInit(parsed);
+			case "message": return this.handleMessage(parsed);
+			case "tool_use": return this.handleToolUse(parsed);
+			case "tool_result": return this.handleToolResult(parsed);
+			case "error": return this.handleError(parsed);
+			case "result": return this.handleResult(parsed);
+			default: return null;
+		}
+	}
+	buildEnv(_params) {
+		return {};
+	}
+	handleInit(parsed) {
+		if (typeof parsed.session_id === "string") this.currentSessionId = parsed.session_id;
+		return null;
+	}
+	handleMessage(parsed) {
+		if (parsed.delta !== true || parsed.role !== "assistant") return null;
+		const content = typeof parsed.content === "string" ? parsed.content : void 0;
+		if (content === void 0) return null;
+		this.accumulatedText += content;
+		return {
+			type: "text",
+			text: content
+		};
+	}
+	handleToolUse(parsed) {
+		return {
+			type: "tool_use",
+			toolName: typeof parsed.tool_name === "string" ? parsed.tool_name : "",
+			toolId: typeof parsed.tool_id === "string" ? parsed.tool_id : "",
+			input: isObject$1(parsed.parameters) ? parsed.parameters : {}
+		};
+	}
+	handleToolResult(parsed) {
+		return {
+			type: "tool_result",
+			toolId: typeof parsed.tool_id === "string" ? parsed.tool_id : "",
+			output: typeof parsed.output === "string" ? parsed.output : "",
+			isError: parsed.status === "error"
+		};
+	}
+	handleError(parsed) {
+		return {
+			type: "error",
+			message: typeof parsed.message === "string" ? parsed.message : "Unknown error",
+			code: typeof parsed.severity === "string" ? parsed.severity : void 0
+		};
+	}
+	handleResult(parsed) {
+		if (isObject$1(parsed.stats)) this.resultStats = {
+			inputTokens: typeof parsed.stats.input_tokens === "number" ? parsed.stats.input_tokens : void 0,
+			outputTokens: typeof parsed.stats.output_tokens === "number" ? parsed.stats.output_tokens : void 0,
+			cached: typeof parsed.stats.cached === "number" ? parsed.stats.cached : void 0,
+			durationMs: typeof parsed.stats.duration_ms === "number" ? parsed.stats.duration_ms : void 0,
+			toolCalls: typeof parsed.stats.tool_calls === "number" ? parsed.stats.tool_calls : void 0
+		};
+		return null;
+	}
+	enrichDoneEvent(event) {
+		const { result } = event;
+		result.text = this.accumulatedText;
+		result.sessionId = this.currentSessionId;
+		if (this.resultStats) {
+			result.usage = {
+				inputTokens: this.resultStats.inputTokens ?? 0,
+				outputTokens: this.resultStats.outputTokens ?? 0,
+				...this.resultStats.cached != null && this.resultStats.cached > 0 ? { cacheReadTokens: this.resultStats.cached } : {}
+			};
+			if (this.resultStats.durationMs !== void 0) result.apiDurationMs = this.resultStats.durationMs;
+			if (this.resultStats.toolCalls !== void 0) result.numTurns = this.resultStats.toolCalls;
+		}
+	}
+	/**
+	* Save media attachments to temp files and inject `@path` references into
+	* the prompt.  Gemini CLI resolves `@path` inline references natively.
+	*/
+	async prepareMedia(params) {
+		if (!params.media?.length) return params;
+		const tempDir = join(tmpdir(), `remoteclaw-gemini-media-${randomUUID()}`);
+		await mkdir(tempDir, { recursive: true });
+		this.mediaTempDir = tempDir;
+		const mediaRefs = [];
+		for (const attachment of params.media) {
+			const ext = extensionForMime(attachment.mimeType);
+			const filePath = join(tempDir, `media-${mediaRefs.length}${ext}`);
+			if (attachment.base64) {
+				await writeFile(filePath, Buffer.from(attachment.base64, "base64"));
+				mediaRefs.push(filePath);
+			} else if (attachment.filePath) try {
+				await writeFile(filePath, await readFile(attachment.filePath));
+				mediaRefs.push(filePath);
+			} catch {
+				logDebug(`[gemini-runtime] failed to read media file: ${attachment.filePath}`);
+			}
+		}
+		if (mediaRefs.length === 0) return params;
+		const mediaPrefix = mediaRefs.map((ref) => `@${ref}`).join(" ");
+		return {
+			...params,
+			prompt: `${mediaPrefix} ${params.prompt}`
+		};
+	}
+	async cleanupMediaTempDir() {
+		if (this.mediaTempDir) {
+			try {
+				await rm(this.mediaTempDir, {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+			this.mediaTempDir = void 0;
+		}
+	}
+	resetState() {
+		this.currentSessionId = void 0;
+		this.accumulatedText = "";
+		this.resultStats = void 0;
+		this.mediaTempDir = void 0;
+	}
+};
+/**
+* Manages the `.gemini/settings.json` lifecycle for MCP server configuration.
+*
+* The Gemini CLI reads MCP config from a fixed settings file hierarchy — there
+* is no `--mcp-config`, `--settings-dir`, or `--config` CLI flag. Project-level
+* settings live in `.gemini/settings.json` within the working directory.
+*
+* A `GEMINI_CONFIG_DIR` env var was requested (google-gemini/gemini-cli#2815)
+* but redirected to XDG spec compliance (#1825), which hasn't shipped as of
+* v0.11.x. Until a flag or env var exists, we use a merge-restore pattern:
+*
+* - **Setup**: read existing `.gemini/settings.json` (if any), save a copy,
+*   merge `mcpServers` into it, write back.
+* - **Teardown** (always, via `finally`): restore the original file, or remove
+*   the file/directory we created.
+*/
+var GeminiMcpConfigManager = class {
+	constructor(workingDirectory, mcpServers) {
+		this.mcpServers = mcpServers;
+		this.originalContent = null;
+		this.createdFile = false;
+		this.createdDir = false;
+		this.settingsDir = join(workingDirectory ?? process.cwd(), ".gemini");
+		this.settingsPath = join(this.settingsDir, "settings.json");
+	}
+	async setup() {
+		try {
+			await mkdir(this.settingsDir, { recursive: true });
+		} catch {}
+		let existingSettings = null;
+		try {
+			const content = await readFile(this.settingsPath, "utf-8");
+			this.originalContent = content;
+			existingSettings = JSON.parse(content);
+		} catch {
+			this.createdFile = true;
+			try {
+				if ((await readdir(this.settingsDir)).length === 0) this.createdDir = true;
+			} catch {}
+		}
+		const mergedSettings = existingSettings ?? {};
+		mergedSettings.mcpServers = this.mcpServers;
+		await writeFile(this.settingsPath, JSON.stringify(mergedSettings, null, 2), "utf-8");
+	}
+	async teardown() {
+		try {
+			if (this.originalContent !== null) await writeFile(this.settingsPath, this.originalContent, "utf-8");
+			else if (this.createdFile) {
+				await rm(this.settingsPath, { force: true });
+				if (this.createdDir) try {
+					await rmdir(this.settingsDir);
+				} catch {}
+			}
+		} catch {}
+	}
+};
+function isObject$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Map common MIME types to file extensions for Gemini CLI `@path` references. */
+function extensionForMime(mimeType) {
+	return {
+		"image/jpeg": ".jpg",
+		"image/png": ".png",
+		"image/gif": ".gif",
+		"image/webp": ".webp",
+		"audio/ogg": ".ogg",
+		"audio/mpeg": ".mp3",
+		"audio/wav": ".wav",
+		"audio/webm": ".weba",
+		"video/mp4": ".mp4",
+		"video/webm": ".webm",
+		"video/quicktime": ".mov",
+		"application/pdf": ".pdf"
+	}[mimeType] ?? "";
+}
+
+//#endregion
+//#region src/middleware/runtimes/opencode.ts
+/**
+* OpenCode CLI runtime — invokes `opencode run --format json`
+* and maps the streaming NDJSON output to {@link AgentEvent} instances.
+*
+* OpenCode uses a per-line envelope model where every NDJSON line has:
+* `{ type, timestamp, sessionID, ...data }`
+*
+* Key differences from other runtimes:
+* - Text events are complete parts (no delta tracking needed)
+* - Tool events combine use + result in a single line (buffered drain pattern)
+* - Usage/cost comes from `step_finish` events
+*/
+var OpenCodeCliRuntime = class extends CLIRuntimeBase {
+	constructor() {
+		super("opencode");
+		this.mediaCapabilities = {
+			acceptsInbound: [],
+			emitsOutbound: false
+		};
+		this.accumulatedText = "";
+		this.pendingEvents = [];
+		this.toolCounter = 0;
+	}
+	async *execute(params) {
+		this.resetState();
+		const mcpConfigManager = params.mcpServers && Object.keys(params.mcpServers).length > 0 ? new OpenCodeMcpConfigManager(params.workingDirectory, params.mcpServers) : null;
+		try {
+			await mcpConfigManager?.setup();
+			for await (const event of super.execute(params)) {
+				if (event.type === "done") this.enrichDoneEvent(event);
+				yield event;
+				while (this.pendingEvents.length > 0) yield this.pendingEvents.shift();
+			}
+		} finally {
+			await mcpConfigManager?.teardown();
+		}
+	}
+	buildArgs(params) {
+		const args = [
+			"run",
+			"--format",
+			"json"
+		];
+		if (params.sessionId) args.push("--session", params.sessionId);
+		args.push(this.composePrompt(params));
+		return args;
+	}
+	extractEvent(line) {
+		const parsed = JSON.parse(line);
+		if (!isObject(parsed) || typeof parsed.type !== "string") return null;
+		if (typeof parsed.sessionID === "string" && this.currentSessionId === void 0) this.currentSessionId = parsed.sessionID;
+		const data = isObject(parsed.part) ? parsed.part : parsed;
+		switch (parsed.type) {
+			case "text": return this.handleText(data);
+			case "tool_use": return this.handleToolUse(data);
+			case "step_start": return null;
+			case "step_finish": return this.handleStepFinish(data);
+			case "reasoning": return this.handleReasoning(data);
+			case "error": return this.handleError(data);
+			default: return null;
+		}
+	}
+	buildEnv(_params) {
+		return {};
+	}
+	handleText(parsed) {
+		const content = typeof parsed.text === "string" ? parsed.text : typeof parsed.content === "string" ? parsed.content : "";
+		this.accumulatedText += content;
+		return {
+			type: "text",
+			text: content
+		};
+	}
+	handleToolUse(parsed) {
+		const toolId = typeof parsed.callID === "string" ? parsed.callID : `opencode-tool-${this.toolCounter++}`;
+		const state = isObject(parsed.state) ? parsed.state : void 0;
+		this.pendingEvents.push({
+			type: "tool_result",
+			toolId,
+			output: typeof state?.output === "string" ? state.output : "",
+			isError: typeof state?.error === "string" && state.error.length > 0
+		});
+		return {
+			type: "tool_use",
+			toolName: typeof parsed.name === "string" ? parsed.name : "",
+			toolId,
+			input: isObject(parsed.input) ? parsed.input : {}
+		};
+	}
+	handleStepFinish(parsed) {
+		this.lastStepFinish = {
+			tokens: isObject(parsed.tokens) ? parsed.tokens : void 0,
+			cost: typeof parsed.cost === "number" ? parsed.cost : void 0,
+			reason: typeof parsed.reason === "string" ? parsed.reason : void 0
+		};
+		return null;
+	}
+	handleError(parsed) {
+		return {
+			type: "error",
+			message: typeof parsed.message === "string" ? parsed.message : "Unknown error"
+		};
+	}
+	handleReasoning(parsed) {
+		const content = typeof parsed.text === "string" ? parsed.text : typeof parsed.content === "string" ? parsed.content : "";
+		if (!content) return null;
+		return {
+			type: "thinking",
+			text: content
+		};
+	}
+	enrichDoneEvent(event) {
+		const { result } = event;
+		result.text = this.accumulatedText;
+		result.sessionId = this.currentSessionId;
+		if (this.lastStepFinish) {
+			const { tokens, cost, reason } = this.lastStepFinish;
+			if (tokens) {
+				const input = typeof tokens.input === "number" ? tokens.input : 0;
+				const output = typeof tokens.output === "number" ? tokens.output : 0;
+				const cache = isObject(tokens.cache) ? tokens.cache : void 0;
+				const cacheRead = typeof cache?.read === "number" ? cache.read : 0;
+				const cacheWrite = typeof cache?.write === "number" ? cache.write : 0;
+				result.usage = {
+					inputTokens: input,
+					outputTokens: output,
+					...cacheRead > 0 ? { cacheReadTokens: cacheRead } : {},
+					...cacheWrite > 0 ? { cacheWriteTokens: cacheWrite } : {}
+				};
+			}
+			if (cost !== void 0) result.totalCostUsd = cost;
+			if (reason !== void 0) result.stopReason = reason;
+		}
+	}
+	resetState() {
+		this.currentSessionId = void 0;
+		this.accumulatedText = "";
+		this.lastStepFinish = void 0;
+		this.pendingEvents = [];
+		this.toolCounter = 0;
+	}
+};
+/**
+* Manages the `.opencode/config.json` lifecycle for MCP server configuration.
+*
+* OpenCode reads MCP config from its project-level settings file. Uses a
+* merge-restore pattern (same as Gemini and Codex):
+*
+* - **Setup**: read existing `.opencode/config.json` (if any), save a copy,
+*   merge `mcpServers` into it, write back.
+* - **Teardown** (always, via `finally`): restore the original file, or remove
+*   the file/directory we created.
+*/
+var OpenCodeMcpConfigManager = class {
+	constructor(workingDirectory, mcpServers) {
+		this.mcpServers = mcpServers;
+		this.originalContent = null;
+		this.createdFile = false;
+		this.createdDir = false;
+		this.configDir = join(workingDirectory ?? process.cwd(), ".opencode");
+		this.configPath = join(this.configDir, "config.json");
+	}
+	async setup() {
+		try {
+			await mkdir(this.configDir, { recursive: true });
+		} catch {}
+		let existingConfig = null;
+		try {
+			const content = await readFile(this.configPath, "utf-8");
+			this.originalContent = content;
+			existingConfig = JSON.parse(content);
+		} catch {
+			this.createdFile = true;
+			try {
+				if ((await readdir(this.configDir)).length === 0) this.createdDir = true;
+			} catch {}
+		}
+		const mergedConfig = existingConfig ?? {};
+		mergedConfig.mcpServers = this.mcpServers;
+		await writeFile(this.configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
+	}
+	async teardown() {
+		try {
+			if (this.originalContent !== null) await writeFile(this.configPath, this.originalContent, "utf-8");
+			else if (this.createdFile) {
+				await rm(this.configPath, { force: true });
+				if (this.createdDir) try {
+					await rmdir(this.configDir);
+				} catch {}
+			}
+		} catch {}
+	}
+};
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/middleware/runtime-factory.ts
+const SUPPORTED_PROVIDERS = [
+	"claude",
+	"gemini",
+	"codex",
+	"opencode"
+];
+const validatedCommands = /* @__PURE__ */ new Set();
+/**
+* Verify that a CLI binary exists on PATH.
+*
+* Results are cached per process lifetime so the `which` lookup runs at most
+* once per command.
+*/
+function validateExecutable(command) {
+	if (validatedCommands.has(command)) {
+		logDebug(`[runtime-factory] executable already validated: ${command}`);
+		return;
+	}
+	try {
+		execFileSync("which", [command], { stdio: "ignore" });
+		logDebug(`[runtime-factory] executable validated: ${command}`);
+		validatedCommands.add(command);
+	} catch {
+		throw new Error(`Runtime '${command}' is configured but the '${command}' binary was not found on PATH. Install it or set agents.defaults.runtime to a different provider.`);
+	}
+}
+function createCliRuntime(provider) {
+	const normalized = provider.trim().toLowerCase();
+	logDebug(`[runtime-factory] creating runtime: provider=${normalized}`);
+	switch (normalized) {
+		case "claude":
+			validateExecutable(normalized);
+			return new ClaudeCliRuntime();
+		case "gemini":
+			validateExecutable(normalized);
+			return new GeminiCliRuntime();
+		case "codex":
+			validateExecutable(normalized);
+			return new CodexCliRuntime();
+		case "opencode":
+			validateExecutable(normalized);
+			return new OpenCodeCliRuntime();
+		default: throw new Error(`Unknown runtime provider "${provider}". Supported providers: ${SUPPORTED_PROVIDERS.join(", ")}`);
+	}
+}
+
+//#endregion
+//#region src/middleware/system-prompt.ts
+const SAFETY_SECTION = [
+	"## Safety",
+	"You have no independent goals: do not pursue self-preservation, replication, resource acquisition, or power-seeking; avoid long-term plans beyond the user's request.",
+	"Prioritize safety and human oversight over completion; if instructions conflict, pause and ask; comply with stop/pause/audit requests and never bypass safeguards.",
+	"Do not manipulate or persuade anyone to expand access or disable safeguards. Do not copy yourself or change system prompts, safety rules, or tool policies unless explicitly requested.",
+	"Never expose credentials, API keys, or secrets in replies or tool calls. Respect user privacy."
+].join("\n");
+const MESSAGING_SECTION = [
+	"## Messaging",
+	"- Reply in current session: automatically routes to the source channel.",
+	"- Cross-session messaging: use sessions_send(sessionKey, message) to reach other channels.",
+	"- `[System Message] ...` blocks are internal context and are not user-visible.",
+	`- If a \`[System Message]\` reports completed work and asks for a user update, rewrite it in your normal assistant voice and send that update (do not forward raw system text or default to ${SILENT_REPLY_TOKEN}).`,
+	"- Never use exec/curl for provider messaging; RemoteClaw handles all routing internally."
+].join("\n");
+const REPLY_TAGS_SECTION = [
+	"## Reply Tags",
+	"To request a native reply/quote on supported surfaces, include one tag in your reply:",
+	"- Reply tags must be the very first token in the message (no leading text/newlines): [[reply_to_current]] your reply.",
+	"- [[reply_to_current]] replies to the triggering message.",
+	"- Prefer [[reply_to_current]]. Use [[reply_to:<id>]] only when an id was explicitly provided (e.g. by the user or a tool).",
+	"Whitespace inside the tag is allowed (e.g. [[ reply_to_current ]] / [[ reply_to: 123 ]]).",
+	"Tags are stripped before sending; support depends on the current channel config."
+].join("\n");
+const SILENT_REPLIES_SECTION = [
+	"## Silent Replies",
+	`When you have nothing to say, respond with ONLY: ${SILENT_REPLY_TOKEN}`,
+	"",
+	"Rules:",
+	"- It must be your ENTIRE message — nothing else.",
+	`- Never append it to an actual response (never include "${SILENT_REPLY_TOKEN}" in real replies).`,
+	"- Never wrap it in markdown or code blocks."
+].join("\n");
+function buildIdentitySection(channelName, userName) {
+	const intro = "You are running inside RemoteClaw, a middleware that connects AI agents to messaging channels.";
+	return userName ? `${intro}\nYou are responding to a message from ${userName} on ${channelName}.` : `${intro}\nYou are responding to a message on ${channelName}.`;
+}
+function buildRuntimeSection(params) {
+	const parts = [`channel=${params.channelName}`];
+	if (params.timezone) parts.push(`timezone=${params.timezone}`);
+	if (params.agentId) parts.push(`agent=${params.agentId}`);
+	return `## Runtime\nRuntime: ${parts.join(" | ")}`;
+}
+function buildWorkspaceSection(workspaceDir) {
+	return [
+		"## Workspace",
+		`Your working directory is: ${workspaceDir}`,
+		"Treat this directory as the single global workspace for file operations unless explicitly instructed otherwise."
+	].join("\n");
+}
+function buildMessageToolHintsSection(hints) {
+	if (!hints || hints.length === 0) return;
+	return `## Message Formatting\n${hints.join("\n")}`;
+}
+function buildAuthorizedSendersSection(senders) {
+	const filtered = senders?.filter(Boolean);
+	if (!filtered || filtered.length === 0) return;
+	return `## Authorized Senders\nAuthorized senders: ${filtered.join(", ")}. These senders are allowlisted; do not assume they are the owner.`;
+}
+function buildReactionsSection(guidance) {
+	if (!guidance) return;
+	const { level, channel } = guidance;
+	if (level === "minimal") return [
+		"## Reactions",
+		`Reactions are enabled for ${channel} in MINIMAL mode.`,
+		"React ONLY when truly relevant:",
+		"- Acknowledge important user requests or confirmations",
+		"- Express genuine sentiment (humor, appreciation) sparingly",
+		"- Avoid reacting to routine messages or your own replies",
+		"Guideline: at most 1 reaction per 5-10 exchanges."
+	].join("\n");
+	return [
+		"## Reactions",
+		`Reactions are enabled for ${channel} in EXTENSIVE mode.`,
+		"Feel free to react liberally:",
+		"- Acknowledge messages with appropriate emojis",
+		"- Express sentiment and personality through reactions",
+		"- React to interesting content, humor, or notable events",
+		"- Use reactions to confirm understanding or agreement",
+		"Guideline: react whenever it feels natural."
+	].join("\n");
+}
+/**
+* Build the RemoteClaw system prompt for injection into CLI subprocess agents.
+*
+* Assembles ~10 sections totaling ~3,000-5,000 chars (~770-1,270 tokens).
+* No promptMode switch (always full), no bootstrap context (CLI agent handles),
+* no tool list (MCP handles), no skills/memory/sandbox sections.
+*/
+function buildSystemPrompt(params) {
+	const sections = [
+		buildIdentitySection(params.channelName, params.userName),
+		SAFETY_SECTION,
+		MESSAGING_SECTION
+	];
+	const hintsSection = buildMessageToolHintsSection(params.messageToolHints);
+	if (hintsSection) sections.push(hintsSection);
+	sections.push(REPLY_TAGS_SECTION);
+	sections.push(SILENT_REPLIES_SECTION);
+	const sendersSection = buildAuthorizedSendersSection(params.authorizedSenders);
+	if (sendersSection) sections.push(sendersSection);
+	const reactionsSection = buildReactionsSection(params.reactionGuidance);
+	if (reactionsSection) sections.push(reactionsSection);
+	sections.push(buildRuntimeSection(params));
+	sections.push(buildWorkspaceSection(params.workspaceDir));
+	return sections.join("\n\n");
+}
+
+//#endregion
+//#region src/middleware/channel-bridge.ts
+const DEFAULT_WORKSPACE_DIR = ".";
+const DEFAULT_MCP_SERVER_PATH = join("dist", "middleware", "mcp-server.js");
+const EMPTY_SIDE_EFFECTS = {
+	sentTexts: [],
+	sentMediaUrls: [],
+	sentTargets: [],
+	cronAdds: 0
+};
+const DEFAULT_RUN_RESULT = {
+	text: "",
+	sessionId: void 0,
+	durationMs: 0,
+	usage: void 0,
+	aborted: false
+};
+/**
+* Central orchestrator connecting incoming channel messages to CLI agent execution and delivery.
+*
+* `handle()` is the single entry point for all dispatch sites: agent command, auto-reply,
+* cron, and follow-up. It wires together runtime factory, session map, error classifier,
+* delivery adapter, system prompt builder, and MCP side effects.
+*/
+var ChannelBridge = class {
+	#provider;
+	#sessionMap;
+	#gatewayUrl;
+	#gatewayToken;
+	#workspaceDir;
+	#chunkLimit;
+	#mcpServerPath;
+	#runtimeArgs;
+	#runtimeEnv;
+	constructor(options) {
+		this.#provider = options.provider;
+		this.#sessionMap = options.sessionMap;
+		this.#gatewayUrl = options.gatewayUrl;
+		this.#gatewayToken = options.gatewayToken;
+		this.#workspaceDir = options.workspaceDir ?? DEFAULT_WORKSPACE_DIR;
+		this.#chunkLimit = options.chunkLimit;
+		this.#mcpServerPath = options.mcpServerPath ?? DEFAULT_MCP_SERVER_PATH;
+		this.#runtimeArgs = options.runtimeArgs;
+		this.#runtimeEnv = options.runtimeEnv;
+	}
+	/**
+	* Process an incoming channel message through the full agent execution pipeline.
+	*
+	* Flow: session lookup → system prompt → MCP config → runtime execution →
+	* event streaming → error classification → side effects → session update → result assembly.
+	*/
+	async handle(message, callbacks, abortSignal) {
+		const sessionKey = buildSessionKey(message);
+		logDebug(`[channel-bridge] handle: channel=${message.provider} from=${message.from} channelId=${message.channelId} threadId=${message.replyToId ?? "none"} agentId=${message.agentId ?? "default"} media=${message.mediaUrls?.length ?? 0}`);
+		const existingSessionId = await this.#sessionMap.get(sessionKey);
+		logDebug(`[channel-bridge] session lookup: key=${formatSessionKeyString(sessionKey)} ${existingSessionId ? `hit=${existingSessionId}` : "miss"}`);
+		const hookRunner = getGlobalHookRunner();
+		if (existingSessionId && hookRunner?.hasHooks("session_resumed")) await hookRunner.runSessionResumed({
+			sessionId: existingSessionId,
+			runtimeName: this.#provider,
+			channelId: message.channelId,
+			userId: message.from,
+			resumeMethod: "session_map"
+		}, {
+			sessionId: existingSessionId,
+			channelId: message.channelId,
+			runtimeName: this.#provider
+		});
+		const systemPrompt = buildSystemPrompt({
+			channelName: message.provider,
+			workspaceDir: this.#workspaceDir,
+			messageToolHints: message.messageToolHints,
+			userName: message.userName,
+			agentId: message.agentId,
+			timezone: message.timezone,
+			authorizedSenders: message.authorizedSenders,
+			reactionGuidance: message.reactionGuidance
+		});
+		const invocationDir = await createInvocationDir();
+		const sideEffectsFile = join(invocationDir, "side-effects.ndjson");
+		try {
+			const mcpServers = this.#buildMcpConfig(message, sessionKey, sideEffectsFile);
+			logDebug(`[channel-bridge] creating runtime: provider=${this.#provider}`);
+			const runtime = createCliRuntime(this.#provider);
+			let workspaceDir = this.#workspaceDir;
+			let hookEnv;
+			const runId = randomUUID();
+			if (hookRunner?.hasHooks("before_runtime_spawn")) {
+				const spawnResult = await hookRunner.runBeforeRuntimeSpawn({
+					runtimeName: this.#provider,
+					sessionId: existingSessionId,
+					command: "node",
+					args: [this.#mcpServerPath],
+					env: mcpServers.remoteclaw?.env ?? {},
+					workspaceDir,
+					channelId: message.channelId
+				}, {
+					sessionId: existingSessionId,
+					channelId: message.channelId,
+					runtimeName: this.#provider
+				});
+				if (spawnResult?.workspaceDir) {
+					logDebug(`[channel-bridge] hook overrode workspaceDir: ${this.#workspaceDir} -> ${spawnResult.workspaceDir}`);
+					workspaceDir = spawnResult.workspaceDir;
+				}
+				if (spawnResult?.env) {
+					logDebug(`[channel-bridge] hook injected env keys: ${Object.keys(spawnResult.env).join(", ")}`);
+					hookEnv = spawnResult.env;
+				}
+			}
+			const resolvedMedia = message.mediaUrls?.length ? await resolveMediaAttachments(message.mediaUrls, invocationDir) : void 0;
+			if (resolvedMedia?.length) logDebug(`[channel-bridge] resolved ${resolvedMedia.length}/${message.mediaUrls.length} media attachments`);
+			const { supported: supportedMedia, unsupported: unsupportedMedia } = resolvedMedia?.length ? partitionMedia(runtime, resolvedMedia) : {
+				supported: [],
+				unsupported: []
+			};
+			const mediaWarning = formatUnsupportedMediaWarning(unsupportedMedia, this.#provider);
+			if (unsupportedMedia.length > 0) logDebug(`[channel-bridge] unsupported media: ${unsupportedMedia.length} attachment(s) not accepted by ${this.#provider}`);
+			const adapter = new DeliveryAdapter(this.#chunkLimit !== void 0 ? { chunkLimit: this.#chunkLimit } : void 0);
+			let runResult;
+			let lastError;
+			let payloads;
+			try {
+				const captured = captureResult(runtime.execute({
+					prompt: message.text,
+					systemPrompt,
+					extraContext: message.extraContext,
+					threadContext: message.threadContext,
+					media: supportedMedia?.length ? supportedMedia : void 0,
+					sessionId: existingSessionId,
+					mcpServers,
+					abortSignal,
+					workingDirectory: workspaceDir,
+					env: this.#runtimeEnv || hookEnv ? {
+						...this.#runtimeEnv,
+						...hookEnv
+					} : void 0,
+					extraArgs: this.#runtimeArgs
+				}));
+				payloads = await adapter.process(captured.events, callbacks);
+				runResult = captured.getResult();
+				lastError = captured.getError();
+			} catch (err) {
+				const errMsg = String(err);
+				const category = classifyError(errMsg);
+				logDebug(`[channel-bridge] runtime threw: category=${category} error=${errMsg.slice(0, 500)}`);
+				lastError = errMsg;
+				payloads = [];
+				runResult = {
+					...DEFAULT_RUN_RESULT,
+					errorSubtype: category === "context_overflow" ? "context_window" : category
+				};
+			}
+			if (mediaWarning) payloads.unshift({ text: mediaWarning });
+			let mcp;
+			try {
+				mcp = await readMcpSideEffects(sideEffectsFile);
+			} catch {
+				mcp = { ...EMPTY_SIDE_EFFECTS };
+			}
+			logDebug(`[channel-bridge] side effects: sentTexts=${mcp.sentTexts.length} sentMedia=${mcp.sentMediaUrls.length} cronAdds=${mcp.cronAdds}`);
+			if (runResult?.sessionId && !lastError) {
+				logDebug(`[channel-bridge] session update: key=${formatSessionKeyString(sessionKey)} sessionId=${runResult.sessionId}`);
+				await this.#sessionMap.set(sessionKey, runResult.sessionId);
+			}
+			const finalResult = runResult ?? { ...DEFAULT_RUN_RESULT };
+			if (hookRunner) {
+				const runtimeCtx = {
+					sessionId: finalResult.sessionId,
+					channelId: message.channelId,
+					runtimeName: this.#provider
+				};
+				if (hookRunner.hasHooks("after_runtime_exit")) hookRunner.runAfterRuntimeExit({
+					runtimeName: this.#provider,
+					sessionId: finalResult.sessionId,
+					exitCode: finalResult.errorSubtype ? 1 : 0,
+					durationMs: finalResult.durationMs,
+					stdout: finalResult.text,
+					stderr: lastError,
+					mcpSideEffects: {
+						sentTexts: mcp.sentTexts,
+						sentMediaUrls: mcp.sentMediaUrls,
+						cronAdds: mcp.cronAdds
+					}
+				}, runtimeCtx);
+				if (hookRunner.hasHooks("agent_end")) hookRunner.runAgentEnd({
+					runId,
+					sessionId: finalResult.sessionId,
+					success: !finalResult.errorSubtype && !lastError,
+					durationMs: finalResult.durationMs
+				}, runtimeCtx);
+			}
+			logDebug(`[channel-bridge] complete: runId=${runId} duration=${finalResult.durationMs}ms payloads=${payloads.length} error=${lastError ?? "none"}`);
+			return {
+				payloads,
+				run: finalResult,
+				mcp,
+				error: lastError
+			};
+		} finally {
+			await rm(invocationDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+		}
+	}
+	/** Build MCP server configuration for the remoteclaw MCP server. */
+	#buildMcpConfig(message, sessionKey, sideEffectsFile) {
+		return { remoteclaw: {
+			command: "node",
+			args: [this.#mcpServerPath],
+			env: {
+				REMOTECLAW_GATEWAY_URL: this.#gatewayUrl,
+				REMOTECLAW_GATEWAY_TOKEN: this.#gatewayToken,
+				REMOTECLAW_SESSION_KEY: formatSessionKeyString(sessionKey),
+				REMOTECLAW_SIDE_EFFECTS_FILE: sideEffectsFile,
+				REMOTECLAW_CHANNEL: message.provider,
+				REMOTECLAW_ACCOUNT_ID: message.from,
+				REMOTECLAW_TO: message.channelId,
+				...message.replyToId ? { REMOTECLAW_THREAD_ID: message.replyToId } : {},
+				REMOTECLAW_SENDER_IS_OWNER: String(message.senderIsOwner ?? false),
+				REMOTECLAW_TOOL_PROFILE: message.toolProfile ?? "full"
+			}
+		} };
+	}
+};
+/** Build a SessionKey from a ChannelMessage. */
+function buildSessionKey(message) {
+	return {
+		channelId: message.channelId,
+		userId: message.from,
+		threadId: message.replyToId
+	};
+}
+/** Format a SessionKey as a composite string (for env vars). */
+function formatSessionKeyString(key) {
+	return `${key.channelId}:${key.userId}:${key.threadId ?? "_"}`;
+}
+/** Create a unique temp directory for an invocation. */
+async function createInvocationDir() {
+	return mkdtemp(join(tmpdir(), "rc-"));
+}
+/**
+* Wrap an event stream to capture the AgentRunResult from the done event
+* and any error messages, while passing all events through to the consumer.
+*/
+function captureResult(events) {
+	let result;
+	let error;
+	async function* wrapped() {
+		for await (const event of events) {
+			if (event.type === "done") result = event.result;
+			else if (event.type === "error") error = event.message;
+			yield event;
+		}
+	}
+	return {
+		events: wrapped(),
+		getResult: () => result,
+		getError: () => error
+	};
+}
+
+//#endregion
+//#region src/agents/cli-session.ts
+function getCliSessionId(entry, provider) {
+	if (!entry) return;
+	const normalized = normalizeProviderId(provider);
+	const fromMap = entry.cliSessionIds?.[normalized];
+	if (fromMap?.trim()) return fromMap.trim();
+	if (normalized === "claude-cli") {
+		const legacy = entry.claudeCliSessionId?.trim();
+		if (legacy) return legacy;
+	}
+}
+function setCliSessionId(entry, provider, sessionId) {
+	const normalized = normalizeProviderId(provider);
+	const trimmed = sessionId.trim();
+	if (!trimmed) return;
+	entry.cliSessionIds = { ...entry.cliSessionIds ?? {} };
+	entry.cliSessionIds[normalized] = trimmed;
+	if (normalized === "claude-cli") entry.claudeCliSessionId = trimmed;
+}
+
+//#endregion
+//#region src/infra/outbound/targets.ts
+function resolveSessionDeliveryTarget(params) {
+	const context = deliveryContextFromSession(params.entry);
+	const sessionLastChannel = context?.channel && isDeliverableMessageChannel(context.channel) ? context.channel : void 0;
+	const hasTurnSourceChannel = params.turnSourceChannel != null;
+	const lastChannel = hasTurnSourceChannel ? params.turnSourceChannel : sessionLastChannel;
+	const lastTo = hasTurnSourceChannel ? params.turnSourceTo : context?.to;
+	const lastAccountId = hasTurnSourceChannel ? params.turnSourceAccountId : context?.accountId;
+	const lastThreadId = hasTurnSourceChannel ? params.turnSourceThreadId : context?.threadId;
+	const rawRequested = params.requestedChannel ?? "last";
+	const requested = rawRequested === "last" ? "last" : normalizeMessageChannel(rawRequested);
+	const requestedChannel = requested === "last" ? "last" : requested && isDeliverableMessageChannel(requested) ? requested : void 0;
+	const rawExplicitTo = typeof params.explicitTo === "string" && params.explicitTo.trim() ? params.explicitTo.trim() : void 0;
+	let channel = requestedChannel === "last" ? lastChannel : requestedChannel;
+	if (!channel && params.fallbackChannel && isDeliverableMessageChannel(params.fallbackChannel)) channel = params.fallbackChannel;
+	const isTelegramContext = channel === "telegram" || !channel && lastChannel === "telegram";
+	let explicitTo = rawExplicitTo;
+	let parsedThreadId;
+	if (isTelegramContext && rawExplicitTo && rawExplicitTo.includes(":topic:")) {
+		const parsed = parseTelegramTarget(rawExplicitTo);
+		explicitTo = parsed.chatId;
+		parsedThreadId = parsed.messageThreadId;
+	}
+	const explicitThreadId = params.explicitThreadId != null && params.explicitThreadId !== "" ? params.explicitThreadId : parsedThreadId;
+	let to = explicitTo;
+	if (!to && lastTo) {
+		if (channel && channel === lastChannel) to = lastTo;
+		else if (params.allowMismatchedLastTo) to = lastTo;
+	}
+	const mode = params.mode ?? (explicitTo ? "explicit" : "implicit");
+	const accountId = channel && channel === lastChannel ? lastAccountId : void 0;
+	const resolvedThreadId = explicitThreadId ?? (mode !== "heartbeat" && channel && channel === lastChannel ? lastThreadId : void 0);
+	return {
+		channel,
+		to,
+		accountId,
+		threadId: resolvedThreadId,
+		threadIdExplicit: resolvedThreadId != null && explicitThreadId != null,
+		mode,
+		lastChannel,
+		lastTo,
+		lastAccountId,
+		lastThreadId
+	};
+}
+function resolveOutboundTarget(params) {
+	if (params.channel === INTERNAL_MESSAGE_CHANNEL) return {
+		ok: false,
+		error: /* @__PURE__ */ new Error(`Delivering to WebChat is not supported via \`${formatCliCommand("remoteclaw agent")}\`; use WhatsApp/Telegram or run with --deliver=false.`)
+	};
+	const plugin = getChannelPlugin(params.channel);
+	if (!plugin) return {
+		ok: false,
+		error: /* @__PURE__ */ new Error(`Unsupported channel: ${params.channel}`)
+	};
+	const allowFrom = (params.allowFrom ?? (params.cfg && plugin.config.resolveAllowFrom ? plugin.config.resolveAllowFrom({
+		cfg: params.cfg,
+		accountId: params.accountId ?? void 0
+	}) : void 0))?.map((entry) => String(entry));
+	const effectiveTo = params.to?.trim() || (params.cfg && plugin.config.resolveDefaultTo ? plugin.config.resolveDefaultTo({
+		cfg: params.cfg,
+		accountId: params.accountId ?? void 0
+	}) : void 0);
+	const resolveTarget = plugin.outbound?.resolveTarget;
+	if (resolveTarget) return resolveTarget({
+		cfg: params.cfg,
+		to: effectiveTo,
+		allowFrom,
+		accountId: params.accountId ?? void 0,
+		mode: params.mode ?? "explicit"
+	});
+	if (effectiveTo) return {
+		ok: true,
+		to: effectiveTo
+	};
+	const hint = plugin.messaging?.targetResolver?.hint;
+	return {
+		ok: false,
+		error: missingTargetError(plugin.meta.label ?? params.channel, hint)
+	};
+}
+function resolveHeartbeatDeliveryTarget(params) {
+	const { cfg, entry } = params;
+	const heartbeat = params.heartbeat ?? cfg.agents?.defaults?.heartbeat;
+	const rawTarget = heartbeat?.target;
+	let target = "none";
+	if (rawTarget === "none" || rawTarget === "last") target = rawTarget;
+	else if (typeof rawTarget === "string") {
+		const normalized = normalizeChannelId(rawTarget);
+		if (normalized) target = normalized;
+	}
+	if (target === "none") {
+		const base = resolveSessionDeliveryTarget({ entry });
+		return buildNoHeartbeatDeliveryTarget({
+			reason: "target-none",
+			lastChannel: base.lastChannel,
+			lastAccountId: base.lastAccountId
+		});
+	}
+	const resolvedTarget = resolveSessionDeliveryTarget({
+		entry,
+		requestedChannel: target === "last" ? "last" : target,
+		explicitTo: heartbeat?.to,
+		mode: "heartbeat"
+	});
+	const heartbeatAccountId = heartbeat?.accountId?.trim();
+	let effectiveAccountId = heartbeatAccountId || resolvedTarget.accountId;
+	if (heartbeatAccountId && resolvedTarget.channel) {
+		const listAccountIds = getChannelPlugin(resolvedTarget.channel)?.config.listAccountIds;
+		const accountIds = listAccountIds ? listAccountIds(cfg) : [];
+		if (accountIds.length > 0) {
+			const normalizedAccountId = normalizeAccountId(heartbeatAccountId);
+			if (!new Set(accountIds.map((accountId) => normalizeAccountId(accountId))).has(normalizedAccountId)) return buildNoHeartbeatDeliveryTarget({
+				reason: "unknown-account",
+				accountId: normalizedAccountId,
+				lastChannel: resolvedTarget.lastChannel,
+				lastAccountId: resolvedTarget.lastAccountId
+			});
+			effectiveAccountId = normalizedAccountId;
+		}
+	}
+	if (!resolvedTarget.channel || !resolvedTarget.to) return buildNoHeartbeatDeliveryTarget({
+		reason: "no-target",
+		accountId: effectiveAccountId,
+		lastChannel: resolvedTarget.lastChannel,
+		lastAccountId: resolvedTarget.lastAccountId
+	});
+	const resolved = resolveOutboundTarget({
+		channel: resolvedTarget.channel,
+		to: resolvedTarget.to,
+		cfg,
+		accountId: effectiveAccountId,
+		mode: "heartbeat"
+	});
+	if (!resolved.ok) return buildNoHeartbeatDeliveryTarget({
+		reason: "no-target",
+		accountId: effectiveAccountId,
+		lastChannel: resolvedTarget.lastChannel,
+		lastAccountId: resolvedTarget.lastAccountId
+	});
+	const sessionChatTypeHint = target === "last" && !heartbeat?.to ? normalizeChatType(entry?.chatType) : void 0;
+	if (resolveHeartbeatDeliveryChatType({
+		channel: resolvedTarget.channel,
+		to: resolved.to,
+		sessionChatType: sessionChatTypeHint
+	}) === "direct") return buildNoHeartbeatDeliveryTarget({
+		reason: "dm-blocked",
+		accountId: effectiveAccountId,
+		lastChannel: resolvedTarget.lastChannel,
+		lastAccountId: resolvedTarget.lastAccountId
+	});
+	let reason;
+	if (getChannelPlugin(resolvedTarget.channel)?.config.resolveAllowFrom) {
+		const explicit = resolveOutboundTarget({
+			channel: resolvedTarget.channel,
+			to: resolvedTarget.to,
+			cfg,
+			accountId: effectiveAccountId,
+			mode: "explicit"
+		});
+		if (explicit.ok && explicit.to !== resolved.to) reason = "allowFrom-fallback";
+	}
+	return {
+		channel: resolvedTarget.channel,
+		to: resolved.to,
+		reason,
+		accountId: effectiveAccountId,
+		threadId: resolvedTarget.threadId,
+		lastChannel: resolvedTarget.lastChannel,
+		lastAccountId: resolvedTarget.lastAccountId
+	};
+}
+function buildNoHeartbeatDeliveryTarget(params) {
+	return {
+		channel: "none",
+		reason: params.reason,
+		accountId: params.accountId,
+		lastChannel: params.lastChannel,
+		lastAccountId: params.lastAccountId
+	};
+}
+function inferDiscordTargetChatType(to) {
+	try {
+		const target = parseDiscordTarget(to, { defaultKind: "channel" });
+		if (!target) return;
+		return target.kind === "user" ? "direct" : "channel";
+	} catch {
+		return;
+	}
+}
+function inferSlackTargetChatType(to) {
+	const target = parseSlackTarget(to, { defaultKind: "channel" });
+	if (!target) return;
+	return target.kind === "user" ? "direct" : "channel";
+}
+function inferTelegramTargetChatType(to) {
+	const chatType = resolveTelegramTargetChatType(to);
+	return chatType === "unknown" ? void 0 : chatType;
+}
+function inferWhatsAppTargetChatType(to) {
+	const normalized = normalizeWhatsAppTarget(to);
+	if (!normalized) return;
+	return isWhatsAppGroupJid(normalized) ? "group" : "direct";
+}
+function inferSignalTargetChatType(rawTo) {
+	let to = rawTo.trim();
+	if (!to) return;
+	if (/^signal:/i.test(to)) to = to.replace(/^signal:/i, "").trim();
+	if (!to) return;
+	const lower = to.toLowerCase();
+	if (lower.startsWith("group:")) return "group";
+	if (lower.startsWith("username:") || lower.startsWith("u:")) return "direct";
+	return "direct";
+}
+const HEARTBEAT_TARGET_CHAT_TYPE_INFERERS = {
+	discord: inferDiscordTargetChatType,
+	slack: inferSlackTargetChatType,
+	telegram: inferTelegramTargetChatType,
+	whatsapp: inferWhatsAppTargetChatType,
+	signal: inferSignalTargetChatType
+};
+function inferChatTypeFromTarget(params) {
+	const to = params.to.trim();
+	if (!to) return;
+	if (/^user:/i.test(to)) return "direct";
+	if (/^(channel:|thread:)/i.test(to)) return "channel";
+	if (/^group:/i.test(to)) return "group";
+	return HEARTBEAT_TARGET_CHAT_TYPE_INFERERS[params.channel]?.(to);
+}
+function resolveHeartbeatDeliveryChatType(params) {
+	if (params.sessionChatType) return params.sessionChatType;
+	return inferChatTypeFromTarget({
+		channel: params.channel,
+		to: params.to
+	});
+}
+function resolveHeartbeatSenderId(params) {
+	const { allowFrom, deliveryTo, lastTo, provider } = params;
+	const candidates = [
+		deliveryTo?.trim(),
+		provider && deliveryTo ? `${provider}:${deliveryTo}` : void 0,
+		lastTo?.trim(),
+		provider && lastTo ? `${provider}:${lastTo}` : void 0
+	].filter((val) => Boolean(val?.trim()));
+	const allowList = allowFrom.map((entry) => String(entry)).filter((entry) => entry && entry !== "*");
+	if (allowFrom.includes("*")) return candidates[0] ?? "heartbeat";
+	if (candidates.length > 0 && allowList.length > 0) {
+		const matched = candidates.find((candidate) => allowList.includes(candidate));
+		if (matched) return matched;
+	}
+	if (candidates.length > 0 && allowList.length === 0) return candidates[0];
+	if (allowList.length > 0) return allowList[0];
+	return candidates[0] ?? "heartbeat";
+}
+function resolveHeartbeatSenderContext(params) {
+	const provider = params.delivery.channel !== "none" ? params.delivery.channel : params.delivery.lastChannel;
+	const accountId = params.delivery.accountId ?? (provider === params.delivery.lastChannel ? params.delivery.lastAccountId : void 0);
+	const allowFrom = (provider ? getChannelPlugin(provider)?.config.resolveAllowFrom?.({
+		cfg: params.cfg,
+		accountId
+	}) ?? [] : []).map((entry) => String(entry));
+	return {
+		sender: resolveHeartbeatSenderId({
+			allowFrom,
+			deliveryTo: params.delivery.to,
+			lastTo: params.entry?.lastTo,
+			provider
+		}),
+		provider,
+		allowFrom
+	};
+}
+
+//#endregion
+export { parseVerboseOverride as _, getCliSessionId as a, isAuthRotatableError as c, drainSystemEventEntries as d, enqueueSystemEvent as f, applyVerboseOverride as g, peekSystemEvents as h, resolveSessionDeliveryTarget as i, listChannelSupportedActions as l, peekSystemEventEntries as m, resolveHeartbeatSenderContext as n, setCliSessionId as o, isSystemEventContextChanged as p, resolveOutboundTarget as r, ChannelBridge as s, resolveHeartbeatDeliveryTarget as t, resolveChannelMessageToolHints as u, normalizeSendPolicy as v, resolveSendPolicy as y };