The desktop-floating pet never appeared. The log established that
open_pet_window ran, took the rebuild branch, and then produced neither
the success log nor the failure log — so it returned Err somewhere in
the config lookup, from_config, or build(), all three of which used a
bare `?` with no log of their own.
Two changes. close_pet_window now hides the window rather than
destroying it, so every later open takes the branch that demonstrably
works instead of the rebuild branch; hiding also keeps the pet's
listeners and animation state, which the mode switch wants back
immediately anyway. And open_pet_window is wrapped so any failure on
any path is logged with the error, rather than only the reveal step.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Switching to the floating pet produced no log line at all, which was
ambiguous: the command may never have been invoked, or it may have failed
before reaching the only log statement, which sat after placement and
show().
Log both open and close on entry, with whether the window already
existed, and log the error on each failure path. A missing line now means
the command was not invoked, which points at the shell rather than the
window.
The pairing also makes the order readable. The shell closes the pet on
startup whenever it renders inside the UI, and that destroy is what
forces every later open through the rebuild path.
Refs: N-11.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The floating pet still does not appear, and the two explanations offered
so far are not sufficient. The rebuild path genuinely never called
show(), which is fixed and correct on its own reading of the code, but it
did not resolve the symptom. A missing Suspense boundary around the lazy
pet view looked like a second cause and is not one: removing the wrapper
still renders the pet, so React 19 tolerates it. That claim is retracted
in the comment rather than left standing.
The window is transparent and undecorated, so "did not appear" covers a
window placed off-screen, a window that reports hidden, and a window
present with nothing painted in it. Log the monitor work area, the
position and size after placement, and the visibility the window
reports, at default level so no filter is needed to read it.
The Suspense wrapper stays. Relying on React tolerating a lazy component
with no boundary is not a contract, and the bubble and quick views
already have their own.
Refs: N-11, F-61.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Switching the pet to the floating desktop mode made it vanish.
close_pet_window destroys the window rather than hiding it, and the app
closes it on startup whenever the pet renders inside the UI, so opening
the floating pet always went through the rebuild path — which honours
the config's `visible: false` and never showed what it had just built.
Only the already-exists path called show() and placed the window. Both
paths now share one helper.
The in-app pet also sat on an opaque card: .app-pet-overlay
.pet-window-embedded painted a 92% gradient with a border and a drop
shadow over a base class that is transparent. Verified against the real
stylesheet — the backdrop now computes to no image, no colour, no
border and no shadow, with the drag box unchanged at 188x226.
Also record the state of voice chat, window awareness and game
companionship, all three of which are in the declared product scope but
largely unwired: the voice path uses a Web Speech API that WebView2 does
not provide and points away from the architecture's server-side STT
design, the window capture and UI automation modules exist in Rust with
no command registered and no route to the companion, and game mode
toggles a window preference and produces no data at all.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The server was upgraded and now routes /api/v1/files: an unknown
/api/v1 path answers 404 "Not Found" where it previously answered 401,
and both /api/v1/files/content and /api/v1/files/{id}/content answer 401
"Missing API key", which is a route that exists rather than a catch-all.
Order the candidates accordingly. By name first, since that is what a
media frame carries; by id second, because markers already written to
local history hold the id from attachment_saved and can now resolve. The
/api/chat pair moves last, where it still serves a server that has not
been upgraded.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The candidate search returned on the first 401, so only the first of the
three addresses was ever tried — the log shows ten requests to
/api/chat/get_file and not a single download record.
A rejection is per-endpoint here rather than per-connection.
/api/chat/* is the dashboard's own API and wants a dashboard JWT, while
/api/v1/* accepts the API key the connection already holds, so a 401
from one says nothing about the others.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The request trace showed the app talks to 192.168.31.210:26185, not the
host I had been probing, so the endpoint list I read from a dashboard
bundle belonged to a different AstrBot build. This server's own bundle
resolves a chat attachment as:
/api/chat/get_attachment?attachment_id=... when an id is known
/api/chat/get_file?filename=... otherwise
There is no /api/v1/files at all here. Asking for it returned AstrBot's
"404 Not found" page under HTTP 200, which is why the status check
passed it through as a successful download of an undecodable file.
Try each address in turn — the stream supplies a file name in the media
frame and an id in the frame after, and different builds expose
different paths. Because an unknown path answers 200 with that text
page, a candidate counts as found only when the bytes are recognisably
an image; the status alone proves nothing here. Trying all three also
recovers attachments in existing history, whose markers hold the id
rather than the name.
Refs: N-6.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Probing the server settled that the endpoints exist: unauthenticated,
/api/v1/files/content?filename= and /api/v1/files/{id}/content both
answer 401 JSON, while an unknown /api/v1 path answers 404 JSON. AstrBot
does not serve an HTML shell for API paths at all.
Our authenticated request nevertheless logs 200 with text/html and 201
bytes, and 201 bytes is exactly the length of AstrBot's plain-text 404
body. That combination cannot be explained from the code: the base URL
has its trailing slashes stripped and is written back, redirects are not
followed, and a non-2xx status returns before the log line.
So record the URL actually requested, the status before the status
checks, and — when the body is not an image — the first 160 bytes of it,
which is the server explaining itself rather than anything the user
wrote.
Refs: N-6.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Exact containment cannot separate "the same text formatted differently"
from "content the stream never carried". A capture had a 278-character
block against 286 streamed characters and reported no containment either
way, which is the reading the segmentation fix depends on.
Report containment with whitespace removed alongside the exact result.
Both are logged: a block that matches only once whitespace is dropped is
the same content, while a block that matches under neither is genuinely
separate.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Reading the dashboard's own bundle settled where the file endpoints
are. It exposes upload as POST /api/v1/files, fetch-by-name as
GET /api/v1/files/content?filename=, and fetch-by-id as
GET /api/v1/files/{id}/content, and it fetches a chat image by name.
Both of our endpoints were wrong in different ways. Upload posted to
/api/v1/file, singular. Download used the by-id form with the id from
the attachment_saved frame, which does not address the file — asking for
it returned the dashboard's HTML shell with HTTP 200, which is what
surfaced as a broken image.
The name was there all along: the media frame carries [IMAGE]{uuid}.jpg
and the mapper discarded it, waiting for the id in the frame after.
Emit the marker from the media frame instead, naming the file, and keep
the saved id as a fallback for a media frame that names nothing usable.
A reference carrying a path or a scheme is refused rather than guessed
at, since the by-name fetch cannot express either.
Refs: N-6.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The trace lived in a thread_local, but the SSE read loop is a tokio task
that moves between worker threads across await points, so the
accumulated text was split across several copies. It reported 139 and 57
streamed characters for replies that the raw frames show as 417 and 266,
which made every containment result from it unusable — including the
ones the segmentation question depends on.
Own it in the stream instead. The raw frame lines were unaffected, so
the frame-shape findings still hold; only the per-stream summary was
wrong.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The capture settled why an attachment rendered as a broken image:
HTTP 200, Content-Type text/html, 201 bytes. AstrBot answers an unknown
/api/v1 path with its dashboard shell rather than a 404, so a wrong
download endpoint arrives looking like a successful download of an
undecodable file. The status check passed it and the type sniffer
correctly refused to call it an image, which left the user reading
"not a decodable image format" for what is really a wrong URL.
Reject an HTML body outright and say so. GET /api/v1/files/{id}/content
is a guess — upload posts to /api/v1/file, singular — and the protocol
review records the file endpoints as never tested.
Also trace the shape of the reference the media frame carries, which
the client currently discards in favour of the id from
attachment_saved. Scheme, whether it looks like a path, and the file
extension are recorded; the reference itself is not.
Refs: N-6.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
An attachment downloaded and then rendered as a broken image. A blob URL
is decoded according to the blob's type, so handing the webview
application/octet-stream makes img refuse bytes that are a perfectly
good PNG — and octet-stream is exactly what the client substitutes when
the server names no type.
Prefer a concrete image type from the server, otherwise identify the
format from its leading bytes. Every signature checked is a fixed marker
at a fixed offset, so this reads no user content, and a JSON error body
served with HTTP 200 is deliberately not mistaken for an image.
Whether that was the cause is not yet established, so the alternative is
made self-diagnosing rather than guessed at. The download outcome —
status, the type the server gave, the type the bytes indicate, and the
length — is now traced, and the frontend reports why an attachment did
not render instead of leaving a bare broken-image icon: a failed
download shows its error, and a payload the browser cannot decode says
so. Both paths were previously swallowed.
Refs: N-6.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The first capture identified the real cause of a reply appearing twice,
and it was neither candidate. All 524 frames carried a message_id and
each reply used exactly one, so the event_id fallback is not involved
and neither is the history session fallback.
AstrBot interleaves two kinds of plain frame in one reply. Frames with
streaming true are incremental deltas whose total matches the complete
frame exactly. Frames with streaming false carry whole finished blocks —
one reply had five of them totalling 915 characters against 173
streamed. map_plain appends both, so the blocks show up inline during
generation, and map_complete then replaces the accumulation with the
streamed text alone, discarding them. That is the reply appearing twice
and then collapsing, and the collapse loses content.
One thing lengths cannot settle: whether a block repeats streamed text
or carries its own. One reply had 133 block characters against 142
streamed, which looks like a repeat; another had 915 against 173, which
cannot be. The two need opposite fixes, so this adds a per-stream
summary reporting how many blocks appear in the final text and in the
streamed text, as counts and lengths only.
Also records that plugin images were never sent: no media or attachment
frame appeared in any capture, and no plain frame carried a message
chain array. The attachment path has still never received data.
Refs: N-9 (new), N-4 (root cause found), N-6 (not a client defect).
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
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 minimize, maximize and close buttons did nothing. They were wired
correctly; the ACL rejected them. core:default resolves to
core🪟default, which grants only read-only queries — is-maximized
is in it, which is why the maximize icon tracked state correctly, but
minimize, toggle-maximize, close and start-dragging are not. Both
windows are decorations: false, so with close denied the main window
could not be closed at all except through the tray.
Add two capabilities rather than widening the shared one: the main
window gets the four controls it draws, and the pet window gets dragging
alone, since it is moved by dragging its body and must not be able to
close or resize itself.
Every one of these calls was a bare void expression, so the rejection
was swallowed and looked identical to an unwired button. Route them
through a helper that reports the failure in the shell error banner.
This is the second time a missing capability has surfaced as a silent
no-op — the pet window previously had no entry at all. Add tests that
read the shipped capability files and assert each permission the UI
calls is granted to the window that calls it.
Also translate the TypeError the Tauri shim throws outside the
application into a sentence a user can act on. The dev server is
reachable at 127.0.0.1:1420, so opening it in a browser and hitting save
produced "Cannot read properties of undefined (reading 'invoke')".
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>
send_connection_slot_message wrote the optimistic user row from the
runtime snapshot alone, then called send_slot_message, which can still
refuse the send for an empty message, a busy slot or a disconnected
slot. The rejected question stayed in history with no failure marker,
and because each attempt minted a fresh local- id, retrying appended a
second copy rather than replacing the first.
Add a read-only pre-flight, ensure_slot_can_send, and run it before any
database write. The conditions it checks are extracted into
slot_send_precondition, which send_slot_message now uses inside its own
critical section, so the two cannot drift. Mint the message id once so
the failure path can address the row it wrote.
A send that fails after AstrBot accepted it must keep its question:
cancelled and streamInterrupted both mean the message is already in the
remote conversation and a partial reply may already be stored. Those
two keep the row; every other code marks it failed. server_received
encodes that rule and is covered by a test that walks every
AstrBotClientError variant through astrbot_send_error, so a future
rename of an R2 error code cannot silently change the classification.
Marking rather than deleting keeps chat_sessions.last_message_id valid,
re-uses the idempotent upsert, and leaves unread counts alone since they
already ignore user rows. The queue sanctions either choice.
The R2 retry loop and its error mapping are untouched; all five R2
transport sentinels still pass.
Refs: F-18 (audit P2-3).
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
probe_connection_slot never consulted the slot assignment table, so the
same profile could be activated into both runtime slots at once. That
bypasses the ProfileAlreadyAssigned policy the database enforces, and
both slots then race to overwrite the same sticky_session_id.
Enforce it in three places. The runtime invariant lives inside
activate_slot's claim phase, so it also covers startup auto-connect,
which calls activate_slot directly and would bypass a command-layer
check. The command adds a cross-check against connection_slots. And the
operations switch guard now covers probe and disconnect, not just slot
assignment.
Both rules are deliberately negative — they ask whether the profile is
bound to the *other* slot, never whether it is bound to this one.
auto_connect_configured_slots activates from profile.auto_connect_slot
and never writes connection_slots, so a positive rule would break
reconnect for every auto-connected profile. For the same reason the
probe guard only refuses a change of profile, so reconnecting the
profile the operations slot already holds still works during a task.
The operations guard has no production writer yet (F-74, audit P3-7),
so it is inert at runtime. It ships with a test that flips the guard
directly rather than as an unexercised branch.
Refs: F-19 (audit P2-4).
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
switch_slot_session released the slot lock while set_session_id ran and
then re-acquired it to write active_session_id, with no check that the
slot still belonged to the same activation. A deactivation or
re-activation in that window put the old session id onto the new
occupant's snapshot, and persist_session_identity then copied it into
that profile's sticky session.
Capture the generation alongside the client in the first critical
section and compare before writing. The write-back is extracted into
commit_session_id so the invariant can be tested directly rather than
raced.
Refs: F-17 (audit P2-1).
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
activate_slot held the single mutex that covers both slots across
health() and probe(). Those go through the REST client, whose total
timeout is 120s, so one unreachable address froze every runtime command
on both slots for that long: status polling, sending, cancelling and
disconnecting all blocked on the same lock. The cancellation token was
also only created after a successful probe, so the activation itself
could not be interrupted.
Split the function into three phases. Validation and client
construction happen first with no lock held; a short critical section
then bumps the generation, installs the cancellation token up front and
publishes the Connecting snapshot; the probe runs outside the lock
inside a biased select against that token; and a final critical section
writes the result back only if the slot still belongs to this
activation.
The listener receives the same token that phase one installed. Creating
a second one there would leave deactivate_slot cancelling a token no
listener observes, so the desktop-v1 reconnect loop would outlive the
disconnect.
This also fixes a stuck-slot bug the queue did not name. Validation used
to run after the Connecting snapshot had been written, so a rejected
request tore down a working connection and left the slot in Connecting
forever, with no client and no last_error to explain it.
The three new tests were checked against a mutation that re-acquires
the lock across the probe; the two concurrency tests fail under it.
Refs: F-14 (audit P1-4).
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
`should_retry_astrbot` treated every `reqwest::Error` as retryable, but that
class covers both "the POST never left" and "the response body broke". `POST
/api/v1/chat` carries no idempotency key, so retrying the second case appended
the user's message to the remote conversation a second time, produced a second
answer, and interleaved the two attempts' deltas into one garbled bubble.
Retries are now limited to connect-phase failures, the one case where the
request provably never reached the server. Anything after that surfaces a
`streamInterrupted` code so the UI can offer a manual retry instead.
Also stops a send from checking the client out of its slot. The other five slot
commands read the client and report "not connected" when it is absent, so a
send disabled sessions, capabilities, upload, download, and session switching
for its whole duration. That window used to be bounded by the client's 120s
total timeout; now that streaming has no total deadline it would last as long
as the reply, so an ordinary long answer would disable the rest of the slot.
The client is cloned instead and concurrent sends are rejected with `slotBusy`.
(P2-13 / F-49, pulled forward from batch R7 because this batch is what made it
user-visible.)
Refs P1-2 / F-12.
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>
Attachment images are rendered from `URL.createObjectURL`, but the production
CSP `img-src` list had no `blob:` entry. Development does not inject a CSP, so
this only broke release builds.
Refs P1-14 / F-04.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The `desktop-pet` window is created at startup but was absent from the
capability window list, so every IPC call and event listener it made was
rejected by the Tauri ACL. Because those calls are issued as `void invoke(...)`
the rejections were swallowed, and the pet silently lost its runtime status
link, dragging, context menu, and preference handling.
Refs P1-13 / F-03.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Add configuration-only auto-connect rules, runtime operations slot lock
while tasks are active, and duplicate server-instance warnings without
silent Profile merge. Surface policy status to the settings UI and cover
the new boundaries with Rust and Vitest checks.