@steipete/summarize 0.11.1 → 0.13.0

package/dist/types/run/flows/url/progress-status-state.d.ts

@@ -0,0 +1,17 @@
+export type UrlProgressStatusState = {
+    summaryText: string | null;
+    slidesActive: boolean;
+    slidesText: string | null;
+    lastSlideRenderAt: number;
+};
+export declare function createUrlProgressStatusState(): UrlProgressStatusState;
+export declare function applySummaryText(state: UrlProgressStatusState, text: string): {
+    renderText: string | null;
+};
+export declare function applySlidesText(state: UrlProgressStatusState, text: string, nowMs: number): {
+    renderText: string | null;
+};
+export declare function clearSlidesText(state: UrlProgressStatusState): {
+    renderText: string | null;
+    summaryText: string | null;
+};

package/dist/types/run/flows/url/progress-status.d.ts

@@ -0,0 +1,17 @@
+import type { OscProgressController } from "../../../tty/osc-progress.js";
+export declare function createUrlProgressStatus({ enabled, spinner, oscProgress, now, }: {
+    enabled: boolean;
+    spinner: {
+        setText: (text: string) => void;
+        refresh?: () => void;
+    };
+    oscProgress: OscProgressController;
+    now?: () => number;
+}): {
+    setSummary(text: string, oscLabel?: string | null): void;
+    setSlides(text: string, percent?: number | null): void;
+    clearSlides(): void;
+    isSlidesActive(): boolean;
+    getSummaryText(): string | null;
+    getSlidesText(): string | null;
+};

package/dist/types/run/flows/url/slides-output-render.d.ts

@@ -0,0 +1,43 @@
+import type { SlideExtractionResult } from "../../../slides/index.js";
+import type { SlideState } from "./slides-output-state.js";
+export declare function createInlineSlidesUnsupportedNotifier({ inlineNoticeEnabled, flags, io, richTty, clearProgressForStdout, restoreProgressAfterStdout, }: {
+    inlineNoticeEnabled: boolean;
+    flags: {
+        plain: boolean;
+    };
+    io: {
+        stderr: NodeJS.WritableStream;
+    };
+    richTty: boolean;
+    clearProgressForStdout: () => void;
+    restoreProgressAfterStdout?: (() => void) | null;
+}): (nextSlides: SlideExtractionResult) => void;
+export declare function createSlidesTerminalRenderer({ io, flags, inlineEnabled, richTty, inlineRenderer, labelTheme, clearProgressForStdout, restoreProgressAfterStdout, onProgressText, getOrder, getSlide, getSourceUrl, waitForSlide, initialSlides, }: {
+    io: {
+        stdout: NodeJS.WritableStream;
+    };
+    flags: {
+        slidesDebug?: boolean;
+    };
+    inlineEnabled: boolean;
+    richTty: boolean;
+    inlineRenderer: {
+        renderSlide: (slide: {
+            index: number;
+            timestamp: number;
+            imagePath: string;
+        }, title?: string | null) => Promise<boolean>;
+    } | null;
+    labelTheme: {
+        dim: (text: string) => string;
+        heading: (text: string) => string;
+    };
+    clearProgressForStdout: () => void;
+    restoreProgressAfterStdout?: (() => void) | null;
+    onProgressText?: ((text: string) => void) | null;
+    getOrder: () => number[];
+    getSlide: (index: number) => SlideState | null;
+    getSourceUrl: () => string;
+    waitForSlide: (index: number) => Promise<SlideState | null>;
+    initialSlides: SlideExtractionResult | null | undefined;
+}): (index: number, title?: string | null) => Promise<void>;

package/dist/types/run/flows/url/slides-output-state.d.ts

@@ -0,0 +1,21 @@
+import type { SlideImage, SlideExtractionResult } from "../../../slides/index.js";
+import type { SlideTimelineEntry } from "./slides-text.js";
+export type SlideState = SlideTimelineEntry & {
+    imagePath: string | null;
+};
+export declare function createSlideOutputState(initialSlides: SlideExtractionResult | null | undefined): {
+    setMeta: (meta: {
+        slidesDir?: string | null;
+        sourceUrl?: string | null;
+    }) => void;
+    updateFromSlides: (slides: SlideExtractionResult) => void;
+    updateSlideEntry: (slide: SlideImage) => void;
+    waitForSlide: (index: number) => Promise<SlideState | null>;
+    markDone: () => void;
+    getSlides: () => SlideState[];
+    getSlide: (index: number) => SlideState | null;
+    getOrder: () => number[];
+    getSlidesDir: () => string;
+    getSourceUrl: () => string;
+    isDone: () => boolean;
+};

package/dist/types/run/flows/url/slides-output-stream.d.ts

@@ -0,0 +1,18 @@
+import { type StreamOutputMode } from "../../stream-output.js";
+import type { SummaryStreamHandler } from "../../summary-engine.js";
+export declare function createSlidesSummaryStreamHandler({ stdout, env, envForRun, plain, outputMode, clearProgressForStdout, restoreProgressAfterStdout, renderSlide, getSlideIndexOrder, getSlideMeta, debugWrite, }: {
+    stdout: NodeJS.WritableStream;
+    env: Record<string, string | undefined>;
+    envForRun: Record<string, string | undefined>;
+    plain: boolean;
+    outputMode: StreamOutputMode;
+    clearProgressForStdout: () => void;
+    restoreProgressAfterStdout?: (() => void) | null;
+    renderSlide: (index: number, title?: string | null) => Promise<void>;
+    getSlideIndexOrder: () => number[];
+    getSlideMeta?: ((index: number) => {
+        total: number;
+        timestamp: number | null;
+    }) | null;
+    debugWrite?: ((text: string) => void) | null;
+}): SummaryStreamHandler;

package/dist/types/run/flows/url/slides-output.d.ts

@@ -1,8 +1,9 @@
 import type { ExtractedLinkContent } from "../../../content/index.js";
 import type { SummaryLength } from "../../../shared/contracts.js";
 import type { SlideExtractionResult, SlideImage, SlideSourceKind } from "../../../slides/index.js";
+import type { StreamOutputMode } from "../../stream-output.js";
 import type { SummaryStreamHandler } from "../../summary-engine.js";
-import { type StreamOutputMode } from "../../stream-output.js";
+export { createSlidesSummaryStreamHandler } from "./slides-output-stream.js";
 export type SlidesTerminalOutput = {
     onSlidesExtracted: (slides: SlideExtractionResult) => void;
     onSlidesDone: (result: {
@@ -48,19 +49,3 @@ export declare function createSlidesTerminalOutput({ io, flags, extracted, slide
     restoreProgressAfterStdout?: (() => void) | null;
     onProgressText?: ((text: string) => void) | null;
 }): SlidesTerminalOutput | null;
-export declare function createSlidesSummaryStreamHandler({ stdout, env, envForRun, plain, outputMode, clearProgressForStdout, restoreProgressAfterStdout, renderSlide, getSlideIndexOrder, getSlideMeta, debugWrite, }: {
-    stdout: NodeJS.WritableStream;
-    env: Record<string, string | undefined>;
-    envForRun: Record<string, string | undefined>;
-    plain: boolean;
-    outputMode: StreamOutputMode;
-    clearProgressForStdout: () => void;
-    restoreProgressAfterStdout?: (() => void) | null;
-    renderSlide: (index: number, title?: string | null) => Promise<void>;
-    getSlideIndexOrder: () => number[];
-    getSlideMeta?: ((index: number) => {
-        total: number;
-        timestamp: number | null;
-    }) | null;
-    debugWrite?: ((text: string) => void) | null;
-}): SummaryStreamHandler;

package/dist/types/run/flows/url/slides-session.d.ts

@@ -0,0 +1,26 @@
+import type { ExtractedLinkContent } from "../../../content/index.js";
+import { type SlideExtractionResult } from "../../../slides/index.js";
+import { type SlidesTerminalOutput } from "./slides-output.js";
+import { type UrlFlowContext } from "./types.js";
+type ProgressStatusLike = {
+    clearSlides: () => void;
+    setSlides: (text: string, percent?: number | null) => void;
+};
+export type UrlSlidesSession = {
+    getSlidesExtracted: () => SlideExtractionResult | null;
+    runSlidesExtraction: () => Promise<SlideExtractionResult | null>;
+    slidesOutput: SlidesTerminalOutput | null;
+    slidesTimelinePromise: Promise<SlideExtractionResult | null> | null;
+    setExtracted: (value: ExtractedLinkContent) => void;
+};
+export declare function createUrlSlidesSession({ ctx, url, extracted: initialExtracted, cacheStore, progressStatus, renderStatus, renderStatusFromText, updateSummaryProgress, }: {
+    ctx: UrlFlowContext;
+    url: string;
+    extracted: ExtractedLinkContent;
+    cacheStore: UrlFlowContext["cache"]["store"] | null;
+    progressStatus: ProgressStatusLike;
+    renderStatus: (label: string, detail?: string) => string;
+    renderStatusFromText: (text: string) => string;
+    updateSummaryProgress: () => void;
+}): UrlSlidesSession;
+export {};

package/dist/types/run/flows/url/slides-text-markdown.d.ts

@@ -0,0 +1,46 @@
+import type { SummaryLength } from "../../../shared/contracts.js";
+import type { SlideTimelineEntry } from "./slides-text-types.js";
+export declare const splitSlideTitleFromText: ({ text, }: {
+    text: string;
+    slideIndex: number;
+    total: number;
+}) => {
+    title: string | null;
+    body: string;
+};
+export declare const ensureSlideTitleLine: ({ text, slide, total, }: {
+    text: string;
+    slide: SlideTimelineEntry;
+    total: number;
+}) => string;
+export declare function findSlidesSectionStart(markdown: string): number | null;
+export declare function splitSummaryFromSlides(markdown: string): {
+    summary: string;
+    slidesSection: string | null;
+};
+export declare function parseSlideSummariesFromMarkdown(markdown: string): Map<number, string>;
+export declare function extractSlideMarkers(markdown: string): number[];
+export declare function normalizeSummarySlideHeadings(markdown: string): string;
+export declare function buildSlideTextFallback({ slides, transcriptTimedText, lengthArg, }: {
+    slides: SlideTimelineEntry[];
+    transcriptTimedText: string | null | undefined;
+    lengthArg: {
+        kind: "preset";
+        preset: SummaryLength;
+    } | {
+        kind: "chars";
+        maxCharacters: number;
+    };
+}): Map<number, string>;
+export declare function coerceSummaryWithSlides({ markdown, slides, transcriptTimedText, lengthArg, }: {
+    markdown: string;
+    slides: SlideTimelineEntry[];
+    transcriptTimedText?: string | null;
+    lengthArg: {
+        kind: "preset";
+        preset: SummaryLength;
+    } | {
+        kind: "chars";
+        maxCharacters: number;
+    };
+}): string;

package/dist/types/run/flows/url/slides-text-transcript.d.ts

@@ -0,0 +1,36 @@
+import type { SummaryLength } from "../../../shared/contracts.js";
+import type { SlideTimelineEntry, TranscriptSegment } from "./slides-text-types.js";
+export declare function interleaveSlidesIntoTranscript({ transcriptTimedText, slides, }: {
+    transcriptTimedText: string;
+    slides: SlideTimelineEntry[];
+}): string;
+export declare function parseTranscriptTimedText(input: string | null | undefined): TranscriptSegment[];
+export declare function formatTimestamp(seconds: number): string;
+export declare function resolveSlideTextBudget({ lengthArg, slideCount, }: {
+    lengthArg: {
+        kind: "preset";
+        preset: SummaryLength;
+    } | {
+        kind: "chars";
+        maxCharacters: number;
+    };
+    slideCount: number;
+}): number;
+export declare function resolveSlideWindowSeconds({ lengthArg, }: {
+    lengthArg: {
+        kind: "preset";
+        preset: SummaryLength;
+    } | {
+        kind: "chars";
+        maxCharacters: number;
+    };
+}): number;
+export declare function getTranscriptTextForSlide({ slide, nextSlide, segments, budget, windowSeconds, }: {
+    slide: SlideTimelineEntry;
+    nextSlide: SlideTimelineEntry | null;
+    segments: TranscriptSegment[];
+    budget: number;
+    windowSeconds: number;
+}): string;
+export declare function formatOsc8Link(label: string, url: string | null, enabled: boolean): string;
+export declare function buildTimestampUrl(sourceUrl: string, seconds: number): string | null;

package/dist/types/run/flows/url/slides-text-types.d.ts

@@ -0,0 +1,8 @@
+export type TranscriptSegment = {
+    startSeconds: number;
+    text: string;
+};
+export type SlideTimelineEntry = {
+    index: number;
+    timestamp: number;
+};

package/dist/types/run/flows/url/slides-text.d.ts

@@ -1,87 +1,3 @@
-import type { SummaryLength } from "../../../shared/contracts.js";
-export type TranscriptSegment = {
-    startSeconds: number;
-    text: string;
-};
-export type SlideTimelineEntry = {
-    index: number;
-    timestamp: number;
-};
-export declare const splitSlideTitleFromText: ({ text, }: {
-    text: string;
-    slideIndex: number;
-    total: number;
-}) => {
-    title: string | null;
-    body: string;
-};
-export declare const ensureSlideTitleLine: ({ text, slide, total, }: {
-    text: string;
-    slide: SlideTimelineEntry;
-    total: number;
-}) => string;
-export declare function findSlidesSectionStart(markdown: string): number | null;
-export declare function splitSummaryFromSlides(markdown: string): {
-    summary: string;
-    slidesSection: string | null;
-};
-export declare function parseSlideSummariesFromMarkdown(markdown: string): Map<number, string>;
-export declare function extractSlideMarkers(markdown: string): number[];
-export declare function normalizeSummarySlideHeadings(markdown: string): string;
-export declare function buildSlideTextFallback({ slides, transcriptTimedText, lengthArg, }: {
-    slides: SlideTimelineEntry[];
-    transcriptTimedText: string | null | undefined;
-    lengthArg: {
-        kind: "preset";
-        preset: SummaryLength;
-    } | {
-        kind: "chars";
-        maxCharacters: number;
-    };
-}): Map<number, string>;
-export declare function coerceSummaryWithSlides({ markdown, slides, transcriptTimedText, lengthArg, }: {
-    markdown: string;
-    slides: SlideTimelineEntry[];
-    transcriptTimedText?: string | null;
-    lengthArg: {
-        kind: "preset";
-        preset: SummaryLength;
-    } | {
-        kind: "chars";
-        maxCharacters: number;
-    };
-}): string;
-export declare function interleaveSlidesIntoTranscript({ transcriptTimedText, slides, }: {
-    transcriptTimedText: string;
-    slides: SlideTimelineEntry[];
-}): string;
-export declare function parseTranscriptTimedText(input: string | null | undefined): TranscriptSegment[];
-export declare function formatTimestamp(seconds: number): string;
-export declare function resolveSlideTextBudget({ lengthArg, slideCount, }: {
-    lengthArg: {
-        kind: "preset";
-        preset: SummaryLength;
-    } | {
-        kind: "chars";
-        maxCharacters: number;
-    };
-    slideCount: number;
-}): number;
-export declare function resolveSlideWindowSeconds({ lengthArg, }: {
-    lengthArg: {
-        kind: "preset";
-        preset: SummaryLength;
-    } | {
-        kind: "chars";
-        maxCharacters: number;
-    };
-}): number;
-export declare function getTranscriptTextForSlide({ slide, nextSlide, segments, budget, windowSeconds, }: {
-    slide: SlideTimelineEntry;
-    nextSlide: SlideTimelineEntry | null;
-    segments: TranscriptSegment[];
-    budget: number;
-    windowSeconds: number;
-}): string;
-export declare function formatOsc8Link(label: string, url: string | null, enabled: boolean): string;
-export declare function buildTimestampUrl(sourceUrl: string, seconds: number): string | null;
+export type { SlideTimelineEntry, TranscriptSegment } from "./slides-text-types.js";
+export { buildSlideTextFallback, coerceSummaryWithSlides, ensureSlideTitleLine, extractSlideMarkers, findSlidesSectionStart, normalizeSummarySlideHeadings, parseSlideSummariesFromMarkdown, splitSlideTitleFromText, splitSummaryFromSlides, } from "./slides-text-markdown.js";
+export { buildTimestampUrl, formatOsc8Link, formatTimestamp, getTranscriptTextForSlide, interleaveSlidesIntoTranscript, parseTranscriptTimedText, resolveSlideTextBudget, resolveSlideWindowSeconds, } from "./slides-text-transcript.js";

package/dist/types/run/flows/url/summary-finish.d.ts

@@ -0,0 +1,16 @@
+import type { ExtractedLinkContent } from "../../../content/index.js";
+import type { ModelAttempt } from "../../types.js";
+import type { UrlFlowContext } from "./types.js";
+export declare function buildFinishExtras({ extracted, metricsDetailed, transcriptionCostLabel, }: {
+    extracted: ExtractedLinkContent;
+    metricsDetailed: boolean;
+    transcriptionCostLabel: string | null;
+}): string[] | null;
+export declare function pickModelForFinishLine(llmCalls: UrlFlowContext["model"]["llmCalls"], fallback: string | null): string | null;
+export declare function buildModelMetaFromAttempt(attempt: ModelAttempt): {
+    provider: "cli";
+    canonical: string;
+} | {
+    provider: import("../../../llm/model-id.js").LlmProvider;
+    canonical: string;
+};

package/dist/types/run/flows/url/summary-json.d.ts

@@ -0,0 +1,51 @@
+import type { UrlFlowContext } from "./types.js";
+export declare function buildUrlJsonInput(options: {
+    flags: UrlFlowContext["flags"];
+    url: string;
+    effectiveMarkdownMode: "off" | "auto" | "llm" | "readability";
+    modelLabel: string | null;
+}): {
+    kind: "url";
+    url: string;
+    timeoutMs: number;
+    youtube: "auto" | "web" | "apify" | "yt-dlp" | "no-auto";
+    firecrawl: "auto" | "off" | "always";
+    format: "text" | "markdown";
+    markdown: "auto" | "off" | "llm" | "readability";
+    timestamps: boolean;
+    length: {
+        kind: "preset";
+        preset: "short" | "medium" | "long" | "xl" | "xxl";
+        maxCharacters?: undefined;
+    } | {
+        kind: "chars";
+        maxCharacters: number;
+        preset?: undefined;
+    };
+    maxOutputTokens: number | null;
+    model: string | null;
+    language: {
+        mode: "auto";
+    } | {
+        mode: "fixed";
+        tag: string;
+        label: string;
+    };
+};
+export declare function buildUrlJsonEnv(apiStatus: {
+    xaiApiKey: string | null;
+    apiKey: string | null;
+    openrouterApiKey: string | null;
+    apifyToken: string | null;
+    firecrawlConfigured: boolean;
+    googleConfigured: boolean;
+    anthropicConfigured: boolean;
+}): {
+    hasXaiKey: boolean;
+    hasOpenAIKey: boolean;
+    hasOpenRouterKey: boolean;
+    hasApifyToken: boolean;
+    hasFirecrawlKey: boolean;
+    hasGoogleKey: boolean;
+    hasAnthropicKey: boolean;
+};

package/dist/types/run/flows/url/summary-prompt.d.ts

@@ -0,0 +1,22 @@
+import type { ExtractedLinkContent } from "../../../content/index.js";
+import type { UrlFlowContext } from "./types.js";
+type SlidesResult = Awaited<ReturnType<typeof import("../../../slides/index.js").extractSlidesForSource>>;
+export declare function shouldBypassShortContentSummary({ extracted, lengthArg, forceSummary, maxOutputTokensArg, json, countTokens, }: {
+    extracted: ExtractedLinkContent;
+    lengthArg: UrlFlowContext["flags"]["lengthArg"];
+    forceSummary: boolean;
+    maxOutputTokensArg: number | null;
+    json: boolean;
+    countTokens: (value: string) => number;
+}): boolean;
+export declare function buildUrlPrompt({ extracted, outputLanguage, lengthArg, promptOverride, lengthInstruction, languageInstruction, slides, buildSummaryTimestampLimitInstruction, }: {
+    extracted: ExtractedLinkContent;
+    outputLanguage: UrlFlowContext["flags"]["outputLanguage"];
+    lengthArg: UrlFlowContext["flags"]["lengthArg"];
+    promptOverride?: string | null;
+    lengthInstruction?: string | null;
+    languageInstruction?: string | null;
+    slides?: SlidesResult | null;
+    buildSummaryTimestampLimitInstruction: (extracted: ExtractedLinkContent) => string | null;
+}): string;
+export {};

package/dist/types/run/flows/url/summary-resolution.d.ts

@@ -0,0 +1,31 @@
+import type { ExtractedLinkContent } from "../../../content/index.js";
+import type { ModelAttempt } from "../../types.js";
+import type { SlidesTerminalOutput } from "./slides-output.js";
+import { buildModelMetaFromAttempt } from "./summary-finish.js";
+import type { UrlFlowContext } from "./types.js";
+type SlidesResult = Awaited<ReturnType<typeof import("../../../slides/index.js").extractSlidesForSource>>;
+type SummaryResolutionUseExtracted = {
+    kind: "use-extracted";
+    footerLabel: string;
+    verboseMessage: string | null;
+};
+type SummaryResolutionSummary = {
+    kind: "summary";
+    normalizedSummary: string;
+    summaryAlreadyPrinted: boolean;
+    summaryFromCache: boolean;
+    usedAttempt: ModelAttempt;
+    modelMeta: ReturnType<typeof buildModelMetaFromAttempt>;
+    maxOutputTokensForCall: number | null;
+};
+export type UrlSummaryResolution = SummaryResolutionUseExtracted | SummaryResolutionSummary;
+export declare function resolveUrlSummaryExecution({ ctx, url, extracted, prompt, onModelChosen, slides, slidesOutput, }: {
+    ctx: UrlFlowContext;
+    url: string;
+    extracted: ExtractedLinkContent;
+    prompt: string;
+    onModelChosen?: ((modelId: string) => void) | null;
+    slides?: SlidesResult | null;
+    slidesOutput?: SlidesTerminalOutput | null;
+}): Promise<UrlSummaryResolution>;
+export {};

package/dist/types/run/flows/url/summary-timestamps.d.ts

@@ -0,0 +1,11 @@
+import type { ExtractedLinkContent } from "../../../content/index.js";
+export declare function buildSummaryTimestampLimitInstruction(extracted: Pick<ExtractedLinkContent, "transcriptSegments" | "transcriptTimedText" | "mediaDurationSeconds">): string | null;
+export declare function resolveSummaryTimestampUpperBound(extracted: Pick<ExtractedLinkContent, "transcriptSegments" | "transcriptTimedText" | "mediaDurationSeconds">): number | null;
+export declare function shouldSanitizeSummaryKeyMoments({ extracted, hasSlides, }: {
+    extracted: Pick<ExtractedLinkContent, "transcriptSegments" | "transcriptTimedText" | "mediaDurationSeconds">;
+    hasSlides: boolean;
+}): boolean;
+export declare function sanitizeSummaryKeyMoments({ markdown, maxSeconds, }: {
+    markdown: string;
+    maxSeconds: number | null;
+}): string;

package/dist/types/run/flows/url/types.d.ts

@@ -80,6 +80,7 @@ export type UrlFlowModel = {
     apiStatus: {
         xaiApiKey: string | null;
         apiKey: string | null;
+        nvidiaApiKey: string | null;
         openrouterApiKey: string | null;
         openrouterConfigured: boolean;
         googleApiKey: string | null;
@@ -88,12 +89,14 @@ export type UrlFlowModel = {
         anthropicConfigured: boolean;
         providerBaseUrls: {
             openai: string | null;
+            nvidia: string | null;
             anthropic: string | null;
             google: string | null;
             xai: string | null;
         };
         zaiApiKey: string | null;
         zaiBaseUrl: string;
+        nvidiaBaseUrl: string;
         firecrawlConfigured: boolean;
         firecrawlApiKey: string | null;
         apifyToken: string | null;
@@ -101,6 +104,7 @@ export type UrlFlowModel = {
         ytDlpCookiesFromBrowser: string | null;
         falApiKey: string | null;
         groqApiKey: string | null;
+        assemblyaiApiKey: string | null;
         openaiTranscriptionKey: string | null;
     };
     summaryEngine: ReturnType<typeof createSummaryEngine>;
@@ -138,6 +142,22 @@ export type UrlFlowHooks = {
     buildReport: () => Promise<RunMetricsReport>;
     estimateCostUsd: () => Promise<number | null>;
 };
+export type UrlFlowEventHooks = Pick<UrlFlowHooks, "onModelChosen" | "onExtracted" | "onSlidesExtracted" | "onSlidesProgress" | "onSlidesDone" | "onSlideChunk" | "onLinkPreviewProgress" | "onSummaryCached">;
+export type UrlFlowRuntimeHooks = Pick<UrlFlowHooks, "setTranscriptionCost" | "summarizeAsset" | "writeViaFooter" | "clearProgressForStdout" | "restoreProgressAfterStdout" | "setClearProgressBeforeStdout" | "clearProgressIfCurrent" | "buildReport" | "estimateCostUsd">;
+export declare function createUrlFlowHooks(options: {
+    runtime: UrlFlowRuntimeHooks;
+    events?: Partial<UrlFlowEventHooks>;
+}): UrlFlowHooks;
+export declare function composeUrlFlowHooks(base: UrlFlowHooks, overrides: Partial<UrlFlowHooks>): UrlFlowHooks;
+export declare function createUrlFlowContext(options: {
+    io: UrlFlowIo;
+    flags: UrlFlowFlags;
+    model: UrlFlowModel;
+    cache: CacheState;
+    mediaCache: MediaCache | null;
+    runtimeHooks: UrlFlowRuntimeHooks;
+    eventHooks?: Partial<UrlFlowEventHooks>;
+}): UrlFlowContext;
 /**
  * Wiring struct for `runUrlFlow`.
  * CLI runner populates the full surface; daemon uses a smaller subset (no TTY/progress/footer),

package/dist/types/run/flows/url/video-only.d.ts

@@ -0,0 +1,27 @@
+import { type ExtractedLinkContent } from "../../../content/index.js";
+import type { SlideExtractionResult } from "../../../slides/index.js";
+import { type UrlExtractionUi } from "./extract.js";
+import type { UrlFlowContext } from "./types.js";
+export type VideoOnlyResult = {
+    handled: true;
+} | {
+    handled: false;
+    extracted: ExtractedLinkContent;
+    extractionUi: UrlExtractionUi;
+};
+export declare function handleVideoOnlyExtractedContent({ ctx, extracted, extractionUi, isYoutubeUrl, fetchWithCache, runSlidesExtraction, renderStatus, renderStatusWithMeta, spinner, styleDim, updateSummaryProgress, accent, }: {
+    ctx: UrlFlowContext;
+    extracted: ExtractedLinkContent;
+    extractionUi: UrlExtractionUi;
+    isYoutubeUrl: boolean;
+    fetchWithCache: (url: string) => Promise<ExtractedLinkContent>;
+    runSlidesExtraction: () => Promise<SlideExtractionResult | null>;
+    renderStatus: (label: string, detail?: string) => string;
+    renderStatusWithMeta: (label: string, meta: string, suffix?: string) => string;
+    spinner: {
+        setText: (text: string) => void;
+    };
+    styleDim: (text: string) => string;
+    updateSummaryProgress: () => void;
+    accent: (text: string) => string;
+}): Promise<VideoOnlyResult>;

package/dist/types/run/markdown-transforms.d.ts

@@ -0,0 +1,3 @@
+export declare function materializeInlineMarkdownLinks(markdown: string): string;
+export declare function collapseExtraBlankLines(markdown: string): string;
+export declare function inlineReferenceStyleLinks(markdown: string): string;

package/dist/types/run/run-context.d.ts

@@ -12,12 +12,15 @@ export declare function resolveRunContextState({ env, envForRun, programOpts, la
     openrouterApiKey: string | null;
     openrouterConfigured: boolean;
     groqApiKey: string | null;
+    assemblyaiApiKey: string | null;
     openaiTranscriptionKey: string | null;
     xaiApiKey: string | null;
     googleApiKey: string | null;
     anthropicApiKey: string | null;
     zaiApiKey: string | null;
     zaiBaseUrl: string;
+    nvidiaApiKey: string | null;
+    nvidiaBaseUrl: string;
     firecrawlApiKey: string | null;
     firecrawlConfigured: boolean;
     googleConfigured: boolean;
@@ -30,6 +33,7 @@ export declare function resolveRunContextState({ env, envForRun, programOpts, la
     envForAuto: Record<string, string | undefined>;
     providerBaseUrls: {
         openai: string | null;
+        nvidia: string | null;
         anthropic: string | null;
         google: string | null;
         xai: string | null;

package/dist/types/run/run-env.d.ts

@@ -4,12 +4,15 @@ export type EnvState = {
     openrouterApiKey: string | null;
     openrouterConfigured: boolean;
     groqApiKey: string | null;
+    assemblyaiApiKey: string | null;
     openaiTranscriptionKey: string | null;
     xaiApiKey: string | null;
     googleApiKey: string | null;
     anthropicApiKey: string | null;
     zaiApiKey: string | null;
     zaiBaseUrl: string;
+    nvidiaApiKey: string | null;
+    nvidiaBaseUrl: string;
     firecrawlApiKey: string | null;
     firecrawlConfigured: boolean;
     googleConfigured: boolean;
@@ -22,6 +25,7 @@ export type EnvState = {
     envForAuto: Record<string, string | undefined>;
     providerBaseUrls: {
         openai: string | null;
+        nvidia: string | null;
         anthropic: string | null;
         google: string | null;
         xai: string | null;

package/dist/types/run/run-settings-parse.d.ts

@@ -0,0 +1,5 @@
+import type { CliProvider } from "../config.js";
+export declare const parseOptionalSetting: <T>(raw: unknown, parse: (value: string) => T, strict: boolean) => T | null;
+export declare const parseOptionalBoolean: (raw: unknown, strict: boolean, label?: string) => boolean | null;
+export declare const parseCliProvider: (raw: string) => CliProvider | null;
+export declare const parseOptionalCliProviderOrder: (raw: unknown, strict: boolean) => CliProvider[] | null;