opencode run --format json never emits the user prompt message

[Kurry]

Description

opencode run --format json doesn't include the user's prompt anywhere in the event stream. The stream starts at step_start, goes straight to the assistant's text / tool_use / step_finish events, and never emits anything carrying the message I sent. Anything that rebuilds a transcript from the JSON stream (logging, eval harnesses, ATIF exporters) loses the user turn entirely.

opencode export <sessionID> does contain the user message, so it's recorded internally — it just never reaches the run stream.

Looking at packages/opencode/src/cli/cmd/run.ts, the text handler in the event loop only emits parts gated on part.time?.end, and a user text part has no time field, so it's skipped. There's also no dedicated user/prompt event type in JSON mode, so even the assistant text events carry no role to distinguish them.

Plugins

No response

OpenCode version

1.15.10

Steps to reproduce

1. opencode --model=openai/gpt-4o-mini run --format json -- "say hello"
2. Read stdout — the first line is step_start; no event contains say hello.
3. opencode export <sessionID> — the user message is present there, confirming it's stored but not streamed.

Screenshot and/or share link

No response

Operating System

macOS (Darwin 25.5.0)

Terminal

No response

[Kurry]

@kitlangton PR

[Kurry]

The step-finish tokens/cost already include the user message — so the user event is metrics-neutral

A concern came up: does surfacing the prompt as its own user event risk double-counting tokens/cost, or are the streamed metrics somehow off? Short answer: no. The user turn has no token/cost record of its own — it's already embedded in the assistant step's input/cost. The user event is a pure transcript/stream addition and changes no metric. Here's the proof, using one real gpt-4o-mini session (ses_1861c075…) captured both ways.

Stream (run --format json) — step_finish:

{"type":"step-finish","tokens":{"total":13185,"input":13174,"output":11,"reasoning":0,"cache":{"write":0,"read":0}},"cost":0.0019827}

export of the same session agrees exactly: assistant message tokens.input 13174, cost 0.0019827; session-level info.cost 0.0019827, info.tokens.input 13174.

1. There is exactly one input-token figure in the whole transcript, and it's on the assistant step

In export, the user message (msg_e79e3f8ca…) is just {"role":"user","parts":[{"type":"text","text":"\"say hello\""}]} — no tokens, no cost. The assistant message (msg_e79e3f904…) has parentID: "msg_e79e3f8ca…", i.e. its parent is that user message — one request→response turn. The only input count anywhere is the 13174 on that assistant step, so the user message's tokens can only be folded into it. If they were excluded they'd be counted nowhere — yet the model clearly read "say hello" to answer.

2. By construction, the user message is inside the request the provider counts

run.ts            session.prompt({ parts: [...files, { type:"text", text: message }] })   ← the prompt
prompt.ts:1121    persists those parts as the user message
prompt.ts:1439/51 msgs (incl. that user message as `lastUser`) → toModelMessagesEffect → messages: <model call>
session.ts:383    getUsage: inputTokens = usage.inputTokens   ← provider's count of the WHOLE prompt

usage.inputTokens is the provider's count of everything it received (system + tools + user message); getUsage takes it verbatim (minus cache). There is no code path where the user text reaches the model but escapes usage.inputTokens.

3. cost is a pure, exact function of those tokens

Formula at session.ts:429-439:

cost = input·Cin/1e6 + output·Cout/1e6 + cacheRead·Cr/1e6 + cacheWrite·Cw/1e6 + reasoning·Cout/1e6

gpt-4o-mini = input 0.15 / output 0.60 per 1M (cache = 0, reasoning = 0 here):

13174 · 0.15/1e6 = 0.0019761
   11 · 0.60/1e6 = 0.0000066
                  ───────────
                    0.0019827   ← exactly the reported cost

Reconstructed to the last digit ⇒ no separate "user-message cost" term. cost is inclusive of the user message iff tokens.input is, and §1–2 show it is.

4. Empirical clincher (model-independent)

Enlarge only the user message; system prompt + tools are identical across two fresh runs, so Δinput = the user message's tokens:

opencode --model=openai/gpt-4o-mini run --format json -- "say hello" \
  | grep -o '"input":[0-9]*'          # → ~13174 (baseline)

MSG=$(python3 -c "print('banana '*2000)")
opencode --model=openai/gpt-4o-mini run --format json -- "$MSG" \
  | grep -o '"input":[0-9]*'          # → ~13174 + ~2000

If step-finish didn't count the user message, the second input would stay ≈13174. It rises by ~2000 — that delta is the user message, counted in step-finish. (On a rerun you may see cache.read > 0; then compare input + cache.read + cache.write, since the system-prompt prefix can be cached but the changing user suffix can't.)

Conclusion

The user turn carries no independent token/cost record — it lives inside the assistant step's input (13174) and the cost derived from it (0.0019827); the session totals equal that single step because this is a one-step run. The user event is therefore purely additive to the stream — it surfaces the prompt text and touches no metric. No double-counting, no off-by-one.