@steipete/summarize 0.9.0 → 0.11.0

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

@@ -0,0 +1,66 @@
+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 { SummaryStreamHandler } from "../../summary-engine.js";
+import { type StreamOutputMode } from "../../stream-output.js";
+export type SlidesTerminalOutput = {
+    onSlidesExtracted: (slides: SlideExtractionResult) => void;
+    onSlidesDone: (result: {
+        ok: boolean;
+        error?: string | null;
+    }) => void;
+    onSlideChunk: (chunk: {
+        slide: SlideImage;
+        meta: {
+            slidesDir: string;
+            sourceUrl: string;
+            sourceId: string;
+            sourceKind: SlideSourceKind;
+            ocrAvailable: boolean;
+        };
+    }) => void;
+    streamHandler: SummaryStreamHandler;
+    renderFromText: (summary: string) => Promise<void>;
+};
+export declare function createSlidesTerminalOutput({ io, flags, extracted, slides, enabled, outputMode, clearProgressForStdout, restoreProgressAfterStdout, onProgressText, }: {
+    io: {
+        env: Record<string, string | undefined>;
+        envForRun: Record<string, string | undefined>;
+        stdout: NodeJS.WritableStream;
+        stderr: NodeJS.WritableStream;
+    };
+    flags: {
+        plain: boolean;
+        lengthArg: {
+            kind: "preset";
+            preset: SummaryLength;
+        } | {
+            kind: "chars";
+            maxCharacters: number;
+        };
+        slidesDebug?: boolean;
+    };
+    extracted: ExtractedLinkContent;
+    slides: SlideExtractionResult | null | undefined;
+    enabled: boolean;
+    outputMode?: StreamOutputMode | null;
+    clearProgressForStdout: () => void;
+    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-text.d.ts

@@ -0,0 +1,87 @@
+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;

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

@@ -1,30 +1,38 @@
-import type { ExtractedLinkContent } from '../../../content/index.js';
-import type { UrlExtractionUi } from './extract.js';
-import type { UrlFlowContext } from './types.js';
-export declare function buildUrlPrompt({ extracted, outputLanguage, lengthArg, promptOverride, lengthInstruction, languageInstruction, }: {
+import type { ExtractedLinkContent } from "../../../content/index.js";
+import type { UrlExtractionUi } from "./extract.js";
+import type { SlidesTerminalOutput } from "./slides-output.js";
+import type { UrlFlowContext } from "./types.js";
+type SlidesResult = Awaited<ReturnType<typeof import("../../../slides/index.js").extractSlidesForSource>>;
+export declare function buildUrlPrompt({ extracted, outputLanguage, lengthArg, promptOverride, lengthInstruction, languageInstruction, slides, }: {
     extracted: ExtractedLinkContent;
-    outputLanguage: UrlFlowContext['flags']['outputLanguage'];
-    lengthArg: UrlFlowContext['flags']['lengthArg'];
+    outputLanguage: UrlFlowContext["flags"]["outputLanguage"];
+    lengthArg: UrlFlowContext["flags"]["lengthArg"];
     promptOverride?: string | null;
     lengthInstruction?: string | null;
     languageInstruction?: string | null;
+    slides?: SlidesResult | null;
 }): string;
-export declare function outputExtractedUrl({ ctx, url, extracted, extractionUi, prompt, effectiveMarkdownMode, transcriptionCostLabel, }: {
+export declare function outputExtractedUrl({ ctx, url, extracted, extractionUi, prompt, effectiveMarkdownMode, transcriptionCostLabel, slides, slidesOutput, }: {
     ctx: UrlFlowContext;
     url: string;
     extracted: ExtractedLinkContent;
     extractionUi: UrlExtractionUi;
     prompt: string;
-    effectiveMarkdownMode: 'off' | 'auto' | 'llm' | 'readability';
+    effectiveMarkdownMode: "off" | "auto" | "llm" | "readability";
     transcriptionCostLabel: string | null;
+    slides?: Awaited<ReturnType<typeof import("../../../slides/index.js").extractSlidesForSource>> | null;
+    slidesOutput?: SlidesTerminalOutput | null;
 }): Promise<void>;
-export declare function summarizeExtractedUrl({ ctx, url, extracted, extractionUi, prompt, effectiveMarkdownMode, transcriptionCostLabel, onModelChosen, }: {
+export declare function summarizeExtractedUrl({ ctx, url, extracted, extractionUi, prompt, effectiveMarkdownMode, transcriptionCostLabel, onModelChosen, slides, slidesOutput, }: {
     ctx: UrlFlowContext;
     url: string;
     extracted: ExtractedLinkContent;
     extractionUi: UrlExtractionUi;
     prompt: string;
-    effectiveMarkdownMode: 'off' | 'auto' | 'llm' | 'readability';
+    effectiveMarkdownMode: "off" | "auto" | "llm" | "readability";
     transcriptionCostLabel: string | null;
     onModelChosen?: ((modelId: string) => void) | null;
+    slides?: Awaited<ReturnType<typeof import("../../../slides/index.js").extractSlidesForSource>> | null;
+    slidesOutput?: SlidesTerminalOutput | null;
 }): Promise<void>;
+export {};

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

@@ -1,13 +1,15 @@
-import type { CacheState } from '../../../cache.js';
-import type { SummarizeConfig } from '../../../config.js';
-import type { ExtractedLinkContent, LinkPreviewProgressEvent } from '../../../content/index.js';
-import type { LlmCall, RunMetricsReport } from '../../../costs.js';
-import type { OutputLanguage } from '../../../language.js';
-import type { ExecFileFn } from '../../../markitdown.js';
-import type { FixedModelSpec, RequestedModel } from '../../../model-spec.js';
-import type { SummaryLength } from '../../../shared/contracts.js';
-import type { createSummaryEngine } from '../../summary-engine.js';
-import type { SummarizeAssetArgs } from '../asset/summary.js';
+import type { CacheState } from "../../../cache.js";
+import type { CliProvider, SummarizeConfig } from "../../../config.js";
+import type { ExtractedLinkContent, LinkPreviewProgressEvent, MediaCache } from "../../../content/index.js";
+import type { LlmCall, RunMetricsReport } from "../../../costs.js";
+import type { StreamMode } from "../../../flags.js";
+import type { OutputLanguage } from "../../../language.js";
+import type { ExecFileFn } from "../../../markitdown.js";
+import type { FixedModelSpec, RequestedModel } from "../../../model-spec.js";
+import type { SummaryLength } from "../../../shared/contracts.js";
+import type { SlideExtractionResult, SlideImage, SlideSettings, SlideSourceKind } from "../../../slides/index.js";
+import type { createSummaryEngine } from "../../summary-engine.js";
+import type { SummarizeAssetArgs } from "../asset/summary.js";
 export type UrlFlowIo = {
     env: Record<string, string | undefined>;
     envForRun: Record<string, string | undefined>;
@@ -20,23 +22,26 @@ export type UrlFlowFlags = {
     timeoutMs: number;
     maxExtractCharacters?: number | null;
     retries: number;
-    format: 'text' | 'markdown';
-    markdownMode: 'off' | 'auto' | 'llm' | 'readability';
-    preprocessMode: 'off' | 'auto' | 'always';
-    youtubeMode: 'auto' | 'web' | 'yt-dlp' | 'apify' | 'no-auto';
-    firecrawlMode: 'off' | 'auto' | 'always';
-    videoMode: 'auto' | 'transcript' | 'understand';
+    format: "text" | "markdown";
+    markdownMode: "off" | "auto" | "llm" | "readability";
+    preprocessMode: "off" | "auto" | "always";
+    youtubeMode: "auto" | "web" | "yt-dlp" | "apify" | "no-auto";
+    firecrawlMode: "off" | "auto" | "always";
+    videoMode: "auto" | "transcript" | "understand";
+    transcriptTimestamps: boolean;
     outputLanguage: OutputLanguage;
     lengthArg: {
-        kind: 'preset';
+        kind: "preset";
         preset: SummaryLength;
     } | {
-        kind: 'chars';
+        kind: "chars";
         maxCharacters: number;
     };
+    forceSummary: boolean;
     promptOverride?: string | null;
     lengthInstruction?: string | null;
     languageInstruction?: string | null;
+    summaryCacheBypass: boolean;
     maxOutputTokensArg: number | null;
     json: boolean;
     extractMode: boolean;
@@ -47,10 +52,14 @@ export type UrlFlowFlags = {
     verbose: boolean;
     verboseColor: boolean;
     progressEnabled: boolean;
+    streamMode: StreamMode;
     streamingEnabled: boolean;
     plain: boolean;
     configPath: string | null;
     configModelLabel: string | null;
+    slides: SlideSettings | null;
+    slidesDebug: boolean;
+    slidesOutput?: boolean;
 };
 export type UrlFlowModel = {
     requestedModel: RequestedModel;
@@ -58,12 +67,14 @@ export type UrlFlowModel = {
     requestedModelLabel: string;
     fixedModelSpec: FixedModelSpec | null;
     isFallbackModel: boolean;
+    isImplicitAutoSelection: boolean;
+    allowAutoCliFallback: boolean;
     isNamedModelSelection: boolean;
     wantsFreeNamedModel: boolean;
     desiredOutputTokens: number | null;
     configForModelSelection: SummarizeConfig | null;
     envForAuto: Record<string, string | undefined>;
-    cliAvailability: Partial<Record<'claude' | 'codex' | 'gemini', boolean>>;
+    cliAvailability: Partial<Record<CliProvider, boolean>>;
     openaiUseChatCompletions: boolean;
     openaiWhisperUsdPerMinute: number;
     apiStatus: {
@@ -87,23 +98,42 @@ export type UrlFlowModel = {
         firecrawlApiKey: string | null;
         apifyToken: string | null;
         ytDlpPath: string | null;
+        ytDlpCookiesFromBrowser: string | null;
         falApiKey: string | null;
+        groqApiKey: string | null;
         openaiTranscriptionKey: string | null;
     };
     summaryEngine: ReturnType<typeof createSummaryEngine>;
-    getLiteLlmCatalog: () => Promise<Awaited<ReturnType<typeof import('../../../pricing/litellm.js').loadLiteLlmCatalog>>['catalog']>;
+    getLiteLlmCatalog: () => Promise<Awaited<ReturnType<typeof import("../../../pricing/litellm.js").loadLiteLlmCatalog>>["catalog"]>;
     llmCalls: LlmCall[];
 };
 export type UrlFlowHooks = {
     onModelChosen?: ((modelId: string) => void) | null;
     onExtracted?: ((extracted: ExtractedLinkContent) => void) | null;
+    onSlidesExtracted?: ((slides: SlideExtractionResult) => void) | null;
+    onSlidesProgress?: ((text: string) => void) | null;
+    onSlidesDone?: ((result: {
+        ok: boolean;
+        error?: string | null;
+    }) => void) | null;
+    onSlideChunk?: (chunk: {
+        slide: SlideImage;
+        meta: {
+            slidesDir: string;
+            sourceUrl: string;
+            sourceId: string;
+            sourceKind: SlideSourceKind;
+            ocrAvailable: boolean;
+        };
+    }) => void;
     onLinkPreviewProgress?: ((event: LinkPreviewProgressEvent) => void) | null;
     onSummaryCached?: ((cached: boolean) => void) | null;
     setTranscriptionCost: (costUsd: number | null, label: string | null) => void;
     summarizeAsset: (args: SummarizeAssetArgs) => Promise<void>;
     writeViaFooter: (parts: string[]) => void;
     clearProgressForStdout: () => void;
-    setClearProgressBeforeStdout: (fn: (() => void) | null) => void;
+    restoreProgressAfterStdout?: (() => void) | null;
+    setClearProgressBeforeStdout: (fn: (() => undefined | (() => void)) | null) => void;
     clearProgressIfCurrent: (fn: () => void) => void;
     buildReport: () => Promise<RunMetricsReport>;
     estimateCostUsd: () => Promise<number | null>;
@@ -118,5 +148,6 @@ export type UrlFlowContext = {
     flags: UrlFlowFlags;
     model: UrlFlowModel;
     cache: CacheState;
+    mediaCache: MediaCache | null;
     hooks: UrlFlowHooks;
 };

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

@@ -1,4 +1,4 @@
-import type { SummaryLength } from '../shared/contracts.js';
+import type { SummaryLength } from "../shared/contracts.js";
 export declare function formatOptionalString(value: string | null | undefined): string;
 export declare function formatOptionalNumber(value: number | null | undefined): string;
 export declare function sumNumbersOrNull(values: Array<number | null>): number | null;
@@ -10,9 +10,9 @@ export declare function estimateWhisperTranscriptionCostUsd({ transcriptionProvi
     openaiWhisperUsdPerMinute: number;
 }): number | null;
 export declare function resolveTargetCharacters(lengthArg: {
-    kind: 'preset';
+    kind: "preset";
     preset: SummaryLength;
 } | {
-    kind: 'chars';
+    kind: "chars";
     maxCharacters: number;
 }, maxMap: Record<SummaryLength, number>): number;

package/dist/types/run/help.d.ts

@@ -1,6 +1,9 @@
-import { Command } from 'commander';
+import { Command } from "commander";
 export declare function buildProgram(): Command;
+export declare function applyHelpStyle(program: Command, env: Record<string, string | undefined>, stdout: NodeJS.WritableStream): void;
+export declare function buildSlidesProgram(): Command;
 export declare function attachRichHelp(program: Command, env: Record<string, string | undefined>, stdout: NodeJS.WritableStream): void;
 export declare function buildConciseHelp(): string;
 export declare function buildRefreshFreeHelp(): string;
 export declare function buildDaemonHelp(): string;
+export declare function buildTranscriberHelp(): string;

package/dist/types/run/logging.d.ts

@@ -1,9 +1,10 @@
-export declare function writeVerbose(stderr: NodeJS.WritableStream, verbose: boolean, message: string, color: boolean): void;
-export declare function createRetryLogger({ stderr, verbose, color, modelId, }: {
+export declare function writeVerbose(stderr: NodeJS.WritableStream, verbose: boolean, message: string, color: boolean, env?: Record<string, string | undefined>): void;
+export declare function createRetryLogger({ stderr, verbose, color, modelId, env, }: {
     stderr: NodeJS.WritableStream;
     verbose: boolean;
     color: boolean;
     modelId: string;
+    env?: Record<string, string | undefined>;
 }): (notice: {
     attempt: number;
     maxRetries: number;

package/dist/types/run/media-cache-state.d.ts

@@ -0,0 +1,7 @@
+import type { SummarizeConfig } from "../config.js";
+import type { MediaCache } from "../content/index.js";
+export declare function createMediaCacheFromConfig({ envForRun, config, noMediaCacheFlag, }: {
+    envForRun: Record<string, string | undefined>;
+    config: SummarizeConfig | null;
+    noMediaCacheFlag?: boolean;
+}): Promise<MediaCache | null>;

package/dist/types/run/model-attempts.d.ts

@@ -1,4 +1,4 @@
-import type { ModelAttempt, ModelAttemptRequiredEnv } from './types.js';
+import type { ModelAttempt, ModelAttemptRequiredEnv } from "./types.js";
 export declare function runModelAttempts<T>({ attempts, isFallbackModel, isNamedModelSelection, envHasKeyFor, formatMissingModelError, onAutoSkip, onAutoFailure, onFixedModelError, runAttempt, }: {
     attempts: ModelAttempt[];
     isFallbackModel: boolean;

package/dist/types/run/progress.d.ts

@@ -1,6 +1,7 @@
 export type ProgressGate = {
-    setClearProgressBeforeStdout: (fn: (() => void) | null) => void;
+    setClearProgressBeforeStdout: (fn: (() => undefined | (() => void)) | null) => void;
     clearProgressForStdout: () => void;
+    restoreProgressAfterStdout: () => void;
     clearProgressIfCurrent: (fn: () => void) => void;
 };
 export declare function createProgressGate(): ProgressGate;

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

@@ -1,13 +1,13 @@
-import type { CliProvider, SummarizeConfig } from '../config.js';
-import { parseVideoMode } from '../flags.js';
-import { type OutputLanguage } from '../language.js';
+import type { CliProvider, SummarizeConfig } from "../config.js";
+import { parseVideoMode } from "../flags.js";
+import { type OutputLanguage } from "../language.js";
 export type ConfigState = {
     config: SummarizeConfig | null;
     configPath: string | null;
     outputLanguage: OutputLanguage;
     openaiWhisperUsdPerMinute: number;
     videoMode: ReturnType<typeof parseVideoMode>;
-    cliConfigForRun: SummarizeConfig['cli'] | undefined;
+    cliConfigForRun: SummarizeConfig["cli"] | undefined;
     configForCli: SummarizeConfig | null;
     openaiUseChatCompletions: boolean;
     configModelLabel: string | null;

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

@@ -1,4 +1,4 @@
-import type { CliProvider } from '../config.js';
+import type { CliProvider } from "../config.js";
 export declare function resolveRunContextState({ env, envForRun, programOpts, languageExplicitlySet, videoModeExplicitlySet, cliFlagPresent, cliProviderArg, }: {
     env: Record<string, string | undefined>;
     envForRun: Record<string, string | undefined>;
@@ -11,6 +11,7 @@ export declare function resolveRunContextState({ env, envForRun, programOpts, la
     apiKey: string | null;
     openrouterApiKey: string | null;
     openrouterConfigured: boolean;
+    groqApiKey: string | null;
     openaiTranscriptionKey: string | null;
     xaiApiKey: string | null;
     googleApiKey: string | null;
@@ -23,6 +24,7 @@ export declare function resolveRunContextState({ env, envForRun, programOpts, la
     anthropicConfigured: boolean;
     apifyToken: string | null;
     ytDlpPath: string | null;
+    ytDlpCookiesFromBrowser: string | null;
     falApiKey: string | null;
     cliAvailability: Partial<Record<CliProvider, boolean>>;
     envForAuto: Record<string, string | undefined>;

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

@@ -1,8 +1,9 @@
-import type { CliProvider, SummarizeConfig } from '../config.js';
+import type { CliProvider, SummarizeConfig } from "../config.js";
 export type EnvState = {
     apiKey: string | null;
     openrouterApiKey: string | null;
     openrouterConfigured: boolean;
+    groqApiKey: string | null;
     openaiTranscriptionKey: string | null;
     xaiApiKey: string | null;
     googleApiKey: string | null;
@@ -15,6 +16,7 @@ export type EnvState = {
     anthropicConfigured: boolean;
     apifyToken: string | null;
     ytDlpPath: string | null;
+    ytDlpCookiesFromBrowser: string | null;
     falApiKey: string | null;
     cliAvailability: Partial<Record<CliProvider, boolean>>;
     envForAuto: Record<string, string | undefined>;

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

@@ -1,5 +1,5 @@
-import type { Command } from 'commander';
-import type { InputTarget } from '../content/asset.js';
+import type { Command } from "commander";
+import type { InputTarget } from "../content/asset.js";
 export type InputResolution = {
     inputTarget: InputTarget;
     url: string | null;

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

@@ -1,11 +1,11 @@
-import type { LlmCall, RunMetricsReport } from '../costs.js';
-import { loadLiteLlmCatalog } from '../pricing/litellm.js';
+import type { LlmCall, RunMetricsReport } from "../costs.js";
+import { loadLiteLlmCatalog } from "../pricing/litellm.js";
 export type RunMetrics = {
     llmCalls: LlmCall[];
     trackedFetch: typeof fetch;
     buildReport: () => Promise<RunMetricsReport>;
     estimateCostUsd: () => Promise<number | null>;
-    getLiteLlmCatalog: () => Promise<Awaited<ReturnType<typeof loadLiteLlmCatalog>>['catalog']>;
+    getLiteLlmCatalog: () => Promise<Awaited<ReturnType<typeof loadLiteLlmCatalog>>["catalog"]>;
     resolveMaxOutputTokensForCall: (modelId: string) => Promise<number | null>;
     resolveMaxInputTokensForCall: (modelId: string) => Promise<number | null>;
     setTranscriptionCost: (costUsd: number | null, label: string | null) => void;

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

@@ -1,10 +1,11 @@
-import type { SummarizeConfig } from '../config.js';
-import type { RequestedModel } from '../model-spec.js';
+import type { SummarizeConfig } from "../config.js";
+import type { RequestedModel } from "../model-spec.js";
 export type ModelSelection = {
     requestedModel: RequestedModel;
     requestedModelInput: string;
     requestedModelLabel: string;
     isNamedModelSelection: boolean;
+    isImplicitAutoSelection: boolean;
     wantsFreeNamedModel: boolean;
     configForModelSelection: SummarizeConfig | null;
     isFallbackModel: boolean;

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

@@ -1,4 +1,4 @@
-import type { LengthArg } from '../flags.js';
+import type { LengthArg } from "../flags.js";
 export declare function resolveDesiredOutputTokens({ lengthArg, maxOutputTokensArg, }: {
     lengthArg: LengthArg;
     maxOutputTokensArg: number | null;

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

@@ -1,6 +1,7 @@
-import type { FirecrawlMode, LengthArg, MarkdownMode, PreprocessMode, VideoMode, YoutubeMode } from '../flags.js';
-import type { OutputLanguage } from '../language.js';
-import type { SummaryLengthTarget } from '../prompts/index.js';
+import type { CliProvider } from "../config.js";
+import type { FirecrawlMode, LengthArg, MarkdownMode, PreprocessMode, VideoMode, YoutubeMode } from "../flags.js";
+import type { OutputLanguage } from "../language.js";
+import type { SummaryLengthTarget } from "../prompts/index.js";
 export type ResolvedRunSettings = {
     lengthArg: LengthArg;
     firecrawlMode: FirecrawlMode;
@@ -17,9 +18,14 @@ export type RunOverrides = {
     preprocessMode: PreprocessMode | null;
     youtubeMode: YoutubeMode | null;
     videoMode: VideoMode | null;
+    transcriptTimestamps: boolean | null;
+    forceSummary: boolean | null;
     timeoutMs: number | null;
     retries: number | null;
     maxOutputTokensArg: number | null;
+    transcriber: "auto" | "whisper" | "parakeet" | "canary" | null;
+    autoCliFallbackEnabled: boolean | null;
+    autoCliOrder: CliProvider[] | null;
 };
 export type RunOverridesInput = {
     firecrawl?: unknown;
@@ -27,9 +33,18 @@ export type RunOverridesInput = {
     preprocess?: unknown;
     youtube?: unknown;
     videoMode?: unknown;
+    timestamps?: unknown;
+    forceSummary?: unknown;
     timeout?: unknown;
     retries?: unknown;
     maxOutputTokens?: unknown;
+    transcriber?: unknown;
+    autoCliFallback?: unknown;
+    autoCliOrder?: unknown;
+    autoCliRememberLastSuccess?: unknown;
+    magicCliAuto?: unknown;
+    magicCliOrder?: unknown;
+    magicCliRememberLastSuccess?: unknown;
 };
 export declare function resolveSummaryLength(raw: unknown, fallback?: string): {
     lengthArg: LengthArg;
@@ -44,13 +59,13 @@ export declare function resolveCliRunSettings({ length, firecrawl, markdownMode,
     firecrawl: string;
     markdownMode?: string | undefined;
     markdown?: string | undefined;
-    format: 'text' | 'markdown';
+    format: "text" | "markdown";
     preprocess: string;
     youtube: string;
     timeout: string;
     retries: string;
     maxOutputTokens?: string | undefined;
 }): ResolvedRunSettings;
-export declare function resolveRunOverrides({ firecrawl, markdownMode, preprocess, youtube, videoMode, timeout, retries, maxOutputTokens, }: RunOverridesInput, options?: {
+export declare function resolveRunOverrides({ firecrawl, markdownMode, preprocess, youtube, videoMode, timestamps, forceSummary, timeout, retries, maxOutputTokens, transcriber, autoCliFallback, autoCliOrder, autoCliRememberLastSuccess, magicCliAuto, magicCliOrder, magicCliRememberLastSuccess, }: RunOverridesInput, options?: {
     strict?: boolean;
 }): RunOverrides;

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

@@ -1,6 +1,6 @@
-import type { StreamMode } from '../flags.js';
+import type { StreamMode } from "../flags.js";
 export type StreamSettings = {
-    effectiveStreamMode: 'on' | 'off';
+    effectiveStreamMode: "on" | "off";
     streamingEnabled: boolean;
 };
 export declare function resolveStreamSettings({ streamMode, stdout, json, extractMode, }: {

package/dist/types/run/runner.d.ts

@@ -1,10 +1,11 @@
-import type { ExecFileFn } from '../markitdown.js';
+import type { ExecFileFn } from "../markitdown.js";
 type RunEnv = {
     env: Record<string, string | undefined>;
     fetch: typeof fetch;
     execFile?: ExecFileFn;
+    stdin?: NodeJS.ReadableStream;
     stdout: NodeJS.WritableStream;
     stderr: NodeJS.WritableStream;
 };
-export declare function runCli(argv: string[], { env, fetch, execFile: execFileOverride, stdout, stderr }: RunEnv): Promise<void>;
+export declare function runCli(argv: string[], { env: inputEnv, fetch, execFile: execFileOverride, stdin, stdout, stderr }: RunEnv): Promise<void>;
 export {};

package/dist/types/run/slides-cli.d.ts

@@ -0,0 +1,9 @@
+type SlidesCliContext = {
+    normalizedArgv: string[];
+    envForRun: Record<string, string | undefined>;
+    fetchImpl: typeof fetch;
+    stdout: NodeJS.WritableStream;
+    stderr: NodeJS.WritableStream;
+};
+export declare function handleSlidesCliRequest({ normalizedArgv, envForRun, stdout, stderr, }: SlidesCliContext): Promise<boolean>;
+export {};