@gaodefa/daocore 2026.5.29 → 2026.5.30

package/dist/acp-stateful-target-driver-DcC76aZW.js

@@ -0,0 +1,89 @@
+import { n as isAcpSessionKey } from "./session-key-utils-Ce_xWkNq.js";
+import { d as resolveAgentIdFromSessionKey } from "./session-key-Bte0mmcq.js";
+import { n as readAcpSessionEntry } from "./session-meta-D0EJkrLy.js";
+import { c as resolveConfiguredAcpBindingSpecFromRecord } from "./binding-registry-CE_PjTju.js";
+import { c as performGatewaySessionReset } from "./session-reset-service-DkepDoob.js";
+import { n as resolveConfiguredAcpBindingSpecBySessionKey } from "./persistent-bindings.resolve-CN05MbMT.js";
+import { n as ensureConfiguredAcpBindingSession, t as ensureConfiguredAcpBindingReady } from "./persistent-bindings.lifecycle-6mMJHv9-.js";
+//#region src/channels/plugins/acp-stateful-target-driver.ts
+function toAcpStatefulBindingTargetDescriptor(params) {
+	const sessionKey = params.sessionKey.trim();
+	if (!sessionKey) return null;
+	const metaAgentId = (readAcpSessionEntry({
+		...params,
+		sessionKey
+	})?.acp)?.agent?.trim();
+	if (metaAgentId) return {
+		kind: "stateful",
+		driverId: "acp",
+		sessionKey,
+		agentId: metaAgentId
+	};
+	const spec = resolveConfiguredAcpBindingSpecBySessionKey({
+		...params,
+		sessionKey
+	});
+	if (!spec) {
+		if (!isAcpSessionKey(sessionKey)) return null;
+		return {
+			kind: "stateful",
+			driverId: "acp",
+			sessionKey,
+			agentId: resolveAgentIdFromSessionKey(sessionKey)
+		};
+	}
+	return {
+		kind: "stateful",
+		driverId: "acp",
+		sessionKey,
+		agentId: spec.agentId,
+		...spec.label ? { label: spec.label } : {}
+	};
+}
+async function ensureAcpTargetReady(params) {
+	const configuredBinding = resolveConfiguredAcpBindingSpecFromRecord(params.bindingResolution.record);
+	if (!configuredBinding) return {
+		ok: false,
+		error: "Configured ACP binding unavailable"
+	};
+	return await ensureConfiguredAcpBindingReady({
+		cfg: params.cfg,
+		configuredBinding: {
+			spec: configuredBinding,
+			record: params.bindingResolution.record
+		}
+	});
+}
+async function ensureAcpTargetSession(params) {
+	const spec = resolveConfiguredAcpBindingSpecFromRecord(params.bindingResolution.record);
+	if (!spec) return {
+		ok: false,
+		sessionKey: params.bindingResolution.statefulTarget.sessionKey,
+		error: "Configured ACP binding unavailable"
+	};
+	return await ensureConfiguredAcpBindingSession({
+		cfg: params.cfg,
+		spec
+	});
+}
+async function resetAcpTargetInPlace(params) {
+	const result = await performGatewaySessionReset({
+		key: params.sessionKey,
+		reason: params.reason,
+		commandSource: params.commandSource ?? "stateful-target:acp-reset-in-place"
+	});
+	if (result.ok) return { ok: true };
+	return {
+		ok: false,
+		error: result.error.message
+	};
+}
+const acpStatefulBindingTargetDriver = {
+	id: "acp",
+	ensureReady: ensureAcpTargetReady,
+	ensureSession: ensureAcpTargetSession,
+	resolveTargetBySessionKey: toAcpStatefulBindingTargetDescriptor,
+	resetInPlace: resetAcpTargetInPlace
+};
+//#endregion
+export { acpStatefulBindingTargetDriver };

package/dist/action-kill-D-dVisIX.js

@@ -0,0 +1,33 @@
+import { i as killControlledSubagentRun, r as killAllControlledSubagentRuns } from "./subagent-control-IyFIvc7T.js";
+import { c as resolveSubagentEntryForToken, i as resolveCommandSubagentController, u as stopWithText } from "./shared-DYxQJxpN.js";
+import "./commands-subagents-control.runtime-DGybTjJ6.js";
+//#region src/auto-reply/reply/commands-subagents/action-kill.ts
+async function handleSubagentsKillAction(ctx) {
+	const { params, handledPrefix, requesterKey, runs, restTokens } = ctx;
+	const target = restTokens[0];
+	if (!target) return stopWithText(handledPrefix === "/subagents" ? "Usage: /subagents kill <id|#|all>" : "Usage: /kill <id|#|all>");
+	if (target === "all" || target === "*") {
+		const controller = resolveCommandSubagentController(params, requesterKey);
+		const result = await killAllControlledSubagentRuns({
+			cfg: params.cfg,
+			controller,
+			runs
+		});
+		if (result.status === "forbidden") return stopWithText(`⚠️ ${result.error}`);
+		if (result.killed > 0) return { shouldContinue: false };
+		return { shouldContinue: false };
+	}
+	const targetResolution = resolveSubagentEntryForToken(runs, target);
+	if ("reply" in targetResolution) return targetResolution.reply;
+	const controller = resolveCommandSubagentController(params, requesterKey);
+	const result = await killControlledSubagentRun({
+		cfg: params.cfg,
+		controller,
+		entry: targetResolution.entry
+	});
+	if (result.status === "forbidden") return stopWithText(`⚠️ ${result.error}`);
+	if (result.status === "done") return stopWithText(result.text);
+	return { shouldContinue: false };
+}
+//#endregion
+export { handleSubagentsKillAction };

package/dist/action-runtime-BEiqwxDD.js

@@ -0,0 +1,469 @@
+import { f as renderMessagePresentationFallbackText, l as normalizeMessagePresentation } from "./payload-BDV15CYA.js";
+import { c as jsonResult, f as readNumberParam, g as readStringParam, h as readStringOrNumberParam, m as readStringArrayParam, p as readReactionParams } from "./common-vJyw6dD-.js";
+import { r as resolvePollMaxSelections } from "./polls-C-v11_tu.js";
+import { t as readBooleanParam } from "./boolean-param-Ch5dc2FQ.js";
+import { t as resolveTelegramToken } from "./token-BbGCANnE.js";
+import { r as resolveReactionMessageId } from "./channel-actions-BEsMIO8Q.js";
+import { c as resolveTelegramPollActionGateState, t as createTelegramActionGate } from "./accounts-CuvH2tuN.js";
+import { a as resolveTelegramTargetChatType, i as parseTelegramTarget } from "./targets-D0gFWyUZ.js";
+import { r as resolveTelegramInlineButtonsScope } from "./inline-buttons-B6zgQW3J.js";
+import { t as resolveTelegramInlineButtons } from "./button-types-C0Gyj4Tz.js";
+import { t as resolveTelegramInteractiveTextFallback } from "./interactive-fallback-hkNKT0cd.js";
+import { t as resolveTelegramReactionLevel } from "./reaction-level-C8Mqxizo.js";
+import { i as getCacheStats, o as searchStickers } from "./sticker-cache-91Tp8mLP.js";
+import { a as editMessageTelegram, d as sendPollTelegram, f as sendStickerTelegram, n as deleteMessageTelegram, o as pinMessageTelegram, r as editForumTopicTelegram, s as reactMessageTelegram, t as createForumTopicTelegram, u as sendMessageTelegram } from "./send-4dLa-BQo.js";
+import { t as resolveTelegramPollVisibility } from "./poll-visibility-Ds4ydsWS.js";
+import { n as notifyTelegramInboundEventOutboundSuccess } from "./inbound-event-delivery-CU-tJK1Q.js";
+//#region extensions/telegram/src/action-runtime.ts
+const telegramActionRuntime = {
+	createForumTopicTelegram,
+	deleteMessageTelegram,
+	editForumTopicTelegram,
+	editMessageTelegram,
+	getCacheStats,
+	pinMessageTelegram,
+	reactMessageTelegram,
+	searchStickers,
+	sendMessageTelegram,
+	sendPollTelegram,
+	sendStickerTelegram
+};
+const TELEGRAM_FORUM_TOPIC_ICON_COLORS = [
+	7322096,
+	16766590,
+	13338331,
+	9367192,
+	16749490,
+	16478047
+];
+const TELEGRAM_ACTION_ALIASES = {
+	createForumTopic: "createForumTopic",
+	delete: "deleteMessage",
+	deleteMessage: "deleteMessage",
+	edit: "editMessage",
+	editForumTopic: "editForumTopic",
+	editMessage: "editMessage",
+	poll: "poll",
+	react: "react",
+	searchSticker: "searchSticker",
+	send: "sendMessage",
+	sendMessage: "sendMessage",
+	sendSticker: "sendSticker",
+	sticker: "sendSticker",
+	stickerCacheStats: "stickerCacheStats",
+	"sticker-search": "searchSticker",
+	"topic-create": "createForumTopic",
+	"topic-edit": "editForumTopic"
+};
+function readTelegramForumTopicIconColor(params) {
+	const iconColor = readNumberParam(params, "iconColor", { integer: true });
+	if (iconColor == null) return;
+	if (!TELEGRAM_FORUM_TOPIC_ICON_COLORS.includes(iconColor)) throw new Error("iconColor must be one of Telegram's supported forum topic colors.");
+	return iconColor;
+}
+function normalizeTelegramActionName(action) {
+	const normalized = TELEGRAM_ACTION_ALIASES[action];
+	if (!normalized) throw new Error(`Unsupported Telegram action: ${action}`);
+	return normalized;
+}
+function readTelegramChatId(params) {
+	return readStringOrNumberParam(params, "chatId") ?? readStringOrNumberParam(params, "channelId") ?? readStringOrNumberParam(params, "to", { required: true });
+}
+function readTelegramThreadId(params) {
+	return readNumberParam(params, "messageThreadId", { integer: true }) ?? readNumberParam(params, "threadId", { integer: true });
+}
+function formatTelegramDeliveryTarget(to, messageThreadId) {
+	const parsed = parseTelegramTarget(to);
+	const topicId = parsed.messageThreadId ?? messageThreadId;
+	if (topicId == null) return to;
+	return `${parsed.chatId}:topic:${topicId}`;
+}
+function readTelegramReplyToMessageId(params) {
+	return readNumberParam(params, "replyToMessageId", { integer: true }) ?? readNumberParam(params, "replyTo", { integer: true });
+}
+function resolveTelegramButtonsFromParams(params, presentation = normalizeMessagePresentation(params.presentation)) {
+	return resolveTelegramInlineButtons({
+		presentation,
+		interactive: params.interactive
+	});
+}
+function readTelegramSendContent(params) {
+	const explicitContent = readStringParam(params.args, "content", { allowEmpty: true }) ?? readStringParam(params.args, "message", { allowEmpty: true }) ?? readStringParam(params.args, "caption", { allowEmpty: true });
+	const presentationText = explicitContent == null && params.presentation ? renderMessagePresentationFallbackText({ presentation: params.presentation }) : void 0;
+	const interactiveText = explicitContent == null && !params.presentation ? resolveTelegramInteractiveTextFallback({ interactive: params.interactive }) : void 0;
+	let content = explicitContent ?? (presentationText?.trim() ? presentationText : void 0) ?? (interactiveText?.trim() ? interactiveText : void 0);
+	if ((content == null || content.trim().length === 0) && !params.mediaUrl && params.hasButtons) {
+		const fallback = presentationText?.trim() ? presentationText : interactiveText;
+		if (fallback?.trim()) content = fallback;
+	}
+	if (content == null && !params.mediaUrl && !params.hasButtons) throw new Error("content required.");
+	return content ?? "";
+}
+function normalizeTelegramDeliveryPin(params) {
+	const delivery = params.delivery;
+	const pin = delivery && typeof delivery === "object" && !Array.isArray(delivery) ? delivery.pin : params.pin === true ? true : void 0;
+	if (pin === true) return { enabled: true };
+	if (!pin || typeof pin !== "object" || Array.isArray(pin)) return;
+	const raw = pin;
+	if (raw.enabled !== true) return;
+	return {
+		enabled: true,
+		...raw.notify === true ? { notify: true } : {},
+		...raw.required === true ? { required: true } : {}
+	};
+}
+async function maybePinTelegramActionSend(params) {
+	const pin = normalizeTelegramDeliveryPin(params.args);
+	if (!pin) return;
+	if (!params.messageId) {
+		if (pin.required) throw new Error("Telegram delivery pin requested, but no message id was returned.");
+		return;
+	}
+	try {
+		await telegramActionRuntime.pinMessageTelegram(params.to, params.messageId, {
+			cfg: params.cfg,
+			accountId: params.accountId,
+			notify: pin.notify,
+			verbose: false,
+			gatewayClientScopes: params.gatewayClientScopes
+		});
+	} catch (err) {
+		if (pin.required) throw err;
+	}
+}
+async function handleTelegramAction(params, cfg, options) {
+	const { action, accountId } = {
+		action: normalizeTelegramActionName(readStringParam(params, "action", { required: true })),
+		accountId: readStringParam(params, "accountId")
+	};
+	const isActionEnabled = createTelegramActionGate({
+		cfg,
+		accountId
+	});
+	const notifyVisibleOutboundSuccess = (to, messageThreadId) => {
+		notifyTelegramInboundEventOutboundSuccess({
+			sessionKey: options?.sessionKey ?? void 0,
+			to: formatTelegramDeliveryTarget(to, messageThreadId),
+			accountId,
+			inboundEventKind: options?.inboundEventKind
+		});
+	};
+	if (action === "react") {
+		const reactionLevelInfo = resolveTelegramReactionLevel({
+			cfg,
+			accountId: accountId ?? void 0
+		});
+		if (!reactionLevelInfo.agentReactionsEnabled) return jsonResult({
+			ok: false,
+			reason: "disabled",
+			hint: `Telegram agent reactions disabled (reactionLevel="${reactionLevelInfo.level}"). Do not retry.`
+		});
+		if (!isActionEnabled("reactions")) return jsonResult({
+			ok: false,
+			reason: "disabled",
+			hint: "Telegram reactions are disabled via actions.reactions. Do not retry."
+		});
+		const chatId = readTelegramChatId(params);
+		const messageId = readNumberParam(params, "messageId", { integer: true }) ?? resolveReactionMessageId({ args: params });
+		if (typeof messageId !== "number" || !Number.isFinite(messageId) || messageId <= 0) return jsonResult({
+			ok: false,
+			reason: "missing_message_id",
+			hint: "Telegram reaction requires a valid messageId (or inbound context fallback). Do not retry."
+		});
+		const { emoji, remove, isEmpty } = readReactionParams(params, { removeErrorMessage: "Emoji is required to remove a Telegram reaction." });
+		const token = resolveTelegramToken(cfg, { accountId }).token;
+		if (!token) return jsonResult({
+			ok: false,
+			reason: "missing_token",
+			hint: "Telegram bot token missing. Do not retry."
+		});
+		let reactionResult;
+		try {
+			reactionResult = await telegramActionRuntime.reactMessageTelegram(chatId ?? "", messageId ?? 0, emoji ?? "", {
+				cfg,
+				token,
+				remove,
+				accountId: accountId ?? void 0,
+				gatewayClientScopes: options?.gatewayClientScopes
+			});
+		} catch (err) {
+			const isInvalid = String(err).includes("REACTION_INVALID");
+			return jsonResult({
+				ok: false,
+				reason: isInvalid ? "REACTION_INVALID" : "error",
+				emoji,
+				hint: isInvalid ? "This emoji is not supported for Telegram reactions. Add it to your reaction disallow list so you do not try it again." : "Reaction failed. Do not retry."
+			});
+		}
+		if (!reactionResult.ok) return jsonResult({
+			ok: false,
+			warning: reactionResult.warning,
+			...remove || isEmpty ? { removed: true } : { added: emoji }
+		});
+		if (!remove && !isEmpty) return jsonResult({
+			ok: true,
+			added: emoji
+		});
+		return jsonResult({
+			ok: true,
+			removed: true
+		});
+	}
+	if (action === "sendMessage") {
+		if (!isActionEnabled("sendMessage")) throw new Error("Telegram sendMessage is disabled.");
+		const to = readStringParam(params, "to", { required: true });
+		const mediaUrl = readStringParam(params, "mediaUrl") ?? readStringParam(params, "media", { trim: false });
+		const presentation = normalizeMessagePresentation(params.presentation);
+		const buttons = resolveTelegramButtonsFromParams(params, presentation);
+		const content = readTelegramSendContent({
+			args: params,
+			mediaUrl: mediaUrl ?? void 0,
+			hasButtons: Array.isArray(buttons) && buttons.length > 0,
+			interactive: params.interactive,
+			presentation
+		});
+		if (buttons) {
+			const inlineButtonsScope = resolveTelegramInlineButtonsScope({
+				cfg,
+				accountId: accountId ?? void 0
+			});
+			if (inlineButtonsScope === "off") throw new Error("Telegram inline buttons are disabled. Set channels.telegram.capabilities.inlineButtons to \"dm\", \"group\", \"all\", or \"allowlist\".");
+			if (inlineButtonsScope === "dm" || inlineButtonsScope === "group") {
+				const targetType = resolveTelegramTargetChatType(to);
+				if (targetType === "unknown") throw new Error(`Telegram inline buttons require a numeric chat id when inlineButtons="${inlineButtonsScope}".`);
+				if (inlineButtonsScope === "dm" && targetType !== "direct") throw new Error("Telegram inline buttons are limited to DMs when inlineButtons=\"dm\".");
+				if (inlineButtonsScope === "group" && targetType !== "group") throw new Error("Telegram inline buttons are limited to groups when inlineButtons=\"group\".");
+			}
+		}
+		const replyToMessageId = readTelegramReplyToMessageId(params);
+		const messageThreadId = readTelegramThreadId(params);
+		const quoteText = readStringParam(params, "quoteText");
+		const token = resolveTelegramToken(cfg, { accountId }).token;
+		if (!token) throw new Error("Telegram bot token missing. Set TELEGRAM_BOT_TOKEN or channels.telegram.botToken.");
+		const result = await telegramActionRuntime.sendMessageTelegram(to, content, {
+			cfg,
+			token,
+			accountId: accountId ?? void 0,
+			mediaUrl: mediaUrl || void 0,
+			mediaLocalRoots: options?.mediaLocalRoots,
+			mediaReadFile: options?.mediaReadFile,
+			gatewayClientScopes: options?.gatewayClientScopes,
+			buttons,
+			replyToMessageId: replyToMessageId ?? void 0,
+			messageThreadId: messageThreadId ?? void 0,
+			quoteText: quoteText ?? void 0,
+			asVoice: readBooleanParam(params, "asVoice"),
+			silent: readBooleanParam(params, "silent"),
+			forceDocument: readBooleanParam(params, "forceDocument") ?? readBooleanParam(params, "asDocument") ?? false
+		});
+		notifyVisibleOutboundSuccess(to, messageThreadId);
+		await maybePinTelegramActionSend({
+			args: params,
+			cfg,
+			accountId: accountId ?? void 0,
+			to,
+			messageId: result.messageId,
+			gatewayClientScopes: options?.gatewayClientScopes
+		});
+		return jsonResult({
+			ok: true,
+			messageId: result.messageId,
+			chatId: result.chatId
+		});
+	}
+	if (action === "poll") {
+		const pollActionState = resolveTelegramPollActionGateState(isActionEnabled);
+		if (!pollActionState.sendMessageEnabled) throw new Error("Telegram sendMessage is disabled.");
+		if (!pollActionState.pollEnabled) throw new Error("Telegram polls are disabled.");
+		const to = readStringParam(params, "to", { required: true });
+		const question = readStringParam(params, "question") ?? readStringParam(params, "pollQuestion", { required: true });
+		const answers = readStringArrayParam(params, "answers") ?? readStringArrayParam(params, "pollOption", { required: true });
+		const allowMultiselect = readBooleanParam(params, "allowMultiselect") ?? readBooleanParam(params, "pollMulti");
+		const durationSeconds = readNumberParam(params, "durationSeconds", { integer: true }) ?? readNumberParam(params, "pollDurationSeconds", {
+			integer: true,
+			strict: true
+		});
+		const durationHours = readNumberParam(params, "durationHours", { integer: true }) ?? readNumberParam(params, "pollDurationHours", {
+			integer: true,
+			strict: true
+		});
+		const replyToMessageId = readTelegramReplyToMessageId(params);
+		const messageThreadId = readTelegramThreadId(params);
+		const isAnonymous = readBooleanParam(params, "isAnonymous") ?? resolveTelegramPollVisibility({
+			pollAnonymous: readBooleanParam(params, "pollAnonymous"),
+			pollPublic: readBooleanParam(params, "pollPublic")
+		});
+		const silent = readBooleanParam(params, "silent");
+		const token = resolveTelegramToken(cfg, { accountId }).token;
+		if (!token) throw new Error("Telegram bot token missing. Set TELEGRAM_BOT_TOKEN or channels.telegram.botToken.");
+		const result = await telegramActionRuntime.sendPollTelegram(to, {
+			question,
+			options: answers,
+			maxSelections: resolvePollMaxSelections(answers.length, allowMultiselect ?? false),
+			durationSeconds: durationSeconds ?? void 0,
+			durationHours: durationHours ?? void 0
+		}, {
+			cfg,
+			token,
+			accountId: accountId ?? void 0,
+			replyToMessageId: replyToMessageId ?? void 0,
+			messageThreadId: messageThreadId ?? void 0,
+			isAnonymous: isAnonymous ?? void 0,
+			silent: silent ?? void 0,
+			gatewayClientScopes: options?.gatewayClientScopes
+		});
+		notifyVisibleOutboundSuccess(to, messageThreadId);
+		return jsonResult({
+			ok: true,
+			messageId: result.messageId,
+			chatId: result.chatId,
+			pollId: result.pollId
+		});
+	}
+	if (action === "deleteMessage") {
+		if (!isActionEnabled("deleteMessage")) throw new Error("Telegram deleteMessage is disabled.");
+		const chatId = readTelegramChatId(params);
+		const messageId = readNumberParam(params, "messageId", {
+			required: true,
+			integer: true
+		});
+		const token = resolveTelegramToken(cfg, { accountId }).token;
+		if (!token) throw new Error("Telegram bot token missing. Set TELEGRAM_BOT_TOKEN or channels.telegram.botToken.");
+		const result = await telegramActionRuntime.deleteMessageTelegram(chatId ?? "", messageId ?? 0, {
+			cfg,
+			token,
+			accountId: accountId ?? void 0,
+			gatewayClientScopes: options?.gatewayClientScopes
+		});
+		if (!result.ok) return jsonResult({
+			ok: false,
+			deleted: false,
+			warning: result.warning
+		});
+		return jsonResult({
+			ok: true,
+			deleted: true
+		});
+	}
+	if (action === "editMessage") {
+		if (!isActionEnabled("editMessage")) throw new Error("Telegram editMessage is disabled.");
+		const chatId = readTelegramChatId(params);
+		const messageId = readNumberParam(params, "messageId", {
+			required: true,
+			integer: true
+		});
+		const content = readStringParam(params, "content", { allowEmpty: false }) ?? readStringParam(params, "message", {
+			required: true,
+			allowEmpty: false
+		});
+		const buttons = resolveTelegramButtonsFromParams(params);
+		if (buttons) {
+			if (resolveTelegramInlineButtonsScope({
+				cfg,
+				accountId: accountId ?? void 0
+			}) === "off") throw new Error("Telegram inline buttons are disabled. Set channels.telegram.capabilities.inlineButtons to \"dm\", \"group\", \"all\", or \"allowlist\".");
+		}
+		const token = resolveTelegramToken(cfg, { accountId }).token;
+		if (!token) throw new Error("Telegram bot token missing. Set TELEGRAM_BOT_TOKEN or channels.telegram.botToken.");
+		const result = await telegramActionRuntime.editMessageTelegram(chatId ?? "", messageId ?? 0, content, {
+			cfg,
+			token,
+			accountId: accountId ?? void 0,
+			buttons,
+			gatewayClientScopes: options?.gatewayClientScopes
+		});
+		return jsonResult({
+			ok: true,
+			messageId: result.messageId,
+			chatId: result.chatId
+		});
+	}
+	if (action === "sendSticker") {
+		if (!isActionEnabled("sticker", false)) throw new Error("Telegram sticker actions are disabled. Set channels.telegram.actions.sticker to true.");
+		const to = readStringParam(params, "to") ?? readStringParam(params, "target", { required: true });
+		const fileId = readStringParam(params, "fileId") ?? readStringArrayParam(params, "stickerId")?.[0];
+		if (!fileId) throw new Error("fileId is required.");
+		const replyToMessageId = readTelegramReplyToMessageId(params);
+		const messageThreadId = readTelegramThreadId(params);
+		const token = resolveTelegramToken(cfg, { accountId }).token;
+		if (!token) throw new Error("Telegram bot token missing. Set TELEGRAM_BOT_TOKEN or channels.telegram.botToken.");
+		const result = await telegramActionRuntime.sendStickerTelegram(to, fileId, {
+			cfg,
+			token,
+			accountId: accountId ?? void 0,
+			replyToMessageId: replyToMessageId ?? void 0,
+			messageThreadId: messageThreadId ?? void 0,
+			gatewayClientScopes: options?.gatewayClientScopes
+		});
+		notifyVisibleOutboundSuccess(to, messageThreadId);
+		return jsonResult({
+			ok: true,
+			messageId: result.messageId,
+			chatId: result.chatId
+		});
+	}
+	if (action === "searchSticker") {
+		if (!isActionEnabled("sticker", false)) throw new Error("Telegram sticker actions are disabled. Set channels.telegram.actions.sticker to true.");
+		const query = readStringParam(params, "query", { required: true });
+		const limit = readNumberParam(params, "limit", { integer: true }) ?? 5;
+		const results = telegramActionRuntime.searchStickers(query, limit);
+		return jsonResult({
+			ok: true,
+			count: results.length,
+			stickers: results.map((s) => ({
+				fileId: s.fileId,
+				emoji: s.emoji,
+				description: s.description,
+				setName: s.setName
+			}))
+		});
+	}
+	if (action === "stickerCacheStats") return jsonResult({
+		ok: true,
+		...telegramActionRuntime.getCacheStats()
+	});
+	if (action === "createForumTopic") {
+		if (!isActionEnabled("createForumTopic")) throw new Error("Telegram createForumTopic is disabled.");
+		const chatId = readTelegramChatId(params);
+		const name = readStringParam(params, "name", { required: true });
+		const iconColor = readTelegramForumTopicIconColor(params);
+		const iconCustomEmojiId = readStringParam(params, "iconCustomEmojiId");
+		const token = resolveTelegramToken(cfg, { accountId }).token;
+		if (!token) throw new Error("Telegram bot token missing. Set TELEGRAM_BOT_TOKEN or channels.telegram.botToken.");
+		const result = await telegramActionRuntime.createForumTopicTelegram(chatId ?? "", name, {
+			cfg,
+			token,
+			accountId: accountId ?? void 0,
+			iconColor,
+			iconCustomEmojiId: iconCustomEmojiId ?? void 0,
+			gatewayClientScopes: options?.gatewayClientScopes
+		});
+		return jsonResult({
+			ok: true,
+			topicId: result.topicId,
+			name: result.name,
+			chatId: result.chatId
+		});
+	}
+	if (action === "editForumTopic") {
+		if (!isActionEnabled("editForumTopic")) throw new Error("Telegram editForumTopic is disabled.");
+		const chatId = readTelegramChatId(params);
+		const messageThreadId = readTelegramThreadId(params);
+		if (typeof messageThreadId !== "number") throw new Error("messageThreadId or threadId is required.");
+		const name = readStringParam(params, "name");
+		const iconCustomEmojiId = readStringParam(params, "iconCustomEmojiId");
+		const token = resolveTelegramToken(cfg, { accountId }).token;
+		if (!token) throw new Error("Telegram bot token missing. Set TELEGRAM_BOT_TOKEN or channels.telegram.botToken.");
+		return jsonResult(await telegramActionRuntime.editForumTopicTelegram(chatId ?? "", messageThreadId, {
+			cfg,
+			token,
+			accountId: accountId ?? void 0,
+			name: name ?? void 0,
+			iconCustomEmojiId: iconCustomEmojiId ?? void 0,
+			gatewayClientScopes: options?.gatewayClientScopes
+		}));
+	}
+	throw new Error(`Unsupported Telegram action: ${String(action)}`);
+}
+//#endregion
+export { handleTelegramAction, telegramActionRuntime };

package/dist/action-runtime-api-1LzcGjcX.js

@@ -0,0 +1,2 @@
+import "./runtime-BktLQ75j.js";
+export {};

package/dist/action-send-c3CnDuPg.js

@@ -0,0 +1,39 @@
+import { t as formatRunLabel } from "./subagents-utils-yfXEDHe3.js";
+import { l as sendControlledSubagentMessage, u as steerControlledSubagentRun } from "./subagent-control-IyFIvc7T.js";
+import { c as resolveSubagentEntryForToken, i as resolveCommandSubagentController, u as stopWithText } from "./shared-DYxQJxpN.js";
+import "./commands-subagents-control.runtime-DGybTjJ6.js";
+//#region src/auto-reply/reply/commands-subagents/action-send.ts
+async function handleSubagentsSendAction(ctx, steerRequested) {
+	const { params, handledPrefix, runs, restTokens } = ctx;
+	const target = restTokens[0];
+	const message = restTokens.slice(1).join(" ").trim();
+	if (!target || !message) return stopWithText(steerRequested ? handledPrefix === "/subagents" ? "Usage: /subagents steer <id|#> <message>" : `Usage: ${handledPrefix} <id|#> <message>` : "Usage: /subagents send <id|#> <message>");
+	const targetResolution = resolveSubagentEntryForToken(runs, target);
+	if ("reply" in targetResolution) return targetResolution.reply;
+	const controller = resolveCommandSubagentController(params, ctx.requesterKey);
+	if (steerRequested) {
+		const result = await steerControlledSubagentRun({
+			cfg: params.cfg,
+			controller,
+			entry: targetResolution.entry,
+			message
+		});
+		if (result.status === "accepted") return stopWithText(`steered ${formatRunLabel(targetResolution.entry)} (run ${result.runId.slice(0, 8)}).`);
+		if (result.status === "done" && result.text) return stopWithText(result.text);
+		if (result.status === "error") return stopWithText(`send failed: ${result.error ?? "error"}`);
+		return stopWithText(`⚠️ ${result.error ?? "send failed"}`);
+	}
+	const result = await sendControlledSubagentMessage({
+		cfg: params.cfg,
+		controller,
+		entry: targetResolution.entry,
+		message
+	});
+	if (result.status === "timeout") return stopWithText(`⏳ Subagent still running (run ${result.runId.slice(0, 8)}).`);
+	if (result.status === "error") return stopWithText(`⚠️ Subagent error: ${result.error} (run ${result.runId.slice(0, 8)}).`);
+	if (result.status === "forbidden") return stopWithText(`⚠️ ${result.error ?? "send failed"}`);
+	if (result.status === "done") return stopWithText(result.text);
+	return stopWithText(result.replyText ?? `✅ Sent to ${formatRunLabel(targetResolution.entry)} (run ${result.runId.slice(0, 8)}).`);
+}
+//#endregion
+export { handleSubagentsSendAction };

package/dist/action-spawn-Dj4kwpWs.js

@@ -0,0 +1,47 @@
+import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { t as spawnSubagentDirect } from "./subagent-spawn-ClJJkz3D.js";
+import { u as stopWithText } from "./shared-DYxQJxpN.js";
+//#region src/auto-reply/reply/commands-subagents/action-spawn.ts
+async function handleSubagentsSpawnAction(ctx) {
+	const { params, requesterKey, restTokens } = ctx;
+	const requesterSessionEntry = params.sessionStore?.[requesterKey] ?? params.sessionEntry;
+	const agentId = restTokens[0];
+	const taskParts = [];
+	let model;
+	let thinking;
+	for (let i = 1; i < restTokens.length; i++) if (restTokens[i] === "--model" && i + 1 < restTokens.length) {
+		i += 1;
+		model = restTokens[i];
+	} else if (restTokens[i] === "--thinking" && i + 1 < restTokens.length) {
+		i += 1;
+		thinking = restTokens[i];
+	} else taskParts.push(restTokens[i]);
+	const task = taskParts.join(" ").trim();
+	if (!agentId || !task) return stopWithText("Usage: /subagents spawn <agentId> <task> [--model <model>] [--thinking <level>]");
+	const commandTo = normalizeOptionalString(params.command.to) ?? "";
+	const originatingTo = normalizeOptionalString(params.ctx.OriginatingTo) ?? "";
+	const fallbackTo = normalizeOptionalString(params.ctx.To) ?? "";
+	const normalizedTo = originatingTo || commandTo || fallbackTo || void 0;
+	const result = await spawnSubagentDirect({
+		task,
+		agentId,
+		model,
+		thinking,
+		mode: "run",
+		cleanup: "keep",
+		expectsCompletionMessage: true
+	}, {
+		agentSessionKey: requesterKey,
+		agentChannel: params.ctx.OriginatingChannel ?? params.command.channel,
+		agentAccountId: params.ctx.AccountId,
+		agentTo: normalizedTo,
+		agentThreadId: params.ctx.MessageThreadId,
+		agentGroupId: requesterSessionEntry?.groupId ?? null,
+		agentGroupChannel: requesterSessionEntry?.groupChannel ?? null,
+		agentGroupSpace: requesterSessionEntry?.space ?? null
+	});
+	if (result.status === "accepted") return stopWithText(`Spawned subagent ${agentId} (session ${result.childSessionKey}, run ${result.runId?.slice(0, 8)}).`);
+	return stopWithText(`Spawn failed: ${result.error ?? result.status}`);
+}
+//#endregion
+export { handleSubagentsSpawnAction };