@kodelyth/feishu 2026.5.39 → 2026.5.42

package/dist/session-conversation-Duaukbnl.js

@@ -0,0 +1,27 @@
+import { r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-_58ecqlx.js";
+//#region extensions/feishu/src/session-conversation.ts
+function resolveFeishuParentConversationCandidates(rawId) {
+	const parsed = parseFeishuConversationId({ conversationId: rawId });
+	if (!parsed) return [];
+	switch (parsed.scope) {
+		case "group_topic_sender": return [buildFeishuConversationId({
+			chatId: parsed.chatId,
+			scope: "group_topic",
+			topicId: parsed.topicId
+		}), parsed.chatId];
+		case "group_topic":
+		case "group_sender": return [parsed.chatId];
+		default: return [];
+	}
+}
+function resolveFeishuSessionConversation(params) {
+	const parsed = parseFeishuConversationId({ conversationId: params.rawId });
+	if (!parsed) return null;
+	return {
+		id: parsed.canonicalConversationId,
+		baseConversationId: parsed.chatId,
+		parentConversationCandidates: resolveFeishuParentConversationCandidates(parsed.canonicalConversationId)
+	};
+}
+//#endregion
+export { resolveFeishuSessionConversation as t };

package/dist/session-key-api.js

@@ -0,0 +1,2 @@
+import { t as resolveFeishuSessionConversation } from "./session-conversation-Duaukbnl.js";
+export { resolveFeishuSessionConversation as resolveSessionConversation };

package/dist/setup-api.js

@@ -0,0 +1,2 @@
+import { i as feishuSetupAdapter, n as feishuSetupWizard, t as feishuPlugin } from "./channel-13WQvQ0u.js";
+export { feishuPlugin, feishuSetupAdapter, feishuSetupWizard };

package/dist/setup-entry.js

@@ -0,0 +1,15 @@
+import { defineBundledChannelSetupEntry } from "klaw/plugin-sdk/channel-entry-contract";
+//#region extensions/feishu/setup-entry.ts
+var setup_entry_default = defineBundledChannelSetupEntry({
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./setup-api.js",
+		exportName: "feishuPlugin"
+	},
+	secrets: {
+		specifier: "./secret-contract-api.js",
+		exportName: "channelSecrets"
+	}
+});
+//#endregion
+export { setup_entry_default as default };

package/dist/subagent-hooks-Dtegs0kh.js

@@ -0,0 +1,235 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-_58ecqlx.js";
+import { r as normalizeFeishuTarget } from "./targets-DFskxX4p.js";
+import { n as getFeishuThreadBindingManager } from "./thread-bindings-DI7lVSOE.js";
+import { normalizeOptionalLowercaseString, normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/feishu/src/subagent-hooks.ts
+var subagent_hooks_exports = /* @__PURE__ */ __exportAll({
+	handleFeishuSubagentDeliveryTarget: () => handleFeishuSubagentDeliveryTarget,
+	handleFeishuSubagentEnded: () => handleFeishuSubagentEnded,
+	handleFeishuSubagentSpawning: () => handleFeishuSubagentSpawning
+});
+function summarizeError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	return "error";
+}
+function stripProviderPrefix(raw) {
+	return raw.replace(/^(feishu|lark):/i, "").trim();
+}
+function resolveFeishuRequesterConversation(params) {
+	const manager = getFeishuThreadBindingManager(params.accountId);
+	if (!manager) return null;
+	const rawTo = params.to?.trim();
+	const withoutProviderPrefix = rawTo ? stripProviderPrefix(rawTo) : "";
+	const normalizedTarget = rawTo ? normalizeFeishuTarget(rawTo) : null;
+	const threadId = params.threadId != null && params.threadId !== "" ? String(params.threadId).trim() : "";
+	const isChatTarget = /^(chat|group|channel):/i.test(withoutProviderPrefix);
+	const parsedRequesterTopic = normalizedTarget && threadId && isChatTarget ? parseFeishuConversationId({
+		conversationId: buildFeishuConversationId({
+			chatId: normalizedTarget,
+			scope: "group_topic",
+			topicId: threadId
+		}),
+		parentConversationId: normalizedTarget
+	}) : null;
+	const requesterSessionKey = params.requesterSessionKey?.trim();
+	if (requesterSessionKey) {
+		const existingBindings = manager.listBySessionKey(requesterSessionKey);
+		if (existingBindings.length === 1) {
+			const existing = existingBindings[0];
+			return {
+				accountId: existing.accountId,
+				conversationId: existing.conversationId,
+				parentConversationId: existing.parentConversationId
+			};
+		}
+		if (existingBindings.length > 1) {
+			if (rawTo && normalizedTarget && !threadId && !isChatTarget) {
+				const directMatches = existingBindings.filter((entry) => entry.accountId === manager.accountId && entry.conversationId === normalizedTarget && !entry.parentConversationId);
+				if (directMatches.length === 1) {
+					const existing = directMatches[0];
+					return {
+						accountId: existing.accountId,
+						conversationId: existing.conversationId,
+						parentConversationId: existing.parentConversationId
+					};
+				}
+				return null;
+			}
+			if (parsedRequesterTopic) {
+				const matchingTopicBindings = existingBindings.filter((entry) => {
+					const parsed = parseFeishuConversationId({
+						conversationId: entry.conversationId,
+						parentConversationId: entry.parentConversationId
+					});
+					return parsed?.chatId === parsedRequesterTopic.chatId && parsed?.topicId === parsedRequesterTopic.topicId;
+				});
+				if (matchingTopicBindings.length === 1) {
+					const existing = matchingTopicBindings[0];
+					return {
+						accountId: existing.accountId,
+						conversationId: existing.conversationId,
+						parentConversationId: existing.parentConversationId
+					};
+				}
+				const senderScopedTopicBindings = matchingTopicBindings.filter((entry) => {
+					return parseFeishuConversationId({
+						conversationId: entry.conversationId,
+						parentConversationId: entry.parentConversationId
+					})?.scope === "group_topic_sender";
+				});
+				if (senderScopedTopicBindings.length === 1 && matchingTopicBindings.length === senderScopedTopicBindings.length) {
+					const existing = senderScopedTopicBindings[0];
+					return {
+						accountId: existing.accountId,
+						conversationId: existing.conversationId,
+						parentConversationId: existing.parentConversationId
+					};
+				}
+				return null;
+			}
+		}
+	}
+	if (!rawTo) return null;
+	if (!normalizedTarget) return null;
+	if (threadId) {
+		if (!isChatTarget) return null;
+		return {
+			accountId: manager.accountId,
+			conversationId: buildFeishuConversationId({
+				chatId: normalizedTarget,
+				scope: "group_topic",
+				topicId: threadId
+			}),
+			parentConversationId: normalizedTarget
+		};
+	}
+	if (isChatTarget) return null;
+	return {
+		accountId: manager.accountId,
+		conversationId: normalizedTarget
+	};
+}
+function resolveFeishuDeliveryOrigin(params) {
+	const deliveryTo = params.deliveryTo?.trim();
+	const deliveryThreadId = params.deliveryThreadId?.trim();
+	if (deliveryTo) return {
+		channel: "feishu",
+		accountId: params.accountId,
+		to: deliveryTo,
+		...deliveryThreadId ? { threadId: deliveryThreadId } : {}
+	};
+	const parsed = parseFeishuConversationId({
+		conversationId: params.conversationId,
+		parentConversationId: params.parentConversationId
+	});
+	if (parsed?.topicId) return {
+		channel: "feishu",
+		accountId: params.accountId,
+		to: `chat:${params.parentConversationId?.trim() || parsed.chatId}`,
+		threadId: parsed.topicId
+	};
+	return {
+		channel: "feishu",
+		accountId: params.accountId,
+		to: `user:${params.conversationId}`
+	};
+}
+function resolveMatchingChildBinding(params) {
+	const manager = getFeishuThreadBindingManager(params.accountId);
+	if (!manager) return null;
+	const childBindings = manager.listBySessionKey(params.childSessionKey.trim());
+	if (childBindings.length === 0) return null;
+	const requesterConversation = resolveFeishuRequesterConversation({
+		accountId: manager.accountId,
+		to: params.requesterOrigin?.to,
+		threadId: params.requesterOrigin?.threadId,
+		requesterSessionKey: params.requesterSessionKey
+	});
+	if (requesterConversation) {
+		const matched = childBindings.find((entry) => entry.accountId === requesterConversation.accountId && entry.conversationId === requesterConversation.conversationId && normalizeOptionalString(entry.parentConversationId) === normalizeOptionalString(requesterConversation.parentConversationId));
+		if (matched) return matched;
+	}
+	return childBindings.length === 1 ? childBindings[0] : null;
+}
+async function handleFeishuSubagentSpawning(event, ctx) {
+	if (!event.threadRequested) return;
+	if (normalizeOptionalLowercaseString(event.requester?.channel) !== "feishu") return;
+	const manager = getFeishuThreadBindingManager(event.requester?.accountId);
+	if (!manager) return {
+		status: "error",
+		error: "Feishu current-conversation binding is unavailable because the Feishu account monitor is not active."
+	};
+	const conversation = resolveFeishuRequesterConversation({
+		accountId: event.requester?.accountId,
+		to: event.requester?.to,
+		threadId: event.requester?.threadId,
+		requesterSessionKey: ctx.requesterSessionKey
+	});
+	if (!conversation) return {
+		status: "error",
+		error: "Feishu current-conversation binding is only available in direct messages or topic conversations."
+	};
+	try {
+		const binding = manager.bindConversation({
+			conversationId: conversation.conversationId,
+			parentConversationId: conversation.parentConversationId,
+			targetKind: "subagent",
+			targetSessionKey: event.childSessionKey,
+			metadata: {
+				agentId: event.agentId,
+				label: event.label,
+				boundBy: "system",
+				deliveryTo: event.requester?.to,
+				deliveryThreadId: event.requester?.threadId != null && event.requester.threadId !== "" ? String(event.requester.threadId) : void 0
+			}
+		});
+		if (!binding) return {
+			status: "error",
+			error: "Unable to bind this Feishu conversation to the spawned subagent session. Session mode is unavailable for this target."
+		};
+		return {
+			status: "ok",
+			threadBindingReady: true,
+			deliveryOrigin: resolveFeishuDeliveryOrigin({
+				conversationId: binding.conversationId,
+				parentConversationId: binding.parentConversationId,
+				accountId: binding.accountId,
+				deliveryTo: binding.deliveryTo,
+				deliveryThreadId: binding.deliveryThreadId
+			})
+		};
+	} catch (err) {
+		return {
+			status: "error",
+			error: `Feishu conversation bind failed: ${summarizeError(err)}`
+		};
+	}
+}
+function handleFeishuSubagentDeliveryTarget(event) {
+	if (!event.expectsCompletionMessage) return;
+	if (normalizeOptionalLowercaseString(event.requesterOrigin?.channel) !== "feishu") return;
+	const binding = resolveMatchingChildBinding({
+		accountId: event.requesterOrigin?.accountId,
+		childSessionKey: event.childSessionKey,
+		requesterSessionKey: event.requesterSessionKey,
+		requesterOrigin: {
+			to: event.requesterOrigin?.to,
+			threadId: event.requesterOrigin?.threadId
+		}
+	});
+	if (!binding) return;
+	return { origin: resolveFeishuDeliveryOrigin({
+		conversationId: binding.conversationId,
+		parentConversationId: binding.parentConversationId,
+		accountId: binding.accountId,
+		deliveryTo: binding.deliveryTo,
+		deliveryThreadId: binding.deliveryThreadId
+	}) };
+}
+function handleFeishuSubagentEnded(event) {
+	getFeishuThreadBindingManager(event.accountId)?.unbindBySessionKey(event.targetSessionKey);
+}
+//#endregion
+export { subagent_hooks_exports as i, handleFeishuSubagentEnded as n, handleFeishuSubagentSpawning as r, handleFeishuSubagentDeliveryTarget as t };

package/dist/subagent-hooks-api.js

@@ -0,0 +1,23 @@
+import { n as handleFeishuSubagentEnded, r as handleFeishuSubagentSpawning, t as handleFeishuSubagentDeliveryTarget } from "./subagent-hooks-Dtegs0kh.js";
+//#region extensions/feishu/subagent-hooks-api.ts
+let feishuSubagentHooksPromise = null;
+function loadFeishuSubagentHooksModule() {
+	feishuSubagentHooksPromise ??= import("./subagent-hooks-Dtegs0kh.js").then((n) => n.i);
+	return feishuSubagentHooksPromise;
+}
+function registerFeishuSubagentHooks(api) {
+	api.on("subagent_spawning", async (event, ctx) => {
+		const { handleFeishuSubagentSpawning } = await loadFeishuSubagentHooksModule();
+		return await handleFeishuSubagentSpawning(event, ctx);
+	});
+	api.on("subagent_delivery_target", async (event) => {
+		const { handleFeishuSubagentDeliveryTarget } = await loadFeishuSubagentHooksModule();
+		return handleFeishuSubagentDeliveryTarget(event);
+	});
+	api.on("subagent_ended", async (event) => {
+		const { handleFeishuSubagentEnded } = await loadFeishuSubagentHooksModule();
+		handleFeishuSubagentEnded(event);
+	});
+}
+//#endregion
+export { handleFeishuSubagentDeliveryTarget, handleFeishuSubagentEnded, handleFeishuSubagentSpawning, registerFeishuSubagentHooks };

package/dist/targets-DFskxX4p.js

@@ -0,0 +1,48 @@
+import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/feishu/src/targets.ts
+const CHAT_ID_PREFIX = "oc_";
+const OPEN_ID_PREFIX = "ou_";
+const USER_ID_REGEX = /^[a-zA-Z0-9_-]+$/;
+function stripProviderPrefix(raw) {
+	return raw.replace(/^(feishu|lark):/i, "").trim();
+}
+function detectIdType(id) {
+	const trimmed = id.trim();
+	if (trimmed.startsWith(CHAT_ID_PREFIX)) return "chat_id";
+	if (trimmed.startsWith(OPEN_ID_PREFIX)) return "open_id";
+	if (USER_ID_REGEX.test(trimmed)) return "user_id";
+	return null;
+}
+function normalizeFeishuTarget(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return null;
+	const withoutProvider = stripProviderPrefix(trimmed);
+	const lowered = normalizeLowercaseStringOrEmpty(withoutProvider);
+	if (lowered.startsWith("chat:")) return withoutProvider.slice(5).trim() || null;
+	if (lowered.startsWith("group:")) return withoutProvider.slice(6).trim() || null;
+	if (lowered.startsWith("channel:")) return withoutProvider.slice(8).trim() || null;
+	if (lowered.startsWith("user:")) return withoutProvider.slice(5).trim() || null;
+	if (lowered.startsWith("dm:")) return withoutProvider.slice(3).trim() || null;
+	if (lowered.startsWith("open_id:")) return withoutProvider.slice(8).trim() || null;
+	return withoutProvider;
+}
+function resolveReceiveIdType(id) {
+	const trimmed = id.trim();
+	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lowered.startsWith("chat:") || lowered.startsWith("group:") || lowered.startsWith("channel:")) return "chat_id";
+	if (lowered.startsWith("open_id:")) return "open_id";
+	if (lowered.startsWith("user:") || lowered.startsWith("dm:")) return trimmed.replace(/^(user|dm):/i, "").trim().startsWith(OPEN_ID_PREFIX) ? "open_id" : "user_id";
+	if (trimmed.startsWith(CHAT_ID_PREFIX)) return "chat_id";
+	if (trimmed.startsWith(OPEN_ID_PREFIX)) return "open_id";
+	return "user_id";
+}
+function looksLikeFeishuId(raw) {
+	const trimmed = stripProviderPrefix(raw.trim());
+	if (!trimmed) return false;
+	if (/^(chat|group|channel|user|dm|open_id):/i.test(trimmed)) return true;
+	if (trimmed.startsWith(CHAT_ID_PREFIX)) return true;
+	if (trimmed.startsWith(OPEN_ID_PREFIX)) return true;
+	return false;
+}
+//#endregion
+export { resolveReceiveIdType as i, looksLikeFeishuId as n, normalizeFeishuTarget as r, detectIdType as t };

package/dist/thread-bindings-DI7lVSOE.js

@@ -0,0 +1,222 @@
+import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { registerSessionBindingAdapter, resolveThreadBindingConversationIdFromBindingId, resolveThreadBindingIdleTimeoutMsForChannel, resolveThreadBindingMaxAgeMsForChannel, unregisterSessionBindingAdapter } from "klaw/plugin-sdk/conversation-runtime";
+import { normalizeAccountId, resolveAgentIdFromSessionKey } from "klaw/plugin-sdk/routing";
+//#region extensions/feishu/src/thread-bindings.ts
+const FEISHU_THREAD_BINDINGS_STATE_KEY = Symbol.for("klaw.feishuThreadBindingsState");
+let state;
+function getState() {
+	if (!state) {
+		const globalStore = globalThis;
+		state = globalStore[FEISHU_THREAD_BINDINGS_STATE_KEY] ?? {
+			managersByAccountId: /* @__PURE__ */ new Map(),
+			bindingsByAccountConversation: /* @__PURE__ */ new Map()
+		};
+		globalStore[FEISHU_THREAD_BINDINGS_STATE_KEY] = state;
+	}
+	return state;
+}
+function resolveBindingKey(params) {
+	return `${params.accountId}:${params.conversationId}`;
+}
+function toSessionBindingTargetKind(raw) {
+	return raw === "subagent" ? "subagent" : "session";
+}
+function toFeishuTargetKind(raw) {
+	return raw === "subagent" ? "subagent" : "acp";
+}
+function toSessionBindingRecord(record, defaults) {
+	const idleExpiresAt = defaults.idleTimeoutMs > 0 ? record.lastActivityAt + defaults.idleTimeoutMs : void 0;
+	const maxAgeExpiresAt = defaults.maxAgeMs > 0 ? record.boundAt + defaults.maxAgeMs : void 0;
+	const expiresAt = idleExpiresAt != null && maxAgeExpiresAt != null ? Math.min(idleExpiresAt, maxAgeExpiresAt) : idleExpiresAt ?? maxAgeExpiresAt;
+	return {
+		bindingId: resolveBindingKey({
+			accountId: record.accountId,
+			conversationId: record.conversationId
+		}),
+		targetSessionKey: record.targetSessionKey,
+		targetKind: toSessionBindingTargetKind(record.targetKind),
+		conversation: {
+			channel: "feishu",
+			accountId: record.accountId,
+			conversationId: record.conversationId,
+			parentConversationId: record.parentConversationId
+		},
+		status: "active",
+		boundAt: record.boundAt,
+		expiresAt,
+		metadata: {
+			agentId: record.agentId,
+			label: record.label,
+			boundBy: record.boundBy,
+			deliveryTo: record.deliveryTo,
+			deliveryThreadId: record.deliveryThreadId,
+			lastActivityAt: record.lastActivityAt,
+			idleTimeoutMs: defaults.idleTimeoutMs,
+			maxAgeMs: defaults.maxAgeMs
+		}
+	};
+}
+function createFeishuThreadBindingManager(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const existing = getState().managersByAccountId.get(accountId);
+	if (existing) return existing;
+	const idleTimeoutMs = resolveThreadBindingIdleTimeoutMsForChannel({
+		cfg: params.cfg,
+		channel: "feishu",
+		accountId
+	});
+	const maxAgeMs = resolveThreadBindingMaxAgeMsForChannel({
+		cfg: params.cfg,
+		channel: "feishu",
+		accountId
+	});
+	const manager = {
+		accountId,
+		getByConversationId: (conversationId) => getState().bindingsByAccountConversation.get(resolveBindingKey({
+			accountId,
+			conversationId
+		})),
+		listBySessionKey: (targetSessionKey) => [...getState().bindingsByAccountConversation.values()].filter((record) => record.accountId === accountId && record.targetSessionKey === targetSessionKey),
+		bindConversation: ({ conversationId, parentConversationId, targetKind, targetSessionKey, metadata }) => {
+			const normalizedConversationId = conversationId.trim();
+			const normalizedTargetSessionKey = targetSessionKey.trim();
+			if (!normalizedConversationId || !normalizedTargetSessionKey) return null;
+			const existing = getState().bindingsByAccountConversation.get(resolveBindingKey({
+				accountId,
+				conversationId: normalizedConversationId
+			}));
+			const now = Date.now();
+			const record = {
+				accountId,
+				conversationId: normalizedConversationId,
+				parentConversationId: normalizeOptionalString(parentConversationId) ?? existing?.parentConversationId,
+				deliveryTo: typeof metadata?.deliveryTo === "string" && metadata.deliveryTo.trim() ? metadata.deliveryTo.trim() : existing?.deliveryTo,
+				deliveryThreadId: typeof metadata?.deliveryThreadId === "string" && metadata.deliveryThreadId.trim() ? metadata.deliveryThreadId.trim() : existing?.deliveryThreadId,
+				targetKind: toFeishuTargetKind(targetKind),
+				targetSessionKey: normalizedTargetSessionKey,
+				agentId: typeof metadata?.agentId === "string" && metadata.agentId.trim() ? metadata.agentId.trim() : existing?.agentId ?? resolveAgentIdFromSessionKey(normalizedTargetSessionKey),
+				label: typeof metadata?.label === "string" && metadata.label.trim() ? metadata.label.trim() : existing?.label,
+				boundBy: typeof metadata?.boundBy === "string" && metadata.boundBy.trim() ? metadata.boundBy.trim() : existing?.boundBy,
+				boundAt: now,
+				lastActivityAt: now
+			};
+			getState().bindingsByAccountConversation.set(resolveBindingKey({
+				accountId,
+				conversationId: normalizedConversationId
+			}), record);
+			return record;
+		},
+		touchConversation: (conversationId, at = Date.now()) => {
+			const key = resolveBindingKey({
+				accountId,
+				conversationId
+			});
+			const existingRecord = getState().bindingsByAccountConversation.get(key);
+			if (!existingRecord) return null;
+			const updated = {
+				...existingRecord,
+				lastActivityAt: at
+			};
+			getState().bindingsByAccountConversation.set(key, updated);
+			return updated;
+		},
+		unbindConversation: (conversationId) => {
+			const key = resolveBindingKey({
+				accountId,
+				conversationId
+			});
+			const existingRecord = getState().bindingsByAccountConversation.get(key);
+			if (!existingRecord) return null;
+			getState().bindingsByAccountConversation.delete(key);
+			return existingRecord;
+		},
+		unbindBySessionKey: (targetSessionKey) => {
+			const removed = [];
+			for (const record of getState().bindingsByAccountConversation.values()) {
+				if (record.accountId !== accountId || record.targetSessionKey !== targetSessionKey) continue;
+				getState().bindingsByAccountConversation.delete(resolveBindingKey({
+					accountId,
+					conversationId: record.conversationId
+				}));
+				removed.push(record);
+			}
+			return removed;
+		},
+		stop: () => {
+			for (const key of getState().bindingsByAccountConversation.keys()) if (key.startsWith(`${accountId}:`)) getState().bindingsByAccountConversation.delete(key);
+			getState().managersByAccountId.delete(accountId);
+			unregisterSessionBindingAdapter({
+				channel: "feishu",
+				accountId,
+				adapter: sessionBindingAdapter
+			});
+		}
+	};
+	const sessionBindingAdapter = {
+		channel: "feishu",
+		accountId,
+		capabilities: { placements: ["current"] },
+		bind: async (input) => {
+			if (input.conversation.channel !== "feishu" || input.placement === "child") return null;
+			const bound = manager.bindConversation({
+				conversationId: input.conversation.conversationId,
+				parentConversationId: input.conversation.parentConversationId,
+				targetKind: input.targetKind,
+				targetSessionKey: input.targetSessionKey,
+				metadata: input.metadata
+			});
+			return bound ? toSessionBindingRecord(bound, {
+				idleTimeoutMs,
+				maxAgeMs
+			}) : null;
+		},
+		listBySession: (targetSessionKey) => manager.listBySessionKey(targetSessionKey).map((entry) => toSessionBindingRecord(entry, {
+			idleTimeoutMs,
+			maxAgeMs
+		})),
+		resolveByConversation: (ref) => {
+			if (ref.channel !== "feishu") return null;
+			const found = manager.getByConversationId(ref.conversationId);
+			return found ? toSessionBindingRecord(found, {
+				idleTimeoutMs,
+				maxAgeMs
+			}) : null;
+		},
+		touch: (bindingId, at) => {
+			const conversationId = resolveThreadBindingConversationIdFromBindingId({
+				accountId,
+				bindingId
+			});
+			if (conversationId) manager.touchConversation(conversationId, at);
+		},
+		unbind: async (input) => {
+			if (input.targetSessionKey?.trim()) return manager.unbindBySessionKey(input.targetSessionKey.trim()).map((entry) => toSessionBindingRecord(entry, {
+				idleTimeoutMs,
+				maxAgeMs
+			}));
+			const conversationId = resolveThreadBindingConversationIdFromBindingId({
+				accountId,
+				bindingId: input.bindingId
+			});
+			if (!conversationId) return [];
+			const removed = manager.unbindConversation(conversationId);
+			return removed ? [toSessionBindingRecord(removed, {
+				idleTimeoutMs,
+				maxAgeMs
+			})] : [];
+		}
+	};
+	registerSessionBindingAdapter(sessionBindingAdapter);
+	getState().managersByAccountId.set(accountId, manager);
+	return manager;
+}
+function getFeishuThreadBindingManager(accountId) {
+	return getState().managersByAccountId.get(normalizeAccountId(accountId)) ?? null;
+}
+const testing = { resetFeishuThreadBindingsForTests() {
+	for (const manager of getState().managersByAccountId.values()) manager.stop();
+	getState().managersByAccountId.clear();
+	getState().bindingsByAccountConversation.clear();
+} };
+//#endregion
+export { getFeishuThreadBindingManager as n, testing as r, createFeishuThreadBindingManager as t };

package/index.ts

@@ -0,0 +1,82 @@
+import {
+  defineBundledChannelEntry,
+  loadBundledEntryExportSync,
+} from "klaw/plugin-sdk/channel-entry-contract";
+import type { KlawPluginApi } from "klaw/plugin-sdk/channel-entry-contract";
+import { registerFeishuSubagentHooks } from "./subagent-hooks-api.js";
+
+function registerFeishuDocTools(api: KlawPluginApi) {
+  const register = loadBundledEntryExportSync<(api: KlawPluginApi) => void>(import.meta.url, {
+    specifier: "./api.js",
+    exportName: "registerFeishuDocTools",
+  });
+  register(api);
+}
+
+function registerFeishuChatTools(api: KlawPluginApi) {
+  const register = loadBundledEntryExportSync<(api: KlawPluginApi) => void>(import.meta.url, {
+    specifier: "./api.js",
+    exportName: "registerFeishuChatTools",
+  });
+  register(api);
+}
+
+function registerFeishuWikiTools(api: KlawPluginApi) {
+  const register = loadBundledEntryExportSync<(api: KlawPluginApi) => void>(import.meta.url, {
+    specifier: "./api.js",
+    exportName: "registerFeishuWikiTools",
+  });
+  register(api);
+}
+
+function registerFeishuDriveTools(api: KlawPluginApi) {
+  const register = loadBundledEntryExportSync<(api: KlawPluginApi) => void>(import.meta.url, {
+    specifier: "./api.js",
+    exportName: "registerFeishuDriveTools",
+  });
+  register(api);
+}
+
+function registerFeishuPermTools(api: KlawPluginApi) {
+  const register = loadBundledEntryExportSync<(api: KlawPluginApi) => void>(import.meta.url, {
+    specifier: "./api.js",
+    exportName: "registerFeishuPermTools",
+  });
+  register(api);
+}
+
+function registerFeishuBitableTools(api: KlawPluginApi) {
+  const register = loadBundledEntryExportSync<(api: KlawPluginApi) => void>(import.meta.url, {
+    specifier: "./api.js",
+    exportName: "registerFeishuBitableTools",
+  });
+  register(api);
+}
+
+export default defineBundledChannelEntry({
+  id: "feishu",
+  name: "Feishu",
+  description: "Feishu/Lark channel plugin",
+  importMetaUrl: import.meta.url,
+  plugin: {
+    specifier: "./channel-plugin-api.js",
+    exportName: "feishuPlugin",
+  },
+  secrets: {
+    specifier: "./secret-contract-api.js",
+    exportName: "channelSecrets",
+  },
+  runtime: {
+    specifier: "./runtime-api.js",
+    exportName: "setFeishuRuntime",
+  },
+  registerFull(api) {
+    registerFeishuSubagentHooks(api);
+    registerFeishuDocTools(api);
+    registerFeishuChatTools(api);
+    registerFeishuWikiTools(api);
+    registerFeishuDriveTools(api);
+    registerFeishuPermTools(api);
+    registerFeishuBitableTools(api);
+  },
+});