import { type TreeIndex } from "./forest.js";
import type { HostedCall } from "./hostedCalls.js";
import { type Round } from "./timeline/rounds.js";
import type { EventEnvelope, TreeNode } from "./types.js";
export type Interrupt = {
    effect: string;
    message: string;
    outcome: string;
    resolvedBy?: string;
};
export type ToolStatus = "completed" | "failed" | "rejected" | "awaitingApproval" | "unfinished";
export type ToolWork = "started" | "notStarted" | "unknown";
export type ToolOutcome = {
    status: ToolStatus;
    work: ToolWork;
};
export type ToolFailure = {
    neverStarted: boolean;
    destructiveRan: boolean;
};
export type ToolEvidence = {
    completed: boolean;
    errors: ToolFailure[];
    interrupts: ("approved" | "rejected" | "pending")[];
};
type RowBase = {
    id: string;
    depth: number;
    node: TreeNode;
    /** The row's span (or its event's span) names a parent this log never
     *  recorded, so it sits at the top level. */
    orphan: boolean;
};
export type RoundStoryRow = RowBase & {
    kind: "round";
    round: Round;
    gist: string;
};
export type UserStoryRow = RowBase & {
    kind: "user";
    text: string;
};
export type ToolStoryRow = RowBase & {
    kind: "tool";
    name: string;
    argSummary: string;
    durationMs: number | undefined;
    status: ToolStatus;
    work: ToolWork;
    /** Arguments the model sent as null that the runtime dropped before the
     *  call, so the parameter's default applied. */
    droppedNulls: string[];
};
/** A tool the provider ran inside the call above it, such as its built-in
 *  web search. It has no events of its own; its node is the call's. */
export type HostedStoryRow = RowBase & {
    kind: "hosted";
    call: HostedCall;
    round: Round;
};
export type InterruptStoryRow = RowBase & {
    kind: "interrupt";
    interrupt: Interrupt;
    toolName: string | undefined;
};
export type ErrorStoryRow = RowBase & {
    kind: "error";
    message: string;
};
/** The run stopped under this interrupt and waited; `pausedMs` is undefined
 *  while it still waits. */
export type PauseStoryRow = RowBase & {
    kind: "pause";
    pausedMs: number | undefined;
    resumed: boolean;
};
export type SubagentStoryRow = RowBase & {
    kind: "subagent";
    label: string;
};
/** `title` is the row's name on every screen: `Thread · <label> · N LLM calls`. */
export type LlmGroupStoryRow = RowBase & {
    title: string;
    kind: "llmGroup";
    label: string;
    /** The tool whose call started this thread; undefined for a top-level thread. */
    toolName: string | undefined;
    rounds: Round[];
};
export type MachineryStoryRow = RowBase & {
    kind: "machinery";
    text: string;
};
export type StoryRow = RoundStoryRow | UserStoryRow | ToolStoryRow | HostedStoryRow | InterruptStoryRow | ErrorStoryRow | PauseStoryRow | SubagentStoryRow | LlmGroupStoryRow | MachineryStoryRow;
export type OutlineOptions = {
    machinery: boolean;
    admin: boolean;
};
type AdminOptions = {
    admin: boolean;
};
export declare function classifyTool(evidence: ToolEvidence): ToolOutcome;
/** The rows laid out directly under `id` in an outline. */
export declare function storyChildren(rows: StoryRow[], id: string): StoryRow[];
/** What a completed tool returned, as text; undefined when it never completed. */
export declare function toolResultText(row: ToolStoryRow): string | undefined;
/** The messages of the errors logged inside this tool and not inside a nested one. */
export declare function toolErrorMessages(row: ToolStoryRow): string[];
/** The one glyph per status every screen uses: ✖ for a tool that failed
 *  or was rejected, ⏸ for one waiting on a person, → for a result. */
export declare const TOOL_STATUS_MARK: Record<ToolStatus, string>;
export declare function toolStatusText(outcome: ToolOutcome): string;
/** Excludes events belonging to nested tool invocations. */
export declare function ownedToolNodes(node: TreeNode, index: TreeIndex): TreeNode[];
export declare function stableLeafId(parent: TreeNode, leafNode: TreeNode): string;
/** The name every screen gives an `llmCall` span: `Thread · main · 13 LLM
 *  calls`. A sub-agent that runs on its caller's thread is named by that
 *  thread too; naming it by its tool instead was tried and read as a
 *  different kind of row. */
export declare function llmGroupTitle(node: TreeNode, allRounds: Round[]): string;
/** The thread name a group of rounds shares, `main`, or the names joined
 *  when they differ. */
export declare function threadLabelOf(rounds: Round[]): string;
/** Whether an `llmCall` span's thread is done: nothing under it still
 *  runs, and its last call was cancelled or answered without asking for a
 *  tool. A span whose last call requested tools is still in its tool loop,
 *  even between the tools' end and the next call. The trace and the
 *  timeline fold a completed sub-agent on first sight by this rule. */
export declare function threadComplete(node: TreeNode): boolean;
export declare function forestOutline(trace: TreeNode, options: AdminOptions): StoryRow[];
/** The log events a row stands for: its own event, or its span's direct
 *  children. A hosted call has none; its LLM call's event is the round's. */
export declare function rowEvents(row: StoryRow): EventEnvelope[];
/** The trace screen's default: an approved interrupt is hidden until the
 *  person asks for approvals (`p`). Rejected and pending ones always show.
 *  The screen and `agency logs outline` both apply this. */
export declare function hiddenByDefault(row: StoryRow): boolean;
export declare function outlineRows(trace: TreeNode, options: OutlineOptions): StoryRow[];
/** Story nesting is computed from flat forest records, then laid out as rows. */
export declare function storyOutline(trace: TreeNode, options: AdminOptions): StoryRow[];
export {};