squidclaw 3.0.32 → 3.0.34

package/dist/plugin-sdk/slack.js

@@ -4,7 +4,7 @@ import chalk, { Chalk } from "chalk";
 import fs from "node:fs";
 import { Logger } from "tslog";
 import os from "node:os";
-import json5 from "json5";
+import JSON5 from "json5";
 import { promisify } from "node:util";
 import fs$1 from "node:fs/promises";
 import { execFile, spawn } from "node:child_process";
@@ -758,7 +758,7 @@ function readLoggingConfig() {
 	try {
 		if (!fs.existsSync(configPath)) return;
 		const raw = fs.readFileSync(configPath, "utf-8");
-		const logging = json5.parse(raw)?.logging;
+		const logging = JSON5.parse(raw)?.logging;
 		if (!logging || typeof logging !== "object" || Array.isArray(logging)) return;
 		return logging;
 	} catch {

package/dist/plugin-sdk/slash-commands.runtime-Dbtq7ppF.js

@@ -0,0 +1,13 @@
+import "./run-with-concurrency-vfuRiXdY.js";
+import "./accounts-BXFDqY90.js";
+import "./paths-8xF5kDne.js";
+import "./github-copilot-token-Dy-0-Kh3.js";
+import "./config-B16xKqSo.js";
+import "./logger-DDdrdbDu.js";
+import "./thinking-DT2ZR60x.js";
+import "./plugins-rivB8KaQ.js";
+import "./accounts-DxiB_4z4.js";
+import "./accounts-DU7Js54-.js";
+import { f as resolveCommandArgMenu, n as findCommandByNativeName, s as listNativeCommandSpecsForConfig, t as buildCommandTextFromArgs, u as parseCommandArgs } from "./commands-registry-D0py59pz.js";
+
+export { buildCommandTextFromArgs, findCommandByNativeName, listNativeCommandSpecsForConfig, parseCommandArgs, resolveCommandArgMenu };

package/dist/plugin-sdk/slash-dispatch.runtime-BhAks953.js

@@ -0,0 +1,52 @@
+import "./run-with-concurrency-vfuRiXdY.js";
+import "./accounts-BXFDqY90.js";
+import { N as finalizeInboundContext, X as createReplyPrefixOptions, a as deliverSlackSlashReplies, m as dispatchReplyWithDispatcher, n as recordInboundSessionMetaSafe, v as resolveAgentRoute } from "./reply-DNSpho0-.js";
+import "./paths-8xF5kDne.js";
+import "./github-copilot-token-Dy-0-Kh3.js";
+import "./config-B16xKqSo.js";
+import "./logger-DDdrdbDu.js";
+import "./thinking-DT2ZR60x.js";
+import "./image-ops-BBY2fn9x.js";
+import { rn as resolveConversationLabel } from "./pi-embedded-helpers-BeYjP1MW.js";
+import "./plugins-rivB8KaQ.js";
+import "./accounts-DxiB_4z4.js";
+import "./accounts-DU7Js54-.js";
+import "./send-DFrnRiWm.js";
+import "./paths-CjFcHB_C.js";
+import "./fetch-B_RcOnt9.js";
+import "./redact-BoNEjbpF.js";
+import "./errors-B8oJXuCF.js";
+import "./channel-activity-Bq1Y9RiB.js";
+import "./path-alias-guards-BX-3FprC.js";
+import "./fs-safe-BW1ypSDS.js";
+import "./ssrf-DvsjfpC2.js";
+import "./fetch-guard-Cgyq6Jv9.js";
+import "./local-roots-C1ETRlaC.js";
+import { d as resolveChunkMode, i as resolveMarkdownTableMode } from "./ir-BJsqyZfm.js";
+import "./render-HmipMDlP.js";
+import "./tables-DNlQ8oQ3.js";
+import "./send-C4KxEJe1.js";
+import "./send-Dh1f5xjE.js";
+import "./tool-images-DroS1EaM.js";
+import "./target-errors-BlVYPwVC.js";
+import "./send-BSD6Pkrk.js";
+import "./audio-transcription-runner-jhHyCc_7.js";
+import "./tokens-CTIYTLWu.js";
+import "./skill-commands-CnqkEfhS.js";
+import "./skills-DSbDUvmU.js";
+import "./chrome-DOnBMnlx.js";
+import "./deliver-BqXXtIuw.js";
+import "./diagnostic-DUbajFSl.js";
+import "./store-DG90hxe6.js";
+import "./commands-registry-D0py59pz.js";
+import "./image-BPXnvxYL.js";
+import "./api-key-rotation-k1ZNheUH.js";
+import "./proxy-fetch-ZPEvp58f.js";
+import "./pi-model-discovery-B_qCKuSW.js";
+import "./send-D3XVKGvq.js";
+import "./outbound-attachment-BppFIMQa.js";
+import "./proxy-BKdNrmWL.js";
+import "./manager-Dn7j3n0d.js";
+import "./query-expansion-C1Nx0XAb.js";
+
+export { createReplyPrefixOptions, deliverSlackSlashReplies, dispatchReplyWithDispatcher, finalizeInboundContext, recordInboundSessionMetaSafe, resolveAgentRoute, resolveChunkMode, resolveConversationLabel, resolveMarkdownTableMode };

package/dist/plugin-sdk/slash-skill-commands.runtime-QGNWVO9S.js

@@ -0,0 +1,16 @@
+import "./run-with-concurrency-vfuRiXdY.js";
+import "./accounts-BXFDqY90.js";
+import "./paths-8xF5kDne.js";
+import "./github-copilot-token-Dy-0-Kh3.js";
+import "./config-B16xKqSo.js";
+import "./logger-DDdrdbDu.js";
+import "./thinking-DT2ZR60x.js";
+import "./plugins-rivB8KaQ.js";
+import "./accounts-DxiB_4z4.js";
+import "./accounts-DU7Js54-.js";
+import "./path-alias-guards-BX-3FprC.js";
+import { n as listSkillCommandsForAgents } from "./skill-commands-CnqkEfhS.js";
+import "./skills-DSbDUvmU.js";
+import "./commands-registry-D0py59pz.js";
+
+export { listSkillCommandsForAgents };

package/dist/plugin-sdk/ssrf-DvsjfpC2.js

@@ -0,0 +1,202 @@
+import { $ as parseCanonicalIpAddress, G as isBlockedSpecialUseIpv4Address, J as isIpv4Address, K as isBlockedSpecialUseIpv6Address, W as extractEmbeddedIpv4FromIpv6, Y as isLegacyIpv4Literal, et as parseLooseIpAddress, q as isCanonicalDottedDecimalIPv4 } from "./config-B16xKqSo.js";
+import { Agent } from "undici";
+import { lookup } from "node:dns";
+import { lookup as lookup$1 } from "node:dns/promises";
+
+//#region src/infra/net/proxy-env.ts
+const PROXY_ENV_KEYS = [
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"ALL_PROXY",
+	"http_proxy",
+	"https_proxy",
+	"all_proxy"
+];
+function hasProxyEnvConfigured(env = process.env) {
+	for (const key of PROXY_ENV_KEYS) {
+		const value = env[key];
+		if (typeof value === "string" && value.trim().length > 0) return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/infra/net/hostname.ts
+function normalizeHostname(hostname) {
+	const normalized = hostname.trim().toLowerCase().replace(/\.$/, "");
+	if (normalized.startsWith("[") && normalized.endsWith("]")) return normalized.slice(1, -1);
+	return normalized;
+}
+
+//#endregion
+//#region src/infra/net/ssrf.ts
+var SsrFBlockedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SsrFBlockedError";
+	}
+};
+const BLOCKED_HOSTNAMES = new Set([
+	"localhost",
+	"localhost.localdomain",
+	"metadata.google.internal"
+]);
+function normalizeHostnameSet(values) {
+	if (!values || values.length === 0) return /* @__PURE__ */ new Set();
+	return new Set(values.map((value) => normalizeHostname(value)).filter(Boolean));
+}
+function normalizeHostnameAllowlist(values) {
+	if (!values || values.length === 0) return [];
+	return Array.from(new Set(values.map((value) => normalizeHostname(value)).filter((value) => value !== "*" && value !== "*." && value.length > 0)));
+}
+function isPrivateNetworkAllowedByPolicy(policy) {
+	return policy?.dangerouslyAllowPrivateNetwork === true || policy?.allowPrivateNetwork === true;
+}
+function resolveIpv4SpecialUseBlockOptions(policy) {
+	return { allowRfc2544BenchmarkRange: policy?.allowRfc2544BenchmarkRange === true };
+}
+function isHostnameAllowedByPattern(hostname, pattern) {
+	if (pattern.startsWith("*.")) {
+		const suffix = pattern.slice(2);
+		if (!suffix || hostname === suffix) return false;
+		return hostname.endsWith(`.${suffix}`);
+	}
+	return hostname === pattern;
+}
+function matchesHostnameAllowlist(hostname, allowlist) {
+	if (allowlist.length === 0) return true;
+	return allowlist.some((pattern) => isHostnameAllowedByPattern(hostname, pattern));
+}
+function looksLikeUnsupportedIpv4Literal(address) {
+	const parts = address.split(".");
+	if (parts.length === 0 || parts.length > 4) return false;
+	if (parts.some((part) => part.length === 0)) return true;
+	return parts.every((part) => /^[0-9]+$/.test(part) || /^0x/i.test(part));
+}
+function isPrivateIpAddress(address, policy) {
+	let normalized = address.trim().toLowerCase();
+	if (normalized.startsWith("[") && normalized.endsWith("]")) normalized = normalized.slice(1, -1);
+	if (!normalized) return false;
+	const blockOptions = resolveIpv4SpecialUseBlockOptions(policy);
+	const strictIp = parseCanonicalIpAddress(normalized);
+	if (strictIp) {
+		if (isIpv4Address(strictIp)) return isBlockedSpecialUseIpv4Address(strictIp, blockOptions);
+		if (isBlockedSpecialUseIpv6Address(strictIp)) return true;
+		const embeddedIpv4 = extractEmbeddedIpv4FromIpv6(strictIp);
+		if (embeddedIpv4) return isBlockedSpecialUseIpv4Address(embeddedIpv4, blockOptions);
+		return false;
+	}
+	if (normalized.includes(":") && !parseLooseIpAddress(normalized)) return true;
+	if (!isCanonicalDottedDecimalIPv4(normalized) && isLegacyIpv4Literal(normalized)) return true;
+	if (looksLikeUnsupportedIpv4Literal(normalized)) return true;
+	return false;
+}
+function isBlockedHostname(hostname) {
+	const normalized = normalizeHostname(hostname);
+	if (!normalized) return false;
+	return isBlockedHostnameNormalized(normalized);
+}
+function isBlockedHostnameNormalized(normalized) {
+	if (BLOCKED_HOSTNAMES.has(normalized)) return true;
+	return normalized.endsWith(".localhost") || normalized.endsWith(".local") || normalized.endsWith(".internal");
+}
+function isBlockedHostnameOrIp(hostname, policy) {
+	const normalized = normalizeHostname(hostname);
+	if (!normalized) return false;
+	return isBlockedHostnameNormalized(normalized) || isPrivateIpAddress(normalized, policy);
+}
+const BLOCKED_HOST_OR_IP_MESSAGE = "Blocked hostname or private/internal/special-use IP address";
+const BLOCKED_RESOLVED_IP_MESSAGE = "Blocked: resolves to private/internal/special-use IP address";
+function assertAllowedHostOrIpOrThrow(hostnameOrIp, policy) {
+	if (isBlockedHostnameOrIp(hostnameOrIp, policy)) throw new SsrFBlockedError(BLOCKED_HOST_OR_IP_MESSAGE);
+}
+function assertAllowedResolvedAddressesOrThrow(results, policy) {
+	for (const entry of results) if (isBlockedHostnameOrIp(entry.address, policy)) throw new SsrFBlockedError(BLOCKED_RESOLVED_IP_MESSAGE);
+}
+function createPinnedLookup(params) {
+	const normalizedHost = normalizeHostname(params.hostname);
+	const fallback = params.fallback ?? lookup;
+	const fallbackLookup = fallback;
+	const fallbackWithOptions = fallback;
+	const records = params.addresses.map((address) => ({
+		address,
+		family: address.includes(":") ? 6 : 4
+	}));
+	let index = 0;
+	return ((host, options, callback) => {
+		const cb = typeof options === "function" ? options : callback;
+		if (!cb) return;
+		const normalized = normalizeHostname(host);
+		if (!normalized || normalized !== normalizedHost) {
+			if (typeof options === "function" || options === void 0) return fallbackLookup(host, cb);
+			return fallbackWithOptions(host, options, cb);
+		}
+		const opts = typeof options === "object" && options !== null ? options : {};
+		const requestedFamily = typeof options === "number" ? options : typeof opts.family === "number" ? opts.family : 0;
+		const candidates = requestedFamily === 4 || requestedFamily === 6 ? records.filter((entry) => entry.family === requestedFamily) : records;
+		const usable = candidates.length > 0 ? candidates : records;
+		if (opts.all) {
+			cb(null, usable);
+			return;
+		}
+		const chosen = usable[index % usable.length];
+		index += 1;
+		cb(null, chosen.address, chosen.family);
+	});
+}
+function dedupeAndPreferIpv4(results) {
+	const seen = /* @__PURE__ */ new Set();
+	const ipv4 = [];
+	const otherFamilies = [];
+	for (const entry of results) {
+		if (seen.has(entry.address)) continue;
+		seen.add(entry.address);
+		if (entry.family === 4) {
+			ipv4.push(entry.address);
+			continue;
+		}
+		otherFamilies.push(entry.address);
+	}
+	return [...ipv4, ...otherFamilies];
+}
+async function resolvePinnedHostnameWithPolicy(hostname, params = {}) {
+	const normalized = normalizeHostname(hostname);
+	if (!normalized) throw new Error("Invalid hostname");
+	const allowPrivateNetwork = isPrivateNetworkAllowedByPolicy(params.policy);
+	const allowedHostnames = normalizeHostnameSet(params.policy?.allowedHostnames);
+	const hostnameAllowlist = normalizeHostnameAllowlist(params.policy?.hostnameAllowlist);
+	const isExplicitAllowed = allowedHostnames.has(normalized);
+	const skipPrivateNetworkChecks = allowPrivateNetwork || isExplicitAllowed;
+	if (!matchesHostnameAllowlist(normalized, hostnameAllowlist)) throw new SsrFBlockedError(`Blocked hostname (not in allowlist): ${hostname}`);
+	if (!skipPrivateNetworkChecks) assertAllowedHostOrIpOrThrow(normalized, params.policy);
+	const results = await (params.lookupFn ?? lookup$1)(normalized, { all: true });
+	if (results.length === 0) throw new Error(`Unable to resolve hostname: ${hostname}`);
+	if (!skipPrivateNetworkChecks) assertAllowedResolvedAddressesOrThrow(results, params.policy);
+	const addresses = dedupeAndPreferIpv4(results);
+	if (addresses.length === 0) throw new Error(`Unable to resolve hostname: ${hostname}`);
+	return {
+		hostname: normalized,
+		addresses,
+		lookup: createPinnedLookup({
+			hostname: normalized,
+			addresses
+		})
+	};
+}
+function createPinnedDispatcher(pinned) {
+	return new Agent({ connect: { lookup: pinned.lookup } });
+}
+async function closeDispatcher(dispatcher) {
+	if (!dispatcher) return;
+	const candidate = dispatcher;
+	try {
+		if (typeof candidate.close === "function") {
+			await candidate.close();
+			return;
+		}
+		if (typeof candidate.destroy === "function") candidate.destroy();
+	} catch {}
+}
+
+//#endregion
+export { isBlockedHostnameOrIp as a, resolvePinnedHostnameWithPolicy as c, isBlockedHostname as i, normalizeHostname as l, closeDispatcher as n, isPrivateIpAddress as o, createPinnedDispatcher as r, isPrivateNetworkAllowedByPolicy as s, SsrFBlockedError as t, hasProxyEnvConfigured as u };

package/dist/plugin-sdk/store-DG90hxe6.js

@@ -0,0 +1,81 @@
+import { w as resolveConfigDir } from "./logger-DDdrdbDu.js";
+import { c as detectMime, l as extensionForMime } from "./image-ops-BBY2fn9x.js";
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import crypto from "node:crypto";
+import { pipeline } from "node:stream/promises";
+import { request } from "node:https";
+
+//#region src/media/store.ts
+const resolveMediaDir = () => path.join(resolveConfigDir(), "media");
+const MEDIA_MAX_BYTES = 5 * 1024 * 1024;
+const MAX_BYTES = MEDIA_MAX_BYTES;
+const DEFAULT_TTL_MS = 120 * 1e3;
+const MEDIA_FILE_MODE = 420;
+/**
+* Sanitize a filename for cross-platform safety.
+* Removes chars unsafe on Windows/SharePoint/all platforms.
+* Keeps: alphanumeric, dots, hyphens, underscores, Unicode letters/numbers.
+*/
+function sanitizeFilename(name) {
+	const trimmed = name.trim();
+	if (!trimmed) return "";
+	return trimmed.replace(/[^\p{L}\p{N}._-]+/gu, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 60);
+}
+/**
+* Extract original filename from path if it matches the embedded format.
+* Pattern: {original}---{uuid}.{ext} → returns "{original}.{ext}"
+* Falls back to basename if no pattern match, or "file.bin" if empty.
+*/
+function extractOriginalFilename(filePath) {
+	const basename = path.basename(filePath);
+	if (!basename) return "file.bin";
+	const ext = path.extname(basename);
+	const match = path.basename(basename, ext).match(/^(.+)---[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i);
+	if (match?.[1]) return `${match[1]}${ext}`;
+	return basename;
+}
+function getMediaDir() {
+	return resolveMediaDir();
+}
+async function ensureMediaDir() {
+	const mediaDir = resolveMediaDir();
+	await fs$1.mkdir(mediaDir, {
+		recursive: true,
+		mode: 448
+	});
+	return mediaDir;
+}
+async function saveMediaBuffer(buffer, contentType, subdir = "inbound", maxBytes = MAX_BYTES, originalFilename) {
+	if (buffer.byteLength > maxBytes) throw new Error(`Media exceeds ${(maxBytes / (1024 * 1024)).toFixed(0)}MB limit`);
+	const dir = path.join(resolveMediaDir(), subdir);
+	await fs$1.mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const uuid = crypto.randomUUID();
+	const headerExt = extensionForMime(contentType?.split(";")[0]?.trim() ?? void 0);
+	const mime = await detectMime({
+		buffer,
+		headerMime: contentType
+	});
+	const ext = headerExt ?? extensionForMime(mime) ?? "";
+	let id;
+	if (originalFilename) {
+		const base = path.parse(originalFilename).name;
+		const sanitized = sanitizeFilename(base);
+		id = sanitized ? `${sanitized}---${uuid}${ext}` : `${uuid}${ext}`;
+	} else id = ext ? `${uuid}${ext}` : uuid;
+	const dest = path.join(dir, id);
+	await fs$1.writeFile(dest, buffer, { mode: MEDIA_FILE_MODE });
+	return {
+		id,
+		path: dest,
+		size: buffer.byteLength,
+		contentType: mime
+	};
+}
+
+//#endregion
+export { saveMediaBuffer as a, getMediaDir as i, ensureMediaDir as n, extractOriginalFilename as r, MEDIA_MAX_BYTES as t };

package/dist/plugin-sdk/subagent-registry-runtime-Db83OZ3_.js

@@ -0,0 +1,52 @@
+import "./run-with-concurrency-vfuRiXdY.js";
+import "./accounts-BXFDqY90.js";
+import { C as countPendingDescendantRunsExcludingRun, S as countPendingDescendantRuns, T as resolveRequesterForChildSession, w as isSubagentSessionRunActive, x as countActiveDescendantRuns } from "./reply-DNSpho0-.js";
+import "./paths-8xF5kDne.js";
+import "./github-copilot-token-Dy-0-Kh3.js";
+import "./config-B16xKqSo.js";
+import "./logger-DDdrdbDu.js";
+import "./thinking-DT2ZR60x.js";
+import "./image-ops-BBY2fn9x.js";
+import "./pi-embedded-helpers-BeYjP1MW.js";
+import "./plugins-rivB8KaQ.js";
+import "./accounts-DxiB_4z4.js";
+import "./accounts-DU7Js54-.js";
+import "./send-DFrnRiWm.js";
+import "./paths-CjFcHB_C.js";
+import "./fetch-B_RcOnt9.js";
+import "./redact-BoNEjbpF.js";
+import "./errors-B8oJXuCF.js";
+import "./channel-activity-Bq1Y9RiB.js";
+import "./path-alias-guards-BX-3FprC.js";
+import "./fs-safe-BW1ypSDS.js";
+import "./ssrf-DvsjfpC2.js";
+import "./fetch-guard-Cgyq6Jv9.js";
+import "./local-roots-C1ETRlaC.js";
+import "./ir-BJsqyZfm.js";
+import "./render-HmipMDlP.js";
+import "./tables-DNlQ8oQ3.js";
+import "./send-C4KxEJe1.js";
+import "./send-Dh1f5xjE.js";
+import "./tool-images-DroS1EaM.js";
+import "./target-errors-BlVYPwVC.js";
+import "./send-BSD6Pkrk.js";
+import "./audio-transcription-runner-jhHyCc_7.js";
+import "./tokens-CTIYTLWu.js";
+import "./skill-commands-CnqkEfhS.js";
+import "./skills-DSbDUvmU.js";
+import "./chrome-DOnBMnlx.js";
+import "./deliver-BqXXtIuw.js";
+import "./diagnostic-DUbajFSl.js";
+import "./store-DG90hxe6.js";
+import "./commands-registry-D0py59pz.js";
+import "./image-BPXnvxYL.js";
+import "./api-key-rotation-k1ZNheUH.js";
+import "./proxy-fetch-ZPEvp58f.js";
+import "./pi-model-discovery-B_qCKuSW.js";
+import "./send-D3XVKGvq.js";
+import "./outbound-attachment-BppFIMQa.js";
+import "./proxy-BKdNrmWL.js";
+import "./manager-Dn7j3n0d.js";
+import "./query-expansion-C1Nx0XAb.js";
+
+export { countActiveDescendantRuns, countPendingDescendantRuns, countPendingDescendantRunsExcludingRun, isSubagentSessionRunActive, resolveRequesterForChildSession };

package/dist/plugin-sdk/tables-DNlQ8oQ3.js

@@ -0,0 +1,55 @@
+import { r as markdownToIRWithMeta } from "./ir-BJsqyZfm.js";
+import { t as renderMarkdownWithMarkers } from "./render-HmipMDlP.js";
+
+//#region src/markdown/tables.ts
+const MARKDOWN_STYLE_MARKERS = {
+	bold: {
+		open: "**",
+		close: "**"
+	},
+	italic: {
+		open: "_",
+		close: "_"
+	},
+	strikethrough: {
+		open: "~~",
+		close: "~~"
+	},
+	code: {
+		open: "`",
+		close: "`"
+	},
+	code_block: {
+		open: "```\n",
+		close: "```"
+	}
+};
+function convertMarkdownTables(markdown, mode) {
+	if (!markdown || mode === "off") return markdown;
+	const { ir, hasTables } = markdownToIRWithMeta(markdown, {
+		linkify: false,
+		autolink: false,
+		headingStyle: "none",
+		blockquotePrefix: "",
+		tableMode: mode
+	});
+	if (!hasTables) return markdown;
+	return renderMarkdownWithMarkers(ir, {
+		styleMarkers: MARKDOWN_STYLE_MARKERS,
+		escapeText: (text) => text,
+		buildLink: (link, text) => {
+			const href = link.href.trim();
+			if (!href) return null;
+			if (!text.slice(link.start, link.end)) return null;
+			return {
+				start: link.start,
+				end: link.end,
+				open: "[",
+				close: `](${href})`
+			};
+		}
+	});
+}
+
+//#endregion
+export { convertMarkdownTables as t };

package/dist/{target-errors-BMTA5KVE.js → plugin-sdk/target-errors-BlVYPwVC.js}

@@ -1,5 +1,5 @@
-import { b as detectMime } from "./image-ops-QLLBkxzG.js";
-import { r as sanitizeToolResultImages } from "./tool-images-HRwkh81U.js";
+import { c as detectMime } from "./image-ops-BBY2fn9x.js";
+import { r as sanitizeToolResultImages } from "./tool-images-DroS1EaM.js";
 import fs from "node:fs/promises";
 
 //#region src/agents/tools/common.ts