Agent Transcript Viewer
Pretty-print agent session logs: threaded turns, tool calls and diffs, all local.
Drop a session .jsonl / .json file here
UserFix the failing test in pricing.test.mjs — it started breaking after the cache-read change≈23 tok · $0.0001
Fix the failing test in pricing.test.mjs — it started breaking after the cache-read change.
AssistantI'll look at the failing test and the recent change to the cache-read path.≈68 tok · $0.0010
I'll look at the failing test and the recent change to the cache-read path.
Read
{ "file_path": "lib/tools/pricing.test.mjs" }result
test('cache read uses cacheReadPerM', () => { assert.equal(callCost(sonnet, 1000, 0, 1), 0.0000003); }); // FAILS: expected 0.0000003, got 0.000003AssistantThe expectation is off by 10× — cacheReadPerM for Sonnet is 0.3 per million, so 1000 fully≈89 tok · $0.0013
The expectation is off by 10× — cacheReadPerM for Sonnet is 0.3 per million, so 1000 fully-cached tokens cost 0.3 × 1000 / 1e6 = $0.0000003. The implementation is right; the test constant was updated against the old rate.
Edit
{ "file_path": "lib/tools/pricing.test.mjs", "old_string": "0.000003", "new_string": "0.0000003" }result
Edit applied. 1 replacement.Assistant→ Bash≈23 tok · $0.0003
Bash
{ "command": "node --test lib/tools/pricing.test.mjs" }result
✔ pricing (12 tests) — all passingAssistantFixed. The test constant assumed the pre-change cache-read rate; updated it to match cache≈31 tok · $0.0005
Fixed. The test constant assumed the pre-change cache-read rate; updated it to match cacheReadPerM = 0.3. All 12 tests pass.
Token counts use the chars ÷ 4 heuristic (≈); costs priced at Claude Sonnet 4.5 rates from our pricing data (2026-06-11). Assistant turns are billed at the output rate, everything else at the input rate.
How it works
Raw agent session logs are write-only: a wall of single-line JSON where one tool result can be 40,000 characters of escaped file content. This viewer turns a Claude Code or OpenAI session file into something a human can actually read — a threaded conversation with collapsible turns, tool calls rendered as cards showing arguments and results, and a per-turn token and cost badge so the expensive turns jump out.
Format detection is structural. Claude Code lines wrap each message as {type, message} with content-block arrays; OpenAI exports use flat {role, content} messages with optional tool_calls. The parser normalizes both into the same turn model and pairs each tool result with the call that produced it, so a Read-then-result sequence renders as one card instead of two disconnected blobs. Unparseable lines are skipped and counted, never fatal.
The economics annotations use honest approximations, clearly marked: tokens are estimated at four characters each, and costs are priced at Claude Sonnet rates from our pricing data (last verified 2026-06-11), with assistant output billed at the output rate. The total in the header is a floor on what the session really cost — live APIs re-send accumulated context every call, so a 50-turn session bills its early turns dozens of times. Reading a few of your own transcripts here makes that dynamic concrete in a way no pricing page does: you will usually find that tool results, not model prose, dominate the token budget.
Everything runs locally. The file is read in your browser tab via FileReader, parsed with plain JavaScript, and rendered with native details elements — no upload, no server, no telemetry on the content. The last four turns open expanded by default since the end of a session is usually what you came to inspect; earlier turns expand on click. For aggregate analysis of the same files — cumulative cost curves and ranked waste hotspots — pair this viewer with the Chat Log Analyzer, which accepts the same formats.
Frequently asked questions
Which transcript formats does the viewer support?
Two families, auto-detected. Claude Code session files — the JSONL files under ~/.claude/projects/ — where each line wraps a message as {type, message}, with content blocks for text, tool_use and tool_result. And OpenAI-style exports: JSONL or JSON arrays of {role, content} messages, including assistant tool_calls and tool-role result messages. The parser is tolerant by design: unparseable lines are counted and skipped rather than failing the whole file, so partially-corrupted logs still render.
Is it safe to load real session logs here? They contain my code.
Yes — the file is read with the browser's FileReader API and parsed entirely in your tab. There is no upload, no network request and no analytics on the content; you can confirm in devtools' network panel that dropping a file triggers zero traffic. That privacy property is the point: agent transcripts routinely contain proprietary source code, file paths and API responses, which is exactly the material you should never paste into a random web service.
How accurate are the per-turn token and cost estimates?
They are deliberate approximations, labeled with ≈ throughout. Tokens are estimated as characters divided by four — accurate to within roughly 10-20% for English prose and slightly conservative for dense code. Costs price each turn at Claude Sonnet rates, with assistant turns at the output rate and everything else at the input rate. Real billing differs because providers charge the full accumulated context on every API call, not just the new turn — so a real session costs more than the sum of its turns. For measured costs, FORG records actuals per session.
Can I share a rendered transcript with a teammate?
Not directly from this tool — the transcript never leaves your browser, so there is no share link by design. The practical pattern: load the transcript, expand the relevant turns, and screenshot or copy the specific tool call you are discussing. If your team needs durable, queryable session history with cost attribution, that is a live-tracking problem rather than a viewer problem — the FORG dashboard keeps every session searchable without manually shuttling JSONL files around.
Why do tool results dominate the token counts in my sessions?
Because agents are chatty readers. A single file-read or test-run tool result can be tens of kilobytes, and agentic loops issue many of them per task — it is common for tool results to account for 60-80% of a session's tokens while the human-visible text is a sliver. The per-turn ≈token badges make those heavy turns easy to spot. If the same large result appears repeatedly, that is a waste hotspot worth fixing with result truncation or context compaction; our Chat Log Analyzer ranks those hotspots automatically.
FORG tracks this automatically across every agent session — live cost attribution, budgets, and alerts.
Start tracking with FORG