fengming 0.3.8 → 0.3.10

package/dist/runtime-D2ee-rNh.js

@@ -0,0 +1,436 @@
+import { c as normalizeOptionalString } from "./string-coerce-DKw2K5wM.js";
+import { a as asFiniteNumber } from "./number-coercion-D1aDmIZp.js";
+import { y as resolveStateDir } from "./paths-9MqJt9oL.js";
+import { c as isRecord } from "./utils-v5zGdVpj.js";
+import { t as createSubsystemLogger } from "./subsystem-B7U-DPv3.js";
+import "./agent-scope-EEbMCF2I.js";
+import { o as resolveAgentWorkspaceDir, r as resolveAgentConfig } from "./agent-scope-config-BHdZonI2.js";
+import { n as resolveHeartbeatIntervalMs } from "./heartbeat-summary-3LqM7qal.js";
+import { d as resolveCommitmentTimezone, f as resolveCommitmentsConfig, i as listPendingCommitmentsForScope, u as upsertInferredCommitments } from "./store-CvcXGP5Y.js";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+//#region src/commitments/extraction.ts
+const KIND_VALUES = new Set([
+	"event_check_in",
+	"deadline_check",
+	"care_check_in",
+	"open_loop"
+]);
+const SENSITIVITY_VALUES = new Set([
+	"routine",
+	"personal",
+	"care"
+]);
+const SOURCE_VALUES = new Set(["inferred_user_context", "agent_promise"]);
+function asNumber(value) {
+	return asFiniteNumber(value);
+}
+function parseCandidate(raw) {
+	if (!isRecord(raw)) return;
+	if (raw.action === "skip") return;
+	const itemId = normalizeOptionalString(raw.itemId);
+	const kind = normalizeOptionalString(raw.kind);
+	const sensitivity = normalizeOptionalString(raw.sensitivity);
+	const source = normalizeOptionalString(raw.source) ?? "inferred_user_context";
+	const reason = normalizeOptionalString(raw.reason);
+	const suggestedText = normalizeOptionalString(raw.suggestedText);
+	const dedupeKey = normalizeOptionalString(raw.dedupeKey);
+	const confidence = asNumber(raw.confidence);
+	const dueWindow = isRecord(raw.dueWindow) ? raw.dueWindow : void 0;
+	const earliest = normalizeOptionalString(dueWindow?.earliest);
+	const latest = normalizeOptionalString(dueWindow?.latest);
+	const timezone = normalizeOptionalString(dueWindow?.timezone);
+	if (!itemId || !KIND_VALUES.has(kind) || !SENSITIVITY_VALUES.has(sensitivity) || !SOURCE_VALUES.has(source) || !reason || !suggestedText || !dedupeKey || confidence === void 0 || !earliest) return;
+	return {
+		itemId,
+		kind,
+		sensitivity,
+		source,
+		reason,
+		suggestedText,
+		dedupeKey,
+		confidence,
+		dueWindow: {
+			earliest,
+			...latest ? { latest } : {},
+			...timezone ? { timezone } : {}
+		}
+	};
+}
+function extractJsonObjectCandidates(raw) {
+	const out = [];
+	let depth = 0;
+	let start = -1;
+	let inString = false;
+	let escaped = false;
+	for (let idx = 0; idx < raw.length; idx += 1) {
+		const char = raw[idx] ?? "";
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			if (inString) escaped = true;
+			continue;
+		}
+		if (char === "\"") {
+			inString = !inString;
+			continue;
+		}
+		if (inString) continue;
+		if (char === "{") {
+			if (depth === 0) start = idx;
+			depth += 1;
+			continue;
+		}
+		if (char === "}" && depth > 0) {
+			depth -= 1;
+			if (depth === 0 && start >= 0) {
+				out.push(raw.slice(start, idx + 1));
+				start = -1;
+			}
+		}
+	}
+	return out;
+}
+function parseCommitmentExtractionOutput(raw) {
+	const candidates = [];
+	const trimmed = raw.trim();
+	if (!trimmed) return { candidates };
+	const records = [];
+	try {
+		const parsed = JSON.parse(trimmed);
+		if (isRecord(parsed)) records.push(parsed);
+	} catch {
+		for (const candidate of extractJsonObjectCandidates(trimmed)) try {
+			const parsed = JSON.parse(candidate);
+			if (isRecord(parsed)) records.push(parsed);
+		} catch {}
+	}
+	for (const record of records) {
+		const rawCandidates = Array.isArray(record.candidates) ? record.candidates : [];
+		for (const candidate of rawCandidates) {
+			const parsed = parseCandidate(candidate);
+			if (parsed) candidates.push(parsed);
+		}
+	}
+	return { candidates };
+}
+async function hydrateCommitmentExtractionItem(params) {
+	const existingPending = await listPendingCommitmentsForScope({
+		cfg: params.cfg,
+		scope: params.item,
+		nowMs: params.item.nowMs,
+		limit: 8
+	});
+	return {
+		...params.item,
+		existingPending: existingPending.map((commitment) => ({
+			kind: commitment.kind,
+			reason: commitment.reason,
+			dedupeKey: commitment.dedupeKey,
+			earliestMs: commitment.dueWindow.earliestMs,
+			latestMs: commitment.dueWindow.latestMs
+		}))
+	};
+}
+function formatExistingPending(item) {
+	return item.existingPending.map((commitment) => ({
+		kind: commitment.kind,
+		reason: commitment.reason,
+		dedupeKey: commitment.dedupeKey,
+		earliest: new Date(commitment.earliestMs).toISOString(),
+		latest: new Date(commitment.latestMs).toISOString()
+	}));
+}
+function buildCommitmentExtractionPrompt(params) {
+	const items = params.items.map((item) => ({
+		itemId: item.itemId,
+		now: new Date(item.nowMs).toISOString(),
+		timezone: item.timezone,
+		latestUserMessage: item.userText,
+		assistantResponse: item.assistantText ?? "",
+		existingPendingCommitments: formatExistingPending(item)
+	}));
+	return `You are FengMing's internal commitment extractor. This is a hidden background classification run. Do not address the user.
+
+Create inferred follow-up commitments only. Exact user requests such as "remind me tomorrow", "schedule this", or "check in at 3" belong to cron/reminders and must be skipped.
+
+Use these categories: event_check_in, deadline_check, care_check_in, open_loop.
+
+Create a candidate only when the latest exchange creates a useful future check-in opportunity that the user did not explicitly schedule. Prefer no candidate over weak candidates.
+
+Rules:
+- Output JSON only, with top-level {"candidates":[...]}.
+- Each candidate must include itemId, kind, sensitivity, source, dueWindow, reason, suggestedText, confidence, and dedupeKey.
+- kind is one of event_check_in, deadline_check, care_check_in, open_loop.
+- sensitivity is routine, personal, or care.
+- source is inferred_user_context or agent_promise.
+- dueWindow.earliest and dueWindow.latest must be ISO timestamps in the future relative to that item.
+- Skip explicit reminders/scheduling requests; those are cron-owned.
+- Skip if the assistant already clearly says a cron reminder was scheduled.
+- Skip if the topic is already resolved in the assistant response.
+- Care check-ins must be gentle, rare, and high confidence. Avoid interrogating language.
+- Suggested text should be short, natural, and suitable to send in the same channel.
+- Dedupe keys should be stable within a session, like "interview:2026-04-29" or "sleep:2026-04-29".
+
+Items:
+${JSON.stringify(items, null, 2)}`;
+}
+function parseDueMs(raw) {
+	if (!raw) return;
+	const parsed = Date.parse(raw);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function resolveMinimumDueMs(params) {
+	const cfg = params.cfg ?? {};
+	const defaults = cfg.agents?.defaults?.heartbeat;
+	const overrides = resolveAgentConfig(cfg, params.item.agentId)?.heartbeat;
+	const intervalMs = resolveHeartbeatIntervalMs(cfg, void 0, defaults || overrides ? {
+		...defaults,
+		...overrides
+	} : void 0) ?? 0;
+	return params.nowMs + intervalMs;
+}
+function validateCommitmentCandidates(params) {
+	const resolved = resolveCommitmentsConfig(params.cfg);
+	const itemsById = new Map(params.items.map((item) => [item.itemId, item]));
+	const nowMs = params.nowMs ?? Date.now();
+	const validated = [];
+	for (const candidate of params.result.candidates) {
+		const item = itemsById.get(candidate.itemId);
+		if (!item) continue;
+		const threshold = candidate.kind === "care_check_in" || candidate.sensitivity === "care" ? resolved.extraction.careConfidenceThreshold : resolved.extraction.confidenceThreshold;
+		if (candidate.confidence < threshold) continue;
+		const extractedEarliestMs = parseDueMs(candidate.dueWindow.earliest);
+		if (extractedEarliestMs === void 0 || extractedEarliestMs <= item.nowMs) continue;
+		const earliestMs = Math.max(extractedEarliestMs, resolveMinimumDueMs({
+			cfg: params.cfg,
+			item,
+			nowMs
+		}));
+		const latestRawMs = parseDueMs(candidate.dueWindow.latest);
+		const latestMs = latestRawMs !== void 0 && latestRawMs >= earliestMs ? latestRawMs : earliestMs + 720 * 60 * 1e3;
+		validated.push({
+			item,
+			candidate,
+			earliestMs,
+			latestMs,
+			timezone: candidate.dueWindow.timezone ?? item.timezone
+		});
+	}
+	return validated;
+}
+async function persistCommitmentExtractionResult(params) {
+	const valid = validateCommitmentCandidates(params);
+	const byItem = /* @__PURE__ */ new Map();
+	for (const entry of valid) {
+		const existing = byItem.get(entry.item.itemId) ?? [];
+		existing.push(entry);
+		byItem.set(entry.item.itemId, existing);
+	}
+	const created = [];
+	for (const entries of byItem.values()) {
+		const item = entries[0]?.item;
+		if (!item) continue;
+		created.push(...await upsertInferredCommitments({
+			cfg: params.cfg,
+			item,
+			candidates: entries.map((entry) => ({
+				candidate: entry.candidate,
+				earliestMs: entry.earliestMs,
+				latestMs: entry.latestMs,
+				timezone: entry.timezone
+			})),
+			nowMs: params.nowMs
+		}));
+	}
+	return created;
+}
+//#endregion
+//#region src/commitments/runtime.ts
+const log = createSubsystemLogger("commitments");
+const TERMINAL_EXTRACTION_FAILURE_COOLDOWN_MS = 15 * 6e4;
+let runtime = {};
+let queue = [];
+let timer = null;
+let draining = false;
+let queueOverflowWarned = false;
+let terminalFailureCooldownUntilByAgent = /* @__PURE__ */ new Map();
+function shouldDisableBackgroundExtractionForTests() {
+	if (runtime.forceInTests) return false;
+	return process.env.VITEST === "true" || false;
+}
+function setTimer(callback, delayMs) {
+	const handle = runtime.setTimer ? runtime.setTimer(callback, delayMs) : setTimeout(callback, delayMs);
+	if (typeof handle === "object" && "unref" in handle && typeof handle.unref === "function") handle.unref();
+	return handle;
+}
+function clearTimer(handle) {
+	(runtime.clearTimer ?? clearTimeout)(handle);
+}
+function configureCommitmentExtractionRuntime(next) {
+	runtime = next;
+}
+function resetCommitmentExtractionRuntimeForTests() {
+	if (timer) clearTimer(timer);
+	runtime = {};
+	queue = [];
+	timer = null;
+	draining = false;
+	queueOverflowWarned = false;
+	terminalFailureCooldownUntilByAgent = /* @__PURE__ */ new Map();
+}
+function buildItemId(params, nowMs) {
+	return `${normalizeOptionalString(params.sourceMessageId) ? "message" : "turn"}:${nowMs.toString(36)}:${randomUUID()}`;
+}
+function isUsefulText(value) {
+	return Boolean(value?.trim());
+}
+function enqueueCommitmentExtraction(input) {
+	const resolved = resolveCommitmentsConfig(input.cfg);
+	const nowMs = input.nowMs ?? Date.now();
+	const agentId = normalizeOptionalString(input.agentId) ?? "";
+	const sessionKey = normalizeOptionalString(input.sessionKey) ?? "";
+	const channel = normalizeOptionalString(input.channel) ?? "";
+	if (!resolved.enabled || shouldDisableBackgroundExtractionForTests() || (agentId ? nowMs < (terminalFailureCooldownUntilByAgent.get(agentId) ?? 0) : false) || !isUsefulText(input.userText) || !isUsefulText(input.assistantText) || !agentId || !sessionKey || !channel) return false;
+	if (queue.length >= resolved.extraction.queueMaxItems) {
+		if (!queueOverflowWarned) {
+			log.warn("commitment extraction queue full; dropping hidden extraction request", {
+				queued: queue.length,
+				max: resolved.extraction.queueMaxItems
+			});
+			queueOverflowWarned = true;
+		}
+		return false;
+	}
+	queue.push({
+		itemId: buildItemId(input, nowMs),
+		nowMs,
+		timezone: resolveCommitmentTimezone(input.cfg),
+		agentId,
+		sessionKey,
+		channel,
+		...input.accountId?.trim() ? { accountId: input.accountId.trim() } : {},
+		...input.to?.trim() ? { to: input.to.trim() } : {},
+		...input.threadId?.trim() ? { threadId: input.threadId.trim() } : {},
+		...input.senderId?.trim() ? { senderId: input.senderId.trim() } : {},
+		userText: input.userText.trim(),
+		...input.assistantText?.trim() ? { assistantText: input.assistantText.trim() } : {},
+		...input.sourceMessageId?.trim() ? { sourceMessageId: input.sourceMessageId.trim() } : {},
+		...input.sourceRunId?.trim() ? { sourceRunId: input.sourceRunId.trim() } : {},
+		cfg: input.cfg
+	});
+	if (!timer) timer = setTimer(() => {
+		timer = null;
+		drainCommitmentExtractionQueue().catch((err) => {
+			log.warn("commitment extraction failed", { error: String(err) });
+		});
+	}, resolved.extraction.debounceMs);
+	return true;
+}
+function isTerminalExtractionError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return /\bNo API key found\b/i.test(message) || /\bUnknown model\b/i.test(message) || /\b认证配置 credentials are missing or expired\b/i.test(message) || /\bOAuth token refresh failed\b/i.test(message) || /\bmissing credential\b/i.test(message) || /\bmissing credentials\b/i.test(message) || /\bmissing_api_key\b/i.test(message) || /\binvalid_grant\b/i.test(message);
+}
+function openTerminalFailureCooldown(agentId, error) {
+	terminalFailureCooldownUntilByAgent.set(agentId, Date.now() + TERMINAL_EXTRACTION_FAILURE_COOLDOWN_MS);
+	queue = queue.filter((item) => item.agentId !== agentId);
+	log.warn("commitment extraction disabled temporarily after terminal model/auth failure", {
+		agentId,
+		cooldownMs: TERMINAL_EXTRACTION_FAILURE_COOLDOWN_MS,
+		error: String(error)
+	});
+}
+function resolveExtractionSessionFile(agentId, runId) {
+	return path.join(resolveStateDir(), "commitments", "extractor-sessions", agentId, `${runId}.jsonl`);
+}
+function joinPayloadText(result) {
+	return result.payloads?.map((payload) => payload.text).filter((text) => Boolean(text?.trim())).join("\n").trim() ?? "";
+}
+async function resolveDefaultModel(params) {
+	if (runtime.resolveDefaultModel) return runtime.resolveDefaultModel(params);
+	const { resolveCommitmentDefaultModelRef } = await import("./model-selection.runtime.js");
+	return resolveCommitmentDefaultModelRef(params);
+}
+async function defaultExtractBatch(params) {
+	const cfg = params.cfg ?? {};
+	const first = params.items[0];
+	if (!first) return { candidates: [] };
+	const resolved = resolveCommitmentsConfig(cfg);
+	const runId = `commitments-${randomUUID()}`;
+	const modelRef = await resolveDefaultModel({
+		cfg,
+		agentId: first.agentId
+	});
+	const { runEmbeddedAgent } = await import("./embedded-agent-CEpOPW6X.js");
+	return parseCommitmentExtractionOutput(joinPayloadText(await runEmbeddedAgent({
+		sessionId: runId,
+		sessionKey: `agent:${first.agentId}:commitments:${runId}`,
+		agentId: first.agentId,
+		trigger: "manual",
+		sessionFile: resolveExtractionSessionFile(first.agentId, runId),
+		workspaceDir: resolveAgentWorkspaceDir(cfg, first.agentId),
+		config: cfg,
+		provider: modelRef.provider,
+		model: modelRef.model,
+		prompt: buildCommitmentExtractionPrompt({
+			cfg,
+			items: params.items
+		}),
+		disableTools: true,
+		thinkLevel: "off",
+		verboseLevel: "off",
+		reasoningLevel: "off",
+		fastMode: true,
+		timeoutMs: resolved.extraction.timeoutSeconds * 1e3,
+		runId,
+		bootstrapContextMode: "lightweight",
+		skillsSnapshot: {
+			prompt: "",
+			skills: []
+		},
+		suppressToolErrorWarnings: true
+	})));
+}
+async function hydrateBatch(batch) {
+	return Promise.all(batch.map(async (item) => hydrateCommitmentExtractionItem({
+		cfg: item.cfg,
+		item
+	})));
+}
+async function drainCommitmentExtractionQueue() {
+	if (draining) return 0;
+	draining = true;
+	try {
+		let processed = 0;
+		while (queue.length > 0) {
+			const firstCfg = queue[0]?.cfg;
+			const resolved = resolveCommitmentsConfig(firstCfg);
+			const items = await hydrateBatch(queue.splice(0, resolved.extraction.batchMaxItems));
+			const extractor = runtime.extractBatch ?? defaultExtractBatch;
+			let result;
+			try {
+				result = await extractor({
+					cfg: firstCfg,
+					items
+				});
+			} catch (error) {
+				if (isTerminalExtractionError(error)) openTerminalFailureCooldown(items[0]?.agentId ?? "", error);
+				throw error;
+			}
+			await persistCommitmentExtractionResult({
+				cfg: firstCfg,
+				items,
+				result,
+				nowMs: Date.now()
+			});
+			processed += items.length;
+		}
+		return processed;
+	} finally {
+		draining = false;
+	}
+}
+//#endregion
+export { resetCommitmentExtractionRuntimeForTests as i, drainCommitmentExtractionQueue as n, enqueueCommitmentExtraction as r, configureCommitmentExtractionRuntime as t };

package/dist/runtime-api-B99ZlkNt.d.ts

@@ -0,0 +1,5 @@
+import { Qn as PluginRuntime } from "./types-BQw1qXGl.js";
+//#region extensions/feishu/src/runtime.d.ts
+declare const setFeishuRuntime: (next: PluginRuntime) => void, getFeishuRuntime: () => PluginRuntime;
+//#endregion
+export { setFeishuRuntime as t };

package/dist/runtime-api-Cta2L_Yo.js

@@ -0,0 +1,12 @@
+import "./json-store-Kl4cTNgj.js";
+import "./agent-media-payload-AjmzlZhy.js";
+import "./text-chunking-BoSCx-lb.js";
+import "./core-Bpk-qSJH.js";
+import "./routing-B7t3bis6.js";
+import "./channel-outbound-Bt45s9Ss.js";
+import "./channel-status-CGihze3B.js";
+import "./channel-pairing-Cv2ZnWj8.js";
+import "./session-store-runtime-BFRScnF6.js";
+import "./webhook-ingress-DyZtA8HM.js";
+import "./runtime-Nn_DZ_d8.js";
+export {};

package/dist/runtime-channel-LKOkML3M.js

@@ -0,0 +1,2 @@
+import { t as createRuntimeChannel } from "./runtime-channel-UtWvrTZ5.js";
+export { createRuntimeChannel };

package/dist/runtime-channel-UtWvrTZ5.js

@@ -0,0 +1,148 @@
+import { u as resolveStorePath } from "./paths-C79m3Aob.js";
+import { o as readSessionUpdatedAt, s as recordSessionMetaFromInbound, u as updateLastRoute } from "./store-DH20opqS.js";
+import "./sessions-CtMqsEs2.js";
+import { i as shouldComputeCommandAuthorized, r as isControlCommandMessage, t as hasControlCommand } from "./command-detection-zEDbyLv6.js";
+import { a as settleReplyDispatcher, i as dispatchReplyFromConfig, o as withReplyDispatcher } from "./dispatch-Dtl-oRuN.js";
+import { n as resolveChannelGroupRequireMention, t as resolveChannelGroupPolicy } from "./group-policy-CRZph9M9.js";
+import { i as resolveAgentRoute, t as buildAgentSessionKey } from "./resolve-route-BiiTEeds.js";
+import { t as resolveCommandAuthorizedFromAuthorizers } from "./command-gating-BZR3snoF.js";
+import { a as readChannelAllowFromStore, d as upsertChannelPairingRequest } from "./pairing-store-Buj1MLbr.js";
+import { n as resolveInboundMentionDecision, t as implicitMentionKindWhen } from "./mention-gating-3P8aSD7o.js";
+import { u as saveMediaBuffer } from "./store-BCRjjjf9.js";
+import { a as saveRemoteMedia, i as readRemoteMediaBuffer, o as saveResponseMedia, r as fetchRemoteMedia } from "./fetch-DcI2KQQQ.js";
+import { i as resolveHumanDelayConfig, r as resolveEffectiveMessagesConfig } from "./identity-Dj0UzUyT.js";
+import { a as chunkText, c as resolveTextChunkLimit, i as chunkMarkdownTextWithMode, o as chunkTextWithMode, r as chunkMarkdownText, s as resolveChunkMode, t as chunkByNewline } from "./chunk-B5pQrXHU.js";
+import { t as loadChannelOutboundAdapter } from "./load-C6GOee5P.js";
+import { t as convertMarkdownTables } from "./tables-BuSEibMW.js";
+import { n as shouldHandleTextCommands } from "./commands-text-routing-CxGxp95A.js";
+import "./commands-registry-Ca8q0Fs-.js";
+import { i as matchesMentionWithExplicit, n as buildMentionRegexes, r as matchesMentionPatterns } from "./mentions-B9wr_oN1.js";
+import { n as createReplyDispatcherWithTyping } from "./reply-dispatcher-DjSNvGzA.js";
+import { t as finalizeInboundContext } from "./inbound-context-CbkangX1.js";
+import { t as dispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher-DCTc4lG_.js";
+import { a as resolveEnvelopeFormatOptions, r as formatInboundEnvelope, t as formatAgentEnvelope } from "./envelope-D38xWWa-.js";
+import { n as resolveInboundDebounceMs, t as createInboundDebouncer } from "./inbound-debounce-DQpLvByk.js";
+import { i as shouldAckReaction, n as removeAckReactionAfterReply, r as removeAckReactionHandleAfterReply, t as createAckReactionHandle } from "./ack-reactions-BceP3SaE.js";
+import { l as runPreparedInboundReply, o as runChannelInboundEvent, r as dispatchChannelInboundReply, y as buildChannelInboundEventContext } from "./kernel-B1lMIbRI.js";
+import { n as setChannelConversationBindingMaxAgeBySessionKey, t as setChannelConversationBindingIdleTimeoutBySessionKey } from "./conversation-bindings-BeP_9560.js";
+import { t as recordInboundSession } from "./session-Ctdnca5j.js";
+import { t as resolveMarkdownTableMode } from "./markdown-tables-XG3mkh4z.js";
+import { n as recordChannelActivity, t as getChannelActivity } from "./channel-activity-eMQlJ3BE.js";
+import { t as buildPairingReply } from "./pairing-messages-DdmsXBqy.js";
+import { t as createChannelRuntimeContextRegistry } from "./channel-runtime-contexts-D5v1SI1w.js";
+//#region src/plugins/runtime/runtime-channel.ts
+function createRuntimeChannel() {
+	return {
+		text: {
+			chunkByNewline,
+			chunkMarkdownText,
+			chunkMarkdownTextWithMode,
+			chunkText,
+			chunkTextWithMode,
+			resolveChunkMode,
+			resolveTextChunkLimit,
+			hasControlCommand,
+			resolveMarkdownTableMode,
+			convertMarkdownTables
+		},
+		reply: {
+			dispatchReplyWithBufferedBlockDispatcher,
+			createReplyDispatcherWithTyping,
+			resolveEffectiveMessagesConfig,
+			resolveHumanDelayConfig,
+			dispatchReplyFromConfig,
+			withReplyDispatcher,
+			settleReplyDispatcher,
+			finalizeInboundContext,
+			formatAgentEnvelope,
+			/** @deprecated Prefer `BodyForAgent` + structured user-context blocks (do not build plaintext envelopes for prompts). */
+			formatInboundEnvelope,
+			resolveEnvelopeFormatOptions
+		},
+		routing: {
+			buildAgentSessionKey,
+			resolveAgentRoute
+		},
+		pairing: {
+			buildPairingReply,
+			readAllowFromStore: ({ channel, accountId, env }) => readChannelAllowFromStore(channel, env, accountId),
+			upsertPairingRequest: ({ channel, id, accountId, meta, env, pairingAdapter }) => upsertChannelPairingRequest({
+				channel,
+				id,
+				accountId,
+				meta,
+				env,
+				pairingAdapter
+			})
+		},
+		media: {
+			readRemoteMediaBuffer,
+			fetchRemoteMedia,
+			saveRemoteMedia,
+			saveResponseMedia,
+			saveMediaBuffer
+		},
+		activity: {
+			record: recordChannelActivity,
+			get: getChannelActivity
+		},
+		session: {
+			resolveStorePath,
+			readSessionUpdatedAt,
+			recordSessionMetaFromInbound,
+			recordInboundSession,
+			updateLastRoute
+		},
+		mentions: {
+			buildMentionRegexes,
+			matchesMentionPatterns,
+			matchesMentionWithExplicit,
+			implicitMentionKindWhen,
+			resolveInboundMentionDecision
+		},
+		reactions: {
+			createAckReactionHandle,
+			shouldAckReaction,
+			removeAckReactionAfterReply,
+			removeAckReactionHandleAfterReply
+		},
+		groups: {
+			resolveGroupPolicy: resolveChannelGroupPolicy,
+			resolveRequireMention: resolveChannelGroupRequireMention
+		},
+		debounce: {
+			createInboundDebouncer,
+			resolveInboundDebounceMs
+		},
+		commands: {
+			resolveCommandAuthorizedFromAuthorizers,
+			isControlCommandMessage,
+			shouldComputeCommandAuthorized,
+			shouldHandleTextCommands
+		},
+		outbound: { loadAdapter: loadChannelOutboundAdapter },
+		inbound: {
+			buildContext: buildChannelInboundEventContext,
+			run: runChannelInboundEvent,
+			runPreparedReply: runPreparedInboundReply,
+			dispatchReply: dispatchChannelInboundReply
+		},
+		threadBindings: {
+			setIdleTimeoutBySessionKey: ({ channelId, targetSessionKey, accountId, idleTimeoutMs }) => setChannelConversationBindingIdleTimeoutBySessionKey({
+				channelId,
+				targetSessionKey,
+				accountId,
+				idleTimeoutMs
+			}),
+			setMaxAgeBySessionKey: ({ channelId, targetSessionKey, accountId, maxAgeMs }) => setChannelConversationBindingMaxAgeBySessionKey({
+				channelId,
+				targetSessionKey,
+				accountId,
+				maxAgeMs
+			})
+		},
+		runtimeContexts: createChannelRuntimeContextRegistry()
+	};
+}
+//#endregion
+export { createRuntimeChannel as t };

package/dist/runtime-embedded-agent.runtime-9O2Idzyb.js

@@ -0,0 +1,2 @@
+import { t as runEmbeddedAgent } from "./embedded-agent-DxwzoZkp.js";
+export { runEmbeddedAgent };

package/dist/runtime-embedded-agent.runtime.js

@@ -1 +1 @@
-export * from "./runtime-embedded-agent.runtime-DwmqKUVp.js";
+export * from "./runtime-embedded-agent.runtime-9O2Idzyb.js";

package/dist/runtime-forwarders-DjI8RFL5.d.ts

@@ -0,0 +1,39 @@
+import { n as ChannelOutboundAdapter } from "./outbound.types-DVkbsxo8.js";
+import { x as ChannelDirectoryAdapter } from "./types.adapters-DSaA0bHm.js";
+
+//#region src/channels/plugins/runtime-forwarders.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type DirectoryMethod = "self" | "listPeersLive" | "listGroupsLive" | "listGroupMembers";
+type OutboundMethod = "renderPresentation" | "sendPayload" | "sendText" | "sendMedia" | "sendPoll";
+declare function createRuntimeDirectoryLiveAdapter<Runtime>(params: {
+  getRuntime: () => MaybePromise<Runtime>;
+  self?: (runtime: Runtime) => ChannelDirectoryAdapter["self"] | null | undefined;
+  listPeersLive?: (runtime: Runtime) => ChannelDirectoryAdapter["listPeersLive"] | null | undefined;
+  listGroupsLive?: (runtime: Runtime) => ChannelDirectoryAdapter["listGroupsLive"] | null | undefined;
+  listGroupMembers?: (runtime: Runtime) => ChannelDirectoryAdapter["listGroupMembers"] | null | undefined;
+}): Pick<ChannelDirectoryAdapter, DirectoryMethod>;
+declare function createRuntimeOutboundDelegates<Runtime>(params: {
+  getRuntime: () => MaybePromise<Runtime>;
+  renderPresentation?: {
+    resolve: (runtime: Runtime) => ChannelOutboundAdapter["renderPresentation"] | null | undefined;
+    unavailableMessage?: string;
+  };
+  sendPayload?: {
+    resolve: (runtime: Runtime) => ChannelOutboundAdapter["sendPayload"] | null | undefined;
+    unavailableMessage?: string;
+  };
+  sendText?: {
+    resolve: (runtime: Runtime) => ChannelOutboundAdapter["sendText"] | null | undefined;
+    unavailableMessage?: string;
+  };
+  sendMedia?: {
+    resolve: (runtime: Runtime) => ChannelOutboundAdapter["sendMedia"] | null | undefined;
+    unavailableMessage?: string;
+  };
+  sendPoll?: {
+    resolve: (runtime: Runtime) => ChannelOutboundAdapter["sendPoll"] | null | undefined;
+    unavailableMessage?: string;
+  };
+}): Pick<ChannelOutboundAdapter, OutboundMethod>;
+//#endregion
+export { createRuntimeOutboundDelegates as n, createRuntimeDirectoryLiveAdapter as t };

package/dist/sdk-setup-tools-B-X04pa6.js

@@ -0,0 +1,8 @@
+import "./media-runtime-BFo_Yvjz.js";
+import "./runtime-env-CvWo8qXm.js";
+import "./setup-tools-D7G3w2rW.js";
+import "./media-mime-CoRc7Jth.js";
+import "./cli-runtime-D7C6yK3b.js";
+import "./agent-harness-runtime-RkTGiliR.js";
+import "./channel-actions-DJzt_5gv.js";
+export {};

package/dist/selection-B02h8Old.js

@@ -0,0 +1,3 @@
+import { t as resolveAgentHarnessPolicy } from "./policy-vPn4fInM.js";
+import { i as selectAgentHarness, n as resolveAvailableAgentHarnessPolicy, r as runAgentHarnessAttempt, t as maybeCompactAgentHarnessSession } from "./selection-DEPvzrW2.js";
+export { maybeCompactAgentHarnessSession, resolveAgentHarnessPolicy, resolveAvailableAgentHarnessPolicy, runAgentHarnessAttempt, selectAgentHarness };