feat: Standardized Dynamo Error Type (#6303)

Signed-off-by: Jacky <18255193+kthui@users.noreply.github.com>

lib/bindings/python/rust/engine.rs

@@ -14,10 +14,11 @@ use tokio::sync::mpsc;
 use tokio_stream::{StreamExt, wrappers::ReceiverStream};
 use tokio_util::sync::CancellationToken;
 
+use dynamo_runtime::error::{BackendError, DynamoError, ErrorType};
 use dynamo_runtime::logging::get_distributed_tracing_context;
 pub use dynamo_runtime::{
     pipeline::{AsyncEngine, AsyncEngineContextProvider, Data, ManyOut, ResponseStream, SingleIn},
-    protocols::annotated::Annotated,
+    protocols::{annotated::Annotated, maybe_error::MaybeError},
 };
 
 use super::context::{Context, callable_accepts_kwarg};
@@ -237,38 +238,36 @@ where
                     Err(e) => {
                         done = true;
 
-                        let msg = match &e {
+                        match e {
                             ResponseProcessingError::DeserializeError(e) => {
                                 // tell the python async generator to stop generating
                                 // right now, this is impossible as we are not passing the context to the python async generator
                                 // todo: add task-local context to the python async generator
                                 ctx.stop_generating();
-                                let msg = format!(
+                                Annotated::from_error(format!(
                                     "critical error: invalid response object from python async generator; application-logic-mismatch: {}",
                                     e
-                                );
-                                msg
-                            }
-                            ResponseProcessingError::PyGeneratorExit(_) => {
-                                "Stream ended before generation completed".to_string()
+                                ))
                             }
+                            ResponseProcessingError::PyGeneratorExit(_) => Annotated::from_err(
+                                DynamoError::builder()
+                                    .error_type(ErrorType::Backend(BackendError::EngineShutdown))
+                                    .message("engine shutting down")
+                                    .build(),
+                            ),
                             ResponseProcessingError::PythonException(e) => {
-                                let msg = format!(
+                                Annotated::from_error(format!(
                                     "a python exception was caught while processing the async generator: {}",
                                     e
-                                );
-                                msg
+                                ))
                             }
                             ResponseProcessingError::OffloadError(e) => {
-                                let msg = format!(
+                                Annotated::from_error(format!(
                                     "critical error: failed to offload the python async generator to a new thread: {}",
                                     e
-                                );
-                                msg
+                                ))
                             }
-                        };
-
-                        Annotated::from_error(msg)
+                        }
                     }
                 };
 

lib/kv-router/src/indexer.rs

@@ -36,6 +36,7 @@ use std::time::Instant;
 
 use async_trait::async_trait;
 use dashmap::DashMap;
+use dynamo_runtime::error::DynamoError;
 #[cfg(feature = "metrics")]
 pub use dynamo_runtime::protocols::maybe_error::MaybeError;
 #[cfg(feature = "metrics")]
@@ -51,9 +52,9 @@ use rustc_hash::FxBuildHasher;
 #[cfg(not(feature = "metrics"))]
 pub trait MaybeError {
     /// Construct an instance from an error.
-    fn from_err(err: Box<dyn std::error::Error + Send + Sync>) -> Self;
+    fn from_err(err: impl std::error::Error + 'static) -> Self;
     /// Convert to an error instance if this represents an error.
-    fn err(&self) -> Option<anyhow::Error>;
+    fn err(&self) -> Option<DynamoError>;
 }
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "metrics")]
@@ -125,14 +126,15 @@ pub enum WorkerKvQueryResponse {
     Error(String),
 }
 
+#[cfg(feature = "metrics")]
 impl MaybeError for WorkerKvQueryResponse {
-    fn from_err(err: Box<dyn std::error::Error + Send + Sync>) -> Self {
+    fn from_err(err: impl std::error::Error + 'static) -> Self {
         WorkerKvQueryResponse::Error(err.to_string())
     }
 
-    fn err(&self) -> Option<anyhow::Error> {
+    fn err(&self) -> Option<DynamoError> {
         match self {
-            WorkerKvQueryResponse::Error(msg) => Some(anyhow::Error::msg(msg.clone())),
+            WorkerKvQueryResponse::Error(msg) => Some(DynamoError::msg(msg.clone())),
             _ => None,
         }
     }

lib/llm/src/audit/stream.rs

@@ -238,6 +238,7 @@ pub fn final_response_to_one_chunk_stream(
         id: None,
         event: None,
         comment: None,
+        error: None,
     };
     Box::pin(futures::stream::once(async move { annotated }))
 }
@@ -290,6 +291,7 @@ mod tests {
             id: None,
             event: None,
             comment: None,
+            error: None,
         }
     }
 
@@ -328,6 +330,7 @@ mod tests {
             id: None,
             event: None,
             comment: None,
+            error: None,
         }
     }
 
@@ -451,6 +454,7 @@ mod tests {
             id: Some("correlation-123".to_string()),
             event: Some("test-event".to_string()),
             comment: Some(vec!["test-comment".to_string()]),
+            error: None,
         };
 
         let input_stream = stream::iter(vec![chunk_with_metadata.clone()]);

lib/llm/src/engines.rs

@@ -160,12 +160,12 @@ impl
                 // we are returning characters not tokens, so there will be some postprocessing overhead
                 tokio::time::sleep(*TOKEN_ECHO_DELAY).await;
                 let response = deltas.create_choice(0, Some(c.to_string()), None, None, None);
-                yield Annotated{ id: Some(id.to_string()), data: Some(response), event: None, comment: None };
+                yield Annotated{ id: Some(id.to_string()), data: Some(response), event: None, comment: None, error: None };
                 id += 1;
             }
 
             let response = deltas.create_choice(0, None, Some(dynamo_async_openai::types::FinishReason::Stop), None, None);
-            yield Annotated { id: Some(id.to_string()), data: Some(response), event: None, comment: None };
+            yield Annotated { id: Some(id.to_string()), data: Some(response), event: None, comment: None, error: None };
         };
 
         Ok(ResponseStream::new(Box::pin(output), ctx))
@@ -193,11 +193,11 @@ impl
             for c in chars_string.chars() {
                 tokio::time::sleep(*TOKEN_ECHO_DELAY).await;
                 let response = deltas.create_choice(0, Some(c.to_string()), None, None);
-                yield Annotated{ id: Some(id.to_string()), data: Some(response), event: None, comment: None };
+                yield Annotated{ id: Some(id.to_string()), data: Some(response), event: None, comment: None, error: None };
                 id += 1;
             }
             let response = deltas.create_choice(0, None, Some(dynamo_async_openai::types::CompletionFinishReason::Stop), None);
-            yield Annotated { id: Some(id.to_string()), data: Some(response), event: None, comment: None };
+            yield Annotated { id: Some(id.to_string()), data: Some(response), event: None, comment: None, error: None };
 
         };
 

lib/llm/src/http/service/metrics.rs

@@ -1766,6 +1766,7 @@ mod tests {
             data: None,
             event: Some(crate::preprocessor::ANNOTATION_LLM_METRICS.to_string()),
             comment: None,
+            error: None,
         };
 
         // Add metrics annotation with cached_tokens
@@ -1870,6 +1871,7 @@ mod tests {
             data: None,
             event: Some(crate::preprocessor::ANNOTATION_LLM_METRICS.to_string()),
             comment: None,
+            error: None,
         };
 
         let llm_metrics = LLMMetricAnnotation {

lib/llm/src/http/service/openai.rs

@@ -756,23 +756,40 @@ fn extract_backend_error_if_present<T: serde::Serialize>(
     if let Some(event_type) = &event.event
         && event_type == "error"
     {
-        let comment_str = event
-            .comment
-            .as_ref()
-            .map(|c| c.join(", "))
-            .unwrap_or_else(|| "Unknown error".to_string());
-
-        // Try to parse comment as error JSON to extract status code
-        if let Ok(error_payload) = serde_json::from_str::<ErrorPayload>(&comment_str) {
+        // Extract error string: prefer DynamoError field, fallback to legacy comment.
+        // Use message() instead of to_string() for DynamoError to avoid prefixing
+        // the ErrorType (e.g., "Unknown: {...}"), which would break JSON parsing.
+        let error_str = if let Some(ref dynamo_err) = event.error {
+            let mut parts = Vec::new();
+            let mut current: Option<&dyn std::error::Error> = Some(dynamo_err);
+            while let Some(e) = current {
+                if let Some(de) = e.downcast_ref::<dynamo_runtime::error::DynamoError>() {
+                    parts.push(de.message().to_string());
+                } else {
+                    parts.push(e.to_string());
+                }
+                current = e.source();
+            }
+            parts.join(", ")
+        } else {
+            event
+                .comment
+                .as_ref()
+                .map(|c| c.join(", "))
+                .unwrap_or_else(|| "Unknown error".to_string())
+        };
+
+        // Try to parse as error JSON to extract status code
+        if let Ok(error_payload) = serde_json::from_str::<ErrorPayload>(&error_str) {
             let code = error_payload
                 .code
                 .and_then(|c| StatusCode::from_u16(c).ok())
                 .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
-            let message = error_payload.message.unwrap_or(comment_str);
+            let message = error_payload.message.unwrap_or(error_str);
             return Some((message, code));
         }
 
-        return Some((comment_str, StatusCode::INTERNAL_SERVER_ERROR));
+        return Some((error_str, StatusCode::INTERNAL_SERVER_ERROR));
     }
 
     // Check if the data payload itself contains an error structure with code >= 400
@@ -2455,6 +2472,7 @@ mod tests {
             id: None,
             event: Some("error".to_string()),
             comment: Some(vec!["Backend service unavailable".to_string()]),
+            error: None,
         };
 
         let test_stream = stream::iter(vec![error_event]);
@@ -2481,6 +2499,7 @@ mod tests {
             id: None,
             event: Some("error".to_string()),
             comment: Some(vec![error_json.to_string()]),
+            error: None,
         };
 
         let test_stream = stream::iter(vec![error_event]);
@@ -2517,6 +2536,7 @@ mod tests {
             id: Some("msg-1".to_string()),
             event: None,
             comment: None,
+            error: None,
         };
 
         let test_stream = stream::iter(vec![normal_event.clone()]);
@@ -2563,6 +2583,7 @@ mod tests {
             id: None,
             event: None,
             comment: Some(vec!["Connection timeout".to_string()]),
+            error: None,
         };
 
         let test_stream = stream::iter(vec![error_event]);

lib/llm/src/kv_router/indexer_standalone.rs

@@ -6,6 +6,7 @@ use serde::{Deserialize, Serialize};
 
 use dynamo_runtime::{
     component::Component,
+    error::DynamoError,
     pipeline::{
         AsyncEngine, AsyncEngineContextProvider, ManyOut, ResponseStream, SingleIn, async_trait,
         network::Ingress,
@@ -42,13 +43,13 @@ pub enum IndexerQueryResponse {
 }
 
 impl MaybeError for IndexerQueryResponse {
-    fn from_err(err: Box<dyn std::error::Error + Send + Sync>) -> Self {
+    fn from_err(err: impl std::error::Error + 'static) -> Self {
         IndexerQueryResponse::Error(err.to_string())
     }
 
-    fn err(&self) -> Option<anyhow::Error> {
+    fn err(&self) -> Option<DynamoError> {
         match self {
-            IndexerQueryResponse::Error(msg) => Some(anyhow::Error::msg(msg.clone())),
+            IndexerQueryResponse::Error(msg) => Some(DynamoError::msg(msg.clone())),
             _ => None,
         }
     }

lib/llm/src/kv_router/prefill_router.rs

@@ -34,10 +34,13 @@ pub enum PrefillError {
     #[error("Prefill router not yet activated")]
     NotActivated,
 
-    /// Error during prefill execution
     /// TODO: Separate prefill worker error from prefill router error
+    /// Error during prefill execution
     #[error("Prefill execution failed: {0}")]
-    PrefillError(String),
+    PrefillError(
+        String,
+        #[source] Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
+    ),
 
     /// Disaggregated params not found in prefill response
     #[error("No disaggregated params in prefill response: {0}")]
@@ -360,7 +363,12 @@ impl PrefillRouter {
         let mut prefill_response = router
             .generate_to_worker(request, target_worker)
             .await
-            .map_err(|e| PrefillError::PrefillError(e.to_string()))?;
+            .map_err(|e| {
+                PrefillError::PrefillError(
+                    "failed to route to prefill worker".to_string(),
+                    Some(e.into()),
+                )
+            })?;
 
         // Drop phase permit now - routing is complete, record_worker_full was called in select_worker.
         // This unblocks set_phase(Decode) in the main task without waiting for prefill output.
@@ -369,6 +377,7 @@ impl PrefillRouter {
         let Some(first_output) = prefill_response.next().await else {
             return Err(PrefillError::PrefillError(
                 "Prefill router returned no output (stream ended)".to_string(),
+                None,
             ));
         };
 
@@ -390,9 +399,10 @@ impl PrefillRouter {
         }
 
         if let Some(err) = first_output.err() {
-            return Err(PrefillError::PrefillError(format!(
-                "Prefill router returned error in output: {err:?}"
-            )));
+            return Err(PrefillError::PrefillError(
+                "Prefill router returned error in output".to_string(),
+                Some(Box::new(err)),
+            ));
         }
 
         let Some(output) = &first_output.data else {

lib/llm/src/migration.rs

 // SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+use std::error::Error as StdError;
 use std::sync::Arc;
 
 use anyhow::{Error, Result};
 use futures::{stream, stream::StreamExt};
 
-use async_nats::client::{
-    RequestError as NatsRequestError, RequestErrorKind::NoResponders as NatsNoResponders,
-};
-
 use crate::{
     http::service::metrics::Metrics, model_card::ModelDeploymentCard, preprocessor::BackendOutput,
     protocols::common::llm_backend::PreprocessedRequest,
 };
 
+use dynamo_runtime::error::{self, BackendError, DynamoError, ErrorType};
 use dynamo_runtime::pipeline::{
     AsyncEngineContext, AsyncEngineContextProvider, Context, ManyOut, Operator, ResponseStream,
-    ServerStreamingEngine, SingleIn, async_trait, network::STREAM_ERR_MSG,
+    ServerStreamingEngine, SingleIn, async_trait,
 };
 use dynamo_runtime::protocols::{annotated::Annotated, maybe_error::MaybeError};
 
+/// Check if an error chain indicates the request should be migrated.
+fn is_migratable(err: &(dyn StdError + 'static)) -> bool {
+    const MIGRATABLE: &[ErrorType] = &[
+        ErrorType::CannotConnect,
+        ErrorType::Disconnected,
+        ErrorType::ConnectionTimeout,
+        ErrorType::Backend(BackendError::EngineShutdown),
+    ];
+    const NON_MIGRATABLE: &[ErrorType] = &[
+        // Future: ErrorType::Cancelled, ErrorType::ValidationError, etc.
+    ];
+    error::match_error_chain(err, MIGRATABLE, NON_MIGRATABLE)
+}
+
 pub struct Migration {
     migration_limit: u32,
     model_name: Arc<String>,
@@ -121,18 +133,15 @@ impl RetryManager {
                 Some(stream) => stream,
                 None => {
                     tracing::error!("next() called with next_stream is None - should not happen");
-                    return Some(Annotated::from_err(
-                        Error::msg("next_stream is None").into(),
-                    ));
+                    return Some(Annotated::from_err(DynamoError::msg("next_stream is None")));
                 }
             };
             if let Some(response) = response_stream.next().await {
+                // Check if this is a migratable error that should trigger stream recreation.
                 if let Some(err) = response.err()
-                    && err
-                        .chain()
-                        .any(|e| e.to_string().starts_with(STREAM_ERR_MSG))
+                    && is_migratable(&err)
                 {
-                    tracing::warn!("Stream disconnected... recreating stream...");
+                    tracing::warn!("Stream disconnected... recreating stream... {}", err);
                     self.metrics.inc_migration_ongoing_request(&self.model_name);
                     if let Err(err) = self.new_stream().await {
                         tracing::warn!("Cannot recreate stream: {:#}", err);
@@ -162,10 +171,9 @@ impl RetryManager {
             }
             response_stream = Some(self.next_generate.generate(request).await);
             if let Some(err) = response_stream.as_ref().unwrap().as_ref().err()
-                && let Some(req_err) = err.downcast_ref::<NatsRequestError>()
-                && matches!(req_err.kind(), NatsNoResponders)
+                && is_migratable(err.as_ref())
             {
-                tracing::warn!("Creating new stream... retrying...");
+                tracing::warn!("Creating new stream... retrying... {}", err);
                 self.metrics.inc_migration_new_request(&self.model_name);
                 continue;
             }
@@ -206,6 +214,7 @@ mod tests {
     use super::*;
     use crate::http::service::metrics::Metrics;
     use crate::protocols::common::{OutputOptions, SamplingOptions, StopConditions};
+    use dynamo_runtime::error::{DynamoError, ErrorType};
     use dynamo_runtime::pipeline::AsyncEngine;
     use dynamo_runtime::pipeline::context::Controller;
     use std::sync::atomic::{AtomicU32, Ordering};
@@ -337,8 +346,12 @@ mod tests {
                 MockBehavior::FailThenSuccess => {
                     if call_num == 0 {
                         // First call - return "No responders available" error to trigger retry
-                        let nats_error: NatsRequestError = NatsNoResponders.into();
-                        return Err(nats_error.into());
+                        return Err(anyhow::anyhow!(
+                            DynamoError::builder()
+                                .error_type(ErrorType::CannotConnect)
+                                .message("no responders")
+                                .build()
+                        ));
                     } else {
                         // Subsequent calls - succeed with remaining responses
                         self.send_responses(responses_already_generated, self.num_responses)
@@ -362,8 +375,12 @@ mod tests {
                                 }
                             }
                             // Send the specific error that triggers retry logic
-                            let error_response =
-                                Annotated::from_err(anyhow::Error::msg(STREAM_ERR_MSG).into());
+                            let error_response = Annotated::from_err(
+                                DynamoError::builder()
+                                    .error_type(ErrorType::Disconnected)
+                                    .message("Stream ended before generation completed")
+                                    .build(),
+                            );
                             let _ = tx.send(error_response).await;
                         });
                     } else {
@@ -402,8 +419,12 @@ mod tests {
                                 }
                             }
                             // Send the specific error that triggers retry logic
-                            let error_response =
-                                Annotated::from_err(anyhow::Error::msg(STREAM_ERR_MSG).into());
+                            let error_response = Annotated::from_err(
+                                DynamoError::builder()
+                                    .error_type(ErrorType::Disconnected)
+                                    .message("Stream ended before generation completed")
+                                    .build(),
+                            );
                             let _ = tx.send(error_response).await;
                         });
 
@@ -415,8 +436,12 @@ mod tests {
                         ))
                     } else {
                         // Subsequent calls - always fail with NoResponders error (same as AlwaysFail)
-                        let nats_error: NatsRequestError = NatsNoResponders.into();
-                        Err(nats_error.into())
+                        Err(anyhow::anyhow!(
+                            DynamoError::builder()
+                                .error_type(ErrorType::CannotConnect)
+                                .message("no responders")
+                                .build()
+                        ))
                     }
                 }
                 MockBehavior::MidStreamFailAlwaysStreamError { fail_after } => {
@@ -436,8 +461,12 @@ mod tests {
                                 }
                             }
                             // Send the specific error that triggers retry logic
-                            let error_response =
-                                Annotated::from_err(anyhow::Error::msg(STREAM_ERR_MSG).into());
+                            let error_response = Annotated::from_err(
+                                DynamoError::builder()
+                                    .error_type(ErrorType::Disconnected)
+                                    .message("Stream ended before generation completed")
+                                    .build(),
+                            );
                             let _ = tx.send(error_response).await;
                         });
 
@@ -451,8 +480,12 @@ mod tests {
                         // Subsequent calls - immediately send stream error (no successful responses)
                         tokio::spawn(async move {
                             // Send the stream error immediately
-                            let error_response =
-                                Annotated::from_err(anyhow::Error::msg(STREAM_ERR_MSG).into());
+                            let error_response = Annotated::from_err(
+                                DynamoError::builder()
+                                    .error_type(ErrorType::Disconnected)
+                                    .message("Stream ended before generation completed")
+                                    .build(),
+                            );
                             let _ = tx.send(error_response).await;
                         });
 
@@ -466,8 +499,12 @@ mod tests {
                 }
                 MockBehavior::AlwaysFail => {
                     // Always fail with NoResponders error (same as FailThenSuccess first call)
-                    let nats_error: NatsRequestError = NatsNoResponders.into();
-                    Err(nats_error.into())
+                    Err(anyhow::anyhow!(
+                        DynamoError::builder()
+                            .error_type(ErrorType::CannotConnect)
+                            .message("no responders")
+                            .build()
+                    ))
                 }
             }
         }
@@ -741,12 +778,10 @@ mod tests {
             }
         }
 
-        // 4th response should be an error after retries are exhausted
+        // 4th response should be a Disconnected error after retries are exhausted
         let error_response = &responses[3];
-        assert!(error_response.err().is_some());
-        if let Some(error) = error_response.err() {
-            assert!(error.to_string().contains(STREAM_ERR_MSG));
-        }
+        let err = error_response.err().expect("expected error response");
+        assert_eq!(err.error_type(), ErrorType::Disconnected);
 
         assert_eq!(metrics.get_migration_new_request_count(TEST_MODEL), 3); // 2 retries + 1 final failure
         assert_eq!(metrics.get_migration_ongoing_request_count(TEST_MODEL), 1); // initial ongoing failure retry
@@ -801,12 +836,10 @@ mod tests {
             }
         }
 
-        // 4th response should be an error after retries are exhausted
+        // 4th response should be a Disconnected error after retries are exhausted
         let error_response = &responses[3];
-        assert!(error_response.err().is_some());
-        if let Some(error) = error_response.err() {
-            assert!(error.to_string().contains(STREAM_ERR_MSG));
-        }
+        let err = error_response.err().expect("expected error response");
+        assert_eq!(err.error_type(), ErrorType::Disconnected);
 
         assert_eq!(metrics.get_migration_new_request_count(TEST_MODEL), 0);
         assert_eq!(metrics.get_migration_ongoing_request_count(TEST_MODEL), 4); // 3 retries + 1 final failure

lib/llm/src/preprocessor.rs

@@ -810,6 +810,7 @@ impl OpenAIPreprocessor {
                             data,
                             event: Some(ANNOTATION_LLM_METRICS.to_string()),
                             comment: annotation.comment,
+                            error: None,
                         };
 
                         tracing::trace!(

lib/llm/src/protocols/codec.rs

@@ -108,6 +108,7 @@ where
             id: value.id,
             event: value.event,
             comment: value.comments,
+            error: None,
         })
     }
 }

lib/llm/src/protocols/common/llm_backend.rs

@@ -8,6 +8,7 @@ pub use super::preprocessor::PreprocessedRequest;
 use crate::protocols::TokenIdType;
 use dynamo_async_openai::types::CompletionUsage;
 use dynamo_async_openai::types::StopReason;
+use dynamo_runtime::error::DynamoError;
 use dynamo_runtime::protocols::maybe_error::MaybeError;
 
 pub type TokenType = Option<String>;
@@ -245,13 +246,13 @@ impl LLMEngineOutput {
 }
 
 impl MaybeError for LLMEngineOutput {
-    fn from_err(err: Box<dyn std::error::Error + Send + Sync>) -> Self {
-        LLMEngineOutput::error(format!("{:?}", err))
+    fn from_err(err: impl std::error::Error + 'static) -> Self {
+        LLMEngineOutput::error(err.to_string())
     }
 
-    fn err(&self) -> Option<anyhow::Error> {
+    fn err(&self) -> Option<DynamoError> {
         if let Some(FinishReason::Error(err_msg)) = &self.finish_reason {
-            Some(anyhow::Error::msg(err_msg.clone()))
+            Some(DynamoError::msg(err_msg.clone()))
         } else {
             None
         }
@@ -281,7 +282,7 @@ mod tests {
         assert!(!output.is_err());
 
         let output = LLMEngineOutput::error("Test error".to_string());
-        assert_eq!(format!("{}", output.err().unwrap()), "Test error");
+        assert!(format!("{}", output.err().unwrap()).contains("Test error"));
         assert!(!output.is_ok());
         assert!(output.is_err());
     }

lib/llm/src/protocols/openai/chat_completions/aggregator.rs

@@ -457,6 +457,7 @@ mod tests {
             id: Some("test_id".to_string()),
             event: None,
             comment: None,
+            error: None,
         }
     }
 
@@ -694,6 +695,7 @@ mod tests {
             id: Some("test_id".to_string()),
             event: None,
             comment: None,
+            error: None,
         };
         let stream = Box::pin(stream::iter(vec![annotated_delta]));
 
@@ -759,6 +761,7 @@ mod tests {
             id: Some("test_id".to_string()),
             event: None,
             comment: None,
+            error: None,
         };
         let stream = Box::pin(stream::iter(vec![annotated_delta]));
 
@@ -801,6 +804,7 @@ mod tests {
             id: Some("test_id".to_string()),
             event: None,
             comment: None,
+            error: None,
         };
         let stream = Box::pin(stream::iter(vec![annotated_delta]));
 
@@ -843,6 +847,7 @@ mod tests {
             id: Some("test_id".to_string()),
             event: None,
             comment: None,
+            error: None,
         };
         let stream = Box::pin(stream::iter(vec![annotated_delta]));
 
@@ -883,6 +888,7 @@ mod tests {
             id: Some("test_id".to_string()),
             event: None,
             comment: None,
+            error: None,
         };
         let stream = Box::pin(stream::iter(vec![annotated_delta]));
 
@@ -927,6 +933,7 @@ mod tests {
             id: Some("test_id".to_string()),
             event: None,
             comment: None,
+            error: None,
         };
         let stream = Box::pin(stream::iter(vec![annotated_delta]));
 
@@ -969,6 +976,7 @@ mod tests {
             id: Some("test_id".to_string()),
             event: None,
             comment: None,
+            error: None,
         };
         let stream = Box::pin(stream::iter(vec![annotated_delta]));
 

lib/llm/src/protocols/openai/chat_completions/jail.rs

@@ -677,6 +677,7 @@ impl JailedStream {
                     id,
                     event,
                     comment,
+                    error: None,
                 }]
             }
             EmissionMode::SingleChoicePerChunk => {
@@ -692,6 +693,7 @@ impl JailedStream {
                             id: id.clone(),
                             event: event.clone(),
                             comment: comment.clone(),
+                            error: None,
                         }
                     })
                     .collect()

lib/llm/src/protocols/openai/completions/aggregator.rs

@@ -265,6 +265,7 @@ mod tests {
             id: Some("test_id".to_string()),
             event: None,
             comment: None,
+            error: None,
         }
     }
 
@@ -395,6 +396,7 @@ mod tests {
             id: Some("test_id".to_string()),
             event: None,
             comment: None,
+            error: None,
         };
 
         // Create a stream

lib/llm/tests/test_jail.rs

@@ -64,6 +64,7 @@ mod tests {
                 id: None,
                 event: None,
                 comment: None,
+                error: None,
             }
         }
 
@@ -104,6 +105,7 @@ mod tests {
                 id: None,
                 event: None,
                 comment: None,
+                error: None,
             }
         }
 
@@ -148,6 +150,7 @@ mod tests {
                 id,
                 event,
                 comment,
+                error: None,
             }
         }
 
@@ -193,6 +196,7 @@ mod tests {
                 id: None,
                 event: None,
                 comment: None,
+                error: None,
             }
         }
 
@@ -238,6 +242,7 @@ mod tests {
                 id: None,
                 event: None,
                 comment: None,
+                error: None,
             }
         }
 
@@ -2395,6 +2400,7 @@ mod parallel_jail_tests {
             id: None,
             event: None,
             comment: None,
+            error: None,
         }
     }
 

lib/llm/tests/test_reasoning_parser.rs

@@ -55,6 +55,7 @@ fn create_mock_response_chunk(
         data: Some(response),
         event: None,
         comment: None,
+        error: None,
     }
 }
 

lib/llm/tests/test_streaming_tool_parsers.rs

@@ -123,6 +123,7 @@ fn load_test_data(file_path: &str) -> TestData {
                 data: Some(response),
                 event: None,
                 comment: None,
+                error: None,
             }
         })
         .collect();

lib/llm/tests/tool_choice.rs

@@ -58,6 +58,7 @@ async fn apply_jail_transformation(
         id: None,
         event: None,
         comment: None,
+        error: None,
     }]);
 
     let mut builder = JailedStream::builder();
@@ -95,6 +96,7 @@ async fn apply_jail_transformation_streaming(
         id: None,
         event: None,
         comment: None,
+        error: None,
     }));
 
     let mut builder = JailedStream::builder();

lib/llm/tests/tool_choice_finish_reasons.rs

@@ -67,6 +67,7 @@ async fn apply_jail_transformation(
         id: None,
         event: None,
         comment: None,
+        error: None,
     }]);
 
     let mut builder = JailedStream::builder();