@gaodefa/daocore 2026.5.99 → 2026.5.100

package/dist/access-groups-ByRGVskC.d.ts

@@ -0,0 +1,58 @@
+import { jt as AccessGroupConfig, r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { t as ChannelId } from "./channel-id.types-ClK6B_QE.js";
+//#region src/plugin-sdk/access-groups.d.ts
+type AccessGroupMembershipResolver = (params: {
+  cfg: DaoCoreConfig;
+  name: string;
+  group: AccessGroupConfig;
+  channel: ChannelId;
+  accountId: string;
+  senderId: string;
+}) => boolean | Promise<boolean>;
+type AccessGroupMembershipLookup = (params: {
+  name: string;
+  group: AccessGroupConfig;
+  channel: ChannelId;
+  accountId: string;
+  senderId: string;
+}) => boolean | Promise<boolean>;
+type ResolvedAccessGroupAllowFromState = {
+  referenced: string[];
+  matched: string[];
+  missing: string[];
+  unsupported: string[];
+  failed: string[];
+  matchedAllowFromEntries: string[];
+  hasReferences: boolean;
+  hasMatch: boolean;
+};
+declare function resolveAccessGroupAllowFromState(params: {
+  accessGroups?: Record<string, AccessGroupConfig>;
+  allowFrom: Array<string | number> | null | undefined;
+  channel: ChannelId;
+  accountId: string;
+  senderId: string;
+  isSenderAllowed?: (senderId: string, allowFrom: string[]) => boolean;
+  resolveMembership?: AccessGroupMembershipLookup;
+}): Promise<ResolvedAccessGroupAllowFromState>;
+declare function resolveAccessGroupAllowFromMatches(params: {
+  cfg?: DaoCoreConfig;
+  allowFrom: Array<string | number> | null | undefined;
+  channel: ChannelId;
+  accountId: string;
+  senderId: string;
+  isSenderAllowed?: (senderId: string, allowFrom: string[]) => boolean;
+  resolveMembership?: AccessGroupMembershipResolver;
+}): Promise<string[]>;
+declare function expandAllowFromWithAccessGroups(params: {
+  cfg?: DaoCoreConfig;
+  allowFrom: Array<string | number> | null | undefined;
+  channel: ChannelId;
+  accountId: string;
+  senderId: string;
+  senderAllowEntry?: string;
+  isSenderAllowed?: (senderId: string, allowFrom: string[]) => boolean;
+  resolveMembership?: AccessGroupMembershipResolver;
+}): Promise<string[]>;
+//#endregion
+export { resolveAccessGroupAllowFromMatches as a, expandAllowFromWithAccessGroups as i, AccessGroupMembershipResolver as n, resolveAccessGroupAllowFromState as o, ResolvedAccessGroupAllowFromState as r, AccessGroupMembershipLookup as t };

package/dist/account-helpers-Q_AY6_at.d.ts

@@ -0,0 +1,63 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { r as ChannelAccountSnapshot } from "./types.core-tk4nkbSB.js";
+
+//#region src/channels/plugins/account-helpers.d.ts
+declare function createAccountListHelpers(channelKey: string, options?: {
+  normalizeAccountId?: (id: string) => string;
+  allowUnlistedDefaultAccount?: boolean;
+  implicitDefaultAccount?: {
+    channelKeys?: readonly string[];
+    envVars?: readonly string[];
+  };
+  hasImplicitDefaultAccount?: (cfg: DaoCoreConfig) => boolean;
+}): {
+  listConfiguredAccountIds: (cfg: DaoCoreConfig) => string[];
+  listAccountIds: (cfg: DaoCoreConfig) => string[];
+  resolveDefaultAccountId: (cfg: DaoCoreConfig) => string;
+};
+declare function hasConfiguredAccountValue(value: unknown): boolean;
+declare function listCombinedAccountIds(params: {
+  configuredAccountIds: Iterable<string>;
+  additionalAccountIds?: Iterable<string>;
+  implicitAccountId?: string | undefined;
+  fallbackAccountIdWhenEmpty?: string | undefined;
+}): string[];
+declare function resolveListedDefaultAccountId(params: {
+  accountIds: readonly string[];
+  configuredDefaultAccountId?: string | undefined;
+  allowUnlistedDefaultAccount?: boolean;
+  ambiguousFallbackAccountId?: string | undefined;
+  normalizeListedAccountId?: ((accountId: string) => string) | undefined;
+}): string;
+declare function mergeAccountConfig<TConfig extends Record<string, unknown>>(params: {
+  channelConfig: TConfig | undefined;
+  accountConfig: Partial<TConfig> | undefined;
+  omitKeys?: string[];
+  nestedObjectKeys?: string[];
+}): TConfig;
+declare function resolveMergedAccountConfig<TConfig extends Record<string, unknown>>(params: {
+  channelConfig: TConfig | undefined;
+  accounts: Record<string, Partial<TConfig>> | undefined;
+  accountId: string;
+  omitKeys?: string[];
+  normalizeAccountId?: (accountId: string) => string;
+  nestedObjectKeys?: string[];
+}): TConfig;
+type AccountSnapshotInput = {
+  accountId?: string | null;
+  enabled?: boolean | null;
+  name?: string | null | undefined;
+};
+declare function describeAccountSnapshot(params: {
+  account: AccountSnapshotInput;
+  configured?: boolean | undefined;
+  extra?: Record<string, unknown> | undefined;
+}): ChannelAccountSnapshot;
+declare function describeWebhookAccountSnapshot(params: {
+  account: AccountSnapshotInput;
+  configured?: boolean | undefined;
+  mode?: string | undefined;
+  extra?: Record<string, unknown> | undefined;
+}): ChannelAccountSnapshot;
+//#endregion
+export { listCombinedAccountIds as a, resolveMergedAccountConfig as c, hasConfiguredAccountValue as i, describeAccountSnapshot as n, mergeAccountConfig as o, describeWebhookAccountSnapshot as r, resolveListedDefaultAccountId as s, createAccountListHelpers as t };

package/dist/account-inspect-C_uZwE3i.d.ts

@@ -0,0 +1,22 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { _t as DiscordAccountConfig } from "./types.channels-CdBHVR2w.js";
+import { t as DiscordCredentialStatus } from "./token-kh7a8qI9.js";
+
+//#region extensions/discord/src/account-inspect.d.ts
+type InspectedDiscordAccount = {
+  accountId: string;
+  enabled: boolean;
+  name?: string;
+  token: string;
+  tokenSource: "env" | "config" | "none";
+  tokenStatus: DiscordCredentialStatus;
+  configured: boolean;
+  config: DiscordAccountConfig;
+};
+declare function inspectDiscordAccount(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+  envToken?: string | null;
+}): InspectedDiscordAccount;
+//#endregion
+export { inspectDiscordAccount as n, InspectedDiscordAccount as t };

package/dist/account-inspect-D92MBBHG.d.ts

@@ -0,0 +1,21 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { _ as TelegramAccountConfig } from "./types.channels-CdBHVR2w.js";
+//#region extensions/telegram/src/account-inspect.d.ts
+type TelegramCredentialStatus = "available" | "configured_unavailable" | "missing";
+type InspectedTelegramAccount = {
+  accountId: string;
+  enabled: boolean;
+  name?: string;
+  token: string;
+  tokenSource: "env" | "tokenFile" | "config" | "none";
+  tokenStatus: TelegramCredentialStatus;
+  configured: boolean;
+  config: TelegramAccountConfig;
+};
+declare function inspectTelegramAccount(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+  envToken?: string | null;
+}): InspectedTelegramAccount;
+//#endregion
+export { TelegramCredentialStatus as n, inspectTelegramAccount as r, InspectedTelegramAccount as t };

package/dist/accounts-21vIfbL5.d.ts

@@ -0,0 +1,51 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { _ as TelegramAccountConfig, v as TelegramActionConfig } from "./types.channels-CdBHVR2w.js";
+import { t as TelegramTransport } from "./fetch-CiBkMzGl.js";
+
+//#region extensions/telegram/src/account-config.d.ts
+declare function resolveTelegramAccountConfig(cfg: DaoCoreConfig, accountId: string): TelegramAccountConfig | undefined;
+declare function mergeTelegramAccountConfig(cfg: DaoCoreConfig, accountId: string): TelegramAccountConfig;
+//#endregion
+//#region extensions/telegram/src/accounts.d.ts
+type ResolvedTelegramAccount = {
+  accountId: string;
+  enabled: boolean;
+  name?: string;
+  token: string;
+  tokenSource: "env" | "tokenFile" | "config" | "none";
+  config: TelegramAccountConfig;
+};
+type TelegramMediaRuntimeOptions = {
+  token: string;
+  transport?: TelegramTransport;
+  apiRoot?: string;
+  trustedLocalFileRoots?: readonly string[];
+  dangerouslyAllowPrivateNetwork?: boolean;
+};
+declare function listTelegramAccountIds(cfg: DaoCoreConfig): string[];
+/** @internal Reset the once-per-process warning flag. Exported for tests only. */
+declare function resetMissingDefaultWarnFlag(): void;
+declare function resolveDefaultTelegramAccountId(cfg: DaoCoreConfig): string;
+declare function createTelegramActionGate(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}): (key: keyof TelegramActionConfig, defaultValue?: boolean) => boolean;
+declare function resolveTelegramMediaRuntimeOptions(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+  token: string;
+  transport?: TelegramTransport;
+}): TelegramMediaRuntimeOptions;
+type TelegramPollActionGateState = {
+  sendMessageEnabled: boolean;
+  pollEnabled: boolean;
+  enabled: boolean;
+};
+declare function resolveTelegramPollActionGateState(isActionEnabled: (key: keyof TelegramActionConfig, defaultValue?: boolean) => boolean): TelegramPollActionGateState;
+declare function resolveTelegramAccount(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}): ResolvedTelegramAccount;
+declare function listEnabledTelegramAccounts(cfg: DaoCoreConfig): ResolvedTelegramAccount[];
+//#endregion
+export { listEnabledTelegramAccounts as a, resolveDefaultTelegramAccountId as c, resolveTelegramPollActionGateState as d, mergeTelegramAccountConfig as f, createTelegramActionGate as i, resolveTelegramAccount as l, TelegramMediaRuntimeOptions as n, listTelegramAccountIds as o, resolveTelegramAccountConfig as p, TelegramPollActionGateState as r, resetMissingDefaultWarnFlag as s, ResolvedTelegramAccount as t, resolveTelegramMediaRuntimeOptions as u };

package/dist/accounts-C-2wkUEP.d.ts

@@ -0,0 +1,128 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { P as MessageReceipt } from "./types-CnYaPwf-.js";
+import { t as BaseProbeResult } from "./types.core-tk4nkbSB.js";
+//#region extensions/line/src/types.d.ts
+type LineTokenSource = "config" | "env" | "file" | "none";
+interface LineThreadBindingsConfig {
+  enabled?: boolean;
+  idleHours?: number;
+  maxAgeHours?: number;
+  spawnSessions?: boolean;
+  defaultSpawnContext?: "isolated" | "fork";
+  /** @deprecated Use spawnSessions instead. */
+  spawnSubagentSessions?: boolean;
+  /** @deprecated Use spawnSessions instead. */
+  spawnAcpSessions?: boolean;
+}
+interface LineAccountBaseConfig {
+  enabled?: boolean;
+  channelAccessToken?: string;
+  channelSecret?: string;
+  tokenFile?: string;
+  secretFile?: string;
+  name?: string;
+  allowFrom?: Array<string | number>;
+  groupAllowFrom?: Array<string | number>;
+  dmPolicy?: "open" | "allowlist" | "pairing" | "disabled";
+  groupPolicy?: "open" | "allowlist" | "disabled";
+  responsePrefix?: string;
+  mediaMaxMb?: number;
+  webhookPath?: string;
+  threadBindings?: LineThreadBindingsConfig;
+  groups?: Record<string, LineGroupConfig>;
+}
+interface LineConfig extends LineAccountBaseConfig {
+  accounts?: Record<string, LineAccountConfig>;
+  defaultAccount?: string;
+}
+interface LineAccountConfig extends LineAccountBaseConfig {}
+interface LineGroupConfig {
+  enabled?: boolean;
+  allowFrom?: Array<string | number>;
+  requireMention?: boolean;
+  systemPrompt?: string;
+  skills?: string[];
+}
+interface ResolvedLineAccount {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  channelAccessToken: string;
+  channelSecret: string;
+  tokenSource: LineTokenSource;
+  config: LineConfig & LineAccountConfig;
+}
+interface LineSendResult {
+  messageId: string;
+  chatId: string;
+  receipt: MessageReceipt;
+}
+type LineProbeResult = BaseProbeResult<string> & {
+  bot?: {
+    displayName?: string;
+    userId?: string;
+    basicId?: string;
+    pictureUrl?: string;
+  };
+};
+type LineFlexMessagePayload = {
+  altText: string;
+  contents: unknown;
+};
+type LineTemplateMessagePayload = {
+  type: "confirm";
+  text: string;
+  confirmLabel: string;
+  confirmData: string;
+  cancelLabel: string;
+  cancelData: string;
+  altText?: string;
+} | {
+  type: "buttons";
+  title: string;
+  text: string;
+  actions: Array<{
+    type: "message" | "uri" | "postback";
+    label: string;
+    data?: string;
+    uri?: string;
+  }>;
+  thumbnailImageUrl?: string;
+  altText?: string;
+} | {
+  type: "carousel";
+  columns: Array<{
+    title?: string;
+    text: string;
+    thumbnailImageUrl?: string;
+    actions: Array<{
+      type: "message" | "uri" | "postback";
+      label: string;
+      data?: string;
+      uri?: string;
+    }>;
+  }>;
+  altText?: string;
+};
+type LineChannelData = {
+  quickReplies?: string[];
+  location?: {
+    title: string;
+    address: string;
+    latitude: number;
+    longitude: number;
+  };
+  flexMessage?: LineFlexMessagePayload;
+  templateMessage?: LineTemplateMessagePayload;
+};
+//#endregion
+//#region extensions/line/src/accounts.d.ts
+declare function resolveLineAccount(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string;
+}): ResolvedLineAccount;
+declare function listLineAccountIds(cfg: DaoCoreConfig): string[];
+declare function resolveDefaultLineAccountId(cfg: DaoCoreConfig): string;
+declare function normalizeAccountId(accountId: string | undefined): string;
+//#endregion
+export { LineChannelData as a, LineProbeResult as c, ResolvedLineAccount as d, resolveLineAccount as i, LineSendResult as l, normalizeAccountId as n, LineConfig as o, resolveDefaultLineAccountId as r, LineGroupConfig as s, listLineAccountIds as t, LineTemplateMessagePayload as u };

package/dist/accounts-C_5S3uks.d.ts

@@ -0,0 +1,36 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { t as BaseProbeResult } from "./types.core-tk4nkbSB.js";
+//#region extensions/signal/src/client-adapter.d.ts
+type SignalApiMode = "native" | "container" | "auto";
+//#endregion
+//#region extensions/signal/src/probe.d.ts
+type SignalProbe = BaseProbeResult & {
+  status?: number | null;
+  elapsedMs: number;
+  version?: string | null;
+};
+declare function probeSignal(baseUrl: string, timeoutMs: number, options?: {
+  apiMode?: SignalApiMode;
+}): Promise<SignalProbe>;
+//#endregion
+//#region extensions/signal/src/account-types.d.ts
+type SignalAccountConfig = Omit<Exclude<NonNullable<DaoCoreConfig["channels"]>["signal"], undefined>, "accounts">;
+//#endregion
+//#region extensions/signal/src/accounts.d.ts
+type ResolvedSignalAccount = {
+  accountId: string;
+  enabled: boolean;
+  name?: string;
+  baseUrl: string;
+  configured: boolean;
+  config: SignalAccountConfig;
+};
+declare const listSignalAccountIds: (cfg: DaoCoreConfig) => string[];
+declare const resolveDefaultSignalAccountId: (cfg: DaoCoreConfig) => string;
+declare function resolveSignalAccount(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}): ResolvedSignalAccount;
+declare function listEnabledSignalAccounts(cfg: DaoCoreConfig): ResolvedSignalAccount[];
+//#endregion
+export { resolveSignalAccount as a, probeSignal as c, resolveDefaultSignalAccountId as i, listEnabledSignalAccounts as n, SignalAccountConfig as o, listSignalAccountIds as r, SignalProbe as s, ResolvedSignalAccount as t };

package/dist/accounts-UqEgY-46.d.ts

@@ -0,0 +1,119 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { P as MessageReceipt } from "./types-CnYaPwf-.js";
+//#region extensions/zalouser/src/zca-constants.d.ts
+declare const TextStyle: {
+  readonly Bold: "b";
+  readonly Italic: "i";
+  readonly Underline: "u";
+  readonly StrikeThrough: "s";
+  readonly Red: "c_db342e";
+  readonly Orange: "c_f27806";
+  readonly Yellow: "c_f7b503";
+  readonly Green: "c_15a85f";
+  readonly Small: "f_13";
+  readonly Big: "f_18";
+  readonly UnorderedList: "lst_1";
+  readonly OrderedList: "lst_2";
+  readonly Indent: "ind_$";
+};
+type TextStyleValue = (typeof TextStyle)[keyof typeof TextStyle];
+type Style = {
+  start: number;
+  len: number;
+  st: Exclude<TextStyleValue, typeof TextStyle.Indent>;
+} | {
+  start: number;
+  len: number;
+  st: typeof TextStyle.Indent;
+  indentSize?: number;
+};
+//#endregion
+//#region extensions/zalouser/src/types.d.ts
+type ZcaFriend = {
+  userId: string;
+  displayName: string;
+  avatar?: string;
+};
+type ZaloGroup = {
+  groupId: string;
+  name: string;
+  memberCount?: number;
+};
+type ZaloGroupMember = {
+  userId: string;
+  displayName: string;
+  avatar?: string;
+};
+type ZcaUserInfo = {
+  userId: string;
+  displayName: string;
+  avatar?: string;
+};
+type ZaloSendOptions = {
+  profile?: string;
+  mediaUrl?: string;
+  caption?: string;
+  isGroup?: boolean;
+  mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
+  textMode?: "markdown" | "plain";
+  textChunkMode?: "length" | "newline";
+  textChunkLimit?: number;
+  textStyles?: Style[];
+};
+type ZaloSendResult = {
+  ok: boolean;
+  messageId?: string;
+  receipt: MessageReceipt;
+  error?: string;
+};
+type ZaloAuthStatus = {
+  connected: boolean;
+  message: string;
+};
+type ZalouserToolConfig = {
+  allow?: string[];
+  deny?: string[];
+};
+type ZalouserGroupConfig = {
+  enabled?: boolean;
+  requireMention?: boolean;
+  tools?: ZalouserToolConfig;
+};
+type ZalouserSharedConfig = {
+  enabled?: boolean;
+  name?: string;
+  profile?: string;
+  dangerouslyAllowNameMatching?: boolean;
+  dmPolicy?: "pairing" | "allowlist" | "open" | "disabled";
+  allowFrom?: Array<string | number>;
+  historyLimit?: number;
+  groupAllowFrom?: Array<string | number>;
+  groupPolicy?: "open" | "allowlist" | "disabled";
+  groups?: Record<string, ZalouserGroupConfig>;
+  messagePrefix?: string;
+  responsePrefix?: string;
+};
+type ZalouserAccountConfig = ZalouserSharedConfig;
+type ResolvedZalouserAccount = {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  profile: string;
+  authenticated: boolean;
+  config: ZalouserAccountConfig;
+};
+//#endregion
+//#region extensions/zalouser/src/accounts.d.ts
+declare const listZalouserAccountIds: (cfg: DaoCoreConfig) => string[], resolveDefaultZalouserAccountId: (cfg: DaoCoreConfig) => string;
+declare function resolveZalouserAccountSync(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}): ResolvedZalouserAccount;
+declare function getZcaUserInfo(profile: string): Promise<{
+  userId?: string;
+  displayName?: string;
+} | null>;
+declare function checkZcaAuthenticated(profile: string): Promise<boolean>;
+//#endregion
+export { resolveZalouserAccountSync as a, ZaloGroup as c, ZaloSendResult as d, ZcaFriend as f, resolveDefaultZalouserAccountId as i, ZaloGroupMember as l, getZcaUserInfo as n, ResolvedZalouserAccount as o, ZcaUserInfo as p, listZalouserAccountIds as r, ZaloAuthStatus as s, checkZcaAuthenticated as t, ZaloSendOptions as u };

package/dist/accounts-qPfl2Ie9.d.ts

@@ -0,0 +1,34 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { _t as DiscordAccountConfig, vt as DiscordActionConfig } from "./types.channels-CdBHVR2w.js";
+import { t as DiscordCredentialStatus } from "./token-kh7a8qI9.js";
+
+//#region extensions/discord/src/accounts.d.ts
+type ResolvedDiscordAccount = {
+  accountId: string;
+  enabled: boolean;
+  name?: string;
+  token: string;
+  tokenSource: "env" | "config" | "none";
+  tokenStatus: DiscordCredentialStatus;
+  config: DiscordAccountConfig;
+};
+declare const listDiscordAccountIds: (cfg: DaoCoreConfig) => string[];
+declare const resolveDefaultDiscordAccountId: (cfg: DaoCoreConfig) => string;
+declare function resolveDiscordAccountConfig(cfg: DaoCoreConfig, accountId: string): DiscordAccountConfig | undefined;
+declare function mergeDiscordAccountConfig(cfg: DaoCoreConfig, accountId: string): DiscordAccountConfig;
+declare function createDiscordActionGate(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}): (key: keyof DiscordActionConfig, defaultValue?: boolean) => boolean;
+declare function resolveDiscordAccount(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}): ResolvedDiscordAccount;
+declare function resolveDiscordMaxLinesPerMessage(params: {
+  cfg: DaoCoreConfig;
+  discordConfig?: DiscordAccountConfig | null;
+  accountId?: string | null;
+}): number | undefined;
+declare function listEnabledDiscordAccounts(cfg: DaoCoreConfig): ResolvedDiscordAccount[];
+//#endregion
+export { mergeDiscordAccountConfig as a, resolveDiscordAccountConfig as c, listEnabledDiscordAccounts as i, resolveDiscordMaxLinesPerMessage as l, createDiscordActionGate as n, resolveDefaultDiscordAccountId as o, listDiscordAccountIds as r, resolveDiscordAccount as s, ResolvedDiscordAccount as t };

package/dist/acp/control-plane/manager.d.ts

@@ -1,4 +1,4 @@
 import { t as AcpSessionRuntimeOptions } from "../../types-DyE5xc5O.js";
-import { a as AcpManagerObservabilitySnapshot, c as AcpSessionStatus, i as AcpInitializeSessionInput, l as AcpStartupIdentityReconcileResult, n as AcpCloseSessionInput, o as AcpRunTurnInput, r as AcpCloseSessionResult, s as AcpSessionResolution, t as AcpSessionManager } from "../../manager.core-BRd2_lqA.js";
-import { n as testing, t as getAcpSessionManager } from "../../manager-DWN3qo90.js";
+import { a as AcpManagerObservabilitySnapshot, c as AcpSessionStatus, i as AcpInitializeSessionInput, l as AcpStartupIdentityReconcileResult, n as AcpCloseSessionInput, o as AcpRunTurnInput, r as AcpCloseSessionResult, s as AcpSessionResolution, t as AcpSessionManager } from "../../manager.core--0SPEwrE.js";
+import { n as testing, t as getAcpSessionManager } from "../../manager-CS6y47Sy.js";
 export { type AcpCloseSessionInput, type AcpCloseSessionResult, type AcpInitializeSessionInput, type AcpManagerObservabilitySnapshot, type AcpRunTurnInput, AcpSessionManager, type AcpSessionResolution, type AcpSessionRuntimeOptions, type AcpSessionStatus, type AcpStartupIdentityReconcileResult, testing as __testing, testing, getAcpSessionManager };

package/dist/acp-binding-runtime-DbE9ykFy.d.ts

@@ -0,0 +1,15 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { n as ResolvedConfiguredAcpBinding } from "./persistent-bindings.resolve-ECRj0z9K.js";
+
+//#region src/acp/persistent-bindings.lifecycle.d.ts
+declare function ensureConfiguredAcpBindingReady(params: {
+  cfg: DaoCoreConfig;
+  configuredBinding: ResolvedConfiguredAcpBinding | null;
+}): Promise<{
+  ok: true;
+} | {
+  ok: false;
+  error: string;
+}>;
+//#endregion
+export { ensureConfiguredAcpBindingReady as t };

package/dist/acp-runtime-BDPnjYqv.d.ts

@@ -0,0 +1,13 @@
+import { t as AcpRuntimeBackend } from "./registry-DHWC2Nhf.js";
+//#region src/plugin-sdk/acp-runtime.d.ts
+declare const testing: {
+  resetAcpSessionManagerForTests(): void;
+  setAcpSessionManagerForTests(manager: unknown): void;
+} & {
+  resetAcpRuntimeBackendsForTests(): void;
+  getAcpRuntimeRegistryGlobalStateForTests(): {
+    backendsById: Map<string, AcpRuntimeBackend>;
+  };
+};
+//#endregion
+export { testing as t };

package/dist/acp-runtime-backend-DYMIULX7.d.ts

@@ -0,0 +1,6 @@
+import { it as PluginHookReplyDispatchResult, nt as PluginHookReplyDispatchContext, rt as PluginHookReplyDispatchEvent } from "./hook-types-D_9P6xki.js";
+
+//#region src/plugin-sdk/acp-runtime-backend.d.ts
+declare function tryDispatchAcpReplyHook(event: PluginHookReplyDispatchEvent, ctx: PluginHookReplyDispatchContext): Promise<PluginHookReplyDispatchResult | void>;
+//#endregion
+export { tryDispatchAcpReplyHook as t };