The first capture answered the question the trace was built for and
eliminated it: all 77 plain frames of one reply carried a message_id, so
a reply splitting into two bubbles is not the event_id fallback in
F-34.
What remains depends on the value rather than its presence. If the id
changes partway through a reply then the client is correctly showing two
messages the server sent; if it stays the same then the split is ours,
in the historySessionId fallback that loads another session's history.
The id is an opaque row identifier, not content.
Also record the length of a string data payload. It separates "the
server streamed many small chunks" from "the server sent the reply in
one piece" without recording any text.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The event set an explicit target of astrbot::frame while the enabled!
guard used the default module-path target. A filter naming either one
therefore failed: naming the crate did not reach the event, and naming
the target left the guard returning false. Either way the trace emitted
nothing, which would have looked like the application producing no logs
at all and wasted a reproduction cycle.
Give the guard the same target, hoist it into a constant, and add a test
that drives the exact RUST_LOG value printed in the acceptance
instructions. The test was checked against the broken guard and fails
with empty output. A second test asserts the trace stays silent at the
default level, and both assert no payload text or attachment URL reaches
the log.
Document the capture procedure in the acceptance checklist.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Two reported defects cannot be diagnosed from the code alone. A reply
sometimes renders as two bubbles during generation, which happens when a
streaming frame carries no message_id — the client then keys it by
event_id, which is unique per event. And images sent by plugins never
appear, which happens when an image frame is not followed by the
attachment_saved frame the mapper waits for. Both depend on what the
server actually sends, and picking the wrong one would produce a fix
that looks right until another conversation path hits the other.
Log the shape of every SSE frame: its type, whether message_id and
session_id are present, the streaming flag, and the key names inside
data. No payload text is recorded, so this is safe to leave enabled in
the field. Off unless RUST_LOG selects debug, and gated on
tracing::enabled! so a disabled level costs one atomic read rather than
a JSON parse.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Combines the P0 event-id fix with the three transport fixes that rewrite the
same stream loop; they are not separable in these two files.
fix(astrbot): scope stream event ids per request (P0-1 / F-01)
`AstrBotStreamMapper` restarts its sequence at zero for every stream, but
`seen_event_ids` lives on the client and outlives a request. Event ids were
built from `server_instance_id + sequence` alone, so the second message on a
connection replayed the first message's ids and every one of its events was
discarded as a duplicate: the assistant's reply never reached the UI or the
database. Ids now carry a per-request `stream_id`.
fix(protocol): serialize model options in camelCase (P1-7b / F-07)
`AstrBotModelOption` had no `rename_all`, so the frontend's `isDefault` was
always undefined and no model was preselected.
fix(net): stop total timeouts from killing streams (P1-1 / F-10)
`Client::timeout` runs from the start of the request until the body is
finished and keeps counting while `bytes_stream()` is consumed. The 30s
desktop-v1 budget therefore tore the long-lived SSE connection down every 30
seconds no matter how healthy it was — heartbeats could not keep it alive —
and the 120s AstrBot budget cut off any generation longer than two minutes.
Streaming now uses a separate client with no total deadline, detecting a
stalled peer with `read_timeout` (which resets on every successful read) plus
a TCP keepalive. REST endpoints keep their total deadline.
fix(astrbot): decode sse bytes on line boundaries (P1-3 / F-11)
Decoding each network chunk with `String::from_utf8_lossy` corrupted any
character straddling a chunk boundary. For CJK text that is one replacement
character per unlucky chunk, persisted into the message. The stream is now
split into lines at the byte level and only complete lines are decoded.
fix(astrbot): finalize streams on cancel and error (P2-2 / F-13)
Cancellation and every error path returned without a `MessageCompleted`
event, leaving the row `streaming = 1` so it rendered as "generating" again
after a restart. All exit paths now finalize with `Cancelled` or `Error` and
keep the text received so far. Cancelling also no longer flips the connection
to Disconnected and back, which was a visible flicker (P3-4 / F-56).
Hardening found while reviewing the above: a 64 MiB per-response ceiling
(removing the total timeout removed the only bound on a response, and
`read_timeout` cannot replace it), and a cursor-based line buffer instead of
draining from the front, which was quadratic in the chunk size.
Tests drive a real `AstrBotClient` against a hand-rolled HTTP/1.1 chunked-SSE
server on a raw `TcpListener`: byte-exact control over chunk boundaries and
dropping a socket mid-body without the terminal chunk are not expressible
through an HTTP framework, and both are needed here.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>