@gaodefa/daocore 2026.5.69 → 2026.5.70

package/dist/types.public-DuFOa-9T.d.ts

@@ -0,0 +1,70 @@
+import { n as ChannelConfigSchema } from "./types.config-CKJTcS4X.js";
+import { t as ChannelId } from "./channel-id.types-ClK6B_QE.js";
+import { n as ChannelMessageAdapterShape } from "./types-CYvxspyL.js";
+import { n as ChannelOutboundAdapter } from "./outbound.types-B2wXms-j.js";
+import { E as ChannelMeta, I as ChannelStreamingAdapter, K as ChannelMessageActionName$1, R as ChannelThreadingAdapter, T as ChannelMessagingAdapter, a as ChannelAgentPromptAdapter, c as ChannelCapabilities, o as ChannelAgentTool, s as ChannelAgentToolFactory, v as ChannelMentionAdapter, y as ChannelMessageActionAdapter } from "./types.core-DpVp9PoP.js";
+import { c as ChannelSetupWizardAdapter, s as ChannelSetupWizard } from "./setup-wizard-types-CDmi5gLx.js";
+import { A as ChannelGroupAdapter, B as ChannelSecretsAdapter, D as ChannelElevatedAdapter, H as ChannelSetupAdapter, M as ChannelLifecycleAdapter, O as ChannelGatewayAdapter, S as ChannelDoctorAdapter, U as ChannelStatusAdapter, V as ChannelSecurityAdapter, b as ChannelConversationBindingSupport, g as ChannelConfigAdapter, i as ChannelApprovalCapability, j as ChannelHeartbeatAdapter, m as ChannelCommandAdapter, n as ChannelAllowlistAdapter, u as ChannelAuthAdapter, x as ChannelDirectoryAdapter, y as ChannelConfiguredBindingProvider, z as ChannelResolverAdapter } from "./types.adapters-StiSC8e-.js";
+import { Go as OperatorScope } from "./index-BKUhFJMP.js";
+import { t as ChannelPairingAdapter } from "./pairing.types-CQONFSHw.js";
+
+//#region src/channels/plugins/types.plugin.d.ts
+/** Full capability contract for a native channel plugin. */
+type ChannelPluginSetupWizard = ChannelSetupWizard | ChannelSetupWizardAdapter;
+type ChannelGatewayMethodDescriptor = {
+  name: string;
+  scope?: OperatorScope;
+  description?: string;
+};
+type ChannelPlugin<ResolvedAccount = any, Probe = unknown, Audit = unknown> = {
+  id: ChannelId;
+  meta: ChannelMeta;
+  capabilities: ChannelCapabilities;
+  defaults?: {
+    queue?: {
+      debounceMs?: number;
+    };
+  };
+  reload?: {
+    configPrefixes: string[];
+    noopPrefixes?: string[];
+  };
+  setupWizard?: ChannelPluginSetupWizard;
+  config: ChannelConfigAdapter<ResolvedAccount>;
+  configSchema?: ChannelConfigSchema;
+  setup?: ChannelSetupAdapter;
+  pairing?: ChannelPairingAdapter;
+  security?: ChannelSecurityAdapter<ResolvedAccount>;
+  groups?: ChannelGroupAdapter;
+  mentions?: ChannelMentionAdapter;
+  outbound?: ChannelOutboundAdapter;
+  status?: ChannelStatusAdapter<ResolvedAccount, Probe, Audit>;
+  gatewayMethods?: string[];
+  gatewayMethodDescriptors?: ChannelGatewayMethodDescriptor[];
+  gateway?: ChannelGatewayAdapter<ResolvedAccount>;
+  auth?: ChannelAuthAdapter;
+  approvalCapability?: ChannelApprovalCapability;
+  elevated?: ChannelElevatedAdapter;
+  commands?: ChannelCommandAdapter;
+  lifecycle?: ChannelLifecycleAdapter;
+  secrets?: ChannelSecretsAdapter;
+  allowlist?: ChannelAllowlistAdapter;
+  doctor?: ChannelDoctorAdapter;
+  bindings?: ChannelConfiguredBindingProvider;
+  conversationBindings?: ChannelConversationBindingSupport;
+  streaming?: ChannelStreamingAdapter;
+  threading?: ChannelThreadingAdapter;
+  message?: ChannelMessageAdapterShape;
+  messaging?: ChannelMessagingAdapter;
+  agentPrompt?: ChannelAgentPromptAdapter;
+  directory?: ChannelDirectoryAdapter;
+  resolver?: ChannelResolverAdapter;
+  actions?: ChannelMessageActionAdapter;
+  heartbeat?: ChannelHeartbeatAdapter;
+  agentTools?: ChannelAgentToolFactory | ChannelAgentTool[];
+};
+//#endregion
+//#region src/channels/plugins/types.public.d.ts
+type ChannelMessageActionName = ChannelMessageActionName$1;
+//#endregion
+export { ChannelPlugin as n, ChannelMessageActionName as t };

package/dist/unhandled-rejections-DQRrM2pr.d.ts

@@ -0,0 +1,38 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { n as LogLevel } from "./levels-561AeL30.js";
+import { m as ConsoleStyle } from "./logger-Byn12s5D.js";
+
+//#region src/logging/console.d.ts
+type ConsoleSettings = {
+  level: LogLevel;
+  style: ConsoleStyle;
+};
+type ConsoleLoggerSettings = ConsoleSettings;
+type ConsoleConfigLoader = () => DaoCoreConfig["logging"] | undefined;
+declare function setConsoleConfigLoaderForTests(loader?: ConsoleConfigLoader): void;
+declare function getConsoleSettings(): ConsoleLoggerSettings;
+declare function getResolvedConsoleSettings(): ConsoleLoggerSettings;
+declare function routeLogsToStderr(): void;
+declare function setConsoleSubsystemFilter(filters?: string[] | null): void;
+declare function setConsoleTimestampPrefix(enabled: boolean): void;
+declare function shouldLogSubsystemToConsole(subsystem?: string | null): boolean;
+/**
+ * Route console.* calls through file logging while still emitting to stdout/stderr.
+ * This keeps user-facing output unchanged but guarantees every console call is captured in log files.
+ */
+declare function enableConsoleCapture(): void;
+//#endregion
+//#region src/infra/abort-signal.d.ts
+declare function waitForAbortSignal(signal?: AbortSignal): Promise<void>;
+//#endregion
+//#region src/infra/unhandled-rejections.d.ts
+type UnhandledRejectionHandler = (reason: unknown) => boolean;
+type UncaughtExceptionHandler = (error: unknown) => boolean;
+/**
+ * Checks if an error is an AbortError.
+ * These are typically intentional cancellations (e.g., during shutdown) and shouldn't crash.
+ */
+declare function registerUnhandledRejectionHandler(handler: UnhandledRejectionHandler): () => void;
+declare function registerUncaughtExceptionHandler(handler: UncaughtExceptionHandler): () => void;
+//#endregion
+export { enableConsoleCapture as a, routeLogsToStderr as c, setConsoleTimestampPrefix as d, shouldLogSubsystemToConsole as f, ConsoleLoggerSettings as i, setConsoleConfigLoaderForTests as l, registerUnhandledRejectionHandler as n, getConsoleSettings as o, waitForAbortSignal as r, getResolvedConsoleSettings as s, registerUncaughtExceptionHandler as t, setConsoleSubsystemFilter as u };

package/dist/uninstall-DYQbVeL8.d.ts

@@ -0,0 +1,45 @@
+import { p as PluginInstallRecord, r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+
+//#region src/infra/plugin-install-path-warnings.d.ts
+type PluginInstallPathIssue = {
+  kind: "custom-path" | "missing-path";
+  pluginId: string;
+  path: string;
+};
+declare function detectPluginInstallPathIssue(params: {
+  pluginId: string;
+  install: PluginInstallRecord | null | undefined;
+}): Promise<PluginInstallPathIssue | null>;
+declare function formatPluginInstallPathIssue(params: {
+  issue: PluginInstallPathIssue;
+  pluginLabel: string;
+  defaultInstallCommand: string;
+  repoInstallCommand?: string | null;
+  formatCommand?: (command: string) => string;
+}): string[];
+//#endregion
+//#region src/plugins/uninstall.d.ts
+type UninstallActions = {
+  entry: boolean;
+  install: boolean;
+  allowlist: boolean;
+  denylist: boolean;
+  loadPath: boolean;
+  memorySlot: boolean;
+  contextEngineSlot: boolean;
+  channelConfig: boolean;
+  directory: boolean;
+};
+/**
+ * Remove plugin references from config (pure config mutation).
+ * Returns a new config with the plugin removed from entries, installs, allow, load.paths, slots,
+ * and owned channel config.
+ */
+declare function removePluginFromConfig(cfg: DaoCoreConfig, pluginId: string, opts?: {
+  channelIds?: string[];
+}): {
+  config: DaoCoreConfig;
+  actions: Omit<UninstallActions, "directory">;
+};
+//#endregion
+export { detectPluginInstallPathIssue as n, formatPluginInstallPathIssue as r, removePluginFromConfig as t };

package/dist/video-generation-DQUbmDnh.d.ts

@@ -0,0 +1,223 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { s as AuthProfileStore } from "./types-dSHooml1.js";
+import { f as VideoGenerationResult$1, p as VideoGenerationSourceAsset$1, t as GeneratedVideoAsset$1, u as VideoGenerationRequest$1 } from "./types-DRM6itxh.js";
+import { n as ProviderOperationTimeoutMs, u as postJsonRequest } from "./provider-http-DPk9wy5-.js";
+
+//#region src/video-generation/dashscope-compatible.d.ts
+declare const DEFAULT_DASHSCOPE_WAN_VIDEO_MODEL = "wan2.6-t2v";
+declare const DASHSCOPE_WAN_VIDEO_MODELS: string[];
+declare const DASHSCOPE_WAN_VIDEO_CAPABILITIES: {
+  generate: {
+    maxVideos: number;
+    maxDurationSeconds: number;
+    supportsSize: true;
+    supportsAspectRatio: true;
+    supportsResolution: true;
+    supportsAudio: true;
+    supportsWatermark: true;
+  };
+  imageToVideo: {
+    enabled: true;
+    maxVideos: number;
+    maxInputImages: number;
+    maxDurationSeconds: number;
+    supportsSize: true;
+    supportsAspectRatio: true;
+    supportsResolution: true;
+    supportsAudio: true;
+    supportsWatermark: true;
+  };
+  videoToVideo: {
+    enabled: true;
+    maxVideos: number;
+    maxInputVideos: number;
+    maxDurationSeconds: number;
+    supportsSize: true;
+    supportsAspectRatio: true;
+    supportsResolution: true;
+    supportsAudio: true;
+    supportsWatermark: true;
+  };
+};
+declare const DEFAULT_VIDEO_GENERATION_DURATION_SECONDS = 5;
+declare const DEFAULT_VIDEO_GENERATION_TIMEOUT_MS = 120000;
+declare const DEFAULT_VIDEO_RESOLUTION_TO_SIZE: Record<string, string>;
+type DashscopeVideoGenerationResponse = {
+  output?: {
+    task_id?: string;
+    task_status?: string;
+    submit_time?: string;
+    results?: Array<{
+      video_url?: string;
+      orig_prompt?: string;
+      actual_prompt?: string;
+    }>;
+    video_url?: string;
+    code?: string;
+    message?: string;
+  };
+  request_id?: string;
+  code?: string;
+  message?: string;
+};
+declare function buildDashscopeVideoGenerationInput(params: {
+  providerLabel: string;
+  req: VideoGenerationRequest$1;
+}): Record<string, unknown>;
+declare function resolveVideoGenerationReferenceUrls(inputImages: VideoGenerationSourceAsset$1[] | undefined, inputVideos: VideoGenerationSourceAsset$1[] | undefined): string[];
+declare function buildDashscopeVideoGenerationParameters(req: VideoGenerationRequest$1, resolutionToSize?: Record<string, string>): Record<string, unknown> | undefined;
+declare function extractDashscopeVideoUrls(payload: DashscopeVideoGenerationResponse): string[];
+declare function pollDashscopeVideoTaskUntilComplete(params: {
+  providerLabel: string;
+  taskId: string;
+  headers: Headers;
+  timeoutMs?: number;
+  fetchFn: typeof fetch;
+  baseUrl: string;
+  defaultTimeoutMs?: number;
+}): Promise<DashscopeVideoGenerationResponse>;
+declare function runDashscopeVideoGenerationTask(params: {
+  providerLabel: string;
+  model: string;
+  req: VideoGenerationRequest$1;
+  url: string;
+  headers: Headers;
+  baseUrl: string;
+  timeoutMs?: number;
+  fetchFn: typeof fetch;
+  allowPrivateNetwork?: boolean;
+  dispatcherPolicy?: Parameters<typeof postJsonRequest>[0]["dispatcherPolicy"];
+  defaultTimeoutMs?: number;
+}): Promise<VideoGenerationResult$1>;
+declare function downloadDashscopeGeneratedVideos(params: {
+  providerLabel: string;
+  urls: string[];
+  timeoutMs?: ProviderOperationTimeoutMs;
+  fetchFn: typeof fetch;
+  defaultTimeoutMs?: number;
+}): Promise<GeneratedVideoAsset$1[]>;
+//#endregion
+//#region src/plugin-sdk/video-generation.d.ts
+type GeneratedVideoAsset = {
+  /** Raw video bytes. Either buffer or url must be present. */buffer?: Buffer;
+  /** Pre-signed or provider-hosted URL for the video. When set and buffer is
+   * absent, callers can deliver or download the asset without requiring the
+   * provider to materialize the full file in memory first. */
+  url?: string;
+  mimeType: string;
+  fileName?: string;
+  metadata?: Record<string, unknown>;
+};
+type VideoGenerationResolution = "480P" | "720P" | "768P" | "1080P" | (string & {});
+/**
+ * Canonical semantic role hints for reference assets (first/last frame,
+ * reference image/video/audio). Providers may accept additional role strings;
+ * the asset.role type accepts both canonical values and arbitrary strings.
+ */
+type VideoGenerationAssetRole = "first_frame" | "last_frame" | "reference_image" | "reference_video" | "reference_audio";
+type VideoGenerationSourceAsset = {
+  url?: string;
+  buffer?: Buffer;
+  mimeType?: string;
+  fileName?: string;
+  /**
+   * Optional semantic role hint forwarded to the provider. Canonical values
+   * come from `VideoGenerationAssetRole`; plain strings are accepted for
+   * provider-specific extensions.
+   */
+  role?: VideoGenerationAssetRole | (string & {});
+  metadata?: Record<string, unknown>;
+};
+type VideoGenerationProviderConfiguredContext = {
+  cfg?: DaoCoreConfig;
+  agentDir?: string;
+};
+type VideoGenerationModelCapabilitiesContext = {
+  provider: string;
+  model: string;
+  cfg: DaoCoreConfig;
+  agentDir?: string;
+  authStore?: AuthProfileStore;
+  timeoutMs?: number;
+};
+type VideoGenerationRequest = {
+  provider: string;
+  model: string;
+  prompt: string;
+  cfg: DaoCoreConfig;
+  agentDir?: string;
+  authStore?: AuthProfileStore;
+  timeoutMs?: number;
+  size?: string;
+  aspectRatio?: string;
+  resolution?: VideoGenerationResolution;
+  durationSeconds?: number;
+  audio?: boolean;
+  watermark?: boolean;
+  inputImages?: VideoGenerationSourceAsset[];
+  inputVideos?: VideoGenerationSourceAsset[]; /** Reference audio assets (e.g. background music) forwarded to the provider. */
+  inputAudios?: VideoGenerationSourceAsset[]; /** Arbitrary provider-specific parameters forwarded as-is (e.g. seed, draft, camerafixed). */
+  providerOptions?: Record<string, unknown>;
+};
+type VideoGenerationResult = {
+  videos: GeneratedVideoAsset[];
+  model?: string;
+  metadata?: Record<string, unknown>;
+};
+type VideoGenerationMode = "generate" | "imageToVideo" | "videoToVideo";
+/**
+ * Primitive type tag for a declared `providerOptions` key. Keep narrow —
+ * plugins that need richer shapes should leave them out of the typed contract
+ * and interpret the forwarded opaque value inside their own provider code.
+ */
+type VideoGenerationProviderOptionType = "number" | "boolean" | "string";
+type VideoGenerationModeCapabilities = {
+  maxVideos?: number;
+  maxInputImages?: number;
+  maxInputImagesByModel?: Readonly<Record<string, number>>;
+  maxInputVideos?: number;
+  maxInputVideosByModel?: Readonly<Record<string, number>>; /** Max number of reference audio assets the provider accepts (e.g. background music, voice reference). */
+  maxInputAudios?: number;
+  maxInputAudiosByModel?: Readonly<Record<string, number>>;
+  maxDurationSeconds?: number;
+  supportedDurationSeconds?: readonly number[];
+  supportedDurationSecondsByModel?: Readonly<Record<string, readonly number[]>>;
+  sizes?: readonly string[];
+  aspectRatios?: readonly string[];
+  resolutions?: readonly VideoGenerationResolution[];
+  supportsSize?: boolean;
+  supportsAspectRatio?: boolean;
+  supportsResolution?: boolean;
+  supportsAudio?: boolean;
+  supportsWatermark?: boolean;
+  /**
+   * Declared typed schema for `VideoGenerationRequest.providerOptions`. Keys
+   * listed here are accepted and validated against the declared primitive
+   * type before forwarding; unknown keys or type mismatches skip the
+   * candidate provider at runtime so mis-typed or provider-specific options
+   * never silently reach the wrong provider.
+   */
+  providerOptions?: Readonly<Record<string, VideoGenerationProviderOptionType>>;
+};
+type VideoGenerationTransformCapabilities = VideoGenerationModeCapabilities & {
+  enabled: boolean;
+};
+type VideoGenerationProviderCapabilities = VideoGenerationModeCapabilities & {
+  generate?: VideoGenerationModeCapabilities;
+  imageToVideo?: VideoGenerationTransformCapabilities;
+  videoToVideo?: VideoGenerationTransformCapabilities;
+};
+type VideoGenerationProvider = {
+  id: string;
+  aliases?: string[];
+  label?: string;
+  defaultModel?: string; /** Default provider operation timeout in milliseconds when caller/config omit timeoutMs. */
+  defaultTimeoutMs?: number;
+  models?: string[];
+  capabilities: VideoGenerationProviderCapabilities;
+  isConfigured?: (ctx: VideoGenerationProviderConfiguredContext) => boolean;
+  resolveModelCapabilities?: (ctx: VideoGenerationModelCapabilitiesContext) => VideoGenerationProviderCapabilities | undefined | Promise<VideoGenerationProviderCapabilities | undefined>;
+  generateVideo: (req: VideoGenerationRequest) => Promise<VideoGenerationResult>;
+};
+//#endregion
+export { buildDashscopeVideoGenerationParameters as C, resolveVideoGenerationReferenceUrls as D, pollDashscopeVideoTaskUntilComplete as E, runDashscopeVideoGenerationTask as O, buildDashscopeVideoGenerationInput as S, extractDashscopeVideoUrls as T, DEFAULT_DASHSCOPE_WAN_VIDEO_MODEL as _, VideoGenerationModelCapabilitiesContext as a, DEFAULT_VIDEO_RESOLUTION_TO_SIZE as b, VideoGenerationProviderConfiguredContext as c, VideoGenerationResolution as d, VideoGenerationResult as f, DASHSCOPE_WAN_VIDEO_MODELS as g, DASHSCOPE_WAN_VIDEO_CAPABILITIES as h, VideoGenerationModeCapabilities as i, VideoGenerationProviderOptionType as l, VideoGenerationTransformCapabilities as m, VideoGenerationAssetRole as n, VideoGenerationProvider as o, VideoGenerationSourceAsset as p, VideoGenerationMode as r, VideoGenerationProviderCapabilities as s, GeneratedVideoAsset as t, VideoGenerationRequest as u, DEFAULT_VIDEO_GENERATION_DURATION_SECONDS as v, downloadDashscopeGeneratedVideos as w, DashscopeVideoGenerationResponse as x, DEFAULT_VIDEO_GENERATION_TIMEOUT_MS as y };

package/dist/video-generation-provider-AeUe21Sx.d.ts

@@ -0,0 +1,6 @@
+import { o as VideoGenerationProvider } from "./video-generation-DQUbmDnh.js";
+
+//#region extensions/google/video-generation-provider.d.ts
+declare function buildGoogleVideoGenerationProvider(): VideoGenerationProvider;
+//#endregion
+export { buildGoogleVideoGenerationProvider as t };

package/dist/video-generation-provider-D8xQ418F.d.ts

@@ -0,0 +1,6 @@
+import { o as VideoGenerationProvider } from "./video-generation-DQUbmDnh.js";
+
+//#region extensions/qwen/video-generation-provider.d.ts
+declare function buildQwenVideoGenerationProvider(): VideoGenerationProvider;
+//#endregion
+export { buildQwenVideoGenerationProvider as t };

package/dist/video-generation-provider-DFT-eq_6.d.ts

@@ -0,0 +1,6 @@
+import { o as VideoGenerationProvider } from "./video-generation-DQUbmDnh.js";
+
+//#region extensions/deepinfra/video-generation-provider.d.ts
+declare function buildDeepInfraVideoGenerationProvider(): VideoGenerationProvider;
+//#endregion
+export { buildDeepInfraVideoGenerationProvider as t };

package/dist/video-generation-provider-REzsR9R0.d.ts

@@ -0,0 +1,6 @@
+import { o as VideoGenerationProvider } from "./video-generation-DQUbmDnh.js";
+
+//#region extensions/openai/video-generation-provider.d.ts
+declare function buildOpenAIVideoGenerationProvider(): VideoGenerationProvider;
+//#endregion
+export { buildOpenAIVideoGenerationProvider as t };

package/dist/video-generation-provider-edNRu4w0.d.ts

@@ -0,0 +1,10 @@
+import { o as VideoGenerationProvider } from "./video-generation-DQUbmDnh.js";
+
+//#region extensions/minimax/video-generation-provider.d.ts
+declare namespace video_generation_provider_d_exports {
+  export { buildMinimaxPortalVideoGenerationProvider, buildMinimaxVideoGenerationProvider };
+}
+declare function buildMinimaxVideoGenerationProvider(): VideoGenerationProvider;
+declare function buildMinimaxPortalVideoGenerationProvider(): VideoGenerationProvider;
+//#endregion
+export { buildMinimaxVideoGenerationProvider as n, video_generation_provider_d_exports as r, buildMinimaxPortalVideoGenerationProvider as t };

package/dist/video-generation-provider-ixkWaGag.d.ts

@@ -0,0 +1,7 @@
+import { a as fetchWithSsrFGuard } from "./fetch-guard-BgaCy73h.js";
+import { o as VideoGenerationProvider } from "./video-generation-DQUbmDnh.js";
+//#region extensions/fal/video-generation-provider.d.ts
+declare function setFalVideoFetchGuardForTesting(impl: typeof fetchWithSsrFGuard | null): void;
+declare function buildFalVideoGenerationProvider(): VideoGenerationProvider;
+//#endregion
+export { setFalVideoFetchGuardForTesting as n, buildFalVideoGenerationProvider as t };

package/dist/video-generation-runtime-Bv3CToHI.d.ts

@@ -0,0 +1,21 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { J as GenerateVideoParams, Y as GenerateVideoRuntimeResult } from "./types-core-C88zUmhD.js";
+import { s as VideoGenerationProvider } from "./types-DRM6itxh.js";
+import { t as SubsystemLogger } from "./subsystem-Ce5qcC5n.js";
+import { n as getProviderEnvVars } from "./provider-env-vars-EEiUqe0C.js";
+import { n as listVideoGenerationProviders, t as getVideoGenerationProvider } from "./provider-registry-D1g0ynPB.js";
+
+//#region src/video-generation/runtime.d.ts
+declare const log: SubsystemLogger;
+type VideoGenerationRuntimeDeps = {
+  getProvider?: typeof getVideoGenerationProvider;
+  listProviders?: typeof listVideoGenerationProviders;
+  getProviderEnvVars?: typeof getProviderEnvVars;
+  log?: Pick<typeof log, "debug" | "warn">;
+};
+declare function listRuntimeVideoGenerationProviders(params?: {
+  config?: DaoCoreConfig;
+}, deps?: VideoGenerationRuntimeDeps): VideoGenerationProvider[];
+declare function generateVideo(params: GenerateVideoParams, deps?: VideoGenerationRuntimeDeps): Promise<GenerateVideoRuntimeResult>;
+//#endregion
+export { listRuntimeVideoGenerationProviders as n, generateVideo as t };

package/dist/video-model-catalog-B0z3MYiX.d.ts

@@ -0,0 +1,16 @@
+import { f as UnifiedModelCatalogEntry } from "./manifest-registry-BytIqZ_A.js";
+import { Kn as UnifiedModelCatalogProviderContext } from "./types-M3Y2bFvZ2.js";
+import { a as VideoGenerationModelCapabilitiesContext, s as VideoGenerationProviderCapabilities } from "./video-generation-DQUbmDnh.js";
+
+//#region extensions/openrouter/video-model-catalog.d.ts
+type OpenRouterVideoModelCatalogCapabilities = VideoGenerationProviderCapabilities & {
+  allowedPassthroughParameters?: readonly string[];
+  canonicalSlug?: string;
+  created?: number;
+  description?: string;
+  pricingSkus?: Readonly<Record<string, string>>;
+};
+declare function listOpenRouterVideoModelCatalog(ctx: UnifiedModelCatalogProviderContext): Promise<Array<UnifiedModelCatalogEntry<OpenRouterVideoModelCatalogCapabilities>> | null>;
+declare function resolveOpenRouterVideoModelCapabilities(ctx: VideoGenerationModelCapabilitiesContext): Promise<VideoGenerationProviderCapabilities | undefined>;
+//#endregion
+export { listOpenRouterVideoModelCatalog as n, resolveOpenRouterVideoModelCapabilities as r, OpenRouterVideoModelCatalogCapabilities as t };

package/dist/web-fetch/runtime.d.ts

@@ -1,5 +1,5 @@
-import { r as DaoCoreConfig } from "../types.daocore-FLA7MxtO.js";
-import { M as PluginWebFetchProviderEntry, R as WebFetchProviderToolDefinition } from "../types-core-7ot658WI.js";
+import { r as DaoCoreConfig } from "../types.daocore-kp8IyikH.js";
+import { M as PluginWebFetchProviderEntry, R as WebFetchProviderToolDefinition } from "../types-core-C88zUmhD.js";
 import { t as RuntimeWebFetchMetadata } from "../runtime-web-tools.types-Co2KBj4w.js";
 //#region src/web-fetch/runtime.d.ts
 type WebFetchConfig = NonNullable<DaoCoreConfig["tools"]>["web"] extends infer Web ? Web extends {

package/dist/web-search-provider-config-CYd7QLy2.d.ts

@@ -0,0 +1,14 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+
+//#region src/agents/tools/web-search-provider-config.d.ts
+declare function getTopLevelCredentialValue(searchConfig?: Record<string, unknown>): unknown;
+declare function setTopLevelCredentialValue(searchConfigTarget: Record<string, unknown>, value: unknown): void;
+declare function getScopedCredentialValue(searchConfig: Record<string, unknown> | undefined, key: string): unknown;
+declare function setScopedCredentialValue(searchConfigTarget: Record<string, unknown>, key: string, value: unknown): void;
+declare function mergeScopedSearchConfig(searchConfig: Record<string, unknown> | undefined, key: string, pluginConfig: Record<string, unknown> | undefined, options?: {
+  mirrorApiKeyToTopLevel?: boolean;
+}): Record<string, unknown> | undefined;
+declare function resolveProviderWebSearchPluginConfig(config: DaoCoreConfig | undefined, pluginId: string): Record<string, unknown> | undefined;
+declare function setProviderWebSearchPluginConfigValue(configTarget: DaoCoreConfig, pluginId: string, key: string, value: unknown): void;
+//#endregion
+export { setProviderWebSearchPluginConfigValue as a, resolveProviderWebSearchPluginConfig as i, getTopLevelCredentialValue as n, setScopedCredentialValue as o, mergeScopedSearchConfig as r, setTopLevelCredentialValue as s, getScopedCredentialValue as t };

package/dist/webhook-targets-t2TBHoxZ.d.ts

@@ -0,0 +1,99 @@
+import { f as FixedWindowRateLimiter, i as WebhookInFlightLimiter } from "./webhook-request-guards-CQf6yUy9.js";
+import { n as registerPluginHttpRoute } from "./http-registry-Bdabm0WI.js";
+import { IncomingMessage, ServerResponse } from "node:http";
+
+//#region src/plugin-sdk/webhook-targets.d.ts
+type RegisteredWebhookTarget<T> = {
+  target: T;
+  unregister: () => void;
+};
+type RegisterWebhookTargetOptions<T extends {
+  path: string;
+}> = {
+  onFirstPathTarget?: (params: {
+    path: string;
+    target: T;
+  }) => void | (() => void);
+  onLastPathTargetRemoved?: (params: {
+    path: string;
+  }) => void;
+};
+type RegisterPluginHttpRouteParams = Parameters<typeof registerPluginHttpRoute>[0];
+type RegisterWebhookPluginRouteOptions = Omit<RegisterPluginHttpRouteParams, "path" | "fallbackPath">;
+/** Register a webhook target and lazily install the matching plugin HTTP route on first use. */
+declare function registerWebhookTargetWithPluginRoute<T extends {
+  path: string;
+}>(params: {
+  targetsByPath: Map<string, T[]>;
+  target: T;
+  route: RegisterWebhookPluginRouteOptions;
+  onLastPathTargetRemoved?: RegisterWebhookTargetOptions<T>["onLastPathTargetRemoved"];
+}): RegisteredWebhookTarget<T>;
+/** Add a normalized target to a path bucket and clean up route state when the last target leaves. */
+declare function registerWebhookTarget<T extends {
+  path: string;
+}>(targetsByPath: Map<string, T[]>, target: T, opts?: RegisterWebhookTargetOptions<T>): RegisteredWebhookTarget<T>;
+/** Resolve all registered webhook targets for the incoming request path. */
+declare function resolveWebhookTargets<T>(req: IncomingMessage, targetsByPath: Map<string, T[]>): {
+  path: string;
+  targets: T[];
+} | null;
+/** Run common webhook guards, then dispatch only when the request path resolves to live targets. */
+declare function withResolvedWebhookRequestPipeline<T>(params: {
+  req: IncomingMessage;
+  res: ServerResponse;
+  targetsByPath: Map<string, T[]>;
+  allowMethods?: readonly string[];
+  rateLimiter?: FixedWindowRateLimiter;
+  rateLimitKey?: string;
+  nowMs?: number;
+  requireJsonContentType?: boolean;
+  inFlightLimiter?: WebhookInFlightLimiter;
+  inFlightKey?: string | ((args: {
+    req: IncomingMessage;
+    path: string;
+    targets: T[];
+  }) => string);
+  inFlightLimitStatusCode?: number;
+  inFlightLimitMessage?: string;
+  handle: (args: {
+    path: string;
+    targets: T[];
+  }) => Promise<boolean | void> | boolean | void;
+}): Promise<boolean>;
+type WebhookTargetMatchResult<T> = {
+  kind: "none";
+} | {
+  kind: "single";
+  target: T;
+} | {
+  kind: "ambiguous";
+};
+/** Match exactly one synchronous target or report whether resolution was empty or ambiguous. */
+declare function resolveSingleWebhookTarget<T>(targets: readonly T[], isMatch: (target: T) => boolean): WebhookTargetMatchResult<T>;
+/** Async variant of single-target resolution for auth checks that need I/O. */
+declare function resolveSingleWebhookTargetAsync<T>(targets: readonly T[], isMatch: (target: T) => Promise<boolean>): Promise<WebhookTargetMatchResult<T>>;
+/** Resolve an authorized target and send the standard unauthorized or ambiguous response on failure. */
+declare function resolveWebhookTargetWithAuthOrReject<T>(params: {
+  targets: readonly T[];
+  res: ServerResponse;
+  isMatch: (target: T) => boolean | Promise<boolean>;
+  unauthorizedStatusCode?: number;
+  unauthorizedMessage?: string;
+  ambiguousStatusCode?: number;
+  ambiguousMessage?: string;
+}): Promise<T | null>;
+/** Synchronous variant of webhook auth resolution for cheap in-memory match checks. */
+declare function resolveWebhookTargetWithAuthOrRejectSync<T>(params: {
+  targets: readonly T[];
+  res: ServerResponse;
+  isMatch: (target: T) => boolean;
+  unauthorizedStatusCode?: number;
+  unauthorizedMessage?: string;
+  ambiguousStatusCode?: number;
+  ambiguousMessage?: string;
+}): T | null;
+/** Reject non-POST webhook requests with the conventional Allow header. */
+declare function rejectNonPostWebhookRequest(req: IncomingMessage, res: ServerResponse): boolean;
+//#endregion
+export { registerWebhookTarget as a, resolveSingleWebhookTarget as c, resolveWebhookTargetWithAuthOrRejectSync as d, resolveWebhookTargets as f, WebhookTargetMatchResult as i, resolveSingleWebhookTargetAsync as l, RegisterWebhookTargetOptions as n, registerWebhookTargetWithPluginRoute as o, withResolvedWebhookRequestPipeline as p, RegisteredWebhookTarget as r, rejectNonPostWebhookRequest as s, RegisterWebhookPluginRouteOptions as t, resolveWebhookTargetWithAuthOrReject as u };

package/dist/workflow-runtime-B4WLIO1t.d.ts

@@ -0,0 +1,45 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { s as AuthProfileStore } from "./types-dSHooml1.js";
+import { a as fetchWithSsrFGuard } from "./fetch-guard-BgaCy73h.js";
+//#region extensions/comfy/workflow-runtime.d.ts
+declare const DEFAULT_COMFY_MODEL = "workflow";
+type ComfyCapability = "image" | "music" | "video";
+type ComfyOutputKind = "audio" | "gifs" | "images" | "videos";
+type ComfyProviderConfig = Record<string, unknown>;
+type ComfySourceImage = {
+  buffer: Buffer;
+  mimeType: string;
+  fileName?: string;
+};
+type ComfyGeneratedAsset = {
+  buffer: Buffer;
+  mimeType: string;
+  fileName: string;
+  nodeId: string;
+};
+type ComfyWorkflowResult = {
+  assets: ComfyGeneratedAsset[];
+  model: string;
+  promptId: string;
+  outputNodeIds: string[];
+};
+declare function setComfyFetchGuardForTesting(impl: typeof fetchWithSsrFGuard | null): void;
+declare function getComfyConfig(cfg?: DaoCoreConfig): ComfyProviderConfig;
+declare function isComfyCapabilityConfigured(params: {
+  cfg?: DaoCoreConfig;
+  agentDir?: string;
+  capability: ComfyCapability;
+}): boolean;
+declare function runComfyWorkflow(params: {
+  cfg: DaoCoreConfig;
+  agentDir?: string;
+  authStore?: AuthProfileStore;
+  prompt: string;
+  model?: string;
+  timeoutMs?: number;
+  capability: ComfyCapability;
+  outputKinds: readonly ComfyOutputKind[];
+  inputImage?: ComfySourceImage;
+}): Promise<ComfyWorkflowResult>;
+//#endregion
+export { setComfyFetchGuardForTesting as a, runComfyWorkflow as i, getComfyConfig as n, isComfyCapabilityConfigured as r, DEFAULT_COMFY_MODEL as t };