@steipete/summarize-core 0.11.0 → 0.12.0

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,28 @@ export type TranscriptionAvailability = {
     onnxReady: boolean;
     hasLocalWhisper: boolean;
     hasGroq: boolean;
+    hasAssemblyAi: boolean;
+    hasGemini: boolean;
     hasOpenai: boolean;
     hasFal: boolean;
     hasAnyProvider: boolean;
+    geminiModelId: string;
 };
-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/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 {};

package/dist/types/transcription/whisper/provider-setup.d.ts

@@ -0,0 +1,30 @@
+type Env = Record<string, string | undefined>;
+export declare const DEFAULT_GEMINI_TRANSCRIPTION_MODEL = "gemini-2.5-flash";
+export declare const GEMINI_TRANSCRIPTION_MODEL_ENV = "SUMMARIZE_GEMINI_TRANSCRIPTION_MODEL";
+export declare const TRANSCRIPTION_PROVIDER_ENV_LIST: readonly ["GROQ_API_KEY", "ASSEMBLYAI_API_KEY", "GEMINI_API_KEY", "OPENAI_API_KEY", "FAL_KEY"];
+export declare const TRANSCRIPTION_PROVIDER_ENV_LABEL = "GROQ_API_KEY, ASSEMBLYAI_API_KEY, GEMINI_API_KEY, OPENAI_API_KEY, or FAL_KEY";
+export declare function normalizeApiKey(raw: string | null | undefined): string | null;
+export declare function resolveGeminiApiKey({ env, geminiApiKey, }: {
+    env?: Env;
+    geminiApiKey?: string | null;
+}): string | null;
+export declare function resolveGroqApiKey({ env, groqApiKey, }: {
+    env?: Env;
+    groqApiKey?: string | null;
+}): string | null;
+export declare function resolveAssemblyAiApiKey({ env, assemblyaiApiKey, }: {
+    env?: Env;
+    assemblyaiApiKey?: string | null;
+}): string | null;
+export declare function resolveOpenAiTranscriptionApiKey({ env, openaiApiKey, }: {
+    env?: Env;
+    openaiApiKey?: string | null;
+}): string | null;
+export declare function resolveFalApiKey({ env, falApiKey, }: {
+    env?: Env;
+    falApiKey?: string | null;
+}): string | null;
+export declare function resolveGeminiTranscriptionModel(env?: Env): string;
+export declare function buildMissingTranscriptionProviderMessage(): string;
+export declare function buildMissingTranscriptionProviderNote(): string;
+export {};

package/dist/types/transcription/whisper/remote-provider-attempts.d.ts

@@ -0,0 +1,51 @@
+import type { CloudProvider } from "./cloud-providers.js";
+import type { WhisperProgressEvent, WhisperTranscriptionResult } from "./types.js";
+type Env = Record<string, string | undefined>;
+export type RemoteByteState = {
+    bytes: Uint8Array;
+    mediaType: string;
+    filename: string | null;
+};
+type RemoteByteAttemptResult = {
+    state: RemoteByteState;
+    result: WhisperTranscriptionResult | null;
+    error: Error | null;
+    skipped?: boolean;
+};
+type RemoteFileAttemptResult = {
+    kind: "result";
+    result: WhisperTranscriptionResult;
+} | {
+    kind: "error";
+    error: Error;
+} | {
+    kind: "delegate-to-bytes";
+};
+type TranscribeOversizedBytesWithChunking = (args: {
+    bytes: Uint8Array;
+    mediaType: string;
+    filename: string | null;
+    onProgress?: ((event: WhisperProgressEvent) => void) | null;
+}) => Promise<WhisperTranscriptionResult>;
+export declare function attemptRemoteBytesProvider(args: {
+    provider: CloudProvider;
+    state: RemoteByteState;
+    assemblyaiApiKey: string | null;
+    geminiApiKey: string | null;
+    openaiApiKey: string | null;
+    falApiKey: string | null;
+    env: Env;
+    notes: string[];
+    onProgress?: ((event: WhisperProgressEvent) => void) | null;
+    transcribeOversizedBytesWithChunking?: TranscribeOversizedBytesWithChunking;
+}): Promise<RemoteByteAttemptResult>;
+export declare function attemptRemoteFileProvider(args: {
+    provider: CloudProvider;
+    filePath: string;
+    mediaType: string;
+    filename: string | null;
+    assemblyaiApiKey: string | null;
+    geminiApiKey: string | null;
+    env: Env;
+}): Promise<RemoteFileAttemptResult>;
+export {};

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

@@ -0,0 +1,51 @@
+import type { WhisperProgressEvent, WhisperTranscriptionResult } from "./types.js";
+type Env = Record<string, string | undefined>;
+type CloudArgs = {
+    groqApiKey: string | null;
+    groqError?: Error | null;
+    assemblyaiApiKey: string | null;
+    geminiApiKey: string | null;
+    openaiApiKey: string | null;
+    falApiKey: string | null;
+    env: Env;
+};
+export declare function transcribeBytesWithRemoteFallbacks({ bytes, mediaType, filename, notes, groqApiKey, groqError, assemblyaiApiKey, geminiApiKey, openaiApiKey, falApiKey, env, onProgress, transcribeOversizedBytesWithChunking, }: {
+    bytes: Uint8Array;
+    mediaType: string;
+    filename: string | null;
+    notes: string[];
+    onProgress?: ((event: WhisperProgressEvent) => void) | null;
+    transcribeOversizedBytesWithChunking: (args: {
+        bytes: Uint8Array;
+        mediaType: string;
+        filename: string | null;
+        onProgress?: ((event: WhisperProgressEvent) => void) | null;
+    }) => Promise<WhisperTranscriptionResult>;
+} & CloudArgs): Promise<WhisperTranscriptionResult>;
+export declare function transcribeFileWithRemoteFallbacks({ filePath, mediaType, filename, notes, groqApiKey, groqError, assemblyaiApiKey, geminiApiKey, openaiApiKey, falApiKey, env, totalDurationSeconds, onProgress, transcribeChunkedFile, }: {
+    filePath: string;
+    mediaType: string;
+    filename: string | null;
+    notes: string[];
+    totalDurationSeconds: number | null;
+    onProgress?: ((event: WhisperProgressEvent) => void) | null;
+    transcribeChunkedFile: (args: {
+        filePath: string;
+        segmentSeconds: number;
+        totalDurationSeconds: number | null;
+        onProgress?: ((event: WhisperProgressEvent) => void) | null;
+    }) => Promise<WhisperTranscriptionResult>;
+} & CloudArgs): Promise<WhisperTranscriptionResult>;
+export declare function transcribeOversizedBytesViaTempFile({ bytes, mediaType, filename, onProgress, transcribeFile, }: {
+    bytes: Uint8Array;
+    mediaType: string;
+    filename: string | null;
+    onProgress?: ((event: WhisperProgressEvent) => void) | null;
+    transcribeFile: (args: {
+        filePath: string;
+        mediaType: string;
+        filename: string | null;
+        onProgress?: ((event: WhisperProgressEvent) => void) | null;
+    }) => Promise<WhisperTranscriptionResult>;
+}): Promise<WhisperTranscriptionResult>;
+export {};

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

@@ -1,4 +1,4 @@
-export type TranscriptionProvider = "groq" | "openai" | "fal" | "whisper.cpp" | "onnx-parakeet" | "onnx-canary";
+export type TranscriptionProvider = "groq" | "assemblyai" | "gemini" | "openai" | "fal" | "whisper.cpp" | "onnx-parakeet" | "onnx-canary";
 export type WhisperTranscriptionResult = {
     text: string | null;
     provider: TranscriptionProvider | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/summarize-core",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Summarize core library (content extraction + prompts).",
   "files": [
     "dist",
@@ -36,28 +36,27 @@
       "import": "./dist/esm/language.js"
     }
   },
-  "scripts": {
-    "build": "pnpm clean && tsc -p tsconfig.build.json",
-    "clean": "rimraf dist",
-    "typecheck": "tsc -p tsconfig.build.json --noEmit"
-  },
   "dependencies": {
-    "@fal-ai/client": "^1.9.1",
+    "@fal-ai/client": "^1.9.4",
     "@mozilla/readability": "0.6.0",
     "cheerio": "^1.2.0",
-    "es-toolkit": "^1.44.0",
-    "jsdom": "28.0.0",
-    "sanitize-html": "^2.17.0"
+    "es-toolkit": "^1.45.1",
+    "jsdom": "28.1.0",
+    "sanitize-html": "^2.17.1"
   },
   "devDependencies": {
-    "@types/jsdom": "^27.0.0",
-    "@types/node": "^25.2.3",
-    "@types/sanitize-html": "^2.16.0",
-    "rimraf": "^6.1.2",
+    "@types/jsdom": "^28.0.0",
+    "@types/node": "^25.3.5",
+    "@types/sanitize-html": "^2.16.1",
+    "rimraf": "^6.1.3",
     "typescript": "^5.9.3"
   },
   "engines": {
     "node": ">=22"
   },
-  "packageManager": "pnpm@10.25.0+sha512.5e82639027af37cf832061bcc6d639c219634488e0f2baebe785028a793de7b525ffcd3f7ff574f5e9860654e098fe852ba8ac5dd5cefe1767d23a020a92f501"
-}
+  "scripts": {
+    "build": "pnpm clean && tsc -p tsconfig.build.json",
+    "clean": "rimraf dist",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit"
+  }
+}