@gaodefa/daocore 2026.5.69 → 2026.5.70

package/dist/channel-DcoW80yh.d.ts

@@ -0,0 +1,114 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { n as ChannelPlugin } from "./types.public-DuFOa-9T.js";
+//#region extensions/clickclack/src/types.d.ts
+type ClickClackAccountConfig = {
+  name?: string;
+  enabled?: boolean;
+  baseUrl?: string;
+  token?: unknown;
+  workspace?: string;
+  botUserId?: string;
+  agentId?: string;
+  replyMode?: "agent" | "model";
+  model?: string;
+  systemPrompt?: string;
+  timeoutSeconds?: number;
+  toolsAllow?: string[];
+  defaultTo?: string;
+  allowFrom?: string[];
+  reconnectMs?: number;
+};
+type ClickClackConfig = ClickClackAccountConfig & {
+  accounts?: Record<string, Partial<ClickClackAccountConfig>>;
+  defaultAccount?: string;
+};
+type CoreConfig = DaoCoreConfig & {
+  channels?: DaoCoreConfig["channels"] & {
+    clickclack?: ClickClackConfig;
+  };
+};
+type ResolvedClickClackAccount = {
+  accountId: string;
+  enabled: boolean;
+  configured: boolean;
+  name?: string;
+  baseUrl: string;
+  token: string;
+  workspace: string;
+  botUserId?: string;
+  agentId?: string;
+  replyMode: "agent" | "model";
+  model?: string;
+  systemPrompt?: string;
+  timeoutSeconds?: number;
+  toolsAllow?: string[];
+  defaultTo: string;
+  allowFrom: string[];
+  reconnectMs: number;
+  config: ClickClackAccountConfig;
+};
+type ClickClackUser = {
+  id: string;
+  kind?: "human" | "bot";
+  owner_user_id?: string;
+  display_name: string;
+  handle: string;
+  avatar_url: string;
+  created_at: string;
+};
+type ClickClackWorkspace = {
+  id: string;
+  name: string;
+  slug: string;
+  created_at: string;
+};
+type ClickClackChannel = {
+  id: string;
+  workspace_id: string;
+  name: string;
+  kind: string;
+  created_at: string;
+};
+type ClickClackMessage = {
+  id: string;
+  workspace_id: string;
+  channel_id?: string;
+  direct_conversation_id?: string;
+  author_id: string;
+  parent_message_id?: string;
+  thread_root_id: string;
+  channel_seq?: number;
+  thread_seq?: number;
+  body: string;
+  body_format: "markdown";
+  created_at: string;
+  author?: ClickClackUser;
+};
+type ClickClackEvent = {
+  id: string;
+  cursor: string;
+  type: string;
+  workspace_id: string;
+  channel_id?: string;
+  seq?: number;
+  created_at: string;
+  payload: Record<string, unknown>;
+};
+type ClickClackTarget = {
+  chatType: "group";
+  kind: "channel";
+  id: string;
+} | {
+  chatType: "group";
+  kind: "thread";
+  id: string;
+} | {
+  chatType: "direct";
+  kind: "dm";
+  id: string;
+};
+//#endregion
+//#region extensions/clickclack/src/channel.d.ts
+declare const clickClackPlugin: ChannelPlugin<ResolvedClickClackAccount>;
+//#endregion
+export { ClickClackMessage as a, ClickClackWorkspace as c, ClickClackEvent as i, CoreConfig as l, ClickClackAccountConfig as n, ClickClackTarget as o, ClickClackChannel as r, ClickClackUser as s, clickClackPlugin as t, ResolvedClickClackAccount as u };

package/dist/channel-DpzbGwHc.d.ts

@@ -0,0 +1,12 @@
+import { t as BaseProbeResult } from "./types.core-DpVp9PoP.js";
+import { n as ChannelPlugin } from "./types.public-DuFOa-9T.js";
+import { o as ResolvedZalouserAccount, p as ZcaUserInfo } from "./accounts-D9GVD8d8.js";
+//#region extensions/zalouser/src/probe.d.ts
+type ZalouserProbeResult = BaseProbeResult<string> & {
+  user?: ZcaUserInfo;
+};
+//#endregion
+//#region extensions/zalouser/src/channel.d.ts
+declare const zalouserPlugin: ChannelPlugin<ResolvedZalouserAccount, ZalouserProbeResult>;
+//#endregion
+export { zalouserPlugin as t };

package/dist/channel-GdRd01F0.d.ts

@@ -0,0 +1,64 @@
+import { l as SecretInput } from "./types.secrets-tbFW-hY6.js";
+import { _ as GroupPolicy, h as DmPolicy, r as BlockStreamingCoalesceConfig } from "./types.base-tQh4FMBR.js";
+import { an as DmConfig } from "./types.channels-DYoH0RJo.js";
+import { n as ChannelPlugin } from "./types.public-DuFOa-9T.js";
+//#region extensions/nextcloud-talk/src/types.d.ts
+type NextcloudTalkRoomConfig = {
+  requireMention?: boolean; /** Optional tool policy overrides for this room. */
+  tools?: {
+    allow?: string[];
+    deny?: string[];
+  }; /** If specified, only load these skills for this room. Omit = all skills; empty = no skills. */
+  skills?: string[]; /** If false, disable the bot for this room. */
+  enabled?: boolean; /** Optional allowlist for room senders (user ids). */
+  allowFrom?: string[]; /** Optional system prompt snippet for this room. */
+  systemPrompt?: string;
+};
+type NextcloudTalkNetworkConfig = {
+  /** Dangerous opt-in for self-hosted Nextcloud Talk on trusted private/internal hosts. */dangerouslyAllowPrivateNetwork?: boolean;
+};
+type NextcloudTalkAccountConfig = {
+  /** Optional display name for this account (used in CLI/UI lists). */name?: string; /** If false, do not start this Nextcloud Talk account. Default: true. */
+  enabled?: boolean; /** Base URL of the Nextcloud instance (e.g., "https://cloud.example.com"). */
+  baseUrl?: string; /** Bot shared secret from occ talk:bot:install output. */
+  botSecret?: SecretInput; /** Path to file containing bot secret (for secret managers). */
+  botSecretFile?: string; /** Optional API user for room lookups (DM detection). */
+  apiUser?: string; /** Optional API password/app password for room lookups. */
+  apiPassword?: SecretInput; /** Path to file containing API password/app password. */
+  apiPasswordFile?: string; /** Direct message policy (default: pairing). */
+  dmPolicy?: DmPolicy; /** Webhook server port. Default: 8788. */
+  webhookPort?: number; /** Webhook server host. Default: "0.0.0.0". */
+  webhookHost?: string; /** Webhook endpoint path. Default: "/nextcloud-talk-webhook". */
+  webhookPath?: string; /** Public URL for the webhook (used if behind reverse proxy). */
+  webhookPublicUrl?: string; /** Optional allowlist of user IDs allowed to DM the bot. */
+  allowFrom?: string[]; /** Optional allowlist for Nextcloud Talk room senders (user ids). */
+  groupAllowFrom?: string[]; /** Group message policy (default: allowlist). */
+  groupPolicy?: GroupPolicy; /** Per-room configuration (key is room token). */
+  rooms?: Record<string, NextcloudTalkRoomConfig>; /** Max group messages to keep as history context (0 disables). */
+  historyLimit?: number; /** Max DM turns to keep as history context. */
+  dmHistoryLimit?: number; /** Per-DM config overrides keyed by user ID. */
+  dms?: Record<string, DmConfig>; /** Outbound text chunk size (chars). Default: 4000. */
+  textChunkLimit?: number; /** Chunking mode: "length" (default) splits by size; "newline" splits on every newline. */
+  chunkMode?: "length" | "newline"; /** Disable block streaming for this account. */
+  blockStreaming?: boolean; /** Merge streamed block replies before sending. */
+  blockStreamingCoalesce?: BlockStreamingCoalesceConfig; /** Outbound response prefix override for this channel/account. */
+  responsePrefix?: string; /** Media upload max size in MB. */
+  mediaMaxMb?: number; /** Network policy overrides for self-hosted Nextcloud Talk on trusted private/internal hosts. */
+  network?: NextcloudTalkNetworkConfig;
+};
+//#endregion
+//#region extensions/nextcloud-talk/src/accounts.d.ts
+type ResolvedNextcloudTalkAccount = {
+  accountId: string;
+  enabled: boolean;
+  name?: string;
+  baseUrl: string;
+  secret: string;
+  secretSource: "env" | "secretFile" | "config" | "none";
+  config: NextcloudTalkAccountConfig;
+};
+//#endregion
+//#region extensions/nextcloud-talk/src/channel.d.ts
+declare const nextcloudTalkPlugin: ChannelPlugin<ResolvedNextcloudTalkAccount>;
+//#endregion
+export { nextcloudTalkPlugin as t };

package/dist/channel-I0GM2uBu.d.ts

@@ -0,0 +1,106 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { P as MessageReceipt, b as ChannelMessageSendTextContext, h as ChannelMessageSendMediaContext } from "./types-CYvxspyL.js";
+import { n as ChannelPlugin } from "./types.public-DuFOa-9T.js";
+import { t as ResolvedSynologyChatAccount } from "./types-BQ8nQjNk.js";
+
+//#region extensions/synology-chat/src/channel.d.ts
+declare const CHANNEL_ID = "synology-chat";
+type SynologyChannelGatewayContext = {
+  cfg: DaoCoreConfig;
+  accountId: string;
+  abortSignal: AbortSignal;
+  log?: {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+  };
+};
+type SynologyChannelOutboundContext = {
+  cfg: DaoCoreConfig;
+  to: string;
+  text?: string;
+  mediaUrl?: string;
+  accountId?: string | null;
+};
+type SynologyChannelSendTextContext = SynologyChannelOutboundContext & {
+  text: string;
+};
+type SynologyChannelSendMediaContext = SynologyChannelOutboundContext & {
+  mediaUrl: string;
+};
+type SynologyChatOutboundResult = {
+  channel: typeof CHANNEL_ID;
+  messageId: string;
+  chatId: string;
+  receipt: MessageReceipt;
+};
+type SynologyChatPlugin = Omit<ChannelPlugin<ResolvedSynologyChatAccount>, "pairing" | "security" | "messaging" | "directory" | "outbound" | "gateway" | "agentPrompt"> & {
+  pairing: {
+    idLabel: string;
+    normalizeAllowEntry?: (entry: string) => string;
+    notifyApproval: (params: {
+      cfg: DaoCoreConfig;
+      id: string;
+    }) => Promise<void>;
+  };
+  security: {
+    resolveDmPolicy: (params: {
+      cfg: DaoCoreConfig;
+      account: ResolvedSynologyChatAccount;
+    }) => {
+      policy: string | null | undefined;
+      allowFrom?: Array<string | number>;
+      normalizeEntry?: (raw: string) => string;
+    } | null;
+    collectWarnings: (params: {
+      cfg: DaoCoreConfig;
+      account: ResolvedSynologyChatAccount;
+    }) => string[];
+  };
+  messaging: {
+    targetPrefixes?: readonly string[];
+    normalizeTarget: (target: string) => string | undefined;
+    targetResolver: {
+      looksLikeId: (id: string) => boolean;
+      hint: string;
+    };
+  };
+  directory: {
+    self?: NonNullable<ChannelPlugin<ResolvedSynologyChatAccount>["directory"]>["self"];
+    listPeers?: NonNullable<ChannelPlugin<ResolvedSynologyChatAccount>["directory"]>["listPeers"];
+    listGroups?: NonNullable<ChannelPlugin<ResolvedSynologyChatAccount>["directory"]>["listGroups"];
+  };
+  outbound: {
+    deliveryMode: "gateway";
+    textChunkLimit: number;
+    sendText: (ctx: SynologyChannelSendTextContext) => Promise<SynologyChatOutboundResult>;
+    sendMedia: (ctx: SynologyChannelSendMediaContext) => Promise<SynologyChatOutboundResult>;
+  };
+  message: typeof synologyChatMessageAdapter;
+  gateway: {
+    startAccount: (ctx: SynologyChannelGatewayContext) => Promise<unknown>;
+    stopAccount: (ctx: SynologyChannelGatewayContext) => Promise<void>;
+  };
+  agentPrompt: {
+    messageToolHints: () => string[];
+  };
+};
+declare const synologyChatMessageAdapter: {
+  readonly id: "synology-chat";
+  readonly durableFinal: {
+    readonly capabilities: {
+      readonly text: true;
+      readonly media: true;
+      readonly messageSendingHooks: true;
+    };
+  };
+  readonly send: {
+    readonly text: (ctx: ChannelMessageSendTextContext<DaoCoreConfig>) => Promise<SynologyChatOutboundResult>;
+    readonly media: (ctx: ChannelMessageSendMediaContext<DaoCoreConfig>) => Promise<SynologyChatOutboundResult>;
+  };
+} & {
+  receive: {};
+};
+declare const synologyChatPlugin: SynologyChatPlugin;
+//#endregion
+export { synologyChatPlugin as t };

package/dist/channel-actions-D79TuV9L.d.ts

@@ -0,0 +1,5 @@
+import { y as ChannelMessageActionAdapter } from "./types.core-DpVp9PoP.js";
+//#region extensions/discord/src/channel-actions.d.ts
+declare const discordMessageActions: ChannelMessageActionAdapter;
+//#endregion
+export { discordMessageActions as t };

package/dist/channel-config-helpers-BKk5kCLm.d.ts

@@ -0,0 +1,152 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { N as ChannelSecurityDmPolicy } from "./types.core-DpVp9PoP.js";
+import { G as ConfigWriteScopeLike, K as ConfigWriteTargetLike, W as ConfigWriteAuthorizationResultLike, g as ChannelConfigAdapter } from "./types.adapters-StiSC8e-.js";
+//#region src/plugin-sdk/channel-config-helpers.d.ts
+type ConfigWriteScope = ConfigWriteScopeLike;
+type ConfigWriteTarget = ConfigWriteTargetLike;
+type ConfigWriteAuthorizationResult = ConfigWriteAuthorizationResultLike;
+type ChannelCrudConfigAdapter<ResolvedAccount> = Pick<ChannelConfigAdapter<ResolvedAccount>, "listAccountIds" | "resolveAccount" | "inspectAccount" | "defaultAccountId" | "setAccountEnabled" | "deleteAccount">;
+type ChannelConfigAdapterWithAccessors<ResolvedAccount> = Pick<ChannelConfigAdapter<ResolvedAccount>, "listAccountIds" | "resolveAccount" | "inspectAccount" | "defaultAccountId" | "setAccountEnabled" | "deleteAccount" | "resolveAllowFrom" | "formatAllowFrom" | "resolveDefaultTo">;
+declare function resolveChannelConfigWrites(params: {
+  cfg: DaoCoreConfig;
+  channelId?: string | null;
+  accountId?: string | null;
+}): boolean;
+declare function authorizeConfigWrite(params: {
+  cfg: DaoCoreConfig;
+  origin?: ConfigWriteScope;
+  target?: ConfigWriteTarget;
+  allowBypass?: boolean;
+}): ConfigWriteAuthorizationResult;
+declare function canBypassConfigWritePolicy(params: {
+  channel?: string | null;
+  gatewayClientScopes?: string[] | null;
+}): boolean;
+declare function formatConfigWriteDeniedMessage(params: {
+  result: Exclude<ConfigWriteAuthorizationResult, {
+    allowed: true;
+  }>;
+  fallbackChannelId?: string | null;
+}): string;
+type ChannelConfigAccessorParams<Config extends DaoCoreConfig = DaoCoreConfig> = {
+  cfg: Config;
+  accountId?: string | null;
+};
+type MultiAccountChannelConfigAdapterParams<ResolvedAccount, AccessorAccount = ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig> = {
+  sectionKey: string;
+  listAccountIds: (cfg: Config) => string[];
+  resolveAccount: (cfg: Config, accountId?: string | null) => ResolvedAccount;
+  resolveAccessorAccount?: (params: ChannelConfigAccessorParams<Config>) => AccessorAccount;
+  defaultAccountId: (cfg: Config) => string;
+  inspectAccount?: (cfg: Config, accountId?: string | null) => unknown;
+  clearBaseFields: string[];
+  resolveAllowFrom: (account: AccessorAccount) => Array<string | number> | null | undefined;
+  formatAllowFrom: (allowFrom: Array<string | number>) => string[];
+  resolveDefaultTo?: (account: AccessorAccount) => string | number | null | undefined;
+};
+type NamedAccountChannelConfigBaseParams<ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig> = {
+  sectionKey: string;
+  listAccountIds: (cfg: Config) => string[];
+  resolveAccount: (cfg: Config, accountId?: string | null) => ResolvedAccount;
+  defaultAccountId: (cfg: Config) => string;
+  inspectAccount?: (cfg: Config, accountId?: string | null) => unknown;
+  clearBaseFields: string[];
+};
+/** Coerce mixed allowlist config values into plain strings without trimming or deduping. */
+declare function mapAllowFromEntries(allowFrom: Array<string | number> | null | undefined): string[];
+/** Normalize user-facing allowlist entries the same way config and doctor flows expect. */
+declare function formatTrimmedAllowFromEntries(allowFrom: Array<string | number>): string[];
+/** Collapse nullable config scalars into a trimmed optional string. */
+declare function resolveOptionalConfigString(value: string | number | null | undefined): string | undefined;
+/** Adapt `{ cfg, accountId }` accessors to callback sites that pass positional args. */
+declare function adaptScopedAccountAccessor<Result, Config extends DaoCoreConfig = DaoCoreConfig>(accessor: (params: {
+  cfg: Config;
+  accountId?: string | null;
+}) => Result): (cfg: Config, accountId?: string | null) => Result;
+/** Build the shared allowlist/default target adapter surface for account-scoped channel configs. */
+declare function createScopedAccountConfigAccessors<ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: {
+  resolveAccount: (params: {
+    cfg: Config;
+    accountId?: string | null;
+  }) => ResolvedAccount;
+  resolveAllowFrom: (account: ResolvedAccount) => Array<string | number> | null | undefined;
+  formatAllowFrom: (allowFrom: Array<string | number>) => string[];
+  resolveDefaultTo?: (account: ResolvedAccount) => string | number | null | undefined;
+}): Pick<ChannelConfigAdapter<ResolvedAccount>, "resolveAllowFrom" | "formatAllowFrom" | "resolveDefaultTo">;
+/** Build the common CRUD/config helpers for channels that store multiple named accounts. */
+declare function createScopedChannelConfigBase<ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: NamedAccountChannelConfigBaseParams<ResolvedAccount, Config> & {
+  allowTopLevel?: boolean;
+}): ChannelCrudConfigAdapter<ResolvedAccount>;
+/** Build the full shared config adapter for account-scoped channels with allowlist/default target accessors. */
+declare function createScopedChannelConfigAdapter<ResolvedAccount, AccessorAccount = ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: MultiAccountChannelConfigAdapterParams<ResolvedAccount, AccessorAccount, Config> & {
+  allowTopLevel?: boolean;
+}): ChannelConfigAdapterWithAccessors<ResolvedAccount>;
+/** Build CRUD/config helpers for top-level single-account channels. */
+declare function createTopLevelChannelConfigBase<ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: {
+  sectionKey: string;
+  resolveAccount: (cfg: Config) => ResolvedAccount;
+  listAccountIds?: (cfg: Config) => string[];
+  defaultAccountId?: (cfg: Config) => string;
+  inspectAccount?: (cfg: Config) => unknown;
+  deleteMode?: "remove-section" | "clear-fields";
+  clearBaseFields?: string[];
+}): Pick<ChannelConfigAdapter<ResolvedAccount>, "listAccountIds" | "resolveAccount" | "inspectAccount" | "defaultAccountId" | "setAccountEnabled" | "deleteAccount">;
+/** Build the full shared config adapter for top-level single-account channels with allowlist/default target accessors. */
+declare function createTopLevelChannelConfigAdapter<ResolvedAccount, AccessorAccount = ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: {
+  sectionKey: string;
+  resolveAccount: (cfg: Config) => ResolvedAccount;
+  resolveAccessorAccount?: (params: {
+    cfg: Config;
+    accountId?: string | null;
+  }) => AccessorAccount;
+  listAccountIds?: (cfg: Config) => string[];
+  defaultAccountId?: (cfg: Config) => string;
+  inspectAccount?: (cfg: Config) => unknown;
+  deleteMode?: "remove-section" | "clear-fields";
+  clearBaseFields?: string[];
+  resolveAllowFrom: (account: AccessorAccount) => Array<string | number> | null | undefined;
+  formatAllowFrom: (allowFrom: Array<string | number>) => string[];
+  resolveDefaultTo?: (account: AccessorAccount) => string | number | null | undefined;
+}): ChannelConfigAdapterWithAccessors<ResolvedAccount>;
+/** Build CRUD/config helpers for channels where the default account lives at channel root and named accounts live under `accounts`. */
+declare function createHybridChannelConfigBase<ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: NamedAccountChannelConfigBaseParams<ResolvedAccount, Config> & {
+  preserveSectionOnDefaultDelete?: boolean;
+}): ChannelCrudConfigAdapter<ResolvedAccount>;
+/** Build the full shared config adapter for hybrid channels with allowlist/default target accessors. */
+declare function createHybridChannelConfigAdapter<ResolvedAccount, AccessorAccount = ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: MultiAccountChannelConfigAdapterParams<ResolvedAccount, AccessorAccount, Config> & {
+  preserveSectionOnDefaultDelete?: boolean;
+}): ChannelConfigAdapterWithAccessors<ResolvedAccount>;
+/** Convert account-specific DM security fields into the shared runtime policy resolver shape. */
+declare function createScopedDmSecurityResolver<ResolvedAccount extends {
+  accountId?: string | null;
+}>(params: {
+  channelKey: string;
+  resolvePolicy: (account: ResolvedAccount) => string | null | undefined;
+  resolveAllowFrom: (account: ResolvedAccount) => Array<string | number> | null | undefined;
+  resolveAccess?: (params: {
+    cfg: DaoCoreConfig;
+    accountId?: string | null;
+    account: ResolvedAccount;
+  }) => {
+    dmPolicy?: string | null;
+    allowFrom?: Array<string | number> | null;
+  };
+  resolveFallbackAccountId?: (account: ResolvedAccount) => string | null | undefined;
+  defaultPolicy?: string;
+  allowFromPathSuffix?: string;
+  policyPathSuffix?: string;
+  approveChannelId?: string;
+  approveHint?: string;
+  normalizeEntry?: (raw: string) => string;
+  inheritSharedDefaultsFromDefaultAccount?: boolean;
+}): ({
+  cfg,
+  accountId,
+  account
+}: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+  account: ResolvedAccount;
+}) => ChannelSecurityDmPolicy;
+//#endregion
+export { mapAllowFromEntries as _, authorizeConfigWrite as a, createHybridChannelConfigBase as c, createScopedChannelConfigBase as d, createScopedDmSecurityResolver as f, formatTrimmedAllowFromEntries as g, formatConfigWriteDeniedMessage as h, adaptScopedAccountAccessor as i, createScopedAccountConfigAccessors as l, createTopLevelChannelConfigBase as m, ConfigWriteScope as n, canBypassConfigWritePolicy as o, createTopLevelChannelConfigAdapter as p, ConfigWriteTarget as r, createHybridChannelConfigAdapter as s, ConfigWriteAuthorizationResult as t, createScopedChannelConfigAdapter as u, resolveChannelConfigWrites as v, resolveOptionalConfigString as y };

package/dist/channel-core-CastyvGp.d.ts

@@ -0,0 +1,6 @@
+import { o as createChannelPluginBase$1 } from "./core-BJHibRk_.js";
+
+//#region src/plugin-sdk/channel-core.d.ts
+declare const createChannelPluginBase: typeof createChannelPluginBase$1;
+//#endregion
+export { createChannelPluginBase as t };

package/dist/channel-entry-contract-D42_qkU5.d.ts

@@ -0,0 +1,112 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { n as ChannelConfigSchema } from "./types.config-CKJTcS4X.js";
+import { n as ChannelOutboundAdapter } from "./outbound.types-B2wXms-j.js";
+import { g as ChannelLegacyStateMigrationPlan } from "./types.core-DpVp9PoP.js";
+import { l as DaoCorePluginApi } from "./types-M3Y2bFvZ2.js";
+import { n as ChannelPlugin } from "./types.public-DuFOa-9T.js";
+import { n as PluginRuntime } from "./types-CqkHo5uy.js";
+import { t as PluginModuleLoaderFactory } from "./plugin-module-loader-cache-DOUa0J2M.js";
+
+//#region src/plugin-sdk/channel-entry-contract.d.ts
+type ChannelEntryConfigSchema<TPlugin> = TPlugin extends ChannelPlugin<unknown> ? NonNullable<TPlugin["configSchema"]> : ChannelConfigSchema;
+type BundledEntryModuleRef = {
+  specifier: string;
+  exportName?: string;
+};
+type DefineBundledChannelEntryOptions<TPlugin = ChannelPlugin> = {
+  id: string;
+  name: string;
+  description: string;
+  importMetaUrl: string;
+  plugin: BundledEntryModuleRef;
+  outbound?: BundledEntryModuleRef;
+  secrets?: BundledEntryModuleRef;
+  configSchema?: ChannelEntryConfigSchema<TPlugin> | (() => ChannelEntryConfigSchema<TPlugin>);
+  runtime?: BundledEntryModuleRef;
+  accountInspect?: BundledEntryModuleRef;
+  features?: BundledChannelEntryFeatures;
+  registerCliMetadata?: (api: DaoCorePluginApi) => void;
+  registerFull?: (api: DaoCorePluginApi) => void;
+};
+type DefineBundledChannelSetupEntryOptions = {
+  importMetaUrl: string;
+  plugin: BundledEntryModuleRef;
+  secrets?: BundledEntryModuleRef;
+  runtime?: BundledEntryModuleRef;
+  legacyStateMigrations?: BundledEntryModuleRef;
+  legacySessionSurface?: BundledEntryModuleRef;
+  features?: BundledChannelSetupEntryFeatures;
+};
+type BundledChannelSetupEntryFeatures = {
+  legacyStateMigrations?: boolean;
+  legacySessionSurfaces?: boolean;
+};
+type BundledChannelEntryFeatures = {
+  accountInspect?: boolean;
+};
+type BundledChannelLegacySessionSurface = {
+  isLegacyGroupSessionKey?: (key: string) => boolean;
+  canonicalizeLegacySessionKey?: (params: {
+    key: string;
+    agentId: string;
+  }) => string | null | undefined;
+};
+type BundledChannelLegacyStateMigrationDetector = (params: {
+  cfg: DaoCoreConfig;
+  env: NodeJS.ProcessEnv;
+  stateDir: string;
+  oauthDir: string;
+}) => ChannelLegacyStateMigrationPlan[] | Promise<ChannelLegacyStateMigrationPlan[] | null | undefined> | null | undefined;
+type BundledChannelEntryContract<TPlugin = ChannelPlugin> = {
+  kind: "bundled-channel-entry";
+  id: string;
+  name: string;
+  description: string;
+  configSchema: ChannelEntryConfigSchema<TPlugin>;
+  features?: BundledChannelEntryFeatures;
+  register: (api: DaoCorePluginApi) => void;
+  loadChannelPlugin: (options?: BundledEntryModuleLoadOptions) => TPlugin;
+  loadChannelOutbound?: (options?: BundledEntryModuleLoadOptions) => ChannelOutboundAdapter | undefined;
+  loadChannelSecrets?: (options?: BundledEntryModuleLoadOptions) => ChannelPlugin["secrets"] | undefined;
+  loadChannelAccountInspector?: (options?: BundledEntryModuleLoadOptions) => NonNullable<ChannelPlugin["config"]["inspectAccount"]>;
+  setChannelRuntime?: (runtime: PluginRuntime) => void;
+};
+type BundledChannelSetupEntryContract<TPlugin = ChannelPlugin> = {
+  kind: "bundled-channel-setup-entry";
+  loadSetupPlugin: (options?: BundledEntryModuleLoadOptions) => TPlugin;
+  loadSetupSecrets?: (options?: BundledEntryModuleLoadOptions) => ChannelPlugin["secrets"] | undefined;
+  loadLegacyStateMigrationDetector?: (options?: BundledEntryModuleLoadOptions) => BundledChannelLegacyStateMigrationDetector;
+  loadLegacySessionSurface?: (options?: BundledEntryModuleLoadOptions) => BundledChannelLegacySessionSurface;
+  setChannelRuntime?: (runtime: PluginRuntime) => void;
+  features?: BundledChannelSetupEntryFeatures;
+};
+type BundledEntryModuleLoadOptions = {
+  createLoaderForTest?: PluginModuleLoaderFactory;
+};
+declare function loadBundledEntryExportSync<T>(importMetaUrl: string, reference: BundledEntryModuleRef, options?: BundledEntryModuleLoadOptions): T;
+declare function defineBundledChannelEntry<TPlugin = ChannelPlugin>({
+  id,
+  name,
+  description,
+  importMetaUrl,
+  plugin,
+  outbound,
+  secrets,
+  configSchema,
+  runtime,
+  accountInspect,
+  features,
+  registerCliMetadata,
+  registerFull
+}: DefineBundledChannelEntryOptions<TPlugin>): BundledChannelEntryContract<TPlugin>;
+declare function defineBundledChannelSetupEntry<TPlugin = ChannelPlugin>({
+  importMetaUrl,
+  plugin,
+  secrets,
+  runtime,
+  legacyStateMigrations,
+  legacySessionSurface,
+  features
+}: DefineBundledChannelSetupEntryOptions): BundledChannelSetupEntryContract<TPlugin>;
+//#endregion
+export { BundledChannelSetupEntryContract as a, defineBundledChannelEntry as c, BundledChannelLegacyStateMigrationDetector as i, defineBundledChannelSetupEntry as l, BundledChannelEntryFeatures as n, BundledChannelSetupEntryFeatures as o, BundledChannelLegacySessionSurface as r, BundledEntryModuleLoadOptions as s, BundledChannelEntryContract as t, loadBundledEntryExportSync as u };

package/dist/channel-inbound-D4UrSB6E.d.ts

@@ -0,0 +1,93 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { n as InboundEventKind } from "./input-provenance-DgsxhTbk.js";
+import { n as HistoryMediaEntry } from "./history.types-D_WxL2c8.js";
+import { s as CommandNormalizeOptions } from "./commands-registry.types-DJQOZKet.js";
+import { t as EnvelopeFormatOptions } from "./envelope-DwKCeGtR.js";
+import { n as createInboundDebouncer, t as InboundDebounceCreateParams } from "./inbound-debounce-D4-RIKEw.js";
+import { x as InboundMediaFacts, y as ConversationFacts } from "./types-DJUlyV3O.js";
+import { i as filterChannelInboundSupplementalContext, n as BuiltChannelInboundEventContext, t as BuildChannelInboundEventContextParams } from "./context-Chf3fShp.js";
+//#region src/channels/inbound-debounce-policy.d.ts
+declare function shouldDebounceTextInbound(params: {
+  text: string | null | undefined;
+  cfg: DaoCoreConfig;
+  hasMedia?: boolean;
+  commandOptions?: CommandNormalizeOptions;
+  allowDebounce?: boolean;
+}): boolean;
+declare function createChannelInboundDebouncer<T>(params: Omit<InboundDebounceCreateParams<T>, "debounceMs"> & {
+  cfg: DaoCoreConfig;
+  channel: string;
+  debounceMsOverride?: number;
+}): {
+  debounceMs: number;
+  debouncer: ReturnType<typeof createInboundDebouncer<T>>;
+};
+//#endregion
+//#region src/channels/session-envelope.d.ts
+declare function resolveInboundSessionEnvelopeContext(params: {
+  cfg: DaoCoreConfig;
+  agentId: string;
+  sessionKey: string;
+}): {
+  storePath: string;
+  envelopeOptions: EnvelopeFormatOptions;
+  previousTimestamp: number | undefined;
+};
+//#endregion
+//#region src/channels/inbound-event/classification.d.ts
+type ClassifyChannelInboundEventParams = {
+  conversation: Pick<ConversationFacts, "kind">;
+  unmentionedGroupPolicy?: InboundEventKind;
+  wasMentioned?: boolean;
+  hasControlCommand?: boolean;
+  hasAbortRequest?: boolean;
+  commandSource?: "native" | "text";
+};
+declare function classifyChannelInboundEvent(params: ClassifyChannelInboundEventParams): InboundEventKind;
+declare function resolveUnmentionedGroupInboundPolicy(params: {
+  cfg: DaoCoreConfig;
+  agentId?: string;
+}): InboundEventKind;
+//#endregion
+//#region src/channels/inbound-event/media.d.ts
+type ChannelInboundMediaInput = {
+  path?: string | null;
+  url?: string | null;
+  contentType?: string | null;
+  kind?: InboundMediaFacts["kind"] | null;
+  transcribed?: boolean | null;
+  messageId?: string | null;
+};
+type ChannelInboundMediaPayload = {
+  MediaPath?: string;
+  MediaUrl?: string;
+  MediaType?: string;
+  MediaPaths?: string[];
+  MediaUrls?: string[];
+  MediaTypes?: string[];
+  MediaTranscribedIndexes?: number[];
+};
+declare function toInboundMediaFacts(media: readonly ChannelInboundMediaInput[] | null | undefined, defaults?: {
+  kind?: InboundMediaFacts["kind"];
+  messageId?: string;
+  transcribed?: (media: ChannelInboundMediaInput, index: number) => boolean;
+}): InboundMediaFacts[];
+declare function toHistoryMediaEntries(media: readonly ChannelInboundMediaInput[] | null | undefined, defaults?: {
+  kind?: InboundMediaFacts["kind"];
+  messageId?: string;
+}): HistoryMediaEntry[];
+declare function buildChannelInboundMediaPayload(media: readonly InboundMediaFacts[] | null | undefined): ChannelInboundMediaPayload;
+//#endregion
+//#region src/plugin-sdk/channel-inbound.d.ts
+type BuildChannelTurnContextParams = Omit<BuildChannelInboundEventContextParams, "message"> & {
+  message: BuildChannelInboundEventContextParams["message"] & {
+    inboundTurnKind?: InboundEventKind;
+  };
+};
+type BuiltChannelTurnContext = BuiltChannelInboundEventContext & {
+  InboundTurnKind: InboundEventKind;
+};
+declare function buildChannelTurnContext(params: BuildChannelTurnContextParams): BuiltChannelTurnContext;
+declare const filterChannelTurnSupplementalContext: typeof filterChannelInboundSupplementalContext;
+//#endregion
+export { ChannelInboundMediaInput as a, toHistoryMediaEntries as c, classifyChannelInboundEvent as d, resolveUnmentionedGroupInboundPolicy as f, shouldDebounceTextInbound as h, filterChannelTurnSupplementalContext as i, toInboundMediaFacts as l, createChannelInboundDebouncer as m, BuiltChannelTurnContext as n, ChannelInboundMediaPayload as o, resolveInboundSessionEnvelopeContext as p, buildChannelTurnContext as r, buildChannelInboundMediaPayload as s, BuildChannelTurnContextParams as t, ClassifyChannelInboundEventParams as u };