@agentproto/corpus-cli 0.1.0-alpha.1

package/dist/ports/index.d.ts

@@ -0,0 +1,531 @@
+export { N as NodeFsAdapter, a as NodeFsAdapterOptions, O as OsIdentityAdapter, b as OsIdentityAdapterOptions } from '../os-identity.adapter-CLBmnRoD.js';
+import { FetcherPort, FetchedSource, DistillPort, DistillInput, DistilledItem, SinkPort, SinkItem, SinkPushResult } from '@agentproto/corpus';
+export { buildDistillPrompt, parseItems } from '@agentproto/corpus';
+import { z } from 'zod';
+
+/**
+ * BrowserMcpFetcher — a FetcherPort that extracts ARTICLE text through
+ * the user's authenticated browser (chrome-devtools-mcp). Use it for
+ * pages that a plain HTTP fetch can't read: login-walled, consent-walled,
+ * or JS-rendered (SPA) content. For public static articles the cheaper
+ * HttpReadabilityFetcher suffices; for video, YtDlpWhisperFetcher handles
+ * transcription — this fetcher does NOT touch video.
+ *
+ *   navigate_page(url) → evaluate_script(readability) → { title, text }
+ *
+ * (It used to also scrape YouTube captions, but YouTube's caption APIs
+ * are pot/SABR-gated and unreliable; transcription via YtDlpWhisperFetcher
+ * replaced that path entirely.)
+ *
+ * The browser is injected as a minimal structural `BrowserMcpLike` (just
+ * `callTool`, matching `@agentproto/driver-mcp`'s `McpClient`), so this
+ * adapter has no hard MCP-SDK dependency and is unit-testable with a fake
+ * client. The CLI wires the real chrome-devtools-mcp client.
+ */
+
+/** Minimal MCP client surface — matches `@agentproto/driver-mcp`'s `McpClient`. */
+interface BrowserMcpLike {
+    callTool(args: {
+        name: string;
+        arguments: Record<string, unknown>;
+    }): Promise<{
+        content?: unknown;
+        structuredContent?: unknown;
+        isError?: boolean;
+    }>;
+}
+interface BrowserMcpFetcherOptions {
+    readonly browser: BrowserMcpLike;
+    /** chrome-devtools-mcp tool names — overridable if a host renames them. */
+    readonly navigateToolName?: string;
+    readonly evaluateToolName?: string;
+}
+declare class BrowserMcpFetcher implements FetcherPort {
+    private readonly browser;
+    private readonly navigateTool;
+    private readonly evaluateTool;
+    constructor(opts: BrowserMcpFetcherOptions);
+    fetch(url: string): Promise<FetchedSource | null>;
+}
+
+/**
+ * ScrapeMcpFetcher — a FetcherPort that delegates article/page fetching to
+ * any MCP server exposing a `scrape(url)` tool (e.g. the browser project's
+ * tiered router: HTTP → Chromium → Camofox stealth → agent, with cookie
+ * injection and auto-escalation on bot-walls). The browser stack is reached
+ * over MCP, so this stays vendor-neutral — corpus-cli never imports it.
+ *
+ *   scrape(url) → { title, markdown } → FetchedSource
+ *
+ * It does NOT touch video URLs (YtDlpWhisperFetcher owns those) and returns
+ * `null` for a blocked / empty page so the importer skips-with-warning
+ * rather than aborting the batch.
+ *
+ * The MCP client is injected as the minimal structural `BrowserMcpLike`
+ * (just `callTool`), the same surface `BrowserMcpFetcher` consumes — so this
+ * adapter has no MCP-SDK dependency and is unit-testable with a fake client.
+ */
+
+interface ScrapeMcpFetcherOptions {
+    readonly client: BrowserMcpLike;
+    /** Tool name on the MCP server — overridable if a host renames it. */
+    readonly scrapeToolName?: string;
+}
+declare class ScrapeMcpFetcher implements FetcherPort {
+    private readonly client;
+    private readonly toolName;
+    constructor(opts: ScrapeMcpFetcherOptions);
+    fetch(url: string): Promise<FetchedSource | null>;
+}
+
+/**
+ * SttPort — speech-to-text boundary the YtDlpWhisperFetcher consumes.
+ *
+ * Keeps the fetcher pure of any STT-vendor specifics: it hands a local
+ * audio file path to `transcribe()` and gets back text. The CLI wires a
+ * concrete impl (OpenAI Whisper here; swap for a self-hosted whisper.cpp
+ * or Deepgram impl without touching the fetcher).
+ */
+interface Transcript {
+    readonly text: string;
+    /** BCP-47 language, when the engine detects it. */
+    readonly language?: string;
+}
+interface SttPort {
+    transcribe(audioPath: string): Promise<Transcript>;
+}
+interface OpenAiWhisperSttOptions {
+    readonly apiKey: string;
+    /** Default "whisper-1". */
+    readonly model?: string;
+    /** Override base URL (proxy / Azure). Default OpenAI. */
+    readonly baseUrl?: string;
+}
+/**
+ * OpenAI Whisper STT. Posts the audio file to /audio/transcriptions with
+ * `response_format=verbose_json` so we recover the detected language.
+ *
+ * Files above OpenAI's 25 MB cap throw a clear error — the caller should
+ * have downloaded at a lower bitrate (the fetcher uses 64 kbps mono) or
+ * chunk long media. We surface the size rather than letting the API 413.
+ */
+declare class OpenAiWhisperStt implements SttPort {
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    constructor(opts: OpenAiWhisperSttOptions);
+    transcribe(audioPath: string): Promise<Transcript>;
+    /**
+     * POST the audio with bounded retry. Transcribing a long talk fans out
+     * into many segment uploads (see ChunkedStt), so a single transient
+     * network blip ("fetch failed") or a 429 / 5xx must not abort the whole
+     * batch. Network errors and retryable statuses back off and retry;
+     * client errors (401 auth, 400 bad request) return immediately so a real
+     * misconfiguration still surfaces loudly.
+     */
+    private postWithRetry;
+}
+
+/**
+ * YtDlpWhisperFetcher — a FetcherPort for video URLs that does NOT rely
+ * on captions (YouTube's caption/transcript APIs are pot/SABR-gated and
+ * frequently unavailable). Instead it pulls the audio with yt-dlp and
+ * transcribes it with an injected SttPort (Whisper). Captions-independent
+ * and robust: works whether or not the video has subtitles.
+ *
+ *   video URL → yt-dlp -f bestaudio -x (mp3) → SttPort.transcribe → text
+ *
+ * yt-dlp handles the pot token / SABR negotiation / signature itself, so
+ * no browser or cookies are needed for public videos. Non-video URLs
+ * resolve to `null` so this fetcher composes ahead of a readability
+ * fetcher (see CompositeFetcher).
+ *
+ * The yt-dlp invocation is injected as `download` so the adapter is unit-
+ * testable with a fake downloader + fake SttPort — no binary, no network.
+ */
+
+interface AudioDownload {
+    readonly audioPath: string;
+    readonly title: string;
+    readonly language?: string;
+    /** Remove the temp working dir. Always called by the fetcher. */
+    cleanup(): Promise<void>;
+}
+/** Pull a URL's audio to a local file. Injectable for tests. */
+type AudioDownloader = (url: string) => Promise<AudioDownload>;
+interface YtDlpWhisperFetcherOptions {
+    readonly stt: SttPort;
+    /** Defaults to a yt-dlp subprocess downloader. */
+    readonly download?: AudioDownloader;
+    /** Path to the yt-dlp binary (default: "yt-dlp" on PATH). */
+    readonly ytDlpBin?: string;
+    /** Treat these hostnames as video (in addition to the YouTube/Vimeo set). */
+    readonly extraVideoHosts?: readonly string[];
+    /**
+     * Skip videos longer than this many seconds, BEFORE downloading
+     * (yt-dlp `--match-filter "duration <= N"`). A filtered video pulls no
+     * bytes and resolves to `null` (skipped), so a stray 40-hour stream
+     * can't blow up the batch. Omit for no cap — long media is segmented by
+     * `ChunkedStt`, so length alone is not a blocker.
+     */
+    readonly maxDurationSec?: number;
+    /**
+     * Read cookies from a local browser (`chrome`, `firefox`, `chrome:Profile 1`)
+     * — passed to yt-dlp as `--cookies-from-browser`. Authenticated requests
+     * sidestep YouTube's "confirm you're not a bot" rate-limit that public
+     * fetches hit after a burst of downloads.
+     */
+    readonly cookiesFromBrowser?: string;
+    /** Path to a Netscape cookies.txt — passed to yt-dlp as `--cookies`. */
+    readonly cookiesFile?: string;
+}
+declare class YtDlpWhisperFetcher implements FetcherPort {
+    private readonly stt;
+    private readonly download;
+    private readonly extraHosts;
+    constructor(opts: YtDlpWhisperFetcherOptions);
+    fetch(url: string): Promise<FetchedSource | null>;
+}
+
+/**
+ * AssemblyAiStt — a diarizing SttPort. Where OpenAiWhisperStt returns a
+ * flat transcript, this returns SPEAKER-LABELLED text (`Speaker A: … /
+ * Speaker B: …`) via AssemblyAI's `speaker_labels`. Use it ad-hoc for
+ * multi-speaker videos (interviews, mock interviews, panels, "day in the
+ * life") where the content only makes sense if you know who said what.
+ *
+ * Same `SttPort` contract — the diarized layout lives in `text`, so it
+ * drops straight into YtDlpWhisperFetcher without any other change.
+ *
+ * Flow: upload audio → create transcript(speaker_labels) → poll → format
+ * utterances. No 25 MB cap (unlike Whisper), so long videos are fine; the
+ * trade-off is latency (~a third of audio duration) — slower than Whisper.
+ */
+
+interface AssemblyAiSttOptions {
+    readonly apiKey: string;
+    readonly baseUrl?: string;
+    readonly pollIntervalMs?: number;
+    readonly maxWaitMs?: number;
+    readonly sleep?: (ms: number) => Promise<void>;
+}
+declare class AssemblyAiStt implements SttPort {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly pollIntervalMs;
+    private readonly maxWaitMs;
+    private readonly sleep;
+    constructor(opts: AssemblyAiSttOptions);
+    transcribe(audioPath: string): Promise<Transcript>;
+    private post;
+    private get;
+}
+
+/**
+ * ChunkedStt — a SttPort decorator that makes a capped engine handle
+ * arbitrarily long audio. Whisper rejects files over 25 MB, so a
+ * multi-hour talk (full course, masterclass, panel) can't be sent in one
+ * request. This wrapper splits oversized audio into time segments with
+ * ffmpeg, transcribes each through the wrapped engine, and concatenates
+ * the text back into a single transcript.
+ *
+ *   transcribe(path) →  ≤cap ? base.transcribe(path)
+ *                       : ffmpeg segment → base.transcribe(eachPart) → join
+ *
+ * The cap is a vendor concern (Whisper's limit), so handling it belongs in
+ * the STT layer rather than the fetcher — the fetcher stays pure and the
+ * concrete `OpenAiWhisperStt` stays a single-request transcriber. Splitting
+ * is injected as `split` so the decorator is unit-testable with a fake
+ * splitter + fake base engine — no ffmpeg, no network.
+ *
+ * Segmenting uses `-c copy` (stream copy, no re-encode): fast, and each
+ * segment is a self-contained valid file. At the fetcher's 64 kbps a 20-min
+ * segment is ~9.6 MB — comfortably under the 25 MB cap with margin for
+ * VBR drift.
+ */
+
+/**
+ * Split a local audio file into ≤`segmentSeconds` parts inside `outDir`,
+ * returning the segment paths in playback order. Injectable for tests.
+ */
+type AudioSplitter = (audioPath: string, segmentSeconds: number, outDir: string) => Promise<string[]>;
+interface ChunkedSttOptions {
+    /** The engine each (sub-cap) part is transcribed through. */
+    readonly base: SttPort;
+    /**
+     * Split anything strictly larger than this. Default 24 MB — just under
+     * Whisper's 25 MB hard cap so VBR drift never pushes a part over.
+     */
+    readonly maxBytes?: number;
+    /** Segment length when splitting. Default 1200 s (20 min). */
+    readonly segmentSeconds?: number;
+    /** Defaults to an ffmpeg segment-muxer splitter. */
+    readonly split?: AudioSplitter;
+    /** Path to the ffmpeg binary (default: "ffmpeg" on PATH). */
+    readonly ffmpegBin?: string;
+}
+declare class ChunkedStt implements SttPort {
+    private readonly base;
+    private readonly maxBytes;
+    private readonly segmentSeconds;
+    private readonly split;
+    constructor(opts: ChunkedSttOptions);
+    transcribe(audioPath: string): Promise<Transcript>;
+}
+
+/**
+ * CompositeFetcher — tries child fetchers in order, first non-null wins.
+ *
+ * Lets the importer route by URL without itself knowing the routing:
+ *   new CompositeFetcher([ ytDlpWhisper, browserReadability ])
+ * sends videos to whisper (the readability one returns null for them is
+ * never reached because whisper handled it) and everything else falls
+ * through to readability. A child that THROWS aborts (hard failure);
+ * a child that returns null means "not mine, try the next".
+ */
+
+declare class CompositeFetcher implements FetcherPort {
+    private readonly children;
+    constructor(children: readonly FetcherPort[]);
+    fetch(url: string): Promise<FetchedSource | null>;
+}
+
+/**
+ * ThrottleFetcher — wraps a FetcherPort to enforce a minimum interval
+ * between fetches (rate limiting). The importer already calls fetch
+ * serially (one URL at a time), so this adds the *pacing* that protects
+ * against YouTube anti-abuse blocks and Whisper RPM limits when running
+ * a large batch.
+ *
+ * `now` + `sleep` are injectable so the throttle is unit-testable without
+ * real timers.
+ */
+
+interface ThrottleFetcherOptions {
+    /** Minimum milliseconds between the START of consecutive fetches. */
+    readonly minIntervalMs: number;
+    readonly now?: () => number;
+    readonly sleep?: (ms: number) => Promise<void>;
+}
+declare class ThrottleFetcher implements FetcherPort {
+    private readonly inner;
+    private readonly minIntervalMs;
+    private readonly now;
+    private readonly sleep;
+    private lastStart;
+    private started;
+    constructor(inner: FetcherPort, opts: ThrottleFetcherOptions);
+    fetch(url: string): Promise<FetchedSource | null>;
+}
+
+/**
+ * HttpReadabilityFetcher — a browser-free FetcherPort for articles:
+ * plain `fetch` + a lightweight readability extraction (prefer
+ * <article>/<main>, strip chrome). Validated to pull ~35k chars from a
+ * real corpus article. Returns `null` for non-HTML or empty bodies so a
+ * video or authed-browser fetcher can take those.
+ *
+ * No JS execution — so it won't get SPA-only content; for login-walled
+ * or JS-rendered pages, compose a BrowserMcpFetcher ahead of/after this.
+ */
+
+interface HttpReadabilityFetcherOptions {
+    readonly userAgent?: string;
+    readonly maxChars?: number;
+}
+declare class HttpReadabilityFetcher implements FetcherPort {
+    private readonly ua;
+    private readonly maxChars;
+    constructor(opts?: HttpReadabilityFetcherOptions);
+    fetch(url: string): Promise<FetchedSource | null>;
+}
+
+/**
+ * Usage telemetry for the metered distill path — cost visibility + optional
+ * Langfuse export. SDK-free (raw fetch to Langfuse's ingestion API), mirroring
+ * the distiller's own no-client-lib ethos and keeping corpus-cli lean.
+ *
+ * Two outputs, both best-effort (telemetry must never break a distill run):
+ *   1. a per-run cost summary printed to stderr (always);
+ *   2. one Langfuse trace with a GENERATION observation per LLM call, when
+ *      LANGFUSE_PUBLIC_KEY / LANGFUSE_SECRET_KEY (+ LANGFUSE_BASE_URL) are set.
+ *
+ * Langfuse runs (test/prod/local) share one project, filtered by the
+ * `environment` tag (LANGFUSE_TRACING_ENVIRONMENT) — same convention as the
+ * Mastra agent tracing in @agstudio/agent-framework.
+ */
+/** One metered LLM call's usage, reported by a distiller. */
+interface DistillUsage {
+    /** Model id as returned by the API (falls back to the requested model). */
+    readonly model: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    /** Human label for the call — the source title. */
+    readonly label: string;
+    readonly startedAt: string;
+    readonly endedAt: string;
+}
+
+/**
+ * AnthropicDistiller — a DistillPort backed by Claude over the Messages API.
+ * Extracts refined AIP-10 items (principle/pattern/critique/summary/example)
+ * from a raw source. Returns self-contained insights, not quote dumps.
+ *
+ * Hand-rolled over the HTTP API (no SDK dep), mirroring the other corpus-cli
+ * port adapters. Prompt + parse are the shared `distill-prompt` core; this
+ * adapter owns only the metered-API transport. For the subscription-billed
+ * alternative see CliAgentDistiller + the `claude-code` engine.
+ */
+
+interface AnthropicDistillerOptions {
+    readonly apiKey: string;
+    /** Default a current Claude model id. */
+    readonly model?: string;
+    readonly baseUrl?: string;
+    /** Max refined items to extract per source. */
+    readonly maxItems?: number;
+    /** Optional sink for per-call token usage (cost + Langfuse export). */
+    readonly onUsage?: (usage: DistillUsage) => void;
+}
+declare class AnthropicDistiller implements DistillPort {
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    private readonly maxItems;
+    private readonly onUsage;
+    constructor(opts: AnthropicDistillerOptions);
+    distill(input: DistillInput): Promise<readonly DistilledItem[]>;
+}
+
+/**
+ * CLI agent engines — descriptors for distilling through a local agent CLI in
+ * headless one-shot mode (prompt on stdin, response on stdout), instead of a
+ * metered API. Each engine declares its `command`, how to `buildArgs` (model
+ * injection, output format, tool/MCP lockdown), and how to `parseOutput` of the
+ * captured stdout into the model's text.
+ *
+ * WHY: distillation is a high-volume batch (hundreds of sources × ~8 items). On
+ * the API that bills per token; routed through an authenticated agent-CLI
+ * subscription (e.g. Claude Max) it draws on a flat monthly plan — ~$0 marginal
+ * cost. Same DistillPort contract + same prompt/parse, swappable transport.
+ *
+ * Engines register full descriptors and are dispatched by id (no `engineId ===`
+ * branching at the call site). Add a CLI by adding a descriptor below; gemini /
+ * goose / codex etc. each become one entry.
+ */
+/** What a CLI engine needs to drive one stdin→stdout completion. */
+interface CliEngine {
+    /** Stable id, used by `corpus distill --engine <id>`. */
+    readonly id: string;
+    /** Whether this engine bills a subscription (no API key needed). Surfaced in help. */
+    readonly subscriptionBilled: boolean;
+    /** Executable to invoke — must be on PATH and logged in. */
+    readonly command: string;
+    /** Build the argv for one completion. The prompt is fed over stdin, not argv. */
+    buildArgs(opts: {
+        readonly model?: string;
+    }): string[];
+    /** Extract the model's text from captured stdout; null → fall back to raw stdout. */
+    parseOutput(stdout: string): string | null;
+}
+/** Registry of CLI engines, keyed by id. */
+declare const CLI_ENGINES: Readonly<Record<string, CliEngine>>;
+
+/**
+ * CliAgentDistiller — a DistillPort backed by any local agent CLI running in
+ * one-shot mode (prompt on stdin, response on stdout). The transport is generic;
+ * the per-CLI specifics (command, argv, output parse) come from a CliEngine
+ * descriptor, so claude / gemini / goose / … are one descriptor each.
+ *
+ * Same DistillPort contract + same prompt/parse as AnthropicDistiller (both use
+ * the shared `distill-prompt` core), so the two are drop-in swappable behind the
+ * `corpus distill --engine` flag.
+ *
+ * TRADE-OFFS vs the metered API:
+ *   - Subscription rate caps — slower for big batches; pace with --throttle and
+ *     let the runner skip+retry on non-zero exits.
+ *   - Output is CLI text, not API structured output — same tolerant parse.
+ *   - One process spawn per source — higher per-call overhead than fetch().
+ */
+
+interface CliAgentDistillerOptions {
+    /** The CLI engine descriptor (command + argv + output parse). */
+    readonly engine: CliEngine;
+    /** Optional model override passed to the engine, e.g. "haiku" to spend less quota. */
+    readonly model?: string;
+    /** Max refined items per source (feeds the shared prompt). */
+    readonly maxItems?: number;
+    /** Hard per-source timeout; kills a wedged CLI call. Default 120s. */
+    readonly timeoutMs?: number;
+    /** Working dir. Default os.tmpdir() — neutral, no project CLAUDE.md / repo. */
+    readonly cwd?: string;
+}
+declare class CliAgentDistiller implements DistillPort {
+    private readonly engine;
+    private readonly model?;
+    private readonly maxItems;
+    private readonly timeoutMs;
+    private readonly cwd;
+    constructor(opts: CliAgentDistillerOptions);
+    distill(input: DistillInput): Promise<readonly DistilledItem[]>;
+}
+
+/**
+ * Minimal streamable-HTTP MCP client (host-agnostic). Used by config-driven
+ * sinks/sources to call ANY MCP server's tools — the corpus never names a
+ * specific host; the endpoint + tool come from a manifest.
+ *
+ * Handles both JSON and SSE (`text/event-stream`) responses, optional
+ * `Mcp-Session-Id`, and the initialize handshake.
+ */
+interface McpClientLike {
+    callTool(name: string, args: Record<string, unknown>): Promise<{
+        content?: unknown;
+        structuredContent?: unknown;
+        isError?: boolean;
+    }>;
+}
+interface ConnectMcpHttpOptions {
+    readonly endpoint: string;
+    readonly headers?: Record<string, string>;
+    readonly protocolVersion?: string;
+    /** "streamable-http" (POST, default) or "sse" (legacy GET stream + POST messages). */
+    readonly transport?: "streamable-http" | "sse";
+}
+declare function connectMcpHttp(opts: ConnectMcpHttpOptions): Promise<McpClientLike>;
+
+/**
+ * McpSink — a config-driven SinkPort that pushes each refined entry by calling
+ * a configured MCP tool. Host-agnostic: the endpoint, tool name, and the
+ * entry→args mapping all come from a sink manifest, so the corpus links to ANY
+ * host (a Guilde guild KB, a Notion db, a vector store) without naming it.
+ *
+ * The manifest's `args` is a template: string values containing `${slug}`,
+ * `${title}`, `${body}`, `${sources}`, `${tags}`, `${access}`, `${uri}`,
+ * `${kind}`, `${confidence}` are substituted per entry. A value that is exactly
+ * one placeholder (e.g. `"${sources}"`) is replaced with the typed value (array
+ * / number), not a string.
+ */
+
+/** Validates a sink manifest (the `--config` JSON) — single source for the type. */
+declare const SINK_CONFIG_SCHEMA: z.ZodObject<{
+    endpoint: z.ZodString;
+    tool: z.ZodString;
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    transport: z.ZodOptional<z.ZodEnum<{
+        "streamable-http": "streamable-http";
+        sse: "sse";
+    }>>;
+    importedAlias: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type McpSinkConfig = z.infer<typeof SINK_CONFIG_SCHEMA>;
+declare class McpSink implements SinkPort {
+    private readonly config;
+    private client;
+    constructor(config: McpSinkConfig, client?: McpClientLike);
+    private ensure;
+    push(item: SinkItem): Promise<SinkPushResult>;
+}
+
+export { AnthropicDistiller, type AnthropicDistillerOptions, AssemblyAiStt, type AssemblyAiSttOptions, type AudioDownload, type AudioDownloader, type AudioSplitter, BrowserMcpFetcher, type BrowserMcpFetcherOptions, type BrowserMcpLike, CLI_ENGINES, ChunkedStt, type ChunkedSttOptions, CliAgentDistiller, type CliAgentDistillerOptions, type CliEngine, CompositeFetcher, type ConnectMcpHttpOptions, HttpReadabilityFetcher, type HttpReadabilityFetcherOptions, type McpClientLike, McpSink, type McpSinkConfig, OpenAiWhisperStt, type OpenAiWhisperSttOptions, ScrapeMcpFetcher, type ScrapeMcpFetcherOptions, type SttPort, ThrottleFetcher, type ThrottleFetcherOptions, type Transcript, YtDlpWhisperFetcher, type YtDlpWhisperFetcherOptions, connectMcpHttp };