@steipete/summarize 0.11.1 → 0.12.0

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>;

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;

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

@@ -0,0 +1,62 @@
+import type { CacheState } from "../cache.js";
+import type { MediaCache } from "../content/index.js";
+import type { SummarizeAssetArgs } from "./flows/asset/summary.js";
+import type { UrlFlowContext } from "./flows/url/types.js";
+type SummarizeMediaFile = typeof import("./flows/asset/media.js").summarizeMediaFile;
+export declare function createRunnerFlowContexts(options: {
+    summarizeMediaFileImpl: SummarizeMediaFile;
+    cacheState: CacheState;
+    mediaCache: MediaCache | null;
+    io: UrlFlowContext["io"];
+    flags: UrlFlowContext["flags"];
+    model: UrlFlowContext["model"];
+    setTranscriptionCost: UrlFlowContext["hooks"]["setTranscriptionCost"];
+    writeViaFooter: UrlFlowContext["hooks"]["writeViaFooter"];
+    clearProgressForStdout: UrlFlowContext["hooks"]["clearProgressForStdout"];
+    restoreProgressAfterStdout: UrlFlowContext["hooks"]["restoreProgressAfterStdout"];
+    setClearProgressBeforeStdout: UrlFlowContext["hooks"]["setClearProgressBeforeStdout"];
+    clearProgressIfCurrent: UrlFlowContext["hooks"]["clearProgressIfCurrent"];
+    buildReport: UrlFlowContext["hooks"]["buildReport"];
+    estimateCostUsd: UrlFlowContext["hooks"]["estimateCostUsd"];
+}): {
+    summarizeAsset: (args: SummarizeAssetArgs) => Promise<void>;
+    assetInputContext: {
+        env: Record<string, string | undefined>;
+        envForRun: Record<string, string | undefined>;
+        stderr: NodeJS.WritableStream;
+        progressEnabled: boolean;
+        timeoutMs: number;
+        trackedFetch: typeof fetch;
+        summarizeAsset: (args: SummarizeAssetArgs) => Promise<void>;
+        summarizeMediaFile: (args: Parameters<SummarizeMediaFile>[1]) => Promise<void>;
+        setClearProgressBeforeStdout: (fn: (() => undefined | (() => void)) | null) => void;
+        clearProgressIfCurrent: (fn: () => void) => void;
+    };
+    urlFlowContext: {
+        io: import("./flows/url/types.js").UrlFlowIo;
+        flags: import("./flows/url/types.js").UrlFlowFlags;
+        model: import("./flows/url/types.js").UrlFlowModel;
+        cache: CacheState;
+        mediaCache: MediaCache | null;
+        hooks: {
+            onModelChosen: null;
+            onExtracted: null;
+            onSlidesExtracted: null;
+            onSlidesProgress: null;
+            onLinkPreviewProgress: null;
+            onSummaryCached: null;
+            setTranscriptionCost: (costUsd: number | null, label: string | null) => void;
+            summarizeAsset: (args: SummarizeAssetArgs) => Promise<void>;
+            writeViaFooter: (parts: string[]) => void;
+            clearProgressForStdout: () => void;
+            restoreProgressAfterStdout: (() => void) | null | undefined;
+            setClearProgressBeforeStdout: (fn: (() => undefined | (() => void)) | null) => void;
+            clearProgressIfCurrent: (fn: () => void) => void;
+            buildReport: () => Promise<import("../costs.js").RunMetricsReport>;
+            estimateCostUsd: () => Promise<number | null>;
+            onSlideChunk: undefined;
+            onSlidesDone: null;
+        };
+    };
+};
+export {};

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

@@ -0,0 +1,57 @@
+import type { InputTarget } from "../content/asset.js";
+import type { RunMetricsReport } from "../costs.js";
+import type { ExecFileFn } from "../markitdown.js";
+import type { AssetExtractContext } from "./flows/asset/extract.js";
+import type { SummarizeAssetArgs } from "./flows/asset/summary.js";
+export declare function executeRunnerInput(options: {
+    inputTarget: InputTarget;
+    stdin: NodeJS.ReadableStream;
+    handleFileInputContext: unknown;
+    url: string | null;
+    isYoutubeUrl: boolean;
+    withUrlAssetContext: unknown;
+    extractMode: boolean;
+    progressEnabled: boolean;
+    renderSpinnerStatus: (label: string, detail?: string) => string;
+    renderSpinnerStatusWithModel: (label: string, modelId: string) => string;
+    extractAssetContext: AssetExtractContext & {
+        execFileImpl: ExecFileFn;
+    };
+    outputExtractedAssetContext: {
+        io: {
+            env: Record<string, string | undefined>;
+            envForRun: Record<string, string | undefined>;
+            stdout: NodeJS.WritableStream;
+            stderr: NodeJS.WritableStream;
+        };
+        flags: {
+            timeoutMs: number;
+            preprocessMode: "off" | "auto" | "always";
+            format: "text" | "markdown";
+            plain: boolean;
+            json: boolean;
+            metricsEnabled: boolean;
+            metricsDetailed: boolean;
+            shouldComputeReport: boolean;
+            runStartedAtMs: number;
+            verboseColor: boolean;
+        };
+        hooks: {
+            clearProgressForStdout: () => void;
+            restoreProgressAfterStdout?: (() => void) | null;
+            buildReport: () => Promise<RunMetricsReport>;
+            estimateCostUsd: () => Promise<number | null>;
+        };
+        apiStatus: {
+            xaiApiKey: string | null;
+            apiKey: string | null;
+            openrouterApiKey: string | null;
+            apifyToken: string | null;
+            firecrawlConfigured: boolean;
+            googleConfigured: boolean;
+            anthropicConfigured: boolean;
+        };
+    };
+    summarizeAsset: (args: SummarizeAssetArgs) => Promise<void>;
+    runUrlFlowContext: unknown;
+}): Promise<void>;

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

@@ -0,0 +1,41 @@
+import { type FirecrawlMode, type LengthArg, type MarkdownMode, type PreprocessMode, parseExtractFormat, parseMaxExtractCharactersArg, parseMetricsMode, parseStreamMode, type YoutubeMode } from "../flags.js";
+type Transcriber = "auto" | "whisper" | "parakeet" | "canary";
+export type RunnerFlagResolution = {
+    videoModeExplicitlySet: boolean;
+    lengthExplicitlySet: boolean;
+    languageExplicitlySet: boolean;
+    noCacheFlag: boolean;
+    noMediaCacheFlag: boolean;
+    extractMode: boolean;
+    json: boolean;
+    forceSummary: boolean;
+    slidesDebug: boolean;
+    streamMode: ReturnType<typeof parseStreamMode>;
+    plain: boolean;
+    debug: boolean;
+    verbose: boolean;
+    transcriber: Transcriber;
+    maxExtractCharacters: ReturnType<typeof parseMaxExtractCharactersArg>;
+    isYoutubeUrl: boolean;
+    format: ReturnType<typeof parseExtractFormat>;
+    youtubeMode: YoutubeMode;
+    lengthArg: LengthArg;
+    maxOutputTokensArg: number | null;
+    timeoutMs: number;
+    retries: number;
+    preprocessMode: PreprocessMode;
+    requestedFirecrawlMode: FirecrawlMode;
+    markdownMode: MarkdownMode;
+    metricsMode: ReturnType<typeof parseMetricsMode>;
+    metricsEnabled: boolean;
+    metricsDetailed: boolean;
+    shouldComputeReport: boolean;
+    markdownModeExplicitlySet: boolean;
+};
+export declare function resolveRunnerFlags({ normalizedArgv, programOpts, envForRun, url, }: {
+    normalizedArgv: readonly string[];
+    programOpts: Record<string, unknown>;
+    envForRun: Record<string, string | undefined>;
+    url: string | null;
+}): RunnerFlagResolution;
+export {};

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

@@ -0,0 +1,21 @@
+export declare function prepareRunEnvironment(argv: string[], inputEnv: Record<string, string | undefined>): {
+    normalizedArgv: string[];
+    envForRun: Record<string, string | undefined>;
+};
+export declare function handleVersionFlag({ versionRequested, stdout, }: {
+    versionRequested: boolean;
+    stdout: NodeJS.WritableStream;
+}): boolean;
+export declare function applyWidthOverride({ width, env, }: {
+    width: unknown;
+    env: Record<string, string | undefined>;
+}): void;
+export declare function resolvePromptOverride({ prompt, promptFile, }: {
+    prompt: unknown;
+    promptFile: unknown;
+}): Promise<string | null>;
+export declare function handleCacheUtilityFlags({ normalizedArgv, envForRun, stdout, }: {
+    normalizedArgv: string[];
+    envForRun: Record<string, string | undefined>;
+    stdout: NodeJS.WritableStream;
+}): Promise<boolean>;

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

@@ -0,0 +1,8 @@
+import type { SummarizeConfig } from "../config.js";
+import { type SlideSettings } from "../slides/index.js";
+export declare function resolveRunnerSlidesSettings(options: {
+    normalizedArgv: string[];
+    programOpts: Record<string, unknown>;
+    config: SummarizeConfig | null;
+    inputKind: "url" | "file" | "stdin";
+}): SlideSettings | null;

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

@@ -2,7 +2,7 @@ export { mergeStreamingChunk } from "../shared/streaming-merge.js";
 export declare function isGoogleStreamingUnsupportedError(error: unknown): boolean;
 export declare function isStreamingTimeoutError(error: unknown): boolean;
 export declare function canStream({ provider, prompt, transport, }: {
-    provider: "xai" | "openai" | "google" | "anthropic" | "zai";
+    provider: "xai" | "openai" | "google" | "anthropic" | "zai" | "nvidia";
     prompt: {
         attachments?: Array<{
             kind: "text" | "image" | "document";

package/dist/types/run/summary-engine.d.ts

@@ -1,9 +1,9 @@
 import type { CliProvider } from "../config.js";
-import type { Prompt } from "../llm/prompt.js";
-import type { ModelAttempt, ModelMeta } from "./types.js";
 import { runCliModel } from "../llm/cli.js";
+import type { Prompt } from "../llm/prompt.js";
 import { type StreamOutputMode } from "./stream-output.js";
 import { summarizeWithModelId } from "./summary-llm.js";
+import type { ModelAttempt, ModelMeta } from "./types.js";
 export type SummaryEngineDeps = {
     env: Record<string, string | undefined>;
     envForRun: Record<string, string | undefined>;
@@ -24,7 +24,7 @@ export type SummaryEngineDeps = {
     resolveMaxOutputTokensForCall: (modelId: string) => Promise<number | null>;
     resolveMaxInputTokensForCall: (modelId: string) => Promise<number | null>;
     llmCalls: Array<{
-        provider: "xai" | "openai" | "google" | "anthropic" | "zai" | "cli";
+        provider: "xai" | "openai" | "google" | "anthropic" | "zai" | "nvidia" | "cli";
         model: string;
         usage: Awaited<ReturnType<typeof summarizeWithModelId>>["usage"] | null;
         costUsd?: number | null;
@@ -48,6 +48,10 @@ export type SummaryEngineDeps = {
         apiKey: string | null;
         baseUrl: string;
     };
+    nvidia: {
+        apiKey: string | null;
+        baseUrl: string;
+    };
     providerBaseUrls: {
         openai: string | null;
         anthropic: string | null;
@@ -64,7 +68,7 @@ export type SummaryStreamHandler = {
     onDone?: ((finalText: string) => void | Promise<void>) | null;
 };
 export declare function createSummaryEngine(deps: SummaryEngineDeps): {
-    applyZaiOverrides: (attempt: ModelAttempt) => ModelAttempt;
+    applyOpenAiGatewayOverrides: (attempt: ModelAttempt) => ModelAttempt;
     envHasKeyFor: (requiredEnv: ModelAttempt["requiredEnv"]) => boolean;
     formatMissingModelError: (attempt: ModelAttempt) => string;
     runSummaryAttempt: ({ attempt, prompt, allowStreaming, onModelChosen, cli, streamHandler, }: {

package/dist/types/run/summary-llm.d.ts

@@ -1,6 +1,6 @@
+import { generateTextWithModelId } from "../llm/generate-text.js";
 import type { parseGatewayStyleModelId } from "../llm/model-id.js";
 import type { Prompt } from "../llm/prompt.js";
-import { generateTextWithModelId } from "../llm/generate-text.js";
 export declare function resolveModelIdForLlmCall({ parsedModel, apiKeys, fetchImpl, timeoutMs, }: {
     parsedModel: ReturnType<typeof parseGatewayStyleModelId>;
     apiKeys: {
@@ -13,7 +13,7 @@ export declare function resolveModelIdForLlmCall({ parsedModel, apiKeys, fetchIm
     note: string | null;
     forceStreamOff: boolean;
 }>;
-export declare function summarizeWithModelId({ modelId, prompt, maxOutputTokens, timeoutMs, fetchImpl, apiKeys, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, forceChatCompletions, retries, onRetry, }: {
+export declare function summarizeWithModelId({ modelId, prompt, maxOutputTokens, timeoutMs, fetchImpl, apiKeys, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, zaiBaseUrlOverride, forceChatCompletions, retries, onRetry, }: {
     modelId: string;
     prompt: Prompt;
     maxOutputTokens?: number;
@@ -31,6 +31,7 @@ export declare function summarizeWithModelId({ modelId, prompt, maxOutputTokens,
     anthropicBaseUrlOverride?: string | null;
     googleBaseUrlOverride?: string | null;
     xaiBaseUrlOverride?: string | null;
+    zaiBaseUrlOverride?: string | null;
     forceChatCompletions?: boolean;
     retries: number;
     onRetry?: (notice: {
@@ -41,7 +42,7 @@ export declare function summarizeWithModelId({ modelId, prompt, maxOutputTokens,
     }) => void;
 }): Promise<{
     text: string;
-    provider: "xai" | "openai" | "google" | "anthropic" | "zai";
+    provider: "xai" | "openai" | "google" | "anthropic" | "zai" | "nvidia";
     canonicalModelId: string;
     usage: Awaited<ReturnType<typeof generateTextWithModelId>>["usage"];
 }>;

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

@@ -2,5 +2,7 @@ export declare function isRichTty(stream: NodeJS.WritableStream): boolean;
 export declare function supportsColor(stream: NodeJS.WritableStream, env: Record<string, string | undefined>): boolean;
 export declare function terminalWidth(stream: NodeJS.WritableStream, env: Record<string, string | undefined>): number;
 export declare function terminalHeight(stream: NodeJS.WritableStream, env: Record<string, string | undefined>): number;
+/** Default max width for markdown rendering to keep text readable on wide terminals. */
+export declare const DEFAULT_MAX_RENDER_WIDTH = 120;
 export declare function markdownRenderWidth(stream: NodeJS.WritableStream, env: Record<string, string | undefined>): number;
 export declare function ansi(code: string, input: string, enabled: boolean): string;

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

@@ -1,5 +1,5 @@
 import type { CliProvider } from "../config.js";
-export type ModelAttemptRequiredEnv = "XAI_API_KEY" | "OPENAI_API_KEY" | "GEMINI_API_KEY" | "ANTHROPIC_API_KEY" | "OPENROUTER_API_KEY" | "Z_AI_API_KEY" | "CLI_CLAUDE" | "CLI_CODEX" | "CLI_GEMINI" | "CLI_AGENT";
+export type ModelAttemptRequiredEnv = "XAI_API_KEY" | "OPENAI_API_KEY" | "NVIDIA_API_KEY" | "GEMINI_API_KEY" | "ANTHROPIC_API_KEY" | "OPENROUTER_API_KEY" | "Z_AI_API_KEY" | "CLI_CLAUDE" | "CLI_CODEX" | "CLI_GEMINI" | "CLI_AGENT";
 export type ModelAttempt = {
     transport: "native" | "openrouter" | "cli";
     userModelId: string;
@@ -14,7 +14,7 @@ export type ModelAttempt = {
     cliModel?: string | null;
 };
 export type ModelMeta = {
-    provider: "xai" | "openai" | "google" | "anthropic" | "zai" | "cli";
+    provider: "xai" | "openai" | "google" | "anthropic" | "zai" | "nvidia" | "cli";
     canonical: string;
 };
 export type MarkdownModel = {