@gaodefa/daocore 2026.5.67 → 2026.5.69

package/dist/host-compat-BZPrug-O.d.ts

@@ -0,0 +1,21 @@
+import { l as ContextEngine, m as ContextEngineOperation, u as ContextEngineHostCapability } from "./registry-CFtrpRX3.js";
+
+//#region src/context-engine/host-compat.d.ts
+type ContextEngineHostSupport = {
+  id: string;
+  label: string;
+  capabilities: readonly ContextEngineHostCapability[];
+};
+declare const CODEX_APP_SERVER_CONTEXT_ENGINE_HOST: {
+  readonly id: "codex-app-server";
+  readonly label: "Codex app-server harness";
+  readonly capabilities: readonly ["bootstrap", "assemble-before-prompt", "after-turn", "maintain", "compact", "runtime-llm-complete", "thread-bootstrap-projection"];
+};
+/** Assert that a context engine can safely run under the supplied host. */
+declare function assertContextEngineHostSupport(params: {
+  contextEngine: ContextEngine;
+  operation: ContextEngineOperation;
+  host: ContextEngineHostSupport;
+}): void;
+//#endregion
+export { assertContextEngineHostSupport as n, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST as t };

package/dist/http-registry-DF87gGOx.d.ts

@@ -0,0 +1,23 @@
+import { i as PluginRegistry } from "./registry-types-CczotiRc.js";
+import { t as PluginHttpRouteRegistration } from "./registry-Cp8bQ0hR.js";
+import { IncomingMessage, ServerResponse } from "node:http";
+
+//#region src/plugins/http-registry.d.ts
+type PluginHttpRouteHandler = (req: IncomingMessage, res: ServerResponse) => Promise<boolean | void> | boolean | void;
+declare function withPluginHttpRouteRegistry<T>(registry: PluginRegistry, run: () => T): T;
+declare function registerPluginHttpRoute(params: {
+  path?: string | null;
+  fallbackPath?: string | null;
+  handler: PluginHttpRouteHandler;
+  auth: PluginHttpRouteRegistration["auth"];
+  match?: PluginHttpRouteRegistration["match"];
+  gatewayRuntimeScopeSurface?: PluginHttpRouteRegistration["gatewayRuntimeScopeSurface"];
+  replaceExisting?: boolean;
+  pluginId?: string;
+  source?: string;
+  accountId?: string;
+  log?: (message: string) => void;
+  registry?: PluginRegistry;
+}): () => void;
+//#endregion
+export { registerPluginHttpRoute as n, withPluginHttpRouteRegistry as r, PluginHttpRouteHandler as t };

package/dist/identity-D1a2u5r2.d.ts

@@ -0,0 +1,31 @@
+import { r as DaoCoreConfig } from "./types.daocore-FLA7MxtO.js";
+import { v as HumanDelayConfig, y as IdentityConfig } from "./types.base-tQh4FMBR.js";
+
+//#region src/agents/identity.d.ts
+declare function resolveAgentIdentity(cfg: DaoCoreConfig, agentId: string): IdentityConfig | undefined;
+declare function resolveAckReaction(cfg: DaoCoreConfig, agentId: string, opts?: {
+  channel?: string;
+  accountId?: string;
+}): string;
+declare function resolveIdentityNamePrefix(cfg: DaoCoreConfig, agentId: string): string | undefined;
+declare function resolveMessagePrefix(cfg: DaoCoreConfig, agentId: string, opts?: {
+  configured?: string;
+  hasAllowFrom?: boolean;
+  fallback?: string;
+}): string;
+declare function resolveResponsePrefix(cfg: DaoCoreConfig, agentId: string, opts?: {
+  channel?: string;
+  accountId?: string;
+}): string | undefined;
+declare function resolveEffectiveMessagesConfig(cfg: DaoCoreConfig, agentId: string, opts?: {
+  hasAllowFrom?: boolean;
+  fallbackMessagePrefix?: string;
+  channel?: string;
+  accountId?: string;
+}): {
+  messagePrefix: string;
+  responsePrefix?: string;
+};
+declare function resolveHumanDelayConfig(cfg: DaoCoreConfig, agentId: string): HumanDelayConfig | undefined;
+//#endregion
+export { resolveIdentityNamePrefix as a, resolveHumanDelayConfig as i, resolveAgentIdentity as n, resolveMessagePrefix as o, resolveEffectiveMessagesConfig as r, resolveResponsePrefix as s, resolveAckReaction as t };

package/dist/image-generation-D0EMwvoT.d.ts

@@ -0,0 +1,123 @@
+import { r as DaoCoreConfig } from "./types.daocore-FLA7MxtO.js";
+import { _ as ImageGenerationSourceImage, l as ImageGenerationProvider, m as ImageGenerationRequest, t as GeneratedImageAsset, u as ImageGenerationProviderCapabilities } from "./types-Eyi3LpQY.js";
+//#region src/image-generation/openai-compatible-image-provider.d.ts
+type ModelProviderConfig = NonNullable<NonNullable<DaoCoreConfig["models"]>["providers"]>[string];
+type OpenAiCompatibleImageRequestMode = "generate" | "edit";
+type OpenAiCompatibleImageProviderRequestParams = {
+  req: ImageGenerationRequest;
+  inputImages: ImageGenerationSourceImage[];
+  model: string;
+  count: number;
+  mode: OpenAiCompatibleImageRequestMode;
+};
+type OpenAiCompatibleImageProviderRequestBody = {
+  kind: "json";
+  body: Record<string, unknown>;
+} | {
+  kind: "multipart";
+  form: FormData;
+};
+type OpenAiCompatibleImageProviderOptions = {
+  id: string;
+  label: string;
+  defaultModel: string;
+  models: readonly string[];
+  capabilities: ImageGenerationProviderCapabilities;
+  defaultBaseUrl: string;
+  providerConfigKey?: string;
+  normalizeModel?: (model: string | undefined, fallback: string) => string;
+  resolveBaseUrl?: (params: {
+    req: ImageGenerationRequest;
+    providerConfig?: ModelProviderConfig;
+    defaultBaseUrl: string;
+  }) => string;
+  resolveAllowPrivateNetwork?: (params: {
+    baseUrl: string;
+    req: ImageGenerationRequest;
+    providerConfig?: ModelProviderConfig;
+  }) => boolean | undefined;
+  useConfiguredRequest?: boolean;
+  defaultTimeoutMs?: number;
+  resolveCount?: (params: {
+    req: ImageGenerationRequest;
+    mode: OpenAiCompatibleImageRequestMode;
+  }) => number;
+  buildGenerateRequest: (params: OpenAiCompatibleImageProviderRequestParams & {
+    mode: "generate";
+  }) => OpenAiCompatibleImageProviderRequestBody;
+  buildEditRequest: (params: OpenAiCompatibleImageProviderRequestParams & {
+    mode: "edit";
+  }) => OpenAiCompatibleImageProviderRequestBody;
+  response?: {
+    defaultMimeType?: string;
+    fileNamePrefix?: string;
+    sniffMimeType?: boolean;
+  };
+  missingApiKeyError?: string;
+  tooManyInputImagesError?: string;
+  missingInputImageError?: string;
+  emptyResponseError?: string;
+  failureLabels?: {
+    generate?: string;
+    edit?: string;
+  };
+};
+declare function createOpenAiCompatibleImageGenerationProvider(options: OpenAiCompatibleImageProviderOptions): ImageGenerationProvider;
+//#endregion
+//#region src/image-generation/image-assets.d.ts
+type ImageMimeTypeDetection = {
+  mimeType: string;
+  extension: string;
+};
+type OpenAiCompatibleImageResponseEntry = {
+  b64_json?: unknown;
+  mime_type?: unknown;
+  revised_prompt?: unknown;
+};
+type OpenAiCompatibleImageResponsePayload = {
+  data?: unknown;
+};
+declare function imageFileExtensionForMimeType(mimeType: string | undefined, fallback?: string): string;
+declare function sniffImageMimeType(buffer: Buffer, fallbackMimeType?: string): ImageMimeTypeDetection;
+declare function toImageDataUrl(params: {
+  buffer: Buffer;
+  mimeType?: string;
+  defaultMimeType?: string;
+}): string;
+declare function parseImageDataUrl(dataUrl: string): {
+  mimeType: string;
+  base64: string;
+} | undefined;
+declare function generatedImageAssetFromBase64(params: {
+  base64: string | undefined;
+  index: number;
+  mimeType?: string;
+  revisedPrompt?: string;
+  defaultMimeType?: string;
+  fileNamePrefix?: string;
+  sniffMimeType?: boolean;
+}): GeneratedImageAsset | undefined;
+declare function generatedImageAssetFromDataUrl(params: {
+  dataUrl: string;
+  index: number;
+  fileNamePrefix?: string;
+}): GeneratedImageAsset | undefined;
+declare function generatedImageAssetFromOpenAiCompatibleEntry(entry: OpenAiCompatibleImageResponseEntry, index: number, options?: {
+  defaultMimeType?: string;
+  fileNamePrefix?: string;
+  sniffMimeType?: boolean;
+}): GeneratedImageAsset | undefined;
+declare function parseOpenAiCompatibleImageResponse(payload: unknown, options?: {
+  defaultMimeType?: string;
+  fileNamePrefix?: string;
+  malformedResponseError?: string;
+  sniffMimeType?: boolean;
+}): GeneratedImageAsset[];
+declare function imageSourceUploadFileName(params: {
+  image: ImageGenerationSourceImage;
+  index: number;
+  defaultMimeType?: string;
+  fileNamePrefix?: string;
+}): string;
+//#endregion
+export { createOpenAiCompatibleImageGenerationProvider as _, generatedImageAssetFromDataUrl as a, imageSourceUploadFileName as c, sniffImageMimeType as d, toImageDataUrl as f, OpenAiCompatibleImageRequestMode as g, OpenAiCompatibleImageProviderRequestParams as h, generatedImageAssetFromBase64 as i, parseImageDataUrl as l, OpenAiCompatibleImageProviderRequestBody as m, OpenAiCompatibleImageResponseEntry as n, generatedImageAssetFromOpenAiCompatibleEntry as o, OpenAiCompatibleImageProviderOptions as p, OpenAiCompatibleImageResponsePayload as r, imageFileExtensionForMimeType as s, ImageMimeTypeDetection as t, parseOpenAiCompatibleImageResponse as u };

package/dist/image-generation-core-D0LhPYXX.d.ts

@@ -0,0 +1,17 @@
+import { p as resolveApiKeyForProvider$1 } from "./model-auth-CBSmDPy1.js";
+declare namespace image_generation_core_auth_runtime_d_exports {
+  export { resolveApiKeyForProvider$1 as resolveApiKeyForProvider };
+}
+//#endregion
+//#region src/image-generation/model-ref.d.ts
+declare function parseImageGenerationModelRef(raw: string | undefined): {
+  provider: string;
+  model: string;
+} | null;
+//#endregion
+//#region src/plugin-sdk/image-generation-core.d.ts
+declare const OPENAI_DEFAULT_IMAGE_MODEL = "gpt-image-2";
+type ImageGenerationCoreAuthRuntimeModule = typeof image_generation_core_auth_runtime_d_exports;
+declare function resolveApiKeyForProvider(...args: Parameters<ImageGenerationCoreAuthRuntimeModule["resolveApiKeyForProvider"]>): Promise<Awaited<ReturnType<ImageGenerationCoreAuthRuntimeModule["resolveApiKeyForProvider"]>>>;
+//#endregion
+export { resolveApiKeyForProvider as n, parseImageGenerationModelRef as r, OPENAI_DEFAULT_IMAGE_MODEL as t };

package/dist/image-generation-provider-BWHW-NSu.d.ts

@@ -0,0 +1,6 @@
+import { l as ImageGenerationProvider } from "./types-Eyi3LpQY.js";
+//#region extensions/minimax/image-generation-provider.d.ts
+declare function buildMinimaxImageGenerationProvider(): ImageGenerationProvider;
+declare function buildMinimaxPortalImageGenerationProvider(): ImageGenerationProvider;
+//#endregion
+export { buildMinimaxPortalImageGenerationProvider as n, buildMinimaxImageGenerationProvider as t };

package/dist/image-generation-provider-C-SH6lhI.d.ts

@@ -0,0 +1,5 @@
+import { l as ImageGenerationProvider } from "./types-Eyi3LpQY.js";
+//#region extensions/xai/image-generation-provider.d.ts
+declare function buildXaiImageGenerationProvider(): ImageGenerationProvider;
+//#endregion
+export { buildXaiImageGenerationProvider as t };

package/dist/image-generation-provider-CT4sTPDK.d.ts

@@ -0,0 +1,5 @@
+import { l as ImageGenerationProvider } from "./types-Eyi3LpQY.js";
+//#region extensions/deepinfra/image-generation-provider.d.ts
+declare function buildDeepInfraImageGenerationProvider(): ImageGenerationProvider;
+//#endregion
+export { buildDeepInfraImageGenerationProvider as t };

package/dist/image-generation-provider-D0us44L1.d.ts

@@ -0,0 +1,5 @@
+import { l as ImageGenerationProvider } from "./types-Eyi3LpQY.js";
+//#region extensions/google/image-generation-provider.d.ts
+declare function buildGoogleImageGenerationProvider(): ImageGenerationProvider;
+//#endregion
+export { buildGoogleImageGenerationProvider as t };

package/dist/image-generation-provider-DON9vqk0.d.ts

@@ -0,0 +1,7 @@
+import { l as ImageGenerationProvider } from "./types-Eyi3LpQY.js";
+import { a as fetchWithSsrFGuard } from "./fetch-guard-BgaCy73h.js";
+//#region extensions/fal/image-generation-provider.d.ts
+declare function setFalFetchGuardForTesting(impl: typeof fetchWithSsrFGuard | null): void;
+declare function buildFalImageGenerationProvider(): ImageGenerationProvider;
+//#endregion
+export { setFalFetchGuardForTesting as n, buildFalImageGenerationProvider as t };

package/dist/image-generation-provider-D_noUV6o.d.ts

@@ -0,0 +1,5 @@
+import { l as ImageGenerationProvider } from "./types-Eyi3LpQY.js";
+//#region extensions/openai/image-generation-provider.d.ts
+declare function buildOpenAIImageGenerationProvider(): ImageGenerationProvider;
+//#endregion
+export { buildOpenAIImageGenerationProvider as t };

package/dist/image-generation-provider-Uu25bryr.d.ts

@@ -0,0 +1,8 @@
+import { l as ImageGenerationProvider, t as GeneratedImageAsset } from "./types-Eyi3LpQY.js";
+//#region extensions/openrouter/image-generation-provider.d.ts
+declare function extractOpenRouterImagesFromResponse(body: unknown, options?: {
+  malformedResponseError?: string;
+}): GeneratedImageAsset[];
+declare function buildOpenRouterImageGenerationProvider(): ImageGenerationProvider;
+//#endregion
+export { extractOpenRouterImagesFromResponse as n, buildOpenRouterImageGenerationProvider as t };

package/dist/image-generation-runtime-rWbw4OxA.d.ts

@@ -0,0 +1,21 @@
+import { r as DaoCoreConfig } from "./types.daocore-FLA7MxtO.js";
+import { X as GenerateImageParams, Z as GenerateImageRuntimeResult } from "./types-core-7ot658WI.js";
+import { l as ImageGenerationProvider } from "./types-Eyi3LpQY.js";
+import { t as SubsystemLogger } from "./subsystem-Ce5qcC5n.js";
+import { n as getProviderEnvVars } from "./provider-env-vars-zmApfelv.js";
+import { n as listImageGenerationProviders, t as getImageGenerationProvider } from "./provider-registry-HS0nOu4d.js";
+
+//#region src/image-generation/runtime.d.ts
+declare const log: SubsystemLogger;
+type ImageGenerationRuntimeDeps = {
+  getProvider?: typeof getImageGenerationProvider;
+  listProviders?: typeof listImageGenerationProviders;
+  getProviderEnvVars?: typeof getProviderEnvVars;
+  log?: Pick<typeof log, "warn">;
+};
+declare function listRuntimeImageGenerationProviders(params?: {
+  config?: DaoCoreConfig;
+}, deps?: ImageGenerationRuntimeDeps): ImageGenerationProvider[];
+declare function generateImage(params: GenerateImageParams, deps?: ImageGenerationRuntimeDeps): Promise<GenerateImageRuntimeResult>;
+//#endregion
+export { listRuntimeImageGenerationProviders as n, generateImage as t };

package/dist/image-runtime-DNdHCakl.d.ts

@@ -0,0 +1,9 @@
+import { i as ImageDescriptionResult, o as ImagesDescriptionRequest, r as ImageDescriptionRequest, s as ImagesDescriptionResult } from "./types-Bxd589-v.js";
+
+//#region src/media-understanding/image-runtime.d.ts
+declare const describeImageWithModel: (params: ImageDescriptionRequest) => Promise<ImageDescriptionResult>;
+declare const describeImagesWithModel: (params: ImagesDescriptionRequest) => Promise<ImagesDescriptionResult>;
+declare const describeImageWithModelPayloadTransform: (params: ImageDescriptionRequest, onPayload: ((payload: unknown, model: import("@earendil-works/pi-ai").Model<import("@earendil-works/pi-ai").Api>) => unknown | undefined | Promise<unknown | undefined>) | undefined) => Promise<ImageDescriptionResult>;
+declare const describeImagesWithModelPayloadTransform: (params: ImagesDescriptionRequest, onPayload: ((payload: unknown, model: import("@earendil-works/pi-ai").Model<import("@earendil-works/pi-ai").Api>) => unknown | undefined | Promise<unknown | undefined>) | undefined) => Promise<ImagesDescriptionResult>;
+//#endregion
+export { describeImagesWithModelPayloadTransform as i, describeImageWithModelPayloadTransform as n, describeImagesWithModel as r, describeImageWithModel as t };

package/dist/inbound-context-C4NsPoBr.d.ts

@@ -0,0 +1,12 @@
+import { t as FinalizedMsgContext } from "./templating-BEHZ8n6P.js";
+
+//#region src/auto-reply/reply/inbound-context.d.ts
+type FinalizeInboundContextOptions = {
+  forceBodyForAgent?: boolean;
+  forceBodyForCommands?: boolean;
+  forceChatType?: boolean;
+  forceConversationLabel?: boolean;
+};
+declare function finalizeInboundContext<T extends Record<string, unknown>>(ctx: T, opts?: FinalizeInboundContextOptions): T & FinalizedMsgContext;
+//#endregion
+export { finalizeInboundContext as t };

package/dist/inbound-debounce-BZJ_qKmp.d.ts

@@ -0,0 +1,26 @@
+import { r as DaoCoreConfig } from "./types.daocore-FLA7MxtO.js";
+
+//#region src/auto-reply/inbound-debounce.d.ts
+declare function resolveInboundDebounceMs(params: {
+  cfg: DaoCoreConfig;
+  channel: string;
+  overrideMs?: number;
+}): number;
+type InboundDebounceCreateParams<T> = {
+  debounceMs: number;
+  maxTrackedKeys?: number;
+  buildKey: (item: T) => string | null | undefined;
+  shouldDebounce?: (item: T) => boolean;
+  resolveDebounceMs?: (item: T) => number | undefined;
+  serializeImmediate?: boolean;
+  onFlush: (items: T[]) => Promise<void>;
+  onError?: (err: unknown, items: T[]) => void;
+  onCancel?: (items: T[]) => void;
+};
+declare function createInboundDebouncer<T>(params: InboundDebounceCreateParams<T>): {
+  enqueue: (item: T) => Promise<void>;
+  flushKey: (key: string) => Promise<void>;
+  cancelKey: (key: string) => boolean;
+};
+//#endregion
+export { createInboundDebouncer as n, resolveInboundDebounceMs as r, InboundDebounceCreateParams as t };

package/dist/inbound-reply-dispatch-BVqoxwfH.d.ts

@@ -0,0 +1,137 @@
+import { r as DaoCoreConfig } from "./types.daocore-FLA7MxtO.js";
+import { n as GetReplyOptions } from "./get-reply-options.types-BXrapyJ-.js";
+import { t as FinalizedMsgContext } from "./templating-BEHZ8n6P.js";
+import { t as OutboundReplyPayload } from "./reply-payload-yCW2N7tu.js";
+import { n as ReplyDispatcher } from "./reply-dispatcher.types-DxImExDW.js";
+import { t as DispatchFromConfigResult } from "./dispatch-from-config.types-DVmSJ0p0.js";
+import { t as DispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher.types-CaRT5X49.js";
+import { F as recordChannelBotPairLoopAndCheckSuppression, M as ChannelBotLoopProtectionFacts, O as RunChannelTurnParams, T as PreparedChannelTurn, _ as ChannelTurnResult, b as DispatchedChannelTurnResult, d as ChannelTurnDroppedHistoryOptions, m as ChannelTurnRecordOptions } from "./types-BH-ggYY0.js";
+import { c as DurableInboundReplyDeliveryParams, r as recordDroppedChannelTurnHistory, s as DurableInboundReplyDeliveryOptions, u as deliverInboundReplyWithMessageSendContext } from "./kernel-C1dSnZtC.js";
+import { a as hasVisibleChannelTurnDispatch, i as hasFinalChannelTurnDispatch, o as resolveChannelTurnDispatchCounts } from "./dispatch-result-CP3niup-.js";
+import { t as recordInboundSession } from "./session-Ducyk2dS.js";
+
+//#region src/plugin-sdk/inbound-reply-dispatch.d.ts
+declare namespace inbound_reply_dispatch_d_exports {
+  export { ChannelBotLoopProtectionFacts, ChannelTurnDroppedHistoryOptions, ChannelTurnRecordOptions, DurableInboundReplyDeliveryParams, buildChannelMessageReplyDispatchBase, buildInboundReplyDispatchBase, deliverInboundReplyWithMessageSendContext as deliverDurableInboundReplyPayload, deliverInboundReplyWithMessageSendContext, dispatchChannelMessageReplyWithBase, dispatchInboundReplyWithBase, dispatchReplyFromConfigWithSettledDispatcher, hasFinalChannelMessageReplyDispatch, hasFinalChannelTurnDispatch as hasFinalInboundReplyDispatch, hasVisibleChannelMessageReplyDispatch, hasVisibleChannelTurnDispatch as hasVisibleInboundReplyDispatch, recordChannelBotPairLoopAndCheckSuppression, recordChannelMessageReplyDispatch, recordDroppedChannelTurnHistory, recordInboundSessionAndDispatchReply, resolveChannelMessageReplyDispatchCounts, resolveChannelTurnDispatchCounts as resolveInboundReplyDispatchCounts, runInboundReplyTurn, runPreparedInboundReplyTurn };
+}
+type ReplyOptionsWithoutModelSelected = Omit<Omit<GetReplyOptions, "onBlockReply">, "onModelSelected">;
+type RecordInboundSessionFn = typeof recordInboundSession;
+type ReplyDispatchFromConfigOptions = Omit<GetReplyOptions, "onBlockReply">;
+/** Run an already assembled channel turn through shared session-record + dispatch ordering. */
+type PreparedInboundReplyTurnWithBotLoopProtection<TDispatchResult> = PreparedChannelTurn<TDispatchResult> & {
+  botLoopProtection: NonNullable<PreparedChannelTurn<TDispatchResult>["botLoopProtection"]>;
+};
+type PreparedInboundReplyTurnWithoutBotLoopProtection<TDispatchResult> = Omit<PreparedChannelTurn<TDispatchResult>, "botLoopProtection"> & {
+  botLoopProtection?: undefined;
+};
+declare function runPreparedInboundReplyTurn<TDispatchResult>(params: PreparedInboundReplyTurnWithBotLoopProtection<TDispatchResult>): Promise<ChannelTurnResult<TDispatchResult>>;
+declare function runPreparedInboundReplyTurn<TDispatchResult>(params: PreparedInboundReplyTurnWithoutBotLoopProtection<TDispatchResult>): Promise<DispatchedChannelTurnResult<TDispatchResult>>;
+declare function runPreparedInboundReplyTurn<TDispatchResult>(params: PreparedChannelTurn<TDispatchResult>): Promise<ChannelTurnResult<TDispatchResult>>;
+/** Run a channel turn through shared ingest, record, dispatch, and finalize ordering. */
+declare function runInboundReplyTurn<TRaw, TDispatchResult = DispatchFromConfigResult>(params: RunChannelTurnParams<TRaw, TDispatchResult>): Promise<ChannelTurnResult<TDispatchResult>>;
+/** Run `dispatchReplyFromConfig` with a dispatcher that always gets its settled callback. */
+declare function dispatchReplyFromConfigWithSettledDispatcher(params: {
+  cfg: DaoCoreConfig;
+  ctxPayload: FinalizedMsgContext;
+  dispatcher: ReplyDispatcher;
+  onSettled: () => void | Promise<void>;
+  replyOptions?: ReplyDispatchFromConfigOptions;
+  configOverride?: DaoCoreConfig;
+}): Promise<DispatchFromConfigResult>;
+/** Assemble the common inbound reply dispatch dependencies for a resolved route. */
+declare function buildInboundReplyDispatchBase(params: {
+  cfg: DaoCoreConfig;
+  channel: string;
+  accountId?: string;
+  route: {
+    agentId: string;
+    sessionKey: string;
+  };
+  storePath: string;
+  ctxPayload: FinalizedMsgContext;
+  core: {
+    channel: {
+      session: {
+        recordInboundSession: RecordInboundSessionFn;
+      };
+      reply: {
+        dispatchReplyWithBufferedBlockDispatcher: DispatchReplyWithBufferedBlockDispatcher;
+      };
+    };
+  };
+}): {
+  cfg: DaoCoreConfig;
+  channel: string;
+  accountId: string | undefined;
+  agentId: string;
+  routeSessionKey: string;
+  storePath: string;
+  ctxPayload: FinalizedMsgContext;
+  recordInboundSession: typeof recordInboundSession;
+  dispatchReplyWithBufferedBlockDispatcher: DispatchReplyWithBufferedBlockDispatcher;
+};
+type BuildInboundReplyDispatchBaseParams = Parameters<typeof buildInboundReplyDispatchBase>[0];
+type RecordChannelMessageReplyDispatchParams = {
+  cfg: DaoCoreConfig;
+  channel: string;
+  accountId?: string;
+  agentId: string;
+  routeSessionKey: string;
+  storePath: string;
+  ctxPayload: FinalizedMsgContext;
+  recordInboundSession: RecordInboundSessionFn;
+  dispatchReplyWithBufferedBlockDispatcher: DispatchReplyWithBufferedBlockDispatcher;
+  deliver: (payload: OutboundReplyPayload) => Promise<void>;
+  durable?: false | DurableInboundReplyDeliveryOptions;
+  onRecordError: (err: unknown) => void;
+  onDispatchError: (err: unknown, info: {
+    kind: string;
+  }) => void;
+  replyOptions?: ReplyOptionsWithoutModelSelected;
+};
+/**
+ * Resolve the shared dispatch base and immediately record + dispatch one inbound reply turn.
+ *
+ * @deprecated Compatibility reply-dispatch bridge. New channel plugins should
+ * expose a `message` adapter via `defineChannelMessageAdapter(...)` and route
+ * sends through `deliverInboundReplyWithMessageSendContext(...)` or
+ * `sendDurableMessageBatch(...)`.
+ */
+declare function dispatchChannelMessageReplyWithBase(params: BuildInboundReplyDispatchBaseParams & Pick<RecordChannelMessageReplyDispatchParams, "deliver" | "durable" | "onRecordError" | "onDispatchError" | "replyOptions">): Promise<void>;
+/**
+ * Resolve the shared dispatch base and immediately record + dispatch one inbound reply turn.
+ *
+ * @deprecated Legacy inbound reply helper. New channel plugins should expose a
+ * `message` adapter via `defineChannelMessageAdapter(...)` and use
+ * `dispatchChannelMessageReplyWithBase` only for compatibility dispatchers that
+ * have not moved to the message lifecycle yet.
+ */
+declare function dispatchInboundReplyWithBase(params: Parameters<typeof dispatchChannelMessageReplyWithBase>[0]): Promise<void>;
+/**
+ * Record the inbound session first, then dispatch the reply using normalized outbound delivery.
+ *
+ * @deprecated Compatibility reply-dispatch bridge. New channel plugins should
+ * expose a `message` adapter via `defineChannelMessageAdapter(...)` and route
+ * sends through `deliverInboundReplyWithMessageSendContext(...)` or
+ * `sendDurableMessageBatch(...)`.
+ */
+declare function recordChannelMessageReplyDispatch(params: RecordChannelMessageReplyDispatchParams): Promise<void>;
+/**
+ * Record the inbound session first, then dispatch the reply using normalized outbound delivery.
+ *
+ * @deprecated Legacy inbound reply helper. New channel plugins should expose a
+ * `message` adapter via `defineChannelMessageAdapter(...)` and use
+ * `recordChannelMessageReplyDispatch` only for compatibility dispatchers that
+ * have not moved to the message lifecycle yet.
+ */
+declare function recordInboundSessionAndDispatchReply(params: RecordChannelMessageReplyDispatchParams): Promise<void>;
+/** @deprecated Compatibility helper for legacy reply dispatch bridges. */
+declare const buildChannelMessageReplyDispatchBase: typeof buildInboundReplyDispatchBase;
+/** @deprecated Compatibility helper for legacy reply dispatch results. */
+declare const hasFinalChannelMessageReplyDispatch: typeof hasFinalChannelTurnDispatch;
+/** @deprecated Compatibility helper for legacy reply dispatch results. */
+declare const hasVisibleChannelMessageReplyDispatch: typeof hasVisibleChannelTurnDispatch;
+/** @deprecated Compatibility helper for legacy reply dispatch results. */
+declare const resolveChannelMessageReplyDispatchCounts: typeof resolveChannelTurnDispatchCounts;
+//#endregion
+export { dispatchReplyFromConfigWithSettledDispatcher as a, inbound_reply_dispatch_d_exports as c, resolveChannelMessageReplyDispatchCounts as d, runInboundReplyTurn as f, dispatchInboundReplyWithBase as i, recordChannelMessageReplyDispatch as l, buildInboundReplyDispatchBase as n, hasFinalChannelMessageReplyDispatch as o, runPreparedInboundReplyTurn as p, dispatchChannelMessageReplyWithBase as r, hasVisibleChannelMessageReplyDispatch as s, buildChannelMessageReplyDispatchBase as t, recordInboundSessionAndDispatchReply as u };