silentlake 2026.3.24

package/dist/common-CUBlLRXB.js

@@ -0,0 +1,457 @@
+import { t as createSubsystemLogger } from "./subsystem-CUp-6QQf.js";
+import { c as resizeToJpeg, i as getImageMetadata, n as buildImageResizeSideGrid, t as IMAGE_REDUCE_QUALITY_STEPS } from "./image-ops-j01UkxEv.js";
+import { t as detectMime } from "./mime-C4vVTBso.js";
+import fs from "node:fs/promises";
+//#region src/media/base64.ts
+function estimateBase64DecodedBytes(base64) {
+	let effectiveLen = 0;
+	for (let i = 0; i < base64.length; i += 1) {
+		if (base64.charCodeAt(i) <= 32) continue;
+		effectiveLen += 1;
+	}
+	if (effectiveLen === 0) return 0;
+	let padding = 0;
+	let end = base64.length - 1;
+	while (end >= 0 && base64.charCodeAt(end) <= 32) end -= 1;
+	if (end >= 0 && base64[end] === "=") {
+		padding = 1;
+		end -= 1;
+		while (end >= 0 && base64.charCodeAt(end) <= 32) end -= 1;
+		if (end >= 0 && base64[end] === "=") padding = 2;
+	}
+	const estimated = Math.floor(effectiveLen * 3 / 4) - padding;
+	return Math.max(0, estimated);
+}
+const BASE64_CHARS_RE = /^[A-Za-z0-9+/]+={0,2}$/;
+/**
+* Normalize and validate a base64 string.
+* Returns canonical base64 (no whitespace) or undefined when invalid.
+*/
+function canonicalizeBase64(base64) {
+	const cleaned = base64.replace(/\s+/g, "");
+	if (!cleaned || cleaned.length % 4 !== 0 || !BASE64_CHARS_RE.test(cleaned)) return;
+	return cleaned;
+}
+//#endregion
+//#region src/agents/image-sanitization.ts
+const DEFAULT_IMAGE_MAX_DIMENSION_PX = 1200;
+const DEFAULT_IMAGE_MAX_BYTES = 5 * 1024 * 1024;
+function resolveImageSanitizationLimits(cfg) {
+	const configured = cfg?.agents?.defaults?.imageMaxDimensionPx;
+	if (typeof configured !== "number" || !Number.isFinite(configured)) return {};
+	return { maxDimensionPx: Math.max(1, Math.floor(configured)) };
+}
+//#endregion
+//#region src/agents/tool-images.ts
+const MAX_IMAGE_DIMENSION_PX = DEFAULT_IMAGE_MAX_DIMENSION_PX;
+const MAX_IMAGE_BYTES = DEFAULT_IMAGE_MAX_BYTES;
+const log = createSubsystemLogger("agents/tool-images");
+function isImageBlock(block) {
+	if (!block || typeof block !== "object") return false;
+	const rec = block;
+	return rec.type === "image" && typeof rec.data === "string" && typeof rec.mimeType === "string";
+}
+function isTextBlock(block) {
+	if (!block || typeof block !== "object") return false;
+	const rec = block;
+	return rec.type === "text" && typeof rec.text === "string";
+}
+function inferMimeTypeFromBase64(base64) {
+	const trimmed = base64.trim();
+	if (!trimmed) return;
+	if (trimmed.startsWith("/9j/")) return "image/jpeg";
+	if (trimmed.startsWith("iVBOR")) return "image/png";
+	if (trimmed.startsWith("R0lGOD")) return "image/gif";
+}
+function formatBytesShort(bytes) {
+	if (!Number.isFinite(bytes) || bytes < 1024) return `${Math.max(0, Math.round(bytes))}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(2)}MB`;
+}
+function parseMediaPathFromText(text) {
+	for (const line of text.split(/\r?\n/u)) {
+		const trimmed = line.trim();
+		if (!trimmed.startsWith("MEDIA:")) continue;
+		const raw = trimmed.slice(6).trim();
+		if (!raw) continue;
+		return (raw.match(/^`([^`]+)`$/u)?.[1] ?? raw).trim();
+	}
+}
+function fileNameFromPathLike(pathLike) {
+	const value = pathLike.trim();
+	if (!value) return;
+	try {
+		const candidate = new URL(value).pathname.split("/").filter(Boolean).at(-1);
+		return candidate && candidate.length > 0 ? candidate : void 0;
+	} catch {}
+	const candidate = value.replaceAll("\\", "/").split("/").filter(Boolean).at(-1);
+	return candidate && candidate.length > 0 ? candidate : void 0;
+}
+function inferImageFileName(params) {
+	const rec = params.block;
+	for (const key of [
+		"fileName",
+		"filename",
+		"path",
+		"url"
+	]) {
+		const raw = rec[key];
+		if (typeof raw !== "string" || raw.trim().length === 0) continue;
+		const candidate = fileNameFromPathLike(raw);
+		if (candidate) return candidate;
+	}
+	if (typeof rec.name === "string" && rec.name.trim().length > 0) return rec.name.trim();
+	if (params.mediaPathHint) {
+		const candidate = fileNameFromPathLike(params.mediaPathHint);
+		if (candidate) return candidate;
+	}
+	if (typeof params.label === "string" && params.label.startsWith("read:")) {
+		const candidate = fileNameFromPathLike(params.label.slice(5));
+		if (candidate) return candidate;
+	}
+}
+async function resizeImageBase64IfNeeded(params) {
+	const buf = Buffer.from(params.base64, "base64");
+	const meta = await getImageMetadata(buf);
+	const width = meta?.width;
+	const height = meta?.height;
+	const overBytes = buf.byteLength > params.maxBytes;
+	const hasDimensions = typeof width === "number" && typeof height === "number";
+	const overDimensions = hasDimensions && (width > params.maxDimensionPx || height > params.maxDimensionPx);
+	if (hasDimensions && !overBytes && width <= params.maxDimensionPx && height <= params.maxDimensionPx) return {
+		base64: params.base64,
+		mimeType: params.mimeType,
+		resized: false,
+		width,
+		height
+	};
+	const maxDim = hasDimensions ? Math.max(width ?? 0, height ?? 0) : params.maxDimensionPx;
+	const sideStart = maxDim > 0 ? Math.min(params.maxDimensionPx, maxDim) : params.maxDimensionPx;
+	const sideGrid = buildImageResizeSideGrid(params.maxDimensionPx, sideStart);
+	let smallest = null;
+	for (const side of sideGrid) for (const quality of IMAGE_REDUCE_QUALITY_STEPS) {
+		const out = await resizeToJpeg({
+			buffer: buf,
+			maxSide: side,
+			quality,
+			withoutEnlargement: true
+		});
+		if (!smallest || out.byteLength < smallest.size) smallest = {
+			buffer: out,
+			size: out.byteLength
+		};
+		if (out.byteLength <= params.maxBytes) {
+			const sourcePixels = typeof width === "number" && typeof height === "number" ? `${width}x${height}px` : "unknown";
+			const sourceWithFile = params.fileName ? `${params.fileName} ${sourcePixels}` : sourcePixels;
+			const byteReductionPct = buf.byteLength > 0 ? Number(((buf.byteLength - out.byteLength) / buf.byteLength * 100).toFixed(1)) : 0;
+			log.info(`Image resized to fit limits: ${sourceWithFile} ${formatBytesShort(buf.byteLength)} -> ${formatBytesShort(out.byteLength)} (-${byteReductionPct}%)`, {
+				label: params.label,
+				fileName: params.fileName,
+				sourceMimeType: params.mimeType,
+				sourceWidth: width,
+				sourceHeight: height,
+				sourceBytes: buf.byteLength,
+				maxBytes: params.maxBytes,
+				maxDimensionPx: params.maxDimensionPx,
+				triggerOverBytes: overBytes,
+				triggerOverDimensions: overDimensions,
+				outputMimeType: "image/jpeg",
+				outputBytes: out.byteLength,
+				outputQuality: quality,
+				outputMaxSide: side,
+				byteReductionPct
+			});
+			return {
+				base64: out.toString("base64"),
+				mimeType: "image/jpeg",
+				resized: true,
+				width,
+				height
+			};
+		}
+	}
+	const best = smallest?.buffer ?? buf;
+	const maxMb = (params.maxBytes / (1024 * 1024)).toFixed(0);
+	const gotMb = (best.byteLength / (1024 * 1024)).toFixed(2);
+	const sourcePixels = typeof width === "number" && typeof height === "number" ? `${width}x${height}px` : "unknown";
+	const sourceWithFile = params.fileName ? `${params.fileName} ${sourcePixels}` : sourcePixels;
+	log.warn(`Image resize failed to fit limits: ${sourceWithFile} best=${formatBytesShort(best.byteLength)} limit=${formatBytesShort(params.maxBytes)}`, {
+		label: params.label,
+		fileName: params.fileName,
+		sourceMimeType: params.mimeType,
+		sourceWidth: width,
+		sourceHeight: height,
+		sourceBytes: buf.byteLength,
+		maxDimensionPx: params.maxDimensionPx,
+		maxBytes: params.maxBytes,
+		smallestCandidateBytes: best.byteLength,
+		triggerOverBytes: overBytes,
+		triggerOverDimensions: overDimensions
+	});
+	throw new Error(`Image could not be reduced below ${maxMb}MB (got ${gotMb}MB)`);
+}
+async function sanitizeContentBlocksImages(blocks, label, opts = {}) {
+	const maxDimensionPx = Math.max(opts.maxDimensionPx ?? MAX_IMAGE_DIMENSION_PX, 1);
+	const maxBytes = Math.max(opts.maxBytes ?? MAX_IMAGE_BYTES, 1);
+	const out = [];
+	let mediaPathHint;
+	for (const block of blocks) {
+		if (isTextBlock(block)) {
+			const mediaPath = parseMediaPathFromText(block.text);
+			if (mediaPath) mediaPathHint = mediaPath;
+		}
+		if (!isImageBlock(block)) {
+			out.push(block);
+			continue;
+		}
+		const data = block.data.trim();
+		if (!data) {
+			out.push({
+				type: "text",
+				text: `[${label}] omitted empty image payload`
+			});
+			continue;
+		}
+		const canonicalData = canonicalizeBase64(data);
+		if (!canonicalData) {
+			out.push({
+				type: "text",
+				text: `[${label}] omitted image payload: invalid base64`
+			});
+			continue;
+		}
+		try {
+			const mimeType = inferMimeTypeFromBase64(canonicalData) ?? block.mimeType;
+			const resized = await resizeImageBase64IfNeeded({
+				base64: canonicalData,
+				mimeType,
+				maxDimensionPx,
+				maxBytes,
+				label,
+				fileName: inferImageFileName({
+					block,
+					label,
+					mediaPathHint
+				})
+			});
+			out.push({
+				...block,
+				data: resized.base64,
+				mimeType: resized.resized ? resized.mimeType : mimeType
+			});
+		} catch (err) {
+			out.push({
+				type: "text",
+				text: `[${label}] omitted image payload: ${String(err)}`
+			});
+		}
+	}
+	return out;
+}
+async function sanitizeImageBlocks(images, label, opts = {}) {
+	if (images.length === 0) return {
+		images,
+		dropped: 0
+	};
+	const next = (await sanitizeContentBlocksImages(images, label, opts)).filter(isImageBlock);
+	return {
+		images: next,
+		dropped: Math.max(0, images.length - next.length)
+	};
+}
+async function sanitizeToolResultImages(result, label, opts = {}) {
+	const content = Array.isArray(result.content) ? result.content : [];
+	if (!content.some((b) => isImageBlock(b) || isTextBlock(b))) return result;
+	const next = await sanitizeContentBlocksImages(content, label, opts);
+	return {
+		...result,
+		content: next
+	};
+}
+//#endregion
+//#region src/param-key.ts
+function toSnakeCaseKey(key) {
+	return key.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function readSnakeCaseParamRaw(params, key) {
+	if (Object.hasOwn(params, key)) return params[key];
+	const snakeKey = toSnakeCaseKey(key);
+	if (snakeKey !== key && Object.hasOwn(params, snakeKey)) return params[snakeKey];
+}
+//#endregion
+//#region src/agents/tools/common.ts
+const OWNER_ONLY_TOOL_ERROR = "Tool restricted to owner senders.";
+var ToolInputError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.status = 400;
+		this.name = "ToolInputError";
+	}
+};
+var ToolAuthorizationError = class extends ToolInputError {
+	constructor(message) {
+		super(message);
+		this.status = 403;
+		this.name = "ToolAuthorizationError";
+	}
+};
+function createActionGate(actions) {
+	return (key, defaultValue = true) => {
+		const value = actions?.[key];
+		if (value === void 0) return defaultValue;
+		return value !== false;
+	};
+}
+function readParamRaw(params, key) {
+	return readSnakeCaseParamRaw(params, key);
+}
+function readStringParam(params, key, options = {}) {
+	const { required = false, trim = true, label = key, allowEmpty = false } = options;
+	const raw = readParamRaw(params, key);
+	if (typeof raw !== "string") {
+		if (required) throw new ToolInputError(`${label} required`);
+		return;
+	}
+	const value = trim ? raw.trim() : raw;
+	if (!value && !allowEmpty) {
+		if (required) throw new ToolInputError(`${label} required`);
+		return;
+	}
+	return value;
+}
+function readStringOrNumberParam(params, key, options = {}) {
+	const { required = false, label = key } = options;
+	const raw = readParamRaw(params, key);
+	if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
+	if (typeof raw === "string") {
+		const value = raw.trim();
+		if (value) return value;
+	}
+	if (required) throw new ToolInputError(`${label} required`);
+}
+function readNumberParam(params, key, options = {}) {
+	const { required = false, label = key, integer = false, strict = false } = options;
+	const raw = readParamRaw(params, key);
+	let value;
+	if (typeof raw === "number" && Number.isFinite(raw)) value = raw;
+	else if (typeof raw === "string") {
+		const trimmed = raw.trim();
+		if (trimmed) {
+			const parsed = strict ? Number(trimmed) : Number.parseFloat(trimmed);
+			if (Number.isFinite(parsed)) value = parsed;
+		}
+	}
+	if (value === void 0) {
+		if (required) throw new ToolInputError(`${label} required`);
+		return;
+	}
+	return integer ? Math.trunc(value) : value;
+}
+function readStringArrayParam(params, key, options = {}) {
+	const { required = false, label = key } = options;
+	const raw = readParamRaw(params, key);
+	if (Array.isArray(raw)) {
+		const values = raw.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
+		if (values.length === 0) {
+			if (required) throw new ToolInputError(`${label} required`);
+			return;
+		}
+		return values;
+	}
+	if (typeof raw === "string") {
+		const value = raw.trim();
+		if (!value) {
+			if (required) throw new ToolInputError(`${label} required`);
+			return;
+		}
+		return [value];
+	}
+	if (required) throw new ToolInputError(`${label} required`);
+}
+function readReactionParams(params, options) {
+	const emojiKey = options.emojiKey ?? "emoji";
+	const removeKey = options.removeKey ?? "remove";
+	const remove = typeof params[removeKey] === "boolean" ? params[removeKey] : false;
+	const emoji = readStringParam(params, emojiKey, {
+		required: true,
+		allowEmpty: true
+	});
+	if (remove && !emoji) throw new ToolInputError(options.removeErrorMessage);
+	return {
+		emoji,
+		remove,
+		isEmpty: !emoji
+	};
+}
+function jsonResult(payload) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(payload, null, 2)
+		}],
+		details: payload
+	};
+}
+function wrapOwnerOnlyToolExecution(tool, senderIsOwner) {
+	if (tool.ownerOnly !== true || senderIsOwner || !tool.execute) return tool;
+	return {
+		...tool,
+		execute: async () => {
+			throw new Error(OWNER_ONLY_TOOL_ERROR);
+		}
+	};
+}
+async function imageResult(params) {
+	const content = [...params.extraText ? [{
+		type: "text",
+		text: params.extraText
+	}] : [], {
+		type: "image",
+		data: params.base64,
+		mimeType: params.mimeType
+	}];
+	const detailsMedia = params.details?.media && typeof params.details.media === "object" && !Array.isArray(params.details.media) ? params.details.media : void 0;
+	return await sanitizeToolResultImages({
+		content,
+		details: {
+			path: params.path,
+			...params.details,
+			media: {
+				...detailsMedia,
+				mediaUrl: params.path
+			}
+		}
+	}, params.label, params.imageSanitization);
+}
+async function imageResultFromFile(params) {
+	const buf = await fs.readFile(params.path);
+	const mimeType = await detectMime({ buffer: buf.slice(0, 256) }) ?? "image/png";
+	return await imageResult({
+		label: params.label,
+		path: params.path,
+		base64: buf.toString("base64"),
+		mimeType,
+		extraText: params.extraText,
+		details: params.details,
+		imageSanitization: params.imageSanitization
+	});
+}
+/**
+* Validate and parse an `availableTags` parameter from untrusted input.
+* Returns `undefined` when the value is missing or not an array.
+* Entries that lack a string `name` are silently dropped.
+*/
+function parseAvailableTags(raw) {
+	if (raw === void 0 || raw === null) return;
+	if (!Array.isArray(raw)) return;
+	const result = raw.filter((t) => typeof t === "object" && t !== null && typeof t.name === "string").map((t) => ({
+		...t.id !== void 0 && typeof t.id === "string" ? { id: t.id } : {},
+		name: t.name,
+		...typeof t.moderated === "boolean" ? { moderated: t.moderated } : {},
+		...t.emoji_id === null || typeof t.emoji_id === "string" ? { emoji_id: t.emoji_id } : {},
+		...t.emoji_name === null || typeof t.emoji_name === "string" ? { emoji_name: t.emoji_name } : {}
+	}));
+	return result.length ? result : void 0;
+}
+//#endregion
+export { sanitizeImageBlocks as _, imageResult as a, canonicalizeBase64 as b, parseAvailableTags as c, readStringArrayParam as d, readStringOrNumberParam as f, sanitizeContentBlocksImages as g, readSnakeCaseParamRaw as h, createActionGate as i, readNumberParam as l, wrapOwnerOnlyToolExecution as m, ToolAuthorizationError as n, imageResultFromFile as o, readStringParam as p, ToolInputError as r, jsonResult as s, OWNER_ONLY_TOOL_ERROR as t, readReactionParams as u, sanitizeToolResultImages as v, estimateBase64DecodedBytes as x, resolveImageSanitizationLimits as y };

package/dist/compact.runtime-Djmzpbn6.js

@@ -0,0 +1,216 @@
+import "./src-CmXHIz5f.js";
+import "./redact-BDinS1q9.js";
+import "./errors-BxyFnvP3.js";
+import "./unhandled-rejections-CDJ8dOVP.js";
+import "./logger-CoEtkjhn.js";
+import "./paths-GHJ97ebE.js";
+import "./tmp-openclaw-dir-idKIOMmb.js";
+import "./theme-CdOoMzRk.js";
+import "./globals-41sdSaKv.js";
+import "./runtime-CT2LIJZu.js";
+import "./ansi-BEJF8NKS.js";
+import "./subsystem-CUp-6QQf.js";
+import "./boolean-DKtCJu_W.js";
+import "./env-BP70DGuy.js";
+import "./warning-filter-CgvLQB4Y.js";
+import "./utils-Bxk6BLTg.js";
+import "./links-Bilm-v0z.js";
+import "./paths-nCHyK08H.js";
+import "./auth-profiles-CWEIQV77.js";
+import "./boundary-path-B3FFLYNx.js";
+import "./boundary-file-read-BP6VMpqH.js";
+import "./logger-Cqy7-Maj.js";
+import "./exec-Dmex2w_d.js";
+import "./workspace-BH7CXmrr.js";
+import "./agent-scope-DPP4Z_UU.js";
+import "./model-selection-BTpJnslv.js";
+import "./io-jOnQRia2.js";
+import "./host-env-security-BogNN146.js";
+import "./shell-env-cD92jEyV.js";
+import "./safe-text-B_CQuica.js";
+import "./version-DCY9_obP.js";
+import "./env-substitution-D6t_sLS_.js";
+import "./includes-7XyL3p1c.js";
+import "./zod-schema.providers-core-Dgq7MTqU.js";
+import "./legacy-web-search-BgZjNG2h.js";
+import "./registry-rgYi7KoO.js";
+import "./config-state-CE0CGjey.js";
+import "./manifest-registry-B90TyTWl.js";
+import "./avatar-policy-Ds9e6uHI.js";
+import "./ip-C8vmzVu0.js";
+import "./zod-schema.agent-runtime-T_EC_6fg.js";
+import "./zod-schema.core-BdgRr-F1.js";
+import "./config-pn7LKJdW.js";
+import "./file-lock-WbEmczmY.js";
+import "./audit-fs-oDMUa5N_.js";
+import "./resolve-T2q_0ARF.js";
+import "./profiles-D17eMKQZ.js";
+import "./repair-qXnOAvDy.js";
+import "./tailscale-Cbsx-2HB.js";
+import "./tailnet-ofqBrXzu.js";
+import "./net-DlJFp95v.js";
+import "./auth-O6LQFLHJ.js";
+import "./credentials-BPwBlm1X.js";
+import "./message-channel-Cy-gN4K2.js";
+import "./store-CvL8MPei.js";
+import "./runtime-CuvWMN7E.js";
+import "./registry-C3q59Qj0.js";
+import "./plugins-1Z50ecJ6.js";
+import "./sessions-DaSBVNwD.js";
+import "./paths-CTjJI9l0.js";
+import "./session-write-lock-DNKvpjKf.js";
+import "./method-scopes-DgypDW23.js";
+import "./call-BmLt3xO1.js";
+import "./ports-lsof-DtJqhFOr.js";
+import "./restart-stale-pids-CLGiqU2E.js";
+import "./ports-DFiK_Jc-.js";
+import "./logging-CbTTfADU.js";
+import "./commands-Bb9xUwz9.js";
+import "./identity-cyBYcoXS.js";
+import "./secret-input-4REZ4sHo.js";
+import "./bindings-kjwuC11Q.js";
+import "./resolve-route-vEY3ONZ2.js";
+import "./routing-Y3m0o-kB.js";
+import "./base-session-key-Cf2rkwag.js";
+import "./token-Bgv8XEsC.js";
+import { l as compactEmbeddedPiSessionDirect$1 } from "./pi-embedded-CSQySvOV.js";
+import "./identity-file-EndG1nfc.js";
+import "./identity-DovQV4zD.js";
+import "./provider-env-vars-CsQlY7bF.js";
+import "./model-auth-env-CF9ts7Th.js";
+import "./anthropic-vertex-provider-Dd5agCN9.js";
+import "./model-auth-B__TJTPw.js";
+import "./kilocode-shared-DS7_0IMs.js";
+import "./provider-models-C2EjYMwW.js";
+import "./provider-model-allowlist-4HSOnlX-.js";
+import "./retry-D15TD1S3.js";
+import "./models-config.providers.discovery-BaIk1NKL.js";
+import "./state-paths-DJIGEFq_.js";
+import "./cli-runtime-aAVwbEYy.js";
+import "./runtime-env-a_iwdJIv.js";
+import "./diagnostic-DqJXx_4Q.js";
+import "./text-runtime-C_Roi_Je.js";
+import "./config-presence-BmUF_5K9.js";
+import "./thread-bindings-messages-Cdo8jSa9.js";
+import "./conversation-runtime-1O0Aaolb.js";
+import "./registry-CPsHw6xU.js";
+import "./internal-hooks-0uipqzRY.js";
+import "./http-registry-WFFbLYRd.js";
+import "./runtime-whatsapp-boundary-xZem0NyQ.js";
+import "./provider-catalog-D7QvsUXS.js";
+import "./provider-catalog-C5vmXjmb.js";
+import "./provider-catalog--18-pW5t.js";
+import "./tool-catalog-BV6FcEWS.js";
+import "./docker-XFNiArwM.js";
+import "./sandbox-CUUouiKs.js";
+import "./common-CUBlLRXB.js";
+import "./image-ops-j01UkxEv.js";
+import "./thinking-BBD_0HSp.js";
+import "./path-alias-guards-ZTKqurNH.js";
+import "./sandbox-paths-fqp_TZdO.js";
+import "./typebox-D0SHDJST.js";
+import "./mime-C4vVTBso.js";
+import "./ssrf-Dk9XaoKN.js";
+import "./fetch-guard-DIyN1HW5.js";
+import "./provider-web-search-NzK8ep1E.js";
+import "./manager-ChTGDe87.js";
+import "./heartbeat-7aHh0m3d.js";
+import "./typing-DG_YqWJ7.js";
+import "./target-registry-krAVlXi_.js";
+import "./external-content-BUdUOqkv.js";
+import "./brave-CkimJe4j.js";
+import "./channel-config-helpers-CieQWILI.js";
+import "./whatsapp-DXbWlm3A.js";
+import "./delegate-D4ql5N70.js";
+import "./config-schema-B1UGMwZ8.js";
+import "./secret-file-DYJtH6kf.js";
+import "./core-C7aHA4Aq.js";
+import "./security-runtime-BuEhpJVE.js";
+import "./pairing-store-C4lsd4pO.js";
+import "./json-store-O1LwpnBH.js";
+import "./dm-policy-shared-6bCJzHOS.js";
+import "./provider-auth-ref-BS3gwrNr.js";
+import "./provider-auth-input-BftBdgvW.js";
+import "./provider-auth-Bw8x1a3o.js";
+import "./provider-auth-helpers-B0dS-1WK.js";
+import "./provider-api-key-auth-BE0taXiB.js";
+import "./image-generation-CNKc-mFK.js";
+import "./shared-LeP8iUTz.js";
+import "./provider-usage-ClDVmkhl.js";
+import "./media-understanding-DD2uMjK8.js";
+import "./provider-onboard-CjOfyeQG.js";
+import "./perplexity-Beshd9zu.js";
+import "./provider-auth-api-key-BrQYvdxi.js";
+import "./command-secret-targets-COcwhn-D.js";
+import "./whatsapp-heartbeat-CSWnPQ7q.js";
+import "./fs-safe-D3qzH-ab.js";
+import "./web-media-CtU6jM5V.js";
+import "./local-roots-DAzCjWbC.js";
+import "./frontmatter-S5vS-I4a.js";
+import "./env-overrides-JneV60sd.js";
+import "./skills-CCgKs_NJ.js";
+import "./skill-commands-CiSwTFBQ.js";
+import "./workspace-dirs-_O4V3xCR.js";
+import "./pairing-token-gKj4SNFJ.js";
+import "./model-selection-Ci9cPkL2.js";
+import "./system-events-mAu6Ap6K.js";
+import "./pi-model-discovery-CuX5CDyZ.js";
+import "./message-hook-mappers-BBTV3JRQ.js";
+import "./delivery-queue-DrrqB4Hi.js";
+import "./channel-plugin-common-BhTxCE5t.js";
+import "./shared-BU0QgVMZ.js";
+import "./status-helpers-Cda-rGLX.js";
+import "./config-runtime-CstET7fq.js";
+import "./routes-TpLEcKO8.js";
+import "./media-limits-Cuvmmhop.js";
+import "./axios-xDDnM0KG.js";
+import "./manager-DuwFn87U.js";
+import "./web-media-BfBb8i48.js";
+import "./mentions-Bxys_va0.js";
+import "./commands-registry.data-XyUTELK9.js";
+import "./commands-registry-ChCep1KJ.js";
+import "./channel-inbound-DwzVf2PK.js";
+import "./config-DdDLrP_v.js";
+import "./ssh-tunnel-Cz51VBAt.js";
+import "./server-middleware-CCqKhKUb.js";
+import "./read-only-account-inspect-DPJzadPo.js";
+import "./channel-summary-CdYLGMVt.js";
+import "./channel-policy-C4GKHvhz.js";
+import "./resolve-utils-CbqJY2bs.js";
+import "./allow-from-C4iBpqFI.js";
+import "./channel-actions-DU2CR3xW.js";
+import "./exec-approvals-BJhuySBz.js";
+import "./exec-approvals-allowlist-B_wPddCb.js";
+import "./http-body-CCiSfloA.js";
+import "./ssrf-policy-Dk6oMa20.js";
+import "./history-CHjo8B5W.js";
+import "./reply-history-CVCD5oE9.js";
+import "./channel-reply-pipeline-CPTuaW8n.js";
+import "./exec-safe-bin-runtime-policy-BZkObC8r.js";
+import "./nodes-screen-CQ7IvP62.js";
+import "./system-run-command-Cxq2F1MB.js";
+import "./stagger-DU7FjHYo.js";
+import "./tool-policy-match-CHqTCSdK.js";
+import "./setup-binary-BOJA7zdN.js";
+import "./archive-Tr0wIUO-.js";
+import "./signal-cli-install-DxoL8CgF.js";
+import "./directory-runtime-DhC8QkMq.js";
+import "./timeouts-BwR1sGom.js";
+import "./outbound-runtime-ic_7ulJJ.js";
+import "./acp-runtime-BdLdT-QY.js";
+import "./gateway-runtime-ih2e7a2K.js";
+import "./connection-auth-BSQJeDOU.js";
+import "./discord-core-5tkl-BzP.js";
+import "./with-timeout-2AKTISee.js";
+import "./multimodal-DC43jYNv.js";
+import "./memory-search-Das1tiuB.js";
+import "./query-expansion-Do45hILP.js";
+import "./search-manager-r8Cw4ZRv.js";
+import "./memory-DBjQ0TPd.js";
+import "./mcp-config-Coky4zS4.js";
+//#region src/agents/pi-embedded-runner/compact.runtime.ts
+function compactEmbeddedPiSessionDirect(...args) {
+	return compactEmbeddedPiSessionDirect$1(...args);
+}
+//#endregion
+export { compactEmbeddedPiSessionDirect };