Skip to content

Runs and transcripts

One run's details, transcript, workspace, logs and telemetry.

runs

Runs: details, transcripts, workspace files, logs, GPU telemetry, cancel, retry and re-grade.

Transcript

Bases: list[dict[str, Any]]

A run's transcript: every event LLMDyno's proxy recorded between the agent and the model, in order. The list holds the raw events ("request", "block_start", "delta", "response"); the methods give the usual views.

turns

turns() -> list[Any]

One dict per model call: the new messages sent ("messages": tool results, the user prompt), the reply's blocks (thinking, text, tool calls), why it stopped, token usage, time to first token, time and cost.

tool_calls

tool_calls() -> list[Any]

Every tool call the agent made: {"seq", "id", "name", "args" (parsed), "result" (what the tool returned)}.

thinking

thinking() -> list[Any]

The model's reasoning text for each call that had any.

final_text

final_text() -> str

What the agent said last (its closing message).

usage

usage() -> dict[str, Any]

Totals over the run: model calls, input / cached / output / reasoning tokens, cost and model time.

to_pandas

to_pandas()

One row per model call (turns()) as a pandas DataFrame, with usage spread into columns.

to_polars

to_polars()

turns() as a polars DataFrame; needs "llmdyno[data]".

Run

Run(data: dict[str, Any] | str)

Bases: Handle

One benchmark run: a profile × harness × benchmark × iteration, with its scores, transcript and workspace.

status property

status: str

queued, running, grading, done, failed, cancelled or skipped (fetched fresh).

reviews property

reviews: list[Any]

LLM-judge reviews of this run.

transcript

transcript(start: int = 0, limit: int = 20000) -> Transcript

Everything the agent and the model said, as a Transcript (turns(), tool_calls(), thinking(), usage()).

requests

requests() -> list[Any]

Each model request through LLMDyno's proxy: tokens, timings, time to first token, cost, finish reason.

files

files(home: bool = False) -> list[Any]

Files the agent left in its workspace (home=True: the agent's home folder, with its config and sessions): [{"path", "size", "mtime"}].

read_file

read_file(path: str, home: bool = False) -> str

A workspace file's text (or a note when it is binary or larger than 2 MB).

log

log(stage: int = 1, stream: str = 'stdout') -> str

The harness's output for one stage (stream "stdout" or "stderr"); the last 400 kB.

server_log

server_log() -> str

The llama-server log of the plan's local model (empty for cloud runs).

gpu

gpu(max_points: int = 600) -> list[Any]

GPU telemetry samples taken while the run was going (utilisation, VRAM, power, temperature).

download

download(path: Union[str, Path, None] = None) -> Path

Save the run's workspace as a zip (default: -workspace.zip in the current folder).

retry

retry() -> Job | None

Queue the run again (its old results are cleared). Restarts the plan if it had stopped and returns that plan's Job; follow it with watch() or plan().wait().

regrade

regrade(wait: bool = True, quiet: bool = False) -> Union['Run', Job]

Grade the finished workspace again (after fixing a grader, say) without re-running the agent.

run

run(run_id: str) -> Run

A run by id (Results.runs() rows and Plan.runs() carry run ids).