@steipete/summarize 0.1.2 → 0.3.0

package/dist/esm/run.js

@@ -1,6 +1,11 @@
+import { execFile } from 'node:child_process';
+import { accessSync, constants as fsConstants } from 'node:fs';
 import fs from 'node:fs/promises';
+import path from 'node:path';
 import { Command, CommanderError, Option } from 'commander';
+import { countTokens } from 'gpt-tokenizer';
 import { createLiveRenderer, render as renderMarkdownAnsi } from 'markdansi';
+import { normalizeTokenUsage, tallyCosts } from 'tokentally';
 import { loadSummarizeConfig } from './config.js';
 import { buildAssetPromptMessages, classifyUrl, loadLocalAsset, loadRemoteAsset, resolveInputTarget, } from './content/asset.js';
 import { createLinkPreviewClient } from './content/index.js';
@@ -11,21 +16,107 @@ import { generateTextWithModelId, streamTextWithModelId } from './llm/generate-t
 import { resolveGoogleModelForUsage } from './llm/google-models.js';
 import { createHtmlToMarkdownConverter } from './llm/html-to-markdown.js';
 import { normalizeGatewayStyleModelId, parseGatewayStyleModelId } from './llm/model-id.js';
-import { loadLiteLlmCatalog, resolveLiteLlmMaxOutputTokensForModelId, resolveLiteLlmPricingForModelId, } from './pricing/litellm.js';
-import { buildFileSummaryPrompt, buildLinkSummaryPrompt, SUMMARY_LENGTH_TO_TOKENS, } from './prompts/index.js';
+import { loadLiteLlmCatalog, resolveLiteLlmMaxInputTokensForModelId, resolveLiteLlmMaxOutputTokensForModelId, resolveLiteLlmPricingForModelId, } from './pricing/litellm.js';
+import { buildFileSummaryPrompt, buildLinkSummaryPrompt } from './prompts/index.js';
 import { startOscProgress } from './tty/osc-progress.js';
 import { startSpinner } from './tty/spinner.js';
 import { resolvePackageVersion } from './version.js';
-const MAP_REDUCE_TRIGGER_CHARACTERS = 120_000;
-const MAP_REDUCE_CHUNK_CHARACTERS = 60_000;
+const BIRD_TIP = 'Tip: Install bird🐦 for better Twitter support: https://github.com/steipete/bird';
+const TWITTER_HOSTS = new Set(['x.com', 'twitter.com', 'mobile.twitter.com']);
+const SUMMARY_LENGTH_MAX_CHARACTERS = {
+    short: 1200,
+    medium: 2500,
+    long: 6000,
+    xl: 14000,
+    xxl: Number.POSITIVE_INFINITY,
+};
+function resolveTargetCharacters(lengthArg) {
+    return lengthArg.kind === 'chars'
+        ? lengthArg.maxCharacters
+        : SUMMARY_LENGTH_MAX_CHARACTERS[lengthArg.preset];
+}
+function isTwitterStatusUrl(raw) {
+    try {
+        const parsed = new URL(raw);
+        const host = parsed.hostname.toLowerCase().replace(/^www\./, '');
+        if (!TWITTER_HOSTS.has(host))
+            return false;
+        return /\/status\/\d+/.test(parsed.pathname);
+    }
+    catch {
+        return false;
+    }
+}
+function isExecutable(filePath) {
+    try {
+        accessSync(filePath, fsConstants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasBirdCli(env) {
+    const candidates = [];
+    const pathEnv = env.PATH ?? process.env.PATH ?? '';
+    for (const entry of pathEnv.split(path.delimiter)) {
+        if (!entry)
+            continue;
+        candidates.push(path.join(entry, 'bird'));
+    }
+    return candidates.some((candidate) => isExecutable(candidate));
+}
+async function readTweetWithBird(args) {
+    return await new Promise((resolve, reject) => {
+        execFile('bird', ['read', args.url, '--json'], {
+            timeout: args.timeoutMs,
+            env: { ...process.env, ...args.env },
+            maxBuffer: 1024 * 1024,
+        }, (error, stdout, stderr) => {
+            if (error) {
+                const detail = stderr?.trim();
+                const suffix = detail ? `: ${detail}` : '';
+                reject(new Error(`bird read failed${suffix}`));
+                return;
+            }
+            const trimmed = stdout.trim();
+            if (!trimmed) {
+                reject(new Error('bird read returned empty output'));
+                return;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                const tweet = Array.isArray(parsed) ? parsed[0] : parsed;
+                if (!tweet || typeof tweet.text !== 'string') {
+                    reject(new Error('bird read returned invalid payload'));
+                    return;
+                }
+                resolve(tweet);
+            }
+            catch (parseError) {
+                const message = parseError instanceof Error ? parseError.message : String(parseError);
+                reject(new Error(`bird read returned invalid JSON: ${message}`));
+            }
+        });
+    });
+}
+function withBirdTip(error, url, env) {
+    if (!url || !isTwitterStatusUrl(url) || hasBirdCli(env)) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const combined = `${message}\n${BIRD_TIP}`;
+    return error instanceof Error ? new Error(combined, { cause: error }) : new Error(combined);
+}
+const MAX_TEXT_BYTES_DEFAULT = 10 * 1024 * 1024;
 function buildProgram() {
     return new Command()
         .name('summarize')
         .description('Summarize web pages and YouTube links (uses direct provider API keys).')
         .argument('[input]', 'URL or local file path to summarize')
-        .option('--youtube <mode>', 'YouTube transcript source: auto (web then apify), web (youtubei/captionTracks), apify', 'auto')
-        .option('--firecrawl <mode>', 'Firecrawl usage: off, auto (fallback), always (try Firecrawl first). Note: in --extract-only website mode, defaults to always when FIRECRAWL_API_KEY is set.', 'auto')
-        .option('--markdown <mode>', 'Website Markdown output: off, auto (prefer Firecrawl, then LLM when configured), llm (force LLM). Only affects --extract-only for non-YouTube URLs.', 'auto')
+        .option('--youtube <mode>', 'YouTube transcript source: auto, web (youtubei/captionTracks), yt-dlp (audio+whisper), apify', 'auto')
+        .option('--firecrawl <mode>', 'Firecrawl usage: off, auto (fallback), always (try Firecrawl first).', 'auto')
+        .option('--markdown <mode>', 'Website Markdown output: off, auto (use LLM when configured), llm (force LLM). Only affects --extract-only for non-YouTube URLs.', 'auto')
         .option('--length <length>', 'Summary length: short|medium|long|xl|xxl or a character limit like 20000, 20k', 'medium')
         .option('--max-output-tokens <count>', 'Hard cap for LLM output tokens (e.g. 2000, 2k). Overrides provider defaults.', undefined)
         .option('--timeout <duration>', 'Timeout for content fetching and LLM request: 30 (seconds), 30s, 2m, 5000ms', '2m')
@@ -139,19 +230,26 @@ function assertAssetMediaTypeSupported({ attachment, sizeLabel, }) {
         `Archive formats (zip/tar/7z/rar) can’t be sent to the model.\n` +
         `Unzip and summarize a specific file instead (e.g. README.md).`);
 }
-function buildAssetPromptPayload({ promptText, attachment, }) {
-    if (attachment.part.type === 'file' && isTextLikeMediaType(attachment.mediaType)) {
-        const data = attachment.part.data;
-        const content = typeof data === 'string'
-            ? data
-            : data instanceof Uint8Array
-                ? new TextDecoder().decode(data)
-                : '';
+function buildAssetPromptPayload({ promptText, attachment, textContent, }) {
+    if (textContent && attachment.part.type === 'file' && isTextLikeMediaType(attachment.mediaType)) {
         const header = `File: ${attachment.filename ?? 'unknown'} (${attachment.mediaType})`;
-        return `${promptText}\n\n---\n${header}\n\n${content}`.trim();
+        return `${promptText}\n\n---\n${header}\n\n${textContent.content}`.trim();
     }
     return buildAssetPromptMessages({ promptText, attachment });
 }
+function getTextContentFromAttachment(attachment) {
+    if (attachment.part.type !== 'file' || !isTextLikeMediaType(attachment.mediaType)) {
+        return null;
+    }
+    const data = attachment.part.data;
+    if (typeof data === 'string') {
+        return { content: data, bytes: Buffer.byteLength(data, 'utf8') };
+    }
+    if (data instanceof Uint8Array) {
+        return { content: new TextDecoder().decode(data), bytes: data.byteLength };
+    }
+    return { content: '', bytes: 0 };
+}
 function assertProviderSupportsAttachment({ provider, modelId, attachment, }) {
     // xAI via AI SDK currently supports image parts, but not generic file parts (e.g. PDFs).
     if (provider === 'xai' &&
@@ -196,6 +294,18 @@ function isGoogleStreamingUnsupportedError(error) {
         /Call ListModels/i.test(errorText) ||
         /supported methods/i.test(errorText));
 }
+function isStreamingTimeoutError(error) {
+    if (!error)
+        return false;
+    const message = typeof error === 'string'
+        ? error
+        : error instanceof Error
+            ? error.message
+            : typeof error.message === 'string'
+                ? String(error.message)
+                : '';
+    return /timed out/i.test(message);
+}
 function attachRichHelp(program, env, stdout) {
     const color = supportsColor(stdout, env);
     const heading = (text) => ansi('1;36', text, color);
@@ -204,29 +314,33 @@ function attachRichHelp(program, env, stdout) {
     program.addHelpText('after', () => `
 ${heading('Examples')}
   ${cmd('summarize "https://example.com"')}
-  ${cmd('summarize "https://example.com" --extract-only')} ${dim('# website markdown (prefers Firecrawl when configured)')}
+  ${cmd('summarize "https://example.com" --extract-only')} ${dim('# website markdown (LLM if configured)')}
   ${cmd('summarize "https://example.com" --extract-only --markdown llm')} ${dim('# website markdown via LLM')}
   ${cmd('summarize "https://www.youtube.com/watch?v=I845O57ZSy4&t=11s" --extract-only --youtube web')}
   ${cmd('summarize "https://example.com" --length 20k --max-output-tokens 2k --timeout 2m --model openai/gpt-5.2')}
-  ${cmd('OPENAI_BASE_URL=https://openrouter.ai/api/v1 OPENROUTER_API_KEY=... summarize "https://example.com" --model openai/xiaomi/mimo-v2-flash:free')}
+  ${cmd('OPENROUTER_API_KEY=... summarize "https://example.com" --model openai/openai/gpt-oss-20b')}
   ${cmd('summarize "https://example.com" --json --verbose')}
 
 ${heading('Env Vars')}
   XAI_API_KEY           optional (required for xai/... models)
   OPENAI_API_KEY        optional (required for openai/... models)
   OPENAI_BASE_URL       optional (OpenAI-compatible API endpoint; e.g. OpenRouter)
-  OPENROUTER_API_KEY    optional (used when OPENAI_BASE_URL points to OpenRouter)
+  OPENROUTER_API_KEY    optional (routes openai/... models through OpenRouter)
+  OPENROUTER_PROVIDERS  optional (provider fallback order, e.g. "groq,google-vertex")
   GEMINI_API_KEY        optional (required for google/... models)
   ANTHROPIC_API_KEY     optional (required for anthropic/... models)
   SUMMARIZE_MODEL       optional (overrides default model selection)
   FIRECRAWL_API_KEY     optional website extraction fallback (Markdown)
   APIFY_API_TOKEN       optional YouTube transcript fallback
+  YT_DLP_PATH           optional path to yt-dlp binary for audio extraction
+  FAL_KEY               optional FAL AI API key for audio transcription
 `);
 }
-async function summarizeWithModelId({ modelId, prompt, maxOutputTokens, timeoutMs, fetchImpl, apiKeys, }) {
+async function summarizeWithModelId({ modelId, prompt, maxOutputTokens, timeoutMs, fetchImpl, apiKeys, openrouter, }) {
     const result = await generateTextWithModelId({
         modelId,
         apiKeys,
+        openrouter,
         prompt,
         temperature: 0,
         maxOutputTokens,
@@ -240,38 +354,6 @@ async function summarizeWithModelId({ modelId, prompt, maxOutputTokens, timeoutM
         usage: result.usage,
     };
 }
-function splitTextIntoChunks(input, maxCharacters) {
-    if (maxCharacters <= 0) {
-        return [input];
-    }
-    const text = input.trim();
-    if (text.length <= maxCharacters) {
-        return [text];
-    }
-    const chunks = [];
-    let offset = 0;
-    while (offset < text.length) {
-        const end = Math.min(offset + maxCharacters, text.length);
-        const slice = text.slice(offset, end);
-        if (end === text.length) {
-            chunks.push(slice.trim());
-            break;
-        }
-        const candidateBreaks = [
-            slice.lastIndexOf('\n\n'),
-            slice.lastIndexOf('\n'),
-            slice.lastIndexOf('. '),
-        ];
-        const lastBreak = Math.max(...candidateBreaks);
-        const splitAt = lastBreak > Math.floor(maxCharacters * 0.5) ? lastBreak + 1 : slice.length;
-        const chunk = slice.slice(0, splitAt).trim();
-        if (chunk.length > 0) {
-            chunks.push(chunk);
-        }
-        offset += splitAt;
-    }
-    return chunks.filter((chunk) => chunk.length > 0);
-}
 const VERBOSE_PREFIX = '[summarize]';
 function writeVerbose(stderr, verbose, message, color) {
     if (!verbose) {
@@ -315,6 +397,11 @@ function formatBytes(bytes) {
     }
     return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[unitIndex]}`;
 }
+function formatCount(value) {
+    if (!Number.isFinite(value))
+        return 'unknown';
+    return value.toLocaleString('en-US');
+}
 function sumNumbersOrNull(values) {
     let sum = 0;
     let any = false;
@@ -339,7 +426,7 @@ function mergeStreamingChunk(previous, chunk) {
     }
     return { next: previous + chunk, appended: chunk };
 }
-function writeFinishLine({ stderr, elapsedMs, model, strategy, chunkCount, report, costUsd, color, }) {
+function writeFinishLine({ stderr, elapsedMs, model, report, costUsd, color, }) {
     const promptTokens = sumNumbersOrNull(report.llm.map((row) => row.promptTokens));
     const completionTokens = sumNumbersOrNull(report.llm.map((row) => row.completionTokens));
     const totalTokens = sumNumbersOrNull(report.llm.map((row) => row.totalTokens));
@@ -357,25 +444,10 @@ function writeFinishLine({ stderr, elapsedMs, model, strategy, chunkCount, repor
     if (report.services.apify.requests > 0) {
         parts.push(`apify=${report.services.apify.requests}`);
     }
-    if (strategy === 'map-reduce') {
-        parts.push('strategy=map-reduce');
-        if (typeof chunkCount === 'number' && Number.isFinite(chunkCount) && chunkCount > 0) {
-            parts.push(`chunks=${chunkCount}`);
-        }
-    }
     const line = `Finished in ${formatElapsedMs(elapsedMs)} (${parts.join(' | ')})`;
     stderr.write('\n');
     stderr.write(`${ansi('1;32', line, color)}\n`);
 }
-function buildChunkNotesPrompt({ content }) {
-    return `Return 10 bullet points summarizing the content below (Markdown).
-
-CONTENT:
-"""
-${content}
-"""
-`;
-}
 export async function runCli(argv, { env, fetch, stdout, stderr }) {
     ;
     globalThis.AI_SDK_LOG_WARNINGS = false;
@@ -427,18 +499,26 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
     const markdownMode = parseMarkdownMode(program.opts().markdown);
     const shouldComputeReport = metricsEnabled;
     const isYoutubeUrl = typeof url === 'string' ? /youtube\.com|youtu\.be/i.test(url) : false;
-    const firecrawlExplicitlySet = normalizedArgv.some((arg) => arg === '--firecrawl' || arg.startsWith('--firecrawl='));
     const requestedFirecrawlMode = parseFirecrawlMode(program.opts().firecrawl);
     const modelArg = typeof program.opts().model === 'string' ? program.opts().model : null;
     const { config, path: configPath } = loadSummarizeConfig({ env });
     const xaiKeyRaw = typeof env.XAI_API_KEY === 'string' ? env.XAI_API_KEY : null;
     const openaiBaseUrl = typeof env.OPENAI_BASE_URL === 'string' ? env.OPENAI_BASE_URL : null;
     const openRouterKeyRaw = typeof env.OPENROUTER_API_KEY === 'string' ? env.OPENROUTER_API_KEY : null;
+    const openRouterProvidersRaw = typeof env.OPENROUTER_PROVIDERS === 'string' ? env.OPENROUTER_PROVIDERS : null;
+    const openRouterProviders = openRouterProvidersRaw
+        ? openRouterProvidersRaw
+            .split(',')
+            .map((p) => p.trim())
+            .filter(Boolean)
+        : null;
     const openaiKeyRaw = typeof env.OPENAI_API_KEY === 'string' ? env.OPENAI_API_KEY : null;
     const apiKey = typeof openaiBaseUrl === 'string' && /openrouter\.ai/i.test(openaiBaseUrl)
         ? (openRouterKeyRaw ?? openaiKeyRaw)
         : openaiKeyRaw;
     const apifyToken = typeof env.APIFY_API_TOKEN === 'string' ? env.APIFY_API_TOKEN : null;
+    const ytDlpPath = typeof env.YT_DLP_PATH === 'string' ? env.YT_DLP_PATH : null;
+    const falApiKey = typeof env.FAL_KEY === 'string' ? env.FAL_KEY : null;
     const firecrawlKey = typeof env.FIRECRAWL_API_KEY === 'string' ? env.FIRECRAWL_API_KEY : null;
     const anthropicKeyRaw = typeof env.ANTHROPIC_API_KEY === 'string' ? env.ANTHROPIC_API_KEY : null;
     const googleKeyRaw = typeof env.GEMINI_API_KEY === 'string'
@@ -453,9 +533,13 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
     const xaiApiKey = xaiKeyRaw?.trim() ?? null;
     const googleApiKey = googleKeyRaw?.trim() ?? null;
     const anthropicApiKey = anthropicKeyRaw?.trim() ?? null;
+    const openrouterApiKey = openRouterKeyRaw?.trim() ?? null;
+    const openaiTranscriptionKey = openaiKeyRaw?.trim() ?? null;
     const googleConfigured = typeof googleApiKey === 'string' && googleApiKey.length > 0;
     const xaiConfigured = typeof xaiApiKey === 'string' && xaiApiKey.length > 0;
     const anthropicConfigured = typeof anthropicApiKey === 'string' && anthropicApiKey.length > 0;
+    const openrouterConfigured = typeof openrouterApiKey === 'string' && openrouterApiKey.length > 0;
+    const openrouterOptions = openRouterProviders ? { providers: openRouterProviders } : undefined;
     const llmCalls = [];
     let firecrawlRequests = 0;
     let apifyRequests = 0;
@@ -485,29 +569,41 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
             return null;
         return capMaxOutputTokensForModel({ modelId, requested: maxOutputTokensArg });
     };
+    const resolveMaxInputTokensForCall = async (modelId) => {
+        const catalog = await getLiteLlmCatalog();
+        if (!catalog)
+            return null;
+        const limit = resolveLiteLlmMaxInputTokensForModelId(catalog, modelId);
+        if (typeof limit === 'number' && Number.isFinite(limit) && limit > 0) {
+            return limit;
+        }
+        return null;
+    };
     const estimateCostUsd = async () => {
         const catalog = await getLiteLlmCatalog();
         if (!catalog)
             return null;
-        let total = 0;
-        let any = false;
-        for (const call of llmCalls) {
+        const calls = llmCalls.map((call) => {
             const promptTokens = call.usage?.promptTokens ?? null;
             const completionTokens = call.usage?.completionTokens ?? null;
-            if (typeof promptTokens !== 'number' ||
-                !Number.isFinite(promptTokens) ||
-                typeof completionTokens !== 'number' ||
-                !Number.isFinite(completionTokens)) {
-                continue;
-            }
-            const pricing = resolveLiteLlmPricingForModelId(catalog, call.model);
-            if (!pricing)
-                continue;
-            total +=
-                promptTokens * pricing.inputUsdPerToken + completionTokens * pricing.outputUsdPerToken;
-            any = true;
-        }
-        return any ? total : null;
+            const hasTokens = typeof promptTokens === 'number' &&
+                Number.isFinite(promptTokens) &&
+                typeof completionTokens === 'number' &&
+                Number.isFinite(completionTokens);
+            const usage = hasTokens
+                ? normalizeTokenUsage({
+                    inputTokens: promptTokens,
+                    outputTokens: completionTokens,
+                    totalTokens: call.usage?.totalTokens ?? undefined,
+                })
+                : null;
+            return { model: call.model, usage };
+        });
+        const result = await tallyCosts({
+            calls,
+            resolvePricing: (modelId) => resolveLiteLlmPricingForModelId(catalog, modelId),
+        });
+        return result.total?.totalUsd ?? null;
     };
     const buildReport = async () => {
         return buildRunMetricsReport({ llmCalls, firecrawlRequests, apifyRequests });
@@ -582,6 +678,7 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
             openaiApiKey: apiKey,
             googleApiKey: googleConfigured ? googleApiKey : null,
             anthropicApiKey: anthropicConfigured ? anthropicApiKey : null,
+            openrouterApiKey: openrouterConfigured ? openrouterApiKey : null,
         };
         const requiredKeyEnv = parsedModel.provider === 'xai'
             ? 'XAI_API_KEY'
@@ -589,14 +686,14 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                 ? 'GEMINI_API_KEY (or GOOGLE_GENERATIVE_AI_API_KEY / GOOGLE_API_KEY)'
                 : parsedModel.provider === 'anthropic'
                     ? 'ANTHROPIC_API_KEY'
-                    : 'OPENAI_API_KEY';
+                    : 'OPENAI_API_KEY (or OPENROUTER_API_KEY)';
         const hasRequiredKey = parsedModel.provider === 'xai'
             ? Boolean(xaiApiKey)
             : parsedModel.provider === 'google'
                 ? googleConfigured
                 : parsedModel.provider === 'anthropic'
                     ? anthropicConfigured
-                    : Boolean(apiKey);
+                    : Boolean(apiKey) || openrouterConfigured;
         if (!hasRequiredKey) {
             throw new Error(`Missing ${requiredKeyEnv} for model ${parsedModel.canonical}. Set the env var or choose a different --model.`);
         }
@@ -617,14 +714,29 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
         const effectiveModelId = modelResolution.modelId;
         const parsedModelEffective = parseGatewayStyleModelId(effectiveModelId);
         const streamingEnabledForCall = streamingEnabled && !modelResolution.forceStreamOff;
+        const maxOutputTokensForCall = await resolveMaxOutputTokensForCall(parsedModelEffective.canonical);
+        const textContent = getTextContentFromAttachment(attachment);
+        if (textContent && textContent.bytes > MAX_TEXT_BYTES_DEFAULT) {
+            throw new Error(`Text file too large (${formatBytes(textContent.bytes)}). Limit is ${formatBytes(MAX_TEXT_BYTES_DEFAULT)}.`);
+        }
         const summaryLengthTarget = lengthArg.kind === 'preset' ? lengthArg.preset : { maxCharacters: lengthArg.maxCharacters };
         const promptText = buildFileSummaryPrompt({
             filename: attachment.filename,
             mediaType: attachment.mediaType,
             summaryLength: summaryLengthTarget,
+            contentLength: textContent?.content.length ?? null,
         });
-        const maxOutputTokensForCall = await resolveMaxOutputTokensForCall(parsedModelEffective.canonical);
-        const promptPayload = buildAssetPromptPayload({ promptText, attachment });
+        const promptPayload = buildAssetPromptPayload({ promptText, attachment, textContent });
+        const maxInputTokensForCall = await resolveMaxInputTokensForCall(parsedModelEffective.canonical);
+        if (typeof maxInputTokensForCall === 'number' &&
+            Number.isFinite(maxInputTokensForCall) &&
+            maxInputTokensForCall > 0 &&
+            typeof promptPayload === 'string') {
+            const tokenCount = countTokens(promptPayload);
+            if (tokenCount > maxInputTokensForCall) {
+                throw new Error(`Input token count (${formatCount(tokenCount)}) exceeds model input limit (${formatCount(maxInputTokensForCall)}). Tokenized with GPT tokenizer; prompt included.`);
+            }
+        }
         const shouldBufferSummaryForRender = streamingEnabledForCall && effectiveRenderMode === 'md' && isRichTty(stdout);
         const shouldLiveRenderSummary = streamingEnabledForCall && effectiveRenderMode === 'md-live' && isRichTty(stdout);
         const shouldStreamSummaryToStdout = streamingEnabledForCall && !shouldBufferSummaryForRender && !shouldLiveRenderSummary;
@@ -637,6 +749,7 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                 streamResult = await streamTextWithModelId({
                     modelId: parsedModelEffective.canonical,
                     apiKeys: apiKeysForLlm,
+                    openrouter: openrouterOptions,
                     prompt: promptPayload,
                     temperature: 0,
                     maxOutputTokens: maxOutputTokensForCall ?? undefined,
@@ -645,7 +758,27 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                 });
             }
             catch (error) {
-                if (parsedModelEffective.provider === 'google' &&
+                if (isStreamingTimeoutError(error)) {
+                    writeVerbose(stderr, verbose, `Streaming timed out for ${parsedModelEffective.canonical}; falling back to non-streaming.`, verboseColor);
+                    const result = await summarizeWithModelId({
+                        modelId: parsedModelEffective.canonical,
+                        prompt: promptPayload,
+                        maxOutputTokens: maxOutputTokensForCall ?? undefined,
+                        timeoutMs,
+                        fetchImpl: trackedFetch,
+                        apiKeys: apiKeysForLlm,
+                        openrouter: openrouterOptions,
+                    });
+                    llmCalls.push({
+                        provider: result.provider,
+                        model: result.canonicalModelId,
+                        usage: result.usage,
+                        purpose: 'summary',
+                    });
+                    summary = result.text;
+                    streamResult = null;
+                }
+                else if (parsedModelEffective.provider === 'google' &&
                     isGoogleStreamingUnsupportedError(error)) {
                     writeVerbose(stderr, verbose, `Google model ${parsedModelEffective.canonical} rejected streamGenerateContent; falling back to non-streaming.`, verboseColor);
                     const result = await summarizeWithModelId({
@@ -655,6 +788,7 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                         timeoutMs,
                         fetchImpl: trackedFetch,
                         apiKeys: apiKeysForLlm,
+                        openrouter: openrouterOptions,
                     });
                     llmCalls.push({
                         provider: result.provider,
@@ -758,6 +892,7 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                     timeoutMs,
                     fetchImpl: trackedFetch,
                     apiKeys: apiKeysForLlm,
+                    openrouter: openrouterOptions,
                 });
             }
             catch (error) {
@@ -829,7 +964,6 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                     model: parsedModelEffective.canonical,
                     maxCompletionTokens: maxOutputTokensForCall,
                     strategy: 'single',
-                    chunkCount: 1,
                 },
                 metrics: metricsEnabled ? finishReport : null,
                 summary,
@@ -844,8 +978,6 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                     stderr,
                     elapsedMs: Date.now() - runStartedAtMs,
                     model: parsedModelEffective.canonical,
-                    strategy: 'single',
-                    chunkCount: 1,
                     report: finishReport,
                     costUsd,
                     color: verboseColor,
@@ -876,8 +1008,6 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                 stderr,
                 elapsedMs: Date.now() - runStartedAtMs,
                 model: parsedModelEffective.canonical,
-                strategy: 'single',
-                chunkCount: 1,
                 report,
                 costUsd,
                 color: verboseColor,
@@ -998,12 +1128,7 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
     if (!url) {
         throw new Error('Only HTTP and HTTPS URLs can be summarized');
     }
-    const firecrawlMode = (() => {
-        if (extractOnly && !isYoutubeUrl && !firecrawlExplicitlySet && firecrawlConfigured) {
-            return 'always';
-        }
-        return requestedFirecrawlMode;
-    })();
+    const firecrawlMode = requestedFirecrawlMode;
     if (firecrawlMode === 'always' && !firecrawlConfigured) {
         throw new Error('--firecrawl always requires FIRECRAWL_API_KEY');
     }
@@ -1029,7 +1154,7 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
     }
     writeVerbose(stderr, verbose, `config url=${url} timeoutMs=${timeoutMs} youtube=${youtubeMode} firecrawl=${firecrawlMode} length=${lengthArg.kind === 'preset' ? lengthArg.preset : `${lengthArg.maxCharacters} chars`} maxOutputTokens=${formatOptionalNumber(maxOutputTokensArg)} json=${json} extractOnly=${extractOnly} markdown=${effectiveMarkdownMode} model=${model} stream=${effectiveStreamMode} render=${effectiveRenderMode}`, verboseColor);
     writeVerbose(stderr, verbose, `configFile path=${formatOptionalString(configPath)} model=${formatOptionalString(config?.model ?? null)}`, verboseColor);
-    writeVerbose(stderr, verbose, `env xaiKey=${xaiConfigured} openaiKey=${Boolean(apiKey)} googleKey=${googleConfigured} anthropicKey=${anthropicConfigured} apifyToken=${Boolean(apifyToken)} firecrawlKey=${firecrawlConfigured}`, verboseColor);
+    writeVerbose(stderr, verbose, `env xaiKey=${xaiConfigured} openaiKey=${Boolean(apiKey)} googleKey=${googleConfigured} anthropicKey=${anthropicConfigured} openrouterKey=${openrouterConfigured} apifyToken=${Boolean(apifyToken)} firecrawlKey=${firecrawlConfigured}`, verboseColor);
     writeVerbose(stderr, verbose, `markdown requested=${markdownRequested} provider=${markdownProvider}`, verboseColor);
     const scrapeWithFirecrawl = firecrawlConfigured && firecrawlMode !== 'off'
         ? createFirecrawlScraper({ apiKey: firecrawlApiKey, fetchImpl: trackedFetch })
@@ -1041,12 +1166,17 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
             googleApiKey: googleConfigured ? googleApiKey : null,
             openaiApiKey: apiKey,
             anthropicApiKey: anthropicConfigured ? anthropicApiKey : null,
+            openrouterApiKey: openrouterConfigured ? openrouterApiKey : null,
+            openrouter: openrouterOptions,
             fetchImpl: trackedFetch,
             onUsage: ({ model: usedModel, provider, usage }) => {
                 llmCalls.push({ provider, model: usedModel, usage, purpose: 'markdown' });
             },
         })
         : null;
+    const readTweetWithBirdClient = hasBirdCli(env)
+        ? ({ url, timeoutMs }) => readTweetWithBird({ url, timeoutMs, env })
+        : null;
     writeVerbose(stderr, verbose, 'extract start', verboseColor);
     const stopOscProgress = startOscProgress({
         label: 'Fetching website',
@@ -1067,22 +1197,65 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
             phase: 'idle',
             htmlDownloadedBytes: 0,
             htmlTotalBytes: null,
+            fetchStartedAtMs: null,
             lastSpinnerUpdateAtMs: 0,
         };
-        const updateSpinner = (text) => {
+        let ticker = null;
+        const updateSpinner = (text, options) => {
             const now = Date.now();
-            if (now - state.lastSpinnerUpdateAtMs < 100)
+            if (!options?.force && now - state.lastSpinnerUpdateAtMs < 100)
                 return;
             state.lastSpinnerUpdateAtMs = now;
             spinner.setText(text);
         };
+        const formatFirecrawlReason = (reason) => {
+            const lower = reason.toLowerCase();
+            if (lower.includes('forced'))
+                return 'forced';
+            if (lower.includes('html fetch failed'))
+                return 'fallback: HTML fetch failed';
+            if (lower.includes('blocked') || lower.includes('thin'))
+                return 'fallback: blocked/thin HTML';
+            return reason;
+        };
+        const renderFetchLine = () => {
+            const downloaded = formatBytes(state.htmlDownloadedBytes);
+            const total = typeof state.htmlTotalBytes === 'number' ? `/${formatBytes(state.htmlTotalBytes)}` : '';
+            const elapsedMs = typeof state.fetchStartedAtMs === 'number' ? Date.now() - state.fetchStartedAtMs : 0;
+            const elapsed = formatElapsedMs(elapsedMs);
+            if (state.htmlDownloadedBytes === 0 && !state.htmlTotalBytes) {
+                return `Fetching website (connecting, ${elapsed})…`;
+            }
+            const rate = elapsedMs > 0 && state.htmlDownloadedBytes > 0
+                ? `, ${formatBytes(state.htmlDownloadedBytes / (elapsedMs / 1000))}/s`
+                : '';
+            return `Fetching website (${downloaded}${total}, ${elapsed}${rate})…`;
+        };
+        const startTicker = () => {
+            if (ticker)
+                return;
+            ticker = setInterval(() => {
+                if (state.phase !== 'fetching')
+                    return;
+                updateSpinner(renderFetchLine());
+            }, 1000);
+        };
+        const stopTicker = () => {
+            if (!ticker)
+                return;
+            clearInterval(ticker);
+            ticker = null;
+        };
         return {
             getHtmlDownloadedBytes: () => state.htmlDownloadedBytes,
+            stop: stopTicker,
             onProgress: (event) => {
                 if (event.kind === 'fetch-html-start') {
                     state.phase = 'fetching';
                     state.htmlDownloadedBytes = 0;
                     state.htmlTotalBytes = null;
+                    state.fetchStartedAtMs = Date.now();
+                    startTicker();
                     updateSpinner('Fetching website (connecting)…');
                     return;
                 }
@@ -1090,31 +1263,69 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                     state.phase = 'fetching';
                     state.htmlDownloadedBytes = event.downloadedBytes;
                     state.htmlTotalBytes = event.totalBytes;
-                    const downloaded = formatBytes(event.downloadedBytes);
-                    const total = typeof event.totalBytes === 'number' ? `/${formatBytes(event.totalBytes)}` : '';
-                    updateSpinner(`Fetching website (${downloaded}${total})…`);
+                    updateSpinner(renderFetchLine());
+                    return;
+                }
+                if (event.kind === 'bird-start') {
+                    state.phase = 'bird';
+                    stopTicker();
+                    updateSpinner('Bird: reading tweet…', { force: true });
+                    return;
+                }
+                if (event.kind === 'bird-done') {
+                    state.phase = 'bird';
+                    stopTicker();
+                    if (event.ok && typeof event.textBytes === 'number') {
+                        updateSpinner(`Bird: got ${formatBytes(event.textBytes)}…`, { force: true });
+                        return;
+                    }
+                    updateSpinner('Bird: failed; fallback…', { force: true });
+                    return;
+                }
+                if (event.kind === 'nitter-start') {
+                    state.phase = 'nitter';
+                    stopTicker();
+                    updateSpinner('Nitter: fetching…', { force: true });
+                    return;
+                }
+                if (event.kind === 'nitter-done') {
+                    state.phase = 'nitter';
+                    stopTicker();
+                    if (event.ok && typeof event.textBytes === 'number') {
+                        updateSpinner(`Nitter: got ${formatBytes(event.textBytes)}…`, { force: true });
+                        return;
+                    }
+                    updateSpinner('Nitter: failed; fallback…', { force: true });
                     return;
                 }
                 if (event.kind === 'firecrawl-start') {
                     state.phase = 'firecrawl';
-                    updateSpinner('Firecrawl: scraping…');
+                    stopTicker();
+                    const reason = event.reason ? formatFirecrawlReason(event.reason) : '';
+                    const suffix = reason ? ` (${reason})` : '';
+                    updateSpinner(`Firecrawl: scraping${suffix}…`, { force: true });
                     return;
                 }
                 if (event.kind === 'firecrawl-done') {
                     state.phase = 'firecrawl';
+                    stopTicker();
                     if (event.ok && typeof event.markdownBytes === 'number') {
-                        updateSpinner(`Firecrawl: got ${formatBytes(event.markdownBytes)}…`);
+                        updateSpinner(`Firecrawl: got ${formatBytes(event.markdownBytes)}…`, { force: true });
                         return;
                     }
-                    updateSpinner('Firecrawl: no content; fallback…');
+                    updateSpinner('Firecrawl: no content; fallback…', { force: true });
                 }
             },
         };
     })();
     const client = createLinkPreviewClient({
         apifyApiToken: apifyToken,
+        ytDlpPath,
+        falApiKey,
+        openaiApiKey: openaiTranscriptionKey,
         scrapeWithFirecrawl,
         convertHtmlToMarkdown,
+        readTweetWithBird: readTweetWithBirdClient,
         fetch: trackedFetch,
         onProgress: websiteProgress?.onProgress ?? null,
     });
@@ -1123,24 +1334,42 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
         if (stopped)
             return;
         stopped = true;
+        websiteProgress?.stop?.();
         spinner.stopAndClear();
         stopOscProgress();
     };
     clearProgressBeforeStdout = stopProgress;
     try {
-        const extracted = await client.fetchLinkContent(url, {
-            timeoutMs,
-            youtubeTranscript: youtubeMode,
-            firecrawl: firecrawlMode,
-            format: markdownRequested ? 'markdown' : 'text',
-        });
+        let extracted;
+        try {
+            extracted = await client.fetchLinkContent(url, {
+                timeoutMs,
+                youtubeTranscript: youtubeMode,
+                firecrawl: firecrawlMode,
+                format: markdownRequested ? 'markdown' : 'text',
+            });
+        }
+        catch (error) {
+            throw withBirdTip(error, url, env);
+        }
         const extractedContentBytes = Buffer.byteLength(extracted.content, 'utf8');
         const extractedContentSize = formatBytes(extractedContentBytes);
-        const viaFirecrawl = extracted.diagnostics.firecrawl.used ? ', Firecrawl' : '';
+        const viaSources = [];
+        if (extracted.diagnostics.strategy === 'bird') {
+            viaSources.push('bird');
+        }
+        if (extracted.diagnostics.strategy === 'nitter') {
+            viaSources.push('Nitter');
+        }
+        if (extracted.diagnostics.firecrawl.used) {
+            viaSources.push('Firecrawl');
+        }
+        const viaSourceLabel = viaSources.length > 0 ? `, ${viaSources.join('+')}` : '';
         if (progressEnabled) {
+            websiteProgress?.stop?.();
             spinner.setText(extractOnly
-                ? `Extracted (${extractedContentSize})`
-                : `Summarizing (sent ${extractedContentSize}${viaFirecrawl})…`);
+                ? `Extracted (${extractedContentSize}${viaSourceLabel})`
+                : `Summarizing (sent ${extractedContentSize}${viaSourceLabel})…`);
         }
         writeVerbose(stderr, verbose, `extract done strategy=${extracted.diagnostics.strategy} siteName=${formatOptionalString(extracted.siteName)} title=${formatOptionalString(extracted.title)} transcriptSource=${formatOptionalString(extracted.transcriptSource)}`, verboseColor);
         writeVerbose(stderr, verbose, `extract stats characters=${extracted.totalCharacters} words=${extracted.wordCount} transcriptCharacters=${formatOptionalNumber(extracted.transcriptCharacters)} transcriptLines=${formatOptionalNumber(extracted.transcriptLines)}`, verboseColor);
@@ -1204,8 +1433,6 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                         stderr,
                         elapsedMs: Date.now() - runStartedAtMs,
                         model,
-                        strategy: 'none',
-                        chunkCount: null,
                         report: finishReport,
                         costUsd,
                         color: verboseColor,
@@ -1223,8 +1450,76 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                     stderr,
                     elapsedMs: Date.now() - runStartedAtMs,
                     model,
-                    strategy: 'none',
-                    chunkCount: null,
+                    report,
+                    costUsd,
+                    color: verboseColor,
+                });
+            }
+            return;
+        }
+        const shouldSkipTweetSummary = isTwitterStatusUrl(url) &&
+            extracted.content.length > 0 &&
+            extracted.content.length <= resolveTargetCharacters(lengthArg);
+        if (shouldSkipTweetSummary) {
+            clearProgressForStdout();
+            writeVerbose(stderr, verbose, `skip summary: tweet content length=${extracted.content.length} target=${resolveTargetCharacters(lengthArg)}`, verboseColor);
+            if (json) {
+                const finishReport = shouldComputeReport ? await buildReport() : null;
+                const payload = {
+                    input: {
+                        kind: 'url',
+                        url,
+                        timeoutMs,
+                        youtube: youtubeMode,
+                        firecrawl: firecrawlMode,
+                        markdown: effectiveMarkdownMode,
+                        length: lengthArg.kind === 'preset'
+                            ? { kind: 'preset', preset: lengthArg.preset }
+                            : { kind: 'chars', maxCharacters: lengthArg.maxCharacters },
+                        maxOutputTokens: maxOutputTokensArg,
+                        model,
+                    },
+                    env: {
+                        hasXaiKey: Boolean(xaiApiKey),
+                        hasOpenAIKey: Boolean(apiKey),
+                        hasApifyToken: Boolean(apifyToken),
+                        hasFirecrawlKey: firecrawlConfigured,
+                        hasGoogleKey: googleConfigured,
+                        hasAnthropicKey: anthropicConfigured,
+                    },
+                    extracted,
+                    prompt,
+                    llm: null,
+                    metrics: metricsEnabled ? finishReport : null,
+                    summary: extracted.content,
+                };
+                if (metricsDetailed && finishReport) {
+                    writeMetricsReport(finishReport);
+                }
+                stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+                if (metricsEnabled && finishReport) {
+                    const costUsd = await estimateCostUsd();
+                    writeFinishLine({
+                        stderr,
+                        elapsedMs: Date.now() - runStartedAtMs,
+                        model,
+                        report: finishReport,
+                        costUsd,
+                        color: verboseColor,
+                    });
+                }
+                return;
+            }
+            stdout.write(`${extracted.content}\n`);
+            const report = shouldComputeReport ? await buildReport() : null;
+            if (metricsDetailed && report)
+                writeMetricsReport(report);
+            if (metricsEnabled && report) {
+                const costUsd = await estimateCostUsd();
+                writeFinishLine({
+                    stderr,
+                    elapsedMs: Date.now() - runStartedAtMs,
+                    model,
                     report,
                     costUsd,
                     color: verboseColor,
@@ -1238,6 +1533,7 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
             openaiApiKey: apiKey,
             googleApiKey: googleConfigured ? googleApiKey : null,
             anthropicApiKey: anthropicConfigured ? anthropicApiKey : null,
+            openrouterApiKey: openrouterConfigured ? openrouterApiKey : null,
         };
         const requiredKeyEnv = parsedModel.provider === 'xai'
             ? 'XAI_API_KEY'
@@ -1245,14 +1541,14 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                 ? 'GEMINI_API_KEY (or GOOGLE_GENERATIVE_AI_API_KEY / GOOGLE_API_KEY)'
                 : parsedModel.provider === 'anthropic'
                     ? 'ANTHROPIC_API_KEY'
-                    : 'OPENAI_API_KEY';
+                    : 'OPENAI_API_KEY (or OPENROUTER_API_KEY)';
         const hasRequiredKey = parsedModel.provider === 'xai'
             ? Boolean(xaiApiKey)
             : parsedModel.provider === 'google'
                 ? googleConfigured
                 : parsedModel.provider === 'anthropic'
                     ? anthropicConfigured
-                    : Boolean(apiKey);
+                    : Boolean(apiKey) || openrouterConfigured;
         if (!hasRequiredKey) {
             throw new Error(`Missing ${requiredKeyEnv} for model ${parsedModel.canonical}. Set the env var or choose a different --model.`);
         }
@@ -1269,321 +1565,168 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
         const streamingEnabledForCall = streamingEnabled && !modelResolution.forceStreamOff;
         writeVerbose(stderr, verbose, `mode summarize provider=${parsedModelEffective.provider} model=${parsedModelEffective.canonical}`, verboseColor);
         const maxOutputTokensForCall = await resolveMaxOutputTokensForCall(parsedModelEffective.canonical);
-        const isLargeContent = extracted.content.length >= MAP_REDUCE_TRIGGER_CHARACTERS;
-        let strategy = 'single';
-        let chunkCount = 1;
+        const maxInputTokensForCall = await resolveMaxInputTokensForCall(parsedModelEffective.canonical);
+        if (typeof maxInputTokensForCall === 'number' &&
+            Number.isFinite(maxInputTokensForCall) &&
+            maxInputTokensForCall > 0) {
+            const tokenCount = countTokens(prompt);
+            if (tokenCount > maxInputTokensForCall) {
+                throw new Error(`Input token count (${formatCount(tokenCount)}) exceeds model input limit (${formatCount(maxInputTokensForCall)}). Tokenized with GPT tokenizer; prompt included.`);
+            }
+        }
         const shouldBufferSummaryForRender = streamingEnabledForCall && effectiveRenderMode === 'md' && isRichTty(stdout);
         const shouldLiveRenderSummary = streamingEnabledForCall && effectiveRenderMode === 'md-live' && isRichTty(stdout);
         const shouldStreamSummaryToStdout = streamingEnabledForCall && !shouldBufferSummaryForRender && !shouldLiveRenderSummary;
         let summaryAlreadyPrinted = false;
         let summary = '';
         let getLastStreamError = null;
-        if (!isLargeContent) {
-            writeVerbose(stderr, verbose, 'summarize strategy=single', verboseColor);
-            if (streamingEnabledForCall) {
-                writeVerbose(stderr, verbose, `summarize stream=on buffered=${shouldBufferSummaryForRender}`, verboseColor);
-                let streamResult = null;
-                try {
-                    streamResult = await streamTextWithModelId({
+        writeVerbose(stderr, verbose, 'summarize strategy=single', verboseColor);
+        if (streamingEnabledForCall) {
+            writeVerbose(stderr, verbose, `summarize stream=on buffered=${shouldBufferSummaryForRender}`, verboseColor);
+            let streamResult = null;
+            try {
+                streamResult = await streamTextWithModelId({
+                    modelId: parsedModelEffective.canonical,
+                    apiKeys: apiKeysForLlm,
+                    prompt,
+                    temperature: 0,
+                    maxOutputTokens: maxOutputTokensForCall ?? undefined,
+                    timeoutMs,
+                    fetchImpl: trackedFetch,
+                });
+            }
+            catch (error) {
+                if (isStreamingTimeoutError(error)) {
+                    writeVerbose(stderr, verbose, `Streaming timed out for ${parsedModelEffective.canonical}; falling back to non-streaming.`, verboseColor);
+                    const result = await summarizeWithModelId({
                         modelId: parsedModelEffective.canonical,
-                        apiKeys: apiKeysForLlm,
                         prompt,
-                        temperature: 0,
                         maxOutputTokens: maxOutputTokensForCall ?? undefined,
                         timeoutMs,
                         fetchImpl: trackedFetch,
+                        apiKeys: apiKeysForLlm,
+                        openrouter: openrouterOptions,
                     });
-                }
-                catch (error) {
-                    if (parsedModelEffective.provider === 'google' &&
-                        isGoogleStreamingUnsupportedError(error)) {
-                        writeVerbose(stderr, verbose, `Google model ${parsedModelEffective.canonical} rejected streamGenerateContent; falling back to non-streaming.`, verboseColor);
-                        const result = await summarizeWithModelId({
-                            modelId: parsedModelEffective.canonical,
-                            prompt,
-                            maxOutputTokens: maxOutputTokensForCall ?? undefined,
-                            timeoutMs,
-                            fetchImpl: trackedFetch,
-                            apiKeys: apiKeysForLlm,
-                        });
-                        llmCalls.push({
-                            provider: result.provider,
-                            model: result.canonicalModelId,
-                            usage: result.usage,
-                            purpose: 'summary',
-                        });
-                        summary = result.text;
-                        streamResult = null;
-                    }
-                    else {
-                        throw error;
-                    }
-                }
-                if (streamResult) {
-                    getLastStreamError = streamResult.lastError;
-                    let streamed = '';
-                    const liveRenderer = shouldLiveRenderSummary
-                        ? createLiveRenderer({
-                            write: (chunk) => {
-                                clearProgressForStdout();
-                                stdout.write(chunk);
-                            },
-                            width: markdownRenderWidth(stdout, env),
-                            renderFrame: (markdown) => renderMarkdownAnsi(markdown, {
-                                width: markdownRenderWidth(stdout, env),
-                                wrap: true,
-                                color: supportsColor(stdout, env),
-                            }),
-                        })
-                        : null;
-                    let lastFrameAtMs = 0;
-                    try {
-                        let cleared = false;
-                        for await (const delta of streamResult.textStream) {
-                            const merged = mergeStreamingChunk(streamed, delta);
-                            streamed = merged.next;
-                            if (shouldStreamSummaryToStdout) {
-                                if (!cleared) {
-                                    clearProgressForStdout();
-                                    cleared = true;
-                                }
-                                if (merged.appended)
-                                    stdout.write(merged.appended);
-                                continue;
-                            }
-                            if (liveRenderer) {
-                                const now = Date.now();
-                                const due = now - lastFrameAtMs >= 120;
-                                const hasNewline = delta.includes('\n');
-                                if (hasNewline || due) {
-                                    liveRenderer.render(streamed);
-                                    lastFrameAtMs = now;
-                                }
-                            }
-                        }
-                        const trimmed = streamed.trim();
-                        streamed = trimmed;
-                        if (liveRenderer) {
-                            liveRenderer.render(trimmed);
-                            summaryAlreadyPrinted = true;
-                        }
-                    }
-                    finally {
-                        liveRenderer?.finish();
-                    }
-                    const usage = await streamResult.usage;
                     llmCalls.push({
-                        provider: streamResult.provider,
-                        model: streamResult.canonicalModelId,
-                        usage,
+                        provider: result.provider,
+                        model: result.canonicalModelId,
+                        usage: result.usage,
                         purpose: 'summary',
                     });
-                    summary = streamed;
-                    if (shouldStreamSummaryToStdout) {
-                        if (!streamed.endsWith('\n')) {
-                            stdout.write('\n');
-                        }
-                        summaryAlreadyPrinted = true;
-                    }
+                    summary = result.text;
+                    streamResult = null;
                 }
-            }
-            else {
-                const result = await summarizeWithModelId({
-                    modelId: parsedModelEffective.canonical,
-                    prompt,
-                    maxOutputTokens: maxOutputTokensForCall ?? undefined,
-                    timeoutMs,
-                    fetchImpl: trackedFetch,
-                    apiKeys: apiKeysForLlm,
-                });
-                llmCalls.push({
-                    provider: result.provider,
-                    model: result.canonicalModelId,
-                    usage: result.usage,
-                    purpose: 'summary',
-                });
-                summary = result.text;
-            }
-        }
-        else {
-            strategy = 'map-reduce';
-            const chunks = splitTextIntoChunks(extracted.content, MAP_REDUCE_CHUNK_CHARACTERS);
-            chunkCount = chunks.length;
-            stderr.write(`Large input (${extracted.content.length} chars); summarizing in ${chunks.length} chunks.\n`);
-            writeVerbose(stderr, verbose, `summarize strategy=map-reduce chunks=${chunks.length}`, verboseColor);
-            const chunkNotes = [];
-            for (let i = 0; i < chunks.length; i += 1) {
-                writeVerbose(stderr, verbose, `summarize chunk ${i + 1}/${chunks.length} notes start`, verboseColor);
-                const chunkPrompt = buildChunkNotesPrompt({
-                    content: chunks[i] ?? '',
-                });
-                const chunkNoteTokensRequested = typeof maxOutputTokensArg === 'number'
-                    ? Math.min(SUMMARY_LENGTH_TO_TOKENS.medium, maxOutputTokensArg)
-                    : SUMMARY_LENGTH_TO_TOKENS.medium;
-                const chunkNoteTokens = await capMaxOutputTokensForModel({
-                    modelId: parsedModelEffective.canonical,
-                    requested: chunkNoteTokensRequested,
-                });
-                const notesResult = await summarizeWithModelId({
-                    modelId: parsedModelEffective.canonical,
-                    prompt: chunkPrompt,
-                    maxOutputTokens: chunkNoteTokens,
-                    timeoutMs,
-                    fetchImpl: trackedFetch,
-                    apiKeys: apiKeysForLlm,
-                });
-                const notes = notesResult.text;
-                llmCalls.push({
-                    provider: notesResult.provider,
-                    model: notesResult.canonicalModelId,
-                    usage: notesResult.usage,
-                    purpose: 'chunk-notes',
-                });
-                chunkNotes.push(notes.trim());
-            }
-            writeVerbose(stderr, verbose, 'summarize merge chunk notes', verboseColor);
-            const mergedContent = `Chunk notes (generated from the full input):\n\n${chunkNotes
-                .filter((value) => value.length > 0)
-                .join('\n\n')}`;
-            const mergedPrompt = buildLinkSummaryPrompt({
-                url: extracted.url,
-                title: extracted.title,
-                siteName: extracted.siteName,
-                description: extracted.description,
-                content: mergedContent,
-                truncated: false,
-                hasTranscript: isYouTube ||
-                    (extracted.transcriptSource !== null && extracted.transcriptSource !== 'unavailable'),
-                summaryLength: lengthArg.kind === 'preset'
-                    ? lengthArg.preset
-                    : { maxCharacters: lengthArg.maxCharacters },
-                shares: [],
-            });
-            if (streamingEnabledForCall) {
-                writeVerbose(stderr, verbose, `summarize stream=on buffered=${shouldBufferSummaryForRender}`, verboseColor);
-                let streamResult = null;
-                try {
-                    streamResult = await streamTextWithModelId({
+                else if (parsedModelEffective.provider === 'google' &&
+                    isGoogleStreamingUnsupportedError(error)) {
+                    writeVerbose(stderr, verbose, `Google model ${parsedModelEffective.canonical} rejected streamGenerateContent; falling back to non-streaming.`, verboseColor);
+                    const result = await summarizeWithModelId({
                         modelId: parsedModelEffective.canonical,
-                        apiKeys: apiKeysForLlm,
-                        prompt: mergedPrompt,
-                        temperature: 0,
+                        prompt,
                         maxOutputTokens: maxOutputTokensForCall ?? undefined,
                         timeoutMs,
                         fetchImpl: trackedFetch,
+                        apiKeys: apiKeysForLlm,
+                        openrouter: openrouterOptions,
+                    });
+                    llmCalls.push({
+                        provider: result.provider,
+                        model: result.canonicalModelId,
+                        usage: result.usage,
+                        purpose: 'summary',
                     });
+                    summary = result.text;
+                    streamResult = null;
                 }
-                catch (error) {
-                    if (parsedModelEffective.provider === 'google' &&
-                        isGoogleStreamingUnsupportedError(error)) {
-                        writeVerbose(stderr, verbose, `Google model ${parsedModelEffective.canonical} rejected streamGenerateContent; falling back to non-streaming.`, verboseColor);
-                        const mergedResult = await summarizeWithModelId({
-                            modelId: parsedModelEffective.canonical,
-                            prompt: mergedPrompt,
-                            maxOutputTokens: maxOutputTokensForCall ?? undefined,
-                            timeoutMs,
-                            fetchImpl: trackedFetch,
-                            apiKeys: apiKeysForLlm,
-                        });
-                        llmCalls.push({
-                            provider: mergedResult.provider,
-                            model: mergedResult.canonicalModelId,
-                            usage: mergedResult.usage,
-                            purpose: 'summary',
-                        });
-                        summary = mergedResult.text;
-                        streamResult = null;
-                    }
-                    else {
-                        throw error;
-                    }
+                else {
+                    throw error;
                 }
-                if (streamResult) {
-                    getLastStreamError = streamResult.lastError;
-                    let streamed = '';
-                    const liveRenderer = shouldLiveRenderSummary
-                        ? createLiveRenderer({
-                            write: (chunk) => {
-                                clearProgressForStdout();
-                                stdout.write(chunk);
-                            },
+            }
+            if (streamResult) {
+                getLastStreamError = streamResult.lastError;
+                let streamed = '';
+                const liveRenderer = shouldLiveRenderSummary
+                    ? createLiveRenderer({
+                        write: (chunk) => {
+                            clearProgressForStdout();
+                            stdout.write(chunk);
+                        },
+                        width: markdownRenderWidth(stdout, env),
+                        renderFrame: (markdown) => renderMarkdownAnsi(markdown, {
                             width: markdownRenderWidth(stdout, env),
-                            renderFrame: (markdown) => renderMarkdownAnsi(markdown, {
-                                width: markdownRenderWidth(stdout, env),
-                                wrap: true,
-                                color: supportsColor(stdout, env),
-                            }),
-                        })
-                        : null;
-                    let lastFrameAtMs = 0;
-                    try {
-                        let cleared = false;
-                        for await (const delta of streamResult.textStream) {
+                            wrap: true,
+                            color: supportsColor(stdout, env),
+                        }),
+                    })
+                    : null;
+                let lastFrameAtMs = 0;
+                try {
+                    let cleared = false;
+                    for await (const delta of streamResult.textStream) {
+                        const merged = mergeStreamingChunk(streamed, delta);
+                        streamed = merged.next;
+                        if (shouldStreamSummaryToStdout) {
                             if (!cleared) {
                                 clearProgressForStdout();
                                 cleared = true;
                             }
-                            const merged = mergeStreamingChunk(streamed, delta);
-                            streamed = merged.next;
-                            if (shouldStreamSummaryToStdout) {
-                                if (merged.appended)
-                                    stdout.write(merged.appended);
-                                continue;
-                            }
-                            if (liveRenderer) {
-                                const now = Date.now();
-                                const due = now - lastFrameAtMs >= 120;
-                                const hasNewline = delta.includes('\n');
-                                if (hasNewline || due) {
-                                    liveRenderer.render(streamed);
-                                    lastFrameAtMs = now;
-                                }
-                            }
+                            if (merged.appended)
+                                stdout.write(merged.appended);
+                            continue;
                         }
-                        const trimmed = streamed.trim();
-                        streamed = trimmed;
                         if (liveRenderer) {
-                            liveRenderer.render(trimmed);
-                            summaryAlreadyPrinted = true;
+                            const now = Date.now();
+                            const due = now - lastFrameAtMs >= 120;
+                            const hasNewline = delta.includes('\n');
+                            if (hasNewline || due) {
+                                liveRenderer.render(streamed);
+                                lastFrameAtMs = now;
+                            }
                         }
                     }
-                    finally {
-                        liveRenderer?.finish();
-                    }
-                    const usage = await streamResult.usage;
-                    llmCalls.push({
-                        provider: streamResult.provider,
-                        model: streamResult.canonicalModelId,
-                        usage,
-                        purpose: 'summary',
-                    });
-                    summary = streamed;
-                    if (shouldStreamSummaryToStdout) {
-                        if (!streamed.endsWith('\n')) {
-                            stdout.write('\n');
-                        }
+                    const trimmed = streamed.trim();
+                    streamed = trimmed;
+                    if (liveRenderer) {
+                        liveRenderer.render(trimmed);
                         summaryAlreadyPrinted = true;
                     }
                 }
-            }
-            else {
-                const mergedResult = await summarizeWithModelId({
-                    modelId: parsedModelEffective.canonical,
-                    prompt: mergedPrompt,
-                    maxOutputTokens: maxOutputTokensForCall ?? undefined,
-                    timeoutMs,
-                    fetchImpl: trackedFetch,
-                    apiKeys: apiKeysForLlm,
-                });
+                finally {
+                    liveRenderer?.finish();
+                }
+                const usage = await streamResult.usage;
                 llmCalls.push({
-                    provider: mergedResult.provider,
-                    model: mergedResult.canonicalModelId,
-                    usage: mergedResult.usage,
+                    provider: streamResult.provider,
+                    model: streamResult.canonicalModelId,
+                    usage,
                     purpose: 'summary',
                 });
-                summary = mergedResult.text;
+                summary = streamed;
+                if (shouldStreamSummaryToStdout) {
+                    if (!streamed.endsWith('\n')) {
+                        stdout.write('\n');
+                    }
+                    summaryAlreadyPrinted = true;
+                }
             }
         }
+        else {
+            const result = await summarizeWithModelId({
+                modelId: parsedModelEffective.canonical,
+                prompt,
+                maxOutputTokens: maxOutputTokensForCall ?? undefined,
+                timeoutMs,
+                fetchImpl: trackedFetch,
+                apiKeys: apiKeysForLlm,
+                openrouter: openrouterOptions,
+            });
+            llmCalls.push({
+                provider: result.provider,
+                model: result.canonicalModelId,
+                usage: result.usage,
+                purpose: 'summary',
+            });
+            summary = result.text;
+        }
         summary = summary.trim();
         if (summary.length === 0) {
             const last = getLastStreamError?.();
@@ -1622,8 +1765,7 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                     provider: parsedModelEffective.provider,
                     model: parsedModelEffective.canonical,
                     maxCompletionTokens: maxOutputTokensForCall,
-                    strategy,
-                    chunkCount,
+                    strategy: 'single',
                 },
                 metrics: metricsEnabled ? finishReport : null,
                 summary,
@@ -1638,8 +1780,6 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                     stderr,
                     elapsedMs: Date.now() - runStartedAtMs,
                     model: parsedModelEffective.canonical,
-                    strategy,
-                    chunkCount,
                     report: finishReport,
                     costUsd,
                     color: verboseColor,
@@ -1670,8 +1810,6 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                 stderr,
                 elapsedMs: Date.now() - runStartedAtMs,
                 model: parsedModelEffective.canonical,
-                strategy,
-                chunkCount,
                 report,
                 costUsd,
                 color: verboseColor,