@gaodefa/daocore 2026.5.51 → 2026.5.53

package/dist/group-access-CZOQhsjs.js

@@ -0,0 +1,112 @@
+import { n as firstDefined } from "./allow-from-D1f7S_rf.js";
+import { i as resolveOpenProviderRuntimeGroupPolicy } from "./runtime-group-policy-CmZDlIwd.js";
+import { W as isSenderAllowed } from "./format-DBhooCE7.js";
+//#region extensions/telegram/src/group-access.ts
+function isGroupAllowOverrideAuthorized(params) {
+	if (!params.effectiveGroupAllow.hasEntries) return false;
+	const senderId = params.senderId ?? "";
+	if (params.requireSenderForAllowOverride && !senderId) return false;
+	return isSenderAllowed({
+		allow: params.effectiveGroupAllow,
+		senderId,
+		senderUsername: params.senderUsername ?? ""
+	});
+}
+const evaluateTelegramGroupBaseAccess = (params) => {
+	if (params.groupConfig?.enabled === false) return {
+		allowed: false,
+		reason: "group-disabled"
+	};
+	if (params.topicConfig?.enabled === false) return {
+		allowed: false,
+		reason: "topic-disabled"
+	};
+	if (!params.isGroup) {
+		if (params.enforceAllowOverride && params.hasGroupAllowOverride) {
+			if (!isGroupAllowOverrideAuthorized({
+				effectiveGroupAllow: params.effectiveGroupAllow,
+				senderId: params.senderId,
+				senderUsername: params.senderUsername,
+				requireSenderForAllowOverride: params.requireSenderForAllowOverride
+			})) return {
+				allowed: false,
+				reason: "group-override-unauthorized"
+			};
+		}
+		return { allowed: true };
+	}
+	if (!params.enforceAllowOverride || !params.hasGroupAllowOverride) return { allowed: true };
+	if (!isGroupAllowOverrideAuthorized({
+		effectiveGroupAllow: params.effectiveGroupAllow,
+		senderId: params.senderId,
+		senderUsername: params.senderUsername,
+		requireSenderForAllowOverride: params.requireSenderForAllowOverride
+	})) return {
+		allowed: false,
+		reason: "group-override-unauthorized"
+	};
+	return { allowed: true };
+};
+const resolveTelegramRuntimeGroupPolicy = (params) => resolveOpenProviderRuntimeGroupPolicy({
+	providerConfigPresent: params.providerConfigPresent,
+	groupPolicy: params.groupPolicy,
+	defaultGroupPolicy: params.defaultGroupPolicy
+});
+const evaluateTelegramGroupPolicyAccess = (params) => {
+	const { groupPolicy: runtimeFallbackPolicy } = resolveTelegramRuntimeGroupPolicy({
+		providerConfigPresent: params.cfg.channels?.telegram !== void 0,
+		groupPolicy: params.telegramCfg.groupPolicy,
+		defaultGroupPolicy: params.cfg.channels?.defaults?.groupPolicy
+	});
+	const fallbackPolicy = firstDefined(params.telegramCfg.groupPolicy, params.cfg.channels?.defaults?.groupPolicy) ?? runtimeFallbackPolicy;
+	const groupPolicy = params.useTopicAndGroupOverrides ? firstDefined(params.topicConfig?.groupPolicy, params.groupConfig?.groupPolicy, params.telegramCfg.groupPolicy, params.cfg.channels?.defaults?.groupPolicy) ?? runtimeFallbackPolicy : fallbackPolicy;
+	if (!params.isGroup || !params.enforcePolicy) return {
+		allowed: true,
+		groupPolicy
+	};
+	if (groupPolicy === "disabled") return {
+		allowed: false,
+		reason: "group-policy-disabled",
+		groupPolicy
+	};
+	let chatExplicitlyAllowed = false;
+	if (params.checkChatAllowlist) {
+		const groupAllowlist = params.resolveGroupPolicy(params.chatId);
+		if (groupAllowlist.allowlistEnabled && !groupAllowlist.allowed) return {
+			allowed: false,
+			reason: "group-chat-not-allowed",
+			groupPolicy
+		};
+		if (groupAllowlist.allowlistEnabled && groupAllowlist.allowed && groupAllowlist.groupConfig) chatExplicitlyAllowed = true;
+	}
+	if (groupPolicy === "allowlist" && params.enforceAllowlistAuthorization) {
+		const senderId = params.senderId ?? "";
+		const allowlistConfigured = chatExplicitlyAllowed || params.allowEmptyAllowlistEntries || params.effectiveGroupAllow.hasEntries;
+		const allowlistMatched = chatExplicitlyAllowed && !params.effectiveGroupAllow.hasEntries || isSenderAllowed({
+			allow: params.effectiveGroupAllow,
+			senderId,
+			senderUsername: params.senderUsername ?? ""
+		});
+		if (params.requireSenderForAllowlistAuthorization && !senderId) return {
+			allowed: false,
+			reason: "group-policy-allowlist-no-sender",
+			groupPolicy
+		};
+		if (!allowlistConfigured) return {
+			allowed: false,
+			reason: "group-policy-allowlist-empty",
+			groupPolicy
+		};
+		if (!allowlistMatched) return {
+			allowed: false,
+			reason: "group-policy-allowlist-unauthorized",
+			groupPolicy
+		};
+	}
+	return {
+		allowed: true,
+		groupPolicy
+	};
+};
+//#endregion
+export { evaluateTelegramGroupPolicyAccess as n, resolveTelegramRuntimeGroupPolicy as r, evaluateTelegramGroupBaseAccess as t };

package/dist/group-keys-B_lbVBmI.d.ts

@@ -0,0 +1,17 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { s as LineGroupConfig } from "./accounts-CqgATPC-.js";
+
+//#region extensions/line/src/group-keys.d.ts
+declare function resolveLineGroupLookupIds(groupId?: string | null): string[];
+declare function resolveLineGroupConfigEntry<T>(groups: Record<string, T | undefined> | undefined, params: {
+  groupId?: string | null;
+  roomId?: string | null;
+}): T | undefined;
+declare function resolveLineGroupsConfig(cfg: DaoCoreConfig, accountId?: string | null): Record<string, LineGroupConfig | undefined> | undefined;
+declare function resolveExactLineGroupConfigKey(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+  groupId?: string | null;
+}): string | undefined;
+//#endregion
+export { resolveLineGroupsConfig as i, resolveLineGroupConfigEntry as n, resolveLineGroupLookupIds as r, resolveExactLineGroupConfigKey as t };

package/dist/handle-action.guild-admin-DjuZqjM2.js

@@ -0,0 +1,288 @@
+import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { f as readNumberParam, g as readStringParam, m as readStringArrayParam } from "./common-vJyw6dD-.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import "./agent-runtime-C5xeqCn8.js";
+import { a as readDiscordChannelCreateParams, n as isDiscordModerationAction, o as readDiscordChannelEditParams, r as readDiscordModerationCommand, s as readDiscordChannelMoveParams, t as handleDiscordAction } from "./runtime-BXJM8M8F.js";
+import "./action-runtime-api-DZY1J62H.js";
+//#region extensions/discord/src/actions/handle-action.guild-admin.ts
+async function tryHandleDiscordMessageActionGuildAdmin(params) {
+	const { ctx, resolveChannelId } = params;
+	const { action, params: actionParams, cfg } = ctx;
+	const accountId = ctx.accountId ?? readStringParam(actionParams, "accountId");
+	if (action === "member-info") {
+		const userId = readStringParam(actionParams, "userId", { required: true });
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "memberInfo",
+			accountId: accountId ?? void 0,
+			guildId,
+			userId
+		}, cfg);
+	}
+	if (action === "role-info") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "roleInfo",
+			accountId: accountId ?? void 0,
+			guildId
+		}, cfg);
+	}
+	if (action === "emoji-list") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "emojiList",
+			accountId: accountId ?? void 0,
+			guildId
+		}, cfg);
+	}
+	if (action === "emoji-upload") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "emojiName", { required: true });
+		const mediaUrl = readStringParam(actionParams, "media", {
+			required: true,
+			trim: false
+		});
+		const roleIds = readStringArrayParam(actionParams, "roleIds");
+		return await handleDiscordAction({
+			action: "emojiUpload",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			mediaUrl,
+			roleIds
+		}, cfg);
+	}
+	if (action === "sticker-upload") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "stickerName", { required: true });
+		const description = readStringParam(actionParams, "stickerDesc", { required: true });
+		const tags = readStringParam(actionParams, "stickerTags", { required: true });
+		const mediaUrl = readStringParam(actionParams, "media", {
+			required: true,
+			trim: false
+		});
+		return await handleDiscordAction({
+			action: "stickerUpload",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			description,
+			tags,
+			mediaUrl
+		}, cfg);
+	}
+	if (action === "role-add" || action === "role-remove") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const userId = readStringParam(actionParams, "userId", { required: true });
+		const roleId = readStringParam(actionParams, "roleId", { required: true });
+		return await handleDiscordAction({
+			action: action === "role-add" ? "roleAdd" : "roleRemove",
+			accountId: accountId ?? void 0,
+			guildId,
+			userId,
+			roleId
+		}, cfg);
+	}
+	if (action === "channel-info") {
+		const channelId = readStringParam(actionParams, "channelId", { required: true });
+		return await handleDiscordAction({
+			action: "channelInfo",
+			accountId: accountId ?? void 0,
+			channelId
+		}, cfg);
+	}
+	if (action === "channel-list") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "channelList",
+			accountId: accountId ?? void 0,
+			guildId
+		}, cfg);
+	}
+	if (action === "channel-create") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "channelCreate",
+			accountId: accountId ?? void 0,
+			...readDiscordChannelCreateParams({
+				...actionParams,
+				guildId
+			})
+		}, cfg);
+	}
+	if (action === "channel-edit") {
+		const channelId = readStringParam(actionParams, "channelId", { required: true });
+		return await handleDiscordAction({
+			action: "channelEdit",
+			accountId: accountId ?? void 0,
+			...readDiscordChannelEditParams({
+				...actionParams,
+				channelId
+			})
+		}, cfg);
+	}
+	if (action === "channel-delete") {
+		const channelId = readStringParam(actionParams, "channelId", { required: true });
+		return await handleDiscordAction({
+			action: "channelDelete",
+			accountId: accountId ?? void 0,
+			channelId
+		}, cfg);
+	}
+	if (action === "channel-move") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const channelId = readStringParam(actionParams, "channelId", { required: true });
+		return await handleDiscordAction({
+			action: "channelMove",
+			accountId: accountId ?? void 0,
+			...readDiscordChannelMoveParams({
+				...actionParams,
+				guildId,
+				channelId
+			})
+		}, cfg);
+	}
+	if (action === "category-create") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "name", { required: true });
+		const position = readNumberParam(actionParams, "position", { integer: true });
+		return await handleDiscordAction({
+			action: "categoryCreate",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			position: position ?? void 0
+		}, cfg);
+	}
+	if (action === "category-edit") {
+		const categoryId = readStringParam(actionParams, "categoryId", { required: true });
+		const name = readStringParam(actionParams, "name");
+		const position = readNumberParam(actionParams, "position", { integer: true });
+		return await handleDiscordAction({
+			action: "categoryEdit",
+			accountId: accountId ?? void 0,
+			categoryId,
+			name: name ?? void 0,
+			position: position ?? void 0
+		}, cfg);
+	}
+	if (action === "category-delete") {
+		const categoryId = readStringParam(actionParams, "categoryId", { required: true });
+		return await handleDiscordAction({
+			action: "categoryDelete",
+			accountId: accountId ?? void 0,
+			categoryId
+		}, cfg);
+	}
+	if (action === "voice-status") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const userId = readStringParam(actionParams, "userId", { required: true });
+		return await handleDiscordAction({
+			action: "voiceStatus",
+			accountId: accountId ?? void 0,
+			guildId,
+			userId
+		}, cfg);
+	}
+	if (action === "event-list") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "eventList",
+			accountId: accountId ?? void 0,
+			guildId
+		}, cfg);
+	}
+	if (action === "event-create") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "eventName", { required: true });
+		const startTime = readStringParam(actionParams, "startTime", { required: true });
+		const endTime = readStringParam(actionParams, "endTime");
+		const description = readStringParam(actionParams, "desc");
+		const channelId = readStringParam(actionParams, "channelId");
+		const location = readStringParam(actionParams, "location");
+		const entityType = readStringParam(actionParams, "eventType");
+		const image = readStringParam(actionParams, "image", { trim: false });
+		return await handleDiscordAction({
+			action: "eventCreate",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			startTime,
+			endTime,
+			description,
+			channelId,
+			location,
+			entityType,
+			image
+		}, cfg, { mediaLocalRoots: ctx.mediaLocalRoots });
+	}
+	if (isDiscordModerationAction(action)) {
+		const moderation = readDiscordModerationCommand(action, {
+			...actionParams,
+			durationMinutes: readNumberParam(actionParams, "durationMin", { integer: true }),
+			deleteMessageDays: readNumberParam(actionParams, "deleteDays", { integer: true })
+		});
+		const senderUserId = normalizeOptionalString(ctx.requesterSenderId);
+		return await handleDiscordAction({
+			action: moderation.action,
+			accountId: accountId ?? void 0,
+			guildId: moderation.guildId,
+			userId: moderation.userId,
+			durationMinutes: moderation.durationMinutes,
+			until: moderation.until,
+			reason: moderation.reason,
+			deleteMessageDays: moderation.deleteMessageDays,
+			senderUserId
+		}, cfg);
+	}
+	if (action === "thread-list") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const channelId = readStringParam(actionParams, "channelId");
+		const includeArchived = typeof actionParams.includeArchived === "boolean" ? actionParams.includeArchived : void 0;
+		const before = readStringParam(actionParams, "before");
+		const limit = readNumberParam(actionParams, "limit", { integer: true });
+		return await handleDiscordAction({
+			action: "threadList",
+			accountId: accountId ?? void 0,
+			guildId,
+			channelId,
+			includeArchived,
+			before,
+			limit
+		}, cfg);
+	}
+	if (action === "thread-reply") {
+		const content = readStringParam(actionParams, "message", { required: true });
+		const mediaUrl = readStringParam(actionParams, "media", { trim: false }) ?? readStringParam(actionParams, "path", { trim: false }) ?? readStringParam(actionParams, "filePath", { trim: false });
+		const replyTo = readStringParam(actionParams, "replyTo");
+		const channelId = readStringParam(actionParams, "threadId") ?? resolveChannelId();
+		return await handleDiscordAction({
+			action: "threadReply",
+			accountId: accountId ?? void 0,
+			channelId,
+			content,
+			mediaUrl: mediaUrl ?? void 0,
+			replyTo: replyTo ?? void 0
+		}, cfg, {
+			mediaLocalRoots: ctx.mediaLocalRoots,
+			mediaReadFile: ctx.mediaReadFile
+		});
+	}
+	if (action === "search") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const query = readStringParam(actionParams, "query", { required: true });
+		return await handleDiscordAction({
+			action: "searchMessages",
+			accountId: accountId ?? void 0,
+			guildId,
+			content: query,
+			channelId: readStringParam(actionParams, "channelId"),
+			channelIds: readStringArrayParam(actionParams, "channelIds"),
+			authorId: readStringParam(actionParams, "authorId"),
+			authorIds: readStringArrayParam(actionParams, "authorIds"),
+			limit: readNumberParam(actionParams, "limit", { integer: true })
+		}, cfg);
+	}
+}
+//#endregion
+export { tryHandleDiscordMessageActionGuildAdmin as t };

package/dist/harness-XL58LNpX.js

@@ -0,0 +1,61 @@
+//#region extensions/codex/harness.ts
+const DEFAULT_CODEX_HARNESS_PROVIDER_IDS = new Set(["codex"]);
+const CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES = [
+	"bootstrap",
+	"assemble-before-prompt",
+	"after-turn",
+	"maintain",
+	"compact",
+	"runtime-llm-complete",
+	"thread-bootstrap-projection"
+];
+function createCodexAppServerAgentHarness(options) {
+	const providerIds = new Set([...options?.providerIds ?? DEFAULT_CODEX_HARNESS_PROVIDER_IDS].map((id) => id.trim().toLowerCase()));
+	return {
+		id: options?.id ?? "codex",
+		label: options?.label ?? "Codex agent harness",
+		contextEngineHostCapabilities: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES,
+		deliveryDefaults: { sourceVisibleReplies: "message_tool" },
+		supports: (ctx) => {
+			const provider = ctx.provider.trim().toLowerCase();
+			if (providerIds.has(provider)) return {
+				supported: true,
+				priority: 100
+			};
+			return {
+				supported: false,
+				reason: `provider is not one of: ${[...providerIds].toSorted().join(", ")}`
+			};
+		},
+		runAttempt: async (params) => {
+			const { runCodexAppServerAttempt } = await import("./run-attempt-DWBeHRdc.js");
+			return runCodexAppServerAttempt(params, {
+				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
+				nativeHookRelay: { enabled: true }
+			});
+		},
+		runSideQuestion: async (params) => {
+			const { runCodexAppServerSideQuestion } = await import("./side-question-Dlr5pcZK.js");
+			return runCodexAppServerSideQuestion(params, {
+				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
+				nativeHookRelay: { enabled: true }
+			});
+		},
+		compact: async (params) => {
+			const { maybeCompactCodexAppServerSession } = await import("./compact-B2rH1SUd.js");
+			return maybeCompactCodexAppServerSession(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
+		},
+		reset: async (params) => {
+			if (params.sessionFile) {
+				const { clearCodexAppServerBinding } = await import("./session-binding-DtmTypDj.js");
+				await clearCodexAppServerBinding(params.sessionFile);
+			}
+		},
+		dispose: async () => {
+			const { clearSharedCodexAppServerClientAndWait } = await import("./shared-client-B2kMpTHH.js");
+			await clearSharedCodexAppServerClientAndWait();
+		}
+	};
+}
+//#endregion
+export { createCodexAppServerAgentHarness as t };

package/dist/health-CFPXXpFW.js

@@ -0,0 +1,4 @@
+import "./agent-scope-Dx1S0aWX.js";
+import "./config-CLrwLpl0.js";
+import "./doctor-core-checks-BTvmehLq.js";
+export {};

package/dist/heartbeat-runner-D_o-itnk.js

@@ -0,0 +1,5 @@
+import { c as setHeartbeatsEnabled, i as areHeartbeatsEnabled } from "./heartbeat-wake-BEc0M8hq.js";
+import { n as resolveHeartbeatIntervalMs, r as resolveHeartbeatSummaryForAgent, t as isHeartbeatEnabledForAgent } from "./heartbeat-summary-D4s-V11G.js";
+import { r as isCronSystemEvent } from "./heartbeat-events-filter-VRH7kGrP.js";
+import { n as runHeartbeatOnce, r as startHeartbeatRunner, t as resolveHeartbeatPrompt } from "./heartbeat-runner-BqUKIwmn.js";
+export { areHeartbeatsEnabled, isCronSystemEvent, isHeartbeatEnabledForAgent, resolveHeartbeatIntervalMs, resolveHeartbeatPrompt, resolveHeartbeatSummaryForAgent, runHeartbeatOnce, setHeartbeatsEnabled, startHeartbeatRunner };

package/dist/heartbeat-runner.runtime-CPVGa3Gd.js

@@ -0,0 +1,4 @@
+import "./queue-CiIfqvH0.js";
+import { t as getReplyFromConfig } from "./get-reply-D140C4TM.js";
+import "./directive-handling.parse-BOHwq5Io.js";
+export { getReplyFromConfig };

package/dist/heartbeat-runner.runtime.js

@@ -1 +1 @@
-export * from "./heartbeat-runner.runtime-BKwSStf9.js";
+export * from "./heartbeat-runner.runtime-CPVGa3Gd.js";

package/dist/hook-runtime-UU80d5qW.d.ts

@@ -0,0 +1,108 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { t as DiagnosticTraceContext } from "./diagnostic-trace-context-DcbwO2-o.js";
+import { t as FinalizedMsgContext } from "./templating-DNuykHor.js";
+import { Bt as PluginHookInboundClaimEvent, Gt as PluginHookMessageSentEvent, Ht as PluginHookMessageReceivedEvent, Vt as PluginHookMessageContext, zt as PluginHookInboundClaimContext } from "./hook-types-DPDFYFH1.js";
+import { a as MessagePreprocessedHookContext, d as MessageTranscribedHookContext, l as MessageSentHookContext, s as MessageReceivedHookContext } from "./internal-hooks-B-lc7D2y.js";
+
+//#region src/hooks/fire-and-forget.d.ts
+type FireAndForgetBoundedHookOptions = {
+  maxConcurrency?: number;
+  maxQueue?: number;
+  timeoutMs?: number;
+};
+declare function formatHookErrorForLog(err: unknown): string;
+declare function fireAndForgetHook(task: Promise<unknown>, label: string, logger?: (message: string) => void): void;
+declare function fireAndForgetBoundedHook(task: () => Promise<unknown>, label: string, logger?: (message: string) => void, options?: FireAndForgetBoundedHookOptions): void;
+//#endregion
+//#region src/hooks/message-hook-mappers.d.ts
+type CanonicalInboundMessageHookContext = {
+  from: string;
+  to?: string;
+  content: string;
+  body?: string;
+  bodyForAgent?: string;
+  transcript?: string;
+  timestamp?: number;
+  channelId: string;
+  accountId?: string;
+  conversationId?: string;
+  sessionKey?: string;
+  runId?: string;
+  messageId?: string;
+  senderId?: string;
+  senderName?: string;
+  senderUsername?: string;
+  senderE164?: string;
+  provider?: string;
+  surface?: string;
+  threadId?: string | number;
+  mediaPath?: string;
+  mediaUrl?: string;
+  mediaType?: string;
+  mediaPaths?: string[];
+  mediaUrls?: string[];
+  mediaTypes?: string[];
+  originatingChannel?: string;
+  originatingTo?: string;
+  guildId?: string;
+  channelName?: string;
+  isGroup: boolean;
+  groupId?: string;
+  topicName?: string;
+  trace?: DiagnosticTraceContext;
+  callDepth?: number;
+};
+type CanonicalSentMessageHookContext = {
+  to: string;
+  content: string;
+  success: boolean;
+  error?: string;
+  channelId: string;
+  accountId?: string;
+  conversationId?: string;
+  sessionKey?: string;
+  runId?: string;
+  messageId?: string;
+  trace?: DiagnosticTraceContext;
+  callDepth?: number;
+  isGroup?: boolean;
+  groupId?: string;
+};
+declare function deriveInboundMessageHookContext(ctx: FinalizedMsgContext, overrides?: {
+  content?: string;
+  messageId?: string;
+}): CanonicalInboundMessageHookContext;
+declare function buildCanonicalSentMessageHookContext(params: {
+  to: string;
+  content: string;
+  success: boolean;
+  error?: string;
+  channelId: string;
+  accountId?: string;
+  conversationId?: string;
+  sessionKey?: string;
+  runId?: string;
+  messageId?: string;
+  trace?: DiagnosticTraceContext;
+  callDepth?: number;
+  isGroup?: boolean;
+  groupId?: string;
+}): CanonicalSentMessageHookContext;
+declare function toPluginMessageContext(canonical: CanonicalInboundMessageHookContext | CanonicalSentMessageHookContext): PluginHookMessageContext;
+declare function toPluginInboundClaimContext(canonical: CanonicalInboundMessageHookContext): PluginHookInboundClaimContext;
+declare function toPluginInboundClaimEvent(canonical: CanonicalInboundMessageHookContext, extras?: {
+  commandAuthorized?: boolean;
+  wasMentioned?: boolean;
+}): PluginHookInboundClaimEvent;
+declare function toPluginMessageReceivedEvent(canonical: CanonicalInboundMessageHookContext): PluginHookMessageReceivedEvent;
+declare function toPluginMessageSentEvent(canonical: CanonicalSentMessageHookContext): PluginHookMessageSentEvent;
+declare function toInternalMessageReceivedContext(canonical: CanonicalInboundMessageHookContext): MessageReceivedHookContext;
+declare function toInternalMessageTranscribedContext(canonical: CanonicalInboundMessageHookContext, cfg: DaoCoreConfig): MessageTranscribedHookContext & {
+  cfg: DaoCoreConfig;
+};
+declare function toInternalMessagePreprocessedContext(canonical: CanonicalInboundMessageHookContext, cfg: DaoCoreConfig): MessagePreprocessedHookContext & {
+  cfg: DaoCoreConfig;
+};
+declare function toInternalMessageSentContext(canonical: CanonicalSentMessageHookContext): MessageSentHookContext;
+//#endregion
+export { formatHookErrorForLog as _, toInternalMessagePreprocessedContext as a, toInternalMessageTranscribedContext as c, toPluginMessageContext as d, toPluginMessageReceivedEvent as f, fireAndForgetHook as g, fireAndForgetBoundedHook as h, deriveInboundMessageHookContext as i, toPluginInboundClaimContext as l, FireAndForgetBoundedHookOptions as m, CanonicalSentMessageHookContext as n, toInternalMessageReceivedContext as o, toPluginMessageSentEvent as p, buildCanonicalSentMessageHookContext as r, toInternalMessageSentContext as s, CanonicalInboundMessageHookContext as t, toPluginInboundClaimEvent as u };