@gaodefa/daocore 2026.5.68 → 2026.5.69

package/dist/outbound.types-CQJou9Fo.d.ts

@@ -0,0 +1,289 @@
+import { r as DaoCoreConfig } from "./types.daocore-FLA7MxtO.js";
+import { S as MarkdownTableMode, T as ReplyToMode } from "./types.base-tQh4FMBR.js";
+import { N as ReplyPayloadDeliveryPin, b as MessagePresentation, s as ReplyPayload } from "./get-reply-options.types-BXrapyJ-.js";
+import { t as ChannelId } from "./channel-id.types-ClK6B_QE.js";
+import { t as OutboundSendDeps } from "./send-deps-BaEC80iY.js";
+import { t as OutboundMediaAccess } from "./load-options-CTuppEe4.js";
+import { P as MessageReceipt } from "./types-DOdQc8vl.js";
+import { A as ChannelPollResult, O as ChannelOutboundTargetMode, k as ChannelPollContext } from "./types.core-C_KSj9hF.js";
+
+//#region src/infra/outbound/deliver-types.d.ts
+type OutboundDeliveryResult = {
+  channel: Exclude<ChannelId, "none">;
+  messageId: string;
+  chatId?: string;
+  channelId?: string;
+  roomId?: string;
+  conversationId?: string;
+  timestamp?: number;
+  toJid?: string;
+  pollId?: string;
+  receipt?: MessageReceipt;
+  meta?: Record<string, unknown>;
+};
+type OutboundPayloadDeliverySuppressionReason = "cancelled_by_message_sending_hook" | "empty_after_message_sending_hook" | "no_visible_payload" | "adapter_returned_no_identity";
+type OutboundDeliveryFailureStage = "platform_send" | "queue" | "unknown";
+type OutboundPayloadDeliveryOutcome = {
+  index: number;
+  status: "sent";
+  results: OutboundDeliveryResult[];
+} | {
+  index: number;
+  status: "suppressed";
+  reason: OutboundPayloadDeliverySuppressionReason;
+  hookEffect?: {
+    cancelReason?: string;
+    metadata?: Record<string, unknown>;
+  };
+} | {
+  index: number;
+  status: "failed";
+  error: unknown;
+  sentBeforeError: boolean;
+  stage: OutboundDeliveryFailureStage;
+};
+//#endregion
+//#region src/auto-reply/chunk.d.ts
+type TextChunkProvider = ChannelId;
+/**
+ * Chunking mode for outbound messages:
+ * - "length": Split only when exceeding textChunkLimit (default)
+ * - "newline": Prefer breaking on "soft" boundaries. Historically this split on every
+ *   newline; now it only breaks on paragraph boundaries (blank lines) unless the text
+ *   exceeds the length limit.
+ */
+type ChunkMode = "length" | "newline";
+declare function resolveTextChunkLimit(cfg: DaoCoreConfig | undefined, provider?: TextChunkProvider, accountId?: string | null, opts?: {
+  fallbackLimit?: number;
+}): number;
+declare function resolveChunkMode(cfg: DaoCoreConfig | undefined, provider?: TextChunkProvider, accountId?: string | null): ChunkMode;
+/**
+ * Split text on newlines, trimming line whitespace.
+ * Blank lines are folded into the next non-empty line as leading "\n" prefixes.
+ * Long lines can be split by length (default) or kept intact via splitLongLines:false.
+ */
+declare function chunkByNewline(text: string, maxLineLength: number, opts?: {
+  splitLongLines?: boolean;
+  trimLines?: boolean;
+  isSafeBreak?: (index: number) => boolean;
+}): string[];
+/**
+ * Unified chunking function that dispatches based on mode.
+ */
+declare function chunkTextWithMode(text: string, limit: number, mode: ChunkMode): string[];
+declare function chunkMarkdownTextWithMode(text: string, limit: number, mode: ChunkMode): string[];
+declare function chunkText(text: string, limit: number): string[];
+declare function chunkMarkdownText(text: string, limit: number): string[];
+//#endregion
+//#region src/infra/outbound/formatting.d.ts
+type OutboundDeliveryFormattingOptions = {
+  textLimit?: number;
+  maxLinesPerMessage?: number;
+  tableMode?: MarkdownTableMode;
+  chunkMode?: ChunkMode;
+  parseMode?: "HTML";
+};
+//#endregion
+//#region src/infra/outbound/identity-types.d.ts
+type OutboundIdentity = {
+  name?: string;
+  avatarUrl?: string;
+  emoji?: string;
+  theme?: string;
+};
+//#endregion
+//#region src/channels/plugins/outbound.types.d.ts
+type ChannelOutboundContext = {
+  cfg: DaoCoreConfig;
+  to: string;
+  text: string;
+  mediaUrl?: string;
+  audioAsVoice?: boolean;
+  mediaAccess?: OutboundMediaAccess;
+  mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
+  gifPlayback?: boolean; /** Send image, GIF, or video as document to avoid channel compression. */
+  forceDocument?: boolean;
+  replyToId?: string | null;
+  replyToIdSource?: "explicit" | "implicit";
+  replyToMode?: ReplyToMode;
+  formatting?: OutboundDeliveryFormattingOptions;
+  threadId?: string | number | null;
+  accountId?: string | null;
+  identity?: OutboundIdentity;
+  deps?: OutboundSendDeps;
+  silent?: boolean;
+  gatewayClientScopes?: readonly string[];
+};
+type ChannelOutboundPayloadContext = ChannelOutboundContext & {
+  payload: ReplyPayload;
+};
+type ChannelPresentationCapabilities = {
+  /** Whether the channel accepts structured presentation payloads at all. */supported?: boolean; /** Whether the channel can render button action blocks natively. */
+  buttons?: boolean; /** Whether the channel can render select/menu blocks natively. */
+  selects?: boolean; /** Whether the channel can render low-emphasis context blocks natively. */
+  context?: boolean; /** Whether the channel can render divider blocks natively. */
+  divider?: boolean; /** Per-channel limits used to adapt portable presentation blocks before rendering. */
+  limits?: {
+    actions?: {
+      /** Maximum total button/select actions in one message. */maxActions?: number; /** Maximum buttons per rendered action row. */
+      maxActionsPerRow?: number; /** Maximum action rows in one message. */
+      maxRows?: number; /** Maximum user-visible button label length. */
+      maxLabelLength?: number; /** Maximum callback/action value size in UTF-8 bytes. */
+      maxValueBytes?: number; /** Whether action styles such as primary or danger are preserved. */
+      supportsStyles?: boolean; /** Whether disabled button state is preserved. */
+      supportsDisabled?: boolean; /** Whether priority/layout hints affect native rendering. */
+      supportsLayoutHints?: boolean;
+    };
+    selects?: {
+      /** Maximum options in one select/menu block. */maxOptions?: number; /** Maximum user-visible option label length. */
+      maxLabelLength?: number; /** Maximum option callback value size in UTF-8 bytes. */
+      maxValueBytes?: number;
+    };
+    text?: {
+      /** Maximum text length for title, text, and context blocks. */maxLength?: number; /** Unit used by maxLength. Defaults to Unicode code points. */
+      encoding?: "characters" | "utf8-bytes" | "utf16-units"; /** Markdown dialect understood by rendered text blocks. */
+      markdownDialect?: "plain" | "markdown" | "html" | "slack-mrkdwn" | "discord-markdown"; /** Whether the channel can edit presentation text in-place. */
+      supportsEdit?: boolean;
+    };
+  };
+};
+type ChannelDeliveryCapabilities = {
+  pin?: boolean;
+  durableFinal?: {
+    text?: boolean;
+    media?: boolean;
+    poll?: boolean;
+    payload?: boolean;
+    silent?: boolean;
+    replyTo?: boolean;
+    thread?: boolean;
+    nativeQuote?: boolean;
+    messageSendingHooks?: boolean;
+    batch?: boolean;
+    reconcileUnknownSend?: boolean;
+    afterSendSuccess?: boolean;
+    afterCommit?: boolean;
+  };
+};
+type ChannelOutboundPayloadHint = {
+  kind: "approval-pending";
+  approvalKind: "exec" | "plugin";
+  nativeRouteActive?: boolean;
+} | {
+  kind: "approval-resolved";
+  approvalKind: "exec" | "plugin";
+};
+type ChannelOutboundTargetRef = {
+  channel: string;
+  to: string;
+  accountId?: string | null;
+  threadId?: string | number | null;
+};
+type ChannelOutboundFormattedContext = ChannelOutboundContext & {
+  abortSignal?: AbortSignal;
+};
+type ChannelOutboundChunkContext = {
+  formatting?: OutboundDeliveryFormattingOptions;
+};
+type ChannelOutboundNormalizePayloadParams = {
+  payload: ReplyPayload;
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+};
+type ChannelOutboundAdapter = {
+  deliveryMode: "direct" | "gateway" | "hybrid";
+  chunker?: ((text: string, limit: number, ctx?: ChannelOutboundChunkContext) => string[]) | null;
+  chunkerMode?: "text" | "markdown";
+  chunkedTextFormatting?: OutboundDeliveryFormattingOptions; /** Lift remote Markdown image syntax in text into outbound media attachments. */
+  extractMarkdownImages?: boolean;
+  textChunkLimit?: number;
+  sanitizeText?: (params: {
+    text: string;
+    payload: ReplyPayload;
+  }) => string;
+  pollMaxOptions?: number;
+  supportsPollDurationSeconds?: boolean;
+  supportsAnonymousPolls?: boolean;
+  normalizePayload?: (params: ChannelOutboundNormalizePayloadParams) => ReplyPayload | null;
+  sendTextOnlyErrorPayloads?: boolean;
+  shouldSkipPlainTextSanitization?: (params: {
+    payload: ReplyPayload;
+  }) => boolean;
+  resolveEffectiveTextChunkLimit?: (params: {
+    cfg: DaoCoreConfig;
+    accountId?: string | null;
+    fallbackLimit?: number;
+  }) => number | undefined;
+  shouldSuppressLocalPayloadPrompt?: (params: {
+    cfg: DaoCoreConfig;
+    accountId?: string | null;
+    payload: ReplyPayload;
+    hint?: ChannelOutboundPayloadHint;
+  }) => boolean;
+  beforeDeliverPayload?: (params: {
+    cfg: DaoCoreConfig;
+    target: ChannelOutboundTargetRef;
+    payload: ReplyPayload;
+    hint?: ChannelOutboundPayloadHint;
+  }) => Promise<void> | void;
+  afterDeliverPayload?: (params: {
+    cfg: DaoCoreConfig;
+    target: ChannelOutboundTargetRef;
+    payload: ReplyPayload;
+    results: readonly OutboundDeliveryResult[];
+  }) => Promise<void> | void; /** Channel-advertised presentation features and limits used by core adaptation. */
+  presentationCapabilities?: ChannelPresentationCapabilities;
+  deliveryCapabilities?: ChannelDeliveryCapabilities; /** Render an adapted portable presentation into channel-native payload data. */
+  renderPresentation?: (params: {
+    payload: ReplyPayload;
+    presentation: MessagePresentation;
+    ctx: ChannelOutboundPayloadContext;
+  }) => Promise<ReplyPayload | null> | ReplyPayload | null;
+  pinDeliveredMessage?: (params: {
+    cfg: DaoCoreConfig;
+    target: ChannelOutboundTargetRef;
+    messageId: string;
+    pin: ReplyPayloadDeliveryPin;
+  }) => Promise<void> | void;
+  /**
+   * @deprecated Use shouldTreatDeliveredTextAsVisible instead.
+   */
+  shouldTreatRoutedTextAsVisible?: (params: {
+    kind: "tool" | "block" | "final";
+    text?: string;
+  }) => boolean;
+  shouldTreatDeliveredTextAsVisible?: (params: {
+    kind: "tool" | "block" | "final";
+    text?: string;
+  }) => boolean;
+  preferFinalAssistantVisibleText?: boolean;
+  targetsMatchForReplySuppression?: (params: {
+    originTarget: string;
+    targetKey: string;
+    targetThreadId?: string;
+  }) => boolean;
+  resolveTarget?: (params: {
+    cfg?: DaoCoreConfig;
+    to?: string;
+    allowFrom?: string[];
+    accountId?: string | null;
+    mode?: ChannelOutboundTargetMode;
+  }) => {
+    ok: true;
+    to: string;
+  } | {
+    ok: false;
+    error: Error;
+  };
+  sendPayload?: (ctx: ChannelOutboundPayloadContext) => Promise<OutboundDeliveryResult>;
+  sendFormattedText?: (ctx: ChannelOutboundFormattedContext) => Promise<OutboundDeliveryResult[]>;
+  sendFormattedMedia?: (ctx: ChannelOutboundFormattedContext & {
+    mediaUrl: string;
+  }) => Promise<OutboundDeliveryResult>;
+  sendText?: (ctx: ChannelOutboundContext) => Promise<OutboundDeliveryResult>;
+  sendMedia?: (ctx: ChannelOutboundContext) => Promise<OutboundDeliveryResult>;
+  sendPoll?: (ctx: ChannelPollContext) => Promise<ChannelPollResult>;
+};
+//#endregion
+export { chunkTextWithMode as _, ChannelOutboundFormattedContext as a, OutboundDeliveryResult as b, ChannelOutboundTargetRef as c, OutboundDeliveryFormattingOptions as d, ChunkMode as f, chunkText as g, chunkMarkdownTextWithMode as h, ChannelOutboundContext as i, ChannelPresentationCapabilities as l, chunkMarkdownText as m, ChannelOutboundAdapter as n, ChannelOutboundPayloadContext as o, chunkByNewline as p, ChannelOutboundChunkContext as r, ChannelOutboundPayloadHint as s, ChannelDeliveryCapabilities as t, OutboundIdentity as u, resolveChunkMode as v, OutboundPayloadDeliveryOutcome as x, resolveTextChunkLimit as y };

package/dist/pairing-challenge-Bm6EgPDI.d.ts

@@ -0,0 +1,87 @@
+import { t as ChannelPairingAdapter } from "./pairing.types-DuI1v4kY.js";
+import { t as PairingChannel } from "./pairing-store.types-J2vgFTIp.js";
+
+//#region src/pairing/pairing-store.d.ts
+type PairingRequest = {
+  id: string;
+  code: string;
+  createdAt: string;
+  lastSeenAt: string;
+  meta?: Record<string, string>;
+};
+declare function resolveChannelAllowFromPath(channel: PairingChannel, env?: NodeJS.ProcessEnv, accountId?: string): string;
+declare function readLegacyChannelAllowFromStore(channel: PairingChannel, env?: NodeJS.ProcessEnv): Promise<string[]>;
+declare function readChannelAllowFromStore(channel: PairingChannel, env?: NodeJS.ProcessEnv, accountId?: string): Promise<string[]>;
+declare function readLegacyChannelAllowFromStoreSync(channel: PairingChannel, env?: NodeJS.ProcessEnv): string[];
+declare function readChannelAllowFromStoreSync(channel: PairingChannel, env?: NodeJS.ProcessEnv, accountId?: string): string[];
+declare function clearPairingAllowFromReadCacheForTest(): void;
+type AllowFromStoreEntryUpdateParams = {
+  channel: PairingChannel;
+  entry: string | number;
+  accountId?: string;
+  env?: NodeJS.ProcessEnv;
+};
+declare function addChannelAllowFromStoreEntry(params: AllowFromStoreEntryUpdateParams): Promise<{
+  changed: boolean;
+  allowFrom: string[];
+}>;
+declare function removeChannelAllowFromStoreEntry(params: AllowFromStoreEntryUpdateParams): Promise<{
+  changed: boolean;
+  allowFrom: string[];
+}>;
+declare function listChannelPairingRequests(channel: PairingChannel, env?: NodeJS.ProcessEnv, accountId?: string): Promise<PairingRequest[]>;
+declare function upsertChannelPairingRequest(params: {
+  channel: PairingChannel;
+  id: string | number;
+  accountId: string;
+  meta?: Record<string, string | undefined | null>;
+  env?: NodeJS.ProcessEnv; /** Extension channels can pass their adapter directly to bypass registry lookup. */
+  pairingAdapter?: ChannelPairingAdapter;
+}): Promise<{
+  code: string;
+  created: boolean;
+}>;
+declare function approveChannelPairingCode(params: {
+  channel: PairingChannel;
+  code: string;
+  accountId?: string;
+  env?: NodeJS.ProcessEnv;
+}): Promise<{
+  id: string;
+  entry?: PairingRequest;
+} | null>;
+//#endregion
+//#region src/pairing/pairing-challenge.d.ts
+type PairingMeta = Record<string, string | undefined>;
+type PairingChallengeParams = {
+  channel: string;
+  senderId: string;
+  senderIdLine: string;
+  meta?: PairingMeta;
+  upsertPairingRequest: (params: {
+    id: string;
+    meta?: PairingMeta;
+  }) => Promise<{
+    code: string;
+    created: boolean;
+  }>;
+  sendPairingReply: (text: string) => Promise<void>;
+  buildReplyText?: (params: {
+    code: string;
+    senderIdLine: string;
+  }) => string;
+  onCreated?: (params: {
+    code: string;
+  }) => void;
+  onReplyError?: (err: unknown) => void;
+};
+/**
+ * Shared pairing challenge issuance for DM pairing policy pathways.
+ * Ensures every channel follows the same create-if-missing + reply flow.
+ */
+declare function issuePairingChallenge(params: PairingChallengeParams): Promise<{
+  created: boolean;
+  code?: string;
+}>;
+//#endregion
+export { approveChannelPairingCode as a, readChannelAllowFromStore as c, readLegacyChannelAllowFromStoreSync as d, removeChannelAllowFromStoreEntry as f, addChannelAllowFromStoreEntry as i, readChannelAllowFromStoreSync as l, upsertChannelPairingRequest as m, issuePairingChallenge as n, clearPairingAllowFromReadCacheForTest as o, resolveChannelAllowFromPath as p, PairingRequest as r, listChannelPairingRequests as s, PairingChallengeParams as t, readLegacyChannelAllowFromStore as u };

package/dist/pairing-messages-C86le7Fl.d.ts

@@ -0,0 +1,10 @@
+import { t as PairingChannel } from "./pairing-store.types-J2vgFTIp.js";
+
+//#region src/pairing/pairing-messages.d.ts
+declare function buildPairingReply(params: {
+  channel: PairingChannel;
+  idLine: string;
+  code: string;
+}): string;
+//#endregion
+export { buildPairingReply as t };

package/dist/pairing-store.types-J2vgFTIp.d.ts

@@ -0,0 +1,23 @@
+import { t as ChannelId } from "./channel-id.types-ClK6B_QE.js";
+import { t as ChannelPairingAdapter } from "./pairing.types-DuI1v4kY.js";
+
+//#region src/pairing/pairing-store.types.d.ts
+type PairingChannel = ChannelId;
+type ReadChannelAllowFromStoreForAccount = (params: {
+  channel: PairingChannel;
+  accountId: string;
+  env?: NodeJS.ProcessEnv;
+}) => Promise<string[]>;
+type UpsertChannelPairingRequestForAccount = (params: {
+  channel: PairingChannel;
+  id: string | number;
+  accountId: string;
+  meta?: Record<string, string | undefined | null>;
+  env?: NodeJS.ProcessEnv;
+  pairingAdapter?: ChannelPairingAdapter;
+}) => Promise<{
+  code: string;
+  created: boolean;
+}>;
+//#endregion
+export { ReadChannelAllowFromStoreForAccount as n, UpsertChannelPairingRequestForAccount as r, PairingChannel as t };

package/dist/pairing.types-DuI1v4kY.d.ts

@@ -0,0 +1,16 @@
+import { r as DaoCoreConfig } from "./types.daocore-FLA7MxtO.js";
+import { n as RuntimeEnv } from "./runtime-Bxifh4bY.js";
+
+//#region src/channels/plugins/pairing.types.d.ts
+type ChannelPairingAdapter = {
+  idLabel: string;
+  normalizeAllowEntry?: (entry: string) => string;
+  notifyApproval?: (params: {
+    cfg: DaoCoreConfig;
+    id: string;
+    accountId?: string;
+    runtime?: RuntimeEnv;
+  }) => Promise<void>;
+};
+//#endregion
+export { ChannelPairingAdapter as t };