Skip to main content

rig_agent/
completion.rs

1//! Runtime errors for the classic agent runtime, plus the portable completion contracts.
2//!
3//! ```
4//! use rig_agent::completion::StructuredOutputError;
5//! let error = StructuredOutputError::EmptyResponse;
6//! assert!(error.provider_response_body().is_none());
7//! ```
8
9use thiserror::Error;
10
11pub use rig_core::completion::*;
12
13pub use crate::run::response::PromptError;
14
15/// Forward provider response accessors through the designated wrapped error variant.
16macro_rules! forward_provider_response_helpers {
17    ($err:ident, $variant:ident, $inner:literal) => {
18        impl $err {
19            #[doc = concat!("Returns the provider response body exposed by a wrapped ", $inner, ".")]
20            pub fn provider_response_body(&self) -> Option<&str> {
21                match self {
22                    Self::$variant(error) => error.provider_response_body(),
23                    _ => None,
24                }
25            }
26
27            #[doc = concat!("Parses the provider response body of a wrapped ", $inner, " as JSON when present.")]
28            pub fn provider_response_json(
29                &self,
30            ) -> Result<Option<serde_json::Value>, serde_json::Error> {
31                match self {
32                    Self::$variant(error) => error.provider_response_json(),
33                    _ => Ok(None),
34                }
35            }
36
37            #[doc = concat!("Returns the provider transport request id exposed by a wrapped ", $inner, ".")]
38            pub fn provider_request_id(&self) -> Option<&str> {
39                match self {
40                    Self::$variant(error) => error.provider_request_id(),
41                    _ => None,
42                }
43            }
44
45            #[doc = concat!("Returns the HTTP status exposed by a wrapped ", $inner, ".")]
46            pub fn provider_response_status(&self) -> Option<http::StatusCode> {
47                match self {
48                    Self::$variant(error) => error.provider_response_status(),
49                    _ => None,
50                }
51            }
52
53            #[doc = concat!("Returns the response headers exposed by a wrapped ", $inner, ".")]
54            pub fn provider_response_headers(&self) -> Option<&http::HeaderMap> {
55                match self {
56                    Self::$variant(error) => error.provider_response_headers(),
57                    _ => None,
58                }
59            }
60        }
61    };
62}
63
64forward_provider_response_helpers!(StructuredOutputError, PromptError, "prompt error");
65
66/// Errors returned by typed structured prompting.
67#[derive(Debug, Error)]
68pub enum StructuredOutputError {
69    /// The underlying classic run failed.
70    #[error("PromptError: {0}")]
71    PromptError(#[from] PromptError),
72    /// The accepted response could not be deserialized.
73    #[error("DeserializationError: {0}")]
74    DeserializationError(#[from] serde_json::Error),
75    /// The model returned no accepted content.
76    #[error("EmptyResponse: model returned no content")]
77    EmptyResponse,
78}
79
80#[cfg(test)]
81mod provider_response_tests;