AstrBot-Desktop/src-tauri/src/networking/astrbot_client.rs

1203 行
46 KiB
Rust

use std::{collections::VecDeque, sync::Arc, time::Duration};
use desktop_protocol::{
AstrBotApiEnvelope, AstrBotAttachment, AstrBotCapabilitySnapshot, AstrBotChatRequest,
AstrBotConfigListData, AstrBotModelOption, AstrBotSessionListData, AstrBotStreamMapper,
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
AuthenticationType, BoundGatewayEvent, ConnectionState, FinishReason, GatewayEvent,
PROTOCOL_VERSION, derive_astrbot_server_instance_id,
};
use futures_util::StreamExt;
use reqwest::header::{ACCEPT, AUTHORIZATION, CONTENT_TYPE, HeaderMap, HeaderValue};
use secrecy::{ExposeSecret, SecretString};
use serde_json::{Value, json};
use thiserror::Error;
use tokio::sync::{Mutex, mpsc, watch};
use tokio_util::sync::CancellationToken;
use super::{GatewayError, SlotKind};
#[derive(Debug, Clone)]
pub struct AstrBotClientConfig {
pub profile_id: String,
pub slot: SlotKind,
pub base_url: String,
pub api_key: SecretString,
/// Remote WebChat username used as session owner identity.
pub remote_username: String,
pub remote_display_name: Option<String>,
pub authentication_type: AuthenticationType,
/// Optional sticky session id. When absent, the first chat response supplies one.
pub session_id: Option<String>,
/// Expected server identity substitute. Empty means accept first observed identity.
pub expected_server_instance_id: Option<String>,
}
#[derive(Debug, Error)]
pub enum AstrBotClientError {
#[error("astrbot request failed")]
Request(#[from] reqwest::Error),
#[error("astrbot returned HTTP {0}")]
HttpStatus(reqwest::StatusCode),
#[error("astrbot api status error: {0}")]
ApiStatus(String),
#[error("invalid astrbot payload")]
Json(#[from] serde_json::Error),
#[error("astrbot stream mapping failed: {0}")]
Map(String),
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
/// The response body broke after the server had already started answering.
///
/// Distinct from [`AstrBotClientError::Request`] on purpose: `/api/v1/chat`
/// has no idempotency key, so re-POSTing a message whose response had
/// already begun duplicates it in the remote conversation. Only the caller
/// (i.e. the user) may retry this.
#[error("astrbot stream interrupted after the response started")]
StreamInterrupted,
#[error("server identity changed")]
ServerIdentityChanged,
#[error("astrbot event channel closed")]
ChannelClosed,
#[error("invalid configuration: {0}")]
InvalidConfig(&'static str),
#[error("astrbot credential expired")]
CredentialExpired,
}
impl From<AstrBotClientError> for GatewayError {
fn from(value: AstrBotClientError) -> Self {
match value {
AstrBotClientError::Request(error) => GatewayError::Request(error),
AstrBotClientError::HttpStatus(status) => GatewayError::HttpStatus(status),
AstrBotClientError::Json(error) => GatewayError::Json(error),
AstrBotClientError::ServerIdentityChanged => GatewayError::ServerIdentityChanged,
AstrBotClientError::ChannelClosed => GatewayError::ChannelClosed,
AstrBotClientError::ApiStatus(message) => GatewayError::Adapter(message),
AstrBotClientError::Map(message) => GatewayError::Adapter(message),
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
AstrBotClientError::StreamInterrupted => GatewayError::Adapter(
"AstrBot stream interrupted after the response started".into(),
),
AstrBotClientError::InvalidConfig(message) => GatewayError::Adapter(message.to_owned()),
AstrBotClientError::CredentialExpired => {
GatewayError::Adapter("AstrBot authentication has expired".into())
}
}
}
}
const MAX_DEDUPLICATED_EVENTS: usize = 4_096;
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
/// Guards against a hostile or broken server streaming an unbounded single line.
const MAX_SSE_LINE_BYTES: usize = 1024 * 1024;
/// Ceiling on the total size of one chat response.
///
/// Removing `Client::timeout` from the streaming client (so a slow reply is no
/// longer cut off) also removed the only bound on how much a server could send
/// in one response. `read_timeout` cannot replace it: it measures the gap
/// between successful reads, so a server that keeps trickling bytes keeps the
/// stream alive forever, and both this buffer and the mapper's accumulated
/// message text would grow without limit. A real reply is far below this.
const MAX_STREAM_BYTES: u64 = 64 * 1024 * 1024;
/// Splits an SSE byte stream into lines at the byte level.
///
/// TCP chunk boundaries fall on arbitrary byte offsets, so decoding each chunk
/// with `String::from_utf8_lossy` corrupts any multi-byte character that
/// straddles two chunks — for CJK text (3 bytes per character) that is a
/// frequent, user-visible `U+FFFD`. Buffering raw bytes and only decoding
/// complete `\n`-delimited lines keeps every character intact, because SSE
/// guarantees `\n` (0x0A) never appears inside a UTF-8 multi-byte sequence.
#[derive(Debug, Default)]
struct SseLineBuffer {
bytes: Vec<u8>,
/// Offset of the first unconsumed byte.
///
/// Consuming a line by draining from the front would memmove the entire
/// remainder once per line, which is quadratic in the chunk size — and a
/// single `bytes_stream()` item from hyper can be several hundred KiB of
/// short delta frames. Advancing a cursor instead makes reading a line O(1)
/// and leaves one memmove per chunk, in `push_chunk`.
cursor: usize,
total: u64,
}
impl SseLineBuffer {
fn push_chunk(&mut self, chunk: &[u8]) {
if self.cursor > 0 {
self.bytes.drain(..self.cursor);
self.cursor = 0;
}
self.total = self.total.saturating_add(chunk.len() as u64);
self.bytes.extend_from_slice(chunk);
}
/// Pops the next complete line, or `None` when the buffer holds no `\n` yet.
///
/// Invalid UTF-8 within a single complete line is replaced rather than
/// rejected: a lossy line is still parseable SSE, and dropping the whole
/// stream over one bad byte would lose the surrounding reply.
fn next_line(&mut self) -> Option<String> {
let pending = &self.bytes[self.cursor..];
let index = pending.iter().position(|byte| *byte == b'\n')?;
let mut line = &pending[..index];
if line.last() == Some(&b'\r') {
line = &line[..line.len() - 1];
}
let text = String::from_utf8_lossy(line).into_owned();
self.cursor += index + 1;
Some(text)
}
/// Consumes whatever is left once the stream ends without a trailing `\n`.
fn take_remainder(&mut self) -> Option<String> {
let mut line = &self.bytes[self.cursor..];
if line.is_empty() {
return None;
}
if line.last() == Some(&b'\r') {
line = &line[..line.len() - 1];
}
let text = String::from_utf8_lossy(line).into_owned();
self.cursor = self.bytes.len();
(!text.trim().is_empty()).then_some(text)
}
/// True when one line, or the whole response, has outgrown its limit.
fn is_overflowing(&self) -> bool {
self.bytes.len() - self.cursor > MAX_SSE_LINE_BYTES || self.total > MAX_STREAM_BYTES
}
}
#[derive(Default)]
struct EventDeduplicator {
ids: std::collections::HashSet<String>,
order: VecDeque<String>,
}
impl EventDeduplicator {
fn insert(&mut self, event_id: String) -> bool {
if !self.ids.insert(event_id.clone()) {
return false;
}
self.order.push_back(event_id);
if self.order.len() > MAX_DEDUPLICATED_EVENTS
&& let Some(expired) = self.order.pop_front()
{
self.ids.remove(&expired);
}
true
}
}
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
/// Total budget for a short request/response exchange (probe, sessions, upload).
const REST_TOTAL_TIMEOUT: Duration = Duration::from_secs(120);
/// How long the chat stream may stay completely silent before it is abandoned.
///
/// This is deliberately *not* a total timeout. `Client::timeout` counts from the
/// start of the request until the body has finished, and it keeps running while
/// `bytes_stream()` is being consumed, so any generation longer than the budget
/// was cut off mid-reply. `read_timeout` resets after every successful read, so
/// a reply may take arbitrarily long as long as it keeps producing bytes.
const STREAM_IDLE_TIMEOUT: Duration = Duration::from_secs(120);
const CONNECT_TIMEOUT: Duration = Duration::from_secs(5);
#[derive(Clone)]
pub struct AstrBotClient {
config: AstrBotClientConfig,
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
/// Short request/response endpoints; keeps a total deadline.
http: reqwest::Client,
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
/// `/api/v1/chat` only; no total deadline, idle detection via `read_timeout`.
stream_http: reqwest::Client,
seen_event_ids: Arc<Mutex<EventDeduplicator>>,
session_id: Arc<Mutex<Option<String>>>,
server_instance_id: Arc<Mutex<String>>,
state_tx: watch::Sender<ConnectionState>,
}
impl AstrBotClient {
pub fn new(config: AstrBotClientConfig) -> Result<Self, AstrBotClientError> {
if config.base_url.trim().is_empty() {
return Err(AstrBotClientError::InvalidConfig("base_url is required"));
}
if config.remote_username.trim().is_empty() {
return Err(AstrBotClientError::InvalidConfig(
"remote_username is required",
));
}
if config.api_key.expose_secret().trim().is_empty() {
return Err(AstrBotClientError::InvalidConfig("api_key is required"));
}
if config.authentication_type == AuthenticationType::Jwt
&& jwt_is_expired(config.api_key.expose_secret())
{
return Err(AstrBotClientError::CredentialExpired);
}
let base = config.base_url.trim_end_matches('/').to_owned();
let derived = derive_astrbot_server_instance_id(&base);
let initial_identity = config
.expected_server_instance_id
.clone()
.filter(|value| !value.trim().is_empty())
.unwrap_or(derived);
let mut headers = HeaderMap::new();
let auth_value = format!("Bearer {}", config.api_key.expose_secret());
headers.insert(
AUTHORIZATION,
HeaderValue::from_str(&auth_value).map_err(|_| {
AstrBotClientError::InvalidConfig("api_key has invalid header chars")
})?,
);
let http = reqwest::Client::builder()
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
.default_headers(headers.clone())
.redirect(reqwest::redirect::Policy::none())
.connect_timeout(CONNECT_TIMEOUT)
.timeout(REST_TOTAL_TIMEOUT)
.build()?;
let stream_http = reqwest::Client::builder()
.default_headers(headers)
.redirect(reqwest::redirect::Policy::none())
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
.connect_timeout(CONNECT_TIMEOUT)
.read_timeout(STREAM_IDLE_TIMEOUT)
.tcp_keepalive(Duration::from_secs(60))
.build()?;
let (state_tx, _) = watch::channel(ConnectionState::Disconnected);
let initial_session = config.session_id.clone();
Ok(Self {
config: AstrBotClientConfig {
base_url: base,
..config
},
http,
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
stream_http,
seen_event_ids: Arc::new(Mutex::new(EventDeduplicator::default())),
session_id: Arc::new(Mutex::new(initial_session)),
server_instance_id: Arc::new(Mutex::new(initial_identity)),
state_tx,
})
}
pub fn state_receiver(&self) -> watch::Receiver<ConnectionState> {
self.state_tx.subscribe()
}
pub fn server_instance_id_blocking(&self) -> String {
self.server_instance_id
.try_lock()
.map(|guard| guard.clone())
.unwrap_or_else(|_| derive_astrbot_server_instance_id(&self.config.base_url))
}
fn set_state(&self, state: ConnectionState) {
self.state_tx.send_replace(state);
}
fn url(&self, path: &str) -> String {
format!("{}{}", self.config.base_url, path)
}
pub async fn probe(&self) -> Result<Value, AstrBotClientError> {
self.set_state(ConnectionState::Connecting);
let response = self
.http
.get(self.url(&format!(
"/api/v1/chat/sessions?username={}&page=1&page_size=1",
urlencoding_username(&self.config.remote_username)
)))
.send()
.await?;
if response.status().as_u16() == 401 || response.status().as_u16() == 403 {
self.set_state(ConnectionState::AuthExpired);
return Err(AstrBotClientError::HttpStatus(response.status()));
}
if !response.status().is_success() {
self.set_state(ConnectionState::ServerUnavailable);
return Err(AstrBotClientError::HttpStatus(response.status()));
}
let envelope: AstrBotApiEnvelope<AstrBotSessionListData> = response.json().await?;
if !envelope.is_ok() {
self.set_state(ConnectionState::FatalError);
return Err(AstrBotClientError::ApiStatus(
envelope
.message
.unwrap_or_else(|| "chat sessions probe failed".into()),
));
}
self.set_state(ConnectionState::Connected);
Ok(json!({
"status": "ok",
"protocolVersion": PROTOCOL_VERSION,
"transport": "astrbot-openapi",
"serverInstanceId": self.server_instance_id.lock().await.clone(),
"remoteUsername": self.config.remote_username,
"sessionCount": envelope.data.map(|data| data.total.unwrap_or(0)).unwrap_or(0),
}))
}
pub async fn set_session_id(&self, session_id: String) -> Result<(), AstrBotClientError> {
if session_id.trim().is_empty() {
return Err(AstrBotClientError::InvalidConfig("session_id is required"));
}
*self.session_id.lock().await = Some(session_id);
Ok(())
}
pub async fn list_sessions(&self) -> Result<AstrBotSessionListData, AstrBotClientError> {
let response = self
.http
.get(self.url(&format!(
"/api/v1/chat/sessions?username={}&page=1&page_size=50",
urlencoding_username(&self.config.remote_username)
)))
.send()
.await?;
if !response.status().is_success() {
return Err(AstrBotClientError::HttpStatus(response.status()));
}
let envelope: AstrBotApiEnvelope<AstrBotSessionListData> = response.json().await?;
if !envelope.is_ok() {
return Err(AstrBotClientError::ApiStatus(
envelope
.message
.unwrap_or_else(|| "list sessions failed".into()),
));
}
Ok(envelope.data.unwrap_or(AstrBotSessionListData {
sessions: Vec::new(),
page: Some(1),
page_size: Some(50),
total: Some(0),
}))
}
pub async fn list_configs(&self) -> Result<AstrBotConfigListData, AstrBotClientError> {
let response = self.http.get(self.url("/api/v1/configs")).send().await?;
if !response.status().is_success() {
return Err(AstrBotClientError::HttpStatus(response.status()));
}
let envelope: AstrBotApiEnvelope<AstrBotConfigListData> = response.json().await?;
if !envelope.is_ok() {
return Err(AstrBotClientError::ApiStatus(
envelope
.message
.unwrap_or_else(|| "list configs failed".into()),
));
}
Ok(envelope.data.unwrap_or(AstrBotConfigListData {
configs: Vec::new(),
}))
}
pub async fn capabilities(&self) -> Result<AstrBotCapabilitySnapshot, AstrBotClientError> {
let configs = self.list_configs().await?;
let models = configs
.configs
.into_iter()
.map(|config| AstrBotModelOption {
id: config.id,
name: config.name,
is_default: config.is_default,
})
.collect::<Vec<_>>();
Ok(AstrBotCapabilitySnapshot {
transport: "astrbot-openapi".to_owned(),
text_chat: true,
streaming: true,
model_selection: !models.is_empty(),
file_upload: true,
image_input: true,
models,
})
}
pub async fn upload_file(
&self,
file_name: &str,
mime_type: &str,
bytes: Vec<u8>,
) -> Result<AstrBotAttachment, AstrBotClientError> {
if file_name.trim().is_empty() || mime_type.trim().is_empty() || bytes.is_empty() {
return Err(AstrBotClientError::InvalidConfig(
"file_name, mime_type, and file bytes are required",
));
}
let part = reqwest::multipart::Part::bytes(bytes.clone())
.file_name(file_name.to_owned())
.mime_str(mime_type)
.map_err(|_| AstrBotClientError::InvalidConfig("invalid attachment mime type"))?;
let form = reqwest::multipart::Form::new().part("file", part);
let response = self
.http
.post(self.url("/api/v1/file"))
.multipart(form)
.send()
.await?;
if !response.status().is_success() {
return Err(AstrBotClientError::HttpStatus(response.status()));
}
let envelope: AstrBotApiEnvelope<Value> = response.json().await?;
if !envelope.is_ok() {
return Err(AstrBotClientError::ApiStatus(
envelope
.message
.unwrap_or_else(|| "file upload failed".into()),
));
}
let data = envelope.data.unwrap_or(Value::Null);
let attachment_id = data
.get("id")
.or_else(|| data.get("file_id"))
.or_else(|| data.get("attachment_id"))
.and_then(Value::as_str)
.ok_or_else(|| AstrBotClientError::Map("upload response has no attachment id".into()))?
.to_owned();
Ok(AstrBotAttachment {
attachment_id,
file_name: file_name.to_owned(),
mime_type: mime_type.to_owned(),
size_bytes: bytes.len() as u64,
url: data
.get("url")
.and_then(Value::as_str)
.map(ToOwned::to_owned),
})
}
pub async fn download_attachment(
&self,
attachment_id: &str,
) -> Result<(String, Vec<u8>), AstrBotClientError> {
if attachment_id.is_empty()
|| attachment_id.len() > 200
|| !attachment_id
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.'))
{
return Err(AstrBotClientError::InvalidConfig("invalid attachment id"));
}
let response = self
.http
.get(self.url(&format!("/api/v1/files/{attachment_id}/content")))
.send()
.await?;
if response.status().as_u16() == 401 || response.status().as_u16() == 403 {
return Err(AstrBotClientError::HttpStatus(response.status()));
}
if !response.status().is_success() {
return Err(AstrBotClientError::HttpStatus(response.status()));
}
let mime_type = response
.headers()
.get(CONTENT_TYPE)
.and_then(|value| value.to_str().ok())
.and_then(|value| value.split(';').next())
.filter(|value| !value.trim().is_empty())
.unwrap_or("application/octet-stream")
.to_owned();
let bytes = response.bytes().await?.to_vec();
if bytes.is_empty() || bytes.len() > 16 * 1024 * 1024 {
return Err(AstrBotClientError::InvalidConfig(
"attachment size is outside the supported range",
));
}
Ok((mime_type, bytes))
}
pub async fn send_chat_stream(
&self,
message: &str,
config_id: Option<String>,
attachments: Vec<AstrBotAttachment>,
sender: &mpsc::Sender<super::gateway_client::BoundGatewayEvent>,
cancellation: &CancellationToken,
) -> Result<Option<String>, AstrBotClientError> {
self.set_state(ConnectionState::Syncing);
let session_id = self.session_id.lock().await.clone();
let request = AstrBotChatRequest {
message: Value::String(message.to_owned()),
session_id: session_id.clone(),
conversation_id: None,
username: Some(self.config.remote_username.clone()),
nickname: self.config.remote_display_name.clone(),
config_id,
attachments: (!attachments.is_empty()).then_some(attachments),
platform_id: None,
enable_streaming: Some(true),
};
let response = self
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
.stream_http
.post(self.url("/api/v1/chat"))
.header(ACCEPT, HeaderValue::from_static("text/event-stream"))
.json(&request)
.send()
.await?;
if response.status().as_u16() == 401 || response.status().as_u16() == 403 {
self.set_state(ConnectionState::AuthExpired);
return Err(AstrBotClientError::HttpStatus(response.status()));
}
if !response.status().is_success() {
self.set_state(ConnectionState::ServerUnavailable);
return Err(AstrBotClientError::HttpStatus(response.status()));
}
let server_instance_id = self.server_instance_id.lock().await.clone();
if let Some(expected) = &self.config.expected_server_instance_id
&& !expected.is_empty()
&& expected != &server_instance_id
{
self.set_state(ConnectionState::CertificateChanged);
return Err(AstrBotClientError::ServerIdentityChanged);
}
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
// Every request gets its own stream id: the mapper restarts its
// sequence counter per stream, and `seen_event_ids` outlives a single
// request, so reusing ids would make the deduplicator discard every
// event of the second and later messages on this connection.
let stream_id = uuid::Uuid::new_v4().to_string();
let mut mapper = AstrBotStreamMapper::new(server_instance_id.clone(), stream_id);
if let Some(existing) = session_id {
let seed = serde_json::json!({
"type": "session_id",
"data": null,
"session_id": existing,
});
let _ = mapper.push_line(&format!("data: {seed}"));
}
let mut stream = response.bytes_stream();
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
let mut buffer = SseLineBuffer::default();
self.set_state(ConnectionState::Connected);
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
// From here on the server has accepted and is answering this POST, so a
// failure must never be retried automatically — see `finish_and_fail`.
loop {
tokio::select! {
_ = cancellation.cancelled() => {
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
// Leave the connection state alone: the socket is still
// healthy and flipping to Disconnected only makes the tray
// and the slot badge flicker.
let events = mapper.finish_stream_with(FinishReason::Cancelled);
self.dispatch_events(events, sender).await?;
if let Some(session) = mapper.session_id() {
*self.session_id.lock().await = Some(session.to_owned());
}
self.set_state(ConnectionState::Connected);
return Ok(mapper.session_id().map(str::to_owned));
}
next = stream.next() => {
let Some(next) = next else { break; };
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
let chunk = match next {
Ok(chunk) => chunk,
Err(_) => {
return self
.finish_and_fail(&mut mapper, sender, AstrBotClientError::StreamInterrupted)
.await;
}
};
buffer.push_chunk(&chunk);
if buffer.is_overflowing() {
return self
.finish_and_fail(
&mut mapper,
sender,
AstrBotClientError::Map(
"astrbot response exceeded the supported size".into(),
),
)
.await;
}
while let Some(line) = buffer.next_line() {
match mapper.push_line(&line) {
Ok(events) => self.dispatch_events(events, sender).await?,
Err(error) => {
return self
.finish_and_fail(
&mut mapper,
sender,
AstrBotClientError::Map(error.to_string()),
)
.await;
}
}
}
}
}
}
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
if let Some(remainder) = buffer.take_remainder() {
match mapper.push_line(&remainder) {
Ok(events) => self.dispatch_events(events, sender).await?,
Err(error) => {
return self
.finish_and_fail(
&mut mapper,
sender,
AstrBotClientError::Map(error.to_string()),
)
.await;
}
}
}
let events = mapper.finish_stream();
self.dispatch_events(events, sender).await?;
if let Some(session) = mapper.session_id() {
*self.session_id.lock().await = Some(session.to_owned());
}
self.set_state(ConnectionState::Connected);
Ok(self.session_id.lock().await.clone())
}
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
/// Closes out a half-streamed message before surfacing a transport failure.
///
/// Every error path after the response headers arrive has to emit a
/// `MessageCompleted { finishReason: error }`; otherwise the partial reply
/// stays `streaming = 1` in the database and renders as "generating"
/// forever, including after a restart.
async fn finish_and_fail(
&self,
mapper: &mut AstrBotStreamMapper,
sender: &mpsc::Sender<super::gateway_client::BoundGatewayEvent>,
error: AstrBotClientError,
) -> Result<Option<String>, AstrBotClientError> {
let events = mapper.finish_stream_with(FinishReason::Error);
// Best effort: if the channel is already gone there is nothing left to
// finalize, and the original transport error is the more useful one.
let _ = self.dispatch_events(events, sender).await;
if let Some(session) = mapper.session_id() {
*self.session_id.lock().await = Some(session.to_owned());
}
self.set_state(ConnectionState::ServerUnavailable);
Err(error)
}
async fn dispatch_events(
&self,
events: Vec<GatewayEvent>,
sender: &mpsc::Sender<super::gateway_client::BoundGatewayEvent>,
) -> Result<(), AstrBotClientError> {
for event in events {
if let Some(session_id) = event.metadata.session_id.clone() {
*self.session_id.lock().await = Some(session_id);
}
let event_id = event.metadata.event_id.clone();
let mut seen = self.seen_event_ids.lock().await;
if !seen.insert(event_id.clone()) {
continue;
}
drop(seen);
let body = serde_json::to_value(&event.body)
.map_err(|error| AstrBotClientError::Map(error.to_string()))?;
let payload = body.get("payload").cloned().unwrap_or(body);
let bound = BoundGatewayEvent {
profile_id: self.config.profile_id.clone(),
slot: protocol_slot(self.config.slot),
event,
};
sender
.send(super::gateway_client::BoundGatewayEvent {
profile_id: bound.profile_id,
slot: self.config.slot,
event_id,
event_type: bound.event.event_type().to_owned(),
server_instance_id: bound.event.metadata.server_instance_id.clone(),
session_id: bound.event.metadata.session_id.clone(),
message_id: bound.event.metadata.message_id.clone(),
payload,
})
.await
.map_err(|_| AstrBotClientError::ChannelClosed)?;
}
Ok(())
}
}
fn protocol_slot(slot: SlotKind) -> desktop_protocol::ActiveSlotKind {
match slot {
SlotKind::Companion => desktop_protocol::ActiveSlotKind::Companion,
SlotKind::Operations => desktop_protocol::ActiveSlotKind::Operations,
}
}
fn urlencoding_username(username: &str) -> String {
username
.chars()
.map(|ch| match ch {
'A'..='Z' | 'a'..='z' | '0'..='9' | '-' | '_' | '.' | '~' => ch.to_string(),
_ => format!("%{:02X}", ch as u8),
})
.collect()
}
fn jwt_is_expired(token: &str) -> bool {
let Some(payload) = token.split('.').nth(1).and_then(decode_base64url) else {
return false;
};
let Ok(value) = serde_json::from_slice::<Value>(&payload) else {
return false;
};
let Some(exp) = value.get("exp").and_then(Value::as_i64) else {
return false;
};
exp <= time::OffsetDateTime::now_utc().unix_timestamp()
}
fn decode_base64url(value: &str) -> Option<Vec<u8>> {
let mut output = Vec::with_capacity(value.len() * 3 / 4);
let mut buffer = 0u32;
let mut bits = 0u8;
for byte in value.bytes() {
let digit = match byte {
b'A'..=b'Z' => byte - b'A',
b'a'..=b'z' => byte - b'a' + 26,
b'0'..=b'9' => byte - b'0' + 52,
b'-' => 62,
b'_' => 63,
b'=' => break,
_ => return None,
};
buffer = (buffer << 6) | u32::from(digit);
bits += 6;
if bits >= 8 {
bits -= 8;
output.push((buffer >> bits) as u8);
buffer &= (1 << bits) - 1;
}
}
Some(output)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_empty_api_key_and_username() {
let result = AstrBotClient::new(AstrBotClientConfig {
profile_id: "p".into(),
slot: SlotKind::Companion,
base_url: "http://127.0.0.1:1".into(),
api_key: SecretString::from(String::new()),
remote_username: "user".into(),
remote_display_name: None,
authentication_type: AuthenticationType::ApiKey,
session_id: None,
expected_server_instance_id: None,
});
assert!(matches!(result, Err(AstrBotClientError::InvalidConfig(_))));
}
#[test]
fn derives_identity_from_base_url() {
let client = AstrBotClient::new(AstrBotClientConfig {
profile_id: "p".into(),
slot: SlotKind::Companion,
base_url: "http://192.168.31.210:26285/".into(),
api_key: SecretString::from("abk_test".to_owned()),
remote_username: "desktop-companion".into(),
remote_display_name: Some("Desktop Companion".into()),
authentication_type: AuthenticationType::ApiKey,
session_id: Some("s1".into()),
expected_server_instance_id: None,
})
.expect("client");
assert!(client.server_instance_id_blocking().starts_with("astrbot-"));
}
#[test]
fn detects_expired_jwt_without_logging_or_exposing_the_token() {
assert!(jwt_is_expired("e30.eyJleHAiOjF9.signature"));
assert!(!jwt_is_expired("not-a-jwt"));
}
fix(astrbot): scope stream event ids and fix the transport layer 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>
2026-07-26 23:12:56 +08:00
#[test]
fn line_buffer_keeps_multibyte_characters_split_across_chunks_intact() {
// "你好世界" is 12 UTF-8 bytes; cut in the middle of the second char.
let payload = "data: {\"type\":\"plain\",\"data\":\"你好世界\"}\n";
let bytes = payload.as_bytes();
let split = bytes
.iter()
.position(|byte| *byte == 0xE4)
.expect("payload contains a CJK lead byte")
+ 4;
assert!(
!payload.is_char_boundary(split),
"split must cut a character"
);
let mut buffer = SseLineBuffer::default();
buffer.push_chunk(&bytes[..split]);
assert!(
buffer.next_line().is_none(),
"an incomplete line must not be emitted"
);
buffer.push_chunk(&bytes[split..]);
let line = buffer
.next_line()
.expect("line completes on the second chunk");
assert!(!line.contains('\u{FFFD}'), "decoded line: {line}");
assert!(line.contains("你好世界"));
}
#[test]
fn line_buffer_strips_crlf_and_returns_the_trailing_line() {
let mut buffer = SseLineBuffer::default();
buffer.push_chunk(b"data: one\r\ndata: two\r\n");
assert_eq!(buffer.next_line().as_deref(), Some("data: one"));
assert_eq!(buffer.next_line().as_deref(), Some("data: two"));
assert_eq!(buffer.next_line(), None);
buffer.push_chunk(b"data: tail");
assert_eq!(buffer.next_line(), None);
assert_eq!(buffer.take_remainder().as_deref(), Some("data: tail"));
assert_eq!(buffer.take_remainder(), None);
}
#[test]
fn line_buffer_cursor_survives_interleaved_reads_and_writes() {
// The cursor is only compacted on push_chunk, so a partially drained
// buffer must still read correctly across the next chunk.
let mut buffer = SseLineBuffer::default();
buffer.push_chunk(b"a\nb\nc");
assert_eq!(buffer.next_line().as_deref(), Some("a"));
buffer.push_chunk(b"d\ne\n");
assert_eq!(buffer.next_line().as_deref(), Some("b"));
assert_eq!(buffer.next_line().as_deref(), Some("cd"));
assert_eq!(buffer.next_line().as_deref(), Some("e"));
assert_eq!(buffer.next_line(), None);
assert_eq!(buffer.take_remainder(), None);
}
#[test]
fn line_buffer_bounds_a_single_line_and_the_whole_response() {
let mut oversized_line = SseLineBuffer::default();
oversized_line.push_chunk(&vec![b'x'; MAX_SSE_LINE_BYTES + 1]);
assert!(oversized_line.is_overflowing());
// Consumed bytes still count towards the response ceiling, otherwise a
// server could stream forever in small well-formed lines: read_timeout
// never fires while bytes keep arriving, and there is no total timeout.
let mut long_response = SseLineBuffer::default();
let line = b"data: {}\n";
let repeats = (MAX_STREAM_BYTES as usize / line.len()) + 1;
for _ in 0..repeats {
long_response.push_chunk(line);
while long_response.next_line().is_some() {}
}
assert!(long_response.is_overflowing());
assert!(
long_response.bytes.len() < 1024,
"the buffer itself must stay small; only the counter grows"
);
}
}
/// End-to-end transport tests against a hand-rolled HTTP/1.1 SSE server.
///
/// A raw `TcpListener` is used instead of an HTTP framework on purpose: these
/// tests need byte-exact control over where the response body is split across
/// TCP writes, and the ability to drop the socket mid-body without sending the
/// terminal chunk. Neither is expressible through a normal server API.
#[cfg(test)]
mod stream_transport_tests {
use super::*;
use std::sync::atomic::{AtomicUsize, Ordering};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
/// What the fake server does after it has written the scripted frames.
#[derive(Clone, Copy, PartialEq)]
enum Ending {
/// Send the terminal `0\r\n\r\n` chunk: a well-formed, complete body.
Complete,
/// Drop the socket without the terminal chunk, so the client sees a
/// truncated body rather than a clean end of stream.
Truncate,
/// Keep the connection open and silent, so only cancellation ends it.
HoldOpen,
}
struct FakeAstrBot {
base_url: String,
requests: Arc<AtomicUsize>,
}
/// Serves `chunks` as separate chunked-encoding frames with a pause between
/// them, which forces hyper to surface them as distinct stream items.
async fn spawn_fake(chunks: Vec<Vec<u8>>, ending: Ending) -> FakeAstrBot {
let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind");
let port = listener.local_addr().expect("addr").port();
let requests = Arc::new(AtomicUsize::new(0));
let counter = Arc::clone(&requests);
tokio::spawn(async move {
loop {
let Ok((mut socket, _)) = listener.accept().await else {
return;
};
let chunks = chunks.clone();
let counter = Arc::clone(&counter);
tokio::spawn(async move {
if read_request(&mut socket).await.is_none() {
return;
}
counter.fetch_add(1, Ordering::SeqCst);
let header = b"HTTP/1.1 200 OK\r\n\
Content-Type: text/event-stream\r\n\
Transfer-Encoding: chunked\r\n\r\n";
if socket.write_all(header).await.is_err() {
return;
}
for chunk in chunks {
let framed = format!("{:X}\r\n", chunk.len());
if socket.write_all(framed.as_bytes()).await.is_err()
|| socket.write_all(&chunk).await.is_err()
|| socket.write_all(b"\r\n").await.is_err()
|| socket.flush().await.is_err()
{
return;
}
// Guarantees the next frame lands in its own TCP read.
tokio::time::sleep(Duration::from_millis(60)).await;
}
match ending {
Ending::Complete => {
let _ = socket.write_all(b"0\r\n\r\n").await;
let _ = socket.flush().await;
}
Ending::Truncate => {
// Dropping without the terminal chunk makes hyper
// report an incomplete message.
let _ = socket.shutdown().await;
}
Ending::HoldOpen => {
tokio::time::sleep(Duration::from_secs(30)).await;
}
}
});
}
});
FakeAstrBot {
base_url: format!("http://127.0.0.1:{port}"),
requests,
}
}
/// Reads request headers plus any declared body so the client's write side
/// completes before the response is produced.
async fn read_request(socket: &mut tokio::net::TcpStream) -> Option<()> {
let mut raw = Vec::new();
let mut scratch = [0u8; 1024];
loop {
let read = socket.read(&mut scratch).await.ok()?;
if read == 0 {
return None;
}
raw.extend_from_slice(&scratch[..read]);
if let Some(index) = raw
.windows(4)
.position(|window| window == b"\r\n\r\n")
.map(|index| index + 4)
{
let headers = String::from_utf8_lossy(&raw[..index]).to_ascii_lowercase();
let length = headers
.lines()
.find_map(|line| line.strip_prefix("content-length:"))
.and_then(|value| value.trim().parse::<usize>().ok())
.unwrap_or(0);
let mut body = raw.len() - index;
while body < length {
let read = socket.read(&mut scratch).await.ok()?;
if read == 0 {
return None;
}
body += read;
}
return Some(());
}
}
}
fn client_for(base_url: &str) -> AstrBotClient {
AstrBotClient::new(AstrBotClientConfig {
profile_id: "profile-a".into(),
slot: SlotKind::Companion,
base_url: base_url.to_owned(),
api_key: SecretString::from("abk_test".to_owned()),
remote_username: "desktop-companion".into(),
remote_display_name: None,
authentication_type: AuthenticationType::ApiKey,
session_id: None,
expected_server_instance_id: None,
})
.expect("client")
}
fn drain(
receiver: &mut mpsc::Receiver<super::super::gateway_client::BoundGatewayEvent>,
) -> Vec<super::super::gateway_client::BoundGatewayEvent> {
let mut events = Vec::new();
while let Ok(event) = receiver.try_recv() {
events.push(event);
}
events
}
#[tokio::test]
async fn decodes_multibyte_text_split_across_tcp_chunks() {
// One SSE frame carrying CJK text, cut in the middle of a character.
let frame = "data: {\"type\":\"plain\",\"data\":\"你好,世界\"}\n\n";
let bytes = frame.as_bytes().to_vec();
let split = bytes
.iter()
.position(|byte| *byte == 0xE4)
.expect("CJK lead byte")
+ 1;
assert!(!frame.is_char_boundary(split), "split must cut a character");
let server = spawn_fake(
vec![bytes[..split].to_vec(), bytes[split..].to_vec()],
Ending::Complete,
)
.await;
let client = client_for(&server.base_url);
let (tx, mut rx) = mpsc::channel(64);
let cancellation = CancellationToken::new();
client
.send_chat_stream("hi", None, Vec::new(), &tx, &cancellation)
.await
.expect("stream completes");
let text = drain(&mut rx)
.iter()
.filter(|event| event.event_type == "message.completed")
.filter_map(|event| {
event
.payload
.get("content")
.and_then(Value::as_str)
.map(ToOwned::to_owned)
})
.collect::<String>();
assert!(!text.contains('\u{FFFD}'), "decoded content: {text}");
assert!(text.contains("你好,世界"), "decoded content: {text}");
}
#[tokio::test]
async fn truncated_body_reports_stream_interrupted_and_finalizes_the_message() {
let server = spawn_fake(
vec![b"data: {\"type\":\"plain\",\"data\":\"partial\"}\n\n".to_vec()],
Ending::Truncate,
)
.await;
let client = client_for(&server.base_url);
let (tx, mut rx) = mpsc::channel(64);
let cancellation = CancellationToken::new();
let error = client
.send_chat_stream("hi", None, Vec::new(), &tx, &cancellation)
.await
.expect_err("a truncated body must not look like success");
assert!(
matches!(error, AstrBotClientError::StreamInterrupted),
"the response had already started, so this must not be auto-retried: {error:?}"
);
let completed = drain(&mut rx)
.into_iter()
.find(|event| event.event_type == "message.completed")
.expect("the half-streamed message must be finalized, not left streaming");
assert_eq!(
completed
.payload
.get("finishReason")
.and_then(Value::as_str),
Some("error")
);
assert_eq!(
completed.payload.get("content").and_then(Value::as_str),
Some("partial"),
"text received before the break must be preserved"
);
}
/// A message whose reply had already started must never be re-sent:
/// `POST /api/v1/chat` carries no idempotency key, so a second attempt
/// appends the user's message to the remote conversation again.
#[tokio::test]
async fn a_broken_response_body_does_not_resend_the_chat_post() {
let server = spawn_fake(
vec![
b"data: {\"type\":\"plain\",\"data\":\"partial\"}
"
.to_vec(),
],
Ending::Truncate,
)
.await;
let client = client_for(&server.base_url);
let (tx, _rx) = mpsc::channel(64);
let cancellation = CancellationToken::new();
let _ = client
.send_chat_stream("hi", None, Vec::new(), &tx, &cancellation)
.await;
// Give any resend time to land before sampling.
tokio::time::sleep(Duration::from_millis(500)).await;
assert_eq!(server.requests.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn cancellation_finalizes_the_message_as_cancelled() {
let server = spawn_fake(
vec![b"data: {\"type\":\"plain\",\"data\":\"half a rep\"}\n\n".to_vec()],
Ending::HoldOpen,
)
.await;
let client = client_for(&server.base_url);
let (tx, mut rx) = mpsc::channel(64);
let cancellation = CancellationToken::new();
let trigger = cancellation.clone();
tokio::spawn(async move {
tokio::time::sleep(Duration::from_millis(400)).await;
trigger.cancel();
});
client
.send_chat_stream("hi", None, Vec::new(), &tx, &cancellation)
.await
.expect("cancellation is not a failure");
let completed = drain(&mut rx)
.into_iter()
.find(|event| event.event_type == "message.completed")
.expect("stopping generation must still finalize the message");
assert_eq!(
completed
.payload
.get("finishReason")
.and_then(Value::as_str),
Some("cancelled")
);
assert_eq!(
completed.payload.get("content").and_then(Value::as_str),
Some("half a rep"),
"content received before the stop must be kept"
);
}
}