@pixelzx/genesis 2026.6.27 → 2026.6.29

package/dist/tools-effective-inventory-CLJ3nPbB.js

@@ -0,0 +1,152 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { b as resolveAgentWorkspaceDir, p as resolveSessionAgentId, y as resolveAgentDir } from "./agent-scope-BUYwVohk.js";
+import { n as extractModelCompat } from "./provider-model-compat-S7CWtyBC.js";
+import { n as getPluginToolMeta } from "./tools-BfX2V_Rd.js";
+import { n as getChannelAgentToolMeta } from "./channel-tools-D4VwiRtZ.js";
+import { r as resolveToolDisplay } from "./tool-display-D7v2v3qV.js";
+import { t as createGenesisCodingTools } from "./pi-tools-DyVcSRei.js";
+import { r as resolveEffectiveToolPolicy } from "./read-capability-w1W5sKua.js";
+import { t as resolveModel } from "./model-BMi7OTrg.js";
+import { n as summarizeToolDescriptionText } from "./tool-description-summary-BFU7Qtc8.js";
+//#region src/agents/tools-effective-inventory.ts
+function resolveEffectiveToolLabel(tool) {
+	const rawLabel = normalizeOptionalString(tool.label) ?? "";
+	if (rawLabel && normalizeLowercaseStringOrEmpty(rawLabel) !== normalizeLowercaseStringOrEmpty(tool.name)) return rawLabel;
+	return resolveToolDisplay({ name: tool.name }).title;
+}
+function resolveRawToolDescription(tool) {
+	return normalizeOptionalString(tool.description) ?? "";
+}
+function summarizeToolDescription(tool) {
+	return summarizeToolDescriptionText({
+		rawDescription: resolveRawToolDescription(tool),
+		displaySummary: tool.displaySummary
+	});
+}
+function resolveEffectiveToolSource(tool) {
+	const pluginMeta = getPluginToolMeta(tool);
+	if (pluginMeta) return {
+		source: "plugin",
+		pluginId: pluginMeta.pluginId
+	};
+	const channelMeta = getChannelAgentToolMeta(tool);
+	if (channelMeta) return {
+		source: "channel",
+		channelId: channelMeta.channelId
+	};
+	return { source: "core" };
+}
+function groupLabel(source) {
+	switch (source) {
+		case "plugin": return "Connected tools";
+		case "channel": return "Channel tools";
+		default: return "Built-in tools";
+	}
+}
+function disambiguateLabels(entries) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const entry of entries) counts.set(entry.label, (counts.get(entry.label) ?? 0) + 1);
+	return entries.map((entry) => {
+		if ((counts.get(entry.label) ?? 0) < 2) return entry;
+		const suffix = entry.pluginId ?? entry.channelId ?? entry.id;
+		return {
+			...entry,
+			label: `${entry.label} (${suffix})`
+		};
+	});
+}
+function resolveEffectiveModelCompat(params) {
+	const provider = params.modelProvider?.trim();
+	const modelId = params.modelId?.trim();
+	if (!provider || !modelId) return;
+	try {
+		return extractModelCompat(resolveModel(provider, modelId, params.agentDir, params.cfg).model);
+	} catch {
+		return;
+	}
+}
+function resolveEffectiveToolInventory(params) {
+	const agentId = params.agentId?.trim() || resolveSessionAgentId({
+		sessionKey: params.sessionKey,
+		config: params.cfg
+	});
+	const workspaceDir = params.workspaceDir ?? resolveAgentWorkspaceDir(params.cfg, agentId);
+	const agentDir = params.agentDir ?? resolveAgentDir(params.cfg, agentId);
+	const modelCompat = resolveEffectiveModelCompat({
+		cfg: params.cfg,
+		agentDir,
+		modelProvider: params.modelProvider,
+		modelId: params.modelId
+	});
+	const effectiveTools = createGenesisCodingTools({
+		agentId,
+		sessionKey: params.sessionKey,
+		workspaceDir,
+		agentDir,
+		config: params.cfg,
+		modelProvider: params.modelProvider,
+		modelId: params.modelId,
+		modelCompat,
+		messageProvider: params.messageProvider,
+		senderIsOwner: params.senderIsOwner,
+		senderId: params.senderId,
+		senderName: params.senderName ?? void 0,
+		senderUsername: params.senderUsername ?? void 0,
+		senderE164: params.senderE164 ?? void 0,
+		agentAccountId: params.accountId ?? void 0,
+		currentChannelId: params.currentChannelId,
+		currentThreadTs: params.currentThreadTs,
+		currentMessageId: params.currentMessageId,
+		groupId: params.groupId ?? void 0,
+		groupChannel: params.groupChannel ?? void 0,
+		groupSpace: params.groupSpace ?? void 0,
+		replyToMode: params.replyToMode,
+		allowGatewaySubagentBinding: true,
+		modelHasVision: params.modelHasVision,
+		requireExplicitMessageTarget: params.requireExplicitMessageTarget,
+		disableMessageTool: params.disableMessageTool
+	});
+	const effectivePolicy = resolveEffectiveToolPolicy({
+		config: params.cfg,
+		agentId,
+		sessionKey: params.sessionKey,
+		modelProvider: params.modelProvider,
+		modelId: params.modelId
+	});
+	const profile = effectivePolicy.providerProfile ?? effectivePolicy.profile ?? "full";
+	const entries = disambiguateLabels(effectiveTools.map((tool) => {
+		const source = resolveEffectiveToolSource(tool);
+		return Object.assign({
+			id: tool.name,
+			label: resolveEffectiveToolLabel(tool),
+			description: summarizeToolDescription(tool),
+			rawDescription: resolveRawToolDescription(tool) || summarizeToolDescription(tool)
+		}, source);
+	}).toSorted((a, b) => a.label.localeCompare(b.label)));
+	const groupsBySource = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const tools = groupsBySource.get(entry.source) ?? [];
+		tools.push(entry);
+		groupsBySource.set(entry.source, tools);
+	}
+	return {
+		agentId,
+		profile,
+		groups: [
+			"core",
+			"plugin",
+			"channel"
+		].map((source) => {
+			const tools = groupsBySource.get(source);
+			if (!tools || tools.length === 0) return null;
+			return {
+				id: source,
+				label: groupLabel(source),
+				source,
+				tools
+			};
+		}).filter((group) => group !== null)
+	};
+}
+//#endregion
+export { resolveEffectiveToolInventory as t };

package/dist/tools-invoke-http-DWbJzMo3.js

@@ -0,0 +1,206 @@
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DPP_aYVc.js";
+import { a as logWarn } from "./logger-BbnBrdB_.js";
+import { n as defaultSlotIdForKey } from "./slots-BpEPHdhK.js";
+import { i as isTestDefaultMemorySlotDisabled } from "./config-state-B_obBded.js";
+import { u as normalizeMessageChannel } from "./message-channel-8hna3ogc.js";
+import { i as resolveMainSessionKey } from "./main-session-DGV-IuVa.js";
+import "./sessions-kO7Dit6B.js";
+import { g as isKnownCoreToolId, n as applyOwnerOnlyToolPolicy } from "./tool-policy-BIGITEMh.js";
+import { i as runBeforeToolCallHook } from "./pi-tools.before-tool-call-BZ1PLh46.js";
+import { r as ToolInputError } from "./common-C4_5xEM_.js";
+import { n as resolveToolLoopDetectionConfig } from "./pi-tools-DyVcSRei.js";
+import { S as sendMethodNotAllowed, b as sendInvalidRequest, i as authorizeScopedGatewayHttpRequestOrReply, m as resolveOpenAiCompatibleHttpSenderIsOwner, p as resolveOpenAiCompatibleHttpOperatorScopes, s as getHeader, v as readJsonBodyOrError, x as sendJson } from "./http-utils-L02eBAVo.js";
+import { t as resolveGatewayScopedTools } from "./tool-resolution-BRHtzc7Q.js";
+//#region src/gateway/tools-invoke-http.ts
+const DEFAULT_BODY_BYTES = 2 * 1024 * 1024;
+const MEMORY_TOOL_NAMES = new Set(["memory_search", "memory_get"]);
+function resolveSessionKeyFromBody(body) {
+	if (typeof body.sessionKey === "string" && body.sessionKey.trim()) return body.sessionKey.trim();
+}
+function resolveMemoryToolDisableReasons(cfg) {
+	if (!process.env.VITEST) return [];
+	const reasons = [];
+	const plugins = cfg.plugins;
+	const slotRaw = plugins?.slots?.memory;
+	const slotDisabled = slotRaw === null || normalizeOptionalLowercaseString(slotRaw) === "none";
+	const pluginsDisabled = plugins?.enabled === false;
+	const defaultDisabled = isTestDefaultMemorySlotDisabled(cfg);
+	if (pluginsDisabled) reasons.push("plugins.enabled=false");
+	if (slotDisabled) reasons.push(slotRaw === null ? "plugins.slots.memory=null" : "plugins.slots.memory=\"none\"");
+	if (!pluginsDisabled && !slotDisabled && defaultDisabled) reasons.push("memory plugin disabled by test default");
+	return reasons;
+}
+function mergeActionIntoArgsIfSupported(params) {
+	const { toolSchema, action, args } = params;
+	if (!action) return args;
+	if (args.action !== void 0) return args;
+	const schemaObj = toolSchema;
+	if (!Boolean(schemaObj && typeof schemaObj === "object" && schemaObj.properties && "action" in schemaObj.properties)) return args;
+	return {
+		...args,
+		action
+	};
+}
+function getErrorMessage(err) {
+	if (err instanceof Error) return err.message || String(err);
+	if (typeof err === "string") return err;
+	return String(err);
+}
+function resolveToolInputErrorStatus(err) {
+	if (err instanceof ToolInputError) {
+		const status = err.status;
+		return typeof status === "number" ? status : 400;
+	}
+	if (typeof err !== "object" || err === null || !("name" in err)) return null;
+	const name = err.name;
+	if (name !== "ToolInputError" && name !== "ToolAuthorizationError") return null;
+	const status = err.status;
+	if (typeof status === "number") return status;
+	return name === "ToolAuthorizationError" ? 403 : 400;
+}
+async function handleToolsInvokeHttpRequest(req, res, opts) {
+	let url;
+	try {
+		url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+	} catch {
+		res.writeHead(400, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({
+			error: "bad_request",
+			message: "Invalid request URL"
+		}));
+		return true;
+	}
+	if (url.pathname !== "/tools/invoke") return false;
+	if (req.method !== "POST") {
+		sendMethodNotAllowed(res, "POST");
+		return true;
+	}
+	const authResult = await authorizeScopedGatewayHttpRequestOrReply({
+		req,
+		res,
+		auth: opts.auth,
+		trustedProxies: opts.trustedProxies,
+		allowRealIpFallback: opts.allowRealIpFallback,
+		rateLimiter: opts.rateLimiter,
+		operatorMethod: "agent",
+		resolveOperatorScopes: resolveOpenAiCompatibleHttpOperatorScopes
+	});
+	if (!authResult) return true;
+	const { cfg, requestAuth } = authResult;
+	const bodyUnknown = await readJsonBodyOrError(req, res, opts.maxBodyBytes ?? DEFAULT_BODY_BYTES);
+	if (bodyUnknown === void 0) return true;
+	const body = bodyUnknown ?? {};
+	const toolName = normalizeOptionalString(body.tool) ?? "";
+	if (!toolName) {
+		sendInvalidRequest(res, "tools.invoke requires body.tool");
+		return true;
+	}
+	if (process.env.VITEST && MEMORY_TOOL_NAMES.has(toolName)) {
+		const reasons = resolveMemoryToolDisableReasons(cfg);
+		if (reasons.length > 0) {
+			sendJson(res, 400, {
+				ok: false,
+				error: {
+					type: "invalid_request",
+					message: `memory tools are disabled in tests${reasons.length > 0 ? ` (${reasons.join(", ")})` : ""}. Enable by setting plugins.slots.memory="${defaultSlotIdForKey("memory")}" (and ensure plugins.enabled is not false).`
+				}
+			});
+			return true;
+		}
+	}
+	const action = normalizeOptionalString(body.action);
+	const argsRaw = body.args;
+	const args = argsRaw && typeof argsRaw === "object" && !Array.isArray(argsRaw) ? argsRaw : {};
+	const rawSessionKey = resolveSessionKeyFromBody(body);
+	const sessionKey = !rawSessionKey || rawSessionKey === "main" ? resolveMainSessionKey(cfg) : rawSessionKey;
+	const messageChannel = normalizeMessageChannel(getHeader(req, "x-genesis-message-channel") ?? "");
+	const accountId = normalizeOptionalString(getHeader(req, "x-genesis-account-id"));
+	const agentTo = normalizeOptionalString(getHeader(req, "x-genesis-message-to"));
+	const agentThreadId = normalizeOptionalString(getHeader(req, "x-genesis-thread-id"));
+	const senderIsOwner = resolveOpenAiCompatibleHttpSenderIsOwner(req, requestAuth);
+	const resolveTools = (disablePluginTools) => resolveGatewayScopedTools({
+		cfg,
+		sessionKey,
+		messageProvider: messageChannel ?? void 0,
+		accountId,
+		agentTo,
+		agentThreadId,
+		allowGatewaySubagentBinding: true,
+		allowMediaInvokeCommands: true,
+		surface: "http",
+		disablePluginTools,
+		senderIsOwner
+	});
+	const knownCoreTool = isKnownCoreToolId(toolName);
+	let { agentId, tools } = resolveTools(knownCoreTool);
+	if (knownCoreTool && !tools.some((candidate) => candidate.name === toolName)) ({agentId, tools} = resolveTools(false));
+	const tool = applyOwnerOnlyToolPolicy(tools, senderIsOwner).find((t) => t.name === toolName);
+	if (!tool) {
+		sendJson(res, 404, {
+			ok: false,
+			error: {
+				type: "not_found",
+				message: `Tool not available: ${toolName}`
+			}
+		});
+		return true;
+	}
+	try {
+		const gatewayTool = tool;
+		const toolCallId = `http-${Date.now()}`;
+		const hookResult = await runBeforeToolCallHook({
+			toolName,
+			params: mergeActionIntoArgsIfSupported({
+				toolSchema: gatewayTool.parameters,
+				action,
+				args
+			}),
+			toolCallId,
+			ctx: {
+				agentId,
+				sessionKey,
+				loopDetection: resolveToolLoopDetectionConfig({
+					cfg,
+					agentId
+				})
+			}
+		});
+		if (hookResult.blocked) {
+			sendJson(res, 403, {
+				ok: false,
+				error: {
+					type: "tool_call_blocked",
+					message: hookResult.reason
+				}
+			});
+			return true;
+		}
+		sendJson(res, 200, {
+			ok: true,
+			result: await gatewayTool.execute?.(toolCallId, hookResult.params)
+		});
+	} catch (err) {
+		const inputStatus = resolveToolInputErrorStatus(err);
+		if (inputStatus !== null) {
+			sendJson(res, inputStatus, {
+				ok: false,
+				error: {
+					type: "tool_error",
+					message: getErrorMessage(err) || "invalid tool arguments"
+				}
+			});
+			return true;
+		}
+		logWarn(`tools-invoke: tool execution failed: ${String(err)}`);
+		sendJson(res, 500, {
+			ok: false,
+			error: {
+				type: "tool_error",
+				message: "tool execution failed"
+			}
+		});
+	}
+	return true;
+}
+//#endregion
+export { handleToolsInvokeHttpRequest };

package/dist/trash-CvOmDpdP.js

@@ -0,0 +1,24 @@
+import { i as runExec } from "./exec-BbrLAvgI.js";
+import { i as generateSecureToken } from "./secure-random-uvU48bnb.js";
+import "./browser-node-runtime-BLHYH8YL.js";
+import "./browser-security-runtime-DXPHFJOj.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+//#region extensions/browser/src/browser/trash.ts
+async function movePathToTrash(targetPath) {
+	try {
+		await runExec("trash", [targetPath], { timeoutMs: 1e4 });
+		return targetPath;
+	} catch {
+		const trashDir = path.join(os.homedir(), ".Trash");
+		fs.mkdirSync(trashDir, { recursive: true });
+		const base = path.basename(targetPath);
+		let dest = path.join(trashDir, `${base}-${Date.now()}`);
+		if (fs.existsSync(dest)) dest = path.join(trashDir, `${base}-${Date.now()}-${generateSecureToken(6)}`);
+		fs.renameSync(targetPath, dest);
+		return dest;
+	}
+}
+//#endregion
+export { movePathToTrash as t };