import { type LLMAgentRoundSpec, type LLMAgentRoundWriter, type LLMAgentRoundStartedListener } from './agentRounds.typedefs';
/**
 * The per-round generation stream of a single agent run.
 *
 * A tool loop is a sequence of model rounds, and each of them is a generation
 * in its own right: the conversation as it stood when the request went out, and
 * what the model answered with. Providers put every provider call through
 * `run`, which is what guarantees a round that throws is traced exactly like a
 * round that succeeds, and that no round of the loop goes unrecorded.
 *
 * The recorder deliberately knows nothing about messages — the provider hands
 * over its own native array as the round's input.
 */
export declare class LLMAgentRounds {
    private readonly writeRound;
    private readonly onRoundStarted?;
    private didRecordRound;
    constructor(writeRound: LLMAgentRoundWriter, onRoundStarted?: LLMAgentRoundStartedListener | undefined);
    /**
     * Whether any model round reached the tracer. A run that fails while still
     * preparing its first request has no transcript to show, and its caller falls
     * back to tracing the failure on its own.
     */
    get hasRecordedRound(): boolean;
    /**
     * Runs one provider call as a traced round. The provider's response is
     * returned untouched and its failure rethrown unchanged: tracing never alters
     * what the loop, or the caller, sees.
     */
    run<ProviderResponse>(round: LLMAgentRoundSpec<ProviderResponse>): Promise<ProviderResponse>;
    private notifyRoundStarted;
    private callProvider;
    private recordSafely;
}