fengming 0.3.8 → 0.3.10

package/dist/core-Bpk-qSJH.js

@@ -0,0 +1,284 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DKw2K5wM.js";
+import "./parse-finite-number-CpgOyjPq.js";
+import "./paths-9MqJt9oL.js";
+import "./types.secrets-Z7uJY7vF.js";
+import "./subsystem-B7U-DPv3.js";
+import { n as resolveBundledPluginsDir } from "./bundled-dir-BVueUQUl.js";
+import { o as normalizeSessionKeyPreservingOpaquePeerIds, u as parseThreadSessionSuffix } from "./session-key-utils-CdfsDYvz.js";
+import { p as resolveThreadSessionKeys } from "./session-key-CJf5_zWs.js";
+import "./net-DAt4-3lj.js";
+import { r as buildChatChannelMetaById } from "./chat-meta-DoN8fbIb.js";
+import { o as emptyChannelConfigSchema } from "./config-schema-CDjjqZEJ.js";
+import "./dedupe-sIA8DWuv.js";
+import "./common-DSTX6z7j.js";
+import "./resolve-route-BiiTEeds.js";
+import "./typebox-Cc8OViuf.js";
+import { t as buildAccountScopedDmSecurityPolicy } from "./helpers-BtTYLgl0.js";
+import { t as buildOutboundBaseSessionKey } from "./base-session-key-8IMNOwZA.js";
+import "./delegate-CwhxUdeb.js";
+import "./config-schema-0wxEVz6p.js";
+import { r as createTopLevelChannelReplyToModeResolver, t as createScopedAccountReplyToModeResolver } from "./threading-helpers-JSVFlQzA.js";
+import { t as normalizeOutboundThreadId } from "./thread-id-U42I4aRK.js";
+import "./plugin-entry-DzJsOsJI.js";
+import "./setup-helpers-Cf0GFnoG.js";
+import "./secret-file-vzaJekKb.js";
+import "./tailscale-status-DTsM5DKY.js";
+import "./persistent-bindings.resolve-BLl3dIT5.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-BNar5iAh.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 (normalizeSessionKeyPreservingOpaquePeerIds(current.baseSessionKey) !== normalizeSessionKeyPreservingOpaquePeerIds(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;
+			}
+			if (api.registrationMode === "tool-discovery") {
+				registerFull?.(api);
+				return;
+			}
+			api.registerChannel({ plugin });
+			setRuntime?.(api.runtime);
+			if (api.registrationMode === "discovery") {
+				registerCliMetadata?.(api);
+				return;
+			}
+			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.gatewayMethodDescriptors ? { gatewayMethodDescriptors: params.gatewayMethodDescriptors } : {},
+		...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 };

package/dist/core-Chrz4oRB.d.ts

@@ -0,0 +1,223 @@
+import { r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
+import { T as ReplyToMode } from "./types.base-BqSq2llv.js";
+import { n as ChannelConfigSchema } from "./types.config-CKJTcS4X.js";
+import { Qn as PluginRuntime, l as FengMingPluginApi } from "./types-BQw1qXGl.js";
+import { n as ChatChannelId } from "./channel-id.types-ClK6B_QE.js";
+import { b as OutboundDeliveryResult, n as ChannelOutboundAdapter } from "./outbound.types-DVkbsxo8.js";
+import { A as ChannelPollResult, D as ChannelOutboundSessionRoute, E as ChannelMeta, R as ChannelThreadingAdapter, T as ChannelMessagingAdapter } from "./types.core-BIOUPd66.js";
+import { V as ChannelSecurityAdapter } from "./types.adapters-DSaA0bHm.js";
+import { t as ChannelPairingAdapter } from "./pairing.types-B0SQgllo.js";
+import { n as ChannelPlugin } from "./types.public-C_bVIMBl.js";
+import { n as ResolvedConfiguredAcpBinding } from "./persistent-bindings.resolve-CxCR6sBh.js";
+//#region src/shared/gateway-bind-url.d.ts
+type GatewayBindUrlResult = {
+  url: string;
+  source: "gateway.bind=custom" | "gateway.bind=tailnet" | "gateway.bind=lan";
+} | {
+  error: string;
+} | null;
+declare function resolveGatewayBindUrl(params: {
+  bind?: string;
+  customBindHost?: string;
+  scheme: "ws" | "wss";
+  port: number;
+  pickTailnetHost: () => string | null;
+  pickLanHost: () => string | null;
+}): GatewayBindUrlResult;
+//#endregion
+//#region src/shared/tailscale-status.d.ts
+type TailscaleStatusCommandResult = {
+  code: number | null;
+  stdout: string;
+};
+type TailscaleStatusCommandRunner = (argv: string[], opts: {
+  timeoutMs: number;
+}) => Promise<TailscaleStatusCommandResult>;
+declare function resolveTailnetHostWithRunner(runCommandWithTimeout?: TailscaleStatusCommandRunner): Promise<string | null>;
+//#endregion
+//#region src/plugin-sdk/core.d.ts
+declare function ensureConfiguredAcpBindingReady(params: {
+  cfg: FengMingConfig;
+  configuredBinding: ResolvedConfiguredAcpBinding | null;
+}): Promise<{
+  ok: true;
+} | {
+  ok: false;
+  error: string;
+}>;
+type ChannelOutboundSessionRouteParams = Parameters<NonNullable<ChannelMessagingAdapter["resolveOutboundSessionRoute"]>>[0];
+declare function getChatChannelMeta(id: ChatChannelId): ChannelMeta;
+/** Remove one of the known provider prefixes from a free-form target string. */
+declare function stripChannelTargetPrefix(raw: string, ...providers: string[]): string;
+/** Remove generic target-kind prefixes such as `user:` or `group:`. */
+declare function stripTargetKindPrefix(raw: string): string;
+/**
+ * Build the canonical outbound session route payload returned by channel
+ * message adapters.
+ */
+declare function buildChannelOutboundSessionRoute(params: {
+  cfg: FengMingConfig;
+  agentId: string;
+  channel: string;
+  accountId?: string | null;
+  peer: {
+    kind: "direct" | "group" | "channel";
+    id: string;
+  };
+  chatType: "direct" | "group" | "channel";
+  from: string;
+  to: string;
+  threadId?: string | number;
+}): ChannelOutboundSessionRoute;
+type ThreadAwareOutboundSessionRouteThreadSource = "replyToId" | "threadId" | "currentSession";
+type ThreadAwareOutboundSessionRouteRecoveryContext = {
+  route: ChannelOutboundSessionRoute;
+  currentBaseSessionKey: string;
+  currentThreadId: string;
+};
+declare function recoverCurrentThreadSessionId(params: {
+  route: ChannelOutboundSessionRoute;
+  currentSessionKey?: string | null;
+  canRecover?: (context: ThreadAwareOutboundSessionRouteRecoveryContext) => boolean;
+}): string | undefined;
+declare function buildThreadAwareOutboundSessionRoute(params: {
+  route: ChannelOutboundSessionRoute;
+  replyToId?: string | number | null;
+  threadId?: string | number | null;
+  currentSessionKey?: string | null;
+  precedence?: readonly ThreadAwareOutboundSessionRouteThreadSource[];
+  useSuffix?: boolean;
+  parentSessionKey?: string;
+  normalizeThreadId?: (threadId: string) => string;
+  canRecoverCurrentThread?: (context: ThreadAwareOutboundSessionRouteRecoveryContext) => boolean;
+}): ChannelOutboundSessionRoute;
+/** Options for a channel plugin entry that should register a channel capability. */
+type ChannelEntryConfigSchema<TPlugin> = TPlugin extends ChannelPlugin<unknown> ? NonNullable<TPlugin["configSchema"]> : ChannelConfigSchema;
+type DefineChannelPluginEntryOptions<TPlugin = ChannelPlugin> = {
+  id: string;
+  name: string;
+  description: string;
+  plugin: TPlugin;
+  configSchema?: ChannelEntryConfigSchema<TPlugin> | (() => ChannelEntryConfigSchema<TPlugin>);
+  setRuntime?: (runtime: PluginRuntime) => void;
+  registerCliMetadata?: (api: FengMingPluginApi) => void;
+  registerFull?: (api: FengMingPluginApi) => void;
+};
+type DefinedChannelPluginEntry<TPlugin> = {
+  id: string;
+  name: string;
+  description: string;
+  configSchema: ChannelEntryConfigSchema<TPlugin>;
+  register: (api: FengMingPluginApi) => void;
+  channelPlugin: TPlugin;
+  setChannelRuntime?: (runtime: PluginRuntime) => void;
+};
+type CreateChannelPluginBaseOptions<TResolvedAccount> = {
+  id: ChannelPlugin<TResolvedAccount>["id"];
+  meta?: Partial<NonNullable<ChannelPlugin<TResolvedAccount>["meta"]>>;
+  setupWizard?: NonNullable<ChannelPlugin<TResolvedAccount>["setupWizard"]>;
+  capabilities?: ChannelPlugin<TResolvedAccount>["capabilities"];
+  commands?: ChannelPlugin<TResolvedAccount>["commands"];
+  doctor?: ChannelPlugin<TResolvedAccount>["doctor"];
+  agentPrompt?: ChannelPlugin<TResolvedAccount>["agentPrompt"];
+  streaming?: ChannelPlugin<TResolvedAccount>["streaming"];
+  reload?: ChannelPlugin<TResolvedAccount>["reload"];
+  gatewayMethods?: ChannelPlugin<TResolvedAccount>["gatewayMethods"];
+  gatewayMethodDescriptors?: ChannelPlugin<TResolvedAccount>["gatewayMethodDescriptors"];
+  configSchema?: ChannelPlugin<TResolvedAccount>["configSchema"];
+  config?: ChannelPlugin<TResolvedAccount>["config"];
+  security?: ChannelPlugin<TResolvedAccount>["security"];
+  setup: NonNullable<ChannelPlugin<TResolvedAccount>["setup"]>;
+  groups?: ChannelPlugin<TResolvedAccount>["groups"];
+};
+type CreatedChannelPluginBase<TResolvedAccount> = Pick<ChannelPlugin<TResolvedAccount>, "id" | "meta" | "setup"> & Partial<Pick<ChannelPlugin<TResolvedAccount>, "setupWizard" | "capabilities" | "commands" | "doctor" | "agentPrompt" | "streaming" | "reload" | "gatewayMethods" | "gatewayMethodDescriptors" | "configSchema" | "config" | "security" | "groups">>;
+/**
+ * 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.
+ */
+declare function defineChannelPluginEntry<TPlugin>({
+  id,
+  name,
+  description,
+  plugin,
+  configSchema,
+  setRuntime,
+  registerCliMetadata,
+  registerFull
+}: DefineChannelPluginEntryOptions<TPlugin>): DefinedChannelPluginEntry<TPlugin>;
+/**
+ * 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.
+ */
+declare function defineSetupPluginEntry<TPlugin>(plugin: TPlugin): {
+  plugin: TPlugin;
+};
+type ChatChannelPluginBase<TResolvedAccount, Probe, Audit> = Omit<ChannelPlugin<TResolvedAccount, Probe, Audit>, "security" | "pairing" | "threading" | "outbound"> & Partial<Pick<ChannelPlugin<TResolvedAccount, Probe, Audit>, "security" | "pairing" | "threading" | "outbound">>;
+type ChatChannelSecurityOptions<TResolvedAccount extends {
+  accountId?: string | null;
+}> = {
+  dm: {
+    channelKey: string;
+    resolvePolicy: (account: TResolvedAccount) => string | null | undefined;
+    resolveAllowFrom: (account: TResolvedAccount) => Array<string | number> | null | undefined;
+    resolveFallbackAccountId?: (account: TResolvedAccount) => string | null | undefined;
+    defaultPolicy?: string;
+    allowFromPathSuffix?: string;
+    policyPathSuffix?: string;
+    approveChannelId?: string;
+    approveHint?: string;
+    normalizeEntry?: (raw: string) => string;
+    inheritSharedDefaultsFromDefaultAccount?: boolean;
+  };
+  collectWarnings?: ChannelSecurityAdapter<TResolvedAccount>["collectWarnings"];
+  collectAuditFindings?: ChannelSecurityAdapter<TResolvedAccount>["collectAuditFindings"];
+};
+type ChatChannelPairingOptions = {
+  text: {
+    idLabel: string;
+    message: string;
+    normalizeAllowEntry?: ChannelPairingAdapter["normalizeAllowEntry"];
+    notify: (params: Parameters<NonNullable<ChannelPairingAdapter["notifyApproval"]>>[0] & {
+      message: string;
+    }) => Promise<void> | void;
+  };
+};
+type ChatChannelThreadingReplyModeOptions<TResolvedAccount> = {
+  topLevelReplyToMode: string;
+} | {
+  scopedAccountReplyToMode: {
+    resolveAccount: (cfg: FengMingConfig, accountId?: string | null) => TResolvedAccount;
+    resolveReplyToMode: (account: TResolvedAccount, chatType?: string | null) => ReplyToMode | null | undefined;
+    fallback?: ReplyToMode;
+  };
+} | {
+  resolveReplyToMode: NonNullable<ChannelThreadingAdapter["resolveReplyToMode"]>;
+};
+type ChatChannelThreadingOptions<TResolvedAccount> = ChatChannelThreadingReplyModeOptions<TResolvedAccount> & Omit<ChannelThreadingAdapter, "resolveReplyToMode">;
+type ChatChannelAttachedOutboundOptions = {
+  base: Omit<ChannelOutboundAdapter, "sendText" | "sendMedia" | "sendPoll">;
+  attachedResults: {
+    channel: string;
+    sendText?: (ctx: Parameters<NonNullable<ChannelOutboundAdapter["sendText"]>>[0]) => MaybePromise<Omit<OutboundDeliveryResult, "channel">>;
+    sendMedia?: (ctx: Parameters<NonNullable<ChannelOutboundAdapter["sendMedia"]>>[0]) => MaybePromise<Omit<OutboundDeliveryResult, "channel">>;
+    sendPoll?: (ctx: Parameters<NonNullable<ChannelOutboundAdapter["sendPoll"]>>[0]) => MaybePromise<Omit<ChannelPollResult, "channel">>;
+  };
+};
+type MaybePromise<T> = T | Promise<T>;
+declare function createChatChannelPlugin<TResolvedAccount extends {
+  accountId?: string | null;
+}, Probe = unknown, Audit = unknown>(params: {
+  base: ChatChannelPluginBase<TResolvedAccount, Probe, Audit>;
+  security?: ChannelSecurityAdapter<TResolvedAccount> | ChatChannelSecurityOptions<TResolvedAccount>;
+  pairing?: ChannelPairingAdapter | ChatChannelPairingOptions;
+  threading?: ChannelThreadingAdapter | ChatChannelThreadingOptions<TResolvedAccount>;
+  outbound?: ChannelOutboundAdapter | ChatChannelAttachedOutboundOptions;
+}): ChannelPlugin<TResolvedAccount, Probe, Audit>;
+declare function createChannelPluginBase<TResolvedAccount>(params: CreateChannelPluginBaseOptions<TResolvedAccount>): CreatedChannelPluginBase<TResolvedAccount>;
+//#endregion
+export { resolveTailnetHostWithRunner as _, buildThreadAwareOutboundSessionRoute as a, defineChannelPluginEntry as c, getChatChannelMeta as d, recoverCurrentThreadSessionId as f, TailscaleStatusCommandRunner as g, TailscaleStatusCommandResult as h, buildChannelOutboundSessionRoute as i, defineSetupPluginEntry as l, stripTargetKindPrefix as m, ThreadAwareOutboundSessionRouteRecoveryContext as n, createChannelPluginBase as o, stripChannelTargetPrefix as p, ThreadAwareOutboundSessionRouteThreadSource as r, createChatChannelPlugin as s, ChannelOutboundSessionRouteParams as t, ensureConfiguredAcpBindingReady as u, GatewayBindUrlResult as v, resolveGatewayBindUrl as y };

package/dist/core-api-DSpUKNVW.js

@@ -0,0 +1,2 @@
+import "./core-api-hLsW03Wo.js";
+export {};

package/dist/core-api-hLsW03Wo.js

@@ -0,0 +1,5 @@
+import "./sdk-security-runtime-CM9KnGnN.js";
+import "./config-BJJhHN9E.js";
+import "./sdk-setup-tools-B-X04pa6.js";
+import "./browser-runtime-Bbzumoha.js";
+export {};

package/dist/crestodian/crestodian.js

@@ -1,2 +1,2 @@
-import { t as runCrestodian } from "../crestodian-FeGTBqO1.js";
+import { t as runCrestodian } from "../crestodian-C0x7JjF-.js";
 export { runCrestodian };

package/dist/crestodian/rescue-message.d.ts

@@ -1,5 +1,5 @@
 import { r as FengMingConfig } from "../types.fengming-NdBrgqd4.js";
-import { t as CommandContext } from "../commands-types-B67CsqXf.js";
+import { t as CommandContext } from "../commands-types-MXHhrssO.js";
 import { t as CrestodianCommandDeps } from "../operations-D5BiOBGd.js";
 
 //#region src/crestodian/rescue-message.d.ts

package/dist/crestodian/rescue-message.js

@@ -1,7 +1,7 @@
 import { y as resolveStateDir } from "../paths-9MqJt9oL.js";
 import { m as writeJson, o as tryReadJson } from "../json-files-9tRkYc-3.js";
 import { l as normalizeAgentId } from "../session-key-CJf5_zWs.js";
-import { a as parseCrestodianOperation, i as isPersistentCrestodianOperation, n as executeCrestodianOperation, r as formatCrestodianPersistentPlan } from "../operations-H2Oq0KYz.js";
+import { a as parseCrestodianOperation, i as isPersistentCrestodianOperation, n as executeCrestodianOperation, r as formatCrestodianPersistentPlan } from "../operations-Z85LFqsT.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";

package/dist/crestodian-C0x7JjF-.js

@@ -0,0 +1,55 @@
+import { n as defaultRuntime, r as writeRuntimeJson } from "./runtime-BkTkFkXs.js";
+import { r as withProgress } from "./progress-G9DILAx2.js";
+import { i as isPersistentCrestodianOperation, n as executeCrestodianOperation } from "./operations-Z85LFqsT.js";
+import { r as loadCrestodianOverview, t as formatCrestodianOverview } from "./overview-6BeqbKXR.js";
+import { r as resolveCrestodianOperation } from "./dialogue-No0NvYX7.js";
+import { stdin, stdout } from "node:process";
+//#region src/crestodian/crestodian.ts
+function crestodianCommandDepsFromOptions(opts) {
+	if (!opts.deps && !opts.formatOverview && !opts.loadOverview) return;
+	return {
+		...opts.deps,
+		...opts.formatOverview ? { formatOverview: opts.formatOverview } : {},
+		...opts.loadOverview ? { loadOverview: opts.loadOverview } : {}
+	};
+}
+async function runOneShot(input, runtime, opts) {
+	const operation = await resolveCrestodianOperation(input, runtime, opts);
+	await executeCrestodianOperation(operation, runtime, {
+		approved: opts.yes === true || !isPersistentCrestodianOperation(operation),
+		deps: crestodianCommandDepsFromOptions(opts)
+	});
+}
+async function runCrestodian(opts = {}, runtime = defaultRuntime) {
+	if (opts.json) {
+		writeRuntimeJson(runtime, await (opts.loadOverview ?? loadCrestodianOverview)());
+		return;
+	}
+	if (opts.message?.trim()) {
+		const overview = await withProgress({
+			label: "Loading Crestodian overview…",
+			indeterminate: true,
+			delayMs: 0,
+			fallback: "none"
+		}, async () => await (opts.loadOverview ?? loadCrestodianOverview)());
+		runtime.log((opts.formatOverview ?? formatCrestodianOverview)(overview));
+		runtime.log("");
+		await runOneShot(opts.message, runtime, opts);
+		return;
+	}
+	const interactive = opts.interactive ?? true;
+	const input = opts.input ?? stdin;
+	const output = opts.output ?? stdout;
+	const inputIsTty = input.isTTY === true;
+	const outputIsTty = output.isTTY === true;
+	if (!interactive || !inputIsTty || !outputIsTty) {
+		runtime.error("Crestodian needs an interactive TTY. Use --message for one command.");
+		runtime.exit(1);
+		return;
+	}
+	const runInteractiveTui = opts.runInteractiveTui ?? (await import("./tui-backend-_Pn3Byj-.js")).runCrestodianTui;
+	opts.onReady?.();
+	await runInteractiveTui(opts, runtime);
+}
+//#endregion
+export { runCrestodian as t };

package/dist/delegate-BArFIZ4B.d.ts

@@ -0,0 +1,30 @@
+import { M as MemoryCitationsMode } from "./types.tools-CNVUa3Mn.js";
+import { Sa as ContextEngine, xa as CompactResult } from "./types-BQw1qXGl.js";
+
+//#region src/context-engine/delegate.d.ts
+/**
+ * Delegate a context-engine compaction request to FengMing's built-in runtime compaction path.
+ *
+ * This is the same bridge used by the legacy context engine. Third-party
+ * engines can call it from their own `compact()` implementations when they do
+ * not own the compaction algorithm but still need `/compact` and overflow
+ * recovery to use the stock runtime behavior.
+ *
+ * Note: `compactionTarget` is part of the public `compact()` contract, but the
+ * built-in runtime compaction path does not expose that knob. This helper
+ * ignores it to preserve legacy behavior; engines that need target-specific
+ * compaction should implement their own `compact()` algorithm.
+ */
+declare function delegateCompactionToRuntime(params: Parameters<ContextEngine["compact"]>[0]): Promise<CompactResult>;
+/**
+ * Build a context-engine-ready systemPromptAddition from the active memory
+ * plugin prompt path. This lets non-legacy engines explicitly opt into the
+ * same memory/wiki guidance that the legacy engine gets via system prompt
+ * assembly, without reimplementing memory prompt formatting.
+ */
+declare function buildMemorySystemPromptAddition(params: {
+  availableTools: Set<string>;
+  citationsMode?: MemoryCitationsMode;
+}): string | undefined;
+//#endregion
+export { delegateCompactionToRuntime as n, buildMemorySystemPromptAddition as t };