@pixelzx/genesis 2026.6.27 → 2026.6.29

package/dist/conversation-id-BTqKksIo.js

@@ -0,0 +1,38 @@
+import { A as parseBlueBubblesTarget, D as normalizeBlueBubblesHandle, x as extractHandleFromChatGuid } from "./probe-89jd9VHi.js";
+//#region extensions/bluebubbles/src/conversation-id.ts
+function normalizeBlueBubblesAcpConversationId(conversationId) {
+	const trimmed = conversationId.trim();
+	if (!trimmed) return null;
+	try {
+		const parsed = parseBlueBubblesTarget(trimmed);
+		if (parsed.kind === "handle") {
+			const handle = normalizeBlueBubblesHandle(parsed.to);
+			return handle ? { conversationId: handle } : null;
+		}
+		if (parsed.kind === "chat_id") return { conversationId: String(parsed.chatId) };
+		if (parsed.kind === "chat_guid") return { conversationId: extractHandleFromChatGuid(parsed.chatGuid) || parsed.chatGuid };
+		return { conversationId: parsed.chatIdentifier };
+	} catch {
+		const handle = normalizeBlueBubblesHandle(trimmed);
+		return handle ? { conversationId: handle } : null;
+	}
+}
+function matchBlueBubblesAcpConversation(params) {
+	const binding = normalizeBlueBubblesAcpConversationId(params.bindingConversationId);
+	const conversation = normalizeBlueBubblesAcpConversationId(params.conversationId);
+	if (!binding || !conversation) return null;
+	if (binding.conversationId !== conversation.conversationId) return null;
+	return {
+		conversationId: conversation.conversationId,
+		matchPriority: 2
+	};
+}
+function resolveBlueBubblesInboundConversationId(params) {
+	if (!params.isGroup) return normalizeBlueBubblesHandle(params.sender) || void 0;
+	return params.chatGuid && normalizeBlueBubblesAcpConversationId(params.chatGuid)?.conversationId || params.chatIdentifier && normalizeBlueBubblesAcpConversationId(params.chatIdentifier)?.conversationId || (params.chatId != null && Number.isFinite(params.chatId) ? String(params.chatId) : "") || void 0;
+}
+function resolveBlueBubblesConversationIdFromTarget(target) {
+	return normalizeBlueBubblesAcpConversationId(target)?.conversationId;
+}
+//#endregion
+export { resolveBlueBubblesInboundConversationId as i, normalizeBlueBubblesAcpConversationId as n, resolveBlueBubblesConversationIdFromTarget as r, matchBlueBubblesAcpConversation as t };

package/dist/conversation-id-DzarUmXD.js

@@ -0,0 +1,235 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { u as normalizeE164 } from "./utils-CWrkFsp0.js";
+import "./text-runtime-DVUvIDNC.js";
+import "./core-CYiHLgHk.js";
+import { i as parseChatTargetPrefixesOrThrow, o as resolveServicePrefixedChatTarget, s as resolveServicePrefixedOrChatAllowTarget, t as createAllowedChatSenderMatcher } from "./chat-target-prefixes-BRhY5IPk.js";
+import "./channel-targets-DlKKUfUx.js";
+import "./status-helpers-pM311_XZ.js";
+import "./media-runtime-awxrKlof.js";
+import "./account-resolution-FMtyCeJh.js";
+import "./channel-status-NqOqZpIV.js";
+import { s as resolveIMessageAccount } from "./media-contract-Cu5jtr6E.js";
+//#region extensions/imessage/src/config-accessors.ts
+function resolveIMessageConfigAllowFrom(params) {
+	return (resolveIMessageAccount(params).config.allowFrom ?? []).map((entry) => String(entry));
+}
+function resolveIMessageConfigDefaultTo(params) {
+	const defaultTo = resolveIMessageAccount(params).config.defaultTo;
+	if (defaultTo == null) return;
+	return defaultTo.trim() || void 0;
+}
+//#endregion
+//#region extensions/imessage/src/normalize.ts
+const SERVICE_PREFIXES$1 = [
+	"imessage:",
+	"sms:",
+	"auto:"
+];
+const CHAT_TARGET_PREFIX_RE = /^(chat_id:|chatid:|chat:|chat_guid:|chatguid:|guid:|chat_identifier:|chatidentifier:|chatident:)/i;
+function looksLikeHandleOrPhoneTarget(params) {
+	const trimmed = params.raw.trim();
+	if (!trimmed) return false;
+	if (params.prefixPattern.test(trimmed)) return true;
+	if (trimmed.includes("@")) return true;
+	return (params.phonePattern ?? /^\+?\d{3,}$/).test(trimmed);
+}
+function normalizeIMessageHandle$1(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return "";
+	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lowered.startsWith("imessage:")) return normalizeIMessageHandle$1(trimmed.slice(9));
+	if (lowered.startsWith("sms:")) return normalizeIMessageHandle$1(trimmed.slice(4));
+	if (lowered.startsWith("auto:")) return normalizeIMessageHandle$1(trimmed.slice(5));
+	if (CHAT_TARGET_PREFIX_RE.test(trimmed)) {
+		const prefix = trimmed.match(CHAT_TARGET_PREFIX_RE)?.[0];
+		if (!prefix) return "";
+		const value = trimmed.slice(prefix.length).trim();
+		return `${normalizeLowercaseStringOrEmpty(prefix)}${value}`;
+	}
+	if (trimmed.includes("@")) return normalizeLowercaseStringOrEmpty(trimmed);
+	const normalized = normalizeE164(trimmed);
+	if (normalized) return normalized;
+	return trimmed.replace(/\s+/g, "");
+}
+function normalizeIMessageMessagingTarget(raw) {
+	const trimmed = normalizeOptionalString(raw);
+	if (!trimmed) return;
+	const lower = normalizeLowercaseStringOrEmpty(trimmed);
+	for (const prefix of SERVICE_PREFIXES$1) if (lower.startsWith(prefix)) {
+		const normalizedHandle = normalizeIMessageHandle$1(trimmed.slice(prefix.length).trim());
+		if (!normalizedHandle) return;
+		if (CHAT_TARGET_PREFIX_RE.test(normalizedHandle)) return normalizedHandle;
+		return `${prefix}${normalizedHandle}`;
+	}
+	return normalizeIMessageHandle$1(trimmed) || void 0;
+}
+function looksLikeIMessageTargetId(raw) {
+	const trimmed = normalizeOptionalString(raw);
+	if (!trimmed) return false;
+	if (CHAT_TARGET_PREFIX_RE.test(trimmed)) return true;
+	return looksLikeHandleOrPhoneTarget({
+		raw: trimmed,
+		prefixPattern: /^(imessage:|sms:|auto:)/i
+	});
+}
+//#endregion
+//#region extensions/imessage/src/targets.ts
+const CHAT_ID_PREFIXES = [
+	"chat_id:",
+	"chatid:",
+	"chat:"
+];
+const CHAT_GUID_PREFIXES = [
+	"chat_guid:",
+	"chatguid:",
+	"guid:"
+];
+const CHAT_IDENTIFIER_PREFIXES = [
+	"chat_identifier:",
+	"chatidentifier:",
+	"chatident:"
+];
+const SERVICE_PREFIXES = [
+	{
+		prefix: "imessage:",
+		service: "imessage"
+	},
+	{
+		prefix: "sms:",
+		service: "sms"
+	},
+	{
+		prefix: "auto:",
+		service: "auto"
+	}
+];
+function normalizeIMessageHandle(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return "";
+	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lowered.startsWith("imessage:")) return normalizeIMessageHandle(trimmed.slice(9));
+	if (lowered.startsWith("sms:")) return normalizeIMessageHandle(trimmed.slice(4));
+	if (lowered.startsWith("auto:")) return normalizeIMessageHandle(trimmed.slice(5));
+	for (const prefix of CHAT_ID_PREFIXES) if (lowered.startsWith(prefix)) return `chat_id:${trimmed.slice(prefix.length).trim()}`;
+	for (const prefix of CHAT_GUID_PREFIXES) if (lowered.startsWith(prefix)) return `chat_guid:${trimmed.slice(prefix.length).trim()}`;
+	for (const prefix of CHAT_IDENTIFIER_PREFIXES) if (lowered.startsWith(prefix)) return `chat_identifier:${trimmed.slice(prefix.length).trim()}`;
+	if (trimmed.includes("@")) return normalizeLowercaseStringOrEmpty(trimmed);
+	const normalized = normalizeE164(trimmed);
+	if (normalized) return normalized;
+	return trimmed.replace(/\s+/g, "");
+}
+function parseIMessageTarget(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) throw new Error("iMessage target is required");
+	const lower = normalizeLowercaseStringOrEmpty(trimmed);
+	const servicePrefixed = resolveServicePrefixedChatTarget({
+		trimmed,
+		lower,
+		servicePrefixes: SERVICE_PREFIXES,
+		chatIdPrefixes: CHAT_ID_PREFIXES,
+		chatGuidPrefixes: CHAT_GUID_PREFIXES,
+		chatIdentifierPrefixes: CHAT_IDENTIFIER_PREFIXES,
+		parseTarget: parseIMessageTarget
+	});
+	if (servicePrefixed) return servicePrefixed;
+	const chatTarget = parseChatTargetPrefixesOrThrow({
+		trimmed,
+		lower,
+		chatIdPrefixes: CHAT_ID_PREFIXES,
+		chatGuidPrefixes: CHAT_GUID_PREFIXES,
+		chatIdentifierPrefixes: CHAT_IDENTIFIER_PREFIXES
+	});
+	if (chatTarget) return chatTarget;
+	return {
+		kind: "handle",
+		to: trimmed,
+		service: "auto"
+	};
+}
+function looksLikeIMessageExplicitTargetId(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return false;
+	const lower = normalizeLowercaseStringOrEmpty(trimmed);
+	if (/^(imessage:|sms:|auto:)/.test(lower)) return true;
+	return CHAT_ID_PREFIXES.some((prefix) => lower.startsWith(prefix)) || CHAT_GUID_PREFIXES.some((prefix) => lower.startsWith(prefix)) || CHAT_IDENTIFIER_PREFIXES.some((prefix) => lower.startsWith(prefix));
+}
+function inferIMessageTargetChatType(raw) {
+	try {
+		if (parseIMessageTarget(raw).kind === "handle") return "direct";
+		return "group";
+	} catch {
+		return;
+	}
+}
+function parseIMessageAllowTarget(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {
+		kind: "handle",
+		handle: ""
+	};
+	const servicePrefixed = resolveServicePrefixedOrChatAllowTarget({
+		trimmed,
+		lower: normalizeLowercaseStringOrEmpty(trimmed),
+		servicePrefixes: SERVICE_PREFIXES,
+		parseAllowTarget: parseIMessageAllowTarget,
+		chatIdPrefixes: CHAT_ID_PREFIXES,
+		chatGuidPrefixes: CHAT_GUID_PREFIXES,
+		chatIdentifierPrefixes: CHAT_IDENTIFIER_PREFIXES
+	});
+	if (servicePrefixed) return servicePrefixed;
+	return {
+		kind: "handle",
+		handle: normalizeIMessageHandle(trimmed)
+	};
+}
+const isAllowedIMessageSenderMatcher = createAllowedChatSenderMatcher({
+	normalizeSender: normalizeIMessageHandle,
+	parseAllowTarget: parseIMessageAllowTarget
+});
+function isAllowedIMessageSender(params) {
+	return isAllowedIMessageSenderMatcher(params);
+}
+function formatIMessageChatTarget(chatId) {
+	if (!chatId || !Number.isFinite(chatId)) return "";
+	return `chat_id:${chatId}`;
+}
+//#endregion
+//#region extensions/imessage/src/conversation-id-core.ts
+function normalizeIMessageAcpConversationId(conversationId) {
+	const trimmed = conversationId.trim();
+	if (!trimmed) return null;
+	try {
+		const parsed = parseIMessageTarget(trimmed);
+		if (parsed.kind === "handle") {
+			const handle = normalizeIMessageHandle(parsed.to);
+			return handle ? { conversationId: handle } : null;
+		}
+		if (parsed.kind === "chat_id") return { conversationId: String(parsed.chatId) };
+		if (parsed.kind === "chat_guid") return { conversationId: parsed.chatGuid };
+		return { conversationId: parsed.chatIdentifier };
+	} catch {
+		const handle = normalizeIMessageHandle(trimmed);
+		return handle ? { conversationId: handle } : null;
+	}
+}
+function matchIMessageAcpConversation(params) {
+	const binding = normalizeIMessageAcpConversationId(params.bindingConversationId);
+	const conversation = normalizeIMessageAcpConversationId(params.conversationId);
+	if (!binding || !conversation) return null;
+	if (binding.conversationId !== conversation.conversationId) return null;
+	return {
+		conversationId: conversation.conversationId,
+		matchPriority: 2
+	};
+}
+function resolveIMessageConversationIdFromTarget(target) {
+	return normalizeIMessageAcpConversationId(target)?.conversationId;
+}
+//#endregion
+//#region extensions/imessage/src/conversation-id.ts
+function resolveIMessageInboundConversationId(params) {
+	if (params.isGroup) return params.chatId != null && Number.isFinite(params.chatId) ? String(params.chatId) : void 0;
+	return normalizeIMessageHandle(params.sender) || void 0;
+}
+//#endregion
+export { formatIMessageChatTarget as a, looksLikeIMessageExplicitTargetId as c, parseIMessageTarget as d, looksLikeIMessageTargetId as f, resolveIMessageConfigDefaultTo as h, resolveIMessageConversationIdFromTarget as i, normalizeIMessageHandle as l, resolveIMessageConfigAllowFrom as m, matchIMessageAcpConversation as n, inferIMessageTargetChatType as o, normalizeIMessageMessagingTarget as p, normalizeIMessageAcpConversationId as r, isAllowedIMessageSender as s, resolveIMessageInboundConversationId as t, parseIMessageAllowTarget as u };

package/dist/conversation-runtime-DbbmwXgr.js

@@ -0,0 +1,31 @@
+import "./session-binding-service-BOdf-6dc.js";
+import "./binding-registry-BW55sLG7.js";
+import "./conversation-binding-DeOigizm.js";
+import "./session-DQK4G2N-.js";
+import "./pairing-store-T3f7yIx-.js";
+import "./dm-policy-shared-6bTNkZt-.js";
+import "./binding-targets-BZWuOcR0.js";
+import "./binding-routing-D7ruDbx0.js";
+import "./thread-bindings-policy-DNca3oOv.js";
+import "./pairing-labels-Bm2Mu2vN.js";
+//#region src/channels/session-meta.ts
+let inboundSessionRuntimePromise = null;
+function loadInboundSessionRuntime() {
+	inboundSessionRuntimePromise ??= import("./inbound.runtime-DwsGti2x.js");
+	return inboundSessionRuntimePromise;
+}
+async function recordInboundSessionMetaSafe(params) {
+	const runtime = await loadInboundSessionRuntime();
+	const storePath = runtime.resolveStorePath(params.cfg.session?.store, { agentId: params.agentId });
+	try {
+		await runtime.recordSessionMetaFromInbound({
+			storePath,
+			sessionKey: params.sessionKey,
+			ctx: params.ctx
+		});
+	} catch (err) {
+		params.onError?.(err);
+	}
+}
+//#endregion
+export { recordInboundSessionMetaSafe as t };

package/dist/core-CYiHLgHk.js

@@ -0,0 +1,275 @@
+import { a as normalizeLowercaseStringOrEmpty, s as normalizeOptionalLowercaseString } from "./string-coerce-DPP_aYVc.js";
+import { t as resolveBundledPluginsDir } from "./bundled-dir-lc2DN9PI.js";
+import "./subsystem-CNq69MoE.js";
+import "./paths-Bv2rGpO9.js";
+import "./types.secrets-BbgGt42I.js";
+import "./net-BzaeD_3Q.js";
+import { a as emptyChannelConfigSchema } from "./config-schema-jug-eHfF.js";
+import { l as parseThreadSessionSuffix } from "./session-key-utils-DDwuwYKT.js";
+import { d as resolveThreadSessionKeys } from "./session-key-CI3KvTQC.js";
+import { l as buildChatChannelMetaById } from "./registry-CdBbOzac.js";
+import "./delegate-CBLxnP3N.js";
+import "./common-C4_5xEM_.js";
+import "./typebox-D1y6vsgs.js";
+import { t as buildAccountScopedDmSecurityPolicy } from "./helpers-DD6zqM-Y.js";
+import "./resolve-route-DANUDWzO.js";
+import { t as buildOutboundBaseSessionKey } from "./base-session-key-B-DTLUBu.js";
+import { r as createTopLevelChannelReplyToModeResolver, t as createScopedAccountReplyToModeResolver } from "./threading-helpers-DnSuctUz.js";
+import { t as normalizeOutboundThreadId } from "./thread-id-D2UlA6q7.js";
+import "./setup-helpers-C31wmCh6.js";
+import "./secret-file-Bwm4cCSC.js";
+import "./tailscale-status-o7VVRpAV.js";
+import "./persistent-bindings.resolve-Bn531W6-.js";
+//#region src/plugin-sdk/core.ts
+function createInlineTextPairingAdapter(params) {
+	return {
+		idLabel: params.idLabel,
+		normalizeAllowEntry: params.normalizeAllowEntry,
+		notifyApproval: async (ctx) => {
+			await params.notify({
+				...ctx,
+				message: params.message
+			});
+		}
+	};
+}
+async function ensureConfiguredAcpBindingReady(params) {
+	return (await import("./persistent-bindings.lifecycle-BhVLGVlI.js")).ensureConfiguredAcpBindingReady(params);
+}
+let cachedSdkChatChannelMeta;
+function resolveSdkChatChannelMeta(id) {
+	const cacheKey = resolveBundledPluginsDir(process.env) ?? "";
+	if (cachedSdkChatChannelMeta?.cacheKey !== cacheKey) cachedSdkChatChannelMeta = {
+		cacheKey,
+		metaById: buildChatChannelMetaById()
+	};
+	return cachedSdkChatChannelMeta.metaById[id];
+}
+function getChatChannelMeta(id) {
+	return resolveSdkChatChannelMeta(id);
+}
+/** Remove one of the known provider prefixes from a free-form target string. */
+function stripChannelTargetPrefix(raw, ...providers) {
+	const trimmed = raw.trim();
+	for (const provider of providers) {
+		const prefix = `${normalizeLowercaseStringOrEmpty(provider)}:`;
+		if (normalizeLowercaseStringOrEmpty(trimmed).startsWith(prefix)) return trimmed.slice(prefix.length).trim();
+	}
+	return trimmed;
+}
+/** Remove generic target-kind prefixes such as `user:` or `group:`. */
+function stripTargetKindPrefix(raw) {
+	return raw.replace(/^(user|channel|group|conversation|room|dm):/i, "").trim();
+}
+/**
+* Build the canonical outbound session route payload returned by channel
+* message adapters.
+*/
+function buildChannelOutboundSessionRoute(params) {
+	const baseSessionKey = buildOutboundBaseSessionKey({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: params.channel,
+		accountId: params.accountId,
+		peer: params.peer
+	});
+	return {
+		sessionKey: baseSessionKey,
+		baseSessionKey,
+		peer: params.peer,
+		chatType: params.chatType,
+		from: params.from,
+		to: params.to,
+		...params.threadId !== void 0 ? { threadId: params.threadId } : {}
+	};
+}
+function recoverCurrentThreadSessionId(params) {
+	const current = parseThreadSessionSuffix(params.currentSessionKey);
+	if (!current.baseSessionKey || !current.threadId) return;
+	if (normalizeOptionalLowercaseString(current.baseSessionKey) !== normalizeOptionalLowercaseString(params.route.baseSessionKey)) return;
+	const context = {
+		route: params.route,
+		currentBaseSessionKey: current.baseSessionKey,
+		currentThreadId: current.threadId
+	};
+	if (params.canRecover && !params.canRecover(context)) return;
+	return current.threadId;
+}
+function buildThreadAwareOutboundSessionRoute(params) {
+	const recoveredThreadId = recoverCurrentThreadSessionId({
+		route: params.route,
+		currentSessionKey: params.currentSessionKey,
+		canRecover: params.canRecoverCurrentThread
+	});
+	const candidates = {
+		replyToId: resolveThreadAwareOutboundCandidate(params.replyToId),
+		threadId: resolveThreadAwareOutboundCandidate(params.threadId),
+		currentSession: resolveThreadAwareOutboundCandidate(recoveredThreadId)
+	};
+	const candidate = (params.precedence ?? [
+		"replyToId",
+		"threadId",
+		"currentSession"
+	]).map((source) => candidates[source]).find(Boolean);
+	const threadKeys = resolveThreadSessionKeys({
+		baseSessionKey: params.route.baseSessionKey,
+		threadId: candidate?.sessionThreadId,
+		parentSessionKey: candidate ? params.parentSessionKey : void 0,
+		useSuffix: params.useSuffix,
+		normalizeThreadId: params.normalizeThreadId
+	});
+	return {
+		...params.route,
+		sessionKey: threadKeys.sessionKey,
+		...candidate !== void 0 ? { threadId: candidate.routeThreadId } : {}
+	};
+}
+function resolveThreadAwareOutboundCandidate(threadId) {
+	const sessionThreadId = normalizeOutboundThreadId(threadId);
+	if (sessionThreadId === void 0) return;
+	return {
+		routeThreadId: typeof threadId === "number" ? threadId : sessionThreadId,
+		sessionThreadId
+	};
+}
+/**
+* Canonical entry helper for channel plugins.
+*
+* This wraps `definePluginEntry(...)`, registers the channel capability, and
+* optionally exposes extra full-runtime registration such as tools or gateway
+* handlers that only make sense outside setup-only registration modes.
+*/
+function defineChannelPluginEntry({ id, name, description, plugin, configSchema, setRuntime, registerCliMetadata, registerFull }) {
+	return {
+		id,
+		name,
+		description,
+		configSchema: typeof configSchema === "function" ? configSchema() : configSchema ?? emptyChannelConfigSchema(),
+		register(api) {
+			if (api.registrationMode === "cli-metadata") {
+				registerCliMetadata?.(api);
+				return;
+			}
+			api.registerChannel({ plugin });
+			if (api.registrationMode === "discovery") {
+				registerCliMetadata?.(api);
+				return;
+			}
+			setRuntime?.(api.runtime);
+			if (api.registrationMode !== "full") return;
+			registerCliMetadata?.(api);
+			registerFull?.(api);
+		},
+		channelPlugin: plugin,
+		...setRuntime ? { setChannelRuntime: setRuntime } : {}
+	};
+}
+/**
+* Minimal setup-entry helper for channels that ship a separate `setup-entry.ts`.
+*
+* The setup entry only needs to export `{ plugin }`, but using this helper
+* keeps the shape explicit in examples and generated typings.
+*/
+function defineSetupPluginEntry(plugin) {
+	return { plugin };
+}
+function createInlineAttachedChannelResultAdapter(params) {
+	return {
+		sendText: params.sendText ? async (ctx) => ({
+			channel: params.channel,
+			...await params.sendText(ctx)
+		}) : void 0,
+		sendMedia: params.sendMedia ? async (ctx) => ({
+			channel: params.channel,
+			...await params.sendMedia(ctx)
+		}) : void 0,
+		sendPoll: params.sendPoll ? async (ctx) => ({
+			channel: params.channel,
+			...await params.sendPoll(ctx)
+		}) : void 0
+	};
+}
+function resolveChatChannelSecurity(security) {
+	if (!security) return;
+	if (!("dm" in security)) return security;
+	return {
+		resolveDmPolicy: ({ cfg, accountId, account }) => buildAccountScopedDmSecurityPolicy({
+			cfg,
+			channelKey: security.dm.channelKey,
+			accountId,
+			fallbackAccountId: security.dm.resolveFallbackAccountId?.(account) ?? account.accountId,
+			policy: security.dm.resolvePolicy(account),
+			allowFrom: security.dm.resolveAllowFrom(account) ?? [],
+			defaultPolicy: security.dm.defaultPolicy,
+			allowFromPathSuffix: security.dm.allowFromPathSuffix,
+			policyPathSuffix: security.dm.policyPathSuffix,
+			approveChannelId: security.dm.approveChannelId,
+			approveHint: security.dm.approveHint,
+			normalizeEntry: security.dm.normalizeEntry,
+			inheritSharedDefaultsFromDefaultAccount: security.dm.inheritSharedDefaultsFromDefaultAccount
+		}),
+		...security.collectWarnings ? { collectWarnings: security.collectWarnings } : {},
+		...security.collectAuditFindings ? { collectAuditFindings: security.collectAuditFindings } : {}
+	};
+}
+function resolveChatChannelPairing(pairing) {
+	if (!pairing) return;
+	if (!("text" in pairing)) return pairing;
+	return createInlineTextPairingAdapter(pairing.text);
+}
+function resolveChatChannelThreading(threading) {
+	if (!threading) return;
+	if (!("topLevelReplyToMode" in threading) && !("scopedAccountReplyToMode" in threading)) return threading;
+	let resolveReplyToMode;
+	if ("topLevelReplyToMode" in threading) resolveReplyToMode = createTopLevelChannelReplyToModeResolver(threading.topLevelReplyToMode);
+	else resolveReplyToMode = createScopedAccountReplyToModeResolver(threading.scopedAccountReplyToMode);
+	return {
+		...threading,
+		resolveReplyToMode
+	};
+}
+function resolveChatChannelOutbound(outbound) {
+	if (!outbound) return;
+	if (!("attachedResults" in outbound)) return outbound;
+	return {
+		...outbound.base,
+		...createInlineAttachedChannelResultAdapter(outbound.attachedResults)
+	};
+}
+function createChatChannelPlugin(params) {
+	return {
+		...params.base,
+		conversationBindings: {
+			supportsCurrentConversationBinding: true,
+			...params.base.conversationBindings
+		},
+		...params.security ? { security: resolveChatChannelSecurity(params.security) } : {},
+		...params.pairing ? { pairing: resolveChatChannelPairing(params.pairing) } : {},
+		...params.threading ? { threading: resolveChatChannelThreading(params.threading) } : {},
+		...params.outbound ? { outbound: resolveChatChannelOutbound(params.outbound) } : {}
+	};
+}
+function createChannelPluginBase(params) {
+	return {
+		id: params.id,
+		meta: {
+			...resolveSdkChatChannelMeta(params.id),
+			...params.meta
+		},
+		...params.setupWizard ? { setupWizard: params.setupWizard } : {},
+		...params.capabilities ? { capabilities: params.capabilities } : {},
+		...params.commands ? { commands: params.commands } : {},
+		...params.doctor ? { doctor: params.doctor } : {},
+		...params.agentPrompt ? { agentPrompt: params.agentPrompt } : {},
+		...params.streaming ? { streaming: params.streaming } : {},
+		...params.reload ? { reload: params.reload } : {},
+		...params.gatewayMethods ? { gatewayMethods: params.gatewayMethods } : {},
+		...params.configSchema ? { configSchema: params.configSchema } : {},
+		...params.config ? { config: params.config } : {},
+		...params.security ? { security: params.security } : {},
+		...params.groups ? { groups: params.groups } : {},
+		setup: params.setup
+	};
+}
+//#endregion
+export { defineChannelPluginEntry as a, getChatChannelMeta as c, stripTargetKindPrefix as d, createChatChannelPlugin as i, recoverCurrentThreadSessionId as l, buildThreadAwareOutboundSessionRoute as n, defineSetupPluginEntry as o, createChannelPluginBase as r, ensureConfiguredAcpBindingReady as s, buildChannelOutboundSessionRoute as t, stripChannelTargetPrefix as u };