@gaodefa/daocore 2026.5.67 → 2026.5.69

package/dist/markdown-tables.types-CQftVTAQ.d.ts

@@ -0,0 +1,12 @@
+import { r as DaoCoreConfig } from "./types.daocore-FLA7MxtO.js";
+import { S as MarkdownTableMode } from "./types.base-tQh4FMBR.js";
+
+//#region src/config/markdown-tables.types.d.ts
+type ResolveMarkdownTableModeParams = {
+  cfg?: Partial<DaoCoreConfig>;
+  channel?: string | null;
+  accountId?: string | null;
+};
+type ResolveMarkdownTableMode = (params: ResolveMarkdownTableModeParams) => MarkdownTableMode;
+//#endregion
+export { ResolveMarkdownTableModeParams as n, ResolveMarkdownTableMode as t };

package/dist/mcp/plugin-tools-serve.d.ts

@@ -1,4 +1,4 @@
-import { r as DaoCoreConfig } from "../types.daocore-kp8IyikH.js";
+import { r as DaoCoreConfig } from "../types.daocore-FLA7MxtO.js";
 import { r as AnyAgentTool } from "../common-BDN0bXby.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 

package/dist/media-contract-api-DRTY_EhJ.d.ts

@@ -0,0 +1,13 @@
+import { r as DaoCoreConfig } from "./types.daocore-FLA7MxtO.js";
+//#region extensions/imessage/src/media-contract.d.ts
+declare const DEFAULT_IMESSAGE_ATTACHMENT_ROOTS: readonly ["/Users/*/Library/Messages/Attachments"];
+declare function resolveIMessageAttachmentRoots(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}): string[];
+declare function resolveIMessageRemoteAttachmentRoots(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}): string[];
+//#endregion
+export { resolveIMessageAttachmentRoots as n, resolveIMessageRemoteAttachmentRoots as r, DEFAULT_IMESSAGE_ATTACHMENT_ROOTS as t };

package/dist/media-runtime-l4eE7eGn.d.ts

@@ -0,0 +1,289 @@
+import { r as DaoCoreConfig } from "./types.daocore-FLA7MxtO.js";
+import { f as MediaUnderstandingConfig } from "./types.tools-nWzVz5Fw.js";
+import { o as SsrFPolicy } from "./ssrf-skjEI_i5.js";
+import { c as MediaAttachment, d as MediaUnderstandingOutput, f as MediaUnderstandingProvider, l as MediaUnderstandingCapability, u as MediaUnderstandingDecision } from "./types-Bxd589-v.js";
+import { n as MsgContext } from "./templating-BEHZ8n6P.js";
+import { t as ActiveMediaModel } from "./active-model.types-DCiq_ik4.js";
+import { t as OutboundSendDeps } from "./send-deps-BaEC80iY.js";
+import { t as OutboundMediaAccess } from "./load-options-CTuppEe4.js";
+import { n as ChannelOutboundAdapter } from "./outbound.types-CQJou9Fo.js";
+//#region src/media/audio-transcode.d.ts
+declare function transcodeAudioBufferToOpus(params: {
+  audioBuffer: Buffer;
+  inputExtension?: string;
+  inputFileName?: string;
+  tempPrefix?: string;
+  outputFileName?: string;
+  timeoutMs?: number;
+  sampleRateHz?: number;
+  bitrate?: string;
+  channels?: number;
+}): Promise<Buffer>;
+type AudioContainerTranscodeOutcome = {
+  ok: true;
+  buffer: Buffer;
+} | {
+  ok: false;
+  reason: "platform-unsupported" | "invalid-extension" | "noop-same-container" | "no-recipe" | "transcoder-failed";
+  detail?: string;
+};
+declare function transcodeAudioBuffer(params: {
+  audioBuffer: Buffer;
+  sourceExtension: string;
+  targetExtension: string;
+  timeoutMs?: number;
+}): Promise<AudioContainerTranscodeOutcome>;
+//#endregion
+//#region src/media/ffmpeg-exec.d.ts
+type MediaExecOptions = {
+  timeoutMs?: number;
+  maxBufferBytes?: number;
+  input?: Buffer | string;
+};
+declare function runFfprobe(args: string[], options?: MediaExecOptions): Promise<string>;
+declare function runFfmpeg(args: string[], options?: MediaExecOptions): Promise<string>;
+declare function parseFfprobeCsvFields(stdout: string, maxFields: number): string[];
+declare function parseFfprobeCodecAndSampleRate(stdout: string): {
+  codec: string | null;
+  sampleRateHz: number | null;
+};
+//#endregion
+//#region src/media/video-dimensions.d.ts
+type VideoDimensions = {
+  width: number;
+  height: number;
+};
+declare function parseFfprobeVideoDimensions(stdout: string): VideoDimensions | undefined;
+declare function probeVideoDimensions(buffer: Buffer): Promise<VideoDimensions | undefined>;
+//#endregion
+//#region src/media/base64.d.ts
+declare function estimateBase64DecodedBytes(base64: string): number;
+/**
+ * Normalize and validate a base64 string.
+ * Returns canonical base64 (no whitespace) or undefined when invalid.
+ */
+declare function canonicalizeBase64(base64: string): string | undefined;
+//#endregion
+//#region src/media/ffmpeg-limits.d.ts
+declare const MEDIA_FFMPEG_MAX_BUFFER_BYTES: number;
+declare const MEDIA_FFPROBE_TIMEOUT_MS = 10000;
+declare const MEDIA_FFMPEG_TIMEOUT_MS = 45000;
+declare const MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS: number;
+//#endregion
+//#region src/media/outbound-attachment.d.ts
+declare function resolveOutboundAttachmentFromUrl(mediaUrl: string, maxBytes: number, options?: {
+  mediaAccess?: OutboundMediaAccess;
+  localRoots?: readonly string[];
+  readFile?: (filePath: string) => Promise<Buffer>;
+}): Promise<{
+  path: string;
+  contentType?: string;
+}>;
+//#endregion
+//#region src/media/qr-image.d.ts
+type QrPngRenderOptions = {
+  scale?: number;
+  marginModules?: number;
+};
+type QrPngTempFileOptions = QrPngRenderOptions & {
+  tmpRoot: string;
+  dirPrefix: string;
+  fileName?: string;
+};
+type QrPngTempFile = {
+  filePath: string;
+  dirPath: string;
+  mediaLocalRoots: string[];
+};
+declare function renderQrPngBase64(input: string, opts?: QrPngRenderOptions): Promise<string>;
+declare function formatQrPngDataUrl(base64: string): string;
+declare function renderQrPngDataUrl(input: string, opts?: QrPngRenderOptions): Promise<string>;
+declare function writeQrPngTempFile(input: string, opts: QrPngTempFileOptions): Promise<QrPngTempFile>;
+//#endregion
+//#region src/media/qr-terminal.d.ts
+declare function renderQrTerminal(input: string, opts?: {
+  small?: boolean;
+}): Promise<string>;
+//#endregion
+//#region src/media/temp-files.d.ts
+declare function unlinkIfExists(filePath: string | null | undefined): Promise<void>;
+//#endregion
+//#region src/channels/plugins/media-limits.d.ts
+declare function resolveChannelMediaMaxBytes(params: {
+  cfg: DaoCoreConfig;
+  resolveChannelLimitMb: (params: {
+    cfg: DaoCoreConfig;
+    accountId: string;
+  }) => number | undefined;
+  accountId?: string | null;
+}): number | undefined;
+//#endregion
+//#region src/media-understanding/audio-preflight.d.ts
+/**
+ * Transcribes the first audio attachment BEFORE mention checking.
+ * This allows voice notes to be processed in group chats with requireMention: true.
+ * Returns the transcript or undefined if transcription fails or no audio is found.
+ */
+declare function transcribeFirstAudio(params: {
+  ctx: MsgContext;
+  cfg: DaoCoreConfig;
+  agentDir?: string;
+  providers?: Record<string, MediaUnderstandingProvider>;
+  activeModel?: ActiveMediaModel;
+}): Promise<string | undefined>;
+//#endregion
+//#region src/media-understanding/defaults.constants.d.ts
+declare const DEFAULT_MAX_CHARS = 500;
+declare const DEFAULT_MAX_CHARS_BY_CAPABILITY: Record<MediaUnderstandingCapability, number | undefined>;
+declare const DEFAULT_MAX_BYTES: Record<MediaUnderstandingCapability, number>;
+declare const DEFAULT_TIMEOUT_SECONDS: Record<MediaUnderstandingCapability, number>;
+declare const DEFAULT_PROMPT: Record<MediaUnderstandingCapability, string>;
+declare const DEFAULT_VIDEO_MAX_BASE64_BYTES: number;
+declare const CLI_OUTPUT_MAX_BUFFER: number;
+declare const DEFAULT_MEDIA_CONCURRENCY = 2;
+declare const MIN_AUDIO_FILE_BYTES = 1024;
+//#endregion
+//#region src/media-understanding/defaults.d.ts
+declare function resolveDefaultMediaModel(params: {
+  providerId: string;
+  capability: MediaUnderstandingCapability;
+  cfg?: DaoCoreConfig;
+  workspaceDir?: string;
+  providerRegistry?: Map<string, MediaUnderstandingProvider>;
+  includeConfiguredImageModels?: boolean;
+}): string | undefined;
+declare function resolveAutoMediaKeyProviders(params: {
+  capability: MediaUnderstandingCapability;
+  cfg?: DaoCoreConfig;
+  workspaceDir?: string;
+  providerRegistry?: Map<string, MediaUnderstandingProvider>;
+}): string[];
+declare function providerSupportsNativePdfDocument(params: {
+  providerId: string;
+  cfg?: DaoCoreConfig;
+  workspaceDir?: string;
+  providerRegistry?: Map<string, MediaUnderstandingProvider>;
+}): boolean;
+//#endregion
+//#region src/media-understanding/attachments.cache.d.ts
+type MediaBufferResult = {
+  buffer: Buffer;
+  mime?: string;
+  fileName: string;
+  size: number;
+};
+type MediaPathResult = {
+  path: string;
+  cleanup?: () => Promise<void> | void;
+};
+type MediaAttachmentCacheOptions = {
+  localPathRoots?: readonly string[];
+  includeDefaultLocalPathRoots?: boolean;
+  ssrfPolicy?: SsrFPolicy;
+  workspaceDir?: string;
+};
+declare class MediaAttachmentCache {
+  private readonly entries;
+  private readonly attachments;
+  private readonly localPathRoots;
+  private readonly ssrfPolicy;
+  private readonly workspaceDir?;
+  private canonicalLocalPathRoots?;
+  constructor(attachments: MediaAttachment[], options?: MediaAttachmentCacheOptions);
+  getBuffer(params: {
+    attachmentIndex: number;
+    maxBytes: number;
+    timeoutMs: number;
+  }): Promise<MediaBufferResult>;
+  getPath(params: {
+    attachmentIndex: number;
+    maxBytes?: number;
+    timeoutMs: number;
+  }): Promise<MediaPathResult>;
+  cleanup(): Promise<void>;
+  private ensureEntry;
+  private resolveLocalPath;
+  private ensureLocalStat;
+  private getCanonicalLocalPathRoots;
+  private readLocalBuffer;
+}
+//#endregion
+//#region src/media-understanding/runner.attachments.d.ts
+declare function normalizeMediaAttachments(ctx: MsgContext): MediaAttachment[];
+declare function createMediaAttachmentCache(attachments: MediaAttachment[], options?: MediaAttachmentCacheOptions): MediaAttachmentCache;
+//#endregion
+//#region src/media-understanding/runner.d.ts
+type ProviderRegistry = Map<string, MediaUnderstandingProvider>;
+type RunCapabilityResult = {
+  outputs: MediaUnderstandingOutput[];
+  decision: MediaUnderstandingDecision;
+};
+declare function buildProviderRegistry(overrides?: Record<string, MediaUnderstandingProvider>, cfg?: DaoCoreConfig): ProviderRegistry;
+declare function resolveMediaAttachmentLocalRoots(params: {
+  cfg: DaoCoreConfig;
+  ctx: MsgContext;
+  workspaceDir?: string;
+}): readonly string[];
+declare function clearMediaUnderstandingBinaryCacheForTests(): void;
+declare function resolveAutoImageModel(params: {
+  cfg: DaoCoreConfig;
+  agentDir?: string;
+  workspaceDir?: string;
+  activeModel?: ActiveMediaModel;
+}): Promise<ActiveMediaModel | null>;
+declare function runCapability(params: {
+  capability: MediaUnderstandingCapability;
+  cfg: DaoCoreConfig;
+  ctx: MsgContext;
+  attachments: MediaAttachmentCache;
+  media: MediaAttachment[];
+  agentDir?: string;
+  workspaceDir?: string;
+  providerRegistry: ProviderRegistry;
+  config?: MediaUnderstandingConfig;
+  activeModel?: ActiveMediaModel;
+}): Promise<RunCapabilityResult>;
+//#endregion
+//#region src/media-understanding/provider-id.d.ts
+declare function normalizeMediaProviderId(id: string): string;
+//#endregion
+//#region src/channels/plugins/outbound/direct-text-media.d.ts
+type DirectSendOptions = {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+  replyToId?: string | null;
+  mediaUrl?: string;
+  mediaAccess?: OutboundMediaAccess;
+  mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
+  maxBytes?: number;
+};
+type DirectSendResult = {
+  messageId: string;
+  [key: string]: unknown;
+};
+type DirectSendFn<TOpts extends Record<string, unknown>, TResult extends DirectSendResult> = (to: string, text: string, opts: TOpts) => Promise<TResult>;
+declare function resolveScopedChannelMediaMaxBytes(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+  resolveChannelLimitMb: (params: {
+    cfg: DaoCoreConfig;
+    accountId: string;
+  }) => number | undefined;
+}): number | undefined;
+declare function createScopedChannelMediaMaxBytesResolver(channel: string): (params: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}) => number | undefined;
+declare function createDirectTextMediaOutbound<TOpts extends Record<string, unknown>, TResult extends DirectSendResult>(params: {
+  channel: string;
+  resolveSender: (deps: OutboundSendDeps | undefined) => DirectSendFn<TOpts, TResult>;
+  resolveMaxBytes: (params: {
+    cfg: DaoCoreConfig;
+    accountId?: string | null;
+  }) => number | undefined;
+  buildTextOptions: (params: DirectSendOptions) => TOpts;
+  buildMediaOptions: (params: DirectSendOptions) => TOpts;
+}): ChannelOutboundAdapter;
+//#endregion
+export { renderQrPngBase64 as A, VideoDimensions as B, DEFAULT_VIDEO_MAX_BASE64_BYTES as C, unlinkIfExists as D, resolveChannelMediaMaxBytes as E, MEDIA_FFMPEG_MAX_BUFFER_BYTES as F, parseFfprobeCsvFields as G, probeVideoDimensions as H, MEDIA_FFMPEG_TIMEOUT_MS as I, AudioContainerTranscodeOutcome as J, runFfmpeg as K, MEDIA_FFPROBE_TIMEOUT_MS as L, writeQrPngTempFile as M, resolveOutboundAttachmentFromUrl as N, renderQrTerminal as O, MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS as P, canonicalizeBase64 as R, DEFAULT_TIMEOUT_SECONDS as S, transcribeFirstAudio as T, MediaExecOptions as U, parseFfprobeVideoDimensions as V, parseFfprobeCodecAndSampleRate as W, transcodeAudioBufferToOpus as X, transcodeAudioBuffer as Y, DEFAULT_MAX_BYTES as _, RunCapabilityResult as a, DEFAULT_MEDIA_CONCURRENCY as b, resolveAutoImageModel as c, createMediaAttachmentCache as d, normalizeMediaAttachments as f, CLI_OUTPUT_MAX_BUFFER as g, resolveDefaultMediaModel as h, normalizeMediaProviderId as i, renderQrPngDataUrl as j, formatQrPngDataUrl as k, resolveMediaAttachmentLocalRoots as l, resolveAutoMediaKeyProviders as m, createScopedChannelMediaMaxBytesResolver as n, buildProviderRegistry as o, providerSupportsNativePdfDocument as p, runFfprobe as q, resolveScopedChannelMediaMaxBytes as r, clearMediaUnderstandingBinaryCacheForTests as s, createDirectTextMediaOutbound as t, runCapability as u, DEFAULT_MAX_CHARS as v, MIN_AUDIO_FILE_BYTES as w, DEFAULT_PROMPT as x, DEFAULT_MAX_CHARS_BY_CAPABILITY as y, estimateBase64DecodedBytes as z };

package/dist/media-understanding/apply.runtime.d.ts

@@ -1,6 +1,6 @@
-import { r as DaoCoreConfig } from "../types.daocore-kp8IyikH.js";
-import { d as MediaUnderstandingOutput, f as MediaUnderstandingProvider, u as MediaUnderstandingDecision } from "../types-CVxsggkU.js";
-import { n as MsgContext } from "../templating-DNuykHor.js";
+import { r as DaoCoreConfig } from "../types.daocore-FLA7MxtO.js";
+import { d as MediaUnderstandingOutput, f as MediaUnderstandingProvider, u as MediaUnderstandingDecision } from "../types-Bxd589-v.js";
+import { n as MsgContext } from "../templating-BEHZ8n6P.js";
 import { t as ActiveMediaModel } from "../active-model.types-DCiq_ik4.js";
 
 //#region src/media-understanding/apply.d.ts

package/dist/media-understanding-B4EMWSBw.d.ts

@@ -0,0 +1,46 @@
+import { n as AudioTranscriptionResult, t as AudioTranscriptionRequest } from "./types-Bxd589-v.js";
+//#region src/media-understanding/openai-compatible-video.d.ts
+type OpenAiCompatibleVideoPayload = {
+  choices?: Array<{
+    message?: {
+      content?: string | Array<{
+        text?: string;
+      }>;
+      reasoning_content?: string;
+    };
+  }>;
+};
+declare function resolveMediaUnderstandingString(value: string | undefined, fallback: string): string;
+declare function coerceOpenAiCompatibleVideoText(payload: OpenAiCompatibleVideoPayload): string | null;
+declare function buildOpenAiCompatibleVideoRequestBody(params: {
+  model: string;
+  prompt: string;
+  mime: string;
+  buffer: Buffer;
+}): {
+  model: string;
+  messages: {
+    role: string;
+    content: ({
+      type: string;
+      text: string;
+      video_url?: undefined;
+    } | {
+      type: string;
+      video_url: {
+        url: string;
+      };
+      text?: undefined;
+    })[];
+  }[];
+};
+//#endregion
+//#region src/media-understanding/openai-compatible-audio.d.ts
+type OpenAiCompatibleAudioParams = AudioTranscriptionRequest & {
+  defaultBaseUrl: string;
+  defaultModel: string;
+  provider?: string;
+};
+declare function transcribeOpenAiCompatibleAudio(params: OpenAiCompatibleAudioParams): Promise<AudioTranscriptionResult>;
+//#endregion
+export { resolveMediaUnderstandingString as a, coerceOpenAiCompatibleVideoText as i, OpenAiCompatibleVideoPayload as n, buildOpenAiCompatibleVideoRequestBody as r, transcribeOpenAiCompatibleAudio as t };

package/dist/media-understanding-provider-BxYIZJoz.d.ts

@@ -0,0 +1,6 @@
+import { f as MediaUnderstandingProvider, n as AudioTranscriptionResult, t as AudioTranscriptionRequest } from "./types-Bxd589-v.js";
+//#region extensions/openrouter/media-understanding-provider.d.ts
+declare function transcribeOpenRouterAudio(params: AudioTranscriptionRequest): Promise<AudioTranscriptionResult>;
+declare const openrouterMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { transcribeOpenRouterAudio as n, openrouterMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-C8ZkkoZw.d.ts

@@ -0,0 +1,6 @@
+import { f as MediaUnderstandingProvider } from "./types-Bxd589-v.js";
+//#region extensions/minimax/media-understanding-provider.d.ts
+declare const minimaxMediaUnderstandingProvider: MediaUnderstandingProvider;
+declare const minimaxPortalMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { minimaxPortalMediaUnderstandingProvider as n, minimaxMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-CH13o72S.d.ts

@@ -0,0 +1,6 @@
+import { f as MediaUnderstandingProvider, v as VideoDescriptionRequest, y as VideoDescriptionResult } from "./types-Bxd589-v.js";
+//#region extensions/moonshot/media-understanding-provider.d.ts
+declare function describeMoonshotVideo(params: VideoDescriptionRequest): Promise<VideoDescriptionResult>;
+declare const moonshotMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { moonshotMediaUnderstandingProvider as n, describeMoonshotVideo as t };

package/dist/media-understanding-provider-Cp0tNB01.d.ts

@@ -0,0 +1,5 @@
+import { f as MediaUnderstandingProvider } from "./types-Bxd589-v.js";
+//#region extensions/groq/media-understanding-provider.d.ts
+declare const groqMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { groqMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-Cw65mFWn.d.ts

@@ -0,0 +1,5 @@
+import { f as MediaUnderstandingProvider } from "./types-Bxd589-v.js";
+//#region extensions/anthropic/media-understanding-provider.d.ts
+declare const anthropicMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { anthropicMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-DEUMM6iQ.d.ts

@@ -0,0 +1,9 @@
+import { f as MediaUnderstandingProvider, n as AudioTranscriptionResult, t as AudioTranscriptionRequest, v as VideoDescriptionRequest, y as VideoDescriptionResult } from "./types-Bxd589-v.js";
+//#region extensions/google/media-understanding-provider.d.ts
+declare const DEFAULT_GOOGLE_AUDIO_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+declare const DEFAULT_GOOGLE_VIDEO_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+declare function transcribeGeminiAudio(params: AudioTranscriptionRequest): Promise<AudioTranscriptionResult>;
+declare function describeGeminiVideo(params: VideoDescriptionRequest): Promise<VideoDescriptionResult>;
+declare const googleMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { transcribeGeminiAudio as a, googleMediaUnderstandingProvider as i, DEFAULT_GOOGLE_VIDEO_BASE_URL as n, describeGeminiVideo as r, DEFAULT_GOOGLE_AUDIO_BASE_URL as t };

package/dist/media-understanding-provider-DHHZC6HL.d.ts

@@ -0,0 +1,6 @@
+import { f as MediaUnderstandingProvider, v as VideoDescriptionRequest, y as VideoDescriptionResult } from "./types-Bxd589-v.js";
+//#region extensions/qwen/media-understanding-provider.d.ts
+declare function describeQwenVideo(params: VideoDescriptionRequest): Promise<VideoDescriptionResult>;
+declare function buildQwenMediaUnderstandingProvider(): MediaUnderstandingProvider;
+//#endregion
+export { describeQwenVideo as n, buildQwenMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-DkVhKqb2.d.ts

@@ -0,0 +1,5 @@
+import { f as MediaUnderstandingProvider } from "./types-Bxd589-v.js";
+//#region extensions/deepgram/media-understanding-provider.d.ts
+declare const deepgramMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { deepgramMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-DvruEr5H.d.ts

@@ -0,0 +1,8 @@
+import { f as MediaUnderstandingProvider, n as AudioTranscriptionResult, t as AudioTranscriptionRequest } from "./types-Bxd589-v.js";
+//#region extensions/openai/media-understanding-provider.d.ts
+declare function transcribeOpenAiAudio(params: AudioTranscriptionRequest): Promise<AudioTranscriptionResult>;
+declare function transcribeOpenAiCodexAudio(params: AudioTranscriptionRequest): Promise<AudioTranscriptionResult>;
+declare const openaiMediaUnderstandingProvider: MediaUnderstandingProvider;
+declare const openaiCodexMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { transcribeOpenAiCodexAudio as i, openaiMediaUnderstandingProvider as n, transcribeOpenAiAudio as r, openaiCodexMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-HMTT0cfQ.d.ts

@@ -0,0 +1,5 @@
+import { f as MediaUnderstandingProvider } from "./types-Bxd589-v.js";
+//#region extensions/zai/media-understanding-provider.d.ts
+declare const zaiMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { zaiMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-V4jV5R8f.d.ts

@@ -0,0 +1,6 @@
+import { f as MediaUnderstandingProvider, n as AudioTranscriptionResult, t as AudioTranscriptionRequest } from "./types-Bxd589-v.js";
+//#region extensions/elevenlabs/media-understanding-provider.d.ts
+declare function transcribeElevenLabsAudio(req: AudioTranscriptionRequest): Promise<AudioTranscriptionResult>;
+declare const elevenLabsMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { transcribeElevenLabsAudio as n, elevenLabsMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-_KqnLaZB.d.ts

@@ -0,0 +1,6 @@
+import { f as MediaUnderstandingProvider, n as AudioTranscriptionResult, t as AudioTranscriptionRequest } from "./types-Bxd589-v.js";
+//#region extensions/deepinfra/media-understanding-provider.d.ts
+declare function transcribeDeepInfraAudio(params: AudioTranscriptionRequest): Promise<AudioTranscriptionResult>;
+declare const deepinfraMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { transcribeDeepInfraAudio as n, deepinfraMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-ce6bSLhU.d.ts

@@ -0,0 +1,5 @@
+import { f as MediaUnderstandingProvider } from "./types-Bxd589-v.js";
+//#region extensions/mistral/media-understanding-provider.d.ts
+declare const mistralMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { mistralMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-qdtwYkA_.d.ts

@@ -0,0 +1,6 @@
+import { f as MediaUnderstandingProvider, n as AudioTranscriptionResult, t as AudioTranscriptionRequest } from "./types-Bxd589-v.js";
+//#region extensions/senseaudio/media-understanding-provider.d.ts
+declare function transcribeSenseAudioAudio(params: AudioTranscriptionRequest): Promise<AudioTranscriptionResult>;
+declare const senseaudioMediaUnderstandingProvider: MediaUnderstandingProvider;
+//#endregion
+export { transcribeSenseAudioAudio as n, senseaudioMediaUnderstandingProvider as t };

package/dist/media-understanding-runtime-DuZ_pQG_.d.ts

@@ -0,0 +1,12 @@
+import { g as StructuredExtractionResult, i as ImageDescriptionResult } from "./types-Bxd589-v.js";
+import { c as TranscribeAudioFileParams, i as ExtractStructuredWithModelParams, n as DescribeImageFileWithModelParams, o as RunMediaUnderstandingFileParams, r as DescribeVideoFileParams, s as RunMediaUnderstandingFileResult, t as DescribeImageFileParams } from "./runtime-types-Bza8FRxX.js";
+
+//#region src/media-understanding/runtime.d.ts
+declare function runMediaUnderstandingFile(params: RunMediaUnderstandingFileParams): Promise<RunMediaUnderstandingFileResult>;
+declare function describeImageFile(params: DescribeImageFileParams): Promise<RunMediaUnderstandingFileResult>;
+declare function describeImageFileWithModel(params: DescribeImageFileWithModelParams): Promise<ImageDescriptionResult>;
+declare function extractStructuredWithModel(params: ExtractStructuredWithModelParams): Promise<StructuredExtractionResult>;
+declare function describeVideoFile(params: DescribeVideoFileParams): Promise<RunMediaUnderstandingFileResult>;
+declare function transcribeAudioFile(params: TranscribeAudioFileParams): Promise<RunMediaUnderstandingFileResult>;
+//#endregion
+export { runMediaUnderstandingFile as a, extractStructuredWithModel as i, describeImageFileWithModel as n, transcribeAudioFile as o, describeVideoFile as r, describeImageFile as t };