@moda-ai/cli 1.22.1 → 1.22.2

package/dist/analyst-tui.js

@@ -1,314 +0,0 @@
-export class AnalystTui {
-    state;
-    active = false;
-    closed = false;
-    lastRenderAt = 0;
-    spinnerIndex = 0;
-    constructor(options) {
-        const startedAt = options.startedAt ?? Date.now();
-        this.state = {
-            adapterName: options.adapterName,
-            command: options.command,
-            root: options.root,
-            reportPath: options.reportPath,
-            startedAt,
-            phase: 'launching analyst',
-            sawOutput: false,
-            lastOutputAt: startedAt,
-            eventCount: 0,
-            rateLimitCount: 0,
-            validation: 'pending',
-            artifacts: [],
-            summary: {},
-            timeline: [],
-            toolCounts: new Map(),
-            completed: false,
-        };
-    }
-    start() {
-        if (this.active || this.closed)
-            return;
-        this.active = true;
-        process.stderr.write('\u001b[?1049h\u001b[?25l');
-        this.pushTimeline('Moda', 'Launching read-only analyst.');
-        this.render(true);
-    }
-    recordEvent(event) {
-        if (this.closed)
-            return;
-        this.state.sawOutput = true;
-        this.state.lastOutputAt = Date.now();
-        this.state.eventCount += 1;
-        if (event.kind === 'rate_limit') {
-            this.state.rateLimitCount += 1;
-            this.state.phase = 'rate limit wait';
-        }
-        else if (event.kind === 'tool') {
-            this.state.phase = `using ${event.toolName ?? 'tool'}`;
-            if (event.toolName) {
-                this.state.toolCounts.set(event.toolName, (this.state.toolCounts.get(event.toolName) ?? 0) + 1);
-            }
-        }
-        else if (event.kind === 'command') {
-            this.state.phase = 'running command';
-        }
-        else if (event.kind === 'agent_text') {
-            this.state.phase = inferPhase(event.message);
-        }
-        const label = event.kind === 'rate_limit'
-            ? 'Rate limit'
-            : event.kind === 'tool'
-                ? event.toolName ?? 'Tool'
-                : event.kind === 'command'
-                    ? 'Command'
-                    : this.state.adapterName;
-        this.pushTimeline(label, event.message);
-        this.render();
-    }
-    heartbeat(options) {
-        if (this.closed)
-            return;
-        this.state.sawOutput = options.sawOutput;
-        this.render();
-    }
-    setValidation(status) {
-        if (this.closed)
-            return;
-        this.state.validation = status;
-        this.state.phase = status === 'running'
-            ? 'validating cited report'
-            : status === 'pass'
-                ? 'validation passed'
-                : status === 'fail'
-                    ? 'validation failed'
-                    : this.state.phase;
-        this.pushTimeline('Moda', `Validation ${status}.`);
-        this.render(true);
-    }
-    setSummary(summary) {
-        if (this.closed)
-            return;
-        this.state.summary = { ...this.state.summary, ...summary };
-        this.render(true);
-    }
-    setArtifacts(artifacts) {
-        if (this.closed)
-            return;
-        this.state.artifacts = artifacts;
-        if (artifacts.length > 0)
-            this.pushTimeline('Moda', `Wrote ${artifacts.length} local artifact${artifacts.length === 1 ? '' : 's'}.`);
-        this.render(true);
-    }
-    complete(status) {
-        if (this.closed)
-            return;
-        this.state.completed = true;
-        this.setValidation(status);
-    }
-    stop() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        if (this.active) {
-            this.render(true);
-            process.stderr.write('\u001b[?25h\u001b[?1049l');
-        }
-        this.active = false;
-    }
-    pushTimeline(label, message) {
-        const compact = compactWhitespace(message);
-        if (!compact)
-            return;
-        const last = this.state.timeline.at(-1);
-        if (last?.label === label && last.message === compact)
-            return;
-        this.state.timeline.push({
-            time: timeOfDay(new Date()),
-            label,
-            message: compact,
-        });
-        if (this.state.timeline.length > 80)
-            this.state.timeline.splice(0, this.state.timeline.length - 80);
-    }
-    render(force = false) {
-        if (!this.active)
-            return;
-        const now = Date.now();
-        if (!force && now - this.lastRenderAt < 120)
-            return;
-        this.lastRenderAt = now;
-        const frame = renderAnalystTuiFrame(this.state, {
-            color: process.env.NO_COLOR !== '1',
-            columns: process.stderr.columns,
-            rows: process.stderr.rows,
-            now,
-            spinnerFrame: spinner(this.spinnerIndex++),
-        });
-        process.stderr.write(`\u001b[H\u001b[2J${frame}`);
-    }
-}
-export function renderAnalystTuiFrame(state, options = {}) {
-    const color = options.color ?? false;
-    const width = Math.max(72, Math.min(options.columns ?? 96, 128));
-    const rows = Math.max(22, Math.min(options.rows ?? 32, 48));
-    const now = options.now ?? Date.now();
-    const paint = (code, text) => color ? `\u001b[${code}m${text}\u001b[0m` : text;
-    const dim = (text) => paint(90, text);
-    const cyan = (text) => paint(36, text);
-    const green = (text) => paint(32, text);
-    const yellow = (text) => paint(33, text);
-    const red = (text) => paint(31, text);
-    const bold = (text) => paint(1, text);
-    const elapsedSeconds = Math.max(0, Math.round((now - state.startedAt) / 1000));
-    const quietForSeconds = Math.max(0, Math.round((now - state.lastOutputAt) / 1000));
-    const validation = state.validation === 'pass'
-        ? green('pass')
-        : state.validation === 'fail'
-            ? red('fail')
-            : state.validation === 'running'
-                ? yellow('running')
-                : dim('pending');
-    const spinnerText = state.completed ? (state.validation === 'pass' ? green('ok') : red('fail')) : cyan(options.spinnerFrame ?? '|');
-    const timelineRows = Math.max(6, rows - 22);
-    const tools = [...state.toolCounts.entries()]
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 4)
-        .map(([name, count]) => `${name} ${count}`)
-        .join(', ') || 'none yet';
-    const lines = [];
-    lines.push(`${bold('Moda Analyst')} ${dim('Step 4/5 Set up')}`);
-    lines.push(rule(width));
-    lines.push(`${spinnerText} ${state.adapterName} ${dim('read-only repository access')}  ${dim(`elapsed ${formatDuration(elapsedSeconds)}`)}  ${dim(state.sawOutput ? `last output ${formatDuration(quietForSeconds)} ago` : 'waiting for first output')}`);
-    lines.push('');
-    lines.push(cyan('Session'));
-    lines.push(keyValue('Phase', state.phase, width));
-    lines.push(keyValue('Command', state.command, width));
-    lines.push(keyValue('Root', state.root, width));
-    lines.push(keyValue('Output', state.reportPath, width));
-    lines.push(keyValue('Boundary', 'Agent can inspect files and print a report. Moda validates, then writes artifacts.', width));
-    lines.push('');
-    lines.push(cyan('Status'));
-    lines.push(`  validation       ${validation}`);
-    lines.push(`  stream events    ${state.eventCount}`);
-    lines.push(`  rate limits      ${state.rateLimitCount}`);
-    lines.push(`  tools            ${tools}`);
-    lines.push('');
-    lines.push(cyan('Evidence'));
-    lines.push(`  runtime agents   ${metric(state.summary.runtimeAgentCount)}`);
-    lines.push(`  agent families   ${metric(state.summary.agentFamilyCount)}`);
-    lines.push(`  artifacts        ${metric(state.summary.artifactCount)}`);
-    lines.push(`  providers        ${metric(state.summary.modelProviderCount)}`);
-    lines.push(`  claims/citations ${metricPair(state.summary.claimCount, state.summary.citationCount)}`);
-    lines.push('');
-    lines.push(cyan('Timeline'));
-    const timeline = state.timeline.slice(-timelineRows);
-    if (timeline.length === 0) {
-        lines.push(`  ${dim('Waiting for analyst output...')}`);
-    }
-    else {
-        for (const item of timeline) {
-            const prefix = `  ${dim(item.time)} ${item.label.padEnd(11).slice(0, 11)} `;
-            lines.push(...wrapWithPrefix(prefix, item.message, width));
-        }
-    }
-    if (state.artifacts.length > 0) {
-        lines.push('');
-        lines.push(cyan('Artifacts'));
-        for (const artifact of state.artifacts.slice(0, 5))
-            lines.push(`  ${artifact}`);
-    }
-    lines.push('');
-    lines.push(dim('Ctrl+C aborts  |  --no-tui shows raw stream  |  --agent --stream emits NDJSON for agents'));
-    return fitToScreen(lines, rows, width).join('\n');
-}
-export function shouldUseAnalystTui(flags, outputMode) {
-    if (outputMode !== 'human')
-        return false;
-    if (flags['no-tui'] === 'true' || process.env.MODA_NO_TUI === '1')
-        return false;
-    if (process.env.TERM === 'dumb')
-        return false;
-    if (flags.tui === 'true')
-        return process.stderr.isTTY === true;
-    return process.stderr.isTTY === true && process.env.CI !== 'true';
-}
-function inferPhase(message) {
-    const lower = message.toLowerCase();
-    if (lower.includes('report') && (lower.includes('json') || lower.includes('final')))
-        return 'producing cited report';
-    if (lower.includes('citation') || lower.includes('line number') || lower.includes('evidence'))
-        return 'verifying citations';
-    if (lower.includes('read') || lower.includes('file'))
-        return 'reading source evidence';
-    if (lower.includes('repository') || lower.includes('structure') || lower.includes('map'))
-        return 'mapping repository';
-    if (lower.includes('agent') || lower.includes('harness'))
-        return 'classifying harness';
-    return 'investigating repo';
-}
-function keyValue(label, value, width) {
-    const prefix = `  ${label.padEnd(10)} `;
-    return wrapWithPrefix(prefix, value, width).join('\n');
-}
-function wrapWithPrefix(prefix, text, width) {
-    const available = Math.max(16, width - visibleLength(prefix));
-    const words = compactWhitespace(text).split(' ');
-    const lines = [];
-    let current = '';
-    for (const word of words) {
-        const next = current ? `${current} ${word}` : word;
-        if (visibleLength(next) > available && current) {
-            lines.push(`${prefix}${current}`);
-            current = word;
-        }
-        else {
-            current = next;
-        }
-    }
-    if (current)
-        lines.push(`${prefix}${current}`);
-    return lines.length > 0 ? lines : [prefix.trimEnd()];
-}
-function fitToScreen(lines, rows, width) {
-    return lines
-        .slice(0, rows)
-        .map((line) => trimVisible(line, width));
-}
-function trimVisible(value, width) {
-    if (visibleLength(value) <= width)
-        return value;
-    const stripped = stripAnsi(value);
-    return stripped.length > width ? `${stripped.slice(0, Math.max(0, width - 3))}...` : stripped;
-}
-function rule(width) {
-    return '-'.repeat(width);
-}
-function metric(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? String(value) : 'pending';
-}
-function metricPair(left, right) {
-    return `${metric(left)} / ${metric(right)}`;
-}
-function formatDuration(seconds) {
-    if (seconds < 60)
-        return `${seconds}s`;
-    const minutes = Math.floor(seconds / 60);
-    const remaining = seconds % 60;
-    return `${minutes}m ${remaining}s`;
-}
-function timeOfDay(date) {
-    return date.toTimeString().slice(0, 8);
-}
-function spinner(index) {
-    return ['|', '/', '-', '\\'][index % 4] ?? '|';
-}
-function compactWhitespace(value) {
-    return value.replace(/\s+/g, ' ').trim();
-}
-function visibleLength(value) {
-    return stripAnsi(value).length;
-}
-function stripAnsi(value) {
-    return value.replace(/\u001b\[[0-9;?]*[A-Za-z]/g, '');
-}
-//# sourceMappingURL=analyst-tui.js.map

package/dist/api-client.d.ts

@@ -1,46 +0,0 @@
-import type { ProfileIOOptions } from './profiles.js';
-export declare class ApiError extends Error {
-    readonly statusCode: number;
-    readonly responseBody: string;
-    constructor(message: string, statusCode: number, responseBody: string);
-}
-/**
- * Transport-level failure: the socket died before any HTTP response existed
- * (`fetch failed`, ECONNRESET, …). Distinct from `ApiError` (an HTTP status)
- * and from the per-attempt timeout so callers can retry ONLY genuine network
- * faults — e.g. undici handing out a pooled connection poisoned by a
- * just-dropped SSE stream on the same origin.
- */
-export declare class NetworkError extends Error {
-    constructor(message: string);
-}
-export declare function callDataAPI(endpoint: string, init?: RequestInit, requestOptions?: ModaRequestOptions): Promise<unknown>;
-/**
- * Per-call transport overrides. Used by expensive, long-running, non-idempotent
- * endpoints (e.g. the agent `ask` POST) that need a longer timeout than the
- * default and must NOT be retried on timeout.
- */
-export interface ModaRequestOptions {
-    /** Abort timeout in ms for each attempt (default REQUEST_TIMEOUT_MS). */
-    timeoutMs?: number;
-    /** Max retries (default MAX_RETRIES). Set 0 to disable retries entirely. */
-    retries?: number;
-    /**
-     * Retry exactly once more on a NETWORK-level failure, even with `retries: 0`.
-     * After a streamed SSE connection dies, undici's per-origin pool can hand
-     * the very next fetch the same dead socket — the buffered fallback then
-     * fails instantly ("fetch failed") against a healthy backend. The retry
-     * waits ~1s and sends `Connection: close` so it cannot reuse a pooled
-     * connection. HTTP errors (`ApiError`) and the per-attempt timeout NEVER
-     * consume this retry.
-     */
-    retryOnceOnNetworkError?: boolean;
-    /** Delay before the network retry (default 1s; test seam). */
-    networkRetryDelayMs?: number;
-    /** Invoked when the network retry is consumed (callers may log a note). */
-    onNetworkRetry?: () => void;
-}
-export declare function callControlAPI(endpoint: string, options?: RequestInit, profileOptions?: ProfileIOOptions, requestOptions?: ModaRequestOptions): Promise<unknown>;
-export declare function getApiRequestCount(): number;
-export declare function resetApiRequestCount(): void;
-//# sourceMappingURL=api-client.d.ts.map

package/dist/api-client.js

@@ -1,120 +0,0 @@
-// src/api-client.ts
-import { resolveApiKey, resolveModaBaseUrl } from './config.js';
-const REQUEST_TIMEOUT_MS = 30_000;
-const MAX_RETRIES = 3;
-const INITIAL_BACKOFF_MS = 500;
-const NETWORK_RETRY_DELAY_MS = 1_000;
-let apiRequestCount = 0;
-export class ApiError extends Error {
-    statusCode;
-    responseBody;
-    constructor(message, statusCode, responseBody) {
-        super(message);
-        this.statusCode = statusCode;
-        this.responseBody = responseBody;
-        this.name = 'ApiError';
-    }
-}
-/**
- * Transport-level failure: the socket died before any HTTP response existed
- * (`fetch failed`, ECONNRESET, …). Distinct from `ApiError` (an HTTP status)
- * and from the per-attempt timeout so callers can retry ONLY genuine network
- * faults — e.g. undici handing out a pooled connection poisoned by a
- * just-dropped SSE stream on the same origin.
- */
-export class NetworkError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'NetworkError';
-    }
-}
-function isRetryable(status) {
-    return status === 429 || status >= 500;
-}
-export async function callDataAPI(endpoint, init = { method: 'GET' }, requestOptions = {}) {
-    apiRequestCount++;
-    const url = `${resolveModaBaseUrl()}/api/v1/data${endpoint}`;
-    return callModaAPI(url, init, {}, requestOptions);
-}
-export async function callControlAPI(endpoint, options = {}, profileOptions = {}, requestOptions = {}) {
-    const url = `${resolveModaBaseUrl(profileOptions)}/api${endpoint}`;
-    return callModaAPI(url, options, profileOptions, requestOptions);
-}
-async function callModaAPI(url, options, profileOptions = {}, requestOptions = {}) {
-    const timeoutMs = requestOptions.timeoutMs ?? REQUEST_TIMEOUT_MS;
-    const maxRetries = requestOptions.retries ?? MAX_RETRIES;
-    const initialNetworkRetryBudget = requestOptions.retryOnceOnNetworkError
-        ? 1
-        : 0;
-    let networkRetryBudget = initialNetworkRetryBudget;
-    // Set once the network-retry budget is consumed: the retry attempt (and any
-    // later ones) must not reuse a possibly-poisoned pooled connection.
-    let connectionClose = false;
-    // Structural termination bound: (maxRetries + 1) normal attempts plus at most
-    // one extra network-retry attempt. Every path inside returns, throws, or
-    // `continue`s, so the trailing throw is unreachable — but the bound makes the
-    // contract hold by construction rather than by manual path analysis.
-    const maxAttempts = maxRetries + initialNetworkRetryBudget + 1;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-        if (attempt > 0) {
-            const backoff = connectionClose
-                ? requestOptions.networkRetryDelayMs ?? NETWORK_RETRY_DELAY_MS
-                : INITIAL_BACKOFF_MS * Math.pow(2, attempt - 1);
-            await new Promise((resolve) => setTimeout(resolve, backoff));
-        }
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            const response = await fetch(url, {
-                ...options,
-                headers: {
-                    'x-api-key': resolveApiKey(profileOptions) ?? '',
-                    'Content-Type': 'application/json',
-                    ...(options.headers ?? {}),
-                    ...(connectionClose ? { Connection: 'close' } : {}),
-                },
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                const error = new ApiError(`API error (${response.status}): ${errorText}`, response.status, errorText);
-                if (isRetryable(response.status) && attempt < maxRetries) {
-                    continue;
-                }
-                throw error;
-            }
-            return response.json();
-        }
-        catch (error) {
-            if (error instanceof ApiError)
-                throw error;
-            const isAbort = error instanceof DOMException && error.name === 'AbortError';
-            const wrapped = isAbort
-                ? new Error(`Request timed out after ${timeoutMs}ms: ${url}`)
-                : new NetworkError(`Network error: ${error instanceof Error ? error.message : String(error)}`);
-            if (attempt < maxRetries) {
-                continue;
-            }
-            if (!isAbort && networkRetryBudget > 0) {
-                networkRetryBudget -= 1;
-                connectionClose = true;
-                requestOptions.onNetworkRetry?.();
-                continue;
-            }
-            throw wrapped;
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
-    // Unreachable: the loop above always returns or throws within maxAttempts.
-    // Present so the bound is enforced by construction, not just documented.
-    throw new NetworkError(`Request retries exhausted: ${url}`);
-}
-export function getApiRequestCount() {
-    return apiRequestCount;
-}
-export function resetApiRequestCount() {
-    apiRequestCount = 0;
-}
-//# sourceMappingURL=api-client.js.map

package/dist/ask-stream.d.ts

@@ -1,146 +0,0 @@
-import type { AgentConfidence } from './output.js';
-/** Mirrors backend `AgentPhase`. */
-export type AskStreamPhase = 'idle' | 'planning' | 'searching' | 'analyzing' | 'writing' | 'done' | 'error' | 'stopped';
-/** Mirrors backend `StreamCitation`. */
-export interface AskStreamCitation {
-    id: string;
-    n: number;
-    label: string;
-    source: string;
-    snippet?: string;
-    href?: string;
-}
-/** Everything the CLI needs from a completed stream to render the final answer. */
-export interface AskStreamOutcome {
-    answer: string;
-    confidence: AgentConfidence;
-    citations: AskStreamCitation[];
-    nextCommands: string[];
-    elapsedMs?: number;
-    /**
-     * Set when the stream terminated with a terminal `error` event (the agent
-     * failed server-side). Transport failures throw `AskStreamError` instead.
-     */
-    errorMessage?: string;
-}
-/** Signals "fall back to the buffered ask endpoint" — never surfaced raw. */
-export declare class AskStreamError extends Error {
-    /** Wall-clock ms the stream ran before failing (annotated by `streamAsk`). */
-    elapsedMs?: number;
-    /** tool_start/tool_end events seen before failing (annotated by `streamAsk`). */
-    toolEvents?: number;
-    constructor(message: string);
-}
-/**
- * Thresholds for "substantial progress": a stream that ran at least this long,
- * or produced more tool events than this, did real work before dropping —
- * the buffered fallback then re-runs the WHOLE question, roughly doubling
- * total latency, so the user deserves a notice instead of silence. The elapsed
- * check is inclusive (`>=`) so a drop landing exactly on the boundary — where
- * the doubled wait is felt most acutely — still gets the notice.
- */
-export declare const SUBSTANTIAL_STREAM_PROGRESS_MS = 60000;
-export declare const SUBSTANTIAL_STREAM_TOOL_EVENTS = 5;
-/**
- * One-line stderr notice for a stream that died after substantial progress.
- * Returns null for early failures (they keep today's silent fallback) and for
- * non-stream errors. The caller still falls back either way — the user must
- * still get an answer, just an informed wait instead of an apparent hang.
- */
-export declare function streamFallbackNotice(error: unknown): string | null;
-/**
- * Incremental SSE frame parser. Feed decoded text chunks (arbitrarily split —
- * even mid `data:` line or mid multi-byte frame); complete `data:` payloads
- * are returned in order. Handles LF and CRLF framing, multi-line `data:`
- * fields, and ignores comments (`: ...`) and non-data fields (`event:`, `id:`).
- */
-export declare class SseParser {
-    private buffer;
-    private pendingCr;
-    push(chunk: string): string[];
-    /** Drain a final frame that was not terminated by a blank line. */
-    flush(): string[];
-}
-/** Quiet period before the first liveness line is printed. */
-export declare const IDLE_TICKER_THRESHOLD_MS = 10000;
-/** Minimum spacing between liveness lines. */
-export declare const IDLE_TICKER_MIN_UPDATE_MS = 15000;
-/**
- * Client-side liveness for quiet stream periods: long tool-less LLM turns
- * (coverage gate, synthesis) emit no events for 30–90s, which reads as a
- * hang. Once no event has arrived for IDLE_TICKER_THRESHOLD_MS this prints an
- * unobtrusive "… still working (Ns)" line (at most every
- * IDLE_TICKER_MIN_UPDATE_MS) through the same progress channel as tool cards —
- * stderr only, never interleaved into the final answer.
- */
-export declare class IdleTicker {
-    private readonly write;
-    private readonly now;
-    private startedAt;
-    private lastEventAt;
-    private lastPrintAt;
-    private timer;
-    constructor(write: (line: string) => void, now?: () => number);
-    start(): void;
-    /** Reset the idle clock — call on every real stream event. */
-    touch(): void;
-    stop(): void;
-    /** One liveness check; driven by the interval (public for tests). */
-    poll(): void;
-}
-/**
- * Consumes parsed stream events: renders live progress lines through
- * `onProgress` and accumulates the final outcome. `finish()` throws
- * `AskStreamError` unless a terminal event (`done` or `error`) arrived, so a
- * connection dropped mid-run triggers the buffered fallback instead of
- * rendering a truncated answer.
- */
-export declare class AskStreamCollector {
-    private readonly onProgress;
-    private answer;
-    private confidence;
-    private citations;
-    private nextCommands;
-    private elapsedMs;
-    private errorMessage;
-    private terminal;
-    private lastPhase;
-    private toolNames;
-    private toolEvents;
-    constructor(onProgress?: (line: string) => void);
-    handle(raw: unknown): void;
-    isTerminal(): boolean;
-    /** tool_start/tool_end events seen so far (fallback-heuristic input). */
-    get toolEventCount(): number;
-    finish(): AskStreamOutcome;
-}
-/**
- * Iterate any chunk source (a fetch body, or test fixtures) through the SSE
- * parser into the collector. Exported separately from `streamAsk` so tests can
- * exercise chunk-splitting behavior without a network layer.
- */
-export declare function consumeAskSse(chunks: AsyncIterable<Uint8Array | string>, collector: AskStreamCollector, 
-/**
- * Fires once per parsed `data:` event (keepalive comment frames never reach
- * it). Used to reset the idle liveness ticker on real progress.
- */
-onEvent?: () => void): Promise<AskStreamOutcome>;
-export interface StreamAskOptions {
-    question: string;
-    daysBack: number;
-    profile?: string;
-    harness?: Record<string, unknown> | null;
-    /** Overall wall-clock budget for the run (default 250s, like buffered ask). */
-    timeoutMs?: number;
-    onProgress?: (line: string) => void;
-    /** Test seam. */
-    fetchImpl?: typeof fetch;
-}
-/**
- * POST the question to `/api/cli/ask/stream` and consume the SSE response.
- * Throws `AskStreamError` on any transport/framing problem (non-2xx, wrong
- * content type, network drop, truncated stream) so callers can fall back to
- * the buffered endpoint.
- */
-export declare function streamAsk(options: StreamAskOptions): Promise<AskStreamOutcome>;
-//# sourceMappingURL=ask-stream.d.ts.map