@steipete/summarize-core 0.11.1 → 0.13.0

package/dist/types/content/link-preview/deps.d.ts

@@ -19,7 +19,8 @@ export declare const ProgressKind: {
     readonly BirdStart: "bird-start";
     readonly BirdDone: "bird-done";
 };
-export type TranscriptionProviderHint = "cpp" | "onnx" | "groq" | "groq->openai" | "groq->fal" | "groq->openai->fal" | "openai" | "fal" | "openai->fal" | "unknown";
+export type CloudTranscriptionProviderHint = "groq" | "assemblyai" | "gemini" | "openai" | "fal";
+export type TranscriptionProviderHint = "cpp" | "onnx" | "unknown" | CloudTranscriptionProviderHint | `${CloudTranscriptionProviderHint}->${string}`;
 /** Public progress events emitted by link preview fetchers. */
 export type LinkPreviewProgressEvent = {
     kind: "fetch-html-start";
@@ -104,9 +105,11 @@ export type LinkPreviewProgressEvent = {
 } | {
     kind: "bird-start";
     url: string;
+    client?: "xurl" | "bird" | null;
 } | {
     kind: "bird-done";
     url: string;
+    client?: "xurl" | "bird" | null;
     ok: boolean;
     textBytes: number | null;
 };
@@ -130,7 +133,7 @@ export type BirdTweetMedia = {
     kind: "video" | "audio";
     urls: string[];
     preferredUrl: string | null;
-    source: "extended_entities" | "card" | "entities";
+    source: "extended_entities" | "card" | "entities" | "xurl";
 };
 export type BirdTweetPayload = {
     id?: string;
@@ -141,6 +144,7 @@ export type BirdTweetPayload = {
     };
     createdAt?: string;
     media?: BirdTweetMedia | null;
+    client?: "xurl" | "bird";
 };
 export type ReadTweetWithBird = (args: {
     url: string;
@@ -164,6 +168,8 @@ export interface LinkPreviewDeps {
     transcription?: TranscriptionConfig | null;
     falApiKey?: string | null;
     groqApiKey?: string | null;
+    assemblyaiApiKey?: string | null;
+    geminiApiKey?: string | null;
     openaiApiKey?: string | null;
     convertHtmlToMarkdown: ConvertHtmlToMarkdown | null;
     transcriptCache: TranscriptCache | null;

package/dist/types/content/link-preview/types.d.ts

@@ -29,7 +29,7 @@ export interface MarkdownDiagnostics {
     notes?: string | null;
 }
 export interface ContentFetchDiagnostics {
-    strategy: "bird" | "firecrawl" | "html" | "nitter";
+    strategy: "bird" | "xurl" | "firecrawl" | "html" | "nitter";
     firecrawl: FirecrawlDiagnostics;
     markdown: MarkdownDiagnostics;
     transcript: TranscriptDiagnostics;

package/dist/types/content/local-file.d.ts

@@ -0,0 +1,16 @@
+import { type DirectMediaKind } from "./direct-media.js";
+export type LocalFileReference = {
+    filePath: string;
+    fileUrl: string;
+    filename: string;
+    mtimeMs: number;
+};
+export type LocalDirectMediaSource = LocalFileReference & {
+    extension: string | null;
+    mediaKind: DirectMediaKind;
+    mediaType: string;
+};
+export declare function isLocalFileUrl(value: string): boolean;
+export declare function resolveLocalFileReference(value: string): LocalFileReference | null;
+export declare function resolveLocalFileMtime(value: string): number | null;
+export declare function resolveLocalDirectMediaSource(value: string, kindHint?: DirectMediaKind | null): LocalDirectMediaSource | null;

package/dist/types/content/transcript/providers/generic-direct-media.d.ts

@@ -0,0 +1,11 @@
+import type { DirectMediaKind } from "../../direct-media.js";
+import type { TranscriptionConfig } from "../transcription-config.js";
+import type { ProviderFetchOptions, ProviderResult } from "../types.js";
+export declare function fetchDirectMediaTranscript({ url, options, transcription, notes, attemptedProviders, kind, }: {
+    url: string;
+    options: ProviderFetchOptions;
+    transcription: TranscriptionConfig;
+    notes: string[];
+    attemptedProviders: ProviderResult["attemptedProviders"];
+    kind: DirectMediaKind | null;
+}): Promise<ProviderResult | null>;

package/dist/types/content/transcript/providers/generic-embedded.d.ts

@@ -0,0 +1,16 @@
+import type { TranscriptSegment } from "../../link-preview/types.js";
+export type EmbeddedTrack = {
+    url: string;
+    type: string | null;
+    language: string | null;
+};
+export type EmbeddedMedia = {
+    kind: "video" | "audio";
+    mediaUrl: string | null;
+    track: EmbeddedTrack | null;
+};
+export declare function detectEmbeddedMedia(html: string, baseUrl: string): EmbeddedMedia | null;
+export declare function fetchCaptionTrack(fetchImpl: typeof fetch, track: EmbeddedTrack, notes: string[], includeSegments: boolean): Promise<{
+    text: string;
+    segments: TranscriptSegment[] | null;
+} | null>;

package/dist/types/content/transcript/providers/generic-twitter.d.ts

@@ -0,0 +1,11 @@
+import type { DirectMediaKind } from "../../direct-media.js";
+import type { TranscriptionConfig } from "../transcription-config.js";
+import type { ProviderContext, ProviderFetchOptions, ProviderResult } from "../types.js";
+export declare function fetchTwitterMediaTranscript({ context, options, transcription, attemptedProviders, notes, mediaKindHint, }: {
+    context: ProviderContext;
+    options: ProviderFetchOptions;
+    transcription: TranscriptionConfig;
+    attemptedProviders: ProviderResult["attemptedProviders"];
+    notes: string[];
+    mediaKindHint: DirectMediaKind | null;
+}): Promise<ProviderResult>;

package/dist/types/content/transcript/providers/podcast/flow-context.d.ts

@@ -1,8 +1,11 @@
+import type { TranscriptionConfig } from "../../transcription-config.js";
 import type { ProviderContext, ProviderFetchOptions, ProviderResult } from "../../types.js";
 import type { TranscribeRequest, TranscriptionResult } from "./media.js";
 export type PodcastFlowContext = {
     context: ProviderContext;
     options: ProviderFetchOptions;
+    transcription: TranscriptionConfig;
+    feedHtml: string | null;
     attemptedProviders: ProviderResult["attemptedProviders"];
     notes: string[];
     pushOnce: (provider: ProviderResult["attemptedProviders"][number]) => void;

package/dist/types/content/transcript/providers/podcast/media.d.ts

@@ -1,5 +1,5 @@
-import type { ProviderFetchOptions } from "../../types.js";
 import { type TranscriptionConfig } from "../../transcription-config.js";
+import type { ProviderFetchOptions } from "../../types.js";
 export type TranscribeRequest = {
     url: string;
     filenameHint: string;
@@ -10,7 +10,7 @@ export type TranscriptionResult = {
     provider: string | null;
     error: Error | null;
 };
-export declare function transcribeMediaUrl({ fetchImpl, transcription, env, url, filenameHint, durationSecondsHint, groqApiKey, openaiApiKey, falApiKey, notes, progress, }: {
+export declare function transcribeMediaUrl({ fetchImpl, transcription, env, url, filenameHint, durationSecondsHint, groqApiKey, assemblyaiApiKey, geminiApiKey, openaiApiKey, falApiKey, notes, progress, }: {
     fetchImpl: typeof fetch;
     transcription?: Partial<TranscriptionConfig> | null;
     env?: Record<string, string | undefined>;
@@ -18,6 +18,8 @@ export declare function transcribeMediaUrl({ fetchImpl, transcription, env, url,
     filenameHint: string;
     durationSecondsHint: number | null;
     groqApiKey?: string | null;
+    assemblyaiApiKey?: string | null;
+    geminiApiKey?: string | null;
     openaiApiKey?: string | null;
     falApiKey?: string | null;
     notes: string[];

package/dist/types/content/transcript/providers/podcast/provider-flow.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderResult } from "../../types.js";
+import type { PodcastFlowContext } from "./flow-context.js";
+export declare function tryPodcastTranscriptFromFeed(flow: PodcastFlowContext): Promise<ProviderResult | null>;
+export declare function tryFeedEnclosureTranscript(flow: PodcastFlowContext): Promise<ProviderResult | null>;
+export declare function tryOgAudioTranscript(flow: PodcastFlowContext): Promise<ProviderResult | null>;
+export declare function tryPodcastYtDlpTranscript(flow: PodcastFlowContext): Promise<ProviderResult | null>;
+export declare function buildNoTranscriptResult(flow: PodcastFlowContext): ProviderResult;

package/dist/types/content/transcript/providers/podcast/rss-feed.d.ts

@@ -0,0 +1,15 @@
+export declare function looksLikeRssOrAtomFeed(xml: string): boolean;
+export declare function extractEnclosureFromFeed(xml: string): {
+    enclosureUrl: string;
+    durationSeconds: number | null;
+} | null;
+export declare function extractEnclosureForEpisode(feedXml: string, episodeTitle: string): {
+    enclosureUrl: string;
+    durationSeconds: number | null;
+} | null;
+export declare function extractItemDurationSeconds(itemXml: string): number | null;
+export declare function decodeXmlEntities(value: string): string;
+export declare function normalizeLooseTitle(value: string): string;
+export declare function extractFeedItems(xml: string): string[];
+export declare function extractItemTitle(itemXml: string): string | null;
+export declare function extractEnclosureUrlFromItem(xml: string): string | null;

package/dist/types/content/transcript/providers/podcast/rss-transcript.d.ts

@@ -0,0 +1,12 @@
+import type { TranscriptSegment } from "../../../link-preview/types.js";
+export declare function tryFetchTranscriptFromFeedXml({ fetchImpl, feedXml, episodeTitle, notes, }: {
+    fetchImpl: typeof fetch;
+    feedXml: string;
+    episodeTitle: string | null;
+    notes: string[];
+}): Promise<{
+    text: string;
+    transcriptUrl: string;
+    transcriptType: string | null;
+    segments: TranscriptSegment[] | null;
+} | null>;

package/dist/types/content/transcript/providers/podcast/rss.d.ts

@@ -1,24 +1,2 @@
-import type { TranscriptSegment } from "../../../link-preview/types.js";
-export declare function looksLikeRssOrAtomFeed(xml: string): boolean;
-export declare function extractEnclosureFromFeed(xml: string): {
-    enclosureUrl: string;
-    durationSeconds: number | null;
-} | null;
-export declare function extractEnclosureForEpisode(feedXml: string, episodeTitle: string): {
-    enclosureUrl: string;
-    durationSeconds: number | null;
-} | null;
-export declare function extractItemDurationSeconds(itemXml: string): number | null;
-export declare function decodeXmlEntities(value: string): string;
-export declare function normalizeLooseTitle(value: string): string;
-export declare function tryFetchTranscriptFromFeedXml({ fetchImpl, feedXml, episodeTitle, notes, }: {
-    fetchImpl: typeof fetch;
-    feedXml: string;
-    episodeTitle: string | null;
-    notes: string[];
-}): Promise<{
-    text: string;
-    transcriptUrl: string;
-    transcriptType: string | null;
-    segments: TranscriptSegment[] | null;
-} | null>;
+export { decodeXmlEntities, extractEnclosureForEpisode, extractEnclosureFromFeed, extractItemDurationSeconds, looksLikeRssOrAtomFeed, normalizeLooseTitle, } from "./rss-feed.js";
+export { tryFetchTranscriptFromFeedXml } from "./rss-transcript.js";

package/dist/types/content/transcript/providers/transcription-capability.d.ts

@@ -0,0 +1,18 @@
+import type { TranscriptionConfig } from "../transcription-config.js";
+import type { ProviderResult, TranscriptSource } from "../types.js";
+import { type TranscriptionAvailability } from "./transcription-start.js";
+export type TranscriptProviderCapabilities = {
+    availability: TranscriptionAvailability;
+    canTranscribe: boolean;
+    canRunYtDlp: boolean;
+    missingProviderNote: string;
+};
+export declare function resolveTranscriptProviderCapabilities({ transcription, ytDlpPath, }: {
+    transcription: TranscriptionConfig;
+    ytDlpPath?: string | null;
+}): Promise<TranscriptProviderCapabilities>;
+export declare function buildMissingTranscriptionProviderResult(args: {
+    attemptedProviders: TranscriptSource[];
+    metadata: NonNullable<ProviderResult["metadata"]>;
+    notes?: string[] | null;
+}): ProviderResult;

package/dist/types/content/transcript/providers/transcription-start.d.ts

@@ -1,5 +1,5 @@
-import type { TranscriptionProviderHint } from "../../link-preview/deps.js";
 import { resolvePreferredOnnxModel } from "../../../transcription/onnx-cli.js";
+import type { TranscriptionProviderHint } from "../../link-preview/deps.js";
 import { type TranscriptionConfig } from "../transcription-config.js";
 type Env = Record<string, string | undefined>;
 export type TranscriptionAvailability = {
@@ -7,21 +7,29 @@ export type TranscriptionAvailability = {
     onnxReady: boolean;
     hasLocalWhisper: boolean;
     hasGroq: boolean;
+    hasAssemblyAi: boolean;
+    hasGemini: boolean;
     hasOpenai: boolean;
     hasFal: boolean;
     hasAnyProvider: boolean;
+    geminiModelId: string;
+    effectiveEnv: Env;
 };
-export declare function resolveTranscriptionAvailability({ env, transcription, groqApiKey, openaiApiKey, falApiKey, }: {
+export declare function resolveTranscriptionAvailability({ env, transcription, groqApiKey, assemblyaiApiKey, geminiApiKey, openaiApiKey, falApiKey, }: {
     env?: Env;
     transcription?: Partial<TranscriptionConfig> | null;
     groqApiKey?: string | null;
+    assemblyaiApiKey?: string | null;
+    geminiApiKey?: string | null;
     openaiApiKey?: string | null;
     falApiKey?: string | null;
 }): Promise<TranscriptionAvailability>;
-export declare function resolveTranscriptionStartInfo({ env, transcription, groqApiKey, openaiApiKey, falApiKey, }: {
+export declare function resolveTranscriptionStartInfo({ env, transcription, groqApiKey, assemblyaiApiKey, geminiApiKey, openaiApiKey, falApiKey, }: {
     env?: Env;
     transcription?: Partial<TranscriptionConfig> | null;
     groqApiKey?: string | null;
+    assemblyaiApiKey?: string | null;
+    geminiApiKey?: string | null;
     openaiApiKey?: string | null;
     falApiKey?: string | null;
 }): Promise<{

package/dist/types/content/transcript/providers/youtube/captions-player.d.ts

@@ -0,0 +1,12 @@
+export declare function extractInitialPlayerResponse(html: string): Record<string, unknown> | null;
+export declare function extractDurationSecondsFromPlayerPayload(payload: Record<string, unknown>): number | null;
+export declare function extractYoutubeDurationSeconds(html: string): number | null;
+export declare function extractInnertubeApiKey(html: string): string | null;
+export declare function fetchYoutubePlayerPayload(fetchImpl: typeof fetch, { html, videoId }: {
+    html: string;
+    videoId: string;
+}): Promise<Record<string, unknown> | null>;
+export declare function fetchYoutubeDurationSecondsViaPlayer(fetchImpl: typeof fetch, { html, videoId }: {
+    html: string;
+    videoId: string;
+}): Promise<number | null>;

package/dist/types/content/transcript/providers/youtube/captions-shared.d.ts

@@ -0,0 +1,42 @@
+import type { TranscriptSegment } from "../../../link-preview/types.js";
+export interface YoutubeTranscriptContext {
+    html: string;
+    originalUrl: string;
+    videoId: string;
+}
+export type TranscriptPayload = {
+    text: string;
+    segments: TranscriptSegment[] | null;
+};
+export declare const REQUEST_HEADERS: Record<string, string>;
+export declare const YT_INITIAL_PLAYER_RESPONSE_TOKEN = "ytInitialPlayerResponse";
+export declare const INNERTUBE_API_KEY_REGEX: RegExp;
+export declare const isObjectLike: (value: unknown) => value is Record<string, unknown>;
+export type YoutubePlayerContext = Record<string, unknown> & {
+    client?: unknown;
+};
+export type CaptionsPayload = Record<string, unknown> & {
+    captions?: unknown;
+    playerCaptionsTracklistRenderer?: unknown;
+};
+export type CaptionListRenderer = Record<string, unknown> & {
+    captionTracks?: unknown;
+    automaticCaptions?: unknown;
+};
+export type CaptionTrackRecord = Record<string, unknown> & {
+    languageCode?: unknown;
+    kind?: unknown;
+    baseUrl?: unknown;
+    url?: unknown;
+};
+export type CaptionEventRecord = Record<string, unknown> & {
+    segs?: unknown;
+    tStartMs?: unknown;
+    dDurationMs?: unknown;
+};
+export type CaptionSegmentRecord = Record<string, unknown> & {
+    utf8?: unknown;
+};
+export type CaptionPayload = {
+    events?: unknown;
+};

package/dist/types/content/transcript/providers/youtube/captions-transcript.d.ts

@@ -0,0 +1,4 @@
+import { TranscriptPayload, YoutubeTranscriptContext } from "./captions-shared.js";
+export declare const fetchTranscriptFromCaptionTracks: (fetchImpl: typeof fetch, { html, originalUrl, videoId, skipAutoGenerated, }: YoutubeTranscriptContext & {
+    skipAutoGenerated?: boolean;
+}) => Promise<TranscriptPayload | null>;

package/dist/types/content/transcript/providers/youtube/captions.d.ts

@@ -1,19 +1,2 @@
-import type { TranscriptSegment } from "../../../link-preview/types.js";
-interface YoutubeTranscriptContext {
-    html: string;
-    originalUrl: string;
-    videoId: string;
-}
-type TranscriptPayload = {
-    text: string;
-    segments: TranscriptSegment[] | null;
-};
-export declare function extractYoutubeDurationSeconds(html: string): number | null;
-export declare function fetchYoutubeDurationSecondsViaPlayer(fetchImpl: typeof fetch, { html, videoId }: {
-    html: string;
-    videoId: string;
-}): Promise<number | null>;
-export declare const fetchTranscriptFromCaptionTracks: (fetchImpl: typeof fetch, { html, originalUrl, videoId, skipAutoGenerated, }: YoutubeTranscriptContext & {
-    skipAutoGenerated?: boolean;
-}) => Promise<TranscriptPayload | null>;
-export {};
+export { extractYoutubeDurationSeconds, fetchYoutubeDurationSecondsViaPlayer, } from "./captions-player.js";
+export { fetchTranscriptFromCaptionTracks } from "./captions-transcript.js";

package/dist/types/content/transcript/providers/youtube/provider-flow.d.ts

@@ -0,0 +1,34 @@
+import type { TranscriptionConfig } from "../../transcription-config.js";
+import type { ProviderContext, ProviderFetchOptions, ProviderResult, TranscriptSource } from "../../types.js";
+type DurationMetadata = {
+    durationSeconds: number;
+} | null;
+export type YouTubeProviderFlow = {
+    context: ProviderContext;
+    options: ProviderFetchOptions;
+    transcription: TranscriptionConfig;
+    htmlText: string;
+    attemptedProviders: TranscriptSource[];
+    notes: string[];
+    effectiveVideoId: string | null;
+    durationMetadata: DurationMetadata;
+    canRunYtDlp: boolean;
+    pushHint: (hint: string) => void;
+};
+export declare function loadYoutubeHtml(context: ProviderContext, options: ProviderFetchOptions): Promise<string | null>;
+export declare function resolveEffectiveVideoId(context: ProviderContext): string | null;
+export declare function resolveDurationMetadata(args: {
+    htmlText: string;
+    effectiveVideoId: string | null;
+    url: string;
+    options: ProviderFetchOptions;
+}): Promise<DurationMetadata>;
+export declare function tryApifyTranscript(flow: YouTubeProviderFlow, hint: string): Promise<ProviderResult | null>;
+export declare function tryManualCaptionTranscript(flow: YouTubeProviderFlow): Promise<ProviderResult | null>;
+export declare function tryWebTranscript(flow: YouTubeProviderFlow): Promise<ProviderResult | null>;
+export declare function tryYtDlpTranscript(args: {
+    flow: YouTubeProviderFlow;
+    mode: ProviderFetchOptions["youtubeTranscriptMode"];
+}): Promise<ProviderResult | null>;
+export declare function buildUnavailableResult(flow: YouTubeProviderFlow): ProviderResult;
+export {};

package/dist/types/content/transcript/providers/youtube/yt-dlp.d.ts

@@ -1,6 +1,6 @@
+import { type TranscriptionProvider } from "../../../../transcription/whisper.js";
 import type { MediaCache } from "../../../cache/types.js";
 import type { LinkPreviewProgressEvent } from "../../../link-preview/deps.js";
-import { type TranscriptionProvider } from "../../../../transcription/whisper.js";
 import { type TranscriptionConfig } from "../../transcription-config.js";
 type YtDlpTranscriptResult = {
     text: string | null;
@@ -13,6 +13,8 @@ type YtDlpRequest = {
     transcription?: Partial<TranscriptionConfig> | null;
     env?: Record<string, string | undefined>;
     groqApiKey?: string | null;
+    assemblyaiApiKey?: string | null;
+    geminiApiKey?: string | null;
     openaiApiKey?: string | null;
     falApiKey?: string | null;
     url: string;
@@ -26,6 +28,6 @@ type YtDlpDurationRequest = {
     ytDlpPath: string | null;
     url: string;
 };
-export declare const fetchTranscriptWithYtDlp: ({ ytDlpPath, transcription, env, groqApiKey, openaiApiKey, falApiKey, url, onProgress, service, mediaKind, mediaCache, extraArgs, }: YtDlpRequest) => Promise<YtDlpTranscriptResult>;
+export declare const fetchTranscriptWithYtDlp: ({ ytDlpPath, transcription, env, groqApiKey, assemblyaiApiKey, geminiApiKey, openaiApiKey, falApiKey, url, onProgress, service, mediaKind, mediaCache, extraArgs, }: YtDlpRequest) => Promise<YtDlpTranscriptResult>;
 export declare const fetchDurationSecondsWithYtDlp: ({ ytDlpPath, url, }: YtDlpDurationRequest) => Promise<number | null>;
 export {};

package/dist/types/content/transcript/transcription-config.d.ts

@@ -1,15 +1,21 @@
 export type TranscriptionConfig = {
     env?: Record<string, string | undefined>;
     groqApiKey: string | null;
+    assemblyaiApiKey: string | null;
+    geminiApiKey: string | null;
     openaiApiKey: string | null;
     falApiKey: string | null;
+    geminiModel: string | null;
 };
 type TranscriptionConfigInput = {
     env?: Record<string, string | undefined>;
     transcription?: Partial<TranscriptionConfig> | null;
     groqApiKey?: string | null;
+    assemblyaiApiKey?: string | null;
+    geminiApiKey?: string | null;
     openaiApiKey?: string | null;
     falApiKey?: string | null;
+    geminiModel?: string | null;
 };
 export declare function resolveTranscriptionConfig(input: TranscriptionConfigInput): TranscriptionConfig;
 export {};

package/dist/types/content/transcript/types.d.ts

@@ -22,6 +22,7 @@ export interface ProviderFetchOptions {
     transcription?: TranscriptionConfig;
     falApiKey?: string | null;
     groqApiKey?: string | null;
+    geminiApiKey?: string | null;
     openaiApiKey?: string | null;
     mediaCache?: MediaCache | null;
     resolveTwitterCookies?: ResolveTwitterCookies | null;

package/dist/types/content/url.d.ts

@@ -1,10 +1,9 @@
+import { DIRECT_MEDIA_EXTENSIONS, inferDirectMediaKind, isDirectMediaExtension, isDirectMediaUrl, isDirectVideoInput } from "./direct-media.js";
 import { isPodcastHost } from "./link-preview/content/podcast-utils.js";
 import { isTwitterBroadcastUrl, isTwitterStatusUrl } from "./link-preview/content/twitter-utils.js";
 export declare const isYouTubeUrl: (rawUrl: string) => boolean;
-export declare const DIRECT_MEDIA_EXTENSIONS: readonly ["mp4", "mov", "m4v", "mkv", "webm", "mpeg", "mpg", "avi", "wmv", "flv", "mp3", "m4a", "wav", "flac", "aac", "ogg", "opus", "aiff", "wma"];
 export declare function isYouTubeVideoUrl(rawUrl: string): boolean;
 export declare function extractYouTubeVideoId(rawUrl: string): string | null;
-export declare function isDirectMediaUrl(url: string): boolean;
-export declare function isDirectMediaExtension(ext: string): boolean;
 export declare function shouldPreferUrlMode(url: string): boolean;
 export { isTwitterBroadcastUrl, isTwitterStatusUrl, isPodcastHost };
+export { DIRECT_MEDIA_EXTENSIONS, inferDirectMediaKind, isDirectMediaExtension, isDirectMediaUrl, isDirectVideoInput, };

package/dist/types/prompts/format.d.ts

@@ -1,5 +1,6 @@
 export type PromptOverrides = {
     promptOverride?: string | null;
+    requiredInstructions?: string[] | null;
     lengthInstruction?: string | null;
     languageInstruction?: string | null;
 };

package/dist/types/prompts/link-summary.d.ts

@@ -16,7 +16,7 @@ export type ShareContextEntry = {
     replyCount?: number | null;
     timestamp?: string | null;
 };
-export declare function buildLinkSummaryPrompt({ url, title, siteName, description, content, truncated, hasTranscript, hasTranscriptTimestamps, slides, outputLanguage, summaryLength, shares, promptOverride, lengthInstruction, languageInstruction, }: {
+export declare function buildLinkSummaryPrompt({ url, title, siteName, description, content, truncated, hasTranscript, hasTranscriptTimestamps, timestampLimitInstruction, slides, outputLanguage, summaryLength, shares, promptOverride, lengthInstruction, languageInstruction, }: {
     url: string;
     title: string | null;
     siteName: string | null;
@@ -25,6 +25,7 @@ export declare function buildLinkSummaryPrompt({ url, title, siteName, descripti
     truncated: boolean;
     hasTranscript: boolean;
     hasTranscriptTimestamps?: boolean;
+    timestampLimitInstruction?: string | null;
     slides?: {
         count: number;
         text: string;

package/dist/types/transcription/whisper/assemblyai.d.ts

@@ -0,0 +1,17 @@
+export declare const ASSEMBLYAI_DEFAULT_SPEECH_MODEL = "universal-2";
+export declare const ASSEMBLYAI_DEFAULT_MODELS: readonly ["universal-2"];
+export declare const ASSEMBLYAI_TRANSCRIPTION_MODEL_ID: "assemblyai/universal-2";
+type AssemblyAiOptions = {
+    fetchImpl?: typeof fetch;
+    baseUrl?: string;
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    mediaType?: string | null;
+};
+export declare function transcribeWithAssemblyAi(bytes: Uint8Array, mediaType: string, apiKey: string, options?: AssemblyAiOptions): Promise<string | null>;
+export declare function transcribeFileWithAssemblyAi({ filePath, mediaType, apiKey, fetchImpl, baseUrl, pollIntervalMs, timeoutMs, }: {
+    filePath: string;
+    mediaType: string;
+    apiKey: string;
+} & Pick<AssemblyAiOptions, "fetchImpl" | "baseUrl" | "pollIntervalMs" | "timeoutMs">): Promise<string | null>;
+export {};

package/dist/types/transcription/whisper/chunking.d.ts

@@ -0,0 +1,11 @@
+import type { WhisperProgressEvent, WhisperTranscriptionResult } from "./types.js";
+export declare function transcribeChunkedFile({ filePath, segmentSeconds, totalDurationSeconds, onProgress, transcribeSegment, }: {
+    filePath: string;
+    segmentSeconds: number;
+    totalDurationSeconds: number | null;
+    onProgress?: ((event: WhisperProgressEvent) => void) | null;
+    transcribeSegment: (args: {
+        bytes: Uint8Array;
+        filename: string;
+    }) => Promise<WhisperTranscriptionResult>;
+}): Promise<WhisperTranscriptionResult>;

package/dist/types/transcription/whisper/cloud-providers.d.ts

@@ -0,0 +1,22 @@
+export type CloudProvider = "assemblyai" | "gemini" | "openai" | "fal";
+type CloudProviderKeyState = {
+    assemblyaiApiKey: string | null;
+    geminiApiKey: string | null;
+    openaiApiKey: string | null;
+    falApiKey: string | null;
+};
+type CloudProviderAvailability = {
+    hasAssemblyAi: boolean;
+    hasGemini: boolean;
+    hasOpenai: boolean;
+    hasFal: boolean;
+};
+export declare function resolveCloudProviderOrder(state: CloudProviderKeyState): CloudProvider[];
+export declare function cloudProviderLabel(provider: CloudProvider, chained: boolean): string;
+export declare function formatCloudFallbackTargets(providers: CloudProvider[]): string;
+export declare function buildCloudProviderHint(availability: CloudProviderAvailability): string | null;
+export declare function buildCloudModelIdChain({ availability, geminiModelId, }: {
+    availability: CloudProviderAvailability;
+    geminiModelId: string;
+}): string | null;
+export {};

package/dist/types/transcription/whisper/core.d.ts

@@ -1,27 +1,25 @@
 import type { WhisperProgressEvent, WhisperTranscriptionResult } from "./types.js";
 type Env = Record<string, string | undefined>;
-export declare function transcribeMediaWithWhisper({ bytes, mediaType, filename, groqApiKey, skipGroq, openaiApiKey, falApiKey, totalDurationSeconds, onProgress, env, }: {
-    bytes: Uint8Array;
-    mediaType: string;
-    filename: string | null;
+type MediaRequest = {
     groqApiKey: string | null;
-    skipGroq?: boolean;
+    assemblyaiApiKey?: string | null;
+    geminiApiKey?: string | null;
     openaiApiKey: string | null;
     falApiKey: string | null;
     totalDurationSeconds?: number | null;
     onProgress?: ((event: WhisperProgressEvent) => void) | null;
     env?: Env;
-}): Promise<WhisperTranscriptionResult>;
-export declare function transcribeMediaFileWithWhisper({ filePath, mediaType, filename, groqApiKey, openaiApiKey, falApiKey, segmentSeconds, totalDurationSeconds, onProgress, env, }: {
+};
+export declare function transcribeMediaWithWhisper({ bytes, mediaType, filename, groqApiKey, skipGroq, assemblyaiApiKey, geminiApiKey, openaiApiKey, falApiKey, totalDurationSeconds, onProgress, env, }: {
+    bytes: Uint8Array;
+    mediaType: string;
+    filename: string | null;
+    skipGroq?: boolean;
+} & MediaRequest): Promise<WhisperTranscriptionResult>;
+export declare function transcribeMediaFileWithWhisper({ filePath, mediaType, filename, groqApiKey, assemblyaiApiKey, geminiApiKey, openaiApiKey, falApiKey, segmentSeconds, totalDurationSeconds, onProgress, env, }: {
     filePath: string;
     mediaType: string;
     filename: string | null;
-    groqApiKey: string | null;
-    openaiApiKey: string | null;
-    falApiKey: string | null;
     segmentSeconds?: number;
-    totalDurationSeconds?: number | null;
-    onProgress?: ((event: WhisperProgressEvent) => void) | null;
-    env?: Env;
-}): Promise<WhisperTranscriptionResult>;
+} & MediaRequest): Promise<WhisperTranscriptionResult>;
 export {};

package/dist/types/transcription/whisper/gemini.d.ts

@@ -0,0 +1,14 @@
+type Env = Record<string, string | undefined>;
+export declare function transcribeWithGemini(bytes: Uint8Array, mediaType: string, filename: string | null, apiKey: string, options?: {
+    env?: Env;
+    model?: string | null;
+}): Promise<string | null>;
+export declare function transcribeFileWithGemini({ filePath, mediaType, filename, apiKey, env, model, }: {
+    filePath: string;
+    mediaType: string;
+    filename: string | null;
+    apiKey: string;
+    env?: Env;
+    model?: string | null;
+}): Promise<string | null>;
+export {};

package/dist/types/transcription/whisper/preferences.d.ts

@@ -0,0 +1,4 @@
+type Env = Record<string, string | undefined>;
+export declare function resolveTranscriberPreference(env: Env): "auto" | "whisper" | "parakeet" | "canary";
+export declare function resolveOnnxModelPreference(env: Env): "parakeet" | "canary" | null;
+export {};