@gaodefa/daocore 2026.5.99 → 2026.5.100

package/dist/registry-types-LmCVjAJ1.d.ts

@@ -0,0 +1,392 @@
+import { r as EmbeddingProviderAdapter } from "./embedding-providers-BVkiSZN4.js";
+import { i as PluginCompatCode } from "./installed-plugin-index-types-B0CEN2Ex.js";
+import { i as PluginFormat, n as PluginConfigUiHint, r as PluginDiagnostic, t as PluginBundleFormat } from "./manifest-types-DYm6ZA7y.js";
+import { t as JsonSchemaObject } from "./json-schema.types-fpZiub1R.js";
+import { c as PluginManifestContracts, d as PluginKind, o as PluginDependencyStatus } from "./manifest-registry-C-PpGA-Y.js";
+import { t as PluginOrigin } from "./plugin-origin.types-CFJ3OkLP.js";
+import { L as WebFetchProviderPlugin, O as DaoCorePluginToolFactory, U as WebSearchProviderPlugin } from "./types-core-C_yvb0RI.js";
+import { t as HookEntry } from "./types-ClWVEKRA.js";
+import { A as DaoCorePluginNodeInvokePolicy, F as DaoCorePluginReloadRegistration, G as ImageGenerationProviderPlugin, Gn as SpeechProviderPlugin, Jn as VideoGenerationProviderPlugin, K as MediaUnderstandingProviderPlugin, L as DaoCorePluginSecurityAuditCollector, O as DaoCorePluginNodeHostCommand, S as DaoCorePluginHttpRouteMatch, St as PluginTextTransformRegistration, Tr as AgentToolResultMiddleware, Un as RealtimeTranscriptionProviderPlugin, Wn as RealtimeVoiceProviderPlugin, b as DaoCorePluginHttpRouteAuth, d as DaoCorePluginCliCommandDescriptor, gr as CliBackendPlugin, ht as PluginLogger, it as MusicGenerationProviderPlugin, jr as AgentToolResultMiddlewareRuntime, lr as CodexAppServerExtensionFactory, m as DaoCorePluginCommandDefinition, o as DaoCoreGatewayDiscoveryService, p as DaoCorePluginCliRegistrar, qn as UnifiedModelCatalogProviderPlugin, si as AgentHarness, sn as ProviderPlugin, tt as MigrationProviderPlugin, v as DaoCorePluginGatewayRuntimeScopeSurface, w as DaoCorePluginHttpRouteUpgradeHandler, x as DaoCorePluginHttpRouteHandler, y as DaoCorePluginHostedMediaResolver, z as DaoCorePluginService, zi as MemoryEmbeddingProviderAdapter } from "./types-DEEPn4W72.js";
+import { Xt as PluginConversationBindingResolvedEvent, tt as PluginHookRegistration$1 } from "./hook-types-D_9P6xki.js";
+import { Ao as PluginRuntimeLifecycleRegistration, Do as PluginControlUiDescriptor, Eo as PluginAgentEventSubscriptionRegistration, Lo as PluginSessionExtensionRegistration, Mo as PluginSessionActionRegistration, Uo as PluginToolMetadataRegistration, Wo as PluginTrustedToolPolicyRegistration, zo as PluginSessionSchedulerJobRegistration } from "./index-DD4-DZR3.js";
+import { n as ChannelPlugin } from "./types.public-zY4a1Bje.js";
+import { h as GatewayMethodDescriptor, i as GatewayRequestHandlers, v as CronServiceContract } from "./types-Dr4yP-Zm.js";
+import { n as PluginRuntime } from "./types-Ciw1aP8l.js";
+import { a as PluginActivationSource } from "./config-state-ecMndUCe.js";
+
+//#region src/plugins/registry-types.d.ts
+type PluginToolRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  factory: DaoCorePluginToolFactory;
+  names: string[];
+  declaredNames?: string[];
+  optional: boolean;
+  source: string;
+  rootDir?: string;
+};
+type PluginCliRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  register: DaoCorePluginCliRegistrar;
+  parentPath: string[];
+  commands: string[];
+  descriptors: DaoCorePluginCliCommandDescriptor[];
+  source: string;
+  rootDir?: string;
+};
+type PluginHttpRouteRegistration = {
+  pluginId?: string;
+  path: string;
+  handler: DaoCorePluginHttpRouteHandler;
+  handleUpgrade?: DaoCorePluginHttpRouteUpgradeHandler;
+  auth: DaoCorePluginHttpRouteAuth;
+  match: DaoCorePluginHttpRouteMatch;
+  gatewayRuntimeScopeSurface?: DaoCorePluginGatewayRuntimeScopeSurface;
+  gatewayMethodDispatchAllowed?: boolean;
+  nodeCapability?: {
+    surface: string;
+    ttlMs?: number;
+  };
+  source?: string;
+};
+type PluginHostedMediaResolverRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  resolver: DaoCorePluginHostedMediaResolver;
+  source: string;
+  rootDir?: string;
+};
+type PluginChannelRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  plugin: ChannelPlugin;
+  source: string;
+  rootDir?: string;
+};
+type PluginChannelSetupRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  plugin: ChannelPlugin;
+  source: string;
+  enabled: boolean;
+  rootDir?: string;
+};
+type PluginProviderRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  provider: ProviderPlugin;
+  source: string;
+  rootDir?: string;
+};
+type PluginModelCatalogProviderRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  provider: UnifiedModelCatalogProviderPlugin;
+  source: string;
+  rootDir?: string;
+};
+type PluginCliBackendRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  backend: CliBackendPlugin;
+  source: string;
+  rootDir?: string;
+};
+type PluginTextTransformsRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  transforms: PluginTextTransformRegistration;
+  source: string;
+  rootDir?: string;
+};
+type PluginOwnedProviderRegistration<T extends {
+  id: string;
+}> = {
+  pluginId: string;
+  pluginName?: string;
+  provider: T;
+  source: string;
+  rootDir?: string;
+};
+type PluginSpeechProviderRegistration = PluginOwnedProviderRegistration<SpeechProviderPlugin>;
+type PluginEmbeddingProviderRegistration = PluginOwnedProviderRegistration<EmbeddingProviderAdapter>;
+type PluginRealtimeTranscriptionProviderRegistration = PluginOwnedProviderRegistration<RealtimeTranscriptionProviderPlugin>;
+type PluginRealtimeVoiceProviderRegistration = PluginOwnedProviderRegistration<RealtimeVoiceProviderPlugin>;
+type PluginMediaUnderstandingProviderRegistration = PluginOwnedProviderRegistration<MediaUnderstandingProviderPlugin>;
+type PluginImageGenerationProviderRegistration = PluginOwnedProviderRegistration<ImageGenerationProviderPlugin>;
+type PluginVideoGenerationProviderRegistration = PluginOwnedProviderRegistration<VideoGenerationProviderPlugin>;
+type PluginMusicGenerationProviderRegistration = PluginOwnedProviderRegistration<MusicGenerationProviderPlugin>;
+type PluginWebFetchProviderRegistration = PluginOwnedProviderRegistration<WebFetchProviderPlugin>;
+type PluginWebSearchProviderRegistration = PluginOwnedProviderRegistration<WebSearchProviderPlugin>;
+type PluginMigrationProviderRegistration = PluginOwnedProviderRegistration<MigrationProviderPlugin>;
+type PluginMemoryEmbeddingProviderRegistration = PluginOwnedProviderRegistration<MemoryEmbeddingProviderAdapter>;
+type PluginCodexAppServerExtensionFactoryRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  rawFactory: CodexAppServerExtensionFactory;
+  factory: CodexAppServerExtensionFactory;
+  source: string;
+  rootDir?: string;
+};
+type PluginAgentToolResultMiddlewareRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  rawHandler: AgentToolResultMiddleware;
+  handler: AgentToolResultMiddleware;
+  runtimes: AgentToolResultMiddlewareRuntime[];
+  source: string;
+  rootDir?: string;
+};
+type PluginAgentHarnessRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  harness: AgentHarness;
+  source: string;
+  rootDir?: string;
+};
+type PluginHookRegistration = {
+  pluginId: string;
+  entry: HookEntry;
+  events: string[];
+  source: string;
+  rootDir?: string;
+};
+type PluginServiceRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  service: DaoCorePluginService;
+  source: string;
+  origin: PluginOrigin;
+  trustedOfficialInstall?: boolean;
+  rootDir?: string;
+};
+type PluginGatewayDiscoveryServiceRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  service: DaoCoreGatewayDiscoveryService;
+  source: string;
+  rootDir?: string;
+};
+type PluginReloadRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  registration: DaoCorePluginReloadRegistration;
+  source: string;
+  rootDir?: string;
+};
+type PluginNodeHostCommandRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  command: DaoCorePluginNodeHostCommand;
+  source: string;
+  rootDir?: string;
+};
+type PluginNodeInvokePolicyRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  policy: DaoCorePluginNodeInvokePolicy;
+  pluginConfig?: Record<string, unknown>;
+  source: string;
+  rootDir?: string;
+};
+type PluginSecurityAuditCollectorRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  collector: DaoCorePluginSecurityAuditCollector;
+  source: string;
+  rootDir?: string;
+};
+type PluginCommandRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  command: DaoCorePluginCommandDefinition;
+  source: string;
+  rootDir?: string;
+};
+type PluginSessionExtensionRegistryRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  extension: PluginSessionExtensionRegistration;
+  source: string;
+  rootDir?: string;
+};
+type PluginTrustedToolPolicyRegistryRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  policy: PluginTrustedToolPolicyRegistration;
+  source: string;
+  rootDir?: string;
+};
+type PluginToolMetadataRegistryRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  metadata: PluginToolMetadataRegistration;
+  source: string;
+  rootDir?: string;
+};
+type PluginControlUiDescriptorRegistryRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  descriptor: PluginControlUiDescriptor;
+  source: string;
+  rootDir?: string;
+};
+type PluginRuntimeLifecycleRegistryRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  lifecycle: PluginRuntimeLifecycleRegistration;
+  source: string;
+  rootDir?: string;
+};
+type PluginAgentEventSubscriptionRegistryRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  subscription: PluginAgentEventSubscriptionRegistration;
+  source: string;
+  rootDir?: string;
+};
+type PluginSessionSchedulerJobRegistryRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  job: PluginSessionSchedulerJobRegistration;
+  generation?: number;
+  source: string;
+  rootDir?: string;
+};
+type PluginSessionActionRegistryRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  action: PluginSessionActionRegistration;
+  source: string;
+  rootDir?: string;
+};
+type PluginConversationBindingResolvedHandlerRegistration = {
+  pluginId: string;
+  pluginName?: string;
+  pluginRoot?: string;
+  handler: (event: PluginConversationBindingResolvedEvent) => void | Promise<void>;
+  source: string;
+  rootDir?: string;
+};
+type PluginRecord = {
+  id: string;
+  name: string;
+  version?: string;
+  packageName?: string;
+  description?: string;
+  format?: PluginFormat;
+  bundleFormat?: PluginBundleFormat;
+  bundleCapabilities?: string[];
+  kind?: PluginKind | PluginKind[];
+  source: string;
+  rootDir?: string;
+  origin: PluginOrigin;
+  workspaceDir?: string;
+  trustedOfficialInstall?: boolean;
+  enabled: boolean;
+  explicitlyEnabled?: boolean;
+  activated?: boolean;
+  imported?: boolean;
+  compat?: readonly PluginCompatCode[];
+  activationSource?: PluginActivationSource;
+  activationReason?: string;
+  status: "loaded" | "disabled" | "error";
+  error?: string;
+  failedAt?: Date;
+  failurePhase?: "validation" | "load" | "register";
+  toolNames: string[];
+  hookNames: string[];
+  channelIds: string[];
+  cliBackendIds: string[];
+  providerIds: string[];
+  syntheticAuthRefs?: string[];
+  embeddingProviderIds: string[];
+  speechProviderIds: string[];
+  realtimeTranscriptionProviderIds: string[];
+  realtimeVoiceProviderIds: string[];
+  mediaUnderstandingProviderIds: string[];
+  imageGenerationProviderIds: string[];
+  videoGenerationProviderIds: string[];
+  musicGenerationProviderIds: string[];
+  webFetchProviderIds: string[];
+  webSearchProviderIds: string[];
+  migrationProviderIds: string[];
+  contextEngineIds?: string[];
+  memoryEmbeddingProviderIds: string[];
+  agentHarnessIds: string[];
+  cliCommands: string[];
+  services: string[];
+  gatewayDiscoveryServiceIds: string[];
+  commands: string[];
+  httpRoutes: number;
+  hookCount: number;
+  configSchema: boolean;
+  configUiHints?: Record<string, PluginConfigUiHint>;
+  configJsonSchema?: JsonSchemaObject;
+  contracts?: PluginManifestContracts;
+  memorySlotSelected?: boolean;
+  dependencyStatus?: PluginDependencyStatus;
+};
+type PluginRegistry = {
+  plugins: PluginRecord[];
+  tools: PluginToolRegistration[];
+  hooks: PluginHookRegistration[];
+  typedHooks: PluginHookRegistration$1[];
+  channels: PluginChannelRegistration[];
+  channelSetups: PluginChannelSetupRegistration[];
+  providers: PluginProviderRegistration[];
+  modelCatalogProviders: PluginModelCatalogProviderRegistration[];
+  cliBackends?: PluginCliBackendRegistration[];
+  textTransforms: PluginTextTransformsRegistration[];
+  embeddingProviders: PluginEmbeddingProviderRegistration[];
+  speechProviders: PluginSpeechProviderRegistration[];
+  realtimeTranscriptionProviders: PluginRealtimeTranscriptionProviderRegistration[];
+  realtimeVoiceProviders: PluginRealtimeVoiceProviderRegistration[];
+  mediaUnderstandingProviders: PluginMediaUnderstandingProviderRegistration[];
+  imageGenerationProviders: PluginImageGenerationProviderRegistration[];
+  videoGenerationProviders: PluginVideoGenerationProviderRegistration[];
+  musicGenerationProviders: PluginMusicGenerationProviderRegistration[];
+  webFetchProviders: PluginWebFetchProviderRegistration[];
+  webSearchProviders: PluginWebSearchProviderRegistration[];
+  migrationProviders: PluginMigrationProviderRegistration[];
+  codexAppServerExtensionFactories: PluginCodexAppServerExtensionFactoryRegistration[];
+  agentToolResultMiddlewares: PluginAgentToolResultMiddlewareRegistration[];
+  memoryEmbeddingProviders: PluginMemoryEmbeddingProviderRegistration[];
+  agentHarnesses: PluginAgentHarnessRegistration[];
+  gatewayHandlers: GatewayRequestHandlers;
+  gatewayMethodDescriptors: GatewayMethodDescriptor[];
+  coreGatewayMethodNames?: string[];
+  httpRoutes: PluginHttpRouteRegistration[];
+  hostedMediaResolvers?: PluginHostedMediaResolverRegistration[];
+  cliRegistrars: PluginCliRegistration[];
+  reloads?: PluginReloadRegistration[];
+  nodeHostCommands?: PluginNodeHostCommandRegistration[];
+  nodeInvokePolicies?: PluginNodeInvokePolicyRegistration[];
+  securityAuditCollectors?: PluginSecurityAuditCollectorRegistration[];
+  services: PluginServiceRegistration[];
+  gatewayDiscoveryServices: PluginGatewayDiscoveryServiceRegistration[];
+  commands: PluginCommandRegistration[];
+  sessionExtensions?: PluginSessionExtensionRegistryRegistration[];
+  trustedToolPolicies?: PluginTrustedToolPolicyRegistryRegistration[];
+  toolMetadata?: PluginToolMetadataRegistryRegistration[];
+  controlUiDescriptors?: PluginControlUiDescriptorRegistryRegistration[];
+  runtimeLifecycles?: PluginRuntimeLifecycleRegistryRegistration[];
+  agentEventSubscriptions?: PluginAgentEventSubscriptionRegistryRegistration[];
+  sessionSchedulerJobs?: PluginSessionSchedulerJobRegistryRegistration[];
+  sessionActions?: PluginSessionActionRegistryRegistration[];
+  conversationBindingResolvedHandlers: PluginConversationBindingResolvedHandlerRegistration[];
+  diagnostics: PluginDiagnostic[];
+};
+type PluginRegistryParams = {
+  logger: PluginLogger;
+  coreGatewayHandlers?: GatewayRequestHandlers;
+  coreGatewayMethodNames?: readonly string[];
+  runtime: PluginRuntime;
+  hostServices?: {
+    /** May be a live accessor; plugin APIs must read it at call time. */cron?: CronServiceContract;
+  };
+  activateGlobalSideEffects?: boolean;
+};
+//#endregion
+export { PluginRegistryParams as a, PluginRegistry as i, PluginHttpRouteRegistration as n, PluginTextTransformsRegistration as o, PluginRecord as r, PluginAgentToolResultMiddlewareRegistration as t };

package/dist/repair-BiZkiQl4.d.ts

@@ -0,0 +1,33 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { c as OAuthCredential, o as AuthProfileIdRepairResult, s as AuthProfileStore } from "./types-DCT-w72n.js";
+
+//#region src/agents/auth-profiles/constants.d.ts
+/** @deprecated Anthropic provider-owned CLI profile id; do not use from third-party plugins. */
+declare const CLAUDE_CLI_PROFILE_ID = "anthropic:claude-cli";
+/** @deprecated OpenAI Codex provider-owned CLI profile id; do not use from third-party plugins. */
+declare const CODEX_CLI_PROFILE_ID = "openai-codex:codex-cli";
+//#endregion
+//#region src/agents/auth-profiles/credential-state.d.ts
+type AuthCredentialReasonCode = "ok" | "missing_credential" | "invalid_expires" | "expired" | "unresolved_ref";
+declare const DEFAULT_OAUTH_REFRESH_MARGIN_MS: number;
+type TokenExpiryState = "missing" | "valid" | "expiring" | "expired" | "invalid_expires";
+declare function hasUsableOAuthCredential(credential: OAuthCredential | undefined, opts?: {
+  now?: number;
+  refreshMarginMs?: number;
+}): boolean;
+//#endregion
+//#region src/agents/auth-profiles/repair.d.ts
+declare function suggestOAuthProfileIdForLegacyDefault(params: {
+  cfg?: DaoCoreConfig;
+  store: AuthProfileStore;
+  provider: string;
+  legacyProfileId: string;
+}): string | null;
+declare function repairOAuthProfileIdMismatch(params: {
+  cfg: DaoCoreConfig;
+  store: AuthProfileStore;
+  provider: string;
+  legacyProfileId?: string;
+}): AuthProfileIdRepairResult;
+//#endregion
+export { TokenExpiryState as a, CODEX_CLI_PROFILE_ID as c, DEFAULT_OAUTH_REFRESH_MARGIN_MS as i, suggestOAuthProfileIdForLegacyDefault as n, hasUsableOAuthCredential as o, AuthCredentialReasonCode as r, CLAUDE_CLI_PROFILE_ID as s, repairOAuthProfileIdMismatch as t };

package/dist/reply-dispatch-runtime-DDUyCOks.d.ts

@@ -0,0 +1,6 @@
+import { n as DispatchReplyWithDispatcher, t as DispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher.types-4jJAfyq8.js";
+//#region src/plugin-sdk/reply-dispatch-runtime.d.ts
+declare const dispatchReplyWithBufferedBlockDispatcher: DispatchReplyWithBufferedBlockDispatcher;
+declare const dispatchReplyWithDispatcher: DispatchReplyWithDispatcher;
+//#endregion
+export { dispatchReplyWithDispatcher as n, dispatchReplyWithBufferedBlockDispatcher as t };

package/dist/reply-payload-BJ364q4f.d.ts

@@ -0,0 +1,200 @@
+import { s as ReplyPayload$1 } from "./get-reply-options.types-BXrapyJ-.js";
+import { n as ChannelOutboundAdapter } from "./outbound.types-BgOkffIj.js";
+
+//#region src/channels/plugins/media-payload.d.ts
+type MediaPayloadInput = {
+  path: string;
+  contentType?: string;
+};
+type MediaPayload = {
+  MediaPath?: string;
+  MediaType?: string;
+  MediaUrl?: string;
+  MediaPaths?: string[];
+  MediaUrls?: string[];
+  MediaTypes?: string[];
+};
+declare function buildMediaPayload(mediaList: MediaPayloadInput[], opts?: {
+  preserveMediaTypeCardinality?: boolean;
+}): MediaPayload;
+//#endregion
+//#region src/plugin-sdk/reply-payload.d.ts
+type ReplyPayload = Omit<ReplyPayload$1, "trustedLocalMedia">;
+type OutboundReplyPayload = {
+  text?: string;
+  mediaUrls?: string[];
+  mediaUrl?: string;
+  presentation?: ReplyPayload$1["presentation"];
+  /**
+   * @deprecated Use presentation. Runtime support remains for legacy producers.
+   */
+  interactive?: ReplyPayload$1["interactive"];
+  channelData?: ReplyPayload$1["channelData"];
+  sensitiveMedia?: boolean;
+  replyToId?: string;
+};
+type ReasoningReplyPayload = {
+  text?: string;
+  isReasoning?: boolean;
+};
+type SendableOutboundReplyParts = {
+  text: string;
+  trimmedText: string;
+  mediaUrls: string[];
+  mediaCount: number;
+  hasText: boolean;
+  hasMedia: boolean;
+  hasContent: boolean;
+};
+type SendPayloadContext = Parameters<NonNullable<ChannelOutboundAdapter["sendPayload"]>>[0];
+type SendPayloadResult = Awaited<ReturnType<NonNullable<ChannelOutboundAdapter["sendPayload"]>>>;
+type SendPayloadAdapter = Pick<ChannelOutboundAdapter, "sendMedia" | "sendText" | "chunker" | "textChunkLimit">;
+declare function isReasoningReplyPayload(payload: ReasoningReplyPayload): boolean;
+/** Extract the supported outbound reply fields from loose tool or agent payload objects. */
+declare function normalizeOutboundReplyPayload(payload: Record<string, unknown>): OutboundReplyPayload;
+/** Wrap a deliverer so callers can hand it arbitrary payloads while channels receive normalized data. */
+declare function createNormalizedOutboundDeliverer(handler: (payload: OutboundReplyPayload) => Promise<void>): (payload: unknown) => Promise<void>;
+/** Prefer multi-attachment payloads, then fall back to the legacy single-media field. */
+declare function resolveOutboundMediaUrls(payload: {
+  mediaUrls?: string[];
+  mediaUrl?: string;
+}): string[];
+/** Resolve media URLs from a channel sendPayload context after legacy fallback normalization. */
+declare function resolvePayloadMediaUrls(payload: SendPayloadContext["payload"]): string[];
+/** Count outbound media items after legacy single-media fallback normalization. */
+declare function countOutboundMedia(payload: {
+  mediaUrls?: string[];
+  mediaUrl?: string;
+}): number;
+/** Check whether an outbound payload includes any media after normalization. */
+declare function hasOutboundMedia(payload: {
+  mediaUrls?: string[];
+  mediaUrl?: string;
+}): boolean;
+/** Check whether an outbound payload includes text, optionally trimming whitespace first. */
+declare function hasOutboundText(payload: {
+  text?: string;
+}, options?: {
+  trim?: boolean;
+}): boolean;
+/** Check whether an outbound payload includes any sendable text, media, or rich reply content. */
+declare function hasOutboundReplyContent(payload: {
+  text?: string;
+  mediaUrls?: string[];
+  mediaUrl?: string;
+  presentation?: unknown;
+  interactive?: unknown;
+  channelData?: unknown;
+}, options?: {
+  trimText?: boolean;
+}): boolean;
+/** Normalize reply payload text/media into a trimmed, sendable shape for delivery paths. */
+declare function resolveSendableOutboundReplyParts(payload: {
+  text?: string;
+  mediaUrls?: string[];
+  mediaUrl?: string;
+}, options?: {
+  text?: string;
+}): SendableOutboundReplyParts;
+/** Preserve caller-provided chunking, but fall back to the full text when chunkers return nothing. */
+declare function resolveTextChunksWithFallback(text: string, chunks: readonly string[]): string[];
+/** Send media-first payloads intact, or chunk text-only payloads through the caller's transport hooks. */
+declare function sendPayloadWithChunkedTextAndMedia<TContext extends {
+  payload: object;
+}, TResult>(params: {
+  ctx: TContext;
+  textChunkLimit?: number;
+  chunker?: ((text: string, limit: number) => string[]) | null;
+  sendText: (ctx: TContext & {
+    text: string;
+  }) => Promise<TResult>;
+  sendMedia: (ctx: TContext & {
+    text: string;
+    mediaUrl: string;
+  }) => Promise<TResult>;
+  emptyResult: TResult;
+}): Promise<TResult>;
+declare function sendPayloadMediaSequence<TResult>(params: {
+  text: string;
+  mediaUrls: readonly string[];
+  send: (input: {
+    text: string;
+    mediaUrl: string;
+    index: number;
+    isFirst: boolean;
+  }) => Promise<TResult>;
+}): Promise<TResult | undefined>;
+declare function sendPayloadMediaSequenceOrFallback<TResult>(params: {
+  text: string;
+  mediaUrls: readonly string[];
+  send: (input: {
+    text: string;
+    mediaUrl: string;
+    index: number;
+    isFirst: boolean;
+  }) => Promise<TResult>;
+  fallbackResult: TResult;
+  sendNoMedia?: () => Promise<TResult>;
+}): Promise<TResult>;
+declare function sendPayloadMediaSequenceAndFinalize<TMediaResult, TResult>(params: {
+  text: string;
+  mediaUrls: readonly string[];
+  send: (input: {
+    text: string;
+    mediaUrl: string;
+    index: number;
+    isFirst: boolean;
+  }) => Promise<TMediaResult>;
+  finalize: () => Promise<TResult>;
+}): Promise<TResult>;
+declare function sendTextMediaPayload(params: {
+  channel: string;
+  ctx: SendPayloadContext;
+  adapter: SendPayloadAdapter;
+}): Promise<SendPayloadResult>;
+/** Detect numeric-looking target ids for channels that distinguish ids from handles. */
+declare function isNumericTargetId(raw: string): boolean;
+/** Append attachment links to plain text when the channel cannot send media inline. */
+declare function formatTextWithAttachmentLinks(text: string | undefined, mediaUrls: string[]): string;
+/** Send a caption with only the first media item, mirroring caption-limited channel transports. */
+declare function sendMediaWithLeadingCaption(params: {
+  mediaUrls: string[];
+  caption: string;
+  send: (payload: {
+    mediaUrl: string;
+    caption?: string;
+  }) => Promise<void>;
+  onError?: (params: {
+    error: unknown;
+    mediaUrl: string;
+    caption?: string;
+    index: number;
+    isFirst: boolean;
+  }) => Promise<void> | void;
+}): Promise<boolean>;
+declare function deliverTextOrMediaReply(params: {
+  payload: OutboundReplyPayload;
+  text: string;
+  chunkText?: (text: string) => readonly string[];
+  sendText: (text: string) => Promise<void>;
+  sendMedia: (payload: {
+    mediaUrl: string;
+    caption?: string;
+  }) => Promise<void>;
+  onMediaError?: (params: {
+    error: unknown;
+    mediaUrl: string;
+    caption?: string;
+    index: number;
+    isFirst: boolean;
+  }) => Promise<void> | void;
+}): Promise<"empty" | "text" | "media">;
+declare function deliverFormattedTextWithAttachments(params: {
+  payload: OutboundReplyPayload;
+  send: (params: {
+    text: string;
+    replyToId?: string;
+  }) => Promise<void>;
+}): Promise<boolean>;
+//#endregion
+export { sendPayloadMediaSequenceOrFallback as C, MediaPayloadInput as D, MediaPayload as E, buildMediaPayload as O, sendPayloadMediaSequenceAndFinalize as S, sendTextMediaPayload as T, resolvePayloadMediaUrls as _, countOutboundMedia as a, sendMediaWithLeadingCaption as b, deliverTextOrMediaReply as c, hasOutboundReplyContent as d, hasOutboundText as f, resolveOutboundMediaUrls as g, normalizeOutboundReplyPayload as h, SendableOutboundReplyParts as i, formatTextWithAttachmentLinks as l, isReasoningReplyPayload as m, ReasoningReplyPayload as n, createNormalizedOutboundDeliverer as o, isNumericTargetId as p, ReplyPayload as r, deliverFormattedTextWithAttachments as s, OutboundReplyPayload as t, hasOutboundMedia as u, resolveSendableOutboundReplyParts as v, sendPayloadWithChunkedTextAndMedia as w, sendPayloadMediaSequence as x, resolveTextChunksWithFallback as y };

package/dist/reply-pipeline-umr5bb7x.d.ts

@@ -0,0 +1,41 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { a as SourceReplyDeliveryMode, s as ReplyPayload } from "./get-reply-options.types-BXrapyJ-.js";
+import { n as InboundEventKind } from "./input-provenance-DgsxhTbk.js";
+import { i as CommandTurnContext } from "./templating-Bw49ZLzH.js";
+import { n as TypingCallbacks, t as CreateTypingCallbacksParams } from "./typing-Bihu7fKL.js";
+import { i as createReplyPrefixOptions, n as ReplyPrefixOptions, t as ReplyPrefixContextBundle } from "./reply-prefix-DJZi-FhA.js";
+
+//#region src/auto-reply/reply/source-reply-delivery-mode.d.ts
+type SourceReplyDeliveryModeContext = {
+  ChatType?: string;
+  InboundEventKind?: InboundEventKind;
+  CommandAuthorized?: boolean;
+  CommandBody?: string;
+  CommandSource?: "text" | "native";
+  CommandTurn?: CommandTurnContext;
+};
+//#endregion
+//#region src/channels/message/reply-pipeline.d.ts
+type ReplyPrefixContext = ReplyPrefixContextBundle["prefixContext"];
+declare function resolveChannelSourceReplyDeliveryMode(params: {
+  cfg: DaoCoreConfig;
+  ctx: SourceReplyDeliveryModeContext;
+  requested?: SourceReplyDeliveryMode;
+  messageToolAvailable?: boolean;
+}): SourceReplyDeliveryMode;
+type ChannelReplyPipeline = ReplyPrefixOptions & {
+  typingCallbacks?: TypingCallbacks;
+  transformReplyPayload?: (payload: ReplyPayload) => ReplyPayload | null;
+};
+type CreateChannelReplyPipelineParams = {
+  cfg: Parameters<typeof createReplyPrefixOptions>[0]["cfg"];
+  agentId: string;
+  channel?: string;
+  accountId?: string;
+  typing?: CreateTypingCallbacksParams;
+  typingCallbacks?: TypingCallbacks;
+  transformReplyPayload?: (payload: ReplyPayload) => ReplyPayload | null;
+};
+declare function createChannelReplyPipeline(params: CreateChannelReplyPipelineParams): ChannelReplyPipeline;
+//#endregion
+export { resolveChannelSourceReplyDeliveryMode as a, createChannelReplyPipeline as i, CreateChannelReplyPipelineParams as n, ReplyPrefixContext as r, ChannelReplyPipeline as t };