Error type refactor; renamed GHA jobs

wdoppenberg · wdoppenberg · commit 819057887139 · 2025-09-22T18:52:10.000+02:00
diff --git a/.github/workflows/rust-lint-test.yml b/.github/workflows/rust-lint-test.yml
@@ -1,4 +1,4 @@
-name: Lint & Test
+name: test
 
 on:
   push:
@@ -23,13 +23,13 @@ defaults:
     working-directory: ./rust
 
 jobs:
-  build-and-test:
+  rust:
     strategy:
       fail-fast: false
       matrix:
         os: [ ubuntu-latest, macos-latest, windows-latest ]
 
-    name: Test multiple workspaces on ${{ matrix.os }}
+    name: Rust SDK Tests [${{ matrix.os }}]
     runs-on: ${{ matrix.os }}
 
     env:
@@ -49,8 +49,11 @@ jobs:
       - name: Check clippy
         run: cargo clippy -- -D warnings
 
-      - name: Publish dry-run
+      - name: Publish ag-ui-core dry-run
         run: cargo publish -p ag-ui-core --dry-run
 
+      - name: Publish ag-ui-client dry-run
+        run: cargo publish -p ag-ui-client --dry-run
+
       - name: Run tests
         run: cargo test --verbose
diff --git a/sdks/community/rust/crates/ag-ui-client/src/agent.rs b/sdks/community/rust/crates/ag-ui-client/src/agent.rs
@@ -1,6 +1,5 @@
 use futures::stream::StreamExt;
 use std::collections::HashSet;
-use thiserror::Error;
 
 use crate::core::JsonValue;
 use crate::core::types::{
@@ -132,18 +131,7 @@ impl<StateT> Default for AgentStateMutation<StateT> {
 }
 
 // Error types
-#[derive(Error, Debug)]
-pub enum AgentError {
-    #[error("Agent execution failed: {message}")]
-    ExecutionError { message: String },
-    #[error("Invalid configuration: {message}")]
-    ConfigError { message: String },
-    #[error("Serialization error: {source}")]
-    SerializationError {
-        #[from]
-        source: serde_json::Error,
-    },
-}
+pub use crate::error::AgUiClientError as AgentError;
 
 // TODO: Expand documentation
 /// Agent trait
diff --git a/sdks/community/rust/crates/ag-ui-client/src/error.rs b/sdks/community/rust/crates/ag-ui-client/src/error.rs
@@ -0,0 +1,62 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+#[non_exhaustive]
+pub enum AgUiClientError {
+    // Configuration/usage errors
+    #[error("Invalid configuration: {message}")]
+    Config { message: String },
+
+    // Transport-level HTTP failures from reqwest
+    #[error("HTTP transport error: {0}")]
+    HttpTransport(#[from] reqwest::Error),
+
+    // Non-success HTTP status with body snippet
+    #[error("HTTP status {status}: {context}")]
+    HttpStatus {
+        status: reqwest::StatusCode,
+        context: String,
+    },
+
+    // SSE parsing/framing/UTF-8 errors
+    #[error("SSE parse error: {message}")]
+    SseParse { message: String },
+
+    // JSON serialization/deserialization
+    #[error("JSON error: {0}")]
+    Json(#[from] serde_json::Error),
+
+    // Errors from subscribers/callbacks
+    #[error("Subscriber error: {message}")]
+    Subscriber { message: String },
+
+    // Pipeline catch-all
+    #[error("Agent execution error: {message}")]
+    Execution { message: String },
+}
+
+impl AgUiClientError {
+    pub fn config(m: impl Into<String>) -> Self {
+        Self::Config { message: m.into() }
+    }
+    pub fn exec(m: impl Into<String>) -> Self {
+        Self::Execution { message: m.into() }
+    }
+
+    pub fn is_retryable(&self) -> bool {
+        use reqwest::StatusCode as S;
+        match self {
+            AgUiClientError::HttpTransport(e) => e.is_connect() || e.is_timeout() || e.is_request(),
+            AgUiClientError::HttpStatus { status, .. } => {
+                status.is_server_error() || *status == S::TOO_MANY_REQUESTS
+            }
+            _ => false,
+        }
+    }
+
+    pub fn is_user_input(&self) -> bool {
+        matches!(self, AgUiClientError::Config { .. })
+    }
+}
+
+pub type Result<T> = std::result::Result<T, AgUiClientError>;
diff --git a/sdks/community/rust/crates/ag-ui-client/src/event_handler.rs b/sdks/community/rust/crates/ag-ui-client/src/event_handler.rs
@@ -358,7 +358,7 @@ where
                     serde_json::from_value(serde_json::to_value(e.delta.clone())?)?;
 
                 json_patch::patch(&mut state_val, &patches).map_err(|err| {
-                    AgentError::ExecutionError {
+                    AgentError::Execution {
                         message: format!("Failed to apply state patch: {err}"),
                     }
                 })?;
diff --git a/sdks/community/rust/crates/ag-ui-client/src/http.rs b/sdks/community/rust/crates/ag-ui-client/src/http.rs
@@ -7,7 +7,6 @@ use std::str::FromStr;
 
 use crate::Agent;
 use crate::agent::AgentError;
-use crate::agent::AgentError::SerializationError;
 use crate::core::event::Event;
 use crate::core::types::RunAgentInput;
 use crate::core::{AgentState, FwdProps};
@@ -61,7 +60,7 @@ impl HttpAgentBuilder {
 
     /// Set the base URL from a string, returning Result for validation
     pub fn with_url_str(mut self, url: &str) -> Result<Self, AgentError> {
-        let parsed_url = Url::parse(url).map_err(|e| AgentError::ConfigError {
+        let parsed_url = Url::parse(url).map_err(|e| AgentError::Config {
             message: format!("Invalid URL '{url}': {e}"),
         })?;
         self.base_url = Some(parsed_url);
@@ -76,10 +75,10 @@ impl HttpAgentBuilder {
 
     /// Add a single header by name and value strings
     pub fn with_header(mut self, name: &str, value: &str) -> Result<Self, AgentError> {
-        let header_name = HeaderName::from_str(name).map_err(|e| AgentError::ConfigError {
+        let header_name = HeaderName::from_str(name).map_err(|e| AgentError::Config {
             message: format!("Invalid header name '{value}': {e}"),
         })?;
-        let header_value = HeaderValue::from_str(value).map_err(|e| AgentError::ConfigError {
+        let header_value = HeaderValue::from_str(value).map_err(|e| AgentError::Config {
             message: format!("Invalid header value '{value}': {e}"),
         })?;
         self.header_map.insert(header_name, header_value);
@@ -115,13 +114,13 @@ impl HttpAgentBuilder {
     }
 
     pub fn build(self) -> Result<HttpAgent, AgentError> {
-        let base_url = self.base_url.ok_or(AgentError::ConfigError {
+        let base_url = self.base_url.ok_or(AgentError::Config {
             message: "Base URL is required".to_string(),
         })?;
 
         // Validate URL scheme
         if !["http", "https"].contains(&base_url.scheme()) {
-            return Err(AgentError::ConfigError {
+            return Err(AgentError::Config {
                 message: format!("Unsupported URL scheme: {}", base_url.scheme()),
             });
         }
@@ -142,14 +141,6 @@ impl Default for HttpAgentBuilder {
     }
 }
 
-impl From<reqwest::Error> for AgentError {
-    fn from(err: reqwest::Error) -> Self {
-        AgentError::ExecutionError {
-            message: err.to_string(),
-        }
-    }
-}
-
 #[async_trait]
 impl<StateT: AgentState, FwdPropsT: FwdProps> Agent<StateT, FwdPropsT> for HttpAgent {
     async fn run(
@@ -165,6 +156,17 @@ impl<StateT: AgentState, FwdPropsT: FwdProps> Agent<StateT, FwdPropsT> for HttpA
             .send()
             .await?;
 
+        // Check HTTP status and surface structured error on non-success
+        let status = response.status();
+        if !status.is_success() {
+            let text = response.text().await.unwrap_or_default();
+            let snippet: String = text.chars().take(512).collect();
+            return Err(AgentError::HttpStatus {
+                status,
+                context: snippet,
+            });
+        }
+
         // Convert the response to an SSE event stream
         let stream = response
             .event_source()
@@ -173,15 +175,12 @@ impl<StateT: AgentState, FwdPropsT: FwdProps> Agent<StateT, FwdPropsT> for HttpA
                 Ok(event) => {
                     trace!("Received event: {event:?}");
 
-                    let event_data: Event<StateT> = serde_json::from_str(&event.data)
-                        .map_err(|err| SerializationError { source: err })?;
+                    let event_data: Event<StateT> = serde_json::from_str(&event.data)?;
                     debug!("Deserialized event: {event_data:?}");
 
                     Ok(event_data)
                 }
-                Err(err) => Err(AgentError::ExecutionError {
-                    message: err.to_string(),
-                }),
+                Err(err) => Err(err),
             })
             .boxed();
         Ok(stream)
diff --git a/sdks/community/rust/crates/ag-ui-client/src/lib.rs b/sdks/community/rust/crates/ag-ui-client/src/lib.rs
@@ -1,6 +1,7 @@
 #![doc = include_str!("../README.md")]
 
 pub mod agent;
+pub mod error;
 pub mod event_handler;
 pub mod http;
 pub mod sse;
diff --git a/sdks/community/rust/crates/ag-ui-client/src/sse.rs b/sdks/community/rust/crates/ag-ui-client/src/sse.rs
@@ -1,24 +1,8 @@
+use crate::error::AgUiClientError;
 use bytes::Bytes;
 use futures::{Stream, StreamExt};
 use reqwest::Response;
 use std::future::Future;
-use thiserror::Error;
-
-/// Error type for SSE response processing
-#[derive(Error, Debug)]
-pub enum SseError {
-    /// Error when parsing SSE data
-    #[error("Failed to parse SSE data: {0}")]
-    ParseError(String),
-
-    /// Error from reqwest
-    #[error("HTTP error: {0}")]
-    HttpError(#[from] reqwest::Error),
-
-    /// Error when deserializing JSON
-    #[error("JSON deserialization error: {0}")]
-    JsonError(#[from] serde_json::Error),
-}
 
 /// Represents a parsed Server-Sent Event
 #[derive(Debug)]
@@ -61,14 +45,14 @@ pub trait SseResponseExt {
     /// Converts a reqwest::Response into a Stream of SSE events
     fn event_source(
         self,
-    ) -> impl Future<Output = impl Stream<Item = Result<SseEvent, SseError>>> + Send;
+    ) -> impl Future<Output = impl Stream<Item = Result<SseEvent, AgUiClientError>>> + Send;
 }
 
 impl SseResponseExt for Response {
     #[allow(clippy::manual_async_fn)]
     fn event_source(
         self,
-    ) -> impl Future<Output = impl Stream<Item = Result<SseEvent, SseError>>> + Send {
+    ) -> impl Future<Output = impl Stream<Item = Result<SseEvent, AgUiClientError>>> + Send {
         async move {
             // Create a stream of bytes from the response
             let stream = self.bytes_stream();
@@ -87,7 +71,7 @@ impl SseEventProcessor {
     #[allow(clippy::new_ret_no_self)]
     fn new(
         stream: impl Stream<Item = Result<Bytes, reqwest::Error>> + 'static,
-    ) -> impl Stream<Item = Result<SseEvent, SseError>> {
+    ) -> impl Stream<Item = Result<SseEvent, AgUiClientError>> {
         let mut buffer = String::new();
 
         // Process the stream
@@ -96,7 +80,7 @@ impl SseEventProcessor {
                 // Map reqwest errors
                 let chunk = match chunk_result {
                     Ok(chunk) => chunk,
-                    Err(err) => return vec![Err(SseError::HttpError(err))],
+                    Err(err) => return vec![Err(AgUiClientError::HttpTransport(err))],
                 };
 
                 // Convert bytes to string and append to buffer
@@ -110,7 +94,9 @@ impl SseEventProcessor {
 
                         events
                     }
-                    Err(e) => vec![Err(SseError::ParseError(format!("Invalid UTF-8: {e}")))],
+                    Err(e) => vec![Err(AgUiClientError::SseParse {
+                        message: format!("Invalid UTF-8: {e}"),
+                    })],
                 }
             })
             .flat_map(futures::stream::iter)
@@ -122,7 +108,7 @@ impl SseEventProcessor {
 /// Returns a tuple of (events, new_buffer) where:
 /// - events: A vector of parsed events or errors
 /// - new_buffer: The remaining buffer that might contain incomplete events
-fn process_raw_sse_events(buffer: &str) -> (Vec<Result<SseEvent, SseError>>, String) {
+fn process_raw_sse_events(buffer: &str) -> (Vec<Result<SseEvent, AgUiClientError>>, String) {
     let mut results = Vec::new();
     let chunks: Vec<&str> = buffer.split("\n\n").collect();
 
@@ -159,7 +145,7 @@ fn process_raw_sse_events(buffer: &str) -> (Vec<Result<SseEvent, SseError>>, Str
 }
 
 /// Parse a single SSE event text into an SseEvent
-fn parse_sse_event(event_text: &str) -> Result<SseEvent, SseError> {
+fn parse_sse_event(event_text: &str) -> Result<SseEvent, AgUiClientError> {
     let mut event = None;
     let mut id = None;
     let mut data_lines = Vec::new();
diff --git a/sdks/community/rust/crates/ag-ui-core/src/event.rs b/sdks/community/rust/crates/ag-ui-core/src/event.rs
@@ -4,7 +4,6 @@ use crate::types::{Message, Role};
 use crate::types::{MessageId, RunId, ThreadId, ToolCallId};
 use serde::{Deserialize, Serialize};
 
-/// Event types for AG-UI protocol
 /// Event types for AG-UI protocol
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "SCREAMING_SNAKE_CASE")]

Original file line number	Diff line number	Diff line change
`@@ -358,7 +358,7 @@ where`
`358`	`358`	`serde_json::from_value(serde_json::to_value(e.delta.clone())?)?;`
`359`	`359`
`360`	`360`	`json_patch::patch(&mut state_val, &patches).map_err(\|err\| {`
`361`		`- AgentError::ExecutionError {`
	`361`	`+ AgentError::Execution {`
`362`	`362`	`message: format!("Failed to apply state patch: {err}"),`
`363`	`363`	`}`
`364`	`364`	`})?;`