@pixelzx/genesis 2026.6.29 → 2026.7.9

package/dist/tool-policy-pipeline-BLtvEs31.js

@@ -0,0 +1,109 @@
+import { g as isKnownCoreToolId, o as expandPolicyWithPluginGroups, p as normalizeToolName, r as buildPluginToolGroups, t as analyzeAllowlistByToolType } from "./tool-policy-BIGITEMh.js";
+import { n as filterToolsByPolicy } from "./read-capability-YFf_CDLF.js";
+//#region src/agents/tool-policy-pipeline.ts
+const MAX_TOOL_POLICY_WARNING_CACHE = 256;
+const seenToolPolicyWarnings = /* @__PURE__ */ new Set();
+const toolPolicyWarningOrder = [];
+function rememberToolPolicyWarning(warning) {
+	if (seenToolPolicyWarnings.has(warning)) return false;
+	if (seenToolPolicyWarnings.size >= MAX_TOOL_POLICY_WARNING_CACHE) {
+		const oldest = toolPolicyWarningOrder.shift();
+		if (oldest) seenToolPolicyWarnings.delete(oldest);
+	}
+	seenToolPolicyWarnings.add(warning);
+	toolPolicyWarningOrder.push(warning);
+	return true;
+}
+function buildDefaultToolPolicyPipelineSteps(params) {
+	const agentId = params.agentId?.trim();
+	const profile = params.profile?.trim();
+	const providerProfile = params.providerProfile?.trim();
+	return [
+		{
+			policy: params.profilePolicy,
+			label: profile ? `tools.profile (${profile})` : "tools.profile",
+			stripPluginOnlyAllowlist: true,
+			suppressUnavailableCoreToolWarningAllowlist: params.profileUnavailableCoreWarningAllowlist
+		},
+		{
+			policy: params.providerProfilePolicy,
+			label: providerProfile ? `tools.byProvider.profile (${providerProfile})` : "tools.byProvider.profile",
+			stripPluginOnlyAllowlist: true,
+			suppressUnavailableCoreToolWarningAllowlist: params.providerProfileUnavailableCoreWarningAllowlist
+		},
+		{
+			policy: params.globalPolicy,
+			label: "tools.allow",
+			stripPluginOnlyAllowlist: true
+		},
+		{
+			policy: params.globalProviderPolicy,
+			label: "tools.byProvider.allow",
+			stripPluginOnlyAllowlist: true
+		},
+		{
+			policy: params.agentPolicy,
+			label: agentId ? `agents.${agentId}.tools.allow` : "agent tools.allow",
+			stripPluginOnlyAllowlist: true
+		},
+		{
+			policy: params.agentProviderPolicy,
+			label: agentId ? `agents.${agentId}.tools.byProvider.allow` : "agent tools.byProvider.allow",
+			stripPluginOnlyAllowlist: true
+		},
+		{
+			policy: params.groupPolicy,
+			label: "group tools.allow",
+			stripPluginOnlyAllowlist: true
+		}
+	];
+}
+function applyToolPolicyPipeline(params) {
+	const coreToolNames = new Set(params.tools.filter((tool) => !params.toolMeta(tool)).map((tool) => normalizeToolName(tool.name)).filter(Boolean));
+	const pluginGroups = buildPluginToolGroups({
+		tools: params.tools,
+		toolMeta: params.toolMeta
+	});
+	let filtered = params.tools;
+	for (const step of params.steps) {
+		if (!step.policy) continue;
+		let policy = step.policy;
+		if (step.stripPluginOnlyAllowlist) {
+			const resolved = analyzeAllowlistByToolType(policy, pluginGroups, coreToolNames);
+			if (resolved.unknownAllowlist.length > 0) {
+				const unavailableCoreWarningAllowlist = new Set((step.suppressUnavailableCoreToolWarningAllowlist ?? []).map((entry) => normalizeToolName(entry)));
+				const gatedCoreEntries = resolved.unknownAllowlist.filter((entry) => isKnownCoreToolId(entry));
+				const warnableGatedCoreEntries = step.suppressUnavailableCoreToolWarning ? [] : gatedCoreEntries.filter((entry) => !unavailableCoreWarningAllowlist.has(entry));
+				const otherEntries = resolved.unknownAllowlist.filter((entry) => !isKnownCoreToolId(entry) && !unavailableCoreWarningAllowlist.has(entry));
+				const warningEntries = [...warnableGatedCoreEntries, ...otherEntries];
+				if (shouldWarnAboutUnknownAllowlist({
+					hasGatedCoreEntries: warnableGatedCoreEntries.length > 0,
+					hasOtherEntries: otherEntries.length > 0
+				})) {
+					const entries = warningEntries.join(", ");
+					const suffix = describeUnknownAllowlistSuffix({
+						pluginOnlyAllowlist: resolved.pluginOnlyAllowlist,
+						hasGatedCoreEntries: warnableGatedCoreEntries.length > 0,
+						hasOtherEntries: otherEntries.length > 0
+					});
+					const warning = `tools: ${step.label} allowlist contains unknown entries (${entries}). ${suffix}`;
+					if (rememberToolPolicyWarning(warning)) params.warn(warning);
+				}
+			}
+			policy = resolved.policy;
+		}
+		const expanded = expandPolicyWithPluginGroups(policy, pluginGroups);
+		filtered = expanded ? filterToolsByPolicy(filtered, expanded) : filtered;
+	}
+	return filtered;
+}
+function shouldWarnAboutUnknownAllowlist(params) {
+	return params.hasGatedCoreEntries || params.hasOtherEntries;
+}
+function describeUnknownAllowlistSuffix(params) {
+	const preface = params.pluginOnlyAllowlist ? "Allowlist contains only plugin entries; core tools will not be available." : "";
+	const detail = params.hasGatedCoreEntries && params.hasOtherEntries ? "Some entries are shipped core tools but unavailable in the current runtime/provider/model/config; other entries won't match any tool unless the plugin is enabled." : params.hasGatedCoreEntries ? "These entries are shipped core tools but unavailable in the current runtime/provider/model/config." : "These entries won't match any tool unless the plugin is enabled.";
+	return preface ? `${preface} ${detail}` : detail;
+}
+//#endregion
+export { buildDefaultToolPolicyPipelineSteps as n, applyToolPolicyPipeline as t };

package/dist/tool-resolution-BpN_yXJT.js

@@ -0,0 +1,90 @@
+import { a as logWarn } from "./logger-BbnBrdB_.js";
+import { b as resolveAgentWorkspaceDir, x as resolveDefaultAgentId } from "./agent-scope-BUYwVohk.js";
+import { t as createGenesisTools } from "./genesis-tools-C0nPYE5t.js";
+import { c as mergeAlsoAllowPolicy, i as collectExplicitAllowlist, m as resolveToolProfilePolicy } from "./tool-policy-BIGITEMh.js";
+import { n as getPluginToolMeta } from "./tools-BfX2V_Rd.js";
+import { a as resolveGroupToolPolicy, o as resolveSubagentToolPolicyForSession, r as resolveEffectiveToolPolicy } from "./read-capability-YFf_CDLF.js";
+import { i as resolveSubagentCapabilityStore, t as isSubagentEnvelopeSession } from "./subagent-capabilities-DN1kjzNE.js";
+import { n as buildDefaultToolPolicyPipelineSteps, t as applyToolPolicyPipeline } from "./tool-policy-pipeline-BLtvEs31.js";
+import { t as DEFAULT_GATEWAY_HTTP_TOOL_DENY } from "./dangerous-tools-DTsU-3_q.js";
+//#region src/gateway/tool-resolution.ts
+function resolveGatewayScopedTools(params) {
+	const { agentId, globalPolicy, globalProviderPolicy, agentPolicy, agentProviderPolicy, profile, providerProfile, profileAlsoAllow, providerProfileAlsoAllow } = resolveEffectiveToolPolicy({
+		config: params.cfg,
+		sessionKey: params.sessionKey
+	});
+	const profilePolicy = resolveToolProfilePolicy(profile);
+	const providerProfilePolicy = resolveToolProfilePolicy(providerProfile);
+	const profilePolicyWithAlsoAllow = mergeAlsoAllowPolicy(profilePolicy, profileAlsoAllow);
+	const providerProfilePolicyWithAlsoAllow = mergeAlsoAllowPolicy(providerProfilePolicy, providerProfileAlsoAllow);
+	const groupPolicy = resolveGroupToolPolicy({
+		config: params.cfg,
+		sessionKey: params.sessionKey,
+		messageProvider: params.messageProvider,
+		accountId: params.accountId ?? null
+	});
+	const subagentStore = resolveSubagentCapabilityStore(params.sessionKey, { cfg: params.cfg });
+	const subagentPolicy = isSubagentEnvelopeSession(params.sessionKey, {
+		cfg: params.cfg,
+		store: subagentStore
+	}) ? resolveSubagentToolPolicyForSession(params.cfg, params.sessionKey, { store: subagentStore }) : void 0;
+	const workspaceDir = resolveAgentWorkspaceDir(params.cfg, agentId ?? resolveDefaultAgentId(params.cfg));
+	const policyFiltered = applyToolPolicyPipeline({
+		tools: createGenesisTools({
+			agentSessionKey: params.sessionKey,
+			agentChannel: params.messageProvider ?? void 0,
+			agentAccountId: params.accountId,
+			agentTo: params.agentTo,
+			agentThreadId: params.agentThreadId,
+			allowGatewaySubagentBinding: params.allowGatewaySubagentBinding,
+			allowMediaInvokeCommands: params.allowMediaInvokeCommands,
+			disablePluginTools: params.disablePluginTools,
+			senderIsOwner: params.senderIsOwner,
+			config: params.cfg,
+			workspaceDir,
+			pluginToolAllowlist: collectExplicitAllowlist([
+				profilePolicy,
+				providerProfilePolicy,
+				globalPolicy,
+				globalProviderPolicy,
+				agentPolicy,
+				agentProviderPolicy,
+				groupPolicy,
+				subagentPolicy
+			])
+		}),
+		toolMeta: (tool) => getPluginToolMeta(tool),
+		warn: logWarn,
+		steps: [...buildDefaultToolPolicyPipelineSteps({
+			profilePolicy: profilePolicyWithAlsoAllow,
+			profile,
+			profileUnavailableCoreWarningAllowlist: profilePolicy?.allow,
+			providerProfilePolicy: providerProfilePolicyWithAlsoAllow,
+			providerProfile,
+			providerProfileUnavailableCoreWarningAllowlist: providerProfilePolicy?.allow,
+			globalPolicy,
+			globalProviderPolicy,
+			agentPolicy,
+			agentProviderPolicy,
+			groupPolicy,
+			agentId
+		}), {
+			policy: subagentPolicy,
+			label: "subagent tools.allow"
+		}]
+	});
+	const surface = params.surface ?? "http";
+	const gatewayToolsCfg = params.cfg.gateway?.tools;
+	const defaultGatewayDeny = surface === "http" ? DEFAULT_GATEWAY_HTTP_TOOL_DENY.filter((name) => !gatewayToolsCfg?.allow?.includes(name)) : [];
+	const gatewayDenySet = new Set([
+		...defaultGatewayDeny,
+		...Array.isArray(gatewayToolsCfg?.deny) ? gatewayToolsCfg.deny : [],
+		...params.excludeToolNames ? Array.from(params.excludeToolNames) : []
+	]);
+	return {
+		agentId,
+		tools: policyFiltered.filter((tool) => !gatewayDenySet.has(tool.name))
+	};
+}
+//#endregion
+export { resolveGatewayScopedTools as t };

package/dist/tools-effective-inventory-DzZfmONO.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-DZSC_w6D.js";
+import { r as resolveEffectiveToolPolicy } from "./read-capability-YFf_CDLF.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-Cc5lWdVY.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-C1_80mqv.js";
+import { g as isKnownCoreToolId, n as applyOwnerOnlyToolPolicy } from "./tool-policy-BIGITEMh.js";
+import { i as runBeforeToolCallHook } from "./pi-tools.before-tool-call-BwU95vEl.js";
+import { r as ToolInputError } from "./common-C4_5xEM_.js";
+import { n as resolveToolLoopDetectionConfig } from "./pi-tools-DZSC_w6D.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-LFOvdepz.js";
+import { t as resolveGatewayScopedTools } from "./tool-resolution-BpN_yXJT.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/transcript-resolve.runtime-wnJiuCEb.js

@@ -0,0 +1,2 @@
+import { r as resolveSessionTranscriptFile } from "./transcript-yKXsllQ2.js";
+export { resolveSessionTranscriptFile };

package/dist/transcript-resolve.runtime.js

@@ -1 +1 @@
-export * from "./transcript-resolve.runtime-D4I8B--1.js";
+export * from "./transcript-resolve.runtime-wnJiuCEb.js";